rvlib-shipkit 2.5.0 → 2.7.0

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 2.7.0
+
+- **What waits on the owner is a pill on every repo's row of the project list.** Beside the open asks badge, a pill in the review hue counts the cards that wait on the owner's verdict or answer; zero draws none, and folded it rides the icon's top left corner. A click opens that repo's review page on its first waiting card, the list on the owner's move. One count, `waitingCards` (`collections/review.ts`), read by the tree's review row, `sk needs`, the review page and the list; `/api/projects.json` reads it on every request, so a new card shows within one poll and a verdict at once. Below 768 px the list is always the rail, so the pills show on a phone.
+- **A trailer's score is the game's waveform, not only its level.** A note starts on its time's nearest sample frame, as the game's synth now rounds it (a time a hair past a frame, 14.450000000000001, no longer starts a frame late); a noise note's playback rate is held per 128 frame block, the browser's k-rate, its sweep starting at the next block (risers and whooshes were another noise). pkm-multi's main4: 38 of 38 sections within 0.1 dB and every one the same waveform, the difference at least 40 dB under it (four were about 10 dB). Every score renders again once.
+- **`sk fleet` skips a linked worktree.** A dir whose `.git` is a file is its main checkout again, as the home already reads it: `--update` no longer dirties a checkout that only follows main (a `-live` one) and blocks its own updater.
+- **A « fix » or a « no » the agent read is still owed.** It stays `claimed` and active (« hide handled » no longer hides it) until `sk review done`, `wontfix` or a new version; `sk review inbox` lists it under `owed`.
+
+## 2.6.0
+
+- **A trailer's score sounds as the game's browser synth, section for section.** A note that starts inside a 128 frame block takes the phase the browser gives it (it runs at the default 440 Hz until its own frame of that block), so overlapping notes of one pitch, a timpani roll, add or cancel as in the browser; `osc: 'square'` is the browser's own square wave, no longer a sine; the master's compressor and limiter are the browser's kernel (32 frame divisions, adaptive release, the sine warp on the gain). pkm-multi's main4 score: 38 of 38 sections within 0.1 dB of the game's render (were 18), each octave band within 0.15 dB. Every score renders again once.
+
 ## 2.5.0
 
 - **A review card hands itself to any agent session.** A small copy icon on the card's header (or C) copies one block: its title and state, its repo, `cd <repo> && sk review show <id>`, its link here and on the phone when the repo has a public host; a toast says what was copied. `sk review show <id> --paste` prints the same block.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rvlib-shipkit",
-    "version": "2.5.0",
+    "version": "2.7.0",
     "funding": "https://github.com/sponsors/rvion",
     "description": "All-in-one repo companion: ci gate (task DAG), auto-discovered health checks, release-contract fulfillness, asks queue, md-wiki tools, asset atelier, live tui",
     "license": "MIT",

package/src/cli/cmd_Review.ts

@@ -436,6 +436,14 @@ export class ReviewInboxCommand extends Command {
                 if (t) printed.add(t.head.item.id)
                 h.out(`${t ? threadDetail(t, h.dir, false, h.say) : detail(x, h.dir, false, false, h.say)}\n`)
             }
+            // a « fix » or a « no » an agent read and has not done: owed, never an unseen answer again
+            const owed = threads.filter((t) => of(t.head) && !printed.has(t.head.item.id) && t.head.item.origin.by === 'agent' && verdictOf(t.head)?.seen === true && stateOf(t.head, false).state === 'claimed')
+            const owedLine = (x: (typeof all.items)[number]): string => {
+                const fix = verdictOf(x)?.status === 'approved-with-fix'
+                const close = fix ? `sk review done ${x.item.id} "<what changed>"` : `--supersedes ${x.item.id} on its new version`
+                return `  ${x.item.id} ${fix ? 'ok with a fix' : 'rejected'} "${x.item.title}": ${close}, or sk review wontfix ${x.item.id} --note "<why>"`
+            }
+            if (owed.length > 0) h.out(`owed, read and not done:\n${owed.map((t) => owedLine(t.head)).join('\n')}\n`)
             const watchers = liveWatchers(h.dir)
             const untaken = all.items.flatMap((x) => {
                 const why = untakenOf(x, followed.has(x.item.id), watchers, new Date(), h.say.spec.dispatcher)

package/src/collections/review.ts

@@ -4,12 +4,27 @@
 // Each collection exists only where the repo has its folder, so a repo with none draws the section greyed
 import { existsSync } from 'node:fs'
 import { join } from 'node:path'
-import { STATUS_LABEL, isFrame, stateOf } from '../review/model.ts'
-import { readAllCached, storeDir } from '../review/store.ts'
-import { statusOf, waitingOnOwner } from '../review/threads.ts'
+import { STATUS_LABEL, isFrame, stateOf, type ReviewItem } from '../review/model.ts'
+import { readAllCached, storeDir, storeStamp } from '../review/store.ts'
+import { statusOf, waitingOnOwner, type Thread } from '../review/threads.ts'
 import { cutsOf, trailerIds } from '../review/trailer-desk.ts'
 import { REVIEW_COL, TRAILER_COL, type Collection, type Instance } from './collection-types.ts'
 
+const waiting = new Map<string, { stamp: string; threads: Thread[]; items: ReviewItem[] }>()
+
+/** what waits on the owner in a repo, the ONE count every surface shows (the tree's review row, the project list's pill,
+ *  `sk needs`): read again only when the store's stamp moved */
+export function waitingCards(root: string): { threads: Thread[]; items: ReviewItem[] } {
+    const dir = storeDir(root)
+    const stamp = storeStamp(dir)
+    const kept = waiting.get(dir)
+    if (kept?.stamp === stamp) return kept
+    const items = stamp === 'none' ? [] : readAllCached(dir).items
+    const fresh = { stamp, threads: waitingOnOwner(items), items }
+    waiting.set(dir, fresh)
+    return fresh
+}
+
 export function reviewCollection(root: string): Collection | null {
     const dir = storeDir(root)
     if (!existsSync(dir)) return null
@@ -19,8 +34,8 @@ export function reviewCollection(root: string): Collection | null {
         kind: 'card',
         media: 'image',
         list: async () => {
-            const { items } = readAllCached(dir)
-            return waitingOnOwner(items).map(({ head: x }): Instance => ({
+            const { threads, items } = waitingCards(root)
+            return threads.map(({ head: x }): Instance => ({
                 id: `card:${x.item.id}`,
                 text: `${x.item.title} (${STATUS_LABEL[statusOf(x, items)]})`,
                 label: x.item.title,

package/src/fleet/scan-fleet.ts

@@ -13,6 +13,7 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
 import { join } from 'path'
 import { isArchived } from '../core/archived.ts'
+import { isLinkedWorktree } from '../core/git-root.ts'
 import { detectPackageManager, isRefusal } from '../core/package-manager.ts'
 import { isBreaking, isLinkedInstall, pinFloor } from '../core/update-policy.ts'
 
@@ -97,7 +98,9 @@ export function scanFleet(root: string, o: { prefix?: string } = {}): FleetRepo[
             continue
         }
         const pkg = readPkg(dir)
-        if (pkg == null || isArchived(dir)) continue
+        // a linked worktree is its main checkout again: an update dirties a
+        // tree that only follows main and blocks that tree's own updater
+        if (pkg == null || isArchived(dir) || isLinkedWorktree(dir)) continue
         const all = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) }
         const names = Object.keys(all).filter((n) => n.startsWith(prefix))
         if (names.length === 0) continue

package/src/review/model.ts

@@ -444,12 +444,12 @@ export function stateOf(x: ReviewItem, superseded: boolean): ItemState {
     let s: ItemState = startOf(i)
     // what his latest verdict left: a released or superseded rework of an agent's card goes back to it
     let given: ItemState = s
-    const read = readBy(x, 'agent')
     for (const m of x.thread) {
         const keep = s.topic ? { topic: s.topic } : {}
         if (m.verdict !== undefined) {
             const v = m.verdict
-            if (v === 'approved' || v === 'archived' || read.has(m.id)) s = { ...keep, state: 'closed', why: v }
+            // « fix » and « no » owe the lane work: reading the verdict is never doing it (done, wontfix or a new version closes it)
+            if (v === 'approved' || v === 'archived') s = { ...keep, state: 'closed', why: v }
             else s = { ...keep, state: 'claimed', ...(lane ? { worker: lane } : {}) }
             given = s
             continue
@@ -502,8 +502,9 @@ export function stateOf(x: ReviewItem, superseded: boolean): ItemState {
                 break
         }
     }
-    // the card that redoes it landed: the rework is over
-    if (superseded && i.origin.by === 'agent' && s.since !== undefined) return given
+    // the card that redoes it landed: the work its verdict owed is over
+    const owed = verdictOf(x)?.status
+    if (superseded && i.origin.by === 'agent' && s.state === 'claimed' && owed !== undefined) return { ...(s.topic ? { topic: s.topic } : {}), state: 'closed', why: owed }
     if (verdictOf(x) === null) {
         if (withdrawnOf(x) !== undefined) return { state: 'closed', why: 'withdrawn' }
         if (superseded && s.state !== 'closed') return { ...(s.topic ? { topic: s.topic } : {}), state: 'closed', why: 'superseded' }
@@ -612,6 +613,8 @@ export function untakenOf(x: ReviewItem, superseded: boolean, watchers: readonly
     if (s.state === 'open') return `raised${s.topic ? ` on ${s.topic}` : ''}, nobody claimed it`
     if (s.state !== 'claimed') return null
     if (s.since !== undefined) return quiet > STALE_CLAIM_MS ? `${s.worker ?? 'its'} claim went stale` : null
+    // an agent read the verdict: the work it owes is taken, only not done yet
+    if (verdictOf(x)?.seen) return null
     return listenersOf([x], watchers).length === 0 ? `the owner's verdict went back to ${s.worker ?? 'its author'}, and no watch reads it` : null
 }
 

package/src/review/threads.ts

@@ -124,8 +124,9 @@ export const isFollowed = (id: string, items: readonly ReviewItem[]): boolean =>
 export const threadOfItem = (id: string, threads: readonly Thread[]): Thread | null =>
     threads.find((t) => t.head.item.id === id) ?? threads.find((t) => membersOf(t).some((x) => x.item.id === id)) ?? null
 
-/** a thread still needs someone: its head pending, or answered and not yet acted on by the agent (an approval needs
- *  nothing), or a lane reworking it; what he or a player raised, until it is closed */
+/** a thread still needs someone: its head pending, or answered with work owed (« fix » until `done` or a new version,
+ *  « no » until a new version or `wontfix`; reading the verdict is never doing it; an approval needs nothing), or a
+ *  lane reworking it; what he or a player raised, until it is closed */
 export function isActive(t: Thread, now = new Date()): boolean {
     if (t.versions.some((x) => unreadBy(x, 'agent').some((m) => m !== openingOf(x)))) return true
     if (t.answers.some((x) => unreadBy(x, 'agent').some((m) => m !== openingOf(x)))) return true
@@ -133,7 +134,7 @@ export function isActive(t: Thread, now = new Date()): boolean {
     if (reworkOf(t.head, false, now)) return true
     const f = verdictOf(t.head)
     if (!f) return withdrawnOf(t.head) === undefined
-    return f.status !== 'approved' && f.status !== 'archived' && !f.seen
+    return stateOf(t.head, false).state !== 'closed'
 }
 
 /** the thread's conversation: every version's and every answered item's replies, oldest first, each with the item it

package/src/serve/hub-app/home-st.ts

@@ -36,6 +36,9 @@ export const PLACE_PATH = { overview: '/', planned: '/planned', activity: '/acti
 /** where a repo's hub answers on the home */
 export const repoBase = (name: string): string => `/r/${encodeURIComponent(name)}`
 /** the page of a repo on the home */
+/** the review list's address on the cards whose move is the owner's */
+const WAITING = 'whose=owner'
+
 export const repoPage = (name: string): string => `${repoBase(name)}/`
 
 /** where a check's own page answers on the home */
@@ -112,6 +115,7 @@ export class HomeSt {
         const m = this.machine
         if (m != null) {
             this.projects.onSelect = (name) => this.select(name)
+            this.projects.onReview = (name, card) => this.openReview(name, card)
             this.projects.onPlace = (p) => this.navigate(PLACE_PATH[p])
             this.projects.onPicker = () => this.palette.toggle()
             this.projects.pickerOpen = () => this.palette.open
@@ -121,6 +125,10 @@ export class HomeSt {
         } else {
             this.projects.onSelect = (name) => void this.openInHome(name)
             const own = this.repo('')
+            this.projects.onReview = (name, card) => {
+                if (this.projects.list.some((p) => p.name === name && p.current)) own.showReview(card, WAITING)
+                else void this.openInHome(name, `#${hashFor({ t: 'review', id: card, q: WAITING })}`)
+            }
             own.markSeen()
             this.selected = own.key
         }
@@ -212,6 +220,13 @@ export class HomeSt {
         this.show('repo', repo, 'push')
     }
 
+    /** the cards that wait on the owner in a repo: its review page in place, on the
+     *  first one, the list on the owner's move */
+    openReview(repo: string, card: string | null): void {
+        this.repo(repo).showReview(card, WAITING)
+        this.show('repo', repo, 'push')
+    }
+
     /** a link to a page of the home: the same page, in place */
     navigate(path: string): void {
         const u = new URL(path, 'http://home.invalid')
@@ -303,9 +318,9 @@ export class HomeSt {
 
     /** a list click on a hub serving on its own: that repo's page on the
      *  home when one serves, else the folder in VS Code */
-    async openInHome(name: string): Promise<void> {
+    async openInHome(name: string, hash = ''): Promise<void> {
         const home = await fetch('/api/home-url').then((r) => r.json() as Promise<{ port: number; up: boolean }>).catch(() => null)
         if (home?.up !== true) return this.projects.open(name)
-        window.location.href = `${window.location.protocol}//${window.location.hostname}:${home.port}${repoPage(name)}`
+        window.location.href = `${window.location.protocol}//${window.location.hostname}:${home.port}${repoPage(name)}${hash}`
     }
 }

package/src/serve/hub-app/hub-app.tsx

@@ -304,7 +304,7 @@ const App = observer(() => {
     const dockRef = usePanelRef()
     const listRef = usePanelRef()
     // ⌘B folds the list to its rail and back; a drag that already did it finds it there
-    const rail = l.listRail
+    const rail = l.folded
     const railW = l.railPx
     useLayoutEffect(() => {
         const p = listRef.current

package/src/serve/hub-app/layout-st.ts

@@ -6,7 +6,7 @@
 // value can hand the page a list wider than LIST.max. The list also folds to
 // its icon rail: a drag below its min or ⌘B, kept per browser too, its icons
 // small, medium or large (RAIL_ICONS), the rail as wide as they need.
-import { makeAutoObservable } from 'mobx'
+import { makeAutoObservable, runInAction } from 'mobx'
 
 export type Bounds = { key: string; min: number; max: number; def: number }
 
@@ -62,16 +62,31 @@ function loadRail(): boolean {
     }
 }
 
+/** a page narrower than this draws the list as its rail, whatever the pick: a list squeezed under its min hides its pills */
+export const NARROW_PX = 768
+
 export class LayoutSt {
     listWidth = loadWidth(LIST)
-    /** the list shows its icons only */
+    /** the owner's pick: the list shows its icons only */
     listRail = loadRail()
+    /** the page is narrower than NARROW_PX, read live */
+    narrow = false
     /** the rail's icon size */
     railIcon: RailIcon = loadRailIcon()
     sidebarWidth = loadWidth(SIDEBAR)
 
     constructor() {
         makeAutoObservable(this)
+        if (typeof window !== 'undefined' && typeof window.matchMedia === 'function') {
+            const mq = window.matchMedia(`(max-width: ${NARROW_PX - 1}px)`)
+            this.narrow = mq.matches
+            mq.addEventListener('change', (e) => runInAction(() => (this.narrow = e.matches)))
+        }
+    }
+
+    /** the list as drawn: the rail when he picked it or the page is narrow */
+    get folded(): boolean {
+        return this.listRail || this.narrow
     }
 
     /** a drag of the list's separator ended at this width */

package/src/serve/hub-app/project-list.css

@@ -74,9 +74,11 @@
 /* ⌘1 to ⌘9 select the first nine rows (keys.ts): the hint sits at the row's end */
 .pjkey{flex:none;font:10px/1 ui-monospace,Menlo,monospace;color:var(--dim);opacity:.6;background:none;border:0;padding:0}
 .pjrow:hover .pjkey,.pjrow.cur .pjkey,.pjpl:hover .pjkey,.pjpl.cur .pjkey{opacity:1}
-/* the one badge: open asks, at the end of the row */
-.pga{flex:none;min-width:16px;height:16px;padding:0 var(--s1);border-radius:8px;
+/* what waits on the owner, at the end of the row: the review cards (a click opens them), then the open asks */
+.pga,.pgr{flex:none;min-width:16px;height:16px;padding:0 var(--s1);border-radius:8px;
  font-size:10px;font-weight:700;line-height:16px;text-align:center;color:var(--bg);background:var(--warn)}
+.pgr{background:var(--review);cursor:pointer}
+.pgr:hover{box-shadow:0 0 0 2px var(--review)}
 /* Claude sessions running: a thin edge on the left that breathes */
 .pgs{position:absolute;left:0;top:5px;bottom:5px;width:2px;border-radius:1px;background:var(--accent);pointer-events:none;animation:pgpulse 2.4s ease-in-out infinite}
 /* the home only: the repo's hub state (starting, crashed) */
@@ -102,6 +104,7 @@
 /* NEEDS YOU: a warn toned bullet, set apart from the facts */
 .pgcneeds{margin-top:var(--s2);padding:var(--s1) var(--s2);border-left:2px solid var(--warn);background:var(--panel2);border-radius:0 3px 3px 0}
 .pgcneed{display:flex;gap:var(--s1);min-width:0;color:var(--warn)}
+.pgcneed.rev{color:var(--review)}
 .pgcneed.red{color:var(--red);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
 .pgcask{flex:1;min-width:0;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
 .pgcmore{flex:none}
@@ -134,7 +137,9 @@
 /* the app icon is a rounded plate already (core/app-icon.ts) */
 .pjlist.rail .pjrow img.pjapp{border-radius:0}
 .pjsize{font:600 10px/1 ui-monospace,Menlo,monospace}
-.pjlist.rail .pga{position:absolute;top:0;right:calc(50% - var(--ri,24px) / 2 - 4px);min-width:14px;height:14px;padding:0 var(--s0);border-radius:7px;font-size:9px;line-height:14px}
+.pjlist.rail .pga,.pjlist.rail .pgr{position:absolute;top:0;min-width:14px;height:14px;padding:0 var(--s0);border-radius:7px;font-size:9px;line-height:14px}
+.pjlist.rail .pga{right:calc(50% - var(--ri,24px) / 2 - 4px)}
+.pjlist.rail .pgr{left:calc(50% - var(--ri,24px) / 2 - 4px)}
 .pjlist.rail .pgd,.pjlist.rail .pgw{position:absolute;bottom:var(--s0);right:calc(50% - var(--ri,24px) / 2 - 2px)}
 .pjlist.rail .pjfoot{flex-direction:column;height:auto;padding:var(--s1) 0}
 .pjlist.rail .pjfoot button{justify-content:center;width:28px;padding:0}

package/src/serve/hub-app/project-list.tsx

@@ -2,7 +2,8 @@
 // down the left of the page, a small icon and the repo's name on one line,
 // the shown repo's row marked in its identity colour. Its width is the
 // panel the page gives it (hub-app.tsx, react-resizable-panels). A row says
-// three things and no more (faceOf): the open asks as its one badge, a dim
+// three things and no more (faceOf): what waits on the owner as pills (the review
+// cards, a click away from them, then the open asks), a dim
 // name (never the icon) while VS Code does not have the folder open, a thin edge breathing
 // while Claude sessions run in it; on the home, a dot while its hub starts
 // or crashed and a mark while a global process it uses is off. Everything
@@ -15,8 +16,8 @@
 // (names only, no ⌘ number, a row opens the archived page, nothing loads),
 // the foot never moving. ⌘B (or the foot's fold button, or a drag of the
 // separator below the list's min) folds the list to its icon rail: the
-// names, the ⌘ hints and the step hint hide, the badge rides the icon's
-// corner, the hover card still names the row. On the home a section of four lines on top, in the
+// names, the ⌘ hints and the step hint hide, the pills ride the icon's
+// corners, the hover card still names the row; a phone width is always the rail. On the home a section of four lines on top, in the
 // repo rows' style, opens the picker, the overview, the activity and the
 // plan, each with its shortcut at the line's end, the page shown lit. It
 // renders from the first paint with the list this browser kept, so a load
@@ -34,7 +35,7 @@ import { RAIL_ICONS, type RailIcon } from './layout-st.ts'
 
 /** what the list needs of its page: the hub and the home both carry one;
  *  the layout, when the page can fold the list to its rail */
-export type ListHost = { projects: ProjectsSvc; layout?: { listRail: boolean; toggleRail(): void; railIcon: RailIcon; cycleRailIcon(): void }; theme?: { pick: ThemePick; cycle(): void } }
+export type ListHost = { projects: ProjectsSvc; layout?: { folded: boolean; toggleRail(): void; railIcon: RailIcon; cycleRailIcon(): void }; theme?: { pick: ThemePick; cycle(): void } }
 
 /** the lines on top of the list, in their order: the picker, the overview,
  *  then the places, each with its shortcut (keys.ts) */
@@ -96,10 +97,14 @@ export const Row = observer(({ app, p, i }: { app: ListHost; p: Project; i: numb
                     },
                     onDragEnd: () => s.dragEnd(),
                 })}>
-                {app.layout?.listRail === true && p.appIcon != null
+                {app.layout?.folded === true && p.appIcon != null
                     ? <img className="pjapp" src={p.appIcon} alt="" width={ROW_ICON} height={ROW_ICON} draggable={false} />
                     : <Face p={p} px={ROW_ICON} />}
                 <span className="pjname">{p.name}</span>
+                {face.cards != null ? (
+                    <b className="pgr" aria-label={`${face.cards} review card${face.cards === 1 ? '' : 's'} wait on you: open them`}
+                        onClick={(e) => { e.stopPropagation(); s.review(p.name) }} onDoubleClick={(e) => e.stopPropagation()}>{face.cards}</b>
+                ) : null}
                 {face.badge != null ? <b className="pga">{face.badge}</b> : null}
                 {face.busy ? <i className="pgs" /> : null}
                 {dot != null ? <i className={`pgd ${dot}`} /> : null}
@@ -138,6 +143,12 @@ export const Card = ({ p, now }: { p: Project; now: number }) => {
             {m.head.description == null ? null : <div className="pgcdesc">{m.head.description}</div>}
             {m.needs == null ? null : (
                 <div className="pgcneeds">
+                    {m.needs.cards == null ? null : (
+                        <div className="pgcneed rev">
+                            <span className="pgcask">{m.needs.cards.count} card{m.needs.cards.count === 1 ? '' : 's'} to review: {m.needs.cards.titles.join(' · ')}</span>
+                            {m.needs.cards.more > 0 ? <span className="pgcmore">+{m.needs.cards.more}</span> : null}
+                        </div>
+                    )}
                     {m.needs.asks == null ? null : (
                         <div className="pgcneed">
                             <span className="pgcask">{m.needs.asks.count} ask{m.needs.asks.count === 1 ? '' : 's'}: {m.needs.asks.titles.join(' · ')}</span>
@@ -165,7 +176,7 @@ export const ProjectList = observer(({ app }: { app: ListHost }) => {
     useEffect(() => app.projects.start(), [app])
     const s = app.projects
     const lay = app.layout
-    const rail = lay?.listRail === true
+    const rail = lay?.folded === true
     return (
         <nav className={`pjlist${rail ? ' rail' : ''}`} aria-label="projects" style={rail ? ({ '--ri': `${RAIL_ICONS[lay!.railIcon]}px` } as CSSProperties) : undefined}>
             {s.onPlace == null && s.onPicker == null && s.error === '' ? null : (

package/src/serve/hub-app/projects-svc.ts

@@ -62,7 +62,8 @@ const keptSort = (): SortMode | null => {
 export function loadList(): Project[] {
     try {
         const v = JSON.parse(globalThis.localStorage?.getItem(LIST_KEY) ?? '[]') as unknown
-        return Array.isArray(v) && v.every((p) => typeof (p as Project)?.name === 'string') ? (v as Project[]) : []
+        // a list kept before a row carried its cards reads as none waiting until the first poll
+        return Array.isArray(v) && v.every((p) => typeof (p as Project)?.name === 'string') ? (v as Project[]).map((p) => ({ ...p, cards: p.cards ?? [] })) : []
     } catch {
         return []
     }
@@ -133,12 +134,13 @@ export function sortNames(list: Project[], mode: SortMode): string[] {
  *  its hub starts or crashed. A hub that is up is the normal case and draws none */
 export type HubDot = 'starting' | 'crashed' | null
 
-/** what the icon face shows, and nothing more: at most ONE badge (the open
- *  asks, the only fact that needs a human's hands), a dim name while VS Code
- *  does not have the folder open (the icon stays whole), and a pulsing edge
- *  while Claude sessions run */
-export type Face = { badge: number | null; dim: boolean; busy: boolean }
+/** what the icon face shows, and nothing more: what waits on the owner as
+ *  two pills (the review cards waiting on a verdict, the open asks waiting
+ *  on hands), a dim name while VS Code does not have the folder open (the
+ *  icon stays whole), and a pulsing edge while Claude sessions run */
+export type Face = { cards: number | null; badge: number | null; dim: boolean; busy: boolean }
 export const faceOf = (p: Project): Face => ({
+    cards: p.cards.length > 0 ? p.cards.length : null,
     badge: p.asks > 0 ? p.asks : null,
     dim: p.vscode === false,
     busy: p.sessions != null && p.sessions > 0,
@@ -149,7 +151,7 @@ export const faceOf = (p: Project): Face => ({
  *  human, and label and value rows. Each part leaves out an unknown fact */
 export type CardModel = {
     head: { name: string; current: boolean; icon: string | null; version: string | null; branch: string | null; description: string | null }
-    needs: { asks: { count: number; titles: string[]; more: number } | null; gate: string | null } | null
+    needs: { cards: { count: number; titles: string[]; more: number } | null; asks: { count: number; titles: string[]; more: number } | null; gate: string | null } | null
     facts: { k: 'release' | 'live' | 'activity'; v: string; tone?: 'warn' }[]
 }
 
@@ -159,6 +161,8 @@ export const CARD_NAMES = 3
 export function cardModel(p: Project, now: number): CardModel {
     const branch = p.branch == null ? null : p.dirty != null && p.dirty > 0 ? `${p.branch} · ${p.dirty} uncommitted` : p.branch
     const asks = p.asks > 0 ? { count: p.asks, titles: p.askTitles.slice(0, CARD_NAMES), more: Math.max(0, p.asks - CARD_NAMES) } : null
+    const n = p.cards.length
+    const cards = n > 0 ? { count: n, titles: p.cards.slice(0, CARD_NAMES).map((c) => c.title), more: Math.max(0, n - CARD_NAMES) } : null
     const reds = p.gate != null && p.gate !== 'green' ? p.gate.reds : []
     const gate = reds.length === 0 ? null : `gate red: ${reds.slice(0, CARD_NAMES).join(', ')}${reds.length > CARD_NAMES ? ` +${reds.length - CARD_NAMES}` : ''}`
     const facts: CardModel['facts'] = []
@@ -177,7 +181,7 @@ export function cardModel(p: Project, now: number): CardModel {
     if (act.length > 0) facts.push({ k: 'activity', v: act.join(' · ') })
     return {
         head: { name: p.name, current: p.current, icon: p.icon, version: p.version, branch, description: p.description },
-        needs: asks == null && gate == null ? null : { asks, gate },
+        needs: cards == null && asks == null && gate == null ? null : { cards, asks, gate },
         facts,
     }
 }
@@ -216,6 +220,9 @@ export class ProjectsSvc {
     /** what a single click does: the home shows that repo in place, a hub
      *  of its own opens the home on it. Default: the folder in VS Code */
     onSelect: (name: string) => void = (name) => void this.open(name)
+    /** a click on a row's review pill: that repo's review page on its first
+     *  waiting card. The home and a hub of its own each set it */
+    onReview: (name: string, card: string | null) => void = (name) => this.select(name)
     /** the two places at the top of the list, the overview and the plan:
      *  the home sets it, a hub of its own has none */
     onPlace: ((p: Place) => void) | null = null
@@ -281,6 +288,12 @@ export class ProjectsSvc {
         this.onSelect(name)
     }
 
+    /** the review pill: the cards that wait on the owner in that repo */
+    review(name: string): void {
+        this.selected = name
+        this.onReview(name, this.list.find((p) => p.name === name)?.cards[0]?.id ?? null)
+    }
+
 
     /** the repo above (-1) or below (+1) the selected one, round the ends;
      *  with none selected, down starts at the top and up at the bottom */

package/src/serve/hub-app/review/review-st.ts

@@ -28,7 +28,7 @@ import {
     type Side,
     type Spec,
 } from '../../../review/model.ts'
-import { answererOf, chainOf, childrenOf, conversationOf, followedIds, isActive, membersOf, orderedThreads, statusOf, threadOfItem, waits, type Thread } from '../../../review/threads.ts'
+import { answererOf, chainOf, childrenOf, conversationOf, followedIds, isActive, membersOf, orderedThreads, statusOf, threadOfItem, waitingOnOwner, waits, type Thread } from '../../../review/threads.ts'
 import { reach } from '../reach.ts'
 import type { RepoSt } from '../repo-st.ts'
 import type { Role } from '../../../review/role.ts'
@@ -450,9 +450,9 @@ export class ReviewSt {
         return orderedThreads(this.items)
     }
 
-    /** what waits on him: the cards waiting for the owner's verdict, and what he raised that asks him */
+    /** what waits on the owner, the one count of every surface (collections/review.ts waitingCards) */
     get pendingCount(): number {
-        return this.threads.filter((t) => waits(t.head) || (t.head.item.origin.by !== 'agent' && this.moveOf(t.head) === 'owner')).length
+        return waitingOnOwner(this.items).length
     }
 
     get activeCount(): number {
@@ -908,8 +908,9 @@ export class ReviewSt {
                 store.put(`${this.prefix}draft.${id}`, null)
             })
             void this.refresh()
-            // the tree's count of what waits on him moves at once
+            // the tree's count of what waits on the owner moves at once, and so does the project list's pill
             void this.st.cols.poll(true)
+            void this.st.home.projects.load()
         } catch (e) {
             runInAction(() => (this.error = (e as Error).message))
         } finally {

package/src/serve/project-gutter-route.ts

@@ -23,11 +23,21 @@ import { readLastStatusReadonly } from '../ledger/run-log.ts'
 import { identityOfText, identityProblem, type Identity } from '../core/identity-color.ts'
 import { writeIdentity } from '../core/identity.ts'
 import { appIconOf, appIconPngs, identityOfRoot } from '../core/app-icon.ts'
+import { waitingCards } from '../collections/review.ts'
 import { writeArchived } from '../core/archived.ts'
 
 export type { Gate }
 
 export const POLL_MS = 5_000
+
+/** a repo's waiting cards as its row carries them; a store that cannot be read waits on nobody, and its hub says why */
+function cardsOf(path: string): ProjectRow['cards'] {
+    try {
+        return waitingCards(path).threads.map((t) => ({ id: t.head.item.id, title: t.head.item.title }))
+    } catch {
+        return []
+    }
+}
 /** the app icon preview: sharp on a 2x screen at the admin page's 128px */
 const PREVIEW_PX = 256
 /** the rail's app icon, cropped to the plate: 40px at 2x, the largest rail size */
@@ -59,6 +69,8 @@ export type ProjectRow = {
     asks: number
     /** their titles, in file order */
     askTitles: string[]
+    /** the review cards that wait on the owner (collections/review.ts waitingCards), oldest first: read on every request */
+    cards: { id: string; title: string }[]
     /** package.json `description`, else the README's first line of prose */
     description: string | null
     /** package.json `version` */
@@ -338,6 +350,7 @@ export function projectGutter(d: GutterDeps) {
                 sessions: counts?.get(r.path) ?? null,
                 asks: asks.length,
                 askTitles: asks,
+                cards: cardsOf(r.path),
                 description,
                 version: versionOf(pkg),
                 branch: branchOf(readText(join(r.path, '.git', 'HEAD'))),
@@ -386,7 +399,11 @@ export function projectGutter(d: GutterDeps) {
 
     /** null when the path is not this route's */
     async function handle(req: Request, path: string): Promise<Response | null> {
-        if (path === '/api/projects.json') return Response.json(await answer())
+        if (path === '/api/projects.json') {
+            // the measure holds 5 s, the cards never: a verdict he just gave shows on the next ask
+            const a = await answer()
+            return Response.json({ ...a, projects: a.projects.map((p) => ({ ...p, cards: cardsOf(p.path) })) })
+        }
         if (path.startsWith('/api/projects/icon/')) {
             if (repos.length === 0) await answer()
             const r = findAny(decodeURIComponent(path.slice('/api/projects/icon/'.length)))

package/src/shot/clip-encoder.ts

@@ -8,7 +8,8 @@
 // `CLIP_INIT` run IN the page, so they import nothing and read only their
 // argument and the document. A WebGL canvas keeps no drawing buffer after it
 // presents, so the clip's page is opened with CLIP_INIT, which asks every
-// WebGL context for `preserveDrawingBuffer`.
+// WebGL context for `preserveDrawingBuffer`; a WebGPU canvas read on a frame
+// it did not draw gives an older drawing, so it is read only after a draw.
 
 /** what the page films: seconds of its largest canvas at fps, H.264 at a fixed quantizer */
 export type PageClipAsk = { seconds: number; fps: number; quantizer: number; keyEvery: number }
@@ -16,13 +17,22 @@ export type PageClipAsk = { seconds: number; fps: number; quantizer: number; key
 /** what the page says once the film ran */
 export type PageClipDone = { frames: number; repeated: number; width: number; height: number; canvasOfViewport: string }
 
-/** IN THE PAGE, as an init script: every WebGL context keeps its drawing buffer, so a frame reads back after it presents */
+/** IN THE PAGE, as an init script: every WebGL context keeps its drawing buffer, so a frame reads back after it presents;
+ *  a WebGPU canvas counts its drawings (window.__skDraws): read on a frame it did not draw, it gives an older drawing */
 export const CLIP_INIT = `(() => {
     const get = HTMLCanvasElement.prototype.getContext
     HTMLCanvasElement.prototype.getContext = function (type, attrs) {
         if (type === 'webgl' || type === 'webgl2' || type === 'experimental-webgl') attrs = Object.assign({}, attrs, { preserveDrawingBuffer: true })
+        if (type === 'webgpu') window.__skDraws ??= 0
         return get.call(this, type, attrs)
     }
+    if (typeof GPUCanvasContext !== 'undefined') {
+        const current = GPUCanvasContext.prototype.getCurrentTexture
+        GPUCanvasContext.prototype.getCurrentTexture = function () {
+            window.__skDraws = (window.__skDraws ?? 0) + 1
+            return current.call(this)
+        }
+    }
 })()`
 
 type ClipState = {
@@ -70,25 +80,37 @@ export async function installClip(a: PageClipAsk): Promise<string | null> {
     const total = Math.round(a.seconds * a.fps)
     const step = 1000 / a.fps
     const rect = { x: 0, y: 0, width, height }
+    // a WebGPU canvas is read only on a frame it drew (CLIP_INIT counts them), else its last drawing is filmed again
+    const gpu = w as unknown as { __skDraws?: number }
     st.done = new Promise<PageClipDone>((ok, fail) => {
         let n = 0
         let repeated = 0
         let t0 = -1
+        let last: VideoFrame | null = null
+        let seen = -1
         const tick = (t: number): void => {
             try {
                 if (st.failed) throw new Error(st.failed)
                 if (t0 < 0) t0 = t
+                const draws = gpu.__skDraws
+                const fresh = last == null || draws === undefined || draws !== seen
+                if (fresh) {
+                    last?.close()
+                    last = new VideoFrame(canvas, { timestamp: 0, visibleRect: rect })
+                    seen = draws ?? -1
+                }
                 // a frame for every step of real time passed: a slow page repeats its last drawing, so the clip keeps its length
                 let made = 0
                 while (n < total && n * step <= t - t0) {
-                    const frame = new VideoFrame(canvas, { timestamp: Math.round(n * step * 1000), duration: Math.round(step * 1000), visibleRect: rect })
+                    const frame = new VideoFrame(last!, { timestamp: Math.round(n * step * 1000), duration: Math.round(step * 1000) })
                     enc.encode(frame, { keyFrame: n % a.keyEvery === 0, avc: { quantizer: a.quantizer } } as VideoEncoderEncodeOptions)
                     frame.close()
-                    if (made++ > 0) repeated++
+                    if (made++ > 0 || !fresh) repeated++
                     n++
                 }
                 if (n < total) requestAnimationFrame(tick)
-                else
+                else {
+                    last?.close()
                     void enc
                         .flush()
                         .then(() => {
@@ -97,7 +119,9 @@ export async function installClip(a: PageClipAsk): Promise<string | null> {
                             ok({ frames: n, repeated, width, height, canvasOfViewport })
                         })
                         .catch(fail)
+                }
             } catch (e) {
+                last?.close()
                 if (enc.state !== 'closed') enc.close()
                 fail(e)
             }