@kodrunhq/opencode-autopilot 1.16.0 → 1.18.0

package/assets/commands/oc-doctor.md

@@ -0,0 +1,17 @@
+---
+# opencode-autopilot
+description: Run plugin health diagnostics — config validity, agent injection, native suppression, assets, memory, commands, and v7 config fields (background, routing, recovery, mcp)
+---
+
+Invoke the `oc_doctor` tool to run a full health check on the opencode-autopilot plugin.
+
+`oc_doctor` runs the current built-in health checks and reports the results by diagnostic area. These checks cover:
+
+- **Config health** — The plugin config exists, parses correctly, and required modern config sections such as `background`, `routing`, `recovery`, and `mcp` are present or reported as needing migration.
+- **Agent setup** — Expected autopilot agents are present in the OpenCode config, and native `plan`/`build` agents are suppressed as subagents.
+- **Assets and installation paths** — Bundled asset directories and the global `~/.config/opencode/` target are accessible.
+- **Skill loading** — Skills load correctly and are filtered against the detected project stack.
+- **Memory storage** — The memory SQLite database is available, readable, or cleanly reported as not yet initialized on first install.
+- **Command files** — Expected slash command files exist and have valid YAML frontmatter.
+
+Each failing check includes a **Fix** suggestion. Run this after installation, after upgrades, or whenever something feels off.

package/bin/configure-tui.ts

@@ -307,7 +307,7 @@ export async function runConfigure(configPath: string = CONFIG_PATH): Promise<vo
 
 	const newConfig = {
 		...baseConfig,
-		version: 6 as const,
+		version: 7 as const,
 		configured: true,
 		groups: groupsRecord,
 		overrides: baseConfig.overrides ?? {},

package/bin/inspect.ts

@@ -249,7 +249,7 @@ export async function inspectCliCore(
 			);
 		}
 		case "project": {
-			const details = getProjectDetails(parsed.projectRef!, dbInput);
+			const details = getProjectDetails(parsed.projectRef ?? "", dbInput);
 			if (details === null) {
 				return makeError(`Project not found: ${parsed.projectRef}`, parsed.json);
 			}
@@ -260,7 +260,7 @@ export async function inspectCliCore(
 			);
 		}
 		case "paths": {
-			const details = getProjectDetails(parsed.projectRef!, dbInput);
+			const details = getProjectDetails(parsed.projectRef ?? "", dbInput);
 			if (details === null) {
 				return makeError(`Project not found: ${parsed.projectRef}`, parsed.json);
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kodrunhq/opencode-autopilot",
-	"version": "1.16.0",
+	"version": "1.18.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": [

package/src/config/index.ts

@@ -0,0 +1,29 @@
+export {
+	CONFIG_PATH,
+	confidenceConfigSchema,
+	confidenceDefaults,
+	createDefaultConfig,
+	isFirstLoad,
+	loadConfig,
+	memoryConfigSchema,
+	memoryDefaults,
+	orchestratorConfigSchema,
+	orchestratorDefaults,
+	type PluginConfig,
+	pluginConfigSchema,
+	saveConfig,
+} from "../config";
+// Re-export migration schemas and functions for backward compatibility
+export {
+	migrateV1toV2,
+	migrateV2toV3,
+	migrateV3toV4,
+	migrateV4toV5,
+	migrateV5toV6,
+	pluginConfigSchemaV1,
+	pluginConfigSchemaV2,
+	pluginConfigSchemaV3,
+	pluginConfigSchemaV4,
+	pluginConfigSchemaV5,
+} from "./migrations";
+export { migrateV6toV7, type PluginConfigV7, v7ConfigDefaults } from "./v7";

package/src/config/migrations.ts

@@ -0,0 +1,196 @@
+import { z } from "zod";
+import {
+	confidenceConfigSchema,
+	confidenceDefaults,
+	memoryConfigSchema,
+	memoryDefaults,
+	orchestratorConfigSchema,
+	orchestratorDefaults,
+} from "../config";
+import {
+	fallbackConfigSchema,
+	fallbackDefaults,
+	testModeDefaults,
+} from "../orchestrator/fallback/fallback-config";
+import { AGENT_REGISTRY, ALL_GROUP_IDS } from "../registry/model-groups";
+
+export const pluginConfigSchemaV1 = z.object({
+	version: z.literal(1),
+	configured: z.boolean(),
+	models: z.record(z.string(), z.string()),
+});
+
+export type PluginConfigV1 = z.infer<typeof pluginConfigSchemaV1>;
+
+export const pluginConfigSchemaV2 = z.object({
+	version: z.literal(2),
+	configured: z.boolean(),
+	models: z.record(z.string(), z.string()),
+	orchestrator: orchestratorConfigSchema.default(orchestratorDefaults),
+	confidence: confidenceConfigSchema.default(confidenceDefaults),
+});
+
+export type PluginConfigV2 = z.infer<typeof pluginConfigSchemaV2>;
+
+export const pluginConfigSchemaV3 = z.object({
+	version: z.literal(3),
+	configured: z.boolean(),
+	models: z.record(z.string(), z.string()),
+	orchestrator: orchestratorConfigSchema.default(orchestratorDefaults),
+	confidence: confidenceConfigSchema.default(confidenceDefaults),
+	fallback: fallbackConfigSchema.default(fallbackDefaults),
+	fallback_models: z.union([z.string(), z.array(z.string())]).optional(),
+});
+
+export type PluginConfigV3 = z.infer<typeof pluginConfigSchemaV3>;
+
+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(),
+});
+
+export 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 type PluginConfigV4 = z.infer<typeof pluginConfigSchemaV4>;
+
+export const pluginConfigSchemaV5 = z
+	.object({
+		version: z.literal(5),
+		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),
+		memory: memoryConfigSchema.default(memoryDefaults),
+	})
+	.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 type PluginConfigV5 = z.infer<typeof pluginConfigSchemaV5>;
+
+export function migrateV1toV2(v1Config: PluginConfigV1): PluginConfigV2 {
+	return {
+		version: 2 as const,
+		configured: v1Config.configured,
+		models: v1Config.models,
+		orchestrator: orchestratorDefaults,
+		confidence: confidenceDefaults,
+	};
+}
+
+export function migrateV2toV3(v2Config: PluginConfigV2): PluginConfigV3 {
+	return {
+		version: 3 as const,
+		configured: v2Config.configured,
+		models: v2Config.models,
+		orchestrator: v2Config.orchestrator,
+		confidence: v2Config.confidence,
+		fallback: fallbackDefaults,
+	};
+}
+
+export function migrateV3toV4(v3Config: PluginConfigV3): PluginConfigV4 {
+	const groups: Record<string, { primary: string; fallbacks: string[] }> = {};
+	const overrides: Record<string, { primary: string }> = {};
+
+	for (const [agentName, modelId] of Object.entries(v3Config.models)) {
+		const entry = AGENT_REGISTRY[agentName];
+		if (!entry) {
+			overrides[agentName] = { primary: modelId };
+			continue;
+		}
+
+		const groupId = entry.group;
+		if (!groups[groupId]) {
+			groups[groupId] = { primary: modelId, fallbacks: [] };
+		} else if (groups[groupId].primary !== modelId) {
+			overrides[agentName] = { primary: modelId };
+		}
+	}
+
+	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,
+	};
+}
+
+export function migrateV4toV5(v4Config: PluginConfigV4): PluginConfigV5 {
+	return {
+		version: 5 as const,
+		configured: v4Config.configured,
+		groups: v4Config.groups,
+		overrides: v4Config.overrides,
+		orchestrator: v4Config.orchestrator,
+		confidence: v4Config.confidence,
+		fallback: v4Config.fallback,
+		memory: memoryDefaults,
+	};
+}
+
+export function migrateV5toV6(
+	v5Config: PluginConfigV5,
+	_fallbackDefaultsV6: typeof fallbackDefaults,
+) {
+	return {
+		version: 6 as const,
+		configured: v5Config.configured,
+		groups: v5Config.groups,
+		overrides: v5Config.overrides,
+		orchestrator: v5Config.orchestrator,
+		confidence: v5Config.confidence,
+		fallback: { ...v5Config.fallback, testMode: testModeDefaults },
+		memory: v5Config.memory,
+	};
+}

package/src/config/v7.ts

@@ -0,0 +1,45 @@
+import type { PluginConfig } from "../config";
+
+export type PluginConfigV7 = Omit<PluginConfig, "version"> & {
+	readonly version: 7;
+	readonly background?: {
+		readonly enabled: boolean;
+		readonly maxConcurrent: number;
+		readonly persistence: boolean;
+	};
+	readonly autonomy?: {
+		readonly enabled: boolean;
+		readonly verification: "strict" | "normal" | "lenient";
+		readonly maxIterations: number;
+	};
+};
+
+export function migrateV6toV7(v6Config: PluginConfig): PluginConfigV7 {
+	return {
+		...v6Config,
+		version: 7,
+		background: {
+			enabled: true,
+			maxConcurrent: 5,
+			persistence: true,
+		},
+		autonomy: {
+			enabled: false,
+			verification: "normal",
+			maxIterations: 10,
+		},
+	};
+}
+
+export const v7ConfigDefaults = {
+	background: {
+		enabled: true,
+		maxConcurrent: 5,
+		persistence: true,
+	},
+	autonomy: {
+		enabled: false,
+		verification: "normal",
+		maxIterations: 10,
+	},
+} as const;

package/src/config.ts

@@ -10,6 +10,10 @@ import {
 	testModeDefaults,
 } from "./orchestrator/fallback/fallback-config";
 import { AGENT_REGISTRY, ALL_GROUP_IDS } from "./registry/model-groups";
+import { backgroundConfigSchema, backgroundDefaults } from "./types/background";
+import { mcpConfigSchema, mcpDefaults } from "./types/mcp";
+import { recoveryConfigSchema, recoveryDefaults } from "./types/recovery";
+import { routingConfigSchema, routingDefaults } from "./types/routing";
 import { ensureDir, isEnoentError } from "./utils/fs-helpers";
 import { getGlobalConfigDir } from "./utils/paths";
 
@@ -53,8 +57,8 @@ export const confidenceConfigSchema = z.object({
 });
 
 // Pre-compute full defaults for nested schema defaults
-const orchestratorDefaults = orchestratorConfigSchema.parse({});
-const confidenceDefaults = confidenceConfigSchema.parse({});
+export const orchestratorDefaults = orchestratorConfigSchema.parse({});
+export const confidenceDefaults = confidenceConfigSchema.parse({});
 
 // --- V2 schema (internal, for migration) ---
 
@@ -90,7 +94,7 @@ export const memoryConfigSchema = z.object({
 	decayHalfLifeDays: z.number().min(7).max(365).default(90),
 });
 
-const memoryDefaults = memoryConfigSchema.parse({});
+export const memoryDefaults = memoryConfigSchema.parse({});
 
 // --- V4 sub-schemas ---
 
@@ -182,14 +186,47 @@ const pluginConfigSchemaV6 = z
 		}
 	});
 
-// Export aliases updated to v6
-export const pluginConfigSchema = pluginConfigSchemaV6;
+type PluginConfigV6 = z.infer<typeof pluginConfigSchemaV6>;
 
-export type PluginConfig = z.infer<typeof pluginConfigSchemaV6>;
+const pluginConfigSchemaV7 = z
+	.object({
+		version: z.literal(7),
+		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: fallbackConfigSchemaV6.default(fallbackDefaultsV6),
+		memory: memoryConfigSchema.default(memoryDefaults),
+		background: backgroundConfigSchema.default(backgroundDefaults),
+		autonomy: z
+			.object({
+				enabled: z.boolean().default(false),
+				verification: z.enum(["strict", "normal", "lenient"]).default("normal"),
+				maxIterations: z.number().int().min(1).max(50).default(10),
+			})
+			.default({ enabled: false, verification: "normal", maxIterations: 10 }),
+		routing: routingConfigSchema.default(routingDefaults),
+		recovery: recoveryConfigSchema.default(recoveryDefaults),
+		mcp: mcpConfigSchema.default(mcpDefaults),
+	})
+	.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 const CONFIG_PATH = join(getGlobalConfigDir(), "opencode-autopilot.json");
+export const pluginConfigSchema = pluginConfigSchemaV7;
+
+export type PluginConfig = z.infer<typeof pluginConfigSchemaV7>;
 
-// --- Migration ---
+export const CONFIG_PATH = join(getGlobalConfigDir(), "opencode-autopilot.json");
 
 function migrateV1toV2(v1Config: PluginConfigV1): PluginConfigV2 {
 	return {
@@ -274,7 +311,7 @@ function migrateV4toV5(v4Config: PluginConfigV4): PluginConfigV5 {
 	};
 }
 
-function migrateV5toV6(v5Config: PluginConfigV5): PluginConfig {
+function migrateV5toV6(v5Config: PluginConfigV5): PluginConfigV6 {
 	return {
 		version: 6 as const,
 		configured: v5Config.configured,
@@ -287,68 +324,106 @@ function migrateV5toV6(v5Config: PluginConfigV5): PluginConfig {
 	};
 }
 
-// --- Public API ---
+export const v7ConfigDefaults = {
+	background: backgroundDefaults,
+	autonomy: {
+		enabled: false,
+		verification: "normal" as const,
+		maxIterations: 10,
+	},
+	routing: routingDefaults,
+	recovery: recoveryDefaults,
+	mcp: mcpDefaults,
+} as const;
+
+export function migrateV6toV7(v6Config: PluginConfigV6): PluginConfig {
+	return {
+		version: 7 as const,
+		configured: v6Config.configured,
+		groups: v6Config.groups,
+		overrides: v6Config.overrides,
+		orchestrator: v6Config.orchestrator,
+		confidence: v6Config.confidence,
+		fallback: v6Config.fallback,
+		memory: v6Config.memory,
+		background: backgroundDefaults,
+		autonomy: {
+			enabled: false,
+			verification: "normal",
+			maxIterations: 10,
+		},
+		routing: routingDefaults,
+		recovery: recoveryDefaults,
+		mcp: mcpDefaults,
+	};
+}
 
 export async function loadConfig(configPath: string = CONFIG_PATH): Promise<PluginConfig | null> {
 	try {
 		const raw = await readFile(configPath, "utf-8");
 		const parsed = JSON.parse(raw);
 
-		// Try v6 first
+		const v7Result = pluginConfigSchemaV7.safeParse(parsed);
+		if (v7Result.success) return v7Result.data;
+
 		const v6Result = pluginConfigSchemaV6.safeParse(parsed);
-		if (v6Result.success) return v6Result.data;
+		if (v6Result.success) {
+			const migrated = migrateV6toV7(v6Result.data);
+			await saveConfig(migrated, configPath);
+			return migrated;
+		}
 
-		// Try v5 and migrate to v6
 		const v5Result = pluginConfigSchemaV5.safeParse(parsed);
 		if (v5Result.success) {
-			const migrated = migrateV5toV6(v5Result.data);
+			const v6 = migrateV5toV6(v5Result.data);
+			const migrated = migrateV6toV7(v6);
 			await saveConfig(migrated, configPath);
 			return migrated;
 		}
 
-		// Try v4 → v5 → v6
 		const v4Result = pluginConfigSchemaV4.safeParse(parsed);
 		if (v4Result.success) {
 			const v5 = migrateV4toV5(v4Result.data);
-			const migrated = migrateV5toV6(v5);
+			const v6 = migrateV5toV6(v5);
+			const migrated = migrateV6toV7(v6);
 			await saveConfig(migrated, configPath);
 			return migrated;
 		}
 
-		// Try v3 → v4 → v5 → v6
 		const v3Result = pluginConfigSchemaV3.safeParse(parsed);
 		if (v3Result.success) {
 			const v4 = migrateV3toV4(v3Result.data);
 			const v5 = migrateV4toV5(v4);
-			const migrated = migrateV5toV6(v5);
+			const v6 = migrateV5toV6(v5);
+			const migrated = migrateV6toV7(v6);
 			await saveConfig(migrated, configPath);
 			return migrated;
 		}
 
-		// Try v2 → v3 → v4 → v5 → v6
 		const v2Result = pluginConfigSchemaV2.safeParse(parsed);
 		if (v2Result.success) {
 			const v3 = migrateV2toV3(v2Result.data);
 			const v4 = migrateV3toV4(v3);
 			const v5 = migrateV4toV5(v4);
-			const migrated = migrateV5toV6(v5);
+			const v6 = migrateV5toV6(v5);
+			const migrated = migrateV6toV7(v6);
 			await saveConfig(migrated, configPath);
 			return migrated;
 		}
 
-		// Try v1 → v2 → v3 → v4 → v5 → v6
 		const v1Result = pluginConfigSchemaV1.safeParse(parsed);
 		if (v1Result.success) {
 			const v2 = migrateV1toV2(v1Result.data);
 			const v3 = migrateV2toV3(v2);
 			const v4 = migrateV3toV4(v3);
 			const v5 = migrateV4toV5(v4);
-			const migrated = migrateV5toV6(v5);
+			const v6 = migrateV5toV6(v5);
+			const migrated = migrateV6toV7(v6);
 			await saveConfig(migrated, configPath);
 			return migrated;
 		}
 
-		return pluginConfigSchemaV6.parse(parsed); // throw with proper error
+		return pluginConfigSchemaV7.parse(parsed);
 	} catch (error: unknown) {
 		if (isEnoentError(error)) return null;
 		throw error;
@@ -371,7 +446,7 @@ export function isFirstLoad(config: PluginConfig | null): boolean {
 
 export function createDefaultConfig(): PluginConfig {
 	return {
-		version: 6 as const,
+		version: 7 as const,
 		configured: false,
 		groups: {},
 		overrides: {},
@@ -379,5 +454,14 @@ export function createDefaultConfig(): PluginConfig {
 		confidence: confidenceDefaults,
 		fallback: fallbackDefaultsV6,
 		memory: memoryDefaults,
+		background: backgroundDefaults,
+		autonomy: {
+			enabled: false,
+			verification: "normal",
+			maxIterations: 10,
+		},
+		routing: routingDefaults,
+		recovery: recoveryDefaults,
+		mcp: mcpDefaults,
 	};
 }