@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/gdd/worth.js

@@ -0,0 +1,507 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { gddOf, lineMinutes, NUGGET, readBar, readGameBar, section } from "../owner/bar.js";
+import { readProgress } from "../progress/progress.js";
+export const WORTH_FILE = join('.funtools', 'worth.json');
+export const WORTH_HEADING = /^worth against the genre\b/i;
+export const WORTH_TITLE = 'Worth building at this length?';
+export const SUPPLY_FLOOR = 2 / 3;
+export const PROVE_FROM_MINUTES = 45;
+export const PROTOTYPE_STAGE = 'prototype';
+const T = 'npx @funpixel/tools';
+export const OPTION_WORDS = {
+    grow: 'Grow the plan: add what is named, then read it again',
+    shrink: 'Shrink the length to what the plan supplies',
+    keep: 'Keep it as it is (my call)',
+    reshape: 'Reshape it to carry the length (new places, verbs, a meta)',
+    drop: 'Drop it: not worth building',
+    prototype: 'Prove the core first: a 5-minute prototype',
+};
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return null;
+} };
+const r1 = (n) => Math.round(n * 10) / 10;
+const median = (xs) => { if (!xs.length)
+    return null; const s = [...xs].sort((a, b) => a - b); const m = s.length >> 1; return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2; };
+const cells = (l) => l.trim().replace(/^\||\|$/g, '').split('|').map((c) => c.trim());
+const isRule = (l) => /^\s*\|[\s:|-]+\|\s*$/.test(l);
+const PLACEHOLDER = /<[^<>\n]{2,}>/;
+function table(body) {
+    if (!body)
+        return null;
+    const lines = body.split('\n').filter((l) => /^\s*\|.*\|\s*$/.test(l));
+    if (lines.length < 2)
+        return null;
+    return { head: cells(lines[0]).map((h) => h.toLowerCase()), rows: lines.slice(1).filter((l) => !isRule(l)).map(cells).filter((r) => r[0] && !PLACEHOLDER.test(r[0])) };
+}
+export function minutesOf(s) {
+    const t = s.replace(/[~≈]/g, '').replace(/,/g, '');
+    const m = /(\d+(?:\.\d+)?)\s*(?:(?:–|-|to)\s*(\d+(?:\.\d+)?)\s*)?(hours?|hrs?|h\b|minutes?|mins?|m\b|seconds?|secs?|s\b)/i.exec(t);
+    if (!m)
+        return null;
+    const lo = Number(m[1]), hi = m[2] ? Number(m[2]) : lo, mid = (lo + hi) / 2;
+    const u = m[3].toLowerCase();
+    return u.startsWith('h') ? mid * 60 : u.startsWith('s') ? mid / 60 : mid;
+}
+const countOf = (s) => { const m = /(?<![\w.])(\d+(?:\.\d+)?)/.exec(s.replace(/[~≈,]/g, '')); return m ? Number(m[1]) : null; };
+const plannedOf = (s) => { const m = /(?<![\w.])(\d+)\s*(?:planned|in all|in the plan|total)\b/i.exec(s.replace(/[~≈,]/g, '')); return m ? Number(m[1]) : countOf(s); };
+const UNITS = 'flights?|runs?|rounds?|levels?|rooms?|laps?|races?|waves?|matche?s?|stages?|missions?|days?|nights?|sessions?|heists?|puzzles?|boards?|tracks?|songs?|chapters?|dives?|trips?|deliveries|delivery|shifts?|seasons?|episodes?|floors?|hunts?|games?|legs?|heats?|sorties|sortie|climbs?|voyages?|crossings?';
+const UNIT_RE = new RegExp(`\\b(${UNITS})\\b`, 'i');
+const singular = (u) => u.toLowerCase().replace(/ies$/, 'y').replace(/(ch|sh|s|x)es$/, '$1').replace(/s$/, '');
+const TIME_RE = /(?<![\w./])(\d+(?:\.\d+)?)\s*(?:(?:–|-|to)\s*(\d+(?:\.\d+)?)\s*)?(seconds?|secs?|s|minutes?|mins?|min)(?![\w/])/gi;
+export function suppliedMinutes(gdd, root = null) {
+    if (root) {
+        const rooms = readJson(join(root, 'design', 'spec', 'rooms.json'));
+        const list = Array.isArray(rooms?.rooms) ? rooms.rooms : Array.isArray(rooms) ? rooms : [];
+        const pars = list.map((r) => Number(r?.par ?? r?.par_s ?? r?.par_seconds)).filter((n) => Number.isFinite(n) && n > 0);
+        if (pars.length) {
+            const s = pars.reduce((a, b) => a + b, 0);
+            return { minutes: r1(s / 60), from: ['design/spec/rooms.json'], says: `${pars.length} rooms, their pars add up to ${Math.round(s)} s` };
+        }
+    }
+    const t = table(section(gdd, /^the numbers\b/i));
+    const rows = t?.rows ?? [];
+    let per = null;
+    const timeIn = (cell, perUnit = false) => {
+        for (const tm of cell.matchAll(TIME_RE)) {
+            const after = cell.slice(tm.index + tm[0].length);
+            if (/^\s*(arc|total|in all|overall|game)/i.test(after) || (!perUnit && /^\s*of play/i.test(after)))
+                continue;
+            const lo = Number(tm[1]), hi = tm[2] ? Number(tm[2]) : lo, v = (lo + hi) / 2;
+            const seconds = /^m/i.test(tm[3]) ? v * 60 : v;
+            if (seconds >= 5 && seconds <= 4 * 3600)
+                return seconds;
+        }
+        return null;
+    };
+    const TIED = new RegExp(`\\b(?:one|a|an|each|per|every)\\s+(?:[a-z-]+\\s+)?(${UNITS})\\b|\\b(${UNITS})\\s+(?:is|lasts|takes|runs)\\b`, 'i');
+    for (const row of rows) {
+        const name = row[0], text = row.slice(1).join(' | ');
+        const named = UNIT_RE.exec(name) ?? (/length|duration|time/i.test(name) ? UNIT_RE.exec(row[1] ?? '') : null);
+        if (named) {
+            const sec = timeIn(`${name} ${row[1] ?? ''}`, true);
+            if (sec) {
+                per = { unit: singular(named[1]), seconds: sec, row: `${name}: ${text.slice(0, 90)}`, named: true };
+                break;
+            }
+        }
+        if (per)
+            continue;
+        for (const cell of row.slice(1)) {
+            const tied = TIED.exec(cell), sec = tied ? timeIn(cell, true) : null;
+            if (tied && sec) {
+                per = { unit: singular(tied[1] ?? tied[2]), seconds: sec, row: `${name}: ${text.slice(0, 90)}`, named: false };
+                break;
+            }
+        }
+    }
+    let count = null;
+    const unitRe = per ? new RegExp(`(?<![\\w.])(\\d+)\\s+${per.unit}(?:e?s)?\\b`, 'i') : null;
+    if (unitRe) {
+        for (const row of rows) {
+            const m = unitRe.exec(row.slice(1).join(' ')) ?? unitRe.exec(row[0]);
+            if (m) {
+                count = { n: Number(m[1]), row: `${row[0]}: ${(row[1] ?? '').slice(0, 80)}` };
+                break;
+            }
+        }
+        if (!count) {
+            const c = table(section(gdd, /^content list\b/i));
+            for (const row of c?.rows ?? [])
+                if (new RegExp(`\\b${per.unit}`, 'i').test(row[0])) {
+                    const n = plannedOf(row[1] ?? '');
+                    if (n) {
+                        count = { n, row: `## Content list: ${row[0]} ${n}` };
+                        break;
+                    }
+                }
+        }
+    }
+    let retries = 1, retryRow = '';
+    for (const row of rows) {
+        if (!/retr|attempts?|tries|lives/i.test(row[0]))
+            continue;
+        const n = countOf(row[1] ?? '');
+        if (n && n >= 1 && n <= 10) {
+            retries = n;
+            retryRow = `${row[0]}: ×${n}`;
+            break;
+        }
+    }
+    if (!per) {
+        const par = /\bpar\s+(?:(\d+):(\d{2})|(\d+)\s*(?:s|sec|seconds)\b)/i.exec(gdd);
+        if (par) {
+            const seconds = par[3] ? Number(par[3]) : Number(par[1]) * 60 + Number(par[2]);
+            const c = table(section(gdd, /^content list\b/i));
+            const row = c?.rows.find((r) => /room|level|stage|track|board|puzzle|mission|course/i.test(r[0]) && countOf(r[1] ?? ''));
+            if (seconds >= 5 && row) {
+                const n = countOf(row[1] ?? '');
+                const m = r1((seconds * n) / 60);
+                return { minutes: m, from: [`par ${par[0].replace(/^par\s+/i, '')}`, `## Content list: ${row[0]} ${n}`], says: `a par of ${seconds} s × ${row[0].toLowerCase()} ${n} = ${m} min` };
+            }
+        }
+    }
+    if (!per)
+        return { minutes: null, from: [], says: rows.length ? '## The numbers never say how long one flight, run, level or session lasts' : 'no ## The numbers table to size play from' };
+    const n = count?.n ?? 1;
+    const minutes = r1((per.seconds * n * retries) / 60);
+    const from = [per.row, ...(count ? [count.row] : []), ...(retryRow ? [retryRow] : [])];
+    return { minutes, from, says: `${Math.round(per.seconds)} s a ${per.unit} × ${n} ${per.unit}${n === 1 ? '' : 's'}${retries > 1 ? ` × ${retries} tries` : ''}${count ? '' : ' (no count named: one)'} = ${minutes} min` };
+}
+export function promisedMinutes(gdd) {
+    const own = /^\s*\**play length:?\**:?\s*(.+)$/im.exec(gdd)?.[1];
+    const line = (own && !/starter default/i.test(own) ? own : undefined) ?? /\brun length\s+([^(·\n]+)/i.exec(gdd)?.[1];
+    if (!line)
+        return null;
+    const m = /(\d+(?:\.\d+)?)\s*(?:(?:–|-|to)\s*\d+(?:\.\d+)?\s*)?(hours?|hrs?|h\b|minutes?|mins?|min\b)/i.exec(line);
+    if (!m)
+        return null;
+    return /^h/i.test(m[2]) ? Number(m[1]) * 60 : Number(m[1]);
+}
+export function tierOf(root) {
+    const t = readJson(join(root, 'funpixel.json'))?.production?.tier;
+    return t === 'small' || t === 'mid' || t === 'deep' ? t : null;
+}
+export function targetOf(root, gdd, env = process.env) {
+    const m = readJson(join(root, 'funpixel.json')) ?? {};
+    const t = Number(m.target_minutes);
+    if (Number.isFinite(t) && t > 0)
+        return { minutes: t, source: 'owner', says: `the owner's target, ${t} min (funpixel.json target_minutes)` };
+    const tier = tierOf(root);
+    let skipped = null;
+    try {
+        const game = readGameBar(root);
+        for (const l of readBar(root, env)) {
+            if (l.aspect !== 'length')
+                continue;
+            const v = lineMinutes(l.text);
+            if (v === null)
+                continue;
+            const rec = game?.lines.find((x) => x.id === l.id);
+            const ownerApplied = rec?.by === 'owner' && rec.verdict === 'applies';
+            if (!ownerApplied && (rec?.verdict === 'skipped' || (tier === 'small' && v >= NUGGET.max))) {
+                skipped ??= { text: l.text, id: l.id };
+                continue;
+            }
+            return { minutes: v, source: 'owner-bar', says: `the owner's bar: "${l.text}"` };
+        }
+    }
+    catch { }
+    const p = promisedMinutes(gdd);
+    if (p)
+        return { minutes: p, source: 'plan', says: `the plan's own Play length (${p} min); the owner set no target (funpixel.json target_minutes)` };
+    const conflict = skipped ? `; the owner's bar asks "${skipped.text}", a longer game than this tier: skipped for it (the owner holds this game to it with \`owner apply ${skipped.id}\`, which makes it a longer game, or sets a target)` : '';
+    if (tier === 'small')
+        return { minutes: NUGGET.minutes, source: 'tier', says: `a nugget's length (production.tier small: a few minutes, about ${NUGGET.minutes}); the owner set no target${conflict}` };
+    return { minutes: null, source: null, says: `no target: the owner sets one (greenlight worth --target <minutes> --by owner, after they say it in the chat)${conflict}` };
+}
+const PLACE_RE = /area|level|stage|world|floor|room|region|zone|biome|island|district|place|track|wing|galler|hall|chapter|\blegs?\b|course|route/i;
+const MECH_RE = /kind|feature|verb|mechanic|tool|power|abilit|upgrade|graft|weapon|spell|gadget|move|enem|hazard|obstacle|piece|trick|rule/i;
+const CHAR_RE = /character|cast|npc|people|person|keeper|villager|folk|speaker|voice|friend|rival|ally/i;
+const PROG_RE = /upgrade|unlock|progression|level[- ]?up|skill|collect|achievement|goal|meta|currency|quest|badge|cosmetic|journal|codex/i;
+export function ourContent(gdd) {
+    const out = { places: 0, mechanics: 0, characters: 0, progression: 0 };
+    const t = table(section(gdd, /^content list\b/i));
+    for (const row of t?.rows ?? []) {
+        const what = row[0], n = plannedOf(row[1] ?? '') ?? 0, names = row[2] ?? '';
+        if (/ending|beat|story|scene|cutscene/i.test(what))
+            continue;
+        if (PROG_RE.test(what))
+            out.progression += n;
+        else if (CHAR_RE.test(what))
+            out.characters += n;
+        else if (/^other$/i.test(what) && /^[A-Z][a-z]+\b/.test(names))
+            out.characters += 1;
+        else if (PLACE_RE.test(what))
+            out.places += n;
+        else if (MECH_RE.test(what))
+            out.mechanics += n;
+    }
+    if (!out.characters) {
+        const a = table(section(gdd, /^actors\b|^the cast\b|^characters\b/i));
+        if (a) {
+            const role = a.head.findIndex((h) => /role/.test(h));
+            out.characters = a.rows.filter((r) => /^[A-Z][a-z]+$/.test(r[0].split(/\s/)[0]) && !(role >= 0 && /player|placed|enemy|prop/i.test(r[role] ?? ''))).length;
+        }
+    }
+    return out;
+}
+const MEMORY = /approx[^|]*memory|from memory/i;
+const URL = /https?:\/\/\S+/;
+const MONEY = /[$€£]\s?\d|\bprice|\breviews?\b|\bratings?\b|% positive|\bsold\b|\bdownloads?\b/i;
+export function genreRows(gdd) {
+    const body = section(gdd, WORTH_HEADING);
+    const t = table(body);
+    const problems = [];
+    if (!t)
+        return { rows: [], problems: [body === null ? 'no ## Worth against the genre: 3–5 of the genre\'s best with length, places, verbs, characters, progression and a source each' : '## Worth against the genre has no table'] };
+    const col = (re) => t.head.findIndex((h) => re.test(h));
+    const L = col(/length|hours|minutes|playtime|time/), P = col(/place|area|level|region|biome|world/), V = col(/verb|mechanic|new/), C = col(/character|cast|people|npc/), G = col(/progress|meta|unlock|upgrade/), S = col(/source|url|ref/);
+    const rows = [];
+    for (const r of t.rows) {
+        const game = r[0].replace(/\*+/g, '').trim();
+        if (/^(this game|ours|our plan|as planned|the plan)\b|\(ours\)|\(this game\)/i.test(game))
+            continue;
+        const raw = r.join(' | ');
+        const get = (i) => (i >= 0 ? r[i] ?? '' : '');
+        const source = URL.test(S >= 0 ? get(S) : raw) || URL.test(raw) ? 'url' : MEMORY.test(raw) ? 'memory' : null;
+        const lenCell = get(L);
+        const endless = /endless|infinite|no end|forever/i.test(lenCell);
+        const row = { game, minutes: endless ? null : minutesOf(lenCell), endless, places: countOf(get(P)), verbs: countOf(get(V)), characters: /^\s*(none|no|0)\b/i.test(get(C)) ? 0 : countOf(get(C)), progression: /^\s*(none|no|a score|score only)\b/i.test(get(G)) ? 0 : countOf(get(G)) ?? (get(G) && !/^\s*-?\s*$/.test(get(G)) ? 1 : null), source, raw };
+        if (!source)
+            problems.push(`${game}: its numbers carry no source: add the URL, or mark them "approx, from memory" (never invent precision)`);
+        if (MONEY.test(raw.replace(URL, '')))
+            problems.push(`${game}: prices, sales and review counts stay out of the table`);
+        rows.push(row);
+    }
+    if (rows.length < 3)
+        problems.push(`## Worth against the genre names ${rows.length} game${rows.length === 1 ? '' : 's'}: 3–5 of the genre's best`);
+    return { rows, problems };
+}
+export function coreEvidence(root) {
+    let weak = false;
+    const says = [];
+    let played = false;
+    try {
+        const rounds = readdirSync(join(root, '.funtools', 'play')).map((n) => /^round-(\d+)$/.exec(n)).filter(Boolean).map((m) => Number(m[1])).sort((a, b) => b - a);
+        for (const n of rounds) {
+            const r = readJson(join(root, '.funtools', 'play', `round-${n}`, 'report.json'));
+            if (!r)
+                continue;
+            played = true;
+            const back = String(r.come_back ?? r.would_return ?? '');
+            if (r.blocked) {
+                weak = true;
+                says.push(`blind round ${n}: the player was blocked`);
+            }
+            else if (/^\s*no\b/i.test(back)) {
+                weak = true;
+                says.push(`blind round ${n}: would not come back ("${back.slice(0, 80)}")`);
+            }
+            else
+                says.push(`blind round ${n}: a new player got through${back ? ` (come back: "${back.slice(0, 60)}")` : ''}`);
+            break;
+        }
+    }
+    catch { }
+    const h = readJson(join(root, '.funtools', 'playtest', 'history.json'));
+    const last = Array.isArray(h?.rounds) ? h.rounds.at(-1) : null;
+    if (last) {
+        played = true;
+        const fun = Number(last.panel?.fun);
+        if (Number.isFinite(fun) && fun < 6) {
+            weak = true;
+            says.push(`playtest round ${last.n}: fun ${fun}`);
+        }
+        else
+            says.push(`playtest round ${last.n ?? '?'}${Number.isFinite(fun) ? `: fun ${fun}` : ''}`);
+    }
+    if (played)
+        return { state: 'played', weak, says: says.join('; ') };
+    const v = readJson(join(root, 'verify.json'));
+    if (v?.verdict === 'pass')
+        return { state: 'built', weak: false, says: 'verify passes, but nobody has played the core yet (funtools play)' };
+    return { state: 'none', weak: false, says: 'no prototype or play of the core verb yet (no blind round, no playtest)' };
+}
+export function worthKey(root, gdd, target, ev) {
+    const parts = [section(gdd, /^the numbers\b/i), section(gdd, /^content list\b/i), section(gdd, WORTH_HEADING), section(gdd, /^actors\b/i), /^\s*\**play length.*$/im.exec(gdd)?.[0] ?? '', String(target), ev];
+    try {
+        parts.push(readFileSync(join(root, 'design', 'spec', 'rooms.json'), 'utf8'));
+    }
+    catch { }
+    return createHash('sha256').update(parts.map((p) => p ?? '').join('\u0000')).digest('hex').slice(0, 16);
+}
+export function readWorth(root, o = {}) {
+    const gdd = o.gdd ?? (gddOf(root) || (() => { try {
+        return readFileSync(join(root, 'design', 'README.md'), 'utf8');
+    }
+    catch {
+        return '';
+    } })());
+    if (!gdd.trim())
+        return null;
+    const target = targetOf(root, gdd, o.env);
+    const promised = promisedMinutes(gdd);
+    const supplied = suppliedMinutes(gdd, root);
+    const ours = ourContent(gdd);
+    const { rows, problems } = genreRows(gdd);
+    const evidence = coreEvidence(root);
+    const used = rows.filter((r) => r.source);
+    const lenRows = used.filter((r) => r.minutes);
+    const bench = {
+        minPerPlace: median(lenRows.filter((r) => r.places).map((r) => r.minutes / r.places)),
+        minPerNew: median(lenRows.filter((r) => (r.places ?? 0) + (r.verbs ?? 0) > 0).map((r) => r.minutes / ((r.places ?? 0) + (r.verbs ?? 0)))),
+        charsPerHour: median(lenRows.filter((r) => r.characters !== null).map((r) => r.characters / (r.minutes / 60))),
+        metaShare: used.filter((r) => r.progression !== null).length ? used.filter((r) => (r.progression ?? 0) > 0).length / used.filter((r) => r.progression !== null).length : null,
+        used: used.length,
+    };
+    for (const k of ['minPerPlace', 'minPerNew', 'charsPerHour', 'metaShare'])
+        if (bench[k] !== null)
+            bench[k] = Math.round(bench[k] * 100) / 100;
+    const T0 = target.minutes;
+    const S = supplied.minutes;
+    const tier = tierOf(root);
+    const scale = tier === 'small' && (T0 === null || T0 < NUGGET.max) ? 'run' : 'minutes';
+    const med = (f) => { const xs = used.map(f).filter((x) => x !== null); const v = median(xs); return v === null ? null : Math.round(v * 10) / 10; };
+    const typical = { places: med((r) => r.places), fresh: med((r) => (r.places === null && r.verbs === null ? null : (r.places ?? 0) + (r.verbs ?? 0))), characters: med((r) => r.characters) };
+    const adds = [];
+    if (S === null)
+        adds.push({ what: 'numbers', count: 1, says: `write the numbers that size play in ## The numbers: how long one flight/run/level lasts and how many there are (${supplied.says})` });
+    if (!used.length)
+        adds.push({ what: 'genre', count: 3, says: '## Worth against the genre: 3–5 of the genre\'s best, each number with a source URL or "approx, from memory"' });
+    const need = (len) => ({
+        places: bench.minPerPlace ? Math.ceil(len / bench.minPerPlace) : null,
+        fresh: bench.minPerNew ? Math.ceil(len / bench.minPerNew) : null,
+        characters: bench.charsPerHour !== null ? Math.round((bench.charsPerHour * len) / 60) : null,
+    });
+    if (T0 && scale === 'run') {
+        if (S !== null && S < T0)
+            adds.push({ what: 'minutes', count: Math.ceil(T0 - S), says: `${Math.ceil(T0 - S)} more minutes of play: the numbers supply ${S} of a nugget's ${T0}` });
+        const p = typical.places !== null ? Math.ceil(typical.places) : null, f = typical.fresh !== null ? Math.ceil(typical.fresh) : null, c = typical.characters !== null ? Math.ceil(typical.characters) : null;
+        if (p !== null && p > ours.places)
+            adds.push({ what: 'places', count: p - ours.places, says: `${p - ours.places} more distinct place${p - ours.places === 1 ? '' : 's'} (the genre's best hold ${typical.places} as a rule; the plan has ${ours.places})` });
+        const placesAfter = Math.max(ours.places, p ?? 0);
+        if (f !== null && f > placesAfter + ours.mechanics)
+            adds.push({ what: 'mechanics', count: f - placesAfter - ours.mechanics, says: `${f - placesAfter - ours.mechanics} more verbs or mechanics (the genre's best hold ${typical.fresh} places and verbs as a rule; the plan has ${placesAfter + ours.mechanics})` });
+        if (c !== null && c - ours.characters >= 2)
+            adds.push({ what: 'characters', count: c - ours.characters, says: `${c - ours.characters} more characters (the genre's best hold ${typical.characters} as a rule; the plan has ${ours.characters})` });
+        if (bench.metaShare !== null && bench.metaShare >= 0.5 && ours.progression === 0)
+            adds.push({ what: 'progression', count: 1, says: `a progression or meta (${Math.round(bench.metaShare * 100)}% of the genre's best carry one: upgrades, unlocks, goals, collectibles, a saved best); the plan's content list has none` });
+    }
+    else if (T0) {
+        if (S !== null && S < T0)
+            adds.push({ what: 'minutes', count: Math.ceil(T0 - S), says: `${Math.ceil(T0 - S)} more minutes of play: the numbers supply ${S} of ${T0}` });
+        const nd = need(T0);
+        if (nd.places !== null && nd.places > ours.places)
+            adds.push({ what: 'places', count: nd.places - ours.places, says: `${nd.places - ours.places} more distinct place${nd.places - ours.places === 1 ? '' : 's'} (the genre's best: one every ${bench.minPerPlace} min; ${T0} min needs ${nd.places}, the plan has ${ours.places})` });
+        const placesAfter = Math.max(ours.places, nd.places ?? 0);
+        if (nd.fresh !== null && nd.fresh > placesAfter + ours.mechanics)
+            adds.push({ what: 'mechanics', count: nd.fresh - placesAfter - ours.mechanics, says: `${nd.fresh - placesAfter - ours.mechanics} more new verbs or mechanics (a new thing every ${bench.minPerNew} min: ${nd.fresh} over ${T0} min, the plan has ${placesAfter + ours.mechanics} with its places)` });
+        if (nd.characters !== null && nd.characters - ours.characters >= 2)
+            adds.push({ what: 'characters', count: nd.characters - ours.characters, says: `${nd.characters - ours.characters} more characters (${bench.charsPerHour} an hour in the genre's best; the plan has ${ours.characters})` });
+        if (bench.metaShare !== null && bench.metaShare >= 0.5 && ours.progression === 0)
+            adds.push({ what: 'progression', count: 1, says: `a progression or meta (${Math.round(bench.metaShare * 100)}% of the genre's best carry one: upgrades, unlocks, goals, collectibles); the plan has none beyond a score` });
+    }
+    else
+        adds.push({ what: 'minutes', count: 0, says: 'no target length: the owner names one (greenlight worth --target <minutes> --by owner)' });
+    const r = S !== null && T0 ? S / T0 : null;
+    const content = adds.filter((a) => ['places', 'mechanics', 'characters', 'progression'].includes(a.what));
+    const placesX = ours.places ? (adds.find((a) => a.what === 'places')?.count ?? 0) / ours.places : content.some((a) => a.what === 'places') ? Infinity : 0;
+    let base;
+    let why;
+    if (r !== null && r >= 0.9 && !content.length && used.length) {
+        base = 'fits';
+        why = `the numbers supply ${S} of ${T0} minutes and the content holds the genre's density`;
+    }
+    else if ((r !== null && r < 1 / 3) || placesX >= 2) {
+        base = 'does not carry';
+        why = r !== null && r < 1 / 3 ? `the numbers supply ${S} of the ${T0} minutes (${Math.round(r * 100)}%)` : scale === 'run' ? `the genre's best hold ${typical.places} places as a rule; the plan has ${ours.places}` : `${T0} minutes at the genre's density needs ${ours.places + (adds.find((a) => a.what === 'places')?.count ?? 0)} places; the plan has ${ours.places}`;
+    }
+    else {
+        base = 'stretch';
+        why = r !== null ? `the numbers supply ${S} of ${T0} minutes${content.length ? `; short of the genre on ${content.map((a) => a.what).join(', ')}` : ''}` : supplied.says;
+    }
+    let verdict = base;
+    if (evidence.state !== 'played' && (T0 ?? 0) >= PROVE_FROM_MINUTES) {
+        verdict = 'prove the core first';
+        why = `${why}; and nobody has played the core yet — ${evidence.says}; ${T0} minutes is worth a 5-minute proof first`;
+    }
+    const thinAtOwnLength = scale === 'run' ? (typical.places ?? 0) > ours.places : S !== null && (need(S).places ?? 0) > ours.places;
+    const options = verdict === 'fits' ? [] : verdict === 'stretch' ? ['grow', 'shrink', 'keep'] : verdict === 'does not carry' ? ['shrink', 'reshape', 'drop'] : ['prototype', 'shrink', 'drop'];
+    let recommend = null, recommendWhy = '';
+    if (verdict === 'prove the core first') {
+        recommend = 'prototype';
+        recommendWhy = 'one session of the core verb, measured, costs minutes; a wrong plan of this length costs the build';
+    }
+    else if (verdict === 'does not carry') {
+        if (evidence.state === 'played' && evidence.weak) {
+            recommend = 'drop';
+            recommendWhy = `the core was played and did not hold (${evidence.says}); more content will not fix the verb`;
+        }
+        else if (thinAtOwnLength || (r !== null && r < 0.2 && content.length >= 3)) {
+            recommend = 'drop';
+            recommendWhy = `thin even at its own ${S} minutes and short on ${content.map((a) => a.what).join(', ')}: an idea this far from the length is cheaper to drop than to inflate`;
+        }
+        else if (evidence.state === 'played') {
+            recommend = 'reshape';
+            recommendWhy = `the core held in play (${evidence.says}); it can carry more if the plan grows the categories named`;
+        }
+        else {
+            recommend = 'shrink';
+            recommendWhy = used.length ? `the content is dense enough for its own ${S} minutes: make that game well, at that length` : `the plan holds ${S} minutes; with no genre table its density is unread: make that game well, or write the table and read again`;
+        }
+    }
+    else if (verdict === 'stretch') {
+        const total = adds.reduce((n, a) => n + (['minutes', 'genre', 'numbers'].includes(a.what) ? 0 : a.count), 0);
+        const have = ours.places + ours.mechanics + ours.characters + ours.progression;
+        if (r !== null && r >= 0.5 && total <= Math.max(2, have)) {
+            recommend = 'grow';
+            recommendWhy = `the gap (${adds.filter((a) => a.count > 0 && a.what !== 'genre' && a.what !== 'numbers').map((a) => a.what === 'minutes' ? `${a.count} minutes` : `${a.count} ${a.what}`).join(', ')}) is small next to what the plan already holds`;
+        }
+        else {
+            recommend = 'shrink';
+            recommendWhy = r !== null && r < 0.5 ? `the numbers supply under half the length; a ${Math.round(S)}-minute game made well beats a stretched one` : 'growing it means more new content than the plan holds; a shorter game made well beats a stretched one';
+        }
+    }
+    if (!(S !== null && used.length > 0 && T0 !== null)) {
+        recommend = null;
+        recommendWhy = 'none until the read has the numbers that size play, the genre table and a target';
+    }
+    const at = (o.now ?? new Date()).toISOString();
+    return { version: 1, at, key: worthKey(root, gdd, T0, `${evidence.state}${evidence.weak ? '!' : ''}${scale === 'run' ? '|run' : ''}`), tier, scale, target, promised, supplied, ours, genre: rows, bench, adds, verdict, why, options, recommend, recommendWhy, evidence, problems, complete: S !== null && used.length > 0 && T0 !== null };
+}
+export const needsOwner = (w) => w.verdict !== 'fits' || (w.supplied.minutes !== null && w.target.minutes !== null && w.supplied.minutes < SUPPLY_FLOOR * w.target.minutes);
+export const readRecord = (root) => { const r = readJson(join(root, WORTH_FILE)); return r && r.version === 1 && typeof r.key === 'string' ? r : null; };
+export const topicOf = (w) => `worth:${w.key.slice(0, 8)}`;
+export function worthQuestion(s, w) {
+    return s.questions.filter((q) => q.topic === topicOf(w) && q.answer?.pick !== 'superseded').at(-1) ?? null;
+}
+export const lastWorthQuestion = (s) => s.questions.filter((q) => q.topic?.startsWith('worth:') && q.answer?.pick !== 'superseded').at(-1) ?? null;
+export function worthAskText(w) {
+    const sup = w.supplied.minutes !== null ? `${w.supplied.minutes} min` : 'not stated';
+    const tgt = w.target.minutes !== null ? `${w.target.minutes} min (${w.target.source === 'owner' ? 'yours' : w.target.source === 'owner-bar' ? 'your bar' : 'the plan\'s promise'})` : 'none set';
+    const adds = w.adds.filter((a) => a.count > 0 && a.what !== 'numbers' && a.what !== 'genre').map((a) => a.says).slice(0, 4);
+    return `${WORTH_TITLE} ${w.verdict.toUpperCase()}: the plan's own numbers supply ${sup} against ${tgt}. ${w.why}.${adds.length ? ` To carry it: ${adds.join('; ')}.` : ''} Recommended: ${w.recommend ? `${w.recommend} — ${w.recommendWhy}` : 'none'}.`;
+}
+const goOf = (root) => readJson(join(root, 'funpixel.json'))?.flow?.autonomy === 'go';
+export function worthGate(root, o = {}) {
+    const run = `${T} greenlight worth (writes ${WORTH_FILE}; a verdict other than fits goes to the owner as a scope question)`;
+    const closes = `a ${WORTH_FILE} on the current plan that fits, or the owner's answer to its question`;
+    const now = readWorth(root, { env: o.env });
+    if (!now)
+        return { state: 'open', says: 'no GDD to judge worth on', closes, run: `write the GDD's pitch, ## The numbers, ## Content list and ## Worth against the genre (skill funpixel-gdd), then ${run}` };
+    const rec = readRecord(root);
+    if (!rec)
+        return { state: 'open', says: 'the worth read never ran: is this idea worth building at this length?', closes, run };
+    if (rec.key !== now.key)
+        return { state: 'stale', says: 'the worth read is from an older plan (its numbers, content list, genre table, target or the core\'s evidence moved)', closes, run };
+    if (o.needPlayed && rec.evidence.state !== 'played')
+        return { state: 'open', says: `the prototype's core has no play yet (${rec.evidence.says})`, closes: 'a blind round on the prototype, then the worth read again', run: `${T} play --viewport phone, then ${run}` };
+    const s = o.s ?? readProgress(root);
+    const q = worthQuestion(s, rec);
+    if (rec.complete === false && !q?.answer)
+        return { state: 'open', says: `worth cannot be judged yet: ${rec.adds.filter((a) => a.what === 'numbers' || a.what === 'genre' || (a.what === 'minutes' && a.count === 0)).map((a) => a.says).join('; ')}`, closes, run: `write ${[rec.supplied.minutes === null && '## The numbers (how long one flight, run or level lasts, and how many)', !rec.bench.used && '## Worth against the genre (3–5 of the genre\'s best, sourced)'].filter(Boolean).join(' and ') || 'the missing numbers'} (skill funpixel-gdd, references/worth.md), then ${run}` };
+    if (!needsOwner(rec))
+        return { state: 'met', says: `worth: fits (${rec.supplied.minutes} of ${rec.target.minutes} min, ${rec.why})`, closes: '', run: '' };
+    const go = goOf(root);
+    if (!q)
+        return { state: 'open', says: `worth: ${rec.verdict} (${rec.why}); not put to the owner yet`, closes, run: go ? `${run}, then record your choice and why: ${T} greenlight worth choose <${rec.options.join('|')}> --why "<reason>"` : run };
+    if (!q.answer)
+        return { state: 'open', says: `worth: ${rec.verdict}; waiting for the owner on ${q.id} (${rec.options.join(' / ')})`, closes, run: go ? `${T} greenlight worth choose <${rec.options.join('|')}> --why "<reason>" (the owner's autonomy go: record your choice and why)` : `ask the owner ${q.id} in the chat (${WORTH_TITLE}) and record their words with progress answer; meanwhile free plan work only, no more of the first look's art` };
+    const a = q.answer, who = a.by === 'owner' ? 'the owner' : 'the agent under the owner\'s go';
+    const answer = { q: q.id, pick: a.pick, by: a.by };
+    const words = a.words ? ` ("${a.words.slice(0, 120)}")` : '';
+    if (a.pick === 'keep')
+        return { state: 'met', says: `worth: ${rec.verdict}, kept by ${who} (${q.id})${words}`, closes: '', run: '', answer };
+    if (a.pick === 'prototype')
+        return { state: 'met', says: `worth: prove the core first, ${who} chose the prototype (${q.id})${words}`, closes: '', run: '', answer };
+    if (a.pick === 'drop')
+        return { state: 'failing', says: `worth: ${who} dropped this idea (${q.id})${words}`, closes: 'nothing: the idea stops here', run: `hand back: the idea is dropped (${q.id}); a new idea starts with ${T} flow start <dir> --idea "<line>"`, answer };
+    const doWhat = a.pick === 'shrink' ? `set the Play length to what the numbers supply (~${Math.round(rec.supplied.minutes ?? 0)} min) and size the plan to it${rec.target.source === 'owner' ? ` (the target: ${T} greenlight worth --target ${Math.round(rec.supplied.minutes ?? 0)} --from ${q.id})` : ''}`
+        : `revise the plan: ${rec.adds.filter((x) => x.count > 0).map((x) => x.says).slice(0, 3).join('; ') || 'add what the read names'}`;
+    return { state: 'open', says: `worth: ${who} chose ${a.pick} (${q.id})${words}; the plan is not revised yet`, closes: 'the revised plan read again', run: `${doWhat}, then ${run}`, answer };
+}