Skip to content

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

sessions: the Sessions page answers before a first read of a long history

yetonebc247a8cc499
diff --git a/docs/subsystems/gateway-sessions.md b/docs/subsystems/gateway-sessions.md
index 9be8c64c5..3fbf4ea58 100644
--- a/docs/subsystems/gateway-sessions.md
+++ b/docs/subsystems/gateway-sessions.md
@@ -48,6 +48,19 @@ counts as in its list, and on `/api/sessions/delete`, a native session is any
session file the agent keeps, one nothing was said in too, with no limit
(`sessions.NativeIDs`); one pass over the agents' files (`sessions.Manage`)
reads only the agent shown and the agents with gateway sessions (#2776).
+It answers before a first read of a long history (hey_boyce on X: the page
+stood on its placeholder rows on its first open). A file it would read whole
+(no parse kept, an older index, a file written over, or a Claude Code or
+Codex parse that can't be read on after a restart) is read behind the
+answer once more than `quickBytes` (32 MB) of them is waiting; until then its
+row stands on the parse kept, or on a glance at its first 256 KB (id,
+folder, first prompt, start) and, for Claude Code, the titles in its last
+64 KB, with its last activity the file's time. Such a row has `pending:
+true` and no counts, the page asks again every 1.5 s until none is, and a
+glance is never saved in the index (`savable`) nor taken by a refresh as a
+parse (`parsed`). See
+[`internal/sessions/manage_quick.go`](../../internal/sessions/manage_quick.go),
+`TestManageAnswersBeforeFirstReads` and `sessions-pending-fill.test.cjs`.
Gateway projections have no path,
resume command or terminal action: the agent's own files of them are not on
this computer. Their rows carry `gateway: true`; the Sessions page groups them
diff --git a/internal/gui/assets/plugins/sessions/client.js b/internal/gui/assets/plugins/sessions/client.js
index 8409c5e0e..7a474edc5 100644
--- a/internal/gui/assets/plugins/sessions/client.js
+++ b/internal/gui/assets/plugins/sessions/client.js
@@ -114,8 +114,29 @@ magpie.plugin("sessions", (ctx) => {
const UNDO = "M5.5 3.5 2.5 6.5l3 3M2.5 6.5H10a3.5 3.5 0 0 1 0 7H7";
const MOVE = "M2.5 8h10M9.5 5l3 3-3 3";
+ // fillIn asks again, while rows are still pending (a file of theirs not
+ // read whole yet: their first lines are what shows), for what the read
+ // behind the answer has found; only the list is drawn again, so the
+ // filter keeps its focus and an open menu stays.
+ let fillT = 0;
+ function fillSoon() {
+ clearTimeout(fillT);
+ if (!data?.sessions?.some((s) => s.pending)) return;
+ const n = loading, was = data.agent;
+ fillT = setTimeout(async () => {
+ if (n !== loading || view !== "sessions") return;
+ let d;
+ try { d = await api("sessions/manage?agent=" + encodeURIComponent(was)); } catch { return fillSoon(); }
+ if (n !== loading || !data || data.agent !== was || d?.agent !== was) return;
+ data = { ...data, ...d, agents: d?.agents || [], sessions: (d?.sessions || []).map((s) => ({ ...s, models: s.models || [] })), trash: d?.trash || [], agent: was };
+ if (view === "sessions" && !trashOn) redrawList(); // the pages shown stay
+ fillSoon();
+ }, 1500);
+ }
+
async function load(name) {
const n = ++loading;
+ clearTimeout(fillT);
if (!data) draw();
try {
const d = await api("sessions/manage?agent=" + encodeURIComponent(name ?? agent));
@@ -131,6 +152,7 @@ magpie.plugin("sessions", (ctx) => {
failed = e.message;
}
if (view === "sessions") draw();
+ if (n === loading) fillSoon();
}
// reveal: the Sessions page, from the Usage page's list (#752):
diff --git a/internal/gui/tests/sessions-pending-fill.test.cjs b/internal/gui/tests/sessions-pending-fill.test.cjs
new file mode 100644
index 000000000..6d6c66f51
--- /dev/null
+++ b/internal/gui/tests/sessions-pending-fill.test.cjs
@@ -0,0 +1,98 @@
+// Run with Node's test runner and Playwright on the module path; see README.md.
+// hey_boyce on X: the Sessions page stood on its placeholder rows for a
+// long time on its first open. magpie now answers before it has read a
+// long history whole: rows it hasn't read yet come from their files' first
+// lines and say they are pending, and the page asks again until none is.
+// Here the first answer has every row pending and no messages counted; the
+// page shows its rows at once, asks again on its own clock, and draws the
+// counts in without taking the filter's focus, then stops asking.
+const assert = require("node:assert/strict");
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const { test } = require("node:test");
+const { chromium, webkit } = require("playwright");
+
+const nap = (ms) => new Promise((r) => setTimeout(r, ms));
+const assets = path.resolve(__dirname, "../assets");
+const at = (min) => new Date(Date.now() - min * 60e3).toISOString();
+const sess = (id, cwd, title, min, extra) => ({
+ agent: "claude", id, cwd, title, start: at(min + 5), last: at(min), models: [],
+ resume: `cd ${cwd} && claude --resume ${id}`, path: `~/.claude/projects/x/${id}.jsonl`, size: 4096, files: 1, deletable: true, ...extra,
+});
+
+function serve(lang, seen) {
+ const state = { agents: [], profiles: [], settings: { lang, theme: "light" } };
+ return async (route) => {
+ const url = new URL(route.request().url());
+ const json = (data) => route.fulfill({ json: data });
+ if (url.pathname === "/boot.js") return route.fulfill({ contentType: "text/javascript", body: `window.bootPrefs = {lang:"${lang}",theme:"light",web:true};` });
+ if (url.pathname === "/wails/runtime.js") return route.fulfill({ contentType: "text/javascript", body: "export const Window = {};" });
+ if (url.pathname === "/api/state") return json(state);
+ if (url.pathname === "/api/plugins") return json({ plugins: [] });
+ if (url.pathname === "/api/groups") return json({ groups: [] });
+ if (url.pathname === "/api/providers") return json({ providers: [], presets: [], excluded: [], gateway: { running: true, window: true } });
+ if (url.pathname === "/api/sessions/manage") {
+ seen.manage++;
+ const read = seen.manage > 1; // read whole by the second ask
+ const extra = read ? { messages: 6 } : { pending: true };
+ return json({
+ agents: [{ agent: "claude", count: 2, deletable: true, name: "Claude Code", icon: "claudecode-color" }],
+ agent: "claude", sessions: [sess("a-1", "/work/app", "fix the login form", 3, extra), sess("a-2", "/work/app", "older task", 90, extra)],
+ terminal: true, trash: [], trashDir: "~/trash",
+ });
+ }
+ if (url.pathname.startsWith("/api/")) return json({});
+ const file = path.join(assets, url.pathname === "/" ? "index.html" : url.pathname);
+ const contentType = { ".html": "text/html", ".js": "text/javascript", ".css": "text/css", ".svg": "image/svg+xml", ".png": "image/png" }[path.extname(file)];
+ const body = await fs.readFile(file).catch(() => null);
+ return body ? route.fulfill({ body, contentType }) : route.fulfill({ status: 404, body: "" });
+ };
+}
+
+const words = {
+ en: { nav: "Sessions", six: "6 messages" },
+ zh: { nav: "会话", six: "6 条消息" },
+ "zh-TW": { nav: "會話", six: "6 條訊息" },
+ ja: { nav: "セッション", six: "6 件のメッセージ" },
+ de: { nav: "Sitzungen", six: "6 Nachrichten" },
+};
+
+for (const engine of (process.env.BROWSER ? [process.env.BROWSER] : ["chromium", "webkit"])) {
+ for (const [lang, width] of [["en", 900], ["zh", 900], ["zh-TW", 700], ["ja", 700], ["de", 420]]) {
+ const w = words[lang];
+ test(`${engine} ${lang} ${width}px: pending rows show at once and fill in`, async (t) => {
+ const browser = await (engine === "webkit" ? webkit.launch() : chromium.launch({ channel: "chromium" }));
+ t.after(() => browser.close());
+ const page = await (await browser.newContext({ viewport: { width, height: 560 }, reducedMotion: "reduce" })).newPage();
+ page.setDefaultTimeout(5000);
+ const errors = [], seen = { manage: 0 };
+ page.on("pageerror", (e) => errors.push(e.message));
+ await page.route("**/*", serve(lang, seen));
+ await page.clock.install();
+ await page.goto("http://magpie.test/?view=providers");
+ await page.locator("#nav").getByRole("button", { name: w.nav, exact: true }).click();
+ const view = page.locator("#view-sessions");
+ const row = view.locator('.row.sm-sess[data-id="a-1"]');
+ await row.waitFor();
+ assert.equal(seen.manage, 1);
+ assert.ok(!(await row.textContent()).includes(w.six), "counted before the read");
+ // the reader is typing in the filter when the counts come in
+ const filter = view.locator(".sm-filter");
+ await filter.click();
+ await filter.pressSequentially("fi");
+ await page.clock.runFor(2000);
+ for (let i = 0; i < 100 && !(await row.textContent()).includes(w.six); i++) await nap(20);
+ assert.ok((await row.textContent()).includes(w.six), "the counts were not drawn in");
+ assert.equal(seen.manage, 2);
+ assert.equal(await page.evaluate(() => document.activeElement?.classList.contains("sm-filter")), true, "the filter lost its focus");
+ assert.equal(await filter.inputValue(), "fi");
+ await filter.pressSequentially("x");
+ assert.equal(await filter.inputValue(), "fix");
+ // none pending: no more asks
+ await page.clock.runFor(6000);
+ await nap(100);
+ assert.equal(seen.manage, 2, "asked again with nothing pending");
+ assert.deepEqual(errors, []);
+ });
+ }
+}
diff --git a/internal/sessions/manage.go b/internal/sessions/manage.go
index 529ee3f97..a358f2f9b 100644
--- a/internal/sessions/manage.go
+++ b/internal/sessions/manage.go
@@ -49,6 +49,10 @@ type Managed struct {
Messages int `json:"messages"`
Files int `json:"files"`
Deletable bool `json:"deletable"`
+ // Pending: a file of it is still being read for the first time, and
+ // what it spent and its messages aren't counted yet (the Sessions page
+ // answers before such a read, manage_quick.go)
+ Pending bool `json:"pending,omitempty"`
// Codex: the provider the session was made with, and the one its Codex
// uses now, whose sessions alone its history lists (#887)
Provider string `json:"provider,omitempty"`
@@ -167,14 +171,24 @@ func Manage(native map[string]bool, pick func([]AgentCount, map[string]map[strin
loadCache()
defer useDBs()()
all := allFiles()
- v := ManageView{Agents: agentCounts(all), Native: nativeIDs(native, all)}
+ v := ManageView{Agents: agentCounts(all), Native: nativeIDsWith(native, all, true)}
v.Agent = pick(v.Agents, v.Native)
if v.Agent != "" {
- v.Sessions = listAgent(v.Agent, all)
+ v.Sessions = listAgentWith(v.Agent, all, true)
}
return v
}
+// readFor brings want's parses up to date: all of them, or, quick, as
+// quickRead does, with pending the paths still being read.
+func readFor(want, all []file, quick bool) (pending map[string]bool, done func()) {
+ if !quick {
+ refresh(want, all)
+ return nil, func() {}
+ }
+ return quickRead(want, all)
+}
+
// idInFile says which agents' session ids are read from inside the
// session's file, not taken from its name (as assemble does).
func idInFile(agent string) bool {
@@ -186,6 +200,10 @@ func idInFile(agent string) bool {
}
func nativeIDs(agents map[string]bool, all []file) map[string]map[string]bool {
+ return nativeIDsWith(agents, all, false)
+}
+
+func nativeIDsWith(agents map[string]bool, all []file, quick bool) map[string]map[string]bool {
groups := byKey(all, func(f *file) bool { return agents[f.agent] })
var want []file
for _, f := range all {
@@ -196,7 +214,8 @@ func nativeIDs(agents map[string]bool, all []file) map[string]map[string]bool {
want = append(want, f)
}
}
- refresh(want, all)
+ _, done := readFor(want, all, quick)
+ defer done()
out := map[string]map[string]bool{}
for a := range agents {
out[a] = map[string]bool{}
@@ -208,6 +227,10 @@ func nativeIDs(agents map[string]bool, all []file) map[string]map[string]bool {
}
func listAgent(agent string, all []file) []Managed {
+ return listAgentWith(agent, all, false)
+}
+
+func listAgentWith(agent string, all []file, quick bool) []Managed {
groups := byKey(all, func(f *file) bool { return f.agent == agent })
var mine []file
for _, f := range all {
@@ -215,7 +238,8 @@ func listAgent(agent string, all []file) []Managed {
mine = append(mine, f)
}
}
- refresh(mine, all)
+ pending, done := readFor(mine, all, quick)
+ defer done()
identities := map[string]CodexIdentity(nil)
taskTitles := map[codexTaskTitle]string(nil)
if agent == "codex" {
@@ -239,6 +263,7 @@ func listAgent(agent string, all []file) []Managed {
m := Managed{Session: s, Files: len(fs), Deletable: Deletable(agent) && !s.ReadOnly}
for _, f := range fs {
m.Size += f.size
+ m.Pending = m.Pending || pending[f.path]
if st := cache[f.path]; st != nil && f.main {
for _, d := range st.Days.all() {
m.Messages += d.Prompts + d.Replies
diff --git a/internal/sessions/manage_quick.go b/internal/sessions/manage_quick.go
new file mode 100644
index 000000000..098c1f0dc
--- /dev/null
+++ b/internal/sessions/manage_quick.go
@@ -0,0 +1,275 @@
+package sessions
+
+import (
+ "bytes"
+ "maps"
+ "runtime"
+ "sync"
+)
+
+// The Sessions page answers before the files it has never read are read
+// whole (hey_boyce on X: the page showed its placeholder rows for a long
+// time on its first open). A first read of a long history (13 GB of Claude
+// Code's and 52 GB of Codex's files on one computer) takes minutes, and
+// Manage used to read all of it before it answered: the agent shown, and
+// every agent with a gateway session for its ids, Codex's too while Claude
+// Code was shown. It still reads at once what is cheap: a file it has a
+// parse of that has only grown, read on from where the parse left off. A
+// file it would read whole (none kept, an older magpie's index, a file
+// written over, or a Claude Code or Codex file whose kept parse can't be
+// read on after a restart) is read behind the answer, as Stats and List
+// read it, and until then its row stands on what is known now: the parse
+// kept of it, or a glance at its first lines (its id, folder, first prompt
+// and start), with its last activity the file's time. Such a row says it
+// is Pending, and the page asks again until none is.
+
+// glanceBytes is how far into a file a glance reads at most.
+const glanceBytes = 256 << 10
+
+// quickBytes is how much reading whole the page still waits for: a store
+// that small is read in well under a second, even on a slow disk, and its
+// rows come complete the first time.
+var quickBytes int64 = 32 << 20
+
+var (
+ // glances are the files glanced at, by path, while their whole read
+ // is under way; each stands for the size and time it was read at
+ glances = map[string]*state{}
+ // overlaid are the glances put into the cache for one pass of
+ // Manage, never saved with it
+ overlaid = map[string]*state{}
+ // behind are the paths a read behind an answer has taken, and
+ // behindRuns the reads, waited for by Reset
+ behind = map[string]bool{}
+ behindRuns sync.WaitGroup
+)
+
+// readsWhole says whether bringing f's parse up to date reads the file
+// from its start: no parse of it is kept, or the one kept can't be read on.
+// Only the agents read line by line can be glanced at; the others are read
+// as before.
+func readsWhole(f file, old *state) bool {
+ p := parserFor(f.agent)
+ if p.line == nil {
+ return false
+ }
+ if old == nil || f.size < old.Size || old.Off > f.size {
+ return true
+ }
+ if f.agent == "codex" && old.Codex == nil {
+ return true
+ }
+ return p.claude && old.Claude == nil
+}
+
+func current(f file, s *state) bool {
+ return s != nil && s.Size == f.size && s.Mod == f.mod.UnixNano()
+}
+
+// quickRead is refresh for the Sessions page, under mu: what is cheap is
+// read now, and what would be read whole is read behind. pending are the
+// paths not read yet, and done takes the glances back out of the cache;
+// nothing may let mu go between the two.
+func quickRead(want, all []file) (pending map[string]bool, done func()) {
+ var now, later []file
+ for _, f := range want {
+ if f.cold {
+ continue
+ }
+ if old := cache[f.path]; !current(f, old) && readsWhole(f, old) {
+ later = append(later, f)
+ continue
+ }
+ now = append(now, f)
+ }
+ var whole int64
+ for _, f := range later {
+ whole += f.size
+ }
+ if whole <= quickBytes {
+ now, later = append(now, later...), nil
+ }
+ refresh(now, all)
+ pending = map[string]bool{}
+ var start, look []file
+ for _, f := range later {
+ old := cache[f.path]
+ if current(f, old) {
+ continue // read meanwhile
+ }
+ pending[f.path] = true
+ if !behind[f.path] {
+ start = append(start, f)
+ }
+ if old == nil && f.main && !current(f, glances[f.path]) {
+ look = append(look, f)
+ }
+ }
+ if len(start) > 0 {
+ readBehind(start)
+ }
+ if len(look) > 0 {
+ mu.Unlock()
+ seen := glanceAll(look)
+ mu.Lock()
+ for i, f := range look {
+ if seen[i] != nil {
+ glances[f.path] = seen[i]
+ }
+ }
+ }
+ put := map[string]*state{}
+ for p := range pending {
+ if cache[p] == nil && glances[p] != nil {
+ put[p] = glances[p]
+ }
+ }
+ for p, g := range put {
+ cache[p], overlaid[p] = g, g
+ }
+ return pending, func() {
+ for p, g := range put {
+ if cache[p] == g {
+ delete(cache, p)
+ }
+ delete(overlaid, p)
+ }
+ }
+}
+
+// readBehind reads fs whole after the answer, as refresh does, and lets
+// their glances go once read.
+func readBehind(fs []file) {
+ for _, f := range fs {
+ behind[f.path] = true
+ }
+ behindRuns.Add(1)
+ go func() {
+ defer behindRuns.Done()
+ storeMu.RLock()
+ defer storeMu.RUnlock()
+ mu.Lock()
+ defer mu.Unlock()
+ loadCache()
+ refresh(fs, nil)
+ for _, f := range fs {
+ delete(behind, f.path)
+ delete(glances, f.path)
+ }
+ }()
+}
+
+// glanceAll glances at each of fs, a few at a time.
+func glanceAll(fs []file) []*state {
+ out := make([]*state, len(fs))
+ ch := make(chan int)
+ var wg sync.WaitGroup
+ for range min(max(runtime.NumCPU()/2, 1), len(fs)) {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ for i := range ch {
+ out[i] = glance(fs[i])
+ }
+ }()
+ }
+ for i := range fs {
+ ch <- i
+ }
+ close(ch)
+ wg.Wait()
+ return out
+}
+
+// glance is what f's first lines say of its session: its id, folder,
+// title and start, read with its agent's own parser, and none of what it
+// spent, which only a whole read can count. Its last activity is the
+// file's time.
+func glance(f file) *state {
+ p := parserFor(f.agent)
+ s := &state{}
+ var head func([]byte) bool
+ var thin func([]byte) (thinner, bool)
+ switch {
+ case p.claude:
+ thin = thinClaude
+ case f.agent == "codex":
+ head = func(b []byte) bool { return codexHead(s, b, f.main) }
+ thin = thinCodex
+ }
+ idIn := idInFile(f.agent)
+ _, err := scanThin(f.path, 0, head, thin, func(b []byte, _, end int64) bool {
+ p.line(s, b, f.main)
+ if s.Cwd != "" && s.Title != "" && (!idIn || s.ID != "") {
+ return false
+ }
+ return end < glanceBytes
+ })
+ if err != nil {
+ return nil
+ }
+ if p.claude && f.main {
+ claudeTail(s, f)
+ }
+ if isBuddy(f.agent) && s.Cwd == "" {
+ workbuddyMeta(s, f.path)
+ }
+ g := &state{Size: f.size, Mod: f.mod.UnixNano(), ID: s.ID, Cwd: s.Cwd, Title: s.Title, Named: s.Named,
+ Custom: s.Custom, First: s.First, Start: s.Start, Last: f.mod, CodexIdentity: s.CodexIdentity,
+ CodexNickname: s.CodexNickname, Provider: s.Provider}
+ if g.Start.IsZero() || g.Start.After(g.Last) {
+ g.Start = g.Last
+ }
+ return g
+}
+
+// parsed is the parse kept of path: none for a glance put in the cache,
+// which a refresh reads whole as though nothing were kept.
+func parsed(path string) *state {
+ s := cache[path]
+ if s != nil && overlaid[path] == s {
+ return nil
+ }
+ return s
+}
+
+// tailBytes is how much of a Claude Code file's end a glance reads for its
+// titles.
+const tailBytes = 64 << 10
+
+// claudeTail reads the titles at the end of a Claude Code file into s: the
+// one Claude Code gives a session, and one the user gave it, are lines it
+// adds as the session goes on, the last of each the one that stands.
+func claudeTail(s *state, f file) {
+ from := max(f.size-tailBytes, 0)
+ p := parserFor(f.agent)
+ scanThin(f.path, from, nil, nil, func(b []byte, start, _ int64) bool {
+ if start == from && from > 0 {
+ return true // the end of a line begun before
+ }
+ if bytes.Contains(b, ccTitle) || bytes.Contains(b, ccCustom) {
+ p.line(s, b, true)
+ }
+ return true
+ })
+}
+
+// savable is the cache as it is saved: without the glances put in it.
+func savable() map[string]*state {
+ c := maps.Clone(cache)
+ for p, g := range overlaid {
+ if c[p] == g {
+ delete(c, p)
+ }
+ }
+ return c
+}
+
+// forgetBehind waits for the reads behind answers, and forgets the glances
+// (Reset).
+func forgetBehind() {
+ behindRuns.Wait()
+ mu.Lock()
+ glances, overlaid, behind = map[string]*state{}, map[string]*state{}, map[string]bool{}
+ mu.Unlock()
+}
diff --git a/internal/sessions/manage_quick_test.go b/internal/sessions/manage_quick_test.go
new file mode 100644
index 000000000..89e791663
--- /dev/null
+++ b/internal/sessions/manage_quick_test.go
@@ -0,0 +1,122 @@
+package sessions
+
+import (
+ "sync/atomic"
+ "testing"
+ "time"
+)
+
+// The Sessions page answers before a first read of its files (hey_boyce on
+// X: its placeholder rows stood for a long time on a first open). Its rows
+// come from a glance at each file's first lines, say they are pending, and
+// the whole read runs behind the answer; the next ask has their counts.
+func TestManageAnswersBeforeFirstReads(t *testing.T) {
+ setup(t)
+ old := quickBytes
+ quickBytes = 0 // as a long history: every file over the bar
+ release := make(chan struct{})
+ var parses atomic.Int64
+ parseHook = func() { parses.Add(1); <-release }
+ opened := false
+ open := func() {
+ if !opened {
+ opened = true
+ close(release)
+ }
+ }
+ t.Cleanup(func() { open(); behindRuns.Wait(); parseHook, quickBytes = nil, old })
+
+ claude := func([]AgentCount, map[string]map[string]bool) string { return "claude" }
+ got := make(chan ManageView, 1)
+ go func() { got <- Manage(map[string]bool{"codex": true, "claude": true}, claude) }()
+ var v ManageView
+ select {
+ case v = <-got:
+ case <-time.After(30 * time.Second): // a fail-safe: the old code never answers
+ n := parses.Load()
+ open()
+ <-got // ended before the test's folder goes
+ t.Fatalf("Manage waited for the whole read (%d files being read)", n)
+ }
+ if len(v.Sessions) < 2 {
+ t.Fatalf("listed %d sessions before the read", len(v.Sessions))
+ }
+ for _, m := range v.Sessions {
+ if !m.Pending {
+ t.Fatalf("%s not pending, read whole before the answer", m.ID)
+ }
+ if m.Last.IsZero() {
+ t.Fatalf("glanced row %+v has no time", m.Session)
+ }
+ if m.Input+m.Output != 0 {
+ t.Fatalf("a glance counted tokens: %+v", m.Tokens)
+ }
+ }
+ glanced := map[string]Managed{}
+ for _, m := range v.Sessions {
+ glanced[m.ID] = m
+ }
+ named := 0
+ for _, m := range glanced {
+ if m.Cwd != "" && m.Title != "" {
+ named++
+ }
+ }
+ if named == 0 {
+ t.Fatalf("no glanced row has a folder and title: %+v", v.Sessions)
+ }
+ if !v.Native["codex"]["01a0bdc9-b5fd-7e63-9658-68bc8dce5ecd"] {
+ t.Fatalf("codex ids from the glance: %v", v.Native["codex"])
+ }
+ // no glance stays in the cache, nor goes into a save
+ mu.Lock()
+ for _, m := range v.Sessions {
+ if s := cache[m.Path]; s != nil {
+ mu.Unlock()
+ t.Fatalf("%s: a glance left in the cache", m.Path)
+ }
+ }
+ if len(savable()) != 0 {
+ mu.Unlock()
+ t.Fatal("a glance would be saved")
+ }
+ mu.Unlock()
+
+ // asked again while the read is under way: still answered, still pending
+ go func() { got <- Manage(map[string]bool{"codex": true}, claude) }()
+ select {
+ case v = <-got:
+ case <-time.After(30 * time.Second):
+ open()
+ <-got
+ t.Fatal("a second ask waited for the read under way")
+ }
+ if len(v.Sessions) == 0 || !v.Sessions[0].Pending {
+ t.Fatalf("second ask: %+v", v.Sessions)
+ }
+
+ open()
+ behindRuns.Wait()
+ v = Manage(map[string]bool{"codex": true}, claude)
+ spent := false
+ for _, m := range v.Sessions {
+ if m.Pending {
+ t.Fatalf("%s still pending after the read", m.ID)
+ }
+ spent = spent || m.Input+m.Output > 0 && m.Messages > 0
+ // the glance showed what the whole read shows
+ g, ok := glanced[m.ID]
+ if !ok || g.Cwd != m.Cwd || g.Title != m.Title || g.Path != m.Path {
+ t.Fatalf("glanced %q %q %q, read %q %q %q", g.ID, g.Cwd, g.Title, m.ID, m.Cwd, m.Title)
+ }
+ }
+ if len(v.Sessions) != len(glanced) {
+ t.Fatalf("%d glanced, %d read", len(glanced), len(v.Sessions))
+ }
+ if !spent {
+ t.Fatalf("read whole and nothing counted: %+v", v.Sessions)
+ }
+ if !v.Native["codex"]["01a0bdc9-b5fd-7e63-9658-68bc8dce5ecd"] {
+ t.Fatalf("codex ids after the read: %v", v.Native["codex"])
+ }
+}
diff --git a/internal/sessions/sessions.go b/internal/sessions/sessions.go
index a8fc1c736..3a86db697 100644
--- a/internal/sessions/sessions.go
+++ b/internal/sessions/sessions.go
@@ -978,7 +978,7 @@ func loadCache() {
// row are folded into the latest, and one is written saveGap after the
// last at the soonest.
func saveCache() {
- snap := save{cacheFile{Version: cacheVersion, Zone: zone(), Files: maps.Clone(cache)}, CachePath()}
+ snap := save{cacheFile{Version: cacheVersion, Zone: zone(), Files: savable()}, CachePath()}
saving.Lock()
defer saving.Unlock()
saving.next = &snap
@@ -1107,7 +1107,7 @@ func refresh(want, all []file) {
if f.cold {
continue // in a stopped WSL distro: what was read of it stands
}
- if s := cache[f.path]; s == nil || s.Size != f.size || s.Mod != f.mod.UnixNano() || (f.agent == "hermes" && (f.m().hermes == nil || f.m().rev == "" || s.DBRevision != f.m().rev)) || ((f.agent == "alma" || f.agent == "cursor" || f.agent == "agy") && s.DBRevision != f.m().rev) {
+ if s := parsed(f.path); s == nil || s.Size != f.size || s.Mod != f.mod.UnixNano() || (f.agent == "hermes" && (f.m().hermes == nil || f.m().rev == "" || s.DBRevision != f.m().rev)) || ((f.agent == "alma" || f.agent == "cursor" || f.agent == "agy") && s.DBRevision != f.m().rev) {
if parsing[f.path] != nil {
// a refresh is reading it, another or this one (a path
// listed twice): its last parse stands until that one is
@@ -1168,7 +1168,7 @@ func refresh(want, all []file) {
}
jobs := make([]job, len(todo))
for i, f := range todo {
- jobs[i] = job{f: f, old: cache[f.path]}
+ jobs[i] = job{f: f, old: parsed(f.path)}
}
generation := cacheGeneration
mu.Unlock()
@@ -1209,7 +1209,7 @@ func refresh(want, all []file) {
publish := func(i int) {
j := &jobs[i]
// A concurrent read may already have published a newer parse.
- if generation == cacheGeneration && cache[j.f.path] == j.old {
+ if generation == cacheGeneration && parsed(j.f.path) == j.old {
cache[j.f.path] = j.parsed
}
close(parsing[j.f.path])
@@ -1383,6 +1383,7 @@ func Reset() {
wslReset()
forgetHermesPrints()
forgetAgySummaries()
+ forgetBehind()
mu.Lock()
defer mu.Unlock()
saved()