@kodrunhq/opencode-autopilot 1.16.0 → 1.18.0

package/src/memory/retrieval.ts

@@ -13,6 +13,7 @@
  */
 
 import type { Database } from "bun:sqlite";
+import { getLogger } from "../logging/domains";
 import { CHARS_PER_TOKEN, DEFAULT_INJECTION_BUDGET } from "./constants";
 import { getMemoryDb } from "./database";
 import { computeRelevanceScore } from "./decay";
@@ -25,6 +26,8 @@ import {
 } from "./repository";
 import type { Observation, Preference } from "./types";
 
+const logger = getLogger("memory", "retrieval");
+
 /**
  * An observation with its computed relevance score.
  */
@@ -194,8 +197,9 @@ export function retrieveMemoryContext(
 				updateAccessCount(id, db);
 			}
 			resolvedDb.run("COMMIT");
-		} catch {
+		} catch (err) {
 			// best-effort — access count update is non-critical
+			logger.warn("access count update failed", { error: String(err) });
 		}
 	}
 

package/src/observability/context-display.ts

@@ -0,0 +1,8 @@
+export function getContextUtilizationString(usedTokens: number, maxTokens: number): string {
+	const safeMaxTokens = Math.max(0, maxTokens);
+	const safeUsedTokens = Math.max(0, usedTokens);
+	const utilization =
+		safeMaxTokens > 0 ? Math.min(100, Math.round((safeUsedTokens / safeMaxTokens) * 100)) : 0;
+
+	return `[${utilization}% used] ${safeUsedTokens} / ${safeMaxTokens} tokens`;
+}

package/src/observability/event-handlers.ts

@@ -12,12 +12,17 @@
  * @module
  */
 
+import { getLogger } from "../logging/domains";
 import { classifyErrorType, getErrorMessage } from "../orchestrator/fallback/error-classifier";
+import { generateSessionSummary } from "../ux/session-summary";
+import { getContextUtilizationString } from "./context-display";
 import type { ContextMonitor } from "./context-monitor";
 import { emitErrorEvent, emitToolCompleteEvent } from "./event-emitter";
 import type { ObservabilityEvent, SessionEventStore, SessionEvents } from "./event-store";
 import { accumulateTokensFromMessage, createEmptyTokenAggregate } from "./token-tracker";
 
+const logger = getLogger("session", "event-handlers");
+
 /**
  * Dependencies for the observability event handler.
  */
@@ -161,7 +166,6 @@ export function createObservabilityEventHandler(deps: ObservabilityHandlerDeps)
 					// Check context utilization
 					const utilResult = contextMonitor.processMessage(sessionId, info.tokens.input);
 					if (utilResult.shouldWarn) {
-						const pct = Math.round(utilResult.utilization * 100);
 						// Append context_warning event
 						const warningEvent: ObservabilityEvent = Object.freeze({
 							type: "context_warning" as const,
@@ -176,10 +180,14 @@ export function createObservabilityEventHandler(deps: ObservabilityHandlerDeps)
 						// Fire toast (per D-35)
 						showToast(
 							"Context Warning",
-							`Context at ${pct}% -- consider compacting`,
+							getContextUtilizationString(info.tokens.input, 200000),
 							"warning",
 						).catch((err) => {
-							console.error("[opencode-autopilot]", err);
+							logger.error("showToast failed for context warning", {
+								operation: "context_warning",
+								sessionId,
+								error: String(err),
+							});
 						});
 					}
 				}
@@ -194,7 +202,11 @@ export function createObservabilityEventHandler(deps: ObservabilityHandlerDeps)
 				const sessionData = eventStore.getUnpersistedSession(sessionId);
 				if (sessionData && sessionData.events.length > 0) {
 					writeSessionLog(sessionData).catch((err) => {
-						console.error("[opencode-autopilot]", err);
+						logger.error("writeSessionLog failed on session.idle", {
+							operation: "session_end",
+							sessionId,
+							error: String(err),
+						});
 					});
 				}
 				return;
@@ -212,11 +224,33 @@ export function createObservabilityEventHandler(deps: ObservabilityHandlerDeps)
 					totalCost: 0,
 				});
 
+				const summary = generateSessionSummary(eventStore.getSession(sessionId), null);
+				logger.info(`Session ended summary:\n${summary}`, {
+					operation: "session_end",
+					sessionId,
+				});
+
+				void showToast(
+					"Session ended",
+					"Run /oc_summary to view the session summary.",
+					"info",
+				).catch((err) => {
+					logger.error("showToast failed for session end", {
+						operation: "session_end",
+						sessionId,
+						error: String(err),
+					});
+				});
+
 				// Final flush — session is done, remove from store
 				const sessionData = eventStore.flush(sessionId);
 				if (sessionData && sessionData.events.length > 0) {
 					writeSessionLog(sessionData).catch((err) => {
-						console.error("[opencode-autopilot]", err);
+						logger.error("writeSessionLog failed on session.deleted", {
+							operation: "session_end",
+							sessionId,
+							error: String(err),
+						});
 					});
 				}
 
@@ -242,7 +276,11 @@ export function createObservabilityEventHandler(deps: ObservabilityHandlerDeps)
 				const sessionData = eventStore.getUnpersistedSession(sessionId);
 				if (sessionData && sessionData.events.length > 0) {
 					writeSessionLog(sessionData).catch((err) => {
-						console.error("[opencode-autopilot]", err);
+						logger.error("writeSessionLog failed on session.compacted", {
+							operation: "compacted",
+							sessionId,
+							error: String(err),
+						});
 					});
 				}
 				return;

package/src/observability/forensic-log.ts

@@ -40,10 +40,18 @@ function toProjectRootFromArtifactDir(artifactDir: string): string {
 }
 
 function appendValidatedForensicEvent(artifactDir: string, event: ForensicEvent): void {
-	appendForensicEventsToKernel(artifactDir, [event]);
+	mkdirSync(artifactDir, { recursive: true });
+
+	try {
+		appendForensicEventsToKernel(artifactDir, [event]);
+	} catch (kernelError) {
+		if (!forensicWriteWarned) {
+			forensicWriteWarned = true;
+			console.warn("[opencode-autopilot] forensic log write failed:", kernelError);
+		}
+	}
 
 	try {
-		mkdirSync(artifactDir, { recursive: true });
 		const logPath = join(artifactDir, FORENSIC_LOG_FILE);
 		appendFileSync(logPath, `${JSON.stringify(event)}\n`, "utf-8");
 	} catch (mirrorError) {

package/src/observability/forensic-schemas.ts

@@ -19,9 +19,17 @@ export const forensicEventTypeSchema = z.enum([
 	"context_warning",
 	"tool_complete",
 	"compacted",
+	"info",
+	"debug",
 ]);
 
-export const forensicEventDomainSchema = z.enum(["session", "orchestrator", "contract"]);
+export const forensicEventDomainSchema = z.enum([
+	"session",
+	"orchestrator",
+	"contract",
+	"system",
+	"review",
+]);
 
 export type JsonValue =
 	| null

package/src/observability/log-reader.ts

@@ -39,9 +39,13 @@ export interface EventSearchFilters {
 	readonly after?: string;
 	readonly before?: string;
 	readonly domain?: string;
+	readonly subsystem?: string;
+	/** Matches against event.type for semantic severity (e.g. "error", "warning"),
+	 *  or against event.payload.severity / event.payload.level for explicit severity fields. */
+	readonly severity?: string;
 }
 
-function isSessionForProject(event: Readonly<ForensicEvent>, sessionId: string): boolean {
+function _isSessionForProject(event: Readonly<ForensicEvent>, sessionId: string): boolean {
 	return event.domain === "session" && event.sessionId === sessionId;
 }
 
@@ -164,6 +168,21 @@ export function searchEvents(
 		if (filters.domain && event.domain !== filters.domain) return false;
 		if (filters.after && event.timestamp <= filters.after) return false;
 		if (filters.before && event.timestamp >= filters.before) return false;
+		if (filters.subsystem) {
+			const subsystem = event.payload.subsystem;
+			if (typeof subsystem !== "string" || subsystem !== filters.subsystem) return false;
+		}
+		if (filters.severity) {
+			const payloadSeverity =
+				typeof event.payload.severity === "string"
+					? event.payload.severity
+					: typeof event.payload.level === "string"
+						? event.payload.level
+						: null;
+			const matchesSemantic = event.type === filters.severity;
+			const matchesPayload = payloadSeverity === filters.severity;
+			if (!matchesSemantic && !matchesPayload) return false;
+		}
 		return true;
 	});
 }

package/src/orchestrator/error-context.ts

@@ -0,0 +1,24 @@
+import type { PipelineState } from "./types";
+
+export function enrichErrorMessage(error: string, state: PipelineState): string {
+	const phase = state.currentPhase ?? "UNKNOWN";
+	const details: string[] = [];
+
+	if (
+		state.currentPhase === "BUILD" &&
+		state.buildProgress?.currentWave !== null &&
+		state.buildProgress?.currentWave !== undefined
+	) {
+		details.push(`wave ${state.buildProgress.currentWave}`);
+	}
+
+	if (state.buildProgress?.currentTask !== null && state.buildProgress?.currentTask !== undefined) {
+		const task = state.tasks.find((entry) => entry.id === state.buildProgress.currentTask);
+		details.push(
+			task ? `task ${task.id}: ${task.title}` : `task ${state.buildProgress.currentTask}`,
+		);
+	}
+
+	const context = details.length > 0 ? ` (${details.join(", ")})` : "";
+	return `Error in phase ${phase}${context}: ${error}`;
+}

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,142 +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");
-}
-
-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);
-}
-
-/**
- * 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,
@@ -146,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",
@@ -155,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",
@@ -165,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) {
@@ -187,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(", ");
@@ -216,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:`,
@@ -245,7 +119,6 @@ export const handleBuild: PhaseHandler = async (
 			} satisfies DispatchResult);
 		}
 
-		// No critical -> advance to next wave
 		const waveMap = groupByWave(effectiveTasks);
 		const nextWave = findCurrentWave(waveMap);
 
@@ -266,7 +139,7 @@ export const handleBuild: PhaseHandler = async (
 
 		const pendingTasks = findPendingTasks(waveMap, nextWave);
 		const inProgressTasks = findInProgressTasks(waveMap, nextWave);
-		const updatedProgress: BuildProgress = {
+		const updatedProgress = {
 			...buildProgress,
 			reviewPending: false,
 			currentWave: nextWave,
@@ -302,7 +175,6 @@ export const handleBuild: PhaseHandler = async (
 		} satisfies DispatchResult);
 	}
 
-	// Case 2: Result provided + not review pending -> mark task done
 	const hasTypedContext = context !== undefined;
 	const isTaskCompletion = hasTypedContext && context.envelope.kind === "task_completion";
 	const taskToComplete = isTaskCompletion ? context.envelope.taskId : buildProgress.currentTask;
@@ -331,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,
@@ -350,7 +221,6 @@ export const handleBuild: PhaseHandler = async (
 			} 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];
@@ -373,19 +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 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",
@@ -401,7 +268,6 @@ export const handleBuild: PhaseHandler = async (
 	}
 
 	if (pendingTasks.length === 0) {
-		// All tasks in all waves DONE (findCurrentWave already checked PENDING + IN_PROGRESS)
 		return Object.freeze({
 			action: "complete",
 			phase: "BUILD",
@@ -431,7 +297,6 @@ export const handleBuild: PhaseHandler = async (
 		} satisfies DispatchResult);
 	}
 
-	// Multiple pending tasks in wave -> dispatch only the next task sequentially.
 	const task = pendingTasks[0];
 	const prompt = await buildTaskPrompt(task, artifactDir);
 	return Object.freeze({

package/src/orchestrator/handlers/retrospective.ts

@@ -1,4 +1,3 @@
-import { join } from "node:path";
 import { getProjectRootFromArtifactDir } from "../../utils/paths";
 import { getArtifactRef, PHASE_ARTIFACTS } from "../artifacts";
 import {

package/src/orchestrator/lesson-memory.ts

@@ -110,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(