@kodrunhq/opencode-autopilot 1.18.0 → 1.19.0

package/src/orchestrator/skill-injection.ts

@@ -9,6 +9,7 @@
 
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
+import { getLogger } from "../logging/domains";
 import { sanitizeTemplateContent } from "../review/sanitize";
 import {
 	buildAdaptiveSkillContext,
@@ -20,6 +21,7 @@ import { loadAllSkills } from "../skills/loader";
 import { isEnoentError } from "../utils/fs-helpers";
 
 const MAX_SKILL_LENGTH = 2048;
+const logger = getLogger("orchestrator", "skill-injection");
 
 /**
  * Load the coding-standards skill content from the global config dir.
@@ -74,6 +76,7 @@ export async function loadAdaptiveSkillContext(
 		readonly phase?: string;
 		readonly budget?: number;
 		readonly mode?: SkillMode;
+		readonly mcpEnabled?: boolean;
 	},
 ): Promise<string> {
 	try {
@@ -89,7 +92,10 @@ export async function loadAdaptiveSkillContext(
 		return buildAdaptiveSkillContext(matchingSkills, options);
 	} catch (err) {
 		// Best-effort: all errors return empty string.
-		console.warn("[opencode-autopilot] adaptive skill load failed:", err);
+		logger.warn("adaptive skill load failed", {
+			operation: "skill_injection",
+			error: err instanceof Error ? err.message : String(err),
+		});
 		return "";
 	}
 }

package/src/orchestrator/state.ts

@@ -3,6 +3,7 @@ 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 { getLogger } from "../logging/domains";
 import { ensureDir, isEnoentError } from "../utils/fs-helpers";
 import { assertStateInvariants } from "./contracts/invariants";
 import { PHASES, pipelineStateSchema } from "./schemas";
@@ -10,6 +11,7 @@ import type { PipelineState } from "./types";
 
 const STATE_FILE = "state.json";
 let legacyStateMirrorWarned = false;
+const logger = getLogger("orchestrator", "state");
 
 function generateRunId(): string {
 	return `run_${randomBytes(8).toString("hex")}`;
@@ -70,7 +72,10 @@ async function syncLegacyStateMirror(state: PipelineState, artifactDir: string):
 	} catch (error: unknown) {
 		if (!legacyStateMirrorWarned) {
 			legacyStateMirrorWarned = true;
-			console.warn("[opencode-autopilot] state.json mirror write failed:", error);
+			logger.warn("state.json mirror write failed", {
+				operation: "legacy_state_mirror",
+				error: error instanceof Error ? error.message : String(error),
+			});
 		}
 	}
 }

package/src/recovery/classifier.ts

@@ -0,0 +1,127 @@
+import type { ErrorCategory } from "../types/recovery";
+import { ErrorCategorySchema } from "../types/recovery";
+import type { ClassificationResult } from "./types";
+
+const CLASSIFICATION_RULES: readonly {
+	readonly category: ErrorCategory;
+	readonly patterns: readonly RegExp[];
+	readonly confidence: number;
+	readonly reasoning: string;
+}[] = Object.freeze([
+	{
+		category: "empty_content",
+		patterns: [/empty\s+content/i, /no\s+content/i, /empty\s+response/i],
+		confidence: 0.98,
+		reasoning: "Matched empty response pattern",
+	},
+	{
+		category: "thinking_block_error",
+		patterns: [/thinking\s+block/i, /reasoning\s+failed/i],
+		confidence: 0.97,
+		reasoning: "Matched reasoning failure pattern",
+	},
+	{
+		category: "tool_result_overflow",
+		patterns: [/result\s+too\s+large/i, /output\s+exceeded/i, /overflow/i],
+		confidence: 0.97,
+		reasoning: "Matched oversized tool output pattern",
+	},
+	{
+		category: "context_window_exceeded",
+		patterns: [/context\s+window/i, /token\s+limit/i, /max\s+tokens/i, /context\s+length/i],
+		confidence: 0.98,
+		reasoning: "Matched context exhaustion pattern",
+	},
+	{
+		category: "session_corruption",
+		patterns: [/session\s+corrupt/i, /invalid\s+state/i, /state\s+mismatch/i],
+		confidence: 0.99,
+		reasoning: "Matched session state corruption pattern",
+	},
+	{
+		category: "agent_loop_stuck",
+		patterns: [/loop\s+detected/i, /infinite\s+loop/i, /stuck/i, /no\s+progress/i],
+		confidence: 0.95,
+		reasoning: "Matched agent loop or no-progress pattern",
+	},
+	{
+		category: "rate_limit",
+		patterns: [/rate\s*limit/i, /too\s+many\s+requests/i, /\b429\b/],
+		confidence: 0.96,
+		reasoning: "Matched rate limit pattern",
+	},
+	{
+		category: "auth_failure",
+		patterns: [/auth/i, /unauthori[sz]ed/i, /forbidden/i, /api\s*key/i, /credential/i],
+		confidence: 0.94,
+		reasoning: "Matched authentication or authorization pattern",
+	},
+	{
+		category: "quota_exceeded",
+		patterns: [/quota/i, /credit\s+balance/i, /insufficient\s+(credits?|funds?|balance)/i],
+		confidence: 0.96,
+		reasoning: "Matched quota exhaustion pattern",
+	},
+	{
+		category: "service_unavailable",
+		patterns: [/service\s+unavailable/i, /temporarily\s+unavailable/i, /overloaded/i, /\b503\b/],
+		confidence: 0.95,
+		reasoning: "Matched service availability pattern",
+	},
+	{
+		category: "timeout",
+		patterns: [/timeout/i, /timed\s+out/i, /deadline\s+exceeded/i],
+		confidence: 0.94,
+		reasoning: "Matched timeout pattern",
+	},
+	{
+		category: "network",
+		patterns: [/network/i, /connection\s+reset/i, /socket\s+hang\s+up/i, /econnreset/i],
+		confidence: 0.93,
+		reasoning: "Matched network transport pattern",
+	},
+	{
+		category: "validation",
+		patterns: [/validation/i, /invalid\s+request/i, /malformed/i, /schema/i],
+		confidence: 0.92,
+		reasoning: "Matched validation pattern",
+	},
+]);
+
+const NON_RECOVERABLE_CATEGORIES = new Set<ErrorCategory>(["auth_failure", "session_corruption"]);
+
+function getErrorMessage(error: Error | string): string {
+	return typeof error === "string" ? error : error.message;
+}
+
+function isKnownBaseCategory(category: string): category is ErrorCategory {
+	return ErrorCategorySchema.safeParse(category).success;
+}
+
+export function classifyError(
+	error: Error | string,
+	context?: Record<string, unknown>,
+): ClassificationResult {
+	const message = getErrorMessage(error);
+	const contextText = context ? JSON.stringify(context) : "";
+	const haystack = `${message}\n${contextText}`;
+
+	for (const rule of CLASSIFICATION_RULES) {
+		if (rule.patterns.some((pattern) => pattern.test(haystack))) {
+			return Object.freeze({
+				category: rule.category,
+				confidence: rule.confidence,
+				reasoning: rule.reasoning,
+				isRecoverable: !NON_RECOVERABLE_CATEGORIES.has(rule.category),
+			});
+		}
+	}
+
+	const category: ErrorCategory = isKnownBaseCategory("unknown") ? "unknown" : "validation";
+	return Object.freeze({
+		category,
+		confidence: 0.35,
+		reasoning: "No known recovery pattern matched",
+		isRecoverable: !NON_RECOVERABLE_CATEGORIES.has(category),
+	});
+}

package/src/recovery/event-handler.ts

@@ -0,0 +1,263 @@
+import type { Database } from "bun:sqlite";
+import { getLogger } from "../logging/domains";
+import type { RecoveryAction } from "../types/recovery";
+import type { RecoveryOrchestrator } from "./orchestrator";
+import { clearRecoveryState } from "./persistence";
+
+const logger = getLogger("recovery", "event-handler");
+
+function getEventProperties(event: { readonly [key: string]: unknown }): Record<string, unknown> {
+	const properties = event.properties;
+	return properties !== null && typeof properties === "object"
+		? (properties as Record<string, unknown>)
+		: {};
+}
+
+function extractSessionId(properties: Record<string, unknown>): string | null {
+	if (typeof properties.sessionID === "string") {
+		return properties.sessionID;
+	}
+
+	const info = properties.info;
+	if (
+		info !== null &&
+		typeof info === "object" &&
+		typeof (info as Record<string, unknown>).id === "string"
+	) {
+		return (info as Record<string, unknown>).id as string;
+	}
+
+	if (
+		info !== null &&
+		typeof info === "object" &&
+		typeof (info as Record<string, unknown>).sessionID === "string"
+	) {
+		return (info as Record<string, unknown>).sessionID as string;
+	}
+
+	return null;
+}
+
+function extractError(properties: Record<string, unknown>): Error | string | null {
+	if (properties.error instanceof Error || typeof properties.error === "string") {
+		return properties.error;
+	}
+
+	const info = properties.info;
+	if (info !== null && typeof info === "object") {
+		const nestedError = (info as Record<string, unknown>).error;
+		if (nestedError instanceof Error || typeof nestedError === "string") {
+			return nestedError;
+		}
+		if (
+			nestedError !== null &&
+			typeof nestedError === "object" &&
+			typeof (nestedError as Record<string, unknown>).message === "string"
+		) {
+			return new Error((nestedError as Record<string, unknown>).message as string);
+		}
+	}
+
+	if (properties.error !== null && typeof properties.error === "object") {
+		const message = (properties.error as Record<string, unknown>).message;
+		if (typeof message === "string") {
+			return new Error(message);
+		}
+	}
+
+	return null;
+}
+
+export interface RecoverySdkOperations {
+	readonly abortSession?: (sessionId: string) => Promise<void>;
+	readonly showToast?: (title: string, message: string, variant: string) => Promise<void>;
+}
+
+function executeRecoveryAction(
+	action: RecoveryAction,
+	sessionId: string,
+	orchestrator: RecoveryOrchestrator,
+	sdk?: RecoverySdkOperations,
+): void {
+	logger.info("Executing recovery action", {
+		sessionId,
+		strategy: action.strategy,
+		errorCategory: action.errorCategory,
+		backoffMs: action.backoffMs,
+		maxAttempts: action.maxAttempts,
+	});
+
+	switch (action.strategy) {
+		case "retry": {
+			if (action.backoffMs > 0) {
+				setTimeout(() => {
+					orchestrator.recordResult(sessionId, true);
+					logger.info("Retry backoff completed", { sessionId, delayMs: action.backoffMs });
+				}, action.backoffMs);
+			} else {
+				orchestrator.recordResult(sessionId, true);
+			}
+			break;
+		}
+
+		case "fallback_model": {
+			orchestrator.recordResult(sessionId, true);
+			logger.info("Fallback model strategy triggered", {
+				sessionId,
+				metadata: action.metadata,
+			});
+			sdk
+				?.showToast?.(
+					"Recovery",
+					`Switching model for session (${action.errorCategory})`,
+					"warning",
+				)
+				.catch(() => {});
+			break;
+		}
+
+		case "compact_and_retry": {
+			if (action.backoffMs > 0) {
+				setTimeout(() => {
+					orchestrator.recordResult(sessionId, true);
+					logger.info("Compact and retry completed", { sessionId });
+				}, action.backoffMs);
+			} else {
+				orchestrator.recordResult(sessionId, true);
+			}
+			break;
+		}
+
+		case "restart_session": {
+			logger.info("Session restart requested", { sessionId });
+			if (sdk?.abortSession) {
+				sdk
+					.abortSession(sessionId)
+					.then(() => {
+						orchestrator.recordResult(sessionId, true);
+						logger.info("Session aborted for restart", { sessionId });
+					})
+					.catch((error: unknown) => {
+						orchestrator.recordResult(sessionId, false);
+						logger.warn("Failed to abort session for restart", {
+							sessionId,
+							error: error instanceof Error ? error.message : String(error),
+						});
+					});
+			} else {
+				orchestrator.recordResult(sessionId, false);
+				logger.warn("No SDK operations available for session restart", { sessionId });
+			}
+			break;
+		}
+
+		case "reduce_context": {
+			orchestrator.recordResult(sessionId, true);
+			logger.info("Context reduction strategy applied", { sessionId });
+			break;
+		}
+
+		case "skip_and_continue": {
+			orchestrator.recordResult(sessionId, true);
+			logger.info("Skipping failed step and continuing", { sessionId });
+			sdk
+				?.showToast?.("Recovery", "Skipped stuck step, continuing execution", "warning")
+				.catch(() => {});
+			break;
+		}
+
+		case "abort": {
+			orchestrator.recordResult(sessionId, false);
+			logger.warn("Recovery aborted — non-recoverable error", {
+				sessionId,
+				errorCategory: action.errorCategory,
+			});
+			sdk
+				?.showToast?.("Recovery Failed", `Unrecoverable error: ${action.errorCategory}`, "error")
+				.catch(() => {});
+			break;
+		}
+
+		case "user_prompt": {
+			orchestrator.recordResult(sessionId, false);
+			logger.info("User intervention required", { sessionId, errorCategory: action.errorCategory });
+			sdk
+				?.showToast?.("Action Required", `Recovery needs input: ${action.errorCategory}`, "warning")
+				.catch(() => {});
+			break;
+		}
+
+		default: {
+			orchestrator.recordResult(sessionId, false);
+			logger.warn("Unknown recovery strategy", { sessionId, strategy: action.strategy });
+		}
+	}
+}
+
+interface RecoveryEventHandlerOptions {
+	readonly orchestrator: RecoveryOrchestrator;
+	readonly db?: Database;
+	readonly sdk?: RecoverySdkOperations;
+}
+
+export function createRecoveryEventHandler(
+	orchestratorOrOptions: RecoveryOrchestrator | RecoveryEventHandlerOptions,
+) {
+	const options: RecoveryEventHandlerOptions =
+		orchestratorOrOptions instanceof Object && "orchestrator" in orchestratorOrOptions
+			? orchestratorOrOptions
+			: { orchestrator: orchestratorOrOptions };
+
+	const { orchestrator, db, sdk } = options;
+
+	return async (input: { event: { type: string; [key: string]: unknown } }): Promise<void> => {
+		try {
+			const { event } = input;
+			const properties = getEventProperties(event);
+
+			switch (event.type) {
+				case "session.error": {
+					const sessionId = extractSessionId(properties);
+					const error = extractError(properties);
+					if (!sessionId || !error) {
+						return;
+					}
+
+					const action = orchestrator.handleError(sessionId, error, properties);
+					if (action) {
+						executeRecoveryAction(action, sessionId, orchestrator, sdk);
+					}
+					return;
+				}
+
+				case "session.deleted": {
+					const sessionId = extractSessionId(properties);
+					if (!sessionId) {
+						return;
+					}
+
+					orchestrator.reset(sessionId);
+					if (db) {
+						try {
+							clearRecoveryState(db, sessionId);
+						} catch (error: unknown) {
+							logger.warn("Failed to clear persisted recovery state on session delete", {
+								sessionId,
+								error: error instanceof Error ? error.message : String(error),
+							});
+						}
+					}
+					logger.info("Recovery state cleared", { sessionId });
+					return;
+				}
+
+				default:
+					return;
+			}
+		} catch (error: unknown) {
+			logger.warn("Recovery event handling failed", {
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	};
+}

package/src/recovery/index.ts

@@ -0,0 +1,20 @@
+export { classifyError } from "./classifier";
+export { createRecoveryEventHandler } from "./event-handler";
+export {
+	createRecoveryOrchestratorWithDb,
+	getDefaultRecoveryOrchestrator,
+	RecoveryOrchestrator,
+} from "./orchestrator";
+export {
+	clearRecoveryState,
+	listRecoveryStates,
+	loadRecoveryState,
+	saveRecoveryState,
+} from "./persistence";
+export { getStrategy, type RecoveryStrategyResolver } from "./strategies";
+export type {
+	ClassificationResult,
+	RecoveryActionEnvelope,
+	RecoveryAttempt,
+	RecoveryState,
+} from "./types";

package/src/recovery/orchestrator.ts

@@ -0,0 +1,180 @@
+import type { Database } from "bun:sqlite";
+import { getLogger } from "../logging/domains";
+import type { Logger } from "../logging/types";
+import type { RecoveryAction } from "../types/recovery";
+import { classifyError } from "./classifier";
+import { clearRecoveryState, loadRecoveryState, saveRecoveryState } from "./persistence";
+import { getStrategy } from "./strategies";
+import type { RecoveryAttempt, RecoveryState } from "./types";
+
+interface RecoveryOrchestratorOptions {
+	readonly maxAttempts?: number;
+	readonly logger?: Logger;
+	readonly db?: Database;
+}
+
+function getErrorMessage(error: Error | string): string {
+	return typeof error === "string" ? error : error.message;
+}
+
+function cloneState(state: RecoveryState): RecoveryState {
+	return Object.freeze({
+		...state,
+		attempts: Object.freeze([...state.attempts]),
+	});
+}
+
+export class RecoveryOrchestrator {
+	private readonly maxAttempts: number;
+	private readonly logger: Logger;
+	private readonly db: Database | null;
+	private readonly states = new Map<string, RecoveryState>();
+
+	constructor(options: RecoveryOrchestratorOptions = {}) {
+		this.maxAttempts = options.maxAttempts ?? 3;
+		this.logger = options.logger ?? getLogger("recovery", "orchestrator");
+		this.db = options.db ?? null;
+	}
+
+	handleError(
+		sessionId: string,
+		error: Error | string,
+		context?: Record<string, unknown>,
+	): RecoveryAction | null {
+		const classification = classifyError(error, context);
+		if (!classification.isRecoverable) {
+			this.logger.warn("Recovery skipped for non-recoverable error", {
+				sessionId,
+				category: classification.category,
+			});
+			return null;
+		}
+
+		const previousState = this.states.get(sessionId) ??
+			this.loadFromDb(sessionId) ?? {
+				sessionId,
+				attempts: Object.freeze([]),
+				currentStrategy: null,
+				maxAttempts: this.maxAttempts,
+				isRecovering: false,
+				lastError: null,
+			};
+
+		if (previousState.attempts.length >= previousState.maxAttempts) {
+			this.logger.warn("Recovery attempt limit reached", {
+				sessionId,
+				attempts: previousState.attempts.length,
+				maxAttempts: previousState.maxAttempts,
+			});
+			return null;
+		}
+
+		const action = getStrategy(classification.category)(previousState);
+		const attempt: RecoveryAttempt = Object.freeze({
+			attemptNumber: previousState.attempts.length + 1,
+			strategy: action.strategy,
+			errorCategory: classification.category,
+			timestamp: new Date().toISOString(),
+			success: false,
+			error: getErrorMessage(error),
+		});
+
+		const nextState = cloneState({
+			sessionId,
+			attempts: Object.freeze([...previousState.attempts, attempt]),
+			currentStrategy: action.strategy,
+			maxAttempts: previousState.maxAttempts,
+			isRecovering: true,
+			lastError: getErrorMessage(error),
+		});
+
+		this.states.set(sessionId, nextState);
+		this.persistToDb(nextState);
+		return action;
+	}
+
+	getState(sessionId: string): RecoveryState | null {
+		const state = this.states.get(sessionId);
+		return state ? cloneState(state) : null;
+	}
+
+	reset(sessionId: string): void {
+		this.states.delete(sessionId);
+		this.clearFromDb(sessionId);
+	}
+
+	getHistory(sessionId: string): readonly RecoveryAttempt[] {
+		return this.getState(sessionId)?.attempts ?? Object.freeze([]);
+	}
+
+	recordResult(sessionId: string, success: boolean): void {
+		const state = this.states.get(sessionId);
+		if (!state || state.attempts.length === 0) {
+			return;
+		}
+
+		const lastAttempt = state.attempts[state.attempts.length - 1];
+		const updatedAttempt: RecoveryAttempt = Object.freeze({
+			...lastAttempt,
+			success,
+		});
+		const attempts = Object.freeze([...state.attempts.slice(0, -1), updatedAttempt]);
+		const nextState = cloneState({
+			...state,
+			attempts,
+			currentStrategy: success ? null : state.currentStrategy,
+			isRecovering: false,
+			lastError: success ? null : state.lastError,
+		});
+		this.states.set(sessionId, nextState);
+		this.persistToDb(nextState);
+	}
+
+	private loadFromDb(sessionId: string): RecoveryState | null {
+		if (!this.db) return null;
+		try {
+			return loadRecoveryState(this.db, sessionId);
+		} catch {
+			return null;
+		}
+	}
+
+	private persistToDb(state: RecoveryState): void {
+		if (!this.db) return;
+		try {
+			saveRecoveryState(this.db, state);
+		} catch (error) {
+			this.logger.warn("Failed to persist recovery state", {
+				sessionId: state.sessionId,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+
+	private clearFromDb(sessionId: string): void {
+		if (!this.db) return;
+		try {
+			clearRecoveryState(this.db, sessionId);
+		} catch (error) {
+			this.logger.warn("Failed to clear recovery state", {
+				sessionId,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+}
+
+let defaultRecoveryOrchestrator: RecoveryOrchestrator | null = null;
+
+export function getDefaultRecoveryOrchestrator(): RecoveryOrchestrator {
+	if (defaultRecoveryOrchestrator) {
+		return defaultRecoveryOrchestrator;
+	}
+
+	defaultRecoveryOrchestrator = new RecoveryOrchestrator();
+	return defaultRecoveryOrchestrator;
+}
+
+export function createRecoveryOrchestratorWithDb(db: Database): RecoveryOrchestrator {
+	return new RecoveryOrchestrator({ db });
+}