pi-crew 0.9.16 → 0.9.17

package/src/runtime/skill-effectiveness.ts

@@ -113,10 +113,7 @@ export interface WeightedSkill {
  * for `.pi`-based projects (see issue #29).
  */
 function getSkillMetricsPath(cwd: string, runId: string): string {
-	return join(
-		projectCrewRoot(cwd),
-		`state/runs/${runId}/skill-metrics.jsonl`,
-	);
+	return join(projectCrewRoot(cwd), `state/runs/${runId}/skill-metrics.jsonl`);
 }
 
 /**
@@ -125,10 +122,7 @@ function getSkillMetricsPath(cwd: string, runId: string): string {
  * for `.pi`-based projects (see issue #29).
  */
 function getSkillActivationsPath(cwd: string, runId: string): string {
-	return join(
-		projectCrewRoot(cwd),
-		`state/runs/${runId}/skill-activations.jsonl`,
-	);
+	return join(projectCrewRoot(cwd), `state/runs/${runId}/skill-activations.jsonl`);
 }
 
 /**
@@ -156,9 +150,7 @@ export function computeInitialConfidence(observationCount: number): number {
  * Per ECC instinct system: +0.05 for success, -0.1 for failure.
  */
 export function adjustConfidence(current: number, passed: boolean): number {
-	const delta = passed
-		? CONFIDENCE_ADJUSTMENTS.CONFIRMING
-		: CONFIDENCE_ADJUSTMENTS.CONTRADICTING;
+	const delta = passed ? CONFIDENCE_ADJUSTMENTS.CONFIRMING : CONFIDENCE_ADJUSTMENTS.CONTRADICTING;
 	return Math.max(0.1, Math.min(0.95, current + delta)); // Clamp to [0.1, 0.95]
 }
 
@@ -179,11 +171,7 @@ export function adjustConfidence(current: number, passed: boolean): number {
  * preserves the existing `adjustConfidence` clamp range [0.1, 0.95] and the
  * existing tests (which assert on the stored numeric values).
  */
-export function computeNextActivationConfidence(
-	skillId: string,
-	activations: SkillActivation[],
-	passed: boolean,
-): number {
+export function computeNextActivationConfidence(skillId: string, activations: SkillActivation[], passed: boolean): number {
 	const prior = activations.filter((a) => a.skillId === skillId);
 	if (prior.length === 0) {
 		// First activation of this skill in the run: seed by observation count.
@@ -191,8 +179,7 @@ export function computeNextActivationConfidence(
 		return computeInitialConfidence(1);
 	}
 	// Rolling confidence = last recorded confidence for this skill, adjusted.
-	const lastConfidence = prior[prior.length - 1]?.confidence
-		?? computeInitialConfidence(prior.length);
+	const lastConfidence = prior[prior.length - 1]?.confidence ?? computeInitialConfidence(prior.length);
 	return adjustConfidence(lastConfidence, passed);
 }
 
@@ -202,9 +189,7 @@ export function computeNextActivationConfidence(
 export function applyDecay(current: number, lastActivation?: string): number {
 	if (!lastActivation) return current;
 
-	const daysSince =
-		(Date.now() - new Date(lastActivation).getTime()) /
-		(1000 * 60 * 60 * 24);
+	const daysSince = (Date.now() - new Date(lastActivation).getTime()) / (1000 * 60 * 60 * 24);
 	const decayWeeks = Math.floor(daysSince / 7);
 	const decay = decayWeeks * CONFIDENCE_ADJUSTMENTS.DECAY_PER_WEEK;
 
@@ -214,11 +199,8 @@ export function applyDecay(current: number, lastActivation?: string): number {
 /**
  * Determine behavior based on confidence threshold.
  */
-export function confidenceToBehavior(
-	confidence: number,
-): WeightedSkill["behavior"] {
-	if (confidence >= CONFIDENCE_THRESHOLDS.NEAR_CERTAIN)
-		return "act_autonomous";
+export function confidenceToBehavior(confidence: number): WeightedSkill["behavior"] {
+	if (confidence >= CONFIDENCE_THRESHOLDS.NEAR_CERTAIN) return "act_autonomous";
 	if (confidence >= CONFIDENCE_THRESHOLDS.STRONG) return "apply_auto";
 	if (confidence >= CONFIDENCE_THRESHOLDS.MODERATE) return "apply_if_asked";
 	return "suggest";
@@ -227,9 +209,7 @@ export function confidenceToBehavior(
 /**
  * Determine threshold name from confidence.
  */
-export function confidenceToThreshold(
-	confidence: number,
-): keyof typeof CONFIDENCE_THRESHOLDS {
+export function confidenceToThreshold(confidence: number): keyof typeof CONFIDENCE_THRESHOLDS {
 	if (confidence >= CONFIDENCE_THRESHOLDS.NEAR_CERTAIN) return "NEAR_CERTAIN";
 	if (confidence >= CONFIDENCE_THRESHOLDS.STRONG) return "STRONG";
 	if (confidence >= CONFIDENCE_THRESHOLDS.TENTATIVE) return "MODERATE";
@@ -240,10 +220,7 @@ export function confidenceToThreshold(
  * Record a skill activation.
  * Appends to the run's skill-activations.jsonl for learning.
  */
-export function recordSkillActivation(
-	cwd: string,
-	activation: SkillActivation,
-): SkillActivation {
+export function recordSkillActivation(cwd: string, activation: SkillActivation): SkillActivation {
 	ensureSkillMetricsDir(cwd, activation.runId);
 
 	const path = getSkillActivationsPath(cwd, activation.runId);
@@ -256,10 +233,7 @@ export function recordSkillActivation(
 /**
  * Get all skill activations for a run.
  */
-export function getSkillActivations(
-	cwd: string,
-	runId: string,
-): SkillActivation[] {
+export function getSkillActivations(cwd: string, runId: string): SkillActivation[] {
 	const path = getSkillActivationsPath(cwd, runId);
 
 	if (!existsSync(path)) {
@@ -280,10 +254,7 @@ export function getSkillActivations(
 /**
  * Compute metrics for a skill across all activations.
  */
-export function computeSkillMetrics(
-	skillId: string,
-	activations: SkillActivation[],
-): SkillMetrics {
+export function computeSkillMetrics(skillId: string, activations: SkillActivation[]): SkillMetrics {
 	const skillActivations = activations.filter((a) => a.skillId === skillId);
 
 	if (skillActivations.length === 0) {
@@ -302,22 +273,14 @@ export function computeSkillMetrics(
 
 	const passed = skillActivations.filter((a) => a.passed).length;
 	const failed = skillActivations.filter((a) => !a.passed).length;
-	const avgConfidence =
-		skillActivations.reduce((sum, a) => sum + a.confidence, 0) /
-		skillActivations.length;
-	const currentConfidence =
-		skillActivations[skillActivations.length - 1]?.confidence ??
-		avgConfidence;
+	const avgConfidence = skillActivations.reduce((sum, a) => sum + a.confidence, 0) / skillActivations.length;
+	const currentConfidence = skillActivations[skillActivations.length - 1]?.confidence ?? avgConfidence;
 
 	// Compute trend from last 5 activations
 	const recent = skillActivations.slice(-5);
-	const recentPassRate =
-		recent.filter((a) => a.passed).length / recent.length;
+	const recentPassRate = recent.filter((a) => a.passed).length / recent.length;
 	const earlier = skillActivations.slice(0, -5);
-	const earlierPassRate =
-		earlier.length > 0
-			? earlier.filter((a) => a.passed).length / earlier.length
-			: recentPassRate;
+	const earlierPassRate = earlier.length > 0 ? earlier.filter((a) => a.passed).length / earlier.length : recentPassRate;
 
 	let trend: SkillMetrics["trend"] = "stable";
 	if (recentPassRate > earlierPassRate + 0.1) {
@@ -329,13 +292,11 @@ export function computeSkillMetrics(
 	// Role breakdown
 	const roleBreakdown: Record<string, number> = {};
 	for (const activation of skillActivations) {
-		roleBreakdown[activation.role] =
-			(roleBreakdown[activation.role] ?? 0) + 1;
+		roleBreakdown[activation.role] = (roleBreakdown[activation.role] ?? 0) + 1;
 	}
 
 	// Apply decay if not observed recently
-	const lastActivation =
-		skillActivations[skillActivations.length - 1]?.timestamp;
+	const lastActivation = skillActivations[skillActivations.length - 1]?.timestamp;
 	const decayedConfidence = applyDecay(currentConfidence, lastActivation);
 
 	return {
@@ -368,13 +329,10 @@ export function evaluatePromotionGate(metrics: SkillMetrics): {
 	reason: string;
 } {
 	const criteria = {
-		correctness:
-			metrics.passRate >= PROMOTION_GATE_CRITERIA.MIN_CORRECTNESS,
-		evidence:
-			metrics.totalActivations >= PROMOTION_GATE_CRITERIA.MIN_ACTIVATIONS,
+		correctness: metrics.passRate >= PROMOTION_GATE_CRITERIA.MIN_CORRECTNESS,
+		evidence: metrics.totalActivations >= PROMOTION_GATE_CRITERIA.MIN_ACTIVATIONS,
 		rollback: metrics.trend !== "declining",
-		encoding:
-			metrics.avgConfidence >= PROMOTION_GATE_CRITERIA.MIN_AVG_CONFIDENCE,
+		encoding: metrics.avgConfidence >= PROMOTION_GATE_CRITERIA.MIN_AVG_CONFIDENCE,
 	};
 
 	const allPassed = Object.values(criteria).every(Boolean);
@@ -439,13 +397,7 @@ function filterSkillsByConfidence(
 	threshold: keyof typeof CONFIDENCE_THRESHOLDS = "MODERATE",
 ): WeightedSkill[] {
 	const minConfidence = CONFIDENCE_THRESHOLDS[threshold];
-	return getWeightedSkillsForRole(
-		cwd,
-		"global",
-		skillIds,
-		runId,
-		minConfidence,
-	);
+	return getWeightedSkillsForRole(cwd, "global", skillIds, runId, minConfidence);
 }
 
 /**
@@ -481,11 +433,7 @@ export function registerSkillEffectivenessHooks(): void {
 
 		// Record each skill activation with its rolling confidence
 		for (const skillId of skillNames) {
-			const confidence = computeNextActivationConfidence(
-				skillId,
-				existingActivations,
-				success,
-			);
+			const confidence = computeNextActivationConfidence(skillId, existingActivations, success);
 			const activation: SkillActivation = {
 				id: `act-${Date.now()}-${Math.random().toString(36).slice(2)}`,
 				skillId,
@@ -517,11 +465,7 @@ export function registerSkillEffectivenessHooks(): void {
 		const existingActivations = getSkillActivations(eventCwd, runId);
 
 		for (const skillId of skillNames) {
-			const confidence = computeNextActivationConfidence(
-				skillId,
-				existingActivations,
-				false,
-			);
+			const confidence = computeNextActivationConfidence(skillId, existingActivations, false);
 			const activation: SkillActivation = {
 				id: `act-${Date.now()}-${Math.random().toString(36).slice(2)}`,
 				skillId,
@@ -541,11 +485,7 @@ export function registerSkillEffectivenessHooks(): void {
  * Generate a skill effectiveness report for a run.
  */
 /** @internal */
-function generateSkillEffectivenessReport(
-	cwd: string,
-	runId: string,
-	skillIds: string[],
-): string {
+function generateSkillEffectivenessReport(cwd: string, runId: string, skillIds: string[]): string {
 	const activations = getSkillActivations(cwd, runId);
 	const lines: string[] = [
 		`# Skill Effectiveness Report: ${runId}`,
@@ -568,21 +508,13 @@ function generateSkillEffectivenessReport(
 		const gate = evaluatePromotionGate(metrics);
 
 		lines.push(`### ${skillId}`);
-		lines.push(
-			`- **Confidence**: ${metrics.currentConfidence.toFixed(2)} (${metrics.trend})`,
-		);
-		lines.push(
-			`- **Pass Rate**: ${(metrics.passRate * 100).toFixed(1)}% (${metrics.passedActivations}/${metrics.totalActivations})`,
-		);
+		lines.push(`- **Confidence**: ${metrics.currentConfidence.toFixed(2)} (${metrics.trend})`);
+		lines.push(`- **Pass Rate**: ${(metrics.passRate * 100).toFixed(1)}% (${metrics.passedActivations}/${metrics.totalActivations})`);
 		lines.push(`- **Avg Confidence**: ${metrics.avgConfidence.toFixed(2)}`);
-		lines.push(
-			`- **Promotion Gate**: ${gate.passed ? "PASSED ✅" : "NOT MET"}`,
-		);
+		lines.push(`- **Promotion Gate**: ${gate.passed ? "PASSED ✅" : "NOT MET"}`);
 
 		if (Object.keys(metrics.roleBreakdown).length > 0) {
-			lines.push(
-				`- **By Role**: ${JSON.stringify(metrics.roleBreakdown)}`,
-			);
+			lines.push(`- **By Role**: ${JSON.stringify(metrics.roleBreakdown)}`);
 		}
 
 		lines.push("");

package/src/runtime/skill-instructions.ts

@@ -3,30 +3,19 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import type { AgentConfig } from "../agents/agent-config.ts";
 import type { TeamRole } from "../teams/team-config.ts";
-import {
-	isSafePathId,
-	resolveContainedPath,
-	resolveRealContainedPath,
-} from "../utils/safe-paths.ts";
+import { isSafePathId, resolveContainedPath, resolveRealContainedPath } from "../utils/safe-paths.ts";
 import type { WorkflowStep } from "../workflows/workflow-config.ts";
-import {
-	CONFIDENCE_THRESHOLDS,
-	getWeightedSkillsForRole,
-	registerSkillEffectivenessHooks,
-} from "./skill-effectiveness.ts";
+import { CONFIDENCE_THRESHOLDS, getWeightedSkillsForRole, registerSkillEffectivenessHooks } from "./skill-effectiveness.ts";
+
+const PACKAGE_SKILLS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "skills");
 
-const PACKAGE_SKILLS_DIR = path.resolve(
-	path.dirname(fileURLToPath(import.meta.url)),
-	"..",
-	"..",
-	"skills",
-);
 import * as os from "node:os";
 // peer-dep.ts resolves @earendil-works/pi-coding-agent robustly across install
 // layouts (extension-under-~/.pi + pi-under-global). A static `import { getAgentDir }`
 // here crashes detached child processes when pi-crew and pi live in separate
 // node_modules trees. See src/runtime/peer-dep.ts.
 import { getAgentDir } from "../runtime/peer-dep.ts";
+
 const MAX_SKILL_CHARS = 1500;
 const MAX_TOTAL_CHARS = 6000;
 const MAX_SKILL_NAME_CHARS = 80;
@@ -38,11 +27,7 @@ const DEFAULT_ROLE_SKILLS: Record<string, string[]> = {
 	analyst: ["read-only-explorer", "requirements-to-task-packet"],
 	planner: ["delegation-patterns", "requirements-to-task-packet"],
 	critic: ["read-only-explorer", "multi-perspective-review"],
-	executor: [
-		"state-mutation-locking",
-		"safe-bash",
-		"verification-before-done",
-	],
+	executor: ["state-mutation-locking", "safe-bash", "verification-before-done"],
 	reviewer: ["read-only-explorer", "multi-perspective-review"],
 	// SECURITY NOTE: The following skill names are trusted package-level skills.
 	// If a project has a skills/ directory containing subdirectories with these names,
@@ -50,13 +35,10 @@ const DEFAULT_ROLE_SKILLS: Record<string, string[]> = {
 	// project dir before package dir) and their content injected verbatim into prompts.
 	// The "Applicable Skills" block will add an untrusted-content warning for project skills,
 	// but be aware this is a potential supply-chain risk in multi-contributor projects.
-	"security-reviewer": [
-		"secure-agent-orchestration-review",
-		"ownership-session-security",
-	],
+	"security-reviewer": ["secure-agent-orchestration-review", "ownership-session-security"],
 	"test-engineer": ["verification-before-done", "safe-bash"],
 	verifier: ["verification-before-done", "runtime-state-reader"],
-	writer: ["context-artifact-hygiene", "verify-evidence"],
+	writer: ["context-artifact-hygiene", "verification-before-done"],
 };
 
 export interface ResolveTaskSkillsInput {
@@ -72,18 +54,11 @@ export interface RenderSkillInstructionsInput extends ResolveTaskSkillsInput {
 }
 
 function isValidSkillName(name: string): boolean {
-	return (
-		name.length > 0 &&
-		name.length <= MAX_SKILL_NAME_CHARS &&
-		isSafePathId(name)
-	);
+	return name.length > 0 && name.length <= MAX_SKILL_NAME_CHARS && isSafePathId(name);
 }
 
 function sanitizeSkillName(name: string): string {
-	return (
-		name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, MAX_SKILL_NAME_CHARS) ||
-		"invalid"
-	);
+	return name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, MAX_SKILL_NAME_CHARS) || "invalid";
 }
 
 function unique(items: string[]): string[] {
@@ -98,9 +73,7 @@ function unique(items: string[]): string[] {
 	return result;
 }
 
-export function normalizeSkillOverride(
-	value: string | string[] | boolean | undefined,
-): string[] | false | undefined {
+export function normalizeSkillOverride(value: string | string[] | boolean | undefined): string[] | false | undefined {
 	if (value === false) return false;
 	if (typeof value === "string")
 		return value
@@ -108,8 +81,7 @@ export function normalizeSkillOverride(
 			.map((entry) => entry.trim())
 			.filter(Boolean);
 	if (value === true) return undefined;
-	if (Array.isArray(value))
-		return value.map((entry) => entry.trim()).filter(Boolean);
+	if (Array.isArray(value)) return value.map((entry) => entry.trim()).filter(Boolean);
 	return undefined;
 }
 
@@ -117,17 +89,13 @@ export function defaultSkillsForRole(role: string): string[] {
 	return DEFAULT_ROLE_SKILLS[role] ?? [];
 }
 
-function collectTaskSkillNames(
-	input: ResolveTaskSkillsInput | undefined,
-): string[] {
+function collectTaskSkillNames(input: ResolveTaskSkillsInput | undefined): string[] {
 	if (!input) return [];
 	if (input.override === false) return [];
-	const roleDefaultsDisabled =
-		input.teamRole?.skills === false || input.step?.skills === false;
+	const roleDefaultsDisabled = input.teamRole?.skills === false || input.step?.skills === false;
 	const names = roleDefaultsDisabled ? [] : defaultSkillsForRole(input.role);
 	if (input.agent?.skills?.length) names.push(...input.agent.skills);
-	if (Array.isArray(input.teamRole?.skills))
-		names.push(...input.teamRole.skills);
+	if (Array.isArray(input.teamRole?.skills)) names.push(...input.teamRole.skills);
 	if (Array.isArray(input.step?.skills)) names.push(...input.step.skills);
 	if (Array.isArray(input.override)) names.push(...input.override);
 	return unique(names);
@@ -143,19 +111,26 @@ export function resolveTaskSkillNames(input: ResolveTaskSkillsInput): string[] {
 // See: SECURITY-ISSUES.md SEC-003
 // ═══════════════════════════════════════════════════════════════════════════
 
-function candidateSkillDirs(
-	cwd: string,
-): Array<{ root: string; source: "project" | "package" | "project-pi" | "user-pi" | "project-agents" | "user-agents" }> {
+function candidateSkillDirs(cwd: string): Array<{
+	root: string;
+	source: "project" | "package" | "project-pi" | "user-pi" | "project-agents" | "user-agents";
+}> {
 	return [
 		{ root: PACKAGE_SKILLS_DIR, source: "package" }, // ✓ Trusted first
 		// F6 (v0.7.9): same five roots as discover-skills, in the same precedence
 		// order. The first hit wins, so a project `.pi/skills/foo/SKILL.md`
 		// overrides both the bundled `foo` and any legacy `<cwd>/skills/foo`.
 		{ 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" },
 	];
 }
@@ -170,10 +145,7 @@ interface CachedSkillMarkdown {
 
 const skillReadCache = new Map<string, CachedSkillMarkdown>();
 
-function rememberSkill(
-	key: string,
-	value: CachedSkillMarkdown,
-): CachedSkillMarkdown {
+function rememberSkill(key: string, value: CachedSkillMarkdown): CachedSkillMarkdown {
 	if (skillReadCache.has(key)) skillReadCache.delete(key);
 	skillReadCache.set(key, value);
 	while (skillReadCache.size > SKILL_CACHE_MAX_ENTRIES) {
@@ -201,7 +173,11 @@ function readSkillMarkdown(
 	cwd: string,
 	name: string,
 ):
-	| { path: string; source: "project" | "package" | "project-pi" | "user-pi" | "project-agents" | "user-agents"; content: string }
+	| {
+			path: string;
+			source: "project" | "package" | "project-pi" | "user-pi" | "project-agents" | "user-agents";
+			content: string;
+	  }
 	| undefined {
 	if (!isValidSkillName(name)) return undefined;
 	const cacheKey = `${path.resolve(cwd)}:${name}`;
@@ -231,9 +207,7 @@ function readSkillMarkdown(
 function frontmatterDescription(content: string): string | undefined {
 	const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
 	if (!match) return undefined;
-	const line = match[1]
-		.split(/\r?\n/)
-		.find((entry) => entry.startsWith("description:"));
+	const line = match[1].split(/\r?\n/).find((entry) => entry.startsWith("description:"));
 	return line?.slice("description:".length).trim();
 }
 
@@ -244,12 +218,8 @@ function stripFrontmatter(content: string): string {
 function compactSkillContent(content: string): string {
 	const body = stripFrontmatter(content);
 	if (body.length <= MAX_SKILL_CHARS) return body;
-	const preferred =
-		body.split(/\r?\n## Verification\r?\n/)[0]?.trim() ?? body;
-	const truncated =
-		preferred.length > MAX_SKILL_CHARS
-			? preferred.slice(0, MAX_SKILL_CHARS - 40).trimEnd()
-			: preferred;
+	const preferred = body.split(/\r?\n## Verification\r?\n/)[0]?.trim() ?? body;
+	const truncated = preferred.length > MAX_SKILL_CHARS ? preferred.slice(0, MAX_SKILL_CHARS - 40).trimEnd() : preferred;
 	return `${truncated}\n\n[skill instructions truncated]`;
 }
 
@@ -285,13 +255,7 @@ export function renderSkillInstructions(
 	if (input.runId) {
 		// Register effectiveness hooks once per process
 		registerSkillEffectivenessHooks();
-		const weighted = getWeightedSkillsForRole(
-			input.cwd,
-			input.role,
-			names,
-			input.runId,
-			CONFIDENCE_THRESHOLDS.TENTATIVE,
-		);
+		const weighted = getWeightedSkillsForRole(input.cwd, input.role, names, input.runId, CONFIDENCE_THRESHOLDS.TENTATIVE);
 		weightedSkills = weighted.map((w) => ({
 			skillId: w.skillId,
 			confidence: w.confidence,
@@ -316,22 +280,15 @@ export function renderSkillInstructions(
 		}
 		skillPaths.push(path.dirname(loaded.path));
 		const description = frontmatterDescription(loaded.content);
-		const source =
-			loaded.source === "project"
-				? `project:skills/${safeName}`
-				: `package:skills/${safeName}`;
+		const source = loaded.source === "project" ? `project:skills/${safeName}` : `package:skills/${safeName}`;
 
 		// ECC INSTINCT: Add confidence annotation from weighted skills
 		const weighted = weightedSkills?.find((w) => w.skillId === name);
-		const confidenceNote = weighted
-			? ` [Confidence: ${(weighted.confidence * 100).toFixed(0)}% — ${weighted.threshold}]`
-			: "";
+		const confidenceNote = weighted ? ` [Confidence: ${(weighted.confidence * 100).toFixed(0)}% — ${weighted.threshold}]` : "";
 
 		const header = [
 			`## ${safeName}`,
-			description
-				? `Description: ${description}${confidenceNote}`
-				: undefined,
+			description ? `Description: ${description}${confidenceNote}` : undefined,
 			`Source: ${source}`,
 			// Path: pointer to the skill directory so the agent can deterministically
 			// `ls <Path>/references/` and `read` a co-located reference corpus.