@kodrunhq/opencode-autopilot 1.17.0 → 1.19.0

package/src/background/repository.ts

@@ -0,0 +1,174 @@
+import type { Database } from "bun:sqlite";
+import { withTransaction } from "../kernel/transaction";
+import type { TaskStatus } from "../types/background";
+import {
+	type BackgroundTaskRecord,
+	type BackgroundTaskResultRecord,
+	type CreateBackgroundTaskInput,
+	createTaskId,
+	createTimestamp,
+	getTaskByIdRow,
+	listBackgroundTasks,
+} from "./database";
+import { assertTransition } from "./state-machine";
+
+export interface TaskUpdatePayload {
+	readonly result?: string | null;
+	readonly error?: string | null;
+	readonly now?: string;
+}
+
+export function createTask(db: Database, task: CreateBackgroundTaskInput): BackgroundTaskRecord {
+	return withTransaction(db, () => {
+		const timestamp = task.createdAt ?? createTimestamp();
+		const nextTask = Object.freeze({
+			id: task.id ?? createTaskId(),
+			sessionId: task.sessionId,
+			description: task.description,
+			category: task.category ?? null,
+			status: task.status ?? "pending",
+			result: task.result ?? null,
+			error: task.error ?? null,
+			agent: task.agent ?? null,
+			model: task.model ?? null,
+			priority: task.priority ?? 50,
+			createdAt: timestamp,
+			updatedAt: task.updatedAt ?? timestamp,
+			startedAt: task.startedAt ?? null,
+			completedAt: task.completedAt ?? null,
+		});
+
+		db.run(
+			`INSERT INTO background_tasks (
+				id, session_id, description, category, status, result, error, agent, model, priority,
+				created_at, updated_at, started_at, completed_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			[
+				nextTask.id,
+				nextTask.sessionId,
+				nextTask.description,
+				nextTask.category,
+				nextTask.status,
+				nextTask.result,
+				nextTask.error,
+				nextTask.agent,
+				nextTask.model,
+				nextTask.priority,
+				nextTask.createdAt,
+				nextTask.updatedAt,
+				nextTask.startedAt,
+				nextTask.completedAt,
+			],
+		);
+
+		const createdTask = getTaskByIdRow(db, nextTask.id);
+		if (!createdTask) {
+			throw new Error(`Failed to create background task '${nextTask.id}'`);
+		}
+
+		return createdTask;
+	});
+}
+
+export function updateStatus(
+	db: Database,
+	taskId: string,
+	newStatus: TaskStatus,
+	payload: TaskUpdatePayload = {},
+): BackgroundTaskRecord {
+	return withTransaction(db, () => {
+		const currentTask = getTaskByIdRow(db, taskId);
+		if (!currentTask) {
+			throw new Error(`Background task '${taskId}' not found`);
+		}
+
+		assertTransition(currentTask.status, newStatus);
+
+		const timestamp = payload.now ?? createTimestamp();
+		const startedAt =
+			newStatus === "running" ? (currentTask.startedAt ?? timestamp) : currentTask.startedAt;
+		const completedAt =
+			newStatus === "completed" || newStatus === "failed" || newStatus === "cancelled"
+				? timestamp
+				: currentTask.completedAt;
+		const result =
+			newStatus === "completed" ? (payload.result ?? currentTask.result) : currentTask.result;
+		const error = newStatus === "failed" ? (payload.error ?? currentTask.error) : null;
+
+		db.run(
+			`UPDATE background_tasks
+			 SET status = ?, result = ?, error = ?, updated_at = ?, started_at = ?, completed_at = ?
+			 WHERE id = ?`,
+			[newStatus, result, error, timestamp, startedAt, completedAt, taskId],
+		);
+
+		const updatedTask = getTaskByIdRow(db, taskId);
+		if (!updatedTask) {
+			throw new Error(`Failed to update background task '${taskId}'`);
+		}
+
+		return updatedTask;
+	});
+}
+
+export function getActiveTasks(db: Database, sessionId?: string): readonly BackgroundTaskRecord[] {
+	return listBackgroundTasks(db, {
+		sessionId,
+		statuses: ["pending", "running"],
+		prioritizePending: true,
+	});
+}
+
+export function getTaskById(db: Database, taskId: string): BackgroundTaskRecord | null {
+	return getTaskByIdRow(db, taskId);
+}
+
+export function getTaskResult(db: Database, taskId: string): BackgroundTaskResultRecord | null {
+	const task = getTaskByIdRow(db, taskId);
+	if (!task) {
+		return null;
+	}
+
+	return Object.freeze({
+		status: task.status,
+		result: task.result,
+		error: task.error,
+		completedAt: task.completedAt,
+	});
+}
+
+export function cancelTask(db: Database, taskId: string): BackgroundTaskRecord | null {
+	const task = getTaskByIdRow(db, taskId);
+	if (!task) {
+		return null;
+	}
+
+	if (task.status !== "pending" && task.status !== "running") {
+		return task;
+	}
+
+	return updateStatus(db, taskId, "cancelled");
+}
+
+export function countByStatus(db: Database, status: TaskStatus): number {
+	const row = db
+		.query("SELECT COUNT(*) as count FROM background_tasks WHERE status = ?")
+		.get(status) as { count?: number } | null;
+	return row?.count ?? 0;
+}
+
+export function enforceMaxConcurrent(db: Database, maxConcurrent: number): void {
+	const runningCount = countByStatus(db, "running");
+	if (runningCount >= maxConcurrent) {
+		throw new Error(
+			`Background concurrency limit reached: ${runningCount} running task(s), max ${maxConcurrent}`,
+		);
+	}
+}
+
+export function listTasks(
+	db: Database,
+	filters: { readonly sessionId?: string; readonly status?: TaskStatus } = {},
+): readonly BackgroundTaskRecord[] {
+	return listBackgroundTasks(db, filters);
+}

package/src/background/schema.ts

@@ -0,0 +1,24 @@
+export const BACKGROUND_TASKS_TABLE_STATEMENT = `CREATE TABLE IF NOT EXISTS background_tasks (
+	id TEXT PRIMARY KEY,
+	session_id TEXT NOT NULL,
+	description TEXT NOT NULL,
+	category TEXT,
+	status TEXT NOT NULL DEFAULT 'pending',
+	result TEXT,
+	error TEXT,
+	agent TEXT,
+	model TEXT,
+	priority INTEGER NOT NULL DEFAULT 50,
+	created_at TEXT NOT NULL,
+	updated_at TEXT NOT NULL,
+	started_at TEXT,
+	completed_at TEXT
+)`;
+
+export const BACKGROUND_TASKS_INDEX_STATEMENT =
+	"CREATE INDEX IF NOT EXISTS idx_background_tasks_status_created_at ON background_tasks(status, created_at)";
+
+export const BACKGROUND_TASKS_SCHEMA_STATEMENTS: readonly string[] = Object.freeze([
+	BACKGROUND_TASKS_TABLE_STATEMENT,
+	BACKGROUND_TASKS_INDEX_STATEMENT,
+]);

package/src/background/sdk-runner.ts

@@ -0,0 +1,40 @@
+import { getLogger } from "../logging/domains";
+import type { BackgroundTaskRecord } from "./database";
+
+export interface BackgroundSdkOperations {
+	readonly promptAsync: (
+		sessionId: string,
+		model: string | undefined,
+		parts: ReadonlyArray<{ type: "text"; text: string }>,
+	) => Promise<void>;
+}
+
+const logger = getLogger("background", "sdk-runner");
+
+export function createSdkRunner(
+	sdk: BackgroundSdkOperations,
+): (task: BackgroundTaskRecord, signal: AbortSignal) => Promise<string> {
+	return async (task, signal) => {
+		if (signal.aborted) {
+			throw signal.reason ?? new Error("Aborted");
+		}
+
+		const model = task.model ?? undefined;
+		const parts: ReadonlyArray<{ type: "text"; text: string }> = [
+			{ type: "text", text: task.description },
+		];
+
+		logger.info("Dispatching background task via SDK", {
+			backgroundTaskId: task.id,
+			sessionId: task.sessionId,
+			agent: task.agent,
+			model: task.model,
+		});
+
+		await sdk.promptAsync(task.sessionId, model, parts);
+
+		const agentLabel = task.agent ? ` via ${task.agent}` : "";
+		const modelLabel = task.model ? ` (${task.model})` : "";
+		return `Dispatched${agentLabel}${modelLabel}: ${task.description}`;
+	};
+}

package/src/background/slot-manager.ts

@@ -0,0 +1,41 @@
+export class SlotManager {
+	private readonly occupiedSlots = new Set<string>();
+
+	constructor(private readonly maxSlots: number) {
+		if (!Number.isInteger(maxSlots) || maxSlots < 1) {
+			throw new Error("SlotManager requires at least one slot");
+		}
+	}
+
+	acquire(): string | null {
+		if (this.isFull()) {
+			return null;
+		}
+
+		for (let index = 1; index <= this.maxSlots; index += 1) {
+			const slotId = `slot-${index}`;
+			if (!this.occupiedSlots.has(slotId)) {
+				this.occupiedSlots.add(slotId);
+				return slotId;
+			}
+		}
+
+		return null;
+	}
+
+	release(slotId: string): void {
+		this.occupiedSlots.delete(slotId);
+	}
+
+	getActiveCount(): number {
+		return this.occupiedSlots.size;
+	}
+
+	isFull(): boolean {
+		return this.occupiedSlots.size >= this.maxSlots;
+	}
+
+	getCapacity(): number {
+		return this.maxSlots;
+	}
+}

package/src/background/state-machine.ts

@@ -0,0 +1,19 @@
+import type { TaskStatus } from "../types/background";
+
+const VALID_TRANSITIONS: Readonly<Record<TaskStatus, readonly TaskStatus[]>> = Object.freeze({
+	pending: Object.freeze<TaskStatus[]>(["running", "cancelled"]),
+	running: Object.freeze<TaskStatus[]>(["completed", "failed", "cancelled"]),
+	completed: Object.freeze<TaskStatus[]>([]),
+	failed: Object.freeze<TaskStatus[]>([]),
+	cancelled: Object.freeze<TaskStatus[]>([]),
+});
+
+export function validateTransition(from: TaskStatus, to: TaskStatus): boolean {
+	return VALID_TRANSITIONS[from].includes(to);
+}
+
+export function assertTransition(from: TaskStatus, to: TaskStatus): void {
+	if (!validateTransition(from, to)) {
+		throw new Error(`Invalid background task transition from '${from}' to '${to}'`);
+	}
+}

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/context/budget.ts

@@ -0,0 +1,45 @@
+import type { ContextSource } from "./types";
+
+const CHARS_PER_TOKEN = 4;
+const DEFAULT_TOTAL_BUDGET = 4000;
+const TRUNCATION_SUFFIX = "... [truncated]";
+
+export function truncateToTokens(content: string, maxTokens: number): string {
+	const maxChars = Math.max(0, Math.floor(maxTokens * CHARS_PER_TOKEN));
+	if (content.length <= maxChars) {
+		return content;
+	}
+
+	if (maxChars === 0) {
+		return "";
+	}
+
+	if (maxChars <= TRUNCATION_SUFFIX.length) {
+		return TRUNCATION_SUFFIX.slice(0, maxChars);
+	}
+
+	const truncatedContent = content.slice(0, maxChars - TRUNCATION_SUFFIX.length).trimEnd();
+	return `${truncatedContent}${TRUNCATION_SUFFIX}`;
+}
+
+export function allocateBudget(
+	sources: readonly ContextSource[],
+	totalBudget: number = DEFAULT_TOTAL_BUDGET,
+): { readonly allocations: ReadonlyMap<string, number>; readonly totalUsed: number } {
+	const orderedSources = [...sources].sort(
+		(left, right) => right.priority - left.priority || left.filePath.localeCompare(right.filePath),
+	);
+	const allocations = new Map<string, number>();
+	let remainingBudget = Math.max(0, totalBudget);
+
+	for (const source of orderedSources) {
+		const allocation = Math.min(source.tokenEstimate, remainingBudget);
+		allocations.set(source.filePath, allocation);
+		remainingBudget -= allocation;
+	}
+
+	return {
+		allocations,
+		totalUsed: Math.max(0, totalBudget) - remainingBudget,
+	};
+}

package/src/context/compaction-handler.ts

@@ -0,0 +1,58 @@
+import { getLogger } from "../logging/domains";
+import type { createContextInjector } from "./injector";
+
+const logger = getLogger("context", "compaction-handler");
+
+interface EventProperties {
+	readonly sessionID?: string;
+	readonly info?: {
+		readonly sessionID?: string;
+		readonly id?: string;
+	};
+}
+
+function extractSessionID(properties: unknown): string | undefined {
+	if (!properties || typeof properties !== "object") {
+		return undefined;
+	}
+
+	const eventProperties = properties as EventProperties;
+	if (typeof eventProperties.sessionID === "string") {
+		return eventProperties.sessionID;
+	}
+
+	if (typeof eventProperties.info?.sessionID === "string") {
+		return eventProperties.info.sessionID;
+	}
+
+	if (typeof eventProperties.info?.id === "string") {
+		return eventProperties.info.id;
+	}
+
+	return undefined;
+}
+
+export function createCompactionHandler(injector: ReturnType<typeof createContextInjector>) {
+	return async (input: {
+		readonly event: {
+			readonly type: string;
+			readonly properties?: unknown;
+		};
+	}): Promise<void> => {
+		try {
+			if (input.event.type !== "session.compacted") {
+				return;
+			}
+
+			const sessionID = extractSessionID(input.event.properties);
+			if (!sessionID) {
+				return;
+			}
+
+			injector.clearCache(sessionID);
+			await injector({ sessionID }, { system: [] });
+		} catch (error) {
+			logger.warn("context compaction handling failed", { error: String(error) });
+		}
+	};
+}