Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
sessions: a grown Claude file is read on after a restart, with the window it had (#3493)
yetoneff6f3188bd61
diff --git a/internal/sessions/call_cache.go b/internal/sessions/call_cache.goindex 96105f869..3caddb6de 100644--- a/internal/sessions/call_cache.go+++ b/internal/sessions/call_cache.go@@ -135,7 +135,8 @@ func pruneCalls(files []file) {if e.IsDir() {continue}- orphan := strings.HasSuffix(e.Name(), ".gob") && !shards[e.Name()]+ orphan := strings.HasSuffix(e.Name(), ".gob") && !shards[e.Name()] ||+ strings.HasSuffix(e.Name(), ".rev") && !shards[strings.TrimSuffix(e.Name(), ".rev")+".gob"]if strings.HasPrefix(e.Name(), "calls-") && strings.HasSuffix(e.Name(), ".tmp") {if st, err := e.Info(); err == nil && time.Since(st.ModTime()) > time.Hour {orphan = true@@ -298,7 +299,7 @@ func readCalls(f file) *callFile {if r, ok := lineCallReaders[f.agent]; ok && r.kept != nil && old != nil && !r.kept(old) {old = nil}- st := prepareCalls(f, old)+ st := prepareCalls(f, withCallRevisions(old))continued := old != nil && st.Off == old.Off && st.Off > 0start := 0if continued {@@ -331,6 +332,9 @@ func readCalls(f file) *callFile {if st.Claude != nil && (old == nil || old.Claude == nil) && !workingRevision(f.mod.UnixNano(), time.Now()) {st = st.withoutRevisions()}+ if err == nil && (f.agent == "claude" || f.agent == "claude-desktop") {+ writeCallRevisions(st)+ }st.dirty = nilcallsMu.Lock()diff --git a/internal/sessions/call_revisions.go b/internal/sessions/call_revisions.gonew file mode 100644index 000000000..a82dfd7b3--- /dev/null+++ b/internal/sessions/call_revisions.go@@ -0,0 +1,102 @@+package sessions++import (+ "bytes"+ "encoding/gob"+ "os"+ "path/filepath"+ "strings"+)++// A Claude Code session's revision window (claudeUsageState) lived in memory+// alone, so once magpie started again, or let a ninth live session's window+// go, every Claude file that had grown was read again from its first line: a+// live 2 GB session took seconds of the first Requests page after every+// update (#3493). The window is bounded (claudeRevisionEntries), so it is+// kept beside the file's shard, with where the read that made it stopped.++// callRevisions is a shard's Claude window, for the read that ended at Off.+type callRevisions struct {+ Off int64+ ContentHash string+ CompactMs int64+ Window []claudeWindowEntry+}++// claudeWindowEntry is one contribution, oldest first, as the window's+// eviction order has them.+type claudeWindowEntry struct {+ Key string+ M *claudeContribution+}++func callRevisionsPath(path string) string {+ return strings.TrimSuffix(callCachePath(path), ".gob") + ".rev"+}++// writeCallRevisions keeps st's window beside its shard, or takes away a+// window kept before when st has none.+func writeCallRevisions(st *callFile) {+ path := callRevisionsPath(st.Path)+ if st.Claude == nil {+ _ = os.Remove(path)+ return+ }+ r := callRevisions{Off: st.Off, ContentHash: st.ContentHash, CompactMs: st.CompactMs}+ for e := st.Claude.recent.Front(); e != nil; e = e.Next() {+ m := e.Value.(*claudeContribution)+ r.Window = append(r.Window, claudeWindowEntry{m.key, m})+ }+ var data bytes.Buffer+ if gob.NewEncoder(&data).Encode(r) != nil {+ return+ }+ out, err := os.CreateTemp(filepath.Dir(path), "calls-*.tmp")+ if err != nil {+ return+ }+ defer os.Remove(out.Name())+ _, err = out.Write(data.Bytes())+ if closeErr := out.Close(); err == nil {+ err = closeErr+ }+ if err == nil {+ _ = os.Rename(out.Name(), path)+ }+}++// withCallRevisions is old with the window kept for it, when old is a+// Claude file's read without one and the window kept is of that same read.+func withCallRevisions(old *callFile) *callFile {+ if old == nil || old.Claude != nil || (old.Agent != "claude" && old.Agent != "claude-desktop") || old.ContentHash == "" {+ return old+ }+ data, err := os.ReadFile(callRevisionsPath(old.Path))+ if err != nil {+ return old+ }+ var r callRevisions+ if gob.NewDecoder(bytes.NewReader(data)).Decode(&r) != nil || r.Off != old.Off || r.ContentHash != old.ContentHash {+ return old+ }+ w := &claudeUsageState{Messages: map[string]map[string]*claudeContribution{}}+ for _, e := range r.Window {+ m := e.M+ if m == nil {+ return old+ }+ m.key = e.Key+ m.weight = m.entryWeight()+ m.node = w.recent.PushBack(m)+ w.entries += m.weight+ branches := w.Messages[e.Key]+ if branches == nil {+ branches = map[string]*claudeContribution{}+ w.Messages[e.Key] = branches+ }+ branches[m.Request] = m+ }+ c := *old+ c.Claude, c.CompactMs = w, r.CompactMs+ return &c+}diff --git a/internal/sessions/claude_window_test.go b/internal/sessions/claude_window_test.goindex 62673b1ac..1de8bfeee 100644--- a/internal/sessions/claude_window_test.go+++ b/internal/sessions/claude_window_test.go@@ -199,3 +199,61 @@ func BenchmarkClaudeLargeActive(b *testing.B) {})}}++// After a restart a grown Claude file is read on from where it was left, with+// the window it had: a live 2 GB session was read from its first line on the+// first Requests page after every update (#3493). What it reads is what a+// read from the start makes.+func TestClaudeFileReadOnAfterRestart(t *testing.T) {+ d := setupCalls(t)+ path := filepath.Join(d.claude, "projects", "fixture", "session.jsonl")+ const count = 3000+ at := time.Date(2026, 9, 20, 12, 0, 0, 0, time.UTC)+ line := func(i int, id string, out int) string {+ return string(claudeUsageLine(at.Add(time.Duration(i)*time.Second), id, "req-"+id, "m", Tokens{Input: 1, Output: out}, "", true))+ }+ lines := make([]string, count)+ for i := range lines {+ lines[i] = line(i, fmt.Sprint(i), 2)+ }+ writeLines(t, path, lines...)+ read := func() []Call {+ t.Helper()+ for _, source := range CallSources() {+ if source.Path == path {+ return ReadCallSource(source)+ }+ }+ t.Fatal("source missing")+ return nil+ }+ read()+ before, err := os.Stat(callCachePath(path))+ if err != nil {+ t.Fatal(err)+ }+ Reset()+ // a recent message written again with more output, the last one replayed+ // as it was, and a new one+ appendText(t, path, line(count, "2990", 9)+"\n"+lines[count-1]+"\n"+line(count+1, "new", 2)+"\n")+ got := read()+ after, err := os.Stat(callCachePath(path))+ if err != nil {+ t.Fatal(err)+ }+ if !os.SameFile(before, after) {+ t.Fatal("the grown file was read again from its start")+ }+ Reset()+ os.Remove(callCachePath(path))+ os.Remove(callRevisionsPath(path))+ want := read()+ if len(got) != count+1 || !reflect.DeepEqual(got, want) {+ t.Fatalf("read on: %d calls, from the start: %d", len(got), len(want))+ }+ for _, c := range got {+ if c.Msg == "2990" && c.Output != 9 {+ t.Fatalf("the rewritten message kept its old output: %+v", c)+ }+ }+}