Every view recomputes from scratch — be status rewalks the worktree, recurses every sub and rebuilds the quad each time it re-fires, and a warm pager pays that again per click. With JAB-032 a drained event names the dir it fell in, so a resident process can keep ONE record per repo of what a view produced and drop it the moment anything under that repo is touched. Cache lifetime is bounded by the watcher's: a failed start leaves the cache null and everything recomputes, so a missed event is never read back as truth. Rulings gritzko 2026-08-02; invalidation IS the design, storage is a Map.
The cache holds a view's OUTPUT, not its intermediate model — that is the difference between instant and 30%.
status in a resident process, 619 files + one sub: a cached HIT still read 2240 of 2425 objects — 7.6% saved, because the recursed sub carries trackPin and bypassed the cache by construction.core/emit.js is a ROW SINK ({uri, verb, ts}) and ONE edge flush/render paints rows with theme + width — so the cacheable artifact is the ROW LIST, never the painted bytes.be status inputs: wt bytes, the ulog/wtlog rows, the refs the quad reads, each sub's status (Status, shared/quad.js). The first two are files the watcher sees; the rest are not.shared/store.js:420, the mutable <shard>/refs ULOG), and no file under the repo changes.mintBe re-mints be per verb invocation (core/loop.js:466), so the cache cannot hang off be — it is a module singleton, and its identity depends on the path it was required through (see Blockers).One record per repo, a fingerprint for what the watcher cannot see, and a hit that renders instantly.
be status src/) caches NOTHING and recomputes. No per-path, per-arg or per-rev keys.{rows: [...], state: "uri?track#base"} — rows for the flush to render, state as the validity fingerprint.state covers every input the watcher CANNOT observe: the track tip, the base sha, each sub's pin, and the patch column's absorbed refs. A mismatch is a miss.R/r in the pager drops the WHOLE cache (gritzko): refresh is the "I do not trust this screen" gesture and must recompute everything, not re-serve a record.fsw.OVERFLOW (or a Buf-full loss) drops everything.Pure performance work: with the cache disabled every view must behave exactly as it does today, byte for byte.
shared/classify.js wtWalk (already extracted); shared/util/ignore.js load/match/isMeta; core/resolve_hash.js treeAt/projectRoot/workRoot (THE .be climb, never reimplemented); shared/subs.js enumerate; shared/util/path.js for joins.shared/cache.js from the first attempt SURVIVES as-is (per-repo buckets, free-form values, ancestor drop, watcher-bound lifetime, lazy arm-before-compute). Only the CONSUMER changes.ts at flush), so a resize or a --plain re-fire would serve output computed for the old geometry.state fingerprint REPLACES the store-refs watching axis: rather than arming <shard>/refs and dropping across worktrees, each repo re-reads its own tips cheaply and compares. Same coverage, no cross-wt bookkeeping.state, compare, flush rows — the ~6-object floor, which is the "instant" target.take(repo, key, compute) — no get/put pair, because a split surface is what lets a caller arm AFTER computing and be born stale.R/r hooks the KEY (views/bro/pager.js:565), not _refresh(): back and editor-exit also call _refresh, and those do not need a full drop (an edited file fires its own event anyway).shared/quad.js quadOf + cloneModel) so the two designs never coexist half-donestate builder: track tip + base sha + each sub's pin + patch-absorbed refs, one greppable string; a miss on ANY difference{rows, state}R/r → cache.dropAll() at views/bro/pager.js:565state with NO fs event; R drops all; overflow drops all; watcher-start failure = every read recomputesstate: two wts on one store, post in wt A, wt B's status must recomputestatus hit must read ~0 objects (the first attempt read 2240 of 2425 — that is the bar to beat)jsrc is a symlink to ., so requiring shared/cache.js through <root>/ and through <root>/jsrc/ yields TWO module instances. A bench run 2026-08-02 showed live=true, hits=0 while the wall time still improved (JIT warm-up), which reads exactly like a working cache. Make the mismatch impossible or loud.pol.init() wipes the fd table and would strand a pol-registered watcher; the first attempt sidesteps this by draining at the top of take — keep that.fsw.unwatch(wd) cannot remove the kernel watch (FSWUndir deleted under ABC-013), so a long-lived watcher over a churning tree accumulates watches until fsw.stop().ninja build inside a watched tree overflows the queue routinely, so dropAll is a normal path, not a corner case.io.lstat warm (0.26 us in C), so a 619-file repo stats in ~2 ms out of a 98 ms status. The win is skipped object reads and quad building.