@kodrunhq/opencode-autopilot 1.15.2 → 1.17.0

package/src/health/checks.ts

@@ -4,11 +4,15 @@ import { join } from "node:path";
 import type { Config } from "@opencode-ai/plugin";
 import { parse } from "yaml";
 import { loadConfig } from "../config";
-import { DB_FILE, MEMORY_DIR } from "../memory/constants";
 import { AGENT_NAMES } from "../orchestrator/handlers/types";
 import { detectProjectStackTags, filterSkillsByStack } from "../skills/adaptive-injector";
 import { loadAllSkills } from "../skills/loader";
-import { getAssetsDir, getGlobalConfigDir } from "../utils/paths";
+import {
+	getAssetsDir,
+	getAutopilotDbPath,
+	getGlobalConfigDir,
+	getLegacyMemoryDbPath,
+} from "../utils/paths";
 import type { HealthResult } from "./types";
 
 /**
@@ -40,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",
@@ -249,19 +350,40 @@ export async function skillHealthCheck(
  */
 export async function memoryHealthCheck(baseDir?: string): Promise<HealthResult> {
 	const resolvedBase = baseDir ?? getGlobalConfigDir();
-	const dbPath = join(resolvedBase, MEMORY_DIR, DB_FILE);
+	const dbPath = getAutopilotDbPath(resolvedBase);
+	const legacyDbPath = getLegacyMemoryDbPath(resolvedBase);
 
 	try {
 		await access(dbPath);
 	} catch (error: unknown) {
 		const code = (error as NodeJS.ErrnoException).code;
 		if (code === "ENOENT") {
+			try {
+				await access(legacyDbPath);
+			} catch (legacyError: unknown) {
+				const legacyCode = (legacyError as NodeJS.ErrnoException).code;
+				if (legacyCode === "ENOENT") {
+					return Object.freeze({
+						name: "memory-db",
+						status: "pass" as const,
+						message: `Memory DB not yet initialized -- will be created on first memory capture`,
+					});
+				}
+				const legacyMsg = legacyError instanceof Error ? legacyError.message : String(legacyError);
+				return Object.freeze({
+					name: "memory-db",
+					status: "fail" as const,
+					message: `Memory DB inaccessible: ${legacyMsg}`,
+				});
+			}
+
 			return Object.freeze({
 				name: "memory-db",
 				status: "pass" as const,
-				message: `Memory DB not yet initialized -- will be created on first memory capture`,
+				message: `Legacy memory DB found -- unified DB will be created on next write`,
 			});
 		}
+
 		const msg = error instanceof Error ? error.message : String(error);
 		return Object.freeze({
 			name: "memory-db",

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,7 +4,13 @@ import { isFirstLoad, loadConfig } from "./config";
 import { runHealthChecks } from "./health/runner";
 import { createAntiSlopHandler } from "./hooks/anti-slop";
 import { installAssets } from "./installer";
-import { createMemoryCaptureHandler, createMemoryInjector, getMemoryDb } from "./memory";
+import { getLogger, initLoggers } from "./logging/domains";
+import {
+	createMemoryCaptureHandler,
+	createMemoryChatMessageHandler,
+	createMemoryInjector,
+	getMemoryDb,
+} from "./memory";
 import { ContextMonitor } from "./observability/context-monitor";
 import {
 	createObservabilityEventHandler,
@@ -12,9 +18,9 @@ import {
 	createToolExecuteBeforeHandler,
 } from "./observability/event-handlers";
 import { SessionEventStore } from "./observability/event-store";
+import { createForensicEvent } from "./observability/forensic-log";
 import { writeSessionLog } from "./observability/log-writer";
 import { pruneOldLogs } from "./observability/retention";
-import type { SessionEvent } from "./observability/types";
 import type { SdkOperations } from "./orchestrator/fallback";
 import {
 	createChatMessageHandler,
@@ -38,6 +44,7 @@ import { ocDoctor, setOpenCodeConfig as setDoctorOpenCodeConfig } from "./tools/
 import { ocForensics } from "./tools/forensics";
 import { ocHashlineEdit } from "./tools/hashline-edit";
 import { ocLogs } from "./tools/logs";
+import { ocMemoryPreferences } from "./tools/memory-preferences";
 import { ocMemoryStatus } from "./tools/memory-status";
 import { ocMockFallback } from "./tools/mock-fallback";
 import { ocOrchestrate } from "./tools/orchestrate";
@@ -49,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).
@@ -96,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 ---
@@ -148,6 +176,29 @@ const plugin: Plugin = async (input) => {
 		manager,
 		sdk: sdkOps,
 		config: fallbackConfig,
+		onFallbackEvent: (event) => {
+			if (event.type === "fallback") {
+				eventStore.appendEvent(event.sessionId, {
+					type: "fallback",
+					timestamp: new Date().toISOString(),
+					sessionId: event.sessionId,
+					failedModel: event.failedModel ?? "unknown",
+					nextModel: event.nextModel ?? "unknown",
+					reason: event.reason ?? "fallback",
+					success: event.success === true,
+				});
+				return;
+			}
+
+			eventStore.appendEvent(event.sessionId, {
+				type: "model_switch",
+				timestamp: new Date().toISOString(),
+				sessionId: event.sessionId,
+				fromModel: event.fromModel ?? "unknown",
+				toModel: event.toModel ?? "unknown",
+				trigger: event.trigger ?? "fallback",
+			});
+		},
 	});
 	const chatMessageHandler = createChatMessageHandler(manager);
 	const toolExecuteAfterHandler = createToolExecuteAfterHandler(manager);
@@ -165,6 +216,9 @@ const plugin: Plugin = async (input) => {
 	const memoryCaptureHandler = memoryConfig.enabled
 		? createMemoryCaptureHandler({ getDb: () => getMemoryDb(), projectRoot: process.cwd() })
 		: null;
+	const memoryChatMessageHandler = memoryConfig.enabled
+		? createMemoryChatMessageHandler({ getDb: () => getMemoryDb(), projectRoot: process.cwd() })
+		: null;
 
 	const memoryInjector = memoryConfig.enabled
 		? createMemoryInjector({
@@ -183,18 +237,73 @@ const plugin: Plugin = async (input) => {
 		showToast: sdkOps.showToast,
 		writeSessionLog: async (sessionData) => {
 			if (!sessionData) return;
-			// Filter to schema-valid event types that match SessionEvent discriminated union
-			const schemaEvents: SessionEvent[] = sessionData.events.filter(
-				(e): e is SessionEvent =>
-					e.type === "fallback" ||
-					e.type === "error" ||
-					e.type === "decision" ||
-					e.type === "model_switch",
-			);
 			await writeSessionLog({
+				projectRoot: process.cwd(),
 				sessionId: sessionData.sessionId,
 				startedAt: sessionData.startedAt,
-				events: schemaEvents,
+				events: sessionData.events.map((event) =>
+					createForensicEvent({
+						projectRoot: process.cwd(),
+						domain: "session",
+						timestamp: event.timestamp,
+						sessionId: event.sessionId,
+						type: event.type,
+						message: event.type === "error" ? event.message : null,
+						code:
+							event.type === "error"
+								? event.errorType
+								: event.type === "fallback"
+									? "FALLBACK"
+									: null,
+						payload:
+							event.type === "error"
+								? {
+										model: event.model,
+										errorType: event.errorType,
+										...(event.statusCode !== undefined ? { statusCode: event.statusCode } : {}),
+									}
+								: event.type === "fallback"
+									? {
+											failedModel: event.failedModel,
+											nextModel: event.nextModel,
+											reason: event.reason,
+											success: event.success,
+										}
+									: event.type === "decision"
+										? {
+												decision: event.decision,
+												rationale: event.rationale,
+											}
+										: event.type === "model_switch"
+											? {
+													fromModel: event.fromModel,
+													toModel: event.toModel,
+													trigger: event.trigger,
+												}
+											: event.type === "context_warning"
+												? {
+														utilization: event.utilization,
+														contextLimit: event.contextLimit,
+														inputTokens: event.inputTokens,
+													}
+												: event.type === "tool_complete"
+													? {
+															tool: event.tool,
+															durationMs: event.durationMs,
+															success: event.success,
+														}
+													: event.type === "phase_transition"
+														? {
+																fromPhase: event.fromPhase,
+																toPhase: event.toPhase,
+															}
+														: event.type === "compacted"
+															? {
+																	trigger: event.trigger,
+																}
+															: {},
+					}),
+				),
 			});
 		},
 	});
@@ -220,10 +329,12 @@ 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,
 			oc_memory_status: ocMemoryStatus,
+			oc_memory_preferences: ocMemoryPreferences,
 		},
 		event: async ({ event }) => {
 			// 1. Observability: collect (pure observer, no side effects on session)
@@ -269,6 +380,10 @@ const plugin: Plugin = async (input) => {
 				parts: unknown[];
 			},
 		) => {
+			if (memoryChatMessageHandler) {
+				await memoryChatMessageHandler(hookInput, output);
+			}
+
 			if (fallbackConfig.enabled) {
 				await chatMessageHandler(hookInput, output);
 			}

package/src/inspect/formatters.ts

@@ -0,0 +1,225 @@
+import type {
+	InspectEventSummary,
+	InspectLessonSummary,
+	InspectMemoryOverview,
+	InspectPreferenceSummary,
+	InspectProjectDetails,
+	InspectProjectSummary,
+	InspectRunSummary,
+} from "./repository";
+
+function sanitizeCell(value: string | number | boolean | null): string {
+	return String(value ?? "")
+		.replace(/\|/g, "\\|")
+		.replace(/\n/g, " ");
+}
+
+function formatTimestamp(value: string | null): string {
+	return value ?? "-";
+}
+
+export function formatProjects(projects: readonly InspectProjectSummary[]): string {
+	if (projects.length === 0) {
+		return "No projects found.";
+	}
+
+	const lines = [
+		"Projects",
+		"",
+		"| Project | Current Path | Updated | Runs | Events | Lessons |",
+		"|---------|--------------|---------|------|--------|---------|",
+	];
+
+	for (const project of projects) {
+		lines.push(
+			`| ${sanitizeCell(project.name)} | ${sanitizeCell(project.path)} | ${sanitizeCell(project.lastUpdated)} | ${project.runCount} | ${project.eventCount} | ${project.lessonCount} |`,
+		);
+	}
+
+	return lines.join("\n");
+}
+
+export function formatProjectDetails(details: InspectProjectDetails): string {
+	const { project, paths, gitFingerprints } = details;
+	const lines = [
+		`Project: ${project.name}`,
+		"",
+		`ID: ${project.id}`,
+		`Current Path: ${project.path}`,
+		`First Seen: ${project.firstSeenAt}`,
+		`Last Updated: ${project.lastUpdated}`,
+		`Runs: ${project.runCount}`,
+		`Events: ${project.eventCount}`,
+		`Lessons: ${project.lessonCount}`,
+		`Observations: ${project.observationCount}`,
+		"",
+		"Paths:",
+	];
+
+	if (paths.length === 0) {
+		lines.push("- none");
+	} else {
+		for (const path of paths) {
+			lines.push(`- ${path.path}${path.isCurrent ? " [current]" : ""}`);
+		}
+	}
+
+	lines.push("", "Git Fingerprints:");
+	if (gitFingerprints.length === 0) {
+		lines.push("- none");
+	} else {
+		for (const fingerprint of gitFingerprints) {
+			lines.push(
+				`- ${fingerprint.normalizedRemoteUrl}${fingerprint.defaultBranch ? ` (${fingerprint.defaultBranch})` : ""}`,
+			);
+		}
+	}
+
+	return lines.join("\n");
+}
+
+export function formatRuns(runs: readonly InspectRunSummary[]): string {
+	if (runs.length === 0) {
+		return "No runs found.";
+	}
+
+	const lines = [
+		"Runs",
+		"",
+		"| Project | Run ID | Status | Phase | Revision | Updated |",
+		"|---------|--------|--------|-------|----------|---------|",
+	];
+
+	for (const run of runs) {
+		lines.push(
+			`| ${sanitizeCell(run.projectName)} | ${sanitizeCell(run.runId)} | ${sanitizeCell(run.status)} | ${sanitizeCell(run.currentPhase ?? "-")} | ${run.stateRevision} | ${sanitizeCell(run.lastUpdatedAt)} |`,
+		);
+	}
+
+	return lines.join("\n");
+}
+
+export function formatEvents(events: readonly InspectEventSummary[]): string {
+	if (events.length === 0) {
+		return "No events found.";
+	}
+
+	const lines = [
+		"Events",
+		"",
+		"| Timestamp | Project | Domain | Type | Phase | Agent | Code | Message |",
+		"|-----------|---------|--------|------|-------|-------|------|---------|",
+	];
+
+	for (const event of events) {
+		lines.push(
+			`| ${sanitizeCell(event.timestamp)} | ${sanitizeCell(event.projectName)} | ${sanitizeCell(event.domain)} | ${sanitizeCell(event.type)} | ${sanitizeCell(event.phase ?? "-")} | ${sanitizeCell(event.agent ?? "-")} | ${sanitizeCell(event.code ?? "-")} | ${sanitizeCell(event.message ?? "")} |`,
+		);
+	}
+
+	return lines.join("\n");
+}
+
+export function formatLessons(lessons: readonly InspectLessonSummary[]): string {
+	if (lessons.length === 0) {
+		return "No lessons found.";
+	}
+
+	const lines = [
+		"Lessons",
+		"",
+		"| Extracted | Project | Domain | Source Phase | Content |",
+		"|-----------|---------|--------|--------------|---------|",
+	];
+
+	for (const lesson of lessons) {
+		lines.push(
+			`| ${sanitizeCell(lesson.extractedAt)} | ${sanitizeCell(lesson.projectName)} | ${sanitizeCell(lesson.domain)} | ${sanitizeCell(lesson.sourcePhase)} | ${sanitizeCell(lesson.content)} |`,
+		);
+	}
+
+	return lines.join("\n");
+}
+
+export function formatPreferences(preferences: readonly InspectPreferenceSummary[]): string {
+	if (preferences.length === 0) {
+		return "No preferences found.";
+	}
+
+	const lines = [
+		"Preferences",
+		"",
+		"| Key | Scope | Value | Confidence | Evidence | Updated |",
+		"|-----|-------|-------|------------|----------|---------|",
+	];
+
+	for (const preference of preferences) {
+		lines.push(
+			`| ${sanitizeCell(preference.key)} | ${sanitizeCell(preference.scope)}${preference.projectId ? `:${sanitizeCell(preference.projectId)}` : ""} | ${sanitizeCell(preference.value)} | ${sanitizeCell(preference.confidence)} | ${sanitizeCell(preference.evidenceCount)} | ${sanitizeCell(preference.lastUpdated)} |`,
+		);
+	}
+
+	return lines.join("\n");
+}
+
+export function formatMemoryOverview(overview: InspectMemoryOverview): string {
+	const lines = [
+		"Memory Overview",
+		"",
+		`Total observations: ${overview.stats.totalObservations}`,
+		`Total projects: ${overview.stats.totalProjects}`,
+		`Total preferences: ${overview.stats.totalPreferences}`,
+		`Storage size: ${overview.stats.storageSizeKb} KB`,
+		"",
+		"Observations by type:",
+	];
+
+	for (const [type, count] of Object.entries(overview.stats.observationsByType)) {
+		lines.push(`- ${type}: ${count}`);
+	}
+
+	lines.push("", "Recent observations:");
+	if (overview.recentObservations.length === 0) {
+		lines.push("- none");
+	} else {
+		for (const observation of overview.recentObservations) {
+			lines.push(
+				`- [${observation.type}] ${observation.summary} (${formatTimestamp(observation.createdAt)})`,
+			);
+		}
+	}
+
+	lines.push("", "Preferences:");
+	if (overview.preferences.length === 0) {
+		lines.push("- none");
+	} else {
+		for (const preference of overview.preferences) {
+			lines.push(
+				`- ${preference.key}: ${preference.value} (${preference.scope}, confidence ${preference.confidence}, evidence ${preference.evidenceCount})`,
+			);
+		}
+	}
+
+	return lines.join("\n");
+}
+
+export function formatPaths(details: InspectProjectDetails): string {
+	if (details.paths.length === 0) {
+		return `No paths found for ${details.project.name}.`;
+	}
+
+	const lines = [
+		`Paths for ${details.project.name}`,
+		"",
+		"| Path | Current | First Seen | Last Updated |",
+		"|------|---------|------------|--------------|",
+	];
+
+	for (const path of details.paths) {
+		lines.push(
+			`| ${sanitizeCell(path.path)} | ${path.isCurrent ? "yes" : "no"} | ${sanitizeCell(path.firstSeenAt)} | ${sanitizeCell(path.lastUpdated)} |`,
+		);
+	}
+
+	return lines.join("\n");
+}