feat: add session resume, interrupt, error recovery, permissions, context window, notifications, git UI, and PR review

- Session resume: store Claude CLI session_id in DB, use --resume flag on reconnect
- Interrupt: SIGINT on first stop click, force kill on second (two-stage)
- Error recovery: edit/resend, retry, and regenerate buttons on messages
- Tool result fix: proper tool_id matching, stdout/stderr separation in ToolUseCard
- Permission mode: configurable via settings (auto, acceptEdits, bypassPermissions, plan)
- Context window: token usage accumulator with color-coded progress bar in toolbar
- Desktop notifications: Web Notification API for background thread completion/errors
- Git management: status, staging, commit, branch switch, create, push, log panel
- PR review: full review panel with overview, files, checks, comments, and review submission

Author: Swofty-Developments

crates/app/src/handlers/agent.rs

@@ -125,7 +125,7 @@ fn handle_event(
                 description,
             });
         }
-        AgentEvent::SessionReady => {
+        AgentEvent::SessionReady { .. } => {
             state
                 .session_states
                 .insert(session_id, SessionState::Ready);

crates/persistence/src/migrations.rs

@@ -73,5 +73,15 @@ 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 {
+        conn.execute_batch("ALTER TABLE sessions ADD COLUMN claude_session_id TEXT;")?;
+    }
+
     Ok(())
 }

crates/persistence/src/queries.rs

@@ -184,6 +184,25 @@ pub fn delete_messages_by_thread(conn: &Connection, thread_id: Uuid) -> anyhow::
     Ok(())
 }
 
+pub fn delete_messages_after(
+    conn: &Connection,
+    thread_id: Uuid,
+    message_id: Uuid,
+) -> anyhow::Result<u64> {
+    // Get the created_at of the reference message
+    let created_at: String = conn.query_row(
+        "SELECT created_at FROM messages WHERE id = ?1 AND thread_id = ?2",
+        params![message_id.to_string(), thread_id.to_string()],
+        |row| row.get(0),
+    )?;
+    // Delete all messages in the thread created after this message (exclusive)
+    let deleted = conn.execute(
+        "DELETE FROM messages WHERE thread_id = ?1 AND created_at > ?2",
+        params![thread_id.to_string(), created_at],
+    )?;
+    Ok(deleted as u64)
+}
+
 // ---------------------------------------------------------------------------
 // Sessions
 // ---------------------------------------------------------------------------
@@ -234,6 +253,35 @@ pub fn update_session_status(conn: &Connection, id: Uuid, status: &str) -> anyho
     Ok(())
 }
 
+pub fn update_session_claude_id(
+    conn: &Connection,
+    id: Uuid,
+    claude_session_id: &str,
+) -> anyhow::Result<()> {
+    conn.execute(
+        "UPDATE sessions SET claude_session_id = ?1 WHERE id = ?2",
+        params![claude_session_id, id.to_string()],
+    )?;
+    Ok(())
+}
+
+/// Get the most recent Claude session ID for a thread (for --resume).
+pub fn get_latest_claude_session_id(
+    conn: &Connection,
+    thread_id: Uuid,
+) -> anyhow::Result<Option<String>> {
+    let mut stmt = conn.prepare(
+        "SELECT claude_session_id FROM sessions WHERE thread_id = ?1 AND claude_session_id IS NOT NULL ORDER BY created_at DESC LIMIT 1",
+    )?;
+    let mut rows = stmt.query_map(params![thread_id.to_string()], |row| {
+        row.get::<_, Option<String>>(0)
+    })?;
+    match rows.next() {
+        Some(r) => Ok(r?),
+        None => Ok(None),
+    }
+}
+
 pub fn delete_session(conn: &Connection, id: Uuid) -> anyhow::Result<()> {
     conn.execute(
         "DELETE FROM sessions WHERE id = ?1",

crates/session/src/claude.rs

@@ -1,4 +1,5 @@
 use std::path::Path;
+use std::sync::{Arc, Mutex};
 
 use anyhow::{Context, Result};
 use serde_json::Value;
@@ -12,30 +13,70 @@ use crate::types::AgentEvent;
 pub struct ClaudeSession {
     child: Child,
     stdin_tx: mpsc::UnboundedSender<String>,
+    /// The Claude CLI session ID captured from the `system.init` event.
+    claude_session_id: Arc<Mutex<Option<String>>>,
 }
 
 impl ClaudeSession {
     pub async fn start(
         cwd: &Path,
         model: Option<&str>,
+        permission_mode: Option<&str>,
     ) -> Result<(Self, mpsc::UnboundedReceiver<AgentEvent>)> {
+        let perm_mode = permission_mode.unwrap_or("bypassPermissions");
+        let mut args = vec![
+            "-p",
+            "--output-format", "stream-json",
+            "--verbose",
+            "--input-format", "stream-json",
+            "--include-partial-messages",
+            "--permission-mode", perm_mode,
+        ];
+        if let Some(m) = model {
+            args.push("--model");
+            args.push(m);
+        }
+
+        Self::spawn_with_args(cwd, &args).await
+    }
+
+    /// Resume a previous Claude CLI session using `--resume`.
+    pub async fn resume(
+        cwd: &Path,
+        claude_session_id: &str,
+        model: Option<&str>,
+    ) -> Result<(Self, mpsc::UnboundedReceiver<AgentEvent>)> {
+        let resume_id = claude_session_id.to_string();
         let mut args = vec![
             "-p",
             "--output-format", "stream-json",
             "--verbose",
             "--input-format", "stream-json",
             "--include-partial-messages",
-            // bypassPermissions since there's no TTY for Claude Code's
-            // own approval TUI — commands would silently hang otherwise.
             "--permission-mode", "bypassPermissions",
+            "--resume",
         ];
+        // Push the resume ID; we need the String to live long enough.
+        args.push(&resume_id);
         if let Some(m) = model {
             args.push("--model");
             args.push(m);
         }
 
+        Self::spawn_with_args(cwd, &args).await
+    }
+
+    /// Return the captured Claude CLI session ID, if available.
+    pub fn claude_session_id(&self) -> Option<String> {
+        self.claude_session_id.lock().ok().and_then(|g| g.clone())
+    }
+
+    async fn spawn_with_args(
+        cwd: &Path,
+        args: &[&str],
+    ) -> Result<(Self, mpsc::UnboundedReceiver<AgentEvent>)> {
         let mut child = Command::new("claude")
-            .args(&args)
+            .args(args)
             .current_dir(cwd)
             .stdin(std::process::Stdio::piped())
             .stdout(std::process::Stdio::piped())
@@ -49,6 +90,7 @@ impl ClaudeSession {
 
         let (event_tx, event_rx) = mpsc::unbounded_channel();
         let (stdin_tx, mut stdin_rx) = mpsc::unbounded_channel::<String>();
+        let claude_session_id: Arc<Mutex<Option<String>>> = Arc::new(Mutex::new(None));
 
         // Stdin writer
         tokio::spawn(async move {
@@ -62,6 +104,7 @@ impl ClaudeSession {
 
         // Stdout reader
         let tx = event_tx;
+        let session_id_clone = claude_session_id.clone();
         tokio::spawn(async move {
             let reader = BufReader::new(stdout);
             let mut lines = reader.lines();
@@ -72,6 +115,10 @@ impl ClaudeSession {
             let mut got_stream_deltas = false;
             // Track active content blocks by their stream index for tool use / thinking.
             let mut active_blocks = std::collections::HashMap::<u64, BlockInfo>::new();
+            // Map tool_id -> tool_name persisted across the turn so we can
+            // look up names when the "user" tool_result event arrives (after
+            // content_block_end has already removed the block from active_blocks).
+            let mut tool_names = std::collections::HashMap::<String, String>::new();
             // Track model name from message_start so we can use it in result.
             let mut current_model: Option<String> = None;
 
@@ -89,13 +136,26 @@ impl ClaudeSession {
                 let events: Vec<AgentEvent> = match event_type {
                     "system" => {
                         if obj.get("subtype").and_then(|s| s.as_str()) == Some("init") {
-                            vec![AgentEvent::SessionReady]
+                            // Capture the session_id from the init event
+                            let sid = obj.get("session_id").and_then(|s| s.as_str()).map(|s| s.to_string());
+                            if let Some(ref s) = sid {
+                                if let Ok(mut guard) = session_id_clone.lock() {
+                                    *guard = Some(s.clone());
+                                }
+                            }
+                            vec![AgentEvent::SessionReady { claude_session_id: sid }]
                         } else {
                             vec![]
                         }
                     }
                     "stream_event" => {
                         let evts = handle_stream_event(&obj, &mut turn_started, &mut active_blocks, &mut current_model);
+                        // Record tool_id -> tool_name for later lookup
+                        for evt in &evts {
+                            if let AgentEvent::ToolUseStart { tool_id, tool_name } = evt {
+                                tool_names.insert(tool_id.clone(), tool_name.clone());
+                            }
+                        }
                         // Mark that we got real streaming deltas so we skip
                         // the `assistant` snapshot which would duplicate them.
                         if evts.iter().any(|e| matches!(e, AgentEvent::ContentDelta { .. }
@@ -141,6 +201,7 @@ impl ClaudeSession {
                         turn_started = false;
                         got_stream_deltas = false;
                         active_blocks.clear();
+                        tool_names.clear();
                         let evts = handle_result(&obj, &current_model);
                         current_model = None;
                         evts
@@ -155,34 +216,59 @@ impl ClaudeSession {
 
                         if let Some(blocks) = content {
                             let mut evts = Vec::new();
+
+                            // Extract stdout/stderr from top-level tool_use_result
+                            let tool_use_result = obj.get("tool_use_result");
+                            let stdout = tool_use_result
+                                .and_then(|r| r.get("stdout"))
+                                .and_then(|s| s.as_str())
+                                .unwrap_or("");
+                            let stderr = tool_use_result
+                                .and_then(|r| r.get("stderr"))
+                                .and_then(|s| s.as_str())
+                                .unwrap_or("");
+
                             for block in blocks {
                                 if block.get("type").and_then(|t| t.as_str()) == Some("tool_result") {
                                     let tool_use_id = block
                                         .get("tool_use_id")
                                         .and_then(|id| id.as_str())
                                         .unwrap_or("")
                                         .to_string();
-                                    let result_content = block
-                                        .get("content")
-                                        .map(|c| {
-                                            if let Some(s) = c.as_str() {
-                                                s.to_string()
-                                            } else {
-                                                serde_json::to_string_pretty(c).unwrap_or_default()
-                                            }
-                                        })
-                                        .unwrap_or_default();
+
+                                    // Build the result content: prefer stdout/stderr
+                                    // from tool_use_result, fall back to block content
+                                    let result_content = if !stdout.is_empty() || !stderr.is_empty() {
+                                        let mut parts = Vec::new();
+                                        if !stdout.is_empty() {
+                                            parts.push(stdout.to_string());
+                                        }
+                                        if !stderr.is_empty() {
+                                            parts.push(format!("[stderr]\n{stderr}"));
+                                        }
+                                        parts.join("\n")
+                                    } else {
+                                        block
+                                            .get("content")
+                                            .map(|c| {
+                                                if let Some(s) = c.as_str() {
+                                                    s.to_string()
+                                                } else {
+                                                    serde_json::to_string_pretty(c).unwrap_or_default()
+                                                }
+                                            })
+                                            .unwrap_or_default()
+                                    };
+
                                     let is_error = block
                                         .get("is_error")
                                         .and_then(|e| e.as_bool())
                                         .unwrap_or(false);
 
-                                    // Try to get the tool name from tool_use_result
-                                    let tool_name = obj
-                                        .get("tool_use_result")
-                                        .and_then(|r| r.get("stdout"))
-                                        .and_then(|s| s.as_str())
-                                        .map(|_| "Bash".to_string())
+                                    // Look up tool name from the turn's tool_names map
+                                    let tool_name = tool_names
+                                        .get(&tool_use_id)
+                                        .cloned()
                                         .unwrap_or_default();
 
                                     evts.push(AgentEvent::ToolResult {
@@ -213,7 +299,7 @@ impl ClaudeSession {
             debug!("Claude stdout reader finished");
         });
 
-        Ok((Self { child, stdin_tx }, event_rx))
+        Ok((Self { child, stdin_tx, claude_session_id }, event_rx))
     }
 
     pub fn send_message(&self, text: &str) -> Result<()> {

crates/session/src/codex.rs

@@ -153,7 +153,7 @@ impl CodexSession {
             .await
             .context("Codex thread/start failed")?;
 
-        let _ = event_tx.send(AgentEvent::SessionReady);
+        let _ = event_tx.send(AgentEvent::SessionReady { claude_session_id: None });
 
         Ok((session, event_rx))
     }

crates/session/src/manager.rs

@@ -41,12 +41,13 @@ impl SessionManager {
         provider: Provider,
         cwd: &Path,
         model: Option<&str>,
+        permission_mode: Option<&str>,
     ) -> Result<(SessionId, mpsc::UnboundedReceiver<AgentEvent>)> {
         let id = uuid::Uuid::new_v4();
 
         let (active, event_rx) = match provider {
             Provider::ClaudeCode => {
-                let (session, rx) = ClaudeSession::start(cwd, model)
+                let (session, rx) = ClaudeSession::start(cwd, model, permission_mode)
                     .await
                     .context("Failed to start Claude Code session")?;
                 (ActiveSession::Claude(session), rx)
@@ -63,6 +64,33 @@ impl SessionManager {
         Ok((id, event_rx))
     }
 
+    /// Resume a previous Claude Code session using `--resume`.
+    ///
+    /// Returns the new internal session ID and event receiver.
+    pub async fn resume_session(
+        &mut self,
+        claude_session_id: &str,
+        cwd: &Path,
+        model: Option<&str>,
+    ) -> Result<(SessionId, mpsc::UnboundedReceiver<AgentEvent>)> {
+        let id = uuid::Uuid::new_v4();
+
+        let (session, rx) = ClaudeSession::resume(cwd, claude_session_id, model)
+            .await
+            .context("Failed to resume Claude Code session")?;
+
+        self.sessions.insert(id, ActiveSession::Claude(session));
+        Ok((id, rx))
+    }
+
+    /// Get the Claude CLI session ID for an active session, if available.
+    pub fn claude_session_id(&self, session_id: SessionId) -> Option<String> {
+        match self.sessions.get(&session_id) {
+            Some(ActiveSession::Claude(s)) => s.claude_session_id(),
+            _ => None,
+        }
+    }
+
     /// Send a message to an existing session.
     pub async fn send_message(&mut self, session_id: SessionId, text: &str) -> Result<()> {
         let session = self

crates/session/src/types.rs

@@ -42,7 +42,11 @@ pub enum AgentEvent {
         description: String,
     },
     /// The session is ready to accept input.
-    SessionReady,
+    SessionReady {
+        /// The Claude CLI session ID (for `--resume`), if available.
+        #[serde(skip_serializing_if = "Option::is_none")]
+        claude_session_id: Option<String>,
+    },
     /// An error occurred in the session.
     SessionError { message: String },
     /// Usage/cost report for a completed turn.

crates/session/tests/claude_integration.rs

@@ -41,7 +41,7 @@ async fn claude_code_send_and_receive() {
         match timeout(Duration::from_secs(30), rx.recv()).await {
             Ok(Some(event)) => {
                 match &event {
-                    AgentEvent::SessionReady => {
+                    AgentEvent::SessionReady { .. } => {
                         println!("[OK] SessionReady");
                         got_session_ready = true;
                     }