patchrelay 0.35.11 → 0.35.13

package/dist/cli/watch/watch-state.js

@@ -8,6 +8,10 @@ function capArray(arr, max) {
 }
 const DETAIL_INITIAL = {
     detailTab: "timeline",
+    detailScrollOffset: 0,
+    detailViewportRows: 0,
+    detailContentRows: 0,
+    detailUnreadBelow: 0,
     timeline: [],
     rawRuns: [],
     rawFeedEvents: [],
@@ -31,6 +35,9 @@ export const initialWatchState = {
     feedEvents: [],
 };
 const TERMINAL_FACTORY_STATES = new Set(["done", "failed"]);
+function effectiveSessionState(issue) {
+    return issue.sessionState ?? (TERMINAL_FACTORY_STATES.has(issue.factoryState) ? issue.factoryState : undefined);
+}
 export function filterIssues(issues, filter) {
     switch (filter) {
         case "all":
@@ -38,7 +45,10 @@ export function filterIssues(issues, filter) {
         case "active":
             return issues.filter((i) => i.activeRunType !== undefined);
         case "non-done":
-            return issues.filter((i) => !TERMINAL_FACTORY_STATES.has(i.factoryState));
+            return issues.filter((i) => {
+                const sessionState = effectiveSessionState(i);
+                return sessionState !== "done" && sessionState !== "failed" && !TERMINAL_FACTORY_STATES.has(i.factoryState);
+            });
     }
 }
 const DONE_STATES = new Set(["done"]);
@@ -50,15 +60,18 @@ export function computeAggregates(issues) {
     let done = 0;
     let failed = 0;
     for (const issue of issues) {
+        const sessionState = effectiveSessionState(issue);
+        const isDone = sessionState === "done" || DONE_STATES.has(issue.factoryState);
+        const isFailed = sessionState === "failed" || FAILED_STATES.has(issue.factoryState);
         if (issue.activeRunType)
             active++;
         if (!issue.activeRunType && issue.blockedByCount > 0)
             blocked++;
-        if (!issue.activeRunType && issue.readyForExecution)
+        if (!issue.activeRunType && issue.readyForExecution && !isDone && !isFailed)
             ready++;
-        if (DONE_STATES.has(issue.factoryState))
+        if (isDone)
             done++;
-        if (FAILED_STATES.has(issue.factoryState))
+        if (isFailed)
             failed++;
     }
     return { active, blocked, ready, done, failed, total: issues.length };
@@ -70,6 +83,60 @@ function nextFilter(filter) {
         case "all": return "non-done";
     }
 }
+function clampIndex(index, length) {
+    return Math.max(0, Math.min(index, Math.max(0, length - 1)));
+}
+function selectedIssueKeyForFilter(state) {
+    const filtered = filterIssues(state.issues, state.filter);
+    return filtered[state.selectedIndex]?.issueKey ?? null;
+}
+function selectedIndexForSnapshot(state, nextIssues) {
+    const nextFiltered = filterIssues(nextIssues, state.filter);
+    if (nextFiltered.length === 0)
+        return 0;
+    const selectedIssueKey = selectedIssueKeyForFilter(state);
+    if (selectedIssueKey) {
+        const selectedIndex = nextFiltered.findIndex((issue) => issue.issueKey === selectedIssueKey);
+        if (selectedIndex >= 0)
+            return selectedIndex;
+    }
+    return clampIndex(state.selectedIndex, nextFiltered.length);
+}
+const DETAIL_BOTTOM_THRESHOLD = 2;
+function maxDetailScrollOffset(contentRows, viewportRows) {
+    return Math.max(0, contentRows - viewportRows);
+}
+function isDetailNearBottom(scrollOffset, contentRows, viewportRows) {
+    const maxOffset = maxDetailScrollOffset(contentRows, viewportRows);
+    return scrollOffset >= Math.max(0, maxOffset - DETAIL_BOTTOM_THRESHOLD);
+}
+function detailStateForPosition(state, scrollOffset, follow) {
+    const maxOffset = maxDetailScrollOffset(state.detailContentRows, state.detailViewportRows);
+    const nextOffset = clampIndex(scrollOffset, maxOffset + 1);
+    const nextFollow = follow || isDetailNearBottom(nextOffset, state.detailContentRows, state.detailViewportRows);
+    return {
+        detailScrollOffset: nextFollow ? maxOffset : nextOffset,
+        detailUnreadBelow: nextFollow ? 0 : Math.max(0, maxOffset - nextOffset),
+        follow: nextFollow,
+    };
+}
+function detailStateAfterLayout(state, viewportRows, contentRows) {
+    const nextState = {
+        ...state,
+        detailViewportRows: Math.max(0, viewportRows),
+        detailContentRows: Math.max(0, contentRows),
+    };
+    const maxOffset = maxDetailScrollOffset(nextState.detailContentRows, nextState.detailViewportRows);
+    const shouldFollow = state.follow || isDetailNearBottom(state.detailScrollOffset, state.detailContentRows, state.detailViewportRows);
+    const nextOffset = shouldFollow ? maxOffset : Math.min(state.detailScrollOffset, maxOffset);
+    return {
+        detailViewportRows: nextState.detailViewportRows,
+        detailContentRows: nextState.detailContentRows,
+        detailScrollOffset: nextOffset,
+        detailUnreadBelow: shouldFollow ? 0 : Math.max(0, maxOffset - nextOffset),
+        follow: shouldFollow,
+    };
+}
 // ─── Reducer ──────────────────────────────────────────────────────
 export function watchReducer(state, action) {
     switch (action.type) {
@@ -84,17 +151,17 @@ export function watchReducer(state, action) {
                 ...state,
                 lastServerMessageAt: action.receivedAt,
                 issues: action.issues,
-                selectedIndex: Math.min(state.selectedIndex, Math.max(0, action.issues.length - 1)),
+                selectedIndex: selectedIndexForSnapshot(state, action.issues),
             };
         case "feed-event":
             return applyFeedEvent(state, action.event, action.receivedAt);
         case "select":
             return {
                 ...state,
-                selectedIndex: Math.max(0, Math.min(action.index, state.issues.length - 1)),
+                selectedIndex: clampIndex(action.index, filterIssues(state.issues, state.filter).length),
             };
         case "enter-detail":
-            return { ...state, view: "detail", activeDetailKey: action.issueKey, ...DETAIL_INITIAL };
+            return { ...state, view: "detail", activeDetailKey: action.issueKey, follow: true, ...DETAIL_INITIAL };
         case "exit-detail":
             return { ...state, view: "list", activeDetailKey: null, ...DETAIL_INITIAL };
         case "detail-navigate": {
@@ -108,8 +175,46 @@ export function watchReducer(state, action) {
             const nextIssue = list[nextIdx];
             if (!nextIssue?.issueKey || nextIssue.issueKey === state.activeDetailKey)
                 return state;
-            return { ...state, activeDetailKey: nextIssue.issueKey, selectedIndex: nextIdx, ...DETAIL_INITIAL };
+            return { ...state, activeDetailKey: nextIssue.issueKey, selectedIndex: nextIdx, follow: true, ...DETAIL_INITIAL };
+        }
+        case "detail-scroll":
+            return {
+                ...state,
+                ...detailStateForPosition(state, state.detailScrollOffset + action.delta, false),
+            };
+        case "detail-page": {
+            const pageSize = Math.max(1, state.detailViewportRows - 2);
+            const delta = action.direction === "down" ? pageSize : -pageSize;
+            return {
+                ...state,
+                ...detailStateForPosition(state, state.detailScrollOffset + delta, false),
+            };
         }
+        case "detail-jump":
+            return action.target === "end"
+                ? {
+                    ...state,
+                    ...detailStateForPosition(state, maxDetailScrollOffset(state.detailContentRows, state.detailViewportRows), true),
+                }
+                : {
+                    ...state,
+                    ...detailStateForPosition(state, 0, false),
+                };
+        case "detail-layout-updated":
+            {
+                const nextDetailState = detailStateAfterLayout(state, action.viewportRows, action.contentRows);
+                if (nextDetailState.detailViewportRows === state.detailViewportRows
+                    && nextDetailState.detailContentRows === state.detailContentRows
+                    && nextDetailState.detailScrollOffset === state.detailScrollOffset
+                    && nextDetailState.detailUnreadBelow === state.detailUnreadBelow
+                    && nextDetailState.follow === state.follow) {
+                    return state;
+                }
+                return {
+                    ...state,
+                    ...nextDetailState,
+                };
+            }
         case "timeline-rehydrate": {
             const timeline = buildTimelineFromRehydration(action.runs, action.feedEvents, action.liveThread, action.activeRunId);
             const activeRun = action.runs.find((r) => r.id === action.activeRunId);
@@ -119,7 +224,7 @@ export function watchReducer(state, action) {
                 rawRuns: action.runs,
                 rawFeedEvents: action.feedEvents,
                 activeRunId: action.activeRunId,
-                activeRunStartedAt: activeRun?.startedAt ?? null,
+                activeRunStartedAt: action.activeRunStartedAt ?? activeRun?.startedAt ?? null,
                 issueContext: action.issueContext,
             };
         }
@@ -128,7 +233,16 @@ export function watchReducer(state, action) {
         case "cycle-filter":
             return { ...state, filter: nextFilter(state.filter), selectedIndex: 0 };
         case "toggle-follow":
-            return { ...state, follow: !state.follow };
+            return state.follow
+                ? {
+                    ...state,
+                    follow: false,
+                    detailUnreadBelow: Math.max(0, maxDetailScrollOffset(state.detailContentRows, state.detailViewportRows) - state.detailScrollOffset),
+                }
+                : {
+                    ...state,
+                    ...detailStateForPosition(state, maxDetailScrollOffset(state.detailContentRows, state.detailViewportRows), true),
+                };
         case "enter-feed":
             return { ...state, view: "feed", activeDetailKey: null, ...DETAIL_INITIAL };
         case "exit-feed":
@@ -138,64 +252,23 @@ export function watchReducer(state, action) {
         case "feed-new-event":
             return { ...state, feedEvents: capArray([...state.feedEvents, action.event], MAX_FEED_EVENTS) };
         case "switch-detail-tab":
-            return { ...state, detailTab: action.tab };
+            return { ...state, follow: true, ...DETAIL_INITIAL, detailTab: action.tab };
         default:
             return state;
     }
 }
 // ─── Feed Event → Issue List + Timeline ───────────────────────────
 function applyFeedEvent(state, event, receivedAt) {
-    if (!event.issueKey) {
-        return { ...state, lastServerMessageAt: receivedAt };
-    }
-    const index = state.issues.findIndex((issue) => issue.issueKey === event.issueKey);
-    if (index === -1) {
-        return { ...state, lastServerMessageAt: receivedAt };
-    }
-    const updated = [...state.issues];
-    const issue = { ...updated[index] };
-    if (event.kind === "stage" && event.stage) {
-        issue.factoryState = event.stage;
-    }
-    if (event.kind === "stage" && event.status === "starting" && event.stage) {
-        issue.activeRunType = event.stage;
-    }
-    if (event.kind === "turn") {
-        if (event.status === "completed" || event.status === "failed") {
-            issue.activeRunType = undefined;
-            issue.latestRunStatus = event.status;
-        }
-    }
-    if (event.kind === "github" && event.status) {
-        if (event.status === "check_passed" || event.status === "check_failed") {
-            issue.prCheckStatus = event.status === "check_passed" ? "passed" : "failed";
-        }
-        if (event.status === "ci_repair_queued") {
-            issue.factoryState = "repairing_ci";
-            issue.statusNote = event.detail ?? event.summary;
-        }
-        if (event.status === "queue_repair_queued") {
-            issue.factoryState = "repairing_queue";
-            issue.statusNote = event.detail ?? event.summary;
-        }
-        if (event.status === "repair_deduped" || event.status === "branch_not_advanced") {
-            issue.statusNote = event.summary;
-        }
-    }
-    if ((event.kind === "turn" || event.kind === "github") && event.status === "branch_not_advanced") {
-        issue.statusNote = event.summary;
-    }
-    issue.updatedAt = event.at;
-    updated[index] = issue;
-    // Append to timeline and raw feed events if this event matches the active detail issue
-    const isActiveDetail = state.view === "detail" && state.activeDetailKey === event.issueKey;
+    const isActiveDetail = Boolean(event.issueKey)
+        && state.view === "detail"
+        && state.activeDetailKey === event.issueKey;
     const timeline = isActiveDetail
         ? capArray(appendFeedToTimeline(state.timeline, event), MAX_TIMELINE_ENTRIES)
         : state.timeline;
     const rawFeedEvents = isActiveDetail
         ? capArray([...state.rawFeedEvents, event], MAX_RAW_FEED_EVENTS)
         : state.rawFeedEvents;
-    return { ...state, lastServerMessageAt: receivedAt, issues: updated, timeline, rawFeedEvents };
+    return { ...state, lastServerMessageAt: receivedAt, timeline, rawFeedEvents };
 }
 // ─── Codex Notification → Timeline + Metadata ─────────────────────
 function applyCodexNotification(state, method, params) {

package/dist/codex-thread-utils.js

@@ -0,0 +1,3 @@
+export function getThreadTurns(thread) {
+    return Array.isArray(thread?.turns) ? thread.turns : [];
+}

package/dist/db/migrations.js

@@ -22,6 +22,8 @@ CREATE TABLE IF NOT EXISTS issues (
   pr_number INTEGER,
   pr_url TEXT,
   pr_state TEXT,
+  pr_head_sha TEXT,
+  pr_author_login TEXT,
   pr_review_state TEXT,
   pr_check_status TEXT,
   ci_repair_attempts INTEGER NOT NULL DEFAULT 0,
@@ -48,6 +50,48 @@ CREATE TABLE IF NOT EXISTS runs (
   ended_at TEXT
 );
 
+CREATE TABLE IF NOT EXISTS issue_sessions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id TEXT NOT NULL,
+  linear_issue_id TEXT NOT NULL,
+  issue_key TEXT,
+  repo_id TEXT NOT NULL,
+  branch_name TEXT,
+  worktree_path TEXT,
+  pr_number INTEGER,
+  pr_head_sha TEXT,
+  pr_author_login TEXT,
+  session_state TEXT NOT NULL DEFAULT 'idle',
+  waiting_reason TEXT,
+  summary_text TEXT,
+  active_thread_id TEXT,
+  thread_generation INTEGER NOT NULL DEFAULT 0,
+  active_run_id INTEGER,
+  last_run_type TEXT,
+  last_wake_reason TEXT,
+  ci_repair_attempts INTEGER NOT NULL DEFAULT 0,
+  queue_repair_attempts INTEGER NOT NULL DEFAULT 0,
+  review_fix_attempts INTEGER NOT NULL DEFAULT 0,
+  lease_id TEXT,
+  worker_id TEXT,
+  leased_until TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE(project_id, linear_issue_id)
+);
+
+CREATE TABLE IF NOT EXISTS issue_session_events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id TEXT NOT NULL,
+  linear_issue_id TEXT NOT NULL,
+  event_type TEXT NOT NULL,
+  event_json TEXT,
+  dedupe_key TEXT,
+  created_at TEXT NOT NULL,
+  processed_at TEXT,
+  consumed_by_run_id INTEGER
+);
+
 CREATE TABLE IF NOT EXISTS webhook_events (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
   webhook_id TEXT NOT NULL UNIQUE,
@@ -167,6 +211,11 @@ CREATE INDEX IF NOT EXISTS idx_issues_branch ON issues(branch_name);
 CREATE INDEX IF NOT EXISTS idx_runs_issue ON runs(issue_id);
 CREATE INDEX IF NOT EXISTS idx_runs_active ON runs(status, project_id, linear_issue_id);
 CREATE INDEX IF NOT EXISTS idx_runs_thread ON runs(thread_id);
+CREATE INDEX IF NOT EXISTS idx_issue_sessions_issue ON issue_sessions(project_id, linear_issue_id);
+CREATE INDEX IF NOT EXISTS idx_issue_sessions_key ON issue_sessions(issue_key);
+CREATE INDEX IF NOT EXISTS idx_issue_sessions_lease ON issue_sessions(leased_until, session_state);
+CREATE INDEX IF NOT EXISTS idx_issue_session_events_issue ON issue_session_events(project_id, linear_issue_id, id);
+CREATE INDEX IF NOT EXISTS idx_issue_session_events_pending ON issue_session_events(processed_at, project_id, linear_issue_id, id);
 CREATE INDEX IF NOT EXISTS idx_run_thread_events_run ON run_thread_events(run_id, id);
 CREATE INDEX IF NOT EXISTS idx_operator_feed_events_issue ON operator_feed_events(issue_key, id);
 CREATE INDEX IF NOT EXISTS idx_operator_feed_events_project ON operator_feed_events(project_id, id);
@@ -185,6 +234,7 @@ export function runPatchRelayMigrations(connection) {
     // Explicit PR branch ownership hand-off between PatchRelay and MergeSteward
     addColumnIfMissing(connection, "issues", "branch_owner", "TEXT NOT NULL DEFAULT 'patchrelay'");
     addColumnIfMissing(connection, "issues", "branch_ownership_changed_at", "TEXT");
+    connection.prepare("UPDATE issues SET branch_owner = 'patchrelay' WHERE branch_owner IS NULL OR branch_owner != 'patchrelay'").run();
     // Add merge_prep_attempts for retry budget / escalation
     addColumnIfMissing(connection, "issues", "merge_prep_attempts", "INTEGER NOT NULL DEFAULT 0");
     // Add review_fix_attempts counter
@@ -195,6 +245,7 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "description", "TEXT");
     addColumnIfMissing(connection, "issues", "priority", "INTEGER");
     addColumnIfMissing(connection, "issues", "estimate", "REAL");
+    addColumnIfMissing(connection, "issues", "status_comment_id", "TEXT");
     addColumnIfMissing(connection, "issues", "current_linear_state_type", "TEXT");
     addColumnIfMissing(connection, "issue_dependencies", "blocker_current_linear_state_type", "TEXT");
     // Zombie/stale recovery backoff
@@ -202,6 +253,8 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "last_zombie_recovery_at", "TEXT");
     // Preserve GitHub failure provenance so reconciliation can distinguish
     // branch CI failures from merge-queue evictions after webhook delivery.
+    addColumnIfMissing(connection, "issues", "pr_head_sha", "TEXT");
+    addColumnIfMissing(connection, "issues", "pr_author_login", "TEXT");
     addColumnIfMissing(connection, "issues", "last_github_failure_source", "TEXT");
     addColumnIfMissing(connection, "issues", "last_github_failure_head_sha", "TEXT");
     addColumnIfMissing(connection, "issues", "last_github_failure_signature", "TEXT");
@@ -218,8 +271,7 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "last_queue_incident_json", "TEXT");
     addColumnIfMissing(connection, "issues", "last_attempted_failure_head_sha", "TEXT");
     addColumnIfMissing(connection, "issues", "last_attempted_failure_signature", "TEXT");
-    // Track whether the merge queue label was successfully applied.
-    addColumnIfMissing(connection, "issues", "queue_label_applied", "INTEGER NOT NULL DEFAULT 0");
+    removeRetiredIssueColumnsIfPresent(connection);
 }
 function addColumnIfMissing(connection, table, column, definition) {
     const cols = connection.prepare(`PRAGMA table_info(${table})`).all();
@@ -227,3 +279,188 @@ function addColumnIfMissing(connection, table, column, definition) {
         return;
     connection.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
 }
+function removeRetiredIssueColumnsIfPresent(connection) {
+    const cols = connection.prepare("PRAGMA table_info(issues)").all();
+    const columnNames = new Set(cols.map((column) => String(column.name)));
+    const retired = ["queue_label_applied", "pending_merge_prep", "merge_prep_attempts"];
+    if (!retired.some((name) => columnNames.has(name))) {
+        return;
+    }
+    connection.exec("PRAGMA foreign_keys = OFF");
+    try {
+        connection.exec(`
+      CREATE TABLE issues_new (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        project_id TEXT NOT NULL,
+        linear_issue_id TEXT NOT NULL,
+        issue_key TEXT,
+        title TEXT,
+        description TEXT,
+        url TEXT,
+        priority INTEGER,
+        estimate REAL,
+        current_linear_state TEXT,
+        current_linear_state_type TEXT,
+        factory_state TEXT NOT NULL DEFAULT 'delegated',
+        pending_run_type TEXT,
+        pending_run_context_json TEXT,
+        branch_name TEXT,
+        branch_owner TEXT NOT NULL DEFAULT 'patchrelay',
+        branch_ownership_changed_at TEXT,
+        worktree_path TEXT,
+        thread_id TEXT,
+        active_run_id INTEGER,
+        status_comment_id TEXT,
+        agent_session_id TEXT,
+        pr_number INTEGER,
+        pr_url TEXT,
+        pr_state TEXT,
+        pr_head_sha TEXT,
+        pr_author_login TEXT,
+        pr_review_state TEXT,
+        pr_check_status TEXT,
+        last_github_failure_source TEXT,
+        last_github_failure_head_sha TEXT,
+        last_github_failure_signature TEXT,
+        last_github_failure_check_name TEXT,
+        last_github_failure_check_url TEXT,
+        last_github_failure_context_json TEXT,
+        last_github_failure_at TEXT,
+        last_github_ci_snapshot_head_sha TEXT,
+        last_github_ci_snapshot_gate_check_name TEXT,
+        last_github_ci_snapshot_gate_check_status TEXT,
+        last_github_ci_snapshot_json TEXT,
+        last_github_ci_snapshot_settled_at TEXT,
+        last_queue_signal_at TEXT,
+        last_queue_incident_json TEXT,
+        last_attempted_failure_head_sha TEXT,
+        last_attempted_failure_signature TEXT,
+        ci_repair_attempts INTEGER NOT NULL DEFAULT 0,
+        queue_repair_attempts INTEGER NOT NULL DEFAULT 0,
+        review_fix_attempts INTEGER NOT NULL DEFAULT 0,
+        zombie_recovery_attempts INTEGER NOT NULL DEFAULT 0,
+        last_zombie_recovery_at TEXT,
+        updated_at TEXT NOT NULL,
+        UNIQUE(project_id, linear_issue_id)
+      );
+
+      INSERT INTO issues_new (
+        id,
+        project_id,
+        linear_issue_id,
+        issue_key,
+        title,
+        description,
+        url,
+        priority,
+        estimate,
+        current_linear_state,
+        current_linear_state_type,
+        factory_state,
+        pending_run_type,
+        pending_run_context_json,
+        branch_name,
+        branch_owner,
+        branch_ownership_changed_at,
+        worktree_path,
+        thread_id,
+        active_run_id,
+        status_comment_id,
+        agent_session_id,
+        pr_number,
+        pr_url,
+        pr_state,
+        pr_head_sha,
+        pr_author_login,
+        pr_review_state,
+        pr_check_status,
+        last_github_failure_source,
+        last_github_failure_head_sha,
+        last_github_failure_signature,
+        last_github_failure_check_name,
+        last_github_failure_check_url,
+        last_github_failure_context_json,
+        last_github_failure_at,
+        last_github_ci_snapshot_head_sha,
+        last_github_ci_snapshot_gate_check_name,
+        last_github_ci_snapshot_gate_check_status,
+        last_github_ci_snapshot_json,
+        last_github_ci_snapshot_settled_at,
+        last_queue_signal_at,
+        last_queue_incident_json,
+        last_attempted_failure_head_sha,
+        last_attempted_failure_signature,
+        ci_repair_attempts,
+        queue_repair_attempts,
+        review_fix_attempts,
+        zombie_recovery_attempts,
+        last_zombie_recovery_at,
+        updated_at
+      )
+      SELECT
+        id,
+        project_id,
+        linear_issue_id,
+        issue_key,
+        title,
+        description,
+        url,
+        priority,
+        estimate,
+        current_linear_state,
+        current_linear_state_type,
+        COALESCE(factory_state, 'delegated'),
+        pending_run_type,
+        pending_run_context_json,
+        branch_name,
+        COALESCE(branch_owner, 'patchrelay'),
+        branch_ownership_changed_at,
+        worktree_path,
+        thread_id,
+        active_run_id,
+        status_comment_id,
+        agent_session_id,
+        pr_number,
+        pr_url,
+        pr_state,
+        pr_head_sha,
+        pr_author_login,
+        pr_review_state,
+        pr_check_status,
+        last_github_failure_source,
+        last_github_failure_head_sha,
+        last_github_failure_signature,
+        last_github_failure_check_name,
+        last_github_failure_check_url,
+        last_github_failure_context_json,
+        last_github_failure_at,
+        last_github_ci_snapshot_head_sha,
+        last_github_ci_snapshot_gate_check_name,
+        last_github_ci_snapshot_gate_check_status,
+        last_github_ci_snapshot_json,
+        last_github_ci_snapshot_settled_at,
+        last_queue_signal_at,
+        last_queue_incident_json,
+        last_attempted_failure_head_sha,
+        last_attempted_failure_signature,
+        COALESCE(ci_repair_attempts, 0),
+        COALESCE(queue_repair_attempts, 0),
+        COALESCE(review_fix_attempts, 0),
+        COALESCE(zombie_recovery_attempts, 0),
+        last_zombie_recovery_at,
+        updated_at
+      FROM issues;
+
+      DROP TABLE issues;
+      ALTER TABLE issues_new RENAME TO issues;
+
+      CREATE INDEX IF NOT EXISTS idx_issues_project ON issues(project_id, linear_issue_id);
+      CREATE INDEX IF NOT EXISTS idx_issues_key ON issues(issue_key);
+      CREATE INDEX IF NOT EXISTS idx_issues_ready ON issues(pending_run_type, active_run_id);
+      CREATE INDEX IF NOT EXISTS idx_issues_branch ON issues(branch_name);
+    `);
+    }
+    finally {
+        connection.exec("PRAGMA foreign_keys = ON");
+    }
+}