pi-crew 0.9.16 → 0.9.17

package/src/schema/team-tool-schema.ts

@@ -83,37 +83,23 @@ export const TeamToolParams = Type.Object({
 		),
 	),
 	resource: Type.Optional(
-		Type.Union(
-			[
-				Type.Literal("agent"),
-				Type.Literal("team"),
-				Type.Literal("workflow"),
-			],
-			{
-				description:
-					"Resource kind for get/create/update/delete/list. Defaults to all for list.",
-			},
-		),
+		Type.Union([Type.Literal("agent"), Type.Literal("team"), Type.Literal("workflow")], {
+			description: "Resource kind for get/create/update/delete/list. Defaults to all for list.",
+		}),
 	),
 	team: Type.Optional(
 		Type.String({
 			description: "Team name, e.g. default or implementation.",
 		}),
 	),
-	workflow: Type.Optional(
-		Type.String({ description: "Workflow name, e.g. default or review." }),
-	),
+	workflow: Type.Optional(Type.String({ description: "Workflow name, e.g. default or review." })),
 	role: Type.Optional(
 		Type.String({
 			description: "Role name to run directly within a team.",
 		}),
 	),
-	agent: Type.Optional(
-		Type.String({ description: "Agent name to inspect or run directly." }),
-	),
-	goal: Type.Optional(
-		Type.String({ description: "High-level objective for a team run." }),
-	),
+	agent: Type.Optional(Type.String({ description: "Agent name to inspect or run directly." })),
+	goal: Type.Optional(Type.String({ description: "High-level objective for a team run." })),
 	chain: Type.Optional(
 		Type.String({
 			description:
@@ -127,7 +113,8 @@ export const TeamToolParams = Type.Object({
 	),
 	singleAgent: Type.Optional(
 		Type.Boolean({
-			description: "When true (with action=plan), compose a single-agent sequential prompt for the workflow instead of a multi-agent plan. Cliff-resilient mode.",
+			description:
+				"When true (with action=plan), compose a single-agent sequential prompt for the workflow instead of a multi-agent plan. Cliff-resilient mode.",
 		}),
 	),
 	runId: Type.Optional(
@@ -136,12 +123,8 @@ export const TeamToolParams = Type.Object({
 			pattern: "^[A-Za-z0-9_-]+$",
 		}),
 	),
-	taskId: Type.Optional(
-		Type.String({ description: "Task ID for respond action." }),
-	),
-	message: Type.Optional(
-		Type.String({ description: "Message for respond action." }),
-	),
+	taskId: Type.Optional(Type.String({ description: "Task ID for respond action." })),
+	message: Type.Optional(Type.String({ description: "Message for respond action." })),
 	async: Type.Optional(
 		Type.Boolean({
 			description: "Run in background when execution support is enabled.",
@@ -156,8 +139,7 @@ export const TeamToolParams = Type.Object({
 	),
 	workspaceMode: Type.Optional(
 		Type.Union([Type.Literal("single"), Type.Literal("worktree")], {
-			description:
-				"Workspace isolation mode. Worktree mode is planned after MVP.",
+			description: "Workspace isolation mode. Worktree mode is planned after MVP.",
 		}),
 	),
 	context: Type.Optional(
@@ -165,22 +147,13 @@ export const TeamToolParams = Type.Object({
 			description: "Child context mode for workers.",
 		}),
 	),
-	cwd: Type.Optional(
-		Type.String({ description: "Working directory override." }),
-	),
-	model: Type.Optional(
-		Type.String({ description: "Model override for direct runs." }),
-	),
+	cwd: Type.Optional(Type.String({ description: "Working directory override." })),
+	model: Type.Optional(Type.String({ description: "Model override for direct runs." })),
 	skill: Type.Optional(SkillOverride),
 	scope: Type.Optional(
-		Type.Union(
-			[
-				Type.Literal("user"),
-				Type.Literal("project"),
-				Type.Literal("both"),
-			],
-			{ description: "Resource scope for discovery or management." },
-		),
+		Type.Union([Type.Literal("user"), Type.Literal("project"), Type.Literal("both")], {
+			description: "Resource scope for discovery or management.",
+		}),
 	),
 	config: Type.Optional(FreeformConfig),
 	dryRun: Type.Optional(
@@ -195,8 +168,7 @@ export const TeamToolParams = Type.Object({
 	),
 	force: Type.Optional(
 		Type.Boolean({
-			description:
-				"Override reference checks for destructive management actions.",
+			description: "Override reference checks for destructive management actions.",
 		}),
 	),
 	keep: Type.Optional(
@@ -207,22 +179,16 @@ export const TeamToolParams = Type.Object({
 	),
 	updateReferences: Type.Optional(
 		Type.Boolean({
-			description:
-				"When renaming agents or workflows, update team references in the same project/user scope.",
+			description: "When renaming agents or workflows, update team references in the same project/user scope.",
 		}),
 	),
 	replyTo: Type.Optional(
 		Type.String({
-			description:
-				"ID of the original mailbox message this is a reply to.",
+			description: "ID of the original mailbox message this is a reply to.",
 		}),
 	),
-	replyFrom: Type.Optional(
-		Type.String({ description: "Task ID sending the reply." }),
-	),
-	replyDeadline: Type.Optional(
-		Type.Integer({ description: "Ms epoch deadline for a reply." }),
-	),
+	replyFrom: Type.Optional(Type.String({ description: "Task ID sending the reply." })),
+	replyDeadline: Type.Optional(Type.Integer({ description: "Ms epoch deadline for a reply." })),
 	planPath: Type.Optional(
 		Type.String({
 			description: "Path to a markdown plan document for orchestration.",
@@ -230,26 +196,22 @@ export const TeamToolParams = Type.Object({
 	),
 	cron: Type.Optional(
 		Type.String({
-			description:
-				"Cron expression for recurring scheduled runs (e.g., '0 9 * * MON').",
+			description: "Cron expression for recurring scheduled runs (e.g., '0 9 * * MON').",
 		}),
 	),
 	interval: Type.Optional(
 		Type.Number({
-			description:
-				"Interval in milliseconds between recurring scheduled runs.",
+			description: "Interval in milliseconds between recurring scheduled runs.",
 		}),
 	),
 	once: Type.Optional(
 		Type.Union([Type.String(), Type.Number()], {
-			description:
-				"ISO timestamp or epoch ms for a one-time scheduled run.",
+			description: "ISO timestamp or epoch ms for a one-time scheduled run.",
 		}),
 	),
 	excludeContextBash: Type.Optional(
 		Type.Boolean({
-			description:
-				"Mark certain bash commands as excludeFromContext to reduce context tokens (default: false).",
+			description: "Mark certain bash commands as excludeFromContext to reduce context tokens (default: false).",
 		}),
 	),
 	// Budget tracking options
@@ -283,17 +245,10 @@ export const TeamToolParams = Type.Object({
 		}),
 	),
 	runKind: Type.Optional(
-		Type.Union(
-			[
-				Type.Literal("team-run"),
-				Type.Literal("goal-loop"),
-				Type.Literal("dynamic-workflow"),
-			],
-			{
-				description:
-					"Background dispatch discriminator. Default \"team-run\" runs the normal executeTeamRun workflow; \"goal-loop\" (P0/P1) and \"dynamic-workflow\" (P2/P3) dispatch to their respective background runners. Absent = \"team-run\" for backward compatibility.",
-			},
-		),
+		Type.Union([Type.Literal("team-run"), Type.Literal("goal-loop"), Type.Literal("dynamic-workflow")], {
+			description:
+				'Background dispatch discriminator. Default "team-run" runs the normal executeTeamRun workflow; "goal-loop" (P0/P1) and "dynamic-workflow" (P2/P3) dispatch to their respective background runners. Absent = "team-run" for backward compatibility.',
+		}),
 	),
 	tokenBudget: Type.Optional(
 		Type.Number({

package/src/schema/validation-types.ts

@@ -40,15 +40,18 @@ const DEFAULT_MODE: ValidationMode = "strict";
 
 /** Recommended range constraints (not enforced by schema, but advisory). */
 const RECOMMENDED_RANGES: Record<string, { max: number; label: string }> = {
-	"limits.maxConcurrentWorkers": { max: 8, label: "maxConcurrentWorkers > 8 may degrade performance" },
-	"limits.maxTaskDepth": { max: 4, label: "maxTaskDepth > 4 may cause excessive nesting" },
+	"limits.maxConcurrentWorkers": {
+		max: 8,
+		label: "maxConcurrentWorkers > 8 may degrade performance",
+	},
+	"limits.maxTaskDepth": {
+		max: 4,
+		label: "maxTaskDepth > 4 may cause excessive nesting",
+	},
 };
 
 /** Recommended optional top-level keys that should be explicitly set. */
-const RECOMMENDED_OPTIONAL_KEYS: readonly string[] = [
-	"limits",
-	"runtime",
-];
+const RECOMMENDED_OPTIONAL_KEYS: readonly string[] = ["limits", "runtime"];
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -83,7 +86,11 @@ export function validateWithSeverity(raw: unknown, mode: ValidationMode = DEFAUL
 	const findings: ValidationFinding[] = [];
 
 	if (!isObject(raw)) {
-		findings.push({ severity: "ERROR", message: "config must be an object", field: "config" });
+		findings.push({
+			severity: "ERROR",
+			message: "config must be an object",
+			field: "config",
+		});
 		return { findings, mode, hasErrors: true, hasWarnings: false };
 	}
 
@@ -92,22 +99,23 @@ export function validateWithSeverity(raw: unknown, mode: ValidationMode = DEFAUL
 	if (!isValid) {
 		for (const error of Value.Errors(PiTeamsConfigSchema, raw)) {
 			const errRecord = error as unknown as Record<string, unknown>;
-			const rawPath = typeof errRecord.path === "string"
-				? errRecord.path
-				: typeof errRecord.instancePath === "string"
-					? errRecord.instancePath
-					: "config";
+			const rawPath =
+				typeof errRecord.path === "string"
+					? errRecord.path
+					: typeof errRecord.instancePath === "string"
+						? errRecord.instancePath
+						: "config";
 
-			const message = typeof errRecord.message === "string"
-				? errRecord.message
-				: "invalid value";
+			const message = typeof errRecord.message === "string" ? errRecord.message : "invalid value";
 
 			const field = rawPath.replace(/^\//, "").replace(/\//g, ".") || undefined;
 
 			// Additional properties / unknown keys are less severe in lenient mode.
 			// @sinclair/typebox uses keyword=undefined with message="Unexpected property" for these.
-			const isUnknownProperty = errRecord.keyword === "additionalProperties" ||
-				message === "Unexpected property" || message.startsWith("Unexpected property");
+			const isUnknownProperty =
+				errRecord.keyword === "additionalProperties" ||
+				message === "Unexpected property" ||
+				message.startsWith("Unexpected property");
 			if (isUnknownProperty) {
 				findings.push({
 					severity: mode === "lenient" ? "WARNING" : "ERROR",

package/src/skills/discover-skills.ts

@@ -7,7 +7,7 @@ import { fileURLToPath } from "node:url";
 import { getAgentDir } from "../runtime/peer-dep.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { isSafePathId, resolveContainedPath, resolveRealContainedPath } from "../utils/safe-paths.ts";
-import { parseSkillFrontmatter, validateSkillFrontmatter, type SkillValidationError } from "./validate.ts";
+import { parseSkillFrontmatter, type SkillValidationError, validateSkillFrontmatter } from "./validate.ts";
 
 const PACKAGE_SKILLS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "skills");
 
@@ -46,10 +46,16 @@ export interface SkillDescriptor {
 function listSkillDirs(cwd: string): Array<{ root: string; source: SkillDescriptor["source"] }> {
 	return [
 		{ root: path.resolve(cwd, ".pi", "skills"), source: "project-pi" },
-		{ root: path.resolve(cwd, ".agents", "skills"), source: "project-agents" },
+		{
+			root: path.resolve(cwd, ".agents", "skills"),
+			source: "project-agents",
+		},
 		{ root: path.resolve(cwd, "skills"), source: "project" },
 		{ root: path.join(getAgentDir(), "skills"), source: "user-pi" },
-		{ root: path.join(os.homedir(), ".agents", "skills"), source: "user-agents" },
+		{
+			root: path.join(os.homedir(), ".agents", "skills"),
+			source: "user-agents",
+		},
 		{ root: path.join(os.homedir(), ".pi", "skills"), source: "user-pi" },
 		{ root: PACKAGE_SKILLS_DIR, source: "package" },
 	];
@@ -72,11 +78,17 @@ export function getLastDiscoveryDiagnostics(): SkillValidationError[] {
  * SKILL.md files that pre-date the validator (we record a diagnostic in that
  * case but still return the description we could salvage).
  */
-function readDescription(content: string): { description: string; parseError: string | null } {
+function readDescription(content: string): {
+	description: string;
+	parseError: string | null;
+} {
 	const parsed = parseSkillFrontmatter(content);
 	if (parsed.ok) {
 		const d = parsed.data.description;
-		return { description: typeof d === "string" ? d : "", parseError: null };
+		return {
+			description: typeof d === "string" ? d : "",
+			parseError: null,
+		};
 	}
 	// YAML parse failed — fall back to legacy line-prefix match so we don't
 	// regress existing skills whose frontmatter the old parser could read.
@@ -96,22 +108,30 @@ export function discoverSkills(cwd: string): SkillDescriptor[] {
 	for (const dir of listSkillDirs(cwd)) {
 		if (!fs.existsSync(dir.root)) continue;
 		try {
-			for (const entry of fs.readdirSync(dir.root, { withFileTypes: true })) {
+			for (const entry of fs.readdirSync(dir.root, {
+				withFileTypes: true,
+			})) {
 				if (!entry.isDirectory()) continue;
 				if (!isSafePathId(entry.name)) continue;
 				const skillDirPath = path.join(dir.root, entry.name);
 				try {
 					if (fs.lstatSync(skillDirPath).isSymbolicLink()) continue;
-				} catch { continue; }
+				} catch {
+					continue;
+				}
 				const skillMdRelative = path.join(entry.name, "SKILL.md");
 				let skillMdPath: string;
 				try {
 					skillMdPath = resolveContainedPath(dir.root, skillMdRelative);
-				} catch { continue; }
+				} catch {
+					continue;
+				}
 				if (!fs.existsSync(skillMdPath)) continue;
 				try {
 					if (fs.lstatSync(skillMdPath).isSymbolicLink()) continue;
-				} catch { continue; }
+				} catch {
+					continue;
+				}
 				let description = "";
 				try {
 					let readPath = skillMdPath;
@@ -136,7 +156,12 @@ export function discoverSkills(cwd: string): SkillDescriptor[] {
 				} catch (error) {
 					logInternalError("discoverSkills.readSkill", error, `skill=${entry.name}`);
 				}
-				results.push({ name: entry.name, description, source: dir.source, path: skillMdPath });
+				results.push({
+					name: entry.name,
+					description,
+					source: dir.source,
+					path: skillMdPath,
+				});
 			}
 		} catch (error) {
 			logInternalError("discoverSkills.readdir", error, `root=${dir.root}`);

package/src/skills/skill-templates.ts

@@ -56,9 +56,25 @@ const CODE_REVIEW_TEMPLATE: SkillTemplate = {
 	description: "Systematic code review skill with configurable language and focus areas.",
 	category: "quality",
 	variables: [
-		{ name: "language", description: "Primary programming language of the codebase", required: true, options: ["TypeScript", "JavaScript", "Python", "Rust", "Go", "Java", "C#", "Other"] },
-		{ name: "focusAreas", description: "Comma-separated list of review focus areas", required: false, defaultValue: "correctness, readability, performance" },
-		{ name: "severityThreshold", description: "Minimum severity level to report", required: false, defaultValue: "warning", options: ["info", "warning", "error", "critical"] },
+		{
+			name: "language",
+			description: "Primary programming language of the codebase",
+			required: true,
+			options: ["TypeScript", "JavaScript", "Python", "Rust", "Go", "Java", "C#", "Other"],
+		},
+		{
+			name: "focusAreas",
+			description: "Comma-separated list of review focus areas",
+			required: false,
+			defaultValue: "correctness, readability, performance",
+		},
+		{
+			name: "severityThreshold",
+			description: "Minimum severity level to report",
+			required: false,
+			defaultValue: "warning",
+			options: ["info", "warning", "error", "critical"],
+		},
 	],
 	body: [
 		"---",
@@ -99,9 +115,25 @@ const TESTING_TEMPLATE: SkillTemplate = {
 	description: "Test writing skill with configurable framework and coverage targets.",
 	category: "testing",
 	variables: [
-		{ name: "framework", description: "Testing framework to use", required: true, options: ["vitest", "jest", "mocha", "pytest", "go-test", "cargo-test", "Other"] },
-		{ name: "coverageTarget", description: "Target coverage percentage", required: false, defaultValue: "80" },
-		{ name: "testType", description: "Primary type of tests to write", required: false, defaultValue: "unit", options: ["unit", "integration", "e2e", "all"] },
+		{
+			name: "framework",
+			description: "Testing framework to use",
+			required: true,
+			options: ["vitest", "jest", "mocha", "pytest", "go-test", "cargo-test", "Other"],
+		},
+		{
+			name: "coverageTarget",
+			description: "Target coverage percentage",
+			required: false,
+			defaultValue: "80",
+		},
+		{
+			name: "testType",
+			description: "Primary type of tests to write",
+			required: false,
+			defaultValue: "unit",
+			options: ["unit", "integration", "e2e", "all"],
+		},
 	],
 	body: [
 		"---",
@@ -137,9 +169,25 @@ const SECURITY_AUDIT_TEMPLATE: SkillTemplate = {
 	description: "Security review skill with configurable scope and severity thresholds.",
 	category: "security",
 	variables: [
-		{ name: "scope", description: "Audit scope: what parts of the codebase to examine", required: true, options: ["full-codebase", "dependencies", "api-surface", "auth-flows", "input-handling"] },
-		{ name: "severityThreshold", description: "Minimum severity to report", required: false, defaultValue: "medium", options: ["low", "medium", "high", "critical"] },
-		{ name: "complianceFramework", description: "Compliance framework to check against (if applicable)", required: false, defaultValue: "OWASP Top 10" },
+		{
+			name: "scope",
+			description: "Audit scope: what parts of the codebase to examine",
+			required: true,
+			options: ["full-codebase", "dependencies", "api-surface", "auth-flows", "input-handling"],
+		},
+		{
+			name: "severityThreshold",
+			description: "Minimum severity to report",
+			required: false,
+			defaultValue: "medium",
+			options: ["low", "medium", "high", "critical"],
+		},
+		{
+			name: "complianceFramework",
+			description: "Compliance framework to check against (if applicable)",
+			required: false,
+			defaultValue: "OWASP Top 10",
+		},
 	],
 	body: [
 		"---",
@@ -179,9 +227,30 @@ const REFACTOR_TEMPLATE: SkillTemplate = {
 	description: "Refactoring skill with configurable scope and constraints.",
 	category: "maintenance",
 	variables: [
-		{ name: "scope", description: "What to refactor: file, module, or architectural pattern", required: true },
-		{ name: "constraints", description: "Constraints to respect during refactoring", required: false, defaultValue: "preserve public API, maintain backward compatibility" },
-		{ name: "goal", description: "Primary refactoring goal", required: false, defaultValue: "improve readability and reduce complexity", options: ["improve readability and reduce complexity", "improve performance", "reduce coupling", "enable extensibility", "simplify testability"] },
+		{
+			name: "scope",
+			description: "What to refactor: file, module, or architectural pattern",
+			required: true,
+		},
+		{
+			name: "constraints",
+			description: "Constraints to respect during refactoring",
+			required: false,
+			defaultValue: "preserve public API, maintain backward compatibility",
+		},
+		{
+			name: "goal",
+			description: "Primary refactoring goal",
+			required: false,
+			defaultValue: "improve readability and reduce complexity",
+			options: [
+				"improve readability and reduce complexity",
+				"improve performance",
+				"reduce coupling",
+				"enable extensibility",
+				"simplify testability",
+			],
+		},
 	],
 	body: [
 		"---",
@@ -223,9 +292,26 @@ const DOCUMENTATION_TEMPLATE: SkillTemplate = {
 	description: "Documentation writing skill with configurable format and audience.",
 	category: "documentation",
 	variables: [
-		{ name: "format", description: "Documentation format to produce", required: true, options: ["markdown", "jsdoc", "rustdoc", "godoc", "pydoc", "openapi"] },
-		{ name: "audience", description: "Target audience for the documentation", required: false, defaultValue: "developers", options: ["developers", "operators", "end-users", "contributors", "architects"] },
-		{ name: "detailLevel", description: "Level of detail", required: false, defaultValue: "standard", options: ["brief", "standard", "comprehensive"] },
+		{
+			name: "format",
+			description: "Documentation format to produce",
+			required: true,
+			options: ["markdown", "jsdoc", "rustdoc", "godoc", "pydoc", "openapi"],
+		},
+		{
+			name: "audience",
+			description: "Target audience for the documentation",
+			required: false,
+			defaultValue: "developers",
+			options: ["developers", "operators", "end-users", "contributors", "architects"],
+		},
+		{
+			name: "detailLevel",
+			description: "Level of detail",
+			required: false,
+			defaultValue: "standard",
+			options: ["brief", "standard", "comprehensive"],
+		},
 	],
 	body: [
 		"---",
@@ -280,9 +366,7 @@ export function getBuiltinTemplates(): SkillTemplate[] {
  */
 export function findTemplate(idOrName: string): SkillTemplate | undefined {
 	const lower = idOrName.toLowerCase();
-	return BUILTIN_TEMPLATES.find(
-		(t) => t.id.toLowerCase() === lower || t.name.toLowerCase() === lower,
-	);
+	return BUILTIN_TEMPLATES.find((t) => t.id.toLowerCase() === lower || t.name.toLowerCase() === lower);
 }
 
 /**
@@ -296,10 +380,7 @@ export function findTemplate(idOrName: string): SkillTemplate | undefined {
  * @param variables User-supplied variable values.
  * @returns An object with the suggested filename and rendered content.
  */
-export function instantiateTemplate(
-	template: SkillTemplate,
-	variables: Record<string, string>,
-): InstantiatedSkill {
+export function instantiateTemplate(template: SkillTemplate, variables: Record<string, string>): InstantiatedSkill {
 	// Validate and resolve all variable values
 	const resolved: Record<string, string> = {};
 
@@ -308,9 +389,7 @@ export function instantiateTemplate(
 
 		if (value === undefined || value === "") {
 			if (variable.required) {
-				throw new Error(
-					`Missing required variable "${variable.name}" for template "${template.id}" (${variable.description}).`,
-				);
+				throw new Error(`Missing required variable "${variable.name}" for template "${template.id}" (${variable.description}).`);
 			}
 			resolved[variable.name] = variable.defaultValue ?? "";
 			continue;
@@ -320,7 +399,7 @@ export function instantiateTemplate(
 		if (variable.options !== undefined && !variable.options.includes(value)) {
 			throw new Error(
 				`Invalid value "${value}" for variable "${variable.name}" in template "${template.id}". ` +
-				`Allowed values: ${variable.options.join(", ")}.`,
+					`Allowed values: ${variable.options.join(", ")}.`,
 			);
 		}
 
@@ -357,7 +436,10 @@ export function listTemplates(): Array<{
 		name: t.name,
 		description: t.description,
 		category: t.category,
-		variables: t.variables.map((v) => ({ name: v.name, required: v.required })),
+		variables: t.variables.map((v) => ({
+			name: v.name,
+			required: v.required,
+		})),
 	}));
 }
 

package/src/skills/validate.ts

@@ -100,20 +100,24 @@ export interface ValidationResult {
  * surface as `{ ok: false }` rather than throwing — discovery must remain
  * exception-safe.
  */
-export function parseSkillFrontmatter(
-	content: string,
-): { ok: true; data: Record<string, unknown> } | { ok: false; error: string } {
+export function parseSkillFrontmatter(content: string): { ok: true; data: Record<string, unknown> } | { ok: false; error: string } {
 	const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
 	if (!match) return { ok: true, data: {} };
 	try {
 		const parsed = yaml.parse(match[1]);
 		if (parsed === null || parsed === undefined) return { ok: true, data: {} };
 		if (typeof parsed !== "object" || Array.isArray(parsed)) {
-			return { ok: false, error: "Frontmatter must be a YAML mapping, not a scalar or list." };
+			return {
+				ok: false,
+				error: "Frontmatter must be a YAML mapping, not a scalar or list.",
+			};
 		}
 		return { ok: true, data: parsed as Record<string, unknown> };
 	} catch (e) {
-		return { ok: false, error: `YAML parse error: ${(e as Error).message}` };
+		return {
+			ok: false,
+			error: `YAML parse error: ${(e as Error).message}`,
+		};
 	}
 }
 
@@ -173,7 +177,13 @@ export function validateSkillFrontmatter(skillDir: string): ValidationResult {
 	const nameRaw = data.name;
 	let resolvedName = derivedName;
 	if (nameRaw === undefined || nameRaw === null) {
-		errors.push(warn(skillDir, "name", `Frontmatter 'name' missing; using directory name "${derivedName}" as fallback. Add explicit 'name' to silence this.`));
+		errors.push(
+			warn(
+				skillDir,
+				"name",
+				`Frontmatter 'name' missing; using directory name "${derivedName}" as fallback. Add explicit 'name' to silence this.`,
+			),
+		);
 	} else if (typeof nameRaw !== "string") {
 		errors.push(hard(skillDir, "name", `'name' must be a string, got ${typeof nameRaw}.`));
 	} else if (nameRaw.length === 0) {
@@ -227,7 +237,13 @@ export function validateSkillFrontmatter(skillDir: string): ValidationResult {
 	// ── OPTIONAL: version
 	if (data.version !== undefined) {
 		if (typeof data.version !== "string" || !VERSION_REGEX.test(data.version)) {
-			errors.push(hard(skillDir, "version", `'version' must be a semver string (e.g. "1.2.3" or "1.2.3-beta.1"); got "${String(data.version)}".`));
+			errors.push(
+				hard(
+					skillDir,
+					"version",
+					`'version' must be a semver string (e.g. "1.2.3" or "1.2.3-beta.1"); got "${String(data.version)}".`,
+				),
+			);
 		}
 	}
 
@@ -239,7 +255,9 @@ export function validateSkillFrontmatter(skillDir: string): ValidationResult {
 	// ── UNKNOWN PROPS: SOFT warn (HYBRID policy)
 	for (const key of Object.keys(data)) {
 		if (!ALLOWED_SKILL_PROPS.has(key)) {
-			errors.push(warn(skillDir, `<unknown-prop:${key}>`, `Unknown property '${key}' is not in the whitelist; keeping for forward-compat.`));
+			errors.push(
+				warn(skillDir, `<unknown-prop:${key}>`, `Unknown property '${key}' is not in the whitelist; keeping for forward-compat.`),
+			);
 		}
 	}