pi-subagents 0.8.2 → 0.8.4

package/render.ts

@@ -28,6 +28,21 @@ function computeWidgetHash(jobs: AsyncJobState[]): string {
 	).join("|");
 }
 
+function extractOutputTarget(task: string): string | undefined {
+	const writeToMatch = task.match(/\[Write to:\s*([^\]\n]+)\]/i);
+	if (writeToMatch?.[1]?.trim()) return writeToMatch[1].trim();
+	const findingsMatch = task.match(/Write your findings to:\s*(\S+)/i);
+	if (findingsMatch?.[1]?.trim()) return findingsMatch[1].trim();
+	const outputMatch = task.match(/[Oo]utput(?:\s+to)?\s*:\s*(\S+)/i);
+	if (outputMatch?.[1]?.trim()) return outputMatch[1].trim();
+	return undefined;
+}
+
+function hasEmptyTextOutputWithoutOutputTarget(task: string, output: string): boolean {
+	if (output.trim()) return false;
+	return !extractOutputTarget(task);
+}
+
 /**
  * Render the async jobs widget
  */
@@ -158,11 +173,18 @@ export function renderSubagentResult(
 	const hasRunning = d.progress?.some((p) => p.status === "running") 
 		|| d.results.some((r) => r.progress?.status === "running");
 	const ok = d.results.filter((r) => r.progress?.status === "completed" || (r.exitCode === 0 && r.progress?.status !== "running")).length;
+	const hasEmptyWithoutTarget = d.results.some((r) =>
+		r.exitCode === 0
+		&& r.progress?.status !== "running"
+		&& hasEmptyTextOutputWithoutOutputTarget(r.task, getFinalOutput(r.messages)),
+	);
 	const icon = hasRunning
 		? theme.fg("warning", "...")
-		: ok === d.results.length
-			? theme.fg("success", "ok")
-			: theme.fg("error", "X");
+		: hasEmptyWithoutTarget
+			? theme.fg("warning", "⚠")
+			: ok === d.results.length
+				? theme.fg("success", "ok")
+				: theme.fg("error", "X");
 
 	const totalSummary =
 		d.progressSummary ||
@@ -205,14 +227,19 @@ export function renderSubagentResult(
 					const result = d.results[i];
 					const isFailed = result && result.exitCode !== 0 && result.progress?.status !== "running";
 					const isComplete = result && result.exitCode === 0 && result.progress?.status !== "running";
+					const isEmptyWithoutTarget = Boolean(result)
+						&& Boolean(isComplete)
+						&& hasEmptyTextOutputWithoutOutputTarget(result.task, getFinalOutput(result.messages));
 					const isCurrent = i === (d.currentStepIndex ?? d.results.length);
 					const icon = isFailed
 						? theme.fg("error", "✗")
-						: isComplete
-							? theme.fg("success", "✓")
-							: isCurrent && hasRunning
-								? theme.fg("warning", "●")
-								: theme.fg("dim", "○");
+						: isEmptyWithoutTarget
+							? theme.fg("warning", "⚠")
+							: isComplete
+								? theme.fg("success", "✓")
+								: isCurrent && hasRunning
+									? theme.fg("warning", "●")
+									: theme.fg("dim", "○");
 					return `${icon} ${agent}`;
 				})
 				.join(theme.fg("dim", " → "))
@@ -259,28 +286,27 @@ export function renderSubagentResult(
 		const rProg = r.progress || progressFromArray || r.progressSummary;
 		const rRunning = rProg?.status === "running";
 
-		// Step header with status
+		const resultOutput = getFinalOutput(r.messages);
 		const statusIcon = rRunning
 			? theme.fg("warning", "●")
-			: r.exitCode === 0
-				? theme.fg("success", "✓")
-				: theme.fg("error", "✗");
+			: r.exitCode !== 0
+				? theme.fg("error", "✗")
+				: hasEmptyTextOutputWithoutOutputTarget(r.task, resultOutput)
+					? theme.fg("warning", "⚠")
+					: theme.fg("success", "✓");
 		const stats = rProg ? ` | ${rProg.toolCount} tools, ${formatDuration(rProg.durationMs)}` : "";
-		// Show model if available (full provider/model format)
 		const modelDisplay = r.model ? theme.fg("dim", ` (${r.model})`) : "";
 		const stepHeader = rRunning
 			? `${statusIcon} Step ${i + 1}: ${theme.bold(theme.fg("warning", r.agent))}${modelDisplay}${stats}`
 			: `${statusIcon} Step ${i + 1}: ${theme.bold(r.agent)}${modelDisplay}${stats}`;
 		c.addChild(new Text(stepHeader, 0, 0));
 
-		// Task (truncated)
 		const taskPreview = r.task.slice(0, 120) + (r.task.length > 120 ? "..." : "");
 		c.addChild(new Text(theme.fg("dim", `    task: ${taskPreview}`), 0, 0));
 
-		// Output target (extract from task)
-		const outputMatch = r.task.match(/[Oo]utput(?:\s+to)?\s+([^\s]+\.(?:md|txt|json))/);
-		if (outputMatch) {
-			c.addChild(new Text(theme.fg("dim", `    output: ${outputMatch[1]}`), 0, 0));
+		const outputTarget = extractOutputTarget(r.task);
+		if (outputTarget) {
+			c.addChild(new Text(theme.fg("dim", `    output: ${outputTarget}`), 0, 0));
 		}
 
 		if (r.skills?.length) {

package/schemas.ts

@@ -11,6 +11,7 @@ export const TaskItem = Type.Object({
 	agent: Type.String(), 
 	task: Type.String(), 
 	cwd: Type.Optional(Type.String()),
+	model: Type.Optional(Type.String({ description: "Override model for this task (e.g. 'google/gemini-3-pro')" })),
 	skill: Type.Optional(SkillOverride),
 });
 
@@ -71,13 +72,13 @@ export const SubagentParams = Type.Object({
 	})),
 	// Agent/chain configuration for create/update (nested to avoid conflicts with execution fields)
 	config: Type.Optional(Type.Any({
-		description: "Agent or chain config for create/update. Agent: name, description, scope ('user'|'project', default 'user'), systemPrompt, model, tools (comma-separated), skills (comma-separated), thinking, output, reads, progress. Chain: name, description, scope, steps (array of {agent, task?, output?, reads?, model?, skills?, progress?}). Presence of 'steps' creates a chain instead of an agent."
+		description: "Agent or chain config for create/update. Agent: name, description, scope ('user'|'project', default 'user'), systemPrompt, model, tools (comma-separated), extensions (comma-separated), skills (comma-separated), thinking, output, reads, progress. Chain: name, description, scope, steps (array of {agent, task?, output?, reads?, model?, skills?, progress?}). Presence of 'steps' creates a chain instead of an agent."
 	})),
 	tasks: Type.Optional(Type.Array(TaskItem, { description: "PARALLEL mode: [{agent, task}, ...]" })),
 	chain: Type.Optional(Type.Array(ChainItem, { description: "CHAIN mode: sequential pipeline where each step's response becomes {previous} for the next. Use {task}, {previous}, {chain_dir} in task templates." })),
-	chainDir: Type.Optional(Type.String({ description: "Persistent directory for chain artifacts. Default: /tmp/pi-chain-runs/ (auto-cleaned after 24h)" })),
+	chainDir: Type.Optional(Type.String({ description: "Persistent directory for chain artifacts. Default: <tmpdir>/pi-chain-runs/ (auto-cleaned after 24h)" })),
 	async: Type.Optional(Type.Boolean({ description: "Run in background (default: false, or per config)" })),
-	agentScope: Type.Optional(Type.String({ description: "Agent discovery scope: 'user', 'project', or 'both' (default: 'user')" })),
+	agentScope: Type.Optional(Type.String({ description: "Agent discovery scope: 'user', 'project', or 'both' (default: 'both'; project wins on name collisions)" })),
 	cwd: Type.Optional(Type.String()),
 	maxOutput: MaxOutputSchema,
 	artifacts: Type.Optional(Type.Boolean({ description: "Write debug artifacts (default: true)" })),
@@ -89,7 +90,7 @@ export const SubagentParams = Type.Object({
 	// Clarification TUI
 	clarify: Type.Optional(Type.Boolean({ description: "Show TUI to preview/edit before execution (default: true for chains, false for single/parallel). Implies sync mode." })),
 	// Solo agent overrides
-	output: Type.Optional(Type.Any({ description: "Override output file for single agent (string), or false to disable (uses agent default if omitted)" })),
+	output: Type.Optional(Type.Any({ description: "Override output file for single agent (string), or false to disable (uses agent default if omitted). Absolute paths are used as-is; relative paths resolve against cwd." })),
 	skill: Type.Optional(SkillOverride),
 	model: Type.Optional(Type.String({ description: "Override model for single agent (e.g. 'anthropic/claude-sonnet-4')" })),
 });

package/settings.ts

@@ -3,11 +3,12 @@
  */
 
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentConfig } from "./agents.js";
 import { normalizeSkillInput } from "./skills.js";
 
-const CHAIN_RUNS_DIR = "/tmp/pi-chain-runs";
+const CHAIN_RUNS_DIR = path.join(os.tmpdir(), "pi-chain-runs");
 const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
 
 // =============================================================================
@@ -358,6 +359,8 @@ export interface ParallelTaskResult {
 	output: string;
 	exitCode: number;
 	error?: string;
+	outputTargetPath?: string;
+	outputTargetExists?: boolean;
 }
 
 /**
@@ -368,7 +371,20 @@ export function aggregateParallelOutputs(results: ParallelTaskResult[]): string
 	return results
 		.map((r, i) => {
 			const header = `=== Parallel Task ${i + 1} (${r.agent}) ===`;
-			return `${header}\n${r.output}`;
+			const hasTextOutput = Boolean(r.output?.trim());
+			const status = r.exitCode !== 0
+				? `⚠️ FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}`
+				: r.error
+					? `⚠️ WARNING: ${r.error}`
+					: !hasTextOutput && r.outputTargetPath && r.outputTargetExists === false
+						? `⚠️ EMPTY OUTPUT (expected output file missing: ${r.outputTargetPath})`
+						: !hasTextOutput && !r.outputTargetPath
+							? "⚠️ EMPTY OUTPUT (no textual response returned)"
+							: "";
+			const body = status
+				? (hasTextOutput ? `${status}\n${r.output}` : status)
+				: r.output;
+			return `${header}\n${body}`;
 		})
 		.join("\n\n");
 }

package/single-output.ts

@@ -0,0 +1,55 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export function resolveSingleOutputPath(
+	output: string | false | undefined,
+	runtimeCwd: string,
+	requestedCwd?: string,
+): string | undefined {
+	if (typeof output !== "string" || !output) return undefined;
+	if (path.isAbsolute(output)) return output;
+	const baseCwd = requestedCwd
+		? (path.isAbsolute(requestedCwd) ? requestedCwd : path.resolve(runtimeCwd, requestedCwd))
+		: runtimeCwd;
+	return path.resolve(baseCwd, output);
+}
+
+export function injectSingleOutputInstruction(task: string, outputPath: string | undefined): string {
+	if (!outputPath) return task;
+	return `${task}\n\n---\n**Output:** Write your findings to: ${outputPath}`;
+}
+
+export function persistSingleOutput(
+	outputPath: string | undefined,
+	fullOutput: string,
+): { savedPath?: string; error?: string } {
+	if (!outputPath) return {};
+	try {
+		fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+		fs.writeFileSync(outputPath, fullOutput, "utf-8");
+		return { savedPath: outputPath };
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+}
+
+export function finalizeSingleOutput(params: {
+	fullOutput: string;
+	truncatedOutput?: string;
+	outputPath?: string;
+	exitCode: number;
+}): { displayOutput: string; savedPath?: string; saveError?: string } {
+	let displayOutput = params.truncatedOutput || params.fullOutput;
+	if (params.outputPath && params.exitCode === 0) {
+		const save = persistSingleOutput(params.outputPath, params.fullOutput);
+		if (save.savedPath) {
+			displayOutput += `\n\n📄 Output saved to: ${save.savedPath}`;
+			return { displayOutput, savedPath: save.savedPath };
+		}
+		if (save.error) {
+			displayOutput += `\n\n⚠️ Failed to save output to: ${params.outputPath}\n${save.error}`;
+			return { displayOutput, saveError: save.error };
+		}
+	}
+	return { displayOutput };
+}

package/skills.ts

@@ -5,12 +5,24 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { loadSkills, type Skill } from "@mariozechner/pi-coding-agent";
+
+export type SkillSource =
+	| "project"
+	| "user"
+	| "project-package"
+	| "user-package"
+	| "project-settings"
+	| "user-settings"
+	| "extension"
+	| "builtin"
+	| "unknown";
 
 export interface ResolvedSkill {
 	name: string;
 	path: string;
 	content: string;
-	source: "project" | "user";
+	source: SkillSource;
 }
 
 interface SkillCacheEntry {
@@ -18,9 +30,35 @@ interface SkillCacheEntry {
 	skill: ResolvedSkill;
 }
 
+interface CachedSkillEntry {
+	name: string;
+	filePath: string;
+	source: SkillSource;
+	description?: string;
+	order: number;
+}
+
 const skillCache = new Map<string, SkillCacheEntry>();
 const MAX_CACHE_SIZE = 50;
 
+let loadSkillsCache: { cwd: string; skills: CachedSkillEntry[]; timestamp: number } | null = null;
+const LOAD_SKILLS_CACHE_TTL_MS = 5000;
+
+const CONFIG_DIR = ".pi";
+const AGENT_DIR = path.join(os.homedir(), ".pi", "agent");
+
+const SOURCE_PRIORITY: Record<SkillSource, number> = {
+	project: 700,
+	"project-settings": 650,
+	"project-package": 600,
+	user: 300,
+	"user-settings": 250,
+	"user-package": 200,
+	extension: 150,
+	builtin: 100,
+	unknown: 0,
+};
+
 function stripSkillFrontmatter(content: string): string {
 	const normalized = content.replace(/\r\n/g, "\n");
 	if (!normalized.startsWith("---")) return normalized;
@@ -31,27 +69,187 @@ function stripSkillFrontmatter(content: string): string {
 	return normalized.slice(endIndex + 4).trim();
 }
 
-export function resolveSkillPath(
-	skillName: string,
-	cwd: string,
-): { path: string; source: "project" | "user" } | undefined {
-	const projectPath = path.resolve(cwd, ".pi", "skills", skillName, "SKILL.md");
-	if (fs.existsSync(projectPath)) {
-		return { path: projectPath, source: "project" };
+function isWithinPath(filePath: string, dir: string): boolean {
+	const relative = path.relative(dir, filePath);
+	return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function getPackageSkillPaths(packageRoot: string): string[] {
+	const pkgJsonPath = path.join(packageRoot, "package.json");
+	try {
+		const content = fs.readFileSync(pkgJsonPath, "utf-8");
+		const pkg = JSON.parse(content);
+		const piSkills = pkg?.pi?.skills;
+		if (!Array.isArray(piSkills)) return [];
+		return piSkills
+			.filter((s: unknown) => typeof s === "string")
+			.map((s: string) => path.resolve(packageRoot, s));
+	} catch {
+		return [];
 	}
+}
+
+function collectPackageSkillPaths(cwd: string): string[] {
+	const dirs = [
+		path.join(cwd, CONFIG_DIR, "npm", "node_modules"),
+		path.join(AGENT_DIR, "npm", "node_modules"),
+	];
+	const results: string[] = [];
 
-	const userPath = path.join(os.homedir(), ".pi", "agent", "skills", skillName, "SKILL.md");
-	if (fs.existsSync(userPath)) {
-		return { path: userPath, source: "user" };
+	for (const dir of dirs) {
+		if (!fs.existsSync(dir)) continue;
+		let entries: fs.Dirent[];
+		try {
+			entries = fs.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+
+		for (const entry of entries) {
+			if (entry.name.startsWith(".")) continue;
+			if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+
+			if (entry.name.startsWith("@")) {
+				const scopeDir = path.join(dir, entry.name);
+				let scopeEntries: fs.Dirent[];
+				try {
+					scopeEntries = fs.readdirSync(scopeDir, { withFileTypes: true });
+				} catch {
+					continue;
+				}
+				for (const scopeEntry of scopeEntries) {
+					if (scopeEntry.name.startsWith(".")) continue;
+					if (!scopeEntry.isDirectory() && !scopeEntry.isSymbolicLink()) continue;
+					const pkgRoot = path.join(scopeDir, scopeEntry.name);
+					results.push(...getPackageSkillPaths(pkgRoot));
+				}
+				continue;
+			}
+
+			const pkgRoot = path.join(dir, entry.name);
+			results.push(...getPackageSkillPaths(pkgRoot));
+		}
 	}
 
-	return undefined;
+	return results;
+}
+
+function collectSettingsSkillPaths(cwd: string): string[] {
+	const results: string[] = [];
+	const settingsFiles = [
+		{ file: path.join(cwd, CONFIG_DIR, "settings.json"), base: path.join(cwd, CONFIG_DIR) },
+		{ file: path.join(AGENT_DIR, "settings.json"), base: AGENT_DIR },
+	];
+
+	for (const { file, base } of settingsFiles) {
+		try {
+			const content = fs.readFileSync(file, "utf-8");
+			const settings = JSON.parse(content);
+			const skills = settings?.skills;
+			if (!Array.isArray(skills)) continue;
+			for (const entry of skills) {
+				if (typeof entry !== "string") continue;
+				let resolved = entry;
+				if (resolved.startsWith("~/")) {
+					resolved = path.join(os.homedir(), resolved.slice(2));
+				} else if (!path.isAbsolute(resolved)) {
+					resolved = path.resolve(base, resolved);
+				}
+				results.push(resolved);
+			}
+		} catch {}
+	}
+
+	return results;
+}
+
+function buildSkillPaths(cwd: string): string[] {
+	const defaultSkillPaths = [
+		path.join(cwd, CONFIG_DIR, "skills"),
+		path.join(AGENT_DIR, "skills"),
+	];
+	const packagePaths = collectPackageSkillPaths(cwd);
+	const settingsPaths = collectSettingsSkillPaths(cwd);
+	return [...new Set([...defaultSkillPaths, ...packagePaths, ...settingsPaths])];
+}
+
+function inferSkillSource(rawSource: unknown, filePath: string, cwd: string): SkillSource {
+	const source = typeof rawSource === "string" ? rawSource : "";
+	const projectRoot = path.resolve(cwd, CONFIG_DIR);
+	const isProjectScoped = isWithinPath(filePath, projectRoot);
+	const isUserScoped = isWithinPath(filePath, AGENT_DIR);
+
+	if (source === "project") return "project";
+	if (source === "user") return "user";
+	if (source === "settings") {
+		if (isProjectScoped) return "project-settings";
+		if (isUserScoped) return "user-settings";
+		return "unknown";
+	}
+	if (source === "package") {
+		if (isProjectScoped) return "project-package";
+		if (isUserScoped) return "user-package";
+		return "unknown";
+	}
+	if (source === "extension") return "extension";
+	if (source === "builtin") return "builtin";
+
+	if (isProjectScoped) return "project";
+	if (isUserScoped) return "user";
+	return "unknown";
+}
+
+function chooseHigherPrioritySkill(existing: CachedSkillEntry | undefined, candidate: CachedSkillEntry): CachedSkillEntry {
+	if (!existing) return candidate;
+	const existingPriority = SOURCE_PRIORITY[existing.source] ?? 0;
+	const candidatePriority = SOURCE_PRIORITY[candidate.source] ?? 0;
+	if (candidatePriority > existingPriority) return candidate;
+	if (candidatePriority < existingPriority) return existing;
+	return candidate.order < existing.order ? candidate : existing;
+}
+
+function getCachedSkills(cwd: string): CachedSkillEntry[] {
+	const now = Date.now();
+	if (loadSkillsCache && loadSkillsCache.cwd === cwd && now - loadSkillsCache.timestamp < LOAD_SKILLS_CACHE_TTL_MS) {
+		return loadSkillsCache.skills;
+	}
+
+	const skillPaths = buildSkillPaths(cwd);
+	const loaded = loadSkills({ cwd, skillPaths, includeDefaults: false });
+	const dedupedByName = new Map<string, CachedSkillEntry>();
+
+	for (let i = 0; i < loaded.skills.length; i++) {
+		const skill = loaded.skills[i] as Skill;
+		const entry: CachedSkillEntry = {
+			name: skill.name,
+			filePath: skill.filePath,
+			source: inferSkillSource((skill as { source?: unknown }).source, skill.filePath, cwd),
+			description: skill.description,
+			order: i,
+		};
+		const current = dedupedByName.get(entry.name);
+		dedupedByName.set(entry.name, chooseHigherPrioritySkill(current, entry));
+	}
+
+	const skills = [...dedupedByName.values()].sort((a, b) => a.order - b.order);
+	loadSkillsCache = { cwd, skills, timestamp: now };
+	return skills;
+}
+
+export function resolveSkillPath(
+	skillName: string,
+	cwd: string,
+): { path: string; source: SkillSource } | undefined {
+	const skills = getCachedSkills(cwd);
+	const skill = skills.find((s) => s.name === skillName);
+	if (!skill) return undefined;
+	return { path: skill.filePath, source: skill.source };
 }
 
 export function readSkill(
 	skillName: string,
 	skillPath: string,
-	source: "project" | "user",
+	source: SkillSource,
 ): ResolvedSkill | undefined {
 	try {
 		const stat = fs.statSync(skillPath);
@@ -123,84 +321,27 @@ export function normalizeSkillInput(
 	if (input === false) return false;
 	if (input === true || input === undefined) return undefined;
 	if (Array.isArray(input)) {
-		// Deduplicate while preserving order
 		return [...new Set(input.map((s) => s.trim()).filter((s) => s.length > 0))];
 	}
-	// Deduplicate while preserving order
 	return [...new Set(input.split(",").map((s) => s.trim()).filter((s) => s.length > 0))];
 }
 
-function isDirectory(p: string): boolean {
-	try {
-		return fs.statSync(p).isDirectory();
-	} catch {
-		return false;
-	}
-}
-
 export function discoverAvailableSkills(cwd: string): Array<{
 	name: string;
-	source: "project" | "user";
+	source: SkillSource;
 	description?: string;
 }> {
-	const skills: Array<{ name: string; source: "project" | "user"; description?: string }> = [];
-	const seen = new Set<string>();
-
-	const scanDir = (dir: string, source: "project" | "user") => {
-		if (!fs.existsSync(dir)) return;
-
-		try {
-			const entries = fs.readdirSync(dir, { withFileTypes: true });
-			for (const entry of entries) {
-				const fullPath = path.join(dir, entry.name);
-
-				const isDir = entry.isDirectory() || (entry.isSymbolicLink() && isDirectory(fullPath));
-				if (!isDir) continue;
-
-				const skillPath = path.join(fullPath, "SKILL.md");
-				if (!fs.existsSync(skillPath)) continue;
-
-				if (source === "project" || !seen.has(entry.name)) {
-					let description: string | undefined;
-					try {
-						const content = fs.readFileSync(skillPath, "utf-8");
-						if (content.startsWith("---")) {
-							const endIndex = content.indexOf("\n---", 3);
-							if (endIndex !== -1) {
-								const fmBlock = content.slice(0, endIndex);
-								const match = fmBlock.match(/description:\s*(.+)/);
-								if (match) {
-									let desc = match[1].trim();
-									if (
-										(desc.startsWith("\"") && desc.endsWith("\"")) ||
-										(desc.startsWith("'") && desc.endsWith("'"))
-									) {
-										desc = desc.slice(1, -1);
-									}
-									description = desc;
-								}
-							}
-						}
-					} catch {}
-
-					if (source === "project" && seen.has(entry.name)) {
-						const idx = skills.findIndex((s) => s.name === entry.name);
-						if (idx !== -1) skills.splice(idx, 1);
-					}
-
-					skills.push({ name: entry.name, source, description });
-					seen.add(entry.name);
-				}
-			}
-		} catch {}
-	};
-
-	scanDir(path.join(os.homedir(), ".pi", "agent", "skills"), "user");
-	scanDir(path.resolve(cwd, ".pi", "skills"), "project");
-
-	return skills.sort((a, b) => a.name.localeCompare(b.name));
+	const skills = getCachedSkills(cwd);
+	return skills
+		.map((s) => ({
+			name: s.name,
+			source: s.source,
+			description: s.description,
+		}))
+		.sort((a, b) => a.name.localeCompare(b.name));
 }
 
 export function clearSkillCache(): void {
 	skillCache.clear();
+	loadSkillsCache = null;
 }