@kodrunhq/opencode-autopilot 0.1.0 → 1.0.0

package/bin/cli.ts

@@ -0,0 +1,346 @@
+#!/usr/bin/env bun
+
+import { execFile as execFileCb } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { CONFIG_PATH, createDefaultConfig, loadConfig, saveConfig } from "../src/config";
+import { diagnose } from "../src/registry/doctor";
+import { ALL_GROUP_IDS, DIVERSITY_RULES, GROUP_DEFINITIONS } from "../src/registry/model-groups";
+import type { GroupId } from "../src/registry/types";
+import { fileExists } from "../src/utils/fs-helpers";
+
+const execFile = promisify(execFileCb);
+
+// ── ANSI color helpers (zero dependencies) ──────────────────────────
+
+const green = (s: string) => `\x1b[32m${s}\x1b[0m`;
+const red = (s: string) => `\x1b[31m${s}\x1b[0m`;
+const yellow = (s: string) => `\x1b[33m${s}\x1b[0m`;
+const bold = (s: string) => `\x1b[1m${s}\x1b[0m`;
+
+// ── Types ───────────────────────────────────────────────────────────
+
+export interface CliOptions {
+	readonly cwd?: string;
+	readonly noTui?: boolean;
+	readonly configDir?: string;
+}
+
+// ── Constants ───────────────────────────────────────────────────────
+
+const PLUGIN_NAME = "@kodrunhq/opencode-autopilot";
+const OPENCODE_JSON = "opencode.json";
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+async function checkOpenCodeInstalled(): Promise<string | null> {
+	try {
+		const { stdout } = await execFile("opencode", ["--version"]);
+		return stdout.trim();
+	} catch (error: unknown) {
+		if (
+			error instanceof Error &&
+			"code" in error &&
+			(error as NodeJS.ErrnoException).code === "ENOENT"
+		) {
+			return null;
+		}
+		throw error;
+	}
+}
+
+// ── runInstall ──────────────────────────────────────────────────────
+
+export async function runInstall(options: CliOptions = {}): Promise<void> {
+	const cwd = options.cwd ?? process.cwd();
+	const configPath = options.configDir ?? CONFIG_PATH;
+
+	console.log("");
+	console.log(bold("opencode-autopilot install"));
+	console.log("─────────────────────────");
+	console.log("");
+
+	// 1. Check OpenCode installed (warn but don't fail)
+	const version = await checkOpenCodeInstalled();
+	if (version) {
+		console.log(`  ${green("✓")} OpenCode installed: ${version}`);
+	} else {
+		console.log(`  ${yellow("⚠")} OpenCode not found — install from https://opencode.ai`);
+	}
+
+	// 2. Locate or create opencode.json
+	const jsonPath = join(cwd, OPENCODE_JSON);
+	let opencodeJson: { plugin?: string[]; [key: string]: unknown };
+
+	if (await fileExists(jsonPath)) {
+		const raw = await readFile(jsonPath, "utf-8");
+		try {
+			opencodeJson = JSON.parse(raw) as typeof opencodeJson;
+		} catch {
+			console.error(
+				`  ${red("✗")} ${OPENCODE_JSON} contains invalid JSON. Please fix it and try again.`,
+			);
+			process.exit(1);
+		}
+		console.log(`  ${green("✓")} Found ${OPENCODE_JSON}`);
+	} else {
+		opencodeJson = { plugin: [] };
+		console.log(`  ${green("✓")} Created ${OPENCODE_JSON}`);
+	}
+
+	// 3. Register plugin (idempotent)
+	const existingPlugins: string[] = Array.isArray(opencodeJson.plugin) ? opencodeJson.plugin : [];
+
+	if (existingPlugins.includes(PLUGIN_NAME)) {
+		console.log(`  ${green("✓")} Plugin already registered`);
+	} else {
+		opencodeJson = {
+			...opencodeJson,
+			plugin: [...existingPlugins, PLUGIN_NAME],
+		};
+		const tmpJsonPath = `${jsonPath}.tmp.${randomBytes(8).toString("hex")}`;
+		await writeFile(tmpJsonPath, JSON.stringify(opencodeJson, null, 2), "utf-8");
+		await rename(tmpJsonPath, jsonPath);
+		console.log(`  ${green("✓")} Plugin registered`);
+	}
+
+	// 4. Create starter config (skip if exists)
+	if (await fileExists(configPath)) {
+		const config = await loadConfig(configPath);
+		if (config?.configured) {
+			console.log(`  ${green("✓")} Config already configured`);
+		} else {
+			console.log(`  ${yellow("⚠")} Config exists, not yet configured`);
+		}
+	} else {
+		const defaultConfig = createDefaultConfig();
+		await saveConfig(defaultConfig, configPath);
+		console.log(`  ${green("✓")} Created starter config`);
+	}
+
+	// 5. Print next steps
+	console.log("");
+	console.log(bold("Next steps:"));
+	console.log("");
+	console.log("  1. Launch OpenCode");
+	console.log("  2. Run /oc-configure to set up your model assignments");
+	console.log("");
+	console.log("  Or paste this into your AI session for guided setup:");
+	console.log("");
+	console.log(
+		"    https://raw.githubusercontent.com/kodrunhq/opencode-autopilot/main/docs/guide/installation.md",
+	);
+	console.log("");
+}
+
+// ── runDoctor helpers ──────────────────────────────────────────────
+
+async function printSystemChecks(
+	cwd: string,
+	configPath: string,
+): Promise<{ hasFailure: boolean; config: Awaited<ReturnType<typeof loadConfig>> }> {
+	let hasFailure = false;
+
+	console.log(bold("System"));
+
+	// 1. OpenCode installed
+	const version = await checkOpenCodeInstalled();
+	if (version) {
+		console.log(`  OpenCode installed      ${green("✓")} ${version}`);
+	} else {
+		console.log(
+			`  OpenCode installed      ${red("✗")} not found — install from https://opencode.ai`,
+		);
+		hasFailure = true;
+	}
+
+	// 2. Plugin registered
+	const jsonPath = join(cwd, OPENCODE_JSON);
+	if (await fileExists(jsonPath)) {
+		try {
+			const raw = await readFile(jsonPath, "utf-8");
+			const parsed = JSON.parse(raw) as { plugin?: string[] };
+			if (Array.isArray(parsed.plugin) && parsed.plugin.includes(PLUGIN_NAME)) {
+				console.log(`  Plugin registered       ${green("✓")} ${OPENCODE_JSON}`);
+			} else {
+				console.log(`  Plugin registered       ${red("✗")} not in ${OPENCODE_JSON} — run install`);
+				hasFailure = true;
+			}
+		} catch (error: unknown) {
+			if (error instanceof SyntaxError) {
+				console.log(
+					`  Plugin registered       ${red("✗")} invalid ${OPENCODE_JSON} — fix JSON syntax`,
+				);
+			} else {
+				console.log(
+					`  Plugin registered       ${red("✗")} could not read ${OPENCODE_JSON}: ${error instanceof Error ? error.message : String(error)}`,
+				);
+			}
+			hasFailure = true;
+		}
+	} else {
+		console.log(`  Plugin registered       ${red("✗")} ${OPENCODE_JSON} not found — run install`);
+		hasFailure = true;
+	}
+
+	// 3. Config file exists + schema valid
+	const config = await loadConfig(configPath);
+	if (config) {
+		console.log(`  Config file             ${green("✓")} found`);
+		console.log(`  Config schema           ${green("✓")} v${config.version}`);
+	} else {
+		console.log(`  Config file             ${red("✗")} not found — run install`);
+		hasFailure = true;
+	}
+
+	// 4. Setup completed
+	if (config) {
+		if (config.configured) {
+			console.log(`  Setup completed         ${green("✓")} configured: true`);
+		} else {
+			console.log(
+				`  Setup completed         ${red("✗")} configured: false — run /oc-configure in OpenCode`,
+			);
+			hasFailure = true;
+		}
+	}
+
+	return { hasFailure, config };
+}
+
+function printModelAssignments(result: ReturnType<typeof diagnose>): void {
+	console.log("");
+	console.log(bold("Model Assignments"));
+
+	if (result.configExists) {
+		for (const groupId of ALL_GROUP_IDS) {
+			const def = GROUP_DEFINITIONS[groupId];
+			const info = result.groupsAssigned[groupId];
+			const label = def.label.padEnd(20);
+
+			if (info?.assigned && info.primary) {
+				const fallbackStr = info.fallbacks.length > 0 ? ` -> ${info.fallbacks.join(", ")}` : "";
+				console.log(`  ${label}  ${info.primary}${fallbackStr}`);
+			} else {
+				console.log(`  ${label}  ${red("✗")} not assigned`);
+			}
+		}
+	} else {
+		console.log(`  ${red("✗")} no config loaded`);
+	}
+}
+
+function printDiversityResults(
+	result: ReturnType<typeof diagnose>,
+	config: Awaited<ReturnType<typeof loadConfig>>,
+): void {
+	console.log("");
+	console.log(bold("Adversarial Diversity"));
+
+	if (config && Object.keys(config.groups).length > 0) {
+		// Derive display rules from DIVERSITY_RULES
+		const rules = DIVERSITY_RULES.map((rule) => {
+			const groupLabels = rule.groups.map((g) => GROUP_DEFINITIONS[g as GroupId].label);
+			const label =
+				groupLabels.length === 2
+					? `${groupLabels[0]} <-> ${groupLabels[1]}`
+					: `${groupLabels[0]} <-> ${groupLabels.slice(1).join("+")}`;
+			return { label, groups: rule.groups };
+		});
+
+		for (const rule of rules) {
+			const key = [...rule.groups].sort().join(",");
+			const allAssigned = rule.groups.every((g) => config.groups[g]);
+
+			if (!allAssigned) {
+				console.log(`  ${rule.label.padEnd(28)} ${yellow("⚠")} groups not fully assigned`);
+				continue;
+			}
+
+			const warning = result.diversityWarnings.find((w) => [...w.groups].sort().join(",") === key);
+
+			if (warning) {
+				console.log(
+					`  ${rule.label.padEnd(28)} ${yellow("⚠")} shared family: ${warning.sharedFamily} — consider different families`,
+				);
+			} else {
+				console.log(`  ${rule.label.padEnd(28)} ${green("✓")} different families`);
+			}
+		}
+	} else {
+		console.log(`  ${yellow("⚠")} no model assignments to check`);
+	}
+}
+
+// ── runDoctor ───────────────────────────────────────────────────────
+
+export async function runDoctor(options: CliOptions = {}): Promise<void> {
+	const cwd = options.cwd ?? process.cwd();
+	const configPath = options.configDir ?? CONFIG_PATH;
+
+	console.log("");
+	console.log(bold("opencode-autopilot doctor"));
+	console.log("─────────────────────────");
+	console.log("");
+
+	const { hasFailure, config } = await printSystemChecks(cwd, configPath);
+
+	// Run shared diagnosis logic
+	const result = diagnose(config);
+
+	printModelAssignments(result);
+	printDiversityResults(result, config);
+
+	// ── Summary ────────────────────────────────────────────────
+
+	console.log("");
+	if (hasFailure) {
+		console.log(red("Some checks failed."));
+		process.exitCode = 1;
+	} else {
+		console.log(green("All checks passed."));
+	}
+	console.log("");
+}
+
+// ── Help ────────────────────────────────────────────────────────────
+
+function printUsage(): void {
+	console.log("");
+	console.log(bold("Usage:") + " opencode-autopilot <command>");
+	console.log("");
+	console.log("Commands:");
+	console.log("  install     Register the plugin and create starter config");
+	console.log("  doctor      Check installation health and model assignments");
+	console.log("");
+	console.log("Options:");
+	console.log("  --help, -h  Show this help message");
+	console.log("");
+}
+
+// ── CLI dispatch (only when run directly, not imported) ─────────────
+
+if (import.meta.main) {
+	const args = process.argv.slice(2);
+	const command = args[0];
+
+	switch (command) {
+		case "install":
+			await runInstall({ noTui: args.includes("--no-tui") });
+			break;
+		case "doctor":
+			await runDoctor();
+			break;
+		case "--help":
+		case "-h":
+		case undefined:
+			printUsage();
+			break;
+		default:
+			console.error(`Unknown command: ${command}`);
+			printUsage();
+			process.exit(1);
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kodrunhq/opencode-autopilot",
-	"version": "0.1.0",
+	"version": "1.0.0",
 	"description": "Curated agents, skills, and commands for the OpenCode AI coding CLI — autonomous orchestrator, multi-agent code review, model fallback, and in-session asset creation tools.",
 	"main": "src/index.ts",
 	"keywords": [
@@ -35,9 +35,13 @@
 	"peerDependencies": {
 		"@opencode-ai/plugin": ">=1.3.0"
 	},
+	"bin": {
+		"opencode-autopilot": "bin/cli.ts"
+	},
 	"files": [
 		"src/",
-		"assets/"
+		"assets/",
+		"bin/"
 	],
 	"scripts": {
 		"test": "bun test",

package/src/agents/index.ts

@@ -1,4 +1,7 @@
 import type { Config } from "@opencode-ai/plugin";
+import { loadConfig } from "../config";
+import { resolveModelForAgent } from "../registry/resolver";
+import type { AgentOverride, GroupModelAssignment } from "../registry/types";
 import { autopilotAgent } from "./autopilot";
 import { documenterAgent } from "./documenter";
 import { metaprompterAgent } from "./metaprompter";
@@ -6,6 +9,11 @@ import { pipelineAgents } from "./pipeline/index";
 import { prReviewerAgent } from "./pr-reviewer";
 import { researcherAgent } from "./researcher";
 
+interface AgentConfig {
+	readonly [key: string]: unknown;
+	readonly permission?: Record<string, unknown>;
+}
+
 const agents = {
 	researcher: researcherAgent,
 	metaprompter: metaprompterAgent,
@@ -14,32 +22,58 @@ const agents = {
 	autopilot: autopilotAgent,
 } as const;
 
-export async function configHook(config: Config): Promise<void> {
-	if (!config.agent) {
-		config.agent = {};
-	}
-	for (const [name, agentConfig] of Object.entries(agents)) {
-		// Only set if not already defined — preserve user customizations (Pitfall 2)
-		if (config.agent[name] === undefined) {
-			// Mutation of config.agent is intentional: the OpenCode plugin configHook
-			// API requires mutating the provided Config object to register agents.
-			// We deep-copy agent config including nested permission to avoid shared references.
-			config.agent[name] = {
+/**
+ * Register a set of agents into the OpenCode config, resolving model
+ * assignments from groups/overrides. Skips agents already defined
+ * to preserve user customizations.
+ *
+ * Mutation of config.agent is intentional: the OpenCode plugin configHook
+ * API requires mutating the provided Config object to register agents.
+ */
+function registerAgents(
+	agentMap: Readonly<Record<string, Readonly<AgentConfig>>>,
+	config: Config,
+	groups: Readonly<Record<string, GroupModelAssignment>>,
+	overrides: Readonly<Record<string, AgentOverride>>,
+): void {
+	for (const [name, agentConfig] of Object.entries(agentMap)) {
+		if (config.agent![name] === undefined) {
+			// Deep-copy agent config including nested permission to avoid shared references.
+			const resolved = resolveModelForAgent(name, groups, overrides);
+			config.agent![name] = {
 				...agentConfig,
 				...(agentConfig.permission && { permission: { ...agentConfig.permission } }),
+				...(resolved && { model: resolved.primary }),
+				...(resolved &&
+					resolved.fallbacks.length > 0 && {
+						fallback_models: [...resolved.fallbacks],
+					}),
 			};
 		}
 	}
+}
 
-	// Register pipeline agents (v2 orchestrator subagents)
-	for (const [name, agentConfig] of Object.entries(pipelineAgents)) {
-		if (config.agent[name] === undefined) {
-			config.agent[name] = {
-				...agentConfig,
-				...(agentConfig.permission && { permission: { ...agentConfig.permission } }),
-			};
-		}
+export async function configHook(config: Config, configPath?: string): Promise<void> {
+	if (!config.agent) {
+		config.agent = {};
 	}
+
+	// Load plugin config for model group resolution
+	let pluginConfig = null;
+	try {
+		pluginConfig = await loadConfig(configPath);
+	} catch (error: unknown) {
+		console.error(
+			"[opencode-autopilot] Failed to load plugin config:",
+			error instanceof Error ? error.message : String(error),
+		);
+	}
+	const groups: Readonly<Record<string, GroupModelAssignment>> = pluginConfig?.groups ?? {};
+	const overrides: Readonly<Record<string, AgentOverride>> = pluginConfig?.overrides ?? {};
+
+	// Register standard agents and pipeline agents (v2 orchestrator subagents)
+	registerAgents(agents, config, groups, overrides);
+	registerAgents(pipelineAgents, config, groups, overrides);
 }
 
 export { autopilotAgent } from "./autopilot";

package/src/config.ts

@@ -1,7 +1,9 @@
+import { randomBytes } from "node:crypto";
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { z } from "zod";
 import { fallbackConfigSchema, fallbackDefaults } from "./orchestrator/fallback/fallback-config";
+import { AGENT_REGISTRY, ALL_GROUP_IDS } from "./registry/model-groups";
 import { ensureDir, isEnoentError } from "./utils/fs-helpers";
 import { getGlobalConfigDir } from "./utils/paths";
 
@@ -60,7 +62,7 @@ const pluginConfigSchemaV2 = z.object({
 
 type PluginConfigV2 = z.infer<typeof pluginConfigSchemaV2>;
 
-// --- V3 schema ---
+// --- V3 schema (internal, for migration) ---
 
 const pluginConfigSchemaV3 = z.object({
 	version: z.literal(3),
@@ -72,10 +74,48 @@ const pluginConfigSchemaV3 = z.object({
 	fallback_models: z.union([z.string(), z.array(z.string())]).optional(),
 });
 
-// Export pluginConfigSchema as alias for v3 (preserves import compatibility)
-export const pluginConfigSchema = pluginConfigSchemaV3;
+type PluginConfigV3 = z.infer<typeof pluginConfigSchemaV3>;
 
-export type PluginConfig = z.infer<typeof pluginConfigSchemaV3>;
+// --- V4 sub-schemas ---
+
+const groupModelAssignmentSchema = z.object({
+	primary: z.string().min(1),
+	fallbacks: z.array(z.string().min(1)).default([]),
+});
+
+const agentOverrideSchema = z.object({
+	primary: z.string().min(1),
+	fallbacks: z.array(z.string().min(1)).optional(),
+});
+
+// --- V4 schema ---
+
+const pluginConfigSchemaV4 = z
+	.object({
+		version: z.literal(4),
+		configured: z.boolean(),
+		groups: z.record(z.string(), groupModelAssignmentSchema).default({}),
+		overrides: z.record(z.string(), agentOverrideSchema).default({}),
+		orchestrator: orchestratorConfigSchema.default(orchestratorDefaults),
+		confidence: confidenceConfigSchema.default(confidenceDefaults),
+		fallback: fallbackConfigSchema.default(fallbackDefaults),
+	})
+	.superRefine((config, ctx) => {
+		for (const groupId of Object.keys(config.groups)) {
+			if (!ALL_GROUP_IDS.includes(groupId as (typeof ALL_GROUP_IDS)[number])) {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					path: ["groups", groupId],
+					message: `Unknown group id "${groupId}". Expected one of: ${ALL_GROUP_IDS.join(", ")}`,
+				});
+			}
+		}
+	});
+
+// Export aliases updated to v4
+export const pluginConfigSchema = pluginConfigSchemaV4;
+
+export type PluginConfig = z.infer<typeof pluginConfigSchemaV4>;
 
 export const CONFIG_PATH = join(getGlobalConfigDir(), "opencode-autopilot.json");
 
@@ -91,7 +131,7 @@ function migrateV1toV2(v1Config: PluginConfigV1): PluginConfigV2 {
 	};
 }
 
-function migrateV2toV3(v2Config: PluginConfigV2): PluginConfig {
+function migrateV2toV3(v2Config: PluginConfigV2): PluginConfigV3 {
 	return {
 		version: 3 as const,
 		configured: v2Config.configured,
@@ -102,6 +142,55 @@ function migrateV2toV3(v2Config: PluginConfigV2): PluginConfig {
 	};
 }
 
+function migrateV3toV4(v3Config: PluginConfigV3): PluginConfig {
+	const groups: Record<string, { primary: string; fallbacks: string[] }> = {};
+	const overrides: Record<string, { primary: string }> = {};
+
+	// Step 1: Reverse-map v3 flat models to groups
+	// v3.models is Record<string, string> where key is agent name, value is model id
+	for (const [agentName, modelId] of Object.entries(v3Config.models)) {
+		const entry = AGENT_REGISTRY[agentName];
+		if (!entry) {
+			// Agent not in registry — preserve as per-agent override
+			overrides[agentName] = { primary: modelId };
+			continue;
+		}
+
+		const groupId = entry.group;
+		if (!groups[groupId]) {
+			// First agent in this group sets the primary
+			groups[groupId] = { primary: modelId, fallbacks: [] };
+		} else if (groups[groupId].primary !== modelId) {
+			// Different model for same group — becomes an override
+			overrides[agentName] = { primary: modelId };
+		}
+		// Same model as group primary — no override needed
+	}
+
+	// Step 2: Migrate global fallback_models to per-group fallbacks
+	const globalFallbacks = v3Config.fallback_models
+		? typeof v3Config.fallback_models === "string"
+			? [v3Config.fallback_models]
+			: [...v3Config.fallback_models]
+		: [];
+
+	for (const group of Object.values(groups)) {
+		if (group.fallbacks.length === 0 && globalFallbacks.length > 0) {
+			group.fallbacks = [...globalFallbacks];
+		}
+	}
+
+	return {
+		version: 4 as const,
+		configured: v3Config.configured,
+		groups,
+		overrides,
+		orchestrator: v3Config.orchestrator,
+		confidence: v3Config.confidence,
+		fallback: v3Config.fallback,
+	};
+}
+
 // --- Public API ---
 
 export async function loadConfig(configPath: string = CONFIG_PATH): Promise<PluginConfig | null> {
@@ -109,35 +198,40 @@ export async function loadConfig(configPath: string = CONFIG_PATH): Promise<Plug
 		const raw = await readFile(configPath, "utf-8");
 		const parsed = JSON.parse(raw);
 
-		// Try v3 first
+		// Try v4 first
+		const v4Result = pluginConfigSchemaV4.safeParse(parsed);
+		if (v4Result.success) return v4Result.data;
+
+		// Try v3 and migrate to v4
 		const v3Result = pluginConfigSchemaV3.safeParse(parsed);
 		if (v3Result.success) {
-			return v3Result.data;
+			const migrated = migrateV3toV4(v3Result.data);
+			await saveConfig(migrated, configPath);
+			return migrated;
 		}
 
-		// Try v2 and migrate to v3
+		// Try v2 → v3 → v4
 		const v2Result = pluginConfigSchemaV2.safeParse(parsed);
 		if (v2Result.success) {
-			const migrated = migrateV2toV3(v2Result.data);
+			const v3 = migrateV2toV3(v2Result.data);
+			const migrated = migrateV3toV4(v3);
 			await saveConfig(migrated, configPath);
 			return migrated;
 		}
 
-		// Try v1 and double-migrate v1->v2->v3
+		// Try v1 → v2 → v3 → v4
 		const v1Result = pluginConfigSchemaV1.safeParse(parsed);
 		if (v1Result.success) {
 			const v2 = migrateV1toV2(v1Result.data);
-			const migrated = migrateV2toV3(v2);
+			const v3 = migrateV2toV3(v2);
+			const migrated = migrateV3toV4(v3);
 			await saveConfig(migrated, configPath);
 			return migrated;
 		}
 
-		// None matched -- force v3 parse to get proper error
-		return pluginConfigSchemaV3.parse(parsed);
+		return pluginConfigSchemaV4.parse(parsed); // throw with proper error
 	} catch (error: unknown) {
-		if (isEnoentError(error)) {
-			return null;
-		}
+		if (isEnoentError(error)) return null;
 		throw error;
 	}
 }
@@ -147,7 +241,7 @@ export async function saveConfig(
 	configPath: string = CONFIG_PATH,
 ): Promise<void> {
 	await ensureDir(dirname(configPath));
-	const tmpPath = `${configPath}.tmp.${Date.now()}`;
+	const tmpPath = `${configPath}.tmp.${randomBytes(8).toString("hex")}`;
 	await writeFile(tmpPath, JSON.stringify(config, null, 2), "utf-8");
 	await rename(tmpPath, configPath);
 }
@@ -158,9 +252,10 @@ export function isFirstLoad(config: PluginConfig | null): boolean {
 
 export function createDefaultConfig(): PluginConfig {
 	return {
-		version: 3 as const,
+		version: 4 as const,
 		configured: false,
-		models: {},
+		groups: {},
+		overrides: {},
 		orchestrator: orchestratorDefaults,
 		confidence: confidenceDefaults,
 		fallback: fallbackDefaults,