@kodrunhq/opencode-autopilot 1.17.0 → 1.19.0

package/src/index.ts

@@ -1,10 +1,15 @@
 import type { Config, Plugin } from "@opencode-ai/plugin";
 import { configHook } from "./agents";
+import { getLoopController } from "./autonomy";
+import { createLoopInjector } from "./autonomy/injector";
 import { isFirstLoad, loadConfig } from "./config";
+import { createCompactionHandler, createContextInjector } from "./context";
 import { runHealthChecks } from "./health/runner";
 import { createAntiSlopHandler } from "./hooks/anti-slop";
 import { installAssets } from "./installer";
+import { openKernelDb } from "./kernel/database";
 import { getLogger, initLoggers } from "./logging/domains";
+import { McpLifecycleManager, setGlobalMcpManager } from "./mcp";
 import {
 	createMemoryCaptureHandler,
 	createMemoryChatMessageHandler,
@@ -30,6 +35,12 @@ import {
 } from "./orchestrator/fallback";
 import { fallbackDefaults } from "./orchestrator/fallback/fallback-config";
 import { resolveChain } from "./orchestrator/fallback/resolve-chain";
+import {
+	createRecoveryEventHandler,
+	createRecoveryOrchestratorWithDb,
+	getDefaultRecoveryOrchestrator,
+} from "./recovery/index";
+import { ocBackground, setBackgroundSdkOperations } from "./tools/background";
 import { ocConfidence } from "./tools/confidence";
 import {
 	ocConfigure,
@@ -40,10 +51,12 @@ import {
 import { ocCreateAgent } from "./tools/create-agent";
 import { ocCreateCommand } from "./tools/create-command";
 import { ocCreateSkill } from "./tools/create-skill";
+import { ocDelegate, setDelegateSdkOperations } from "./tools/delegate";
 import { ocDoctor, setOpenCodeConfig as setDoctorOpenCodeConfig } from "./tools/doctor";
 import { ocForensics } from "./tools/forensics";
 import { ocHashlineEdit } from "./tools/hashline-edit";
 import { ocLogs } from "./tools/logs";
+import { ocLoop } from "./tools/loop";
 import { ocMemoryPreferences } from "./tools/memory-preferences";
 import { ocMemoryStatus } from "./tools/memory-status";
 import { ocMockFallback } from "./tools/mock-fallback";
@@ -52,12 +65,17 @@ import { ocPhase } from "./tools/phase";
 import { ocPipelineReport } from "./tools/pipeline-report";
 import { ocPlan } from "./tools/plan";
 import { ocQuick } from "./tools/quick";
+import { ocRecover } from "./tools/recover";
 import { ocReview } from "./tools/review";
 import { ocSessionStats } from "./tools/session-stats";
 import { ocState } from "./tools/state";
 import { ocStocktake } from "./tools/stocktake";
 import { ocSummary } from "./tools/summary";
 import { ocUpdateDocs } from "./tools/update-docs";
+import { ContextWarningMonitor } from "./ux/context-warnings";
+import { getRemediationHint } from "./ux/error-hints";
+import { NotificationManager } from "./ux/notifications";
+import { ProgressTracker } from "./ux/progress";
 
 let openCodeConfig: Config | null = null;
 
@@ -127,6 +145,20 @@ const plugin: Plugin = async (input) => {
 		});
 	});
 
+	// --- UX notification manager (rate-limited, best-effort) ---
+	const notificationManager = new NotificationManager({
+		sink: {
+			showToast: async (title, message, variant, duration) => {
+				await sdkOps.showToast(title, message, variant as "info" | "warning" | "error");
+				void duration;
+			},
+		},
+	});
+
+	// --- UX surfaces: context warnings, progress tracking, error hints ---
+	const contextWarningMonitor = new ContextWarningMonitor({ notificationManager });
+	const _progressTracker = new ProgressTracker({ notificationManager });
+
 	// --- Fallback subsystem initialization ---
 	const sdkOps: SdkOperations = {
 		abortSession: async (sessionID) => {
@@ -160,6 +192,24 @@ const plugin: Plugin = async (input) => {
 		},
 	};
 
+	// --- Background task SDK wiring (enables real dispatch via promptAsync) ---
+	const backgroundSdkOps = {
+		promptAsync: async (
+			sessionId: string,
+			model: string | undefined,
+			parts: ReadonlyArray<{ type: "text"; text: string }>,
+		) => {
+			const modelSpec = model ? { providerID: "", modelID: model } : undefined;
+			await sdkOps.promptAsync(
+				sessionId,
+				modelSpec as { readonly providerID: string; readonly modelID: string },
+				parts as readonly import("./orchestrator/fallback").MessagePart[],
+			);
+		},
+	};
+	setBackgroundSdkOperations(backgroundSdkOps);
+	setDelegateSdkOperations(backgroundSdkOps);
+
 	const manager = new FallbackManager({
 		config: fallbackConfig,
 		resolveFallbackChain: (_sessionID, agentName) => {
@@ -202,6 +252,23 @@ const plugin: Plugin = async (input) => {
 	});
 	const chatMessageHandler = createChatMessageHandler(manager);
 	const toolExecuteAfterHandler = createToolExecuteAfterHandler(manager);
+	const recoveryEventHandler = (() => {
+		try {
+			const kernelDb = openKernelDb();
+			const orchestrator = createRecoveryOrchestratorWithDb(kernelDb);
+			return createRecoveryEventHandler({
+				orchestrator,
+				db: kernelDb,
+				sdk: {
+					abortSession: sdkOps.abortSession,
+					showToast: (title, message, variant) =>
+						sdkOps.showToast(title, message, variant as "info" | "warning" | "error"),
+				},
+			});
+		} catch {
+			return createRecoveryEventHandler(getDefaultRecoveryOrchestrator());
+		}
+	})();
 
 	// --- Anti-slop hook initialization ---
 	const antiSlopHandler = createAntiSlopHandler({ showToast: sdkOps.showToast });
@@ -228,6 +295,16 @@ const plugin: Plugin = async (input) => {
 				getDb: () => getMemoryDb(),
 			})
 		: null;
+	const contextInjector = createContextInjector({
+		projectRoot: process.cwd(),
+		totalBudget: 4000,
+	});
+	const compactionHandler = createCompactionHandler(contextInjector);
+	const loopInjector = createLoopInjector(getLoopController());
+
+	// --- MCP lifecycle manager (lazy — servers start when skills with mcp: config activate) ---
+	const mcpManager = new McpLifecycleManager();
+	setGlobalMcpManager(mcpManager);
 
 	// --- Observability handlers ---
 	const toolStartTimes = new Map<string, number>();
@@ -312,7 +389,9 @@ const plugin: Plugin = async (input) => {
 
 	return {
 		tool: {
+			oc_background: ocBackground,
 			oc_configure: ocConfigure,
+			oc_delegate: ocDelegate,
 			oc_create_agent: ocCreateAgent,
 			oc_create_skill: ocCreateSkill,
 			oc_create_command: ocCreateCommand,
@@ -323,10 +402,12 @@ const plugin: Plugin = async (input) => {
 			oc_orchestrate: ocOrchestrate,
 			oc_doctor: ocDoctor,
 			oc_quick: ocQuick,
+			oc_recover: ocRecover,
 			oc_forensics: ocForensics,
 			oc_hashline_edit: ocHashlineEdit,
 			oc_review: ocReview,
 			oc_logs: ocLogs,
+			oc_loop: ocLoop,
 			oc_session_stats: ocSessionStats,
 			oc_pipeline_report: ocPipelineReport,
 			oc_summary: ocSummary,
@@ -337,10 +418,8 @@ const plugin: Plugin = async (input) => {
 			oc_memory_preferences: ocMemoryPreferences,
 		},
 		event: async ({ event }) => {
-			// 1. Observability: collect (pure observer, no side effects on session)
 			await observabilityEventHandler({ event });
 
-			// 2. Memory capture (pure observer, best-effort)
 			if (memoryCaptureHandler) {
 				try {
 					await memoryCaptureHandler({ event });
@@ -349,19 +428,45 @@ const plugin: Plugin = async (input) => {
 				}
 			}
 
-			// 3. First-load toast
 			if (event.type === "session.created" && isFirstLoad(config)) {
-				await sdkOps.showToast(
+				await notificationManager.info(
 					"Welcome to OpenCode Autopilot!",
 					"Plugin loaded. Run oc_doctor to verify your setup.",
-					"info",
 				);
 			}
 
-			// 4. Fallback event handling
+			if (event.type === "session.error") {
+				const props = event.properties;
+				const errorMsg =
+					props && typeof props === "object" && "error" in props
+						? String((props as Record<string, unknown>).error)
+						: "Unknown error";
+				const hint = getRemediationHint(errorMsg);
+				const displayMsg = hint ? `${errorMsg}\n${hint}` : errorMsg;
+				await notificationManager.error("Session Error", displayMsg);
+			}
+
+			if (event.type === "message.updated") {
+				const props = (event.properties ?? {}) as Record<string, unknown>;
+				const info = props.info as Record<string, unknown> | undefined;
+				if (info) {
+					const tokens = info.tokens as { input?: number } | undefined;
+					if (tokens && typeof tokens.input === "number") {
+						contextWarningMonitor.checkUtilization(tokens.input, 200_000);
+					}
+				}
+			}
+
 			if (fallbackConfig.enabled) {
 				await fallbackEventHandler({ event });
 			}
+
+			await recoveryEventHandler({ event });
+			await compactionHandler({ event });
+
+			if (event.type === "session.deleted") {
+				mcpManager.stopAll().catch(() => {});
+			}
 		},
 		config: async (cfg: Config) => {
 			openCodeConfig = cfg;
@@ -422,6 +527,8 @@ const plugin: Plugin = async (input) => {
 			if (memoryInjector) {
 				await memoryInjector(input, output);
 			}
+			await contextInjector(input, output);
+			await loopInjector(input, output);
 		},
 	};
 };

package/src/installer.ts

@@ -9,6 +9,19 @@ import { getAssetsDir, getGlobalConfigDir } from "./utils/paths";
  */
 const DEPRECATED_ASSETS = [
 	"agents/placeholder-agent.md",
+	"agents/auth-flow-verifier.md",
+	"agents/concurrency-checker.md",
+	"agents/dead-code-scanner.md",
+	"agents/go-idioms-auditor.md",
+	"agents/python-django-auditor.md",
+	"agents/react-patterns-auditor.md",
+	"agents/rust-safety-auditor.md",
+	"agents/scope-intent-verifier.md",
+	"agents/silent-failure-hunter.md",
+	"agents/spec-checker.md",
+	"agents/state-mgmt-auditor.md",
+	"agents/type-soundness.md",
+	"agents/wiring-inspector.md",
 	"commands/configure.md",
 	"commands/oc-configure.md",
 	"commands/brainstorm.md",

package/src/kernel/index.ts

@@ -0,0 +1,6 @@
+export { getKernelDbPath, KERNEL_DB_FILE, kernelDbExists, openKernelDb } from "./database";
+export { runKernelMigrations } from "./migrations";
+export { type RetryOptions, withRetry } from "./retry";
+export * from "./schema";
+export * from "./transaction";
+export * from "./types";

package/src/kernel/migrations.ts

@@ -9,6 +9,13 @@ function columnExists(database: Database, tableName: string, columnName: string)
 	return columns.some((column) => column.name === columnName);
 }
 
+function tableExists(database: Database, tableName: string): boolean {
+	const row = database
+		.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
+		.get(tableName) as { name?: string } | null;
+	return row?.name === tableName;
+}
+
 function backfillProjectAwareColumns(database: Database): void {
 	if (!columnExists(database, "pipeline_runs", "project_id")) {
 		database.run("ALTER TABLE pipeline_runs ADD COLUMN project_id TEXT");
@@ -44,6 +51,48 @@ function backfillProjectAwareColumns(database: Database): void {
 	}
 }
 
+function backfillBackgroundTaskColumns(database: Database): void {
+	if (!tableExists(database, "background_tasks")) {
+		return;
+	}
+
+	const columnDefinitions = Object.freeze([
+		{ name: "category", ddl: "ALTER TABLE background_tasks ADD COLUMN category TEXT" },
+		{ name: "result", ddl: "ALTER TABLE background_tasks ADD COLUMN result TEXT" },
+		{ name: "error", ddl: "ALTER TABLE background_tasks ADD COLUMN error TEXT" },
+		{ name: "agent", ddl: "ALTER TABLE background_tasks ADD COLUMN agent TEXT" },
+		{ name: "model", ddl: "ALTER TABLE background_tasks ADD COLUMN model TEXT" },
+		{
+			name: "priority",
+			ddl: "ALTER TABLE background_tasks ADD COLUMN priority INTEGER NOT NULL DEFAULT 50",
+		},
+		{ name: "created_at", ddl: "ALTER TABLE background_tasks ADD COLUMN created_at TEXT" },
+		{ name: "updated_at", ddl: "ALTER TABLE background_tasks ADD COLUMN updated_at TEXT" },
+		{ name: "started_at", ddl: "ALTER TABLE background_tasks ADD COLUMN started_at TEXT" },
+		{ name: "completed_at", ddl: "ALTER TABLE background_tasks ADD COLUMN completed_at TEXT" },
+	]);
+
+	for (const column of columnDefinitions) {
+		if (!columnExists(database, "background_tasks", column.name)) {
+			database.run(column.ddl);
+		}
+	}
+
+	const now = new Date().toISOString();
+	if (columnExists(database, "background_tasks", "created_at")) {
+		database.run(
+			"UPDATE background_tasks SET created_at = COALESCE(created_at, ?) WHERE created_at IS NULL",
+			[now],
+		);
+	}
+	if (columnExists(database, "background_tasks", "updated_at")) {
+		database.run(
+			"UPDATE background_tasks SET updated_at = COALESCE(updated_at, created_at, ?) WHERE updated_at IS NULL",
+			[now],
+		);
+	}
+}
+
 export function runKernelMigrations(database: Database): void {
 	const row = database.query("PRAGMA user_version").get() as { user_version?: number } | null;
 	const currentVersion = row?.user_version ?? 0;
@@ -55,6 +104,7 @@ export function runKernelMigrations(database: Database): void {
 	}
 
 	backfillProjectAwareColumns(database);
+	backfillBackgroundTaskColumns(database);
 
 	if (currentVersion < KERNEL_SCHEMA_VERSION) {
 		database.run(`PRAGMA user_version = ${KERNEL_SCHEMA_VERSION}`);

package/src/kernel/retry.ts

@@ -0,0 +1,49 @@
+export interface RetryOptions {
+	readonly maxRetries?: number;
+	readonly backoffMs?: number;
+	readonly onRetry?: (attempt: number, error: Error) => void;
+}
+
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_BACKOFF_MS = 100;
+
+function isBusyError(error: Error): boolean {
+	return (
+		error.message.includes("database is locked") ||
+		error.message.includes("SQLITE_BUSY") ||
+		error.message.includes("database table is locked")
+	);
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+
+export async function withRetry<T>(
+	fn: () => T | Promise<T>,
+	options: RetryOptions = {},
+): Promise<T> {
+	const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+	const backoffMs = options.backoffMs ?? DEFAULT_BACKOFF_MS;
+
+	let attempt = 0;
+	while (true) {
+		try {
+			return await fn();
+		} catch (error: unknown) {
+			if (!(error instanceof Error) || !isBusyError(error)) {
+				throw error;
+			}
+
+			if (attempt >= maxRetries) {
+				throw error;
+			}
+
+			attempt += 1;
+			options.onRetry?.(attempt, error);
+			await sleep(backoffMs * 2 ** (attempt - 1));
+		}
+	}
+}

package/src/kernel/schema.ts

@@ -1,4 +1,6 @@
-export const KERNEL_SCHEMA_VERSION = 1;
+import { BACKGROUND_TASKS_SCHEMA_STATEMENTS } from "../background/schema";
+
+export const KERNEL_SCHEMA_VERSION = 3;
 
 export const KERNEL_SCHEMA_STATEMENTS: readonly string[] = Object.freeze([
 	`CREATE TABLE IF NOT EXISTS pipeline_runs (
@@ -119,4 +121,10 @@ export const KERNEL_SCHEMA_STATEMENTS: readonly string[] = Object.freeze([
 	`CREATE INDEX IF NOT EXISTS idx_forensic_events_run ON forensic_events(run_id, timestamp, event_id)`,
 	`CREATE INDEX IF NOT EXISTS idx_forensic_events_dispatch ON forensic_events(dispatch_id, timestamp, event_id)`,
 	`CREATE INDEX IF NOT EXISTS idx_forensic_events_type ON forensic_events(type, timestamp, event_id)`,
+	`CREATE TABLE IF NOT EXISTS recovery_state (
+		session_id TEXT PRIMARY KEY,
+		state_json TEXT NOT NULL,
+		updated_at TEXT NOT NULL
+	)`,
+	...BACKGROUND_TASKS_SCHEMA_STATEMENTS,
 ]);

package/src/kernel/transaction.ts

@@ -6,6 +6,29 @@ export interface TransactionOptions {
 	useImmediate?: boolean;
 }
 
+const transactionDepthByDatabase = new WeakMap<Database, number>();
+
+function getTransactionDepth(db: Database): number {
+	return transactionDepthByDatabase.get(db) ?? 0;
+}
+
+function enterTransaction(db: Database): void {
+	const currentDepth = getTransactionDepth(db);
+	if (currentDepth > 0) {
+		throw new Error("Nested transactions are not supported for this database instance");
+	}
+	transactionDepthByDatabase.set(db, currentDepth + 1);
+}
+
+function exitTransaction(db: Database): void {
+	const currentDepth = getTransactionDepth(db);
+	if (currentDepth <= 1) {
+		transactionDepthByDatabase.delete(db);
+		return;
+	}
+	transactionDepthByDatabase.set(db, currentDepth - 1);
+}
+
 export function withTransaction<T>(db: Database, fn: () => T, options: TransactionOptions = {}): T {
 	const maxRetries = options.maxRetries ?? 5;
 	const backoffMs = options.backoffMs ?? 100;
@@ -14,20 +37,25 @@ export function withTransaction<T>(db: Database, fn: () => T, options: Transacti
 	let attempts = 0;
 	while (true) {
 		try {
-			if (useImmediate) {
-				db.run("BEGIN IMMEDIATE");
-				try {
-					const result = fn();
-					db.run("COMMIT");
-					return result;
-				} catch (innerError) {
-					db.run("ROLLBACK");
-					throw innerError;
+			enterTransaction(db);
+			try {
+				if (useImmediate) {
+					db.run("BEGIN IMMEDIATE");
+					try {
+						const result = fn();
+						db.run("COMMIT");
+						return result;
+					} catch (innerError) {
+						db.run("ROLLBACK");
+						throw innerError;
+					}
 				}
-			}
 
-			const transaction = db.transaction(fn);
-			return transaction();
+				const transaction = db.transaction(fn);
+				return transaction();
+			} finally {
+				exitTransaction(db);
+			}
 		} catch (error: unknown) {
 			const e = error as Error;
 			const isBusyError =

package/src/logging/forensic-writer.ts

@@ -5,6 +5,10 @@ import {
 import type { ForensicEventDomain, ForensicEventType } from "../observability/forensic-types";
 import type { LogEntry, LogSink } from "./types";
 
+function normalizeTaskId(taskId: unknown): number | null {
+	return typeof taskId === "number" && Number.isInteger(taskId) && taskId > 0 ? taskId : null;
+}
+
 export function createForensicSinkForArtifactDir(artifactDir: string): LogSink {
 	return {
 		write(entry: LogEntry): void {
@@ -63,7 +67,7 @@ export function createForensicSinkForArtifactDir(artifactDir: string): LogSink {
 				parentSessionId: (parentSessionId as string) ?? null,
 				phase: (phase as string) ?? null,
 				dispatchId: (dispatchId as string) ?? null,
-				taskId: (taskId as number) ?? null,
+				taskId: normalizeTaskId(taskId),
 				agent: (agent as string) ?? null,
 				type: forensicType,
 				code: (code as string) ?? null,
@@ -136,7 +140,7 @@ export function createForensicSink(projectRoot: string): LogSink {
 				parentSessionId: (parentSessionId as string) ?? null,
 				phase: (phase as string) ?? null,
 				dispatchId: (dispatchId as string) ?? null,
-				taskId: (taskId as number) ?? null,
+				taskId: normalizeTaskId(taskId),
 				agent: (agent as string) ?? null,
 				type: forensicType,
 				code: (code as string) ?? null,

package/src/logging/index.ts

@@ -1,4 +1,6 @@
 export * from "./domains";
 export * from "./forensic-writer";
 export * from "./logger";
+export * from "./performance";
+export * from "./rotation";
 export * from "./types";

package/src/mcp/index.ts

@@ -0,0 +1,34 @@
+export { McpLifecycleManager } from "./manager";
+export type { McpToolAction, ScopeViolation } from "./scope-filter";
+export { filterByScope, isActionAllowed } from "./scope-filter";
+export type {
+	ManagedMcpServer,
+	McpHealthResult,
+	McpScope,
+	McpServerState,
+	McpTransport,
+	SkillMcpConfig,
+} from "./types";
+export {
+	mcpScopeSchema,
+	mcpTransportSchema,
+	skillMcpConfigSchema,
+} from "./types";
+
+let globalMcpManager: InstanceType<typeof import("./manager").McpLifecycleManager> | null = null;
+
+export function setGlobalMcpManager(
+	manager: InstanceType<typeof import("./manager").McpLifecycleManager>,
+): void {
+	globalMcpManager = manager;
+}
+
+export function getGlobalMcpManager(): InstanceType<
+	typeof import("./manager").McpLifecycleManager
+> | null {
+	return globalMcpManager;
+}
+
+export function resetGlobalMcpManager(): void {
+	globalMcpManager = null;
+}