@agentplate/cli 1.0.0

package/src/skills/feedback.test.ts

@@ -0,0 +1,300 @@
+import { describe, expect, test } from "bun:test";
+
+import type { OutcomeStatus } from "../types.ts";
+import {
+	computeConfidence,
+	evaluateLifecycle,
+	type LifecycleConfig,
+	wilsonLowerBound,
+} from "./feedback.ts";
+import type { Skill, SkillOutcome, SkillStatus } from "./types.ts";
+
+// --- builders -------------------------------------------------------------
+
+let outcomeSeq = 0;
+
+/** Build a minimal {@link SkillOutcome} carrying just the status under test. */
+function outcome(status: OutcomeStatus): SkillOutcome {
+	outcomeSeq += 1;
+	return {
+		status,
+		agent: "builder-1",
+		taskId: `task-${outcomeSeq}`,
+		gates: status,
+		ts: new Date(2026, 4, 31, 0, 0, outcomeSeq).toISOString(),
+	};
+}
+
+/** Build N outcomes of the same status. */
+function outcomes(status: OutcomeStatus, n: number): SkillOutcome[] {
+	return Array.from({ length: n }, () => outcome(status));
+}
+
+/** Build a {@link Skill} with overridable derived fields for lifecycle tests. */
+function makeSkill(overrides: Partial<Skill> = {}): Skill {
+	return {
+		id: "00000000-0000-0000-0000-000000000000",
+		slug: "example-skill",
+		title: "Example skill",
+		version: 1,
+		status: "active",
+		goal: "Do the thing reliably.",
+		whenToUse: ["when the thing needs doing"],
+		filePatterns: ["src/**/*.ts"],
+		tags: ["example"],
+		created: "2026-05-31T00:00:00.000Z",
+		updatedAt: "2026-05-31T00:00:00.000Z",
+		relatesTo: [],
+		supersedes: [],
+		body: "Steps go here.",
+		confidence: 0.9,
+		appliedCount: 0,
+		successCount: 0,
+		lastOutcome: null,
+		...overrides,
+	};
+}
+
+const CFG: LifecycleConfig = { quarantineBelow: 0.3, minSamples: 5 };
+
+// --- wilsonLowerBound -----------------------------------------------------
+
+describe("wilsonLowerBound", () => {
+	test("n <= 0 returns 0 (no evidence, no confidence)", () => {
+		expect(wilsonLowerBound(0, 0)).toBe(0);
+		expect(wilsonLowerBound(5, 0)).toBe(0);
+		expect(wilsonLowerBound(3, -2)).toBe(0);
+	});
+
+	test("0 successes out of n yields a lower bound of 0", () => {
+		expect(wilsonLowerBound(0, 1)).toBe(0);
+		expect(wilsonLowerBound(0, 10)).toBe(0);
+		expect(wilsonLowerBound(0, 1000)).toBe(0);
+	});
+
+	test("all successes give a high bound but strictly below 1 for small n", () => {
+		const small = wilsonLowerBound(1, 1);
+		expect(small).toBeGreaterThan(0);
+		expect(small).toBeLessThan(1);
+
+		// More all-success evidence pushes the bound up, but never reaches 1.
+		const more = wilsonLowerBound(20, 20);
+		expect(more).toBeLessThan(1);
+		expect(more).toBeGreaterThan(small);
+	});
+
+	test("result is always clamped to [0, 1]", () => {
+		for (const [s, n] of [
+			[0, 1],
+			[1, 1],
+			[5, 10],
+			[10, 10],
+			[100, 100],
+			[3, 7],
+		] as const) {
+			const lb = wilsonLowerBound(s, n);
+			expect(lb).toBeGreaterThanOrEqual(0);
+			expect(lb).toBeLessThanOrEqual(1);
+		}
+	});
+
+	test("out-of-range successes are clamped, keeping the bound in [0,1]", () => {
+		// successes > n is clamped to n -> behaves like an all-success run.
+		expect(wilsonLowerBound(99, 10)).toBe(wilsonLowerBound(10, 10));
+		// negative successes clamp to 0.
+		expect(wilsonLowerBound(-5, 10)).toBe(wilsonLowerBound(0, 10));
+	});
+
+	test("monotonic in successes at fixed n", () => {
+		const n = 10;
+		let previous = -1;
+		for (let s = 0; s <= n; s += 1) {
+			const lb = wilsonLowerBound(s, n);
+			expect(lb).toBeGreaterThan(previous);
+			previous = lb;
+		}
+	});
+
+	test("monotonic in n for a fixed perfect success rate (more evidence => higher bound)", () => {
+		let previous = -1;
+		for (const n of [1, 2, 5, 10, 25, 50, 100]) {
+			const lb = wilsonLowerBound(n, n);
+			expect(lb).toBeGreaterThan(previous);
+			previous = lb;
+		}
+	});
+
+	test("larger z (wider interval) lowers the bound", () => {
+		const tight = wilsonLowerBound(8, 10, 1.0);
+		const wide = wilsonLowerBound(8, 10, 2.576);
+		expect(wide).toBeLessThan(tight);
+	});
+
+	test("supports fractional (weighted) successes", () => {
+		// 5 partials over 10 trials -> weight 2.5; bound sits between 0 and the
+		// 0.5 raw proportion.
+		const lb = wilsonLowerBound(2.5, 10);
+		expect(lb).toBeGreaterThan(0);
+		expect(lb).toBeLessThan(0.5);
+	});
+});
+
+// --- computeConfidence ----------------------------------------------------
+
+describe("computeConfidence", () => {
+	test("empty outcome log -> zeroed result with null lastOutcome", () => {
+		expect(computeConfidence([])).toEqual({
+			confidence: 0,
+			appliedCount: 0,
+			successCount: 0,
+			lastOutcome: null,
+		});
+	});
+
+	test("weights outcomes: success=1, partial=0.5, failure=0", () => {
+		const result = computeConfidence([
+			outcome("success"),
+			outcome("partial"),
+			outcome("failure"),
+			outcome("success"),
+		]);
+		expect(result.appliedCount).toBe(4);
+		// 1 + 0.5 + 0 + 1 = 2.5 (kept as a real-valued weight sum, NOT rounded).
+		expect(result.successCount).toBe(2.5);
+		expect(result.confidence).toBeCloseTo(wilsonLowerBound(2.5, 4), 12);
+	});
+
+	test("lastOutcome reflects the final element in chronological order", () => {
+		expect(computeConfidence([outcome("success"), outcome("failure")]).lastOutcome).toBe("failure");
+		expect(computeConfidence([outcome("failure"), outcome("partial")]).lastOutcome).toBe("partial");
+		expect(computeConfidence([outcome("success")]).lastOutcome).toBe("success");
+	});
+
+	test("successCount is a SUM of weights, not a rounded integer", () => {
+		const result = computeConfidence(outcomes("partial", 3));
+		expect(result.successCount).toBe(1.5);
+		expect(Number.isInteger(result.successCount)).toBe(false);
+	});
+
+	test("all-success confidence equals the Wilson bound for n/n", () => {
+		const result = computeConfidence(outcomes("success", 8));
+		expect(result.successCount).toBe(8);
+		expect(result.confidence).toBeCloseTo(wilsonLowerBound(8, 8), 12);
+		expect(result.confidence).toBeLessThan(1);
+	});
+
+	test("all-failure confidence is 0", () => {
+		const result = computeConfidence(outcomes("failure", 6));
+		expect(result.successCount).toBe(0);
+		expect(result.confidence).toBe(0);
+	});
+
+	test("small-sample penalty: 1/1 success has LOWER confidence than 30/33", () => {
+		const oneOfOne = computeConfidence(outcomes("success", 1));
+
+		const thirtyOfThirtyThree = computeConfidence([
+			...outcomes("success", 30),
+			...outcomes("failure", 3),
+		]);
+
+		expect(thirtyOfThirtyThree.appliedCount).toBe(33);
+		expect(thirtyOfThirtyThree.successCount).toBe(30);
+		expect(oneOfOne.confidence).toBeLessThan(thirtyOfThirtyThree.confidence);
+	});
+
+	test("more consistent successes raise confidence over time", () => {
+		const few = computeConfidence(outcomes("success", 3));
+		const many = computeConfidence(outcomes("success", 30));
+		expect(many.confidence).toBeGreaterThan(few.confidence);
+	});
+
+	test("confidence stays within [0, 1] across mixed logs", () => {
+		const result = computeConfidence([
+			...outcomes("success", 7),
+			...outcomes("partial", 4),
+			...outcomes("failure", 5),
+		]);
+		expect(result.confidence).toBeGreaterThanOrEqual(0);
+		expect(result.confidence).toBeLessThanOrEqual(1);
+		expect(result.appliedCount).toBe(16);
+		expect(result.successCount).toBe(9); // 7 + 2 + 0
+	});
+});
+
+// --- evaluateLifecycle ----------------------------------------------------
+
+describe("evaluateLifecycle", () => {
+	test("quarantines on low confidence WITH enough samples", () => {
+		const skill = makeSkill({ status: "active", appliedCount: 10, confidence: 0.2 });
+		expect(evaluateLifecycle(skill, [], CFG)).toBe("quarantined");
+	});
+
+	test("does NOT quarantine on low confidence when below minSamples", () => {
+		const skill = makeSkill({ status: "active", appliedCount: 2, confidence: 0.1 });
+		expect(evaluateLifecycle(skill, [], CFG)).toBe("active");
+	});
+
+	test("does NOT quarantine when confidence is at or above the floor", () => {
+		const atFloor = makeSkill({ status: "active", appliedCount: 20, confidence: 0.3 });
+		expect(evaluateLifecycle(atFloor, [], CFG)).toBe("active");
+
+		const aboveFloor = makeSkill({ status: "active", appliedCount: 20, confidence: 0.8 });
+		expect(evaluateLifecycle(aboveFloor, [], CFG)).toBe("active");
+	});
+
+	test("quarantines on three consecutive failures regardless of historical confidence", () => {
+		const skill = makeSkill({ status: "active", appliedCount: 50, confidence: 0.95 });
+		const recent = outcomes("failure", 3);
+		expect(evaluateLifecycle(skill, recent, CFG)).toBe("quarantined");
+	});
+
+	test("inspects only the trailing 3 outcomes for the consecutive-failure rule", () => {
+		const skill = makeSkill({ status: "active", appliedCount: 50, confidence: 0.95 });
+		// Older failures + a recent success tail -> NOT quarantined.
+		const recoveredTail: SkillOutcome[] = [
+			...outcomes("failure", 5),
+			outcome("success"),
+			outcome("success"),
+			outcome("success"),
+		];
+		expect(evaluateLifecycle(skill, recoveredTail, CFG)).toBe("active");
+
+		// A full log whose final three are failures DOES quarantine.
+		const regressedTail: SkillOutcome[] = [
+			outcome("success"),
+			outcome("success"),
+			...outcomes("failure", 3),
+		];
+		expect(evaluateLifecycle(skill, regressedTail, CFG)).toBe("quarantined");
+	});
+
+	test("fewer than 3 trailing failures never trips the consecutive rule", () => {
+		const skill = makeSkill({ status: "active", appliedCount: 50, confidence: 0.95 });
+		expect(evaluateLifecycle(skill, outcomes("failure", 2), CFG)).toBe("active");
+		expect(
+			evaluateLifecycle(skill, [outcome("failure"), outcome("success"), outcome("failure")], CFG),
+		).toBe("active");
+	});
+
+	test("preserves the current status when neither rule fires", () => {
+		const healthy = makeSkill({ status: "active", appliedCount: 40, confidence: 0.7 });
+		expect(evaluateLifecycle(healthy, outcomes("success", 3), CFG)).toBe("active");
+	});
+
+	test("never auto-resurrects a deprecated skill", () => {
+		const deprecated = makeSkill({ status: "deprecated", appliedCount: 40, confidence: 0.99 });
+		const status: SkillStatus = evaluateLifecycle(deprecated, outcomes("success", 3), CFG);
+		expect(status).toBe("deprecated");
+	});
+
+	test("a deprecated skill can still be (re)quarantined by the rules", () => {
+		const deprecated = makeSkill({ status: "deprecated", appliedCount: 40, confidence: 0.05 });
+		expect(evaluateLifecycle(deprecated, [], CFG)).toBe("quarantined");
+	});
+
+	test("an already-quarantined skill stays quarantined when healthy again", () => {
+		// Status is preserved (not promoted) — only an explicit action reactivates.
+		const quarantined = makeSkill({ status: "quarantined", appliedCount: 40, confidence: 0.9 });
+		expect(evaluateLifecycle(quarantined, outcomes("success", 3), CFG)).toBe("quarantined");
+	});
+});

package/src/skills/feedback.ts

@@ -0,0 +1,168 @@
+/**
+ * Confidence + lifecycle scoring for skills — the canonical, pure implementation.
+ *
+ * A skill earns trust through use. Every time an agent applies a skill the
+ * session-end feedback step appends a {@link SkillOutcome} to its
+ * `outcomes.jsonl`. This module turns that outcome log into the derived
+ * confidence track record (Wilson lower bound) and decides when a skill should
+ * be quarantined out of retrieval.
+ *
+ * WHY the Wilson score lower bound (rather than a naive success ratio): a skill
+ * that succeeded once (1/1) should NOT outrank a skill that succeeded 30 of 33
+ * times. The naive ratio gives the 1/1 skill a "perfect" 1.0; Wilson penalises
+ * small samples by reporting the lower bound of the confidence interval on the
+ * true success rate, so 1/1 lands well below 30/33. Outcomes are weighted —
+ * `partial` counts as half a success — so the "successes" fed to Wilson is a
+ * real-valued weight, not an integer count.
+ *
+ * PURITY: this module performs no I/O and imports no store. The skill store and
+ * the session-end hook each recompute these values inline at write time, but
+ * they converge on the formulas defined here (this is the single tested source
+ * of truth). Do NOT import the store from here — that would create a cycle.
+ */
+
+import type { OutcomeStatus } from "../types.ts";
+import type { Skill, SkillOutcome, SkillStatus } from "./types.ts";
+
+/** z-score for a 95% one-sided confidence interval (the default for Wilson). */
+const DEFAULT_Z = 1.96;
+
+/** Outcome-to-weight mapping for the success proportion. */
+const OUTCOME_WEIGHT: Record<OutcomeStatus, number> = {
+	success: 1.0,
+	partial: 0.5,
+	failure: 0.0,
+};
+
+/** Derived confidence figures recomputed from a skill's full outcome log. */
+export interface ConfidenceResult {
+	/** Wilson lower bound (0..1) of the weighted success proportion. */
+	confidence: number;
+	/** Total number of recorded outcomes (= the sample size n). */
+	appliedCount: number;
+	/** Sum of outcome weights (success=1, partial=0.5, failure=0) — a real number. */
+	successCount: number;
+	/** Status of the most recent outcome, or null when there are none. */
+	lastOutcome: OutcomeStatus | null;
+}
+
+/**
+ * Wilson score interval lower bound for a proportion.
+ *
+ * Given `successes` out of `n` trials (successes may be fractional, since
+ * outcomes are weighted), returns the lower bound of the Wilson confidence
+ * interval at the given z-score. This is a small-sample-aware estimate of the
+ * true success rate: it rewards more evidence and stays conservative when n is
+ * tiny.
+ *
+ * Edge cases: `n <= 0` returns 0 (no evidence ⇒ no confidence). The result is
+ * clamped to `[0, 1]`. `successes` is clamped to `[0, n]` defensively so a
+ * caller passing a slightly out-of-range weight cannot push the bound outside
+ * the unit interval.
+ *
+ * Formula (one-sided lower bound):
+ *
+ *   p  = successes / n
+ *   lb = (p + z²/2n − z·√( (p(1−p) + z²/4n) / n )) / (1 + z²/n)
+ */
+export function wilsonLowerBound(successes: number, n: number, z: number = DEFAULT_Z): number {
+	if (n <= 0) {
+		return 0;
+	}
+	// Defensive clamp: weighted successes must lie within [0, n].
+	const s = Math.min(Math.max(successes, 0), n);
+	const p = s / n;
+	const z2 = z * z;
+	const denominator = 1 + z2 / n;
+	const centre = p + z2 / (2 * n);
+	const margin = z * Math.sqrt((p * (1 - p) + z2 / (4 * n)) / n);
+	const lb = (centre - margin) / denominator;
+	// Clamp to the unit interval — guards against tiny floating-point overshoot.
+	return Math.min(Math.max(lb, 0), 1);
+}
+
+/**
+ * Recompute a skill's derived confidence figures from its full outcome log.
+ *
+ * Weights each outcome (success=1.0, partial=0.5, failure=0.0), sums the weights
+ * into `successCount`, and feeds `p = successCount / appliedCount` to the Wilson
+ * lower bound. With no outcomes, confidence is 0 and `lastOutcome` is null.
+ *
+ * `outcomes` is treated as chronologically ordered (append-only `outcomes.jsonl`
+ * order), so `lastOutcome` is the status of the final element.
+ */
+export function computeConfidence(outcomes: SkillOutcome[]): ConfidenceResult {
+	const appliedCount = outcomes.length;
+	if (appliedCount === 0) {
+		return { confidence: 0, appliedCount: 0, successCount: 0, lastOutcome: null };
+	}
+
+	let successCount = 0;
+	for (const outcome of outcomes) {
+		successCount += OUTCOME_WEIGHT[outcome.status];
+	}
+
+	const confidence = wilsonLowerBound(successCount, appliedCount);
+	const last = outcomes[appliedCount - 1];
+	const lastOutcome: OutcomeStatus | null = last ? last.status : null;
+
+	return { confidence, appliedCount, successCount, lastOutcome };
+}
+
+/** How many trailing failures in a row trigger an automatic quarantine. */
+const CONSECUTIVE_FAILURE_LIMIT = 3;
+
+/** Tunables controlling when a skill is quarantined out of retrieval. */
+export interface LifecycleConfig {
+	/** Quarantine when confidence drops below this (and the skill has >= minSamples). */
+	quarantineBelow: number;
+	/** Minimum sample size before the confidence floor is enforced. */
+	minSamples: number;
+}
+
+/**
+ * Decide a skill's lifecycle status given its (already-recomputed) confidence
+ * and its most recent outcomes.
+ *
+ * Returns `"quarantined"` when EITHER:
+ *   - the skill has enough evidence and its confidence is below the floor
+ *     (`skill.appliedCount >= minSamples && skill.confidence < quarantineBelow`), OR
+ *   - its last three outcomes are all failures (a sudden regression, regardless
+ *     of historical confidence).
+ *
+ * Otherwise the skill keeps its current `status`. In particular this never
+ * auto-resurrects a `deprecated` (or already `quarantined`) skill back to
+ * `active` — promotion is an explicit, human/distiller action, not a side
+ * effect of a few good runs.
+ *
+ * `recentOutcomes` should be the most recent outcomes in chronological order;
+ * only the final {@link CONSECUTIVE_FAILURE_LIMIT} are inspected for the
+ * consecutive-failure rule, so passing the full log or just the tail both work.
+ */
+export function evaluateLifecycle(
+	skill: Skill,
+	recentOutcomes: SkillOutcome[],
+	cfg: LifecycleConfig,
+): SkillStatus {
+	const lowConfidenceWithEvidence =
+		skill.appliedCount >= cfg.minSamples && skill.confidence < cfg.quarantineBelow;
+
+	if (lowConfidenceWithEvidence || hasConsecutiveFailures(recentOutcomes)) {
+		return "quarantined";
+	}
+
+	return skill.status;
+}
+
+/**
+ * True when the final {@link CONSECUTIVE_FAILURE_LIMIT} outcomes are all
+ * failures. Requires at least that many outcomes — fewer than the limit can
+ * never trip the rule.
+ */
+function hasConsecutiveFailures(outcomes: SkillOutcome[]): boolean {
+	if (outcomes.length < CONSECUTIVE_FAILURE_LIMIT) {
+		return false;
+	}
+	const tail = outcomes.slice(-CONSECUTIVE_FAILURE_LIMIT);
+	return tail.every((outcome) => outcome.status === "failure");
+}

package/src/skills/lifecycle.ts

@@ -0,0 +1,169 @@
+/**
+ * Skills lifecycle glue — the two integration points that close the learning
+ * loop, kept out of the command files so `sling`/`log` stay thin.
+ *
+ *  - {@link retrieveSkillsForSpawn}: at spawn, select relevant skills, persist an
+ *    `applied-skills.json` record, and return the overlay markdown block.
+ *  - {@link runSkillFeedbackAndDistill}: at session-end, append outcomes to the
+ *    applied skills (evolving confidence) and — when gates passed — distill a new
+ *    or updated skill from the diff.
+ */
+
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { appliedSkillsPath } from "../paths.ts";
+import type { AgentRuntime } from "../runtimes/types.ts";
+import type { OutcomeStatus, SkillsConfig } from "../types.ts";
+import { distillSkill } from "./distiller.ts";
+import { selectSkills } from "./retrieval.ts";
+import { createSkillStore } from "./store.ts";
+import type { AppliedSkillsRecord } from "./types.ts";
+
+export interface RetrieveSpawnArgs {
+	root: string;
+	agentName: string;
+	capability: string;
+	taskId: string;
+	fileScope: string[];
+	taskText: string;
+	skills: SkillsConfig;
+}
+
+/**
+ * Select skills for a spawning agent. Returns the overlay markdown to inject
+ * (empty string when skills are disabled or none match) and writes the
+ * `applied-skills.json` record the feedback step consumes.
+ */
+export function retrieveSkillsForSpawn(args: RetrieveSpawnArgs): string {
+	if (!args.skills.enabled) return "";
+	const store = createSkillStore(args.root);
+	try {
+		const all = store.list({ status: "active" });
+		if (all.length === 0) return "";
+		const result = selectSkills(all, {
+			fileScope: args.fileScope,
+			taskText: args.taskText,
+			capability: args.capability,
+			budgetChars: args.skills.retrieval.budgetChars,
+			maxFull: args.skills.retrieval.maxFull,
+		});
+
+		const record: AppliedSkillsRecord = {
+			taskId: args.taskId,
+			agent: args.agentName,
+			capability: args.capability,
+			skills: [
+				...result.full.map((r) => ({
+					id: r.skill.id,
+					slug: r.skill.slug,
+					injected: "full" as const,
+				})),
+				...result.summarized.map((r) => ({
+					id: r.skill.id,
+					slug: r.skill.slug,
+					injected: "summary" as const,
+				})),
+			],
+		};
+		if (record.skills.length > 0) {
+			const path = appliedSkillsPath(args.root, args.agentName);
+			mkdirSync(dirname(path), { recursive: true });
+			writeFileSync(path, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+		}
+		return result.overlayMarkdown;
+	} finally {
+		store.close();
+	}
+}
+
+export interface FeedbackDistillArgs {
+	root: string;
+	agentName: string;
+	capability: string;
+	taskId: string | null;
+	worktreePath: string;
+	baseRef: string;
+	runtime: AgentRuntime;
+	/** Quality-gate status for the session (null when no gates ran). */
+	outcomeStatus: OutcomeStatus | null;
+	skills: SkillsConfig;
+	model?: string;
+}
+
+export interface FeedbackDistillResult {
+	outcomesAppended: number;
+	distill: { action: "created" | "updated" | "skipped"; slug?: string };
+}
+
+/**
+ * Session-end: append the session's outcome to each applied skill (evolving its
+ * confidence), then — when enabled and gates passed — distill a skill from the
+ * work. Best-effort: never throws into the caller's hook path.
+ */
+export async function runSkillFeedbackAndDistill(
+	args: FeedbackDistillArgs,
+): Promise<FeedbackDistillResult> {
+	const result: FeedbackDistillResult = {
+		outcomesAppended: 0,
+		distill: { action: "skipped" },
+	};
+	if (!args.skills.enabled) return result;
+
+	const store = createSkillStore(args.root);
+	try {
+		// 1. Feedback: append the session outcome to every applied skill. Capture
+		//    the applied slugs first (the record file is removed afterward, but the
+		//    distiller still needs them to target an UPDATE).
+		const appliedSlugs = readAppliedSlugs(args.root, args.agentName);
+		const appliedPath = appliedSkillsPath(args.root, args.agentName);
+		if (existsSync(appliedPath)) {
+			const status: OutcomeStatus = args.outcomeStatus ?? "partial";
+			const ts = new Date().toISOString();
+			for (const slug of appliedSlugs) {
+				if (!store.get(slug)) continue;
+				store.appendOutcome(slug, {
+					status,
+					agent: args.agentName,
+					taskId: args.taskId,
+					gates: args.outcomeStatus,
+					ts,
+					note: `Applied by ${args.capability} ${args.agentName}`,
+				});
+				result.outcomesAppended++;
+			}
+			rmSync(appliedPath, { force: true });
+		}
+
+		// 2. Distill: only from work that passed its gates (when configured).
+		const gatesOk = !args.skills.distill.onlyOnGatesPass || args.outcomeStatus === "success";
+		if (gatesOk) {
+			result.distill = await distillSkill({
+				store,
+				runtime: args.runtime,
+				root: args.root,
+				worktreePath: args.worktreePath,
+				baseRef: args.baseRef,
+				taskId: args.taskId,
+				agentName: args.agentName,
+				capability: args.capability,
+				appliedSlugs,
+				model: args.skills.distill.model ?? args.model,
+			});
+		}
+		return result;
+	} finally {
+		store.close();
+	}
+}
+
+/** Read the applied-skill slugs recorded at spawn (empty when absent/corrupt). */
+function readAppliedSlugs(root: string, agentName: string): string[] {
+	const path = appliedSkillsPath(root, agentName);
+	if (!existsSync(path)) return [];
+	try {
+		const record = JSON.parse(readFileSync(path, "utf8")) as AppliedSkillsRecord;
+		return record.skills.map((s) => s.slug);
+	} catch {
+		return [];
+	}
+}