diff --git a/README.md b/README.md
index 99226d2..fa35398 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # ccview
 
-A terminal-based explorer and renderer for [Claude Code](https://docs.anthropic.com/en/docs/claude-code) and [OpenCode](https://github.com/opencode-ai/opencode) conversation histories. Browse projects, view conversations with markdown rendering, inspect sub-agents, search across sessions, and export to HTML/Markdown/JSONL.
+A terminal-based explorer and renderer for [Claude Code](https://docs.anthropic.com/en/docs/claude-code), [OpenCode](https://github.com/opencode-ai/opencode), and Codex CLI conversation histories. Browse projects, view conversations with markdown rendering, inspect sub-agents, search across sessions, and export to HTML/Markdown/JSONL.
 
 Built with [Bubble Tea](https://github.com/charmbracelet/bubbletea), [Lip Gloss](https://github.com/charmbracelet/lipgloss), and [Glamour](https://github.com/charmbracelet/glamour).
 
@@ -85,7 +85,7 @@ ccview
 
 Split-pane interactive explorer. Left pane shows the project tree with conversations, plans, and memory files. Right pane renders conversation content with syntax-highlighted markdown.
 
-- **Multi-provider support** - Claude Code (`~/.claude/`) and OpenCode (`~/.local/share/opencode/opencode.db`) side by side. Tabbed UI when both are available; tabs hidden with only one provider.
+- **Multi-provider support** - Claude Code (`~/.claude/`), OpenCode (`~/.local/share/opencode/opencode.db`), and Codex (`~/.codex/`) side by side. Tabbed UI when multiple providers are available; tabs hidden with only one provider.
 - Conversations sorted newest-first with smart timestamps
 - Sub-agents collapsed by default, expand on selection
 - Global plans shown in sidebar
@@ -141,7 +141,7 @@ For full conversations with sub-agents, HTML export creates a directory with `in
 
 | Key | Action |
 |-----|--------|
-| `1` / `2` | Switch provider tab |
+| `1`-`9` | Switch provider tab |
 | `/` | Open session search (global) |
 
 ### Viewer
@@ -193,6 +193,21 @@ ccview reads from multiple sources:
 | Sessions | Grouped by project (worktree path) |
 | Message parts | Text, tool calls, reasoning, patches, and file references |
 
+#### Codex CLI (`~/.codex/`)
+
+| Source | Description |
+|--------|-------------|
+| `~/.codex/sessions/YYYY/MM/DD/*.jsonl` | JSONL rollout session logs |
+| `~/.codex/state_*.sqlite` | Thread index with cwd, title, git metadata, model, source, token totals, and subagent edges |
+| `session_meta` records | Session ID, cwd, originator, CLI version, model provider |
+| `response_item` records | User/assistant messages, reasoning summaries, function calls, tool outputs |
+| `turn_context` records | Runtime context such as model, sandbox, approval policy, timezone |
+| `event_msg` records | Token usage, task lifecycle, patch/file-edit, web search, and image-generation metadata |
+| `~/.codex/session_index.jsonl` | Session titles and updated timestamps |
+| `~/.codex/shell_snapshots/*.sh` | Shell environment snapshots linked back to sessions when available |
+| `~/.codex/goals_*.sqlite` | Thread goals and token budgets (available for future UI surfacing) |
+| `~/.codex/history.jsonl` | Prompt history by session (available for future fallback titles/search) |
+
 ### Message types rendered
 
 - **User messages** - with markdown rendering
@@ -208,6 +223,7 @@ main.go              CLI entry point, flag parsing
 provider.go          Provider interface (abstracts data sources)
 provider_claude.go   Claude Code provider (filesystem/JSONL)
 provider_opencode.go OpenCode provider (SQLite)
+provider_codex.go    Codex provider (filesystem/JSONL rollouts)
 data.go              Tree types, project scanning, filesystem loading
 parse.go             JSONL parsing, glamour rendering, formatting helpers
 ui.go                Bubble Tea TUI with split-pane layout, search
diff --git a/data.go b/data.go
index 4f6f6a9..abd4fa6 100644
--- a/data.go
+++ b/data.go
@@ -21,9 +21,10 @@ type TreeData struct {
 }
 
 type TreeStats struct {
-	TotalProjects      int `json:"totalProjects"`
-	TotalConversations int `json:"totalConversations"`
-	TotalMessages      int `json:"totalMessages"`
+	TotalProjects      int   `json:"totalProjects"`
+	TotalConversations int   `json:"totalConversations"`
+	TotalMessages      int   `json:"totalMessages"`
+	TotalTokens        int64 `json:"totalTokens,omitempty"`
 }
 
 type TreeFileRef struct {
@@ -41,24 +42,29 @@ type TreeProject struct {
 	LastActive    string             `json:"lastActive"`
 	ConvCount     int                `json:"convCount"`
 	MsgCount      int                `json:"msgCount"`
-	Source        string             `json:"source,omitempty"` // "claude" or "opencode"
+	TokenCount    int64              `json:"tokenCount,omitempty"`
+	Source        string             `json:"source,omitempty"` // "claude", "opencode", or "codex"
 }
 
 type TreeConversation struct {
-	SessionID     string         `json:"sessionId"`
-	Path          string         `json:"path"`
-	ModTime       string         `json:"modTime"`
-	Title         string         `json:"title"`
-	Preview       string         `json:"preview"`
-	MsgCount      int            `json:"msgCount"`
-	CWD           string         `json:"cwd,omitempty"`
-	Version       string         `json:"version,omitempty"`
-	GitBranch     string         `json:"gitBranch,omitempty"`
-	Slug          string         `json:"slug,omitempty"`
-	SubAgents     []TreeSubAgent `json:"subAgents,omitempty"`
-	FileEditCount int            `json:"fileEditCount,omitempty"`
-	ToolResults   int            `json:"toolResults,omitempty"`
-	Source        string         `json:"source,omitempty"` // "claude" or "opencode"
+	SessionID      string         `json:"sessionId"`
+	Path           string         `json:"path"`
+	ModTime        string         `json:"modTime"`
+	Title          string         `json:"title"`
+	Preview        string         `json:"preview"`
+	MsgCount       int            `json:"msgCount"`
+	TokenCount     int64          `json:"tokenCount,omitempty"`
+	Model          string         `json:"model,omitempty"`
+	Reasoning      string         `json:"reasoning,omitempty"`
+	CWD            string         `json:"cwd,omitempty"`
+	Version        string         `json:"version,omitempty"`
+	GitBranch      string         `json:"gitBranch,omitempty"`
+	Slug           string         `json:"slug,omitempty"`
+	SubAgents      []TreeSubAgent `json:"subAgents,omitempty"`
+	ShellSnapshots []TreeFileRef  `json:"shellSnapshots,omitempty"`
+	FileEditCount  int            `json:"fileEditCount,omitempty"`
+	ToolResults    int            `json:"toolResults,omitempty"`
+	Source         string         `json:"source,omitempty"` // "claude", "opencode", or "codex"
 }
 
 type TreeSubAgent struct {
diff --git a/export.go b/export.go
index 29eaf50..e40a627 100644
--- a/export.go
+++ b/export.go
@@ -19,7 +19,7 @@ const exportHTMLHeader = `<!DOCTYPE html>
 <head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>Claude Code Conversation</title>
+<title>AI Conversation</title>
 <style>
 * { box-sizing: border-box; }
 body {
@@ -138,7 +138,7 @@ a { color: #58a6ff; }
 </head>
 <body>
 <div class="header">
-<h1>Claude Code Conversation</h1>
+<h1>AI Conversation</h1>
 <div class="meta">Source: %s</div>
 </div>
 `
@@ -273,7 +273,7 @@ func exportMarkdown(entries []Entry, outPath, sourcePath string) error {
 	}
 	defer f.Close()
 
-	fmt.Fprintf(f, "# Claude Code Conversation\n\nSource: `%s`\n\n---\n\n", sourcePath)
+	fmt.Fprintf(f, "# AI Conversation\n\nSource: `%s`\n\n---\n\n", sourcePath)
 
 	for _, entry := range entries {
 		switch entry.Type {
@@ -367,7 +367,7 @@ func exportHTMLDir(convPath string, proj *TreeProject, outDir, indexName string)
 
 	if conv == nil || len(conv.SubAgents) == 0 {
 		// No subagents, just export single file
-		entries, err := parseConversation(convPath)
+		entries, err := parseAnyConversation(convPath)
 		if err != nil {
 			return err
 		}
@@ -401,7 +401,7 @@ func exportHTMLDir(convPath string, proj *TreeProject, outDir, indexName string)
 	navHTML := navBuf.String()
 
 	// Export main conversation as index.html with nav
-	entries, err := parseConversation(convPath)
+	entries, err := parseAnyConversation(convPath)
 	if err != nil {
 		return err
 	}
@@ -420,7 +420,7 @@ func exportHTMLDir(convPath string, proj *TreeProject, outDir, indexName string)
 			at = "agent"
 		}
 		saFile := fmt.Sprintf("subagent-%s-%s.html", at, sa.Name[:min(8, len(sa.Name))])
-		saEntries, err := parseConversation(sa.Path)
+		saEntries, err := parseAnyConversation(sa.Path)
 		if err != nil {
 			continue
 		}
diff --git a/main.go b/main.go
index cafd112..5dfa932 100644
--- a/main.go
+++ b/main.go
@@ -36,7 +36,7 @@ func main() {
 			fmt.Fprintln(os.Stderr, "Usage: ccview --export output.html --file conversation.jsonl")
 			os.Exit(1)
 		}
-		entries, err := parseConversation(src)
+		entries, err := parseAnyConversation(src)
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Error parsing %s: %v\n", src, err)
 			os.Exit(1)
@@ -50,17 +50,9 @@ func main() {
 	}
 
 	// Discover available providers
-	var providers []Provider
-	claude := &ClaudeProvider{}
-	if claude.Available() {
-		providers = append(providers, claude)
-	}
-	opencode := NewOpenCodeProvider()
-	if opencode.Available() {
-		providers = append(providers, opencode)
-	}
+	providers := discoverProviders()
 	if len(providers) == 0 && *filePath == "" {
-		fmt.Fprintln(os.Stderr, "No session data found. Checked ~/.claude/ and ~/.local/share/opencode/")
+		fmt.Fprintln(os.Stderr, "No session data found. Checked ~/.claude/, ~/.local/share/opencode/, and ~/.codex/")
 		os.Exit(1)
 	}
 
diff --git a/parse.go b/parse.go
index b24e457..abfab02 100644
--- a/parse.go
+++ b/parse.go
@@ -89,6 +89,13 @@ func parseConversation(path string) ([]Entry, error) {
 	return entries, scanner.Err()
 }
 
+func parseAnyConversation(path string) ([]Entry, error) {
+	if isCodexSessionFile(path) {
+		return NewCodexProvider().parseSession(path)
+	}
+	return parseConversation(path)
+}
+
 // ── Metadata scanning (fast single-pass) ──
 
 type conversationMeta struct {
diff --git a/provider.go b/provider.go
index ad18498..4904c3c 100644
--- a/provider.go
+++ b/provider.go
@@ -1,5 +1,11 @@
 package main
 
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
 // Provider abstracts a session data source (Claude Code, OpenCode, etc.).
 type Provider interface {
 	Name() string
@@ -19,3 +25,72 @@ type SearchResult struct {
 	ModTime     string
 	ProjIndex   int // index into provider's tree.Projects
 }
+
+func discoverProviders() []Provider {
+	var providers []Provider
+	claude := &ClaudeProvider{}
+	if claude.Available() {
+		providers = append(providers, claude)
+	}
+	opencode := NewOpenCodeProvider()
+	if opencode.Available() {
+		providers = append(providers, opencode)
+	}
+	codex := NewCodexProvider()
+	if codex.Available() {
+		providers = append(providers, codex)
+	}
+	return providers
+}
+
+func mergeProviderTrees(providers []Provider) (*TreeData, error) {
+	merged := &TreeData{}
+	for _, provider := range providers {
+		tree, err := provider.LoadTree()
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", provider.Name(), err)
+		}
+		if tree == nil {
+			continue
+		}
+		if merged.ClaudeDir == "" {
+			merged.ClaudeDir = tree.ClaudeDir
+		}
+		if merged.GlobalClaudeMD == "" {
+			merged.GlobalClaudeMD = tree.GlobalClaudeMD
+		}
+		merged.Plans = append(merged.Plans, tree.Plans...)
+		merged.Projects = append(merged.Projects, tree.Projects...)
+		merged.Stats.TotalProjects += tree.Stats.TotalProjects
+		merged.Stats.TotalConversations += tree.Stats.TotalConversations
+		merged.Stats.TotalMessages += tree.Stats.TotalMessages
+		merged.Stats.TotalTokens += tree.Stats.TotalTokens
+	}
+	sort.Slice(merged.Projects, func(i, j int) bool {
+		return merged.Projects[i].LastActive > merged.Projects[j].LastActive
+	})
+	return merged, nil
+}
+
+func providerForSource(providers []Provider, source string) Provider {
+	source = strings.ToLower(source)
+	for _, provider := range providers {
+		if providerSourceKey(provider) == source {
+			return provider
+		}
+	}
+	return nil
+}
+
+func providerSourceKey(provider Provider) string {
+	switch provider.(type) {
+	case *ClaudeProvider:
+		return "claude"
+	case *OpenCodeProvider:
+		return "opencode"
+	case *CodexProvider:
+		return "codex"
+	default:
+		return strings.ToLower(strings.ReplaceAll(provider.Name(), " ", ""))
+	}
+}
diff --git a/provider_codex.go b/provider_codex.go
new file mode 100644
index 0000000..a34cf1e
--- /dev/null
+++ b/provider_codex.go
@@ -0,0 +1,889 @@
+package main
+
+import (
+	"bufio"
+	"database/sql"
+	"encoding/json"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+)
+
+// CodexProvider loads sessions from Codex CLI's ~/.codex/ directory.
+type CodexProvider struct {
+	codexDir    string
+	sessionsDir string
+	shellDir    string
+	indexPath   string
+	statePath   string
+}
+
+func NewCodexProvider() *CodexProvider {
+	home, _ := os.UserHomeDir()
+	codexDir := filepath.Join(home, ".codex")
+	return &CodexProvider{
+		codexDir:    codexDir,
+		sessionsDir: filepath.Join(codexDir, "sessions"),
+		shellDir:    filepath.Join(codexDir, "shell_snapshots"),
+		indexPath:   filepath.Join(codexDir, "session_index.jsonl"),
+		statePath:   latestCodexStatePath(codexDir),
+	}
+}
+
+func (p *CodexProvider) Name() string { return "Codex" }
+
+func (p *CodexProvider) Available() bool {
+	return dirExists(p.sessionsDir)
+}
+
+func latestCodexStatePath(codexDir string) string {
+	matches, err := filepath.Glob(filepath.Join(codexDir, "state_*.sqlite"))
+	if err != nil || len(matches) == 0 {
+		return filepath.Join(codexDir, "state_5.sqlite")
+	}
+	sort.Slice(matches, func(i, j int) bool {
+		iInfo, iErr := os.Stat(matches[i])
+		jInfo, jErr := os.Stat(matches[j])
+		if iErr == nil && jErr == nil && !iInfo.ModTime().Equal(jInfo.ModTime()) {
+			return iInfo.ModTime().After(jInfo.ModTime())
+		}
+		return matches[i] > matches[j]
+	})
+	return matches[0]
+}
+
+func (p *CodexProvider) LoadTree() (*TreeData, error) {
+	titles := p.loadSessionTitles()
+	threads, spawnEdges := p.loadThreadMetadata()
+	shellSnapshots := p.loadShellSnapshots()
+	childSessionIDs := map[string]bool{}
+	for _, edge := range spawnEdges {
+		childSessionIDs[edge.ChildThreadID] = true
+	}
+	projects := map[string]*TreeProject{}
+
+	err := filepath.WalkDir(p.sessionsDir, func(path string, d fs.DirEntry, err error) error {
+		if err != nil || d.IsDir() || !strings.HasSuffix(d.Name(), ".jsonl") {
+			return nil
+		}
+
+		meta := p.scanSessionMeta(path)
+		if meta.SessionID == "" {
+			meta.SessionID = codexSessionIDFromPath(path)
+		}
+		if meta.SessionID == "" && meta.MsgCount == 0 {
+			return nil
+		}
+		thread, hasThread := threads[meta.SessionID]
+		if hasThread {
+			if thread.Title != "" {
+				meta.Title = thread.Title
+			}
+			if thread.UpdatedAt != "" {
+				meta.UpdatedAt = thread.UpdatedAt
+			}
+			if thread.CWD != "" {
+				meta.CWD = thread.CWD
+			}
+			if thread.CLIVersion != "" {
+				meta.Version = thread.CLIVersion
+			}
+			if thread.Preview != "" && meta.Preview == "" {
+				meta.Preview = thread.Preview
+			}
+		}
+
+		if meta.Title == "" {
+			if title, ok := titles[meta.SessionID]; ok && title.Title != "" {
+				meta.Title = title.Title
+				if title.UpdatedAt != "" && meta.UpdatedAt == "" {
+					meta.UpdatedAt = title.UpdatedAt
+				}
+			}
+		} else if title, ok := titles[meta.SessionID]; ok && title.UpdatedAt != "" && meta.UpdatedAt == "" {
+			meta.UpdatedAt = title.UpdatedAt
+		}
+		if meta.Title == "" {
+			meta.Title = meta.Preview
+		}
+		if meta.Title == "" {
+			meta.Title = meta.SessionID
+		}
+
+		cwd := meta.CWD
+		if cwd == "" {
+			cwd = "(unknown)"
+		}
+		proj := projects[cwd]
+		if proj == nil {
+			proj = &TreeProject{
+				DisplayName: shortenPath(cwd),
+				DirName:     cwd,
+				DirPath:     cwd,
+				Source:      "codex",
+			}
+			projects[cwd] = proj
+		}
+
+		modTime := meta.UpdatedAt
+		if modTime == "" {
+			modTime = meta.LastTimestamp
+		}
+		if modTime == "" {
+			if info, statErr := os.Stat(path); statErr == nil {
+				modTime = info.ModTime().Format(time.RFC3339)
+			}
+		}
+
+		conv := TreeConversation{
+			SessionID:      meta.SessionID,
+			Path:           path,
+			ModTime:        modTime,
+			Title:          truncateCodexText(meta.Title, 80),
+			Preview:        truncateCodexText(meta.Preview, 100),
+			MsgCount:       meta.MsgCount,
+			CWD:            meta.CWD,
+			Version:        meta.Version,
+			Slug:           meta.Originator,
+			ShellSnapshots: shellSnapshots[meta.SessionID],
+			FileEditCount:  meta.FileEditCount,
+			ToolResults:    meta.ToolResults,
+			Source:         "codex",
+		}
+		if hasThread {
+			conv.TokenCount = thread.TokensUsed
+			conv.Model = thread.Model
+			conv.Reasoning = thread.ReasoningEffort
+			conv.GitBranch = thread.GitBranch
+			conv.Slug = thread.SourceLabel()
+		}
+		proj.Conversations = append(proj.Conversations, conv)
+
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	var tree TreeData
+	childAgents := buildCodexSubAgents(threads, spawnEdges)
+	for _, proj := range projects {
+		var conversations []TreeConversation
+		for _, conv := range proj.Conversations {
+			if agents := childAgents[conv.SessionID]; len(agents) > 0 {
+				conv.SubAgents = agents
+			}
+			if childSessionIDs[conv.SessionID] {
+				continue
+			}
+			conversations = append(conversations, conv)
+			proj.ConvCount++
+			proj.MsgCount += conv.MsgCount
+			proj.TokenCount += conv.TokenCount
+			if proj.LastActive == "" || conv.ModTime > proj.LastActive {
+				proj.LastActive = conv.ModTime
+			}
+		}
+		proj.Conversations = conversations
+		sort.Slice(proj.Conversations, func(i, j int) bool {
+			return proj.Conversations[i].ModTime > proj.Conversations[j].ModTime
+		})
+		if len(proj.Conversations) == 0 {
+			continue
+		}
+		tree.Projects = append(tree.Projects, *proj)
+	}
+	sort.Slice(tree.Projects, func(i, j int) bool {
+		return tree.Projects[i].LastActive > tree.Projects[j].LastActive
+	})
+	for _, proj := range tree.Projects {
+		tree.Stats.TotalProjects++
+		tree.Stats.TotalConversations += proj.ConvCount
+		tree.Stats.TotalMessages += proj.MsgCount
+		tree.Stats.TotalTokens += proj.TokenCount
+	}
+
+	return &tree, nil
+}
+
+func (p *CodexProvider) LoadConversation(path string) ([]Entry, error) {
+	return p.parseSession(path)
+}
+
+func (p *CodexProvider) SearchSessions(query, projectID string) []SearchResult {
+	tree, err := p.LoadTree()
+	if err != nil || tree == nil {
+		return nil
+	}
+	q := strings.ToLower(query)
+	var results []SearchResult
+	for i, proj := range tree.Projects {
+		if projectID != "" && proj.DirName != projectID {
+			continue
+		}
+		for _, conv := range proj.Conversations {
+			if strings.Contains(strings.ToLower(conv.Title), q) ||
+				strings.Contains(strings.ToLower(conv.Preview), q) ||
+				strings.Contains(strings.ToLower(conv.SessionID), q) ||
+				strings.Contains(strings.ToLower(proj.DisplayName), q) {
+				results = append(results, SearchResult{
+					Source:      "codex",
+					ProjectName: proj.DisplayName,
+					Title:       conv.Title,
+					Preview:     conv.Preview,
+					Path:        conv.Path,
+					ModTime:     conv.ModTime,
+					ProjIndex:   i,
+				})
+			}
+		}
+	}
+	return results
+}
+
+type codexSessionTitle struct {
+	Title     string
+	UpdatedAt string
+}
+
+func (p *CodexProvider) loadSessionTitles() map[string]codexSessionTitle {
+	titles := map[string]codexSessionTitle{}
+	f, err := os.Open(p.indexPath)
+	if err != nil {
+		return titles
+	}
+	defer f.Close()
+
+	scanner := bufio.NewScanner(f)
+	scanner.Buffer(make([]byte, 0), 1024*1024)
+	for scanner.Scan() {
+		var entry struct {
+			ID         string `json:"id"`
+			ThreadName string `json:"thread_name"`
+			UpdatedAt  string `json:"updated_at"`
+		}
+		if json.Unmarshal(scanner.Bytes(), &entry) != nil || entry.ID == "" {
+			continue
+		}
+		titles[entry.ID] = codexSessionTitle{Title: entry.ThreadName, UpdatedAt: entry.UpdatedAt}
+	}
+	return titles
+}
+
+type codexThreadMetadata struct {
+	ID              string
+	RolloutPath     string
+	CWD             string
+	Title           string
+	Preview         string
+	Source          string
+	ModelProvider   string
+	Model           string
+	ReasoningEffort string
+	CLIVersion      string
+	GitBranch       string
+	AgentNickname   string
+	AgentRole       string
+	UpdatedAt       string
+	TokensUsed      int64
+}
+
+func (t codexThreadMetadata) SourceLabel() string {
+	if t.AgentNickname != "" {
+		if t.AgentRole != "" {
+			return "subagent: " + t.AgentNickname + " (" + t.AgentRole + ")"
+		}
+		return "subagent: " + t.AgentNickname
+	}
+	if strings.HasPrefix(t.Source, "{") {
+		var parsed struct {
+			Subagent struct {
+				ThreadSpawn struct {
+					AgentNickname string `json:"agent_nickname"`
+					AgentRole     string `json:"agent_role"`
+				} `json:"thread_spawn"`
+			} `json:"subagent"`
+		}
+		if json.Unmarshal([]byte(t.Source), &parsed) == nil && parsed.Subagent.ThreadSpawn.AgentNickname != "" {
+			if parsed.Subagent.ThreadSpawn.AgentRole != "" {
+				return "subagent: " + parsed.Subagent.ThreadSpawn.AgentNickname + " (" + parsed.Subagent.ThreadSpawn.AgentRole + ")"
+			}
+			return "subagent: " + parsed.Subagent.ThreadSpawn.AgentNickname
+		}
+	}
+	if t.Source != "" {
+		return t.Source
+	}
+	return "codex"
+}
+
+type codexSpawnEdge struct {
+	ParentThreadID string
+	ChildThreadID  string
+	Status         string
+}
+
+func (p *CodexProvider) loadThreadMetadata() (map[string]codexThreadMetadata, []codexSpawnEdge) {
+	threads := map[string]codexThreadMetadata{}
+	if !fileExists(p.statePath) {
+		return threads, nil
+	}
+	db, err := sql.Open("sqlite", p.statePath+"?mode=ro&_journal_mode=WAL")
+	if err != nil {
+		return threads, nil
+	}
+	defer db.Close()
+
+	rows, err := db.Query(`
+		SELECT id, rollout_path, cwd, title, preview, source, model_provider, model,
+		       reasoning_effort, cli_version, git_branch, agent_nickname, agent_role,
+		       updated_at_ms, tokens_used
+		FROM threads
+	`)
+	if err == nil {
+		defer rows.Close()
+		for rows.Next() {
+			var t codexThreadMetadata
+			var updatedAt sql.NullInt64
+			var tokensUsed sql.NullInt64
+			var rolloutPath, cwd, title, preview, source, modelProvider, model sql.NullString
+			var effort, cliVersion, gitBranch, nickname, role sql.NullString
+			if rows.Scan(&t.ID, &rolloutPath, &cwd, &title, &preview, &source, &modelProvider, &model,
+				&effort, &cliVersion, &gitBranch, &nickname, &role, &updatedAt, &tokensUsed) != nil {
+				continue
+			}
+			t.RolloutPath = rolloutPath.String
+			t.CWD = cwd.String
+			t.Title = title.String
+			t.Preview = preview.String
+			t.Source = source.String
+			t.ModelProvider = modelProvider.String
+			t.Model = model.String
+			t.ReasoningEffort = effort.String
+			t.CLIVersion = cliVersion.String
+			t.GitBranch = gitBranch.String
+			t.AgentNickname = nickname.String
+			t.AgentRole = role.String
+			if updatedAt.Valid && updatedAt.Int64 > 0 {
+				t.UpdatedAt = time.UnixMilli(updatedAt.Int64).Format(time.RFC3339)
+			}
+			if tokensUsed.Valid {
+				t.TokensUsed = tokensUsed.Int64
+			}
+			threads[t.ID] = t
+		}
+	}
+
+	var edges []codexSpawnEdge
+	edgeRows, err := db.Query(`SELECT parent_thread_id, child_thread_id, status FROM thread_spawn_edges`)
+	if err == nil {
+		defer edgeRows.Close()
+		for edgeRows.Next() {
+			var edge codexSpawnEdge
+			if edgeRows.Scan(&edge.ParentThreadID, &edge.ChildThreadID, &edge.Status) == nil {
+				edges = append(edges, edge)
+			}
+		}
+	}
+
+	return threads, edges
+}
+
+func (p *CodexProvider) loadShellSnapshots() map[string][]TreeFileRef {
+	snapshots := map[string][]TreeFileRef{}
+	entries, err := os.ReadDir(p.shellDir)
+	if err != nil {
+		return snapshots
+	}
+	for _, entry := range entries {
+		if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".sh") {
+			continue
+		}
+		name := entry.Name()
+		threadID, _, ok := strings.Cut(name, ".")
+		if !ok || threadID == "" {
+			continue
+		}
+		path := filepath.Join(p.shellDir, name)
+		displayName := "shell snapshot"
+		if info, statErr := entry.Info(); statErr == nil {
+			displayName = "shell " + info.ModTime().Format("Jan 2 15:04")
+		}
+		snapshots[threadID] = append(snapshots[threadID], TreeFileRef{Name: displayName, Path: path})
+	}
+	for threadID := range snapshots {
+		sort.Slice(snapshots[threadID], func(i, j int) bool {
+			return snapshots[threadID][i].Name > snapshots[threadID][j].Name
+		})
+	}
+	return snapshots
+}
+
+func buildCodexSubAgents(threads map[string]codexThreadMetadata, edges []codexSpawnEdge) map[string][]TreeSubAgent {
+	agentsByParent := map[string][]TreeSubAgent{}
+	for _, edge := range edges {
+		child, ok := threads[edge.ChildThreadID]
+		if !ok || child.RolloutPath == "" {
+			continue
+		}
+		name := child.AgentNickname
+		if name == "" {
+			name = edge.ChildThreadID
+		}
+		desc := child.Title
+		if desc == "" {
+			desc = child.Preview
+		}
+		if desc == "" {
+			desc = name
+		}
+		if len(desc) > 60 {
+			desc = desc[:57] + "..."
+		}
+		agentType := child.AgentRole
+		if agentType == "" {
+			agentType = "agent"
+		}
+		agentsByParent[edge.ParentThreadID] = append(agentsByParent[edge.ParentThreadID], TreeSubAgent{
+			Name:        name,
+			AgentType:   agentType,
+			Description: desc,
+			Path:        child.RolloutPath,
+			ModTime:     child.UpdatedAt,
+		})
+	}
+	for parent := range agentsByParent {
+		sort.Slice(agentsByParent[parent], func(i, j int) bool {
+			return agentsByParent[parent][i].ModTime > agentsByParent[parent][j].ModTime
+		})
+	}
+	return agentsByParent
+}
+
+type codexSessionMeta struct {
+	SessionID     string
+	Title         string
+	Preview       string
+	MsgCount      int
+	CWD           string
+	Version       string
+	Originator    string
+	LastTimestamp string
+	UpdatedAt     string
+	FileEditCount int
+	ToolResults   int
+}
+
+func (p *CodexProvider) scanSessionMeta(path string) codexSessionMeta {
+	f, err := os.Open(path)
+	if err != nil {
+		return codexSessionMeta{}
+	}
+	defer f.Close()
+
+	var meta codexSessionMeta
+	scanner := bufio.NewScanner(f)
+	scanner.Buffer(make([]byte, 0), 32*1024*1024)
+	for scanner.Scan() {
+		var record codexRecord
+		if json.Unmarshal(scanner.Bytes(), &record) != nil {
+			continue
+		}
+		if record.Timestamp != "" {
+			meta.LastTimestamp = record.Timestamp
+		}
+
+		switch record.Type {
+		case "session_meta":
+			var payload codexSessionMetaPayload
+			if json.Unmarshal(record.Payload, &payload) == nil {
+				meta.SessionID = payload.ID
+				meta.CWD = payload.CWD
+				meta.Version = payload.CLIVersion
+				meta.Originator = payload.Originator
+				if payload.Timestamp != "" && meta.LastTimestamp == "" {
+					meta.LastTimestamp = payload.Timestamp
+				}
+			}
+		case "response_item":
+			var item codexResponseItem
+			if json.Unmarshal(record.Payload, &item) != nil {
+				continue
+			}
+			switch item.Type {
+			case "message":
+				if item.Role != "user" && item.Role != "assistant" {
+					continue
+				}
+				text := codexContentText(item.Content)
+				if item.Role == "user" && isCodexEnvironmentContext(text) {
+					continue
+				}
+				if strings.TrimSpace(text) == "" {
+					continue
+				}
+				meta.MsgCount++
+				if meta.Preview == "" && item.Role == "user" {
+					meta.Preview = compactCodexText(text)
+				}
+			case "function_call_output", "custom_tool_call_output":
+				meta.ToolResults++
+			case "web_search_call", "image_generation_call", "custom_tool_call":
+				meta.ToolResults++
+			}
+		case "event_msg":
+			var event struct {
+				Type    string                          `json:"type"`
+				Changes map[string]codexPatchChangeStub `json:"changes"`
+			}
+			if json.Unmarshal(record.Payload, &event) == nil && event.Type == "patch_apply_end" {
+				meta.FileEditCount += len(event.Changes)
+			}
+		}
+	}
+
+	return meta
+}
+
+func (p *CodexProvider) parseSession(path string) ([]Entry, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	var entries []Entry
+	var sessionMeta codexSessionMetaPayload
+	var lastAssistant *Entry
+	var pendingThinking []string
+	scanner := bufio.NewScanner(f)
+	scanner.Buffer(make([]byte, 0), 32*1024*1024)
+	for scanner.Scan() {
+		var record codexRecord
+		if json.Unmarshal(scanner.Bytes(), &record) != nil {
+			continue
+		}
+
+		switch record.Type {
+		case "session_meta":
+			_ = json.Unmarshal(record.Payload, &sessionMeta)
+
+		case "turn_context":
+			var turnContext struct {
+				Model string `json:"model"`
+			}
+			if json.Unmarshal(record.Payload, &turnContext) == nil && turnContext.Model != "" {
+				sessionMeta.Model = turnContext.Model
+			}
+
+		case "response_item":
+			var item codexResponseItem
+			if json.Unmarshal(record.Payload, &item) != nil {
+				continue
+			}
+			switch item.Type {
+			case "message":
+				if item.Role != "user" && item.Role != "assistant" {
+					continue
+				}
+				blocks := codexMessageBlocks(item.Content)
+				if len(blocks) == 0 {
+					continue
+				}
+				if item.Role == "user" && isCodexEnvironmentContext(blocksToText(blocks)) {
+					continue
+				}
+				entry := codexEntry(item.Role, record.Timestamp, sessionMeta, blocks)
+				if item.Role == "assistant" {
+					entry.Parsed.Model = sessionMeta.Model
+					if len(pendingThinking) > 0 {
+						blocks := getContentBlocks(entry.Parsed)
+						thinking := strings.Join(pendingThinking, "\n\n")
+						blocks = append([]ContentBlock{{Type: "thinking", Thinking: thinking}}, blocks...)
+						contentJSON, _ := json.Marshal(blocks)
+						entry.Parsed.Content = contentJSON
+						pendingThinking = nil
+					}
+					lastAssistant = &entry
+				} else {
+					lastAssistant = nil
+				}
+				entries = append(entries, entry)
+				if item.Role == "assistant" {
+					lastAssistant = &entries[len(entries)-1]
+				}
+
+			case "reasoning":
+				thinking := codexReasoningText(item.Summary)
+				if thinking == "" {
+					continue
+				}
+				if lastAssistant == nil || lastAssistant.Parsed == nil {
+					pendingThinking = append(pendingThinking, thinking)
+					continue
+				}
+				blocks := getContentBlocks(lastAssistant.Parsed)
+				blocks = append([]ContentBlock{{Type: "thinking", Thinking: thinking}}, blocks...)
+				contentJSON, _ := json.Marshal(blocks)
+				lastAssistant.Parsed.Content = contentJSON
+
+			case "function_call", "custom_tool_call":
+				appendCodexToolBlock(lastAssistant, item)
+
+			case "web_search_call":
+				item.Name = "WebSearch"
+				item.Arguments = string(codexWebSearchInput(item.Action))
+				appendCodexToolBlock(lastAssistant, item)
+
+			case "image_generation_call":
+				item.Name = "ImageGeneration"
+				item.CallID = item.ID
+				item.Arguments = string(codexImageInput(item.RevisedPrompt, item.Status))
+				appendCodexToolBlock(lastAssistant, item)
+
+			case "function_call_output", "custom_tool_call_output":
+				blocks := []ContentBlock{{Type: "tool_result", ToolUseID: item.CallID}}
+				entries = append(entries, codexEntry("user", record.Timestamp, sessionMeta, blocks))
+				lastAssistant = nil
+			}
+
+		case "event_msg":
+			var event codexEventMessage
+			if json.Unmarshal(record.Payload, &event) != nil {
+				continue
+			}
+			if event.Type == "token_count" && event.Info != nil {
+				usage := &Usage{
+					InputTokens:          event.Info.LastTokenUsage.InputTokens,
+					OutputTokens:         event.Info.LastTokenUsage.OutputTokens,
+					CacheReadInputTokens: event.Info.LastTokenUsage.CachedInputTokens,
+				}
+				if lastAssistant != nil && lastAssistant.Parsed != nil {
+					lastAssistant.Parsed.Usage = usage
+				} else {
+					attachUsageToLastAssistant(entries, usage)
+				}
+			}
+		}
+	}
+
+	return entries, scanner.Err()
+}
+
+func codexEntry(role, timestamp string, meta codexSessionMetaPayload, blocks []ContentBlock) Entry {
+	contentJSON, _ := json.Marshal(blocks)
+	pm := &ParsedMessage{Role: role, Content: contentJSON}
+	return Entry{
+		Type:      role,
+		Timestamp: timestamp,
+		SessionID: meta.ID,
+		CWD:       meta.CWD,
+		Version:   meta.CLIVersion,
+		Parsed:    pm,
+	}
+}
+
+func attachUsageToLastAssistant(entries []Entry, usage *Usage) {
+	for i := len(entries) - 1; i >= 0; i-- {
+		if entries[i].Type == "assistant" && entries[i].Parsed != nil {
+			entries[i].Parsed.Usage = usage
+			return
+		}
+	}
+}
+
+func appendCodexToolBlock(lastAssistant *Entry, item codexResponseItem) {
+	if lastAssistant == nil || lastAssistant.Parsed == nil {
+		return
+	}
+	input := item.Arguments
+	if input == "" {
+		input = item.Input
+	}
+	name := item.Name
+	if name == "" {
+		name = item.Type
+	}
+	blocks := getContentBlocks(lastAssistant.Parsed)
+	blocks = append(blocks, ContentBlock{
+		Type:  "tool_use",
+		Name:  capitalizeToolName(name),
+		ID:    item.CallID,
+		Input: codexRawJSON(input),
+	})
+	contentJSON, _ := json.Marshal(blocks)
+	lastAssistant.Parsed.Content = contentJSON
+}
+
+func codexWebSearchInput(action json.RawMessage) json.RawMessage {
+	if len(action) > 0 && json.Valid(action) {
+		return action
+	}
+	fallback, _ := json.Marshal(map[string]string{"type": "web_search"})
+	return fallback
+}
+
+func codexImageInput(prompt, status string) json.RawMessage {
+	fallback, _ := json.Marshal(map[string]string{"prompt": prompt, "status": status})
+	return fallback
+}
+
+type codexRecord struct {
+	Timestamp string          `json:"timestamp"`
+	Type      string          `json:"type"`
+	Payload   json.RawMessage `json:"payload"`
+}
+
+type codexSessionMetaPayload struct {
+	ID            string `json:"id"`
+	Timestamp     string `json:"timestamp"`
+	CWD           string `json:"cwd"`
+	Originator    string `json:"originator"`
+	CLIVersion    string `json:"cli_version"`
+	ModelProvider string `json:"model_provider"`
+	Model         string `json:"model"`
+}
+
+type codexResponseItem struct {
+	Type          string             `json:"type"`
+	Role          string             `json:"role"`
+	Content       []codexContentPart `json:"content"`
+	Phase         string             `json:"phase"`
+	Summary       []codexSummaryPart `json:"summary"`
+	Name          string             `json:"name"`
+	Arguments     string             `json:"arguments"`
+	Input         string             `json:"input"`
+	CallID        string             `json:"call_id"`
+	ID            string             `json:"id"`
+	Output        string             `json:"output"`
+	Status        string             `json:"status"`
+	Action        json.RawMessage    `json:"action"`
+	RevisedPrompt string             `json:"revised_prompt"`
+}
+
+type codexContentPart struct {
+	Type string `json:"type"`
+	Text string `json:"text"`
+}
+
+type codexSummaryPart struct {
+	Type string `json:"type"`
+	Text string `json:"text"`
+}
+
+type codexEventMessage struct {
+	Type string `json:"type"`
+	Info *struct {
+		LastTokenUsage struct {
+			InputTokens       int `json:"input_tokens"`
+			CachedInputTokens int `json:"cached_input_tokens"`
+			OutputTokens      int `json:"output_tokens"`
+		} `json:"last_token_usage"`
+	} `json:"info"`
+}
+
+type codexPatchChangeStub struct {
+	Type string `json:"type"`
+}
+
+func codexMessageBlocks(parts []codexContentPart) []ContentBlock {
+	var blocks []ContentBlock
+	for _, part := range parts {
+		if part.Text == "" {
+			continue
+		}
+		blocks = append(blocks, ContentBlock{Type: "text", Text: part.Text})
+	}
+	return blocks
+}
+
+func codexContentText(parts []codexContentPart) string {
+	var texts []string
+	for _, part := range parts {
+		if part.Text != "" {
+			texts = append(texts, part.Text)
+		}
+	}
+	return strings.Join(texts, "\n")
+}
+
+func blocksToText(blocks []ContentBlock) string {
+	var texts []string
+	for _, block := range blocks {
+		if block.Text != "" {
+			texts = append(texts, block.Text)
+		}
+	}
+	return strings.Join(texts, "\n")
+}
+
+func codexReasoningText(summary []codexSummaryPart) string {
+	var texts []string
+	for _, part := range summary {
+		if part.Text != "" {
+			texts = append(texts, part.Text)
+		}
+	}
+	return strings.Join(texts, "\n\n")
+}
+
+func codexRawJSON(s string) json.RawMessage {
+	trimmed := strings.TrimSpace(s)
+	if trimmed != "" && json.Valid([]byte(trimmed)) {
+		return json.RawMessage(trimmed)
+	}
+	fallback, _ := json.Marshal(map[string]string{"arguments": s})
+	return fallback
+}
+
+func compactCodexText(s string) string {
+	s = strings.ReplaceAll(s, "\n", " ")
+	return strings.Join(strings.Fields(s), " ")
+}
+
+func truncateCodexText(s string, maxLen int) string {
+	s = compactCodexText(s)
+	if maxLen > 3 && len(s) > maxLen {
+		return s[:maxLen-3] + "..."
+	}
+	return s
+}
+
+func isCodexEnvironmentContext(s string) bool {
+	trimmed := strings.TrimSpace(s)
+	return strings.HasPrefix(trimmed, "<environment_context>")
+}
+
+func codexSessionIDFromPath(path string) string {
+	base := strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
+	parts := strings.Split(base, "-")
+	if len(parts) >= 7 {
+		return strings.Join(parts[len(parts)-5:], "-")
+	}
+	if strings.HasPrefix(base, "rollout-") {
+		return strings.TrimPrefix(base, "rollout-")
+	}
+	return base
+}
+
+func isCodexSessionFile(path string) bool {
+	f, err := os.Open(path)
+	if err != nil {
+		return false
+	}
+	defer f.Close()
+
+	scanner := bufio.NewScanner(f)
+	scanner.Buffer(make([]byte, 0), 1024*1024)
+	if !scanner.Scan() {
+		return false
+	}
+	var record codexRecord
+	if json.Unmarshal(scanner.Bytes(), &record) != nil {
+		return false
+	}
+	return record.Type == "session_meta" && len(record.Payload) > 0
+}
diff --git a/server.go b/server.go
index ee124cb..9812d24 100644
--- a/server.go
+++ b/server.go
@@ -23,7 +23,7 @@ func startServer(port int) error {
 }
 
 func serveTree(w http.ResponseWriter, r *http.Request) {
-	tree, err := loadTree()
+	tree, err := mergeProviderTrees(discoverProviders())
 	if err != nil {
 		http.Error(w, err.Error(), 500)
 		return
@@ -54,7 +54,7 @@ func serveMessages(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "missing path", 400)
 		return
 	}
-	entries, err := parseConversation(path)
+	entries, err := loadMessagesForRequest(path, r.URL.Query().Get("source"))
 	if err != nil {
 		http.Error(w, err.Error(), 500)
 		return
@@ -141,7 +141,7 @@ func serveExport(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "missing path", 400)
 		return
 	}
-	entries, err := parseConversation(path)
+	entries, err := loadMessagesForRequest(path, r.URL.Query().Get("source"))
 	if err != nil {
 		http.Error(w, err.Error(), 500)
 		return
@@ -153,6 +153,16 @@ func serveExport(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func loadMessagesForRequest(path, source string) ([]Entry, error) {
+	if source != "" {
+		provider := providerForSource(discoverProviders(), source)
+		if provider != nil {
+			return provider.LoadConversation(path)
+		}
+	}
+	return parseAnyConversation(path)
+}
+
 func extractCommandName(content string) string {
 	if idx := strings.Index(content, "<command-name>"); idx >= 0 {
 		start := idx + len("<command-name>")
@@ -310,11 +320,13 @@ body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;b
 
 <script>
 (function(){
-  var treeData=null, selectedPath=null, currentProjIdx=-1;
+  var treeData=null, selectedPath=null, selectedSource='', currentProjIdx=-1;
 
   function esc(s){var d=document.createElement('div');d.textContent=s||'';return d.innerHTML}
   function fmtDate(iso){try{var d=new Date(iso);return d.toLocaleDateString(undefined,{month:'short',day:'numeric'})+' '+d.toLocaleTimeString(undefined,{hour:'2-digit',minute:'2-digit'})}catch(e){return iso||''}}
   function wordCount(s){return s?s.split(/\s+/).filter(function(w){return w.length>0}).length:0}
+  function providerLabel(s){if(s==='opencode')return 'OpenCode';if(s==='codex')return 'Codex';return 'Claude'}
+  function compactCount(n){n=Number(n||0);if(n>=1e9)return (n/1e9).toFixed(1)+'B';if(n>=1e6)return (n/1e6).toFixed(1)+'M';if(n>=1e3)return (n/1e3).toFixed(1)+'k';return String(n)}
 
   function showScreen(id){
     document.querySelectorAll('.screen').forEach(function(el){el.classList.remove('active')});
@@ -324,8 +336,9 @@ body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;b
   // Load tree data
   fetch('/api/tree').then(function(r){return r.json()}).then(function(data){
     treeData=data;
-    document.getElementById('global-stats').textContent=
-      data.stats.totalProjects+' projects | '+data.stats.totalConversations+' conversations | '+data.stats.totalMessages+' messages';
+    var stats=data.stats.totalProjects+' projects | '+data.stats.totalConversations+' conversations | '+data.stats.totalMessages+' messages';
+    if(data.stats.totalTokens) stats+=' | '+compactCount(data.stats.totalTokens)+' tokens';
+    document.getElementById('global-stats').textContent=stats;
     renderProjectList();
   }).catch(function(e){
     document.getElementById('project-list').innerHTML='<div style="padding:24px;color:#a8a29e">Error: '+esc(e.message)+'</div>';
@@ -336,10 +349,11 @@ body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;b
     for(var i=0;i<treeData.projects.length;i++){
       var p=treeData.projects[i];
       h+='<div class="project-card" onclick="openProject('+i+')">';
-      h+='<div class="pc-name">'+esc(p.displayName)+'</div>';
+      h+='<div class="pc-name">'+esc(p.displayName)+' <span class="pc-badge">'+esc(providerLabel(p.source))+'</span></div>';
       h+='<div class="pc-meta">';
       h+='<span>'+p.convCount+' conversation'+(p.convCount!==1?'s':'')+'</span>';
       h+='<span>'+p.msgCount+' messages</span>';
+      if(p.tokenCount) h+='<span>'+compactCount(p.tokenCount)+' tokens</span>';
       h+='<span>'+fmtDate(p.lastActive)+'</span>';
       if(p.claudeMD) h+=' <span class="pc-badge">CLAUDE.md</span>';
       if(p.memoryFiles&&p.memoryFiles.length) h+=' <span class="pc-badge">Memory('+p.memoryFiles.length+')</span>';
@@ -389,11 +403,13 @@ body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;b
     var lh='';
     for(var ci=0;ci<proj.conversations.length;ci++){
       var c=proj.conversations[ci];
-      lh+='<div class="sb-conv" data-path="'+esc(c.path)+'" onclick="loadConv(this)">';
+      lh+='<div class="sb-conv" data-path="'+esc(c.path)+'" data-source="'+esc(c.source||proj.source||'claude')+'" onclick="loadConv(this)">';
       lh+='<div class="sb-conv-title">'+esc(c.title||c.slug||c.sessionId.substring(0,8))+'</div>';
       lh+='<div class="sb-conv-meta">';
       lh+='<span>'+fmtDate(c.modTime)+'</span>';
       lh+='<span>'+c.msgCount+' msgs</span>';
+      if(c.tokenCount) lh+='<span>'+compactCount(c.tokenCount)+' tok</span>';
+      if(c.shellSnapshots&&c.shellSnapshots.length) lh+='<span>'+c.shellSnapshots.length+' shells</span>';
       if(c.gitBranch) lh+='<span>'+esc(c.gitBranch)+'</span>';
       lh+='</div></div>';
       if(c.subAgents){
@@ -401,16 +417,25 @@ body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;b
           var sa=c.subAgents[si];
           var saDesc=sa.description||sa.name;
           var saType=sa.agentType||'agent';
-          lh+='<div class="sb-agent" data-path="'+esc(sa.path)+'" onclick="loadConv(this)">';
+          lh+='<div class="sb-agent" data-path="'+esc(sa.path)+'" data-source="'+esc(c.source||proj.source||'claude')+'" onclick="loadConv(this)">';
           lh+='<span class="at">'+esc(saType)+'</span> <span style="overflow:hidden;text-overflow:ellipsis">'+esc(saDesc)+'</span>';
           lh+='</div>';
         }
       }
+      if(c.shellSnapshots){
+        for(var shi=0;shi<c.shellSnapshots.length;shi++){
+          var sh=c.shellSnapshots[shi];
+          lh+='<div class="sb-agent" data-path="'+esc(sh.path)+'" data-name="'+esc(sh.name)+'" onclick="loadFile(this.getAttribute(\'data-path\'),this.getAttribute(\'data-name\'))">';
+          lh+='<span class="at">shell</span> <span style="overflow:hidden;text-overflow:ellipsis">'+esc(sh.name)+'</span>';
+          lh+='</div>';
+        }
+      }
     }
     document.getElementById('sb-list').innerHTML=lh;
 
     // Reset content
     selectedPath=null;
+    selectedSource='';
     document.getElementById('ct-header').style.display='none';
     document.getElementById('export-btn').style.display='none';
     document.getElementById('ct-body').innerHTML='<div class="ct-empty">Select a conversation</div>';
@@ -418,9 +443,11 @@ body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;b
 
   window.loadConv=function(el){
     var path=el.getAttribute('data-path');
+    var source=el.getAttribute('data-source')||'';
     var title=el.querySelector('.sb-conv-title');
     var titleText=title?title.textContent:(el.textContent||'').trim();
     selectedPath=path;
+    selectedSource=source;
 
     // Update selection UI
     document.querySelectorAll('.sb-conv,.sb-agent').forEach(function(e){e.classList.remove('selected')});
@@ -432,7 +459,7 @@ body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;b
     document.getElementById('export-btn').style.display='inline-block';
     document.getElementById('ct-body').innerHTML='<div class="loading-wrap"><div class="spinner"></div> Loading...</div>';
 
-    fetch('/api/messages?path='+encodeURIComponent(path)).then(function(r){return r.json()}).then(function(msgs){
+    fetch('/api/messages?path='+encodeURIComponent(path)+'&source='+encodeURIComponent(source)).then(function(r){return r.json()}).then(function(msgs){
       renderMessages(msgs||[]);
     }).catch(function(e){
       document.getElementById('ct-body').innerHTML='<div style="padding:28px;color:var(--text-muted)">Error: '+esc(e.message)+'</div>';
@@ -441,6 +468,7 @@ body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;b
 
   window.loadFile=function(path,name){
     selectedPath=path;
+    selectedSource='';
     document.querySelectorAll('.sb-conv,.sb-agent').forEach(function(e){e.classList.remove('selected')});
     document.getElementById('ct-header').style.display='flex';
     document.getElementById('ct-title').textContent=name;
@@ -485,7 +513,7 @@ body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;b
         h+='<div class="message"><div class="msg-header"><div class="avatar u">U</div><span class="msg-role">You</span><span class="msg-time">'+esc(m.timestamp)+'</span></div><div class="msg-body">'+m.html+'</div></div>';
       }else if(m.type==='assistant'){
         var ml=m.model?' <span class="msg-model">'+esc(m.model)+'</span>':'';
-        h+='<div class="message"><div class="msg-header"><div class="avatar a">C</div><span class="msg-role">Claude</span>'+ml+'<span class="msg-time">'+esc(m.timestamp)+'</span></div><div class="msg-body">';
+        h+='<div class="message"><div class="msg-header"><div class="avatar a">A</div><span class="msg-role">Assistant</span>'+ml+'<span class="msg-time">'+esc(m.timestamp)+'</span></div><div class="msg-body">';
         if(m.thinking){
           var tid='th-'+i,wc=wordCount(m.thinking);
           h+='<div class="thinking-block"><div class="thinking-toggle" onclick="toggleThink(\''+tid+'\')"><span class="tg-arrow" id="tga-'+tid+'">&#9654;</span> Thinking... ('+wc+' words)</div><div class="thinking-content" id="'+tid+'">'+esc(m.thinking)+'</div></div>';
@@ -511,11 +539,12 @@ body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;b
   document.getElementById('back-btn').addEventListener('click',function(){
     showScreen('screen-projects');
     currentProjIdx=-1;selectedPath=null;
+    selectedSource='';
   });
 
   // Export
   document.getElementById('export-btn').addEventListener('click',function(){
-    if(selectedPath) window.open('/api/export?path='+encodeURIComponent(selectedPath),'_blank');
+    if(selectedPath) window.open('/api/export?path='+encodeURIComponent(selectedPath)+'&source='+encodeURIComponent(selectedSource),'_blank');
   });
 })();
 
diff --git a/ui.go b/ui.go
index 1d306e8..816739a 100644
--- a/ui.go
+++ b/ui.go
@@ -47,13 +47,13 @@ const (
 )
 
 type sessionSearchState struct {
-	active    bool
-	scope     searchScope
-	input     []rune
-	results   []SearchResult
-	cursor    int
-	offset    int
-	gen       int // debounce generation — only the latest tick fires search
+	active  bool
+	scope   searchScope
+	input   []rune
+	results []SearchResult
+	cursor  int
+	offset  int
+	gen     int // debounce generation — only the latest tick fires search
 }
 
 // ── Model ──
@@ -112,7 +112,7 @@ type model struct {
 	contentSearchGen    int    // debounce generation
 
 	// Session search overlay
-	sessionSearch       sessionSearchState
+	sessionSearch sessionSearchState
 }
 
 // ── Export overlay types ──
@@ -120,7 +120,7 @@ type model struct {
 type exportStep int
 
 const (
-	exportStepWhat     exportStep = iota
+	exportStepWhat exportStep = iota
 	exportStepFormat
 	exportStepPath
 	exportStepFilename
@@ -306,7 +306,7 @@ func loadConvCmd(path, title string, width int, provider Provider) tea.Cmd {
 		if provider != nil {
 			entries, err = provider.LoadConversation(path)
 		} else {
-			entries, err = parseConversation(path)
+			entries, err = parseAnyConversation(path)
 		}
 		if err != nil {
 			return contentLoadedMsg{nil, title, path, "conversation", err}
@@ -365,10 +365,7 @@ func buildSidebar(proj *TreeProject, plans []TreeFileRef, expandedConvPath strin
 		if title == "" && len(conv.SessionID) >= 8 {
 			title = conv.SessionID[:8]
 		}
-		badge := fmt.Sprintf("%s  %d msgs", formatDateSmart(conv.ModTime), conv.MsgCount)
-		if len(conv.SubAgents) > 0 {
-			badge = fmt.Sprintf("%s  %d msgs · %d agents", formatDateSmart(conv.ModTime), conv.MsgCount, len(conv.SubAgents))
-		}
+		badge := conversationBadge(conv)
 		items = append(items, sidebarItem{
 			kind:  "conversation",
 			label: title,
@@ -392,11 +389,28 @@ func buildSidebar(proj *TreeProject, plans []TreeFileRef, expandedConvPath strin
 				}
 				items = append(items, sidebarItem{kind: "subagent", label: lbl, path: sa.Path})
 			}
+			for _, snapshot := range conv.ShellSnapshots {
+				items = append(items, sidebarItem{kind: "file", label: snapshot.Name, path: snapshot.Path})
+			}
 		}
 	}
 	return items
 }
 
+func conversationBadge(conv TreeConversation) string {
+	parts := []string{formatDateSmart(conv.ModTime), fmt.Sprintf("%d msgs", conv.MsgCount)}
+	if conv.TokenCount > 0 {
+		parts = append(parts, formatCompactCount(conv.TokenCount)+" tok")
+	}
+	if len(conv.SubAgents) > 0 {
+		parts = append(parts, fmt.Sprintf("%d agents", len(conv.SubAgents)))
+	}
+	if len(conv.ShellSnapshots) > 0 {
+		parts = append(parts, fmt.Sprintf("%d shells", len(conv.ShellSnapshots)))
+	}
+	return strings.Join(parts, " · ")
+}
+
 // navigable returns true if the sidebar item can be selected with cursor.
 func (si sidebarItem) navigable() bool {
 	return si.kind != "separator" && si.kind != "header"
@@ -605,6 +619,11 @@ func (m model) updateProjectList(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
 		if len(m.providerTrees) > 1 && m.hasMultipleTabs() {
 			m.switchProviderTab(1)
 		}
+	case "3", "4", "5", "6", "7", "8", "9":
+		if m.hasMultipleTabs() {
+			idx := int(msg.String()[0] - '1')
+			m.switchProviderTab(idx)
+		}
 	case "tab":
 		if m.hasMultipleTabs() {
 			next := (m.providerTab + 1) % len(m.providerTrees)
@@ -1212,7 +1231,7 @@ func (m model) contentPaneRect() (int, int, int, int) {
 	}
 	leftW, rightW := m.paneWidths()
 	x := leftW + 3 // left pane + separator " │ "
-	y := 1          // title bar
+	y := 1         // title bar
 	return x, y, rightW, m.height - 2
 }
 
@@ -1632,7 +1651,7 @@ func (m model) executeExport() tea.Cmd {
 				}
 				return exportDoneMsg{filepath.Join(outDir, strings.TrimSuffix(outFile, filepath.Ext(outFile))), nil}
 			}
-			entries, err := parseConversation(ex.sourcePath)
+			entries, err := parseAnyConversation(ex.sourcePath)
 			if err != nil {
 				return exportDoneMsg{"", err}
 			}
@@ -1640,7 +1659,7 @@ func (m model) executeExport() tea.Cmd {
 			return exportDoneMsg{outPath, err}
 
 		case exportFormatMarkdown:
-			entries, err := parseConversation(ex.sourcePath)
+			entries, err := parseAnyConversation(ex.sourcePath)
 			if err != nil {
 				return exportDoneMsg{"", err}
 			}
@@ -1888,6 +1907,9 @@ func (m model) renderProjectList() string {
 			meta += "s"
 		}
 		meta += fmt.Sprintf(" · %d msgs", proj.MsgCount)
+		if proj.TokenCount > 0 {
+			meta += " · " + formatCompactCount(proj.TokenCount) + " tok"
+		}
 		if proj.LastActive != "" {
 			meta += " · " + formatDateSmart(proj.LastActive)
 		}
@@ -1918,13 +1940,26 @@ func (m model) renderProjectList() string {
 	total := len(m.tree.Projects)
 	hint := " %d projects | enter: open | j/k: navigate | q: quit"
 	if m.hasMultipleTabs() {
-		hint = " %d projects | enter: open | j/k: navigate | tab/1-2: switch | q: quit"
+		hint = " %d projects | enter: open | j/k: navigate | tab/1-9: switch | q: quit"
 	}
 	b.WriteString(statusStyle.Render(fmt.Sprintf(hint, total)))
 
 	return b.String()
 }
 
+func formatCompactCount(n int64) string {
+	switch {
+	case n >= 1_000_000_000:
+		return fmt.Sprintf("%.1fB", float64(n)/1_000_000_000)
+	case n >= 1_000_000:
+		return fmt.Sprintf("%.1fM", float64(n)/1_000_000)
+	case n >= 1_000:
+		return fmt.Sprintf("%.1fk", float64(n)/1_000)
+	default:
+		return fmt.Sprintf("%d", n)
+	}
+}
+
 func formatDateSmart(iso string) string {
 	for _, layout := range []string{time.RFC3339Nano, time.RFC3339} {
 		if t, err := time.Parse(layout, iso); err == nil {