spexcode 0.6.0 → 0.6.2

package/spec-eval/src/sessioneval.ts

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from 'node:crypto'
 import { mkdtemp, readFile, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
-import { dirname, join, relative } from 'node:path'
+import { dirname, join, relative, resolve as resolvePath } from 'node:path'
 import {
   batchBlobTexts,
   batchRevisionOids,
@@ -13,13 +13,16 @@ import {
   driftIndex,
   historyIndex,
   treeTextFiles,
+  withEventLedgerBuild,
+  withEventLedgerDemand,
   type DriftIndex,
   type DriftPathEvent,
   type ReviewDiffFile,
 } from '../../spec-cli/src/git.js'
+import { touchRoot } from '../../spec-cli/src/root-lru.js'
 import { loadSpecs } from '../../spec-cli/src/specs.js'
 import { mainBranch } from '../../spec-cli/src/layout.js'
-import { reviewPayload } from '../../spec-cli/src/sessions.js'
+import { reviewIdentity, reviewPayload, type ReviewIdentity } from '../../spec-cli/src/sessions.js'
 import { loadEvalRemarkTracks } from '../../spec-cli/src/issues.js'
 import {
   anchorHitCommits,
@@ -120,7 +123,7 @@ type LoadedSpec = Awaited<ReturnType<typeof loadSpecs>>[number]
 async function impactGit(root: string, args: string[], operation: string): Promise<string> {
   const result = await gitTry(['-C', root, ...args])
   if (!result.ok) {
-    const detail = result.stderr.trim() || `${result.failure ?? 'git'} failure`
+    const detail = result.failure ? `${result.failure} failure${result.stderr.trim() ? `: ${result.stderr.trim()}` : ''}` : result.stderr.trim() || 'git failure'
     throw new SessionImpactUnavailableError(`session impact cannot ${operation}: ${detail}`)
   }
   return result.stdout
@@ -129,7 +132,7 @@ async function impactGit(root: string, args: string[], operation: string): Promi
 async function impactIndexGit(root: string, indexFile: string, args: string[], operation: string): Promise<string> {
   const result = await gitTry(['-C', root, ...args], { indexFile })
   if (!result.ok) {
-    const detail = result.stderr.trim() || `${result.failure ?? 'git'} failure`
+    const detail = result.failure ? `${result.failure} failure${result.stderr.trim() ? `: ${result.stderr.trim()}` : ''}` : result.stderr.trim() || 'git failure'
     throw new SessionImpactUnavailableError(`session impact cannot ${operation}: ${detail}`)
   }
   return result.stdout
@@ -400,11 +403,45 @@ function parsedRelation(raw: readonly string[], relation: 'code' | 'related', ow
 // Public, exact-revision impact projection. It reads both spec trees and all scenario declarations from
 // immutable Git objects, reuses the canonical relation/anchor engine, then re-resolves the caller's selectors
 // before publication. Callers may pass branch names, but never receive a projection spanning two ref states.
+// @@@ the projection is the PERMANENT half ([[taste]] 19) - what commits between two immutable trees changed
+// which paths, and what each side declared, are facts about those commits: they cannot change, so a repeat
+// projection over the same inputs is pure recomputation. It used to be deliberately build-local, which was
+// right while it was cheap; on a branch 840 commits from its base it is 2.4s, and a detail open pays it
+// EVERY time because a focused build deposits no cut. Every input that can move the result is in the key —
+// the two resolved commit oids, the live overlay's own content revision, and the measurement axis — so a hit
+// answers the identical question. The promise is cached, not the value, so concurrent openers join one
+// projection; a rejection is never retained, keeping an unavailable selector loud on every read.
+const impactSlots = Math.max(4, Number(process.env.SPEXCODE_IMPACT_SLOTS || 32))
+const impactRoots = new Map<string, string>()
+const impactMemo = new Map<string, Promise<SessionImpactProjection>>()
+function impactKey(root: string, base: string, head: string, options: SessionImpactOptions): string {
+  const measurements = Object.entries(options.measurements ?? {})
+    .map(([node, names]) => `${node}:${[...names].sort().join(',')}`).sort().join('\u001f')
+  return [resolvePath(root), base, head, options.overlay?.revision ?? '', createHash('sha256').update(measurements).digest('hex')].join('\0')
+}
+
 export async function projectSessionImpact(root: string, options: SessionImpactOptions): Promise<SessionImpactProjection> {
   const [base, head] = await Promise.all([
     impactCommit(root, options.base),
     impactCommit(root, options.head),
   ])
+  const memoKey = impactKey(root, base, head, options)
+  const memoHit = impactMemo.get(memoKey)
+  if (memoHit) return memoHit
+  const flight = projectSessionImpactUncached(root, options, base, head)
+  impactMemo.set(memoKey, flight)
+  flight.catch(() => { if (impactMemo.get(memoKey) === flight) impactMemo.delete(memoKey) })
+  touchRoot(impactRoots, impactMemo, resolvePath(root), memoKey, impactSlots)
+  return flight
+}
+
+// the slow, obviously-correct recompute — kept whole as the specification the cached path must equal
+export async function projectSessionImpactUncached(
+  root: string,
+  options: SessionImpactOptions,
+  base: string,
+  head: string,
+): Promise<SessionImpactProjection> {
   const ancestry = await gitTry(['-C', root, 'merge-base', '--is-ancestor', base, head])
   if (!ancestry.ok) {
     if (ancestry.failure === 'exit') {
@@ -413,7 +450,7 @@ export async function projectSessionImpact(root: string, options: SessionImpactO
     throw new SessionImpactUnavailableError(`session impact cannot verify base/head ancestry: ${ancestry.stderr.trim() || ancestry.failure}`)
   }
   // One immutable .spec tree read per distinct revision supplies BOTH spec relations and eval declarations.
-  // This is deliberately build-local: exact projections do not need another resident cache or generation.
+  // Build-local by design: the memo above owns reuse ACROSS builds, this map owns it within one.
   const treeByRevision = new Map<string, ReadonlyMap<string, string>>()
   const readTree = (revision: string): ReadonlyMap<string, string> => {
     const cached = treeByRevision.get(revision)
@@ -763,14 +800,23 @@ export type ExportModel = {
 
 // null when no session has that id (route → 404).
 export async function buildExportModel(id: string): Promise<ExportModel | null> {
-  const payload = await reviewPayload(id)
-  if (!payload) return null
+  const identity = reviewIdentity(id)
+  if (!identity) return null
   // root EVERYTHING at the SESSION's worktree — readings, freshness, AND the spec tree itself. The
   // worktree's .spec is the branch's pending proposal ([[source-of-truth]]): a node the branch ADDED
   // exists only there, so a trunk-rooted loadSpecs would silently drop it from the model (the 0fca
   // family's node-existence layer). No worktree → the backend checkout, unchanged.
-  const wtPath = worktreePathForBranch(payload.branch)
+  const wtPath = worktreePathForBranch(identity.branch)
   const ctxRoot = wtPath ?? repoRoot()
+  return withEventLedgerDemand(ctxRoot, async () => {
+    const payload = await reviewPayload(id)
+    return payload
+      ? withEventLedgerBuild(ctxRoot, () => buildExportModelInLedger(id, payload, wtPath, ctxRoot))
+      : null
+  })
+}
+
+async function buildExportModelInLedger(id: string, payload: ReviewPayloadValue, wtPath: string | null, ctxRoot: string): Promise<ExportModel> {
   const specs = await loadSpecs(ctxRoot)
   const specById = new Map(specs.map((s) => [s.id, s]))
   const [didx, hidx] = await Promise.all([driftIndex(ctxRoot), historyIndex(ctxRoot)])
@@ -1383,13 +1429,18 @@ export type SessionEvals = {
   node: string | null
   branch: string | null
   title: string
-  ahead: number
-  dirtyNonRuntime: number
-  gates: ExportGate[]
   nodes: SessionEvalNode[]
   impact: SessionImpactProjection
-  summary: SessionEvalSummary
+  // the whole scope's seven counts. A FOCUSED build cannot honestly produce them — it measured six rows,
+  // not the scope — so it carries the summary only when the cut already holds one, and otherwise omits it
+  // rather than publishing a fold over the window. `evalRevision.content` is the stronger identity anyway:
+  // equal content revision IS the same evaluation cut, so a consumer fencing on it needs no counts.
+  summary?: SessionEvalSummary
   evalRevision: SessionEvalRevision
+  // present ONLY on a focused build: the whole population's identity+sequence facts, because `nodes` then
+  // holds just the few the response will render. Its presence is exactly what marks a model as PARTIAL —
+  // such a model may never enter the shared cut, or the list page would read the scope as those few nodes.
+  order?: SessionEvalOrderRow[]
 }
 
 export type SessionEvalSummary = {
@@ -1449,7 +1500,7 @@ async function sessionScopeNodes(
   ctx: Awaited<ReturnType<typeof evalContext>>,
   impact: SessionImpactProjection,
   shas: ReadonlySet<string>,
-  latestOnly = false,
+  freshness: { order?: boolean; only?: ReadonlySet<string> } = {},
 ): Promise<SessionEvalNode[]> {
   const evalById = new Map(ctx.ynodes.map((node) => [node.id, node]))
   const specById = new Map(ctx.specs.map((spec) => [spec.id, spec]))
@@ -1460,10 +1511,13 @@ async function sessionScopeNodes(
   // instead of one per node. Reading the timelines inside the loop instead cost 74% of a warm open.
   const timelineIds = impact.nodes
     .filter((projected) => specById.has(projected.id) && evalById.has(projected.id))
+    .filter((projected) => !freshness.only || freshness.only.has(projected.id))
     .map((projected) => projected.id)
-  const timelineById = new Map((await evalTimelines(timelineIds, ctx)).map((timeline, i) => [timelineIds[i], timeline]))
+  const timelineById = new Map((await evalTimelines(timelineIds, ctx, { order: freshness.order }))
+    .map((timeline, i) => [timelineIds[i], timeline]))
 
   for (const projected of impact.nodes) {
+    if (freshness.only && !freshness.only.has(projected.id)) continue
     const spec = specById.get(projected.id)
     if (!spec) continue // removed nodes remain fully explained by impact.nodes; they have no live eval rows.
     const evalNode = evalById.get(spec.id)
@@ -1507,7 +1561,7 @@ async function sessionScopeNodes(
       scenarios: scoped.scenarios,
       // Preserve the whole A/B history for selected scenarios. Fresh, stale, legacy and missing remain
       // honest downstream states; impact selection never removes a row because its reading is stale.
-      evals: latestOnly ? latestPerScenario(scoped.evals) as (EvalEntry & { inSession: boolean })[] : scoped.evals,
+      evals: scoped.evals,
     })
   }
 
@@ -1570,35 +1624,71 @@ type SessionEvalModel = Omit<SessionEvals, 'summary' | 'evalRevision'>
 
 async function buildSessionEvalModel(
   id: string,
-  payload: ReviewPayloadValue,
+  identity: ReviewIdentity,
   wtPath: string | null,
-  latestOnly: boolean,
+  pick?: SessionEvalFocus,
 ): Promise<SessionEvalModel> {
   // spec tree from the session worktree, same root as readings/indexes — a branch-NEW node must exist
   // in this model or the Eval tab/deep link can never reach its readings (see buildExportModel above).
   const ctxRoot = wtPath ?? repoRoot()
+  return withEventLedgerBuild(ctxRoot, () => buildSessionEvalModelInLedger(id, identity, wtPath, pick, ctxRoot))
+}
+
+async function buildSessionEvalModelInLedger(
+  id: string,
+  identity: ReviewIdentity,
+  wtPath: string | null,
+  pick: SessionEvalFocus | undefined,
+  ctxRoot: string,
+): Promise<SessionEvalModel> {
   const specs = await loadSpecs(ctxRoot)
   const specById = new Map(specs.map((s) => [s.id, s]))
   const [didx, hidx] = await Promise.all([driftIndex(ctxRoot), historyIndex(ctxRoot)])
   const ctx = await evalContext(ctxRoot, specs, didx, hidx)
   const { impact, shas } = await sessionImpactForContext(id, ctx, wtPath)
-  const nodes = await sessionScopeNodes(id, ctx, impact, shas, latestOnly)
+  // @@@ TWO passes, ONE context - a detail open renders one scenario and at most five neighbours, but it
+  // still owes the full population's sequence (its `index` and `total`). Sequence is freshness-free, so the
+  // first pass reads every node's rows with no probes at all (~0.4s of the 25s), the caller names the few
+  // nodes whose verdicts will actually be published, and only those pay the freshness pass. The context and
+  // the impact projection are built once and shared, so the cheap pass adds no second projection.
+  let order: SessionEvalOrderRow[] | undefined
+  let only: ReadonlySet<string> | undefined
+  if (pick) {
+    const draft = await sessionScopeNodes(id, ctx, impact, shas, { order: true })
+    order = orderRowsOf(draft)
+    only = new Set(pick(order))
+  }
+  const nodes = await sessionScopeNodes(id, ctx, impact, shas, only ? { only } : {})
   // nodes with in-session measurements lead, then the most-measured — the session's own evidence first.
   nodes.sort((a, b) => (b.evals.filter((e) => e.inSession).length - a.evals.filter((e) => e.inSession).length)
     || (b.scenarios.length - a.scenarios.length) || (b.unknownCoverage.length - a.unknownCoverage.length))
 
-  const primary = payload.node && specById.has(payload.node) ? specById.get(payload.node)!.title : null
+  const primary = identity.node && specById.has(identity.node) ? specById.get(identity.node)!.title : null
   return {
     id,
-    node: payload.node,
-    branch: payload.branch,
-    title: primary || payload.node || payload.branch || id.slice(0, 8),
-    ahead: payload.ahead,
-    dirtyNonRuntime: payload.dirtyNonRuntime,
-    gates: gateRows(payload),
+    node: identity.node,
+    branch: identity.branch,
+    title: primary || identity.node || identity.branch || id.slice(0, 8),
     nodes,
     impact,
+    ...(order ? { order } : {}),
+  }
+}
+
+// the identity+sequence facts a detail open needs about scenarios it will NOT render: which exist, whether
+// they carry a filed reading, and when. Deliberately not an EvalEntry — there is no verdict here to leak.
+export type SessionEvalOrderRow = { node: string; scenario: string; ts: string | null }
+export type SessionEvalFocus = (order: SessionEvalOrderRow[]) => readonly string[]
+
+export function orderRowsOf(nodes: SessionEvalNode[]): SessionEvalOrderRow[] {
+  const rows: SessionEvalOrderRow[] = []
+  for (const node of nodes) {
+    const latest = new Map<string, string>()
+    for (const reading of node.evals) if (!latest.has(reading.scenario)) latest.set(reading.scenario, reading.ts)
+    for (const scenario of node.scenarios)
+      rows.push({ node: node.id, scenario: scenario.name, ts: latest.get(scenario.name) ?? null })
   }
+  return rows
 }
 
 function untrackedPaths(status: string): string[] {
@@ -1652,13 +1742,6 @@ type SummaryBuildResult =
 
 export type SessionEvalSummaryBuilder = (id: string, path: string) => Promise<SummaryBuildResult>
 
-type DemandJob<T> = {
-  id: string
-  run: () => Promise<T>
-  resolve: (value: T) => void
-  reject: (error: unknown) => void
-}
-
 type ProjectionEntry = {
   id: string
   path: string
@@ -1668,6 +1751,7 @@ type ProjectionEntry = {
   current?: { generation: number; revision: string; value: SessionEvalSummary }
   scheduled: number | null
   running: number | null
+  flight: Promise<void> | null
   demandCancelledGeneration: number | null
   observerHolds: Set<string>
 }
@@ -1682,27 +1766,16 @@ type ProjectionCohortRow = Pick<StagedProjection, 'entry' | 'generation'>
 
 type ProjectionTarget = 'all' | { id?: string; path?: string }
 
-// Summary builds touch a session worktree's diff, history, and eval sidecars. Running one job per row
-// multiplies those git children and their parsed indexes by the retained session count, so the shared
-// projection queue has one bounded capacity for every project. A deployment can tune the capacity, but the
-// default is deliberately serial: board assembly remains responsive and memory has a natural settle point.
-const configuredProjectionConcurrency = Number(process.env.SPEXCODE_SESSION_EVAL_CONCURRENCY || 1)
-const PROJECTION_CONCURRENCY = Number.isFinite(configuredProjectionConcurrency)
-  ? Math.max(1, Math.floor(configuredProjectionConcurrency))
-  : 1
-
-// Pure generation coordinator around an injected stable builder. Snapshot construction only serializes
-// entries and authorizes the newest dirty generations; the async batch runs after that snapshot has captured
-// `updating(lastKnown)`, then emits one completion nudge for all stable/error results in the batch.
+// Pure generation coordinator around an injected stable builder. Sessions have independent evaluation cuts,
+// so an entry launches and publishes independently; generation/revision fences remain per entry.
 export class SessionEvalProjectionCache {
   readonly epoch: string
   private readonly entries = new Map<string, ProjectionEntry>()
   private readonly observerHolds = new Map<string, ProjectionTarget>()
   private readonly observerWaiters = new Set<() => void>()
-  private batch: Promise<void> | null = null
+  private readonly flights = new Set<Promise<void>>()
   private notify: () => void
   private precompute: boolean
-  private readonly demandQueue: DemandJob<any>[] = []
   private readonly demands = new Map<string, Promise<unknown>>()
 
   constructor(
@@ -1730,7 +1803,7 @@ export class SessionEvalProjectionCache {
       }
       this.authorize(entry)
     }
-    if (enabled) queueMicrotask(() => this.startBatch())
+    if (enabled) queueMicrotask(() => this.startScheduled())
   }
 
   private authorize(entry: ProjectionEntry): void {
@@ -1755,6 +1828,7 @@ export class SessionEvalProjectionCache {
       phase: 'loading',
       scheduled: null,
       running: null,
+      flight: null,
       demandCancelledGeneration: null,
       observerHolds: new Set(),
     }
@@ -1778,6 +1852,7 @@ export class SessionEvalProjectionCache {
           phase: 'loading',
           scheduled: null,
           running: null,
+          flight: null,
           demandCancelledGeneration: null,
           observerHolds: new Set(),
         }
@@ -1797,7 +1872,7 @@ export class SessionEvalProjectionCache {
       this.authorize(entry)
       out.set(session.id, this.project(entry))
     }
-    queueMicrotask(() => this.startBatch())
+    queueMicrotask(() => this.startScheduled())
     return out
   }
 
@@ -1875,28 +1950,31 @@ export class SessionEvalProjectionCache {
     const existing = this.demands.get(id)
     if (existing) return existing as Promise<T>
     const entry = this.ensureEntry(id, path)
-    // A queued summary for this same generation is superseded by the full demand build. If that demand
-    // rejects, snapshots must not recreate the cancelled eager work until a later invalidation advances g.
-    // A running summary is left alone; the priority job waits for it to settle before taking the slot.
+    // An unstarted summary is superseded by the full demand build. A running summary stays the one flight for
+    // this entry; demand waits for it only, never for unrelated session work.
     if (entry.running == null && entry.scheduled === entry.generation) {
       entry.scheduled = null
       entry.demandCancelledGeneration = entry.generation
     }
-    let resolve!: (value: T) => void
-    let reject!: (error: unknown) => void
-    const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej })
+    const priorFlight = entry.flight
+    const promise = (async () => {
+      if (priorFlight) await priorFlight
+      return run()
+    })()
     this.demands.set(id, promise)
-    this.demandQueue.push({ id, run, resolve, reject })
     promise.finally(() => {
       if (this.demands.get(id) === promise) this.demands.delete(id)
     }).catch(() => {})
-    queueMicrotask(() => this.startBatch())
     return promise
   }
 
   async idle(): Promise<void> {
-    await Promise.resolve()
-    while (this.batch) await this.batch
+    for (;;) {
+      await Promise.resolve()
+      const pending = [...this.flights, ...this.demands.values()]
+      if (!pending.length) return
+      await Promise.allSettled(pending)
+    }
   }
 
   accept(id: string, generation: number, revision: string, value: SessionEvalSummary): boolean {
@@ -1926,64 +2004,57 @@ export class SessionEvalProjectionCache {
     return target === 'all' || target.id === entry.id || target.path === entry.path
   }
 
-  private hasPending(): boolean {
-    return this.demandQueue.length > 0
-      || [...this.entries.values()].some((entry) => entry.scheduled != null && entry.running == null)
-  }
-
-  private publishCohort(staged: StagedProjection[]): boolean {
+  private publish(staged: StagedProjection): boolean {
     let changed = false
-    for (const { entry, generation, result } of staged) {
-      if (this.entries.get(entry.id) !== entry || entry.generation !== generation || entry.observerHolds.size) continue
-      if (result.kind === 'unstable') {
-        entry.generation++
-        entry.phase = 'updating'
-        entry.scheduled = null
-        entry.demandCancelledGeneration = null
-        this.authorize(entry)
-        changed = true
-        continue
-      }
-      if (result.kind === 'missing') {
-        changed = changed || entry.phase !== 'error'
-        entry.phase = 'error'
-        entry.scheduled = null
-        continue
-      }
-      changed = changed || entry.phase !== 'ready' || entry.current?.revision !== result.revision
-      entry.current = { generation, revision: result.revision, value: result.summary }
-      entry.phase = 'ready'
+    const { entry, generation, result } = staged
+    if (this.entries.get(entry.id) !== entry || entry.generation !== generation || entry.observerHolds.size) return false
+    if (result.kind === 'unstable') {
+      entry.generation++
+      entry.phase = 'updating'
       entry.scheduled = null
+      entry.demandCancelledGeneration = null
+      this.authorize(entry)
+      return true
     }
+    if (result.kind === 'missing') {
+      changed = entry.phase !== 'error'
+      entry.phase = 'error'
+      entry.scheduled = null
+      return changed
+    }
+    changed = entry.phase !== 'ready' || entry.current?.revision !== result.revision
+    entry.current = { generation, revision: result.revision, value: result.summary }
+    entry.phase = 'ready'
+    entry.scheduled = null
     return changed
   }
 
-  private startBatch(): void {
-    if (this.batch) return
-    if (!this.hasPending()) return
-    this.batch = (async () => {
-      const demand = this.demandQueue.shift()
-      if (demand) {
-        try { demand.resolve(await demand.run()) }
-        catch (error) { demand.reject(error) }
-        return
-      }
-      // Freeze this finite cohort. Inputs that arrive later remain scheduled for the next batch, so a
-      // busy stream cannot keep a completed cohort unpublished forever.
-      const cohort = [...this.entries.values()]
-        .filter((entry) => entry.scheduled != null && entry.running == null)
-        .map((entry) => ({ entry, generation: entry.scheduled! }))
-      const staged: StagedProjection[] = []
-      for (let offset = 0; offset < cohort.length && !this.demandQueue.length; offset += PROJECTION_CONCURRENCY) {
-        const chunk = cohort.slice(offset, offset + PROJECTION_CONCURRENCY)
-        const results = await Promise.all(chunk.map((row) => this.runEntry(row)))
-        for (const result of results) if (result) staged.push(result)
-      }
-      if (this.publishCohort(staged)) this.notify()
-    })().finally(() => {
-      this.batch = null
-      if (this.hasPending()) this.startBatch()
+  private startScheduled(): void {
+    for (const entry of this.entries.values()) {
+      if (entry.scheduled == null || entry.running != null) continue
+      this.startEntry({ entry, generation: entry.scheduled })
+    }
+  }
+
+  private startEntry(row: ProjectionCohortRow): void {
+    const flight = this.runEntry(row).then((staged) => {
+      if (staged && this.publish(staged)) this.notify()
     })
+    row.entry.flight = flight
+    this.flights.add(flight)
+    void flight.then(
+      () => {
+        this.flights.delete(flight)
+        if (row.entry.flight === flight) row.entry.flight = null
+        queueMicrotask(() => this.startScheduled())
+      },
+      (error) => {
+        this.flights.delete(flight)
+        if (row.entry.flight === flight) row.entry.flight = null
+        console.warn(`spec-eval: session summary runner failed for ${row.entry.id}: ${error instanceof Error ? error.message : String(error)}`)
+        queueMicrotask(() => this.startScheduled())
+      },
+    )
   }
 
   private async runEntry({ entry, generation }: ProjectionCohortRow): Promise<StagedProjection | null> {
@@ -2004,35 +2075,41 @@ export class SessionEvalProjectionCache {
 }
 
 async function buildSummaryAttempt(id: string, _path: string): Promise<SummaryBuildResult> {
-  const payload = await reviewPayload(id)
-  if (!payload) return { kind: 'missing' }
-  const wtPath = worktreePathForBranch(payload.branch)
+  const identity = reviewIdentity(id)
+  if (!identity) return { kind: 'missing' }
+  const wtPath = worktreePathForBranch(identity.branch)
   const ctxPath = wtPath ?? repoRoot()
-  const before = await sessionEvalContentRevision(ctxPath)
-  const cacheKey = `${id}\0${before}`
-  const cached = summaryByContent.get(cacheKey)
-  if (cached) {
+  return withEventLedgerDemand(ctxPath, async () => {
+    const before = await sessionEvalContentRevision(ctxPath)
+    const cacheKey = `${id}\0${before}`
+    const cached = summaryByContent.get(cacheKey)
+    if (cached) {
+      const after = await sessionEvalContentRevision(ctxPath)
+      return before === after
+        ? { kind: 'stable', revision: after, summary: cached.summary }
+        : { kind: 'unstable' }
+    }
+    const model = await buildSessionEvalModel(id, identity, wtPath)
     const after = await sessionEvalContentRevision(ctxPath)
-    return before === after
-      ? { kind: 'stable', revision: after, summary: cached.summary }
-      : { kind: 'unstable' }
-  }
-  const model = await buildSessionEvalModel(id, payload, wtPath, true)
-  const after = await sessionEvalContentRevision(ctxPath)
-  if (before !== after) return { kind: 'unstable' }
-  const summary = sessionEvalSummary(model.nodes)
-  // Keep one content-addressed stable value per session. Revisions, not elapsed time, decide reuse. This
-  // fold is latestOnly, so it deposits no model — it only carries any model an earlier demand left here.
-  depositStableCut(id, after, { summary })
-  return { kind: 'stable', revision: after, summary }
-}
-
-// ONE content-addressed cut per session, keyed by id + content revision. It carries the summary the graph
-// reads and — only when the demand path built it — the derived full model a repeat open replays.
-// @@@the two builders do not produce the same model - buildSummaryAttempt folds latestOnly=true (latest
-// reading per scenario, enough for counts) while the demand path needs the complete A/B history. Only the
-// demand path may deposit `model`, and only a demand read may consume it; serving the summary path's fold
-// to a demand would silently truncate every scenario's history.
+    if (before !== after) return { kind: 'unstable' }
+    const summary = sessionEvalSummary(model.nodes)
+    // Keep one content-addressed stable value per session. Revisions, not elapsed time, decide reuse.
+    // This fold IS the demand's fold, so it deposits the model too and a later open replays it.
+    depositStableCut(id, after, { summary, model })
+    return { kind: 'stable', revision: after, summary }
+  })
+}
+
+// ONE content-addressed cut per session, keyed by id + content revision, carrying the summary the graph
+// reads and the full model a repeat open replays.
+// @@@one builder, not two - these used to be separate folds: the graph's built latestOnly (latest reading
+// per scenario) and deposited counts alone, so the demand path re-derived the WHOLE thing to get history
+// the graph fold had held one line earlier and thrown away. The trim never made the fold cheaper — the
+// expensive part is the freshness pass over every node in scope, and it ran identically either way — and
+// it never mattered to the counts, because sessionEvalSummary folds latestPerScenario itself. So the trim
+// bought nothing and cost a second full build per session per revision. The price of dropping it is
+// MEMORY: a cut now retains complete A/B history rather than latest-per-scenario, bounded by the one-cut-
+// per-session rule below.
 type StableCut = { summary: SessionEvalSummary; model?: SessionEvalModel }
 const summaryByContent = new Map<string, StableCut>()
 
@@ -2078,15 +2155,19 @@ export function releaseSessionEvalProjectionObserver(observer: string): boolean
 }
 export async function awaitSessionEvalProjectionIdle(): Promise<void> { await projectionCache.idle() }
 
-export async function buildSessionEvals(id: string): Promise<SessionEvals | null> {
-  // A full model is demand-only, but it still runs through the projection queue. This gives a selected session
-  // priority over unrelated queued summaries without opening a second git/build lane.
+// `pick` makes this a FOCUSED build: the caller names, from the population's sequence, the few nodes whose
+// verdicts its response will publish, and only those pay the freshness pass. A focused build is PARTIAL, so
+// it never deposits — but it still prefers a cached FULL model when one exists, because a complete answer
+// already paid for beats a cheap incomplete one.
+export async function buildSessionEvals(id: string, pick?: SessionEvalFocus): Promise<SessionEvals | null> {
+  // A full model is demand-only. It joins its session's current summary flight, but unrelated summaries never
+  // gate this demand; a cached stable cut then replays without re-deriving Git state.
+  const identity = reviewIdentity(id)
+  if (!identity) return null
+  const wtPath = worktreePathForBranch(identity.branch)
+  const ctxPath = wtPath ?? repoRoot()
   for (;;) {
-    const attempt = await projectionCache.demand(id, '', async () => {
-      const payload = await reviewPayload(id)
-      if (!payload) return { kind: 'missing' as const }
-      const wtPath = worktreePathForBranch(payload.branch)
-      const ctxPath = wtPath ?? repoRoot()
+    const attempt = await projectionCache.demand(id, '', () => withEventLedgerDemand(ctxPath, async () => {
       const known = projectionCache.get(id)
       const generation = known?.generation ?? 0
       await awaitObservableInputs(id, ctxPath)
@@ -2108,7 +2189,7 @@ export async function buildSessionEvals(id: string): Promise<SessionEvals | null
         if (before !== settled) projectionCache.invalidate({ id })
         return { kind: 'retry' as const }
       }
-      const model = await buildSessionEvalModel(id, payload, wtPath, false)
+      const model = await buildSessionEvalModel(id, identity, wtPath, pick)
       const after = await sessionEvalContentRevision(ctxPath)
       const current = projectionCache.get(id)
       if (before !== after || projectionCache.isObserverHeld(id, ctxPath)
@@ -2116,18 +2197,23 @@ export async function buildSessionEvals(id: string): Promise<SessionEvals | null
         if (before !== after) projectionCache.invalidate({ id })
         return { kind: 'retry' as const }
       }
+      // A focused model holds only the nodes it was asked to publish, so its counts are NOT the scope's and
+      // its nodes are NOT the scope's. Neither may be deposited or accepted: doing so would tell the list
+      // page and the graph that the session's whole evaluation is those few nodes.
+      if (model.order)
+        return { kind: 'ready' as const, model, summary: known?.value, generation, revision: after }
       const summary = sessionEvalSummary(model.nodes)
       // Only a settled fold deposits, and only here does a model enter the cut — a thrown build reaches
       // neither line, so a failure can never poison the entry.
       depositStableCut(id, after, { summary, model })
       if (current) projectionCache.accept(id, generation, after, summary)
       return { kind: 'ready' as const, model, summary, generation, revision: after }
-    })
-    if (attempt.kind === 'missing') return null
+    }))
     if (attempt.kind === 'retry') continue
     return {
       ...attempt.model,
-      summary: attempt.summary,
+      // absent on a focused build whose cut holds no summary — never a fold over the rendered window
+      ...(attempt.summary ? { summary: attempt.summary } : {}),
       evalRevision: { epoch: projectionCache.epoch, generation: attempt.generation, content: attempt.revision },
     }
   }