@kodrunhq/opencode-autopilot 0.1.3 → 1.0.0

package/src/index.ts

@@ -12,13 +12,13 @@ import {
 import { fallbackDefaults } from "./orchestrator/fallback/fallback-config";
 import { resolveChain } from "./orchestrator/fallback/resolve-chain";
 import { ocConfidence } from "./tools/confidence";
+import { ocConfigure, setOpenCodeConfig } from "./tools/configure";
 import { ocCreateAgent } from "./tools/create-agent";
 import { ocCreateCommand } from "./tools/create-command";
 import { ocCreateSkill } from "./tools/create-skill";
 import { ocForensics } from "./tools/forensics";
 import { ocOrchestrate } from "./tools/orchestrate";
 import { ocPhase } from "./tools/phase";
-import { ocPlaceholder } from "./tools/placeholder";
 import { ocPlan } from "./tools/plan";
 import { ocReview } from "./tools/review";
 import { ocState } from "./tools/state";
@@ -77,7 +77,9 @@ const plugin: Plugin = async (input) => {
 			const agentConfigs = openCodeConfig?.agent as
 				| Record<string, Record<string, unknown>>
 				| undefined;
-			return resolveChain(agentName ?? "", agentConfigs, config?.fallback_models);
+			// Per-agent fallback_models are populated by configHook from group/override config.
+			// resolveChain reads config.agent[agentName].fallback_models (tier 1).
+			return resolveChain(agentName ?? "", agentConfigs, undefined);
 		},
 	});
 
@@ -91,7 +93,7 @@ const plugin: Plugin = async (input) => {
 
 	return {
 		tool: {
-			oc_placeholder: ocPlaceholder,
+			oc_configure: ocConfigure,
 			oc_create_agent: ocCreateAgent,
 			oc_create_skill: ocCreateSkill,
 			oc_create_command: ocCreateCommand,
@@ -105,8 +107,11 @@ const plugin: Plugin = async (input) => {
 		},
 		event: async ({ event }) => {
 			if (event.type === "session.created" && isFirstLoad(config)) {
-				// First load: config wizard will be triggered via /configure command
-				// Phase 2 will add the oc_configure tool
+				await sdkOps.showToast(
+					"Welcome to OpenCode Autopilot!",
+					"Run /oc-configure to set up your model assignments for each agent group.",
+					"info",
+				);
 			}
 
 			// Fallback event handling (runs for all events)
@@ -116,6 +121,7 @@ const plugin: Plugin = async (input) => {
 		},
 		config: async (cfg: Config) => {
 			openCodeConfig = cfg;
+			setOpenCodeConfig(cfg);
 			await configHook(cfg);
 		},
 		"chat.message": async (

package/src/registry/diversity.ts

@@ -0,0 +1,78 @@
+import { DIVERSITY_RULES } from "./model-groups";
+import { extractFamily } from "./resolver";
+import type { DiversityWarning, GroupId, GroupModelAssignment } from "./types";
+
+/**
+ * Check all diversity rules against current group assignments.
+ * Returns warnings for adversarial pairs that share the same model family.
+ *
+ * Only checks groups that are assigned — unassigned groups are skipped
+ * (no warning for missing assignments; that's the config validator's job).
+ */
+export function checkDiversity(
+	groups: Readonly<Record<string, GroupModelAssignment>>,
+): readonly DiversityWarning[] {
+	const warnings: DiversityWarning[] = [];
+
+	for (const rule of DIVERSITY_RULES) {
+		// Extract families for all assigned groups in this rule
+		const families = new Map<GroupId, string>();
+		for (const groupId of rule.groups) {
+			const assignment = groups[groupId];
+			if (assignment) {
+				families.set(groupId, extractFamily(assignment.primary));
+			}
+		}
+
+		// All groups in the rule must be assigned to check diversity
+		if (families.size < rule.groups.length) continue;
+
+		// For 2-group rules: warn if both use same family
+		// For 3-group rules (red-team + builders + reviewers):
+		//   warn if red-team shares family with ANY of the others
+		if (rule.groups.length === 2) {
+			const [familyA, familyB] = [...families.values()];
+			if (familyA === familyB) {
+				warnings.push({
+					rule,
+					sharedFamily: familyA,
+					groups: [...families.keys()],
+				});
+			}
+		} else if (rule.groups.includes("red-team" as GroupId)) {
+			// 3-group rule with red-team: only compare red-team against the others
+			// (builders↔reviewers is already covered by its own 2-group strong rule)
+			const redTeamFamily = families.get("red-team" as GroupId);
+			if (redTeamFamily) {
+				const conflicting = rule.groups.filter(
+					(g) => g !== ("red-team" as GroupId) && families.get(g) === redTeamFamily,
+				);
+				if (conflicting.length > 0) {
+					warnings.push({
+						rule,
+						sharedFamily: redTeamFamily,
+						groups: ["red-team" as GroupId, ...conflicting],
+					});
+				}
+			}
+		} else {
+			// Generic multi-group rule: check if any pair shares a family
+			const entries = [...families.entries()];
+			const seen = new Set<string>();
+			for (const [, family] of entries) {
+				if (seen.has(family)) {
+					const sharing = entries.filter(([, f]) => f === family).map(([g]) => g);
+					warnings.push({
+						rule,
+						sharedFamily: family,
+						groups: sharing,
+					});
+					break;
+				}
+				seen.add(family);
+			}
+		}
+	}
+
+	return Object.freeze(warnings);
+}

package/src/registry/doctor.ts

@@ -0,0 +1,84 @@
+import { checkDiversity } from "./diversity";
+import { ALL_GROUP_IDS } from "./model-groups";
+import type { DiversityWarning, GroupModelAssignment } from "./types";
+
+/**
+ * Plugin config shape expected by diagnose().
+ * Minimal subset to avoid coupling to the full PluginConfig Zod schema.
+ */
+export interface DiagnosableConfig {
+	readonly configured: boolean;
+	readonly version: number;
+	readonly groups: Readonly<Record<string, GroupModelAssignment>>;
+}
+
+/**
+ * Structured result of a diagnostic check, suitable for both
+ * CLI terminal formatting and JSON serialization by the tool.
+ */
+export interface DiagnosticResult {
+	readonly configExists: boolean;
+	readonly schemaValid: boolean;
+	readonly configured: boolean;
+	readonly groupsAssigned: Readonly<
+		Record<
+			string,
+			{
+				readonly assigned: boolean;
+				readonly primary: string | null;
+				readonly fallbacks: readonly string[];
+			}
+		>
+	>;
+	readonly diversityWarnings: readonly DiversityWarning[];
+	readonly allPassed: boolean;
+}
+
+/**
+ * Pure diagnostic function — inspects a config (or null) and returns
+ * a structured result. No side effects, no I/O.
+ *
+ * Both `bin/cli.ts:runDoctor()` and `src/tools/configure.ts:handleDoctor()`
+ * call this and format the result differently (terminal vs JSON).
+ */
+export function diagnose(config: DiagnosableConfig | null): DiagnosticResult {
+	const configExists = config !== null;
+	// Always true when configExists — loadConfig validates through Zod on load
+	const schemaValid = configExists;
+	const configured = config?.configured ?? false;
+
+	const groupsAssigned: Record<
+		string,
+		{ assigned: boolean; primary: string | null; fallbacks: readonly string[] }
+	> = {};
+
+	for (const groupId of ALL_GROUP_IDS) {
+		const assignment = config?.groups[groupId];
+		groupsAssigned[groupId] = assignment
+			? { assigned: true, primary: assignment.primary, fallbacks: assignment.fallbacks }
+			: { assigned: false, primary: null, fallbacks: [] };
+	}
+
+	// Diversity check on assigned groups
+	const assignedGroups: Record<string, GroupModelAssignment> = {};
+	if (config) {
+		for (const [key, val] of Object.entries(config.groups)) {
+			assignedGroups[key] = val;
+		}
+	}
+
+	const diversityWarnings = checkDiversity(assignedGroups);
+
+	const allGroupsAssigned = ALL_GROUP_IDS.every((id) => groupsAssigned[id]?.assigned);
+	// diversityWarnings are advisory — they don't affect allPassed
+	const allPassed = configExists && schemaValid && configured && allGroupsAssigned;
+
+	return Object.freeze({
+		configExists,
+		schemaValid,
+		configured,
+		groupsAssigned: Object.freeze(groupsAssigned),
+		diversityWarnings,
+		allPassed,
+	});
+}

package/src/registry/model-groups.ts

@@ -0,0 +1,163 @@
+import type { AgentEntry, DiversityRule, GroupDefinition, GroupId } from "./types";
+
+function deepFreeze<T extends object>(obj: T): Readonly<T> {
+	for (const value of Object.values(obj)) {
+		if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+			deepFreeze(value as object);
+		}
+	}
+	return Object.freeze(obj);
+}
+
+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" },
+
+	// ── Challengers ────────────────────────────────────────────
+	// Adversarial to Architects: critique proposals, enhance ideas
+	"oc-critic": { group: "challengers" },
+	"oc-challenger": { group: "challengers" },
+
+	// ── Builders ───────────────────────────────────────────────
+	// Code generation
+	"oc-implementer": { 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" },
+
+	// ── 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" },
+});
+
+export const GROUP_DEFINITIONS: Readonly<Record<GroupId, GroupDefinition>> = deepFreeze({
+	architects: {
+		id: "architects",
+		label: "Architects",
+		purpose: "System design, task decomposition, pipeline orchestration",
+		recommendation:
+			"Most powerful model available. Bad architecture cascades into everything downstream.",
+		tier: "heavy",
+		order: 1,
+	},
+	challengers: {
+		id: "challengers",
+		label: "Challengers",
+		purpose: "Challenge architecture proposals, enhance ideas, find design flaws",
+		recommendation:
+			"Strong model, different family from Architects for genuine adversarial review.",
+		tier: "heavy",
+		order: 2,
+	},
+	builders: {
+		id: "builders",
+		label: "Builders",
+		purpose: "Write production code",
+		recommendation: "Strong coding model. This is where most tokens are spent.",
+		tier: "heavy",
+		order: 3,
+	},
+	reviewers: {
+		id: "reviewers",
+		label: "Reviewers",
+		purpose: "Find bugs, security issues, logic errors in code",
+		recommendation:
+			"Strong model, different family from Builders to catch different classes of bugs.",
+		tier: "heavy",
+		order: 4,
+	},
+	"red-team": {
+		id: "red-team",
+		label: "Red Team",
+		purpose: "Final adversarial pass — hunt exploits, find UX gaps",
+		recommendation: "Different family from both Builders and Reviewers for a third perspective.",
+		tier: "heavy",
+		order: 5,
+	},
+	researchers: {
+		id: "researchers",
+		label: "Researchers",
+		purpose: "Domain research, feasibility analysis, information gathering",
+		recommendation: "Good context window and comprehension. Any model family works.",
+		tier: "medium",
+		order: 6,
+	},
+	communicators: {
+		id: "communicators",
+		label: "Communicators",
+		purpose: "Write docs, changelogs, extract lessons",
+		recommendation: "Mid-tier model. Clear writing matters more than deep reasoning.",
+		tier: "light",
+		order: 7,
+	},
+	utilities: {
+		id: "utilities",
+		label: "Utilities",
+		purpose: "Fast lookups, prompt tuning, PR scanning",
+		recommendation:
+			"Fastest available model. Speed over intelligence — don't waste expensive tokens on grep.",
+		tier: "light",
+		order: 8,
+	},
+});
+
+/**
+ * All valid group IDs, derived from GROUP_DEFINITIONS and sorted by order.
+ * Adding a new group to GROUP_DEFINITIONS auto-includes it here.
+ */
+export const ALL_GROUP_IDS: readonly GroupId[] = Object.freeze(
+	[...(Object.values(GROUP_DEFINITIONS) as GroupDefinition[])]
+		.sort((a: GroupDefinition, b: GroupDefinition) => a.order - b.order)
+		.map((d: GroupDefinition) => d.id),
+);
+
+export const DIVERSITY_RULES: readonly DiversityRule[] = Object.freeze([
+	Object.freeze({
+		groups: Object.freeze(["architects", "challengers"] as const),
+		severity: "strong" as const,
+		reason:
+			"Challengers critique architect output. Same-model review creates confirmation bias — the model agrees with its own reasoning patterns.",
+	}),
+	Object.freeze({
+		groups: Object.freeze(["builders", "reviewers"] as const),
+		severity: "strong" as const,
+		reason:
+			"Reviewers find bugs in builder code. Same model shares the same blind spots — it won't catch errors it would also make.",
+	}),
+	Object.freeze({
+		groups: Object.freeze(["red-team", "builders", "reviewers"] as const),
+		severity: "soft" as const,
+		reason:
+			"Red Team is most effective as a third perspective. If you only have 2 model families, use whichever isn't assigned to Reviewers.",
+	}),
+]);

package/src/registry/resolver.ts

@@ -0,0 +1,74 @@
+import { AGENT_REGISTRY } from "./model-groups";
+import type { AgentOverride, GroupId, GroupModelAssignment, ResolvedModel } from "./types";
+
+/**
+ * Extract model family (provider) from a model string.
+ * "anthropic/claude-opus-4-6" → "anthropic"
+ * "openai/gpt-5.4" → "openai"
+ * Returns the full string if no "/" is found.
+ */
+export function extractFamily(model: string): string {
+	const idx = model.indexOf("/");
+	return idx === -1 ? model : model.slice(0, idx);
+}
+
+/**
+ * Resolve model for a named agent.
+ *
+ * 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)
+ */
+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 {
+			primary: override.primary,
+			fallbacks: override.fallbacks ?? [],
+			source: "override",
+		};
+	}
+
+	// Tier 2: group assignment
+	const entry = AGENT_REGISTRY[agentName];
+	if (entry) {
+		const group = groups[entry.group];
+		if (group) {
+			return {
+				primary: group.primary,
+				fallbacks: group.fallbacks,
+				source: "group",
+			};
+		}
+	}
+
+	// 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,
+	groups: Readonly<Record<string, GroupModelAssignment>>,
+): ResolvedModel | null {
+	const group = groups[groupId];
+	if (!group) return null;
+	return {
+		primary: group.primary,
+		fallbacks: group.fallbacks,
+		source: "group",
+	};
+}

package/src/registry/types.ts

@@ -0,0 +1,91 @@
+// src/registry/types.ts
+
+/**
+ * The 8 model groups. Used as keys in config.groups and GROUP_DEFINITIONS.
+ */
+export type GroupId =
+	| "architects"
+	| "challengers"
+	| "builders"
+	| "reviewers"
+	| "red-team"
+	| "researchers"
+	| "communicators"
+	| "utilities";
+
+/**
+ * Model tier hint — used for display ordering and recommendations.
+ * Does not affect resolution logic.
+ */
+export type ModelTier = "heavy" | "medium" | "light";
+
+/**
+ * Diversity warning severity.
+ * "strong" — displayed with warning icon, explicitly recommended to change.
+ * "soft" — displayed as suggestion, not a strong recommendation.
+ */
+export type DiversitySeverity = "strong" | "soft";
+
+/**
+ * Entry in the agent registry. Maps an agent name to its group.
+ */
+export interface AgentEntry {
+	readonly group: GroupId;
+}
+
+/**
+ * Metadata for a model group. Pure display/recommendation data.
+ */
+export interface GroupDefinition {
+	readonly id: GroupId;
+	readonly label: string;
+	readonly purpose: string;
+	readonly recommendation: string;
+	readonly tier: ModelTier;
+	readonly order: number;
+}
+
+/**
+ * Adversarial diversity rule. Declares which groups should use
+ * different model families for quality benefits.
+ */
+export interface DiversityRule {
+	readonly groups: readonly GroupId[];
+	readonly severity: DiversitySeverity;
+	readonly reason: string;
+}
+
+/**
+ * A model assignment for a group (stored in config).
+ */
+export interface GroupModelAssignment {
+	readonly primary: string;
+	readonly fallbacks: readonly string[];
+}
+
+/**
+ * A per-agent override (stored in config.overrides).
+ */
+export interface AgentOverride {
+	readonly primary: string;
+	readonly fallbacks?: readonly string[];
+}
+
+/**
+ * Resolved model for an agent — returned by the resolver.
+ * `null` means no assignment found; agent uses OpenCode's default.
+ */
+export interface ResolvedModel {
+	readonly primary: string;
+	readonly fallbacks: readonly string[];
+	readonly source: "override" | "group" | "default";
+}
+
+/**
+ * Diversity warning emitted by checkDiversity().
+ */
+export interface DiversityWarning {
+	readonly rule: DiversityRule;
+	readonly sharedFamily: string;
+	readonly groups: readonly GroupId[];
+}