rulesync 16.10.0 → 16.12.0

package/dist/{import-danhPI2x.cjs → import-BwdPcfzS.cjs}

@@ -891,6 +891,7 @@ const ErrorCodes = {
 	INIT_FAILED: "INIT_FAILED",
 	MCP_FAILED: "MCP_FAILED",
 	DOCTOR_FAILED: "DOCTOR_FAILED",
+	RELEASE_NOTES_FAILED: "RELEASE_NOTES_FAILED",
 	UNKNOWN_ERROR: "UNKNOWN_ERROR"
 };
 /**
@@ -2477,38 +2478,67 @@ const AMP_HOOK_EVENTS = [
 ];
 /**
 * Hook events supported by Cline's file-based hooks. Cline resolves one
-* executable per lifecycle event from its hooks directory, and the event names
-* it accepts are fixed by `VALID_HOOK_TYPES` in
-* `apps/vscode/src/core/hooks/utils.ts`: `TaskStart`, `TaskResume`,
-* `TaskCancel`, `TaskComplete`, `PreToolUse`, `PostToolUse`,
-* `UserPromptSubmit`, `Notification` and `PreCompact`.
+* executable per lifecycle event from its hooks directory, and the accepted
+* event names come from two runtimes that read the same directory:
+*
+* - The VS Code extension fixes them in `VALID_HOOK_TYPES`
+*   (`apps/vscode/src/core/hooks/utils.ts`): `TaskStart`, `TaskResume`,
+*   `TaskCancel`, `TaskComplete`, `PreToolUse`, `PostToolUse`,
+*   `UserPromptSubmit`, `Notification` and `PreCompact`.
+* - The SDK/CLI fixes them in `HookConfigFileName`
+*   (`sdk/packages/core/src/hooks/hook-file-config.ts`), which drops
+*   `Notification` but adds `TaskError` (→ `agent_error`) and
+*   `SessionShutdown` (→ `session_shutdown`).
+*
+* This set is the union, because `.clinerules/hooks` is in both runtimes'
+* search paths and a script named for an event the running one does not know
+* is simply never spawned. That holds for unknown *names* only: for an event a
+* runtime does know, the SDK/CLI spawns both the extensionless script and its
+* `.ps1` twin, so each generated script opens with a guard that stands down on
+* the platform the other one owns — see `generateClineHookScript` and
+* `generateClineHookPowerShellScript`.
 *
 * `TaskResume` and `TaskCancel` have no canonical counterpart and stay
 * unmapped rather than being approximated by `sessionEnd` / `stop`, whose
 * semantics differ.
 *
 * @see https://github.com/cline/cline/blob/main/apps/vscode/src/core/hooks/utils.ts
+* @see https://github.com/cline/cline/blob/main/sdk/packages/core/src/hooks/hook-file-config.ts
 */
 const CLINE_HOOK_EVENTS = [
 	"sessionStart",
+	"sessionEnd",
 	"preToolUse",
 	"postToolUse",
 	"beforeSubmitPrompt",
 	"preCompact",
 	"notification",
-	"taskCompleted"
+	"taskCompleted",
+	"afterError"
 ];
 /**
 * Hook events supported by GitHub Copilot (cloud coding agent).
 *
-* GitHub now documents an eight-event surface for `.github/hooks/*.json`:
+* The events rulesync writes to `.github/hooks/*.json`:
 * `sessionStart`, `sessionEnd`, `userPromptSubmitted` ← `beforeSubmitPrompt`,
-* `preToolUse`, `postToolUse`, `agentStop` ← `stop`, `subagentStop`, and
-* `errorOccurred` ← `afterError`. `subagentStart` is intentionally absent: it is
-* not part of the documented cloud-agent surface.
+* `preToolUse`, `postToolUse`, `postToolUseFailure`, `agentStop` ← `stop`,
+* `subagentStart`, `subagentStop`, `errorOccurred` ← `afterError`,
+* `preCompact`, and `userPromptTransformed` ← `userPromptExpansion`.
+*
+* `preCompact` and `subagentStart` are authorable because the unified hooks
+* reference's per-event "Cloud agent" column says both fire there. That column
+* is the authority for this set: the older cloud-agent concept page still
+* lists only the eight events this set began as, and re-narrowing to it would
+* undo that. `notification` and `permissionRequest` stay out because the same
+* column is explicit that they do not fire on the cloud agent.
+*
+* `postToolUseFailure` and `userPromptTransformed` are shared with
+* {@link COPILOTCLI_HOOK_EVENTS}; the same column records both as firing on the
+* cloud agent, so they are authorable here too. The event surfaces overlap but
+* the config surfaces do not: `copilot` emits `command` hooks only, while the
+* CLI adapter also handles `http` and `prompt`.
 *
-* @see https://docs.github.com/en/copilot/concepts/agents/coding-agent/about-hooks
-* @see https://docs.github.com/en/copilot/concepts/agents/hooks
+* @see https://docs.github.com/en/copilot/reference/hooks-reference
 */
 const COPILOT_HOOK_EVENTS = [
 	"sessionStart",
@@ -2516,9 +2546,13 @@ const COPILOT_HOOK_EVENTS = [
 	"beforeSubmitPrompt",
 	"preToolUse",
 	"postToolUse",
+	"postToolUseFailure",
 	"stop",
+	"subagentStart",
 	"subagentStop",
-	"afterError"
+	"afterError",
+	"preCompact",
+	"userPromptExpansion"
 ];
 /**
 * Hook events supported by the GitHub Copilot CLI (`copilotcli-hooks.ts`).
@@ -3234,15 +3268,21 @@ const CANONICAL_TO_AMP_EVENT_NAMES = {
 	beforeSubmitPrompt: "agent.start",
 	stop: "agent.end"
 };
-/** Map canonical hook events to Cline's `VALID_HOOK_TYPES` file names. */
+/**
+* Map canonical hook events to Cline's hook script file names — the union of
+* the VS Code extension's `VALID_HOOK_TYPES` and the SDK/CLI's
+* `HookConfigFileName`, see {@link CLINE_HOOK_EVENTS}.
+*/
 const CANONICAL_TO_CLINE_EVENT_NAMES = {
 	sessionStart: "TaskStart",
+	sessionEnd: "SessionShutdown",
 	preToolUse: "PreToolUse",
 	postToolUse: "PostToolUse",
 	beforeSubmitPrompt: "UserPromptSubmit",
 	preCompact: "PreCompact",
 	notification: "Notification",
-	taskCompleted: "TaskComplete"
+	taskCompleted: "TaskComplete",
+	afterError: "TaskError"
 };
 /**
 * Map canonical camelCase event names to Copilot camelCase.
@@ -3253,9 +3293,13 @@ const CANONICAL_TO_COPILOT_EVENT_NAMES = {
 	beforeSubmitPrompt: "userPromptSubmitted",
 	preToolUse: "preToolUse",
 	postToolUse: "postToolUse",
+	postToolUseFailure: "postToolUseFailure",
 	stop: "agentStop",
+	subagentStart: "subagentStart",
 	subagentStop: "subagentStop",
-	afterError: "errorOccurred"
+	afterError: "errorOccurred",
+	preCompact: "preCompact",
+	userPromptExpansion: "userPromptTransformed"
 };
 /**
 * Map Copilot camelCase event names to canonical camelCase.
@@ -5480,6 +5524,7 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 	})),
 	cline: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	roo: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	amp: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	devin: zod_mini.z.optional(zod_mini.z.looseObject({
 		"argument-hint": zod_mini.z.optional(zod_mini.z.string()),
 		model: zod_mini.z.optional(zod_mini.z.string()),
@@ -11712,7 +11757,8 @@ const KiloCommandFrontmatterSchema = zod_mini.z.looseObject({
 	description: zod_mini.z.optional(zod_mini.z.string()),
 	agent: zod_mini.z.optional(zod_mini.z.string()),
 	subtask: zod_mini.z.optional(zod_mini.z.boolean()),
-	model: zod_mini.z.optional(zod_mini.z.string())
+	model: zod_mini.z.optional(zod_mini.z.string()),
+	variant: zod_mini.z.optional(zod_mini.z.string())
 });
 var KiloCommand = class KiloCommand extends ToolCommand {
 	frontmatter;
@@ -15394,6 +15440,13 @@ function generateClineHookScript({ event, commands }) {
 		`# ${event} hook generated by rulesync — edit .rulesync/hooks.jsonc and regenerate.`,
 		`# ${CLINE_HOOK_SCRIPT_MARKER}`,
 		"",
+		"case \"${OSTYPE:-$(uname -s 2>/dev/null || true)}\" in",
+		"  msys*|MSYS*|cygwin*|CYGWIN*|MINGW*|mingw*)",
+		`    printf '{"cancel": false, "contextModification": "", "errorMessage": ""}\\n'`,
+		"    exit 0",
+		"    ;;",
+		"esac",
+		"",
 		"payload=$(cat)",
 		"cancel=false",
 		"error_message=''",
@@ -15407,15 +15460,39 @@ function generateClineHookScript({ event, commands }) {
 	return lines.join("\n");
 }
 /**
-* The PowerShell twin of {@link generateClineHookScript}. On Windows Cline
-* resolves only `<Event>.ps1` and runs it through `powershell -File`, so both
-* spellings are written and the platform picks one.
+* The PowerShell twin of {@link generateClineHookScript}. On Windows the VS Code
+* extension resolves only `<Event>.ps1` and runs it through `powershell -File`,
+* so both spellings are written and the platform picks one.
+*
+* The SDK/CLI runtime does not pick one. `listHookConfigFiles` dedupes by path,
+* so `TaskError` and `TaskError.ps1` are two entries naming the same event, and
+* `createHookCommandMap` appends both to that event's command list without a
+* per-event dedupe — it then runs every command in the list, spawning a `.ps1`
+* through `pwsh` on Unix too. That produced noise rather than a second
+* execution (the body shells out through `cmd /c`, which Unix has no such
+* thing), but it is still a failure reported on every fire.
+*
+* Hence the leading platform guard: off Windows the script answers with the
+* neutral success payload and exits, leaving the POSIX twin to do the work.
+* Its counterpart at the top of {@link generateClineHookScript} covers the
+* quadrant where the duplication is real — Windows with a POSIX shell.
+* `$IsWindows` only exists in PowerShell 6+, and is `$null` under the Windows
+* PowerShell 5.1 that `powershell -File` starts — so the guard tests that it is
+* defined *and* false, rather than `-not $IsWindows`, which would be true on
+* 5.1 and would no-op the script on the one platform it exists for.
+*
+* @see https://github.com/cline/cline/blob/main/sdk/packages/core/src/hooks/hook-file-hooks.ts
 */
 function generateClineHookPowerShellScript({ event, commands }) {
 	const lines = [
 		`# ${event} hook generated by rulesync — edit .rulesync/hooks.jsonc and regenerate.`,
 		`# ${CLINE_HOOK_SCRIPT_MARKER}`,
 		"",
+		"if ($null -ne $IsWindows -and -not $IsWindows) {",
+		`  Write-Output '{"cancel": false, "contextModification": "", "errorMessage": ""}'`,
+		"  exit 0",
+		"}",
+		"",
 		"$payload = [Console]::In.ReadToEnd()",
 		"$cancel = $false",
 		"$errorMessage = ''",
@@ -15477,10 +15554,14 @@ var ClineHookScript = class extends ToolFile {
 * by the contract, so every generated script carries a marker line and a script
 * without it is never overwritten.
 *
-* Cline's CLI and SDK use a different, in-process hook surface (`AgentHooks`
-* from `@cline/core`), which this adapter does not target.
+* The project hooks directory is in the search paths of both the VS Code
+* extension and the SDK/CLI, whose accepted event names differ slightly, so the
+* emitted set is their union ({@link CANONICAL_TO_CLINE_EVENT_NAMES}). Cline's
+* in-process hook surface (`AgentHooks` from `@cline/core`) is a separate
+* mechanism this adapter does not target.
 *
 * @see https://github.com/cline/cline/blob/main/apps/vscode/src/core/hooks/utils.ts
+* @see https://github.com/cline/cline/blob/main/sdk/packages/core/src/hooks/hook-file-config.ts
 */
 var ClineHooks = class ClineHooks extends ToolHooks {
 	scriptsByEvent;
@@ -15635,6 +15716,11 @@ const CODEXCLI_CONVERTER_CONFIG = {
 	numberPassthroughFields: [{
 		canonical: "additionalContextLimit",
 		tool: "additionalContextLimit"
+	}],
+	booleanPassthroughFields: [{
+		canonical: "async",
+		tool: "async",
+		commandOnly: true
 	}]
 };
 /**
@@ -16761,6 +16847,16 @@ const FACTORYDROID_CONVERTER_CONFIG = {
 		subdividesGroup: true
 	}]
 };
+/** Droid's nine event names, the keys a standalone `hooks.json` is made of. */
+const FACTORYDROID_EVENT_NAMES = new Set(Object.values(CANONICAL_TO_FACTORYDROID_EVENT_NAMES));
+/**
+* Whether a parsed hooks file is the standalone shape — keyed directly by event
+* name — rather than the `settings.json` shape that wraps the same map in a
+* `hooks` key.
+*/
+function hasFactorydroidEventKey(parsed) {
+	return Object.keys(parsed).some((key) => FACTORYDROID_EVENT_NAMES.has(key));
+}
 var FactorydroidHooks = class FactorydroidHooks extends ToolHooks {
 	constructor(params) {
 		super({
@@ -16788,14 +16884,6 @@ var FactorydroidHooks = class FactorydroidHooks extends ToolHooks {
 	}
 	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
 		const paths = FactorydroidHooks.getSettablePaths({ global });
-		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
-		const existingContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
-		let settings;
-		try {
-			settings = JSON.parse(existingContent);
-		} catch (error) {
-			throw new Error(`Failed to parse existing Factory Droid hooks file at ${filePath}: ${formatError(error)}`, { cause: error });
-		}
 		const config = rulesyncHooks.getJson();
 		const factorydroidHooks = canonicalToToolHooks({
 			config,
@@ -16803,11 +16891,7 @@ var FactorydroidHooks = class FactorydroidHooks extends ToolHooks {
 			converterConfig: FACTORYDROID_CONVERTER_CONFIG,
 			logger
 		});
-		const merged = {
-			...settings,
-			hooks: factorydroidHooks
-		};
-		const fileContent = JSON.stringify(merged, null, 2);
+		const fileContent = JSON.stringify(factorydroidHooks, null, 2);
 		return new FactorydroidHooks({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -16817,14 +16901,14 @@ var FactorydroidHooks = class FactorydroidHooks extends ToolHooks {
 		});
 	}
 	toRulesyncHooks({ logger } = {}) {
-		let settings;
+		let parsed;
 		try {
-			settings = JSON.parse(this.getFileContent());
+			parsed = JSON.parse(this.getFileContent());
 		} catch (error) {
 			throw new Error(`Failed to parse Factory Droid hooks content in ${(0, node_path.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
 		}
 		const hooks = toolHooksToCanonical({
-			hooks: settings.hooks,
+			hooks: hasFactorydroidEventKey(parsed) ? parsed : parsed.hooks,
 			converterConfig: FACTORYDROID_CONVERTER_CONFIG,
 			logger
 		});
@@ -16959,18 +17043,7 @@ const GROKCLI_CONVERTER_CONFIG = {
 		tool: "env",
 		commandOnly: true
 	}],
-	noMatcherEvents: /* @__PURE__ */ new Set([
-		"sessionStart",
-		"sessionEnd",
-		"beforeSubmitPrompt",
-		"stop",
-		"stopFailure",
-		"notification",
-		"subagentStart",
-		"subagentStop",
-		"preCompact",
-		"postCompact"
-	])
+	noMatcherEvents: /* @__PURE__ */ new Set(["stop", "beforeSubmitPrompt"])
 };
 /**
 * Hooks generator for Grok CLI (xAI Grok Build).
@@ -17070,6 +17143,13 @@ var GrokcliHooks = class GrokcliHooks extends ToolHooks {
 * @see https://github.com/NousResearch/hermes-agent/blob/main/website/docs/user-guide/features/hooks.md
 */
 const HERMESAGENT_MATCHER_EVENTS = /* @__PURE__ */ new Set(["pre_tool_call", "post_tool_call"]);
+/**
+* The only Hermes event that can block, and therefore the only one whose
+* entries accept `fail_closed`. Upstream warns and ignores the key on every
+* other event ("only blocking-capable events can fail closed").
+* @see https://github.com/NousResearch/hermes-agent/blob/main/website/docs/user-guide/features/hooks.md
+*/
+const HERMESAGENT_FAIL_CLOSED_EVENT = "pre_tool_call";
 const HERMESAGENT_CANONICAL_EVENTS = new Set(HERMESAGENT_HOOK_EVENTS);
 const HERMESAGENT_NATIVE_EVENTS = new Set(HERMESAGENT_NATIVE_HOOK_EVENTS);
 /**
@@ -17103,7 +17183,9 @@ function isHermesHookEventEntry(key, value) {
 * unsupported hook types centrally). `matcher` is only carried through for
 * `pre_tool_call`/`post_tool_call`; on any other event it is dropped with a
 * warning, mirroring how other adapters (e.g. AugmentCode) handle
-* matcher-less lifecycle events.
+* matcher-less lifecycle events. The canonical `failClosed` field (shared with
+* Cursor, whose semantics Hermes copied) becomes `fail_closed`, which upstream
+* only honours on `pre_tool_call`.
 */
 function definitionsToHermesEntries({ event, sourceEvent = event, definitions, logger }) {
 	const supportsMatcher = HERMESAGENT_MATCHER_EVENTS.has(event);
@@ -17114,6 +17196,10 @@ function definitionsToHermesEntries({ event, sourceEvent = event, definitions, l
 		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;
+		if (typeof definition.failClosed === "boolean") {
+			if (event === HERMESAGENT_FAIL_CLOSED_EVENT) entry.fail_closed = definition.failClosed;
+			else if (definition.failClosed) logger?.warn(`failClosed on "${sourceEvent}" hook will be ignored — Hermes Agent only supports fail_closed on pre_tool_call`);
+		}
 		entries.push(entry);
 	}
 	return entries;
@@ -17165,6 +17251,37 @@ function canonicalToHermesHooks({ config, toolOverrideHooks, logger }) {
 	return result;
 }
 /**
+* Reads a hook entry's fail-closed flag. Upstream accepts its own `fail_closed`
+* and the Cursor/Claude Code `failClosed` spelling alike, so both have to be
+* read back into the single canonical field.
+*/
+function readHermesFailClosed(entry) {
+	if (typeof entry.fail_closed === "boolean") return entry.fail_closed;
+	if (typeof entry.failClosed === "boolean") return entry.failClosed;
+}
+/**
+* Converts one serialized Hermes hook entry back into a canonical definition,
+* or `undefined` when it is not a hook rulesync models (no string `command`).
+* `matcher` and `fail_closed` are read only on the events upstream honours them
+* on, so an imported value is never one the next generate warns about and drops.
+*/
+function hermesEntryToDefinition({ nativeEvent, raw }) {
+	if (!isRecord$1(raw)) return;
+	const entry = raw;
+	if (typeof entry.command !== "string") return;
+	const def = {
+		type: "command",
+		command: entry.command
+	};
+	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;
+	if (nativeEvent === HERMESAGENT_FAIL_CLOSED_EVENT) {
+		const failClosed = readHermesFailClosed(entry);
+		if (failClosed !== void 0) def.failClosed = failClosed;
+	}
+	return def;
+}
+/**
 * 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`,
@@ -17178,19 +17295,10 @@ function hermesHooksToCanonical(hooks) {
 		if (PROTOTYPE_POLLUTION_KEYS.has(nativeEvent) || !Array.isArray(entries)) continue;
 		if (!isHermesHookEventEntry(nativeEvent, entries)) 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;
-			const entry = raw;
-			if (typeof entry.command !== "string") continue;
-			const def = {
-				type: "command",
-				command: entry.command
-			};
-			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);
-		}
+		const defs = entries.map((raw) => hermesEntryToDefinition({
+			nativeEvent,
+			raw
+		})).filter((def) => def !== void 0);
 		if (defs.length > 0) canonical[rulesyncEvent] = defs;
 	}
 	return canonical;
@@ -23116,6 +23224,78 @@ var CursorMcp = class CursorMcp extends ToolMcp {
 };
 //#endregion
 //#region src/features/mcp/deepagents-mcp.ts
+const TOOL_NAME = "deepagents";
+/**
+* Map a canonical transport onto the three dcode accepts.
+*
+* `_resolve_server_type` takes `stdio`, `sse` and `http`, plus the aliases
+* `streamable_http` / `streamable-http` → `http`. Rulesync's canonical
+* vocabulary is wider: `local` and `ws` are spellings dcode rejects outright,
+* and a rejected server is dropped at load time with only a log line. `local`
+* has an exact equivalent so it is translated; `ws` has none and is skipped at
+* generate time instead, where the warning can still reach the author.
+*
+* @see https://docs.langchain.com/oss/deepagents/code/mcp-tools
+*/
+function normalizeDeepagentsTransport(transport) {
+	switch (transport) {
+		case "local":
+		case "stdio": return "stdio";
+		case "streamable-http":
+		case "streamable_http":
+		case "http": return "http";
+		case "sse": return "sse";
+		default: return;
+	}
+}
+/**
+* Translate one canonical server into dcode's `.mcp.json` shape, or `null` to
+* skip it.
+*
+* Two upstream constraints from `_validate_tool_filter_fields` are enforced
+* here, because breaking either one makes dcode drop the whole server: the two
+* filters are mutually exclusive on a single server, and neither may be an
+* empty list.
+*/
+function toDeepagentsServer({ name, server, logger }) {
+	const rawTransport = server.transport ?? server.type;
+	if (rawTransport === "ws") return warnAndSkipMcpServer({
+		toolName: TOOL_NAME,
+		serverName: name,
+		reason: "the WebSocket transport, which deepagents does not support",
+		logger
+	});
+	const { enabledTools, disabledTools, type: _type, transport, ...rest } = server;
+	const converted = { ...rest };
+	const normalized = normalizeDeepagentsTransport(rawTransport);
+	if (normalized !== void 0) if (transport !== void 0) converted.transport = normalized;
+	else converted.type = normalized;
+	if (enabledTools !== void 0 && disabledTools !== void 0) return warnAndSkipMcpServer({
+		toolName: TOOL_NAME,
+		serverName: name,
+		reason: "both enabledTools and disabledTools, which deepagents rejects — pick one",
+		logger
+	});
+	if (enabledTools !== void 0) {
+		if (enabledTools.length === 0) return warnAndSkipMcpServer({
+			toolName: TOOL_NAME,
+			serverName: name,
+			reason: "an empty enabledTools list, which allows no tools at all and which deepagents rejects",
+			logger
+		});
+		converted.allowedTools = enabledTools;
+	} else if (disabledTools !== void 0) if (disabledTools.length === 0) logger?.warn(`${TOOL_NAME} MCP: dropping the empty disabledTools list on "${name}"; it denies nothing, and deepagents rejects the empty form.`);
+	else converted.disabledTools = disabledTools;
+	return converted;
+}
+/** Lift dcode's spellings back into the canonical model. */
+function toRulesyncServer(server) {
+	const { allowedTools, ...rest } = server;
+	const converted = { ...rest };
+	for (const key of ["type", "transport"]) if (converted[key] === "streamable_http" || converted[key] === "streamable-http") converted[key] = "http";
+	if (Array.isArray(allowedTools)) converted.enabledTools = allowedTools;
+	return converted;
+}
 var DeepagentsMcp = class DeepagentsMcp extends ToolMcp {
 	json;
 	constructor(params) {
@@ -23150,12 +23330,22 @@ var DeepagentsMcp = class DeepagentsMcp extends ToolMcp {
 			validate
 		});
 	}
-	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false }) {
+	static async fromRulesyncMcp({ outputRoot = process.cwd(), rulesyncMcp, validate = true, global = false, logger }) {
 		const paths = this.getSettablePaths({ global });
 		const fileContent = await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? JSON.stringify({ mcpServers: {} }, null, 2);
+		const json = JSON.parse(fileContent);
+		const mcpServers = {};
+		for (const [name, server] of Object.entries(rulesyncMcp.getMcpServers())) {
+			const converted = toDeepagentsServer({
+				name,
+				server,
+				logger
+			});
+			if (converted !== null) mcpServers[name] = converted;
+		}
 		const mcpJson = {
-			...JSON.parse(fileContent),
-			mcpServers: rulesyncMcp.getMcpServers()
+			...json,
+			mcpServers
 		};
 		return new DeepagentsMcp({
 			outputRoot,
@@ -23166,7 +23356,9 @@ var DeepagentsMcp = class DeepagentsMcp extends ToolMcp {
 		});
 	}
 	toRulesyncMcp() {
-		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({ mcpServers: this.json.mcpServers }, null, 2) });
+		const servers = isRecord$1(this.json.mcpServers) ? this.json.mcpServers : {};
+		const mcpServers = Object.fromEntries(Object.entries(servers).map(([name, server]) => [name, isRecord$1(server) ? toRulesyncServer(server) : server]));
+		return this.toRulesyncMcpDefault({ fileContent: JSON.stringify({ mcpServers }, null, 2) });
 	}
 	validate() {
 		return {
@@ -23871,7 +24063,7 @@ function resolveHermesTimeout(config) {
 * alias — `auth` (`oauth` for OAuth 2.1/PKCE), mTLS `client_cert` (string PEM
 * path, or `[cert, key]`/`[cert, key, password]` list) and `client_key`,
 * `connect_timeout` (seconds), `supports_parallel_tool_calls`,
-* `keepalive_interval`, and `elicitation` — verbatim
+* `keepalive_interval`, `elicitation`, `trust`, and `identity_header` — verbatim
 * from `source` to `target`. Field names are identical on both sides (the
 * canonical `McpServerSchema` is a `looseObject`), so this serves export and
 * import alike. See the Hermes mcp-config-reference.
@@ -23940,6 +24132,14 @@ function copyHermesAdvancedFields(source, target) {
 		target.elicitation = omitPrototypePollutionKeys(structuredClone(source.elicitation));
 		copied = true;
 	}
+	if (typeof source.trust === "string") {
+		target.trust = source.trust;
+		copied = true;
+	}
+	if (isPlainObject$1(source.identity_header)) {
+		target.identity_header = omitPrototypePollutionKeys(structuredClone(source.identity_header));
+		copied = true;
+	}
 	return copied;
 }
 /**
@@ -27173,8 +27373,8 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 		meta: {
 			supportsProject: true,
 			supportsGlobal: true,
-			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsEnabledTools: true,
+			supportsDisabledTools: true
 		}
 	}],
 	["factorydroid", {
@@ -27183,7 +27383,7 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: true,
 			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsDisabledTools: true
 		}
 	}],
 	["goose", {
@@ -27309,7 +27509,7 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: false,
 			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsDisabledTools: true
 		}
 	}],
 	["zoocode", {
@@ -27318,7 +27518,7 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: false,
 			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsDisabledTools: true
 		}
 	}],
 	["rovodev", {
@@ -31245,6 +31445,7 @@ function convertGoosePermissionConfigToRulesync(userPermission) {
 const GROKCLI_UI_KEY = "ui";
 const GROKCLI_PERMISSION_MODE_KEY = "permission_mode";
 const GROKCLI_PERMISSION_KEY = "permission";
+const GROKCLI_AUTO_PERMISSION_MODE = "auto";
 const CATCH_ALL_PATTERN$2 = "*";
 const MCP_CANONICAL_PREFIX$1 = "mcp__";
 const CATEGORY_TO_GROK_TOOL = {
@@ -31458,8 +31659,9 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 			deny: buckets.deny,
 			ask: buckets.ask
 		};
-		const uiPatch = global ? { [GROKCLI_UI_KEY]: {
-			...isRecord$1(parsed[GROKCLI_UI_KEY]) ? parsed[GROKCLI_UI_KEY] : {},
+		const existingUi = isRecord$1(parsed[GROKCLI_UI_KEY]) ? parsed[GROKCLI_UI_KEY] : {};
+		const uiPatch = global && existingUi[GROKCLI_PERMISSION_MODE_KEY] !== GROKCLI_AUTO_PERMISSION_MODE ? { [GROKCLI_UI_KEY]: {
+			...existingUi,
 			[GROKCLI_PERMISSION_MODE_KEY]: deriveGrokPermissionMode(config)
 		} } : {};
 		return new GrokcliPermissions({
@@ -36744,11 +36946,12 @@ var AmpSkill = class AmpSkill extends ToolSkill {
 		};
 	}
 	toRulesyncSkill() {
-		const frontmatter = this.getFrontmatter();
+		const { name, description, ...ampSection } = this.getFrontmatter();
 		const rulesyncFrontmatter = {
-			name: frontmatter.name,
-			description: frontmatter.description,
-			targets: ["*"]
+			name,
+			description,
+			targets: ["*"],
+			...Object.keys(ampSection).length > 0 && { amp: ampSection }
 		};
 		return new RulesyncSkill({
 			outputRoot: this.outputRoot,
@@ -36765,6 +36968,7 @@ var AmpSkill = class AmpSkill extends ToolSkill {
 		const settablePaths = AmpSkill.getSettablePaths({ global });
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
 		const ampFrontmatter = {
+			...rulesyncFrontmatter.amp,
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description
 		};
@@ -39191,6 +39395,47 @@ const JunieSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
 	description: zod_mini.z.string()
 });
+/** An ATX markdown heading line (`#` … `######`). */
+const HEADING_LINE = /^#{1,6}(\s|$)/;
+/**
+* Junie's own fallback for a `SKILL.md` with no `description`: "If
+* `description` is not provided in the frontmatter, Junie CLI extracts the
+* first paragraph of the body content as the description." Headings do not
+* count as that paragraph — "If the body is also empty or contains only
+* headings, the skill will fail to load."
+*
+* This is import-only. The canonical `RulesyncSkillFrontmatter` requires a
+* description, so without the fallback a skill Junie itself loads fine aborts
+* the whole import; generation keeps emitting an explicit description, which
+* the same docs recommend.
+*
+* Heading lines are therefore skipped rather than taken: a body opening with
+* `# Skill Name` would otherwise import that title as the description and —
+* because the next generate writes it out explicitly — replace Junie's own
+* correct fallback with the wrong value everywhere, canonical config included.
+*
+* A paragraph runs to the first blank line or heading, and is collapsed onto
+* one line because it becomes a YAML frontmatter value. A fenced code block is
+* not treated specially: it is ordinary content, so a body whose first
+* paragraph is a fence yields the fence text. Returns an empty string when the
+* body holds no such paragraph, which the caller turns into a skipped skill.
+*
+* @see https://junie.jetbrains.com/docs/agent-skills.html
+*/
+function deriveDescriptionFromBody(body) {
+	const paragraph = [];
+	for (const rawLine of body.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (paragraph.length === 0) {
+			if (line === "" || HEADING_LINE.test(line)) continue;
+			paragraph.push(line);
+			continue;
+		}
+		if (line === "" || HEADING_LINE.test(line)) break;
+		paragraph.push(line);
+	}
+	return paragraph.join(" ").trim();
+}
 /**
 * Represents a JetBrains Junie skill directory.
 * Skills are stored under the .junie/skills directory with SKILL.md files.
@@ -39287,7 +39532,16 @@ var JunieSkill = class JunieSkill extends ToolSkill {
 			...params,
 			getSettablePaths: JunieSkill.getSettablePaths
 		});
-		const result = JunieSkillFrontmatterSchema.safeParse(loaded.frontmatter);
+		let frontmatter = loaded.frontmatter;
+		if (isRecord$1(frontmatter) && frontmatter.description === void 0) {
+			const derived = deriveDescriptionFromBody(loaded.body);
+			if (derived === "") throw new Error(`Cannot import ${(0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName, SKILL_FILE_NAME)}: it has no description and its body has no paragraph to derive one from, so Junie cannot load it either. Add a description to the frontmatter.`);
+			frontmatter = {
+				...frontmatter,
+				description: derived
+			};
+		}
+		const result = JunieSkillFrontmatterSchema.safeParse(frontmatter);
 		if (!result.success) {
 			const skillDirPath = (0, node_path.join)(loaded.outputRoot, loaded.relativeDirPath, loaded.dirName);
 			throw new Error(`Invalid frontmatter in ${(0, node_path.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`);
@@ -41752,7 +42006,8 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 		meta: {
 			supportsProject: true,
 			supportsSimulated: false,
-			supportsGlobal: true
+			supportsGlobal: true,
+			lenientImport: true
 		}
 	}],
 	["kilo", {