@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/pipeline/pipeline.js

@@ -0,0 +1,929 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { BAR_DEFAULT, fixList, fixSummary, STRETCH_DEFAULT } from "../direct/round.js";
+import { roomsGate, specHash } from "../spec/rooms.js";
+import { firstLookSet, missingLines, SET_RUN } from "../firstlook/set.js";
+import { worthGate, PROTOTYPE_STAGE } from "../gdd/worth.js";
+import { chaptersGate } from "../gdd/chapters.js";
+import { readKeep } from "../playtest/keep.js";
+import { readsUnchanged, sceneReads } from "../verify/reads.js";
+export const PIPELINE_FILE = join('design', 'pipeline.json');
+const T = 'npx @funpixel/tools';
+export const ACCURACY_DEFAULT = BAR_DEFAULT;
+export const PANEL_DEFAULT = 7.3;
+export const CATALOGUE = {
+    pitch: {
+        title: 'Invent and pitch',
+        why: 'a game whose answers are generic loses to one that invented something (an A/B, 3 of 3 seats)',
+        gates: [{ kind: 'gdd', headings: ['The invention'] }, { kind: 'studio' }, { kind: 'worth' }],
+        rules: [
+            'Answer the six forcing questions for THIS game in the GDD\'s `## The invention`: what the core object means, why the verb exists in this world, who wants what (names), what the twist costs, the one system that lives, what only this game has. A generic answer means the idea is not there yet.',
+            'A hit per axis (mechanic, feel, touch controls, layout, satisfaction, readability, market) with what you take, what you avoid and a source.',
+            `Pitch the choices as cards (\`${T} pitch\`): genre and fidelity, depth, the core that burns, story standard, extras with their cost.`,
+            'Scaffold after the GDD names the genre and the controls, not before.',
+            `Worth building at this length? Challenge the owner with numbers before the rest of the first look's art (the opening's key art and hero sheet come first, and the first playable; this read follows what the owner played): \`## The numbers\` say how long one flight/run/level lasts and how many there are, \`## Content list\` counts the places, verbs, characters and meta, and \`## Worth against the genre\` holds 3–5 of the genre's best (length, places, verbs, characters, progression; every number with a source URL or "approx, from memory"). \`${T} greenlight worth\` computes the minutes the plan supplies against the owner's target and gives one verdict: fits, stretch (what to add), does not carry (shrink, reshape or drop) or prove the core first. Recommend dropping a weak idea when the numbers say so.`,
+        ],
+    },
+    'key-look': {
+        title: 'First look: the key art and the hero',
+        why: 'the owner steers a picture before a model, a sound or code is paid for; the first playable is built from it and judged against it',
+        gates: [{ kind: 'refs', min: 1 }, { kind: 'targets', min: 1 }, { kind: 'owner' }],
+        rules: [
+            'From the confirmed brief, two pictures only: the key art (the game\'s look in its own light, at the play framing: desktop 1280x720, phone held sideways 852x393, named as a target) and the hero\'s reference sheet (ref-*.png, the one the model is made from).',
+            `Show both in the chat and take the owner's words ("warmer", "darker", "yes") before any model, sound or code is paid for; the stage ends on their yes (\`${T} note verdict key-look accept "<their words>"\`), a "not this" redraws.`,
+            `A look drawn in code (budget 0, or the owner's code-drawn choice): both pictures are composed from the game's own draw module on design/first-look/draw.html and rendered to PNG (\`${T} firstlook render\`; skill funpixel-gdd, references/first-look.md, "Drawn in code"), never a capture of play.`,
+            'The rest of the first look (screens, HUD, places, the living world, animation) grows later, while the game is planned around the first playable.',
+        ],
+    },
+    [PROTOTYPE_STAGE]: {
+        title: 'A first playable that already looks like the game',
+        why: 'the owner plays something real and nice before the whole game is planned, and says whether it has potential (owner, 5 Oct: "plan the first look, develop, then iterate if we see potential")',
+        gates: [{ kind: 'verify' }, { kind: 'world' }, { kind: 'owner' }],
+        rules: [
+            'Sized by the game: a short game (small) about 1 minute, mostly the place: its look, light, sound and the verb once; a mid game 2 to 3 minutes; a long game (deep) 3 to 5 minutes: the core loop once through, a win and a loss.',
+            'Short in CONTENT, never bare in LOOK: built in the game itself (the starter, its framework and real camera; a 3D game in 3D) with real assets made from the key art and the hero sheet: the hero (rigged and moving where it moves), the sky and the place in the key art\'s light, the title art, a music loop and the verb\'s sounds. No stand-in shapes where a planned piece belongs.',
+            `Judge it before the owner sees it: the key art is its target (\`${T} score --target\`), \`${T} check --front-door\`, and a blind player on a long game (\`${T} play --viewport phone\`).`,
+            `Show it in the chat with captures and the preview link. The owner plays it and says whether it has potential: \`${T} note verdict ${PROTOTYPE_STAGE} accept "<their words>"\` plans the whole game around it; their "not this" changes direction (a new key art) or drops the idea.`,
+        ],
+    },
+    lock: {
+        title: 'Pick and lock the core',
+        why: 'effort, art budget and checks concentrate on what was picked; the rest stays light',
+        gates: [{ kind: 'pitch-locked' }],
+        rules: [
+            `The owner picks: \`${T} pitch ask\` puts each choice to the owner in the chat (taste, spend, scope) with your proposal; \`${T} pitch lock\` locks once every choice has their answer (only the owner's own autonomy "go" lets your proposals lock). Autonomy is the owner's setting, never a card.`,
+            'Go hard on the locked core; what was not picked stays light or out.',
+            `Under autonomy "go", record each pick with its reason (\`${T} decide\`).`,
+        ],
+    },
+    gdd: {
+        title: 'The GDD core',
+        why: 'a short core the creator owns beats a long template filled in',
+        gates: [{ kind: 'gdd', headings: ['Core loop', 'The numbers', 'The hook'] }, { kind: 'gdd', min: 3 }],
+        rules: [
+            'The core is short and the creator\'s: pitch, invention, core loop, the numbers (each with why exactly that value), the hook, behaviour tests named before code.',
+            'Every attack tells 0.6 s or more; teach once, at the element; a camera that never fights the player.',
+            'Bodies in a world: one scale sheet in metres (a person 1.75 m), every asset sized from it.',
+            'Grow a section when the tier or the game calls for it, never to fill the template.',
+        ],
+    },
+    'first-look': {
+        title: 'First look',
+        why: 'identity drifts between frames unless it is locked first (one game: 7 of 7 redraws on-model with reference sheets)',
+        gates: [{ kind: 'refs', min: 1 }, { kind: 'targets', min: 4 }, { kind: 'kit' }, { kind: 'set' }],
+        rules: [
+            `The whole game, not a few frames (owner, 4 Oct, asked twice): key art; every screen (the title as the play world, pause, the end; past small settings, results, a level select); the HUD on the phone and the desktop; a frame per place, each tied to a story beat; a living-world sheet; an animation board; a juice board; the sound list; the fun page. \`${T} firstlook\` lists what is missing; places and the living world only for a world game.`,
+            'Reference sheets (identity lock) BEFORE moment frames; every recurring design drawn with its references and one verbatim style block.',
+            'A target frame per hook moment at the play framing (desktop 1280x720, phone held sideways 852x393).',
+            `The world's kit beside the hero: sheets of its made parts (structures, ground, props, the living cast), cut into pieces before the slice (\`${T} cut\`); the slice is built from them, never from plain shapes (a fresh build shipped code-drawn primitives until the owner's note).`,
+            'A picture of every place; no two places alike in shape, material, era and light.',
+            'The HUD mockup drawn over a target frame.',
+        ],
+    },
+    'core-test': {
+        title: 'Core test (A1): the game bites',
+        why: 'both builds of one game spent their rounds on looks and the challenge never bit ("no challenges at all")',
+        gates: [{ kind: 'tests' }, { kind: 'sim' }],
+        rules: [
+            `The GDD's named bots play the REAL level (\`${T} sim\`): an engine-free, fixed-step, seeded sim, plus a replay test.`,
+            'The naive steer-to-goal bot must be able to lose; a run nobody can lose is no game yet.',
+            'A sharp bot that stalls is a broken bot, not a design note: fix the bot before reading the curve.',
+            `Named behaviour tests green on the current files (\`${T} test\`).`,
+            'Resolve each curve warning, or accept it by id in design/pipeline.json with the reason in the GDD.',
+        ],
+    },
+    slice: {
+        title: 'A playable slice',
+        why: 'one place in real art and sound, a win and a loss, through the real controls, in a world that reads as made and alive (judged, not claimed)',
+        gates: [{ kind: 'verify' }, { kind: 'world' }],
+        rules: [
+            `\`${T} check --front-door\` (build, tests, verify, and the world: boxes, grounding, life) — or \`npm run build\`, \`${T} verify --front-door\`, then \`${T} check --world\`; exit 2 measured nothing, which is not a pass.`,
+            'Never a dead end: a disabled control says why and leads to the fix; pressing it opens the missing step.',
+            'Touch controls only for touch input (last input wins).',
+            'A living world as it is built: each person animates, walks a task loop through space, idles and answers the player; a crowd is a few focused scenes along the path (fewer people, each readable), never the hero\'s face; creatures have gaits matched to ground speed, flyers flap; a painted cut-out animates too (frames by distance, a bent plane, a hinge), never a picture slid or bobbed; feet on the ground, never inside a prop (skill funpixel-world-and-story, references/living-world.md; expose them in __FPX_ACTORS__).',
+            `A made world as it is built: camera-near geometry is the most detailed, never the plainest; every structure the player passes reads as made (shape detail + textures or decals in the palette), matched to the best-painted asset; landed vehicles and big props rest on the ground (\`${T} boxes\`).`,
+            'Name every stand-in (state.art.placeholders) and in the hand-back.',
+        ],
+    },
+    chapters: {
+        title: 'Chapter by chapter',
+        why: 'a long game is built in segments, as studios build theirs after the vertical slice: each chapter planned, made to its own target frames and agreed before the next, so the plan and the asks grow only as far as the game does',
+        gates: [{ kind: 'chapters' }],
+        rules: [
+            'One chapter at a time, in the order of the GDD\'s ## Chapters: plan it with the owner in the chat (its place, what it adds, its story beat, its length), make its target frames first, then build it with its assets and the look-dev loop until each target is close.',
+            `Show it in the chat; the owner plays it and says yes (\`${T} note verdict chapter:<id> accept "<their words>"\`), then the next opens. Their "not yet" is the next round on that chapter.`,
+            'A chapter extends the game, never redesigns the slice; its levels can be data in design/spec/rooms.json like any room.',
+        ],
+    },
+    expand: {
+        title: 'Expand, room by room',
+        why: 'our real games are 10 to 18 minutes of designed play, grown room by room from a slice that passed (one plan: "nothing in Rooms 2-6 starts until the slice passes its gates")',
+        gates: [{ kind: 'rooms' }],
+        rules: [
+            `Slice first: a room is opened for building only once the room before it passes (\`${T} rooms open <id>\`); the owner alone releases one early (\`--by owner\`).`,
+            `Each room is data in design/spec/rooms.json (par, exit, what it teaches, its numbers), never hand-placed in code; \`${T} rooms\` plays every room with bots over 5 seeds and times each against its par.`,
+            'A par is the seconds a good first run takes; the pars add up to the play floor (15 minutes for a complete game). A room far off its par is a guess: fix the room or the par.',
+            `Every number a room changes is a tunable (design/spec/tunables.json); \`${T} spec lint\` names a number typed into the code, an id nothing reads, a room without a par or an exit.`,
+        ],
+    },
+    hook: {
+        title: 'The hook: the first minutes',
+        why: 'the title and the first minutes decide whether people keep playing',
+        gates: [{ kind: 'hook' }, { kind: 'life' }],
+        rules: [
+            `Read the title, the real Play and the first minutes (\`${T} hook\`): 2 to 4 wow moments on the clock.`,
+            'A loading screen or a staged capture is not a moment: measure from the real Play.',
+            `Something alive in every play view: people on task loops that move them through space, idles, reactions to the player, creatures with gaits, flyers that flap; motion without animation slides like a stone, a crowd that only animates in place reads as a still (\`${T} life\`).`,
+            'Collisions solid, nothing floating, one scale.',
+        ],
+    },
+    accuracy: {
+        title: 'Accuracy to the targets',
+        why: 'the owner\'s bar: every moment at 75+ beside its target (90 the stretch), built toward the target round by round',
+        gates: [{ kind: 'score' }],
+        rules: [
+            `Score each moment against its target at the same framing (\`${T} score --target\`, 0 to 100): composition, hero size and pose, identity, palette and light, density, life.`,
+            `The bar is funpixel.json \`accuracy_min\` (${ACCURACY_DEFAULT} by default, \`accuracy_stretch\` ${STRETCH_DEFAULT} the stretch); below it the moment goes back with its fix list.`,
+            `Each round works down the fix list the score printed (\`${T} score --fixes\`: the camera, the light, the colours, the dressing as numbers), then re-shoots at the same framing; three rounds without a gain ask the owner about scope.`,
+        ],
+    },
+    walk: {
+        title: 'World walk',
+        why: 'world building is verified by playing, not by stills ("lots of misplaces, collisions, static people")',
+        gates: [{ kind: 'walk' }, { kind: 'sim' }],
+        rules: [
+            `Walk every route from the title as a player, no teleports, filmed from the play camera (\`${T} walk\`).`,
+            'Along the way: no clipping, nothing floating (people or the landed ship), one scale, no blocked path unless planned, every person and creature animated and the people moving through space, a few focused scenes with no clumps or empty stretches, no crowd wearing the hero\'s face, no flat boxes near the camera, the challenge visible and a run that can be lost, then retried.',
+            `A prologue and the first run are one walk: \`then\` on the route (or \`${T} walk --chain prologue,run01\`), one film from the title.`,
+            'A still is not evidence that a world is built; a walk is.',
+        ],
+    },
+    'blind-play': {
+        title: 'Blind play from the title',
+        why: 'blind players from the title found the blockers no panel could',
+        gates: [{ kind: 'play' }, { kind: 'sim' }],
+        rules: [
+            `A blind player from the title, no instructions (\`${T} play\`): a stall counts as blocking.`,
+            'A play round counts only when the challenge is proven on the same files: sim fresh, the naive bot can lose.',
+            'Read the mid-hold frames for hold verbs.',
+            'The owner\'s own phone play is the last word; keep their screenshots as named before-frames.',
+        ],
+    },
+    panel: {
+        title: 'The panel',
+        why: 'blind seats on fresh captures; read the flaw list, not the score',
+        gates: [{ kind: 'panel' }],
+        rules: [
+            `\`${T} playtest\`: fresh captures, blind seats; a passing panel is a floor, not proof of fun.`,
+            'Work down the blockers ledger before polishing anything else.',
+        ],
+    },
+    publish: {
+        title: 'Publish',
+        why: 'the person plays it and says yes',
+        gates: [{ kind: 'verify' }, { kind: 'owner' }, { kind: 'published' }],
+        rules: [
+            `\`${T} pack --dry-run\` clean and verify passing on the files that ship, then \`${T} publish\`.`,
+            'Finish when the person plays it and says yes; green means stop.',
+        ],
+    },
+};
+export const TIER_STAGES = {
+    small: ['pitch', 'gdd', 'first-look', 'core-test', 'slice', 'hook', 'blind-play', 'publish'],
+    mid: ['pitch', 'lock', 'gdd', 'first-look', 'core-test', 'slice', 'expand', 'hook', 'accuracy', 'blind-play', 'panel', 'publish'],
+    deep: ['pitch', 'lock', 'gdd', 'first-look', 'core-test', 'slice', 'expand', 'chapters', 'hook', 'accuracy', 'walk', 'blind-play', 'panel', 'publish'],
+};
+export const TIER_NAME = { small: 'nugget (a few minutes)', mid: 'short (15 to 30 minutes)', deep: 'long (an hour or more, chapter by chapter)' };
+export const OPENING_STAGES = ['key-look', PROTOTYPE_STAGE];
+export const SESSION_RULE = 'Never end the session while a background job, subagent or recording runs: a session that ends does not come back. Do the work in the session and wait for it.';
+export function defaultPipeline(tier, now = new Date(), by = 'funtools init', opts = {}) {
+    const stages = [...(opts.opening ? OPENING_STAGES : []), ...TIER_STAGES[tier]].map((id) => {
+        const c = CATALOGUE[id];
+        const gates = id === 'first-look' && tier === 'small' ? [{ kind: 'targets', min: 2 }, ...(opts.world ? [{ kind: 'kit' }] : []), { kind: 'set' }]
+            : id === 'publish' && tier === 'small' ? c.gates.filter((g) => g.kind !== 'owner')
+                : id === 'gdd' && tier !== 'small' ? [...c.gates, { kind: 'spec' }] : c.gates;
+        return { id, title: c.title, gates: gates.map((g) => ({ ...g })), status: 'open' };
+    });
+    return { version: 1, tier, written_by: by, at: now.toISOString(), stages, notes: [] };
+}
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return null;
+} };
+export function readPipeline(root) {
+    const p = readJson(join(root, PIPELINE_FILE));
+    if (!p || !Array.isArray(p.stages))
+        return null;
+    const out = { version: 1, tier: ['small', 'mid', 'deep'].includes(p.tier) ? p.tier : 'small', written_by: String(p.written_by ?? ''), at: String(p.at ?? ''), stages: p.stages.filter((s) => s && typeof s.id === 'string' && Array.isArray(s.gates)), notes: Array.isArray(p.notes) ? p.notes : [], ...(Array.isArray(p.verdicts) ? { verdicts: p.verdicts } : {}), ...(p.dropped?.by === 'owner' ? { dropped: p.dropped } : {}) };
+    return withAccuracy(root, withKeyLookOwner(withFreshOwnerPlan(root, out)));
+}
+export function withKeyLookOwner(p) {
+    const st = p.stages.find((s) => s.id === 'key-look');
+    if (!st || st.status === 'done' || st.status === 'skipped' || st.gates.some((g) => g.kind === 'owner'))
+        return p;
+    return { ...p, stages: p.stages.map((s) => (s === st ? { ...s, gates: [...s.gates, { kind: 'owner' }] } : s)) };
+}
+export function withAccuracy(root, p) {
+    const owed = p.stages.some((s) => s.status !== 'skipped' && s.status !== 'done' && s.gates.some((g) => g.kind === 'targets'));
+    if (p.tier !== 'small' || p.stages.some((s) => s.id === 'accuracy') || !(owed || pictures(root).targets.length))
+        return p;
+    const c = CATALOGUE.accuracy;
+    const stage = { id: 'accuracy', title: c.title, gates: c.gates.map((g) => ({ ...g })), status: 'open' };
+    const at = (id) => p.stages.findIndex((s) => s.id === id);
+    const after = at('hook') >= 0 ? at('hook') + 1 : at('slice') >= 0 ? at('slice') + 1 : at('blind-play') >= 0 ? at('blind-play') : p.stages.length;
+    return { ...p, stages: [...p.stages.slice(0, after), stage, ...p.stages.slice(after)] };
+}
+const DESIGN_DOCS = [join('design', 'GDD.md'), join('design', 'README.md'), join('design', 'plan.md')];
+function gddText(root) {
+    const found = [];
+    for (const rel of DESIGN_DOCS) {
+        try {
+            found.push({ text: readFileSync(join(root, rel), 'utf8'), rel });
+        }
+        catch { }
+    }
+    if (!found.length)
+        return null;
+    return { text: found.map((f) => f.text).join('\n\n'), rel: found.map((f) => f.rel).join(' + ') };
+}
+function sectionLike(text, heading, min) {
+    for (const m of text.matchAll(/^(#{1,4})\s+(.+)$/gm)) {
+        if (!heading.test(m[2]))
+            continue;
+        const body = sectionBody(text, m[2].trim().replace(/\s+/g, ' ').slice(0, 60)) ?? '';
+        const words = saysWords(body);
+        if (words >= min)
+            return { heading: m[2].trim(), words };
+    }
+    return null;
+}
+function sourceFiles(root) {
+    let n = 0;
+    const walk = (dir, depth) => {
+        if (depth > 4 || n > 200)
+            return;
+        let names = [];
+        try {
+            names = readdirSync(join(root, dir));
+        }
+        catch {
+            return;
+        }
+        for (const f of names) {
+            if (/\.(ts|tsx|js|jsx)$/.test(f))
+                n++;
+            else if (!f.includes('.') && f !== 'node_modules')
+                walk(join(dir, f), depth + 1);
+        }
+    };
+    walk('src', 0);
+    return n;
+}
+export function existingEvidence(root) {
+    const out = {};
+    const doc = gddText(root);
+    const m = readJson(join(root, 'funpixel.json')) ?? {};
+    const files = sourceFiles(root);
+    const building = existsSync(join(root, 'verify.json')) || files >= 8;
+    const pitch = doc ? sectionLike(doc.text, PITCH_HEADING, 30) : null;
+    if (pitch)
+        out.pitch = `${doc.rel} has the pitch (## ${pitch.heading}, ${pitch.words} words)`;
+    else if (doc && building && saysWords(doc.text) >= 400)
+        out.pitch = `${doc.rel} (${saysWords(doc.text)} words) is the plan this game is built from`;
+    if (m.studio?.locked)
+        out.lock = 'funpixel.json studio is locked';
+    else if (out.pitch && building)
+        out.lock = `the plan is already being built (${files} source files${existsSync(join(root, 'verify.json')) ? ', verify.json' : ''})`;
+    if (doc && building) {
+        const core = CORE_HEADINGS.filter((h) => sectionLike(doc.text, new RegExp(h, 'i'), 8));
+        if (core.length >= 2)
+            out.gdd = `${doc.rel} covers the core (${core.length} of 4: loop, controls, numbers, hook) and the game is being built`;
+    }
+    return { ...ownerPlan(root), ...out };
+}
+export const PLANNING_STAGES = new Set(['pitch', 'lock', 'gdd']);
+const DESIGN_WORK_STAGES = new Set([...PLANNING_STAGES, 'key-look', 'first-look']);
+const SIGN_OFF = /\b(signed[- ]off|approved|green-?lit|agreed|locked)\s+(?:by|with)\s+the\s+owner\b/gi;
+const NOT_YET = /\b(?:not|never|no|nor|yet to be|awaits?|awaiting|waits?|waiting|until|before|once|when|if|unless|pending|needs? to be|to be)\b[^.;·\n]{0,30}$/i;
+export function ownerSignOff(head) {
+    for (const m of head.matchAll(SIGN_OFF))
+        if (!NOT_YET.test(head.slice(Math.max(0, m.index - 40), m.index)))
+            return m[0];
+    return null;
+}
+const HEAD_LINE = /^#\s|\b(?:stage|status|state|version)\b[*_ ]*:|sign|approv|green|agreed|locked/i;
+export function planSig(root) {
+    const h = createHash('sha256');
+    for (const rel of DESIGN_DOCS) {
+        let text = '';
+        try {
+            text = readFileSync(join(root, rel), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        h.update(`${rel}\n`);
+        for (const l of text.slice(0, 4000).split('\n'))
+            if (HEAD_LINE.test(l))
+                h.update(`${l.trim()}\n`);
+    }
+    return h.digest('hex').slice(0, 16);
+}
+const FROM_OWNER_PLAN = /^the owner's plan /;
+export function withFreshOwnerPlan(root, p) {
+    const from = p.stages.filter((st) => st.status === 'done' && FROM_OWNER_PLAN.test(st.found ?? ''));
+    if (!from.length)
+        return p;
+    const sig = planSig(root);
+    if (from.every((st) => st.found_sig === sig))
+        return p;
+    const now = ownerPlan(root);
+    return { ...p, stages: p.stages.map((st) => {
+            if (!from.includes(st))
+                return st;
+            if (now[st.id])
+                return { ...st, found: now[st.id], found_sig: sig };
+            const { found, found_sig: _sig, done_at: _done, ...rest } = st;
+            return { ...rest, status: 'open', reopened: `${st.title} was read as done from "${found}"; the design's head no longer says the owner signed it off, so it is open again (their yes: \`${T} flow agree --by owner\`)` };
+        }) };
+}
+const PITCH_HEADING = /pitch|invention|premise|concept|log ?line|the game|overview|elevator|one line|what it is|promise/i;
+const CORE_HEADINGS = ['core loop|gameplay|mechanics?|the loop', 'controls?|input', 'numbers|tuning|balance|values', 'hook|first minutes?|opening|journey'];
+export function ownerPlan(root) {
+    for (const rel of DESIGN_DOCS) {
+        let text = '';
+        try {
+            text = readFileSync(join(root, rel), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const head = text.slice(0, 4000);
+        const agreed = ownerSignOff(head);
+        if (!rel.endsWith('plan.md') && (!agreed || /\(starter default\)/.test(text)))
+            continue;
+        const words = saysWords(text);
+        if (words < 400)
+            continue;
+        const out = {};
+        const said = sectionLike(text, PITCH_HEADING, 30);
+        const bold = /^\*\*(pitch|the pitch|premise|log ?line|promise)[^*]*:\*\*\s*(.+)$/im.exec(head);
+        const pitch = said ? `## ${said.heading}` : bold && saysWords(bold[2]) >= 12 ? `**${bold[1]}:**` : null;
+        if (pitch)
+            out.pitch = `the owner's plan ${rel} (${words} words) has the pitch (${pitch})`;
+        const m = readJson(join(root, 'funpixel.json')) ?? {};
+        if (agreed || m.studio?.locked)
+            out.lock = `the owner's plan ${rel} is agreed (${agreed ? `"${agreed}"` : 'funpixel.json studio locked'})`;
+        const core = CORE_HEADINGS.filter((h) => sectionLike(text, new RegExp(h, 'i'), 8));
+        if (core.length >= 2)
+            out.gdd = `the owner's plan ${rel} covers the core (${core.length} of 4: loop, controls, numbers, hook)`;
+        return out;
+    }
+    return {};
+}
+export function adoptExisting(p, found, now = new Date(), sig) {
+    const marked = [];
+    for (const st of p.stages) {
+        const why = found[st.id];
+        if (!why || st.status === 'done' || st.status === 'skipped')
+            continue;
+        st.status = 'done';
+        st.found = why;
+        st.done_at = now.toISOString();
+        if (sig && FROM_OWNER_PLAN.test(why))
+            st.found_sig = sig;
+        marked.push(st.id);
+    }
+    return marked;
+}
+const NUMBERED = '(?:\\d{1,3}\\s*[.):·–-]?\\s*[·–-]?\\s*|(?:[IVX]{1,5}|[A-Z])\\s*[.):·–-]\\s*)?';
+export function sectionBody(text, heading) {
+    const lines = text.split('\n');
+    const at = lines.findIndex((l) => new RegExp(`^##+\\s+${NUMBERED}${heading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i').test(l.trim()));
+    if (at < 0)
+        return null;
+    const level = /^(#+)/.exec(lines[at].trim())[1].length;
+    const end = lines.findIndex((l, i) => i > at && /^(#+)\s/.test(l.trim()) && /^(#+)/.exec(l.trim())[1].length <= level);
+    return lines.slice(at + 1, end < 0 ? lines.length : end).join('\n');
+}
+export function saysWords(body) {
+    const clean = body.replace(/<[^>\n]*>/g, ' ').replace(/^\s*\|?[\s:|-]+\|?\s*$/gm, ' ').replace(/[`*_|…]/g, ' ')
+        .replace(/^[\s-]*[A-Z][\w ,'()]*:\s*$/gm, ' ');
+    return (clean.match(/[A-Za-z]{3,}/g) ?? []).length;
+}
+export function namedTests(text) {
+    const body = sectionBody(text, 'Behaviour tests');
+    if (!body)
+        return [];
+    return [...body.matchAll(/^\s*[-*]\s+`([^`<>]{6,})`/gm)].map((m) => m[1].trim());
+}
+function pictures(root) {
+    const out = { refs: [], targets: [] };
+    for (const rel of [join('design', 'first-look'), join('design', 'look', 'targets'), join('design', 'targets')]) {
+        let names = [];
+        try {
+            names = readdirSync(join(root, rel));
+        }
+        catch {
+            continue;
+        }
+        for (const n of names) {
+            if (!/\.(png|jpe?g|webp)$/i.test(n))
+                continue;
+            (/^ref[-_]/i.test(n) ? out.refs : out.targets).push(join(rel, n));
+        }
+    }
+    return out;
+}
+export function ownerGates(root) {
+    const m = readJson(join(root, 'funpixel.json')) ?? {};
+    const og = m.owner_gates && typeof m.owner_gates === 'object' ? m.owner_gates : {};
+    const acc = typeof og.accuracy_min === 'number' ? og.accuracy_min : typeof m.accuracy_min === 'number' ? m.accuracy_min : null;
+    const panel = typeof og.panel_min === 'number' && og.panel_min >= 0 && og.panel_min <= 10 ? og.panel_min : null;
+    return { accuracy_min: acc, evidence: og.evidence === true || og.round_needs_evidence === true, panel_min: panel };
+}
+function latestPlay(root) {
+    let names = [];
+    try {
+        names = readdirSync(join(root, '.funtools', 'play'));
+    }
+    catch {
+        return null;
+    }
+    const rounds = names.map((n) => /^round-(\d+)$/.exec(n)).filter((m) => !!m).map((m) => Number(m[1])).sort((a, b) => b - a);
+    for (const n of rounds) {
+        const rel = join('.funtools', 'play', `round-${n}`, 'report.json');
+        const r = readJson(join(root, rel));
+        if (r)
+            return { rel, r };
+    }
+    return null;
+}
+export function momentScores(raw) {
+    if (!raw)
+        return [];
+    const list = Array.isArray(raw) ? raw : Array.isArray(raw.moments) ? raw.moments : Array.isArray(raw.scores) ? raw.scores : null;
+    if (list) {
+        return list.map((m) => ({ moment: String(m.moment ?? m.name ?? m.view ?? '?'), score: Number(m.score ?? m.total ?? m.accuracy) })).filter((m) => Number.isFinite(m.score));
+    }
+    const map = raw.scores && typeof raw.scores === 'object' ? raw.scores : raw;
+    return Object.entries(map).map(([moment, v]) => ({ moment, score: Number(typeof v === 'object' && v ? v.score ?? v.total : v) })).filter((m) => Number.isFinite(m.score));
+}
+const warnsOf = (r) => (Array.isArray(r?.findings) ? r.findings : [])
+    .filter((f) => f && (f.level === 'warn' || f.level === 'fail' || f.state === 'warn' || f.state === 'fail'))
+    .map((f) => String(f.text ?? f.says ?? f.id ?? 'a warning'));
+const short = (t, n = 110) => (t.length > n ? `${t.slice(0, n - 1)}…` : t);
+const notesSaid = (kind, w) => `${kind} holds on the current files; ${w.length} note(s), not a gate until the owner's agreed plan lists the world: ${w.slice(0, 2).map((x) => short(x, 90)).join('; ')}`;
+export const KIT_KINDS = [
+    ['structures', /struct|build|house|hut|home|shack|machine|ship|vehicle|tower|ruin|env|place|landmark|architect|bridge|dock|station/i],
+    ['ground', /ground|terrain|tile|floor|path|road|crust|grass|sand|soil|rock/i],
+    ['props', /prop|item|object|crate|furniture|debris|clutter|barrel|kit/i],
+    ['living cast', /fauna|flora|creature|animal|crowd|npc|folk|people|cast|bird|beast|critter|townsfolk|villager/i],
+];
+export function worldKit(root) {
+    const out = Object.fromEntries(KIT_KINDS.map(([k]) => [k, []]));
+    for (const rel of [join('design', 'first-look'), join('design', 'kit'), join('design', 'look', 'targets'), join('design', 'targets'), join('assets', 'kit')]) {
+        let names = [];
+        try {
+            names = readdirSync(join(root, rel));
+        }
+        catch {
+            continue;
+        }
+        for (const n of names) {
+            if (!/\.(png|jpe?g|webp)$/i.test(n) || /^ref[-_]/i.test(n))
+                continue;
+            const kind = KIT_KINDS.find(([, re]) => re.test(n));
+            if (kind)
+                out[kind[0]].push(join(rel, n));
+        }
+    }
+    return out;
+}
+export function isWorldGame(dir) {
+    let m = {};
+    try {
+        m = JSON.parse(readFileSync(join(dir, 'funpixel.json'), 'utf8'));
+    }
+    catch { }
+    const three = m?.metadata?.dimension === '3d' || /three/i.test(String(m?.metadata?.framework ?? ''));
+    if (three)
+        return { world: true, three };
+    const grep = (d, depth) => {
+        let names = [];
+        try {
+            names = readdirSync(join(dir, d));
+        }
+        catch {
+            return false;
+        }
+        for (const n of names) {
+            if (n === 'node_modules' || n.startsWith('.'))
+                continue;
+            const rel = join(d, n);
+            if (/\.(ts|tsx|js|jsx)$/.test(n)) {
+                try {
+                    if (readFileSync(join(dir, rel), 'utf8').includes('__FPX_ACTORS__'))
+                        return true;
+                }
+                catch { }
+            }
+            else if (!n.includes('.') && depth < 4 && grep(rel, depth + 1))
+                return true;
+        }
+        return false;
+    };
+    return { world: grep('src', 0), three };
+}
+const WORLD_RECORDS = { walk: join('.funtools', 'walk.json'), life: join('.funtools', 'life.json'), boxes: join('.funtools', 'boxes.json') };
+export function worldRead(root, fp) {
+    let now;
+    const fresh = (rec) => !fp || !rec?.fingerprint || rec.fingerprint === fp || (Boolean(rec?.reads) && readsUnchanged(root, rec, now ??= sceneReads(root)));
+    const m = readJson(join(root, 'funpixel.json')) ?? {};
+    const three = m.metadata?.dimension === '3d' || /three/i.test(String(m.metadata?.framework ?? ''));
+    const warnsIn = {
+        walk: (r) => (Array.isArray(r?.routes) ? r.routes : []).flatMap((x) => (Array.isArray(x?.checks) ? x.checks : []).filter((c) => c?.status === 'warn').map((c) => String(c.text))),
+        life: (r) => (Array.isArray(r?.findings) ? r.findings : []).filter((f) => f?.level === 'warn').map((f) => String(f.text)),
+        boxes: (r) => (Array.isArray(r?.views) ? r.views : []).flatMap((v) => (Array.isArray(v?.checks) ? v.checks : []).filter((c) => c?.status === 'warn').map((c) => `${v.view}: ${String(c.text)}`)),
+    };
+    const seen = [];
+    const warns = [];
+    for (const check of ['walk', 'life', 'boxes']) {
+        const rec = readJson(join(root, WORLD_RECORDS[check]));
+        if (!rec)
+            continue;
+        const isFresh = fresh(rec);
+        const w = isFresh ? [...new Set(warnsIn[check](rec))] : [];
+        seen.push({ check, fresh: isFresh, warns: w.length });
+        warns.push(...w.map((x) => `${check}: ${x}`));
+    }
+    const loud = (x) => (/: [A-Z][A-Z' -]{3,}:/.test(x) ? 0 : 1);
+    warns.sort((a, b) => loud(a) - loud(b));
+    const ok = (c) => seen.some((x) => x.check === c && x.fresh);
+    if (!seen.length)
+        return { state: 'open', says: 'the world was never judged: no walk, life or boxes record', warns, seen };
+    if (!seen.some((x) => x.fresh))
+        return { state: 'stale', says: `the world was judged on older files (${seen.map((x) => x.check).join(', ')})`, warns, seen };
+    if (warns.length)
+        return { state: 'failing', says: `${warns.length} warning(s): ${warns.slice(0, 2).map((x) => short(x, 120)).join('; ')}`, warns, seen };
+    if (ok('walk') || (ok('life') && (ok('boxes') || !three)))
+        return { state: 'met', says: `the world holds on the current files (${seen.filter((x) => x.fresh).map((x) => x.check).join(', ')})`, warns, seen };
+    const missing = ['life', ...(three ? ['boxes'] : [])].filter((c) => !ok(c));
+    return { state: 'open', says: `${seen.filter((x) => x.fresh).map((x) => x.check).join(', ')} holds; ${missing.join(' and ')} never ran on these files`, warns, seen };
+}
+export const HOLD_LABELS = ['BOXES', 'BOX FIGURES', 'CUT-OUTS THAT GLIDE', 'CUT-OUTS ON A STICK', 'HERO CLONES', 'NOTHING MOVES', 'NO HERO', 'OFF THE GROUND'];
+const HOLD_LABEL = new RegExp(`(^|: )(${HOLD_LABELS.join('|')}):`);
+const NO_HERO_LINE = /no (player|hero) node found|no hero on screen/i;
+export const isWorldFault = (line) => HOLD_LABEL.test(line) || NO_HERO_LINE.test(line);
+const WORLD_READS = new Set(['life', 'walk', 'world']);
+export function evaluateGate(root, g, fp, p, stageId, has = () => true, agreed = true) {
+    const r = (state, says, closes, run) => ({ gate: g, state, says, closes, run });
+    const fresh = (rec) => !fp || !rec?.fingerprint || rec.fingerprint === fp;
+    switch (g.kind) {
+        case 'gdd': {
+            const doc = gddText(root);
+            if (!doc)
+                return r('open', 'no design/GDD.md', g.min ? `${g.min}+ named behaviour tests in design/GDD.md` : `design/GDD.md with ${(g.headings ?? []).map((h) => `## ${h}`).join(', ')} written`, 'write it (skill funpixel-gdd, references/invent-first.md)');
+            if (g.min) {
+                const n = namedTests(doc.text).length;
+                return n >= g.min ? r('met', `${n} behaviour tests named`, '', '') : r('open', `${n} behaviour tests named in ${doc.rel}`, `${g.min}+ test names under ### Behaviour tests (rules as tests, before code)`, `name them in ${doc.rel}, then write them in test/`);
+            }
+            const thin = (g.headings ?? []).filter((h) => { const b = sectionBody(doc.text, h); return b === null || saysWords(b) < (h === 'The invention' ? 30 : 8); });
+            return thin.length ? r('open', `${doc.rel}: ${thin.map((h) => `## ${h}`).join(', ')} ${thin.length === 1 ? 'is' : 'are'} not written yet`, `${thin.map((h) => `## ${h}`).join(', ')} answered for this game`, `write ${thin.length === 1 ? 'it' : 'them'} in ${doc.rel} (skill funpixel-gdd)`) : r('met', `${(g.headings ?? []).map((h) => `## ${h}`).join(', ')} written`, '', '');
+        }
+        case 'studio':
+            return existsSync(join(root, 'design', 'studio.json')) ? r('met', 'the pitch is on the cards (design/studio.json)', '', '') : r('open', 'no studio pitch yet', 'design/studio.json with the choices proposed for this game', `${T} pitch, then ${T} pitch propose <choice> <option> --why "…"`);
+        case 'pitch-locked': {
+            const m = readJson(join(root, 'funpixel.json'));
+            return m?.studio?.locked ? r('met', 'the picks are locked (funpixel.json studio)', '', '') : r('open', 'the studio pitch is not locked', 'funpixel.json `studio` with the locked picks', `${T} pitch ask (each choice to the owner in the chat), then ${T} pitch lock once they answer (under the owner's autonomy go: propose, record why, lock)`);
+        }
+        case 'targets':
+        case 'refs': {
+            const pics = pictures(root), have = g.kind === 'refs' ? pics.refs : pics.targets, min = g.min ?? 1;
+            const what = g.kind === 'refs' ? 'reference sheet(s) named ref-*.png' : 'target frame(s)';
+            const m = readJson(join(root, 'funpixel.json')) ?? {};
+            const coded = m.art3d?.heroes === 'procedural' || m.assets?.budget?.credits === 0;
+            const route = coded ? `, drawn in code: compose them from the game's draw module on design/first-look/draw.html, then ${T} firstlook render` : '';
+            return have.length >= min ? r('met', `${have.length} ${what} in design/first-look`, '', '') : r('open', `${have.length} ${what} in design/first-look`, `${min}+ ${what} in design/first-look/`, g.kind === 'refs' ? `draw the identity lock first: one sheet per recurring design from the best draft${route} (skill funpixel-gdd, references/first-look.md)` : coded ? `draw them at the play framing, one per hook moment${route}` : `draw them at the play framing (${T} gen image, or your own route), one per hook moment`);
+        }
+        case 'tests': {
+            const rec = readJson(join(root, '.funtools', 'tests.json'));
+            if (!rec)
+                return r('open', 'the tests never ran through funtools', '.funtools/tests.json: exit 0 on the current files', `${T} test`);
+            if (!fresh(rec))
+                return r('stale', 'the tests ran on older files', '.funtools/tests.json: exit 0 on the current files', `${T} test`);
+            return rec.exit === 0 ? r('met', 'tests pass on the current files', '', '') : r('failing', `the tests exit ${rec.exit}`, '.funtools/tests.json: exit 0', `${T} test, and fix what fails`);
+        }
+        case 'sim': {
+            const rec = readJson(join(root, '.funtools', 'sim.json'));
+            const closes = '.funtools/sim.json on the current files: the naive bot loses at least one run (a run that ENDS failed, not a penalty), a careful player at a human pace wins some, no "a run cannot be lost", no broken bot, every warning resolved or accepted by id';
+            if (!rec)
+                return r('open', 'the bots never played the rules', closes, existsSync(join(root, 'test', 'probes.ts')) ? `${T} sim` : `write test/probes.ts with the GDD's bots on the real level, then ${T} sim (skill funpixel-game-logic, references/probes.md)`);
+            if (!fresh(rec))
+                return r('stale', 'sim ran on older files', closes, `${T} sim`);
+            const accepted = new Set(g.accept ?? []);
+            const cohorts = Array.isArray(rec.cohorts) ? rec.cohorts : [];
+            const naive = cohorts.find((c) => c.role === 'naive');
+            const problems = [];
+            for (const f of Array.isArray(rec.findings) ? rec.findings : [])
+                if (f.state === 'warn' && !accepted.has(f.id))
+                    problems.push(short(String(f.says)));
+            if (!naive)
+                problems.push('no naive bot played (a steer-to-goal policy with role "naive")');
+            else if (!(naive.lost > 0) && !accepted.has('losable'))
+                problems.push(`the naive bot never loses (${naive.lost ?? 0} of ${naive.seeds ?? '?'} seeds)`);
+            const careful = cohorts.filter((c) => c.human && (c.role === 'skilled' || c.role === 'taught'));
+            if (careful.length && !careful.some((c) => c.won > 0 && !c.foresight) && !accepted.has('human-win'))
+                problems.push(`at a human pace nobody wins with the defaults (${careful.map((c) => `${c.policy ?? c.role} ${c.won ?? 0}/${c.seeds ?? '?'}`).join(', ')})`);
+            const missing = (g.bots ?? []).filter((b) => !cohorts.some((c) => c.policy === b));
+            if (missing.length)
+                problems.push(`the GDD's bots never played: ${missing.join(', ')}`);
+            return problems.length ? r('failing', [...new Set(problems)].slice(0, 3).join('; '), closes, `change the rules (or fix the bot), then ${T} sim`) : r('met', `the challenge bites: the naive bot loses ${naive.lost} of ${naive.seeds}`, '', '');
+        }
+        case 'verify': {
+            const rec = readJson(join(root, 'verify.json'));
+            if (!rec)
+                return r('open', 'never verified', 'verify.json: pass on the current files', `${T} check --front-door (or npm run build, then ${T} verify --front-door)`);
+            if (!fresh(rec))
+                return r('stale', 'verify.json is from older files', 'verify.json: pass on the current files', `${T} check --front-door (or npm run build, then ${T} verify --front-door)`);
+            return rec.verdict === 'pass' ? r('met', 'verify passes on the current files', '', '') : rec.verdict === 'fail' ? r('failing', 'the last verify failed', 'verify.json: pass', `read its FAIL lines, fix, ${T} verify`) : r('not_observed', 'the last verify measured nothing', 'verify.json: pass', `${T} verify (hooks missing or the page did not load)`);
+        }
+        case 'hook':
+        case 'life':
+        case 'walk': {
+            const rel = join('.funtools', `${g.kind}.json`), rec = readJson(join(root, rel));
+            const cmd = g.kind === 'walk' ? `${T} walk` : `${T} ${g.kind}${g.kind === 'hook' ? ' --viewport phone' : ''}`;
+            const closes = `${rel} on the current files with zero warnings`;
+            if (!rec)
+                return has(g.kind) ? r('open', `${g.kind} never ran`, closes, cmd) : r('not_observed', `\`funtools ${g.kind}\` is not in this funtools yet: not observed, never a pass`, closes, `upgrade funtools, then ${cmd}`);
+            if (!fresh(rec) && !(g.kind !== 'hook' && readsUnchanged(root, rec)))
+                return r('stale', `${g.kind} ran on older files`, closes, cmd);
+            const w = warnsOf(rec);
+            if (rec.verdict === 'fail' && !w.length)
+                w.push('its verdict is fail');
+            if (w.length && !agreed && WORLD_READS.has(g.kind) && !w.some(isWorldFault))
+                return r('met', notesSaid(g.kind, w), '', '');
+            return w.length ? r('failing', w.slice(0, 2).map((x) => short(x)).join('; '), closes, `fix what it names, then ${cmd}`) : r('met', `${g.kind} holds on the current files`, '', '');
+        }
+        case 'score': {
+            const rel = join('design', 'look', 'scores.json'), raw = readJson(join(root, rel));
+            const bar = g.min ?? ownerGates(root).accuracy_min ?? ACCURACY_DEFAULT;
+            const closes = `${rel}: every moment at ${bar} or more beside its target`;
+            if (!raw)
+                return has('score') ? r('open', 'no moment scored against its target', closes, `${T} score --target`) : r('not_observed', '`funtools score` is not in this funtools yet: not observed, never a pass', closes, `upgrade funtools, then ${T} score --target`);
+            if (!fresh(raw))
+                return r('stale', 'the scores are from older files', closes, `${T} score --target`);
+            const s = momentScores(raw);
+            if (!s.length)
+                return r('not_observed', `${rel} names no moment`, closes, `${T} score --target`);
+            const low = s.filter((m) => m.score < bar);
+            const fx = fixSummary(fixList(root, raw));
+            return low.length ? r('failing', `${low.length} of ${s.length} under ${bar}: ${low.slice(0, 3).map((m) => `${m.moment} ${m.score}`).join(', ')}`, closes, `apply the fix list${fx ? ` (${fx})` : ''}, rebuild, then ${T} score at the same framing (${T} score --fixes prints it whole)`) : r('met', `every moment at ${bar}+ (${s.map((m) => `${m.moment} ${m.score}`).slice(0, 4).join(', ')})`, '', '');
+        }
+        case 'play': {
+            const last = latestPlay(root);
+            const closes = 'a blind round from the title on the current files that is not blocked (.funtools/play/round-N/report.json)';
+            if (!last)
+                return r('open', 'no blind round yet', closes, `${T} play --viewport phone (the player agent plays from the title)`);
+            if (last.r.source_changed === true || !fresh(last.r))
+                return r('stale', `${last.rel} played older files`, closes, `${T} play --viewport phone`);
+            return last.r.blocked ? r('failing', `the blind player was blocked: ${short(String(last.r.blocking || last.r.defects?.[0]?.title || 'see the report'))}`, closes, `fix it, then ${T} play`) : r('met', `${last.rel}: a new player gets through`, '', '');
+        }
+        case 'panel': {
+            const h = readJson(join(root, '.funtools', 'playtest', 'history.json'));
+            const rounds = Array.isArray(h?.rounds) ? h.rounds : [];
+            const bar = g.min ?? PANEL_DEFAULT;
+            const closes = `a playtest round on the current files with the panel's mean at ${bar}+, no blocker still there and nothing on the do-not-regress list lost`;
+            if (!rounds.length)
+                return r('open', 'no playtest round yet', closes, `${T} playtest`);
+            const last = rounds[rounds.length - 1];
+            if (!fresh(last))
+                return r('stale', `playtest round ${last.n} judged older files`, closes, `${T} playtest`);
+            const vals = Object.values(last.panel ?? {}).filter((v) => typeof v === 'number');
+            const mean = vals.length ? Math.round((vals.reduce((a, b) => a + b, 0) / vals.length) * 100) / 100 : null;
+            const still = (last.blockers ?? []).filter((b) => /still/i.test(String(b.status))).length;
+            const dropped = new Set((readKeep(root)?.items ?? []).filter((k) => k.dropped).map((k) => k.id));
+            const lost = (Array.isArray(last.keep) ? last.keep : []).filter((k) => k?.status === 'lost' && !dropped.has(k.id));
+            if (lost.length)
+                return r('failing', `a regression: ${lost.map((k) => `${k.id} ${short(String(k.text ?? ''), 80)}`).join('; ')} worked and is lost (round ${last.n})`, closes, `put ${lost.length === 1 ? 'it' : 'them'} back first (.funtools/keep.json has the evidence), then ${T} playtest; the ledger seat judges ${lost.length === 1 ? 'it' : 'them'} again`);
+            if (mean === null)
+                return r('not_observed', `round ${last.n} has no panel numbers`, closes, `${T} playtest report`);
+            return mean >= bar && !still ? r('met', `panel ${mean} (round ${last.n})`, '', '') : r('failing', `panel ${mean}${still ? `, ${still} blocker(s) still there` : ''} (round ${last.n})`, closes, 'work down the blockers ledger, then playtest again');
+        }
+        case 'owner': {
+            const v = [...(p.verdicts ?? [])].reverse().find((x) => x.stage === stageId);
+            const closes = `the owner's verdict on ${stageId}: accept`;
+            const look = stageId === 'key-look';
+            if (!v)
+                return look
+                    ? r('open', 'the owner has not looked at the key art and the hero\'s sheet yet', closes, `show both in the chat, opened big, and ask whether this is the look; record their words: ${T} note verdict key-look accept|reject "…"`)
+                    : r('open', 'the owner has not played it', closes, `the owner plays it on a phone; record their words: ${T} note verdict ${stageId} accept|reject "…"`);
+            return v.says === 'accept' ? r('met', `the owner accepted (${v.at.slice(0, 10)})`, '', '') : r('failing', `the owner rejected: ${short(v.words ?? '')}`, closes, look ? 'redraw what they named; show them again' : 'fix what they named; ask them to play again');
+        }
+        case 'published': {
+            let lines = 0;
+            try {
+                lines = readFileSync(join(root, '.funtools', 'publish.jsonl'), 'utf8').split('\n').filter((l) => l.trim()).length;
+            }
+            catch { }
+            return lines ? r('met', 'published', '', '') : r('open', 'not published', '.funtools/publish.jsonl', `${T} pack --dry-run, then ${T} publish`);
+        }
+        case 'kit': {
+            const k = worldKit(root);
+            const have = KIT_KINDS.map(([kind]) => kind).filter((kind) => k[kind].length);
+            const closes = 'sheets of at least two of the world\'s made parts (structures, ground, props, the living cast) in design/first-look, named for what they hold';
+            return have.length >= 2 ? r('met', `the world's kit: ${have.map((kind) => `${kind} (${k[kind].length})`).join(', ')}`, '', '')
+                : r('open', have.length ? `the world's kit has only ${have.join(', ')}` : 'no sheet of the world\'s made parts yet (only the hero and the frames)', closes, `draw them from the reference sheets with the style block (skill funpixel-art), then \`${T} cut <sheet>\` into pieces the slice is built from`);
+        }
+        case 'set': {
+            const s = firstLookSet(root);
+            const have = s.items.filter((i) => i.state === 'have').length;
+            if (!s.missing.length)
+                return r('met', `the first-look set: ${have} of ${s.items.length} shown${s.items.some((i) => i.state === 'skipped') ? `, ${s.items.filter((i) => i.state === 'skipped').length} skipped by the owner` : ''}${s.skippedGroups.length ? ` (${s.skippedGroups.map((x) => x.why).join('; ')})` : ''}`, '', '');
+            const waiting = s.missing.find((i) => i.state === 'waiting');
+            return r('open', `the first-look set misses ${s.missing.length} of ${s.items.length}: ${s.missing.slice(0, 6).map((i) => i.title.replace(/ \(.*$/, '')).join(', ')}${s.missing.length > 6 ? '…' : ''}`, `${missingLines(s).slice(0, 3).join('; ')}${s.missing.length > 3 ? `; …and ${s.missing.length - 3} more (${T} firstlook)` : ''}`, waiting ? `the owner answers ${s.world.ask ?? 'the world question'} in the chat; meanwhile ${SET_RUN}` : SET_RUN);
+        }
+        case 'worth': {
+            const w = worthGate(root, { needPlayed: !!g.played });
+            return r(w.state, w.says, w.closes, w.run);
+        }
+        case 'world': {
+            const w = worldRead(root, fp);
+            const run = `${T} check --world (boxes, grounding, life on the play views), or ${T} walk on a route from the title`;
+            const closes = 'walk.json, or life.json + boxes.json (boxes for a 3D game), on the current files with zero warnings: no flat boxes near the camera, nothing floating, every person and creature animated (not a picture slid or bobbed)';
+            if (w.state === 'failing' && !agreed && !w.warns.some(isWorldFault))
+                return r('met', notesSaid('world', w.warns), '', '');
+            return w.state === 'met' ? r('met', w.says, '', '') : r(w.state, w.says, closes, w.state === 'failing' ? `fix what it names, then ${T} check --world` : run);
+        }
+        case 'spec': {
+            const rec = readJson(join(root, '.funtools', 'spec.json'));
+            const closes = '.funtools/spec.json on the current spec and src/: zero warnings (every id cited exists, every tunable read and none typed into the code, every room with a par and an exit, the pars at the floor, the tier\'s sections there)';
+            if (!existsSync(join(root, 'design', 'spec', 'tunables.json')))
+                return r('open', 'no spec folder yet (design/spec/)', closes, `${T} spec init (the big tier: the build contract, every number as data, rooms and chapters), then ${T} spec lint`);
+            if (!rec)
+                return r('open', 'the spec was never linted', closes, `${T} spec lint`);
+            if (rec.hash !== specHash(root))
+                return r('stale', 'the spec or the code changed since the last lint', closes, `${T} spec lint`);
+            const warn = Number(rec.counts?.warn ?? 0);
+            return warn ? r('failing', `spec lint: ${warn} warning${warn === 1 ? '' : 's'}${rec.first ? ` (${short(String(rec.first))})` : ''}`, closes, `fix what it names, then ${T} spec lint`) : r('met', `the spec lints clean${rec.counts?.note ? ` (${rec.counts.note} notes)` : ''}`, '', '');
+        }
+        case 'chapters': {
+            const v = chaptersGate(root, (p.verdicts ?? []), T);
+            return r(v.state, v.says, v.closes, v.run);
+        }
+        case 'rooms': {
+            const v = roomsGate(root, fp);
+            return r(v.state, v.says, v.closes, v.run);
+        }
+        case 'file': {
+            const path = g.path ?? '';
+            return path && existsSync(join(root, path)) ? r('met', `${path} exists`, '', '') : r('open', `${path || '(no path)'} is missing`, path, `make ${path}`);
+        }
+    }
+}
+const FORBIDS_BUILD = /\b(?:do not|don'?t|never)\s+(?:start|begin|touch|write|make)?\s*(?:on\s+)?(?:the\s+|any\s+)?(?:build|building|game code|code)\b|\bno build(?:ing)?\b|\bnot (?:yet )?signed off\b|\bno sign-?off\b|\bkeep (?:designing|planning)\b|\bnothing (?:is )?built\b/i;
+const DESIGN_WORK = /\bopen questions?\b|\b(?:in|into|update|revise|rewrite) the (?:GDD|design doc(?:ument)?|plan)\b/i;
+const DESIGN_STAGES = new Set(['pitch', 'lock', 'gdd']);
+export const LOOK_NOTE = /\b(look\w*|shapes?|box(es|y)?|primitives?|world|art|ugly|worst|flat|ground\w*|float\w*|glid\w*|models?|sprites?|style|colou?rs?|pictures?|visual\w*|cut-?outs?|3d|scenes?|plain|blocky|graphics)\b/i;
+export const forbidsBuild = (n) => FORBIDS_BUILD.test(n.text);
+export const designNote = (n) => forbidsBuild(n) || (!LOOK_NOTE.test(n.text) && (DESIGN_WORK.test(n.text) || DESIGN_STAGES.has(n.stage)));
+export const designPath = (rel) => /^(design\/|GDD\.md$)/.test(rel) && !/^design\/(pipeline|status|plan-notes)\.json$/.test(rel);
+const HOLD_WORDS = /\bnot (?:yet )?signed off\b|\bno sign-?off\b|\bkeep (?:designing|planning)\b|\b(?:do not|don'?t)\s+(?:start|begin)\s+(?:the\s+)?build(?:ing)?\b|\b(?:do not|don'?t)\s+build(?:\s+anything)?\s*(?:yet\b|until\b|before\b|[.;:!,)]|$)/i;
+export const holdsStage = (n) => n.by === 'owner' && (n.hold ?? HOLD_WORDS.test(n.text));
+export function openNotes(p) {
+    const open = p.notes.filter((n) => n.status === 'open' || (n.status !== 'dropped' && n.verdict?.says === 'reject'));
+    return open.sort((a, b) => (a.by === b.by ? 0 : a.by === 'owner' ? -1 : 1));
+}
+export function evaluate(root, p, fp, has, o = {}) {
+    const og = ownerGates(root);
+    const fl = readJson(join(root, '.funtools', 'flow.json'));
+    const broughtOnly = !!fl && Array.isArray(fl.rounds) && !fl.owner_plan;
+    const plan = !broughtOnly && p.stages.some((s) => PLANNING_STAGES.has(s.id) && s.status !== 'done' && s.status !== 'skipped') ? ownerPlan(root) : {};
+    const stages = p.stages.map((stage, index) => {
+        const skipped = stage.status === 'skipped';
+        const byPlan = !skipped && stage.status !== 'done' && PLANNING_STAGES.has(stage.id) ? plan[stage.id] : undefined;
+        const gates = skipped ? [] : byPlan ? stage.gates.map((g) => ({ gate: g, state: 'met', says: `answered by ${byPlan}`, closes: '', run: '' }))
+            : stage.gates.map((g) => evaluateGate(root, g.kind === 'score' && og.accuracy_min !== null && g.min === undefined ? { ...g, min: og.accuracy_min, owner: true }
+                : g.kind === 'panel' && og.panel_min !== null && g.min === undefined ? { ...g, min: og.panel_min, owner: true } : g, fp, p, stage.id, has, o.agreed ?? true));
+        return { stage, index, gates, skipped, done: skipped || stage.status === 'done' || gates.every((x) => x.state === 'met') };
+    });
+    const current = stages.find((s) => !s.done) ?? null;
+    const notes = openNotes(p);
+    const order = new Map(p.stages.map((s, i) => [s.id, i]));
+    const holds = notes.filter(holdsStage);
+    const due = notes.filter((n) => n.by === 'owner' && !holds.includes(n) && (current === null || (order.get(n.stage) ?? 0) <= current.index || stages[order.get(n.stage) ?? 0]?.done));
+    const held = holds.length && current && !DESIGN_WORK_STAGES.has(current.stage.id) ? holds[0] : null;
+    let next;
+    if (p.dropped) {
+        next = { kind: 'done', stage: null, step: `the owner dropped this game (${p.dropped.at.slice(0, 10)}): "${short(p.dropped.words, 160)}"`, why: 'a drop is the owner\'s word; nothing more is built', closes: 'nothing: the game is dropped', run: `none; a new idea starts with ${T} flow start <dir> --idea "<line>"` };
+    }
+    else if (due.length) {
+        const n = due[0];
+        const st = stages.find((s) => s.stage.id === n.stage) ?? current;
+        next = {
+            kind: 'owner-note', stage: st, note: n,
+            step: `the owner's note ${n.id} (${n.stage}): "${short(n.text, 160)}"${n.verdict?.says === 'reject' ? ` — reopened by the owner: ${short(n.verdict.words ?? '', 80)}` : ''}`,
+            why: 'the owner\'s notes outrank anything an agent claims; it stays open until evidence closes it',
+            ...(designNote(n)
+                ? { closes: 'the design it asks for: a commit that changes the GDD or design/ made after the note (or the owner\'s own word)', run: `${T} note close ${n.id} --evidence <commit sha>` }
+                : { closes: `evidence that it is fixed: a file (a film or a still from the same framing${n.screenshot ? ` as ${n.screenshot}` : ''}), a commit or a test name`, run: `${T} note close ${n.id} --evidence <path|sha|test>` }),
+        };
+    }
+    else if (held) {
+        next = {
+            kind: 'hold', stage: current, note: held,
+            step: `waiting on the owner: their note ${held.id} holds the stage: "${short(held.text, 160)}"`,
+            why: 'the owner holds the stage: the build waits for their word, and only the work the note names goes on (the design, the GDD, art tests); it is not a task to close',
+            closes: `the owner's word in the chat; only when they release it, record it in their words (\`${T} note close ${held.id} --by owner --force "<their words>"\`)`,
+            run: 'nothing to run for it: go on with the work the note names, or ask the owner in the chat',
+        };
+    }
+    else if (current) {
+        const g = current.gates.find((x) => x.state !== 'met');
+        const c = CATALOGUE[current.stage.id];
+        next = {
+            kind: 'gate', stage: current, gate: g,
+            step: `${current.stage.title}: ${g.says}`,
+            why: current.stage.why ?? c?.why ?? 'the stage\'s gate has no evidence yet',
+            closes: g.closes, run: g.run,
+        };
+    }
+    else {
+        next = { kind: 'done', stage: null, step: 'every stage has its evidence', why: 'the path is walked', closes: 'the person plays it and says yes', run: 'hand back: what plays, what is out on purpose, the next two or three steps, every stand-in' };
+    }
+    return { tier: p.tier, stages, current, openNotes: notes, holds, next, ownerGates: og };
+}
+export function rulesFor(stage) {
+    if (!stage)
+        return [SESSION_RULE];
+    return [...(stage.rules?.length ? stage.rules : CATALOGUE[stage.id]?.rules ?? []), SESSION_RULE];
+}
+const MARK = { met: 'met', open: 'no evidence', stale: 'stale', failing: 'failing', not_observed: 'not observed' };
+export function stageBlock(e, opts = {}) {
+    const out = [];
+    const n = e.stages.length;
+    const at = e.current ? `stage ${e.current.index + 1} of ${n}: ${e.current.stage.title}` : `all ${n} stages have their evidence`;
+    out.push(`## ${opts.heading ?? 'Where the game is'} (design/pipeline.json, ${TIER_NAME[e.tier] ?? e.tier})`);
+    out.push(`- path: ${e.stages.map((s) => `${s.skipped ? '-' : s.done ? '✓' : s === e.current ? '▸' : '·'} ${s.stage.id}`).join('  ')}`);
+    out.push(`- now: ${at}`);
+    if (e.current?.stage.reopened)
+        out.push(`- reopened: ${e.current.stage.reopened}`);
+    out.push(`- next: ${e.next.step}`);
+    out.push(`  run: ${e.next.run}`);
+    out.push(`  closes when: ${e.next.closes}`);
+    if (e.current) {
+        const other = e.current.gates.filter((g) => g !== e.next.gate && g.state !== 'met');
+        for (const g of other)
+            out.push(`  also open here (${MARK[g.state]}): ${g.says} → ${g.run}`);
+    }
+    const holds = e.holds ?? [];
+    if (holds.length) {
+        out.push('', 'Waiting on the owner (they hold the stage; information, not a step: only they release it):');
+        for (const note of holds)
+            out.push(`- ${note.id} [${note.stage}] "${short(note.text, 180)}"`);
+    }
+    const own = e.openNotes.filter((n) => !n.from_bar && !holds.includes(n)), bar = e.openNotes.filter((n) => n.from_bar);
+    if (own.length) {
+        out.push('', 'The owner\'s open notes (they outrank any agent claim; each stays open until evidence closes it):');
+        for (const note of own.slice(0, 6))
+            out.push(`- ${note.id} [${note.stage}] ${note.by === 'owner' ? '' : '(agent) '}"${short(note.text, 180)}"${note.screenshot ? ` (${note.screenshot})` : ''}`);
+        if (own.length > 6)
+            out.push(`- …and ${own.length - 6} more: \`${T} note\``);
+    }
+    if (bar.length) {
+        out.push('', `The owner's standing bar for this game (${bar.length} line${bar.length === 1 ? '' : 's'}, carried from their earlier games; the plan, the first look and the build answer each):`);
+        for (const note of bar.slice(0, 12))
+            out.push(`- ${note.id} [${note.stage}] ${short(note.text.replace(/^the owner's bar: /, ''), 120)}`);
+        if (bar.length > 12)
+            out.push(`- …and ${bar.length - 12} more: \`${T} owner list\``);
+    }
+    if (opts.rules !== false) {
+        out.push('', `What matters at this stage${e.current ? ` (${e.current.stage.title})` : ''}:`);
+        for (const r of rulesFor(e.current?.stage))
+            out.push(`- ${r}`);
+    }
+    out.push('', `Start from \`${T} next\`: the one next step, why, and the evidence that closes it.`);
+    return out.join('\n');
+}
+export function gatesWithoutEvidence(e) {
+    if (!e.current)
+        return [];
+    return e.current.gates.filter((g) => g.state !== 'met').map((g) => `${e.current.stage.title} — ${g.gate.kind}: ${MARK[g.state]} (${g.says}). Closes with ${g.closes}: ${g.run}`);
+}
+export function ownerGateItems(e) {
+    const out = [];
+    for (const s of e.stages) {
+        for (const g of s.gates)
+            if (g.gate.owner && g.state !== 'met' && !s.skipped && s.index <= (e.current?.index ?? Infinity))
+                out.push(`the owner's bar (funpixel.json accuracy_min ${g.gate.min}): ${g.says}`);
+    }
+    if (e.ownerGates.evidence && e.current) {
+        for (const g of e.current.gates)
+            if (g.state !== 'met')
+                out.push(`the owner's rule "a round is not done without evidence" (funpixel.json owner_gates.evidence): ${e.current.stage.title} has no ${g.gate.kind} evidence (${g.says})`);
+    }
+    return out;
+}