@kodrunhq/opencode-autopilot 1.15.2 → 1.17.0

package/src/orchestrator/handlers/build-utils.ts

@@ -0,0 +1,118 @@
+import { fileExists } from "../../utils/fs-helpers";
+import { getArtifactRef } from "../artifacts";
+import type { BuildProgress, Task } from "../types";
+import type { DispatchResult } from "./types";
+
+const MAX_STRIKES = 3;
+
+export function findCurrentWave(waveMap: ReadonlyMap<number, readonly Task[]>): number | null {
+	const sortedWaves = [...waveMap.keys()].sort((a, b) => a - b);
+	for (const wave of sortedWaves) {
+		const tasks = waveMap.get(wave) ?? [];
+		if (tasks.some((t) => t.status === "PENDING" || t.status === "IN_PROGRESS")) {
+			return wave;
+		}
+	}
+	return null;
+}
+
+export function findPendingTasks(
+	waveMap: ReadonlyMap<number, readonly Task[]>,
+	wave: number,
+): readonly Task[] {
+	const tasks = waveMap.get(wave) ?? [];
+	return tasks.filter((t) => t.status === "PENDING");
+}
+
+export function findInProgressTasks(
+	waveMap: ReadonlyMap<number, readonly Task[]>,
+	wave: number,
+): readonly Task[] {
+	const tasks = waveMap.get(wave) ?? [];
+	return tasks.filter((t) => t.status === "IN_PROGRESS");
+}
+
+export function buildPendingResultError(
+	wave: number,
+	inProgressTasks: readonly Task[],
+	buildProgress: Readonly<BuildProgress>,
+	updatedTasks?: readonly Task[],
+): DispatchResult {
+	const taskIds = inProgressTasks.map((task) => task.id);
+	return Object.freeze({
+		action: "error",
+		code: "E_BUILD_RESULT_PENDING",
+		phase: "BUILD",
+		message: `Wave ${wave} still has in-progress task result(s) pending for taskIds [${taskIds.join(", ")}]. Wait for the typed result envelope and pass it back to oc_orchestrate.`,
+		progress: `Wave ${wave} — waiting for typed result(s) for taskIds [${taskIds.join(", ")}]`,
+		_stateUpdates: {
+			...(updatedTasks ? { tasks: [...updatedTasks] } : {}),
+			buildProgress: {
+				...buildProgress,
+				currentWave: wave,
+				currentTask: buildProgress.currentTask ?? inProgressTasks[0]?.id ?? null,
+			},
+		},
+	} satisfies DispatchResult);
+}
+
+export function markTasksInProgress(
+	tasks: readonly Task[],
+	taskIds: readonly number[],
+): readonly Task[] {
+	const idSet = new Set(taskIds);
+	return tasks.map((t) => (idSet.has(t.id) ? { ...t, status: "IN_PROGRESS" as const } : t));
+}
+
+export async function buildTaskPrompt(task: Task, artifactDir: string): Promise<string> {
+	const planRef = getArtifactRef(artifactDir, "PLAN", "tasks.json");
+	const planFallbackRef = getArtifactRef(artifactDir, "PLAN", "tasks.md");
+	const designRef = getArtifactRef(artifactDir, "ARCHITECT", "design.md");
+	const planPath = (await fileExists(planRef)) ? planRef : planFallbackRef;
+	return [
+		`Implement task ${task.id}: ${task.title}.`,
+		`Reference the plan at ${planPath}`,
+		`and architecture at ${designRef}.`,
+		`If a CLAUDE.md file exists in the project root, read it for project-specific conventions.`,
+		`Check ~/.config/opencode/skills/coding-standards/SKILL.md for coding standards.`,
+		`Report completion when done.`,
+	].join(" ");
+}
+
+export function markTaskDone(tasks: readonly Task[], taskId: number): readonly Task[] {
+	return tasks.map((t) => (t.id === taskId ? { ...t, status: "DONE" as const } : t));
+}
+
+export function isWaveComplete(
+	waveMap: ReadonlyMap<number, readonly Task[]>,
+	wave: number,
+): boolean {
+	const tasks = waveMap.get(wave) ?? [];
+	return tasks.every((t) => t.status === "DONE");
+}
+
+export function hasCriticalFindings(resultStr: string): boolean {
+	try {
+		const parsed = JSON.parse(resultStr);
+		if (parsed.severity === "CRITICAL") return true;
+		const hasCritical = (arr: unknown[]): boolean =>
+			arr.some(
+				(f: unknown) =>
+					typeof f === "object" &&
+					f !== null &&
+					"severity" in f &&
+					(f as { severity: string }).severity === "CRITICAL",
+			);
+		if (Array.isArray(parsed.findings)) {
+			return hasCritical(parsed.findings);
+		}
+		if (parsed.report?.findings && Array.isArray(parsed.report.findings)) {
+			return hasCritical(parsed.report.findings);
+		}
+		return false;
+	} catch {
+		return false;
+	}
+}
+
+export { MAX_STRIKES };

package/src/orchestrator/handlers/build.ts

@@ -1,118 +1,22 @@
 import { sanitizeTemplateContent } from "../../review/sanitize";
-import { fileExists } from "../../utils/fs-helpers";
 import { getArtifactRef } from "../artifacts";
 import { groupByWave } from "../plan";
-import type { BuildProgress, Task } from "../types";
 import { assignWaves } from "../wave-assigner";
+import {
+	buildPendingResultError,
+	buildTaskPrompt,
+	findCurrentWave,
+	findInProgressTasks,
+	findPendingTasks,
+	hasCriticalFindings,
+	isWaveComplete,
+	MAX_STRIKES,
+	markTaskDone,
+	markTasksInProgress,
+} from "./build-utils";
 import type { DispatchResult, PhaseHandler, PhaseHandlerContext } from "./types";
 import { AGENT_NAMES } from "./types";
 
-const MAX_STRIKES = 3;
-
-/**
- * Find the first wave number that has PENDING tasks.
- */
-function findCurrentWave(waveMap: ReadonlyMap<number, readonly Task[]>): number | null {
-	const sortedWaves = [...waveMap.keys()].sort((a, b) => a - b);
-	for (const wave of sortedWaves) {
-		const tasks = waveMap.get(wave) ?? [];
-		if (tasks.some((t) => t.status === "PENDING" || t.status === "IN_PROGRESS")) {
-			return wave;
-		}
-	}
-	return null;
-}
-
-/**
- * Get pending tasks for a specific wave.
- */
-function findPendingTasks(
-	waveMap: ReadonlyMap<number, readonly Task[]>,
-	wave: number,
-): readonly Task[] {
-	const tasks = waveMap.get(wave) ?? [];
-	return tasks.filter((t) => t.status === "PENDING");
-}
-
-/**
- * Get in-progress tasks for a specific wave.
- */
-function findInProgressTasks(
-	waveMap: ReadonlyMap<number, readonly Task[]>,
-	wave: number,
-): readonly Task[] {
-	const tasks = waveMap.get(wave) ?? [];
-	return tasks.filter((t) => t.status === "IN_PROGRESS");
-}
-
-/**
- * Mark multiple tasks as IN_PROGRESS immutably.
- */
-function markTasksInProgress(tasks: readonly Task[], taskIds: readonly number[]): readonly Task[] {
-	const idSet = new Set(taskIds);
-	return tasks.map((t) => (idSet.has(t.id) ? { ...t, status: "IN_PROGRESS" as const } : t));
-}
-
-/**
- * Build a prompt for a single task dispatch.
- */
-async function buildTaskPrompt(task: Task, artifactDir: string): Promise<string> {
-	const planRef = getArtifactRef(artifactDir, "PLAN", "tasks.json");
-	const planFallbackRef = getArtifactRef(artifactDir, "PLAN", "tasks.md");
-	const designRef = getArtifactRef(artifactDir, "ARCHITECT", "design.md");
-	const planPath = (await fileExists(planRef)) ? planRef : planFallbackRef;
-	return [
-		`Implement task ${task.id}: ${task.title}.`,
-		`Reference the plan at ${planPath}`,
-		`and architecture at ${designRef}.`,
-		`If a CLAUDE.md file exists in the project root, read it for project-specific conventions.`,
-		`Check ~/.config/opencode/skills/coding-standards/SKILL.md for coding standards.`,
-		`Report completion when done.`,
-	].join(" ");
-}
-
-/**
- * Mark a task as DONE immutably and return the updated tasks array.
- */
-function markTaskDone(tasks: readonly Task[], taskId: number): readonly Task[] {
-	return tasks.map((t) => (t.id === taskId ? { ...t, status: "DONE" as const } : t));
-}
-
-/**
- * Check whether all tasks in a given wave are DONE.
- */
-function isWaveComplete(waveMap: ReadonlyMap<number, readonly Task[]>, wave: number): boolean {
-	const tasks = waveMap.get(wave) ?? [];
-	return tasks.every((t) => t.status === "DONE");
-}
-
-/**
- * Parse review result to check for CRITICAL findings.
- */
-function hasCriticalFindings(resultStr: string): boolean {
-	try {
-		const parsed = JSON.parse(resultStr);
-		if (parsed.severity === "CRITICAL") return true;
-		const hasCritical = (arr: unknown[]): boolean =>
-			arr.some(
-				(f: unknown) =>
-					typeof f === "object" &&
-					f !== null &&
-					"severity" in f &&
-					(f as { severity: string }).severity === "CRITICAL",
-			);
-		if (Array.isArray(parsed.findings)) {
-			return hasCritical(parsed.findings);
-		}
-		if (parsed.report?.findings && Array.isArray(parsed.report.findings)) {
-			return hasCritical(parsed.report.findings);
-		}
-		return false;
-	} catch {
-		return false;
-	}
-}
-
 export const handleBuild: PhaseHandler = async (
 	state,
 	artifactDir,
@@ -122,7 +26,6 @@ export const handleBuild: PhaseHandler = async (
 	const { tasks, buildProgress } = state;
 	const resultText = context?.envelope.payload.text ?? result;
 
-	// Edge case: no tasks
 	if (tasks.length === 0) {
 		return Object.freeze({
 			action: "error",
@@ -131,7 +34,6 @@ export const handleBuild: PhaseHandler = async (
 		} satisfies DispatchResult);
 	}
 
-	// Edge case: strike count exceeded
 	if (buildProgress.strikeCount > MAX_STRIKES && buildProgress.reviewPending && resultText) {
 		return Object.freeze({
 			action: "error",
@@ -141,7 +43,6 @@ export const handleBuild: PhaseHandler = async (
 		} satisfies DispatchResult);
 	}
 
-	// Auto-assign waves from depends_on declarations (D-15)
 	let effectiveTasks = tasks;
 	const hasDependencies = tasks.some((t) => t.depends_on && t.depends_on.length > 0);
 	if (hasDependencies) {
@@ -163,7 +64,6 @@ export const handleBuild: PhaseHandler = async (
 		}
 	}
 
-	// Check if all remaining tasks are BLOCKED (cycles or MAX_TASKS cap)
 	const nonDoneTasks = effectiveTasks.filter((t) => t.status !== "DONE" && t.status !== "SKIPPED");
 	if (nonDoneTasks.length > 0 && nonDoneTasks.every((t) => t.status === "BLOCKED")) {
 		const blockedIds = nonDoneTasks.map((t) => t.id).join(", ");
@@ -192,10 +92,8 @@ export const handleBuild: PhaseHandler = async (
 		} satisfies DispatchResult);
 	}
 
-	// Case 1: Review pending + result provided -> process review outcome
 	if (buildProgress.reviewPending && resultText) {
 		if (hasCriticalFindings(resultText)) {
-			// Re-dispatch implementer with fix instructions
 			const safeResult = sanitizeTemplateContent(resultText).slice(0, 4000);
 			const prompt = [
 				`CRITICAL review findings detected. Fix the following issues:`,
@@ -214,13 +112,13 @@ export const handleBuild: PhaseHandler = async (
 				_stateUpdates: {
 					buildProgress: {
 						...buildProgress,
+						reviewPending: false,
 						strikeCount: buildProgress.strikeCount + 1,
 					},
 				},
 			} satisfies DispatchResult);
 		}
 
-		// No critical -> advance to next wave
 		const waveMap = groupByWave(effectiveTasks);
 		const nextWave = findCurrentWave(waveMap);
 
@@ -232,6 +130,7 @@ export const handleBuild: PhaseHandler = async (
 				_stateUpdates: {
 					buildProgress: {
 						...buildProgress,
+						currentTask: null,
 						reviewPending: false,
 					},
 				},
@@ -239,13 +138,18 @@ export const handleBuild: PhaseHandler = async (
 		}
 
 		const pendingTasks = findPendingTasks(waveMap, nextWave);
-		const updatedProgress: BuildProgress = {
+		const inProgressTasks = findInProgressTasks(waveMap, nextWave);
+		const updatedProgress = {
 			...buildProgress,
 			reviewPending: false,
 			currentWave: nextWave,
 		};
 
-		if (pendingTasks.length === 1) {
+		if (pendingTasks.length === 0 && inProgressTasks.length > 0) {
+			return buildPendingResultError(nextWave, inProgressTasks, updatedProgress);
+		}
+
+		if (pendingTasks.length > 0) {
 			const task = pendingTasks[0];
 			const prompt = await buildTaskPrompt(task, artifactDir);
 			return Object.freeze({
@@ -257,62 +161,24 @@ export const handleBuild: PhaseHandler = async (
 				taskId: task.id,
 				progress: `Wave ${nextWave} — task ${task.id}`,
 				_stateUpdates: {
+					tasks: [...markTasksInProgress(effectiveTasks, [task.id])],
 					buildProgress: { ...updatedProgress, currentTask: task.id },
 				},
 			} satisfies DispatchResult);
 		}
 
-		const dispatchedIds = pendingTasks.map((t) => t.id);
-		const promptsByTaskId = new Map<number, string>();
-		await Promise.all(
-			pendingTasks.map(async (task) => {
-				promptsByTaskId.set(task.id, await buildTaskPrompt(task, artifactDir));
-			}),
-		);
 		return Object.freeze({
-			action: "dispatch_multi",
-			agents: pendingTasks.map((task) => ({
-				agent: AGENT_NAMES.BUILD,
-				prompt: promptsByTaskId.get(task.id) ?? "",
-				taskId: task.id,
-				resultKind: "task_completion" as const,
-			})),
+			action: "error",
+			code: "E_BUILD_NO_DISPATCHABLE_TASK",
 			phase: "BUILD",
-			progress: `Wave ${nextWave} — ${pendingTasks.length} concurrent tasks`,
-			_stateUpdates: {
-				tasks: [...markTasksInProgress(effectiveTasks, dispatchedIds)],
-				buildProgress: { ...updatedProgress, currentTask: null },
-			},
+			message: `Wave ${nextWave} has no dispatchable pending tasks.`,
 		} satisfies DispatchResult);
 	}
 
-	// Case 2: Result provided + not review pending -> mark task done
-	// For dispatch_multi, currentTask may be null — find the first IN_PROGRESS task instead
-	const hasTypedContext = context !== undefined && !context.legacy;
+	const hasTypedContext = context !== undefined;
 	const isTaskCompletion = hasTypedContext && context.envelope.kind === "task_completion";
-	const isLegacyContext = context !== undefined && context.legacy;
-	const taskToComplete = isTaskCompletion
-		? context.envelope.taskId
-		: hasTypedContext
-			? buildProgress.currentTask
-			: (buildProgress.currentTask ??
-				effectiveTasks.find((t) => t.status === "IN_PROGRESS")?.id ??
-				null);
+	const taskToComplete = isTaskCompletion ? context.envelope.taskId : buildProgress.currentTask;
 
-	if (
-		resultText &&
-		!buildProgress.reviewPending &&
-		isLegacyContext &&
-		buildProgress.currentTask === null
-	) {
-		return Object.freeze({
-			action: "error",
-			code: "E_BUILD_TASK_ID_REQUIRED",
-			phase: "BUILD",
-			message:
-				"Legacy BUILD result cannot be attributed when currentTask is null. Submit typed envelope with taskId.",
-		} satisfies DispatchResult);
-	}
 	if (resultText && !buildProgress.reviewPending && taskToComplete === null) {
 		return Object.freeze({
 			action: "error",
@@ -337,7 +203,6 @@ export const handleBuild: PhaseHandler = async (
 		const currentWave = buildProgress.currentWave ?? 1;
 
 		if (isWaveComplete(waveMap, currentWave)) {
-			// Wave complete -> trigger review (same for final wave or intermediate)
 			return Object.freeze({
 				action: "dispatch",
 				agent: AGENT_NAMES.REVIEW,
@@ -349,14 +214,13 @@ export const handleBuild: PhaseHandler = async (
 					tasks: [...updatedTasks],
 					buildProgress: {
 						...buildProgress,
-						currentTask: null,
+						currentTask: taskToComplete,
 						reviewPending: true,
 					},
 				},
 			} satisfies DispatchResult);
 		}
 
-		// Wave not complete -> dispatch next pending task or wait for in-progress
 		const pendingInWave = findPendingTasks(waveMap, currentWave);
 		if (pendingInWave.length > 0) {
 			const next = pendingInWave[0];
@@ -370,7 +234,7 @@ export const handleBuild: PhaseHandler = async (
 				taskId: next.id,
 				progress: `Wave ${currentWave} — task ${next.id}`,
 				_stateUpdates: {
-					tasks: [...updatedTasks],
+					tasks: [...markTasksInProgress(updatedTasks, [next.id])],
 					buildProgress: {
 						...buildProgress,
 						currentTask: next.id,
@@ -379,33 +243,16 @@ export const handleBuild: PhaseHandler = async (
 			} satisfies DispatchResult);
 		}
 
-		// No pending tasks but wave not complete — other tasks are still IN_PROGRESS
 		const inProgressInWave = findInProgressTasks(waveMap, currentWave);
 		if (inProgressInWave.length > 0) {
-			return Object.freeze({
-				action: "dispatch",
-				agent: AGENT_NAMES.BUILD,
-				prompt: `Wave ${currentWave} has ${inProgressInWave.length} task(s) still in progress. Continue working on remaining tasks.`,
-				phase: "BUILD",
-				resultKind: "phase_output",
-				progress: `Wave ${currentWave} — waiting for ${inProgressInWave.length} in-progress task(s)`,
-				_stateUpdates: {
-					tasks: [...updatedTasks],
-					buildProgress: {
-						...buildProgress,
-						currentTask: null,
-					},
-				},
-			} satisfies DispatchResult);
+			return buildPendingResultError(currentWave, inProgressInWave, buildProgress, updatedTasks);
 		}
 	}
 
-	// Case 3: No result (first call or resume) -> find first pending wave
 	const waveMap = groupByWave(effectiveTasks);
 	const currentWave = findCurrentWave(waveMap);
 
 	if (currentWave === null) {
-		// All tasks already DONE
 		return Object.freeze({
 			action: "complete",
 			phase: "BUILD",
@@ -417,27 +264,10 @@ export const handleBuild: PhaseHandler = async (
 	const inProgressTasks = findInProgressTasks(waveMap, currentWave);
 
 	if (pendingTasks.length === 0 && inProgressTasks.length > 0) {
-		// Wave has only IN_PROGRESS tasks (e.g., resume after dispatch_multi).
-		// Return a dispatch instruction so the orchestrator knows work is underway.
-		return Object.freeze({
-			action: "dispatch",
-			agent: AGENT_NAMES.BUILD,
-			prompt: `Resume: wave ${currentWave} has ${inProgressTasks.length} task(s) still in progress. Wait for agent results and pass them back.`,
-			phase: "BUILD",
-			resultKind: "phase_output",
-			progress: `Wave ${currentWave} — waiting for ${inProgressTasks.length} in-progress task(s)`,
-			_stateUpdates: {
-				buildProgress: {
-					...buildProgress,
-					currentWave,
-					currentTask: null,
-				},
-			},
-		} satisfies DispatchResult);
+		return buildPendingResultError(currentWave, inProgressTasks, buildProgress);
 	}
 
 	if (pendingTasks.length === 0) {
-		// All tasks in all waves DONE (findCurrentWave already checked PENDING + IN_PROGRESS)
 		return Object.freeze({
 			action: "complete",
 			phase: "BUILD",
@@ -457,6 +287,7 @@ export const handleBuild: PhaseHandler = async (
 			taskId: task.id,
 			progress: `Wave ${currentWave} — task ${task.id}`,
 			_stateUpdates: {
+				tasks: [...markTasksInProgress(effectiveTasks, [task.id])],
 				buildProgress: {
 					...buildProgress,
 					currentTask: task.id,
@@ -466,29 +297,21 @@ export const handleBuild: PhaseHandler = async (
 		} satisfies DispatchResult);
 	}
 
-	// Multiple pending tasks in wave -> dispatch_multi
-	const dispatchedIds = pendingTasks.map((t) => t.id);
-	const promptsByTaskId = new Map<number, string>();
-	await Promise.all(
-		pendingTasks.map(async (task) => {
-			promptsByTaskId.set(task.id, await buildTaskPrompt(task, artifactDir));
-		}),
-	);
+	const task = pendingTasks[0];
+	const prompt = await buildTaskPrompt(task, artifactDir);
 	return Object.freeze({
-		action: "dispatch_multi",
-		agents: pendingTasks.map((task) => ({
-			agent: AGENT_NAMES.BUILD,
-			prompt: promptsByTaskId.get(task.id) ?? "",
-			taskId: task.id,
-			resultKind: "task_completion" as const,
-		})),
+		action: "dispatch",
+		agent: AGENT_NAMES.BUILD,
+		prompt,
 		phase: "BUILD",
-		progress: `Wave ${currentWave} — ${pendingTasks.length} concurrent tasks`,
+		resultKind: "task_completion",
+		taskId: task.id,
+		progress: `Wave ${currentWave} — task ${task.id}`,
 		_stateUpdates: {
-			tasks: [...markTasksInProgress(effectiveTasks, dispatchedIds)],
+			tasks: [...markTasksInProgress(effectiveTasks, [task.id])],
 			buildProgress: {
 				...buildProgress,
-				currentTask: null,
+				currentTask: task.id,
 				currentWave,
 			},
 		},

package/src/orchestrator/handlers/retrospective.ts

@@ -1,4 +1,4 @@
-import { join } from "node:path";
+import { getProjectRootFromArtifactDir } from "../../utils/paths";
 import { getArtifactRef, PHASE_ARTIFACTS } from "../artifacts";
 import {
 	createEmptyLessonMemory,
@@ -81,7 +81,7 @@ export const handleRetrospective: PhaseHandler = async (_state, artifactDir, res
 
 		// Persist lessons to memory (best-effort: failure should not mark pipeline as FAILED)
 		try {
-			const projectRoot = join(artifactDir, "..");
+			const projectRoot = getProjectRootFromArtifactDir(artifactDir);
 			const existing = await loadLessonMemory(projectRoot);
 			const memory = existing ?? createEmptyLessonMemory();
 			const merged = [...memory.lessons, ...valid];

package/src/orchestrator/handlers/types.ts

@@ -40,7 +40,6 @@ export interface DispatchResult {
 
 export interface PhaseHandlerContext {
 	readonly envelope: ResultEnvelope;
-	readonly legacy: boolean;
 }
 
 export type PhaseHandler = (

package/src/orchestrator/lesson-memory.ts

@@ -1,8 +1,9 @@
 /**
  * Per-project lesson memory persistence.
  *
- * Stores lessons extracted from pipeline runs at
- * {projectRoot}/.opencode-autopilot/lesson-memory.json
+ * Stores lessons extracted from pipeline runs in the project kernel,
+ * with {projectRoot}/.opencode-autopilot/lesson-memory.json kept as a
+ * compatibility mirror/export during the Phase 4 migration window.
  *
  * Memory is pruned on load to remove stale entries (>90 days)
  * and cap at 50 lessons. All writes are atomic (tmp file + rename)
@@ -12,7 +13,9 @@
 import { randomBytes } from "node:crypto";
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { loadLessonMemoryFromKernel, saveLessonMemoryToKernel } from "../kernel/repository";
 import { ensureDir, isEnoentError } from "../utils/fs-helpers";
+import { getProjectArtifactDir } from "../utils/paths";
 import { lessonMemorySchema } from "./lesson-schemas";
 import type { LessonMemory } from "./lesson-types";
 
@@ -21,6 +24,7 @@ export type { LessonMemory };
 const LESSON_FILE = "lesson-memory.json";
 const MAX_LESSONS = 50;
 const NINETY_DAYS_MS = 90 * 24 * 60 * 60 * 1000;
+let legacyLessonMemoryMirrorWarned = false;
 
 /**
  * Create a valid empty lesson memory object.
@@ -41,6 +45,11 @@ export function createEmptyLessonMemory(): LessonMemory {
  * Prunes on load to remove stale entries and cap storage.
  */
 export async function loadLessonMemory(projectRoot: string): Promise<LessonMemory | null> {
+	const kernelMemory = loadLessonMemoryFromKernel(getProjectArtifactDir(projectRoot));
+	if (kernelMemory !== null) {
+		return pruneLessons(kernelMemory);
+	}
+
 	const memoryPath = join(projectRoot, ".opencode-autopilot", LESSON_FILE);
 	try {
 		const raw = await readFile(memoryPath, "utf-8");
@@ -51,7 +60,9 @@ export async function loadLessonMemory(projectRoot: string): Promise<LessonMemor
 			...parsed,
 			lessons: Array.isArray(parsed.lessons) ? parsed.lessons : [],
 		});
-		return lessonMemorySchema.parse(pruned);
+		const validated = lessonMemorySchema.parse(pruned);
+		saveLessonMemoryToKernel(getProjectArtifactDir(projectRoot), validated);
+		return validated;
 	} catch (error: unknown) {
 		if (isEnoentError(error)) {
 			return null;
@@ -74,12 +85,21 @@ export async function loadLessonMemory(projectRoot: string): Promise<LessonMemor
  */
 export async function saveLessonMemory(memory: LessonMemory, projectRoot: string): Promise<void> {
 	const validated = lessonMemorySchema.parse(memory);
-	const dir = join(projectRoot, ".opencode-autopilot");
-	await ensureDir(dir);
-	const memoryPath = join(dir, LESSON_FILE);
-	const tmpPath = `${memoryPath}.tmp.${randomBytes(8).toString("hex")}`;
-	await writeFile(tmpPath, JSON.stringify(validated, null, 2), "utf-8");
-	await rename(tmpPath, memoryPath);
+	saveLessonMemoryToKernel(getProjectArtifactDir(projectRoot), validated);
+
+	try {
+		const dir = join(projectRoot, ".opencode-autopilot");
+		await ensureDir(dir);
+		const memoryPath = join(dir, LESSON_FILE);
+		const tmpPath = `${memoryPath}.tmp.${randomBytes(8).toString("hex")}`;
+		await writeFile(tmpPath, JSON.stringify(validated, null, 2), "utf-8");
+		await rename(tmpPath, memoryPath);
+	} catch (error: unknown) {
+		if (!legacyLessonMemoryMirrorWarned) {
+			legacyLessonMemoryMirrorWarned = true;
+			console.warn("[opencode-autopilot] lesson-memory.json mirror write failed:", error);
+		}
+	}
 }
 
 /**
@@ -90,8 +110,13 @@ export async function saveLessonMemory(memory: LessonMemory, projectRoot: string
  * - Sort remaining by extractedAt descending (newest first)
  * - Cap at 50 lessons
  */
-export function pruneLessons(memory: LessonMemory): LessonMemory {
-	const now = Date.now();
+import { systemTimeProvider, type TimeProvider } from "../scoring/time-provider";
+
+export function pruneLessons(
+	memory: LessonMemory,
+	timeProvider: TimeProvider = systemTimeProvider,
+): LessonMemory {
+	const now = timeProvider.now();
 
 	// Filter out stale lessons (>90 days)
 	const fresh = memory.lessons.filter(