pi-crew 0.6.0 → 0.6.3

package/src/runtime/skill-effectiveness.ts

@@ -1,17 +1,18 @@
 /**
  * Skill Effectiveness — ECC INSTINCT/CONFIDENCE Pattern Implementation
- * 
+ *
  * Implements confidence-weighted skill activation based on ECC's instinct system.
  * Tracks skill activation success and adjusts confidence scores.
- * 
+ *
  * Based on: docs/distillation/ECC-hooks-instincts.md §2-3 (instinct system, confidence thresholds)
  * Based on: docs/distillation/ECC-10-skills.md §8 (continuous-learning-v2)
- * 
+ *
  * @module skill-effectiveness
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
+import { projectCrewRoot } from "../utils/paths.ts";
 import { crewHooks } from "./crew-hooks.ts";
 
 /**
@@ -19,10 +20,10 @@ import { crewHooks } from "./crew-hooks.ts";
  * Skills below 0.3 threshold are considered tentative and not enforced.
  */
 export const CONFIDENCE_THRESHOLDS = {
-	TENTATIVE: 0.3,      // Suggested but not enforced
-	MODERATE: 0.5,       // Applied when relevant
-	STRONG: 0.7,         // Auto-approved for application
-	NEAR_CERTAIN: 0.9,   // Core behavior
+	TENTATIVE: 0.3, // Suggested but not enforced
+	MODERATE: 0.5, // Applied when relevant
+	STRONG: 0.7, // Auto-approved for application
+	NEAR_CERTAIN: 0.9, // Core behavior
 } as const;
 
 /**
@@ -30,12 +31,12 @@ export const CONFIDENCE_THRESHOLDS = {
  * From ECC instinct system: 1-2 observations → 0.3, 3-5 → 0.5, etc.
  */
 export const INITIAL_CONFIDENCE_BY_FREQUENCY: Record<string, number> = {
-	"1": 0.3,  // 1 observation → tentative
-	"2": 0.3,  // 2 observations → tentative
-	"3": 0.5,  // 3 observations → moderate
+	"1": 0.3, // 1 observation → tentative
+	"2": 0.3, // 2 observations → tentative
+	"3": 0.5, // 3 observations → moderate
 	"4": 0.5,
 	"5": 0.5,
-	"6": 0.7,  // 6-10 observations → strong
+	"6": 0.7, // 6-10 observations → strong
 	"7": 0.7,
 	"8": 0.7,
 	"9": 0.7,
@@ -47,8 +48,8 @@ export const INITIAL_CONFIDENCE_BY_FREQUENCY: Record<string, number> = {
  * Confidence adjustments per ECC instinct system.
  */
 export const CONFIDENCE_ADJUSTMENTS = {
-	CONFIRMING: 0.05,      // Each confirming observation
-	CONTRADICTING: -0.1,   // Each contradicting observation
+	CONFIRMING: 0.05, // Each confirming observation
+	CONTRADICTING: -0.1, // Each contradicting observation
 	DECAY_PER_WEEK: -0.02, // Per week without observation
 } as const;
 
@@ -57,24 +58,24 @@ export const CONFIDENCE_ADJUSTMENTS = {
  * Skill can be promoted to "strong enforcement" when these are met.
  */
 export const PROMOTION_GATE_CRITERIA = {
-	MIN_CORRECTNESS: 0.8,      // 80% pass rate
-	MIN_ACTIVATIONS: 5,         // Minimum observations before filtering
-	MIN_AVG_CONFIDENCE: 0.7,   // Average confidence threshold
+	MIN_CORRECTNESS: 0.8, // 80% pass rate
+	MIN_ACTIVATIONS: 5, // Minimum observations before filtering
+	MIN_AVG_CONFIDENCE: 0.7, // Average confidence threshold
 } as const;
 
 /**
  * Skill activation record - captures each time a skill is used.
  */
 export interface SkillActivation {
-	id: string;           // Unique activation ID
-	skillId: string;      // Skill identifier (e.g., "verification-before-done")
-	role: string;         // Role that activated the skill
-	runId: string;        // Run ID
-	taskId: string;       // Task ID
-	timestamp: string;    // ISO timestamp
-	passed: boolean;       // Whether the skill was successfully applied
-	outcome?: string;     // Optional outcome description
-	confidence: number;    // Confidence at time of activation
+	id: string; // Unique activation ID
+	skillId: string; // Skill identifier (e.g., "verification-before-done")
+	role: string; // Role that activated the skill
+	runId: string; // Run ID
+	taskId: string; // Task ID
+	timestamp: string; // ISO timestamp
+	passed: boolean; // Whether the skill was successfully applied
+	outcome?: string; // Optional outcome description
+	confidence: number; // Confidence at time of activation
 }
 
 /**
@@ -85,13 +86,13 @@ export interface SkillMetrics {
 	totalActivations: number;
 	passedActivations: number;
 	failedActivations: number;
-	passRate: number;           // passed / total
-	avgConfidence: number;       // Rolling average confidence
-	currentConfidence: number;   // Current confidence score
+	passRate: number; // passed / total
+	avgConfidence: number; // Rolling average confidence
+	currentConfidence: number; // Current confidence score
 	trend: "improving" | "stable" | "declining";
-	lastActivation?: string;    // ISO timestamp
-	firstActivation?: string;   // ISO timestamp
-	roleBreakdown: Record<string, number>;  // Activations per role
+	lastActivation?: string; // ISO timestamp
+	firstActivation?: string; // ISO timestamp
+	roleBreakdown: Record<string, number>; // Activations per role
 }
 
 /**
@@ -102,35 +103,39 @@ export interface WeightedSkill {
 	confidence: number;
 	threshold: keyof typeof CONFIDENCE_THRESHOLDS;
 	behavior: "suggest" | "apply_if_asked" | "apply_auto" | "act_autonomous";
-	evidence: string;  // Evidence for confidence score
+	evidence: string; // Evidence for confidence score
 	metrics: SkillMetrics;
 }
 
 /**
  * Get skill effectiveness storage path.
+ * Uses projectCrewRoot() so the path honours the `.pi/teams/` fallback
+ * for `.pi`-based projects (see issue #29).
  */
-function getSkillMetricsPath(runId: string): string {
+function getSkillMetricsPath(cwd: string, runId: string): string {
 	return join(
-		process.cwd(),
-		`.crew/state/runs/${runId}/skill-metrics.jsonl`,
+		projectCrewRoot(cwd),
+		`state/runs/${runId}/skill-metrics.jsonl`,
 	);
 }
 
 /**
  * Get skill activations path.
+ * Uses projectCrewRoot() so the path honours the `.pi/teams/` fallback
+ * for `.pi`-based projects (see issue #29).
  */
-function getSkillActivationsPath(runId: string): string {
+function getSkillActivationsPath(cwd: string, runId: string): string {
 	return join(
-		process.cwd(),
-		`.crew/state/runs/${runId}/skill-activations.jsonl`,
+		projectCrewRoot(cwd),
+		`state/runs/${runId}/skill-activations.jsonl`,
 	);
 }
 
 /**
  * Ensure directory exists for skill metrics.
  */
-function ensureSkillMetricsDir(runId: string): void {
-	const dir = dirname(getSkillMetricsPath(runId));
+function ensureSkillMetricsDir(cwd: string, runId: string): void {
+	const dir = dirname(getSkillMetricsPath(cwd, runId));
 	if (!existsSync(dir)) {
 		mkdirSync(dir, { recursive: true });
 	}
@@ -163,7 +168,9 @@ export function adjustConfidence(current: number, passed: boolean): number {
 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;
 
@@ -173,8 +180,11 @@ 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";
@@ -183,7 +193,9 @@ export function confidenceToBehavior(confidence: number): WeightedSkill["behavio
 /**
  * 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";
@@ -195,11 +207,12 @@ export function confidenceToThreshold(confidence: number): keyof typeof CONFIDEN
  * Appends to the run's skill-activations.jsonl for learning.
  */
 export function recordSkillActivation(
+	cwd: string,
 	activation: SkillActivation,
 ): SkillActivation {
-	ensureSkillMetricsDir(activation.runId);
+	ensureSkillMetricsDir(cwd, activation.runId);
 
-	const path = getSkillActivationsPath(activation.runId);
+	const path = getSkillActivationsPath(cwd, activation.runId);
 	const line = JSON.stringify(activation) + "\n";
 	writeFileSync(path, line, { flag: "a", encoding: "utf-8" });
 
@@ -209,8 +222,11 @@ export function recordSkillActivation(
 /**
  * Get all skill activations for a run.
  */
-export function getSkillActivations(runId: string): SkillActivation[] {
-	const path = getSkillActivationsPath(runId);
+export function getSkillActivations(
+	cwd: string,
+	runId: string,
+): SkillActivation[] {
+	const path = getSkillActivationsPath(cwd, runId);
 
 	if (!existsSync(path)) {
 		return [];
@@ -256,11 +272,13 @@ export function computeSkillMetrics(
 		skillActivations.reduce((sum, a) => sum + a.confidence, 0) /
 		skillActivations.length;
 	const currentConfidence =
-		skillActivations[skillActivations.length - 1]?.confidence ?? avgConfidence;
+		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
@@ -282,7 +300,8 @@ export function computeSkillMetrics(
 	}
 
 	// 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 {
@@ -315,10 +334,13 @@ 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);
@@ -341,12 +363,13 @@ export function evaluatePromotionGate(metrics: SkillMetrics): {
  * Filters by minimum confidence threshold.
  */
 export function getWeightedSkillsForRole(
+	cwd: string,
 	role: string,
 	skillIds: string[],
 	runId: string,
 	minConfidence: number = CONFIDENCE_THRESHOLDS.TENTATIVE,
 ): WeightedSkill[] {
-	const activations = getSkillActivations(runId);
+	const activations = getSkillActivations(cwd, runId);
 
 	return skillIds
 		.map((skillId) => {
@@ -374,13 +397,21 @@ export function getWeightedSkillsForRole(
  * Filter skills by confidence threshold.
  * Skills below threshold are marked as "suggest" only.
  */
-export function filterSkillsByConfidence(
+/** @internal */
+function filterSkillsByConfidence(
+	cwd: string,
 	skillIds: string[],
 	runId: string,
 	threshold: keyof typeof CONFIDENCE_THRESHOLDS = "MODERATE",
 ): WeightedSkill[] {
 	const minConfidence = CONFIDENCE_THRESHOLDS[threshold];
-	return getWeightedSkillsForRole("global", skillIds, runId, minConfidence);
+	return getWeightedSkillsForRole(
+		cwd,
+		"global",
+		skillIds,
+		runId,
+		minConfidence,
+	);
 }
 
 /**
@@ -414,7 +445,11 @@ export function registerSkillEffectivenessHooks(): void {
 				passed: success,
 				confidence: computeInitialConfidence(1),
 			};
-			recordSkillActivation(activation);
+			// cwd comes from the event payload (set by callers) so that the
+			// activation lands in the correct .pi/teams/ or .crew/state/runs/
+			// (see issue #29).
+			const eventCwd = (data?.cwd as string) ?? process.cwd();
+			recordSkillActivation(eventCwd, activation);
 		}
 	});
 
@@ -431,11 +466,13 @@ export function registerSkillEffectivenessHooks(): void {
 /**
  * Generate a skill effectiveness report for a run.
  */
-export function generateSkillEffectivenessReport(
+/** @internal */
+function generateSkillEffectivenessReport(
+	cwd: string,
 	runId: string,
 	skillIds: string[],
 ): string {
-	const activations = getSkillActivations(runId);
+	const activations = getSkillActivations(cwd, runId);
 	const lines: string[] = [
 		`# Skill Effectiveness Report: ${runId}`,
 		"",
@@ -457,13 +494,21 @@ export 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,15 +3,24 @@ 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 type { WorkflowStep } from "../workflows/workflow-config.ts";
-import { isSafePathId, resolveContainedPath, resolveRealContainedPath } from "../utils/safe-paths.ts";
 import {
+	CONFIDENCE_THRESHOLDS,
 	getWeightedSkillsForRole,
 	registerSkillEffectivenessHooks,
-	CONFIDENCE_THRESHOLDS,
 } 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",
+);
 const MAX_SKILL_CHARS = 1500;
 const MAX_TOTAL_CHARS = 6000;
 const MAX_SKILL_NAME_CHARS = 80;
@@ -23,7 +32,11 @@ 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,
@@ -31,7 +44,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"],
@@ -50,11 +66,18 @@ 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[] {
@@ -69,11 +92,18 @@ 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.split(",").map((entry) => entry.trim()).filter(Boolean);
+	if (typeof value === "string")
+		return value
+			.split(",")
+			.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;
 }
 
@@ -81,13 +111,17 @@ 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);
@@ -103,10 +137,12 @@ export function resolveTaskSkillNames(input: ResolveTaskSkillsInput): string[] {
 // See: SECURITY-ISSUES.md SEC-003
 // ═══════════════════════════════════════════════════════════════════════════
 
-function candidateSkillDirs(cwd: string): Array<{ root: string; source: "project" | "package" }> {
+function candidateSkillDirs(
+	cwd: string,
+): Array<{ root: string; source: "project" | "package" }> {
 	return [
-		{ root: PACKAGE_SKILLS_DIR, source: "package" },   // ✓ Trusted first
-		{ root: path.resolve(cwd, "skills"), source: "project" },  // ⚠️ Override second
+		{ root: PACKAGE_SKILLS_DIR, source: "package" }, // ✓ Trusted first
+		{ root: path.resolve(cwd, "skills"), source: "project" }, // ⚠️ Override second
 	];
 }
 
@@ -120,7 +156,10 @@ 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) {
@@ -144,7 +183,12 @@ function cachedSkillFresh(value: CachedSkillMarkdown): boolean {
 	}
 }
 
-function readSkillMarkdown(cwd: string, name: string): { path: string; source: "project" | "package"; content: string } | undefined {
+function readSkillMarkdown(
+	cwd: string,
+	name: string,
+):
+	| { path: string; source: "project" | "package"; content: string }
+	| undefined {
 	if (!isValidSkillName(name)) return undefined;
 	const cacheKey = `${path.resolve(cwd)}:${name}`;
 	const cached = skillReadCache.get(cacheKey);
@@ -158,9 +202,14 @@ function readSkillMarkdown(cwd: string, name: string): { path: string; source: "
 			if (fs.lstatSync(contained).isSymbolicLink()) continue;
 			const filePath = resolveRealContainedPath(entry.root, relative);
 			const stat = fs.statSync(filePath);
-			return rememberSkill(cacheKey, { path: filePath, source: entry.source, content: fs.readFileSync(filePath, "utf-8"), mtimeMs: stat.mtimeMs, size: stat.size });
-		} catch {
-		}
+			return rememberSkill(cacheKey, {
+				path: filePath,
+				source: entry.source,
+				content: fs.readFileSync(filePath, "utf-8"),
+				mtimeMs: stat.mtimeMs,
+				size: stat.size,
+			});
+		} catch {}
 	}
 	return undefined;
 }
@@ -168,7 +217,9 @@ function readSkillMarkdown(cwd: string, name: string): { path: string; source: "
 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();
 }
 
@@ -179,8 +230,12 @@ 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]`;
 }
 
@@ -197,7 +252,11 @@ export interface RenderedSkillInstructions {
 	}>;
 }
 
-export function renderSkillInstructions(input: RenderSkillInstructionsInput & { runId?: string } = {} as RenderSkillInstructionsInput & { runId?: string }): RenderedSkillInstructions {
+export function renderSkillInstructions(
+	input: RenderSkillInstructionsInput & {
+		runId?: string;
+	} = {} as RenderSkillInstructionsInput & { runId?: string },
+): RenderedSkillInstructions {
 	const allNames = collectTaskSkillNames(input);
 	const names = allNames.slice(0, MAX_SELECTED_SKILLS);
 	const overflowCount = Math.max(0, allNames.length - names.length);
@@ -208,12 +267,18 @@ export function renderSkillInstructions(input: RenderSkillInstructionsInput & {
 	let omittedCount = overflowCount;
 
 	// ECC INSTINCT: Get confidence-weighted skills if runId is provided
-	let weightedSkills: RenderedSkillInstructions["weightedSkills"] = undefined;
+	let weightedSkills: RenderedSkillInstructions["weightedSkills"];
 	if (input.runId) {
 		// Register effectiveness hooks once per process
 		registerSkillEffectivenessHooks();
-		const weighted = getWeightedSkillsForRole(input.role, names, input.runId, CONFIDENCE_THRESHOLDS.TENTATIVE);
-		weightedSkills = weighted.map(w => ({
+		const weighted = getWeightedSkillsForRole(
+			input.cwd,
+			input.role,
+			names,
+			input.runId,
+			CONFIDENCE_THRESHOLDS.TENTATIVE,
+		);
+		weightedSkills = weighted.map((w) => ({
 			skillId: w.skillId,
 			confidence: w.confidence,
 			behavior: w.behavior,
@@ -237,14 +302,30 @@ export function renderSkillInstructions(input: RenderSkillInstructionsInput & {
 		}
 		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 weighted = weightedSkills?.find((w) => w.skillId === name);
+		const confidenceNote = weighted
+			? ` [Confidence: ${(weighted.confidence * 100).toFixed(0)}% — ${weighted.threshold}]`
+			: "";
 
-		const header = [`## ${safeName}`, description ? `Description: ${description}${confidenceNote}` : undefined, `Source: ${source}`].filter(Boolean).join("\n");
-		const section = `${header}\n\n${compactSkillContent(loaded.content)}`;
+		const header = [
+			`## ${safeName}`,
+			description
+				? `Description: ${description}${confidenceNote}`
+				: undefined,
+			`Source: ${source}`,
+		]
+			.filter(Boolean)
+			.join("\n");
+		const rawContent = compactSkillContent(loaded.content);
+		// Wrap skill content with provenance markers to help LLMs distinguish skill instructions
+		const wrappedContent = `<!-- skill: ${safeName} -->\n${rawContent}\n<!-- end-skill: ${safeName} -->`;
+		const section = `${header}\n\n${wrappedContent}`;
 		if (!pushSection(section)) omittedCount += 1;
 	}
 	if (omittedCount > 0) {