rulesync 15.0.0 → 15.1.0

package/dist/{import-DRN7goJ_.cjs → import-CVk4I0-A.cjs}

@@ -127,27 +127,27 @@ const isFeatureValueEnabled = (value) => {
 };
 //#endregion
 //#region src/constants/rulesync-paths.ts
-const { join: join$272 } = node_path.posix;
+const { join: join$273 } = 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$272(RULESYNC_RELATIVE_DIR_PATH, "rules");
-const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$272(RULESYNC_RULES_RELATIVE_DIR_PATH, ".curated");
-const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "commands");
-const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "subagents");
-const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "checks");
-const RULESYNC_MCP_RELATIVE_FILE_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
-const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
-const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
-join$272(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
-const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
-const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
+const RULESYNC_RULES_RELATIVE_DIR_PATH = join$273(RULESYNC_RELATIVE_DIR_PATH, "rules");
+const RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH = join$273(RULESYNC_RULES_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_COMMANDS_RELATIVE_DIR_PATH = join$273(RULESYNC_RELATIVE_DIR_PATH, "commands");
+const RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH = join$273(RULESYNC_RELATIVE_DIR_PATH, "subagents");
+const RULESYNC_CHECKS_RELATIVE_DIR_PATH = join$273(RULESYNC_RELATIVE_DIR_PATH, "checks");
+const RULESYNC_MCP_RELATIVE_FILE_PATH = join$273(RULESYNC_RELATIVE_DIR_PATH, "mcp.jsonc");
+const RULESYNC_HOOKS_RELATIVE_FILE_PATH = join$273(RULESYNC_RELATIVE_DIR_PATH, "hooks.jsonc");
+const RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH = join$273(RULESYNC_RELATIVE_DIR_PATH, "permissions.jsonc");
+join$273(RULESYNC_RELATIVE_DIR_PATH, "mcp.json");
+const RULESYNC_HOOKS_LEGACY_RELATIVE_FILE_PATH = join$273(RULESYNC_RELATIVE_DIR_PATH, "hooks.json");
+const RULESYNC_PERMISSIONS_LEGACY_RELATIVE_FILE_PATH = join$273(RULESYNC_RELATIVE_DIR_PATH, "permissions.json");
 const RULESYNC_AIIGNORE_FILE_NAME = ".aiignore";
-const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$272(RULESYNC_RELATIVE_DIR_PATH, ".aiignore");
+const RULESYNC_AIIGNORE_RELATIVE_FILE_PATH = join$273(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$272(RULESYNC_RELATIVE_DIR_PATH, "skills");
-const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$272(RULESYNC_SKILLS_RELATIVE_DIR_PATH, ".curated");
+const RULESYNC_SKILLS_RELATIVE_DIR_PATH = join$273(RULESYNC_RELATIVE_DIR_PATH, "skills");
+const RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH = join$273(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";
@@ -2598,15 +2598,14 @@ const KIMI_CODE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CAN
 *
 * Hermes validates hook events against a fixed `VALID_HOOKS` set:
 * `pre_tool_call`, `post_tool_call`, `pre_llm_call`, `post_llm_call`,
-* `pre_verify`, `on_session_start`, `on_session_end`, `on_session_finalize`,
+* `pre_verify`, `pre_api_request`, `post_api_request`, `api_request_error`,
+* `on_session_start`, `on_session_end`, `on_session_finalize`,
 * `on_session_reset`, `subagent_start`, `subagent_stop`, `pre_gateway_dispatch`,
 * `pre_approval_request`, `post_approval_response`, `transform_tool_result`,
-* `transform_terminal_output`, `transform_llm_output`. Only the events with a
-* clean 1:1 canonical equivalent are mapped here; the remaining `VALID_HOOKS`
-* entries (`pre_verify`, `on_session_finalize`, `on_session_reset`,
-* `pre_gateway_dispatch`, `pre_approval_request`, `post_approval_response`, the
-* `transform_*` result-rewriting hooks) have no canonical rulesync equivalent,
-* so no canonical event maps to them.
+* `transform_terminal_output`, `transform_llm_output`, and the three
+* `kanban_task_*` events. Only the events with a clean 1:1 canonical equivalent
+* are mapped here. All other native events round-trip through
+* `hermesagent.hooks`.
 * @see https://github.com/NousResearch/hermes-agent/blob/main/website/docs/user-guide/features/hooks.md
 */
 const HERMESAGENT_HOOK_EVENTS = [
@@ -2619,6 +2618,31 @@ const HERMESAGENT_HOOK_EVENTS = [
 	"subagentStart",
 	"subagentStop"
 ];
+const HERMESAGENT_NATIVE_HOOK_EVENTS = [
+	"pre_tool_call",
+	"post_tool_call",
+	"transform_terminal_output",
+	"transform_tool_result",
+	"transform_llm_output",
+	"pre_llm_call",
+	"post_llm_call",
+	"pre_verify",
+	"pre_api_request",
+	"post_api_request",
+	"api_request_error",
+	"on_session_start",
+	"on_session_end",
+	"on_session_finalize",
+	"on_session_reset",
+	"subagent_start",
+	"subagent_stop",
+	"pre_gateway_dispatch",
+	"pre_approval_request",
+	"post_approval_response",
+	"kanban_task_claimed",
+	"kanban_task_completed",
+	"kanban_task_blocked"
+];
 /**
 * Map canonical camelCase event names to Hermes Agent's native `VALID_HOOKS`
 * snake_case keys under the `hooks:` block of `~/.hermes/config.yaml`.
@@ -4766,6 +4790,7 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 		metadata: zod_mini.z.optional(zod_mini.z.looseObject({})),
 		"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
 	})),
+	hermesagent: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	vibe: zod_mini.z.optional(zod_mini.z.looseObject({
 		license: zod_mini.z.optional(zod_mini.z.string()),
 		compatibility: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})])),
@@ -5338,6 +5363,7 @@ const HERMESAGENT_GLOBAL_DIR = ".hermes";
 /** MCP servers and other settings live in `config.yaml` under `~/.hermes/`. */
 const HERMESAGENT_CONFIG_FILE_NAME = "config.yaml";
 const HERMESAGENT_CONFIG_FILE_PATH = (0, node_path.join)(HERMESAGENT_GLOBAL_DIR, HERMESAGENT_CONFIG_FILE_NAME);
+const HERMESAGENT_PROJECT_PLUGINS_ENV_VAR = "HERMES_ENABLE_PROJECT_PLUGINS";
 const HERMESAGENT_SKILLS_DIR_PATH = (0, node_path.join)(HERMESAGENT_GLOBAL_DIR, "skills");
 const HERMESAGENT_RULESYNC_DIR_PATH = (0, node_path.join)(HERMESAGENT_GLOBAL_DIR, "rulesync");
 const HERMESAGENT_RULESYNC_COMMANDS_DIR_PATH = (0, node_path.join)(HERMESAGENT_RULESYNC_DIR_PATH, "commands");
@@ -8267,7 +8293,12 @@ var AgentsSkillsSkill = class AgentsSkillsSkill extends ToolSkill {
 };
 //#endregion
 //#region src/features/skills/hermesagent-skill.ts
-var HermesagentSkill = class extends AgentsSkillsSkill {
+const SHARED_AGENT_SKILL_FIELDS = /* @__PURE__ */ new Set([
+	"license",
+	"compatibility",
+	"allowed-tools"
+]);
+var HermesagentSkill = class HermesagentSkill extends AgentsSkillsSkill {
 	static isTargetedByRulesyncSkill(rulesyncSkill) {
 		const targets = rulesyncSkill.getFrontmatter().targets;
 		return targets.includes("*") || targets.includes("agentsskills") || targets.includes("hermesagent");
@@ -8281,6 +8312,87 @@ var HermesagentSkill = class extends AgentsSkillsSkill {
 			relativeDirPath: HERMESAGENT_SKILLS_DIR_PATH
 		});
 	}
+	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
+		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+		const shared = rulesyncFrontmatter.agentsskills ?? {};
+		const hermes = rulesyncFrontmatter.hermesagent ?? {};
+		return new this({
+			outputRoot,
+			relativeDirPath: HERMESAGENT_SKILLS_DIR_PATH,
+			dirName: rulesyncSkill.getDirName(),
+			frontmatter: {
+				...shared,
+				...hermes,
+				name: rulesyncFrontmatter.name,
+				description: rulesyncFrontmatter.description
+			},
+			body: rulesyncSkill.getBody(),
+			otherFiles: rulesyncSkill.getOtherFiles(),
+			validate,
+			global
+		});
+	}
+	toRulesyncSkill() {
+		const frontmatter = this.getFrontmatter();
+		const agentsskills = {
+			...frontmatter.license !== void 0 && { license: frontmatter.license },
+			...frontmatter.compatibility !== void 0 && { compatibility: frontmatter.compatibility },
+			...frontmatter["allowed-tools"] !== void 0 && { "allowed-tools": frontmatter["allowed-tools"] }
+		};
+		const hermesagent = {};
+		for (const [key, value] of Object.entries(frontmatter)) {
+			if (key === "name" || key === "description") continue;
+			if (!SHARED_AGENT_SKILL_FIELDS.has(key)) hermesagent[key] = value;
+		}
+		const rulesyncFrontmatter = {
+			name: frontmatter.name,
+			description: frontmatter.description,
+			targets: ["*"],
+			...Object.keys(agentsskills).length > 0 && { agentsskills },
+			...Object.keys(hermesagent).length > 0 && { hermesagent }
+		};
+		return new RulesyncSkill({
+			outputRoot: this.outputRoot,
+			relativeDirPath: RULESYNC_SKILLS_RELATIVE_DIR_PATH,
+			dirName: this.getDirName(),
+			frontmatter: rulesyncFrontmatter,
+			body: this.getBody(),
+			otherFiles: this.getOtherFiles(),
+			validate: true,
+			global: this.global
+		});
+	}
+	static async fromDir(params) {
+		const loaded = await this.loadSkillDirContent({
+			...params,
+			getSettablePaths: HermesagentSkill.getSettablePaths
+		});
+		return new this({
+			outputRoot: loaded.outputRoot,
+			relativeDirPath: loaded.relativeDirPath,
+			dirName: loaded.dirName,
+			frontmatter: loaded.frontmatter,
+			body: loaded.body,
+			otherFiles: loaded.otherFiles,
+			validate: true,
+			global: loaded.global
+		});
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, dirName, global = false }) {
+		return new this({
+			outputRoot,
+			relativeDirPath: relativeDirPath ?? HERMESAGENT_SKILLS_DIR_PATH,
+			dirName,
+			frontmatter: {
+				name: "",
+				description: ""
+			},
+			body: "",
+			otherFiles: [],
+			validate: false,
+			global
+		});
+	}
 };
 //#endregion
 //#region src/features/commands/hermesagent-command.ts
@@ -8307,7 +8419,7 @@ import json
 from pathlib import Path
 
 
-COMMANDS_DIR = Path.home() / ".hermes" / "rulesync" / "commands"
+COMMANDS_DIR = Path(__file__).resolve().parents[2] / "rulesync" / "commands"
 
 
 def _load_commands():
@@ -10760,7 +10872,7 @@ function isToolMatcherEntry(x) {
 /**
 * Filter the shared canonical hooks to the supported events and merge tool overrides on top.
 */
-function buildEffectiveHooks$2({ config, toolOverrideHooks, supportedEvents }) {
+function buildEffectiveHooks$1({ config, toolOverrideHooks, supportedEvents }) {
 	const supported = new Set(supportedEvents);
 	const sharedHooks = {};
 	for (const [event, defs] of Object.entries(config.hooks)) if (supported.has(event)) sharedHooks[event] = defs;
@@ -10890,7 +11002,7 @@ function buildToolHooks({ defs, converterConfig }) {
 * (e.g. beforeSubmitPrompt → UserPromptSubmit).
 */
 function canonicalToToolHooks({ config, toolOverrideHooks, converterConfig, logger }) {
-	const effectiveHooks = buildEffectiveHooks$2({
+	const effectiveHooks = buildEffectiveHooks$1({
 		config,
 		toolOverrideHooks,
 		supportedEvents: converterConfig.supportedEvents
@@ -12924,20 +13036,9 @@ var GrokcliHooks = class GrokcliHooks extends ToolHooks {
 * `matcher`.
 * @see https://github.com/NousResearch/hermes-agent/blob/main/website/docs/user-guide/features/hooks.md
 */
-const HERMESAGENT_MATCHER_EVENTS = /* @__PURE__ */ new Set(["preToolUse", "postToolUse"]);
-/**
-* Filter the shared canonical hooks to the events Hermes understands and merge
-* the `hermesagent`-specific override block on top.
-*/
-function buildEffectiveHooks$1(config, toolOverrideHooks) {
-	const supported = new Set(HERMESAGENT_HOOK_EVENTS);
-	const shared = {};
-	for (const [event, defs] of Object.entries(config.hooks)) if (supported.has(event)) shared[event] = defs;
-	return {
-		...shared,
-		...toolOverrideHooks
-	};
-}
+const HERMESAGENT_MATCHER_EVENTS = /* @__PURE__ */ new Set(["pre_tool_call", "post_tool_call"]);
+const HERMESAGENT_CANONICAL_EVENTS = new Set(HERMESAGENT_HOOK_EVENTS);
+const HERMESAGENT_NATIVE_EVENTS = new Set(HERMESAGENT_NATIVE_HOOK_EVENTS);
 /**
 * Convert the canonical hooks config into Hermes's native
 * `hooks: { <event>: [{ matcher?, command, timeout? }] }` shape.
@@ -12950,24 +13051,62 @@ function buildEffectiveHooks$1(config, toolOverrideHooks) {
 * warning, mirroring how other adapters (e.g. AugmentCode) handle
 * matcher-less lifecycle events.
 */
+function definitionsToHermesEntries({ event, sourceEvent = event, definitions, logger }) {
+	const supportsMatcher = HERMESAGENT_MATCHER_EVENTS.has(event);
+	const entries = [];
+	for (const definition of definitions) {
+		if ((definition.type ?? "command") !== "command" || typeof definition.command !== "string" || definition.command === "") continue;
+		const entry = { command: definition.command };
+		if (typeof definition.matcher === "string" && definition.matcher !== "") if (supportsMatcher) entry.matcher = definition.matcher;
+		else logger?.warn(`matcher "${definition.matcher}" on "${sourceEvent}" hook will be ignored — Hermes Agent only supports matchers on pre_tool_call/post_tool_call`);
+		if (typeof definition.timeout === "number") entry.timeout = definition.timeout;
+		entries.push(entry);
+	}
+	return entries;
+}
+function setHermesHookEntries({ result, event, sourceEvent, definitions, logger }) {
+	if (PROTOTYPE_POLLUTION_KEYS.has(event)) return;
+	const entries = definitionsToHermesEntries({
+		event,
+		sourceEvent,
+		definitions,
+		logger
+	});
+	if (entries.length > 0) result[event] = entries;
+}
 function canonicalToHermesHooks({ config, toolOverrideHooks, logger }) {
-	const effectiveHooks = buildEffectiveHooks$1(config, toolOverrideHooks);
 	const result = {};
-	for (const [canonicalEvent, defs] of Object.entries(effectiveHooks)) {
+	for (const [canonicalEvent, definitions] of Object.entries(config.hooks)) {
+		if (!HERMESAGENT_CANONICAL_EVENTS.has(canonicalEvent)) continue;
 		const nativeEvent = CANONICAL_TO_HERMESAGENT_EVENT_NAMES[canonicalEvent];
-		if (!nativeEvent) continue;
-		const supportsMatcher = HERMESAGENT_MATCHER_EVENTS.has(canonicalEvent);
-		const entries = [];
-		for (const def of defs) {
-			if ((def.type ?? "command") !== "command") continue;
-			if (typeof def.command !== "string" || def.command === "") continue;
-			const entry = { command: def.command };
-			if (typeof def.matcher === "string" && def.matcher !== "") if (supportsMatcher) entry.matcher = def.matcher;
-			else logger?.warn(`matcher "${def.matcher}" on "${canonicalEvent}" hook will be ignored — Hermes Agent only supports matchers on pre_tool_call/post_tool_call`);
-			if (typeof def.timeout === "number") entry.timeout = def.timeout;
-			entries.push(entry);
-		}
-		if (entries.length > 0) result[nativeEvent] = entries;
+		if (nativeEvent) setHermesHookEntries({
+			result,
+			event: nativeEvent,
+			sourceEvent: canonicalEvent,
+			definitions,
+			logger
+		});
+	}
+	for (const [canonicalEvent, definitions] of Object.entries(toolOverrideHooks ?? {})) {
+		if (!HERMESAGENT_CANONICAL_EVENTS.has(canonicalEvent)) continue;
+		const nativeEvent = CANONICAL_TO_HERMESAGENT_EVENT_NAMES[canonicalEvent];
+		if (nativeEvent) setHermesHookEntries({
+			result,
+			event: nativeEvent,
+			sourceEvent: canonicalEvent,
+			definitions,
+			logger
+		});
+	}
+	for (const [nativeEvent, definitions] of Object.entries(toolOverrideHooks ?? {})) {
+		if (HERMESAGENT_CANONICAL_EVENTS.has(nativeEvent)) continue;
+		if (!HERMESAGENT_NATIVE_EVENTS.has(nativeEvent)) logger?.warn(`Hermes hook event "${nativeEvent}" is not documented by Hermes Agent v0.19.0; preserving it for forward compatibility.`);
+		setHermesHookEntries({
+			result,
+			event: nativeEvent,
+			definitions,
+			logger
+		});
 	}
 	return result;
 }
@@ -12975,16 +13114,15 @@ function canonicalToHermesHooks({ config, toolOverrideHooks, logger }) {
 * Reverse {@link canonicalToHermesHooks}: parse Hermes's native
 * `hooks: { <event>: [...] }` map back into a canonical event → definition[]
 * record. Native events with no canonical equivalent (`pre_verify`,
-* `transform_tool_result`, ...) are skipped since there is nothing to round
-* -trip them into.
+* `transform_tool_result`, ...) retain their native names so
+* {@link buildImportedHooksConfig} places them under `hermesagent.hooks`.
 */
 function hermesHooksToCanonical(hooks) {
 	const canonical = {};
 	if (hooks === null || typeof hooks !== "object" || Array.isArray(hooks)) return canonical;
 	for (const [nativeEvent, entries] of Object.entries(hooks)) {
 		if (PROTOTYPE_POLLUTION_KEYS.has(nativeEvent) || !Array.isArray(entries)) continue;
-		const canonicalEvent = HERMESAGENT_TO_CANONICAL_EVENT_NAMES[nativeEvent];
-		if (!canonicalEvent) continue;
+		const rulesyncEvent = HERMESAGENT_TO_CANONICAL_EVENT_NAMES[nativeEvent] ?? nativeEvent;
 		const defs = [];
 		for (const raw of entries) {
 			if (raw === null || typeof raw !== "object" || Array.isArray(raw)) continue;
@@ -12994,11 +13132,11 @@ function hermesHooksToCanonical(hooks) {
 				type: "command",
 				command: entry.command
 			};
-			if (typeof entry.matcher === "string" && entry.matcher !== "") def.matcher = entry.matcher;
+			if (HERMESAGENT_MATCHER_EVENTS.has(nativeEvent) && typeof entry.matcher === "string" && entry.matcher !== "") def.matcher = entry.matcher;
 			if (typeof entry.timeout === "number") def.timeout = entry.timeout;
 			defs.push(def);
 		}
-		if (defs.length > 0) canonical[canonicalEvent] = defs;
+		if (defs.length > 0) canonical[rulesyncEvent] = defs;
 	}
 	return canonical;
 }
@@ -15055,7 +15193,8 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		},
 		supportedEvents: HERMESAGENT_HOOK_EVENTS,
 		supportedHookTypes: ["command"],
-		supportsMatcher: true
+		supportsMatcher: true,
+		passthroughOverrideEvents: true
 	}],
 	["kimi-code", {
 		class: KimiCodeHooks,
@@ -18792,12 +18931,51 @@ function resolveHermesTimeout(config) {
 * canonical `McpServerSchema` is a `looseObject`), so this serves export and
 * import alike. See the Hermes mcp-config-reference.
 */
+function copyHermesOauth(source) {
+	if (!isRecord(source)) return;
+	const oauth = {};
+	for (const key of [
+		"redirect_uri",
+		"redirect_host",
+		"client_id",
+		"client_secret"
+	]) if (typeof source[key] === "string") oauth[key] = source[key];
+	if (typeof source.redirect_port === "number") oauth.redirect_port = source.redirect_port;
+	if (isStringArray$1(source.scopes)) oauth.scopes = source.scopes;
+	return Object.keys(oauth).length > 0 ? oauth : void 0;
+}
 function copyHermesAdvancedFields(source, target) {
-	if (typeof source.auth === "string") target.auth = source.auth;
-	if (typeof source.client_cert === "string" || isStringArray$1(source.client_cert)) target.client_cert = source.client_cert;
-	if (typeof source.client_key === "string") target.client_key = source.client_key;
-	if (typeof source.connect_timeout === "number") target.connect_timeout = source.connect_timeout;
-	if (typeof source.supports_parallel_tool_calls === "boolean") target.supports_parallel_tool_calls = source.supports_parallel_tool_calls;
+	let copied = false;
+	if (typeof source.auth === "string") {
+		target.auth = source.auth;
+		copied = true;
+	}
+	if (typeof source.client_cert === "string" || isStringArray$1(source.client_cert)) {
+		target.client_cert = source.client_cert;
+		copied = true;
+	}
+	if (typeof source.client_key === "string") {
+		target.client_key = source.client_key;
+		copied = true;
+	}
+	if (typeof source.connect_timeout === "number") {
+		target.connect_timeout = source.connect_timeout;
+		copied = true;
+	}
+	if (typeof source.supports_parallel_tool_calls === "boolean") {
+		target.supports_parallel_tool_calls = source.supports_parallel_tool_calls;
+		copied = true;
+	}
+	const oauth = copyHermesOauth(source.oauth);
+	if (oauth) {
+		target.oauth = oauth;
+		copied = true;
+	}
+	for (const key of ["idle_timeout_seconds", "max_lifetime_seconds"]) if (typeof source[key] === "number") {
+		target[key] = source[key];
+		copied = true;
+	}
+	return copied;
 }
 /**
 * Builds Hermes's per-server `tools` block from a canonical server config. The
@@ -18899,6 +19077,7 @@ function mergeHermesMcpServers(config, mcpServers) {
 */
 function convertFromHermesFormat(mcpServers) {
 	const result = {};
+	const hermesOverrides = {};
 	for (const [name, config] of Object.entries(mcpServers)) {
 		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord(config)) continue;
 		const server = {};
@@ -18909,11 +19088,15 @@ function convertFromHermesFormat(mcpServers) {
 		if (isPlainObject$1(config.headers)) server.headers = omitPrototypePollutionKeys(config.headers);
 		if (config.enabled === false) server.disabled = true;
 		if (typeof config.timeout === "number") server.networkTimeout = config.timeout;
-		copyHermesAdvancedFields(config, server);
 		if (isRecord(config.tools)) applyHermesToolsBlock(config.tools, server);
 		result[name] = server;
+		const hermesServer = { ...server };
+		if (copyHermesAdvancedFields(config, hermesServer)) hermesOverrides[name] = hermesServer;
 	}
-	return result;
+	return {
+		mcpServers: result,
+		hermesOverrides
+	};
 }
 /**
 * Hermes Agent MCP servers.
@@ -18998,8 +19181,11 @@ var HermesagentMcp = class HermesagentMcp extends ToolMcp {
 		});
 	}
 	toRulesyncMcp() {
-		const servers = convertFromHermesFormat(isRecord(this.config.mcp_servers) ? this.config.mcp_servers : {});
-		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({ mcpServers: servers }, null, 2) });
+		const { mcpServers: servers, hermesOverrides } = convertFromHermesFormat(isRecord(this.config.mcp_servers) ? this.config.mcp_servers : {});
+		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({
+			mcpServers: servers,
+			...Object.keys(hermesOverrides).length > 0 && { hermesagent: { mcpServers: hermesOverrides } }
+		}, null, 2) });
 	}
 	validate() {
 		return {
@@ -21009,8 +21195,8 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 		meta: {
 			supportsProject: false,
 			supportsGlobal: true,
-			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsEnabledTools: true,
+			supportsDisabledTools: true
 		}
 	}],
 	["kimi-code", {
@@ -25024,6 +25210,59 @@ function deriveGrokPermissionMode(config) {
 function patternsByAction(category, action) {
 	return Object.entries(category ?? {}).filter(([, value]) => value === action).map(([pattern]) => pattern);
 }
+function clonePermissionBlock(permission) {
+	return Object.fromEntries(Object.entries(permission).map(([category, rules]) => [category, { ...rules }]));
+}
+function deleteRulesByAction(rules, action) {
+	for (const [pattern, currentAction] of Object.entries(rules)) if (currentAction === action) delete rules[pattern];
+}
+function ensureCategory(permission, category) {
+	return permission[category] ??= {};
+}
+function removeEmptyCategories(permission) {
+	for (const [category, rules] of Object.entries(permission)) if (Object.keys(rules).length === 0) delete permission[category];
+}
+function reconcileCommandAllowlist({ permission, commandAllowlist }) {
+	const nativeAllows = new Set(commandAllowlist);
+	const existingAllowCategories = /* @__PURE__ */ new Map();
+	for (const [category, rules] of Object.entries(permission)) for (const [pattern, action] of Object.entries(rules)) {
+		if (action !== "allow") continue;
+		existingAllowCategories.set(pattern, category);
+		if (!nativeAllows.has(pattern)) delete rules[pattern];
+	}
+	for (const pattern of nativeAllows) {
+		const existingCategory = existingAllowCategories.get(pattern);
+		if (existingCategory) ensureCategory(permission, existingCategory)[pattern] = "allow";
+		else ensureCategory(permission, "bash")[pattern] = "allow";
+	}
+}
+function reconcileNativeDenies({ permission, category, patterns }) {
+	const rules = ensureCategory(permission, category);
+	deleteRulesByAction(rules, "deny");
+	for (const pattern of patterns) rules[pattern] = "deny";
+}
+function withoutKey(record, key) {
+	return Object.fromEntries(Object.entries(record).filter(([entryKey]) => entryKey !== key));
+}
+function buildHermesOverride(config, provenance) {
+	const base = isRecord(provenance.hermes) ? { ...provenance.hermes } : {};
+	const approvalsOverride = withoutKey(isRecord(config.approvals) ? config.approvals : {}, "deny");
+	if (Object.keys(approvalsOverride).length > 0) base.approvals = approvalsOverride;
+	else delete base.approvals;
+	const security = isRecord(config.security) ? { ...config.security } : {};
+	const blocklist = isRecord(security.website_blocklist) ? { ...security.website_blocklist } : void 0;
+	if (blocklist?.enabled === true) {
+		delete blocklist.domains;
+		delete blocklist.enabled;
+	}
+	if (blocklist && Object.keys(blocklist).length > 0) security.website_blocklist = blocklist;
+	else delete security.website_blocklist;
+	if (Object.keys(security).length > 0) base.security = security;
+	else delete base.security;
+	for (const key of ["skills", "memory"]) if (isRecord(config[key])) base[key] = config[key];
+	else delete base[key];
+	return base;
+}
 var HermesagentPermissions = class HermesagentPermissions extends ToolPermissions {
 	static getSettablePaths() {
 		return {
@@ -25080,12 +25319,40 @@ var HermesagentPermissions = class HermesagentPermissions extends ToolPermission
 			format: "yaml",
 			fileContent: this.getFileContent()
 		});
-		const permissions = config.permissions && typeof config.permissions === "object" ? config.permissions.rulesync : {};
+		const permissionsRoot = isRecord(config.permissions) ? config.permissions : {};
+		const parsedProvenance = RulesyncPermissionsFileSchema.safeParse(permissionsRoot.rulesync);
+		const provenance = parsedProvenance.success ? parsedProvenance.data : { permission: {} };
+		const permission = clonePermissionBlock(provenance.permission);
+		reconcileCommandAllowlist({
+			permission,
+			commandAllowlist: isStringArray$1(config.command_allowlist) ? config.command_allowlist : []
+		});
+		const approvals = isRecord(config.approvals) ? config.approvals : {};
+		reconcileNativeDenies({
+			permission,
+			category: "bash",
+			patterns: isStringArray$1(approvals.deny) ? approvals.deny : []
+		});
+		const security = isRecord(config.security) ? config.security : {};
+		const websiteBlocklist = isRecord(security.website_blocklist) ? security.website_blocklist : {};
+		reconcileNativeDenies({
+			permission,
+			category: "webfetch",
+			patterns: websiteBlocklist.enabled === true && isStringArray$1(websiteBlocklist.domains) ? websiteBlocklist.domains : []
+		});
+		removeEmptyCategories(permission);
+		const { permission: _permission, hermes: _hermes, ...otherProvenance } = provenance;
+		const hermes = buildHermesOverride(config, provenance);
+		const imported = {
+			...otherProvenance,
+			permission,
+			...Object.keys(hermes).length > 0 && { hermes }
+		};
 		return new RulesyncPermissions({
 			outputRoot: this.outputRoot,
 			relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
 			relativeFilePath: RULESYNC_PERMISSIONS_FILE_NAME,
-			fileContent: JSON.stringify(permissions ?? {}, null, 2)
+			fileContent: JSON.stringify(imported, null, 2)
 		});
 	}
 	static fromRulesyncPermissions({ outputRoot, rulesyncPermissions }) {
@@ -35828,7 +36095,7 @@ import json
 from pathlib import Path
 
 
-SUBAGENTS_DIR = Path.home() / ".hermes" / "rulesync" / "subagents"
+SUBAGENTS_DIR = Path(__file__).resolve().parents[2] / "rulesync" / "subagents"
 
 
 def _load_subagents():
@@ -35937,12 +36204,12 @@ var HermesagentSubagent = class HermesagentSubagent extends ToolSubagent {
 			validate: false
 		});
 	}
-	static async fromFile({ global = false, outputRoot = process.cwd(), relativeFilePath, validate = true }) {
+	static async fromFile({ global = false, outputRoot = process.cwd(), relativeDirPath, relativeFilePath, validate = true }) {
 		return new HermesagentSubagent({
-			fileContent: await (0, node_fs_promises.readFile)((0, node_path.join)(outputRoot, relativeFilePath), "utf8"),
+			fileContent: await (0, node_fs_promises.readFile)((0, node_path.join)(outputRoot, relativeDirPath ?? HERMESAGENT_RULESYNC_SUBAGENTS_DIR_PATH, relativeFilePath), "utf8"),
 			global,
 			outputRoot,
-			relativeDirPath: (0, node_path.dirname)(relativeFilePath),
+			relativeDirPath: relativeDirPath ?? (0, node_path.dirname)(relativeFilePath),
 			relativeFilePath: (0, node_path.basename)(relativeFilePath),
 			validate
 		});
@@ -35951,7 +36218,7 @@ var HermesagentSubagent = class HermesagentSubagent extends ToolSubagent {
 		const targets = rulesyncSubagent.getFrontmatter().targets;
 		return !targets || targets.includes("*") || targets.includes("hermesagent");
 	}
-	static fromRulesyncSubagents({ rulesyncSubagents, outputRoot }) {
+	static fromRulesyncSubagents({ rulesyncSubagents, outputRoot, global = false }) {
 		return [
 			...rulesyncSubagents.map((rulesyncSubagent) => HermesagentSubagent.fromRulesyncSubagent({
 				relativeDirPath: HERMESAGENT_RULESYNC_SUBAGENTS_DIR_PATH,
@@ -35970,12 +36237,12 @@ var HermesagentSubagent = class HermesagentSubagent extends ToolSubagent {
 				fileContent: "",
 				outputRoot
 			}),
-			new HermesagentSubagent({
+			...global ? [new HermesagentSubagent({
 				relativeDirPath: HERMESAGENT_GLOBAL_DIR,
 				relativeFilePath: (0, node_path.basename)(HERMESAGENT_CONFIG_FILE_PATH),
 				fileContent: "",
 				outputRoot
-			})
+			})] : []
 		];
 	}
 	static fromRulesyncSubagent({ rulesyncSubagent, outputRoot }) {
@@ -35996,11 +36263,11 @@ var HermesagentSubagent = class HermesagentSubagent extends ToolSubagent {
 	* shared `~/.hermes/config.yaml` (enabling the `rulesync-subagents` plugin),
 	* so the write must be declared for the shared-file order derivation.
 	*/
-	static getExtraSharedWritePaths() {
-		return [{
+	static getExtraSharedWritePaths({ global = false } = {}) {
+		return global ? [{
 			relativeDirPath: HERMESAGENT_GLOBAL_DIR,
 			relativeFilePath: (0, node_path.basename)(HERMESAGENT_CONFIG_FILE_PATH)
-		}];
+		}] : [];
 	}
 	static getSettablePathsForRulesyncSubagent(rulesyncSubagent) {
 		return [(0, node_path.join)(HERMESAGENT_RULESYNC_SUBAGENTS_DIR_PATH, `${subagentSlug(rulesyncSubagent.getRelativePathFromCwd())}.json`)];
@@ -36010,13 +36277,13 @@ var HermesagentSubagent = class HermesagentSubagent extends ToolSubagent {
 		const json = JSON.parse(this.getFileContent());
 		return new RulesyncSubagent({
 			relativeDirPath: RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH,
-			relativeFilePath: (0, node_path.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, `${slug}.md`),
+			relativeFilePath: `${slug}.md`,
 			body: json.prompt ?? "",
 			frontmatter: {
 				name: json.name ?? slug,
 				description: json.description
 			},
-			outputRoot: this.outputRoot
+			outputRoot: this.global ? this.outputRoot : process.cwd()
 		});
 	}
 	validate() {
@@ -43666,6 +43933,74 @@ function buildChecksStrategy(ctx) {
 	};
 }
 //#endregion
+//#region src/features/shared/hermes-project-plugin-activation.ts
+function mergeEnabledPlugins({ existingContent, filePath, pluginNames }) {
+	const config = parseSharedConfig({
+		format: "yaml",
+		fileContent: existingContent,
+		filePath,
+		invalidRootPolicy: "error"
+	});
+	const plugins = isPlainObject$1(config.plugins) ? config.plugins : {};
+	const disabled = Array.isArray(plugins.disabled) ? plugins.disabled.filter((value) => typeof value === "string") : [];
+	const conflicts = pluginNames.filter((pluginName) => disabled.includes(pluginName));
+	if (conflicts.length > 0) throw new Error(`Cannot activate Hermes project plugin(s) ${conflicts.join(", ")} because ${filePath} explicitly lists them in plugins.disabled. Remove the conflicting entries or exclude those RuleSync features.`);
+	const enabled = Array.isArray(plugins.enabled) ? plugins.enabled : [];
+	return stringifySharedConfig({
+		format: "yaml",
+		document: {
+			...config,
+			plugins: {
+				...plugins,
+				enabled: Array.from(/* @__PURE__ */ new Set([...enabled, ...pluginNames]))
+			}
+		}
+	});
+}
+async function writeActivationFile({ filePath, relativePath, expectedContent, dryRun, logger }) {
+	const existingContent = await readFileContentOrNull(filePath);
+	const normalizedExpected = addTrailingNewline(expectedContent);
+	if (fileContentsEquivalent({
+		filePath,
+		expected: normalizedExpected,
+		existing: existingContent
+	})) return false;
+	if (dryRun) logger.info(`[DRY RUN] Would write: ${filePath}`);
+	else await writeFileContent(filePath, normalizedExpected);
+	logger.debug(`Hermes project-plugin activation requires ${relativePath}`);
+	return true;
+}
+async function activateHermesProjectPlugins({ pluginNames, dryRun, logger }) {
+	if (pluginNames.length === 0) return {
+		count: 0,
+		paths: [],
+		hasDiff: false
+	};
+	const configuredHermesHome = process.env.HERMES_HOME?.trim();
+	const configRoot = configuredHermesHome ? (0, node_path.resolve)(configuredHermesHome) : getHomeDirectory();
+	const relativeConfigPath = configuredHermesHome ? HERMESAGENT_CONFIG_FILE_NAME : HERMESAGENT_CONFIG_FILE_PATH;
+	const configPath = (0, node_path.join)(configRoot, relativeConfigPath);
+	const expectedConfig = mergeEnabledPlugins({
+		existingContent: await readFileContentOrNull(configPath) ?? "",
+		filePath: configPath,
+		pluginNames
+	});
+	const paths = [];
+	logger.warn(`Hermes project plugins require explicit trust. Run Hermes from this trusted repository with ${HERMESAGENT_PROJECT_PLUGINS_ENV_VAR}=true. RuleSync does not persist this global setting.`);
+	if (await writeActivationFile({
+		filePath: configPath,
+		relativePath: relativeConfigPath,
+		expectedContent: expectedConfig,
+		dryRun,
+		logger
+	})) paths.push(relativeConfigPath);
+	return {
+		count: paths.length,
+		paths,
+		hasDiff: paths.length > 0
+	};
+}
+//#endregion
 //#region src/types/processor-registry.ts
 const PROCESSOR_REGISTRY = [
 	{
@@ -44127,6 +44462,41 @@ async function warnSkillSubagentNameCollisions(params) {
 		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.`);
 	}
 }
+async function collectHermesProjectPluginNames({ config, resultsById }) {
+	if (config.getGlobal() || !config.getTargets().includes("hermesagent")) return [];
+	const outputRoots = config.getOutputRoots("hermesagent");
+	const enabledFeatures = config.getFeatures("hermesagent");
+	const descriptors = [
+		{
+			feature: "ignore",
+			pluginName: "rulesync-ignore",
+			manifestPath: HERMESAGENT_IGNORE_PLUGIN_MANIFEST_PATH
+		},
+		{
+			feature: "subagents",
+			pluginName: "rulesync-subagents",
+			manifestPath: HERMESAGENT_RULESYNC_SUBAGENTS_PLUGIN_MANIFEST_PATH
+		},
+		{
+			feature: "checks",
+			pluginName: "rulesync-checks",
+			manifestPath: HERMESAGENT_CHECKS_PLUGIN_MANIFEST_PATH
+		}
+	];
+	const pluginNames = [];
+	for (const descriptor of descriptors) {
+		if (!enabledFeatures.includes(descriptor.feature)) continue;
+		const relativeManifestPath = toPosixPath(descriptor.manifestPath);
+		const willWriteManifest = resultsById.get(descriptor.feature)?.paths.some((generatedPath) => toPosixPath(generatedPath) === relativeManifestPath) ?? false;
+		let manifestExists = false;
+		for (const outputRoot of outputRoots) if (await fileExists((0, node_path.join)(outputRoot, descriptor.manifestPath))) {
+			manifestExists = true;
+			break;
+		}
+		if (willWriteManifest || manifestExists) pluginNames.push(descriptor.pluginName);
+	}
+	return pluginNames;
+}
 /**
 * Generate configuration files for AI tools.
 * @throws Error if generation fails
@@ -44190,13 +44560,21 @@ async function generate(params) {
 	})));
 	const resultsById = /* @__PURE__ */ new Map();
 	for (const step of orderedSteps) resultsById.set(step.id, await step.run());
+	const activationResult = await activateHermesProjectPlugins({
+		pluginNames: await collectHermesProjectPluginNames({
+			config,
+			resultsById
+		}),
+		dryRun: config.isPreviewMode(),
+		logger
+	});
 	if (!skillsResult) throw new Error("Skills generation step did not run.");
 	const get = (id) => {
 		const result = resultsById.get(id);
 		if (!result) throw new Error(`Missing generation result for step '${id}'.`);
 		return result;
 	};
-	const hasDiff = orderedSteps.some((step) => get(step.id).hasDiff);
+	const hasDiff = activationResult.hasDiff || orderedSteps.some((step) => get(step.id).hasDiff);
 	return {
 		rulesCount: get("rules").count,
 		rulesPaths: get("rules").paths,
@@ -44216,6 +44594,8 @@ async function generate(params) {
 		permissionsPaths: get("permissions").paths,
 		checksCount: get("checks").count,
 		checksPaths: get("checks").paths,
+		activationCount: activationResult.count,
+		activationPaths: activationResult.paths,
 		skills: skillsResult.skills,
 		hasDiff
 	};