@kodrunhq/opencode-autopilot 1.18.0 → 1.19.0

package/src/health/checks.ts

@@ -1,10 +1,13 @@
 import { Database } from "bun:sqlite";
 import { access, readFile, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import type { Config } from "@opencode-ai/plugin";
 import { parse } from "yaml";
 import { loadConfig } from "../config";
+import { getGlobalMcpManager } from "../mcp";
 import { AGENT_NAMES } from "../orchestrator/handlers/types";
+import { ALL_GROUP_IDS } from "../registry/model-groups";
+import { getAllCategories } from "../routing";
 import { detectProjectStackTags, filterSkillsByStack } from "../skills/adaptive-injector";
 import { loadAllSkills } from "../skills/loader";
 import {
@@ -15,6 +18,8 @@ import {
 } from "../utils/paths";
 import type { HealthResult } from "./types";
 
+const VALID_CATEGORY_NAMES = new Set(getAllCategories().map((definition) => definition.category));
+
 /**
  * Check that the plugin config file exists and passes Zod validation.
  * loadConfig returns null when the file is missing, and throws on invalid JSON/schema.
@@ -213,9 +218,13 @@ export async function configV7FieldsCheck(configPath?: string): Promise<HealthRe
 const STANDARD_AGENT_NAMES: readonly string[] = Object.freeze([
 	"researcher",
 	"metaprompter",
-	"documenter",
 	"pr-reviewer",
 	"autopilot",
+	"coder",
+	"debugger",
+	"planner",
+	"reviewer",
+	"security-auditor",
 ]);
 
 /** Pipeline agent names, derived from AGENT_NAMES in the orchestrator. */
@@ -410,6 +419,88 @@ export async function skillHealthCheck(
 	}
 }
 
+export async function mcpHealthCheck(configPath?: string): Promise<HealthResult> {
+	try {
+		const config = await loadConfig(configPath);
+		if (config === null) {
+			return Object.freeze({
+				name: "mcp-health",
+				status: "fail" as const,
+				message: "Plugin config file not found",
+			});
+		}
+
+		if (!config.mcp.enabled) {
+			return Object.freeze({
+				name: "mcp-health",
+				status: "pass" as const,
+				message: "MCP disabled in config",
+			});
+		}
+
+		const manager = getGlobalMcpManager();
+		if (manager) {
+			const healthResults = await manager.healthCheckAll();
+			if (healthResults.length === 0) {
+				return Object.freeze({
+					name: "mcp-health",
+					status: "pass" as const,
+					message: "MCP enabled, no servers running",
+				});
+			}
+
+			const unhealthy = healthResults.filter((result) => result.state !== "healthy");
+			const details = Object.freeze(
+				healthResults.map((result) => {
+					const status = result.state === "healthy" ? "ok" : result.state;
+					const errorSuffix = result.error ? ` - ${result.error}` : "";
+					return `${result.serverName} (${result.skillName}): ${status}${errorSuffix}`;
+				}),
+			);
+
+			if (unhealthy.length > 0) {
+				return Object.freeze({
+					name: "mcp-health",
+					status: "warn" as const,
+					message: `MCP enabled: ${healthResults.length} server(s), ${unhealthy.length} unhealthy`,
+					details,
+				});
+			}
+
+			return Object.freeze({
+				name: "mcp-health",
+				status: "pass" as const,
+				message: `MCP enabled: ${healthResults.length} server(s) healthy`,
+				details,
+			});
+		}
+
+		const skillsDir = join(configPath ? dirname(configPath) : getGlobalConfigDir(), "skills");
+		const skills = await loadAllSkills(skillsDir);
+		const mcpSkills = [...skills.values()].filter((skill) => skill.frontmatter.mcp !== null);
+		const details = Object.freeze(
+			mcpSkills.map((skill) => {
+				const mcp = skill.frontmatter.mcp;
+				return `${skill.frontmatter.name}: ${mcp?.serverName} (${mcp?.transport})`;
+			}),
+		);
+
+		return Object.freeze({
+			name: "mcp-health",
+			status: "pass" as const,
+			message: `MCP enabled with ${mcpSkills.length} MCP-capable skill${mcpSkills.length === 1 ? "" : "s"} (manager not initialized)`,
+			details,
+		});
+	} catch (error: unknown) {
+		const msg = error instanceof Error ? error.message : String(error);
+		return Object.freeze({
+			name: "mcp-health",
+			status: "fail" as const,
+			message: `MCP health check failed: ${msg}`,
+		});
+	}
+}
+
 /**
  * Check memory DB health: existence, readability, observation count.
  * Does NOT call getMemoryDb() to avoid creating an empty DB as a side effect.
@@ -573,3 +664,55 @@ export async function commandHealthCheck(targetDir?: string): Promise<HealthResu
 		details: Object.freeze(issues),
 	});
 }
+
+export async function routingHealthCheck(configPath?: string): Promise<HealthResult> {
+	try {
+		const invalidDefinitions = getAllCategories().flatMap((definition) => {
+			const issues: string[] = [];
+			if (!VALID_CATEGORY_NAMES.has(definition.category)) {
+				issues.push(`${definition.category}: unknown category`);
+			}
+			if (!ALL_GROUP_IDS.includes(definition.modelGroup as (typeof ALL_GROUP_IDS)[number])) {
+				issues.push(`${definition.category}: invalid model group '${definition.modelGroup}'`);
+			}
+			if (definition.maxIterations < 1) {
+				issues.push(`${definition.category}: maxIterations must be >= 1`);
+			}
+			if (definition.timeoutSeconds < 1) {
+				issues.push(`${definition.category}: timeoutSeconds must be >= 1`);
+			}
+			return issues;
+		});
+
+		const config = await loadConfig(configPath);
+		const invalidOverrides = Object.keys(config?.routing.categories ?? {}).flatMap(
+			(categoryName) =>
+				VALID_CATEGORY_NAMES.has(categoryName as import("../types/routing").Category)
+					? []
+					: [`Invalid routing override category '${categoryName}'`],
+		);
+
+		const issues = [...invalidDefinitions, ...invalidOverrides];
+		if (issues.length > 0) {
+			return Object.freeze({
+				name: "routing-health",
+				status: "fail" as const,
+				message: `${issues.length} routing issue(s) found`,
+				details: Object.freeze(issues),
+			});
+		}
+
+		return Object.freeze({
+			name: "routing-health",
+			status: "pass" as const,
+			message: `All ${getAllCategories().length} routing categories and overrides are valid`,
+		});
+	} catch (error: unknown) {
+		const msg = error instanceof Error ? error.message : String(error);
+		return Object.freeze({
+			name: "routing-health",
+			status: "fail" as const,
+			message: `Routing health check failed: ${msg}`,
+		});
+	}
+}

package/src/health/index.ts

@@ -1,3 +1,9 @@
-export { agentHealthCheck, assetHealthCheck, configHealthCheck } from "./checks";
+export {
+	agentHealthCheck,
+	assetHealthCheck,
+	configHealthCheck,
+	mcpHealthCheck,
+	routingHealthCheck,
+} from "./checks";
 export { runHealthChecks } from "./runner";
 export type { HealthReport, HealthResult } from "./types";

package/src/health/runner.ts

@@ -5,8 +5,10 @@ import {
 	commandHealthCheck,
 	configHealthCheck,
 	configV7FieldsCheck,
+	mcpHealthCheck,
 	memoryHealthCheck,
 	nativeAgentSuppressionHealthCheck,
+	routingHealthCheck,
 	skillHealthCheck,
 } from "./checks";
 import type { HealthReport, HealthResult } from "./types";
@@ -54,6 +56,8 @@ export async function runHealthChecks(options?: {
 		memoryHealthCheck(options?.targetDir),
 		commandHealthCheck(options?.targetDir),
 		configV7FieldsCheck(options?.configPath),
+		routingHealthCheck(options?.configPath),
+		mcpHealthCheck(options?.configPath),
 	]);
 
 	const allSettled = [...configOutcome, ...settled];
@@ -67,6 +71,8 @@ export async function runHealthChecks(options?: {
 		"memory-db",
 		"command-accessibility",
 		"config-v7-fields",
+		"routing-health",
+		"mcp-health",
 	];
 	const results: readonly HealthResult[] = Object.freeze(
 		allSettled.map((outcome, i) => settledToResult(outcome, fallbackNames[i])),

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,
 ]);