rulesync 16.11.0 → 16.12.0

package/dist/{import--_2cfZlH.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,34 +2478,52 @@ 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).
 *
 * The events rulesync writes to `.github/hooks/*.json`:
 * `sessionStart`, `sessionEnd`, `userPromptSubmitted` ← `beforeSubmitPrompt`,
-* `preToolUse`, `postToolUse`, `agentStop` ← `stop`, `subagentStart`,
-* `subagentStop`, `errorOccurred` ← `afterError`, and `preCompact`.
+* `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
@@ -2513,9 +2532,11 @@ const CLINE_HOOK_EVENTS = [
 * undo that. `notification` and `permissionRequest` stay out because the same
 * column is explicit that they do not fire on the cloud agent.
 *
-* Two further CLI events — `postToolUseFailure` and `userPromptTransformed`
-* ({@link COPILOTCLI_HOOK_EVENTS}) — are documented as firing on the cloud
-* agent as well but are not modelled here yet.
+* `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/reference/hooks-reference
 */
@@ -2525,11 +2546,13 @@ const COPILOT_HOOK_EVENTS = [
 	"beforeSubmitPrompt",
 	"preToolUse",
 	"postToolUse",
+	"postToolUseFailure",
 	"stop",
 	"subagentStart",
 	"subagentStop",
 	"afterError",
-	"preCompact"
+	"preCompact",
+	"userPromptExpansion"
 ];
 /**
 * Hook events supported by the GitHub Copilot CLI (`copilotcli-hooks.ts`).
@@ -3245,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.
@@ -3264,11 +3293,13 @@ const CANONICAL_TO_COPILOT_EVENT_NAMES = {
 	beforeSubmitPrompt: "userPromptSubmitted",
 	preToolUse: "preToolUse",
 	postToolUse: "postToolUse",
+	postToolUseFailure: "postToolUseFailure",
 	stop: "agentStop",
 	subagentStart: "subagentStart",
 	subagentStop: "subagentStop",
 	afterError: "errorOccurred",
-	preCompact: "preCompact"
+	preCompact: "preCompact",
+	userPromptExpansion: "userPromptTransformed"
 };
 /**
 * Map Copilot camelCase event names to canonical camelCase.
@@ -5493,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()),
@@ -11725,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;
@@ -15407,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=''",
@@ -15420,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 = ''",
@@ -15490,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;
@@ -15648,6 +15716,11 @@ const CODEXCLI_CONVERTER_CONFIG = {
 	numberPassthroughFields: [{
 		canonical: "additionalContextLimit",
 		tool: "additionalContextLimit"
+	}],
+	booleanPassthroughFields: [{
+		canonical: "async",
+		tool: "async",
+		commandOnly: true
 	}]
 };
 /**
@@ -16774,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({
@@ -16801,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,
@@ -16816,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,
@@ -16830,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
 		});
@@ -16972,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).
@@ -23164,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) {
@@ -23198,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,
@@ -23214,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 {
@@ -27229,8 +27373,8 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 		meta: {
 			supportsProject: true,
 			supportsGlobal: true,
-			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsEnabledTools: true,
+			supportsDisabledTools: true
 		}
 	}],
 	["factorydroid", {
@@ -27239,7 +27383,7 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: true,
 			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsDisabledTools: true
 		}
 	}],
 	["goose", {
@@ -27365,7 +27509,7 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: false,
 			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsDisabledTools: true
 		}
 	}],
 	["zoocode", {
@@ -27374,7 +27518,7 @@ const toolMcpFactories = /* @__PURE__ */ new Map([
 			supportsProject: true,
 			supportsGlobal: false,
 			supportsEnabledTools: false,
-			supportsDisabledTools: false
+			supportsDisabledTools: true
 		}
 	}],
 	["rovodev", {
@@ -31301,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 = {
@@ -31514,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({
@@ -36800,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,
@@ -36821,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
 		};
@@ -39247,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.
@@ -39343,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)}`);
@@ -41808,7 +42006,8 @@ const toolSkillFactories = /* @__PURE__ */ new Map([
 		meta: {
 			supportsProject: true,
 			supportsSimulated: false,
-			supportsGlobal: true
+			supportsGlobal: true,
+			lenientImport: true
 		}
 	}],
 	["kilo", {