@kodrunhq/opencode-autopilot 1.15.1 → 1.16.0

package/src/health/runner.ts

@@ -5,6 +5,7 @@ import {
 	commandHealthCheck,
 	configHealthCheck,
 	memoryHealthCheck,
+	nativeAgentSuppressionHealthCheck,
 	skillHealthCheck,
 } from "./checks";
 import type { HealthReport, HealthResult } from "./types";
@@ -45,6 +46,7 @@ export async function runHealthChecks(options?: {
 	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),
@@ -54,6 +56,7 @@ export async function runHealthChecks(options?: {
 	const fallbackNames = [
 		"config-validity",
 		"agent-injection",
+		"native-agent-suppression",
 		"asset-directories",
 		"skill-loading",
 		"memory-db",

package/src/index.ts

@@ -4,7 +4,12 @@ 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 {
+	createMemoryCaptureHandler,
+	createMemoryChatMessageHandler,
+	createMemoryInjector,
+	getMemoryDb,
+} from "./memory";
 import { ContextMonitor } from "./observability/context-monitor";
 import {
 	createObservabilityEventHandler,
@@ -12,9 +17,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,
@@ -34,10 +39,11 @@ import {
 import { ocCreateAgent } from "./tools/create-agent";
 import { ocCreateCommand } from "./tools/create-command";
 import { ocCreateSkill } from "./tools/create-skill";
-import { ocDoctor } from "./tools/doctor";
+import { ocDoctor, setOpenCodeConfig as setDoctorOpenCodeConfig } from "./tools/doctor";
 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";
@@ -148,6 +154,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 +194,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 +215,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,
+																}
+															: {},
+					}),
+				),
 			});
 		},
 	});
@@ -224,6 +311,7 @@ const plugin: Plugin = async (input) => {
 			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)
@@ -255,6 +343,7 @@ const plugin: Plugin = async (input) => {
 		config: async (cfg: Config) => {
 			openCodeConfig = cfg;
 			setOpenCodeConfig(cfg);
+			setDoctorOpenCodeConfig(cfg);
 			await configHook(cfg);
 		},
 		"chat.message": async (
@@ -268,6 +357,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");
+}