@mrace07/kairo 0.1.0

package/dist/infrastructure/persistence/sqlite-session-store.js

@@ -0,0 +1,447 @@
+import Database from "better-sqlite3";
+import { databasePath, ensureStateDir } from "../filesystem/platform-paths.js";
+export class SqliteSessionStore {
+    db;
+    /** Wraps an already-initialized database; callers use open() to guarantee setup. */
+    constructor(db) {
+        this.db = db;
+    }
+    /** Opens the database, creates current schema objects, and recovers interrupted tasks. */
+    static async open(path) {
+        if (!path)
+            await ensureStateDir();
+        const db = new Database(path || databasePath());
+        db.exec(`PRAGMA journal_mode=WAL;
+      CREATE TABLE IF NOT EXISTS schema_version (version INTEGER NOT NULL);
+      INSERT INTO schema_version(version) SELECT 1 WHERE NOT EXISTS (SELECT 1 FROM schema_version);
+      CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, workspace TEXT NOT NULL, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL);
+      CREATE TABLE IF NOT EXISTS messages (id INTEGER PRIMARY KEY, session_id TEXT NOT NULL, role TEXT NOT NULL, content TEXT NOT NULL, tool_call_id TEXT, tool_name TEXT, created_at INTEGER NOT NULL, FOREIGN KEY(session_id) REFERENCES sessions(id));
+      CREATE TABLE IF NOT EXISTS tool_events (id INTEGER PRIMARY KEY, session_id TEXT NOT NULL, call_id TEXT NOT NULL, name TEXT NOT NULL, args_json TEXT NOT NULL, approved INTEGER, output TEXT, created_at INTEGER NOT NULL);
+      CREATE TABLE IF NOT EXISTS tasks (id TEXT PRIMARY KEY, session_id TEXT NOT NULL, prompt TEXT NOT NULL, mode TEXT NOT NULL DEFAULT 'implementation', status TEXT NOT NULL, plan_json TEXT, changed_files_json TEXT NOT NULL DEFAULT '[]', approved_write_paths_json TEXT NOT NULL DEFAULT '[]', verification_command TEXT, verification_output TEXT, verification_ok INTEGER, verification_exit_code INTEGER, verification_discovered INTEGER, verification_selection_json TEXT, summary TEXT, error TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, FOREIGN KEY(session_id) REFERENCES sessions(id));
+      CREATE INDEX IF NOT EXISTS tasks_session_updated ON tasks(session_id, updated_at DESC);
+      CREATE TABLE IF NOT EXISTS context_checkpoints (id TEXT PRIMARY KEY, session_id TEXT NOT NULL, task_id TEXT, summary TEXT NOT NULL, through_message_id INTEGER NOT NULL, created_at INTEGER NOT NULL, FOREIGN KEY(session_id) REFERENCES sessions(id));
+      CREATE INDEX IF NOT EXISTS checkpoints_session_created ON context_checkpoints(session_id, created_at DESC);
+      CREATE TABLE IF NOT EXISTS repository_profiles (session_id TEXT PRIMARY KEY, profile_json TEXT NOT NULL, updated_at INTEGER NOT NULL, FOREIGN KEY(session_id) REFERENCES sessions(id));`);
+        db.exec(`CREATE TABLE IF NOT EXISTS repair_attempts (id TEXT PRIMARY KEY, task_id TEXT NOT NULL, command TEXT NOT NULL, evidence_json TEXT NOT NULL, selected_files_json TEXT NOT NULL, created_at INTEGER NOT NULL, FOREIGN KEY(task_id) REFERENCES tasks(id));
+      CREATE INDEX IF NOT EXISTS repair_attempts_task_created ON repair_attempts(task_id, created_at DESC);`);
+        const columns = db.prepare("SELECT name FROM pragma_table_info('tasks')").all();
+        if (!columns.some((column) => column.name === "verification_ok"))
+            db.exec("ALTER TABLE tasks ADD COLUMN verification_ok INTEGER");
+        if (!columns.some((column) => column.name === "verification_exit_code"))
+            db.exec("ALTER TABLE tasks ADD COLUMN verification_exit_code INTEGER");
+        if (!columns.some((column) => column.name === "verification_discovered"))
+            db.exec("ALTER TABLE tasks ADD COLUMN verification_discovered INTEGER");
+        if (!columns.some((column) => column.name === "verification_selection_json"))
+            db.exec("ALTER TABLE tasks ADD COLUMN verification_selection_json TEXT");
+        if (!columns.some((column) => column.name === "mode"))
+            db.exec("ALTER TABLE tasks ADD COLUMN mode TEXT NOT NULL DEFAULT 'implementation'");
+        if (!columns.some((column) => column.name === "plan_json"))
+            db.exec("ALTER TABLE tasks ADD COLUMN plan_json TEXT");
+        if (!columns.some((column) => column.name === "approved_write_paths_json"))
+            db.exec("ALTER TABLE tasks ADD COLUMN approved_write_paths_json TEXT NOT NULL DEFAULT '[]'");
+        const store = new SqliteSessionStore(db);
+        db.exec("CREATE TABLE IF NOT EXISTS task_events (id INTEGER PRIMARY KEY, task_id TEXT NOT NULL, event_json TEXT NOT NULL); CREATE INDEX IF NOT EXISTS task_events_task ON task_events(task_id, id)");
+        db.exec(`CREATE TABLE IF NOT EXISTS evaluation_runs (
+        id TEXT PRIMARY KEY,
+        suite TEXT NOT NULL,
+        provider TEXT NOT NULL DEFAULT 'gemini',
+        model TEXT NOT NULL,
+        source_revision TEXT NOT NULL,
+        trial_count INTEGER NOT NULL,
+        attempt_count INTEGER NOT NULL DEFAULT 0,
+        passed_count INTEGER NOT NULL DEFAULT 0,
+        started_at INTEGER NOT NULL,
+        completed_at INTEGER
+      );
+      CREATE INDEX IF NOT EXISTS evaluation_runs_started ON evaluation_runs(started_at DESC);
+      CREATE TABLE IF NOT EXISTS evaluation_attempts (
+        id INTEGER PRIMARY KEY,
+        run_id TEXT NOT NULL,
+        scenario_id TEXT NOT NULL,
+        trial INTEGER NOT NULL,
+        passed INTEGER NOT NULL,
+        task_status TEXT NOT NULL,
+        verified INTEGER NOT NULL,
+        expectation_passed INTEGER NOT NULL,
+        failure_category TEXT,
+        metrics_json TEXT NOT NULL,
+        duration_ms INTEGER NOT NULL,
+        created_at INTEGER NOT NULL,
+        FOREIGN KEY(run_id) REFERENCES evaluation_runs(id)
+      );
+      CREATE INDEX IF NOT EXISTS evaluation_attempts_run ON evaluation_attempts(run_id, id);`);
+        const evaluationColumns = db
+            .prepare("SELECT name FROM pragma_table_info('evaluation_runs')")
+            .all();
+        if (!evaluationColumns.some((column) => column.name === "provider"))
+            db.exec("ALTER TABLE evaluation_runs ADD COLUMN provider TEXT NOT NULL DEFAULT 'gemini'");
+        db.exec("CREATE TABLE IF NOT EXISTS evaluation_baselines (suite TEXT PRIMARY KEY, run_id TEXT NOT NULL REFERENCES evaluation_runs(id))");
+        store.recoverInterruptedTasks();
+        return store;
+    }
+    /** Closes the SQLite handle after the CLI session exits. */
+    close() {
+        this.db.close();
+    }
+    /** Atomically replaces the local self baseline after validating the selected run. */
+    setEvaluationBaseline(runId) {
+        const run = this.evaluationRun(runId);
+        if (!run)
+            throw new Error(`Evaluation run not found: ${runId}`);
+        if (run.suite !== "self" || run.completedAt === undefined || run.trialCount < 3)
+            throw new Error("Baseline must be a completed self-evaluation run with at least three trials.");
+        this.db
+            .prepare("INSERT INTO evaluation_baselines(suite, run_id) VALUES ('self', ?) ON CONFLICT(suite) DO UPDATE SET run_id=excluded.run_id")
+            .run(runId);
+        return run;
+    }
+    /** Resolves the baseline pointer without duplicating evaluation metadata. */
+    evaluationBaseline() {
+        const row = this.db
+            .prepare("SELECT run_id FROM evaluation_baselines WHERE suite='self'")
+            .get();
+        return row ? this.evaluationRun(row.run_id) : undefined;
+    }
+    /** Starts a metadata-only real-model evaluation run. */
+    createEvaluationRun(input) {
+        const run = {
+            ...input,
+            id: `eval-${input.startedAt.toString(36)}-${crypto.randomUUID().slice(0, 8)}`,
+            attemptCount: 0,
+            passedCount: 0,
+        };
+        this.db
+            .prepare("INSERT INTO evaluation_runs(id, suite, provider, model, source_revision, trial_count, attempt_count, passed_count, started_at, completed_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
+            .run(run.id, run.suite, run.provider, run.model, run.sourceRevision, run.trialCount, 0, 0, run.startedAt, null);
+        return run;
+    }
+    /** Saves counters and a sanitized outcome without raw prompts, source, or tool output. */
+    saveEvaluationAttempt(attempt) {
+        this.db
+            .prepare("INSERT INTO evaluation_attempts(run_id, scenario_id, trial, passed, task_status, verified, expectation_passed, failure_category, metrics_json, duration_ms, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
+            .run(attempt.runId, attempt.scenarioId, attempt.trial, Number(attempt.passed), attempt.taskStatus, Number(attempt.verified), Number(attempt.expectationPassed), attempt.failureCategory ?? null, JSON.stringify(attempt.metrics), attempt.durationMs, attempt.createdAt);
+    }
+    /** Computes aggregate counts from attempts so historical reports cannot drift. */
+    completeEvaluationRun(id) {
+        const aggregate = this.db
+            .prepare("SELECT count(*) AS attempts, coalesce(sum(passed), 0) AS passed FROM evaluation_attempts WHERE run_id=?")
+            .get(id);
+        this.db
+            .prepare("UPDATE evaluation_runs SET attempt_count=?, passed_count=?, completed_at=? WHERE id=?")
+            .run(aggregate.attempts, aggregate.passed, Date.now(), id);
+        const run = this.evaluationRun(id);
+        if (!run)
+            throw new Error(`Evaluation run not found: ${id}`);
+        return run;
+    }
+    /** Lists recent evaluation runs, newest first. */
+    evaluationRuns(limit = 20) {
+        return this.db
+            .prepare("SELECT * FROM evaluation_runs ORDER BY started_at DESC LIMIT ?")
+            .all(limit).map((row) => this.toEvaluationRun(row));
+    }
+    /** Reads one saved evaluation run. */
+    evaluationRun(id) {
+        const row = this.db.prepare("SELECT * FROM evaluation_runs WHERE id=?").get(id);
+        return row ? this.toEvaluationRun(row) : undefined;
+    }
+    /** Reads attempts in stable execution order. */
+    evaluationAttempts(runId) {
+        return this.db
+            .prepare("SELECT * FROM evaluation_attempts WHERE run_id=? ORDER BY id")
+            .all(runId).map((row) => ({
+            runId: String(row.run_id),
+            scenarioId: String(row.scenario_id),
+            trial: Number(row.trial),
+            passed: Boolean(row.passed),
+            taskStatus: row.task_status,
+            verified: Boolean(row.verified),
+            expectationPassed: Boolean(row.expectation_passed),
+            failureCategory: row.failure_category,
+            metrics: JSON.parse(String(row.metrics_json)),
+            durationMs: Number(row.duration_ms),
+            createdAt: Number(row.created_at),
+        }));
+    }
+    /** Stores bounded operation metadata separately from model context and raw tool history. */
+    recordTaskEvent(event) {
+        this.db
+            .prepare("INSERT INTO task_events(task_id, event_json) VALUES (?, ?)")
+            .run(event.taskId, JSON.stringify(event));
+    }
+    /** Uses insertion ids rather than timestamps to preserve ordering within the same millisecond. */
+    taskEvents(taskId) {
+        return this.db
+            .prepare("SELECT id, event_json FROM task_events WHERE task_id=? ORDER BY id")
+            .all(taskId).map((row) => ({ ...JSON.parse(row.event_json), id: row.id }));
+    }
+    /** Creates a durable session associated with one resolved workspace. */
+    create(workspace) {
+        const now = Date.now();
+        const id = `${now.toString(36)}-${crypto.randomUUID().slice(0, 8)}`;
+        this.db.prepare("INSERT INTO sessions VALUES (?, ?, ?, ?)").run(id, workspace, now, now);
+        return { id, workspace, createdAt: now, updatedAt: now };
+    }
+    /** Loads one session by id, if it still exists. */
+    get(id) {
+        const row = this.db
+            .prepare("SELECT id, workspace, created_at, updated_at FROM sessions WHERE id = ?")
+            .get(id);
+        return (row && {
+            id: String(row.id),
+            workspace: String(row.workspace),
+            createdAt: Number(row.created_at),
+            updatedAt: Number(row.updated_at),
+        });
+    }
+    /** Lists sessions from most recently active to oldest. */
+    list() {
+        return this.db
+            .prepare("SELECT id, workspace, created_at, updated_at FROM sessions ORDER BY updated_at DESC")
+            .all().map((r) => ({
+            id: String(r.id),
+            workspace: String(r.workspace),
+            createdAt: Number(r.created_at),
+            updatedAt: Number(r.updated_at),
+        }));
+    }
+    /** Loads all messages required to reconstruct a full conversation. */
+    messages(sessionId) {
+        return this.db
+            .prepare("SELECT role, content, tool_call_id, tool_name, created_at FROM messages WHERE session_id=? ORDER BY id")
+            .all(sessionId).map((r) => ({
+            role: r.role,
+            content: String(r.content),
+            toolCallId: r.tool_call_id ? String(r.tool_call_id) : undefined,
+            toolName: r.tool_name ? String(r.tool_name) : undefined,
+            createdAt: Number(r.created_at),
+        }));
+    }
+    /** Loads only the newest messages for bounded model context. */
+    recentMessages(sessionId, limit) {
+        return this.db
+            .prepare("SELECT role, content, tool_call_id, tool_name, created_at FROM (SELECT * FROM messages WHERE session_id=? ORDER BY id DESC LIMIT ?) ORDER BY id")
+            .all(sessionId, limit).map((r) => ({
+            role: r.role,
+            content: String(r.content),
+            toolCallId: r.tool_call_id ? String(r.tool_call_id) : undefined,
+            toolName: r.tool_name ? String(r.tool_name) : undefined,
+            createdAt: Number(r.created_at),
+        }));
+    }
+    /** Appends one durable message and refreshes the owning session timestamp. */
+    addMessage(sessionId, message) {
+        this.db
+            .prepare("INSERT INTO messages(session_id, role, content, tool_call_id, tool_name, created_at) VALUES (?, ?, ?, ?, ?, ?)")
+            .run(sessionId, message.role, message.content, message.toolCallId ?? null, message.toolName ?? null, message.createdAt);
+        this.db.prepare("UPDATE sessions SET updated_at=? WHERE id=?").run(Date.now(), sessionId);
+    }
+    /** Records the requested action, approval decision, and visible tool output. */
+    recordTool(sessionId, id, name, args, approved, output) {
+        this.db
+            .prepare("INSERT INTO tool_events(session_id, call_id, name, args_json, approved, output, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)")
+            .run(sessionId, id, name, JSON.stringify(args), approved === null ? null : Number(approved), output, Date.now());
+    }
+    /** Creates a new task in the initial planning state. */
+    startTask(sessionId, prompt, mode = "implementation") {
+        const now = Date.now();
+        const id = `task-${now.toString(36)}-${crypto.randomUUID().slice(0, 8)}`;
+        this.db
+            .prepare("INSERT INTO tasks(id, session_id, prompt, mode, status, changed_files_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)")
+            .run(id, sessionId, prompt, mode, "planning", "[]", now, now);
+        this.recordTaskEvent({ taskId: id, kind: "status", outcome: "planning", createdAt: now });
+        return this.task(id);
+    }
+    /** Loads one task by id and maps database columns to domain names. */
+    task(id) {
+        return this.toTask(this.db.prepare("SELECT * FROM tasks WHERE id=?").get(id));
+    }
+    /** Finds the newest task belonging to a session. */
+    latestTask(sessionId) {
+        return this.toTask(this.db
+            .prepare("SELECT * FROM tasks WHERE session_id=? ORDER BY updated_at DESC, rowid DESC LIMIT 1")
+            .get(sessionId));
+    }
+    /** Finds the most recently saved planning artifact in a session. */
+    latestPlan(sessionId) {
+        return this.toTask(this.db
+            .prepare("SELECT * FROM tasks WHERE session_id=? AND mode='planning' ORDER BY updated_at DESC LIMIT 1")
+            .get(sessionId));
+    }
+    /** Merges a partial task update and writes the complete task state atomically. */
+    updateTask(id, patch) {
+        const task = this.task(id);
+        if (!task)
+            throw new Error(`Task not found: ${id}`);
+        const next = { ...task, ...patch, updatedAt: Date.now() };
+        this.db
+            .prepare("UPDATE tasks SET mode=?, status=?, plan_json=?, changed_files_json=?, approved_write_paths_json=?, verification_command=?, verification_output=?, verification_ok=?, verification_exit_code=?, verification_discovered=?, verification_selection_json=?, summary=?, error=?, updated_at=? WHERE id=?")
+            .run(next.mode, next.status, next.plan ? JSON.stringify(next.plan) : null, JSON.stringify(next.changedFiles), JSON.stringify(next.approvedWritePaths), next.verificationCommand ?? null, next.verificationOutput ?? null, next.verificationPassed === undefined ? null : Number(next.verificationPassed), next.verificationExitCode ?? null, next.verificationDiscovered === undefined ? null : Number(next.verificationDiscovered), next.verificationSelection ? JSON.stringify(next.verificationSelection) : null, next.summary ?? null, next.error ?? null, next.updatedAt, id);
+        if (next.status !== task.status)
+            this.recordTaskEvent({
+                taskId: id,
+                kind: "status",
+                outcome: next.status,
+                createdAt: next.updatedAt,
+            });
+        return next;
+    }
+    /** Persists a summary that replaces older conversation detail in future context. */
+    saveCheckpoint(sessionId, taskId, summary, throughMessageId) {
+        const checkpoint = {
+            id: `checkpoint-${crypto.randomUUID()}`,
+            sessionId,
+            taskId,
+            summary,
+            throughMessageId,
+            createdAt: Date.now(),
+        };
+        this.db
+            .prepare("INSERT INTO context_checkpoints VALUES (?, ?, ?, ?, ?, ?)")
+            .run(checkpoint.id, checkpoint.sessionId, checkpoint.taskId ?? null, checkpoint.summary, checkpoint.throughMessageId, checkpoint.createdAt);
+        return checkpoint;
+    }
+    /** Retrieves the most recent compaction checkpoint for a session. */
+    latestCheckpoint(sessionId) {
+        const row = this.db
+            .prepare("SELECT * FROM context_checkpoints WHERE session_id=? ORDER BY created_at DESC LIMIT 1")
+            .get(sessionId);
+        return (row && {
+            id: String(row.id),
+            sessionId: String(row.session_id),
+            taskId: row.task_id ? String(row.task_id) : undefined,
+            summary: String(row.summary),
+            throughMessageId: Number(row.through_message_id),
+            createdAt: Number(row.created_at),
+        });
+    }
+    /** Counts messages to decide when automatic compaction is needed. */
+    messageCount(sessionId) {
+        return Number(this.db
+            .prepare("SELECT count(*) AS count FROM messages WHERE session_id=?")
+            .get(sessionId).count);
+    }
+    /** Returns the newest message id used to mark checkpoint coverage. */
+    lastMessageId(sessionId) {
+        return Number(this.db
+            .prepare("SELECT coalesce(max(id), 0) AS id FROM messages WHERE session_id=?")
+            .get(sessionId).id);
+    }
+    /** Upserts the session's bounded, derived repository snapshot. */
+    saveRepositorySnapshot(sessionId, snapshot) {
+        this.db
+            .prepare("INSERT INTO repository_profiles(session_id, profile_json, updated_at) VALUES (?, ?, ?) ON CONFLICT(session_id) DO UPDATE SET profile_json=excluded.profile_json, updated_at=excluded.updated_at")
+            .run(sessionId, JSON.stringify(snapshot), Date.now());
+    }
+    /** Reads current snapshots and normalizes legacy profiles as stale snapshots. */
+    repositorySnapshot(sessionId) {
+        const row = this.db
+            .prepare("SELECT profile_json FROM repository_profiles WHERE session_id=?")
+            .get(sessionId);
+        if (!row)
+            return undefined;
+        const value = JSON.parse(row.profile_json);
+        if (value.schemaVersion === 1 && value.fingerprint && Array.isArray(value.entries))
+            return value;
+        return {
+            ...value,
+            schemaVersion: 1,
+            fingerprint: { value: "legacy-stale", kind: "filesystem" },
+            entries: value.entries ?? [],
+            ecosystems: value.ecosystems ?? [],
+            changedPaths: value.changedPaths ?? [],
+            instructionFiles: value.instructionFiles ?? [],
+            documentationFiles: value.documentationFiles ?? [],
+            manifestFiles: value.manifestFiles ?? [],
+            ciFiles: value.ciFiles ?? [],
+            buildFiles: value.buildFiles ?? [],
+            truncated: value.truncated ?? false,
+        };
+    }
+    /** Persists one verification failure that started an agent repair cycle. */
+    recordRepairAttempt(attempt) {
+        this.recordTaskEvent({ taskId: attempt.taskId, kind: "repair", createdAt: attempt.createdAt });
+        this.db
+            .prepare("INSERT INTO repair_attempts(id, task_id, command, evidence_json, selected_files_json, created_at) VALUES (?, ?, ?, ?, ?, ?)")
+            .run(attempt.id, attempt.taskId, attempt.command, JSON.stringify(attempt.evidence), JSON.stringify(attempt.selectedFiles), attempt.createdAt);
+    }
+    /** Returns repair attempts in the order they happened for context and evaluation. */
+    repairAttempts(taskId) {
+        return this.db
+            .prepare("SELECT * FROM repair_attempts WHERE task_id=? ORDER BY created_at")
+            .all(taskId).map((row) => ({
+            id: String(row.id),
+            taskId: String(row.task_id),
+            command: String(row.command),
+            evidence: JSON.parse(String(row.evidence_json)),
+            selectedFiles: JSON.parse(String(row.selected_files_json)),
+            createdAt: Number(row.created_at),
+        }));
+    }
+    /** Marks tasks left active by a process exit so the user can explicitly resume them. */
+    recoverInterruptedTasks() {
+        const active = this.db
+            .prepare("SELECT id FROM tasks WHERE status IN ('planning', 'acting', 'verifying')")
+            .all();
+        for (const task of active)
+            this.recordTaskEvent({
+                taskId: task.id,
+                kind: "status",
+                outcome: "interrupted",
+                createdAt: Date.now(),
+            });
+        this.db
+            .prepare("UPDATE tasks SET status='interrupted', updated_at=? WHERE status IN ('planning', 'acting', 'verifying')")
+            .run(Date.now());
+    }
+    /** Converts a raw SQLite row into the application's Task object. */
+    toTask(row) {
+        if (!row)
+            return undefined;
+        return {
+            id: String(row.id),
+            sessionId: String(row.session_id),
+            prompt: String(row.prompt),
+            mode: (row.mode ? String(row.mode) : "implementation"),
+            status: row.status,
+            plan: row.plan_json ? JSON.parse(String(row.plan_json)) : undefined,
+            changedFiles: JSON.parse(String(row.changed_files_json)),
+            approvedWritePaths: row.approved_write_paths_json
+                ? JSON.parse(String(row.approved_write_paths_json))
+                : [],
+            verificationCommand: row.verification_command ? String(row.verification_command) : undefined,
+            verificationOutput: row.verification_output ? String(row.verification_output) : undefined,
+            verificationPassed: row.verification_ok === null || row.verification_ok === undefined
+                ? undefined
+                : Boolean(row.verification_ok),
+            verificationExitCode: row.verification_exit_code === null || row.verification_exit_code === undefined
+                ? undefined
+                : Number(row.verification_exit_code),
+            verificationDiscovered: row.verification_discovered === null || row.verification_discovered === undefined
+                ? undefined
+                : Boolean(row.verification_discovered),
+            verificationSelection: row.verification_selection_json
+                ? JSON.parse(String(row.verification_selection_json))
+                : undefined,
+            summary: row.summary ? String(row.summary) : undefined,
+            error: row.error ? String(row.error) : undefined,
+            createdAt: Number(row.created_at),
+            updatedAt: Number(row.updated_at),
+        };
+    }
+    /** Converts one evaluation run row while keeping persistence column names private. */
+    toEvaluationRun(row) {
+        return {
+            id: String(row.id),
+            suite: row.suite,
+            provider: (row.provider ? String(row.provider) : "gemini"),
+            model: String(row.model),
+            sourceRevision: String(row.source_revision),
+            trialCount: Number(row.trial_count),
+            attemptCount: Number(row.attempt_count),
+            passedCount: Number(row.passed_count),
+            startedAt: Number(row.started_at),
+            completedAt: row.completed_at === null ? undefined : Number(row.completed_at),
+        };
+    }
+}

package/dist/infrastructure/providers/gemini-provider.d.ts

@@ -0,0 +1,14 @@
+import type { ProviderProgress } from "../../domain/provider-error.js";
+import type { Message, ModelTurn } from "../../domain/models.js";
+import type { ModelProvider, ToolDefinition } from "../../domain/ports.js";
+export declare class GeminiProvider implements ModelProvider {
+    private readonly model;
+    private readonly tools;
+    private readonly client;
+    /** Configures the Gemini client with the selected model and Kairo tool schema. */
+    constructor(apiKey: string, model: string, tools: ToolDefinition[]);
+    /** Streams Gemini text and normalizes function calls into the provider-neutral model turn. */
+    stream(messages: Message[], onText: (chunk: string) => void, onProgress?: (event: ProviderProgress) => void, systemInstruction?: string, toolsEnabled?: boolean): Promise<ModelTurn>;
+    /** Performs one stream; received calls prevent automatic replay even before execution. */
+    private streamOnce;
+}

package/dist/infrastructure/providers/gemini-provider.js

@@ -0,0 +1,90 @@
+import { GoogleGenAI } from "@google/genai";
+import { recoverProvider } from "./provider-recovery.js";
+import { modelSystemInstruction } from "../../application/model-system-instruction.js";
+export class GeminiProvider {
+    model;
+    tools;
+    client;
+    /** Configures the Gemini client with the selected model and Kairo tool schema. */
+    constructor(apiKey, model, tools) {
+        this.model = model;
+        this.tools = tools;
+        // This SDK version uses a single fetch when retryOptions is absent.
+        // Enabling its retry wrapper discards HTTP status and structured retry hints.
+        this.client = new GoogleGenAI({ apiKey });
+    }
+    /** Streams Gemini text and normalizes function calls into the provider-neutral model turn. */
+    async stream(messages, onText, onProgress, systemInstruction = modelSystemInstruction, toolsEnabled = true) {
+        return recoverProvider((markContent) => this.streamOnce(messages, (text) => {
+            markContent();
+            onText(text);
+        }, markContent, systemInstruction, toolsEnabled), onProgress, undefined, "Gemini");
+    }
+    /** Performs one stream; received calls prevent automatic replay even before execution. */
+    async streamOnce(messages, onText, markContent, systemInstruction, toolsEnabled) {
+        const contents = messages.map((message) => {
+            if (message.role === "tool")
+                return {
+                    role: "user",
+                    parts: [
+                        { functionResponse: { name: message.toolName, response: { result: message.content } } },
+                    ],
+                };
+            if (message.role === "model" && message.toolCallId && message.toolName)
+                return {
+                    role: "model",
+                    parts: [
+                        {
+                            functionCall: {
+                                id: message.toolCallId,
+                                name: message.toolName,
+                                args: JSON.parse(message.content),
+                            },
+                        },
+                    ],
+                };
+            return {
+                role: message.role === "model" ? "model" : "user",
+                parts: [{ text: message.content }],
+            };
+        });
+        const stream = await this.client.models.generateContentStream({
+            model: this.model,
+            contents: contents,
+            config: {
+                systemInstruction,
+                ...(toolsEnabled
+                    ? {
+                        tools: [
+                            {
+                                functionDeclarations: this.tools.map(({ name, description, parameters }) => ({
+                                    name,
+                                    description,
+                                    parameters,
+                                })),
+                            },
+                        ],
+                    }
+                    : {}),
+            },
+        });
+        let text = "";
+        const calls = [];
+        for await (const chunk of stream) {
+            const chunkText = chunk.candidates?.[0]?.content?.parts?.map((part) => part.text ?? "").join("") ?? "";
+            if (chunkText) {
+                text += chunkText;
+                onText(chunkText);
+            }
+            for (const call of chunk.functionCalls ?? []) {
+                markContent();
+                calls.push({
+                    id: call.id || crypto.randomUUID(),
+                    name: String(call.name),
+                    args: (call.args || {}),
+                });
+            }
+        }
+        return { text, toolCalls: calls };
+    }
+}

package/dist/infrastructure/providers/groq-provider.d.ts

@@ -0,0 +1,16 @@
+import { type ProviderProgress } from "../../domain/provider-error.js";
+import type { Message, ModelTurn } from "../../domain/models.js";
+import type { ModelProvider, ToolDefinition } from "../../domain/ports.js";
+export declare class GroqProvider implements ModelProvider {
+    private readonly model;
+    private readonly tools;
+    private readonly client;
+    /** Configures Groq without hidden SDK retries so Kairo owns recovery reporting. */
+    constructor(apiKey: string, model: string, tools: ToolDefinition[]);
+    /** Streams Groq text and reconstructs incremental OpenAI-style tool calls. */
+    stream(messages: Message[], onText: (chunk: string) => void, onProgress?: (event: ProviderProgress) => void, systemInstruction?: string, toolsEnabled?: boolean): Promise<ModelTurn>;
+    /** Performs one request and rejects malformed tool arguments before execution. */
+    private streamOnce;
+    /** Converts Kairo's durable message representation to Groq chat messages. */
+    private message;
+}

package/dist/infrastructure/providers/groq-provider.js

@@ -0,0 +1,101 @@
+import Groq from "groq-sdk";
+import { modelSystemInstruction } from "../../application/model-system-instruction.js";
+import { ProviderError } from "../../domain/provider-error.js";
+import { recoverProvider } from "./provider-recovery.js";
+export class GroqProvider {
+    model;
+    tools;
+    client;
+    /** Configures Groq without hidden SDK retries so Kairo owns recovery reporting. */
+    constructor(apiKey, model, tools) {
+        this.model = model;
+        this.tools = tools;
+        this.client = new Groq({ apiKey, maxRetries: 0 });
+    }
+    /** Streams Groq text and reconstructs incremental OpenAI-style tool calls. */
+    async stream(messages, onText, onProgress, systemInstruction = modelSystemInstruction, toolsEnabled = true) {
+        return recoverProvider((markContent) => this.streamOnce(messages, onText, markContent, systemInstruction, toolsEnabled), onProgress, undefined, "Groq");
+    }
+    /** Performs one request and rejects malformed tool arguments before execution. */
+    async streamOnce(messages, onText, markContent, systemInstruction, toolsEnabled) {
+        const stream = await this.client.chat.completions.create({
+            model: this.model,
+            stream: true,
+            messages: [
+                { role: "system", content: systemInstruction },
+                ...messages.map((message) => this.message(message)),
+            ],
+            ...(toolsEnabled
+                ? {
+                    tools: this.tools.map(({ name, description, parameters }) => ({
+                        type: "function",
+                        function: { name, description, parameters },
+                    })),
+                    tool_choice: "auto",
+                    parallel_tool_calls: false,
+                }
+                : {}),
+        });
+        let text = "";
+        const pending = new Map();
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta;
+            if (delta?.content) {
+                markContent();
+                text += delta.content;
+                onText(delta.content);
+            }
+            for (const call of delta?.tool_calls ?? []) {
+                markContent();
+                const current = pending.get(call.index) ?? { name: "", arguments: "" };
+                if (call.id)
+                    current.id = call.id;
+                if (call.function?.name)
+                    current.name += call.function.name;
+                if (call.function?.arguments)
+                    current.arguments += call.function.arguments;
+                pending.set(call.index, current);
+            }
+        }
+        const toolCalls = [...pending.entries()]
+            .sort(([left], [right]) => left - right)
+            .map(([, call]) => {
+            try {
+                return {
+                    id: call.id || crypto.randomUUID(),
+                    name: call.name,
+                    args: JSON.parse(call.arguments || "{}"),
+                };
+            }
+            catch {
+                throw new ProviderError("request", false, undefined, "Groq");
+            }
+        });
+        return { text, toolCalls };
+    }
+    /** Converts Kairo's durable message representation to Groq chat messages. */
+    message(message) {
+        if (message.role === "tool")
+            return {
+                role: "tool",
+                tool_call_id: message.toolCallId,
+                content: message.content,
+            };
+        if (message.role === "model" && message.toolCallId && message.toolName)
+            return {
+                role: "assistant",
+                content: null,
+                tool_calls: [
+                    {
+                        id: message.toolCallId,
+                        type: "function",
+                        function: { name: message.toolName, arguments: message.content },
+                    },
+                ],
+            };
+        return {
+            role: message.role === "model" ? "assistant" : "user",
+            content: message.content,
+        };
+    }
+}