@kodrunhq/opencode-autopilot 1.16.0 → 1.17.0

package/bin/inspect.ts

@@ -249,7 +249,7 @@ export async function inspectCliCore(
 			);
 		}
 		case "project": {
-			const details = getProjectDetails(parsed.projectRef!, dbInput);
+			const details = getProjectDetails(parsed.projectRef ?? "", dbInput);
 			if (details === null) {
 				return makeError(`Project not found: ${parsed.projectRef}`, parsed.json);
 			}
@@ -260,7 +260,7 @@ export async function inspectCliCore(
 			);
 		}
 		case "paths": {
-			const details = getProjectDetails(parsed.projectRef!, dbInput);
+			const details = getProjectDetails(parsed.projectRef ?? "", dbInput);
 			if (details === null) {
 				return makeError(`Project not found: ${parsed.projectRef}`, parsed.json);
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kodrunhq/opencode-autopilot",
-	"version": "1.16.0",
+	"version": "1.17.0",
 	"description": "Curated agents, skills, and commands for the OpenCode AI coding CLI — autonomous orchestrator, multi-agent code review, model fallback, and in-session asset creation tools.",
 	"main": "src/index.ts",
 	"keywords": [

package/src/config/index.ts

@@ -0,0 +1,29 @@
+export {
+	CONFIG_PATH,
+	confidenceConfigSchema,
+	confidenceDefaults,
+	createDefaultConfig,
+	isFirstLoad,
+	loadConfig,
+	memoryConfigSchema,
+	memoryDefaults,
+	orchestratorConfigSchema,
+	orchestratorDefaults,
+	type PluginConfig,
+	pluginConfigSchema,
+	saveConfig,
+} from "../config";
+// Re-export migration schemas and functions for backward compatibility
+export {
+	migrateV1toV2,
+	migrateV2toV3,
+	migrateV3toV4,
+	migrateV4toV5,
+	migrateV5toV6,
+	pluginConfigSchemaV1,
+	pluginConfigSchemaV2,
+	pluginConfigSchemaV3,
+	pluginConfigSchemaV4,
+	pluginConfigSchemaV5,
+} from "./migrations";
+export { migrateV6toV7, type PluginConfigV7, v7ConfigDefaults } from "./v7";

package/src/config/migrations.ts

@@ -0,0 +1,196 @@
+import { z } from "zod";
+import {
+	confidenceConfigSchema,
+	confidenceDefaults,
+	memoryConfigSchema,
+	memoryDefaults,
+	orchestratorConfigSchema,
+	orchestratorDefaults,
+} from "../config";
+import {
+	fallbackConfigSchema,
+	fallbackDefaults,
+	testModeDefaults,
+} from "../orchestrator/fallback/fallback-config";
+import { AGENT_REGISTRY, ALL_GROUP_IDS } from "../registry/model-groups";
+
+export const pluginConfigSchemaV1 = z.object({
+	version: z.literal(1),
+	configured: z.boolean(),
+	models: z.record(z.string(), z.string()),
+});
+
+export type PluginConfigV1 = z.infer<typeof pluginConfigSchemaV1>;
+
+export const pluginConfigSchemaV2 = z.object({
+	version: z.literal(2),
+	configured: z.boolean(),
+	models: z.record(z.string(), z.string()),
+	orchestrator: orchestratorConfigSchema.default(orchestratorDefaults),
+	confidence: confidenceConfigSchema.default(confidenceDefaults),
+});
+
+export type PluginConfigV2 = z.infer<typeof pluginConfigSchemaV2>;
+
+export const pluginConfigSchemaV3 = z.object({
+	version: z.literal(3),
+	configured: z.boolean(),
+	models: z.record(z.string(), z.string()),
+	orchestrator: orchestratorConfigSchema.default(orchestratorDefaults),
+	confidence: confidenceConfigSchema.default(confidenceDefaults),
+	fallback: fallbackConfigSchema.default(fallbackDefaults),
+	fallback_models: z.union([z.string(), z.array(z.string())]).optional(),
+});
+
+export type PluginConfigV3 = z.infer<typeof pluginConfigSchemaV3>;
+
+const groupModelAssignmentSchema = z.object({
+	primary: z.string().min(1),
+	fallbacks: z.array(z.string().min(1)).default([]),
+});
+
+const agentOverrideSchema = z.object({
+	primary: z.string().min(1),
+	fallbacks: z.array(z.string().min(1)).optional(),
+});
+
+export const pluginConfigSchemaV4 = z
+	.object({
+		version: z.literal(4),
+		configured: z.boolean(),
+		groups: z.record(z.string(), groupModelAssignmentSchema).default({}),
+		overrides: z.record(z.string(), agentOverrideSchema).default({}),
+		orchestrator: orchestratorConfigSchema.default(orchestratorDefaults),
+		confidence: confidenceConfigSchema.default(confidenceDefaults),
+		fallback: fallbackConfigSchema.default(fallbackDefaults),
+	})
+	.superRefine((config, ctx) => {
+		for (const groupId of Object.keys(config.groups)) {
+			if (!ALL_GROUP_IDS.includes(groupId as (typeof ALL_GROUP_IDS)[number])) {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					path: ["groups", groupId],
+					message: `Unknown group id "${groupId}". Expected one of: ${ALL_GROUP_IDS.join(", ")}`,
+				});
+			}
+		}
+	});
+
+export type PluginConfigV4 = z.infer<typeof pluginConfigSchemaV4>;
+
+export const pluginConfigSchemaV5 = z
+	.object({
+		version: z.literal(5),
+		configured: z.boolean(),
+		groups: z.record(z.string(), groupModelAssignmentSchema).default({}),
+		overrides: z.record(z.string(), agentOverrideSchema).default({}),
+		orchestrator: orchestratorConfigSchema.default(orchestratorDefaults),
+		confidence: confidenceConfigSchema.default(confidenceDefaults),
+		fallback: fallbackConfigSchema.default(fallbackDefaults),
+		memory: memoryConfigSchema.default(memoryDefaults),
+	})
+	.superRefine((config, ctx) => {
+		for (const groupId of Object.keys(config.groups)) {
+			if (!ALL_GROUP_IDS.includes(groupId as (typeof ALL_GROUP_IDS)[number])) {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					path: ["groups", groupId],
+					message: `Unknown group id "${groupId}". Expected one of: ${ALL_GROUP_IDS.join(", ")}`,
+				});
+			}
+		}
+	});
+
+export type PluginConfigV5 = z.infer<typeof pluginConfigSchemaV5>;
+
+export function migrateV1toV2(v1Config: PluginConfigV1): PluginConfigV2 {
+	return {
+		version: 2 as const,
+		configured: v1Config.configured,
+		models: v1Config.models,
+		orchestrator: orchestratorDefaults,
+		confidence: confidenceDefaults,
+	};
+}
+
+export function migrateV2toV3(v2Config: PluginConfigV2): PluginConfigV3 {
+	return {
+		version: 3 as const,
+		configured: v2Config.configured,
+		models: v2Config.models,
+		orchestrator: v2Config.orchestrator,
+		confidence: v2Config.confidence,
+		fallback: fallbackDefaults,
+	};
+}
+
+export function migrateV3toV4(v3Config: PluginConfigV3): PluginConfigV4 {
+	const groups: Record<string, { primary: string; fallbacks: string[] }> = {};
+	const overrides: Record<string, { primary: string }> = {};
+
+	for (const [agentName, modelId] of Object.entries(v3Config.models)) {
+		const entry = AGENT_REGISTRY[agentName];
+		if (!entry) {
+			overrides[agentName] = { primary: modelId };
+			continue;
+		}
+
+		const groupId = entry.group;
+		if (!groups[groupId]) {
+			groups[groupId] = { primary: modelId, fallbacks: [] };
+		} else if (groups[groupId].primary !== modelId) {
+			overrides[agentName] = { primary: modelId };
+		}
+	}
+
+	const globalFallbacks = v3Config.fallback_models
+		? typeof v3Config.fallback_models === "string"
+			? [v3Config.fallback_models]
+			: [...v3Config.fallback_models]
+		: [];
+
+	for (const group of Object.values(groups)) {
+		if (group.fallbacks.length === 0 && globalFallbacks.length > 0) {
+			group.fallbacks = [...globalFallbacks];
+		}
+	}
+
+	return {
+		version: 4 as const,
+		configured: v3Config.configured,
+		groups,
+		overrides,
+		orchestrator: v3Config.orchestrator,
+		confidence: v3Config.confidence,
+		fallback: v3Config.fallback,
+	};
+}
+
+export function migrateV4toV5(v4Config: PluginConfigV4): PluginConfigV5 {
+	return {
+		version: 5 as const,
+		configured: v4Config.configured,
+		groups: v4Config.groups,
+		overrides: v4Config.overrides,
+		orchestrator: v4Config.orchestrator,
+		confidence: v4Config.confidence,
+		fallback: v4Config.fallback,
+		memory: memoryDefaults,
+	};
+}
+
+export function migrateV5toV6(
+	v5Config: PluginConfigV5,
+	_fallbackDefaultsV6: typeof fallbackDefaults,
+) {
+	return {
+		version: 6 as const,
+		configured: v5Config.configured,
+		groups: v5Config.groups,
+		overrides: v5Config.overrides,
+		orchestrator: v5Config.orchestrator,
+		confidence: v5Config.confidence,
+		fallback: { ...v5Config.fallback, testMode: testModeDefaults },
+		memory: v5Config.memory,
+	};
+}

package/src/config/v7.ts

@@ -0,0 +1,45 @@
+import type { PluginConfig } from "../config";
+
+export type PluginConfigV7 = Omit<PluginConfig, "version"> & {
+	readonly version: 7;
+	readonly background?: {
+		readonly enabled: boolean;
+		readonly maxConcurrent: number;
+		readonly defaultTimeout: number;
+	};
+	readonly autonomy?: {
+		readonly enabled: boolean;
+		readonly verification: "strict" | "normal" | "lenient";
+		readonly maxIterations: number;
+	};
+};
+
+export function migrateV6toV7(v6Config: PluginConfig): PluginConfigV7 {
+	return {
+		...v6Config,
+		version: 7,
+		background: {
+			enabled: true,
+			maxConcurrent: 5,
+			defaultTimeout: 300000,
+		},
+		autonomy: {
+			enabled: false,
+			verification: "normal",
+			maxIterations: 10,
+		},
+	};
+}
+
+export const v7ConfigDefaults = {
+	background: {
+		enabled: true,
+		maxConcurrent: 5,
+		defaultTimeout: 300000,
+	},
+	autonomy: {
+		enabled: false,
+		verification: "normal",
+		maxIterations: 10,
+	},
+} as const;

package/src/config.ts

@@ -53,8 +53,8 @@ export const confidenceConfigSchema = z.object({
 });
 
 // Pre-compute full defaults for nested schema defaults
-const orchestratorDefaults = orchestratorConfigSchema.parse({});
-const confidenceDefaults = confidenceConfigSchema.parse({});
+export const orchestratorDefaults = orchestratorConfigSchema.parse({});
+export const confidenceDefaults = confidenceConfigSchema.parse({});
 
 // --- V2 schema (internal, for migration) ---
 
@@ -90,7 +90,7 @@ export const memoryConfigSchema = z.object({
 	decayHalfLifeDays: z.number().min(7).max(365).default(90),
 });
 
-const memoryDefaults = memoryConfigSchema.parse({});
+export const memoryDefaults = memoryConfigSchema.parse({});
 
 // --- V4 sub-schemas ---
 

package/src/health/checks.ts

@@ -44,6 +44,103 @@ export async function configHealthCheck(configPath?: string): Promise<HealthResu
 	}
 }
 
+const LATEST_CONFIG_VERSION = 6;
+
+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}`,
+		});
+	}
+}
+
 /** Standard agent names, derived from the agents barrel export. */
 const STANDARD_AGENT_NAMES: readonly string[] = Object.freeze([
 	"researcher",

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