@kodrunhq/opencode-autopilot 1.18.0 → 1.19.0

package/src/recovery/persistence.ts

@@ -0,0 +1,87 @@
+import type { Database } from "bun:sqlite";
+import { withTransaction } from "../kernel/transaction";
+import type { RecoveryAttempt, RecoveryState } from "./types";
+
+interface RecoveryStateRow {
+	readonly session_id: string;
+	readonly state_json: string;
+	readonly updated_at: string;
+}
+
+function isRecoveryAttempt(value: unknown): value is RecoveryAttempt {
+	if (value === null || typeof value !== "object") {
+		return false;
+	}
+
+	const candidate = value as Record<string, unknown>;
+	return (
+		typeof candidate.attemptNumber === "number" &&
+		typeof candidate.strategy === "string" &&
+		typeof candidate.errorCategory === "string" &&
+		typeof candidate.timestamp === "string" &&
+		typeof candidate.success === "boolean" &&
+		(candidate.error === undefined || typeof candidate.error === "string")
+	);
+}
+
+function isRecoveryState(value: unknown): value is RecoveryState {
+	if (value === null || typeof value !== "object") {
+		return false;
+	}
+
+	const candidate = value as Record<string, unknown>;
+	return (
+		typeof candidate.sessionId === "string" &&
+		Array.isArray(candidate.attempts) &&
+		candidate.attempts.every(isRecoveryAttempt) &&
+		(candidate.currentStrategy === null || typeof candidate.currentStrategy === "string") &&
+		typeof candidate.maxAttempts === "number" &&
+		typeof candidate.isRecovering === "boolean" &&
+		(candidate.lastError === null || typeof candidate.lastError === "string")
+	);
+}
+
+function parseState(row: RecoveryStateRow | null): RecoveryState | null {
+	if (!row) {
+		return null;
+	}
+
+	const parsed = JSON.parse(row.state_json) as unknown;
+	return isRecoveryState(parsed) ? Object.freeze(parsed) : null;
+}
+
+export function saveRecoveryState(db: Database, state: RecoveryState): void {
+	const updatedAt = new Date().toISOString();
+	withTransaction(db, () => {
+		db.run(
+			`INSERT INTO recovery_state (session_id, state_json, updated_at)
+			 VALUES (?, ?, ?)
+			 ON CONFLICT(session_id) DO UPDATE SET
+			 state_json = excluded.state_json,
+			 updated_at = excluded.updated_at`,
+			[state.sessionId, JSON.stringify(state), updatedAt],
+		);
+	});
+}
+
+export function loadRecoveryState(db: Database, sessionId: string): RecoveryState | null {
+	const row = db
+		.query("SELECT session_id, state_json, updated_at FROM recovery_state WHERE session_id = ?")
+		.get(sessionId) as RecoveryStateRow | null;
+	return parseState(row);
+}
+
+export function clearRecoveryState(db: Database, sessionId: string): void {
+	withTransaction(db, () => {
+		db.run("DELETE FROM recovery_state WHERE session_id = ?", [sessionId]);
+	});
+}
+
+export function listRecoveryStates(db: Database): readonly RecoveryState[] {
+	const rows = db
+		.query("SELECT session_id, state_json, updated_at FROM recovery_state ORDER BY updated_at DESC")
+		.all() as RecoveryStateRow[];
+	return Object.freeze(
+		rows.map(parseState).filter((state): state is RecoveryState => state !== null),
+	);
+}

package/src/recovery/strategies.ts

@@ -0,0 +1,107 @@
+import type { ErrorCategory, RecoveryAction } from "../types/recovery";
+import type { RecoveryState } from "./types";
+
+export type RecoveryStrategyResolver = (context: RecoveryState) => RecoveryAction;
+
+function createAction(
+	strategy: RecoveryAction["strategy"],
+	errorCategory: ErrorCategory,
+	maxAttempts: number,
+	backoffMs: number,
+	metadata: Record<string, unknown> = {},
+): RecoveryAction {
+	return Object.freeze({
+		strategy,
+		errorCategory,
+		maxAttempts,
+		backoffMs,
+		metadata,
+	});
+}
+
+function getAttemptIndex(context: RecoveryState): number {
+	return context.attempts.length;
+}
+
+function retryWithBackoff(category: ErrorCategory): RecoveryStrategyResolver {
+	return (context) => {
+		const attemptIndex = getAttemptIndex(context);
+		return createAction("retry", category, context.maxAttempts, 1000 * 2 ** attemptIndex, {
+			retryMode: "backoff",
+		});
+	};
+}
+
+function fallbackModel(category: ErrorCategory): RecoveryStrategyResolver {
+	return (context) =>
+		createAction("fallback_model", category, context.maxAttempts, 0, {
+			switchModel: true,
+		});
+}
+
+function compactAndRetry(category: ErrorCategory): RecoveryStrategyResolver {
+	return (context) =>
+		createAction("compact_and_retry", category, context.maxAttempts, 500, {
+			compactContext: true,
+		});
+}
+
+function restartSession(category: ErrorCategory): RecoveryStrategyResolver {
+	return (context) =>
+		createAction("restart_session", category, context.maxAttempts, 0, {
+			restartSession: true,
+		});
+}
+
+function reduceContext(category: ErrorCategory): RecoveryStrategyResolver {
+	return (context) =>
+		createAction("reduce_context", category, context.maxAttempts, 250, {
+			trimContext: true,
+		});
+}
+
+function skipAndContinue(category: ErrorCategory): RecoveryStrategyResolver {
+	return (context) =>
+		createAction("skip_and_continue", category, context.maxAttempts, 0, {
+			skipCurrentStep: true,
+		});
+}
+
+function userPrompt(category: ErrorCategory): RecoveryStrategyResolver {
+	return (context) => createAction("user_prompt", category, context.maxAttempts, 0);
+}
+
+function abort(category: ErrorCategory): RecoveryStrategyResolver {
+	return (context) => createAction("abort", category, context.maxAttempts, 0);
+}
+
+export function getStrategy(category: ErrorCategory): RecoveryStrategyResolver {
+	switch (category) {
+		case "rate_limit":
+		case "timeout":
+		case "network":
+		case "service_unavailable":
+			return retryWithBackoff(category);
+		case "quota_exceeded":
+		case "empty_content":
+		case "thinking_block_error":
+			return fallbackModel(category);
+		case "tool_result_overflow":
+			return compactAndRetry(category);
+		case "context_window_exceeded":
+			return (context) =>
+				getAttemptIndex(context) > 0
+					? reduceContext(category)(context)
+					: compactAndRetry(category)(context);
+		case "session_corruption":
+			return restartSession(category);
+		case "agent_loop_stuck":
+			return skipAndContinue(category);
+		case "validation":
+			return userPrompt(category);
+		case "auth_failure":
+			return abort(category);
+		default:
+			return retryWithBackoff(category);
+	}
+}

package/src/recovery/types.ts

@@ -0,0 +1,31 @@
+import type { ErrorCategory, RecoveryAction, RecoveryStrategy } from "../types/recovery";
+
+export interface ClassificationResult {
+	readonly category: ErrorCategory;
+	readonly confidence: number;
+	readonly reasoning: string;
+	readonly isRecoverable: boolean;
+}
+
+export interface RecoveryAttempt {
+	readonly attemptNumber: number;
+	readonly strategy: RecoveryStrategy;
+	readonly errorCategory: ErrorCategory;
+	readonly timestamp: string;
+	readonly success: boolean;
+	readonly error?: string;
+}
+
+export interface RecoveryState {
+	readonly sessionId: string;
+	readonly attempts: readonly RecoveryAttempt[];
+	readonly currentStrategy: RecoveryStrategy | null;
+	readonly maxAttempts: number;
+	readonly isRecovering: boolean;
+	readonly lastError: string | null;
+}
+
+export interface RecoveryActionEnvelope {
+	readonly action: RecoveryAction;
+	readonly state: RecoveryState;
+}

package/src/registry/model-groups.ts

@@ -11,56 +11,39 @@ function deepFreeze<T extends object>(obj: T): Readonly<T> {
 
 export const AGENT_REGISTRY: Readonly<Record<string, AgentEntry>> = deepFreeze({
 	// ── Architects ─────────────────────────────────────────────
-	// Deep reasoning: system design, task decomposition, orchestration
 	"oc-architect": { group: "architects" },
 	"oc-planner": { group: "architects" },
 	autopilot: { group: "architects" },
 	planner: { group: "architects" },
 
 	// ── Challengers ────────────────────────────────────────────
-	// Adversarial to Architects: critique proposals, enhance ideas
 	"oc-critic": { group: "challengers" },
 	"oc-challenger": { group: "challengers" },
 
 	// ── Builders ───────────────────────────────────────────────
-	// Code generation and debugging
 	"oc-implementer": { group: "builders" },
+	coder: { group: "builders" },
 	debugger: { group: "builders" },
 
 	// ── Reviewers ──────────────────────────────────────────────
-	// Code analysis, adversarial to Builders
-	// NOTE: The 21 internal ReviewAgent objects (logic-auditor, security-auditor,
-	// etc.) are NOT in this registry. They use the ReviewAgent type from
-	// src/review/types.ts, not AgentConfig. The review pipeline resolves their
-	// model via resolveModelForGroup("reviewers") directly.
 	"oc-reviewer": { group: "reviewers" },
 	reviewer: { group: "reviewers" },
 
 	// ── Red Team ───────────────────────────────────────────────
-	// Final adversarial pass
-	// NOTE: red-team and product-thinker are ALSO internal ReviewAgent objects
-	// in STAGE3_AGENTS (src/review/agents/index.ts). They appear here so the
-	// review pipeline can resolve their model via resolveModelForGroup("red-team")
-	// separately from the "reviewers" group.
 	"red-team": { group: "red-team" },
 	"product-thinker": { group: "red-team" },
 
 	// ── Researchers ────────────────────────────────────────────
-	// Domain research, feasibility analysis
 	"oc-researcher": { group: "researchers" },
 	researcher: { group: "researchers" },
 
 	// ── Communicators ──────────────────────────────────────────
-	// Docs, changelogs, lesson extraction
 	"oc-shipper": { group: "communicators" },
-	documenter: { group: "communicators" },
-	"oc-retrospector": { group: "communicators" },
 
 	// ── Utilities ──────────────────────────────────────────────
-	// Fast lookups, prompt tuning, PR scanning
-	"oc-explorer": { group: "utilities" },
 	metaprompter: { group: "utilities" },
 	"pr-reviewer": { group: "utilities" },
+	"security-auditor": { group: "reviewers" },
 });
 
 export const GROUP_DEFINITIONS: Readonly<Record<GroupId, GroupDefinition>> = deepFreeze({

package/src/registry/resolver.ts

@@ -1,6 +1,15 @@
 import { AGENT_REGISTRY } from "./model-groups";
 import type { AgentOverride, GroupId, GroupModelAssignment, ResolvedModel } from "./types";
 
+const DEPRECATED_AGENT_REMAP: Readonly<Record<string, string>> = Object.freeze({
+	documenter: "coder",
+	devops: "coder",
+	"frontend-engineer": "coder",
+	"db-specialist": "coder",
+	"oc-explorer": "oc-researcher",
+	"oc-retrospector": "oc-shipper",
+});
+
 /**
  * Extract model family (provider) from a model string.
  * "anthropic/claude-opus-4-6" → "anthropic"
@@ -17,15 +26,15 @@ export function extractFamily(model: string): string {
  *
  * Resolution order:
  * 1. Per-agent override in overrides[agentName]
- * 2. Agent's group in AGENT_REGISTRY → groups[groupId]
- * 3. null (agent uses OpenCode's default model)
+ * 2. Deprecated agent remap → resolve via new agent name
+ * 3. Agent's group in AGENT_REGISTRY → groups[groupId]
+ * 4. null (agent uses OpenCode's default model)
  */
 export function resolveModelForAgent(
 	agentName: string,
 	groups: Readonly<Record<string, GroupModelAssignment>>,
 	overrides: Readonly<Record<string, AgentOverride>>,
 ): ResolvedModel | null {
-	// Tier 1: per-agent override
 	const override = overrides[agentName];
 	if (override) {
 		return {
@@ -35,7 +44,30 @@ export function resolveModelForAgent(
 		};
 	}
 
-	// Tier 2: group assignment
+	const remappedName = DEPRECATED_AGENT_REMAP[agentName];
+	if (remappedName) {
+		const remappedOverride = overrides[remappedName];
+		if (remappedOverride) {
+			return {
+				primary: remappedOverride.primary,
+				fallbacks: remappedOverride.fallbacks ?? [],
+				source: "override",
+			};
+		}
+
+		const remappedEntry = AGENT_REGISTRY[remappedName];
+		if (remappedEntry) {
+			const remappedGroup = groups[remappedEntry.group];
+			if (remappedGroup) {
+				return {
+					primary: remappedGroup.primary,
+					fallbacks: remappedGroup.fallbacks,
+					source: "group",
+				};
+			}
+		}
+	}
+
 	const entry = AGENT_REGISTRY[agentName];
 	if (entry) {
 		const group = groups[entry.group];
@@ -48,17 +80,12 @@ export function resolveModelForAgent(
 		}
 	}
 
-	// Tier 3: no assignment
 	return null;
 }
 
 /**
  * Resolve model for a group directly (used by review pipeline for
  * internal ReviewAgent objects that are not in AGENT_REGISTRY).
- *
- * Used by:
- * - Review pipeline for the 19 universal+specialized agents → "reviewers"
- * - Review pipeline for red-team + product-thinker → "red-team"
  */
 export function resolveModelForGroup(
 	groupId: GroupId,
@@ -72,3 +99,5 @@ export function resolveModelForGroup(
 		source: "group",
 	};
 }
+
+export { DEPRECATED_AGENT_REMAP };