@straiffi/archon 1.7.2 → 1.7.4

package/dist/server/db.js

@@ -1,6 +1,7 @@
 import Database from 'better-sqlite3';
 import { createHash } from 'crypto';
 import { ensureParentDirectory, resolveArchonDbPath } from './lib/runtimePaths.js';
+import { TRANSCRIPT_RUN_TEXT_LIMIT_BYTES, truncateUtf8 } from './lib/transcriptRuns.js';
 const dbPath = ensureParentDirectory(resolveArchonDbPath());
 const db = new Database(dbPath);
 db.pragma('foreign_keys = ON');
@@ -11,6 +12,7 @@ db.exec(`
     description  TEXT,
     state        TEXT NOT NULL DEFAULT 'plan',
     agent_status TEXT,
+    agent_operation TEXT,
     parked_at    DATETIME,
     auto_park_dismissed_at DATETIME,
     branch       TEXT,
@@ -89,6 +91,7 @@ const ensureColumn = (table, column, type) => {
     }
 };
 ensureColumn('tickets', 'model', 'TEXT');
+ensureColumn('tickets', 'agent_operation', 'TEXT');
 ensureColumn('tickets', 'variant', 'TEXT');
 ensureColumn('tickets', 'skills_json', 'TEXT');
 ensureColumn('tickets', 'session_id', 'TEXT');
@@ -1241,6 +1244,7 @@ ensureColumn('review_runs', 'workspace_signature', 'TEXT');
 db.exec(`
   CREATE TABLE IF NOT EXISTS agent_runs (
     id                 TEXT PRIMARY KEY,
+    execution_run_id   TEXT,
     parent_type        TEXT NOT NULL,
     parent_id          TEXT NOT NULL,
     run_index          INTEGER NOT NULL,
@@ -1250,12 +1254,451 @@ db.exec(`
     agent_log          TEXT,
     streaming_response TEXT,
     response_text      TEXT,
+    failure_message    TEXT,
     session_id         TEXT,
+    completed_at       DATETIME,
     created_at         DATETIME DEFAULT CURRENT_TIMESTAMP,
-    updated_at         DATETIME DEFAULT CURRENT_TIMESTAMP
+    updated_at         DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (execution_run_id) REFERENCES execution_runs(id) ON DELETE CASCADE,
+    CHECK (failure_message IS NULL OR length(CAST(failure_message AS BLOB)) <= 16384)
   )
 `);
+const executionRunsTableSql = `
+  CREATE TABLE execution_runs (
+    id                 TEXT PRIMARY KEY,
+    project_id         TEXT NOT NULL,
+    kind               TEXT NOT NULL,
+    status             TEXT NOT NULL DEFAULT 'queued',
+    domain_status      TEXT,
+    source_kind        TEXT,
+    source_id          TEXT,
+    source_label       TEXT,
+    source_url         TEXT,
+    correlation_id     TEXT NOT NULL,
+    initiated_by       TEXT NOT NULL DEFAULT 'user',
+    metadata_schema_version INTEGER NOT NULL DEFAULT 1,
+    metadata_json      TEXT,
+    parent_run_id      TEXT,
+    retry_of_run_id    TEXT,
+    attempt            INTEGER NOT NULL DEFAULT 1,
+    failure_code       TEXT,
+    failure_message    TEXT,
+    failure_details_json TEXT,
+    created_at         DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    started_at         DATETIME,
+    completed_at       DATETIME,
+    updated_at         DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE (id, project_id),
+    FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+    FOREIGN KEY (parent_run_id) REFERENCES execution_runs(id) ON DELETE RESTRICT,
+    FOREIGN KEY (retry_of_run_id) REFERENCES execution_runs(id) ON DELETE RESTRICT,
+    CHECK (length(kind) BETWEEN 1 AND 100),
+    CHECK (status IN ('queued', 'running', 'waiting', 'completed', 'failed', 'cancelled', 'interrupted')),
+    CHECK (length(correlation_id) >= 1),
+    CHECK (initiated_by IN ('user', 'automation', 'recovery', 'system')),
+    CHECK (metadata_schema_version >= 1),
+    CHECK (metadata_json IS NULL OR length(metadata_json) <= 16384),
+    CHECK (attempt >= 1)
+  )
+`;
+const lifecycleEventsTableSql = `
+  CREATE TABLE lifecycle_events (
+    id                    TEXT PRIMARY KEY,
+    project_id            TEXT NOT NULL,
+    execution_run_id      TEXT NOT NULL,
+    correlation_id        TEXT NOT NULL,
+    sequence              INTEGER NOT NULL,
+    event_type            TEXT NOT NULL,
+    from_status           TEXT,
+    to_status             TEXT,
+    domain_status         TEXT,
+    message               TEXT,
+    metadata_schema_version INTEGER NOT NULL DEFAULT 1,
+    metadata_json         TEXT,
+    created_at            DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE (execution_run_id, sequence),
+    FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+    FOREIGN KEY (execution_run_id, project_id) REFERENCES execution_runs(id, project_id) ON DELETE CASCADE,
+    CHECK (length(correlation_id) >= 1),
+    CHECK (sequence >= 1),
+    CHECK (from_status IS NULL OR from_status IN ('queued', 'running', 'waiting', 'completed', 'failed', 'cancelled', 'interrupted')),
+    CHECK (to_status IS NULL OR to_status IN ('queued', 'running', 'waiting', 'completed', 'failed', 'cancelled', 'interrupted')),
+    CHECK (metadata_schema_version >= 1)
+  )
+`;
+db.exec(executionRunsTableSql.replace('CREATE TABLE execution_runs', 'CREATE TABLE IF NOT EXISTS execution_runs'));
+db.exec(lifecycleEventsTableSql.replace('CREATE TABLE lifecycle_events', 'CREATE TABLE IF NOT EXISTS lifecycle_events'));
+const migrateExecutionLifecycleSchema = () => {
+    const runColumns = db.prepare('PRAGMA table_info(execution_runs)').all();
+    const eventColumns = db.prepare('PRAGMA table_info(lifecycle_events)').all();
+    const runTableSql = db.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'execution_runs'").get()?.sql ?? '';
+    const correlationColumn = runColumns.find(column => column.name === 'correlation_id');
+    const needsMigration = !runColumns.some(column => column.name === 'initiated_by')
+        || !runColumns.some(column => column.name === 'metadata_json')
+        || correlationColumn?.notnull !== 1
+        || !eventColumns.some(column => column.name === 'sequence')
+        || !eventColumns.some(column => column.name === 'correlation_id')
+        || /CHECK\s*\(\s*kind\s+IN/i.test(runTableSql)
+        || /length\s*\(\s*correlation_id\s*\)\s+BETWEEN/i.test(runTableSql);
+    if (!needsMigration) {
+        return;
+    }
+    const sourceLabel = runColumns.some(column => column.name === 'source_label') ? 'source_label' : 'NULL';
+    const legacyCorrelationId = runColumns.some(column => column.name === 'correlation_id')
+        ? 'CASE WHEN correlation_id IS NOT NULL AND length(trim(correlation_id)) > 0 THEN correlation_id ELSE NULL END'
+        : 'NULL';
+    db.exec('PRAGMA foreign_keys = OFF');
+    try {
+        db.exec('BEGIN');
+        db.exec(executionRunsTableSql.replace('execution_runs', 'execution_runs_v2'));
+        db.exec(lifecycleEventsTableSql.replace('lifecycle_events', 'lifecycle_events_v2').replaceAll('execution_runs', 'execution_runs_v2'));
+        db.exec(`
+      CREATE TEMP TABLE execution_run_correlations (
+        id TEXT PRIMARY KEY,
+        correlation_id TEXT
+      )
+    `);
+        db.exec(`
+      INSERT INTO execution_run_correlations (id, correlation_id)
+      SELECT
+        id,
+        COALESCE(
+          ${legacyCorrelationId},
+          CASE WHEN parent_run_id IS NULL THEN CASE WHEN length(id) > 0 THEN id ELSE 'legacy-run' END END
+        )
+      FROM execution_runs
+    `);
+        const inheritCorrelation = db.prepare(`
+      UPDATE execution_run_correlations
+      SET correlation_id = (
+        SELECT parent.correlation_id
+        FROM execution_runs child
+        JOIN execution_run_correlations parent ON parent.id = child.parent_run_id
+        WHERE child.id = execution_run_correlations.id
+      )
+      WHERE correlation_id IS NULL
+        AND EXISTS (
+          SELECT 1
+          FROM execution_runs child
+          JOIN execution_run_correlations parent ON parent.id = child.parent_run_id
+          WHERE child.id = execution_run_correlations.id
+            AND parent.correlation_id IS NOT NULL
+        )
+    `);
+        while (inheritCorrelation.run().changes > 0) {
+            // Resolve one lineage level at a time so descendants inherit the migrated root correlation.
+        }
+        db.exec(`
+      UPDATE execution_run_correlations
+      SET correlation_id = CASE WHEN length(id) > 0 THEN id ELSE 'legacy-run' END
+      WHERE correlation_id IS NULL
+    `);
+        db.exec(`
+      INSERT INTO execution_runs_v2 (
+        id, project_id, kind, status, domain_status, source_kind, source_id, source_label,
+        source_url, correlation_id, initiated_by, metadata_schema_version, metadata_json,
+        parent_run_id, retry_of_run_id, attempt, failure_code, failure_message,
+        failure_details_json, created_at, started_at, completed_at, updated_at
+      )
+      SELECT
+        id, project_id, kind, status, domain_status, source_kind, source_id, ${sourceLabel},
+        source_url,
+        correlations.correlation_id,
+        'system', 1, NULL, parent_run_id, retry_of_run_id, attempt, failure_code,
+        failure_message, failure_details_json, created_at, started_at, completed_at, updated_at
+      FROM execution_runs
+      JOIN execution_run_correlations correlations USING (id)
+    `);
+        db.exec(`
+      INSERT INTO lifecycle_events_v2 (
+        id, project_id, execution_run_id, correlation_id, sequence, event_type,
+        from_status, to_status, domain_status, message, metadata_schema_version,
+        metadata_json, created_at
+      )
+      SELECT
+        event.id,
+        event.project_id,
+        event.execution_run_id,
+        run.correlation_id,
+        1 + (
+          SELECT COUNT(*)
+          FROM lifecycle_events preceding
+          WHERE preceding.execution_run_id = event.execution_run_id
+            AND (
+              preceding.created_at < event.created_at
+              OR (preceding.created_at = event.created_at AND preceding.id < event.id)
+            )
+        ),
+        event.event_type,
+        event.from_status,
+        event.to_status,
+        event.domain_status,
+        event.message,
+        event.metadata_schema_version,
+        event.metadata_json,
+        event.created_at
+      FROM lifecycle_events event
+      JOIN execution_runs_v2 run
+        ON run.id = event.execution_run_id AND run.project_id = event.project_id
+    `);
+        db.exec('DROP TABLE lifecycle_events');
+        db.exec('DROP TABLE execution_runs');
+        db.exec('ALTER TABLE execution_runs_v2 RENAME TO execution_runs');
+        db.exec('ALTER TABLE lifecycle_events_v2 RENAME TO lifecycle_events');
+        db.exec('DROP TABLE execution_run_correlations');
+        const violations = db.prepare('PRAGMA foreign_key_check').all();
+        if (violations.some(violation => ['execution_runs', 'lifecycle_events', 'test_execution_details', 'github_actions_run_details'].includes(violation.table))) {
+            throw new Error('Execution lifecycle migration produced foreign key violations');
+        }
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+    finally {
+        db.exec('PRAGMA foreign_keys = ON');
+    }
+};
+migrateExecutionLifecycleSchema();
+const migrateAgentRunsSchema = () => {
+    const columns = db.prepare('PRAGMA table_info(agent_runs)').all();
+    const tableSql = db.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'agent_runs'").get()?.sql ?? '';
+    const needsMigration = !columns.some(column => column.name === 'execution_run_id')
+        || !columns.some(column => column.name === 'completed_at')
+        || !columns.some(column => column.name === 'failure_message')
+        || !/REFERENCES\s+execution_runs/i.test(tableSql)
+        || !/failure_message[\s\S]*16384/i.test(tableSql);
+    if (!needsMigration) {
+        return;
+    }
+    const executionRunId = columns.some(column => column.name === 'execution_run_id')
+        ? 'CASE WHEN execution_run_id IN (SELECT id FROM execution_runs) THEN execution_run_id ELSE NULL END'
+        : 'NULL';
+    const completedAt = columns.some(column => column.name === 'completed_at') ? 'completed_at' : 'NULL';
+    const failureMessage = columns.some(column => column.name === 'failure_message')
+        ? 'CASE WHEN failure_message IS NULL OR length(CAST(failure_message AS BLOB)) <= 16384 THEN failure_message ELSE NULL END'
+        : 'NULL';
+    db.exec('PRAGMA foreign_keys = OFF');
+    try {
+        db.exec('BEGIN');
+        db.exec(`
+      CREATE TABLE agent_runs_v2 (
+        id                 TEXT PRIMARY KEY,
+        execution_run_id   TEXT,
+        parent_type        TEXT NOT NULL,
+        parent_id          TEXT NOT NULL,
+        run_index          INTEGER NOT NULL,
+        label              TEXT NOT NULL,
+        role               TEXT NOT NULL,
+        agent_status       TEXT NOT NULL,
+        agent_log          TEXT,
+        streaming_response TEXT,
+        response_text      TEXT,
+        failure_message    TEXT,
+        session_id         TEXT,
+        completed_at       DATETIME,
+        created_at         DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at         DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (execution_run_id) REFERENCES execution_runs(id) ON DELETE CASCADE,
+        CHECK (failure_message IS NULL OR length(CAST(failure_message AS BLOB)) <= 16384)
+      )
+    `);
+        db.exec(`
+      INSERT INTO agent_runs_v2 (
+        id, execution_run_id, parent_type, parent_id, run_index, label, role,
+        agent_status, agent_log, streaming_response, response_text, failure_message,
+        session_id, completed_at, created_at, updated_at
+      )
+      SELECT
+        id, ${executionRunId}, parent_type, parent_id, run_index, label, role,
+        agent_status, agent_log, streaming_response, response_text, ${failureMessage},
+        session_id, ${completedAt}, created_at, updated_at
+      FROM agent_runs
+    `);
+        db.exec('DROP TABLE agent_runs');
+        db.exec('ALTER TABLE agent_runs_v2 RENAME TO agent_runs');
+        const violations = db.prepare('PRAGMA foreign_key_check').all();
+        if (violations.some(violation => violation.table === 'agent_runs' || violation.table === 'project_memory_selections')) {
+            throw new Error('Agent run migration produced foreign key violations');
+        }
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+    finally {
+        db.exec('PRAGMA foreign_keys = ON');
+    }
+};
+migrateAgentRunsSchema();
+const oversizedAgentRunRows = db.prepare(`
+  SELECT id, agent_log, streaming_response, response_text, failure_message
+  FROM agent_runs
+  WHERE length(CAST(agent_log AS BLOB)) > ?
+    OR length(CAST(streaming_response AS BLOB)) > ?
+    OR length(CAST(response_text AS BLOB)) > ?
+    OR length(CAST(failure_message AS BLOB)) > 16384
+`).all(TRANSCRIPT_RUN_TEXT_LIMIT_BYTES, TRANSCRIPT_RUN_TEXT_LIMIT_BYTES, TRANSCRIPT_RUN_TEXT_LIMIT_BYTES);
+const boundAgentRunEvidenceStatement = db.prepare(`
+  UPDATE agent_runs
+  SET agent_log = ?, streaming_response = ?, response_text = ?, failure_message = ?
+  WHERE id = ?
+`);
+const boundAgentRunEvidence = db.transaction(() => {
+    for (const row of oversizedAgentRunRows) {
+        boundAgentRunEvidenceStatement.run(truncateUtf8(row.agent_log).text, truncateUtf8(row.streaming_response).text, truncateUtf8(row.response_text).text, truncateUtf8(row.failure_message, 16384).text, row.id);
+    }
+});
+boundAgentRunEvidence();
 db.exec('CREATE INDEX IF NOT EXISTS idx_agent_runs_parent ON agent_runs(parent_type, parent_id)');
+db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_agent_runs_execution_run_index ON agent_runs(execution_run_id, run_index) WHERE execution_run_id IS NOT NULL');
+db.exec('CREATE INDEX IF NOT EXISTS idx_agent_runs_active_parent ON agent_runs(parent_type, parent_id, execution_run_id, agent_status, created_at DESC, id DESC)');
+db.exec(`
+  CREATE TABLE IF NOT EXISTS execution_run_links (
+    execution_run_id TEXT NOT NULL,
+    project_id       TEXT NOT NULL,
+    entity_type      TEXT NOT NULL,
+    entity_id        TEXT NOT NULL,
+    relationship     TEXT NOT NULL,
+    label_snapshot   TEXT,
+    url_snapshot     TEXT,
+    created_at       DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (execution_run_id, entity_type, entity_id, relationship),
+    FOREIGN KEY (execution_run_id, project_id) REFERENCES execution_runs(id, project_id) ON DELETE CASCADE,
+    CHECK (length(entity_type) BETWEEN 1 AND 100),
+    CHECK (length(entity_id) BETWEEN 1 AND 500),
+    CHECK (relationship IN ('primary', 'context', 'result', 'trigger')),
+    CHECK (label_snapshot IS NULL OR length(label_snapshot) <= 500),
+    CHECK (url_snapshot IS NULL OR length(url_snapshot) <= 2000)
+  )
+`);
+db.exec(`
+  INSERT OR IGNORE INTO execution_run_links (
+    execution_run_id, project_id, entity_type, entity_id, relationship,
+    label_snapshot, url_snapshot, created_at
+  )
+  SELECT
+    id, project_id, substr(source_kind, 1, 100), substr(source_id, 1, 500), 'primary',
+    CASE WHEN source_label IS NULL THEN NULL ELSE substr(source_label, 1, 500) END,
+    CASE WHEN source_url IS NULL THEN NULL ELSE substr(source_url, 1, 2000) END,
+    created_at
+  FROM execution_runs
+  WHERE source_kind IS NOT NULL AND length(trim(source_kind)) > 0
+    AND source_id IS NOT NULL AND length(trim(source_id)) > 0
+`);
+db.exec(`
+  CREATE TABLE IF NOT EXISTS test_execution_details (
+    execution_run_id  TEXT PRIMARY KEY,
+    command_id        TEXT,
+    command_name      TEXT,
+    command_runner    TEXT,
+    command_snapshot  TEXT,
+    active_command    TEXT,
+    target_kind       TEXT,
+    target_bundle_id  TEXT,
+    target_label      TEXT,
+    ticket_id         TEXT,
+    selection_json    TEXT,
+    summary_json      TEXT,
+    exit_code         INTEGER,
+    duration_ms       INTEGER,
+    output             TEXT NOT NULL DEFAULT '',
+    output_truncated   INTEGER NOT NULL DEFAULT 0,
+    output_retention_state TEXT NOT NULL DEFAULT 'retained',
+    output_expired_at  DATETIME,
+    output_byte_count  INTEGER,
+    FOREIGN KEY (execution_run_id) REFERENCES execution_runs(id) ON DELETE CASCADE
+  )
+`);
+db.exec(`
+  CREATE TRIGGER IF NOT EXISTS validate_test_execution_details_target_insert
+  BEFORE INSERT ON test_execution_details
+  WHEN NEW.target_kind IS NULL
+    OR NEW.target_kind NOT IN ('repo_root', 'bundle')
+    OR (NEW.target_kind = 'repo_root' AND NEW.target_bundle_id IS NOT NULL)
+    OR (NEW.target_kind = 'bundle' AND (NEW.target_bundle_id IS NULL OR length(trim(NEW.target_bundle_id)) = 0))
+  BEGIN
+    SELECT RAISE(ABORT, 'Invalid test execution target');
+  END
+`);
+db.exec(`
+  CREATE TRIGGER IF NOT EXISTS validate_test_execution_details_target_update
+  BEFORE UPDATE OF target_kind, target_bundle_id ON test_execution_details
+  WHEN NEW.target_kind IS NULL
+    OR NEW.target_kind NOT IN ('repo_root', 'bundle')
+    OR (NEW.target_kind = 'repo_root' AND NEW.target_bundle_id IS NOT NULL)
+    OR (NEW.target_kind = 'bundle' AND (NEW.target_bundle_id IS NULL OR length(trim(NEW.target_bundle_id)) = 0))
+  BEGIN
+    SELECT RAISE(ABORT, 'Invalid test execution target');
+  END
+`);
+ensureColumn('test_execution_details', 'command_snapshot', 'TEXT');
+ensureColumn('test_execution_details', 'active_command', 'TEXT');
+ensureColumn('test_execution_details', 'target_label', 'TEXT');
+ensureColumn('test_execution_details', 'output', "TEXT NOT NULL DEFAULT ''");
+ensureColumn('test_execution_details', 'output_truncated', 'INTEGER NOT NULL DEFAULT 0');
+ensureColumn('test_execution_details', 'output_retention_state', "TEXT NOT NULL DEFAULT 'retained'");
+ensureColumn('test_execution_details', 'output_expired_at', 'DATETIME');
+ensureColumn('test_execution_details', 'output_byte_count', 'INTEGER');
+db.prepare(`
+  UPDATE test_execution_details
+  SET output_byte_count = length(CAST(output AS BLOB))
+  WHERE output_byte_count IS NULL AND output_retention_state = 'retained'
+`).run();
+db.exec(`
+  CREATE TABLE IF NOT EXISTS github_actions_run_details (
+    execution_run_id  TEXT PRIMARY KEY,
+    workflow_id       INTEGER NOT NULL,
+    workflow_name     TEXT,
+    ref                TEXT,
+    input_names_json   TEXT,
+    input_fingerprint  TEXT,
+    resolution_attempts INTEGER NOT NULL DEFAULT 0,
+    provider_error_count INTEGER NOT NULL DEFAULT 0,
+    provider_run_id   INTEGER,
+    provider_status   TEXT,
+    conclusion        TEXT,
+    html_url          TEXT,
+    head_sha          TEXT,
+    head_branch       TEXT,
+    provider_created_at DATETIME,
+    provider_updated_at DATETIME,
+    provider_started_at DATETIME,
+    dispatched_at     DATETIME,
+    last_synced_at    DATETIME,
+    jobs_json         TEXT,
+    jobs_retention_state TEXT NOT NULL DEFAULT 'retained',
+    jobs_expired_at   DATETIME,
+    jobs_count        INTEGER,
+    FOREIGN KEY (execution_run_id) REFERENCES execution_runs(id) ON DELETE CASCADE
+  )
+`);
+ensureColumn('github_actions_run_details', 'ref', 'TEXT');
+ensureColumn('github_actions_run_details', 'input_names_json', 'TEXT');
+ensureColumn('github_actions_run_details', 'input_fingerprint', 'TEXT');
+ensureColumn('github_actions_run_details', 'resolution_attempts', 'INTEGER NOT NULL DEFAULT 0');
+ensureColumn('github_actions_run_details', 'provider_error_count', 'INTEGER NOT NULL DEFAULT 0');
+ensureColumn('github_actions_run_details', 'jobs_json', 'TEXT');
+ensureColumn('github_actions_run_details', 'provider_created_at', 'DATETIME');
+ensureColumn('github_actions_run_details', 'provider_updated_at', 'DATETIME');
+ensureColumn('github_actions_run_details', 'provider_started_at', 'DATETIME');
+ensureColumn('github_actions_run_details', 'jobs_retention_state', "TEXT NOT NULL DEFAULT 'retained'");
+ensureColumn('github_actions_run_details', 'jobs_expired_at', 'DATETIME');
+ensureColumn('github_actions_run_details', 'jobs_count', 'INTEGER');
+db.exec('CREATE INDEX IF NOT EXISTS idx_execution_runs_project_created ON execution_runs(project_id, created_at DESC, id DESC)');
+db.exec('CREATE INDEX IF NOT EXISTS idx_execution_runs_project_kind_status ON execution_runs(project_id, kind, status, created_at DESC, id DESC)');
+db.exec('CREATE INDEX IF NOT EXISTS idx_execution_runs_parent ON execution_runs(parent_run_id)');
+db.exec('CREATE INDEX IF NOT EXISTS idx_execution_runs_retry ON execution_runs(retry_of_run_id)');
+db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_execution_runs_direct_retry ON execution_runs(retry_of_run_id) WHERE retry_of_run_id IS NOT NULL');
+db.exec('CREATE INDEX IF NOT EXISTS idx_execution_runs_correlation ON execution_runs(project_id, correlation_id)');
+db.exec('CREATE INDEX IF NOT EXISTS idx_execution_run_links_project_entity ON execution_run_links(project_id, entity_type, entity_id, created_at DESC)');
+db.exec('CREATE INDEX IF NOT EXISTS idx_execution_run_links_run_relationship ON execution_run_links(execution_run_id, relationship, created_at ASC)');
+db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_execution_run_links_primary ON execution_run_links(execution_run_id) WHERE relationship = 'primary'");
+db.exec('CREATE INDEX IF NOT EXISTS idx_lifecycle_events_run_sequence ON lifecycle_events(project_id, execution_run_id, sequence ASC)');
+db.exec('CREATE INDEX IF NOT EXISTS idx_lifecycle_events_project_created ON lifecycle_events(project_id, created_at DESC, id DESC)');
+db.exec('CREATE INDEX IF NOT EXISTS idx_github_actions_details_dispatch ON github_actions_run_details(workflow_id, ref, dispatched_at DESC)');
 db.exec(`
   CREATE TABLE IF NOT EXISTS project_memory_selections (
     id                  TEXT PRIMARY KEY,
@@ -1374,6 +1817,9 @@ db.exec(`
     worktree_bundle_id       TEXT NOT NULL,
     review_iteration_count   INTEGER NOT NULL DEFAULT 0,
     fix_loop_active          INTEGER NOT NULL DEFAULT 0,
+    automation_progression_run_id TEXT,
+    automation_paused_stage_run_id TEXT,
+    automation_pause_reason_code TEXT,
     automation_paused_code   TEXT,
     automation_paused_reason TEXT,
     automation_paused_at     DATETIME,
@@ -1385,6 +1831,29 @@ db.exec(`
   )
 `);
 ensureColumn('bundle_automation_state', 'automation_paused_code', 'TEXT');
+ensureColumn('bundle_automation_state', 'automation_progression_run_id', 'TEXT');
+ensureColumn('bundle_automation_state', 'automation_paused_stage_run_id', 'TEXT');
+ensureColumn('bundle_automation_state', 'automation_pause_reason_code', 'TEXT');
+db.exec(`
+  CREATE TABLE IF NOT EXISTS automation_stage_details (
+    execution_run_id  TEXT PRIMARY KEY,
+    project_id        TEXT NOT NULL,
+    worktree_bundle_id TEXT NOT NULL,
+    stage_kind        TEXT NOT NULL,
+    schema_version    INTEGER NOT NULL,
+    intent_json       TEXT NOT NULL,
+    result_json       TEXT,
+    created_at        DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at        DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (execution_run_id, project_id) REFERENCES execution_runs(id, project_id) ON DELETE CASCADE,
+    FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+    FOREIGN KEY (worktree_bundle_id) REFERENCES worktree_bundles(id) ON DELETE CASCADE,
+    CHECK (stage_kind IN ('automation_commit', 'automation_push', 'automation_pull_request')),
+    CHECK (schema_version = 1),
+    CHECK (length(CAST(intent_json AS BLOB)) BETWEEN 2 AND 16384),
+    CHECK (result_json IS NULL OR length(CAST(result_json AS BLOB)) BETWEEN 2 AND 16384)
+  )
+`);
 db.exec(`
   CREATE TABLE IF NOT EXISTS build_open_question_batches (
     id                 TEXT PRIMARY KEY,
@@ -1447,47 +1916,11 @@ db.exec('CREATE INDEX IF NOT EXISTS idx_build_sequence_tickets_sequence_position
 db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_integration_connections_provider_project ON integration_connections(provider, project_id)');
 db.exec('CREATE INDEX IF NOT EXISTS idx_tickets_external_key ON tickets(external_provider, external_key)');
 db.exec('CREATE INDEX IF NOT EXISTS idx_bundle_automation_state_project_bundle ON bundle_automation_state(project_id, worktree_bundle_id)');
+db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_bundle_automation_state_progression ON bundle_automation_state(automation_progression_run_id) WHERE automation_progression_run_id IS NOT NULL');
+db.exec('CREATE INDEX IF NOT EXISTS idx_automation_stage_details_bundle_stage ON automation_stage_details(project_id, worktree_bundle_id, stage_kind, created_at DESC)');
 db.exec('CREATE INDEX IF NOT EXISTS idx_build_open_questions_ticket_status ON build_open_questions(ticket_id, status)');
 db.exec('CREATE INDEX IF NOT EXISTS idx_build_open_questions_bundle_status ON build_open_questions(project_id, worktree_bundle_id, status)');
 db.exec('CREATE INDEX IF NOT EXISTS idx_build_open_question_batches_bundle_status ON build_open_question_batches(project_id, worktree_bundle_id, status)');
-const recoverInterruptedBuildOpenQuestionBatches = () => {
-    const interrupted = db.prepare(`
-    SELECT id, project_id, worktree_bundle_id
-    FROM build_open_question_batches
-    WHERE status IN ('pending', 'running')
-  `).all();
-    if (interrupted.length === 0) {
-        return;
-    }
-    const recover = db.transaction(() => {
-        for (const batch of interrupted) {
-            db.prepare(`
-        UPDATE build_open_question_batches
-        SET status = 'error', error_message = ?, completed_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
-        WHERE id = ? AND status IN ('pending', 'running')
-      `).run('Server restarted before the Build open question follow-up completed', batch.id);
-            db.prepare(`
-        UPDATE build_open_questions
-        SET status = 'open', answer_text = NULL, answered_at = NULL,
-            dismissed_at = NULL, dismissed_by = NULL, dismissal_reason = NULL,
-            resolution_batch_id = NULL, updated_at = CURRENT_TIMESTAMP
-        WHERE resolution_batch_id = ? AND status IN ('answered', 'dismissed')
-      `).run(batch.id);
-            db.prepare(`
-        INSERT INTO bundle_automation_state (
-          project_id, worktree_bundle_id, automation_paused_code, automation_paused_reason, automation_paused_at
-        ) VALUES (?, ?, 'open_questions', ?, CURRENT_TIMESTAMP)
-        ON CONFLICT(project_id, worktree_bundle_id) DO UPDATE SET
-          automation_paused_code = 'open_questions',
-          automation_paused_reason = excluded.automation_paused_reason,
-          automation_paused_at = CURRENT_TIMESTAMP,
-          updated_at = CURRENT_TIMESTAMP
-      `).run(batch.project_id, batch.worktree_bundle_id, 'Build open question follow-up was interrupted by a server restart');
-        }
-    });
-    recover();
-};
-recoverInterruptedBuildOpenQuestionBatches();
 const migrateLegacyBuildOpenQuestions = () => {
     const rows = db.prepare(`
     SELECT id, project_id, worktree_bundle_id, planning_context_json