npm - rvlib-shipkit - Versions diffs - 0.1.1 → 0.3.0 - Mend

rvlib-shipkit 0.1.1 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (57) hide show

package/CHANGELOG.md +137 -0
package/README.md +23 -8
package/package.json +15 -3
package/src/asks/asks-queue.ts +20 -7
package/src/assets/gen/comfy-gen.ts +106 -0
package/src/assets/gen/generate-roll.ts +57 -0
package/src/assets/gen/workflow-loader.ts +67 -0
package/src/assets/image-ops.ts +30 -0
package/src/assets/json-store.ts +27 -0
package/src/assets/kit-config.ts +179 -0
package/src/assets/kits/identity-kit.ts +119 -0
package/src/assets/native-deps.ts +18 -0
package/src/assets/panels/geometry-rects.ts +84 -0
package/src/assets/roll-workspace.ts +41 -0
package/src/assets/run-assets.ts +142 -0
package/src/assets/server/studio-page.ts +620 -0
package/src/assets/server/studio-queue.ts +58 -0
package/src/assets/server/studio-server.ts +412 -0
package/src/assets/vite.ts +62 -0
package/src/cli/cmd_Asks.ts +83 -0
package/src/cli/cmd_Assets.ts +120 -0
package/src/cli/cmd_Check.ts +30 -0
package/src/cli/cmd_Ci.ts +41 -0
package/src/cli/cmd_Contracts.ts +35 -0
package/src/cli/cmd_Init.ts +28 -0
package/src/cli/cmd_Serve.ts +34 -0
package/src/cli/cmd_Tui.ts +36 -0
package/src/cli/cmd_Wiki.ts +53 -0
package/src/cli.ts +44 -25
package/src/contracts/run-contracts.ts +33 -0
package/src/core/check-ctx.ts +3 -16
package/src/core/check-suite.ts +16 -2
package/src/core/discover-checks.ts +48 -0
package/src/core/run-check.ts +73 -0
package/src/core/run-ci.ts +54 -0
package/src/core/spawn-timeout.ts +65 -0
package/src/core/task-runner.ts +36 -43
package/src/core/wire.ts +20 -0
package/src/core/write-status.ts +70 -0
package/src/init-repo.ts +60 -0
package/src/repo-config.ts +82 -15
package/src/serve/hub-pages.ts +84 -0
package/src/serve/run-serve.ts +85 -0
package/src/serve/serve-hub.ts +77 -0
package/src/shipkit.ts +39 -3
package/src/tui/checks-panel.ts +39 -0
package/src/tui/tasks-panel.ts +54 -0
package/src/tui/tui-app.tsx +91 -0
package/src/tui/tui-panel.ts +57 -0
package/src/tui/tui-store.ts +98 -0
package/src/wiki/run-wiki.ts +50 -0
package/src/cli/shipkit-asks.ts +0 -26
package/src/cli/shipkit-check.ts +0 -26
package/src/cli/shipkit-ci.ts +0 -30
package/src/cli/shipkit-contracts.ts +0 -26
package/src/cli/shipkit-init.ts +0 -41
package/src/cli/shipkit-wiki.ts +0 -74

package/src/serve/hub-pages.ts ADDED Viewed

@@ -0,0 +1,84 @@
+// The hub's two no-build pages (served by serve-hub.ts): the landing page
+// whose links ARE the toolbox, and the /status page (STATUS.md + a
+// "run check" button streaming wire lines). Same style family as the
+// studio: one template string, vanilla JS, no build step, no CDN.
+import type { HubTool } from './serve-hub.ts'
+const esc = (s: string): string => s.replace(/&/g, '&amp;').replace(/</g, '&lt;')
+const SHELL = `
+:root{--bg:#141210;--panel:#1e1a15;--panel2:#262019;--line:#332b22;--ink:#f3ebe0;--dim:#a89a88;
+ --accent:#e88c28;--gold:#ffcf5c;--teal:#58c0b0;--red:#e05252}
+*{box-sizing:border-box}
+body{margin:0;background:var(--bg);color:var(--ink);font:15px/1.6 system-ui,sans-serif;min-height:100vh}
+.wrap{max-width:860px;margin:0 auto;padding:40px 24px}
+h1{font-size:20px;margin:0}
+h1 small{color:var(--dim);font-weight:400;font-size:13px;margin-left:10px}
+.crumb{font-size:12px;letter-spacing:.14em;text-transform:uppercase;color:var(--accent);margin-bottom:6px}
+.crumb a{color:var(--accent);text-decoration:none}.crumb a:hover{color:var(--gold)}
+`
+export function landingPage(o: { name: string; port: number; tools: HubTool[] }): string {
+    const cards = o.tools
+        .map((t) => `<a class=card href="${esc(t.path)}"><b>${esc(t.label)}</b><span>${esc(t.desc)}</span><code>${esc(t.path)}</code></a>`)
+        .join('\n')
+    return `<!doctype html><html><head><meta charset=utf-8>
+<meta name=viewport content="width=device-width,initial-scale=1"><title>${esc(o.name)} · shipkit</title>
+<style>${SHELL}
+.cards{display:grid;grid-template-columns:repeat(auto-fill,minmax(240px,1fr));gap:14px;margin-top:26px}
+.card{display:flex;flex-direction:column;gap:6px;background:var(--panel);border:1px solid var(--line);border-radius:12px;
+ padding:16px;text-decoration:none;color:var(--ink)}
+.card:hover{border-color:var(--accent);background:var(--panel2)}
+.card b{font-size:15px}.card span{font-size:13px;color:var(--dim)}
+.card code{font:11px ui-monospace,Menlo,monospace;color:var(--teal)}
+</style></head><body><div class=wrap>
+<div class=crumb>shipkit hub</div>
+<h1>${esc(o.name)}<small>http://localhost:${o.port}</small></h1>
+<div class=cards>
+${cards}
+</div>
+</div></body></html>`
+}
+export function statusPage(o: { name: string; statusMd: string | null }): string {
+    const body = o.statusMd ?? 'no STATUS.md yet — hit "run check" (or run: shipkit check)'
+    return `<!doctype html><html><head><meta charset=utf-8>
+<meta name=viewport content="width=device-width,initial-scale=1"><title>${esc(o.name)} · status</title>
+<style>${SHELL}
+.bar{display:flex;align-items:center;gap:12px;margin:18px 0 12px}
+button{background:var(--accent);color:#1a1206;border:0;border-radius:9px;padding:8px 14px;font-weight:650;cursor:pointer}
+button:disabled{opacity:.45;cursor:default}
+#note{font-size:12px;color:var(--dim)}
+pre{background:var(--panel);border:1px solid var(--line);border-radius:12px;padding:16px;overflow-x:auto;
+ font:12.5px/1.55 ui-monospace,Menlo,monospace;white-space:pre-wrap}
+.ok{color:var(--teal)}.warn{color:var(--gold)}.fail{color:var(--red)}.dim{color:var(--dim)}
+</style></head><body><div class=wrap>
+<div class=crumb><a href="/">shipkit hub</a> / status</div>
+<h1>${esc(o.name)}<small>STATUS.md</small></h1>
+<div class=bar><button id=run>run check</button><span id=note>shells <code>shipkit check</code>, wire lines stream in below</span></div>
+<pre id=out></pre>
+<script>
+const out=document.getElementById('out'),btn=document.getElementById('run'),note=document.getElementById('note')
+// wire-line coloring: ok/WARN/FAIL/skip prefixes → the house palette
+const esc=s=>s.replace(/&/g,'&amp;').replace(/</g,'&lt;')
+const cls=l=>{const t=l.trimStart()
+ if(t.startsWith('FAIL')||t.startsWith('✗'))return 'fail'
+ if(t.startsWith('WARN')||t.startsWith('⚠'))return 'warn'
+ if(t.startsWith('ok')||t.startsWith('✓'))return 'ok'
+ if(t.startsWith('skip')||t.startsWith('fix:')||t.startsWith('#'))return 'dim'
+ return ''}
+const paint=text=>{out.innerHTML=text.split('\\n').map(l=>'<span class="'+cls(l)+'">'+esc(l)+'</span>').join('\\n')}
+paint(${JSON.stringify(body).replaceAll('<', '\\u003c')})
+btn.onclick=async()=>{
+ btn.disabled=true;note.textContent='running…';let text=''
+ try{
+  const r=await fetch('status/run',{method:'POST'})
+  const rd=r.body.getReader(),dec=new TextDecoder()
+  for(;;){const{done,value}=await rd.read();if(done)break;text+=dec.decode(value,{stream:true});paint(text)}
+  note.textContent='done — STATUS.md refreshed on disk'
+ }catch(e){text+='\\nFAIL stream broke: '+e;paint(text);note.textContent='stream broke'}
+ btn.disabled=false
+}
+</script>
+</div></body></html>`
+}

package/src/serve/run-serve.ts ADDED Viewed

@@ -0,0 +1,85 @@
+// shipkit serve — resolve the repo's toolbox and run the hub. What mounts
+// comes from convention + repo.config's `serve` block: the wiki graph is
+// always on (custom provider via serve.wikiGraph, else the generic md
+// scan), agent/ graph when the dir exists, the studio when .rv-assets/
+// 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 } from 'fs'
+import { join } from 'path'
+import { fileURLToPath } from 'url'
+import { loadKit } from '../assets/kit-config.ts'
+import { page as studioPage } from '../assets/server/studio-page.ts'
+import { studioRoutes, type StudioRoutes } from '../assets/server/studio-server.ts'
+import { loadRepoConfig, type RepoConfig } from '../repo-config.ts'
+import { scanMdGraph } from '../wiki/scan-md.ts'
+import { serveHub, type HubDeps } from './serve-hub.ts'
+export type ServeIo = { print: (l: string) => void; printErr: (l: string) => void }
+export function defaultHubPort(name: string): number {
+    let h = 0
+    for (const c of name) h = (h * 31 + c.charCodeAt(0)) >>> 0
+    return 4800 + (h % 180)
+}
+export async function resolveHubDeps(root: string, c: RepoConfig, io: ServeIo, o?: { port?: number }): Promise<HubDeps> {
+    const wikiGraph = c.serve?.wikiGraph != null
+        ? { title: c.serve.wikiGraph.title ?? `${c.name} wiki`, load: c.serve.wikiGraph.load }
+        : { title: `${c.name} wiki`, load: () => scanMdGraph({ root }) }
+    const agentRoot = join(root, 'agent')
+    const agentGraph = existsSync(agentRoot)
+        ? { title: `${c.name} agent/`, load: () => scanMdGraph({ root: agentRoot, index: c.serve?.agentIndex }) }
+        : null
+    let studio: StudioRoutes | 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 {
+            studio = await studioRoutes({ kit: await loadKit(root), root, page: studioPage })
+        } catch (e) {
+            io.print(`WARN assets studio not mounted: ${(e as Error).message}`)
+        }
+    }
+    const cli = fileURLToPath(new URL('../cli.ts', import.meta.url))
+    return {
+        root,
+        name: c.name,
+        port: o?.port ?? c.serve?.port ?? defaultHubPort(c.name),
+        wikiGraph,
+        agentGraph,
+        studio,
+        checkCmd: [process.execPath, cli, 'check'],
+    }
+}
+export async function runServe(root: string, io: ServeIo, o?: { port?: number }): Promise<number> {
+    const c = await loadRepoConfig(root)
+    const deps = await resolveHubDeps(root, c, io, o)
+    try {
+        const hub = serveHub(deps)
+        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}`)
+        await new Promise(() => {}) // the hub owns the process — never resolve
+        return 0
+    } catch (e) {
+        if (e instanceof Error && e.message.includes('in use')) {
+            // same repo in another window is fine; a different repo hashed
+            // onto this port is a real collision — never claim its hub
+            const owner = await fetch(`http://127.0.0.1:${deps.port}/hub.json`, { signal: AbortSignal.timeout(1500) })
+                .then((r) => r.json() as Promise<{ hub?: string; name?: string; tools?: { path: string; label: string }[] }>)
+                .catch(() => null)
+            if (owner?.hub === 'shipkit' && owner.name === c.name) {
+                // a re-run terminal stays as clickable as a first run — the
+                // owner's /hub.json tool list is the same source of truth
+                io.print(`ok: hub already served → http://localhost:${deps.port} (another window owns it)`)
+                for (const t of owner.tools ?? []) io.print(`ok: ${t.label} → http://localhost:${deps.port}${t.path}`)
+                return 0
+            }
+            io.printErr(`FAIL: port ${deps.port} is taken by ${owner?.name != null ? `repo '${owner.name}'` : 'another process'} — set serve: { port } in repo.config.ts to a free one`)
+            return 1
+        }
+        throw e
+    }
+}

package/src/serve/serve-hub.ts ADDED Viewed

@@ -0,0 +1,77 @@
+// shipkit serve — ONE hub server per repo, ONE port (his call 2026-07-22:
+// "a single shipkit task in vscode with multiple urls I can click"). The
+// landing page's links are the whole toolbox: /graph/wiki · /graph/agent ·
+// /assets/ (the studio, mounted IN-PROCESS) · /status (STATUS.md + run
+// check). Route logic only — resolving WHAT to mount from repo.config is
+// run-serve.ts's job.
+import { existsSync } from 'fs'
+import { join } from 'path'
+import { graphHtml } from 'rvlib-shipkit/src/wiki/graph-page.ts'
+import type { MdGraph } from 'rvlib-shipkit/src/wiki/md-graph.ts'
+import type { StudioRoutes } from '../assets/server/studio-server.ts'
+import { landingPage, statusPage } from './hub-pages.ts'
+export type HubGraph = { title: string; load: () => MdGraph }
+export type HubTool = { path: string; label: string; desc: string }
+export type HubDeps = {
+    root: string
+    name: string
+    /** 0 = random (tests); real launches pass repo.config/default */
+    port: number
+    wikiGraph: HubGraph
+    /** null = no agent/ dir */
+    agentGraph: HubGraph | null
+    /** null = no .rv-assets/kit.ts (or it failed to load — caller prints the WARN) */
+    studio: StudioRoutes | null
+    /** argv shelling the check run streamed by /status/run (test seam) */
+    checkCmd: string[]
+}
+export type Hub = { server: ReturnType<typeof Bun.serve>; tools: HubTool[]; stop: () => void }
+// the toolbox as data — the landing page, /hub.json, and the stdout ok:
+// lines all render THIS list, so they can never disagree
+export function hubTools(d: Pick<HubDeps, 'wikiGraph' | 'agentGraph' | 'studio'>): HubTool[] {
+    const tools: HubTool[] = [{ path: '/graph/wiki', label: 'wiki graph', desc: d.wikiGraph.title }]
+    if (d.agentGraph != null) tools.push({ path: '/graph/agent', label: 'agent graph', desc: d.agentGraph.title })
+    if (d.studio != null) tools.push({ path: '/assets/', label: 'assets studio', desc: 'roll, curate, pick, ship' })
+    tools.push({ path: '/status', label: 'status', desc: 'STATUS.md + run check' })
+    return tools
+}
+export function serveHub(d: HubDeps): Hub {
+    const tools = hubTools(d)
+    const html = (s: string): Response => new Response(s, { headers: { 'content-type': 'text/html; charset=utf-8' } })
+    const server: ReturnType<typeof Bun.serve> = Bun.serve({
+        hostname: '127.0.0.1',
+        port: d.port,
+        async fetch(req): Promise<Response> {
+            const path = new URL(req.url).pathname
+            if (path === '/') return html(landingPage({ name: d.name, port: server.port ?? d.port, tools }))
+            // identity probe: lets a second launch tell "same repo, another
+            // window" from "a DIFFERENT repo hashed onto my port"
+            if (path === '/hub.json') return Response.json({ hub: 'shipkit', name: d.name, tools })
+            if (path === '/graph/wiki') return html(graphHtml(d.wikiGraph.load(), { title: d.wikiGraph.title }))
+            if (path === '/graph/wiki/graph.json') return Response.json(d.wikiGraph.load())
+            if (d.agentGraph != null && path === '/graph/agent') return html(graphHtml(d.agentGraph.load(), { title: d.agentGraph.title }))
+            if (d.agentGraph != null && path === '/graph/agent/graph.json') return Response.json(d.agentGraph.load())
+            if (path === '/status') {
+                const p = join(d.root, 'STATUS.md')
+                return html(statusPage({ name: d.name, statusMd: existsSync(p) ? await Bun.file(p).text() : null }))
+            }
+            if (path === '/status/run' && req.method === 'POST') {
+                // stream wire lines as the check emits them; sh merges stderr
+                // so FAIL lines reach the page, not just the terminal
+                const proc = Bun.spawn(['sh', '-c', 'exec "$0" "$@" 2>&1', ...d.checkCmd], { cwd: d.root, stdout: 'pipe', stderr: 'ignore' })
+                return new Response(proc.stdout, { headers: { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' } })
+            }
+            if (d.studio != null) {
+                // the studio page fetches RELATIVE urls — it must live under
+                // the slash-terminated prefix for them to resolve
+                if (path === '/assets') return new Response(null, { status: 307, headers: { location: '/assets/' } })
+                if (path.startsWith('/assets/')) return d.studio.handle(req, path.slice('/assets'.length))
+            }
+            return new Response('not found', { status: 404 })
+        },
+    })
+    return { server, tools, stop: () => server.stop(true) }
+}

package/src/shipkit.ts CHANGED Viewed

@@ -1,13 +1,27 @@
 // rvlib-shipkit — barrel. One import per repo: defineRepo in repo.config.ts;
 // everything else is the machinery behind the shipkit CLI.
 export { defineRepo, loadRepoConfig, resolveFloor, allTasks, contractsTask, contractsConfigFrom, activeContracts } from './repo-config.ts'
-export type { RepoConfig, RepoCheck } from './repo-config.ts'
+export type { RepoConfig, ServeConfig, FloorResolution, FloorSource } from './repo-config.ts'
+// the hub (`shipkit serve`): one server, one port, every tool a click away
+export { serveHub, hubTools } from './serve/serve-hub.ts'
+export type { Hub, HubDeps, HubGraph, HubTool } from './serve/serve-hub.ts'
+export { runServe, resolveHubDeps, defaultHubPort } from './serve/run-serve.ts'
+export { landingPage, statusPage } from './serve/hub-pages.ts'
+export { discoverChecks } from './core/discover-checks.ts'
+export type { DiscoveredCheck } from './core/discover-checks.ts'
 export { runTasks, selectTasks } from './core/task-runner.ts'
 export type { TaskDef, TaskResult, RunOpts, RunSummary } from './core/task-runner.ts'
 export { CheckSuite } from './core/check-suite.ts'
-export type { CheckSuiteOpts, GetSecret, SecretSpec } from './core/check-suite.ts'
+export type { CheckSuiteOpts, CheckOutcome, GetSecret, SecretSpec } from './core/check-suite.ts'
+// tui: type-only here — the store/view/panels import ink+mobx, which must
+// not load on every `shipkit ci`; runtime pieces live at rvlib-shipkit/src/tui/*
+export type { TuiPanelDef, TuiRow, TuiRowStatus, MarkedLine } from './tui/tui-panel.ts'
 export { CheckCtx, RateLimited, ToolUnresolved } from './core/check-ctx.ts'
-export { formatLine, parseDuration, fmtAge } from './core/wire.ts'
+export { spawnWithTimeout } from './core/spawn-timeout.ts'
+export type { SpawnOutcome, SpawnTimeoutOpts } from './core/spawn-timeout.ts'
+export { writeStatus } from './core/write-status.ts'
+export type { StatusInput, StatusOutcome } from './core/write-status.ts'
+export { formatLine, parseDuration, fmtAge, parseWireOutput } from './core/wire.ts'
 export type { Line } from './core/wire.ts'
 export { evaluateContracts, pngDims } from './contracts/contracts-engine.ts'
 export type { ContractsConfig, ContractsResult, ContractOutcome } from './contracts/contracts-engine.ts'
@@ -16,6 +30,28 @@ export type { ContractManifest, ArtifactRule, Detector, ContractEnv } from './co
 export { allContracts } from './contracts/contract-manifests.ts'
 export { listAsks, openAsks, checkAsks, createAsk, renderAsksTable } from './asks/asks-queue.ts'
 export type { Ask, CreateOpts } from './asks/asks-queue.ts'
+// assets surface (folded in from the standalone atelier lib; that npm
+// package is frozen). A repo's .rv-assets/kit.ts imports defineKit and
+// declares its kinds; `shipkit assets …` derives the rest.
+export { defineKit, defineKind, comfy, canvas, geometryPanel, gridPanel, customPanel, validateKit, missingPanelScripts, loadKit, findAsset, allAssets, categoriesOf } from './assets/kit-config.ts'
+export type { KitConfig, ResolvedKit, Kind, KindMeta, AssetSpec, GeneratorSpec, ComfyGen, CanvasGen, PanelSpec, GeometryPanelSpec, GridPanelSpec, CustomPanelSpec, FoundAsset, ShipContext, ShipFn } from './assets/kit-config.ts'
+export { identityKinds, renderIdentity, renderIdentityFromMark, NO_PICK_FIX, FAVICON_SIZE, OG_W, OG_H, LOGO_SIZE } from './assets/kits/identity-kit.ts'
+export type { Brand } from './assets/kits/identity-kit.ts'
+export { serveStudio, studioRoutes } from './assets/server/studio-server.ts'
+export type { Studio, StudioDeps, StudioRoutes } from './assets/server/studio-server.ts'
+export { page as studioPage } from './assets/server/studio-page.ts'
+export { StudioQueue } from './assets/server/studio-queue.ts'
+export type { Job, QueueState } from './assets/server/studio-queue.ts'
+export { cleanRect, liveRect, defaultLegs, migrateCircle } from './assets/panels/geometry-rects.ts'
+export type { GroundRect, LegRect } from './assets/panels/geometry-rects.ts'
+export { generate, submit, waitFor, applyInputs, expectNode, randomSeed, batchFolderName } from './assets/gen/comfy-gen.ts'
+export type { ComfyOpts } from './assets/gen/comfy-gen.ts'
+export { loadWorkflows, workflowFor } from './assets/gen/workflow-loader.ts'
+export type { Workflow, Sidekick, Binding, Graph } from './assets/gen/workflow-loader.ts'
+export { toPng, alphaHeight } from './assets/image-ops.ts'
+export { updateJson, readJson } from './assets/json-store.ts'
+export { assetDir, listRolls, isRollFile, readPick, updatePick, metaPath, pickPath, readPromptOverlay, updatePromptOverlay, promptPath } from './assets/roll-workspace.ts'
+export type { PickState, PromptOverlay } from './assets/roll-workspace.ts'
 export { scanMdGraph } from './wiki/scan-md.ts'
 export { lintMd } from './wiki/lint-md.ts'
 export { serveMdGraph } from './wiki/serve-graph.ts'

package/src/tui/checks-panel.ts ADDED Viewed

@@ -0,0 +1,39 @@
+// built-in panel: contracts + every discovered *.check.ts through runCheck
+// (both TTL cache layers intact) — per-check results stream in via the
+// onResult tap. status:false: the tasks panel owns STATUS.md in a TUI run.
+import { discoverChecks } from '../core/discover-checks.ts'
+import { runCheck } from '../core/run-check.ts'
+import { formatLine } from '../core/wire.ts'
+import type { TuiPanelDef, TuiRow } from './tui-panel.ts'
+export function checksPanel(root: string): TuiPanelDef {
+    let rows: TuiRow[] = []
+    return {
+        id: 'checks',
+        title: 'Checks',
+        rows: () => rows,
+        refresh: async (update) => {
+            rows = ['contracts', ...discoverChecks(root).map((d) => d.name)]
+                .map((n): TuiRow => ({ key: n, label: n, status: 'pending', detail: [] }))
+            const byKey = new Map(rows.map((r, i) => [r.key, i]))
+            update()
+            await runCheck(root, {
+                status: false,
+                print: () => {},
+                onResult: (name, r) => {
+                    const row: TuiRow = {
+                        key: name,
+                        label: name,
+                        status: r.status,
+                        ...(r.cached ? { hint: 'cached' } : {}),
+                        detail: r.lines.map((l) => formatLine(l, false)),
+                    }
+                    const i = byKey.get(name)
+                    if (i == null) { byKey.set(name, rows.length); rows.push(row) } // suite-side names (secret checks) still land
+                    else rows[i] = row
+                    update()
+                },
+            })
+        },
+    }
+}

package/src/tui/tasks-panel.ts ADDED Viewed

@@ -0,0 +1,54 @@
+// built-in panel: the ci gate (floor + contracts + repo tasks) through
+// runCi — results stream in via the onTaskFinish tap. STATUS.md refreshes
+// exactly like a terminal `shipkit ci`; the checks panel writes nothing
+// (one STATUS writer per TUI session).
+import type { RepoConfig } from '../repo-config.ts'
+import { allTasks } from '../repo-config.ts'
+import { runCi } from '../core/run-ci.ts'
+import { formatLine } from '../core/wire.ts'
+import type { TaskResult } from '../core/task-runner.ts'
+import type { TuiPanelDef, TuiRow } from './tui-panel.ts'
+const taskRow = (r: TaskResult): TuiRow => ({
+    key: r.id,
+    label: r.id,
+    status: r.status === 'pass' ? (r.lines.some((l) => l.kind === 'warn') ? 'warn' : 'pass') : r.status === 'fail' ? 'fail' : 'skip',
+    hint: `${(r.durationMs / 1000).toFixed(1)}s`,
+    detail: [
+        ...r.lines.map((l) => formatLine(l, false)),
+        ...(r.status === 'fail' && r.lastLine !== '' ? [`FAIL: ${r.lastLine}`] : []),
+        ...(r.note !== '' ? [`skip: ${r.note}`] : []),
+        ...(r.logPath != null ? [`full log: ${r.logPath}`] : []),
+    ],
+})
+export function tasksPanel(root: string, config: RepoConfig): TuiPanelDef {
+    let rows: TuiRow[] = []
+    return {
+        id: 'tasks',
+        title: 'Tasks',
+        rows: () => rows,
+        refresh: async (update) => {
+            const { tasks, disabled, unfilled } = allTasks(config, root)
+            rows = [
+                ...tasks.map((t): TuiRow => ({ key: t.id, label: t.id, status: 'pending', detail: [] })),
+                ...disabled.map((id): TuiRow => ({ key: id, label: id, status: 'skip', detail: ['skip: disabled by repo.config defaults'] })),
+                ...unfilled.map((u): TuiRow => ({ key: u.id, label: u.id, status: 'skip', detail: [`skip: ${u.reason}`] })),
+            ]
+            const byKey = new Map(rows.map((r, i) => [r.key, i]))
+            update()
+            await runCi(root, {
+                print: () => {}, // rows carry everything the wire lines would
+                onTaskFinish: (r) => {
+                    const i = byKey.get(r.id)
+                    if (i == null) return
+                    rows[i] = taskRow(r)
+                    update()
+                },
+            })
+            // bail/interrupt leftovers never got a finish tap — visible, never a fake pass
+            rows = rows.map((r) => (r.status === 'pending' ? { ...r, status: 'skip', detail: ['skip: never ran (bailed or interrupted)'] } : r))
+            update()
+        },
+    }
+}

package/src/tui/tui-app.tsx ADDED Viewed

@@ -0,0 +1,91 @@
+// shipkit tui — the generic view: tab bar, list left, detail right, wire
+// lines normalized to one visual language (✓/✗/⚠/~/»). All data comes from
+// panels (tui-panel.ts); this file owns ONLY rendering + keys.
+import React from 'react'
+import { Box, Text, useApp, useInput } from 'ink'
+import { observer } from 'mobx-react-lite'
+import { markLine, ROW_MARK, type TuiRow } from './tui-panel.ts'
+import type { TuiStore } from './tui-store.ts'
+const SPIN = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+const RowLine = observer(function RowLine(p: { row: TuiRow; selected: boolean; spin: number; width: number }) {
+    const m = ROW_MARK[p.row.status]
+    const mark = p.row.status === 'pending' ? SPIN[p.spin % SPIN.length]! : (p.row.mark ?? m.mark)
+    return (
+        <Text inverse={p.selected} wrap="truncate">
+            <Text color={m.color}>{mark.padEnd(2)}</Text>
+            <Text dimColor={p.row.status === 'pending'}>{p.row.label.padEnd(p.width)}</Text>
+            {p.row.hint != null && <Text dimColor> {p.row.hint}</Text>}
+        </Text>
+    )
+})
+const Detail = observer(function Detail(p: { row: TuiRow; spin: number }) {
+    const m = ROW_MARK[p.row.status]
+    return (
+        <Box flexDirection="column" borderStyle="round" borderColor={m.color ?? 'gray'} paddingX={1} flexGrow={1}>
+            <Box justifyContent="space-between">
+                <Text bold>{p.row.label}</Text>
+                {p.row.status === 'pending'
+                    ? <Text color="cyan">{SPIN[p.spin % SPIN.length]} running</Text>
+                    : <Text bold color={m.color}>{p.row.status.toUpperCase()}</Text>}
+            </Box>
+            {p.row.detail.map((l, i) => {
+                const c = markLine(l)
+                return <Text key={i} bold={c.bold} wrap="truncate-end"><Text color={c.color}>{c.mark}</Text> {c.text}</Text>
+            })}
+            {p.row.status !== 'pending' && p.row.detail.length === 0 && <Text dimColor>no output</Text>}
+        </Box>
+    )
+})
+const Summary = observer(function Summary(p: { store: TuiStore }) {
+    const c = p.store.counts
+    return (
+        <Text>
+            <Text color="green">{c.pass} ok</Text><Text dimColor> · </Text>
+            <Text color="yellow">{c.warn} warn</Text><Text dimColor> · </Text>
+            <Text color="red">{c.fail} fail</Text>
+            {c.pending > 0 && <Text color="cyan"> · {SPIN[p.store.spin % SPIN.length]} {c.pending} running</Text>}
+        </Text>
+    )
+})
+export const TuiApp = observer(function TuiApp(p: { store: TuiStore }) {
+    const app = useApp()
+    const s = p.store
+    useInput((input, key) => {
+        if (input === 'q') app.exit()
+        else if (input === 'r') s.refresh()
+        else if (/^[1-9]$/.test(input)) s.setTab(Number(input) - 1)
+        else if (key.tab || key.rightArrow) s.cycleTab(1)
+        else if (key.leftArrow) s.cycleTab(-1)
+        else if (key.downArrow || input === 'j') s.move(1)
+        else if (key.upArrow || input === 'k') s.move(-1)
+    })
+    const rows = s.activeRows
+    const width = Math.max(8, ...rows.map((r) => r.label.length))
+    return (
+        <Box flexDirection="column">
+            <Box justifyContent="space-between">
+                <Text bold color="cyan">⚙ {s.name} — shipkit</Text>
+                <Summary store={s} />
+            </Box>
+            <Box gap={2}>
+                {s.panels.map((panel, i) => (
+                    <Text key={panel.id} bold inverse={i === s.tab}> {i + 1} {panel.title}{s.rowsOf(panel).length > 0 ? ` (${s.rowsOf(panel).length})` : ''} </Text>
+                ))}
+                {s.error != null && <Text color="red">{s.error}</Text>}
+            </Box>
+            <Box gap={1}>
+                <Box flexDirection="column" flexShrink={0}>
+                    {rows.length === 0 && <Text color="green">{s.activePanel.emptyText ?? '(empty)'}</Text>}
+                    {rows.map((r, i) => <RowLine key={r.key} row={r} selected={i === s.sel} spin={s.spin} width={width} />)}
+                </Box>
+                {s.selectedRow != null && <Detail row={s.selectedRow} spin={s.spin} />}
+            </Box>
+            <Text dimColor>1-{s.panels.length}/tab switch · j/k move · r refresh · q quit</Text>
+        </Box>
+    )
+})

package/src/tui/tui-panel.ts ADDED Viewed

@@ -0,0 +1,57 @@
+// TUI panel contract — render-free and mobx-free on purpose: a panel is
+// DATA (rows + wire-format detail lines), the generic view (tui-app.tsx)
+// owns all ink. Built-ins: tasks-panel.ts (the ci gate) + checks-panel.ts
+// (contracts + discovered *.check.ts); a repo injects extras via
+// repo.config `tui: { panels: [...] }`.
+export type TuiRowStatus = 'pass' | 'fail' | 'warn' | 'skip' | 'pending' | 'info'
+export type TuiRow = {
+    key: string
+    /** left-list label */
+    label: string
+    /** drives the list mark + detail border color; 'pending' shows the spinner */
+    status: TuiRowStatus
+    /** dim right-side hint (duration, age, cached, owner) */
+    hint?: string
+    /** list-mark override (default derives from status — asks rows use '?') */
+    mark?: string
+    /** detail-panel lines — wire format (ok:/WARN/FAIL:/skip:/fix:) or plain text */
+    detail: string[]
+}
+export type TuiPanelDef = {
+    id: string
+    /** tab label */
+    title: string
+    /** shown green when rows() is empty after refresh (e.g. "no open asks …") */
+    emptyText?: string
+    /** current rows — the store re-reads after every update() */
+    rows: () => TuiRow[]
+    /** (re)load data; call update() after each mutation so the view repaints.
+     *  The spinner runs until every panel's returned promise settled. */
+    refresh: (update: () => void) => void | Promise<void>
+}
+export const ROW_MARK: Record<TuiRowStatus, { mark: string; color?: string }> = {
+    pass: { mark: '✓', color: 'green' },
+    fail: { mark: '✗', color: 'red' },
+    warn: { mark: '⚠', color: 'yellow' },
+    skip: { mark: '~', color: 'gray' },
+    pending: { mark: '', color: 'cyan' }, // the view substitutes the spinner frame
+    info: { mark: '·' },
+}
+// normalize a wire/detail line to the one visual language (✓/✗/⚠/~/»),
+// no raw 'ok'/'FAIL' prefixes in the detail panel
+export type MarkedLine = { mark: string; color?: string; text: string; bold?: boolean }
+export const markLine = (l: string): MarkedLine => {
+    if (/^ok[:\s]/.test(l)) return { mark: '✓', color: 'green', text: l.replace(/^ok[:\s]+/, '') }
+    if (l.startsWith('FAIL')) return { mark: '✗', color: 'red', text: l.replace(/^FAIL[:\s]+/, '') }
+    if (l.startsWith('WARN')) return { mark: '⚠', color: 'yellow', text: l.replace(/^WARN[:\s]+/, '') }
+    if (l.startsWith('skip:')) return { mark: '~', color: 'gray', text: l.replace(/^skip:\s*/, '') }
+    if (/^\s+fix: /.test(l)) return { mark: '»', color: 'yellow', text: l.trim() }
+    if (l.startsWith('VERDICT')) return { mark: '»', text: l, bold: true }
+    return { mark: ' ', text: l }
+}

package/src/tui/tui-store.ts ADDED Viewed

@@ -0,0 +1,98 @@
+// TUI state — MobX per the house playbook (build/state + build/mobx):
+// `makeAutoObservable` WITH exceptions (the 2026-07-21 doctrine — no
+// decorators), runInAction around every post-await mutation. Panels are
+// plain data providers (no mobx): they signal mutations through update(),
+// which bumps the observable `version` counter every rows() read tracks.
+import { makeAutoObservable, runInAction } from 'mobx'
+import type { TuiPanelDef, TuiRow, TuiRowStatus } from './tui-panel.ts'
+export class TuiStore {
+    tab = 0
+    sel = 0
+    spin = 0 // spinner frame, ticked while any panel refresh is in flight
+    version = 0 // bumped by panel update() — activeRows re-derives from it
+    error: string | null = null
+    inflight = 0 // panel refresh promises not yet settled
+    readonly name: string
+    readonly panels: TuiPanelDef[]
+    private spinTimer: ReturnType<typeof setInterval> | null = null
+    constructor(name: string, panels: TuiPanelDef[]) {
+        if (panels.length === 0) throw new Error('TuiStore: at least one panel required')
+        this.name = name
+        this.panels = panels
+        // panels/name/spinTimer are infra, never observed
+        makeAutoObservable<TuiStore, 'spinTimer'>(this, { name: false, panels: false, spinTimer: false })
+    }
+    get activePanel(): TuiPanelDef {
+        return this.panels[this.tab]!
+    }
+    get activeRows(): TuiRow[] {
+        void this.version // panels mutate outside mobx — update() bumps this
+        return this.activePanel.rows()
+    }
+    get selectedRow(): TuiRow | null {
+        return this.activeRows[this.sel] ?? null
+    }
+    /** per-status counts over the ACTIVE panel — the header summary */
+    get counts(): Record<TuiRowStatus, number> {
+        const c: Record<TuiRowStatus, number> = { pass: 0, fail: 0, warn: 0, skip: 0, pending: 0, info: 0 }
+        for (const r of this.activeRows) c[r.status]++
+        return c
+    }
+    rowsOf(panel: TuiPanelDef): TuiRow[] {
+        void this.version
+        return panel.rows()
+    }
+    setTab(i: number): void {
+        if (i < 0 || i >= this.panels.length || i === this.tab) return
+        this.tab = i
+        this.sel = 0
+    }
+    cycleTab(delta = 1): void {
+        this.setTab((this.tab + delta + this.panels.length) % this.panels.length)
+    }
+    move(delta: number): void {
+        const max = Math.max(0, this.activeRows.length - 1)
+        this.sel = Math.min(max, Math.max(0, this.sel + delta))
+    }
+    // kick every panel's refresh; results stream in via update(). A refresh
+    // while one is in flight is ignored — panels own no superseding logic.
+    refresh(): void {
+        if (this.inflight > 0) return
+        this.error = null
+        this.startSpinner()
+        const update = (): void => runInAction(() => { this.version++ })
+        for (const p of this.panels) {
+            this.inflight++
+            void Promise.resolve()
+                .then(() => p.refresh(update))
+                .catch((e) => runInAction(() => { this.error = `${p.id}: ${String(e).slice(0, 200)}` })) // never fail silently — surfaced in the header
+                .finally(() => runInAction(() => {
+                    this.version++
+                    if (--this.inflight === 0) this.stopSpinner()
+                }))
+        }
+    }
+    private startSpinner(): void {
+        if (this.spinTimer != null) return
+        this.spinTimer = setInterval(() => runInAction(() => { this.spin++ }), 120)
+    }
+    private stopSpinner(): void {
+        if (this.spinTimer == null) return
+        clearInterval(this.spinTimer)
+        this.spinTimer = null
+    }
+}