Add process detection and session summaries

- Detect running Claude processes to distinguish active vs inactive sessions
- Show session summary from JSONL log entries
- Add Inactive status for sessions without a running Claude process
- Sort sessions by status priority (Working > Needs Input > Waiting > Idle > Inactive)
- Live view only shows active sessions, with inactive count in summary

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: yepzdk

internal/session/session.go

@@ -2,8 +2,10 @@ package session
 
 import (
 	"bufio"
+	"bytes"
 	"encoding/json"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -18,6 +20,7 @@ const (
 	StatusNeedsInput   Status = "Needs Input"
 	StatusWaiting      Status = "Waiting"
 	StatusIdle         Status = "Idle"
+	StatusInactive     Status = "Inactive"
 )
 
 // Session represents a Claude Code session
@@ -26,7 +29,9 @@ type Session struct {
 	Status       Status    `json:"status"`
 	LastActivity time.Time `json:"last_activity"`
 	Task         string    `json:"task"`
+	Summary      string    `json:"summary,omitempty"`
 	LogFile      string    `json:"-"`
+	ProjectPath  string    `json:"-"` // Full path to the project directory
 }
 
 // LogEntry represents a single line in the JSONL log
@@ -35,6 +40,7 @@ type LogEntry struct {
 	Subtype   string    `json:"subtype,omitempty"`
 	Timestamp time.Time `json:"timestamp"`
 	Message   *Message  `json:"message,omitempty"`
+	Summary   string    `json:"summary,omitempty"` // For type: "summary" entries
 }
 
 // Message represents the message field in a log entry
@@ -56,6 +62,52 @@ func ClaudeProjectsDir() string {
 	return filepath.Join(home, ".claude", "projects")
 }
 
+// getRunningClaudeDirs returns a set of encoded directory names where Claude processes are running
+// The keys are in the same format as the project directory names (e.g., -Users-username-Projects-...)
+func getRunningClaudeDirs() map[string]bool {
+	dirs := make(map[string]bool)
+
+	// Use ps to get Claude process IDs (more reliable than pgrep)
+	cmd := exec.Command("sh", "-c", "ps ax -o pid,comm | grep '[c]laude$' | awk '{print $1}'")
+	output, err := cmd.Output()
+	if err != nil {
+		return dirs
+	}
+
+	pids := strings.Fields(string(output))
+	for _, pid := range pids {
+		// Get cwd for each process using lsof
+		lsofCmd := exec.Command("lsof", "-p", pid)
+		lsofOutput, err := lsofCmd.Output()
+		if err != nil {
+			continue
+		}
+
+		// Parse lsof output to find cwd
+		lines := bytes.Split(lsofOutput, []byte("\n"))
+		for _, line := range lines {
+			if bytes.Contains(line, []byte(" cwd ")) {
+				fields := bytes.Fields(line)
+				if len(fields) >= 9 {
+					// Last field is the path
+					path := string(fields[len(fields)-1])
+					// Convert to encoded format (same as project directory names)
+					encoded := encodeProjectPath(path)
+					dirs[encoded] = true
+				}
+			}
+		}
+	}
+
+	return dirs
+}
+
+// encodeProjectPath converts a filesystem path to the encoded directory name format
+func encodeProjectPath(path string) string {
+	// /Users/username/Projects/org/project -> -Users-username-Projects-org-project
+	return strings.ReplaceAll(path, "/", "-")
+}
+
 // Discover finds all active Claude sessions
 func Discover() ([]Session, error) {
 	projectsDir := ClaudeProjectsDir()
@@ -65,6 +117,9 @@ func Discover() ([]Session, error) {
 		return nil, err
 	}
 
+	// Get directories where Claude is currently running
+	runningDirs := getRunningClaudeDirs()
+
 	var sessions []Session
 
 	for _, entry := range entries {
@@ -83,22 +138,45 @@ func Discover() ([]Session, error) {
 			continue
 		}
 
-		session, err := parseSession(entry.Name(), logFile)
+		session, err := parseSession(entry.Name(), logFile, runningDirs)
 		if err != nil {
 			continue
 		}
 
 		sessions = append(sessions, session)
 	}
 
-	// Sort by last activity (most recent first)
+	// Sort by status priority, then by last activity
 	sort.Slice(sessions, func(i, j int) bool {
+		// Priority: Working > NeedsInput > Waiting > Idle > Inactive
+		pi, pj := statusPriority(sessions[i].Status), statusPriority(sessions[j].Status)
+		if pi != pj {
+			return pi < pj
+		}
 		return sessions[i].LastActivity.After(sessions[j].LastActivity)
 	})
 
 	return sessions, nil
 }
 
+// statusPriority returns the sort priority for a status (lower = higher priority)
+func statusPriority(s Status) int {
+	switch s {
+	case StatusWorking:
+		return 0
+	case StatusNeedsInput:
+		return 1
+	case StatusWaiting:
+		return 2
+	case StatusIdle:
+		return 3
+	case StatusInactive:
+		return 4
+	default:
+		return 5
+	}
+}
+
 // findMostRecentLog finds the most recently modified .jsonl file in a directory
 func findMostRecentLog(dir string) (string, error) {
 	entries, err := os.ReadDir(dir)
@@ -139,13 +217,18 @@ func findMostRecentLog(dir string) (string, error) {
 }
 
 // parseSession parses a session from its log file
-func parseSession(projectName, logFile string) (Session, error) {
+func parseSession(projectName, logFile string, runningDirs map[string]bool) (Session, error) {
 	session := Session{
-		Project: decodeProjectName(projectName),
-		LogFile: logFile,
-		Status:  StatusIdle,
+		Project:     decodeProjectName(projectName),
+		LogFile:     logFile,
+		Status:      StatusInactive, // Default to inactive
+		ProjectPath: projectName,    // Store the encoded name for matching
 	}
 
+	// Check if Claude is running in this project directory
+	// runningDirs keys are in the same encoded format as projectName
+	isRunning := runningDirs[projectName]
+
 	// Get file modification time as fallback for last activity
 	info, err := os.Stat(logFile)
 	if err != nil {
@@ -154,7 +237,7 @@ func parseSession(projectName, logFile string) (Session, error) {
 	session.LastActivity = info.ModTime()
 
 	// Read last N lines of the file to determine status
-	entries, err := readLastEntries(logFile, 50)
+	entries, err := readLastEntries(logFile, 100)
 	if err != nil {
 		return session, nil // Return with defaults
 	}
@@ -163,8 +246,11 @@ func parseSession(projectName, logFile string) (Session, error) {
 		return session, nil
 	}
 
+	// Extract summary from entries
+	session.Summary = extractSummary(entries)
+
 	// Determine status from log entries
-	session.Status, session.Task = determineStatus(entries)
+	session.Status, session.Task = determineStatus(entries, isRunning)
 
 	// Get actual last activity timestamp from entries
 	for i := len(entries) - 1; i >= 0; i-- {
@@ -177,6 +263,17 @@ func parseSession(projectName, logFile string) (Session, error) {
 	return session, nil
 }
 
+// extractSummary finds the most recent summary entry
+func extractSummary(entries []LogEntry) string {
+	// Look for the most recent summary entry
+	for i := len(entries) - 1; i >= 0; i-- {
+		if entries[i].Type == "summary" && entries[i].Summary != "" {
+			return entries[i].Summary
+		}
+	}
+	return ""
+}
+
 // decodeProjectName converts the directory name to a readable project name
 func decodeProjectName(name string) string {
 	// Format: -Users-username-Projects-org-project
@@ -253,9 +350,12 @@ func readLastEntries(filePath string, count int) ([]LogEntry, error) {
 }
 
 // determineStatus analyzes log entries to determine session status
-func determineStatus(entries []LogEntry) (Status, string) {
+func determineStatus(entries []LogEntry, isRunning bool) (Status, string) {
 	if len(entries) == 0 {
-		return StatusIdle, "-"
+		if isRunning {
+			return StatusIdle, "-"
+		}
+		return StatusInactive, "-"
 	}
 
 	var lastAssistant *LogEntry
@@ -292,6 +392,11 @@ func determineStatus(entries []LogEntry) (Status, string) {
 		}
 	}
 
+	// If Claude is not running, session is inactive
+	if !isRunning {
+		return StatusInactive, "-"
+	}
+
 	// Check for idle (5+ minutes since last activity)
 	if time.Since(lastTimestamp) > 5*time.Minute {
 		return StatusIdle, "-"

internal/ui/ui.go

@@ -28,6 +28,7 @@ const (
 	SymbolNeedsInput = "⚠"
 	SymbolWaiting    = "◉"
 	SymbolIdle       = "○"
+	SymbolInactive   = "◌"
 )
 
 // RenderList renders sessions as a simple list (for -l flag)
@@ -38,18 +39,24 @@ func RenderList(sessions []session.Session) {
 	}
 
 	// Header
-	fmt.Printf("%-15s %-35s %-15s %s\n", "STATUS", "PROJECT", "LAST ACTIVITY", "TASK")
-	fmt.Println(strings.Repeat("─", 80))
+	fmt.Printf("%-15s %-35s %-15s %s\n", "STATUS", "PROJECT", "LAST ACTIVITY", "SUMMARY")
+	fmt.Println(strings.Repeat("─", 100))
 
 	for _, s := range sessions {
 		symbol, color := getStatusDisplay(s.Status)
 		elapsed := formatElapsed(time.Since(s.LastActivity))
 
+		// Use summary if available, otherwise task
+		desc := s.Summary
+		if desc == "" {
+			desc = s.Task
+		}
+
 		fmt.Printf("%s%s %-13s%s %-35s %-15s %s\n",
 			color, symbol, s.Status, Reset,
 			truncate(s.Project, 35),
 			elapsed,
-			truncate(s.Task, 30))
+			truncate(desc, 40))
 	}
 }
 
@@ -68,29 +75,46 @@ func RenderLive(sessions []session.Session) {
 	// Header
 	fmt.Printf("%s🤖 Claude Code Sessions%s\n\n", Bold, Reset)
 
-	// Status summary
-	counts := countByStatus(sessions)
+	// Split sessions into active and inactive
+	var active, inactive []session.Session
+	for _, s := range sessions {
+		if s.Status == session.StatusInactive {
+			inactive = append(inactive, s)
+		} else {
+			active = append(active, s)
+		}
+	}
+
+	// Status summary (only active sessions)
+	counts := countByStatus(active)
 	fmt.Printf("%s%s Working: %d%s  ", Green, SymbolWorking, counts[session.StatusWorking], Reset)
 	fmt.Printf("%s%s Needs Input: %d%s  ", Yellow, SymbolNeedsInput, counts[session.StatusNeedsInput], Reset)
 	fmt.Printf("%s%s Waiting: %d%s  ", Blue, SymbolWaiting, counts[session.StatusWaiting], Reset)
-	fmt.Printf("%s%s Idle: %d%s\n\n", Gray, SymbolIdle, counts[session.StatusIdle], Reset)
+	fmt.Printf("%s%s Idle: %d%s  ", Gray, SymbolIdle, counts[session.StatusIdle], Reset)
+	fmt.Printf("%s%s Inactive: %d%s\n\n", Dim, SymbolInactive, len(inactive), Reset)
 
-	if len(sessions) == 0 {
-		fmt.Printf("%sNo active Claude sessions found.%s\n", Dim, Reset)
+	if len(active) == 0 {
+		fmt.Printf("%sNo active Claude sessions.%s\n", Dim, Reset)
 	} else {
 		// Column headers
-		fmt.Printf("  %-15s %-35s %-15s %s\n", "STATUS", "PROJECT", "LAST ACTIVITY", "CURRENT TASK")
-		fmt.Printf("  %s\n", strings.Repeat("─", 78))
+		fmt.Printf("  %-15s %-35s %-15s %s\n", "STATUS", "PROJECT", "LAST ACTIVITY", "SUMMARY")
+		fmt.Printf("  %s\n", strings.Repeat("─", 95))
 
-		for _, s := range sessions {
+		for _, s := range active {
 			symbol, color := getStatusDisplay(s.Status)
 			elapsed := formatElapsed(time.Since(s.LastActivity))
 
+			// Use summary if available, otherwise task
+			desc := s.Summary
+			if desc == "" {
+				desc = s.Task
+			}
+
 			fmt.Printf("  %s%s %-13s%s %-35s %-15s %s\n",
 				color, symbol, s.Status, Reset,
 				truncate(s.Project, 35),
 				elapsed,
-				truncate(s.Task, 25))
+				truncate(desc, 35))
 		}
 	}
 
@@ -123,8 +147,10 @@ func getStatusDisplay(status session.Status) (string, string) {
 		return SymbolWaiting, Blue
 	case session.StatusIdle:
 		return SymbolIdle, Gray
+	case session.StatusInactive:
+		return SymbolInactive, Dim
 	default:
-		return SymbolIdle, Reset
+		return SymbolInactive, Reset
 	}
 }