Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

codex: threads started on magpie come back to the provider Codex is on

yetone85534cd0788d
diff --git a/internal/agent/codex.go b/internal/agent/codex.go
index 66dde2443..6c5d1d21d 100644
--- a/internal/agent/codex.go
+++ b/internal/agent/codex.go
@@ -6,6 +6,7 @@ import (
"errors"
"fmt"
"io/fs"
+ "log"
"net/url"
"os"
"path/filepath"
@@ -520,6 +521,34 @@ func codexIn(at place) *Agent {
dropList()
return nil
}
+ // bringBack moves the threads started while magpie was Codex's
+ // provider (model_provider "magpie") onto the provider Codex is on now,
+ // once it is off magpie: Codex lists only the threads of its current
+ // provider (app-server thread/list, the TUI's resume picker), so after
+ // a Disconnect, a hand edit, or magpie stepping back beside the
+ // ChatGPT sign-in, every thread started on magpie was gone from Codex
+ // (kaizaoji on X). Only magpie's own threads move, never those of a
+ // provider of the user's (CC Switch's, #887); none while a profile
+ // still names magpie, whose threads they are; and a copy of each is
+ // kept in magpie's trash (MoveCodexProvider). A thread Codex wrote to
+ // in the last minute waits for the next Sync. This machine's Codex
+ // only: a distro's state database isn't magpie's to open.
+ bringBack := func() {
+ if at.spell != nil || namesMagpie() {
+ return
+ }
+ to := sessions.CodexProviderIn(dir)
+ if to == magpieID {
+ return
+ }
+ moved, err := sessions.MoveCodexThreads(dir, magpieID, to)
+ if len(moved) > 0 {
+ log.Printf("codex: %d thread(s) started on magpie moved to %s, where Codex lists them", len(moved), to)
+ }
+ if err != nil {
+ log.Println("codex: moving magpie's threads:", err)
+ }
+ }
// mirrorsTaken are the mirrors takeMirrors pointed at magpie (#1796)
mirrorsTaken := func() []string {
var ids []string
@@ -1162,6 +1191,8 @@ func codexIn(at place) *Agent {
if at.spell == nil {
portCodexHome(dir, codexPortUnwire)
}
+ // and are listed where Codex now is
+ bringBack()
return settle()
},
// signed in with ChatGPT, Codex reaches magpie by the base URL with
@@ -1223,6 +1254,9 @@ func codexIn(at place) *Agent {
},
OwnVia: codexOwnViaMagpie,
Sync: func() error {
+ // after the sync, which may have put Codex back beside its
+ // sign-in, and whatever it failed at
+ defer bringBack()
// model_catalog_json naming magpie's list with the list gone,
// as an older magpie's Disconnect could leave it (zwaydot on
// X): Codex loads no config at all then. Connected or not, the
diff --git a/internal/agent/codex_threads_back_test.go b/internal/agent/codex_threads_back_test.go
new file mode 100644
index 000000000..8c4fe3dbe
--- /dev/null
+++ b/internal/agent/codex_threads_back_test.go
@@ -0,0 +1,136 @@
+package agent
+
+import (
+ "database/sql"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/yetone/magpie/internal/edit"
+)
+
+// codexThreadOn writes a thread of Codex's on the provider p, its rollout
+// a day old and its row in the state database, as Codex 0.162 keeps them.
+func codexThreadOn(t *testing.T, dir, id, p string) string {
+ t.Helper()
+ sub := filepath.Join(dir, "sessions", "2026", "10", "21")
+ os.MkdirAll(sub, 0o755)
+ path := filepath.Join(sub, "rollout-2026-10-21T10-00-00-"+id+".jsonl")
+ b := `{"timestamp":"2026-10-21T10:00:00.000Z","type":"session_meta","payload":{"id":"` + id + `","timestamp":"2026-10-21T10:00:00.000Z","cwd":"/work/proj","originator":"codex_cli_rs","cli_version":"0.162.1","source":"cli","model_provider":"` + p + `","base_instructions":{"text":"x"}}}` + "\n"
+ if err := os.WriteFile(path, []byte(b), 0o644); err != nil {
+ t.Fatal(err)
+ }
+ day := time.Now().Add(-24 * time.Hour)
+ os.Chtimes(path, day, day)
+ db, err := sql.Open("sqlite", filepath.Join(dir, "state_5.sqlite"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer db.Close()
+ if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS threads (id TEXT PRIMARY KEY, rollout_path TEXT NOT NULL, model_provider TEXT NOT NULL, model TEXT)`); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := db.Exec(`INSERT INTO threads VALUES (?, ?, ?, 'fake/m1')`, id, path, p); err != nil {
+ t.Fatal(err)
+ }
+ return path
+}
+
+func codexRowOn(t *testing.T, dir, id string) string {
+ t.Helper()
+ db, err := sql.Open("sqlite", filepath.Join(dir, "state_5.sqlite"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer db.Close()
+ var p string
+ if err := db.QueryRow(`SELECT model_provider FROM threads WHERE id = ?`, id).Scan(&p); err != nil {
+ t.Fatal(err)
+ }
+ return p
+}
+
+// kaizaoji on X: after using magpie with Codex and disconnecting it, Codex
+// said a project's earlier context didn't exist. Codex lists only the
+// threads of the provider it is on (app-server thread/list, the resume
+// picker), and with no ChatGPT sign-in (or an API key, or an account out
+// of its allowance) magpie is Codex's provider, so every thread started
+// then names "magpie" and was gone once Codex was back on OpenAI. They
+// come back to the provider Codex is on: at the Disconnect, and at a sync
+// after the provider was taken off by hand. A thread of a provider of the
+// user's own (CC Switch's "custom") stays where it is, and none moves
+// while Codex is on magpie, at its top or in a profile.
+func TestCodexThreadsComeBackOffMagpie(t *testing.T) {
+ const (
+ mine = "019a0000-0000-7000-8000-0000000000a1"
+ theirs = "019a0000-0000-7000-8000-0000000000a2"
+ before = "019a0000-0000-7000-8000-0000000000a3"
+ )
+ t.Run("disconnect", func(t *testing.T) {
+ home, _ := codexHome(t, "", "model = \"gpt-5.4\"\n")
+ dir := filepath.Join(home, ".codex")
+ cx := codex(home)
+ if err := cx.Fields[0].Set("fake/m1"); err != nil {
+ t.Fatal(err)
+ }
+ if p, _ := edit.GetTOMLTop(filepath.Join(dir, "config.toml"), "model_provider"); p != "magpie" {
+ t.Fatalf("provider %q, want magpie as Codex's provider with no sign-in", p)
+ }
+ minePath := codexThreadOn(t, dir, mine, "magpie")
+ codexThreadOn(t, dir, theirs, "custom")
+ codexThreadOn(t, dir, before, "openai")
+ // connected, magpie's threads are where Codex lists them
+ if err := cx.Sync(); err != nil {
+ t.Fatal(err)
+ }
+ if p := codexRowOn(t, dir, mine); p != "magpie" {
+ t.Fatalf("moved off magpie while Codex is on it: %q", p)
+ }
+ if err := cx.Unwire(); err != nil {
+ t.Fatal(err)
+ }
+ for id, want := range map[string]string{mine: "openai", theirs: "custom", before: "openai"} {
+ if p := codexRowOn(t, dir, id); p != want {
+ t.Errorf("thread %s on %q, want %q", id, p, want)
+ }
+ }
+ if b, _ := os.ReadFile(minePath); !strings.Contains(string(b), `"model_provider":"openai"`) {
+ t.Fatalf("rollout:\n%s", b)
+ }
+ })
+ t.Run("by hand", func(t *testing.T) {
+ // magpie taken out of config.toml by hand, its table left for its
+ // threads, and a profile of the user's on magpie
+ table := "\n[model_providers.magpie]\nname = \"magpie\"\nbase_url = \"http://127.0.0.1:3425/v1\"\nwire_api = \"responses\"\n"
+ profile := "\n[profiles.mg]\nmodel_provider = \"magpie\"\n"
+ home, _ := codexHome(t, "", "model = \"gpt-5.4\"\n"+table+profile)
+ dir := filepath.Join(home, ".codex")
+ path := filepath.Join(dir, "config.toml")
+ codexThreadOn(t, dir, mine, "magpie")
+ codexThreadOn(t, dir, theirs, "custom")
+ cx := codex(home)
+ cx.Sync()
+ // its threads are where `codex -p mg` lists them
+ if p := codexRowOn(t, dir, mine); p != "magpie" {
+ t.Fatalf("moved while a profile is on magpie: %q", p)
+ }
+ os.WriteFile(path, []byte("model = \"gpt-5.4\"\n"+table), 0o644)
+ cx.Sync()
+ for id, want := range map[string]string{mine: "openai", theirs: "custom"} {
+ if p := codexRowOn(t, dir, id); p != want {
+ t.Errorf("thread %s on %q, want %q", id, p, want)
+ }
+ }
+ // CC Switch's provider set by hand: a thread left on magpie goes there
+ codexThreadOn(t, dir, before, "magpie")
+ os.WriteFile(path, []byte("model = \"gpt-5.4\"\nmodel_provider = \"custom\"\n"+table+"\n[model_providers.custom]\nname = \"custom\"\nbase_url = \"https://relay.example/v1\"\n"), 0o644)
+ cx.Sync()
+ for id, want := range map[string]string{mine: "openai", theirs: "custom", before: "custom"} {
+ if p := codexRowOn(t, dir, id); p != want {
+ t.Errorf("thread %s on %q, want %q", id, p, want)
+ }
+ }
+ })
+}
diff --git a/internal/sessions/codex_provider.go b/internal/sessions/codex_provider.go
index 9c276d94a..db951ee7d 100644
--- a/internal/sessions/codex_provider.go
+++ b/internal/sessions/codex_provider.go
@@ -13,6 +13,7 @@ import (
"path/filepath"
"regexp"
"strconv"
+ "strings"
"time"
"github.com/klauspost/compress/zstd"
@@ -230,7 +231,12 @@ func MoveCodexProvider(id, to string) (CodexMove, error) {
if len(paths) == 0 {
return CodexMove{}, errors.New("no such session")
}
- now := time.Now()
+ return moveCodexPaths(id, to, paths, time.Now())
+}
+
+// moveCodexPaths moves one Codex thread, whose files are paths, to the
+// provider to, as MoveCodexProvider says; storeMu and mu are held.
+func moveCodexPaths(id, to string, paths []string, now time.Time) (CodexMove, error) {
for _, p := range paths {
if recent(p, now) {
return CodexMove{}, ErrActive
@@ -288,8 +294,8 @@ func MoveCodexProvider(id, to string) (CodexMove, error) {
mv.Files = append(mv.Files, p)
}
}
- for _, f := range fs {
- delete(cache, f.path)
+ for _, p := range paths {
+ delete(cache, p)
}
saveCache()
homes := map[string]bool{}
@@ -340,6 +346,95 @@ func CodexThreadProviders(home string) []string {
return out
}
+// codexThreadsOn are the ids of the threads a Codex folder's state
+// databases keep on the provider p. A database without the threads table,
+// or one that can't be read, says nothing.
+func codexThreadsOn(home, p string) []string {
+ var out []string
+ for _, path := range codexStateDBs(home) {
+ u := url.URL{Scheme: "file", Path: filepath.ToSlash(path), RawQuery: "mode=ro&_pragma=busy_timeout(2000)"}
+ if len(u.Path) >= 2 && u.Path[1] == ':' {
+ u.Path = "/" + u.Path
+ }
+ db, err := sql.Open("sqlite", u.String())
+ if err != nil {
+ continue
+ }
+ rows, err := db.Query(`SELECT id FROM threads WHERE model_provider = ?`, p)
+ if err == nil {
+ for rows.Next() {
+ var id string
+ if rows.Scan(&id) == nil && safeID.MatchString(id) && !contains(out, id) {
+ out = append(out, id)
+ }
+ }
+ rows.Close()
+ }
+ db.Close()
+ }
+ return out
+}
+
+// MoveCodexThreads moves every thread of a Codex folder its state database
+// keeps on the provider from to the provider to, each as MoveCodexProvider
+// moves one: its files' session_meta and its row, a copy of the files kept
+// in magpie's trash first. Codex lists only the threads of the provider it
+// is on (app-server thread/list, the TUI's resume picker), so the threads
+// started while magpie was Codex's provider were gone from Codex's lists
+// once Codex was off magpie (kaizaoji on X: "the context doesn't exist").
+// A thread written to in the last minute is left for the next call, and
+// so is one whose files can't be found; it says what it moved and the
+// first error it met, having gone on past it.
+func MoveCodexThreads(home, from, to string) ([]CodexMove, error) {
+ if !codexProviderRe.MatchString(from) || !codexProviderRe.MatchString(to) || from == to {
+ return nil, fmt.Errorf("can't move Codex's threads from %q to %q", from, to)
+ }
+ ids := codexThreadsOn(home, from)
+ if len(ids) == 0 {
+ return nil, nil
+ }
+ storeMu.Lock()
+ defer storeMu.Unlock()
+ mu.Lock()
+ defer mu.Unlock()
+ loadCache()
+ // each thread's files: its rollout, its segments (<id>_<child>) and
+ // their compressed twins, in sessions/ or archived_sessions/
+ files := map[string][]string{}
+ for _, sub := range []string{"sessions", "archived_sessions"} {
+ filepath.WalkDir(filepath.Join(home, sub), func(p string, d os.DirEntry, err error) error {
+ if err != nil || !d.Type().IsRegular() || !strings.HasPrefix(d.Name(), "rollout-") {
+ return nil
+ }
+ for _, id := range ids {
+ if strings.Contains(d.Name(), id) {
+ files[id] = append(files[id], p)
+ break
+ }
+ }
+ return nil
+ })
+ }
+ var moved []CodexMove
+ var first error
+ now := time.Now()
+ for _, id := range ids {
+ if len(files[id]) == 0 {
+ continue
+ }
+ mv, err := moveCodexPaths(id, to, files[id], now)
+ if err != nil {
+ if !errors.Is(err, ErrActive) && first == nil {
+ first = fmt.Errorf("thread %s: %w", id, err)
+ }
+ continue
+ }
+ mv.From = from
+ moved = append(moved, mv)
+ }
+ return moved, first
+}
+
func contains(list []string, s string) bool {
for _, x := range list {
if x == s {
diff --git a/internal/sessions/codex_threads_move_test.go b/internal/sessions/codex_threads_move_test.go
new file mode 100644
index 000000000..86f2af741
--- /dev/null
+++ b/internal/sessions/codex_threads_move_test.go
@@ -0,0 +1,131 @@
+package sessions
+
+import (
+ "database/sql"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+ "time"
+)
+
+// cxRollout writes a Codex rollout of the thread id on the provider p, as
+// Codex 0.162 starts one, with the time at.
+func cxRollout(t *testing.T, home, sub, id, p string, at time.Time) string {
+ t.Helper()
+ dir := filepath.Join(home, sub, "2026", "10", "21")
+ if sub == "archived_sessions" {
+ dir = filepath.Join(home, sub)
+ }
+ os.MkdirAll(dir, 0o755)
+ path := filepath.Join(dir, "rollout-2026-10-21T10-00-00-"+id+".jsonl")
+ b := `{"timestamp":"2026-10-21T10:00:00.000Z","type":"session_meta","payload":{"id":"` + id + `","timestamp":"2026-10-21T10:00:00.000Z","cwd":"/work/proj","originator":"codex_cli_rs","cli_version":"0.162.1","source":"cli","model_provider":"` + p + `","base_instructions":{"text":"x"}}}` + "\n" +
+ `{"timestamp":"2026-10-21T10:00:01.000Z","type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":"remember: the build uses make"}]}}` + "\n"
+ if err := os.WriteFile(path, []byte(b), 0o644); err != nil {
+ t.Fatal(err)
+ }
+ os.Chtimes(path, at, at)
+ return path
+}
+
+func cxThreadRows(t *testing.T, home string, rows map[string]string) string {
+ t.Helper()
+ p := filepath.Join(home, "state_5.sqlite")
+ db, err := sql.Open("sqlite", p)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer db.Close()
+ if _, err := db.Exec(`CREATE TABLE threads (id TEXT PRIMARY KEY, rollout_path TEXT NOT NULL, model_provider TEXT NOT NULL, title TEXT NOT NULL, archived INTEGER NOT NULL DEFAULT 0)`); err != nil {
+ t.Fatal(err)
+ }
+ for id, prov := range rows {
+ if _, err := db.Exec(`INSERT INTO threads VALUES (?, 'x', ?, 't', 0)`, id, prov); err != nil {
+ t.Fatal(err)
+ }
+ }
+ return p
+}
+
+// Codex lists only the threads of the provider it is on now, so the threads
+// started while magpie was its provider ("magpie") were gone from Codex
+// once it was off magpie (kaizaoji on X). MoveCodexThreads moves every
+// thread on one provider to another, in its files and its row, a copy of
+// each kept: an archived one too; one Codex wrote to in the last minute
+// waits; a thread of another provider (CC Switch's "custom") stays.
+func TestMoveCodexThreads(t *testing.T) {
+ _, home := manageSetup(t)
+ const (
+ old = "019a0000-0000-7000-8000-00000000000a"
+ archived = "019a0000-0000-7000-8000-00000000000b"
+ hot = "019a0000-0000-7000-8000-00000000000c"
+ theirs = "019a0000-0000-7000-8000-00000000000d"
+ )
+ day := time.Now().Add(-24 * time.Hour).Truncate(time.Second)
+ oldPath := cxRollout(t, home, "sessions", old, "magpie", day)
+ arPath := cxRollout(t, home, "archived_sessions", archived, "magpie", day)
+ hotPath := cxRollout(t, home, "sessions", hot, "magpie", time.Now())
+ theirPath := cxRollout(t, home, "sessions", theirs, "custom", day)
+ db := cxThreadRows(t, home, map[string]string{old: "magpie", archived: "magpie", hot: "magpie", theirs: "custom"})
+
+ moved, err := MoveCodexThreads(home, "magpie", "openai")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(moved) != 2 {
+ t.Fatalf("moved %+v, want the two not written to lately", moved)
+ }
+ for _, mv := range moved {
+ if mv.From != "magpie" || mv.To != "openai" || len(mv.DB) != 1 || mv.Backup == "" {
+ t.Fatalf("moved %+v", mv)
+ }
+ if _, err := os.Stat(filepath.Join(mv.Backup, "move.json")); err != nil {
+ t.Fatalf("no copy kept: %v", err)
+ }
+ }
+ want := map[string]string{oldPath: "openai", arPath: "openai", hotPath: "magpie", theirPath: "custom"}
+ for p, prov := range want {
+ if got := codexMetaProvider(p); got != prov {
+ t.Errorf("%s: file on %q, want %q", filepath.Base(p), got, prov)
+ }
+ if fi, _ := os.Stat(p); p != hotPath && !fi.ModTime().Equal(day) {
+ t.Errorf("%s: time %v, want %v kept", filepath.Base(p), fi.ModTime(), day)
+ }
+ }
+ for id, prov := range map[string]string{old: "openai", archived: "openai", hot: "magpie", theirs: "custom"} {
+ if got, _, _ := threadProvider(t, db, id); got != prov {
+ t.Errorf("row %s on %q, want %q", id, got, prov)
+ }
+ }
+ b, _ := os.ReadFile(oldPath)
+ if !strings.Contains(string(b), "remember: the build uses make") {
+ t.Fatalf("the thread's messages went:\n%s", b)
+ }
+
+ // the one written to lately goes once Codex is done with it
+ hour := time.Now().Add(-time.Hour)
+ os.Chtimes(hotPath, hour, hour)
+ if moved, err = MoveCodexThreads(home, "magpie", "openai"); err != nil || len(moved) != 1 || moved[0].ID != hot {
+ t.Fatalf("again: %+v %v", moved, err)
+ }
+ if moved, err = MoveCodexThreads(home, "magpie", "openai"); err != nil || len(moved) != 0 {
+ t.Fatalf("a third time: %+v %v", moved, err)
+ }
+}
+
+// A Codex folder with no state database, or none of its threads on the
+// provider, is left as it is, with nothing kept in the trash.
+func TestMoveCodexThreadsNone(t *testing.T) {
+ _, home := manageSetup(t)
+ day := time.Now().Add(-24 * time.Hour)
+ p := cxRollout(t, home, "sessions", "019a0000-0000-7000-8000-00000000000e", "magpie", day)
+ if moved, err := MoveCodexThreads(home, "magpie", "openai"); err != nil || len(moved) != 0 {
+ t.Fatalf("no database: %+v %v", moved, err)
+ }
+ if got := codexMetaProvider(p); got != "magpie" {
+ t.Fatalf("file on %q", got)
+ }
+ if _, err := MoveCodexThreads(home, "magpie", "magpie"); err == nil {
+ t.Fatal("a move to the same provider went")
+ }
+}