stageflow 0.23.0 → 0.27.0

package/dist/runstore/sqlite/SqliteRunStore.js

@@ -1,189 +1,20 @@
 import Database from "better-sqlite3";
+import { existsSync, statSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import path from "node:path";
 import { projectRunDetail, projectRunSummary, orderStageSnapshots } from "../runProjection.js";
-import { normalizeCatalogPath } from "../normalizeCatalogPath.js";
+import { normalizeCatalogPath, normalizeProjectRoot } from "../normalizeCatalogPath.js";
 import { buildStageSnapshotFromStore } from "../stageSnapshot.js";
 import { parsePipelineDagSnapshot } from "../pipelineDagSnapshot.js";
 import { newRunId, runWorkspaceDir } from "../paths.js";
 import { attemptAgentDir, attemptArtifactsDir, stageDir, } from "../workspaceLayout.js";
 import { importDiskRunsIfEmpty } from "./migrateFromDisk.js";
-import { SCHEMA_SQL } from "./schema.js";
+import { applyPendingMigrations, assertSchemaVersion, } from "./migrations/index.js";
+import { StoreSchemaError } from "./storeSchemaError.js";
+import { applyStorePragmas } from "./applyStorePragmas.js";
+import { RunSubmissionExistsError } from "../submission.js";
+const EXECUTION_SELECT_COLS = `run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json, cost_usd, usage_json, auto_resume_count`;
 const ensuredStageDirs = new Set();
-const DEFAULT_SQLITE_BUSY_TIMEOUT_MS = 5000;
-function readSqliteBusyTimeoutMs() {
-    const raw = process.env.STAGEFLOW_SQLITE_BUSY_TIMEOUT_MS;
-    if (raw === undefined || raw.trim() === "") {
-        return DEFAULT_SQLITE_BUSY_TIMEOUT_MS;
-    }
-    const parsed = Number.parseInt(raw, 10);
-    if (!Number.isFinite(parsed) || parsed < 0) {
-        return DEFAULT_SQLITE_BUSY_TIMEOUT_MS;
-    }
-    return parsed;
-}
-function ensureCheckoutRootColumn(db) {
-    const cols = db.prepare(`PRAGMA table_info(runs)`).all();
-    if (!cols.some((c) => c.name === "checkout_root")) {
-        db.exec(`ALTER TABLE runs ADD COLUMN checkout_root TEXT`);
-    }
-}
-function ensureCiIdentityColumns(db) {
-    const cols = db.prepare(`PRAGMA table_info(runs)`).all();
-    const names = new Set(cols.map((c) => c.name));
-    for (const name of ["git_sha", "ci_pr_url", "ci_job_url"]) {
-        if (!names.has(name)) {
-            db.exec(`ALTER TABLE runs ADD COLUMN ${name} TEXT`);
-        }
-    }
-}
-function ensurePipelineDagColumn(db) {
-    const cols = db.prepare(`PRAGMA table_info(runs)`).all();
-    if (!cols.some((c) => c.name === "pipeline_dag_json")) {
-        db.exec(`ALTER TABLE runs ADD COLUMN pipeline_dag_json TEXT`);
-    }
-}
-function ensureRunLocatorColumns(db) {
-    const cols = db.prepare(`PRAGMA table_info(runs)`).all();
-    const names = new Set(cols.map((c) => c.name));
-    for (const name of ["pipeline_path", "task_path", "project_root"]) {
-        if (!names.has(name)) {
-            db.exec(`ALTER TABLE runs ADD COLUMN ${name} TEXT`);
-        }
-    }
-}
-function ensureStageExecutionsTable(db) {
-    db.exec(`
-CREATE TABLE IF NOT EXISTS stage_executions (
-  run_id TEXT NOT NULL,
-  stage_id TEXT NOT NULL,
-  attempt INTEGER NOT NULL,
-  status TEXT NOT NULL,
-  verification_outcome TEXT NOT NULL DEFAULT 'not_run',
-  started_at TEXT,
-  finished_at TEXT,
-  envelope_json TEXT,
-  PRIMARY KEY (run_id, stage_id, attempt),
-  FOREIGN KEY (run_id) REFERENCES runs(run_id)
-);
-CREATE INDEX IF NOT EXISTS idx_stage_executions_run_stage
-  ON stage_executions (run_id, stage_id, attempt);
-`);
-}
-function ensureStageExecutionVerificationOutcomeColumn(db) {
-    const cols = db
-        .prepare(`PRAGMA table_info(stage_executions)`)
-        .all();
-    if (!cols.some((c) => c.name === "verification_outcome")) {
-        db.exec(`ALTER TABLE stage_executions ADD COLUMN verification_outcome TEXT NOT NULL DEFAULT 'not_run'`);
-    }
-}
-function ensureStageExecutionCostColumns(db) {
-    const cols = db
-        .prepare(`PRAGMA table_info(stage_executions)`)
-        .all();
-    const names = new Set(cols.map((c) => c.name));
-    if (!names.has("cost_usd")) {
-        db.exec(`ALTER TABLE stage_executions ADD COLUMN cost_usd REAL`);
-    }
-    if (!names.has("usage_json")) {
-        db.exec(`ALTER TABLE stage_executions ADD COLUMN usage_json TEXT`);
-    }
-}
-function backfillVerificationOutcomes(db) {
-    db.exec(`
-UPDATE stage_executions
-SET verification_outcome = CASE
-  WHEN status = 'succeeded'
-    AND EXISTS (
-      SELECT 1 FROM verification_check_results AS check_result
-      WHERE check_result.run_id = stage_executions.run_id
-        AND check_result.stage_id = stage_executions.stage_id
-        AND check_result.attempt = stage_executions.attempt
-    )
-    AND NOT EXISTS (
-      SELECT 1 FROM verification_check_results AS check_result
-      WHERE check_result.run_id = stage_executions.run_id
-        AND check_result.stage_id = stage_executions.stage_id
-        AND check_result.attempt = stage_executions.attempt
-        AND check_result.status != 'passed'
-    )
-    THEN 'passed'
-  WHEN status = 'failed'
-    AND EXISTS (
-      SELECT 1 FROM verification_check_results AS check_result
-      WHERE check_result.run_id = stage_executions.run_id
-        AND check_result.stage_id = stage_executions.stage_id
-        AND check_result.attempt = stage_executions.attempt
-    )
-    THEN 'failed'
-  ELSE verification_outcome
-END
-WHERE verification_outcome = 'not_run';
-`);
-}
-function ensureStageEventsAttemptColumn(db) {
-    const cols = db
-        .prepare(`PRAGMA table_info(stage_events)`)
-        .all();
-    if (!cols.some((c) => c.name === "attempt")) {
-        db.exec(`ALTER TABLE stage_events ADD COLUMN attempt INTEGER NOT NULL DEFAULT 1`);
-        db.exec(`
-CREATE INDEX IF NOT EXISTS idx_stage_events_run_stage_attempt_at
-  ON stage_events (run_id, stage_id, attempt, at);
-`);
-    }
-}
-function ensureVerificationCheckResultsTable(db) {
-    db.exec(`
-CREATE TABLE IF NOT EXISTS verification_check_results (
-  run_id TEXT NOT NULL,
-  stage_id TEXT NOT NULL,
-  attempt INTEGER NOT NULL,
-  check_id TEXT NOT NULL,
-  check_type TEXT NOT NULL,
-  status TEXT NOT NULL,
-  started_at TEXT,
-  finished_at TEXT,
-  evidence_json TEXT,
-  PRIMARY KEY (run_id, stage_id, attempt, check_id),
-  FOREIGN KEY (run_id, stage_id, attempt)
-    REFERENCES stage_executions(run_id, stage_id, attempt)
-);
-CREATE INDEX IF NOT EXISTS idx_verification_check_results_execution
-  ON verification_check_results (run_id, stage_id, attempt, check_id);
-`);
-}
-function ensureFeedbackReplayStagePassEnvelopeColumn(db) {
-    const cols = db
-        .prepare(`PRAGMA table_info(feedback_replay_stage_passes)`)
-        .all();
-    if (cols.length === 0)
-        return;
-    if (!cols.some((c) => c.name === "emitted_envelope_json")) {
-        db.exec(`ALTER TABLE feedback_replay_stage_passes ADD COLUMN emitted_envelope_json TEXT`);
-    }
-}
-function ensureFeedbackReplayStagePassSessionOriginColumn(db) {
-    const cols = db
-        .prepare(`PRAGMA table_info(feedback_replay_stage_passes)`)
-        .all();
-    if (cols.length === 0)
-        return;
-    if (!cols.some((c) => c.name === "session_origin_attempt")) {
-        db.exec(`ALTER TABLE feedback_replay_stage_passes ADD COLUMN session_origin_attempt INTEGER`);
-    }
-}
-function ensureFeedbackLoopDeferredSendBackColumn(db) {
-    const cols = db
-        .prepare(`PRAGMA table_info(feedback_loops)`)
-        .all();
-    if (cols.length === 0)
-        return;
-    if (!cols.some((c) => c.name === "deferred_send_back_json")) {
-        db.exec(`ALTER TABLE feedback_loops ADD COLUMN deferred_send_back_json TEXT`);
-    }
-}
 function executionFromRow(row) {
     return {
         run_id: row.run_id,
@@ -197,7 +28,10 @@ function executionFromRow(row) {
             ? JSON.parse(row.envelope_json)
             : null,
         ...(row.cost_usd != null ? { cost_usd: row.cost_usd } : {}),
-        ...(row.usage_json != null ? { usage: JSON.parse(row.usage_json) } : {}),
+        ...(row.usage_json != null
+            ? { usage: JSON.parse(row.usage_json) }
+            : {}),
+        auto_resume_count: row.auto_resume_count ?? 0,
     };
 }
 function verificationCheckResultFromRow(row) {
@@ -293,38 +127,57 @@ export class SqliteRunStore {
     storeRoot;
     db;
     migratePromise;
-    constructor(storeRoot) {
+    constructor(storeRoot, options) {
         this.storeRoot = storeRoot;
+        const openerMode = options?.openerMode ??
+            (process.env.VITEST === "true" ? "migrate" : "assert");
         const dbPath = path.join(storeRoot, "state.db");
+        if (openerMode === "assert") {
+            if (!existsSync(dbPath)) {
+                throw new StoreSchemaError("store_schema_migration_required: database file is missing", "store_schema_migration_required");
+            }
+            this.db = new Database(dbPath);
+            applyStorePragmas(this.db);
+            assertSchemaVersion(this.db);
+            this.migratePromise = Promise.resolve();
+            return;
+        }
         this.db = new Database(dbPath);
-        this.db.pragma("journal_mode = WAL");
-        this.db.pragma(`busy_timeout = ${readSqliteBusyTimeoutMs()}`);
-        this.db.exec(SCHEMA_SQL);
-        ensureCheckoutRootColumn(this.db);
-        ensureCiIdentityColumns(this.db);
-        ensurePipelineDagColumn(this.db);
-        ensureRunLocatorColumns(this.db);
-        ensureStageExecutionsTable(this.db);
-        ensureStageExecutionVerificationOutcomeColumn(this.db);
-        ensureStageExecutionCostColumns(this.db);
-        ensureStageEventsAttemptColumn(this.db);
-        ensureVerificationCheckResultsTable(this.db);
-        ensureFeedbackReplayStagePassEnvelopeColumn(this.db);
-        ensureFeedbackReplayStagePassSessionOriginColumn(this.db);
-        ensureFeedbackLoopDeferredSendBackColumn(this.db);
-        backfillVerificationOutcomes(this.db);
+        applyStorePragmas(this.db);
+        applyPendingMigrations(this.db);
         this.migratePromise = importDiskRunsIfEmpty(this.db, storeRoot).then(() => undefined);
     }
     /** Await one-shot disk import before catalog reads (create paths also wait). */
     async ready() {
         await this.migratePromise;
     }
+    async close() {
+        await this.ready();
+        this.db.pragma("wal_checkpoint(TRUNCATE)");
+        this.db.close();
+    }
+    async snapshotInto(destPath) {
+        await this.ready();
+        const userVersion = this.db.pragma("user_version", {
+            simple: true,
+        });
+        const escaped = destPath.replace(/'/g, "''");
+        this.db.exec(`VACUUM INTO '${escaped}'`);
+        return { userVersion };
+    }
+    /**
+     * The connection this store owns, for the one caller allowed to share it: the composition root
+     * wiring the A2A tables into the same `state.db` file. Not part of the `RunStore` interface.
+     */
+    get connection() {
+        return this.db;
+    }
     getWorkspaceDir(runId) {
         return runWorkspaceDir(this.storeRoot, runId);
     }
     async createRun(input) {
         await this.ready();
-        const runId = newRunId();
+        const runId = input.runId ?? newRunId();
         const workspaceDir = this.getWorkspaceDir(runId);
         await mkdir(path.join(workspaceDir, "stages"), { recursive: true });
         const now = new Date().toISOString();
@@ -337,45 +190,265 @@ export class SqliteRunStore {
         const projectRoot = input.projectRoot
             ? normalizeCatalogPath(input.projectRoot)
             : null;
-        this.db
-            .prepare(`INSERT INTO runs
-          (run_id, pipeline_id, task_id, task_yaml, status, created_at, updated_at, checkout_root, pipeline_dag_json, git_sha, ci_pr_url, ci_job_url, pipeline_path, task_path, project_root)
+        const pipelineBody = input.pipelineBody ??
+            (input.inlinePipeline !== undefined
+                ? JSON.stringify(input.inlinePipeline)
+                : null);
+        const pipelineSource = input.pipelineSource ??
+            (pipelineBody != null && pipelinePath == null ? "inline" : null);
+        this.db.transaction(() => {
+            if (input.submission) {
+                const existing = this.readSubmission(input.submission.key);
+                if (existing)
+                    throw new RunSubmissionExistsError(existing);
+            }
+            this.db
+                .prepare(`INSERT INTO runs
+          (run_id, pipeline_id, task_id, task_yaml, status, created_at, updated_at, checkout_root, pipeline_dag_json, git_sha, ci_pr_url, ci_job_url, pipeline_path, task_path, project_root, repository, ref, resolved_sha, run_branch, git_author_name, git_author_email, pipeline_source, pipeline_body, caller_id, run_manifest, skip_gates)
          VALUES
-          (@run_id, @pipeline_id, @task_id, @task_yaml, @status, @created_at, @updated_at, @checkout_root, @pipeline_dag_json, @git_sha, @ci_pr_url, @ci_job_url, @pipeline_path, @task_path, @project_root)`)
+          (@run_id, @pipeline_id, @task_id, @task_yaml, @status, @created_at, @updated_at, @checkout_root, @pipeline_dag_json, @git_sha, @ci_pr_url, @ci_job_url, @pipeline_path, @task_path, @project_root, @repository, @ref, @resolved_sha, @run_branch, @git_author_name, @git_author_email, @pipeline_source, @pipeline_body, @caller_id, @run_manifest, @skip_gates)`)
+                .run({
+                run_id: runId,
+                pipeline_id: input.pipelineId,
+                task_id: input.taskId ?? null,
+                task_yaml: input.taskYaml,
+                status: input.status ?? "running",
+                created_at: now,
+                updated_at: now,
+                checkout_root: input.checkoutRoot ?? null,
+                pipeline_dag_json: input.pipelineDag
+                    ? JSON.stringify(input.pipelineDag)
+                    : null,
+                git_sha: input.gitSha ?? null,
+                ci_pr_url: input.ciPrUrl ?? null,
+                ci_job_url: input.ciJobUrl ?? null,
+                pipeline_path: pipelinePath,
+                task_path: taskPath,
+                project_root: projectRoot,
+                repository: input.repository ?? null,
+                ref: input.ref ?? null,
+                resolved_sha: input.resolvedSha ?? null,
+                run_branch: input.runBranch ?? null,
+                git_author_name: input.gitAuthorName ?? null,
+                git_author_email: input.gitAuthorEmail ?? null,
+                pipeline_source: pipelineSource,
+                pipeline_body: pipelineBody,
+                caller_id: input.callerId ?? null,
+                run_manifest: input.runManifest !== undefined
+                    ? JSON.stringify(input.runManifest)
+                    : null,
+                skip_gates: input.skipGates === undefined ? null : input.skipGates ? 1 : 0,
+            });
+            if (input.submission) {
+                this.db.prepare("INSERT INTO run_submissions (submission_key, request_hash, run_id) VALUES (?, ?, ?)")
+                    .run(input.submission.key, input.submission.requestHash, runId);
+            }
+        })();
+        return { runId, workspaceDir };
+    }
+    readSubmission(key) {
+        const row = this.db.prepare("SELECT submission_key AS key, request_hash AS requestHash, run_id AS runId FROM run_submissions WHERE submission_key = ?")
+            .get(key);
+        return row ?? null;
+    }
+    async getRunBySubmission(key) {
+        await this.ready();
+        return this.readSubmission(key);
+    }
+    async updateRunStatus(runId, status) {
+        await this.ready();
+        const now = new Date().toISOString();
+        const isTerminal = status === "succeeded" || status === "failed" || status === "cancelled";
+        const result = isTerminal
+            ? this.db
+                .prepare(`UPDATE runs SET status = @status, updated_at = @updated_at,
+              finished_at = COALESCE(finished_at, @finished_at)
+             WHERE run_id = @run_id`)
+                .run({
+                run_id: runId,
+                status,
+                updated_at: now,
+                finished_at: now,
+            })
+            : this.db
+                .prepare(`UPDATE runs SET status = @status, updated_at = @updated_at WHERE run_id = @run_id`)
+                .run({
+                run_id: runId,
+                status,
+                updated_at: now,
+            });
+        if (result.changes === 0) {
+            throw new Error(`Run not found: ${runId}`);
+        }
+    }
+    async tryUpdateRunStatus(runId, status, expectedStatus) {
+        await this.ready();
+        const now = new Date().toISOString();
+        const isTerminal = status === "succeeded" || status === "failed" || status === "cancelled";
+        const result = isTerminal
+            ? this.db
+                .prepare(`UPDATE runs SET status = @status, updated_at = @updated_at,
+              finished_at = COALESCE(finished_at, @finished_at)
+             WHERE run_id = @run_id AND status = @expected_status`)
+                .run({
+                run_id: runId,
+                status,
+                expected_status: expectedStatus,
+                updated_at: now,
+                finished_at: now,
+            })
+            : this.db
+                .prepare(`UPDATE runs SET status = @status, updated_at = @updated_at
+             WHERE run_id = @run_id AND status = @expected_status`)
+                .run({
+                run_id: runId,
+                status,
+                expected_status: expectedStatus,
+                updated_at: now,
+            });
+        if (result.changes > 0)
+            return true;
+        const exists = this.db
+            .prepare(`SELECT 1 AS ok FROM runs WHERE run_id = ?`)
+            .get(runId);
+        if (exists === undefined) {
+            throw new Error(`Run not found: ${runId}`);
+        }
+        return false;
+    }
+    async patchRunWorkspaceBinding(runId, patch) {
+        await this.ready();
+        const sets = ["updated_at = @updated_at"];
+        const params = {
+            run_id: runId,
+            updated_at: new Date().toISOString(),
+        };
+        if (patch.checkoutRoot !== undefined) {
+            sets.push("checkout_root = @checkout_root");
+            params.checkout_root = patch.checkoutRoot;
+        }
+        if (patch.repository !== undefined) {
+            sets.push("repository = @repository");
+            params.repository = patch.repository;
+        }
+        if (patch.ref !== undefined) {
+            sets.push("ref = @ref");
+            params.ref = patch.ref;
+        }
+        if (patch.resolvedSha !== undefined) {
+            sets.push("resolved_sha = @resolved_sha");
+            params.resolved_sha = patch.resolvedSha;
+        }
+        if (patch.runBranch !== undefined) {
+            sets.push("run_branch = @run_branch");
+            params.run_branch = patch.runBranch;
+        }
+        if (sets.length === 1) {
+            return;
+        }
+        const result = this.db
+            .prepare(`UPDATE runs SET ${sets.join(", ")} WHERE run_id = @run_id`)
+            .run(params);
+        if (result.changes === 0) {
+            throw new Error(`Run not found: ${runId}`);
+        }
+    }
+    async appendConfigOrigins(runId, origins) {
+        await this.ready();
+        if (origins.length === 0)
+            return;
+        const row = this.getRunRow(runId);
+        const existing = row.config_origins_json
+            ? JSON.parse(row.config_origins_json)
+            : [];
+        const keyOf = (o) => `${o.name}\0${o.origin}\0${o.path ?? ""}`;
+        const seen = new Set(existing.map(keyOf));
+        const merged = [...existing];
+        for (const origin of origins) {
+            const key = keyOf(origin);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            merged.push(origin);
+        }
+        if (merged.length === existing.length)
+            return;
+        const result = this.db
+            .prepare(`UPDATE runs SET config_origins_json = @config_origins_json, updated_at = @updated_at WHERE run_id = @run_id`)
             .run({
             run_id: runId,
-            pipeline_id: input.pipelineId,
-            task_id: input.taskId ?? null,
-            task_yaml: input.taskYaml,
-            status: "running",
-            created_at: now,
-            updated_at: now,
-            checkout_root: input.checkoutRoot ?? null,
-            pipeline_dag_json: input.pipelineDag
-                ? JSON.stringify(input.pipelineDag)
-                : null,
-            git_sha: input.gitSha ?? null,
-            ci_pr_url: input.ciPrUrl ?? null,
-            ci_job_url: input.ciJobUrl ?? null,
-            pipeline_path: pipelinePath,
-            task_path: taskPath,
-            project_root: projectRoot,
+            config_origins_json: JSON.stringify(merged),
+            updated_at: new Date().toISOString(),
         });
-        return { runId, workspaceDir };
+        if (result.changes === 0) {
+            throw new Error(`Run not found: ${runId}`);
+        }
     }
-    async updateRunStatus(runId, status) {
+    async setCancelReason(runId, reason) {
         await this.ready();
         const result = this.db
-            .prepare(`UPDATE runs SET status = @status, updated_at = @updated_at WHERE run_id = @run_id`)
+            .prepare(`UPDATE runs SET cancel_reason = @cancel_reason, updated_at = @updated_at WHERE run_id = @run_id`)
             .run({
             run_id: runId,
-            status,
+            cancel_reason: reason,
             updated_at: new Date().toISOString(),
         });
         if (result.changes === 0) {
             throw new Error(`Run not found: ${runId}`);
         }
     }
+    async setRunDiskUsage(runId, diskBytes, measuredAt) {
+        await this.ready();
+        const result = this.db
+            .prepare(`UPDATE runs SET disk_bytes = @disk_bytes, disk_measured_at = @disk_measured_at
+         WHERE run_id = @run_id`)
+            .run({
+            run_id: runId,
+            disk_bytes: diskBytes,
+            disk_measured_at: measuredAt,
+        });
+        if (result.changes === 0) {
+            throw new Error(`Run not found: ${runId}`);
+        }
+    }
+    async setSlimmedAt(runId, slimmedAt) {
+        await this.ready();
+        const result = this.db
+            .prepare(`UPDATE runs SET slimmed_at = @slimmed_at WHERE run_id = @run_id`)
+            .run({
+            run_id: runId,
+            slimmed_at: slimmedAt,
+        });
+        if (result.changes === 0) {
+            throw new Error(`Run not found: ${runId}`);
+        }
+    }
+    async deleteRun(runId) {
+        await this.ready();
+        const deleteAll = this.db.transaction(() => {
+            const exists = this.db
+                .prepare(`SELECT 1 AS ok FROM runs WHERE run_id = ?`)
+                .get(runId);
+            if (exists === undefined) {
+                throw new Error(`Run not found: ${runId}`);
+            }
+            this.db.prepare(`DELETE FROM stage_events WHERE run_id = ?`).run(runId);
+            this.db
+                .prepare(`DELETE FROM verification_check_results WHERE run_id = ?`)
+                .run(runId);
+            this.db.prepare(`DELETE FROM stage_executions WHERE run_id = ?`).run(runId);
+            this.db
+                .prepare(`DELETE FROM feedback_replay_stage_passes WHERE run_id = ?`)
+                .run(runId);
+            this.db.prepare(`DELETE FROM fork_generations WHERE run_id = ?`).run(runId);
+            this.db.prepare(`DELETE FROM feedback_replays WHERE run_id = ?`).run(runId);
+            this.db.prepare(`DELETE FROM feedback_loops WHERE run_id = ?`).run(runId);
+            this.db.prepare(`DELETE FROM stages WHERE run_id = ?`).run(runId);
+            this.db.prepare(`DELETE FROM run_submissions WHERE run_id = ?`).run(runId);
+            this.db.prepare(`DELETE FROM runs WHERE run_id = ?`).run(runId);
+        });
+        deleteAll();
+    }
     async updatePipelineDag(runId, dag) {
         await this.ready();
         const result = this.db
@@ -397,6 +470,25 @@ export class SqliteRunStore {
         await this.ready();
         return this.getRunRow(runId).task_yaml;
     }
+    async readPipelineBody(runId) {
+        await this.ready();
+        return this.getRunRow(runId).pipeline_body;
+    }
+    async updateRunManifest(runId, manifest) {
+        await this.ready();
+        const result = this.db
+            .prepare(`UPDATE runs SET run_manifest = @run_manifest, updated_at = @updated_at WHERE run_id = @run_id`)
+            .run({
+            run_id: runId,
+            run_manifest: manifest === null || manifest === undefined
+                ? null
+                : JSON.stringify(manifest),
+            updated_at: new Date().toISOString(),
+        });
+        if (result.changes === 0) {
+            throw new Error(`Run not found: ${runId}`);
+        }
+    }
     async ensureStageWorkspace(runId, stageId) {
         await this.ready();
         this.getRunRow(runId);
@@ -447,7 +539,7 @@ export class SqliteRunStore {
                 verification_outcome: "not_run",
             });
             const row = this.db
-                .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json, cost_usd, usage_json
+                .prepare(`SELECT ${EXECUTION_SELECT_COLS}
            FROM stage_executions
            WHERE run_id = ? AND stage_id = ? AND attempt = ?`)
                 .get(runId, stageId, attempt);
@@ -457,7 +549,7 @@ export class SqliteRunStore {
     async listStageExecutions(runId, stageId) {
         await this.ready();
         const rows = this.db
-            .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json, cost_usd, usage_json
+            .prepare(`SELECT ${EXECUTION_SELECT_COLS}
          FROM stage_executions
          WHERE run_id = ? AND stage_id = ?
          ORDER BY attempt ASC`)
@@ -467,7 +559,7 @@ export class SqliteRunStore {
     async getLatestStageExecution(runId, stageId) {
         await this.ready();
         const row = this.db
-            .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json, cost_usd, usage_json
+            .prepare(`SELECT ${EXECUTION_SELECT_COLS}
          FROM stage_executions
          WHERE run_id = ? AND stage_id = ?
          ORDER BY attempt DESC
@@ -486,7 +578,7 @@ export class SqliteRunStore {
     async getStageExecution(runId, stageId, attempt) {
         await this.ready();
         const row = this.db
-            .prepare(`SELECT run_id, stage_id, attempt, status, verification_outcome, started_at, finished_at, envelope_json, cost_usd, usage_json
+            .prepare(`SELECT ${EXECUTION_SELECT_COLS}
          FROM stage_executions
          WHERE run_id = ? AND stage_id = ? AND attempt = ?`)
             .get(runId, stageId, attempt);
@@ -495,6 +587,21 @@ export class SqliteRunStore {
         }
         return executionFromRow(row);
     }
+    async listInterruptedStageExecutions() {
+        await this.ready();
+        const rows = this.db
+            .prepare(`SELECT ${EXECUTION_SELECT_COLS}
+         FROM stage_executions e
+         WHERE e.status = 'interrupted'
+           AND e.attempt = (
+             SELECT MAX(e2.attempt)
+             FROM stage_executions e2
+             WHERE e2.run_id = e.run_id AND e2.stage_id = e.stage_id
+           )
+         ORDER BY e.run_id ASC, e.stage_id ASC, e.attempt ASC`)
+            .all();
+        return rows.map(executionFromRow);
+    }
     async updateStageExecution(runId, stageId, attempt, patch) {
         await this.ready();
         const sets = [];
@@ -532,6 +639,10 @@ export class SqliteRunStore {
             sets.push("usage_json = @usage_json");
             params.usage_json = JSON.stringify(patch.usage);
         }
+        if (patch.auto_resume_count !== undefined) {
+            sets.push("auto_resume_count = @auto_resume_count");
+            params.auto_resume_count = patch.auto_resume_count;
+        }
         if (sets.length === 0)
             return;
         const result = this.db
@@ -708,9 +819,13 @@ export class SqliteRunStore {
             clauses.push("(pipeline_id = ? OR pipeline_path = ? OR pipeline_path = ?)");
             params.push(pipeline, pipeline, normalized);
         }
+        if (filter?.caller_id !== undefined) {
+            clauses.push("caller_id = ?");
+            params.push(filter.caller_id);
+        }
         const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
         const rows = this.db
-            .prepare(`SELECT run_id, pipeline_id, task_id, task_yaml, status, created_at, updated_at, checkout_root, pipeline_dag_json, git_sha, ci_pr_url, ci_job_url, pipeline_path, task_path, project_root
+            .prepare(`SELECT run_id, pipeline_id, task_id, task_yaml, status, created_at, updated_at, checkout_root, pipeline_dag_json, git_sha, ci_pr_url, ci_job_url, pipeline_path, task_path, project_root, repository, ref, resolved_sha, run_branch, git_author_name, git_author_email, cancel_reason, finished_at, slimmed_at, disk_bytes, disk_measured_at, config_origins_json, pipeline_source, pipeline_body, caller_id, run_manifest, skip_gates
          FROM runs ${where} ORDER BY created_at DESC`)
             .all(...params);
         const summaries = [];
@@ -724,10 +839,34 @@ export class SqliteRunStore {
         }
         return summaries;
     }
-    async listProjectRoots() {
+    async ensureProject(absPath) {
+        await this.ready();
+        const resolved = path.resolve(absPath);
+        let st;
+        try {
+            st = statSync(resolved);
+        }
+        catch {
+            throw new Error(`project_root does not exist: ${resolved}`);
+        }
+        if (!st.isDirectory()) {
+            throw new Error(`project_root is not a directory: ${resolved}`);
+        }
+        const normalized = normalizeProjectRoot(absPath);
+        if (normalized === path.parse(normalized).root) {
+            throw new Error(`project_root must not be filesystem root: ${normalized}`);
+        }
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`INSERT INTO projects (project_root, created_at) VALUES (?, ?)
+         ON CONFLICT(project_root) DO NOTHING`)
+            .run(normalized, now);
+        return normalized;
+    }
+    async listRegisteredProjects() {
         await this.ready();
         const rows = this.db
-            .prepare(`SELECT DISTINCT project_root FROM runs WHERE project_root IS NOT NULL AND project_root != ''`)
+            .prepare(`SELECT project_root FROM projects ORDER BY project_root`)
             .all();
         return rows.map((row) => row.project_root);
     }
@@ -1138,12 +1277,47 @@ export class SqliteRunStore {
             ...(row.pipeline_path != null ? { pipeline_path: row.pipeline_path } : {}),
             ...(row.task_path != null ? { task_path: row.task_path } : {}),
             ...(row.project_root != null ? { project_root: row.project_root } : {}),
+            ...(row.repository != null ? { repository: row.repository } : {}),
+            ...(row.ref != null ? { ref: row.ref } : {}),
+            ...(row.resolved_sha != null ? { resolved_sha: row.resolved_sha } : {}),
+            ...(row.run_branch != null ? { run_branch: row.run_branch } : {}),
+            ...(row.git_author_name != null
+                ? { git_author_name: row.git_author_name }
+                : {}),
+            ...(row.git_author_email != null
+                ? { git_author_email: row.git_author_email }
+                : {}),
+            ...(row.cancel_reason != null ? { cancel_reason: row.cancel_reason } : {}),
+            ...(row.finished_at != null ? { finished_at: row.finished_at } : {}),
+            ...(row.slimmed_at != null ? { slimmed_at: row.slimmed_at } : {}),
+            ...(row.disk_bytes != null ? { disk_bytes: row.disk_bytes } : {}),
+            ...(row.disk_measured_at != null
+                ? { disk_measured_at: row.disk_measured_at }
+                : {}),
+            ...(row.config_origins_json
+                ? {
+                    config_origins: JSON.parse(row.config_origins_json),
+                }
+                : {}),
+            ...(row.pipeline_source === "inline" || row.pipeline_source === "path"
+                ? { pipeline_source: row.pipeline_source }
+                : {}),
+            ...(row.caller_id != null ? { caller_id: row.caller_id } : {}),
+            ...(row.run_manifest
+                ? { run_manifest: JSON.parse(row.run_manifest) }
+                : {}),
+            ...(row.skip_gates != null ? { skip_gates: row.skip_gates !== 0 } : {}),
             ...(pipeline_dag ? { pipeline_dag } : {}),
+            ...(row.pipeline_body
+                ? {
+                    inline_pipeline: JSON.parse(row.pipeline_body),
+                }
+                : {}),
         };
     }
     getRunRow(runId) {
         const row = this.db
-            .prepare(`SELECT run_id, pipeline_id, task_id, task_yaml, status, created_at, updated_at, checkout_root, pipeline_dag_json, git_sha, ci_pr_url, ci_job_url, pipeline_path, task_path, project_root
+            .prepare(`SELECT run_id, pipeline_id, task_id, task_yaml, status, created_at, updated_at, checkout_root, pipeline_dag_json, git_sha, ci_pr_url, ci_job_url, pipeline_path, task_path, project_root, repository, ref, resolved_sha, run_branch, git_author_name, git_author_email, cancel_reason, finished_at, slimmed_at, disk_bytes, disk_measured_at, config_origins_json, pipeline_source, pipeline_body, caller_id, run_manifest, skip_gates
          FROM runs WHERE run_id = ?`)
             .get(runId);
         if (!row)