@kodrunhq/opencode-autopilot 1.17.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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kodrunhq/opencode-autopilot",
-	"version": "1.17.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/v7.ts

@@ -5,7 +5,7 @@ export type PluginConfigV7 = Omit<PluginConfig, "version"> & {
 	readonly background?: {
 		readonly enabled: boolean;
 		readonly maxConcurrent: number;
-		readonly defaultTimeout: number;
+		readonly persistence: boolean;
 	};
 	readonly autonomy?: {
 		readonly enabled: boolean;
@@ -21,7 +21,7 @@ export function migrateV6toV7(v6Config: PluginConfig): PluginConfigV7 {
 		background: {
 			enabled: true,
 			maxConcurrent: 5,
-			defaultTimeout: 300000,
+			persistence: true,
 		},
 		autonomy: {
 			enabled: false,
@@ -35,7 +35,7 @@ export const v7ConfigDefaults = {
 	background: {
 		enabled: true,
 		maxConcurrent: 5,
-		defaultTimeout: 300000,
+		persistence: true,
 	},
 	autonomy: {
 		enabled: false,

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";
 
@@ -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,
 	};
 }

package/src/health/checks.ts

@@ -44,7 +44,7 @@ export async function configHealthCheck(configPath?: string): Promise<HealthResu
 	}
 }
 
-const LATEST_CONFIG_VERSION = 6;
+const LATEST_CONFIG_VERSION = 7;
 
 export async function configVersionCheck(configPath?: string): Promise<HealthResult> {
 	try {
@@ -141,6 +141,74 @@ export async function configGroupsCheck(configPath?: string): Promise<HealthResu
 	}
 }
 
+/** v7 config fields that must be present on a v7 config. */
+const V7_REQUIRED_FIELDS: readonly string[] = Object.freeze([
+	"background",
+	"routing",
+	"recovery",
+	"mcp",
+]);
+
+/**
+ * Check that v7 configs contain all four new top-level fields introduced in v7:
+ * background, routing, recovery, and mcp.
+ * Inspects the raw on-disk JSON so that Zod default-filling does not mask
+ * actually-missing fields. Pre-v7 configs receive a pass with a migration notice.
+ */
+export async function configV7FieldsCheck(configPath?: string): Promise<HealthResult> {
+	const resolvedPath = configPath ?? join(getGlobalConfigDir(), "opencode-autopilot.json");
+	try {
+		let raw: Record<string, unknown>;
+		try {
+			const content = await readFile(resolvedPath, "utf-8");
+			raw = JSON.parse(content) as Record<string, unknown>;
+		} catch (error: unknown) {
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+				return Object.freeze({
+					name: "config-v7-fields",
+					status: "fail" as const,
+					message: "Config file not found",
+				});
+			}
+			throw error;
+		}
+
+		const version = typeof raw.version === "number" ? raw.version : 0;
+
+		if (version < 7) {
+			return Object.freeze({
+				name: "config-v7-fields",
+				status: "pass" as const,
+				message: `Config v${version} will gain v7 fields (background, routing, recovery, mcp) on next load`,
+			});
+		}
+
+		const missingFields = V7_REQUIRED_FIELDS.filter((field) => !(field in raw));
+
+		if (missingFields.length > 0) {
+			return Object.freeze({
+				name: "config-v7-fields",
+				status: "fail" as const,
+				message: `Config v7 is missing required fields: ${missingFields.join(", ")}`,
+				details: Object.freeze(missingFields),
+			});
+		}
+
+		return Object.freeze({
+			name: "config-v7-fields",
+			status: "pass" as const,
+			message: `Config v7 fields present: ${V7_REQUIRED_FIELDS.join(", ")}`,
+		});
+	} catch (error: unknown) {
+		const msg = error instanceof Error ? error.message : String(error);
+		return Object.freeze({
+			name: "config-v7-fields",
+			status: "fail" as const,
+			message: `Config v7 fields check failed: ${msg}`,
+		});
+	}
+}
+
 /** Standard agent names, derived from the agents barrel export. */
 const STANDARD_AGENT_NAMES: readonly string[] = Object.freeze([
 	"researcher",

package/src/health/runner.ts

@@ -4,6 +4,7 @@ import {
 	assetHealthCheck,
 	commandHealthCheck,
 	configHealthCheck,
+	configV7FieldsCheck,
 	memoryHealthCheck,
 	nativeAgentSuppressionHealthCheck,
 	skillHealthCheck,
@@ -43,16 +44,20 @@ export async function runHealthChecks(options?: {
 }): Promise<HealthReport> {
 	const start = Date.now();
 
+	const configOutcome = await Promise.allSettled([configHealthCheck(options?.configPath)]);
+
 	const settled = await Promise.allSettled([
-		configHealthCheck(options?.configPath),
 		agentHealthCheck(options?.openCodeConfig ?? null),
 		nativeAgentSuppressionHealthCheck(options?.openCodeConfig ?? null),
 		assetHealthCheck(options?.assetsDir, options?.targetDir),
 		skillHealthCheck(options?.projectRoot ?? process.cwd()),
 		memoryHealthCheck(options?.targetDir),
 		commandHealthCheck(options?.targetDir),
+		configV7FieldsCheck(options?.configPath),
 	]);
 
+	const allSettled = [...configOutcome, ...settled];
+
 	const fallbackNames = [
 		"config-validity",
 		"agent-injection",
@@ -61,9 +66,10 @@ export async function runHealthChecks(options?: {
 		"skill-loading",
 		"memory-db",
 		"command-accessibility",
+		"config-v7-fields",
 	];
 	const results: readonly HealthResult[] = Object.freeze(
-		settled.map((outcome, i) => settledToResult(outcome, fallbackNames[i])),
+		allSettled.map((outcome, i) => settledToResult(outcome, fallbackNames[i])),
 	);
 
 	const allPassed = results.every((r) => r.status === "pass");

package/src/tools/configure.ts

@@ -314,7 +314,7 @@ async function handleCommit(configPath?: string): Promise<string> {
 	}
 	const newConfig = {
 		...currentConfig,
-		version: 6 as const,
+		version: 7 as const,
 		configured: true,
 		groups: groupsRecord,
 		overrides: currentConfig.overrides ?? {},

package/src/types/background.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+
+export const TaskStatusSchema = z.enum(["pending", "running", "completed", "failed", "cancelled"]);
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+
+export const TaskResultSchema = z.object({
+	taskId: z.string().min(1),
+	status: TaskStatusSchema,
+	output: z.string().optional(),
+	error: z.string().optional(),
+	startedAt: z.number().optional(),
+	completedAt: z.number().optional(),
+	durationMs: z.number().optional(),
+});
+export type TaskResult = z.infer<typeof TaskResultSchema>;
+
+export const BackgroundTaskSchema = z.object({
+	id: z.string().min(1),
+	name: z.string().min(1),
+	status: TaskStatusSchema,
+	agentId: z.string().optional(),
+	priority: z.number().int().min(0).max(100).default(50),
+	createdAt: z.number(),
+	result: TaskResultSchema.optional(),
+	metadata: z.record(z.string(), z.unknown()).default({}),
+});
+export type BackgroundTask = z.infer<typeof BackgroundTaskSchema>;
+
+export const AgentSlotSchema = z.object({
+	slotId: z.string().min(1),
+	agentId: z.string().min(1),
+	capacity: z.number().int().min(1).max(100).default(1),
+	activeTaskCount: z.number().int().min(0).default(0),
+	reserved: z.boolean().default(false),
+});
+export type AgentSlot = z.infer<typeof AgentSlotSchema>;
+
+export const ConcurrencyLimitsSchema = z.object({
+	global: z.number().int().min(1).max(50).default(5),
+	perAgent: z.number().int().min(1).max(10).default(2),
+	perCategory: z.record(z.string(), z.number().int().min(1).max(20)).default({}),
+});
+export type ConcurrencyLimits = z.infer<typeof ConcurrencyLimitsSchema>;
+
+export const backgroundConfigSchema = z.object({
+	enabled: z.boolean().default(false),
+	maxConcurrent: z.number().int().min(1).max(50).default(5),
+	persistence: z.boolean().default(true),
+});
+export type BackgroundConfig = z.infer<typeof backgroundConfigSchema>;
+export const backgroundDefaults = backgroundConfigSchema.parse({});

package/src/types/mcp.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+
+export const McpSkillSchema = z.object({
+	name: z.string().min(1),
+	description: z.string().optional(),
+	enabled: z.boolean().default(true),
+	version: z.string().optional(),
+	config: z.record(z.string(), z.unknown()).default({}),
+});
+export type McpSkill = z.infer<typeof McpSkillSchema>;
+
+export const McpServerSchema = z.object({
+	id: z.string().min(1),
+	url: z.string().url().optional(),
+	transport: z.enum(["stdio", "http", "sse"]).default("stdio"),
+	enabled: z.boolean().default(true),
+	skills: z.array(z.string()).default([]),
+	metadata: z.record(z.string(), z.unknown()).default({}),
+});
+export type McpServer = z.infer<typeof McpServerSchema>;
+
+export const mcpConfigSchema = z.object({
+	enabled: z.boolean().default(false),
+	skills: z.record(z.string(), z.unknown()).default({}),
+});
+export type McpConfig = z.infer<typeof mcpConfigSchema>;
+export const mcpDefaults = mcpConfigSchema.parse({});

package/src/types/recovery.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+
+export const ErrorCategorySchema = z.enum([
+	"rate_limit",
+	"auth_failure",
+	"quota_exceeded",
+	"service_unavailable",
+	"timeout",
+	"network",
+	"validation",
+	"unknown",
+]);
+export type ErrorCategory = z.infer<typeof ErrorCategorySchema>;
+
+export const RecoveryStrategySchema = z.enum([
+	"retry",
+	"fallback_model",
+	"skip",
+	"abort",
+	"user_prompt",
+]);
+export type RecoveryStrategy = z.infer<typeof RecoveryStrategySchema>;
+
+export const RecoveryActionSchema = z.object({
+	strategy: RecoveryStrategySchema,
+	errorCategory: ErrorCategorySchema,
+	maxAttempts: z.number().int().min(1).max(10).default(3),
+	backoffMs: z.number().int().min(0).default(1000),
+	fallbackAgentId: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).default({}),
+});
+export type RecoveryAction = z.infer<typeof RecoveryActionSchema>;
+
+export const recoveryConfigSchema = z.object({
+	enabled: z.boolean().default(true),
+	maxRetries: z.number().int().min(0).max(10).default(3),
+});
+export type RecoveryConfig = z.infer<typeof recoveryConfigSchema>;
+export const recoveryDefaults = recoveryConfigSchema.parse({});

package/src/types/routing.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+
+export const CategorySchema = z.enum([
+	"quick",
+	"visual-engineering",
+	"ultrabrain",
+	"artistry",
+	"writing",
+	"unspecified-high",
+	"unspecified-low",
+]);
+export type Category = z.infer<typeof CategorySchema>;
+
+export const CategoryConfigSchema = z.object({
+	enabled: z.boolean().default(true),
+	agentId: z.string().optional(),
+	modelGroup: z.string().optional(),
+	maxTokenBudget: z.number().int().min(1000).optional(),
+	timeoutSeconds: z.number().int().min(1).max(3600).optional(),
+	skills: z.array(z.string()).default([]),
+	metadata: z.record(z.string(), z.unknown()).default({}),
+});
+export type CategoryConfig = z.infer<typeof CategoryConfigSchema>;
+
+export const RoutingDecisionSchema = z.object({
+	category: CategorySchema,
+	confidence: z.number().min(0).max(1),
+	agentId: z.string().optional(),
+	reasoning: z.string().optional(),
+	appliedConfig: CategoryConfigSchema.optional(),
+});
+export type RoutingDecision = z.infer<typeof RoutingDecisionSchema>;
+
+export const routingConfigSchema = z.object({
+	enabled: z.boolean().default(false),
+	categories: z.record(z.string(), CategoryConfigSchema).default({}),
+});
+export type RoutingConfig = z.infer<typeof routingConfigSchema>;
+export const routingDefaults = routingConfigSchema.parse({});