@sireai/optimus 0.1.1

package/dist/task-environment/storage/sqlite-task-store.js

@@ -0,0 +1,1182 @@
+import { mkdir, rm } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+const MANAGED_TASK_TABLES = ["runtime_external_refs", "repository_roots", "observation_hints", "task_publication_attempts", "task_delivery_attempts", "task_delivery_bundles", "task_artifacts", "task_events", "task_runs", "tasks", "task_packages"];
+export class SQLiteTaskStore {
+    rootDir;
+    dbPath;
+    db;
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+        this.dbPath = join(rootDir, "optimus.db");
+    }
+    // SQLite is the source of truth for packaged tasks, orchestrated tasks, runs, and artifacts.
+    async init() {
+        await mkdir(this.rootDir, { recursive: true });
+        await rm(join(this.rootDir, "store.json"), { force: true });
+        await rm(join(this.rootDir, "events.json"), { force: true });
+        const db = this.getDb();
+        db.pragma("journal_mode = WAL");
+        db.pragma("foreign_keys = ON");
+        if (this.shouldResetLegacySchema(db)) {
+            this.resetManagedTaskSchema(db);
+        }
+        this.migrateTaskRunAddressColumns(db);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS task_packages (
+        task_package_id TEXT PRIMARY KEY,
+        source_event_id TEXT NOT NULL,
+        source TEXT NOT NULL,
+        source_ref TEXT,
+        idempotency_key TEXT,
+        task_type TEXT NOT NULL,
+        title TEXT NOT NULL,
+        repo TEXT,
+        branch TEXT,
+        input_json TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS tasks (
+        task_id TEXT PRIMARY KEY,
+        task_package_id TEXT NOT NULL UNIQUE,
+        source_event_id TEXT NOT NULL,
+        task_type TEXT NOT NULL,
+        title TEXT NOT NULL,
+        status TEXT NOT NULL,
+        risk_level TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        active_run_id TEXT,
+        run_count INTEGER NOT NULL DEFAULT 0,
+        FOREIGN KEY(task_package_id) REFERENCES task_packages(task_package_id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS task_runs (
+        run_id TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL,
+        task_package_id TEXT NOT NULL,
+        source_event_id TEXT,
+        status TEXT NOT NULL,
+        task_status TEXT NOT NULL,
+        health TEXT,
+        started_at TEXT NOT NULL,
+        ended_at TEXT,
+        summary TEXT,
+        failure_category TEXT,
+        addresses_workspace_dir TEXT,
+        addresses_visible_repo_dir TEXT,
+        addresses_configured_execution_mode TEXT,
+        addresses_resolved_execution_mode TEXT,
+        sandbox_mode TEXT,
+        approval_policy TEXT,
+        sdk_thread_id TEXT,
+        workspace_skill_mount_dir TEXT,
+        mounted_skills_json TEXT,
+        last_event_at TEXT,
+        last_event_type TEXT,
+        heartbeat_at TEXT,
+        progress_counter INTEGER DEFAULT 0,
+        command_count INTEGER DEFAULT 0,
+        file_change_count INTEGER DEFAULT 0,
+        last_agent_message_preview TEXT,
+        cancel_requested_at TEXT,
+        cancel_request_source_event_id TEXT,
+        FOREIGN KEY(task_id) REFERENCES tasks(task_id) ON DELETE CASCADE,
+        FOREIGN KEY(task_package_id) REFERENCES task_packages(task_package_id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS task_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        detail TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        run_id TEXT,
+        source_event_id TEXT,
+        FOREIGN KEY(task_id) REFERENCES tasks(task_id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS task_artifacts (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        content TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY(task_id) REFERENCES tasks(task_id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS task_delivery_bundles (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL,
+        run_id TEXT,
+        task_type TEXT NOT NULL,
+        outcome TEXT NOT NULL,
+        summary_json TEXT NOT NULL,
+        warnings_json TEXT,
+        artifacts_json TEXT NOT NULL,
+        publication_json TEXT,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY(task_id) REFERENCES tasks(task_id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS task_delivery_attempts (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL,
+        run_id TEXT,
+        channel TEXT NOT NULL,
+        status TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        delivered_at TEXT,
+        error TEXT,
+        FOREIGN KEY(task_id) REFERENCES tasks(task_id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS task_publication_attempts (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL,
+        run_id TEXT,
+        mode TEXT NOT NULL,
+        status TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        artifact_path TEXT,
+        topic TEXT,
+        topic_url TEXT,
+        review_url TEXT,
+        review_urls_json TEXT,
+        change_id TEXT,
+        change_ids_json TEXT,
+        error TEXT,
+        FOREIGN KEY(task_id) REFERENCES tasks(task_id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS repository_roots (
+        path TEXT PRIMARY KEY,
+        alias TEXT UNIQUE,
+        execution_mode TEXT NOT NULL DEFAULT "copy",
+        enabled INTEGER NOT NULL DEFAULT 1,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS runtime_external_refs (
+        ref_key TEXT PRIMARY KEY,
+        ref_value_json TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS observation_hints (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL,
+        area TEXT NOT NULL,
+        signal TEXT NOT NULL,
+        reason TEXT NOT NULL,
+        suggested_action TEXT NOT NULL,
+        FOREIGN KEY(task_id) REFERENCES tasks(task_id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_repository_roots_alias ON repository_roots(alias);
+      CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+      CREATE INDEX IF NOT EXISTS idx_task_packages_idempotency_key ON task_packages(idempotency_key);
+      CREATE INDEX IF NOT EXISTS idx_tasks_active_run_id ON tasks(active_run_id);
+      CREATE INDEX IF NOT EXISTS idx_task_runs_task_id ON task_runs(task_id, started_at);
+      CREATE INDEX IF NOT EXISTS idx_task_events_task_id ON task_events(task_id, created_at);
+      CREATE INDEX IF NOT EXISTS idx_task_delivery_bundles_task_id ON task_delivery_bundles(task_id, created_at);
+      CREATE INDEX IF NOT EXISTS idx_task_delivery_attempts_task_id ON task_delivery_attempts(task_id, created_at);
+      CREATE INDEX IF NOT EXISTS idx_task_publication_attempts_task_id ON task_publication_attempts(task_id, created_at);
+    `);
+        this.migrateTaskPublicationAttemptColumns(db);
+    }
+    // Repository roots are runtime-managed candidate code repositories used later for repo discovery and worktree creation.
+    async listRepositoryRoots() {
+        const rows = this.getDb().prepare(`SELECT * FROM repository_roots ORDER BY created_at ASC`).all();
+        return rows.map((row) => this.mapRepositoryRootRow(row));
+    }
+    async addRepositoryRoot(input) {
+        const now = new Date().toISOString();
+        this.getDb().prepare(`
+      INSERT INTO repository_roots (path, alias, execution_mode, enabled, created_at, updated_at)
+      VALUES (@path, @alias, @execution_mode, 1, @created_at, @updated_at)
+      ON CONFLICT(path) DO UPDATE SET
+        alias = excluded.alias,
+        execution_mode = excluded.execution_mode,
+        enabled = 1,
+        updated_at = excluded.updated_at
+    `).run({
+            path: input.path,
+            alias: input.alias ?? null,
+            execution_mode: input.executionMode ?? "copy",
+            created_at: now,
+            updated_at: now
+        });
+        const row = this.getDb().prepare(`SELECT * FROM repository_roots WHERE path = ?`).get(input.path);
+        return this.mapRepositoryRootRow(row);
+    }
+    async getRuntimeExternalRef(key) {
+        const row = this.getDb().prepare(`
+      SELECT ref_key, ref_value_json, updated_at
+      FROM runtime_external_refs
+      WHERE ref_key = ?
+    `).get(key);
+        if (!row) {
+            return undefined;
+        }
+        return JSON.parse(row.ref_value_json);
+    }
+    async setRuntimeExternalRef(key, value) {
+        const now = new Date().toISOString();
+        this.getDb().prepare(`
+      INSERT INTO runtime_external_refs (ref_key, ref_value_json, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(ref_key) DO UPDATE SET
+        ref_value_json = excluded.ref_value_json,
+        updated_at = excluded.updated_at
+    `).run(key, JSON.stringify(value), now);
+    }
+    async deleteRuntimeExternalRef(key) {
+        this.getDb().prepare(`DELETE FROM runtime_external_refs WHERE ref_key = ?`).run(key);
+    }
+    async removeRepositoryRoot(pathOrAlias) {
+        const row = this.getDb().prepare(`SELECT * FROM repository_roots WHERE path = ? OR alias = ? LIMIT 1`).get(pathOrAlias, pathOrAlias);
+        if (!row) {
+            return undefined;
+        }
+        this.getDb().prepare(`DELETE FROM repository_roots WHERE path = ?`).run(row.path);
+        return this.mapRepositoryRootRow(row);
+    }
+    // Repository updates keep the same identity row and only mutate the explicitly requested fields.
+    // This lets CLI callers change mode or alias without forcing a remove+add cycle.
+    async updateRepositoryRoot(pathOrAlias, input) {
+        const row = this.getDb().prepare(`SELECT * FROM repository_roots WHERE path = ? OR alias = ? LIMIT 1`).get(pathOrAlias, pathOrAlias);
+        if (!row) {
+            return undefined;
+        }
+        const nextAlias = input.alias !== undefined ? (input.alias || null) : row.alias;
+        const nextExecutionMode = input.executionMode ?? row.execution_mode ?? "copy";
+        const updatedAt = new Date().toISOString();
+        this.getDb().prepare(`
+      UPDATE repository_roots
+      SET alias = ?, execution_mode = ?, updated_at = ?, enabled = 1
+      WHERE path = ?
+    `).run(nextAlias, nextExecutionMode, updatedAt, row.path);
+        const updatedRow = this.getDb().prepare(`SELECT * FROM repository_roots WHERE path = ?`).get(row.path);
+        return this.mapRepositoryRootRow(updatedRow);
+    }
+    async createTaskFromPackage(taskPackage, options = {}) {
+        const now = new Date().toISOString();
+        const task = {
+            taskId: `task-${Date.now()}-${randomUUID().slice(0, 8)}`,
+            taskPackageId: taskPackage.taskPackageId,
+            sourceEventId: taskPackage.sourceEventId,
+            taskType: taskPackage.taskType,
+            title: taskPackage.title,
+            status: "queued",
+            riskLevel: "low",
+            createdAt: now,
+            updatedAt: now,
+            runCount: 0
+        };
+        const db = this.getDb();
+        const tx = db.transaction(() => {
+            db.prepare(`
+        INSERT INTO task_packages (
+          task_package_id, source_event_id, source, source_ref, idempotency_key, task_type, title,
+          repo, branch, input_json, created_at
+        ) VALUES (
+          @task_package_id, @source_event_id, @source, @source_ref, @idempotency_key, @task_type, @title,
+          @repo, @branch, @input_json, @created_at
+        )
+      `).run(this.toTaskPackageParams(taskPackage));
+            db.prepare(`
+        INSERT INTO tasks (
+          task_id, task_package_id, source_event_id, task_type, title,
+          status, risk_level, created_at, updated_at, active_run_id, run_count
+        ) VALUES (
+          @task_id, @task_package_id, @source_event_id, @task_type, @title,
+          @status, @risk_level, @created_at, @updated_at, @active_run_id, @run_count
+        )
+      `).run(this.toTaskParams(task));
+            db.prepare(`
+        INSERT INTO task_events (task_id, type, detail, created_at, run_id, source_event_id)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(task.taskId, "task.created", `Task package accepted for ${taskPackage.taskType}.`, now, null, options.sourceEventId ?? taskPackage.sourceEventId);
+        });
+        tx();
+        return task;
+    }
+    async listTasks() {
+        const rows = this.getDb().prepare(`SELECT * FROM tasks ORDER BY created_at ASC`).all();
+        return rows.map((row) => this.mapTaskRow(row));
+    }
+    async listTaskPackages() {
+        const rows = this.getDb().prepare(`SELECT * FROM task_packages ORDER BY created_at ASC`).all();
+        return rows.map((row) => this.mapTaskPackageRow(row));
+    }
+    async getTaskPackage(taskPackageId) {
+        const row = this.getDb().prepare(`SELECT * FROM task_packages WHERE task_package_id = ?`).get(taskPackageId);
+        return row ? this.mapTaskPackageRow(row) : undefined;
+    }
+    async findTaskBySourceEventId(sourceEventId) {
+        const row = this.getDb().prepare(`SELECT * FROM tasks WHERE source_event_id = ?`).get(sourceEventId);
+        return row ? this.mapTaskRow(row) : undefined;
+    }
+    async findTaskByIdempotencyKey(idempotencyKey) {
+        const row = this.getDb().prepare(`
+      SELECT tasks.*
+      FROM tasks
+      INNER JOIN task_packages ON task_packages.task_package_id = tasks.task_package_id
+      WHERE task_packages.idempotency_key = ?
+      ORDER BY tasks.created_at DESC
+      LIMIT 1
+    `).get(idempotencyKey);
+        return row ? this.mapTaskRow(row) : undefined;
+    }
+    async listTaskRuns() {
+        const rows = this.getDb().prepare(`SELECT * FROM task_runs ORDER BY started_at ASC`).all();
+        return rows.map((row) => this.mapRunRow(row));
+    }
+    // Doctor and operator tooling read recent task events from SQLite instead of scraping runtime logs.
+    // This keeps task-state diagnostics available even after process restarts or log rotation.
+    async listRecentTaskEvents(limit = 20, types) {
+        const normalizedLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 20;
+        const params = [];
+        let sql = `SELECT task_id, type, detail, created_at, run_id, source_event_id FROM task_events`;
+        if (types && types.length > 0) {
+            sql += ` WHERE type IN (${types.map(() => "?").join(",")})`;
+            params.push(...types);
+        }
+        sql += ` ORDER BY created_at DESC, id DESC LIMIT ?`;
+        params.push(normalizedLimit);
+        const rows = this.getDb().prepare(sql).all(...params);
+        return rows.map((row) => this.mapTaskEventRow(row));
+    }
+    // Result inspection reads persisted artifacts and observation hints directly from SQLite so CLI views do not need raw SQL.
+    async listTaskArtifacts(taskId) {
+        const rows = this.getDb().prepare(`SELECT task_id, kind, content, created_at FROM task_artifacts WHERE task_id = ? ORDER BY id ASC`).all(taskId);
+        return rows.map((row) => {
+            if (row.kind && row.kind !== "attachment") {
+                return {
+                    kind: row.kind,
+                    path: row.content,
+                    createdAt: row.created_at
+                };
+            }
+            return {
+                path: row.content,
+                createdAt: row.created_at
+            };
+        });
+    }
+    async getLatestTaskDeliveryBundle(taskId) {
+        const row = this.getDb().prepare(`SELECT * FROM task_delivery_bundles WHERE task_id = ? ORDER BY id DESC LIMIT 1`).get(taskId);
+        if (!row) {
+            return undefined;
+        }
+        return {
+            taskId: row.task_id,
+            ...(row.run_id ? { runId: row.run_id } : {}),
+            taskType: row.task_type,
+            outcome: row.outcome,
+            createdAt: row.created_at,
+            summary: JSON.parse(row.summary_json),
+            ...(row.warnings_json ? { warnings: JSON.parse(row.warnings_json) } : {}),
+            artifacts: JSON.parse(row.artifacts_json),
+            ...(row.publication_json ? { publication: JSON.parse(row.publication_json) } : {})
+        };
+    }
+    async listTaskDeliveryAttempts(taskId) {
+        const rows = this.getDb().prepare(`SELECT task_id, run_id, channel, status, summary, created_at, delivered_at, error FROM task_delivery_attempts WHERE task_id = ? ORDER BY id ASC`).all(taskId);
+        return rows.map((row) => ({
+            taskId: row.task_id,
+            ...(row.run_id ? { runId: row.run_id } : {}),
+            channel: row.channel,
+            status: row.status,
+            summary: row.summary,
+            createdAt: row.created_at,
+            ...(row.delivered_at ? { deliveredAt: row.delivered_at } : {}),
+            ...(row.error ? { error: row.error } : {})
+        }));
+    }
+    async listRetryableDeliveryAttempts(limit) {
+        const rows = this.getDb().prepare(`
+      SELECT latest.task_id, latest.run_id, latest.channel, latest.status, latest.summary, latest.created_at, latest.delivered_at, latest.error
+      FROM task_delivery_attempts latest
+      INNER JOIN (
+        SELECT task_id, channel, MAX(id) AS max_id
+        FROM task_delivery_attempts
+        GROUP BY task_id, channel
+      ) grouped
+        ON grouped.max_id = latest.id
+      WHERE latest.status = 'failed'
+      ORDER BY latest.created_at ASC
+      LIMIT ?
+    `).all(limit);
+        return rows.map((row) => ({
+            taskId: row.task_id,
+            ...(row.run_id ? { runId: row.run_id } : {}),
+            channel: row.channel,
+            status: row.status,
+            summary: row.summary,
+            createdAt: row.created_at,
+            ...(row.delivered_at ? { deliveredAt: row.delivered_at } : {}),
+            ...(row.error ? { error: row.error } : {})
+        }));
+    }
+    async listTaskPublicationAttempts(taskId) {
+        const rows = this.getDb().prepare(`SELECT task_id, run_id, mode, status, summary, created_at, artifact_path, topic, topic_url, review_url, review_urls_json, change_id, change_ids_json, error FROM task_publication_attempts WHERE task_id = ? ORDER BY id ASC`).all(taskId);
+        return rows.map((row) => ({
+            taskId: row.task_id,
+            ...(row.run_id ? { runId: row.run_id } : {}),
+            mode: row.mode,
+            status: row.status,
+            summary: row.summary,
+            createdAt: row.created_at,
+            ...(row.artifact_path ? { artifactPath: row.artifact_path } : {}),
+            ...(row.topic ? { topic: row.topic } : {}),
+            ...(row.topic_url ? { topicUrl: row.topic_url } : {}),
+            ...(row.review_url ? { reviewUrl: row.review_url } : {}),
+            ...(row.review_urls_json ? { reviewUrls: JSON.parse(row.review_urls_json) } : {}),
+            ...(row.change_id ? { changeId: row.change_id } : {}),
+            ...(row.change_ids_json ? { changeIds: JSON.parse(row.change_ids_json) } : {}),
+            ...(row.error ? { error: row.error } : {})
+        }));
+    }
+    async listObservationHints(taskId) {
+        const rows = this.getDb().prepare(`SELECT task_id, area, signal, reason, suggested_action FROM observation_hints WHERE task_id = ? ORDER BY id ASC`).all(taskId);
+        return rows.map((row) => ({
+            area: row.area,
+            signal: row.signal,
+            reason: row.reason,
+            suggestedAction: row.suggested_action
+        }));
+    }
+    async getTask(taskId) {
+        const row = this.getDb().prepare(`SELECT * FROM tasks WHERE task_id = ?`).get(taskId);
+        return row ? this.mapTaskRow(row) : undefined;
+    }
+    async retryTask(taskId, sourceEventId) {
+        const db = this.getDb();
+        const task = this.requireTask(taskId, false);
+        if (!task || task.activeRunId) {
+            return undefined;
+        }
+        if (!["failed", "needs_human", "completed"].includes(task.status)) {
+            return undefined;
+        }
+        const now = new Date().toISOString();
+        task.status = "queued";
+        task.updatedAt = now;
+        const tx = db.transaction(() => {
+            this.writeTask(task);
+            db.prepare(`
+        INSERT INTO task_events (task_id, type, detail, created_at, run_id, source_event_id)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(taskId, "task.retry_requested", "Task was re-queued for another execution attempt.", now, null, sourceEventId ?? task.sourceEventId ?? null);
+        });
+        tx();
+        return this.getTask(taskId);
+    }
+    async cancelTask(taskId, sourceEventId) {
+        const db = this.getDb();
+        const task = this.requireTask(taskId, false);
+        if (!task) {
+            return undefined;
+        }
+        const now = new Date().toISOString();
+        const activeRun = task.activeRunId ? this.getRun(taskId, task.activeRunId) : undefined;
+        if (task.activeRunId && activeRun && !activeRun.endedAt) {
+            activeRun.status = "cancel_requested";
+            activeRun.health = "cancel_requested";
+            activeRun.lastEventAt = now;
+            activeRun.lastEventType = "task.cancel_requested";
+            activeRun.heartbeatAt = now;
+            activeRun.cancelRequestedAt = now;
+            if (sourceEventId) {
+                activeRun.cancelRequestSourceEventId = sourceEventId;
+            }
+            const tx = db.transaction(() => {
+                this.writeRun(activeRun);
+                db.prepare(`
+          INSERT INTO task_events (task_id, type, detail, created_at, run_id, source_event_id)
+          VALUES (?, ?, ?, ?, ?, ?)
+        `).run(taskId, "task.cancel_requested", "Cancellation requested for running task; runtime will interrupt the active run.", now, task.activeRunId ?? null, sourceEventId ?? null);
+            });
+            tx();
+            return this.getTask(taskId);
+        }
+        if (!["queued", "failed", "needs_human"].includes(task.status)) {
+            return undefined;
+        }
+        task.status = "canceled";
+        task.updatedAt = now;
+        const tx = db.transaction(() => {
+            this.writeTask(task);
+            db.prepare(`
+        INSERT INTO task_events (task_id, type, detail, created_at, run_id, source_event_id)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(taskId, "task.cancel_requested", "Task was canceled before a new execution started.", now, null, sourceEventId ?? null);
+        });
+        tx();
+        return this.getTask(taskId);
+    }
+    async listRunnableTasks(options) {
+        const excluded = options.excludeTaskIds ?? [];
+        const params = ["queued"];
+        let sql = `SELECT * FROM tasks WHERE status = ? AND active_run_id IS NULL`;
+        if (excluded.length > 0) {
+            sql += ` AND task_id NOT IN (${excluded.map(() => "?").join(",")})`;
+            params.push(...excluded);
+        }
+        sql += ` ORDER BY created_at ASC LIMIT ?`;
+        params.push(options.limit);
+        const rows = this.getDb().prepare(sql).all(...params);
+        return rows.map((row) => this.mapTaskRow(row));
+    }
+    async claimTask(taskId) {
+        const db = this.getDb();
+        const task = this.requireTask(taskId, false);
+        if (!task || task.status !== "queued" || task.activeRunId) {
+            return undefined;
+        }
+        const taskPackage = this.requireTaskPackage(task.taskPackageId);
+        const now = new Date().toISOString();
+        const runId = `run-${Date.now()}-${randomUUID().slice(0, 8)}`;
+        task.status = "preparing";
+        task.activeRunId = runId;
+        task.runCount = (task.runCount ?? 0) + 1;
+        task.updatedAt = now;
+        const taskRun = {
+            runId,
+            taskId,
+            taskPackageId: task.taskPackageId,
+            status: "leased",
+            taskStatus: "preparing",
+            health: "waiting_start",
+            startedAt: now,
+            lastEventAt: now,
+            lastEventType: "task.claimed",
+            heartbeatAt: now,
+            progressCounter: 0,
+            commandCount: 0,
+            fileChangeCount: 0,
+            ...(task.sourceEventId ? { sourceEventId: task.sourceEventId } : {})
+        };
+        const tx = db.transaction(() => {
+            this.writeTask(task);
+            db.prepare(`
+        INSERT INTO task_runs (
+          run_id, task_id, task_package_id, source_event_id, status, task_status, health,
+          started_at, ended_at, summary, failure_category, addresses_workspace_dir, addresses_visible_repo_dir,
+          addresses_configured_execution_mode, addresses_resolved_execution_mode, sandbox_mode,
+          approval_policy, sdk_thread_id, workspace_skill_mount_dir, mounted_skills_json, last_event_at, last_event_type, heartbeat_at,
+          progress_counter, command_count, file_change_count, last_agent_message_preview,
+          cancel_requested_at, cancel_request_source_event_id
+        ) VALUES (
+          @run_id, @task_id, @task_package_id, @source_event_id, @status, @task_status, @health,
+          @started_at, @ended_at, @summary, @failure_category, @addresses_workspace_dir, @addresses_visible_repo_dir,
+          @addresses_configured_execution_mode, @addresses_resolved_execution_mode, @sandbox_mode,
+          @approval_policy, @sdk_thread_id, @workspace_skill_mount_dir, @mounted_skills_json, @last_event_at, @last_event_type, @heartbeat_at,
+          @progress_counter, @command_count, @file_change_count, @last_agent_message_preview,
+          @cancel_requested_at, @cancel_request_source_event_id
+        )
+      `).run(this.toRunParams(taskRun));
+            db.prepare(`
+        INSERT INTO task_events (task_id, type, detail, created_at, run_id, source_event_id)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(taskId, "task.claimed", `Task claimed by scheduler for package ${taskPackage.taskType}.`, now, runId, task.sourceEventId ?? null);
+        });
+        tx();
+        return this.getTask(taskId);
+    }
+    async transitionTask(taskId, status, detail, options = {}) {
+        const db = this.getDb();
+        const task = this.requireTask(taskId);
+        const now = new Date().toISOString();
+        task.status = status;
+        task.updatedAt = now;
+        const run = this.getRun(taskId, options.runId ?? task.activeRunId);
+        if (run) {
+            run.taskStatus = status;
+            run.status = options.runStatus ?? this.toRunStatus(status, run.status);
+            run.health = options.health ?? this.toRunHealth(run.status, status);
+            run.lastEventAt = now;
+            run.lastEventType = options.eventType ?? "task.status.changed";
+            run.heartbeatAt = options.heartbeatAt ?? now;
+            if (options.sdkThreadId) {
+                run.sdkThreadId = options.sdkThreadId;
+            }
+            if (options.agentMessagePreview) {
+                run.lastAgentMessagePreview = options.agentMessagePreview;
+            }
+            if (options.incrementProgressCounter) {
+                run.progressCounter = (run.progressCounter ?? 0) + 1;
+            }
+            if (options.incrementCommandCount) {
+                run.commandCount = (run.commandCount ?? 0) + 1;
+            }
+            if (options.incrementFileChangeCount) {
+                run.fileChangeCount = (run.fileChangeCount ?? 0) + 1;
+            }
+            if (options.addresses) {
+                run.addresses = {
+                    ...(run.addresses ?? {}),
+                    ...options.addresses
+                };
+            }
+            if (options.workspaceSkillMountDir) {
+                run.workspaceSkillMountDir = options.workspaceSkillMountDir;
+            }
+            if (options.mountedSkills) {
+                run.mountedSkills = options.mountedSkills;
+            }
+            if (options.sandboxMode) {
+                run.sandboxMode = options.sandboxMode;
+            }
+            if (options.approvalPolicy) {
+                run.approvalPolicy = options.approvalPolicy;
+            }
+        }
+        const tx = db.transaction(() => {
+            this.writeTask(task);
+            if (run) {
+                this.writeRun(run);
+            }
+            db.prepare(`
+        INSERT INTO task_events (task_id, type, detail, created_at, run_id, source_event_id)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(taskId, options.eventType ?? "task.status.changed", detail, now, options.runId ?? task.activeRunId ?? null, options.sourceEventId ?? null);
+        });
+        tx();
+    }
+    async recoverActiveTasks() {
+        const db = this.getDb();
+        const tasks = await this.listTasks();
+        const recovered = [];
+        const now = new Date().toISOString();
+        const tx = db.transaction(() => {
+            for (const task of tasks) {
+                if (!task.activeRunId) {
+                    continue;
+                }
+                const runId = task.activeRunId;
+                const previousStatus = task.status;
+                task.status = "queued";
+                task.updatedAt = now;
+                delete task.activeRunId;
+                this.writeTask(task);
+                const run = this.getRun(task.taskId, runId);
+                if (run) {
+                    run.taskStatus = "failed";
+                    run.status = "recovered";
+                    run.health = "recovered";
+                    run.endedAt = now;
+                    run.summary = "Runtime restarted before the task completed; active lease was recovered and the task was re-queued.";
+                    run.failureCategory = "environment_error";
+                    run.lastEventAt = now;
+                    run.lastEventType = "task.recovered";
+                    run.heartbeatAt = now;
+                    this.writeRun(run);
+                }
+                db.prepare(`
+          INSERT INTO task_events (task_id, type, detail, created_at, run_id, source_event_id)
+          VALUES (?, ?, ?, ?, ?, ?)
+        `).run(task.taskId, "task.recovered", `Recovered stale run ${runId} from ${previousStatus}; task moved back to queued.`, now, runId, task.sourceEventId ?? null);
+                recovered.push({ taskId: task.taskId, runId, previousStatus });
+            }
+        });
+        tx();
+        return recovered;
+    }
+    async updateTaskRun(taskId, runId, options) {
+        const run = this.getRun(taskId, runId);
+        if (!run) {
+            return;
+        }
+        const now = new Date().toISOString();
+        if (options.runStatus) {
+            run.status = options.runStatus;
+        }
+        if (options.health) {
+            run.health = options.health;
+        }
+        if (options.failureCategory) {
+            run.failureCategory = options.failureCategory;
+        }
+        if (options.summary) {
+            run.summary = options.summary;
+        }
+        if (options.endedAt) {
+            run.endedAt = options.endedAt;
+        }
+        if (options.cancelRequestedAt) {
+            run.cancelRequestedAt = options.cancelRequestedAt;
+        }
+        if (options.cancelRequestSourceEventId) {
+            run.cancelRequestSourceEventId = options.cancelRequestSourceEventId;
+        }
+        if (options.workspaceSkillMountDir) {
+            run.workspaceSkillMountDir = options.workspaceSkillMountDir;
+        }
+        if (options.mountedSkills) {
+            run.mountedSkills = options.mountedSkills;
+        }
+        run.lastEventAt = now;
+        run.lastEventType = options.eventType ?? run.lastEventType ?? "runtime.monitor";
+        run.heartbeatAt = options.heartbeatAt ?? now;
+        this.writeRun(run);
+    }
+    async completeTaskRun(taskId, status, summary, options = {}) {
+        const db = this.getDb();
+        const task = this.requireTask(taskId);
+        const now = new Date().toISOString();
+        const activeRunId = task.activeRunId;
+        task.status = status;
+        task.updatedAt = now;
+        delete task.activeRunId;
+        const run = this.getRun(taskId, activeRunId);
+        if (run) {
+            run.taskStatus = status;
+            run.status = status === "failed" ? "failed" : status === "canceled" ? "canceled" : "completed";
+            run.health = status === "failed" ? "failed" : status === "canceled" ? "canceled" : "completed";
+            run.endedAt = now;
+            run.summary = summary;
+            run.lastEventAt = now;
+            run.lastEventType = status === "failed" ? "execution.failed" : status === "canceled" ? "execution.canceled" : "execution.completed";
+            run.heartbeatAt = now;
+            if (options.failureCategory) {
+                run.failureCategory = options.failureCategory;
+            }
+            else {
+                delete run.failureCategory;
+            }
+        }
+        const eventType = status === "failed" ? "execution.failed" : status === "canceled" ? "execution.canceled" : "execution.completed";
+        const tx = db.transaction(() => {
+            this.writeTask(task);
+            if (run) {
+                this.writeRun(run);
+            }
+            db.prepare(`
+        INSERT INTO task_events (task_id, type, detail, created_at, run_id, source_event_id)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(taskId, eventType, summary, now, activeRunId ?? null, task.sourceEventId ?? null);
+        });
+        tx();
+    }
+    async updateTask(taskId, patch) {
+        const task = this.requireTask(taskId);
+        Object.assign(task, patch, { updatedAt: new Date().toISOString() });
+        this.writeTask(task);
+    }
+    async appendArtifacts(taskId, artifacts) {
+        if (artifacts.length === 0) {
+            return;
+        }
+        const db = this.getDb();
+        const insert = db.prepare(`
+      INSERT INTO task_artifacts (task_id, kind, content, created_at)
+      VALUES (?, ?, ?, ?)
+    `);
+        const tx = db.transaction(() => {
+            for (const artifact of artifacts) {
+                insert.run(taskId, artifact.kind ?? "attachment", artifact.path, artifact.createdAt);
+            }
+        });
+        tx();
+    }
+    async appendTaskDeliveryBundle(bundle) {
+        this.getDb().prepare(`
+      INSERT INTO task_delivery_bundles (
+        task_id, run_id, task_type, outcome, summary_json, warnings_json, artifacts_json, publication_json, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(bundle.taskId, bundle.runId ?? null, bundle.taskType, bundle.outcome, JSON.stringify(bundle.summary), bundle.warnings ? JSON.stringify(bundle.warnings) : null, JSON.stringify(bundle.artifacts), bundle.publication ? JSON.stringify(bundle.publication) : null, bundle.createdAt);
+    }
+    async appendTaskDeliveryAttempts(attempts) {
+        if (attempts.length === 0) {
+            return;
+        }
+        const db = this.getDb();
+        const insert = db.prepare(`
+      INSERT INTO task_delivery_attempts (
+        task_id, run_id, channel, status, summary, created_at, delivered_at, error
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const tx = db.transaction(() => {
+            for (const attempt of attempts) {
+                insert.run(attempt.taskId, attempt.runId ?? null, attempt.channel, attempt.status, attempt.summary, attempt.createdAt, attempt.deliveredAt ?? null, attempt.error ?? null);
+            }
+        });
+        tx();
+    }
+    async appendTaskPublicationAttempts(attempts) {
+        if (attempts.length === 0) {
+            return;
+        }
+        const db = this.getDb();
+        const insert = db.prepare(`
+      INSERT INTO task_publication_attempts (
+        task_id, run_id, mode, status, summary, created_at, artifact_path, topic, topic_url, review_url, review_urls_json, change_id, change_ids_json, error
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const tx = db.transaction(() => {
+            for (const attempt of attempts) {
+                insert.run(attempt.taskId, attempt.runId ?? null, attempt.mode, attempt.status, attempt.summary, attempt.createdAt, attempt.artifactPath ?? null, attempt.topic ?? null, attempt.topicUrl ?? null, attempt.reviewUrl ?? null, attempt.reviewUrls ? JSON.stringify(attempt.reviewUrls) : null, attempt.changeId ?? null, attempt.changeIds ? JSON.stringify(attempt.changeIds) : null, attempt.error ?? null);
+            }
+        });
+        tx();
+    }
+    migrateTaskPublicationAttemptColumns(db) {
+        if (!this.tableExists(db, "task_publication_attempts")) {
+            return;
+        }
+        if (!this.tableHasColumn(db, "task_publication_attempts", "review_url")) {
+            db.exec("ALTER TABLE task_publication_attempts ADD COLUMN review_url TEXT");
+        }
+        if (!this.tableHasColumn(db, "task_publication_attempts", "topic")) {
+            db.exec("ALTER TABLE task_publication_attempts ADD COLUMN topic TEXT");
+        }
+        if (!this.tableHasColumn(db, "task_publication_attempts", "topic_url")) {
+            db.exec("ALTER TABLE task_publication_attempts ADD COLUMN topic_url TEXT");
+        }
+        if (!this.tableHasColumn(db, "task_publication_attempts", "review_urls_json")) {
+            db.exec("ALTER TABLE task_publication_attempts ADD COLUMN review_urls_json TEXT");
+        }
+        if (!this.tableHasColumn(db, "task_publication_attempts", "change_id")) {
+            db.exec("ALTER TABLE task_publication_attempts ADD COLUMN change_id TEXT");
+        }
+        if (!this.tableHasColumn(db, "task_publication_attempts", "change_ids_json")) {
+            db.exec("ALTER TABLE task_publication_attempts ADD COLUMN change_ids_json TEXT");
+        }
+        if (!this.tableHasColumn(db, "task_delivery_bundles", "warnings_json")) {
+            db.exec("ALTER TABLE task_delivery_bundles ADD COLUMN warnings_json TEXT");
+        }
+    }
+    async appendObservationHints(taskId, hints) {
+        if (hints.length === 0) {
+            return;
+        }
+        const db = this.getDb();
+        const insert = db.prepare(`
+      INSERT INTO observation_hints (task_id, area, signal, reason, suggested_action)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        const tx = db.transaction(() => {
+            for (const hint of hints) {
+                insert.run(taskId, hint.area, hint.signal, hint.reason, hint.suggestedAction);
+            }
+        });
+        tx();
+    }
+    async appendEvent(taskId, type, detail, options = {}) {
+        this.getDb().prepare(`
+      INSERT INTO task_events (task_id, type, detail, created_at, run_id, source_event_id)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(taskId, type, detail, new Date().toISOString(), options.runId ?? null, options.sourceEventId ?? null);
+    }
+    // Old JSON-backed and early SQLite schemas are not compatible with the packaged-task model.
+    // For this stage we intentionally discard legacy task history and recreate the managed tables.
+    shouldResetLegacySchema(db) {
+        const requiredColumnsByTable = {
+            tasks: ["task_package_id", "active_run_id", "run_count"],
+            task_runs: ["task_package_id", "health", "last_event_type", "progress_counter", "cancel_requested_at", "addresses_visible_repo_dir", "addresses_configured_execution_mode", "addresses_resolved_execution_mode", "workspace_skill_mount_dir", "mounted_skills_json"],
+            task_packages: ["task_package_id", "source_ref", "idempotency_key", "repo", "branch", "input_json"],
+            repository_roots: ["execution_mode"]
+        };
+        return Object.entries(requiredColumnsByTable).some(([tableName, requiredColumns]) => {
+            if (!this.tableExists(db, tableName)) {
+                return false;
+            }
+            return requiredColumns.some((columnName) => !this.tableHasColumn(db, tableName, columnName));
+        });
+    }
+    resetManagedTaskSchema(db) {
+        db.exec("PRAGMA foreign_keys = OFF");
+        for (const tableName of MANAGED_TASK_TABLES) {
+            db.exec(`DROP TABLE IF EXISTS ${tableName}`);
+        }
+        db.exec("PRAGMA foreign_keys = ON");
+    }
+    // Address columns were renamed from flat run fields to grouped addresses_* fields.
+    // Migrate older SQLite files in place so runtime state survives local upgrades without keeping dual mappings forever.
+    migrateTaskRunAddressColumns(db) {
+        if (!this.tableExists(db, "task_runs")) {
+            return;
+        }
+        const columnRenames = [
+            { from: "workspace_dir", to: "addresses_workspace_dir" },
+            { from: "repo_path", to: "addresses_visible_repo_dir" },
+            { from: "configured_execution_mode", to: "addresses_configured_execution_mode" },
+            { from: "resolved_execution_mode", to: "addresses_resolved_execution_mode" }
+        ];
+        for (const rename of columnRenames) {
+            if (!this.tableHasColumn(db, "task_runs", rename.from) || this.tableHasColumn(db, "task_runs", rename.to)) {
+                continue;
+            }
+            db.exec(`ALTER TABLE task_runs RENAME COLUMN ${rename.from} TO ${rename.to}`);
+        }
+    }
+    tableExists(db, tableName) {
+        const row = db.prepare("SELECT name FROM sqlite_master WHERE type = ? AND name = ?").get("table", tableName);
+        return Boolean(row);
+    }
+    tableHasColumn(db, tableName, columnName) {
+        if (!this.tableExists(db, tableName)) {
+            return false;
+        }
+        const columns = db.prepare(`PRAGMA table_info(${tableName})`).all();
+        return columns.some((column) => column.name === columnName);
+    }
+    getDb() {
+        if (!this.db) {
+            this.db = new Database(this.dbPath);
+        }
+        return this.db;
+    }
+    requireTask(taskId, throwOnMissing = true) {
+        const row = this.getDb().prepare(`SELECT * FROM tasks WHERE task_id = ?`).get(taskId);
+        if (!row) {
+            if (throwOnMissing) {
+                throw new Error(`Task not found: ${taskId}`);
+            }
+            return undefined;
+        }
+        return this.mapTaskRow(row);
+    }
+    requireTaskPackage(taskPackageId, throwOnMissing = true) {
+        const row = this.getDb().prepare(`SELECT * FROM task_packages WHERE task_package_id = ?`).get(taskPackageId);
+        if (!row) {
+            if (throwOnMissing) {
+                throw new Error(`Task package not found: ${taskPackageId}`);
+            }
+            return undefined;
+        }
+        return this.mapTaskPackageRow(row);
+    }
+    getRun(taskId, runId) {
+        if (!runId) {
+            return undefined;
+        }
+        const row = this.getDb().prepare(`SELECT * FROM task_runs WHERE task_id = ? AND run_id = ?`).get(taskId, runId);
+        return row ? this.mapRunRow(row) : undefined;
+    }
+    writeTask(task) {
+        this.getDb().prepare(`
+      UPDATE tasks SET
+        task_package_id = @task_package_id,
+        source_event_id = @source_event_id,
+        task_type = @task_type,
+        title = @title,
+        status = @status,
+        risk_level = @risk_level,
+        created_at = @created_at,
+        updated_at = @updated_at,
+        active_run_id = @active_run_id,
+        run_count = @run_count
+      WHERE task_id = @task_id
+    `).run(this.toTaskParams(task));
+    }
+    writeRun(run) {
+        this.getDb().prepare(`
+      UPDATE task_runs SET
+        task_package_id = @task_package_id,
+        source_event_id = @source_event_id,
+        status = @status,
+        task_status = @task_status,
+        health = @health,
+        started_at = @started_at,
+        ended_at = @ended_at,
+        summary = @summary,
+        failure_category = @failure_category,
+        addresses_workspace_dir = @addresses_workspace_dir,
+        addresses_visible_repo_dir = @addresses_visible_repo_dir,
+        addresses_configured_execution_mode = @addresses_configured_execution_mode,
+        addresses_resolved_execution_mode = @addresses_resolved_execution_mode,
+        sandbox_mode = @sandbox_mode,
+        approval_policy = @approval_policy,
+        sdk_thread_id = @sdk_thread_id,
+        workspace_skill_mount_dir = @workspace_skill_mount_dir,
+        mounted_skills_json = @mounted_skills_json,
+        last_event_at = @last_event_at,
+        last_event_type = @last_event_type,
+        heartbeat_at = @heartbeat_at,
+        progress_counter = @progress_counter,
+        command_count = @command_count,
+        file_change_count = @file_change_count,
+        last_agent_message_preview = @last_agent_message_preview,
+        cancel_requested_at = @cancel_requested_at,
+        cancel_request_source_event_id = @cancel_request_source_event_id
+      WHERE run_id = @run_id
+    `).run(this.toRunParams(run));
+    }
+    mapRepositoryRootRow(row) {
+        return {
+            path: row.path,
+            ...(row.alias ? { alias: row.alias } : {}),
+            executionMode: row.execution_mode ?? "copy",
+            enabled: row.enabled === 1,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at
+        };
+    }
+    mapTaskPackageRow(row) {
+        return {
+            taskPackageId: row.task_package_id,
+            sourceEventId: row.source_event_id,
+            source: row.source,
+            ...(row.source_ref ? { sourceRef: row.source_ref } : {}),
+            ...(row.idempotency_key ? { idempotencyKey: row.idempotency_key } : {}),
+            taskType: row.task_type,
+            title: row.title,
+            ...(row.repo ? { repo: row.repo } : {}),
+            ...(row.branch ? { branch: row.branch } : {}),
+            input: JSON.parse(row.input_json),
+            createdAt: row.created_at
+        };
+    }
+    mapTaskRow(row) {
+        return {
+            taskId: row.task_id,
+            taskPackageId: row.task_package_id,
+            sourceEventId: row.source_event_id,
+            taskType: row.task_type,
+            title: row.title,
+            status: row.status,
+            riskLevel: row.risk_level,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            ...(row.active_run_id ? { activeRunId: row.active_run_id } : {}),
+            runCount: row.run_count,
+        };
+    }
+    mapTaskEventRow(row) {
+        return {
+            taskId: row.task_id,
+            type: row.type,
+            detail: row.detail,
+            createdAt: row.created_at,
+            ...(row.run_id ? { runId: row.run_id } : {}),
+            ...(row.source_event_id ? { sourceEventId: row.source_event_id } : {})
+        };
+    }
+    mapRunRow(row) {
+        const addresses = {
+            ...(row.addresses_workspace_dir ? { workspaceDir: row.addresses_workspace_dir } : {}),
+            ...(row.addresses_visible_repo_dir ? { visibleRepoDir: row.addresses_visible_repo_dir } : {}),
+            ...(row.addresses_configured_execution_mode ? { configuredExecutionMode: row.addresses_configured_execution_mode } : {}),
+            ...(row.addresses_resolved_execution_mode ? { resolvedExecutionMode: row.addresses_resolved_execution_mode } : {})
+        };
+        return {
+            runId: row.run_id,
+            taskId: row.task_id,
+            taskPackageId: row.task_package_id,
+            ...(row.source_event_id ? { sourceEventId: row.source_event_id } : {}),
+            status: row.status,
+            taskStatus: row.task_status,
+            ...(row.health ? { health: row.health } : {}),
+            startedAt: row.started_at,
+            ...(row.ended_at ? { endedAt: row.ended_at } : {}),
+            ...(row.summary ? { summary: row.summary } : {}),
+            ...(row.failure_category ? { failureCategory: row.failure_category } : {}),
+            ...(Object.keys(addresses).length > 0 ? { addresses } : {}),
+            ...(row.sandbox_mode ? { sandboxMode: row.sandbox_mode } : {}),
+            ...(row.approval_policy ? { approvalPolicy: row.approval_policy } : {}),
+            ...(row.sdk_thread_id ? { sdkThreadId: row.sdk_thread_id } : {}),
+            ...(row.workspace_skill_mount_dir ? { workspaceSkillMountDir: row.workspace_skill_mount_dir } : {}),
+            ...(row.mounted_skills_json ? { mountedSkills: JSON.parse(row.mounted_skills_json) } : {}),
+            ...(row.last_event_at ? { lastEventAt: row.last_event_at } : {}),
+            ...(row.last_event_type ? { lastEventType: row.last_event_type } : {}),
+            ...(row.heartbeat_at ? { heartbeatAt: row.heartbeat_at } : {}),
+            progressCounter: row.progress_counter ?? 0,
+            commandCount: row.command_count ?? 0,
+            fileChangeCount: row.file_change_count ?? 0,
+            ...(row.last_agent_message_preview ? { lastAgentMessagePreview: row.last_agent_message_preview } : {}),
+            ...(row.cancel_requested_at ? { cancelRequestedAt: row.cancel_requested_at } : {}),
+            ...(row.cancel_request_source_event_id ? { cancelRequestSourceEventId: row.cancel_request_source_event_id } : {})
+        };
+    }
+    toTaskPackageParams(taskPackage) {
+        return {
+            task_package_id: taskPackage.taskPackageId,
+            source_event_id: taskPackage.sourceEventId,
+            source: taskPackage.source,
+            source_ref: taskPackage.sourceRef ?? null,
+            idempotency_key: taskPackage.idempotencyKey ?? null,
+            task_type: taskPackage.taskType,
+            title: taskPackage.title,
+            repo: taskPackage.repo ?? null,
+            branch: taskPackage.branch ?? null,
+            input_json: JSON.stringify(taskPackage.input),
+            created_at: taskPackage.createdAt
+        };
+    }
+    toTaskParams(task) {
+        return {
+            task_id: task.taskId,
+            task_package_id: task.taskPackageId,
+            source_event_id: task.sourceEventId,
+            task_type: task.taskType,
+            title: task.title,
+            status: task.status,
+            risk_level: task.riskLevel,
+            created_at: task.createdAt,
+            updated_at: task.updatedAt,
+            active_run_id: task.activeRunId ?? null,
+            run_count: task.runCount ?? 0,
+        };
+    }
+    toRunParams(run) {
+        return {
+            run_id: run.runId,
+            task_id: run.taskId,
+            task_package_id: run.taskPackageId,
+            source_event_id: run.sourceEventId ?? null,
+            status: run.status,
+            task_status: run.taskStatus,
+            health: run.health ?? null,
+            started_at: run.startedAt,
+            ended_at: run.endedAt ?? null,
+            summary: run.summary ?? null,
+            failure_category: run.failureCategory ?? null,
+            addresses_workspace_dir: run.addresses?.workspaceDir ?? null,
+            addresses_visible_repo_dir: run.addresses?.visibleRepoDir ?? null,
+            addresses_configured_execution_mode: run.addresses?.configuredExecutionMode ?? null,
+            addresses_resolved_execution_mode: run.addresses?.resolvedExecutionMode ?? null,
+            sandbox_mode: run.sandboxMode ?? null,
+            approval_policy: run.approvalPolicy ?? null,
+            sdk_thread_id: run.sdkThreadId ?? null,
+            workspace_skill_mount_dir: run.workspaceSkillMountDir ?? null,
+            mounted_skills_json: run.mountedSkills ? JSON.stringify(run.mountedSkills) : null,
+            last_event_at: run.lastEventAt ?? null,
+            last_event_type: run.lastEventType ?? null,
+            heartbeat_at: run.heartbeatAt ?? null,
+            progress_counter: run.progressCounter ?? 0,
+            command_count: run.commandCount ?? 0,
+            file_change_count: run.fileChangeCount ?? 0,
+            last_agent_message_preview: run.lastAgentMessagePreview ?? null,
+            cancel_requested_at: run.cancelRequestedAt ?? null,
+            cancel_request_source_event_id: run.cancelRequestSourceEventId ?? null
+        };
+    }
+    toRunStatus(status, current) {
+        if (status === "running") {
+            return current === "leased" ? "sdk_starting" : current;
+        }
+        if (status === "patch_generated") {
+            return "sdk_streaming";
+        }
+        if (status === "validating") {
+            return "validating";
+        }
+        return current;
+    }
+    toRunHealth(runStatus, status) {
+        if (status === "running" || status === "patch_generated" || status === "validating") {
+            return runStatus === "sdk_starting" ? "waiting_start" : "healthy_running";
+        }
+        return "waiting_start";
+    }
+}
+//# sourceMappingURL=sqlite-task-store.js.map