@kodrunhq/opencode-autopilot 1.18.0 → 1.19.0

package/src/skills/loader.ts

@@ -9,6 +9,7 @@
 import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { parse } from "yaml";
+import { skillMcpConfigSchema } from "../mcp/types";
 import { isEnoentError } from "../utils/fs-helpers";
 
 export interface SkillFrontmatter {
@@ -16,6 +17,7 @@ export interface SkillFrontmatter {
 	readonly description: string;
 	readonly stacks: readonly string[];
 	readonly requires: readonly string[];
+	readonly mcp: import("../mcp/types").SkillMcpConfig | null;
 }
 
 export interface LoadedSkill {
@@ -36,6 +38,7 @@ export function parseSkillFrontmatter(content: string): SkillFrontmatter | null
 		const parsed = parse(match[1]);
 		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
 		const fm = parsed as Record<string, unknown>;
+		const parsedMcp = fm.mcp === undefined ? null : skillMcpConfigSchema.safeParse(fm.mcp);
 		return {
 			name: typeof fm.name === "string" ? fm.name : "",
 			description: typeof fm.description === "string" ? fm.description : "",
@@ -45,6 +48,7 @@ export function parseSkillFrontmatter(content: string): SkillFrontmatter | null
 			requires: Array.isArray(fm.requires)
 				? fm.requires.filter((s): s is string => typeof s === "string")
 				: [],
+			mcp: parsedMcp?.success === true ? parsedMcp.data : null,
 		};
 	} catch {
 		return null;

package/src/tools/background.ts

@@ -0,0 +1,196 @@
+import type { Database } from "bun:sqlite";
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+import { BackgroundManager } from "../background/manager";
+import { type BackgroundSdkOperations, createSdkRunner } from "../background/sdk-runner";
+import { openKernelDb } from "../kernel/database";
+import type { TaskStatus } from "../types/background";
+
+const backgroundActionSchema = z.enum(["spawn", "status", "list", "cancel", "result"]);
+
+interface BackgroundToolOptions {
+	readonly sessionId?: string;
+	readonly taskId?: string;
+	readonly description?: string;
+	readonly category?: string;
+	readonly agent?: string;
+	readonly priority?: number;
+	readonly status?: TaskStatus;
+}
+
+let defaultManager: BackgroundManager | null = null;
+let backgroundSdkOps: BackgroundSdkOperations | null = null;
+
+export function setBackgroundSdkOperations(ops: BackgroundSdkOperations): void {
+	backgroundSdkOps = ops;
+}
+
+function getDefaultManager(): BackgroundManager {
+	if (defaultManager) {
+		return defaultManager;
+	}
+
+	const runTask = backgroundSdkOps ? createSdkRunner(backgroundSdkOps) : undefined;
+	defaultManager = new BackgroundManager({ db: openKernelDb(), runTask });
+	return defaultManager;
+}
+
+function createDisplayText(title: string, lines: readonly string[]): string {
+	return [title, ...lines].join("\n");
+}
+
+export async function backgroundCore(
+	action: z.infer<typeof backgroundActionSchema>,
+	options: BackgroundToolOptions = {},
+	db?: Database,
+): Promise<string> {
+	const isTransientManager = db !== undefined;
+	const manager = isTransientManager ? new BackgroundManager({ db }) : getDefaultManager();
+
+	try {
+		switch (action) {
+			case "spawn": {
+				if (!options.description) {
+					return JSON.stringify({ action: "error", message: "description required" });
+				}
+
+				const taskId = manager.spawn(options.sessionId ?? "unknown-session", options.description, {
+					category: options.category,
+					agent: options.agent,
+					priority: options.priority,
+				});
+				if (isTransientManager) {
+					await manager.waitForIdle();
+				}
+				const task = manager.getStatus(taskId);
+				return JSON.stringify({
+					action: "background_spawn",
+					task,
+					displayText: createDisplayText("Background task queued", [
+						`Task ID: ${taskId}`,
+						`Session: ${options.sessionId ?? "unknown-session"}`,
+						`Description: ${options.description}`,
+					]),
+				});
+			}
+
+			case "status": {
+				if (!options.taskId) {
+					return JSON.stringify({ action: "error", message: "taskId required" });
+				}
+
+				const task = manager.getStatus(options.taskId);
+				if (!task) {
+					return JSON.stringify({
+						action: "error",
+						message: `Task '${options.taskId}' not found.`,
+					});
+				}
+
+				return JSON.stringify({
+					action: "background_status",
+					task,
+					displayText: createDisplayText("Background task status", [
+						`Task ID: ${task.id}`,
+						`Status: ${task.status}`,
+						`Description: ${task.description}`,
+					]),
+				});
+			}
+
+			case "list": {
+				const tasks = manager.list(options.sessionId, options.status);
+				const taskLines =
+					tasks.length > 0
+						? tasks.map((task) => `${task.id} | ${task.status} | ${task.description}`)
+						: ["No background tasks found."];
+				return JSON.stringify({
+					action: "background_list",
+					tasks,
+					displayText: createDisplayText("Background tasks", taskLines),
+				});
+			}
+
+			case "cancel": {
+				if (!options.taskId) {
+					return JSON.stringify({ action: "error", message: "taskId required" });
+				}
+
+				const cancelled = manager.cancel(options.taskId);
+				const task = manager.getStatus(options.taskId);
+				return JSON.stringify({
+					action: "background_cancel",
+					cancelled,
+					task,
+					displayText: createDisplayText("Background cancel", [
+						`Task ID: ${options.taskId}`,
+						cancelled ? "Cancelled." : "Task could not be cancelled.",
+					]),
+				});
+			}
+
+			case "result": {
+				if (!options.taskId) {
+					return JSON.stringify({ action: "error", message: "taskId required" });
+				}
+
+				const result = manager.getResult(options.taskId);
+				if (!result) {
+					return JSON.stringify({
+						action: "error",
+						message: `Task '${options.taskId}' not found.`,
+					});
+				}
+
+				return JSON.stringify({
+					action: "background_result",
+					result,
+					displayText: createDisplayText("Background task result", [
+						`Task ID: ${options.taskId}`,
+						`Status: ${result.status}`,
+						`Result: ${result.result ?? "<none>"}`,
+						`Error: ${result.error ?? "<none>"}`,
+					]),
+				});
+			}
+		}
+	} finally {
+		if (isTransientManager && action === "spawn") {
+			await manager.dispose();
+		}
+	}
+
+	return JSON.stringify({ action: "error", message: `Unsupported action: ${action}` });
+}
+
+export const ocBackground = tool({
+	description:
+		"Manage background tasks. Actions: spawn, status, list, cancel, result. Returns JSON with displayText for presentation.",
+	args: {
+		action: backgroundActionSchema.describe("Background task action"),
+		sessionId: z.string().min(1).optional().describe("Session ID to scope tasks to"),
+		taskId: z.string().min(1).optional().describe("Background task ID"),
+		description: z.string().min(1).optional().describe("Background task description for spawn"),
+		category: z.string().min(1).optional().describe("Optional task category for spawn/list"),
+		agent: z.string().min(1).optional().describe("Optional agent hint for spawn"),
+		priority: z.number().int().min(0).max(100).optional().describe("Optional task priority"),
+		status: z
+			.enum(["pending", "running", "completed", "failed", "cancelled"])
+			.optional()
+			.describe("Optional status filter for list"),
+	},
+	async execute(
+		{ action, sessionId, taskId, description, category, agent, priority, status },
+		context,
+	) {
+		return backgroundCore(action, {
+			sessionId: sessionId ?? context.sessionID,
+			taskId,
+			description,
+			category,
+			agent,
+			priority,
+			status,
+		});
+	},
+});

package/src/tools/delegate.ts

@@ -0,0 +1,205 @@
+import type { Database } from "bun:sqlite";
+import { tool } from "@opencode-ai/plugin";
+import { BackgroundManager } from "../background/manager";
+import { type BackgroundSdkOperations, createSdkRunner } from "../background/sdk-runner";
+import { loadConfig } from "../config";
+import { openKernelDb } from "../kernel/database";
+import { makeRoutingDecision } from "../routing";
+import { getCategoryDefinition } from "../routing/categories";
+import { type Category, CategoryConfigSchema, CategorySchema } from "../types/routing";
+
+function buildDisplayText(input: {
+	readonly task: string;
+	readonly category: Category;
+	readonly confidence: number;
+	readonly reasoning: string;
+	readonly modelGroup: string;
+	readonly skills: readonly string[];
+	readonly taskId?: string;
+}): string {
+	const skillLine = input.skills.length > 0 ? input.skills.join(", ") : "none";
+	const lines = [
+		"Routing decision",
+		`Task: ${input.task}`,
+		`Category: ${input.category}`,
+		`Confidence: ${input.confidence.toFixed(2)}`,
+		`Model group: ${input.modelGroup}`,
+		`Skills: ${skillLine}`,
+		`Reasoning: ${input.reasoning}`,
+	];
+	if (input.taskId) {
+		lines.push(`Background task ID: ${input.taskId}`);
+	}
+	return lines.join("\n");
+}
+
+interface DelegateCoreOptions {
+	readonly sessionId?: string;
+	readonly spawn?: boolean;
+}
+
+interface ResolvedRouting {
+	readonly category: Category;
+	readonly confidence: number;
+	readonly reasoning: string;
+	readonly modelGroup: string;
+	readonly agentId: string | undefined;
+	readonly skills: readonly string[];
+}
+
+function resolveRoutingDecision(
+	task: string,
+	category: string | undefined,
+	config: Awaited<ReturnType<typeof loadConfig>>,
+): ResolvedRouting | null {
+	if (category !== undefined) {
+		const parsedCategory = CategorySchema.safeParse(category);
+		if (!parsedCategory.success) {
+			return null;
+		}
+
+		const explicitDefinition = getCategoryDefinition(parsedCategory.data);
+		const override = config?.routing?.categories?.[parsedCategory.data];
+		const appliedConfig = CategoryConfigSchema.parse({
+			enabled: override?.enabled ?? true,
+			agentId: override?.agentId,
+			modelGroup: override?.modelGroup ?? explicitDefinition.modelGroup,
+			timeoutSeconds: override?.timeoutSeconds ?? explicitDefinition.timeoutSeconds,
+			skills: override?.skills ?? [...explicitDefinition.skills],
+			metadata: {
+				maxIterations: explicitDefinition.maxIterations,
+				...(override?.metadata ?? {}),
+			},
+		});
+
+		return {
+			category: parsedCategory.data,
+			confidence: 1,
+			reasoning: `Category explicitly provided as '${parsedCategory.data}'.`,
+			modelGroup: appliedConfig?.modelGroup ?? explicitDefinition.modelGroup,
+			agentId: appliedConfig?.agentId,
+			skills: appliedConfig?.skills ?? explicitDefinition.skills,
+		};
+	}
+
+	const decision = makeRoutingDecision(task, config?.routing);
+	const definition = getCategoryDefinition(decision.category);
+	return {
+		category: decision.category,
+		confidence: decision.confidence,
+		reasoning: decision.reasoning ?? "No routing reasoning available.",
+		modelGroup: decision.appliedConfig?.modelGroup ?? definition.modelGroup,
+		agentId: decision.agentId,
+		skills: decision.appliedConfig?.skills ?? definition.skills,
+	};
+}
+
+let defaultDelegateManager: BackgroundManager | null = null;
+let delegateSdkOps: BackgroundSdkOperations | null = null;
+
+export function setDelegateSdkOperations(ops: BackgroundSdkOperations): void {
+	delegateSdkOps = ops;
+}
+
+function getDelegateManager(db?: Database): BackgroundManager {
+	if (db) {
+		return new BackgroundManager({ db });
+	}
+	if (defaultDelegateManager) {
+		return defaultDelegateManager;
+	}
+	const runTask = delegateSdkOps ? createSdkRunner(delegateSdkOps) : undefined;
+	defaultDelegateManager = new BackgroundManager({ db: openKernelDb(), runTask });
+	return defaultDelegateManager;
+}
+
+export async function delegateCore(
+	task: string,
+	category?: string,
+	db?: Database,
+	options?: DelegateCoreOptions,
+): Promise<string> {
+	if (task.trim().length === 0) {
+		return JSON.stringify({
+			action: "error",
+			message: "Task is required.",
+		});
+	}
+
+	const config = await loadConfig();
+
+	if (category !== undefined) {
+		const parsedCategory = CategorySchema.safeParse(category);
+		if (!parsedCategory.success) {
+			return JSON.stringify({
+				action: "error",
+				message: `Invalid category '${category}'.`,
+			});
+		}
+	}
+
+	const routing = resolveRoutingDecision(task, category, config);
+	if (!routing) {
+		return JSON.stringify({
+			action: "error",
+			message: `Invalid category '${category}'.`,
+		});
+	}
+
+	const shouldSpawn = options?.spawn !== false;
+	let taskId: string | undefined;
+
+	if (shouldSpawn) {
+		const manager = getDelegateManager(db);
+		const sessionId = options?.sessionId ?? "delegate-session";
+		taskId = manager.spawn(sessionId, task, {
+			category: routing.category,
+			agent: routing.agentId,
+			model: routing.modelGroup,
+		});
+
+		if (db) {
+			await manager.waitForIdle();
+			await manager.dispose();
+		}
+	}
+
+	return JSON.stringify({
+		action: shouldSpawn ? "delegated" : "routing_only",
+		category: routing.category,
+		confidence: routing.confidence,
+		reasoning: routing.reasoning,
+		suggestedModelGroup: routing.modelGroup,
+		suggestedSkills: routing.skills,
+		...(taskId ? { taskId } : {}),
+		displayText: buildDisplayText({
+			task,
+			category: routing.category,
+			confidence: routing.confidence,
+			reasoning: routing.reasoning,
+			modelGroup: routing.modelGroup,
+			skills: routing.skills,
+			taskId,
+		}),
+	});
+}
+
+export const ocDelegate = tool({
+	description:
+		"Route a task to the best category and spawn a background task with the routing decision. Returns routing info and a background task ID.",
+	args: {
+		task: tool.schema.string().min(1).max(4096).describe("Task description to route"),
+		category: CategorySchema.optional().describe("Optional explicit routing category override"),
+		spawn: tool.schema
+			.boolean()
+			.optional()
+			.default(true)
+			.describe("Whether to spawn a background task (default: true)"),
+	},
+	async execute(args, context) {
+		return delegateCore(args.task, args.category, undefined, {
+			sessionId: context.sessionID,
+			spawn: args.spawn,
+		});
+	},
+});

package/src/tools/loop.ts

@@ -0,0 +1,94 @@
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+import { getLoopController, type LoopController } from "../autonomy";
+
+type LoopAction = "status" | "abort" | "start" | "pause" | "resume" | "iterate";
+
+function buildDisplayText(action: LoopAction, controller: LoopController): string {
+	const context = controller.getStatus();
+	const lines = [
+		`Loop action: ${action}`,
+		`State: ${context.state}`,
+		`Task: ${context.taskDescription || "No active task"}`,
+		`Iteration: ${context.currentIteration}/${context.maxIterations}`,
+		`Contexts: ${context.accumulatedContext.length}`,
+		`Verification runs: ${context.verificationResults.length}`,
+	];
+
+	return lines.join("\n");
+}
+
+export async function loopCore(
+	action: LoopAction,
+	options?: {
+		readonly taskDescription?: string;
+		readonly maxIterations?: number;
+		readonly iterationResult?: string;
+	},
+	controller: LoopController = getLoopController(),
+): Promise<string> {
+	switch (action) {
+		case "start": {
+			const description = options?.taskDescription ?? "Untitled task";
+			controller.start(description, {
+				maxIterations: options?.maxIterations,
+			});
+			break;
+		}
+
+		case "iterate": {
+			const result = options?.iterationResult ?? "";
+			await controller.iterate(result);
+			break;
+		}
+
+		case "pause": {
+			controller.pause();
+			break;
+		}
+
+		case "resume": {
+			controller.resume();
+			break;
+		}
+
+		case "abort": {
+			controller.abort();
+			break;
+		}
+
+		case "status":
+			break;
+	}
+
+	return JSON.stringify({
+		action: `loop_${action}`,
+		context: controller.getStatus(),
+		displayText: buildDisplayText(action, controller),
+	});
+}
+
+export const ocLoop = tool({
+	description:
+		"Manage the autonomy loop. Actions: start (begin new loop), iterate (advance with result), pause, resume, abort, status.",
+	args: {
+		action: z
+			.enum(["status", "abort", "start", "pause", "resume", "iterate"])
+			.describe("Loop action to perform"),
+		taskDescription: z.string().min(1).optional().describe("Task description for the start action"),
+		maxIterations: z
+			.number()
+			.int()
+			.min(1)
+			.max(100)
+			.optional()
+			.describe("Max iterations for the start action"),
+		iterationResult: z
+			.string()
+			.optional()
+			.describe("Result of the current iteration for the iterate action"),
+	},
+	async execute({ action, taskDescription, maxIterations, iterationResult }) {
+		return loopCore(action, { taskDescription, maxIterations, iterationResult });
+	},
+});

package/src/tools/recover.ts

@@ -0,0 +1,172 @@
+import type { Database } from "bun:sqlite";
+import { tool } from "@opencode-ai/plugin";
+import { openKernelDb } from "../kernel/database";
+import {
+	getDefaultRecoveryOrchestrator,
+	getStrategy,
+	type RecoveryOrchestrator,
+} from "../recovery";
+import { clearRecoveryState, loadRecoveryState } from "../recovery/persistence";
+import type { RecoveryState } from "../recovery/types";
+
+const recoverActionSchema = tool.schema.enum(["status", "retry", "reset", "history"]);
+type RecoverToolAction = "status" | "retry" | "reset" | "history";
+
+interface RecoverToolOptions {
+	readonly sessionId?: string;
+	readonly orchestrator?: RecoveryOrchestrator;
+}
+
+function createDisplayText(title: string, lines: readonly string[]): string {
+	return [title, ...lines].join("\n");
+}
+
+function getOrchestrator(options?: RecoverToolOptions): RecoveryOrchestrator {
+	return options?.orchestrator ?? getDefaultRecoveryOrchestrator();
+}
+
+function getState(
+	orchestrator: RecoveryOrchestrator,
+	sessionId: string,
+	db?: Database,
+): RecoveryState | null {
+	const inMemoryState = orchestrator.getState(sessionId);
+	if (inMemoryState) {
+		return inMemoryState;
+	}
+
+	return db ? loadRecoveryState(db, sessionId) : null;
+}
+
+export async function recoverCore(
+	action: RecoverToolAction,
+	options: RecoverToolOptions = {},
+	db?: Database,
+): Promise<string> {
+	const sessionId = options.sessionId;
+	if (!sessionId) {
+		return JSON.stringify({ action: "error", message: "sessionId required" });
+	}
+
+	const orchestrator = getOrchestrator(options);
+	const state = getState(orchestrator, sessionId, db);
+
+	switch (action) {
+		case "status": {
+			if (!state) {
+				return JSON.stringify({
+					action: "recovery_status",
+					sessionId,
+					state: null,
+					displayText: createDisplayText("Recovery status", [
+						`Session: ${sessionId}`,
+						"No recovery state found.",
+					]),
+				});
+			}
+
+			return JSON.stringify({
+				action: "recovery_status",
+				sessionId,
+				state,
+				displayText: createDisplayText("Recovery status", [
+					`Session: ${sessionId}`,
+					`Attempts: ${state.attempts.length}/${state.maxAttempts}`,
+					`Recovering: ${state.isRecovering ? "yes" : "no"}`,
+					`Current strategy: ${state.currentStrategy ?? "<none>"}`,
+					`Last error: ${state.lastError ?? "<none>"}`,
+				]),
+			});
+		}
+
+		case "history": {
+			const history = state?.attempts ?? [];
+			return JSON.stringify({
+				action: "recovery_history",
+				sessionId,
+				history,
+				displayText: createDisplayText(
+					"Recovery history",
+					history.length > 0
+						? history.map(
+								(attempt) =>
+									`#${attempt.attemptNumber} ${attempt.errorCategory} -> ${attempt.strategy} (${attempt.success ? "success" : "pending"})`,
+							)
+						: [`Session: ${sessionId}`, "No recovery attempts found."],
+				),
+			});
+		}
+
+		case "reset": {
+			orchestrator.reset(sessionId);
+			if (db) {
+				clearRecoveryState(db, sessionId);
+			}
+
+			return JSON.stringify({
+				action: "recovery_reset",
+				sessionId,
+				ok: true,
+				displayText: createDisplayText("Recovery reset", [
+					`Session: ${sessionId}`,
+					"Recovery state cleared.",
+				]),
+			});
+		}
+
+		case "retry": {
+			if (!state || state.attempts.length === 0) {
+				return JSON.stringify({
+					action: "error",
+					message: "No recovery history available for retry",
+				});
+			}
+
+			const lastAttempt = state.attempts[state.attempts.length - 1];
+			orchestrator.reset(sessionId);
+			if (db) {
+				clearRecoveryState(db, sessionId);
+			}
+
+			const nextAction = getStrategy(lastAttempt.errorCategory)({
+				sessionId,
+				attempts: Object.freeze([]),
+				currentStrategy: null,
+				maxAttempts: state.maxAttempts,
+				isRecovering: false,
+				lastError: state.lastError,
+			});
+
+			return JSON.stringify({
+				action: "recovery_retry",
+				sessionId,
+				nextAction,
+				displayText: createDisplayText("Recovery retry", [
+					`Session: ${sessionId}`,
+					`Strategy: ${nextAction.strategy}`,
+					`Category: ${nextAction.errorCategory}`,
+					`Backoff: ${nextAction.backoffMs}ms`,
+				]),
+			});
+		}
+	}
+
+	return JSON.stringify({ action: "error", message: `Unsupported action: ${action}` });
+}
+
+export const ocRecover = tool({
+	description:
+		"Inspect and manage session recovery state. Actions: status, retry, reset, history. Returns JSON with displayText.",
+	args: {
+		action: recoverActionSchema.describe("Recovery action"),
+		sessionId: tool.schema.string().min(1).optional().describe("Session ID to inspect"),
+	},
+	async execute({ action, sessionId }, context) {
+		const db = openKernelDb();
+		try {
+			return await recoverCore(action, { sessionId: sessionId ?? context.sessionID }, db);
+		} finally {
+			db.close();
+		}
+	},
+});