@kodrunhq/opencode-autopilot 1.17.0 → 1.19.0

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