@kodrunhq/opencode-autopilot 1.15.2 → 1.17.0

package/src/kernel/schema.ts

@@ -0,0 +1,122 @@
+export const KERNEL_SCHEMA_VERSION = 1;
+
+export const KERNEL_SCHEMA_STATEMENTS: readonly string[] = Object.freeze([
+	`CREATE TABLE IF NOT EXISTS pipeline_runs (
+		project_id TEXT NOT NULL,
+		run_id TEXT PRIMARY KEY,
+		schema_version INTEGER NOT NULL,
+		status TEXT NOT NULL,
+		current_phase TEXT,
+		idea TEXT NOT NULL,
+		state_revision INTEGER NOT NULL,
+		started_at TEXT NOT NULL,
+		last_updated_at TEXT NOT NULL,
+		failure_phase TEXT,
+		failure_agent TEXT,
+		failure_message TEXT,
+		last_successful_phase TEXT,
+		state_json TEXT NOT NULL,
+		FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+	)`,
+	`CREATE INDEX IF NOT EXISTS idx_pipeline_runs_project_updated_at ON pipeline_runs(project_id, last_updated_at DESC, run_id DESC)`,
+	`CREATE TABLE IF NOT EXISTS run_phases (
+		run_id TEXT NOT NULL,
+		phase_name TEXT NOT NULL,
+		status TEXT NOT NULL,
+		completed_at TEXT,
+		confidence TEXT,
+		PRIMARY KEY (run_id, phase_name),
+		FOREIGN KEY (run_id) REFERENCES pipeline_runs(run_id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS run_tasks (
+		run_id TEXT NOT NULL,
+		task_id INTEGER NOT NULL,
+		title TEXT NOT NULL,
+		status TEXT NOT NULL,
+		wave INTEGER NOT NULL,
+		depends_on_json TEXT NOT NULL,
+		attempt INTEGER NOT NULL,
+		strike INTEGER NOT NULL,
+		PRIMARY KEY (run_id, task_id),
+		FOREIGN KEY (run_id) REFERENCES pipeline_runs(run_id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS run_pending_dispatches (
+		run_id TEXT NOT NULL,
+		dispatch_id TEXT NOT NULL,
+		phase TEXT NOT NULL,
+		agent TEXT NOT NULL,
+		issued_at TEXT NOT NULL,
+		result_kind TEXT NOT NULL,
+		task_id INTEGER,
+		PRIMARY KEY (run_id, dispatch_id),
+		FOREIGN KEY (run_id) REFERENCES pipeline_runs(run_id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS run_processed_results (
+		run_id TEXT NOT NULL,
+		result_id TEXT NOT NULL,
+		PRIMARY KEY (run_id, result_id),
+		FOREIGN KEY (run_id) REFERENCES pipeline_runs(run_id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS active_review_state (
+		project_id TEXT PRIMARY KEY,
+		stage INTEGER NOT NULL,
+		scope TEXT NOT NULL,
+		started_at TEXT NOT NULL,
+		saved_at TEXT NOT NULL,
+		state_json TEXT NOT NULL,
+		FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS project_review_memory (
+		project_id TEXT PRIMARY KEY,
+		schema_version INTEGER NOT NULL,
+		last_reviewed_at TEXT,
+		state_json TEXT NOT NULL,
+		FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS project_lesson_memory (
+		project_id TEXT PRIMARY KEY,
+		schema_version INTEGER NOT NULL,
+		last_updated_at TEXT,
+		state_json TEXT NOT NULL,
+		FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS project_lessons (
+		lesson_id INTEGER PRIMARY KEY AUTOINCREMENT,
+		project_id TEXT NOT NULL,
+		content TEXT NOT NULL,
+		domain TEXT NOT NULL,
+		extracted_at TEXT NOT NULL,
+		source_phase TEXT NOT NULL,
+		last_updated_at TEXT,
+		FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+		UNIQUE(project_id, extracted_at, domain, source_phase, content)
+	)`,
+	`CREATE INDEX IF NOT EXISTS idx_project_lessons_project_extracted_at ON project_lessons(project_id, extracted_at DESC, lesson_id DESC)`,
+	`CREATE INDEX IF NOT EXISTS idx_project_lessons_domain ON project_lessons(project_id, domain, extracted_at DESC, lesson_id DESC)`,
+	`CREATE TABLE IF NOT EXISTS forensic_events (
+		event_id INTEGER PRIMARY KEY AUTOINCREMENT,
+		project_id TEXT NOT NULL,
+		schema_version INTEGER NOT NULL,
+		timestamp TEXT NOT NULL,
+		project_root TEXT NOT NULL,
+		domain TEXT NOT NULL,
+		run_id TEXT,
+		session_id TEXT,
+		parent_session_id TEXT,
+		phase TEXT,
+		dispatch_id TEXT,
+		task_id INTEGER,
+		agent TEXT,
+		type TEXT NOT NULL,
+		code TEXT,
+		message TEXT,
+		payload_json TEXT NOT NULL,
+		FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+	)`,
+	`CREATE INDEX IF NOT EXISTS idx_forensic_events_timestamp ON forensic_events(timestamp, event_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_forensic_events_project ON forensic_events(project_id, timestamp, event_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_forensic_events_session ON forensic_events(session_id, timestamp, event_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_forensic_events_run ON forensic_events(run_id, timestamp, event_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_forensic_events_dispatch ON forensic_events(dispatch_id, timestamp, event_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_forensic_events_type ON forensic_events(type, timestamp, event_id)`,
+]);

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

@@ -0,0 +1,65 @@
+import type { ForensicEvent } from "../observability/forensic-types";
+import type { PipelineState } from "../orchestrator/types";
+import type { ReviewState } from "../review/types";
+
+export const KERNEL_STATE_CONFLICT_CODE = "E_STATE_CONFLICT";
+
+export interface PipelineRunRow {
+	readonly project_id: string;
+	readonly run_id: string;
+	readonly schema_version: number;
+	readonly status: PipelineState["status"];
+	readonly current_phase: string | null;
+	readonly idea: string;
+	readonly state_revision: number;
+	readonly started_at: string;
+	readonly last_updated_at: string;
+	readonly failure_phase: string | null;
+	readonly failure_agent: string | null;
+	readonly failure_message: string | null;
+	readonly last_successful_phase: string | null;
+	readonly state_json: string;
+}
+
+export interface ActiveReviewStateRow {
+	readonly project_id: string;
+	readonly stage: ReviewState["stage"];
+	readonly scope: string;
+	readonly started_at: string;
+	readonly saved_at: string;
+	readonly state_json: string;
+}
+
+export interface ProjectReviewMemoryRow {
+	readonly project_id: string;
+	readonly schema_version: number;
+	readonly last_reviewed_at: string | null;
+	readonly state_json: string;
+}
+
+export interface ProjectLessonMemoryRow {
+	readonly project_id: string;
+	readonly schema_version: number;
+	readonly last_updated_at: string | null;
+	readonly state_json: string;
+}
+
+export interface ForensicEventRow {
+	readonly event_id: number;
+	readonly project_id: string;
+	readonly schema_version: number;
+	readonly timestamp: string;
+	readonly project_root: string;
+	readonly domain: ForensicEvent["domain"];
+	readonly run_id: string | null;
+	readonly session_id: string | null;
+	readonly parent_session_id: string | null;
+	readonly phase: string | null;
+	readonly dispatch_id: string | null;
+	readonly task_id: number | null;
+	readonly agent: string | null;
+	readonly type: ForensicEvent["type"];
+	readonly code: string | null;
+	readonly message: string | null;
+	readonly payload_json: string;
+}

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,
+	});
+}