@kodrunhq/opencode-autopilot 1.16.0 → 1.18.0

package/src/health/checks.ts

@@ -44,6 +44,171 @@ export async function configHealthCheck(configPath?: string): Promise<HealthResu
 	}
 }
 
+const LATEST_CONFIG_VERSION = 7;
+
+export async function configVersionCheck(configPath?: string): Promise<HealthResult> {
+	try {
+		const config = await loadConfig(configPath);
+		if (config === null) {
+			return Object.freeze({
+				name: "config-version",
+				status: "fail" as const,
+				message: "Config file not found",
+			});
+		}
+		if (config.version < LATEST_CONFIG_VERSION) {
+			return Object.freeze({
+				name: "config-version",
+				status: "warn" as const,
+				message: `Config v${config.version} is outdated (latest: v${LATEST_CONFIG_VERSION}). Auto-migration will upgrade on next load.`,
+			});
+		}
+		return Object.freeze({
+			name: "config-version",
+			status: "pass" as const,
+			message: `Config is on latest version (v${config.version})`,
+		});
+	} catch (error: unknown) {
+		const msg = error instanceof Error ? error.message : String(error);
+		return Object.freeze({
+			name: "config-version",
+			status: "fail" as const,
+			message: `Config version check failed: ${msg}`,
+		});
+	}
+}
+
+const REQUIRED_GROUPS: readonly string[] = Object.freeze([
+	"architects",
+	"challengers",
+	"builders",
+	"reviewers",
+	"red-team",
+	"researchers",
+	"communicators",
+	"utilities",
+]);
+
+export async function configGroupsCheck(configPath?: string): Promise<HealthResult> {
+	try {
+		const config = await loadConfig(configPath);
+		if (config === null) {
+			return Object.freeze({
+				name: "config-groups",
+				status: "fail" as const,
+				message: "Config file not found",
+			});
+		}
+
+		const assignedGroups = Object.keys(config.groups);
+		const missingGroups = REQUIRED_GROUPS.filter((g) => !assignedGroups.includes(g));
+
+		if (missingGroups.length > 0) {
+			return Object.freeze({
+				name: "config-groups",
+				status: "warn" as const,
+				message: `Missing model assignments for groups: ${missingGroups.join(", ")}`,
+				details: Object.freeze(missingGroups),
+			});
+		}
+
+		const groupsWithoutPrimary = assignedGroups.filter((g) => {
+			const group = config.groups[g];
+			return !group?.primary;
+		});
+
+		if (groupsWithoutPrimary.length > 0) {
+			return Object.freeze({
+				name: "config-groups",
+				status: "warn" as const,
+				message: `Groups without primary model: ${groupsWithoutPrimary.join(", ")}`,
+				details: Object.freeze(groupsWithoutPrimary),
+			});
+		}
+
+		return Object.freeze({
+			name: "config-groups",
+			status: "pass" as const,
+			message: `All ${REQUIRED_GROUPS.length} required groups have primary models assigned`,
+		});
+	} catch (error: unknown) {
+		const msg = error instanceof Error ? error.message : String(error);
+		return Object.freeze({
+			name: "config-groups",
+			status: "fail" as const,
+			message: `Config groups check failed: ${msg}`,
+		});
+	}
+}
+
+/** v7 config fields that must be present on a v7 config. */
+const V7_REQUIRED_FIELDS: readonly string[] = Object.freeze([
+	"background",
+	"routing",
+	"recovery",
+	"mcp",
+]);
+
+/**
+ * Check that v7 configs contain all four new top-level fields introduced in v7:
+ * background, routing, recovery, and mcp.
+ * Inspects the raw on-disk JSON so that Zod default-filling does not mask
+ * actually-missing fields. Pre-v7 configs receive a pass with a migration notice.
+ */
+export async function configV7FieldsCheck(configPath?: string): Promise<HealthResult> {
+	const resolvedPath = configPath ?? join(getGlobalConfigDir(), "opencode-autopilot.json");
+	try {
+		let raw: Record<string, unknown>;
+		try {
+			const content = await readFile(resolvedPath, "utf-8");
+			raw = JSON.parse(content) as Record<string, unknown>;
+		} catch (error: unknown) {
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+				return Object.freeze({
+					name: "config-v7-fields",
+					status: "fail" as const,
+					message: "Config file not found",
+				});
+			}
+			throw error;
+		}
+
+		const version = typeof raw.version === "number" ? raw.version : 0;
+
+		if (version < 7) {
+			return Object.freeze({
+				name: "config-v7-fields",
+				status: "pass" as const,
+				message: `Config v${version} will gain v7 fields (background, routing, recovery, mcp) on next load`,
+			});
+		}
+
+		const missingFields = V7_REQUIRED_FIELDS.filter((field) => !(field in raw));
+
+		if (missingFields.length > 0) {
+			return Object.freeze({
+				name: "config-v7-fields",
+				status: "fail" as const,
+				message: `Config v7 is missing required fields: ${missingFields.join(", ")}`,
+				details: Object.freeze(missingFields),
+			});
+		}
+
+		return Object.freeze({
+			name: "config-v7-fields",
+			status: "pass" as const,
+			message: `Config v7 fields present: ${V7_REQUIRED_FIELDS.join(", ")}`,
+		});
+	} catch (error: unknown) {
+		const msg = error instanceof Error ? error.message : String(error);
+		return Object.freeze({
+			name: "config-v7-fields",
+			status: "fail" as const,
+			message: `Config v7 fields check failed: ${msg}`,
+		});
+	}
+}
+
 /** Standard agent names, derived from the agents barrel export. */
 const STANDARD_AGENT_NAMES: readonly string[] = Object.freeze([
 	"researcher",

package/src/health/runner.ts

@@ -4,6 +4,7 @@ import {
 	assetHealthCheck,
 	commandHealthCheck,
 	configHealthCheck,
+	configV7FieldsCheck,
 	memoryHealthCheck,
 	nativeAgentSuppressionHealthCheck,
 	skillHealthCheck,
@@ -43,16 +44,20 @@ export async function runHealthChecks(options?: {
 }): Promise<HealthReport> {
 	const start = Date.now();
 
+	const configOutcome = await Promise.allSettled([configHealthCheck(options?.configPath)]);
+
 	const settled = await Promise.allSettled([
-		configHealthCheck(options?.configPath),
 		agentHealthCheck(options?.openCodeConfig ?? null),
 		nativeAgentSuppressionHealthCheck(options?.openCodeConfig ?? null),
 		assetHealthCheck(options?.assetsDir, options?.targetDir),
 		skillHealthCheck(options?.projectRoot ?? process.cwd()),
 		memoryHealthCheck(options?.targetDir),
 		commandHealthCheck(options?.targetDir),
+		configV7FieldsCheck(options?.configPath),
 	]);
 
+	const allSettled = [...configOutcome, ...settled];
+
 	const fallbackNames = [
 		"config-validity",
 		"agent-injection",
@@ -61,9 +66,10 @@ export async function runHealthChecks(options?: {
 		"skill-loading",
 		"memory-db",
 		"command-accessibility",
+		"config-v7-fields",
 	];
 	const results: readonly HealthResult[] = Object.freeze(
-		settled.map((outcome, i) => settledToResult(outcome, fallbackNames[i])),
+		allSettled.map((outcome, i) => settledToResult(outcome, fallbackNames[i])),
 	);
 
 	const allPassed = results.every((r) => r.status === "pass");

package/src/health/types.ts

@@ -4,7 +4,7 @@
  */
 export interface HealthResult {
 	readonly name: string;
-	readonly status: "pass" | "fail";
+	readonly status: "pass" | "warn" | "fail";
 	readonly message: string;
 	readonly details?: readonly string[];
 }

package/src/index.ts

@@ -4,6 +4,7 @@ import { isFirstLoad, loadConfig } from "./config";
 import { runHealthChecks } from "./health/runner";
 import { createAntiSlopHandler } from "./hooks/anti-slop";
 import { installAssets } from "./installer";
+import { getLogger, initLoggers } from "./logging/domains";
 import {
 	createMemoryCaptureHandler,
 	createMemoryChatMessageHandler,
@@ -55,17 +56,36 @@ import { ocReview } from "./tools/review";
 import { ocSessionStats } from "./tools/session-stats";
 import { ocState } from "./tools/state";
 import { ocStocktake } from "./tools/stocktake";
+import { ocSummary } from "./tools/summary";
 import { ocUpdateDocs } from "./tools/update-docs";
 
 let openCodeConfig: Config | null = null;
 
+let processHandlersRegistered = false;
+function registerProcessHandlers() {
+	if (processHandlersRegistered) return;
+	processHandlersRegistered = true;
+	process.on("uncaughtException", (error) => {
+		getLogger("system").error("Uncaught exception", {
+			error: error instanceof Error ? error.stack : String(error),
+		});
+	});
+	process.on("unhandledRejection", (reason) => {
+		getLogger("system").error("Unhandled rejection", {
+			reason: reason instanceof Error ? reason.stack : String(reason),
+		});
+	});
+}
+
 const plugin: Plugin = async (input) => {
 	const client = input.client;
+	initLoggers(process.cwd());
+	registerProcessHandlers();
 
 	// Self-healing asset installation on every load
 	const installResult = await installAssets();
 	if (installResult.errors.length > 0) {
-		console.error("[opencode-autopilot] Asset installation errors:", installResult.errors);
+		getLogger("system").warn("Asset installation errors", { errors: installResult.errors });
 	}
 
 	// Discover available providers/models in the background (non-blocking).
@@ -102,7 +122,9 @@ const plugin: Plugin = async (input) => {
 
 	// Retention pruning on load (non-blocking per D-14)
 	pruneOldLogs().catch((err) => {
-		console.error("[opencode-autopilot]", err);
+		getLogger("system").error("Log retention pruning failed", {
+			error: err instanceof Error ? err.stack : String(err),
+		});
 	});
 
 	// --- Fallback subsystem initialization ---
@@ -307,6 +329,7 @@ const plugin: Plugin = async (input) => {
 			oc_logs: ocLogs,
 			oc_session_stats: ocSessionStats,
 			oc_pipeline_report: ocPipelineReport,
+			oc_summary: ocSummary,
 			oc_mock_fallback: ocMockFallback,
 			oc_stocktake: ocStocktake,
 			oc_update_docs: ocUpdateDocs,

package/src/kernel/transaction.ts

@@ -0,0 +1,48 @@
+import type { Database } from "bun:sqlite";
+
+export interface TransactionOptions {
+	maxRetries?: number;
+	backoffMs?: number;
+	useImmediate?: boolean;
+}
+
+export function withTransaction<T>(db: Database, fn: () => T, options: TransactionOptions = {}): T {
+	const maxRetries = options.maxRetries ?? 5;
+	const backoffMs = options.backoffMs ?? 100;
+	const useImmediate = options.useImmediate ?? true;
+
+	let attempts = 0;
+	while (true) {
+		try {
+			if (useImmediate) {
+				db.run("BEGIN IMMEDIATE");
+				try {
+					const result = fn();
+					db.run("COMMIT");
+					return result;
+				} catch (innerError) {
+					db.run("ROLLBACK");
+					throw innerError;
+				}
+			}
+
+			const transaction = db.transaction(fn);
+			return transaction();
+		} catch (error: unknown) {
+			const e = error as Error;
+			const isBusyError =
+				e.message &&
+				(e.message.includes("database is locked") ||
+					e.message.includes("SQLITE_BUSY") ||
+					e.message.includes("database table is locked"));
+
+			if (isBusyError && attempts < maxRetries) {
+				attempts++;
+				const waitTime = backoffMs * attempts;
+				Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, waitTime);
+				continue;
+			}
+			throw error;
+		}
+	}
+}

package/src/kernel/types.ts

@@ -1,7 +1,6 @@
 import type { ForensicEvent } from "../observability/forensic-types";
-import type { LessonMemory } from "../orchestrator/lesson-types";
 import type { PipelineState } from "../orchestrator/types";
-import type { ReviewMemory, ReviewState } from "../review/types";
+import type { ReviewState } from "../review/types";
 
 export const KERNEL_STATE_CONFLICT_CODE = "E_STATE_CONFLICT";
 

package/src/logging/domains.ts

@@ -0,0 +1,39 @@
+import { createForensicSink } from "./forensic-writer";
+import { BaseLogger } from "./logger";
+import type { LogEntry, Logger, LogMetadata, LogSink } from "./types";
+
+export class MultiplexSink implements LogSink {
+	constructor(private readonly sinks: readonly LogSink[]) {}
+
+	write(entry: LogEntry): void {
+		for (const sink of this.sinks) {
+			sink.write(entry);
+		}
+	}
+}
+
+let rootLogger: Logger | null = null;
+
+export function initLoggers(projectRoot: string, sinks?: readonly LogSink[]): void {
+	const resolvedSinks = sinks ?? [createForensicSink(projectRoot)];
+	rootLogger = new BaseLogger(new MultiplexSink(resolvedSinks), { domain: "system" });
+}
+
+export function getLogger(domain: string, subsystem?: string): Logger {
+	if (!rootLogger) {
+		return new BaseLogger(
+			{
+				write(entry: LogEntry): void {
+					console.log(entry.level, entry.message);
+				},
+			},
+			compactMetadata(domain, subsystem),
+		);
+	}
+
+	return rootLogger.child(compactMetadata(domain, subsystem));
+}
+
+function compactMetadata(domain: string, subsystem?: string): LogMetadata {
+	return subsystem ? { domain, subsystem } : { domain };
+}

package/src/logging/forensic-writer.ts

@@ -0,0 +1,177 @@
+import {
+	appendForensicEvent,
+	appendForensicEventForArtifactDir,
+} from "../observability/forensic-log";
+import type { ForensicEventDomain, ForensicEventType } from "../observability/forensic-types";
+import type { LogEntry, LogSink } from "./types";
+
+export function createForensicSinkForArtifactDir(artifactDir: string): LogSink {
+	return {
+		write(entry: LogEntry): void {
+			const {
+				domain,
+				operation,
+				runId,
+				sessionId,
+				parentSessionId,
+				phase,
+				dispatchId,
+				taskId,
+				agent,
+				code,
+				subsystem,
+				...payload
+			} = entry.metadata;
+
+			let forensicDomain: ForensicEventDomain = "system";
+			if (
+				domain === "session" ||
+				domain === "orchestrator" ||
+				domain === "contract" ||
+				domain === "system" ||
+				domain === "review"
+			) {
+				forensicDomain = domain;
+			}
+
+			let forensicType: ForensicEventType = "info";
+
+			if (operation && isValidForensicType(operation as string)) {
+				forensicType = operation as ForensicEventType;
+			} else {
+				switch (entry.level) {
+					case "ERROR":
+						forensicType = "error";
+						break;
+					case "WARN":
+						forensicType = "warning";
+						break;
+					case "INFO":
+						forensicType = "info";
+						break;
+					case "DEBUG":
+						forensicType = "debug";
+						break;
+				}
+			}
+
+			appendForensicEventForArtifactDir(artifactDir, {
+				timestamp: entry.timestamp,
+				domain: forensicDomain,
+				runId: (runId as string) ?? null,
+				sessionId: (sessionId as string) ?? null,
+				parentSessionId: (parentSessionId as string) ?? null,
+				phase: (phase as string) ?? null,
+				dispatchId: (dispatchId as string) ?? null,
+				taskId: (taskId as number) ?? null,
+				agent: (agent as string) ?? null,
+				type: forensicType,
+				code: (code as string) ?? null,
+				message: entry.message,
+				payload: {
+					...payload,
+					...(subsystem ? { subsystem } : {}),
+				} as Record<string, string | number | boolean | object | readonly unknown[] | null>,
+			});
+		},
+	};
+}
+
+export function createForensicSink(projectRoot: string): LogSink {
+	return {
+		write(entry: LogEntry): void {
+			const {
+				domain,
+				operation,
+				runId,
+				sessionId,
+				parentSessionId,
+				phase,
+				dispatchId,
+				taskId,
+				agent,
+				code,
+				subsystem,
+				...payload
+			} = entry.metadata;
+
+			let forensicDomain: ForensicEventDomain = "system";
+			if (
+				domain === "session" ||
+				domain === "orchestrator" ||
+				domain === "contract" ||
+				domain === "system" ||
+				domain === "review"
+			) {
+				forensicDomain = domain;
+			}
+
+			let forensicType: ForensicEventType = "info";
+
+			if (operation && isValidForensicType(operation as string)) {
+				forensicType = operation as ForensicEventType;
+			} else {
+				switch (entry.level) {
+					case "ERROR":
+						forensicType = "error";
+						break;
+					case "WARN":
+						forensicType = "warning";
+						break;
+					case "INFO":
+						forensicType = "info";
+						break;
+					case "DEBUG":
+						forensicType = "debug";
+						break;
+				}
+			}
+
+			appendForensicEvent(projectRoot, {
+				timestamp: entry.timestamp,
+				projectRoot,
+				domain: forensicDomain,
+				runId: (runId as string) ?? null,
+				sessionId: (sessionId as string) ?? null,
+				parentSessionId: (parentSessionId as string) ?? null,
+				phase: (phase as string) ?? null,
+				dispatchId: (dispatchId as string) ?? null,
+				taskId: (taskId as number) ?? null,
+				agent: (agent as string) ?? null,
+				type: forensicType,
+				code: (code as string) ?? null,
+				message: entry.message,
+				payload: {
+					...payload,
+					...(subsystem ? { subsystem } : {}),
+				} as Record<string, string | number | boolean | object | readonly unknown[] | null>,
+			});
+		},
+	};
+}
+
+function isValidForensicType(type: string): boolean {
+	const validTypes = [
+		"run_started",
+		"dispatch",
+		"dispatch_multi",
+		"result_applied",
+		"phase_transition",
+		"complete",
+		"decision",
+		"error",
+		"loop_detected",
+		"failure_recorded",
+		"warning",
+		"session_start",
+		"session_end",
+		"fallback",
+		"model_switch",
+		"context_warning",
+		"tool_complete",
+		"compacted",
+		"info",
+		"debug",
+	];
+	return validTypes.includes(type);
+}

package/src/logging/index.ts

@@ -0,0 +1,4 @@
+export * from "./domains";
+export * from "./forensic-writer";
+export * from "./logger";
+export * from "./types";

package/src/logging/logger.ts

@@ -0,0 +1,44 @@
+import type { LogEntry, Logger, LogLevel, LogMetadata, LogSink } from "./types";
+
+export class BaseLogger implements Logger {
+	constructor(
+		private readonly sink: LogSink,
+		private readonly baseMetadata: LogMetadata,
+	) {}
+
+	debug(message: string, metadata?: Partial<LogMetadata>): void {
+		this.log("DEBUG", message, metadata);
+	}
+
+	info(message: string, metadata?: Partial<LogMetadata>): void {
+		this.log("INFO", message, metadata);
+	}
+
+	warn(message: string, metadata?: Partial<LogMetadata>): void {
+		this.log("WARN", message, metadata);
+	}
+
+	error(message: string, metadata?: Partial<LogMetadata>): void {
+		this.log("ERROR", message, metadata);
+	}
+
+	child(metadata: Partial<LogMetadata>): Logger {
+		return new BaseLogger(this.sink, {
+			...this.baseMetadata,
+			...metadata,
+		});
+	}
+
+	private log(level: LogLevel, message: string, metadata?: Partial<LogMetadata>): void {
+		const entry: LogEntry = {
+			timestamp: new Date().toISOString(),
+			level,
+			message,
+			metadata: {
+				...this.baseMetadata,
+				...metadata,
+			},
+		};
+		this.sink.write(Object.freeze(entry));
+	}
+}

package/src/logging/performance.ts

@@ -0,0 +1,59 @@
+import { getLogger } from "./domains";
+
+function log() {
+	return getLogger("system", "performance");
+}
+
+export interface MemorySnapshot {
+	readonly rss: number;
+	readonly heapTotal: number;
+	readonly heapUsed: number;
+	readonly external: number;
+	readonly arrayBuffers: number;
+}
+
+export interface TimerHandle {
+	stop(metadata?: Record<string, unknown>): void;
+}
+
+export function recordMemoryUsage(): void {
+	const mem = process.memoryUsage();
+
+	const snapshot: MemorySnapshot = {
+		rss: mem.rss,
+		heapTotal: mem.heapTotal,
+		heapUsed: mem.heapUsed,
+		external: mem.external,
+		arrayBuffers: mem.arrayBuffers,
+	};
+
+	log().info("memory usage", {
+		operation: "memory_snapshot",
+		...snapshot,
+	});
+}
+
+export function startTimer(operation: string): TimerHandle {
+	// performance.now() is monotonic and unaffected by system-clock adjustments
+	const startMs = performance.now();
+
+	return {
+		stop(metadata?: Record<string, unknown>): void {
+			const durationMs = performance.now() - startMs;
+
+			log().info("operation completed", {
+				operation,
+				durationMs,
+				...metadata,
+			});
+		},
+	};
+}
+
+export function recordAgentResponseTime(agent: string, durationMs: number): void {
+	log().info("agent response time", {
+		operation: "agent_response_time",
+		agent,
+		durationMs,
+	});
+}