@kodrunhq/opencode-autopilot 1.16.0 → 1.18.0

package/src/orchestrator/orchestration-logger.ts

@@ -1,4 +1,6 @@
-import { appendForensicEventForArtifactDir } from "../observability/forensic-log";
+import { getLogger } from "../logging/domains";
+import { createForensicSinkForArtifactDir } from "../logging/forensic-writer";
+import type { LogLevel } from "../logging/types";
 
 export interface OrchestrationEvent {
 	readonly timestamp: string;
@@ -16,39 +18,52 @@ export interface OrchestrationEvent {
 	readonly payload?: Record<string, string | number | boolean | null>;
 }
 
-/**
- * Append an orchestration event to the project-local JSONL log.
- * Uses synchronous append to survive crashes. Best-effort — errors are swallowed.
- */
+function resolveOperation(event: OrchestrationEvent): string {
+	if (event.action === "dispatch") return "dispatch";
+	if (event.action === "dispatch_multi") return "dispatch_multi";
+	if (event.action === "complete") return "complete";
+	if (event.action === "loop_detected") return "loop_detected";
+	if (event.action === "error" && event.code?.startsWith("E_")) return "warning";
+	return "error";
+}
+
 export function logOrchestrationEvent(artifactDir: string, event: OrchestrationEvent): void {
-	appendForensicEventForArtifactDir(artifactDir, {
-		timestamp: event.timestamp,
-		domain: event.action === "error" && event.code?.startsWith("E_") ? "contract" : "orchestrator",
-		runId: event.runId ?? null,
-		sessionId: event.sessionId ?? null,
-		phase: event.phase,
-		dispatchId: event.dispatchId ?? null,
-		taskId: event.taskId ?? null,
-		agent: event.agent ?? null,
-		type:
-			event.action === "dispatch"
-				? "dispatch"
-				: event.action === "dispatch_multi"
-					? "dispatch_multi"
-					: event.action === "complete"
-						? "complete"
-						: event.action === "loop_detected"
-							? "loop_detected"
-							: event.action === "error" && event.code?.startsWith("E_")
-								? "warning"
-								: "error",
-		code: event.code ?? null,
-		message: event.message ?? null,
-		payload: {
+	try {
+		const domain =
+			event.action === "error" && event.code?.startsWith("E_") ? "contract" : "orchestrator";
+		const operation = resolveOperation(event);
+		const level: LogLevel = event.action === "error" ? "ERROR" : "INFO";
+
+		const metadata = {
+			domain,
+			operation,
+			runId: event.runId ?? null,
+			sessionId: event.sessionId ?? null,
+			phase: event.phase,
+			dispatchId: event.dispatchId ?? null,
+			taskId: event.taskId ?? null,
+			agent: event.agent ?? null,
+			code: event.code ?? null,
 			action: event.action,
 			...(event.promptLength !== undefined ? { promptLength: event.promptLength } : {}),
 			...(event.attempt !== undefined ? { attempt: event.attempt } : {}),
 			...(event.payload ?? {}),
-		},
-	});
+		};
+
+		createForensicSinkForArtifactDir(artifactDir).write(
+			Object.freeze({
+				timestamp: event.timestamp,
+				level,
+				message: event.message ?? event.action,
+				metadata,
+			}),
+		);
+
+		const globalLogger = getLogger(domain);
+		if (event.action === "error") {
+			globalLogger.error(event.message ?? event.action, { operation, phase: event.phase });
+		} else {
+			globalLogger.info(event.message ?? event.action, { operation, phase: event.phase });
+		}
+	} catch {}
 }

package/src/orchestrator/progress.ts

@@ -0,0 +1,63 @@
+import { PHASES } from "./schemas";
+import type { PipelineState } from "./types";
+
+const PHASE_INDEX = Object.freeze(
+	Object.fromEntries(PHASES.map((phase, index) => [phase, index + 1])) as Record<
+		(typeof PHASES)[number],
+		number
+	>,
+);
+
+/**
+ * Generate a concise progress string for the user indicating current phase and progress.
+ * e.g., "[1/8] Analyzing requirements..." or "[6/8] Building wave 2 of 5..."
+ */
+export function getPhaseProgressString(state: PipelineState): string {
+	const currentPhase = state.currentPhase;
+	if (!currentPhase) {
+		if (state.status === "COMPLETED") return "[Done] Pipeline finished successfully.";
+		if (state.status === "FAILED") return "[Failed] Pipeline encountered an error.";
+		return `[0/${PHASES.length}] Not started`;
+	}
+
+	const phaseIndex = PHASE_INDEX[currentPhase];
+	const totalPhases = PHASES.length;
+	const baseProgress = `[${phaseIndex}/${totalPhases}]`;
+
+	switch (currentPhase) {
+		case "RECON":
+			return `${baseProgress} Researching feasibility and codebase context...`;
+		case "CHALLENGE":
+			return `${baseProgress} Evaluating architecture enhancements...`;
+		case "ARCHITECT":
+			return `${baseProgress} Designing technical architecture...`;
+		case "EXPLORE":
+			return `${baseProgress} Exploring implementation paths...`;
+		case "PLAN":
+			return `${baseProgress} Planning implementation waves...`;
+		case "BUILD": {
+			const progress = state.buildProgress;
+			if (!progress || progress.currentWave === null) {
+				return `${baseProgress} Starting build phase...`;
+			}
+
+			// Find max wave to show total waves
+			const allWaves = state.tasks.map((t) => t.wave);
+			const totalWaves = allWaves.length > 0 ? Math.max(...allWaves) : 0;
+			const totalTasksInWave = state.tasks.filter((t) => t.wave === progress.currentWave).length;
+
+			if (progress.reviewPending) {
+				return `${baseProgress} Reviewing wave ${progress.currentWave}/${totalWaves}...`;
+			}
+
+			// Just a sensible string for current build status
+			return `${baseProgress} Building wave ${progress.currentWave}/${totalWaves} (${totalTasksInWave} tasks)...`;
+		}
+		case "SHIP":
+			return `${baseProgress} Generating changelog and documentation...`;
+		case "RETROSPECTIVE":
+			return `${baseProgress} Extracting lessons learned...`;
+		default:
+			return `${baseProgress} Executing ${currentPhase}...`;
+	}
+}

package/src/review/memory.ts

@@ -12,6 +12,7 @@
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { loadReviewMemoryFromKernel, saveReviewMemoryToKernel } from "../kernel/repository";
+import { getLogger } from "../logging/domains";
 import { ensureDir, isEnoentError } from "../utils/fs-helpers";
 import { getProjectArtifactDir } from "../utils/paths";
 import { reviewMemorySchema } from "./schemas";
@@ -93,7 +94,9 @@ export async function saveReviewMemory(memory: ReviewMemory, projectRoot: string
 	} catch (error: unknown) {
 		if (!legacyReviewMemoryMirrorWarned) {
 			legacyReviewMemoryMirrorWarned = true;
-			console.warn("[opencode-autopilot] review-memory.json mirror write failed:", error);
+			getLogger("review", "memory").warn("review-memory.json mirror write failed", {
+				error: String(error),
+			});
 		}
 	}
 }
@@ -106,8 +109,13 @@ export async function saveReviewMemory(memory: ReviewMemory, projectRoot: string
  * - falsePositives: cap at 50 (keep newest by markedAt date)
  * - falsePositives: remove entries older than 30 days
  */
-export function pruneMemory(memory: ReviewMemory): ReviewMemory {
-	const now = Date.now();
+import { systemTimeProvider, type TimeProvider } from "../scoring/time-provider";
+
+export function pruneMemory(
+	memory: ReviewMemory,
+	timeProvider: TimeProvider = systemTimeProvider,
+): ReviewMemory {
+	const now = timeProvider.now();
 
 	// Prune false positives older than 30 days first, then cap
 	const freshFalsePositives = memory.falsePositives.filter(

package/src/review/parse-findings.ts

@@ -0,0 +1,116 @@
+import { reviewFindingSchema, reviewFindingsEnvelopeSchema } from "./schemas";
+import type { ReviewFinding, ReviewFindingsEnvelope } from "./types";
+
+export function parseTypedFindingsEnvelope(raw: string): ReviewFindingsEnvelope | null {
+	try {
+		const parsed = JSON.parse(raw);
+		return reviewFindingsEnvelopeSchema.parse(parsed);
+	} catch {
+		return null;
+	}
+}
+
+export function parseAgentFindings(raw: string, agentName: string): readonly ReviewFinding[] {
+	const findings: ReviewFinding[] = [];
+
+	const jsonStr = extractJson(raw);
+	if (jsonStr === null) return Object.freeze(findings);
+
+	try {
+		const cleanJson = sanitizeMalformedJson(jsonStr);
+		const parsed = JSON.parse(cleanJson);
+		const items = Array.isArray(parsed) ? parsed : parsed?.findings;
+
+		if (!Array.isArray(items)) return Object.freeze(findings);
+
+		for (const item of items) {
+			if (typeof item !== "object" || item === null) continue;
+
+			const problem = item.problem || item.description || item.issue || "No description provided";
+			const normalized = {
+				...item,
+				agent: item.agent || agentName,
+				severity: normalizeSeverity(item.severity),
+				domain: item.domain || "general",
+				title:
+					item.title || item.name || (problem ? String(problem).slice(0, 50) : "Untitled finding"),
+				file: item.file || item.path || item.filename || "unknown",
+				source: item.source || "phase1",
+				evidence: item.evidence || item.snippet || item.context || "No evidence provided",
+				problem: problem,
+				fix: item.fix || item.recommendation || item.solution || "No fix provided",
+			};
+
+			const result = reviewFindingSchema.safeParse(normalized);
+			if (result.success) {
+				findings.push(result.data);
+			}
+		}
+	} catch {
+		// JSON parse failed completely
+	}
+
+	return Object.freeze(findings);
+}
+
+function normalizeSeverity(sev: unknown): string {
+	if (typeof sev !== "string") return "LOW";
+	const upper = sev.toUpperCase();
+	if (["CRITICAL", "HIGH", "MEDIUM", "LOW"].includes(upper)) return upper;
+	return "LOW";
+}
+
+function sanitizeMalformedJson(json: string): string {
+	let clean = json;
+	// Remove trailing commas in objects and arrays
+	clean = clean.replace(/,\s*([}\]])/g, "$1");
+	// Replace unescaped newlines in strings (basic attempt)
+	// This is risky with regex but catches common LLM markdown mistakes
+	return clean;
+}
+
+export function extractJson(raw: string): string | null {
+	const codeBlockMatch = raw.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+	if (codeBlockMatch) {
+		return codeBlockMatch[1].trim();
+	}
+
+	const objectStart = raw.indexOf("{");
+	const arrayStart = raw.indexOf("[");
+
+	if (objectStart === -1 && arrayStart === -1) return null;
+
+	const start =
+		objectStart === -1
+			? arrayStart
+			: arrayStart === -1
+				? objectStart
+				: Math.min(objectStart, arrayStart);
+
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+	for (let i = start; i < raw.length; i++) {
+		const ch = raw[i];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (ch === "\\" && inString) {
+			escaped = true;
+			continue;
+		}
+		if (ch === '"') {
+			inString = !inString;
+			continue;
+		}
+		if (inString) continue;
+		if (ch === "{" || ch === "[") depth++;
+		if (ch === "}" || ch === "]") depth--;
+		if (depth === 0) {
+			return raw.slice(start, i + 1);
+		}
+	}
+
+	return null;
+}

package/src/review/pipeline.ts

@@ -18,8 +18,8 @@ import { buildCrossVerificationPrompts, condenseFinding } from "./cross-verifica
 const STAGE3_NAMES: ReadonlySet<string> = new Set(STAGE3_AGENTS.map((a) => a.name));
 
 import { buildFixInstructions, determineFixableFindings } from "./fix-cycle";
+import { parseAgentFindings, parseTypedFindingsEnvelope } from "./parse-findings";
 import { buildReport } from "./report";
-import { reviewFindingSchema, reviewFindingsEnvelopeSchema } from "./schemas";
 import type { ReviewFinding, ReviewFindingsEnvelope, ReviewReport, ReviewState } from "./types";
 
 export type { ReviewState };
@@ -38,112 +38,6 @@ export interface ReviewStageResult {
 	readonly parseMode?: "typed" | "legacy";
 }
 
-function parseTypedFindingsEnvelope(raw: string): ReviewFindingsEnvelope | null {
-	try {
-		const parsed = JSON.parse(raw);
-		return reviewFindingsEnvelopeSchema.parse(parsed);
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Parse findings from raw LLM output (which may contain markdown, prose, code blocks).
- *
- * Handles:
- * - {"findings": [...]} wrapper
- * - Raw array [{...}, ...]
- * - JSON embedded in markdown code blocks
- * - Prose with embedded JSON
- *
- * Sets agent field to agentName if missing from individual findings.
- * Validates each finding through reviewFindingSchema, discards invalid ones.
- */
-export function parseAgentFindings(raw: string, agentName: string): readonly ReviewFinding[] {
-	const findings: ReviewFinding[] = [];
-
-	// Try to extract JSON from the raw text
-	const jsonStr = extractJson(raw);
-	if (jsonStr === null) return Object.freeze(findings);
-
-	try {
-		const parsed = JSON.parse(jsonStr);
-		const items = Array.isArray(parsed) ? parsed : parsed?.findings;
-
-		if (!Array.isArray(items)) return Object.freeze(findings);
-
-		for (const item of items) {
-			// Set agent field if missing
-			const withAgent = item.agent ? item : { ...item, agent: agentName };
-			const result = reviewFindingSchema.safeParse(withAgent);
-			if (result.success) {
-				findings.push(result.data);
-			}
-		}
-	} catch {
-		// JSON parse failed -- return empty
-	}
-
-	return Object.freeze(findings);
-}
-
-/**
- * Extract the first JSON object or array from raw text.
- * Looks for:
- * 1. JSON inside markdown code blocks
- * 2. {"findings": ...} pattern
- * 3. Raw array [{...}]
- */
-function extractJson(raw: string): string | null {
-	// Try markdown code block extraction first
-	const codeBlockMatch = raw.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
-	if (codeBlockMatch) {
-		return codeBlockMatch[1].trim();
-	}
-
-	// Try to find {"findings": ...} or [{...}]
-	const objectStart = raw.indexOf("{");
-	const arrayStart = raw.indexOf("[");
-
-	if (objectStart === -1 && arrayStart === -1) return null;
-
-	// Pick whichever comes first
-	const start =
-		objectStart === -1
-			? arrayStart
-			: arrayStart === -1
-				? objectStart
-				: Math.min(objectStart, arrayStart);
-
-	// Find matching close bracket (string-literal-aware depth tracking)
-	let depth = 0;
-	let inString = false;
-	let escaped = false;
-	for (let i = start; i < raw.length; i++) {
-		const ch = raw[i];
-		if (escaped) {
-			escaped = false;
-			continue;
-		}
-		if (ch === "\\" && inString) {
-			escaped = true;
-			continue;
-		}
-		if (ch === '"') {
-			inString = !inString;
-			continue;
-		}
-		if (inString) continue;
-		if (ch === "{" || ch === "[") depth++;
-		if (ch === "}" || ch === "]") depth--;
-		if (depth === 0) {
-			return raw.slice(start, i + 1);
-		}
-	}
-
-	return null;
-}
-
 /**
  * Advance the pipeline from the current stage to the next.
  *
@@ -155,6 +49,8 @@ export function advancePipeline(
 	findingsJson: string,
 	currentState: ReviewState,
 	agentName = "unknown",
+	_runId?: string,
+	_seed?: string,
 ): ReviewStageResult {
 	const typedEnvelope = parseTypedFindingsEnvelope(findingsJson);
 	const parseMode = typedEnvelope ? "typed" : "legacy";

package/src/review/selection.ts

@@ -5,6 +5,8 @@
  * agents with non-empty relevantStacks require at least one match.
  */
 
+import { createSeededRandom, deterministicShuffle } from "../utils/random";
+
 /** Minimal agent shape needed for selection (compatible with ReviewAgent from agents/). */
 interface SelectableAgent {
 	readonly name: string;
@@ -21,6 +23,13 @@ export interface DiffAnalysisInput {
 	readonly fileCount: number;
 }
 
+export interface SelectionOptions {
+	/** Seed for reproducible agent ordering. If omitted, uses a fixed default. */
+	readonly seed?: string;
+	/** Maximum number of gated agents to select. Universal agents are always included. */
+	readonly limit?: number;
+}
+
 export interface SelectionResult {
 	readonly selected: readonly SelectableAgent[];
 	readonly excluded: readonly { readonly agent: string; readonly reason: string }[];
@@ -32,25 +41,28 @@ export interface SelectionResult {
  * @param detectedStacks - Stack tags detected in the project (e.g., ["node", "typescript"])
  * @param diffAnalysis - Analysis of changed files
  * @param agents - All candidate agents
+ * @param options - Options for seeding and limiting the number of agents
  * @returns Frozen SelectionResult with selected and excluded lists
  */
 export function selectAgents(
 	detectedStacks: readonly string[],
 	_diffAnalysis: DiffAnalysisInput,
 	agents: readonly SelectableAgent[],
+	options: SelectionOptions = {},
 ): SelectionResult {
 	const stackSet = new Set(detectedStacks);
-	const selected: SelectableAgent[] = [];
+	const universal: SelectableAgent[] = [];
+	const gatedCandidates: SelectableAgent[] = [];
 	const excluded: { readonly agent: string; readonly reason: string }[] = [];
 
 	for (const agent of agents) {
 		// Pass 1: Stack gate
 		if (agent.relevantStacks.length === 0) {
 			// Universal agent -- always passes
-			selected.push(agent);
+			universal.push(agent);
 		} else if (agent.relevantStacks.some((s) => stackSet.has(s))) {
 			// Gated agent with at least one matching stack
-			selected.push(agent);
+			gatedCandidates.push(agent);
 		} else {
 			// Gated agent with no matching stack
 			const stackList = detectedStacks.length > 0 ? detectedStacks.join(", ") : "none";
@@ -63,8 +75,30 @@ export function selectAgents(
 		}
 	}
 
+	const seed = options.seed ?? "default-selection-seed";
+	const rng = createSeededRandom(seed);
+
+	const shuffledGated = deterministicShuffle([...gatedCandidates], rng);
+	const finalGated =
+		options.limit !== undefined ? shuffledGated.slice(0, options.limit) : shuffledGated;
+
+	if (options.limit !== undefined && finalGated.length < shuffledGated.length) {
+		const dropped = shuffledGated.slice(options.limit);
+		for (const agent of dropped) {
+			excluded.push(
+				Object.freeze({
+					agent: agent.name,
+					reason: `Diversity limit: dropped to meet limit of ${options.limit}`,
+				}),
+			);
+		}
+	}
+
+	const combined = [...universal, ...finalGated];
+	deterministicShuffle(combined, rng);
+
 	return Object.freeze({
-		selected: Object.freeze(selected),
+		selected: Object.freeze(combined),
 		excluded: Object.freeze(excluded),
 	});
 }

package/src/scoring/time-provider.ts

@@ -0,0 +1,23 @@
+export interface TimeProvider {
+	readonly now: () => number;
+}
+
+export const systemTimeProvider: TimeProvider = Object.freeze({
+	now: () => Date.now(),
+});
+
+export function createFixedTimeProvider(
+	initialTimeMs: number,
+): TimeProvider & { advance: (ms: number) => void; set: (ms: number) => void } {
+	let currentTime = initialTimeMs;
+
+	return Object.freeze({
+		now: () => currentTime,
+		advance: (ms: number) => {
+			currentTime += ms;
+		},
+		set: (ms: number) => {
+			currentTime = ms;
+		},
+	});
+}

package/src/tools/configure.ts

@@ -314,7 +314,7 @@ async function handleCommit(configPath?: string): Promise<string> {
 	}
 	const newConfig = {
 		...currentConfig,
-		version: 6 as const,
+		version: 7 as const,
 		configured: true,
 		groups: groupsRecord,
 		overrides: currentConfig.overrides ?? {},

package/src/tools/doctor.ts

@@ -17,7 +17,7 @@ export function setOpenCodeConfig(config: Config | null): void {
  */
 interface DoctorCheck {
 	readonly name: string;
-	readonly status: "pass" | "fail";
+	readonly status: "pass" | "warn" | "fail";
 	readonly message: string;
 	readonly fixSuggestion: string | null;
 }
@@ -120,7 +120,7 @@ function formatCheck(result: HealthResult): DoctorCheck {
  */
 function buildDisplayText(checks: readonly DoctorCheck[], duration: number): string {
 	const lines = checks.map((c) => {
-		const icon = c.status === "pass" ? "OK" : "FAIL";
+		const icon = c.status === "pass" ? "OK" : c.status === "warn" ? "WARN" : "FAIL";
 		const line = `[${icon}] ${c.name}: ${c.message}`;
 		return c.fixSuggestion ? `${line}\n     Fix: ${c.fixSuggestion}` : line;
 	});

package/src/tools/logs.ts

@@ -22,14 +22,14 @@ import {
 } from "../observability/log-reader";
 import { generateSessionSummary } from "../observability/summary-generator";
 
-/**
- * Options for logsCore search/detail modes.
- */
 interface LogsOptions {
 	readonly sessionID?: string;
 	readonly eventType?: string;
 	readonly after?: string;
 	readonly before?: string;
+	readonly domain?: string;
+	readonly subsystem?: string;
+	readonly severity?: string;
 }
 
 /**
@@ -135,6 +135,9 @@ export async function logsCore(
 				type: options?.eventType,
 				after: options?.after,
 				before: options?.before,
+				domain: options?.domain,
+				subsystem: options?.subsystem,
+				severity: options?.severity,
 			});
 
 			const displayLines = [
@@ -146,6 +149,15 @@ export async function logsCore(
 			return JSON.stringify({
 				action: "logs_search",
 				sessionId: log.sessionId,
+				filters: {
+					eventType: options?.eventType,
+					after: options?.after,
+					before: options?.before,
+					domain: options?.domain,
+					subsystem: options?.subsystem,
+					severity: options?.severity,
+				},
+				matchCount: filtered.length,
 				events: filtered,
 				displayText: displayLines.join("\n"),
 			});
@@ -158,7 +170,7 @@ export async function logsCore(
 export const ocLogs = tool({
 	description:
 		"View session logs. Modes: 'list' shows all sessions, 'detail' shows full log with " +
-		"summary, 'search' filters events by type/time. Use to inspect session history and errors.",
+		"summary, 'search' filters events by type/time/domain/subsystem/severity. Use to inspect session history and errors.",
 	args: {
 		mode: z.enum(["list", "detail", "search"]).describe("View mode: list, detail, or search"),
 		sessionID: z
@@ -172,8 +184,22 @@ export const ocLogs = tool({
 			.string()
 			.optional()
 			.describe("Only events before this ISO timestamp (for search mode)"),
+		domain: z
+			.string()
+			.optional()
+			.describe("Filter events by domain (e.g. 'session', 'orchestrator') (for search mode)"),
+		subsystem: z
+			.string()
+			.optional()
+			.describe("Filter events by payload.subsystem field (for search mode)"),
+		severity: z
+			.string()
+			.optional()
+			.describe(
+				"Filter by severity: matches event.type (e.g. 'error', 'warning') or payload.severity/payload.level (for search mode)",
+			),
 	},
-	async execute({ mode, sessionID, eventType, after, before }) {
-		return logsCore(mode, { sessionID, eventType, after, before });
+	async execute({ mode, sessionID, eventType, after, before, domain, subsystem, severity }) {
+		return logsCore(mode, { sessionID, eventType, after, before, domain, subsystem, severity });
 	},
 });