fix: import archived codex sessions (#479)

mariusvniekerk · web-flow · commit 9beed32d2d3d · 2026-05-10T10:14:32.000-05:00
## Summary - import Codex sessions from both `~/.codex/sessions` and `~/.codex/archived_sessions` - support both dated live-session paths and flat archived-session paths during discovery and direct path sync - deduplicate Codex sessions by canonical session ID and prefer live paths when both live and archived copies exist Closes #477.
diff --git a/internal/config/config_test.go b/internal/config/config_test.go
@@ -72,6 +72,24 @@ func loadConfigFromPFlags(t *testing.T, args ...string) (Config, error) {
 	return LoadPFlags(fs)
 }
 
+func TestDefault_IncludesCodexArchivedSessionsDir(t *testing.T) {
+	cfg, err := Default()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	dirs := cfg.ResolveDirs(parser.AgentCodex)
+	if len(dirs) != 2 {
+		t.Fatalf("len(codex dirs) = %d, want 2", len(dirs))
+	}
+	if !strings.HasSuffix(dirs[0], filepath.Join(".codex", "sessions")) {
+		t.Fatalf("dirs[0] = %q", dirs[0])
+	}
+	if !strings.HasSuffix(dirs[1], filepath.Join(".codex", "archived_sessions")) {
+		t.Fatalf("dirs[1] = %q", dirs[1])
+	}
+}
+
 func TestLoadEnv_OverridesDataDir(t *testing.T) {
 	custom := setupTestEnv(t)
 
diff --git a/internal/parser/discovery.go b/internal/parser/discovery.go
@@ -382,11 +382,28 @@ func DiscoverClaudeProjects(projectsDir string) []DiscoveredFile {
 	return files
 }
 
-// DiscoverCodexSessions finds all JSONL files under the Codex
-// sessions dir (year/month/day structure).
+// DiscoverCodexSessions finds all Codex JSONL session files under
+// either the standard year/month/day layout or a flat archived dir.
 func DiscoverCodexSessions(sessionsDir string) []DiscoveredFile {
 	var files []DiscoveredFile
 
+	entries, err := os.ReadDir(sessionsDir)
+	if err != nil {
+		return nil
+	}
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+		if !isCodexSessionFilename(entry.Name()) {
+			continue
+		}
+		files = append(files, DiscoveredFile{
+			Path:  filepath.Join(sessionsDir, entry.Name()),
+			Agent: AgentCodex,
+		})
+	}
+
 	walkCodexDayDirs(sessionsDir, func(dayPath string) bool {
 		entries, err := os.ReadDir(dayPath)
 		if err != nil {
@@ -396,7 +413,7 @@ func DiscoverCodexSessions(sessionsDir string) []DiscoveredFile {
 			if sf.IsDir() {
 				continue
 			}
-			if !strings.HasSuffix(sf.Name(), ".jsonl") {
+			if !isCodexSessionFilename(sf.Name()) {
 				continue
 			}
 			files = append(files, DiscoveredFile{
@@ -473,16 +490,34 @@ func FindClaudeSourceFile(
 }
 
 // FindCodexSourceFile finds a Codex session file by UUID.
-// Searches the year/month/day directory structure for files matching
-// rollout-{timestamp}-{uuid}.jsonl.
+// Prefers the standard year/month/day live path when present,
+// then falls back to a flat archived dir entry.
 func FindCodexSourceFile(sessionsDir, sessionID string) string {
 	if !IsValidSessionID(sessionID) {
 		return ""
 	}
 
-	var result string
+	var archived string
+	entries, err := os.ReadDir(sessionsDir)
+	if err == nil {
+		for _, f := range entries {
+			if f.IsDir() {
+				continue
+			}
+			name := f.Name()
+			if !isCodexSessionFilename(name) {
+				continue
+			}
+			if extractUUIDFromRollout(name) == sessionID {
+				archived = filepath.Join(sessionsDir, name)
+				break
+			}
+		}
+	}
+
+	var live string
 	walkCodexDayDirs(sessionsDir, func(dayPath string) bool {
-		if result != "" {
+		if live != "" {
 			return false
 		}
 		entries, err := os.ReadDir(dayPath)
@@ -494,18 +529,83 @@ func FindCodexSourceFile(sessionsDir, sessionID string) string {
 				continue
 			}
 			name := f.Name()
-			if !strings.HasPrefix(name, "rollout-") ||
-				!strings.HasSuffix(name, ".jsonl") {
+			if !isCodexSessionFilename(name) {
 				continue
 			}
 			if extractUUIDFromRollout(name) == sessionID {
-				result = filepath.Join(dayPath, name)
+				live = filepath.Join(dayPath, name)
 				return false
 			}
 		}
 		return true
 	})
-	return result
+	if live != "" {
+		return live
+	}
+	return archived
+}
+
+func isCodexSessionFilename(name string) bool {
+	return strings.HasPrefix(name, "rollout-") &&
+		strings.HasSuffix(name, ".jsonl")
+}
+
+// CodexSessionUUIDFromFilename extracts the canonical session UUID
+// from a Codex rollout filename. Returns "" when the filename does
+// not match Codex session naming.
+func CodexSessionUUIDFromFilename(name string) string {
+	if !isCodexSessionFilename(name) {
+		return ""
+	}
+	return extractUUIDFromRollout(name)
+}
+
+// CodexLayout reports which on-disk layout a Codex session path uses.
+type CodexLayout int
+
+const (
+	CodexLayoutUnknown CodexLayout = iota
+	CodexLayoutArchivedFlat
+	CodexLayoutDated
+)
+
+// CodexSessionPathInfo parses a Codex path relative to a configured
+// root and reports whether it is a valid session path plus its layout
+// and canonical session UUID.
+func CodexSessionPathInfo(root, path string) (CodexLayout, string, bool) {
+	root = filepath.Clean(root)
+	path = filepath.Clean(path)
+	rel, err := filepath.Rel(root, path)
+	if err != nil {
+		return CodexLayoutUnknown, "", false
+	}
+	sep := string(filepath.Separator)
+	if rel == "." || rel == ".." || strings.HasPrefix(rel, ".."+sep) {
+		return CodexLayoutUnknown, "", false
+	}
+	if !strings.HasSuffix(path, ".jsonl") {
+		return CodexLayoutUnknown, "", false
+	}
+	parts := strings.Split(rel, sep)
+	switch len(parts) {
+	case 1:
+		if !isCodexSessionFilename(parts[0]) {
+			return CodexLayoutUnknown, "", false
+		}
+		return CodexLayoutArchivedFlat,
+			CodexSessionUUIDFromFilename(parts[0]), true
+	case 4:
+		if !IsDigits(parts[0]) || !IsDigits(parts[1]) || !IsDigits(parts[2]) {
+			return CodexLayoutUnknown, "", false
+		}
+		if !isCodexSessionFilename(parts[3]) {
+			return CodexLayoutUnknown, "", false
+		}
+		return CodexLayoutDated,
+			CodexSessionUUIDFromFilename(parts[3]), true
+	default:
+		return CodexLayoutUnknown, "", false
+	}
 }
 
 // walkCodexDayDirs traverses a Codex sessions directory with
diff --git a/internal/parser/discovery_test.go b/internal/parser/discovery_test.go
@@ -136,6 +136,7 @@ func TestDiscoverClaudeProjects(t *testing.T) {
 func TestDiscoverCodexSessions(t *testing.T) {
 	file1 := "rollout-123-abc-def-ghi-jkl-mno.jsonl"
 	file2 := "rollout-456-abc-def-ghi-jkl-mno.jsonl"
+	flat := "rollout-2026-05-04T02-10-04-019df19b-ad1a-7f82-bfc3-38701744cc66.jsonl"
 
 	tests := []struct {
 		name      string
@@ -150,6 +151,13 @@ func TestDiscoverCodexSessions(t *testing.T) {
 			},
 			wantFiles: []string{file1, file2},
 		},
+		{
+			name: "FlatArchivedDir",
+			files: map[string]string{
+				flat: "{}",
+			},
+			wantFiles: []string{flat},
+		},
 		{
 			name: "SkipsNonDigit",
 			files: map[string]string{
@@ -330,6 +338,7 @@ func TestFindCodexSourceFile(t *testing.T) {
 	uuid := "abc12345-1234-5678-9abc-def012345678"
 	filename := "rollout-20240115-" + uuid + ".jsonl"
 	relPath := filepath.Join("2024", "01", "15", filename)
+	flatName := "rollout-2026-05-04T02-10-04-" + uuid + ".jsonl"
 
 	tests := []struct {
 		name     string
@@ -338,11 +347,26 @@ func TestFindCodexSourceFile(t *testing.T) {
 		wantFile string
 	}{
 		{
-			name:     "Found",
+			name:     "FoundDated",
 			files:    map[string]string{relPath: "{}"},
 			targetID: uuid,
 			wantFile: relPath,
 		},
+		{
+			name:     "FoundFlatArchived",
+			files:    map[string]string{flatName: "{}"},
+			targetID: uuid,
+			wantFile: flatName,
+		},
+		{
+			name: "PrefersDatedOverFlat",
+			files: map[string]string{
+				relPath:  "{}",
+				flatName: "{}",
+			},
+			targetID: uuid,
+			wantFile: relPath,
+		},
 		{
 			name:     "Nonexistent",
 			files:    map[string]string{relPath: "{}"},
diff --git a/internal/parser/types.go b/internal/parser/types.go
@@ -74,11 +74,14 @@ var Registry = []AgentDef{
 		FindSourceFunc: FindClaudeSourceFile,
 	},
 	{
-		Type:           AgentCodex,
-		DisplayName:    "Codex",
-		EnvVar:         "CODEX_SESSIONS_DIR",
-		ConfigKey:      "codex_sessions_dirs",
-		DefaultDirs:    []string{".codex/sessions"},
+		Type:        AgentCodex,
+		DisplayName: "Codex",
+		EnvVar:      "CODEX_SESSIONS_DIR",
+		ConfigKey:   "codex_sessions_dirs",
+		DefaultDirs: []string{
+			".codex/sessions",
+			".codex/archived_sessions",
+		},
 		IDPrefix:       "codex:",
 		FileBased:      true,
 		DiscoverFunc:   DiscoverCodexSessions,
diff --git a/internal/sync/engine.go b/internal/sync/engine.go
@@ -310,7 +310,76 @@ func (e *Engine) classifyPaths(
 			files = append(files, df)
 		}
 	}
-	return files
+	return dedupeDiscoveredFiles(files)
+}
+
+func dedupeDiscoveredFiles(
+	files []parser.DiscoveredFile,
+) []parser.DiscoveredFile {
+	if len(files) < 2 {
+		return files
+	}
+
+	bestByKey := make(map[string]parser.DiscoveredFile, len(files))
+	for _, file := range files {
+		key := discoveredFileKey(file)
+		if current, ok := bestByKey[key]; ok {
+			if preferDiscoveredFile(file, current) {
+				bestByKey[key] = file
+			}
+			continue
+		}
+		bestByKey[key] = file
+	}
+
+	out := make([]parser.DiscoveredFile, 0, len(bestByKey))
+	for _, file := range files {
+		key := discoveredFileKey(file)
+		chosen, ok := bestByKey[key]
+		if !ok || chosen.Path != file.Path || chosen.Agent != file.Agent {
+			continue
+		}
+		out = append(out, file)
+		delete(bestByKey, key)
+	}
+	return out
+}
+
+func discoveredFileKey(file parser.DiscoveredFile) string {
+	if file.Agent == parser.AgentCodex {
+		if id := parser.CodexSessionUUIDFromFilename(filepath.Base(file.Path)); id != "" {
+			return string(file.Agent) + "\x00" + id
+		}
+	}
+	return string(file.Agent) + "\x00" + file.Path
+}
+
+func preferDiscoveredFile(
+	candidate, current parser.DiscoveredFile,
+) bool {
+	if candidate.Agent == parser.AgentCodex && current.Agent == parser.AgentCodex {
+		candLayout := codexLayoutForPath(candidate.Path)
+		currLayout := codexLayoutForPath(current.Path)
+		if candLayout != currLayout {
+			return candLayout == parser.CodexLayoutDated
+		}
+	}
+	return false
+}
+
+func codexLayoutForPath(path string) parser.CodexLayout {
+	path = filepath.Clean(path)
+	name := filepath.Base(path)
+	if parser.CodexSessionUUIDFromFilename(name) == "" {
+		return parser.CodexLayoutUnknown
+	}
+	day := filepath.Base(filepath.Dir(path))
+	month := filepath.Base(filepath.Dir(filepath.Dir(path)))
+	year := filepath.Base(filepath.Dir(filepath.Dir(filepath.Dir(path))))
+	if parser.IsDigits(day) && parser.IsDigits(month) && parser.IsDigits(year) {
+		return parser.CodexLayoutDated
+	}
+	return parser.CodexLayoutArchivedFlat
 }
 
 // isUnder checks whether path is strictly inside dir after
@@ -409,24 +478,13 @@ func (e *Engine) classifyOnePath(
 		}
 	}
 
-	// Codex: <codexDir>/<year>/<month>/<day>/<file>.jsonl
+	// Codex: either <codexDir>/<year>/<month>/<day>/<file>.jsonl
+	// or <codexDir>/<file>.jsonl for archived sessions.
 	for _, codexDir := range e.agentDirs[parser.AgentCodex] {
 		if codexDir == "" {
 			continue
 		}
-		if rel, ok := isUnder(codexDir, path); ok {
-			parts := strings.Split(rel, sep)
-			if len(parts) != 4 {
-				continue
-			}
-			if !parser.IsDigits(parts[0]) ||
-				!parser.IsDigits(parts[1]) ||
-				!parser.IsDigits(parts[2]) {
-				continue
-			}
-			if !strings.HasSuffix(parts[3], ".jsonl") {
-				continue
-			}
+		if _, _, ok := parser.CodexSessionPathInfo(codexDir, path); ok {
 			return parser.DiscoveredFile{
 				Path:  path,
 				Agent: parser.AgentCodex,
@@ -1430,6 +1488,8 @@ func (e *Engine) syncAllLocked(
 		all = filterFilesByMtime(all, since)
 	}
 
+	all = dedupeDiscoveredFiles(all)
+
 	verbose := onProgress == nil
 
 	if verbose {
diff --git a/internal/sync/engine_integration_test.go b/internal/sync/engine_integration_test.go
