feat: split thread state into runStates/lifecycleStates with full PR lifecycle reconciliation

Rearchitects PR/worktree state tracking. The `worktrees` table is now the
single source of truth; `get_pr_status` is the one place that reconciles
GitHub state into the DB, handling merged/closed/reopened/reverted/missing PRs
in one gh call per poll. Frontend splits run state (agent process) from
lifecycle state (worktree/PR relationship) and surfaces the latter through a
new LifecycleBanner pinned above the chat. Adds safer PR pushes with
divergence detection, an open_external_url Tauri command, and a
link_pr_to_thread command that actually persists the link.

Author: Swofty-Developments

.vite/deps/_metadata.json

@@ -0,0 +1,8 @@
+{
+  "hash": "86b9f780",
+  "configHash": "cb03bef2",
+  "lockfileHash": "e3b0c442",
+  "browserHash": "57056a4f",
+  "optimized": {},
+  "chunks": {}
+}

.vite/deps/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

crates/core/src/id.rs

@@ -155,6 +155,11 @@ typed_id!(
     ToolCallId
 );
 
+typed_id!(
+    /// Unique identifier for a git worktree.
+    WorktreeId
+);
+
 /// Helper to generate a batch of IDs of the same type.
 pub fn generate_ids<T: From<Uuid>>(count: usize) -> Vec<T> {
     (0..count).map(|_| T::from(Uuid::new_v4())).collect()

crates/persistence/src/lib.rs

@@ -3,6 +3,6 @@ pub mod migrations;
 pub mod models;
 pub mod queries;
 
-pub use codeforge_core::id::{MessageId, ProjectId, SessionId, ThreadId};
+pub use codeforge_core::id::{MessageId, ProjectId, SessionId, ThreadId, WorktreeId};
 pub use db::Database;
 pub use models::*;

crates/persistence/src/migrations.rs

@@ -1,5 +1,13 @@
 use rusqlite::Connection;
 
+fn column_exists(conn: &Connection, table: &str, column: &str) -> rusqlite::Result<bool> {
+    let mut stmt = conn.prepare(&format!("PRAGMA table_info({table})"))?;
+    let exists = stmt
+        .query_map([], |row| row.get::<_, String>(1))?
+        .any(|col| col.as_deref() == Ok(column));
+    Ok(exists)
+}
+
 /// Run all database migrations. This is idempotent — tables are created only if
 /// they do not already exist.
 pub fn run_migrations(conn: &Connection) -> rusqlite::Result<()> {
@@ -46,12 +54,7 @@ pub fn run_migrations(conn: &Connection) -> rusqlite::Result<()> {
     )?;
 
     // Add color column to threads if missing
-    let has_color: bool = conn
-        .prepare("PRAGMA table_info(threads)")?
-        .query_map([], |row| row.get::<_, String>(1))?
-        .any(|col| col.as_deref() == Ok("color"));
-
-    if !has_color {
+    if !column_exists(conn, "threads", "color")? {
         conn.execute_batch("ALTER TABLE threads ADD COLUMN color TEXT;")?;
     }
 
@@ -74,15 +77,167 @@ pub fn run_migrations(conn: &Connection) -> rusqlite::Result<()> {
     )?;
 
     // Add claude_session_id column to sessions if missing (used for --resume)
-    let has_claude_session_id: bool = conn
-        .prepare("PRAGMA table_info(sessions)")?
-        .query_map([], |row| row.get::<_, String>(1))?
-        .any(|col| col.as_deref() == Ok("claude_session_id"));
-
-    if !has_claude_session_id {
+    if !column_exists(conn, "sessions", "claude_session_id")? {
         conn.execute_batch("ALTER TABLE sessions ADD COLUMN claude_session_id TEXT;")?;
     }
 
+    // Worktrees table — replaces worktree:* and pr:* settings keys
+    conn.execute_batch(
+        "
+        CREATE TABLE IF NOT EXISTS worktrees (
+            id         TEXT PRIMARY KEY NOT NULL,
+            thread_id  TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+            project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+            branch     TEXT NOT NULL,
+            path       TEXT NOT NULL,
+            pr_number  INTEGER,
+            status     TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'merged', 'deleted', 'orphaned')),
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+        );
+        ",
+    )?;
+
+    // Migrate existing worktree/pr data from settings table into worktrees table.
+    // Format in settings: worktree:<thread_id> = <branch>|<path>, pr:<thread_id> = <number>
+    {
+        let mut wt_stmt = conn.prepare(
+            "SELECT key, value FROM settings WHERE key LIKE 'worktree:%'"
+        )?;
+        let wt_rows: Vec<(String, String)> = wt_stmt
+            .query_map([], |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?)))?
+            .filter_map(|r| r.ok())
+            .collect();
+
+        for (key, val) in &wt_rows {
+            let thread_id = key.strip_prefix("worktree:").unwrap_or(key);
+            let parts: Vec<&str> = val.splitn(2, '|').collect();
+            if parts.len() != 2 { continue; }
+            let branch = parts[0];
+            let path = parts[1];
+
+            // Look up PR number if linked
+            let pr_num: Option<u32> = conn
+                .query_row(
+                    "SELECT value FROM settings WHERE key = ?1",
+                    rusqlite::params![format!("pr:{thread_id}")],
+                    |row| row.get::<_, String>(0),
+                )
+                .ok()
+                .and_then(|v| v.parse().ok());
+
+            // Look up project_id from threads table
+            let project_id: Option<String> = conn
+                .query_row(
+                    "SELECT project_id FROM threads WHERE id = ?1",
+                    rusqlite::params![thread_id],
+                    |row| row.get(0),
+                )
+                .ok();
+
+            if let Some(project_id) = project_id {
+                // Only migrate if not already present
+                let exists: bool = conn
+                    .query_row(
+                        "SELECT COUNT(*) FROM worktrees WHERE thread_id = ?1",
+                        rusqlite::params![thread_id],
+                        |row| row.get::<_, i64>(0),
+                    )
+                    .unwrap_or(0) > 0;
+
+                if !exists {
+                    let id = uuid::Uuid::new_v4().to_string();
+                    let now = chrono::Utc::now().to_rfc3339();
+                    let _ = conn.execute(
+                        "INSERT INTO worktrees (id, thread_id, project_id, branch, path, pr_number, status, created_at, updated_at) VALUES (?1, ?2, ?3, ?4, ?5, ?6, 'active', ?7, ?7)",
+                        rusqlite::params![id, thread_id, project_id, branch, path, pr_num, now],
+                    );
+                }
+            }
+        }
+
+        // Clean up migrated settings
+        if !wt_rows.is_empty() {
+            conn.execute_batch(
+                "DELETE FROM settings WHERE key LIKE 'worktree:%'; DELETE FROM settings WHERE key LIKE 'pr:%';",
+            )?;
+        }
+    }
+
+    // Turn checkpoints — tracks HEAD commit at start of each AI turn for undo
+    conn.execute_batch(
+        "
+        CREATE TABLE IF NOT EXISTS turn_checkpoints (
+            id          TEXT PRIMARY KEY NOT NULL,
+            thread_id   TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+            turn_id     TEXT NOT NULL,
+            commit_sha  TEXT NOT NULL,
+            created_at  TEXT NOT NULL
+        );
+        ",
+    )?;
+
+    // ── Add full PR lifecycle columns to worktrees ──
+    if !column_exists(conn, "worktrees", "pr_state")? {
+        conn.execute_batch("ALTER TABLE worktrees ADD COLUMN pr_state TEXT;")?;
+    }
+    if !column_exists(conn, "worktrees", "pr_merge_commit")? {
+        conn.execute_batch("ALTER TABLE worktrees ADD COLUMN pr_merge_commit TEXT;")?;
+    }
+    if !column_exists(conn, "worktrees", "last_seen_comment_count")? {
+        conn.execute_batch(
+            "ALTER TABLE worktrees ADD COLUMN last_seen_comment_count INTEGER NOT NULL DEFAULT 0;",
+        )?;
+    }
+    if !column_exists(conn, "worktrees", "pr_url")? {
+        conn.execute_batch("ALTER TABLE worktrees ADD COLUMN pr_url TEXT;")?;
+    }
+
+    // ── Expand the CHECK constraint on worktrees.status to include 'closed' ──
+    // SQLite can't ALTER a CHECK constraint; we rebuild the table only if needed.
+    let needs_status_rebuild: bool = conn
+        .query_row(
+            "SELECT COUNT(*) FROM sqlite_master
+             WHERE type='table' AND name='worktrees'
+             AND sql LIKE '%''active'', ''merged'', ''deleted'', ''orphaned''%'
+             AND sql NOT LIKE '%''closed''%'",
+            [],
+            |row| row.get::<_, i64>(0),
+        )
+        .unwrap_or(0) > 0;
+
+    if needs_status_rebuild {
+        conn.execute_batch(
+            "
+            CREATE TABLE worktrees_new (
+                id                        TEXT PRIMARY KEY NOT NULL,
+                thread_id                 TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+                project_id                TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+                branch                    TEXT NOT NULL,
+                path                      TEXT NOT NULL,
+                pr_number                 INTEGER,
+                status                    TEXT NOT NULL DEFAULT 'active'
+                    CHECK(status IN ('active', 'merged', 'deleted', 'orphaned', 'closed')),
+                created_at                TEXT NOT NULL,
+                updated_at                TEXT NOT NULL,
+                pr_state                  TEXT,
+                pr_merge_commit           TEXT,
+                last_seen_comment_count   INTEGER NOT NULL DEFAULT 0,
+                pr_url                    TEXT
+            );
+            INSERT INTO worktrees_new (id, thread_id, project_id, branch, path, pr_number, status, created_at, updated_at, pr_state, pr_merge_commit, last_seen_comment_count, pr_url)
+                SELECT id, thread_id, project_id, branch, path, pr_number, status, created_at, updated_at, pr_state, pr_merge_commit, last_seen_comment_count, pr_url FROM worktrees;
+            DROP TABLE worktrees;
+            ALTER TABLE worktrees_new RENAME TO worktrees;
+            ",
+        )?;
+    }
+
+    // ── Add system_kind to messages for event vs state differentiation ──
+    if !column_exists(conn, "messages", "system_kind")? {
+        conn.execute_batch("ALTER TABLE messages ADD COLUMN system_kind TEXT;")?;
+    }
+
     // Performance indexes — idempotent via IF NOT EXISTS
     conn.execute_batch(
         "
@@ -92,6 +247,9 @@ pub fn run_migrations(conn: &Connection) -> rusqlite::Result<()> {
         CREATE INDEX IF NOT EXISTS idx_sessions_thread_id ON sessions(thread_id);
         CREATE INDEX IF NOT EXISTS idx_sessions_thread_claude ON sessions(thread_id, claude_session_id);
         CREATE INDEX IF NOT EXISTS idx_usage_logs_thread_id ON usage_logs(thread_id);
+        CREATE INDEX IF NOT EXISTS idx_worktrees_thread_id ON worktrees(thread_id);
+        CREATE INDEX IF NOT EXISTS idx_worktrees_project_id ON worktrees(project_id);
+        CREATE INDEX IF NOT EXISTS idx_turn_checkpoints_thread ON turn_checkpoints(thread_id);
         ",
     )?;
 

crates/persistence/src/models.rs

@@ -1,5 +1,5 @@
 use chrono::{DateTime, Utc};
-use codeforge_core::id::{MessageId, ProjectId, SessionId, ThreadId};
+use codeforge_core::id::{MessageId, ProjectId, SessionId, ThreadId, WorktreeId};
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -105,3 +105,107 @@ pub struct Setting {
     pub key: String,
     pub value: String,
 }
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum WorktreeStatus {
+    /// Worktree exists on disk and is available for work.
+    Active,
+    /// PR was merged on GitHub and the change is reachable from the base branch.
+    /// Thread is read-only.
+    Merged,
+    /// PR was closed on GitHub without being merged. Thread is read-only.
+    Closed,
+    /// User explicitly detached this worktree — thread is free to create a new one.
+    Deleted,
+    /// Worktree directory/record is missing from git but the DB row survives.
+    Orphaned,
+}
+
+impl WorktreeStatus {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::Active => "active",
+            Self::Merged => "merged",
+            Self::Closed => "closed",
+            Self::Deleted => "deleted",
+            Self::Orphaned => "orphaned",
+        }
+    }
+
+    /// True if the worktree still accepts work (composer enabled, button active).
+    pub fn is_open(&self) -> bool {
+        matches!(self, Self::Active)
+    }
+}
+
+impl std::str::FromStr for WorktreeStatus {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "active" => Ok(Self::Active),
+            "merged" => Ok(Self::Merged),
+            "closed" => Ok(Self::Closed),
+            "deleted" => Ok(Self::Deleted),
+            "orphaned" => Ok(Self::Orphaned),
+            other => Err(format!("invalid worktree status: {other}")),
+        }
+    }
+}
+
+/// Last-observed GitHub PR state — mirrors `gh pr view --json state`.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum PrGhState {
+    Open,
+    Closed,
+    Merged,
+    Unknown,
+}
+
+impl PrGhState {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::Open => "open",
+            Self::Closed => "closed",
+            Self::Merged => "merged",
+            Self::Unknown => "unknown",
+        }
+    }
+}
+
+impl std::str::FromStr for PrGhState {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_ascii_lowercase().as_str() {
+            "open" => Ok(Self::Open),
+            "closed" => Ok(Self::Closed),
+            "merged" => Ok(Self::Merged),
+            _ => Ok(Self::Unknown),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Worktree {
+    pub id: WorktreeId,
+    pub thread_id: ThreadId,
+    pub project_id: ProjectId,
+    pub branch: String,
+    pub path: String,
+    pub pr_number: Option<u32>,
+    pub status: WorktreeStatus,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+    /// Last-observed GitHub PR state (open/closed/merged/unknown).
+    pub pr_state: Option<PrGhState>,
+    /// Merge commit SHA when the PR has been merged — used for revert detection.
+    pub pr_merge_commit: Option<String>,
+    /// Number of PR review comments seen by the poller, persisted across restarts
+    /// so we can compute a true delta and not replay history or lose comments.
+    pub last_seen_comment_count: u32,
+    /// Cached PR URL for quick access (banner, clickable links).
+    pub pr_url: Option<String>,
+}