rvlib-shipkit 0.10.0 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,209 @@
 # Changelog
 
+## 0.13.0 — 2026-07-26
+
+Stable rule ids. Every built-in invariant `shipkit check` enforces is now
+an SK rule — one module per rule (`src/rules/SK###-<slug>.ts`), one
+registry (`rule-registry.ts`, throws at import on a duplicate or malformed
+id), ids never reused or renumbered. The two existing built-ins migrated
+whole: SK001 package.json shape (was `core/package-json-check.ts`, deleted),
+SK002 `.rv-*` contracts fulfillness. Line text changed on every consumer:
+rule-emitted `ok:`/`WARN`/`FAIL:`/`skip:` lines now carry a `[SK###]` tag
+after the wire prefix — on `check`, `shipkit contracts`, AND the ci
+`contracts` task (one tagged rendering path,
+`contracts/apply-contracts.ts`; `contractsConfigFrom`/`activeContracts`/
+`applyContractsResult` moved there, still exported from the barrel). A
+failing/warning rule always carries at least one `fix:` pointer (the
+framework appends `docsBase + rule.owner` when the lint attached none).
+New command: `shipkit rules [--json]` — the id catalog (plain lines, not
+wire). Wire prefixes themselves are unchanged; matchers keying on prefixes
+are unaffected.
+
+`shipkit check --fix [SK### …]`: rules may carry an idempotent `fix()` —
+apply, re-lint, show the real end state; never cached, never under ci;
+unknown/unfixable ids fail loud. First fixers: SK001 (private:true, license
+removal, canonical scripts from the ONE shared module
+`core/canonical-scripts.ts` that `shipkit init` also scaffolds from —
+bodies the vocabulary page doesn't state are named in the summary, never
+invented; rvlib-* roots refused), SK003 CLAUDE.md include-index (new rule:
+prose/extra lines/inverted order/untracked-CLAUDE.local.md FAIL; fix routes
+a missing `@./agent/index.md` on an EXISTING file, never creates one),
+SK004 `.gitignore` policy block (new rule: marker-keyed managed block of
+the always-gitignored contract surfaces + tmp/; a well-formed block is
+rewritten IN PLACE so below-block `!`-overrides keep winning; CRLF files
+keep their EOL; repo lines outside the block never touched;
+`defineRepo({ gitignore: [...] })` contributes repo lines INSIDE the
+block, for names a published lib may not carry; `shipkit init` — fresh or
+re-run on an existing repo — writes it through the same fixer). A failing
+rule's fix pointers advertise `autofix: shipkit check --fix SK###`; the
+post-fix re-lint strips the advertisement and an unchanged fix reports as
+a note, not a WARN; `--fix` rejects `--json` and closes with a count of
+rules no fixer covers. SK001's fixer refuses field flips on anything
+publish-marked (files/exports/publishConfig/prepublishOnly) and never
+duplicates a script a banned alias already satisfies.
+
+SK005 rvlib versions: every `rvlib-*` dep is compared (real semver order,
+so a dist-tag pointing BEHIND the installed version is reported, never a
+silent downgrade) to npm latest on each `shipkit check` (rules may now
+declare `ttl` — SK005 caches clean passes 24h; registry unreachable = loud
+skip, never red; a `link:` dep that does not resolve is a FAIL instead of
+a cryptic import crash). When a newer version is live the rule
+SELF-UPDATES: `bun update --latest`, run by the lint itself, only when
+package.json/lockfile are git-clean (else WARN deferred), never under ci;
+the applied update itself reports as WARN — the repo was mutated and a
+restart+commit is owed, so it lands on the attention surface and is never
+cached. New `shipkit check --frozen` (or standing `SHIPKIT_FROZEN=1`)
+reports drift without touching anything; the flag threads through
+`CheckOpts` so doctor/TUI/hub callers can pass it too. Committing the bump
+stays with the working agent — shipkit never commits. Suite-level fix
+riding along: a TTL'd check that emitted a `skip` line is no longer
+cached — "only clean passes replay" is now literally true (a dead
+registry was being restated as fact for 24h).
+
+SK006 npm publish safety: a `private: true` package carrying publishConfig
+/ prepublish* scripts / an npm-publishing `publish` script FAILs — the
+machinery is dead weight while private holds and a loaded gun the day it
+flips; rvlib-* roots exempt; lint-only on purpose (a `publish` script may
+deploy a site). SK007 github visibility: new repo.config
+`visibility: 'private' | 'public'` (absent = private, defineRepo validates)
+vs `gh repo view --json isPrivate` — mismatch FAILs in BOTH directions
+(public-while-declared-private is the leak case), 7d clean-pass cache,
+every unverifiable path (no gh, no remote, gh error) a loud skip that is
+never red and never cached.
+
+Motherhome reporting: `check`/`ci` (and `init` on an already-configured
+repo) upsert one row for the repo — name, path, version (`+src` suffix
+when consumed by path/link), npm|link|file|path mode, last-seen day —
+into `<docsBase>/build/shipkit/local-projects.md`, ONLY when that page
+already exists on this disk. The lib never creates the page and never
+writes into a relative or URL docsBase — a consumer using docsBase as a
+plain fix-pointer prefix will never find surprise files in its docs tree.
+Whole read-modify-write under a file lock with atomic rename
+(core/locked-write, extracted from write-status — one lock concern),
+dead-path rows pruned, data-change-or->7d churn control, every failure a
+WARN note that never breaks the calling command.
+
+## 0.12.0 — 2026-07-23
+
+ONE server, ONE page. `shipkit serve` runs the repo's single `Bun.serve`,
+and `/` is the single surface: a mobx+react app (Bun HTML import, no build
+step) holding the full media atelier (rolls, compare, pick, geometry
+overlay, custom panels, uploads, generate queue) plus foldable sections
+for asks, creds, posts, health (STATUS.md + streaming check runner) and
+graphs (each lint-checked), with a segmented severity filter (all · needs ·
+red) at `/?f=needs` / `/?f=red` (legacy `/?needs=1` reads as needs) and
+hash deep-links (`#<asset-id>` / `#cat-<Category>`).
+Kit-less repos serve the same page with no media section. Graph canvases
+stay as drill-down pages (`/graph/wiki`, `/graph/agent`) with a home link.
+
+New:
+
+- Navigation on the one page: a thin icon RAIL that scrolls/unfolds to a
+  section (red dot when it holds a red item — never a separate page), a
+  sidebar SEARCH filtering rows and grid cards, a `cmd+j` palette jumping
+  to any item or section.
+- Instances carry `md` (truth-file markdown body, frontmatter stripped,
+  4000-char cap): cards render it via marked (GFM — tables render) behind
+  a sanitize-html allowlist — clamped in the grid, full in the item view.
+- Secret cards presented properly: mono name, service line,
+  present/missing chip, mint link; copy block only when missing.
+- Roll strips: newest first with a stable tiebreak; the generating
+  spinner tile sits at the START of the strip.
+- Every section has BOTH views: title → collection view (one card per
+  instance in the stage), row/card → item view with a back link. A graph's
+  item view EMBEDS the graph (iframe of /graph/*), never a bare link.
+- Sections show everything, always: asks include the done/ archive
+  (quiet, remarkable — consult past answers), the secrets section lists
+  every repo-declared cred (present = quiet, missing = red with the mint
+  artifact); section headers render even at 0 items. "needs" is THE
+  waiting-on-me filter, "red" the hard-blocked cut.
+- Watch mode is the house default for the hub script
+  (`bun --watch … serve`, `shipkit init` scaffolds it): lib/config edits
+  restart the server live. Accepted tradeoff: a restart drops in-memory
+  queue state (`assets fill` recovers).
+- `serve.publicHost` (repo.config): off-machine hostname printed beside
+  localhost and appended to ping messages — a phone can't resolve
+  localhost.
+- `/api/collections.json`: browse-all — every instance of every
+  collection, healthy included (quiet tiles), rendered as foldable
+  sections with red/yellow dots.
+- Trust surface: instances carry `file` (the git file the tile IS — shown
+  on the card; the file always wins) and `img` (thumbnails via the media
+  API).
+- Remarks: cards AND the asset view have a remark box; `/api/act/remark`
+  routes the text into the item's own file (post `## Feedback`, the ask
+  file, or `.rv-assets/notes.md` for media) and it returns as `remarks`
+  on the instance — `shipkit needs --json` briefs agents on them at boot.
+- Posted/rejected post history is VISIBLE (quiet), no longer hidden;
+  media collections list ALL kit assets, not only needing ones.
+- `shipkit reflect [repo…] [--short --out <dir> --json]`: your prompts
+  across every Claude Code session of a repo, chronological md corpus for a
+  retrospective. Corpus fidelity is the whole feature — it unions EVERY
+  config root on the machine (`$CLAUDE_CONFIG_DIR` plus `~/.claude` plus
+  sibling `~/.claude-<account>`; honoring only the env var hides the account
+  you are not currently running as), scans worktree session dirs, includes
+  the prompts you QUEUED while the agent was working (`queue-operation`
+  entries, marked `origin: 'queued'` — they carry mid-run corrections and
+  standing instructions, and when a run ends first they never become user
+  messages at all), drops harness-authored user entries (tool results,
+  command wrappers, compaction summaries, subagent prompts, SDK-driven
+  sessions), rescues the text you typed inside a slash command, strips
+  reminder blocks appended inside real prompts, recovers pruned sessions
+  from `sessions-index.json`, and removes only MECHANICAL copies — a
+  replayed entry, or a queued prompt arriving again as a message — so real
+  repetition (saying it twice) survives in the corpus. `--json` emits one
+  shape whatever the run looked like: `[{repo, prompts, error?}]`.
+
+BREAKING (0.11.0 → 0.12.0):
+
+- `shipkit assets serve` DELETED — the studio UI rides the hub page; the
+  media API mounts at `/media/*` (was `/assets/*` under the hub).
+- `serveStudio`, `Studio`, `studioPage`, `withRail` exports DELETED
+  (`studioRoutes` stays — it IS the media API).
+- `kit.port` DELETED from `defineKit` (nothing standalone listens anymore).
+- `/status` and `/assets/` pages DELETED (404, no redirect); the check
+  stream moved `/status/run` → `/api/check/run`; the vanilla
+  template-string studio SPA and the injected rail are gone — the react
+  app is the only UI code path.
+
+## 0.11.0 — 2026-07-23
+
+The needs feed: the hub's `/` now answers "what needs a human right now,
+artifact in hand".
+
+New:
+
+- Collection model (`src/collections/`): every curatable surface projects
+  through one interface — media kinds, asks, missing declared secrets
+  (mint artifact + `credsCommand` store template as config data), repo
+  health, social posts. `projectNeeds` is failure-isolated per collection.
+- `shipkit needs [--json]`: the feed as a CLI — red/yellow by collection,
+  REPORT-ONLY (exit 0 always; `check`/`ci` stay the gates).
+- Hub `/` = the needs feed: act-in-place tiles (copy buttons for briefs/
+  commands/post text, mint links, done + proof-URL inputs, draft pick
+  buttons), reds-only toggle, `/api/needs.json` + `/api/act/*` (every
+  mutation hits a git-tracked truth file).
+- RED-only pings while the hub serves: one batched notification per tick
+  of NEW red items (`notifyCommand` template + macOS notification).
+  Once-ever per item: cache file for non-ask items, the ask file's own
+  `pinged:` field for asks. Yellow never pings.
+- Social posts contract v2: slug-only files, variants (`<slug>.a.md`) as
+  drafts-as-rolls (pick flips siblings to rejected, files kept),
+  frontmatter kind/tone/status/posted/rating, `## Angle` / `## Post` /
+  `## Feedback` sections — the copy button pastes ONLY `## Post`;
+  feedback appends are non-destructive.
+- Missing manual media tiles carry their brief as the copy artifact.
+
+Breaking (0.10.x consumers):
+
+- `/api/attention.json` → `/api/needs.json` (NeedItem[] — flat, severity
+  red|yellow); `attentionRedCount`/`AttentionSection`/`AttentionLine`
+  exports removed (use `redCount`/`NeedItem`/`Instance`). Unpicked-roll
+  and stale assets are now YELLOW (taste pending — a default ships), no
+  longer red.
+- `.rv-social` post files: `status:` frontmatter is required (missing =
+  a red feed item); v1 vocab maps idea→draft, ready→picked, link→posted.
+
 ## 0.10.0 — 2026-07-22
 
 New:

package/README.md

@@ -34,16 +34,30 @@ shipkit ci        commit gate: floor (lint/typecheck/test/imports/cycles —
                   + your tasks, parallel DAG; refreshes STATUS.md
                   [--bail --skip g --only id --json]
 shipkit contracts release-contract fulfillness alone       [--venue v --json]
-shipkit check     periodic health: every *.check.ts in the repo,
-                  auto-discovered + TTL-cached              [--json --fresh]
+shipkit check     periodic health: built-in SK rules + every *.check.ts in
+                  the repo, auto-discovered + TTL-cached
+                  [--json --fresh --frozen --fix [SK### …]]
+                  --fix applies rule autofixes then re-lints; --frozen =
+                  self-maintaining rules (rvlib self-update) report only
+shipkit rules     the SK rule catalog: id, what it lints, owning doc,
+                  fixable?                                          [--json]
 shipkit tui       live dashboard: ci tasks + discovered checks + panels
                   the repo injects via repo.config tui.panels
 shipkit asks      human action queue: list · ask "<title>" · asks check (auto-close)
+shipkit needs     everything blocked on a human, red/yellow by collection
+                  report-only, exit 0 always                            [--json]
 shipkit wiki      serve|lint — live md link-graph + orphan/dangling-ref lint
+shipkit mv        rename an md page + its sibling dir, sweeping every ref
 shipkit assets    serve|fill|add|gen|identity|check — the asset atelier
                   (declare kinds in .rv-assets/kit.ts, roll, curate, ship)
+shipkit serve     the repo's ONE server: hub page, graphs, studio, status
+shipkit reflect   your prompts across every Claude Code session of a repo:
+                  all config roots, queued-mid-run ones included, harness
+                  noise out, chronological md corpus for a retrospective
+                                         [repo…] [--short --out <dir> --json]
 shipkit init      scaffold config + scripts, print the resolved floor
                   [--bin <cli.ts path> for in-repo-source consumers]
+shipkit start     ensure <root>/<name> + its CLAUDE.md include; prints the dir
 ```
 
 Output is a stable line protocol — `ok:` / `WARN` / `FAIL:` / `skip:` with
@@ -67,7 +81,7 @@ Ship your own contracts via `contracts: { extra: [defineContract({...})] }`
 Everything the CLI does is importable: `runTasks`, `CheckSuite`,
 `evaluateContracts`, the asks queue, `scanMdGraph`/`lintMd`/`serveMdGraph`,
 and the assets surface (`defineKit`/`defineKind`, `identityKinds`,
-`serveStudio`, `saveEndpoint` via `rvlib-shipkit/vite`).
+`studioRoutes`, `saveEndpoint` via `rvlib-shipkit/vite`).
 Ships TypeScript source; Bun ≥ 1.0.
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rvlib-shipkit",
-    "version": "0.10.0",
+    "version": "0.13.0",
     "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",
     "type": "module",
@@ -21,17 +21,20 @@
     "devDependencies": {
         "@types/bun": "^1.3.14",
         "@types/react": "^19.2.17",
-        "@types/react-dom": "^19.2.3"
+        "@types/react-dom": "^19.2.3",
+        "@types/sanitize-html": "^2.16.1"
     },
     "dependencies": {
         "@napi-rs/canvas": "^1.0.2",
         "clipanion": "^4.0.0-rc.4",
         "ink": "^7.1.1",
+        "marked": "^18.0.7",
         "mobx": "^6.16.1",
         "mobx-react-lite": "^4.1.1",
         "react": "^19.2.7",
         "react-dom": "^19.2.7",
         "rvlib-ts-tools": "^0.2.0",
+        "sanitize-html": "^2.17.6",
         "sharp": "^0.35.3"
     }
 }

package/src/asks/asks-queue.ts

@@ -45,6 +45,14 @@ export function openAsks(dir: string): Ask[] {
     return listAsks(dir).filter((a) => a.status !== 'done')
 }
 
+/** the <dir>/done archive, newest-first — READ-ONLY: never mints the dir
+ *  (numeric filename prefixes are creation order, so reverse-sort = newest) */
+export function doneAsks(dir: string): Ask[] {
+    const done = join(dir, 'done')
+    if (!existsSync(done)) return []
+    return readdirSync(done).filter((f) => f.endsWith('.md')).sort().reverse().map((f) => parse(done, f))
+}
+
 export function checkAsks(dir: string, print: (line: string) => void = console.log): { closed: number } {
     const done = join(dir, 'done')
     mkdirSync(done, { recursive: true })
@@ -99,6 +107,40 @@ ${whyBlock}**Answer**: _(fill in / check off, or just do it — the check probe
     return file
 }
 
+/** flip an ask to done and archive it (the hub's "done" verb) */
+export function archiveAsk(dir: string, file: string): void {
+    const p = join(dir, file)
+    if (!existsSync(p)) throw new Error(`no such ask: ${file}`)
+    const md = readFileSync(p, 'utf8').replace(/^status:.*$/m, `status: done\nclosed: ${new Date().toISOString().slice(0, 10)}`)
+    writeFileSync(p, md)
+    const done = join(dir, 'done')
+    mkdirSync(done, { recursive: true })
+    renameSync(p, join(done, file))
+}
+
+/** record the completion proof (human-loop: URL back = done), then archive */
+export function proofAsk(dir: string, file: string, url: string): void {
+    const p = join(dir, file)
+    if (!existsSync(p)) throw new Error(`no such ask: ${file}`)
+    writeFileSync(p, `${readFileSync(p, 'utf8').trimEnd()}\n\n**Proof**: ${url}\n`)
+    archiveAsk(dir, file)
+}
+
+/** once-ever ping marker, shared with every ping path (notify doctrine):
+ *  returns false when the ask was already pinged — never double-fire */
+export function markPinged(dir: string, file: string): boolean {
+    const p = join(dir, file)
+    if (!existsSync(p)) return false
+    const md = readFileSync(p, 'utf8')
+    if (/^pinged:/m.test(md)) return false
+    const line = `pinged: ${new Date().toISOString().slice(0, 10)}`
+    const withMark = md.replace(/^status:(.*)$/m, `status:$1\n${line}`)
+    // a hand-edited ask without status: still gets a durable marker — a
+    // no-op write here would re-fire the ping every tick forever
+    writeFileSync(p, withMark !== md ? withMark : `${line}\n${md}`)
+    return true
+}
+
 export function renderAsksTable(dir: string, print: (line: string) => void = console.log, opts?: { emptyText?: string }): number {
     const open = openAsks(dir)
     if (open.length === 0) { print(opts?.emptyText ?? 'no open asks — all caught up 🎉'); return 0 }

package/src/assets/kit-config.ts

@@ -112,14 +112,13 @@ export type Kind = {
 }
 
 export type KitConfig = {
-    port?: number
     /** roll workspace root, repo-root-relative; gitignored */
     workspace?: string
     comfy?: { host: string; workflows: string; heal?: string }
     kinds: Kind[]
 }
 
-export type ResolvedKit = KitConfig & { port: number; workspace: string }
+export type ResolvedKit = KitConfig & { workspace: string }
 
 export function validateKit(k: KitConfig): string[] {
     const errs: string[] = []
@@ -190,7 +189,7 @@ export function missingPanelScripts(kit: KitConfig, root: string): string[] {
 export function defineKit(k: KitConfig): ResolvedKit {
     const errs = validateKit(k)
     if (errs.length > 0) throw new Error(`invalid kit:\n  ${errs.join('\n  ')}`)
-    return { ...k, port: k.port ?? 4800, workspace: k.workspace ?? '.rv-assets/out' }
+    return { ...k, workspace: k.workspace ?? '.rv-assets/out' }
 }
 
 export const defineKind = (k: Kind): Kind => k

package/src/assets/roll-workspace.ts

@@ -25,7 +25,8 @@ export function listRolls(dir: string): string[] {
     if (!existsSync(dir)) return []
     return readdirSync(dir)
         .filter(isRollFile)
-        .sort((a, b) => statSync(join(dir, b)).mtimeMs - statSync(join(dir, a)).mtimeMs) // newest first
+        // newest first; filename tiebreak — same-second batches must not shuffle between polls
+        .sort((a, b) => statSync(join(dir, b)).mtimeMs - statSync(join(dir, a)).mtimeMs || a.localeCompare(b))
 }
 
 export const pickPath = (dir: string): string => join(dir, 'pick.json')

package/src/assets/run-assets.ts

@@ -10,8 +10,6 @@ import { loadWorkflows } from './gen/workflow-loader.ts'
 import { allAssets, findAsset, loadKit, type ResolvedKit } from './kit-config.ts'
 import { NO_PICK_FIX, renderIdentity, type Brand } from './kits/identity-kit.ts'
 import { assetDir, listRolls, readPick, readPromptOverlay } from './roll-workspace.ts'
-import { page } from './server/studio-page.ts'
-import { serveStudio } from './server/studio-server.ts'
 
 export type Print = (line: string) => void
 export type AssetsIo = { print: Print; printErr: Print }
@@ -61,15 +59,6 @@ async function guarded(io: AssetsIo, body: () => Promise<number>): Promise<numbe
     }
 }
 
-export const runAssetsServe = (root: string, io: AssetsIo): Promise<number> =>
-    guarded(io, async () => {
-        const kit = await loadKit(root)
-        const studio = await serveStudio({ kit, root, page })
-        io.print(`ok: studio → http://127.0.0.1:${studio.server.port}  (${allAssets(kit).length} assets)`)
-        await new Promise(() => {}) // Bun.serve owns the process — never resolve
-        return 0
-    })
-
 export const runAssetsTopUp = (root: string, io: AssetsIo, o: { mode: 'fill' | 'add'; n: number; categories: string[] }): Promise<number> =>
     guarded(io, async () => {
         const kit = await loadKit(root)

package/src/assets/server/studio-server.ts

@@ -1,6 +1,7 @@
 // The studio HTTP server — roll variants, compare, pick, geometry metadata,
-// category grid data. 127.0.0.1 ONLY, forever. Never run with --watch: the
-// queue is in-memory (fill is the recovery path).
+// category grid data. 127.0.0.1 ONLY, forever. Watch-mode restarts drop the
+// in-memory queue — accepted tradeoff (his order 2026-07-23); `shipkit
+// assets fill` is the recovery path.
 //
 // ids/names are validated against the kit + the roll-file regex — no path
 // from the client ever reaches the filesystem unchecked.
@@ -20,14 +21,11 @@ import { StudioQueue } from './studio-queue.ts'
 export type StudioDeps = {
     kit: ResolvedKit
     root: string
-    page: () => string
     /** test seam — defaults to the real engines. `context` = a derived
      *  asset's resolved parent picks (queue resolves it at run time) */
     generateOne?: (found: FoundAsset, prompt: string, seed: number, destDir: string, onProgress?: OnProgress, context?: ParentContext) => Promise<void>
 }
 
-export type Studio = { server: ReturnType<typeof Bun.serve>; queue: StudioQueue; stop: () => void }
-
 // what the studio detail view shows about an asset's plumbing (W2-2)
 export type AssetInfo = {
     backend: 'canvas' | 'comfy' | 'manual' | 'gemini'
@@ -42,9 +40,9 @@ export type AssetInfo = {
     kitSource: string
 }
 
-// the studio's route table without a server: `handle` answers the studio's
-// own path space ('/', '/api/…', '/img', '/panel/…') so serveStudio can own
-// a port AND the shipkit hub can mount the same routes under /assets/.
+// the studio's route table without a server: `handle` answers the media
+// path space ('/api/…', '/img', '/panel/…'); the hub — the repo's ONE
+// server — mounts it under /media/*. The page itself is the hub's react app.
 export type StudioRoutes = { handle: (req: Request, pathname: string) => Promise<Response>; queue: StudioQueue }
 
 export async function studioRoutes(deps: StudioDeps): Promise<StudioRoutes> {
@@ -220,8 +218,6 @@ export async function studioRoutes(deps: StudioDeps): Promise<StudioRoutes> {
         const q = (k: string): string => url.searchParams.get(k) ?? ''
         const body = async (): Promise<Record<string, unknown>> => (await req.json().catch(() => ({}))) as Record<string, unknown>
 
-        if (pathname === '/') return new Response(deps.page(), { headers: { 'Content-Type': 'text/html; charset=utf-8' } })
-
         if (pathname === '/api/state') {
             const assets = await Promise.all(allAssets(kit).map(async (f) => {
                 const dir = dirOf(f.asset.id)
@@ -242,7 +238,7 @@ export async function studioRoutes(deps: StudioDeps): Promise<StudioRoutes> {
             const dir = dirOf(f.asset.id)
             const pick = await readPick(dir)
             const rolls = listRolls(dir).map((name) => ({ name, picked: name === pick.pick, alt: pick.alts.includes(name), hasMeta: existsSync(metaPath(dir, name)) }))
-            const custom = customPanelsOf(f).map((p) => ({ id: p.id, kind: f.kind.id, url: `./panel/${encodeURIComponent(f.kind.id)}/${encodeURIComponent(p.id)}.js` }))
+            const custom = customPanelsOf(f).map((p) => ({ id: p.id, kind: f.kind.id, url: `panel/${encodeURIComponent(f.kind.id)}/${encodeURIComponent(p.id)}.js` }))
             return json({ asset: { ...f.asset, prompt: await promptOf(f), cat: f.kind.category, geometry: geometryOf(f) != null, custom }, info: infoOf(f), rolls, pick })
         }
 
@@ -472,16 +468,3 @@ export async function studioRoutes(deps: StudioDeps): Promise<StudioRoutes> {
 
     return { handle, queue }
 }
-
-// standalone studio server (`shipkit assets serve`): the same routes on
-// their own port. The hub (`shipkit serve`) mounts studioRoutes under
-// /assets/ instead — one route table, two front doors.
-export async function serveStudio(deps: StudioDeps): Promise<Studio> {
-    const routes = await studioRoutes(deps)
-    const server = Bun.serve({
-        hostname: '127.0.0.1',
-        port: deps.kit.port,
-        fetch: (req) => routes.handle(req, new URL(req.url).pathname),
-    })
-    return { server, queue: routes.queue, stop: () => server.stop(true) }
-}

package/src/cli/cmd_Assets.ts

@@ -2,26 +2,15 @@
 // (ComfyUI or procedural canvas), curate in the studio, ship with metadata
 // write-through. Thin clipanion surfaces; logic in assets/run-assets.ts.
 import { Command, Option } from 'clipanion'
-import { runAssetsCheck, runAssetsGen, runAssetsIdentity, runAssetsServe, runAssetsTopUp, type AssetsIo } from '../assets/run-assets.ts'
+import { runAssetsCheck, runAssetsGen, runAssetsIdentity, runAssetsTopUp, type AssetsIo } from '../assets/run-assets.ts'
 
 const ioOf = (cmd: Command): AssetsIo => ({
     print: (l) => cmd.context.stdout.write(`${l}\n`),
     printErr: (l) => cmd.context.stderr.write(`${l}\n`),
 })
 
-export class AssetsServeCommand extends Command {
-    static override paths = [['assets', 'serve']]
-
-    static override usage = Command.Usage({
-        category: 'Assets',
-        description: 'the studio — roll, curate, pick, ship (127.0.0.1, kit port)',
-        examples: [['launch the studio for the cwd kit', 'shipkit assets serve']],
-    })
-
-    async execute(): Promise<number> {
-        return runAssetsServe(process.cwd(), ioOf(this))
-    }
-}
+// the studio UI has no standalone server command — it rides the hub page
+// (`shipkit serve`, the repo's ONE Bun.serve)
 
 export class AssetsFillCommand extends Command {
     static override paths = [['assets', 'fill']]

package/src/cli/cmd_Check.ts

@@ -1,27 +1,45 @@
-// shipkit check — periodic health, TTL-cached. Thin clipanion surface;
-// logic in core/run-check.ts.
+// shipkit check — periodic health, TTL-cached; `--fix` applies rule
+// autofixes then re-lints. Thin clipanion surface; logic in
+// core/run-check.ts and rules/run-fix.ts. ci NEVER fixes.
 import { Command, Option } from 'clipanion'
 import { runCheck } from '../core/run-check.ts'
+import { runFix } from '../rules/run-fix.ts'
 
 export class CheckCommand extends Command {
     static override paths = [['check']]
 
     static override usage = Command.Usage({
         category: 'Health',
-        description: 'periodic health: contracts + every *.check.ts in the repo (auto-discovered, run as subprocesses), clean passes replay from a TTL cache',
+        description: 'periodic health: SK rules + every *.check.ts in the repo (auto-discovered, run as subprocesses), clean passes replay from a TTL cache; --fix applies rule autofixes',
         examples: [
             ['run (cached where valid)', 'shipkit check'],
             ['bust every cache layer', 'shipkit check --fresh'],
+            ['apply every rule autofix, re-lint', 'shipkit check --fix'],
+            ['fix one rule', 'shipkit check --fix SK004'],
+            ['report-only: self-maintaining rules never write', 'shipkit check --frozen'],
             ['machine-readable', 'shipkit check --json'],
         ],
     })
 
     json = Option.Boolean('--json', false, { description: 'machine-readable result instead of wire lines' })
     fresh = Option.Boolean('--fresh', false, { description: 'bust every TTL cache layer (travels to child checks)' })
+    fix = Option.Boolean('--fix', false, { description: 'apply rule autofixes (all fixable rules, or only the listed SK ids), then re-lint' })
+    frozen = Option.Boolean('--frozen', false, { description: 'report-only mode for self-maintaining rules (SK005 never touches package.json)' })
+    fixIds = Option.Rest()
 
     async execute(): Promise<number> {
         try {
-            return await runCheck(process.cwd(), { json: this.json, fresh: this.fresh, print: (l) => this.context.stdout.write(`${l}\n`) })
+            if (this.fixIds.length > 0 && !this.fix) {
+                this.context.stderr.write(`FAIL: rule ids need --fix (shipkit check --fix ${this.fixIds.join(' ')})\n`)
+                return 2
+            }
+            if (this.fix && this.json) {
+                this.context.stderr.write('FAIL: --fix has no --json shape — run the fix, then `shipkit check --json` for state\n')
+                return 2
+            }
+            if (this.fix)
+                return await runFix(process.cwd(), { ids: this.fixIds, print: (l) => this.context.stdout.write(`${l}\n`) })
+            return await runCheck(process.cwd(), { json: this.json, fresh: this.fresh, frozen: this.frozen, print: (l) => this.context.stdout.write(`${l}\n`) })
         } catch (e) {
             this.context.stderr.write(`FAIL: ${e instanceof Error ? e.message : String(e)}\n`)
             return 1

package/src/cli/cmd_Needs.ts

@@ -0,0 +1,47 @@
+// shipkit needs — the needs feed as a CLI: everything blocked on a human,
+// red/yellow, grouped by collection. REPORT-ONLY: exit 0 always — `check`
+// and `ci` stay the gates. Thin clipanion surface; logic in collections/.
+import { Command, Option } from 'clipanion'
+import { loadKit } from '../assets/kit-config.ts'
+import { projectNeeds } from '../collections/collection-types.ts'
+import { buildCollections } from '../collections/providers.ts'
+import { loadRepoConfig } from '../repo-config.ts'
+
+export class NeedsCommand extends Command {
+    static override paths = [['needs']]
+
+    static override usage = Command.Usage({
+        category: 'Health',
+        description: 'everything blocked on a human, red/yellow by collection — report-only, exit 0 always (check/ci are the gates)',
+        examples: [
+            ['what needs me', 'shipkit needs'],
+            ['machine-readable (agents, drills, cross-repo rollups)', 'shipkit needs --json'],
+        ],
+    })
+
+    json = Option.Boolean('--json', false, { description: 'emit NeedItem[] JSON' })
+
+    async execute(): Promise<number> {
+        const root = process.cwd()
+        const c = await loadRepoConfig(root)
+        const kit = await loadKit(root).catch(() => null)
+        const needs = await projectNeeds(buildCollections(root, c, kit))
+        if (this.json) {
+            this.context.stdout.write(`${JSON.stringify(needs, null, 2)}\n`)
+            return 0
+        }
+        if (needs.length === 0) {
+            this.context.stdout.write('ok: nothing needs you\n')
+            return 0
+        }
+        for (const n of needs) {
+            const line = `${n.severity === 'red' ? 'red:   ' : 'yellow:'} [${n.collection}] ${n.text}`
+            this.context.stdout.write(`${line}\n`)
+            if (n.artifact?.copy != null) this.context.stdout.write(`        paste: ${n.artifact.copy}\n`)
+            if (n.artifact?.url != null) this.context.stdout.write(`        mint:  ${n.artifact.url}\n`)
+        }
+        const reds = needs.filter((n) => n.severity === 'red').length
+        this.context.stdout.write(`${reds} red · ${needs.length - reds} yellow\n`)
+        return 0
+    }
+}