@kodrunhq/opencode-autopilot 1.15.2 → 1.17.0

package/src/orchestrator/orchestration-logger.ts

@@ -1,5 +1,6 @@
-import { appendFileSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
+import { getLogger } from "../logging/domains";
+import { createForensicSinkForArtifactDir } from "../logging/forensic-writer";
+import type { LogLevel } from "../logging/types";
 
 export interface OrchestrationEvent {
 	readonly timestamp: string;
@@ -9,32 +10,60 @@ export interface OrchestrationEvent {
 	readonly promptLength?: number;
 	readonly attempt?: number;
 	readonly message?: string;
+	readonly runId?: string;
+	readonly dispatchId?: string;
+	readonly taskId?: number | null;
+	readonly code?: string;
+	readonly sessionId?: string;
+	readonly payload?: Record<string, string | number | boolean | null>;
 }
 
-const LOG_FILE = "orchestration.jsonl";
-
-/** Rate-limit: warn about log failures at most once per process. */
-let logWriteWarned = false;
+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";
+}
 
-/**
- * Append an orchestration event to the project-local JSONL log.
- * Uses synchronous append to survive crashes. Best-effort — errors are swallowed.
- */
 export function logOrchestrationEvent(artifactDir: string, event: OrchestrationEvent): void {
 	try {
-		mkdirSync(artifactDir, { recursive: true });
-		const logPath = join(artifactDir, LOG_FILE);
-		// Redact filesystem paths from message to avoid leaking sensitive directory info
-		const safe = event.message
-			? { ...event, message: event.message.replace(/[/\\][^\s"']+/g, "[PATH]") }
-			: event;
-		const line = `${JSON.stringify(safe)}\n`;
-		appendFileSync(logPath, line, "utf-8");
-	} catch (err) {
-		// Best-effort — never block the pipeline. Warn once so operators know logging is broken.
-		if (!logWriteWarned) {
-			logWriteWarned = true;
-			console.warn("[opencode-autopilot] orchestration log write failed:", err);
+		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/phase.ts

@@ -1,3 +1,4 @@
+import { patchState } from "./state";
 import type { Phase, PhaseStatus, PipelineState } from "./types";
 
 /** Maps each phase to its 1-based position for user-facing progress display. */
@@ -71,12 +72,15 @@ export function completePhase(state: Readonly<PipelineState>): PipelineState {
 		return phase;
 	});
 
-	return {
-		...state,
+	return patchState(state, {
+		status: nextPhase === null ? "COMPLETED" : state.status,
 		currentPhase: nextPhase,
 		phases: updatedPhases,
-		lastUpdatedAt: new Date().toISOString(),
-	};
+		pendingDispatches:
+			nextPhase === null
+				? []
+				: state.pendingDispatches.filter((entry) => entry.phase === nextPhase),
+	});
 }
 
 /**

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/orchestrator/state.ts

@@ -1,12 +1,15 @@
 import { randomBytes } from "node:crypto";
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { loadLatestPipelineStateFromKernel, savePipelineStateToKernel } from "../kernel/repository";
+import { KERNEL_STATE_CONFLICT_CODE } from "../kernel/types";
 import { ensureDir, isEnoentError } from "../utils/fs-helpers";
 import { assertStateInvariants } from "./contracts/invariants";
 import { PHASES, pipelineStateSchema } from "./schemas";
 import type { PipelineState } from "./types";
 
 const STATE_FILE = "state.json";
+let legacyStateMirrorWarned = false;
 
 function generateRunId(): string {
 	return `run_${randomBytes(8).toString("hex")}`;
@@ -37,12 +40,14 @@ export function createInitialState(idea: string): PipelineState {
 	});
 }
 
-export async function loadState(artifactDir: string): Promise<PipelineState | null> {
+async function loadLegacyState(artifactDir: string): Promise<PipelineState | null> {
 	const statePath = join(artifactDir, STATE_FILE);
 	try {
 		const raw = await readFile(statePath, "utf-8");
 		const parsed = JSON.parse(raw);
-		return pipelineStateSchema.parse(parsed);
+		const validated = pipelineStateSchema.parse(parsed);
+		assertStateInvariants(validated);
+		return validated;
 	} catch (error: unknown) {
 		if (isEnoentError(error)) {
 			return null;
@@ -51,28 +56,85 @@ export async function loadState(artifactDir: string): Promise<PipelineState | nu
 	}
 }
 
+async function writeLegacyStateMirror(state: PipelineState, artifactDir: string): Promise<void> {
+	await ensureDir(artifactDir);
+	const statePath = join(artifactDir, STATE_FILE);
+	const tmpPath = `${statePath}.tmp.${randomBytes(8).toString("hex")}`;
+	await writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+	await rename(tmpPath, statePath);
+}
+
+async function syncLegacyStateMirror(state: PipelineState, artifactDir: string): Promise<void> {
+	try {
+		await writeLegacyStateMirror(state, artifactDir);
+	} catch (error: unknown) {
+		if (!legacyStateMirrorWarned) {
+			legacyStateMirrorWarned = true;
+			console.warn("[opencode-autopilot] state.json mirror write failed:", error);
+		}
+	}
+}
+
+export async function loadState(artifactDir: string): Promise<PipelineState | null> {
+	const kernelState = loadLatestPipelineStateFromKernel(artifactDir);
+	if (kernelState !== null) {
+		return kernelState;
+	}
+
+	const legacyState = await loadLegacyState(artifactDir);
+	if (legacyState === null) {
+		return null;
+	}
+
+	savePipelineStateToKernel(artifactDir, legacyState);
+	return legacyState;
+}
+
 export async function saveState(
 	state: PipelineState,
 	artifactDir: string,
 	expectedRevision?: number,
 ): Promise<void> {
-	if (typeof expectedRevision === "number") {
-		const current = await loadState(artifactDir);
-		const currentRevision = current?.stateRevision ?? -1;
-		if (currentRevision !== expectedRevision) {
-			throw new Error(
-				`E_STATE_CONFLICT: expected stateRevision ${expectedRevision}, found ${currentRevision}`,
-			);
-		}
-	}
-
 	const validated = pipelineStateSchema.parse(state);
 	assertStateInvariants(validated);
-	await ensureDir(artifactDir);
-	const statePath = join(artifactDir, STATE_FILE);
-	const tmpPath = `${statePath}.tmp.${randomBytes(8).toString("hex")}`;
-	await writeFile(tmpPath, JSON.stringify(validated, null, 2), "utf-8");
-	await rename(tmpPath, statePath);
+	savePipelineStateToKernel(artifactDir, validated, expectedRevision);
+	await syncLegacyStateMirror(validated, artifactDir);
+}
+
+export function isStateConflictError(error: unknown): boolean {
+	return error instanceof Error && error.message.startsWith(`${KERNEL_STATE_CONFLICT_CODE}:`);
+}
+
+export async function updatePersistedState(
+	artifactDir: string,
+	state: Readonly<PipelineState>,
+	transform: (current: Readonly<PipelineState>) => PipelineState,
+	options?: { readonly maxConflicts?: number },
+): Promise<PipelineState> {
+	const maxConflicts = options?.maxConflicts ?? 2;
+	let currentState = state;
+
+	for (let attempt = 0; ; attempt += 1) {
+		const nextState = transform(currentState);
+		if (nextState === currentState) {
+			return currentState;
+		}
+
+		try {
+			await saveState(nextState, artifactDir, currentState.stateRevision);
+			return nextState;
+		} catch (error: unknown) {
+			if (!isStateConflictError(error) || attempt >= maxConflicts) {
+				throw error;
+			}
+
+			const latestState = await loadState(artifactDir);
+			if (latestState === null) {
+				throw new Error(`${KERNEL_STATE_CONFLICT_CODE}: state disappeared during update`);
+			}
+			currentState = latestState;
+		}
+	}
 }
 
 export function patchState(

package/src/projects/database.ts

@@ -0,0 +1,47 @@
+import type { Database } from "bun:sqlite";
+
+export const PROJECT_REGISTRY_STATEMENTS: readonly string[] = Object.freeze([
+	`CREATE TABLE IF NOT EXISTS projects (
+		id TEXT PRIMARY KEY,
+		path TEXT NOT NULL UNIQUE,
+		name TEXT NOT NULL,
+		first_seen_at TEXT NOT NULL,
+		last_updated TEXT NOT NULL
+	)`,
+	`CREATE TABLE IF NOT EXISTS project_paths (
+		project_id TEXT NOT NULL,
+		path TEXT NOT NULL,
+		first_seen_at TEXT NOT NULL,
+		last_updated TEXT NOT NULL,
+		is_current INTEGER NOT NULL CHECK(is_current IN (0, 1)),
+		PRIMARY KEY (project_id, path),
+		UNIQUE(path),
+		FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+	)`,
+	`CREATE INDEX IF NOT EXISTS idx_project_paths_project ON project_paths(project_id, is_current DESC, path)`,
+	`CREATE TABLE IF NOT EXISTS project_git_fingerprints (
+		project_id TEXT NOT NULL,
+		normalized_remote_url TEXT NOT NULL,
+		default_branch TEXT,
+		first_seen_at TEXT NOT NULL,
+		last_updated TEXT NOT NULL,
+		PRIMARY KEY (project_id, normalized_remote_url),
+		FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+	)`,
+	`CREATE INDEX IF NOT EXISTS idx_project_git_remote ON project_git_fingerprints(normalized_remote_url, last_updated DESC)`,
+]);
+
+export function runProjectRegistryMigrations(database: Database): void {
+	for (const statement of PROJECT_REGISTRY_STATEMENTS) {
+		database.run(statement);
+	}
+
+	const projectsInfo = database.query("PRAGMA table_info(projects)").all() as Array<{
+		name?: string;
+	}>;
+	const hasFirstSeenAt = projectsInfo.some((column) => column.name === "first_seen_at");
+	if (!hasFirstSeenAt) {
+		database.run("ALTER TABLE projects ADD COLUMN first_seen_at TEXT");
+		database.run("UPDATE projects SET first_seen_at = COALESCE(first_seen_at, last_updated)");
+	}
+}

package/src/projects/repository.ts

@@ -0,0 +1,264 @@
+import type { Database } from "bun:sqlite";
+import { getMemoryDb } from "../memory/database";
+import {
+	gitFingerprintInputSchema,
+	projectGitFingerprintSchema,
+	projectPathRecordSchema,
+	projectRecordSchema,
+} from "./schemas";
+import type {
+	GitFingerprintInput,
+	ProjectGitFingerprint,
+	ProjectPathRecord,
+	ProjectRecord,
+} from "./types";
+
+interface ProjectRow {
+	readonly id: string;
+	readonly path: string;
+	readonly name: string;
+	readonly first_seen_at: string | null;
+	readonly last_updated: string;
+}
+
+interface ProjectPathRow {
+	readonly project_id: string;
+	readonly path: string;
+	readonly first_seen_at: string;
+	readonly last_updated: string;
+	readonly is_current: number;
+}
+
+interface ProjectFingerprintRow {
+	readonly project_id: string;
+	readonly normalized_remote_url: string;
+	readonly default_branch: string | null;
+	readonly first_seen_at: string;
+	readonly last_updated: string;
+}
+
+function resolveDb(db?: Database): Database {
+	return db ?? getMemoryDb();
+}
+
+function withWriteTransaction<T>(db: Database, callback: () => T): T {
+	const row = db.query("PRAGMA transaction_state").get() as { transaction_state?: string } | null;
+	const isAlreadyInTransaction = row?.transaction_state === "TRANSACTION";
+	if (isAlreadyInTransaction) {
+		return callback();
+	}
+
+	db.run("BEGIN IMMEDIATE");
+	try {
+		const result = callback();
+		db.run("COMMIT");
+		return result;
+	} catch (error: unknown) {
+		try {
+			db.run("ROLLBACK");
+		} catch {
+			// Ignore rollback failures so the original error wins.
+		}
+		throw error;
+	}
+}
+
+function rowToProject(row: ProjectRow): ProjectRecord {
+	return projectRecordSchema.parse({
+		id: row.id,
+		path: row.path,
+		name: row.name,
+		firstSeenAt: row.first_seen_at ?? row.last_updated,
+		lastUpdated: row.last_updated,
+	});
+}
+
+function rowToProjectPath(row: ProjectPathRow): ProjectPathRecord {
+	return projectPathRecordSchema.parse({
+		projectId: row.project_id,
+		path: row.path,
+		firstSeenAt: row.first_seen_at,
+		lastUpdated: row.last_updated,
+		isCurrent: row.is_current === 1,
+	});
+}
+
+function rowToProjectFingerprint(row: ProjectFingerprintRow): ProjectGitFingerprint {
+	return projectGitFingerprintSchema.parse({
+		projectId: row.project_id,
+		normalizedRemoteUrl: row.normalized_remote_url,
+		defaultBranch: row.default_branch,
+		firstSeenAt: row.first_seen_at,
+		lastUpdated: row.last_updated,
+	});
+}
+
+export function upsertProjectRecord(project: ProjectRecord, db?: Database): ProjectRecord {
+	const validated = projectRecordSchema.parse(project);
+	const d = resolveDb(db);
+	const firstSeenAt = validated.firstSeenAt ?? validated.lastUpdated;
+
+	withWriteTransaction(d, () => {
+		d.run(
+			`INSERT INTO projects (id, path, name, first_seen_at, last_updated)
+			 VALUES (?, ?, ?, ?, ?)
+			 ON CONFLICT(id) DO UPDATE SET
+				path = excluded.path,
+				name = excluded.name,
+				first_seen_at = COALESCE(projects.first_seen_at, excluded.first_seen_at),
+				last_updated = excluded.last_updated`,
+			[validated.id, validated.path, validated.name, firstSeenAt, validated.lastUpdated],
+		);
+
+		d.run("UPDATE project_paths SET is_current = 0, last_updated = ? WHERE project_id = ?", [
+			validated.lastUpdated,
+			validated.id,
+		]);
+		d.run(
+			`INSERT INTO project_paths (project_id, path, first_seen_at, last_updated, is_current)
+			 VALUES (?, ?, ?, ?, 1)
+			 ON CONFLICT(project_id, path) DO UPDATE SET
+				last_updated = excluded.last_updated,
+				is_current = 1`,
+			[validated.id, validated.path, firstSeenAt, validated.lastUpdated],
+		);
+	});
+
+	return projectRecordSchema.parse({
+		...validated,
+		firstSeenAt,
+	});
+}
+
+export function getProjectById(projectId: string, db?: Database): ProjectRecord | null {
+	const d = resolveDb(db);
+	const row = d.query("SELECT * FROM projects WHERE id = ?").get(projectId) as ProjectRow | null;
+	return row ? rowToProject(row) : null;
+}
+
+export function getProjectByCurrentPath(path: string, db?: Database): ProjectRecord | null {
+	const d = resolveDb(db);
+	const row = d.query("SELECT * FROM projects WHERE path = ?").get(path) as ProjectRow | null;
+	return row ? rowToProject(row) : null;
+}
+
+export function getProjectByAnyPath(path: string, db?: Database): ProjectRecord | null {
+	const current = getProjectByCurrentPath(path, db);
+	if (current !== null) {
+		return current;
+	}
+
+	const d = resolveDb(db);
+	const row = d
+		.query(
+			`SELECT p.*
+			 FROM project_paths pp
+			 JOIN projects p ON p.id = pp.project_id
+			 WHERE pp.path = ?
+			 ORDER BY pp.is_current DESC, pp.last_updated DESC
+			 LIMIT 1`,
+		)
+		.get(path) as ProjectRow | null;
+	return row ? rowToProject(row) : null;
+}
+
+export function listProjectPaths(projectId: string, db?: Database): readonly ProjectPathRecord[] {
+	const d = resolveDb(db);
+	const rows = d
+		.query(
+			`SELECT *
+			 FROM project_paths
+			 WHERE project_id = ?
+			 ORDER BY is_current DESC, last_updated DESC, path ASC`,
+		)
+		.all(projectId) as ProjectPathRow[];
+	return Object.freeze(rows.map(rowToProjectPath));
+}
+
+export function setProjectCurrentPath(
+	projectId: string,
+	path: string,
+	name: string,
+	seenAt: string,
+	db?: Database,
+): ProjectRecord {
+	const d = resolveDb(db);
+	const existing = getProjectById(projectId, d);
+	if (existing === null) {
+		throw new Error(`Unknown project id: ${projectId}`);
+	}
+
+	const next = projectRecordSchema.parse({
+		id: existing.id,
+		path,
+		name,
+		firstSeenAt: existing.firstSeenAt,
+		lastUpdated: seenAt,
+	});
+	return upsertProjectRecord(next, d);
+}
+
+export function upsertProjectGitFingerprint(
+	projectId: string,
+	fingerprint: GitFingerprintInput,
+	seenAt: string,
+	db?: Database,
+): ProjectGitFingerprint {
+	const validated = gitFingerprintInputSchema.parse(fingerprint);
+	const d = resolveDb(db);
+
+	d.run(
+		`INSERT INTO project_git_fingerprints (
+			project_id,
+			normalized_remote_url,
+			default_branch,
+			first_seen_at,
+			last_updated
+		) VALUES (?, ?, ?, ?, ?)
+		ON CONFLICT(project_id, normalized_remote_url) DO UPDATE SET
+			default_branch = excluded.default_branch,
+			last_updated = excluded.last_updated`,
+		[projectId, validated.normalizedRemoteUrl, validated.defaultBranch, seenAt, seenAt],
+	);
+
+	return projectGitFingerprintSchema.parse({
+		projectId,
+		normalizedRemoteUrl: validated.normalizedRemoteUrl,
+		defaultBranch: validated.defaultBranch,
+		firstSeenAt: seenAt,
+		lastUpdated: seenAt,
+	});
+}
+
+export function getProjectsByGitFingerprint(
+	normalizedRemoteUrl: string,
+	db?: Database,
+): readonly ProjectRecord[] {
+	const d = resolveDb(db);
+	const rows = d
+		.query(
+			`SELECT DISTINCT p.*
+			 FROM project_git_fingerprints pgf
+			 JOIN projects p ON p.id = pgf.project_id
+			 WHERE pgf.normalized_remote_url = ?
+			 ORDER BY p.last_updated DESC, p.id DESC`,
+		)
+		.all(normalizedRemoteUrl) as ProjectRow[];
+	return Object.freeze(rows.map(rowToProject));
+}
+
+export function listProjectGitFingerprints(
+	projectId: string,
+	db?: Database,
+): readonly ProjectGitFingerprint[] {
+	const d = resolveDb(db);
+	const rows = d
+		.query(
+			`SELECT *
+			 FROM project_git_fingerprints
+			 WHERE project_id = ?
+			 ORDER BY last_updated DESC, normalized_remote_url ASC`,
+		)
+		.all(projectId) as ProjectFingerprintRow[];
+	return Object.freeze(rows.map(rowToProjectFingerprint));
+}