rvlib-shipkit 0.10.0 → 0.13.0

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

@@ -0,0 +1,299 @@
+// Media views — topbar, info chips, stage (image/audio + geometry), roll
+// strip, category grid + size-true lineup, drawer (asset json · roll meta ·
+// repo-defined custom panels). Feature parity with the deleted vanilla
+// studio SPA; state lives in MediaSvc (components read and call).
+import { runInAction } from 'mobx'
+import { observer } from 'mobx-react-lite'
+import { useEffect, useRef, useState, type DragEvent, type ReactNode } from 'react'
+import type { HubSt } from './hub-st.ts'
+import { isAud, rollUrl, thumbUrl } from './media-svc.ts'
+import { GeometryLayer, Rectbar, measureBox, type Box } from './geometry-view.tsx'
+import type { CatRow } from './hub-types.ts'
+
+const TEX = 1024
+const MIX_UNIT = 24
+const MIX_GROUND = 44
+
+export const MediaTopbar = observer(({ app }: { app: HubSt }) => {
+    const m = app.media
+    const fileRef = useRef<HTMLInputElement>(null)
+    const taRef = useRef<HTMLTextAreaElement>(null)
+    const manual = m.cur?.manual === true
+    const det = m.deterministic
+    // auto-grow on EVERY prompt change, programmatic (selection) included —
+    // the css max-height caps it, overflow scrolls only past ~14 lines
+    useEffect(() => {
+        const t = taRef.current
+        if (t == null) return
+        t.style.height = 'auto'
+        t.style.height = `${t.scrollHeight + 2}px`
+    }, [m.prompt])
+    return (
+        <div className="bar">
+            {/* the prompt AUTOSAVES (debounced) — no save button, no fear */}
+            <textarea className="prompt" ref={taRef} value={m.prompt} placeholder="select an asset ←"
+                onChange={(e) => m.setPrompt(e.target.value)} />
+            <div className="toolbar">
+                {!manual ? <button disabled={m.curId == null} onClick={() => void m.generate()}>Generate</button> : null}
+                {!manual ? (
+                    <label className="xn" title="rolls per generate">×
+                        <select value={m.n} disabled={det} onChange={(e) => runInAction(() => { m.n = e.target.value })}>
+                            {['1', '3', '6', '9', '12'].map((v) => <option key={v}>{v}</option>)}
+                        </select>
+                    </label>
+                ) : null}
+                <button className="ghost" title="add files as rolls (or drag-drop onto the strip)" onClick={() => fileRef.current?.click()}>upload</button>
+                <input type="file" ref={fileRef} multiple style={{ display: 'none' }}
+                    accept={m.cur?.media === 'audio' ? '.mp3,.wav,.ogg,.m4a' : '.png,.webp'}
+                    onChange={(e) => { if (e.target.files != null) void m.upload(e.target.files); e.target.value = '' }} />
+                <button className="ghost" title="copy the prompt" onClick={() => m.copyPrompt()}>copy</button>
+                {det || manual ? <span className="detnote">{manual ? 'manual — upload files (drag-drop works)' : 'deterministic — rolls identical'}</span> : null}
+                <span className="sp" />
+                {m.generating ? <button className="ghost" title="interrupt the current job (queued jobs stay)" onClick={() => m.stopCurrent()}>stop current</button> : null}
+                {m.queued > 0 ? <button className="ghost" title="drop queued jobs" onClick={() => m.clearQueue()}>clear queue ({m.queued})</button> : null}
+                {m.generating && m.progress?.max ? (
+                    <span className="progbar"><i style={{ width: `${Math.round((100 * m.progress.value) / m.progress.max)}%` }} /></span>
+                ) : null}
+                <span className="status">{m.promptMsg !== '' ? m.promptMsg : m.generating ? m.genLine : m.statusLine}</span>
+            </div>
+        </div>
+    )
+})
+
+export const InfoChips = observer(({ app }: { app: HubSt }) => {
+    const info = app.media.detail?.info
+    if (info == null) return null
+    const chips: { k: string; v: ReactNode; warn?: boolean }[] = [{ k: 'backend', v: info.backend }]
+    if (info.workflow != null) {
+        const w = info.workflow
+        if (w.id != null) chips.push({ k: 'workflow', v: <>{w.id}{w.path != null ? <> <code>{w.path}</code></> : null}</> })
+        else chips.push({ k: 'workflow', v: w.note ?? 'unresolved', warn: true })
+    }
+    const sh = info.ship
+    chips.push({ k: 'ship', v: sh.mode === 'hook' ? <code>{sh.path}</code> : sh.mode === 'built-in' ? `built-in hook — ${sh.note ?? ''}` : sh.note ?? 'pick.json only' })
+    if (info.metaFile != null) chips.push({ k: 'meta', v: <code>{info.metaFile}</code> })
+    chips.push({ k: 'kit', v: <><code>{info.kitSource}</code> · {info.kindId}</> })
+    return (
+        <div className="info" style={{ display: 'flex' }}>
+            {chips.map((c, i) => <span key={i} className={`chip${c.warn === true ? ' warn' : ''}`}><b>{c.k}</b> {c.v}</span>)}
+        </div>
+    )
+})
+
+export const AssetStage = observer(({ app }: { app: HubSt }) => {
+    const m = app.media
+    const stageRef = useRef<HTMLDivElement>(null)
+    const imgRef = useRef<HTMLImageElement>(null)
+    const [box, setBox] = useState<Box | null>(null)
+    const remeasure = (): void => setBox(measureBox(stageRef.current, imgRef.current))
+    useEffect(() => {
+        window.addEventListener('resize', remeasure)
+        return () => window.removeEventListener('resize', remeasure)
+    }, [])
+    const rolls = m.detail?.rolls ?? []
+    const genHere = m.curId != null && m.pending.includes(m.curId)
+    const shown = m.hover ?? m.active
+    let content: ReactNode
+    if (shown == null) content = <div className="ph">{genHere ? 'generating…' : rolls.length === 0 ? 'no rolls yet' : 'Pick an asset on the left, then Generate.'}</div>
+    else if (isAud(shown)) content = (
+        // key = the roll identity: heartbeats re-render but never recreate
+        // the element, so playback survives; the src carries no cache-bust
+        <div className="stageaud" key={`${m.curId}/${shown}`}>🔊<audio controls src={rollUrl(m.curId!, shown)} /></div>
+    )
+    else content = <img className="roll" src={rollUrl(m.curId!, shown)} ref={imgRef} onLoad={remeasure} />
+    return (
+        <div className="stage" ref={stageRef}>
+            {content}
+            {shown != null && !isAud(shown) ? <GeometryLayer app={app} box={box} /> : null}
+            <Rectbar app={app} />
+        </div>
+    )
+})
+
+export const RollStrip = observer(({ app }: { app: HubSt }) => {
+    const m = app.media
+    const rolls = m.detail?.rolls ?? []
+    const genHere = m.curId != null && m.pending.includes(m.curId)
+    const onDrop = (e: DragEvent<HTMLDivElement>): void => { e.preventDefault(); void m.upload(e.dataTransfer.files) }
+    if (rolls.length === 0) return (
+        <div className="strip" onDragOver={(e) => e.preventDefault()} onDrop={onDrop}>
+            {genHere ? <div className="vig gen"><div className="spin" />generating…</div>
+                : <div className="ph">{m.cur?.manual === true ? 'no files — upload (or drag-drop here)' : 'no rolls — hit Generate'}</div>}
+        </div>
+    )
+    return (
+        <div className="strip" onDragOver={(e) => e.preventDefault()} onDrop={onDrop}>
+            {/* rolls are newest-first; generation lands where the eye is */}
+            {genHere ? <div className="vig gen"><div className="spin" />generating…</div> : null}
+            {rolls.map((x) => (
+                <div key={x.name}
+                    className={`vig${isAud(x.name) ? ' aud' : ''}${x.name === m.active ? ' active' : ''}${x.picked ? ' picked' : ''}${x.alt ? ' alt' : ''}`}
+                    // hover-preview stays image-only — swapping an <audio> mid-playback would cut the sound
+                    onMouseEnter={() => { if (!isAud(x.name)) runInAction(() => { m.hover = x.name }) }}
+                    onMouseLeave={() => runInAction(() => { m.hover = null })}
+                    onClick={() => m.setActive(x.name)}>
+                    {isAud(x.name) ? <>🔊<audio controls src={rollUrl(m.curId!, x.name)} /></> : <img src={rollUrl(m.curId!, x.name)} />}
+                    {x.picked ? <span className="st">★</span> : null}
+                    <div className="btns">
+                        <button className="b-pick" onClick={(e) => { e.stopPropagation(); void m.pick(x.name) }}>pick</button>
+                        <button className="b-alt" onClick={(e) => { e.stopPropagation(); void m.alt(x.name) }}>alt</button>
+                        <button className="b-del" onClick={(e) => { e.stopPropagation(); void m.discard(x.name) }}>✕</button>
+                    </div>
+                </div>
+            ))}
+        </div>
+    )
+})
+
+// ── category grid + size-true lineup ─────────────────────────────────────
+const MixLineup = observer(({ rows }: { rows: CatRow[] }) => {
+    const items = rows.filter((r) => !r.icon && r.rect != null).sort((a, b) => a.rect!.size - b.rect!.size || a.label.localeCompare(b.label))
+    const boxH = 420
+    const baseY = boxH - MIX_GROUND
+    let cx = 30
+    const sprites: ReactNode[] = []
+    for (const it of items) {
+        const rect = it.rect!
+        const ts = (rect.size * MIX_UNIT) / rect.w
+        const slot = Math.max(rect.size * MIX_UNIT * 1.35, TEX * ts * 0.62, 40)
+        cx += slot / 2
+        const fx = rect.flip === true ? TEX - rect.x - rect.w : rect.x
+        sprites.push(
+            <img key={it.id} className="mixsprite" src={thumbUrl(it.id)} style={{
+                width: TEX * ts, height: TEX * ts,
+                left: cx - (fx + rect.w / 2) * ts, top: baseY - (rect.y + rect.h / 2) * ts,
+                transform: rect.flip === true ? 'scaleX(-1)' : undefined, zIndex: Math.round(cx),
+            }} />,
+            <div key={`${it.id}-lb`} className="mixlabel" style={{ left: cx, bottom: 14 }}>{it.label} · {+rect.size.toFixed(2)}</div>,
+        )
+        cx += slot / 2 + 10
+    }
+    const rulers: ReactNode[] = []
+    for (let u = 5; u * MIX_UNIT < baseY; u += 5)
+        rulers.push(<div key={u} className={`rlabel${u % 10 === 0 ? ' b' : ''}`} style={{ bottom: MIX_GROUND + u * MIX_UNIT - 5 }}>{u}</div>)
+    return (
+        <div id="mixsec"><div id="mixbox"><div id="mixinner" style={{ width: cx + 30, minWidth: '100%' }}>
+            <div className="ruler" />
+            <div id="mixground" />
+            {sprites}{rulers}
+        </div></div></div>
+    )
+})
+
+export const CatGrid = observer(({ app }: { app: HubSt }) => {
+    const m = app.media
+    const cat = m.catMode
+    if (cat == null) return null
+    const pc = (v: number): string => `${v / (TEX / 100)}%`
+    return (
+        <div id="catgrid" style={{ display: 'block' }}>
+            <div id="allbar">
+                <label>size for ALL {cat} <input type="number" step={0.1} min={0.1} value={m.allSize}
+                    onChange={(e) => runInAction(() => { m.allSize = e.target.value })} /></label>
+                <button className="ghost" onClick={() => void m.applyAllSize()}>apply</button>
+                <span className="jmsg">{m.allMsg}</span>
+            </div>
+            <div className="cards">
+                {m.catRows.map((row) => {
+                    const fl = row.rect?.flip === true
+                    return (
+                        // the WHOLE card jumps into the asset (his order
+                        // 2026-07-23) — inner controls stopPropagation
+                        <div className="card" key={row.id} onClick={() => app.selectAsset(row.id)}>
+                            {isAud(row.name)
+                                ? <div className="aud">🔊<audio controls src={rollUrl(row.id, row.name)} onClick={(e) => e.stopPropagation()} />{m.pending.includes(row.id) ? <div className="spin" /> : null}</div>
+                                : <div className="th">
+                                    <img src={thumbUrl(row.id)} style={fl ? { transform: 'scaleX(-1)' } : undefined} />
+                                    {row.rect != null ? <div className="ovmini" style={{
+                                        left: pc(fl ? TEX - row.rect.x - row.rect.w : row.rect.x), top: pc(row.rect.y),
+                                        width: pc(row.rect.w), height: pc(row.rect.h),
+                                    }} /> : null}
+                                    {m.pending.includes(row.id) ? <div className="spin" /> : null}
+                                </div>}
+                            <div className="nm">{row.label}</div>
+                            {row.icon || isAud(row.name) ? null : (
+                                <div className="row" onClick={(e) => e.stopPropagation()}>
+                                    {/* commit-on-blur/Enter like the vanilla onchange (one POST,
+                                        not one per keystroke); the size in the key remounts the
+                                        input when apply-all changes it programmatically */}
+                                    <label>size <input key={`${row.id}:${row.rect?.size ?? 1}`} type="number" step={0.1} min={0.1}
+                                        defaultValue={row.rect?.size ?? 1}
+                                        onBlur={(e) => void m.setSize(row.id, row.name, +e.target.value)}
+                                        onKeyDown={(e) => { if (e.key === 'Enter') (e.target as HTMLInputElement).blur() }} /></label>
+                                    <button className="ghost" onClick={() => void m.toggleFlip(row.id, row.name)}>⇆ flip</button>
+                                </div>
+                            )}
+                        </div>
+                    )
+                })}
+            </div>
+            <MixLineup rows={m.catRows} />
+        </div>
+    )
+})
+
+// ── drawer: asset json (read-only) · roll meta · custom panels ───────────
+const PanelHost = observer(({ app }: { app: HubSt }) => {
+    const m = app.media
+    const ref = useRef<HTMLDivElement>(null)
+    const c = m.detail?.asset.custom.find((x) => `c:${x.id}` === m.tab) ?? null
+    const key = `${m.curId}|${m.active}|${c?.id ?? ''}`
+    useEffect(() => {
+        const host = ref.current
+        if (host == null) return
+        if (c == null || m.curId == null || m.active == null) {
+            host.textContent = c == null ? 'panel not on this asset' : 'no roll selected — generate or pick one first'
+            return
+        }
+        let dead = false
+        let mod: Record<string, unknown> | null = null
+        void (async () => {
+            try {
+                // repo-defined editor module, served by the media API
+                mod = (await import(`/media/${c.url}`)) as Record<string, unknown>
+                if (typeof mod.mount !== 'function') throw new Error(`${c.url} must export mount(el, api)`)
+                if (!dead) await (mod.mount as (el: HTMLElement, api: unknown) => unknown)(host, m.panelApi(c))
+            } catch (e) {
+                host.textContent = `panel FAILED: ${(e as Error).message}` // loud in the drawer, never blank
+            }
+        })()
+        return () => {
+            dead = true
+            if (typeof mod?.unmount === 'function') void (mod.unmount as () => unknown)()
+            host.innerHTML = ''
+        }
+    }, [key])
+    return <div ref={ref} />
+})
+
+export const Drawer = observer(({ app }: { app: HubSt }) => {
+    const m = app.media
+    const customs = m.detail?.asset.custom ?? []
+    const isCustom = m.tab.startsWith('c:')
+    return (
+        <div className="drawer">
+            <div className="tabs">
+                {[{ id: 'asset', label: 'asset' }, { id: 'meta', label: 'roll meta' }, ...customs.map((c) => ({ id: `c:${c.id}`, label: c.id }))].map((t) => (
+                    <button key={t.id} className={m.tab === t.id ? 'on' : ''} onClick={() => m.setTab(t.id)}>{t.label}</button>
+                ))}
+                <span className="sp" />
+                <button className="ghost" onClick={() => runInAction(() => { m.drawerOpen = !m.drawerOpen })}>JSON ▾</button>
+            </div>
+            {m.drawerOpen ? (
+                <div id="drawerbody" className="on">
+                    {isCustom ? <PanelHost app={app} /> : (
+                        <div>
+                            <textarea id="jsonta" spellCheck={false} readOnly={m.tab === 'asset'} value={m.jsonText}
+                                onChange={(e) => runInAction(() => { m.jsonText = e.target.value })} />
+                            <div className="jrow">
+                                {/* kind/asset structure is git-reviewed TS — read-only here */}
+                                <button disabled={m.tab === 'asset'} onClick={() => void m.saveMeta()}>save</button>
+                                <span className="jmsg">{m.jsonMsg}</span>
+                            </div>
+                        </div>
+                    )}
+                </div>
+            ) : null}
+        </div>
+    )
+})

package/src/serve/run-serve.ts

@@ -5,20 +5,17 @@
 // kit.ts loads. Port: --port > serve.port > a deterministic house-range
 // default (4800-4979, hashed from the repo name — stable across launches;
 // pin serve.port when two repos collide).
-import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
+import { existsSync, readFileSync } from 'fs'
 import { join } from 'path'
 import { fileURLToPath } from 'url'
-import { loadKit, allAssets, type ResolvedKit } from '../assets/kit-config.ts'
-import { isStale } from '../assets/gen/derived.ts'
-import { assetDir, listRolls, readPick } from '../assets/roll-workspace.ts'
-import { healIdentity } from '../assets/run-assets.ts'
-import { page as studioPage } from '../assets/server/studio-page.ts'
+import { loadKit, type ResolvedKit } from '../assets/kit-config.ts'
 import { studioRoutes, type StudioRoutes } from '../assets/server/studio-server.ts'
-import { openAsks } from '../asks/asks-queue.ts'
-import { evaluateContracts } from '../contracts/contracts-engine.ts'
-import { activeContracts, contractsConfigFrom, loadRepoConfig, type RepoConfig } from '../repo-config.ts'
+import { projectNeeds } from '../collections/collection-types.ts'
+import { graphsCollection } from '../collections/graphs.ts'
+import { pingTick } from '../collections/pings.ts'
+import { buildCollections } from '../collections/providers.ts'
+import { loadRepoConfig, type RepoConfig } from '../repo-config.ts'
 import { scanMdGraph } from '../wiki/scan-md.ts'
-import type { AttentionSection } from './hub-pages.ts'
 import { serveHub, type HubDeps } from './serve-hub.ts'
 
 export type ServeIo = { print: (l: string) => void; printErr: (l: string) => void }
@@ -37,29 +34,55 @@ export async function resolveHubDeps(root: string, c: RepoConfig, io: ServeIo, o
     const agentGraph = existsSync(agentRoot)
         ? { title: `${c.name} agent/`, load: () => scanMdGraph({ root: agentRoot, index: c.serve?.agentIndex }) }
         : null
-    let studio: StudioRoutes | null = null
+    // ONE page for every repo (his rule 2026-07-23): the studio ALWAYS
+    // mounts — kit-less repos get an empty media section, never a second
+    // page. A broken kit degrades to the same empty kit, loudly.
     let kit: ResolvedKit | null = null
     if (existsSync(join(root, '.rv-assets/kit.ts'))) {
-        // a broken kit must not take the graphs and status down with it —
-        // WARN + mount everything else
         try {
             kit = await loadKit(root)
-            studio = await studioRoutes({ kit, root, page: studioPage })
         } catch (e) {
-            kit = null
-            io.print(`WARN assets studio not mounted: ${(e as Error).message}`)
+            io.print(`WARN kit not loaded (media section empty): ${(e as Error).message}`)
         }
     }
+    const emptyKit: ResolvedKit = { kinds: [], workspace: '.rv-assets/out' }
+    let studio: StudioRoutes | null = null
+    try {
+        studio = await studioRoutes({ kit: kit ?? emptyKit, root })
+    } catch (e) {
+        io.print(`WARN media API not mounted: ${(e as Error).message}`)
+    }
     const cli = fileURLToPath(new URL('../cli.ts', import.meta.url))
+    const allCollections = () => [
+        ...buildCollections(root, c, kit, { bootVersion: BOOT_VERSION, libVersion }),
+        graphsCollection(root, { customWiki: c.serve?.wikiGraph != null, agentIndex: c.serve?.agentIndex }),
+    ]
+    const port = o?.port ?? c.serve?.port ?? defaultHubPort(c.name)
     return {
         root,
         name: c.name,
-        port: o?.port ?? c.serve?.port ?? defaultHubPort(c.name),
+        port,
         wikiGraph,
         agentGraph,
         studio,
         checkCmd: [process.execPath, cli, 'check'],
-        attention: attentionCollector(root, c, kit),
+        needs: () => projectNeeds(allCollections()),
+        collections: allCollections,
+        asksDir: c.asks?.dir ?? 'asks',
+        // RED-only pings while serving; notify command is repo config data.
+        // Delivery failure must be LOUD — a silently broken notify path means
+        // he assumes no blockers exist
+        pingTick: (needs) =>
+            pingTick(root, c.asks?.dir ?? 'asks', needs, {
+                link: c.serve?.publicHost != null ? `http://${c.serve.publicHost}:${port}/?f=needs` : undefined,
+                run: (cmd) => {
+                    const p = Bun.spawn(cmd, { stdout: 'ignore', stderr: 'pipe' })
+                    void p.exited.then(async (code) => {
+                        if (code !== 0) io.printErr(`WARN ping delivery failed (exit ${code}): ${await new Response(p.stderr).text().then((s) => s.trim().slice(0, 160))}`)
+                    })
+                },
+                notifyCommand: c.notifyCommand,
+            }),
     }
 }
 
@@ -72,79 +95,9 @@ const libVersion = (): string => {
 }
 const BOOT_VERSION = libVersion()
 
-// ── the / dashboard's data: everything red, one collector per source, each
-//    failure-isolated (a broken source reports itself, never blanks the page)
-export function attentionCollector(root: string, c: RepoConfig, kit: ResolvedKit | null): () => Promise<AttentionSection[]> {
-    const guard = async (title: string, tone: 'red' | 'warn', body: () => Promise<AttentionSection['lines']>): Promise<AttentionSection> => {
-        try { return { title, tone, lines: await body() } } catch (e) { return { title, tone: 'red', lines: [{ text: `collector broke: ${(e as Error).message}` }] } }
-    }
-    return async () => {
-        const sections = await Promise.all([
-            guard('hub process', 'red', async () => {
-                const now = libVersion()
-                if (now === BOOT_VERSION) return []
-                return [{ text: `hub is running shipkit ${BOOT_VERSION} but ${now} is on disk (stale process, stale pages, old studio code). Restart the 🚀 shipkit task` }]
-            }),
-            guard('failing checks', 'red', async () => {
-                const p = join(root, 'STATUS.md')
-                if (!existsSync(p)) return []
-                // a cred FAIL whose ask already sits in the asks section is
-                // ONE action shown twice — the ask (his hands) wins
-                const askDir = join(root, c.asks?.dir ?? 'asks')
-                const askText = existsSync(askDir) ? openAsks(askDir).map((a) => a.title.toLowerCase()).join(' ') : ''
-                return (await Bun.file(p).text()).split('\n')
-                    .filter((l) => l.trimStart().startsWith('FAIL'))
-                    .filter((l) => {
-                        const cred = l.match(/cred rv\/([a-z0-9-]+)\/[a-z0-9-]+ missing/)?.[1]
-                        return cred == null || !askText.includes(cred)
-                    })
-                    .map((text) => ({ text, href: '/status' }))
-            }),
-            guard('asks — waiting on you', 'red', async () => {
-                const dir = join(root, c.asks?.dir ?? 'asks')
-                if (!existsSync(dir)) return [] // read path must not mint an asks/ dir
-                return openAsks(dir).map((a) => ({ text: `${a.title}${a.kind !== '' ? ` (${a.kind})` : ''}` }))
-            }),
-            guard('assets', 'red', async () => {
-                // self-heal first: identity re-renders itself on brand.ts
-                // drift; only pick-blocked (taste) surfaces below
-                const idn = await healIdentity(root)
-                const lines: AttentionSection['lines'] = []
-                if (idn.state === 'blocked') lines.push({ text: `identity — ${idn.detail ?? 'blocked'}`, href: '/assets/#identity-logo' })
-                if (kit == null) return lines
-                for (const f of allAssets(kit)) {
-                    const dir = assetDir(join(root, kit.workspace), f.asset.id)
-                    const rolls = listRolls(dir)
-                    const manual = f.kind.generate.backend === 'manual'
-                    if (manual && rolls.length === 0) lines.push({ text: `${f.asset.id} — manual, nothing uploaded`, href: `/assets/#${f.asset.id}` })
-                    else if (rolls.length > 0 && (await readPick(dir)).pick == null) lines.push({ text: `${f.asset.id} — ${rolls.length} roll(s), none picked`, href: `/assets/#${f.asset.id}` })
-                    else if (await isStale(kit, join(root, kit.workspace), f)) lines.push({ text: `${f.asset.id} — stale (a parent was re-picked)`, href: `/assets/#${f.asset.id}` })
-                }
-                return lines
-            }),
-            guard('contracts', 'red', async () => {
-                const r = await evaluateContracts(activeContracts(c), contractsConfigFrom(c, root))
-                return r.lines.filter((l) => l.kind === 'fail').map((l) => ({ text: l.text }))
-            }),
-            guard('contract warnings', 'warn', async () => {
-                const r = await evaluateContracts(activeContracts(c), contractsConfigFrom(c, root))
-                return r.lines.filter((l) => l.kind === 'warn').map((l) => ({ text: l.text }))
-            }),
-            guard('posts to write', 'warn', async () => {
-                const social = join(root, '.rv-social')
-                if (!existsSync(social)) return []
-                const lines: AttentionSection['lines'] = []
-                for (const ch of readdirSync(social)) {
-                    const d = join(social, ch)
-                    if (!statSync(d).isDirectory()) continue
-                    for (const f of readdirSync(d).filter((x) => x.endsWith('.md'))) lines.push({ text: `${ch}/${f}` })
-                }
-                return lines
-            }),
-        ])
-        return sections
-    }
-}
+// the / dashboard's data now comes from the collection providers
+// (src/collections/providers.ts) — the old attentionCollector was DELETED
+// when they landed; never reintroduce a parallel projection.
 
 export async function runServe(root: string, io: ServeIo, o?: { port?: number }): Promise<number> {
     const c = await loadRepoConfig(root)
@@ -154,6 +107,8 @@ export async function runServe(root: string, io: ServeIo, o?: { port?: number })
         const base = `http://localhost:${hub.server.port}`
         io.print(`ok: ${c.name} hub → ${base}`)
         for (const t of hub.tools) io.print(`ok: ${t.label} → ${base}${t.path}`)
+        // the off-machine door (phone, other machines) — publicHost is config
+        if (c.serve?.publicHost != null) io.print(`ok: public → http://${c.serve.publicHost}:${hub.server.port}/`)
         await new Promise(() => {}) // the hub owns the process — never resolve
         return 0
     } catch (e) {