skilld 1.7.3 → 2.0.0

package/dist/_chunks/agent.mjs

@@ -1,62 +1,130 @@
-import { n as sanitizeMarkdown } from "./sanitize.mjs";
-import { _ as writeSections, g as readCachedSection } from "./cache.mjs";
-import { i as resolveSkilldCommand } from "./shared.mjs";
 import { a as targets, t as detectInstalledAgents } from "./detect.mjs";
-import { c as wrapSection, n as SECTION_OUTPUT_FILES, o as getSectionValidator, r as buildAllSectionPrompts, t as SECTION_MERGE_ORDER } from "./prompts.mjs";
-import "./skill.mjs";
-import { homedir } from "node:os";
-import { dirname, join } from "pathe";
-import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, unlinkSync, writeFileSync } from "node:fs";
+import { A as resolveSkilldCommand, C as SECTION_OUTPUT_FILES, S as SECTION_MERGE_ORDER, _ as buildAllSectionPrompts, x as wrapSection, y as getSectionValidator } from "./prompts.mjs";
+import { g as skillLogDir, i as LLM_CACHE_DIR, m as skillInternalDir, n as CACHE_DIR, o as PI_AI_AUTH_PATH } from "./paths.mjs";
+import { d as SECTION_HEADING_RE, m as TRAILING_SLASH_RE, p as SOURCE_LINK_RE, t as API_CHANGE_BULLET_RE } from "./regex.mjs";
+import { n as sanitizeMarkdown } from "./sanitize.mjs";
+import { n as getSkillReferenceDirs, t as createReferenceCache } from "./cache.mjs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { promisify, styleText } from "node:util";
+import { join } from "pathe";
 import { exec, execFileSync, spawn } from "node:child_process";
 import { isWindows } from "std-env";
-import { glob } from "tinyglobby";
-import { findDynamicImports, findStaticImports } from "mlly";
-import { createHash } from "node:crypto";
-import { setTimeout as setTimeout$1 } from "node:timers/promises";
-import { promisify } from "node:util";
+import { homedir } from "node:os";
+import { getEnvApiKey, getEnvApiKey as getEnvApiKey$1, getModel, getModels, getProviders, streamSimple } from "@earendil-works/pi-ai";
+import { getOAuthApiKey, getOAuthProvider, getOAuthProviders } from "@earendil-works/pi-ai/oauth";
 import { resolve as resolve$1 } from "node:path";
-import { getEnvApiKey, getModel, getModels, getProviders, streamSimple } from "@mariozechner/pi-ai";
-import { getOAuthApiKey, getOAuthProvider, getOAuthProviders } from "@mariozechner/pi-ai/oauth";
 import { Type } from "typebox";
-import { readFile } from "node:fs/promises";
+import { glob, readFile } from "node:fs/promises";
 import { parseSync } from "oxc-parser";
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var claude_exports = /* @__PURE__ */ __exportAll({
-	agentId: () => agentId$2,
-	buildArgs: () => buildArgs$2,
-	cli: () => cli$2,
-	models: () => models$2,
-	parseLine: () => parseLine$2
-});
-const cli$2 = "claude";
-const agentId$2 = "claude-code";
-const models$2 = {
-	opus: {
-		model: "opus",
-		name: "Opus 4.6",
-		hint: "Most capable for complex work"
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { createHash } from "node:crypto";
+const STATIC_REGEX_1$6 = /-\d{8}$/;
+const STATIC_REGEX_2$5 = /-\d{4}-\d{2}-\d{2}$/;
+const STATIC_REGEX_3$3 = /-preview/;
+function isStableId(id) {
+	if (STATIC_REGEX_1$6.test(id)) return false;
+	if (STATIC_REGEX_2$5.test(id)) return false;
+	if (STATIC_REGEX_3$3.test(id)) return false;
+	return true;
+}
+function compareVersions(a, b) {
+	const versionOf = (id) => {
+		return (id.match(/\d+(?:\.\d+)?/g) ?? []).flatMap((n) => n.split(".").map(Number));
+	};
+	const av = versionOf(a);
+	const bv = versionOf(b);
+	for (let i = 0; i < Math.max(av.length, bv.length); i++) {
+		const x = av[i] ?? 0;
+		const y = bv[i] ?? 0;
+		if (x !== y) return y - x;
+	}
+	return 0;
+}
+function resolve$2(opts) {
+	const { provider, prefix, contains, exclude } = opts;
+	return getModels(provider).filter((m) => isStableId(m.id)).filter((m) => m.id.startsWith(prefix)).filter((m) => !contains || m.id.includes(contains)).filter((m) => !exclude?.some((e) => m.id.includes(e))).sort((a, b) => compareVersions(a.id, b.id))[0];
+}
+function buildModelEntry(opts) {
+	const found = resolve$2(opts);
+	const piName = found?.name;
+	const transformed = piName && opts.nameTransform ? opts.nameTransform(piName) : piName;
+	const name = opts.name ?? transformed ?? opts.model ?? opts.prefix;
+	return {
+		model: opts.model ?? found?.id ?? opts.prefix,
+		name,
+		hint: opts.hint,
+		recommended: opts.recommended
+	};
+}
+function buildModels(entries) {
+	return Object.fromEntries(entries.map((e) => {
+		const entry = buildModelEntry(e);
+		return [entry.model, entry];
+	}));
+}
+const TOOL_NAMES = {
+	Read: {
+		canonical: "read",
+		verb: "Reading"
 	},
-	sonnet: {
-		model: "sonnet",
-		name: "Sonnet 4.6",
-		hint: "Best for everyday tasks"
+	Glob: {
+		canonical: "search",
+		verb: "Searching"
 	},
-	haiku: {
-		model: "haiku",
-		name: "Haiku 4.5",
-		hint: "Fastest for quick answers",
-		recommended: true
+	Grep: {
+		canonical: "search",
+		verb: "Searching"
+	},
+	Write: {
+		canonical: "write",
+		verb: "Writing"
+	},
+	Bash: {
+		canonical: "shell",
+		verb: "Running"
+	},
+	read_file: {
+		canonical: "read",
+		verb: "Reading"
+	},
+	glob_tool: {
+		canonical: "search",
+		verb: "Searching"
+	},
+	write_file: {
+		canonical: "write",
+		verb: "Writing"
+	},
+	list_directory: {
+		canonical: "list",
+		verb: "Listing"
+	},
+	search_file_content: {
+		canonical: "search",
+		verb: "Searching"
+	},
+	run_shell_command: {
+		canonical: "shell",
+		verb: "Running"
 	}
 };
+function extractToolHint(input) {
+	if (!input) return void 0;
+	for (const k of [
+		"file_path",
+		"path",
+		"dir_path",
+		"pattern",
+		"query",
+		"command"
+	]) {
+		const v = input[k];
+		if (typeof v === "string" && v) return v;
+	}
+}
+const STATIC_REGEX_1$5 = /^Claude\s+/;
+const STATIC_REGEX_2$4 = /\s*\(latest\)\s*$/i;
+const stripClaude = (n) => n.replace(STATIC_REGEX_1$5, "").replace(STATIC_REGEX_2$4, "");
 function buildArgs$2(model, skillDir, symlinkDirs) {
 	return [
 		"-p",
@@ -82,38 +150,36 @@ function buildArgs$2(model, skillDir, symlinkDirs) {
 		"--no-session-persistence"
 	];
 }
-function parseLine$2(line) {
+function parseEvent$2(line) {
 	try {
 		const obj = JSON.parse(line);
 		if (obj.type === "stream_event") {
 			const evt = obj.event;
-			if (!evt) return {};
-			if (evt.type === "content_block_delta" && evt.delta?.type === "text_delta") return { textDelta: evt.delta.text };
-			return {};
+			if (evt?.type === "content_block_delta" && evt.delta?.type === "text_delta") return {
+				kind: "text",
+				delta: evt.delta.text
+			};
+			return { kind: "noop" };
 		}
 		if (obj.type === "assistant" && obj.message?.content) {
 			const content = obj.message.content;
 			const tools = content.filter((c) => c.type === "tool_use");
-			if (tools.length) {
-				const names = tools.map((t) => t.name);
-				const hint = tools.map((t) => {
-					const input = t.input || {};
-					return input.file_path || input.path || input.pattern || input.query || input.command || "";
-				}).filter(Boolean).join(", ");
-				const writeTool = tools.find((t) => t.name === "Write" && t.input?.content);
-				return {
-					toolName: names.join(", "),
-					toolHint: hint || void 0,
-					writeContent: writeTool?.input?.content
-				};
-			}
+			if (tools.length) return {
+				kind: "tool-call",
+				tool: tools.map((t) => t.name).join(", "),
+				hint: tools.map((t) => extractToolHint(t.input) ?? "").filter(Boolean).join(", ") || void 0,
+				writeContent: tools.find((t) => t.name === "Write" && t.input?.content)?.input?.content
+			};
 			const text = content.filter((c) => c.type === "text").map((c) => c.text).join("");
-			if (text) return { fullText: text };
+			if (text) return {
+				kind: "text",
+				full: text
+			};
 		}
 		if (obj.type === "result") {
 			const u = obj.usage;
 			return {
-				done: true,
+				kind: "done",
 				usage: u ? {
 					input: u.input_tokens ?? u.inputTokens ?? 0,
 					output: u.output_tokens ?? u.outputTokens ?? 0
@@ -123,35 +189,40 @@ function parseLine$2(line) {
 			};
 		}
 	} catch {}
-	return {};
+	return { kind: "noop" };
 }
-var codex_exports = /* @__PURE__ */ __exportAll({
-	agentId: () => agentId$1,
-	buildArgs: () => buildArgs$1,
-	cli: () => cli$1,
-	models: () => models$1,
-	parseLine: () => parseLine$1
-});
-const cli$1 = "codex";
-const agentId$1 = "codex";
-const models$1 = {
-	"gpt-5.3-codex": {
-		model: "gpt-5.3-codex",
-		name: "GPT-5.3 Codex",
-		hint: "Latest frontier Codex model"
-	},
-	"gpt-5.3-codex-spark": {
-		model: "gpt-5.3-codex-spark",
-		name: "GPT-5.3 Codex Spark",
-		hint: "Faster GPT-5.3 Codex variant",
-		recommended: true
-	},
-	"gpt-5.2-codex": {
-		model: "gpt-5.2-codex",
-		name: "GPT-5.2 Codex",
-		hint: "Frontier agentic coding model"
-	}
+const adapter$2 = {
+	cli: "claude",
+	agentId: "claude-code",
+	providerName: "Anthropic",
+	models: buildModels([
+		{
+			model: "opus",
+			provider: "anthropic",
+			prefix: "claude-opus-",
+			nameTransform: stripClaude,
+			hint: "Most capable for complex work"
+		},
+		{
+			model: "sonnet",
+			provider: "anthropic",
+			prefix: "claude-sonnet-",
+			nameTransform: stripClaude,
+			hint: "Best for everyday tasks"
+		},
+		{
+			model: "haiku",
+			provider: "anthropic",
+			prefix: "claude-haiku-",
+			nameTransform: stripClaude,
+			hint: "Fastest for quick answers",
+			recommended: true
+		}
+	]),
+	buildArgs: buildArgs$2,
+	parseEvent: parseEvent$2
 };
+const STATIC_REGEX_1$4 = /^cat\s*>|>/;
 function buildArgs$1(model, _skillDir, _symlinkDirs) {
 	return [
 		"exec",
@@ -163,62 +234,82 @@ function buildArgs$1(model, _skillDir, _symlinkDirs) {
 		"-"
 	];
 }
-function parseLine$1(line) {
+function parseEvent$1(line) {
 	try {
 		const obj = JSON.parse(line);
 		if (obj.type === "item.completed" && obj.item) {
 			const item = obj.item;
-			if (item.type === "agent_message" && item.text) return { fullText: item.text };
+			if (item.type === "agent_message" && item.text) return {
+				kind: "text",
+				full: item.text
+			};
 			if (item.type === "command_execution" && item.aggregated_output) {
 				const cmd = item.command || "";
-				const writeContent = /^cat\s*>|>/.test(cmd) ? item.aggregated_output : void 0;
+				const writeContent = STATIC_REGEX_1$4.test(cmd) ? item.aggregated_output : void 0;
 				return {
-					toolName: "Bash",
-					toolHint: `(${item.aggregated_output.length} chars output)`,
+					kind: "tool-call",
+					tool: "Bash",
+					hint: `(${item.aggregated_output.length} chars output)`,
 					writeContent
 				};
 			}
 			if (item.type === "file_change" && item.changes?.length) return {
-				toolName: "Write",
-				toolHint: item.changes.map((c) => c.path).join(", ")
+				kind: "tool-call",
+				tool: "Write",
+				hint: item.changes.map((c) => c.path).join(", ")
 			};
 		}
 		if (obj.type === "item.started" && obj.item?.type === "command_execution") return {
-			toolName: "Bash",
-			toolHint: obj.item.command
+			kind: "tool-call",
+			tool: "Bash",
+			hint: obj.item.command
 		};
 		if (obj.type === "turn.completed" && obj.usage) return {
-			done: true,
+			kind: "done",
 			usage: {
 				input: obj.usage.input_tokens ?? 0,
 				output: obj.usage.output_tokens ?? 0
 			}
 		};
-		if (obj.type === "turn.failed" || obj.type === "error") return { done: true };
+		if (obj.type === "turn.failed" || obj.type === "error") return {
+			kind: "error",
+			message: obj.message
+		};
 	} catch {}
-	return {};
+	return { kind: "noop" };
 }
-var gemini_exports = /* @__PURE__ */ __exportAll({
-	agentId: () => agentId,
-	buildArgs: () => buildArgs,
-	cli: () => cli,
-	models: () => models,
-	parseLine: () => parseLine
-});
-const cli = "gemini";
-const agentId = "gemini-cli";
-const models = {
-	"gemini-3.1-pro": {
-		model: "gemini-3.1-pro",
-		name: "Gemini 3.1 Pro",
-		hint: "Most capable"
-	},
-	"gemini-3-flash": {
-		model: "gemini-3-flash",
-		name: "Gemini 3 Flash",
-		hint: "Balanced",
-		recommended: true
-	}
+const adapter$1 = {
+	cli: "codex",
+	agentId: "codex",
+	providerName: "OpenAI",
+	models: buildModels([
+		{
+			provider: "openai",
+			prefix: "gpt-",
+			contains: "codex",
+			exclude: [
+				"spark",
+				"mini",
+				"max"
+			],
+			hint: "Latest frontier Codex model"
+		},
+		{
+			provider: "openai",
+			prefix: "gpt-",
+			contains: "codex-spark",
+			hint: "Faster Codex variant",
+			recommended: true
+		},
+		{
+			provider: "openai",
+			prefix: "gpt-",
+			contains: "codex-mini",
+			hint: "Cheapest Codex variant"
+		}
+	]),
+	buildArgs: buildArgs$1,
+	parseEvent: parseEvent$1
 };
 function buildArgs(model, skillDir, symlinkDirs) {
 	return [
@@ -233,28 +324,30 @@ function buildArgs(model, skillDir, symlinkDirs) {
 		...symlinkDirs.flatMap((d) => ["--include-directories", d])
 	];
 }
-function parseLine(line) {
+function parseEvent(line) {
 	try {
 		const obj = JSON.parse(line);
-		if (obj.type === "message" && obj.role === "assistant" && obj.content) return obj.delta ? { textDelta: obj.content } : { fullText: obj.content };
+		if (obj.type === "message" && obj.role === "assistant" && obj.content) return obj.delta ? {
+			kind: "text",
+			delta: obj.content
+		} : {
+			kind: "text",
+			full: obj.content
+		};
 		if (obj.type === "tool_use" || obj.type === "tool_call") {
-			const name = obj.tool_name || obj.name || obj.tool || "tool";
+			const tool = obj.tool_name || obj.name || obj.tool || "tool";
 			const params = obj.parameters || obj.args || obj.input || {};
-			const hint = params.file_path || params.path || params.dir_path || params.pattern || params.query || params.command || "";
-			if (name === "write_file" && params.content) return {
-				toolName: name,
-				toolHint: hint || void 0,
-				writeContent: params.content
-			};
 			return {
-				toolName: name,
-				toolHint: hint || void 0
+				kind: "tool-call",
+				tool,
+				hint: extractToolHint(params),
+				writeContent: tool === "write_file" && typeof params.content === "string" ? params.content : void 0
 			};
 		}
 		if (obj.type === "result") {
 			const s = obj.stats;
 			return {
-				done: true,
+				kind: "done",
 				usage: s ? {
 					input: s.input_tokens ?? s.input ?? 0,
 					output: s.output_tokens ?? s.output ?? 0
@@ -263,21 +356,37 @@ function parseLine(line) {
 			};
 		}
 	} catch {}
-	return {};
-}
-function isPiAiModel(model) {
-	return model.startsWith("pi:");
-}
-function parsePiAiModelId(model) {
-	if (!model.startsWith("pi:")) return null;
-	const rest = model.slice(3);
-	const slashIdx = rest.indexOf("/");
-	if (slashIdx === -1) return null;
-	return {
-		provider: rest.slice(0, slashIdx),
-		modelId: rest.slice(slashIdx + 1)
-	};
+	return { kind: "noop" };
 }
+const adapter = {
+	cli: "gemini",
+	agentId: "gemini-cli",
+	providerName: "Google",
+	models: buildModels([{
+		provider: "google",
+		prefix: "gemini-",
+		contains: "pro",
+		exclude: [
+			"flash",
+			"live",
+			"gemma"
+		],
+		hint: "Most capable"
+	}, {
+		provider: "google",
+		prefix: "gemini-",
+		contains: "flash",
+		exclude: [
+			"lite",
+			"live",
+			"preview"
+		],
+		hint: "Balanced",
+		recommended: true
+	}]),
+	buildArgs,
+	parseEvent
+};
 const BLOCKED_OAUTH_PROVIDERS = new Set([
 	"google-antigravity",
 	"google-gemini-cli",
@@ -286,7 +395,11 @@ const BLOCKED_OAUTH_PROVIDERS = new Set([
 	"openai-codex"
 ]);
 const PI_AGENT_AUTH_PATH = join(process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent"), "auth.json");
-const SKILLD_AUTH_PATH = join(homedir(), ".skilld", "pi-ai-auth.json");
+const SKILLD_AUTH_PATH = PI_AI_AUTH_PATH;
+const OAUTH_PROVIDER_OVERRIDES = {
+	google: "google-gemini-cli",
+	openai: "openai-codex"
+};
 function readAuthFile(path) {
 	if (!existsSync(path)) return {};
 	try {
@@ -303,16 +416,12 @@ function loadAuth() {
 	};
 }
 function saveAuth(auth) {
-	mkdirSync(join(homedir(), ".skilld"), {
+	mkdirSync(CACHE_DIR, {
 		recursive: true,
 		mode: 448
 	});
 	writeFileSync(SKILLD_AUTH_PATH, JSON.stringify(auth, null, 2), { mode: 384 });
 }
-const OAUTH_PROVIDER_OVERRIDES = {
-	google: "google-gemini-cli",
-	openai: "openai-codex"
-};
 function resolveOAuthProviderId(modelProvider) {
 	const oauthId = OAUTH_PROVIDER_OVERRIDES[modelProvider] ?? modelProvider;
 	if (BLOCKED_OAUTH_PROVIDERS.has(oauthId)) return null;
@@ -321,7 +430,7 @@ function resolveOAuthProviderId(modelProvider) {
 	return null;
 }
 async function resolveApiKey(provider) {
-	const envKey = getEnvApiKey(provider);
+	const envKey = getEnvApiKey$1(provider);
 	if (envKey) return envKey;
 	const oauthProviderId = resolveOAuthProviderId(provider);
 	if (!oauthProviderId) return null;
@@ -366,6 +475,19 @@ function logoutOAuthProvider(providerId) {
 	delete auth[providerId];
 	saveAuth(auth);
 }
+function isPiAiModel(model) {
+	return model.startsWith("pi:");
+}
+function parsePiAiModelId(model) {
+	if (!model.startsWith("pi:")) return null;
+	const rest = model.slice(3);
+	const slashIdx = rest.indexOf("/");
+	if (slashIdx === -1) return null;
+	return {
+		provider: rest.slice(0, slashIdx),
+		modelId: rest.slice(slashIdx + 1)
+	};
+}
 const MIN_CONTEXT_WINDOW = 32e3;
 const LEGACY_MODEL_PATTERNS = [
 	/^claude-3-/,
@@ -429,6 +551,10 @@ function getAvailablePiAiModels() {
 	}
 	return available;
 }
+const STATIC_REGEX_1$3 = /^\.\/\.skilld\//;
+const STATIC_REGEX_2$3 = /^\.skilld\//;
+const STATIC_REGEX_3$2 = /^\.\//;
+const STATIC_REGEX_5$2 = /\s+/;
 const TOOLS = [
 	{
 		name: "Read",
@@ -457,7 +583,6 @@ const TOOLS = [
 		parameters: Type.Object({ command: Type.String({ description: "Shell command to run" }) })
 	}
 ];
-const MAX_TOOL_TURNS = 30;
 const SAFE_COMMANDS = new Set([
 	"skilld",
 	"ls",
@@ -466,7 +591,7 @@ const SAFE_COMMANDS = new Set([
 ]);
 const SHELL_META_RE = /[;&|`$()<>]/;
 function resolveSandboxedPath(p, skilldDir) {
-	const resolved = resolve$1(skilldDir, String(p).replace(/^\.\/\.skilld\//, "./").replace(/^\.skilld\//, "./").replace(/^\.\//, ""));
+	const resolved = resolve$1(skilldDir, String(p).replace(STATIC_REGEX_1$3, "./").replace(STATIC_REGEX_2$3, "./").replace(STATIC_REGEX_3$2, ""));
 	if (!resolved.startsWith(`${skilldDir}/`) && resolved !== skilldDir) throw new Error(`Path traversal blocked: ${p}`);
 	return resolved;
 }
@@ -522,7 +647,7 @@ function executeTool(toolCall, skilldDir) {
 			return sanitizeMarkdown(readFileSync(filePath, "utf-8"));
 		}
 		case "Glob": {
-			const pattern = String(args.pattern).replace(/^\.\/\.skilld\//, "./").replace(/^\.skilld\//, "./").replace(/^\.\//, "");
+			const pattern = String(args.pattern).replace(STATIC_REGEX_1$3, "./").replace(STATIC_REGEX_2$3, "./").replace(STATIC_REGEX_3$2, "");
 			const results = [];
 			const walkDir = (dir, prefix) => {
 				if (!existsSync(dir)) return;
@@ -532,9 +657,9 @@ function executeTool(toolCall, skilldDir) {
 					else results.push(`./.skilld/${relPath}`);
 				}
 			};
-			const baseDir = pattern.split("*")[0]?.replace(/\/$/, "") ?? "";
+			const baseDir = pattern.split("*")[0]?.replace(TRAILING_SLASH_RE, "") ?? "";
 			walkDir(join(skilldDir, baseDir), baseDir);
-			const matched = results.filter((r) => globMatch(r.replace(/^\.\/\.skilld\//, ""), pattern));
+			const matched = results.filter((r) => globMatch(r.replace(STATIC_REGEX_1$3, ""), pattern));
 			return matched.length > 0 ? matched.join("\n") : `No files matching: ${args.pattern}`;
 		}
 		case "Write":
@@ -542,7 +667,7 @@ function executeTool(toolCall, skilldDir) {
 			return "File written successfully.";
 		case "Bash": {
 			const cmd = String(args.command).trim();
-			const parts = cmd.split(/\s+/);
+			const parts = cmd.split(STATIC_REGEX_5$2);
 			const bin = parts[0] ?? "";
 			if (!SAFE_COMMANDS.has(bin) || SHELL_META_RE.test(cmd)) return `Error: command not allowed. Only skilld, ls, cat, find commands are permitted.`;
 			try {
@@ -559,12 +684,13 @@ function executeTool(toolCall, skilldDir) {
 		default: return `Unknown tool: ${toolCall.name}`;
 	}
 }
+const SYSTEM_PROMPT = "You are a technical documentation expert generating SKILL.md sections for AI agent skills. Follow the format instructions exactly. Use the provided tools to explore reference files in ./.skilld/ before writing your output.";
 async function optimizeSectionPiAi(opts) {
 	const parsed = parsePiAiModelId(opts.model);
 	if (!parsed) throw new Error(`Invalid pi-ai model ID: ${opts.model}. Expected format: pi:provider/model-id`);
 	const model = getModel(parsed.provider, parsed.modelId);
 	const apiKey = await resolveApiKey(parsed.provider);
-	const skilldDir = join(opts.skillDir, ".skilld");
+	const skilldDir = skillInternalDir(opts.skillDir);
 	const fullPrompt = opts.prompt;
 	opts.onProgress?.({
 		chunk: "[starting...]",
@@ -586,10 +712,10 @@ async function optimizeSectionPiAi(opts) {
 	let totalUsage;
 	let totalCost;
 	let lastWriteContent = "";
-	for (let turn = 0; turn < MAX_TOOL_TURNS; turn++) {
+	for (let turn = 0; turn < 30; turn++) {
 		if (opts.signal?.aborted) throw new Error("pi-ai request timed out");
 		const eventStream = streamSimple(model, {
-			systemPrompt: "You are a technical documentation expert generating SKILL.md sections for AI agent skills. Follow the format instructions exactly. Use the provided tools to explore reference files in ./.skilld/ before writing your output.",
+			systemPrompt: SYSTEM_PROMPT,
 			messages,
 			tools: TOOLS
 		}, {
@@ -664,7 +790,7 @@ async function optimizeSectionPiAi(opts) {
 			});
 		}
 	}
-	if (!completed) throw new Error(`pi-ai exceeded ${MAX_TOOL_TURNS} tool turns without completing`);
+	if (!completed) throw new Error(`pi-ai exceeded 30 tool turns without completing`);
 	return {
 		text: text || lastWriteContent,
 		fullPrompt,
@@ -672,19 +798,51 @@ async function optimizeSectionPiAi(opts) {
 		cost: totalCost
 	};
 }
-const TOOL_VERBS = {
-	Read: "Reading",
-	Glob: "Searching",
-	Grep: "Searching",
-	Write: "Writing",
-	Bash: "Running",
-	read_file: "Reading",
-	glob_tool: "Searching",
-	write_file: "Writing",
-	list_directory: "Listing",
-	search_file_content: "Searching",
-	run_shell_command: "Running"
-};
+const STATIC_REGEX_1$2 = /^```(?:markdown|md)?[^\S\n]*\n([\s\S]+)\n```[^\S\n]*$/;
+const STATIC_REGEX_2$2 = /^```(?:markdown|md)/;
+const STATIC_REGEX_5$1 = /^-{3,}\n/;
+const STATIC_REGEX_6 = /\n-{3,}/;
+const STATIC_REGEX_7 = /^(##\s|- (?:BREAKING|DEPRECATED|NEW): )/m;
+const STATIC_REGEX_8 = /^(## .+)\n/;
+const STATIC_REGEX_9 = /^\.\/(?:\.skilld\/|references\/)/;
+function cleanSectionOutput(content) {
+	let cleaned = content.trim();
+	const wrapMatch = cleaned.match(STATIC_REGEX_1$2);
+	if (wrapMatch) {
+		const inner = wrapMatch[1].trim();
+		if (STATIC_REGEX_2$2.test(cleaned) || SECTION_HEADING_RE.test(inner) || API_CHANGE_BULLET_RE.test(inner)) cleaned = inner;
+	}
+	cleaned = cleaned.replace(/^# (?!#)/gm, "## ");
+	const fmMatch = cleaned.match(STATIC_REGEX_5$1);
+	if (fmMatch) {
+		const afterOpen = fmMatch[0].length;
+		const closeMatch = cleaned.slice(afterOpen).match(STATIC_REGEX_6);
+		if (closeMatch) cleaned = cleaned.slice(afterOpen + closeMatch.index + closeMatch[0].length).trim();
+		else cleaned = cleaned.slice(afterOpen).trim();
+	}
+	const firstMarker = cleaned.match(STATIC_REGEX_7);
+	if (firstMarker?.index && firstMarker.index > 0) cleaned = cleaned.slice(firstMarker.index).trim();
+	const headingMatch = cleaned.match(STATIC_REGEX_8);
+	if (headingMatch) {
+		const heading = headingMatch[1];
+		const afterFirst = headingMatch[0].length;
+		const secondIdx = cleaned.indexOf(heading, afterFirst);
+		if (secondIdx !== -1) {
+			if (secondIdx - afterFirst < 200) cleaned = cleaned.slice(secondIdx).trim();
+		}
+	}
+	cleaned = cleaned.replace(/\(?\[`?\.\/(?:\.skilld\/|references\/)[^)\]]*\]\(([^)]+)\)\)?/g, (match, url) => {
+		if (STATIC_REGEX_9.test(url)) return `[source](${url})`;
+		return match;
+	});
+	cleaned = cleaned.replace(/\[source\]\(\.\/((docs|issues|discussions|releases|pkg|guide)\/)/g, "[source](./.skilld/$1");
+	cleaned = sanitizeMarkdown(cleaned);
+	if (!SECTION_HEADING_RE.test(cleaned) && !API_CHANGE_BULLET_RE.test(cleaned) && !SOURCE_LINK_RE.test(cleaned)) return "";
+	return cleaned;
+}
+const STATIC_REGEX_1$1 = /^\[(?:starting|retrying|cached)/;
+const STATIC_REGEX_2$1 = /^\[([^:[\]]+)(?::\s(.+))?\]$/;
+const STATIC_REGEX_3$1 = /skilld search\s+"([^"]+)"/;
 function createToolProgress(log) {
 	let lastMsg = "";
 	let repeatCount = 0;
@@ -693,7 +851,7 @@ function createToolProgress(log) {
 	function emit(msg) {
 		if (msg === lastMsg) {
 			repeatCount++;
-			log.message(`${msg} \x1B[90m(+${repeatCount})\x1B[0m`);
+			log.message(`${msg} ${styleText("gray", `(+${repeatCount})`)}`);
 		} else {
 			lastMsg = msg;
 			repeatCount = 0;
@@ -706,57 +864,55 @@ function createToolProgress(log) {
 			const now = Date.now();
 			if (now - (lastTextEmit.get(key) ?? 0) < TEXT_THROTTLE_MS) return;
 			lastTextEmit.set(key, now);
-			const prefix = section ? `\x1B[90m[${section}]\x1B[0m ` : "";
+			const prefix = section ? `${styleText("gray", `[${section}]`)} ` : "";
 			const items = text ? text.match(/^- (?:BREAKING|DEPRECATED|NEW|CHANGED|REMOVED|Use |Do |Set |Add |Avoid |Always |Never |Prefer |Check |Ensure )/gm)?.length ?? 0 : 0;
-			emit(items > 0 ? `${prefix}Writing... \x1B[90m(${items} items)\x1B[0m` : `${prefix}Writing...`);
+			emit(items > 0 ? `${prefix}Writing... ${styleText("gray", `(${items} items)`)}` : `${prefix}Writing...`);
 			return;
 		}
 		if (type !== "reasoning" || !chunk.startsWith("[")) return;
-		if (/^\[(?:starting|retrying|cached)/.test(chunk)) {
-			emit(`${section ? `\x1B[90m[${section}]\x1B[0m ` : ""}${chunk.slice(1, -1)}`);
+		if (STATIC_REGEX_1$1.test(chunk)) {
+			emit(`${section ? `${styleText("gray", `[${section}]`)} ` : ""}${chunk.slice(1, -1)}`);
 			return;
 		}
-		const match = chunk.match(/^\[([^:[\]]+)(?::\s(.+))?\]$/);
+		const match = chunk.match(STATIC_REGEX_2$1);
 		if (!match) return;
 		const names = match[1].split(",").map((n) => n.trim());
 		const hints = match[2]?.split(",").map((h) => h.trim()) ?? [];
 		for (let i = 0; i < names.length; i++) {
 			const rawName = names[i];
 			const hint = hints[i] ?? hints[0] ?? "";
-			const verb = TOOL_VERBS[rawName] ?? rawName;
-			const prefix = section ? `\x1B[90m[${section}]\x1B[0m ` : "";
+			const verb = TOOL_NAMES[rawName]?.verb ?? rawName;
+			const prefix = section ? `${styleText("gray", `[${section}]`)} ` : "";
 			if ((rawName === "Bash" || rawName === "run_shell_command") && hint) {
-				const searchMatch = hint.match(/skilld search\s+"([^"]+)"/);
-				if (searchMatch) emit(`${prefix}Searching \x1B[36m"${searchMatch[1]}"\x1B[0m`);
+				const searchMatch = hint.match(STATIC_REGEX_3$1);
+				if (searchMatch) emit(`${prefix}Searching ${styleText("cyan", `"${searchMatch[1]}"`)}`);
 				else if (hint.includes("skilld validate")) emit(`${prefix}Validating...`);
 				else {
 					const shortened = shortenCommand(hint);
 					emit(`${prefix}Running ${shortened.length > 50 ? `${shortened.slice(0, 47)}...` : shortened}`);
 				}
-			} else emit(`${prefix}${verb} \x1B[90m${shortenPath(hint || "...")}\x1B[0m`);
+			} else emit(`${prefix}${verb} ${styleText("gray", shortenPath(hint || "..."))}`);
 		}
 	};
 }
-const CLI_DEFS = [
-	claude_exports,
-	gemini_exports,
-	codex_exports
-];
-const CLI_BUILD_ARGS = {
-	claude: buildArgs$2,
-	gemini: buildArgs,
-	codex: buildArgs$1
-};
-const CLI_PARSE_LINE = {
-	claude: parseLine$2,
-	gemini: parseLine,
-	codex: parseLine$1
-};
-const CLI_PROVIDER_NAMES = {
-	"claude-code": "Anthropic",
-	"gemini-cli": "Google",
-	"codex": "OpenAI"
+function shortenPath(p) {
+	const refIdx = p.indexOf(".skilld/");
+	if (refIdx !== -1) return p.slice(refIdx + 8);
+	const parts = p.split("/");
+	return parts.length > 2 ? `.../${parts.slice(-2).join("/")}` : p;
+}
+function shortenCommand(cmd) {
+	return cmd.replace(/\/[^\s"']+/g, (match) => {
+		if (match.includes(".claude/") || match.includes(".skilld/") || match.includes("node_modules/")) return `.../${match.split("/").slice(-2).join("/")}`;
+		return match;
+	});
+}
+const CLI_ADAPTERS = {
+	claude: adapter$2,
+	gemini: adapter,
+	codex: adapter$1
 };
+const CLI_PROVIDER_NAMES = Object.fromEntries(Object.values(CLI_ADAPTERS).map((a) => [a.agentId, a.providerName]));
 const PI_PROVIDER_NAMES = {
 	"anthropic": "Anthropic",
 	"google": "Google",
@@ -770,10 +926,10 @@ const PI_PROVIDER_NAMES = {
 	"mistral": "Mistral",
 	"xai": "xAI"
 };
-const CLI_MODELS = Object.fromEntries(CLI_DEFS.flatMap((def) => Object.entries(def.models).map(([id, entry]) => [id, {
+const CLI_MODELS = Object.fromEntries(Object.values(CLI_ADAPTERS).flatMap((adapter) => Object.entries(adapter.models).map(([id, entry]) => [id, {
 	...entry,
-	cli: def.cli,
-	agentId: def.agentId
+	cli: adapter.cli,
+	agentId: adapter.agentId
 }])));
 function getModelName(id) {
 	if (isPiAiModel(id)) return parsePiAiModelId(id)?.modelId ?? id;
@@ -834,135 +990,248 @@ async function getAvailableModels() {
 	});
 	return [...cliModels, ...piAiEntries];
 }
-function resolveReferenceDirs(skillDir) {
-	const refsDir = join(skillDir, ".skilld");
-	if (!existsSync(refsDir)) return [];
-	const resolved = readdirSync(refsDir).map((entry) => join(refsDir, entry)).filter((p) => lstatSync(p).isSymbolicLink() && existsSync(p)).map((p) => realpathSync(p));
-	const parents = /* @__PURE__ */ new Set();
-	for (const p of resolved) {
-		const parent = dirname(p);
-		if (!resolved.includes(parent)) parents.add(parent);
+const NUXT_CONFIG_FILES = [
+	"nuxt.config.ts",
+	"nuxt.config.js",
+	"nuxt.config.mjs"
+];
+const NUXT_ECOSYSTEM = [
+	"vue",
+	"nitro",
+	"h3"
+];
+async function findNuxtConfig(cwd) {
+	for (const name of NUXT_CONFIG_FILES) {
+		const path = join(cwd, name);
+		const content = await readFile(path, "utf8").catch(() => null);
+		if (content) return {
+			path,
+			content
+		};
 	}
-	return [...resolved, ...parents];
-}
-const CACHE_DIR = join(homedir(), ".skilld", "llm-cache");
-function normalizePromptForHash(prompt) {
-	return prompt.replace(/\/[^\s`]*\.(?:claude|codex|gemini)\/skills\/[^\s/`]+/g, "<SKILL_DIR>");
+	return null;
 }
-function hashPrompt(prompt, model, section) {
-	return createHash("sha256").update(`exec:${model}:${section}:${normalizePromptForHash(prompt)}`).digest("hex").slice(0, 16);
+function extractModuleStrings(node) {
+	if (!node || typeof node !== "object") return [];
+	if (node.type === "Property" && !node.computed && node.key?.type === "Identifier" && node.key.name === "modules" && node.value?.type === "ArrayExpression") return node.value.elements.filter((el) => el?.type === "Literal" && typeof el.value === "string").map((el) => el.value);
+	const results = [];
+	if (Array.isArray(node)) for (const child of node) results.push(...extractModuleStrings(child));
+	else for (const key of Object.keys(node)) {
+		if (key === "start" || key === "end" || key === "type") continue;
+		const val = node[key];
+		if (val && typeof val === "object") results.push(...extractModuleStrings(val));
+	}
+	return results;
 }
-function getCached(prompt, model, section, maxAge = 10080 * 60 * 1e3) {
-	const path = join(CACHE_DIR, `${hashPrompt(prompt, model, section)}.json`);
-	if (!existsSync(path)) return null;
-	try {
-		const { text, timestamp } = JSON.parse(readFileSync(path, "utf-8"));
-		return Date.now() - timestamp > maxAge ? null : text;
-	} catch {
-		return null;
+async function detectNuxtModules(cwd) {
+	const config = await findNuxtConfig(cwd);
+	if (!config) return [];
+	const modules = extractModuleStrings(parseSync(config.path, config.content).program);
+	const seen = /* @__PURE__ */ new Set();
+	const packages = [];
+	for (const mod of modules) if (!seen.has(mod)) {
+		seen.add(mod);
+		packages.push({
+			name: mod,
+			count: 0,
+			source: "preset"
+		});
+	}
+	for (const pkg of NUXT_ECOSYSTEM) if (!seen.has(pkg)) {
+		seen.add(pkg);
+		packages.push({
+			name: pkg,
+			count: 0,
+			source: "preset"
+		});
 	}
+	return packages;
 }
-function setCache(prompt, model, section, text) {
-	mkdirSync(CACHE_DIR, {
-		recursive: true,
-		mode: 448
-	});
-	writeFileSync(join(CACHE_DIR, `${hashPrompt(prompt, model, section)}.json`), JSON.stringify({
-		text,
-		model,
-		section,
-		timestamp: Date.now()
-	}), { mode: 384 });
+async function detectPresetPackages(cwd) {
+	return detectNuxtModules(cwd);
 }
-async function optimizeSectionViaPiAi(opts) {
-	const { section, prompt, outputFile, skillDir, model, onProgress, timeout, debug } = opts;
-	const skilldDir = join(skillDir, ".skilld");
-	const outputPath = join(skilldDir, outputFile);
-	const logsDir = join(skilldDir, "logs");
-	const logName = section.toUpperCase().replace(/-/g, "_");
-	if (existsSync(outputPath)) unlinkSync(outputPath);
-	writeFileSync(join(skilldDir, `PROMPT_${section}.md`), prompt);
+const FROM_STATIC_IMPORT_RE = /\bfrom\s*['"]([^'"\n]+)['"]/g;
+const SIDE_EFFECT_IMPORT_RE = /\bimport\s*['"]([^'"\n]+)['"]/g;
+const DYNAMIC_IMPORT_RE = /\bimport\s*\(\s*['"]([^'"\n]+)['"]\s*\)/g;
+const PATTERNS = ["**/*.{ts,js,vue,mjs,cjs,tsx,jsx,mts,cts}"];
+const IGNORE_DIRS = [
+	"node_modules",
+	"dist",
+	".nuxt",
+	".output",
+	"coverage"
+];
+function addPackage(counts, specifier) {
+	if (!specifier || specifier.startsWith(".") || specifier.startsWith("/")) return;
+	const name = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+	if (!isNodeBuiltin(name)) counts.set(name, (counts.get(name) || 0) + 1);
+}
+async function detectImportedPackages(cwd = process.cwd()) {
 	try {
-		const ac = new AbortController();
-		const timer = setTimeout(() => ac.abort(), timeout);
-		const result = await optimizeSectionPiAi({
-			section,
-			prompt,
-			skillDir,
-			model,
-			onProgress,
-			signal: ac.signal
-		}).finally(() => clearTimeout(timer));
-		const raw = result.text.trim();
-		if (debug) {
-			mkdirSync(logsDir, { recursive: true });
-			writeFileSync(join(skilldDir, `PROMPT_${section}.md`), result.fullPrompt);
-			if (raw) writeFileSync(join(logsDir, `${logName}.md`), raw);
-		}
-		if (!raw) return {
-			section,
-			content: "",
-			wasOptimized: false,
-			error: "pi-ai returned empty response"
-		};
-		const content = cleanSectionOutput(raw);
-		if (content) writeFileSync(outputPath, content);
-		const validator = getSectionValidator(section);
-		const warnings = (content && validator ? validator(content) : []).map((w) => ({
-			section,
-			warning: w.warning
+		const counts = /* @__PURE__ */ new Map();
+		const files = [];
+		for await (const file of glob(PATTERNS, {
+			cwd,
+			exclude: (p) => IGNORE_DIRS.some((dir) => p === dir || p.endsWith(`/${dir}`))
+		})) files.push(join(cwd, file));
+		await Promise.all(files.map(async (file) => {
+			const content = await readFile(file, "utf8");
+			for (const m of content.matchAll(FROM_STATIC_IMPORT_RE)) addPackage(counts, m[1]);
+			for (const m of content.matchAll(SIDE_EFFECT_IMPORT_RE)) addPackage(counts, m[1]);
+			for (const m of content.matchAll(DYNAMIC_IMPORT_RE)) addPackage(counts, m[1]);
 		}));
-		return {
-			section,
-			content,
-			wasOptimized: !!content,
-			warnings: warnings?.length ? warnings : void 0,
-			usage: result.usage,
-			cost: result.cost
-		};
+		const packages = Array.from(counts.entries(), ([name, count]) => ({
+			name,
+			count,
+			source: "import"
+		})).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+		const presets = await detectPresetPackages(cwd);
+		const importNames = new Set(packages.map((p) => p.name));
+		for (const preset of presets) if (!importNames.has(preset.name)) packages.push(preset);
+		return { packages };
 	} catch (err) {
-		const errMsg = err.message;
-		if (debug || errMsg) {
-			mkdirSync(logsDir, { recursive: true });
-			writeFileSync(join(logsDir, `${logName}.stderr.log`), errMsg);
-		}
 		return {
-			section,
-			content: "",
-			wasOptimized: false,
-			error: errMsg
+			packages: [],
+			error: String(err)
 		};
 	}
 }
-function optimizeSection(opts) {
-	const { section, prompt, outputFile, skillDir, model, onProgress, timeout, debug, preExistingFiles } = opts;
-	if (isPiAiModel(model)) return optimizeSectionViaPiAi({
-		section,
-		prompt,
-		outputFile,
-		skillDir,
-		model,
-		onProgress,
-		timeout,
-		debug
+const NODE_BUILTINS = new Set([
+	"assert",
+	"async_hooks",
+	"buffer",
+	"child_process",
+	"cluster",
+	"console",
+	"constants",
+	"crypto",
+	"dgram",
+	"diagnostics_channel",
+	"dns",
+	"domain",
+	"events",
+	"fs",
+	"http",
+	"http2",
+	"https",
+	"inspector",
+	"module",
+	"net",
+	"os",
+	"path",
+	"perf_hooks",
+	"process",
+	"punycode",
+	"querystring",
+	"readline",
+	"repl",
+	"sea",
+	"sqlite",
+	"stream",
+	"string_decoder",
+	"sys",
+	"test",
+	"timers",
+	"tls",
+	"trace_events",
+	"tty",
+	"url",
+	"util",
+	"v8",
+	"vm",
+	"wasi",
+	"worker_threads",
+	"zlib"
+]);
+function isNodeBuiltin(pkg) {
+	const base = pkg.startsWith("node:") ? pkg.slice(5) : pkg;
+	return NODE_BUILTINS.has(base.split("/")[0]);
+}
+const DEFAULT_MAX_AGE = 10080 * 60 * 1e3;
+function normalizePromptForHash(prompt) {
+	return prompt.replace(/\/[^\s`]*\.(?:claude|codex|gemini)\/skills\/[^\s/`]+/g, "<SKILL_DIR>");
+}
+function hashPrompt(prompt, model, section) {
+	return createHash("sha256").update(`exec:${model}:${section}:${normalizePromptForHash(prompt)}`).digest("hex").slice(0, 16);
+}
+function getCached(prompt, model, section, maxAge = DEFAULT_MAX_AGE) {
+	const path = join(LLM_CACHE_DIR, `${hashPrompt(prompt, model, section)}.json`);
+	if (!existsSync(path)) return null;
+	try {
+		const { text, timestamp } = JSON.parse(readFileSync(path, "utf-8"));
+		return Date.now() - timestamp > maxAge ? null : text;
+	} catch {
+		return null;
+	}
+}
+function setCache(prompt, model, section, text) {
+	mkdirSync(LLM_CACHE_DIR, {
+		recursive: true,
+		mode: 448
 	});
-	const cliConfig = CLI_MODELS[model];
-	if (!cliConfig) return Promise.resolve({
+	writeFileSync(join(LLM_CACHE_DIR, `${hashPrompt(prompt, model, section)}.json`), JSON.stringify({
+		text,
+		model,
+		section,
+		timestamp: Date.now()
+	}), { mode: 384 });
+}
+function prepareSection(opts) {
+	if (existsSync(opts.outputPath)) unlinkSync(opts.outputPath);
+	writeFileSync(join(opts.skilldDir, `PROMPT_${opts.section}.md`), opts.prompt);
+}
+function finalizeSection(opts) {
+	const { section, raw, outputFile, outputPath, skilldDir, debug, cliCleanup } = opts;
+	if (cliCleanup) for (const entry of readdirSync(skilldDir)) {
+		if (entry === outputFile || cliCleanup.preExistingFiles.has(entry)) continue;
+		if (Object.values(SECTION_OUTPUT_FILES).includes(entry)) continue;
+		if (entry.startsWith("PROMPT_") || entry === "logs") continue;
+		try {
+			unlinkSync(join(skilldDir, entry));
+		} catch {}
+	}
+	const logsDir = join(skilldDir, "logs");
+	const logName = section.toUpperCase().replace(/-/g, "_");
+	const text = ((existsSync(outputPath) ? readFileSync(outputPath, "utf-8") : "") || raw.writeContent || raw.text).trim();
+	const stderr = raw.stderr ?? "";
+	const code = raw.exitCode ?? 0;
+	if (debug || stderr && (!text || code !== 0)) {
+		mkdirSync(logsDir, { recursive: true });
+		if (stderr) writeFileSync(join(logsDir, `${logName}.stderr.log`), stderr);
+	}
+	if (debug) {
+		mkdirSync(logsDir, { recursive: true });
+		if (raw.rawLines?.length) writeFileSync(join(logsDir, `${logName}.jsonl`), raw.rawLines.join("\n"));
+		if (text) writeFileSync(join(logsDir, `${logName}.md`), text);
+	}
+	if (!text && code !== 0) return {
 		section,
 		content: "",
 		wasOptimized: false,
-		error: `No CLI mapping for model: ${model}`
-	});
-	const { cli, model: cliModel } = cliConfig;
-	const symlinkDirs = resolveReferenceDirs(skillDir);
-	const args = CLI_BUILD_ARGS[cli](cliModel, skillDir, symlinkDirs);
-	const parseLine = CLI_PARSE_LINE[cli];
-	const skilldDir = join(skillDir, ".skilld");
-	const outputPath = join(skilldDir, outputFile);
-	if (existsSync(outputPath)) unlinkSync(outputPath);
-	writeFileSync(join(skilldDir, `PROMPT_${section}.md`), prompt);
+		error: stderr.trim() || `CLI exited with code ${code}`
+	};
+	const content = text ? cleanSectionOutput(text) : "";
+	if (content) writeFileSync(outputPath, content);
+	const validator = getSectionValidator(section);
+	const warnings = (content && validator ? validator(content) : []).map((w) => ({
+		section,
+		warning: w.warning
+	}));
+	return {
+		section,
+		content,
+		wasOptimized: !!content,
+		warnings: warnings.length ? warnings : void 0,
+		usage: raw.usage,
+		cost: raw.cost
+	};
+}
+function spawnCliAndStream(opts) {
+	const { adapter, cliModel, prompt, skillDir, skilldDir, symlinkDirs, timeout, debug, section, onProgress } = opts;
+	const args = adapter.buildArgs(cliModel, skillDir, symlinkDirs);
+	const parseEvent = adapter.parseEvent;
 	return new Promise((resolve) => {
-		const proc = spawn(cli, args, {
+		const proc = spawn(adapter.cli, args, {
 			cwd: skilldDir,
 			stdio: [
 				"pipe",
@@ -991,6 +1260,32 @@ function optimizeSection(opts) {
 		});
 		proc.stdin.write(prompt);
 		proc.stdin.end();
+		function applyEvent(evt) {
+			switch (evt.kind) {
+				case "text":
+					if (evt.delta) accumulatedText += evt.delta;
+					if (evt.full !== void 0) accumulatedText = evt.full;
+					break;
+				case "tool-call": {
+					if (evt.writeContent) lastWriteContent = evt.writeContent;
+					const chunk = evt.hint ? `[${evt.tool}: ${evt.hint}]` : `[${evt.tool}]`;
+					onProgress?.({
+						chunk,
+						type: "reasoning",
+						text: "",
+						reasoning: chunk,
+						section
+					});
+					break;
+				}
+				case "done":
+					if (evt.usage) usage = evt.usage;
+					if (evt.cost != null) cost = evt.cost;
+					break;
+				case "error":
+				case "noop": break;
+			}
+		}
 		proc.stdout.on("data", (chunk) => {
 			buffer += chunk.toString();
 			const lines = buffer.split("\n");
@@ -998,22 +1293,7 @@ function optimizeSection(opts) {
 			for (const line of lines) {
 				if (!line.trim()) continue;
 				if (debug) rawLines.push(line);
-				const evt = parseLine(line);
-				if (evt.textDelta) accumulatedText += evt.textDelta;
-				if (evt.fullText) accumulatedText = evt.fullText;
-				if (evt.writeContent) lastWriteContent = evt.writeContent;
-				if (evt.toolName) {
-					const hint = evt.toolHint ? `[${evt.toolName}: ${evt.toolHint}]` : `[${evt.toolName}]`;
-					onProgress?.({
-						chunk: hint,
-						type: "reasoning",
-						text: "",
-						reasoning: hint,
-						section
-					});
-				}
-				if (evt.usage) usage = evt.usage;
-				if (evt.cost != null) cost = evt.cost;
+				applyEvent(parseEvent(line));
 			}
 		});
 		let stderr = "";
@@ -1021,70 +1301,118 @@ function optimizeSection(opts) {
 			stderr += chunk.toString();
 		});
 		proc.on("close", (code) => {
-			if (buffer.trim()) {
-				const evt = parseLine(buffer);
-				if (evt.textDelta) accumulatedText += evt.textDelta;
-				if (evt.fullText) accumulatedText = evt.fullText;
-				if (evt.writeContent) lastWriteContent = evt.writeContent;
-				if (evt.usage) usage = evt.usage;
-				if (evt.cost != null) cost = evt.cost;
-			}
-			for (const entry of readdirSync(skilldDir)) if (entry !== outputFile && !preExistingFiles.has(entry)) {
-				if (Object.values(SECTION_OUTPUT_FILES).includes(entry)) continue;
-				if (entry.startsWith("PROMPT_") || entry === "logs") continue;
-				try {
-					unlinkSync(join(skilldDir, entry));
-				} catch {}
-			}
-			const raw = (existsSync(outputPath) ? readFileSync(outputPath, "utf-8") : lastWriteContent || accumulatedText).trim();
-			const logsDir = join(skilldDir, "logs");
-			const logName = section.toUpperCase().replace(/-/g, "_");
-			if (debug || stderr && (!raw || code !== 0)) {
-				mkdirSync(logsDir, { recursive: true });
-				if (stderr) writeFileSync(join(logsDir, `${logName}.stderr.log`), stderr);
-			}
-			if (debug) {
-				mkdirSync(logsDir, { recursive: true });
-				if (rawLines.length) writeFileSync(join(logsDir, `${logName}.jsonl`), rawLines.join("\n"));
-				if (raw) writeFileSync(join(logsDir, `${logName}.md`), raw);
-			}
-			if (!raw && code !== 0) {
-				resolve({
-					section,
-					content: "",
-					wasOptimized: false,
-					error: stderr.trim() || `CLI exited with code ${code}`
-				});
-				return;
-			}
-			const content = raw ? cleanSectionOutput(raw) : "";
-			if (content) writeFileSync(outputPath, content);
-			const validator = getSectionValidator(section);
-			const warnings = (content && validator ? validator(content) : []).map((w) => ({
-				section,
-				warning: w.warning
-			}));
+			if (buffer.trim()) applyEvent(parseEvent(buffer));
 			resolve({
-				section,
-				content,
-				wasOptimized: !!content,
-				warnings: warnings?.length ? warnings : void 0,
+				text: accumulatedText,
+				writeContent: lastWriteContent || void 0,
 				usage,
-				cost
+				cost,
+				stderr,
+				exitCode: code ?? 0,
+				rawLines: debug ? rawLines : void 0
 			});
 		});
 		proc.on("error", (err) => {
 			resolve({
-				section,
-				content: "",
-				wasOptimized: false,
-				error: err.message
+				text: "",
+				stderr: err.message,
+				exitCode: 1
 			});
 		});
 	});
 }
+function cliExecutor(model) {
+	const cliConfig = CLI_MODELS[model];
+	if (!cliConfig) return { error: `No CLI mapping for model: ${model}` };
+	const adapter = CLI_ADAPTERS[cliConfig.cli];
+	return {
+		cliCleanup: true,
+		run: ({ section, prompt, skillDir, skilldDir, timeout, debug, onProgress }) => spawnCliAndStream({
+			adapter,
+			cliModel: cliConfig.model,
+			prompt,
+			skillDir,
+			skilldDir,
+			symlinkDirs: getSkillReferenceDirs(skillDir),
+			timeout,
+			debug,
+			section,
+			onProgress
+		})
+	};
+}
+function piAiExecutor(model) {
+	if (!new Set(getAvailablePiAiModels().map((m) => m.id)).has(model)) return { error: `Pi model unavailable or not authenticated: ${model}` };
+	return {
+		cliCleanup: false,
+		run: async ({ section, prompt, skillDir, timeout, onProgress }) => {
+			const ac = new AbortController();
+			const timer = setTimeout(() => ac.abort(), timeout);
+			try {
+				const result = await optimizeSectionPiAi({
+					section,
+					prompt,
+					skillDir,
+					model,
+					onProgress,
+					signal: ac.signal
+				});
+				return {
+					text: result.text.trim(),
+					usage: result.usage,
+					cost: result.cost
+				};
+			} catch (err) {
+				return {
+					text: "",
+					stderr: err.message,
+					exitCode: 1
+				};
+			} finally {
+				clearTimeout(timer);
+			}
+		}
+	};
+}
+function selectExecutor(model) {
+	return isPiAiModel(model) ? piAiExecutor(model) : cliExecutor(model);
+}
+const STATIC_REGEX_1 = /\b429\b/;
+const STATIC_REGEX_2 = /rate.?limit/i;
+const STATIC_REGEX_3 = /exhausted.*capacity/i;
+const STATIC_REGEX_4 = /quota.*reset/i;
+const STATIC_REGEX_5 = /reset\s+after\s+(\d+)s/i;
+async function optimizeSection(opts) {
+	const { section, prompt, outputFile, skillDir, executor, onProgress, timeout, debug, preExistingFiles } = opts;
+	const skilldDir = skillInternalDir(skillDir);
+	const outputPath = join(skilldDir, outputFile);
+	prepareSection({
+		section,
+		prompt,
+		outputPath,
+		skilldDir
+	});
+	return finalizeSection({
+		section,
+		raw: await executor.run({
+			section,
+			prompt,
+			skillDir,
+			skilldDir,
+			timeout,
+			debug,
+			onProgress
+		}),
+		outputFile,
+		outputPath,
+		skilldDir,
+		debug: !!debug,
+		cliCleanup: executor.cliCleanup ? { preExistingFiles } : void 0
+	});
+}
 async function optimizeDocs(opts) {
 	const { packageName, skillDir, model = "sonnet", version, hasGithub, hasReleases, hasChangelog, docFiles, docsType, hasShippedDocs, onProgress, timeout = 18e4, debug, noCache, sections, customPrompt, features, pkgFiles, overheadLines } = opts;
+	const cache = createReferenceCache(packageName, version);
 	const sectionPrompts = buildAllSectionPrompts({
 		packageName,
 		skillDir,
@@ -1107,24 +1435,20 @@ async function optimizeDocs(opts) {
 		wasOptimized: false,
 		error: "No valid sections to generate"
 	};
-	if (isPiAiModel(model)) {
-		if (!new Set(getAvailablePiAiModels().map((m) => m.id)).has(model)) return {
-			optimized: "",
-			wasOptimized: false,
-			error: `Pi model unavailable or not authenticated: ${model}`
-		};
-	} else if (!CLI_MODELS[model]) return {
+	const executorOrError = selectExecutor(model);
+	if ("error" in executorOrError) return {
 		optimized: "",
 		wasOptimized: false,
-		error: `No CLI mapping for model: ${model}`
+		error: executorOrError.error
 	};
+	const executor = executorOrError;
 	const cachedResults = [];
 	const uncachedSections = [];
 	for (const [section, prompt] of sectionPrompts) {
 		if (!noCache) {
 			if (version) {
 				const outputFile = SECTION_OUTPUT_FILES[section];
-				const refCached = readCachedSection(packageName, version, outputFile);
+				const refCached = cache.readSection(outputFile);
 				if (refCached) {
 					onProgress?.({
 						chunk: `[${section}: cached]`,
@@ -1163,7 +1487,7 @@ async function optimizeDocs(opts) {
 			prompt
 		});
 	}
-	const skilldDir = join(skillDir, ".skilld");
+	const skilldDir = skillInternalDir(skillDir);
 	mkdirSync(skilldDir, { recursive: true });
 	for (const entry of readdirSync(skilldDir)) {
 		const entryPath = join(skilldDir, entry);
@@ -1185,8 +1509,7 @@ async function optimizeDocs(opts) {
 			prompt,
 			outputFile,
 			skillDir,
-			model,
-			packageName,
+			executor,
 			onProgress,
 			timeout,
 			debug,
@@ -1247,8 +1570,7 @@ async function optimizeDocs(opts) {
 			prompt,
 			outputFile: SECTION_OUTPUT_FILES[section],
 			skillDir,
-			model,
-			packageName,
+			executor,
 			onProgress,
 			timeout,
 			debug,
@@ -1276,7 +1598,7 @@ async function optimizeDocs(opts) {
 			file: SECTION_OUTPUT_FILES[r.section],
 			content: r.content
 		}));
-		if (sectionFiles.length > 0) writeSections(packageName, version, sectionFiles);
+		if (sectionFiles.length > 0) cache.writeSections(sectionFiles);
 	}
 	const mergedParts = [];
 	for (const section of SECTION_MERGE_ORDER) {
@@ -1292,7 +1614,7 @@ async function optimizeDocs(opts) {
 	} : void 0;
 	const errors = allResults.filter((r) => r.error).map((r) => `${r.section}: ${r.error}`);
 	const warnings = allResults.flatMap((r) => r.warnings ?? []).map((w) => `${w.section}: ${w.warning}`);
-	const debugLogsDir = debug && uncachedSections.length > 0 ? join(skillDir, ".skilld", "logs") : void 0;
+	const debugLogsDir = debug && uncachedSections.length > 0 ? skillLogDir(skillDir) : void 0;
 	return {
 		optimized,
 		wasOptimized,
@@ -1306,221 +1628,17 @@ async function optimizeDocs(opts) {
 }
 function isRateLimitError(error) {
 	if (!error) return false;
-	return /\b429\b/.test(error) || /rate.?limit/i.test(error) || /exhausted.*capacity/i.test(error) || /quota.*reset/i.test(error);
+	return STATIC_REGEX_1.test(error) || STATIC_REGEX_2.test(error) || STATIC_REGEX_3.test(error) || STATIC_REGEX_4.test(error);
 }
 function parseRateLimitDelay(error) {
 	if (!error || !isRateLimitError(error)) return void 0;
-	const match = error.match(/reset\s+after\s+(\d+)s/i);
+	const match = error.match(STATIC_REGEX_5);
 	return match ? Number(match[1]) : 10;
 }
 function getRetryError(result) {
 	if (result.status === "rejected") return String(result.reason);
 	return result.value.error;
 }
-function shortenPath(p) {
-	const refIdx = p.indexOf(".skilld/");
-	if (refIdx !== -1) return p.slice(refIdx + 8);
-	const parts = p.split("/");
-	return parts.length > 2 ? `.../${parts.slice(-2).join("/")}` : p;
-}
-function shortenCommand(cmd) {
-	return cmd.replace(/\/[^\s"']+/g, (match) => {
-		if (match.includes(".claude/") || match.includes(".skilld/") || match.includes("node_modules/")) return `.../${match.split("/").slice(-2).join("/")}`;
-		return match;
-	});
-}
-function cleanSectionOutput(content) {
-	let cleaned = content.trim();
-	const wrapMatch = cleaned.match(/^```(?:markdown|md)?[^\S\n]*\n([\s\S]+)\n```[^\S\n]*$/);
-	if (wrapMatch) {
-		const inner = wrapMatch[1].trim();
-		if (/^```(?:markdown|md)/.test(cleaned) || /^##\s/m.test(inner) || /^- (?:BREAKING|DEPRECATED|NEW): /m.test(inner)) cleaned = inner;
-	}
-	cleaned = cleaned.replace(/^# (?!#)/gm, "## ");
-	const fmMatch = cleaned.match(/^-{3,}\n/);
-	if (fmMatch) {
-		const afterOpen = fmMatch[0].length;
-		const closeMatch = cleaned.slice(afterOpen).match(/\n-{3,}/);
-		if (closeMatch) cleaned = cleaned.slice(afterOpen + closeMatch.index + closeMatch[0].length).trim();
-		else cleaned = cleaned.slice(afterOpen).trim();
-	}
-	const firstMarker = cleaned.match(/^(##\s|- (?:BREAKING|DEPRECATED|NEW): )/m);
-	if (firstMarker?.index && firstMarker.index > 0) cleaned = cleaned.slice(firstMarker.index).trim();
-	const headingMatch = cleaned.match(/^(## .+)\n/);
-	if (headingMatch) {
-		const heading = headingMatch[1];
-		const afterFirst = headingMatch[0].length;
-		const secondIdx = cleaned.indexOf(heading, afterFirst);
-		if (secondIdx !== -1) {
-			if (secondIdx - afterFirst < 200) cleaned = cleaned.slice(secondIdx).trim();
-		}
-	}
-	cleaned = cleaned.replace(/\(?\[`?\.\/(?:\.skilld\/|references\/)[^)\]]*\]\(([^)]+)\)\)?/g, (match, url) => {
-		if (/^\.\/(?:\.skilld\/|references\/)/.test(url)) return `[source](${url})`;
-		return match;
-	});
-	cleaned = cleaned.replace(/\[source\]\(\.\/((docs|issues|discussions|releases|pkg|guide)\/)/g, "[source](./.skilld/$1");
-	cleaned = sanitizeMarkdown(cleaned);
-	if (!/^##\s/m.test(cleaned) && !/^- (?:BREAKING|DEPRECATED|NEW): /m.test(cleaned) && !/\[source\]/.test(cleaned)) return "";
-	return cleaned;
-}
-const NUXT_CONFIG_FILES = [
-	"nuxt.config.ts",
-	"nuxt.config.js",
-	"nuxt.config.mjs"
-];
-const NUXT_ECOSYSTEM = [
-	"vue",
-	"nitro",
-	"h3"
-];
-async function findNuxtConfig(cwd) {
-	for (const name of NUXT_CONFIG_FILES) {
-		const path = join(cwd, name);
-		const content = await readFile(path, "utf8").catch(() => null);
-		if (content) return {
-			path,
-			content
-		};
-	}
-	return null;
-}
-function extractModuleStrings(node) {
-	if (!node || typeof node !== "object") return [];
-	if (node.type === "Property" && !node.computed && node.key?.type === "Identifier" && node.key.name === "modules" && node.value?.type === "ArrayExpression") return node.value.elements.filter((el) => el?.type === "Literal" && typeof el.value === "string").map((el) => el.value);
-	const results = [];
-	if (Array.isArray(node)) for (const child of node) results.push(...extractModuleStrings(child));
-	else for (const key of Object.keys(node)) {
-		if (key === "start" || key === "end" || key === "type") continue;
-		const val = node[key];
-		if (val && typeof val === "object") results.push(...extractModuleStrings(val));
-	}
-	return results;
-}
-async function detectNuxtModules(cwd) {
-	const config = await findNuxtConfig(cwd);
-	if (!config) return [];
-	const modules = extractModuleStrings(parseSync(config.path, config.content).program);
-	const seen = /* @__PURE__ */ new Set();
-	const packages = [];
-	for (const mod of modules) if (!seen.has(mod)) {
-		seen.add(mod);
-		packages.push({
-			name: mod,
-			count: 0,
-			source: "preset"
-		});
-	}
-	for (const pkg of NUXT_ECOSYSTEM) if (!seen.has(pkg)) {
-		seen.add(pkg);
-		packages.push({
-			name: pkg,
-			count: 0,
-			source: "preset"
-		});
-	}
-	return packages;
-}
-async function detectPresetPackages(cwd) {
-	return detectNuxtModules(cwd);
-}
-const PATTERNS = ["**/*.{ts,js,vue,mjs,cjs,tsx,jsx,mts,cts}"];
-const IGNORE = [
-	"**/node_modules/**",
-	"**/dist/**",
-	"**/.nuxt/**",
-	"**/.output/**",
-	"**/coverage/**"
-];
-function addPackage(counts, specifier) {
-	if (!specifier || specifier.startsWith(".") || specifier.startsWith("/")) return;
-	const name = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
-	if (!isNodeBuiltin(name)) counts.set(name, (counts.get(name) || 0) + 1);
-}
-async function detectImportedPackages(cwd = process.cwd()) {
-	try {
-		const counts = /* @__PURE__ */ new Map();
-		const files = await glob(PATTERNS, {
-			cwd,
-			ignore: IGNORE,
-			absolute: true,
-			expandDirectories: false
-		});
-		await Promise.all(files.map(async (file) => {
-			const content = await readFile(file, "utf8");
-			for (const imp of findStaticImports(content)) addPackage(counts, imp.specifier);
-			for (const imp of findDynamicImports(content)) {
-				const match = imp.expression.match(/^['"]([^'"]+)['"]$/);
-				if (match) addPackage(counts, match[1]);
-			}
-		}));
-		const packages = Array.from(counts.entries(), ([name, count]) => ({
-			name,
-			count,
-			source: "import"
-		})).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
-		const presets = await detectPresetPackages(cwd);
-		const importNames = new Set(packages.map((p) => p.name));
-		for (const preset of presets) if (!importNames.has(preset.name)) packages.push(preset);
-		return { packages };
-	} catch (err) {
-		return {
-			packages: [],
-			error: String(err)
-		};
-	}
-}
-const NODE_BUILTINS = new Set([
-	"assert",
-	"async_hooks",
-	"buffer",
-	"child_process",
-	"cluster",
-	"console",
-	"constants",
-	"crypto",
-	"dgram",
-	"diagnostics_channel",
-	"dns",
-	"domain",
-	"events",
-	"fs",
-	"http",
-	"http2",
-	"https",
-	"inspector",
-	"module",
-	"net",
-	"os",
-	"path",
-	"perf_hooks",
-	"process",
-	"punycode",
-	"querystring",
-	"readline",
-	"repl",
-	"sea",
-	"sqlite",
-	"stream",
-	"string_decoder",
-	"sys",
-	"test",
-	"timers",
-	"tls",
-	"trace_events",
-	"tty",
-	"url",
-	"util",
-	"v8",
-	"vm",
-	"wasi",
-	"worker_threads",
-	"zlib"
-]);
-function isNodeBuiltin(pkg) {
-	const base = pkg.startsWith("node:") ? pkg.slice(5) : pkg;
-	return NODE_BUILTINS.has(base.split("/")[0]);
-}
-export { getModelLabel as a, getOAuthProviderList as c, getAvailableModels as i, loginOAuthProvider as l, cleanSectionOutput as n, getModelName as o, createToolProgress as r, optimizeDocs as s, detectImportedPackages as t, logoutOAuthProvider as u };
+export { getModelName as a, getOAuthProviderList as c, getModelLabel as i, loginOAuthProvider as l, detectImportedPackages as n, createToolProgress as o, getAvailableModels as r, cleanSectionOutput as s, optimizeDocs as t, logoutOAuthProvider as u };
 
 //# sourceMappingURL=agent.mjs.map