@funpixel/tools 0.0.0-stage → 0.1.1

package/plugins/claude/hooks/vendor/flow/flow.mjs

@@ -0,0 +1,456 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/flow/flow.ts by the GDK build. Do not edit.
+import { createHash } from 'node:crypto';
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { forbidsBuild, ownerPlan, planSig } from '../pipeline/pipeline.mjs';
+import { budgetLine, buildRefusal, readProgress, settledBudget, unpickedNotes } from '../progress/progress.mjs';
+import { fixList, fixSummary, flatRounds, FLAT_ROUNDS } from '../direct/round.mjs';
+import { lanesLine, readLanes } from '../lanes/lanes.mjs';
+import { pitchForks } from '../studio/forks.mjs';
+import { readStudio } from '../studio/pitch.mjs';
+import { PROTOTYPE_STAGE } from '../gdd/worth.mjs';
+import { sectionStates } from '../gdd/book.mjs';
+import { keepLines, lostItems, readKeep } from '../playtest/keep.mjs';
+import { lookDue, lookEvery, lookLines } from './look.mjs';
+import { stuckLine, stuckScores, STUCK_BELOW, STUCK_PLAYTESTS } from '../playtest/stuck.mjs';
+import { boardLine, readBoard } from '../status/board.mjs';
+export const FLOW_FILE = join('.funtools', 'flow.json');
+export const SESSION_FILE = join('.funtools', 'session.json');
+export const SESSION_LIVE_MS = 10 * 60_000;
+export const PLAN_STAGE_IDS = ['key-look', 'pitch', 'lock', 'gdd', 'first-look'];
+export const ROUNDS_DEFAULT = 3;
+export const STUCK_ROUNDS = 3;
+const T = 'npx @funpixel/tools';
+const REFUSAL_WHY = 'the owner chose that cap; a 3D game without its models is the starter\'s fallback shapes, and the owner judges that as the game';
+const BUDGET_ASK = 'Say how many credits the art may cost, or choose a look drawn in code.';
+export const OPENING_ASK = {
+    'key-look': 'Look at the key art and the hero\'s sheet in the chat: say yes, or what to change.',
+    [PROTOTYPE_STAGE]: 'Play the first playable, then say whether it has potential.',
+};
+export function askForAnswers(qs) {
+    const text = qs[0].text.trim();
+    const first = text.length <= 120 ? text : `${text.slice(0, 120).replace(/\s+\S*$/, '')}…`;
+    return qs.length === 1 ? `Answer the question in the chat: "${first}"` : `Answer ${qs.length} questions in the chat, starting with: "${first}"`;
+}
+export const LANE_STAGES = ['slice', 'accuracy', 'walk', 'panel'];
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return null;
+} };
+const ms = (iso) => { const t = iso ? Date.parse(iso) : NaN; return Number.isFinite(t) ? t : 0; };
+const short = (s, n = 140) => (s.length <= n ? s : `${s.slice(0, n - 1)}…`);
+export function readFlow(root) {
+    const f = readJson(join(root, FLOW_FILE));
+    if (!f || typeof f !== 'object' || !Array.isArray(f.rounds))
+        return null;
+    return { version: 1, started_at: String(f.started_at ?? ''), ...(f.idea ? { idea: String(f.idea) } : {}), scaffold: f.scaffold && typeof f.scaffold === 'object' ? f.scaffold : {}, rounds: f.rounds, owner_plan: typeof f.owner_plan === 'string' ? f.owner_plan : null, ...(typeof f.owner_plan_sig === 'string' ? { owner_plan_sig: f.owner_plan_sig } : {}), ...(typeof f.owner_plan_was === 'string' ? { owner_plan_was: f.owner_plan_was } : {}), ...(f.dropped?.by === 'owner' ? { dropped: f.dropped } : {}), ...(f.at ? { at: f.at } : {}) };
+}
+export function writeFlow(root, f) {
+    const p = join(root, FLOW_FILE);
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify(f, null, 2) + '\n');
+}
+export function codeHashes(root) {
+    const out = {};
+    const add = (rel) => { try {
+        out[rel] = createHash('sha256').update(readFileSync(join(root, rel))).digest('hex').slice(0, 16);
+    }
+    catch { } };
+    let n = 0;
+    const walk = (dir, depth) => {
+        if (depth > 6 || n > 2000)
+            return;
+        let names = [];
+        try {
+            names = readdirSync(join(root, dir));
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            if (name === 'node_modules' || name.startsWith('.'))
+                continue;
+            const rel = join(dir, name);
+            let st;
+            try {
+                st = statSync(join(root, rel));
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory())
+                walk(rel, depth + 1);
+            else if (/\.(ts|tsx|js|jsx|mjs|css|html|glsl|wgsl)$/.test(name)) {
+                n++;
+                add(rel);
+            }
+        }
+    };
+    walk('src', 0);
+    add('index.html');
+    return out;
+}
+export function beat(root, kind, o = {}) {
+    try {
+        const now = o.now ?? new Date();
+        const was = readJson(join(root, SESSION_FILE)) ?? {};
+        if (kind === 'work' && was.at && !(ms(was.idle_at) >= ms(was.at)) && now.getTime() - ms(was.at) < 20_000)
+            return;
+        const next = kind === 'start' ? { started_at: now.toISOString(), at: now.toISOString(), ...(o.by ? { by: o.by } : {}) }
+            : kind === 'idle' ? { ...was, at: was.at ?? now.toISOString(), idle_at: now.toISOString() }
+                : { ...was, at: now.toISOString(), ...(o.by ? { by: o.by } : {}) };
+        if (kind === 'work')
+            delete next.idle_at;
+        mkdirSync(join(root, '.funtools'), { recursive: true });
+        writeFileSync(join(root, SESSION_FILE), JSON.stringify(next) + '\n');
+    }
+    catch { }
+}
+export function sessionLive(root, now = Date.now()) {
+    const b = readJson(join(root, SESSION_FILE));
+    if (!b?.at)
+        return { live: false, at: null };
+    const idle = ms(b.idle_at) >= ms(b.at);
+    return { live: !idle && now - ms(b.at) < SESSION_LIVE_MS, at: idle ? b.idle_at : b.at };
+}
+export function startFlow(root, o = {}) {
+    const brought = ownerPlan(root).lock ?? null;
+    const f = { version: 1, started_at: (o.now ?? new Date()).toISOString(), ...(o.idea ? { idea: o.idea } : {}), scaffold: codeHashes(root), rounds: [], owner_plan: brought, owner_plan_sig: planSig(root) };
+    writeFlow(root, f);
+    return f;
+}
+export function pastScaffold(root, f) {
+    const now = codeHashes(root);
+    const changed = Object.keys(now).filter((k) => f.scaffold[k] !== now[k]);
+    const gone = Object.keys(f.scaffold).filter((k) => !(k in now));
+    return [...changed, ...gone].sort();
+}
+export function ownerSettings(root) {
+    const m = readJson(join(root, 'funpixel.json')) ?? {};
+    const f = m.flow && typeof m.flow === 'object' ? m.flow : {};
+    const a = f.autonomy === 'ask' || f.autonomy === 'plan-then-go' || f.autonomy === 'go' ? f.autonomy : null;
+    const r = Number(f.rounds_per_session);
+    return { autonomy: a, rounds: f.rounds_per_session !== undefined && Number.isInteger(r) && r >= 0 && r <= 50 ? r : ROUNDS_DEFAULT };
+}
+export const planQuestions = (s) => s.questions.filter((q) => q.kind === 'plan');
+function applied(root) {
+    return readJson(join(root, 'design', 'plan-notes.json'))?.applied ?? null;
+}
+export function planAgreement(root, s = readProgress(root)) {
+    const settings = ownerSettings(root);
+    const qs = planQuestions(s);
+    const open = qs.filter((q) => q.state === 'open').at(-1);
+    const answered = qs.filter((q) => q.answer && q.answer.by === 'owner').sort((a, b) => ms(a.answer.at) - ms(b.answer.at)).at(-1) ?? null;
+    const a = applied(root);
+    const words = [];
+    if (a && (a.by === 'owner' || a.by === undefined))
+        words.push({ at: ms(a.at ?? a.date), agreed: true, by: 'owner', says: `the owner applied the plan (${a.version})` });
+    if (answered) {
+        const yes = answered.answer.pick === 'approve';
+        words.push({ at: ms(answered.answer.at), agreed: yes, by: 'answer', says: yes ? `the owner approved the plan (${answered.id}${answered.answer.words ? `: "${short(answered.answer.words, 80)}"` : ''})` : `the owner asked for changes (${answered.id})`, ...(yes ? {} : { change: answered.answer.words ?? 'no words given: ask what to change' }) });
+    }
+    const last = words.sort((a, b) => a.at - b.at).at(-1);
+    if (last && !last.agreed)
+        return { agreed: false, by: null, says: last.says, change: last.change, ...(open ? { asking: open.id } : {}) };
+    if (last?.agreed)
+        return { agreed: true, by: last.by, says: last.says, at: new Date(last.at).toISOString() };
+    const f = readFlow(root);
+    const b = f ? broughtPlan(root, f) : { lock: ownerPlan(root).lock ?? null };
+    if (b.lock)
+        return { agreed: true, by: 'owner-plan', says: b.lock };
+    if (b.was && settings.autonomy !== 'go')
+        return { agreed: false, by: null, says: staleLine(b.was), ...(open ? { asking: open.id } : {}) };
+    if (settings.autonomy === 'go')
+        return { agreed: true, by: 'autonomy', says: 'the owner set autonomy "go" (funpixel.json flow.autonomy): the plan goes without a stop; they review what was made' };
+    return { agreed: false, by: null, says: open ? `the plan is with the owner (${open.id})` : 'the owner has not agreed the plan', ...(open ? { asking: open.id } : {}) };
+}
+export function broughtPlan(root, f) {
+    if (!f.owner_plan)
+        return { lock: null, ...(f.owner_plan_was ? { was: f.owner_plan_was } : {}) };
+    if (f.owner_plan_sig === planSig(root) || ownerPlan(root).lock)
+        return { lock: f.owner_plan };
+    return { lock: null, was: f.owner_plan };
+}
+const staleLine = (was) => `the plan read as agreed when the flow began (${short(was, 90)}) no longer reads so: the design's head names no owner sign-off, so it waits for the owner (\`${T} flow ask\`, then their \`${T} flow agree --by owner\`)`;
+export function freshFlow(root, f) {
+    const sig = planSig(root);
+    if (!f.owner_plan || f.owner_plan_sig === sig)
+        return f;
+    const b = broughtPlan(root, f);
+    return b.lock ? { ...f, owner_plan_sig: sig } : { ...f, owner_plan: null, owner_plan_was: b.was, owner_plan_sig: sig };
+}
+const RECORD_GATES = new Set(['tests', 'sim', 'verify', 'hook', 'life', 'walk', 'score', 'play', 'panel', 'world', 'spec', 'rooms']);
+export function roundEvidence(root, stage, since, s = readProgress(root)) {
+    const gates = stage?.gates ?? [];
+    const unrun = gates.filter((g) => RECORD_GATES.has(g.gate.kind) && (g.state === 'stale' || g.state === 'open'));
+    const card = [...s.cards].reverse().find((c) => ms(c.at) >= since && c.kind !== 'decided' && c.kind !== 'waiting' && [c.shot, c.clip].some((f) => f && f.source !== 'picture'));
+    return { unrun, card: card?.n ?? null, unpicked: unpickedNotes(root, s).map((n) => ({ id: n.id, text: n.text })) };
+}
+export const closedSince = (f, start) => (f?.rounds ?? []).filter((r) => r.closed_at && ms(r.closed_at) >= start).length;
+export function roundsWithoutGates(f, stage, s) {
+    const answered = s.questions.filter((q) => q.kind === 'scope' && q.stage === stage && q.answer).map((q) => ms(q.answer.at));
+    const after = answered.length ? Math.max(...answered) : 0;
+    const since = f.rounds.filter((r) => r.stage === stage && r.closed_at && ms(r.closed_at) > after);
+    if (since.some((r) => typeof r.accuracy === 'number'))
+        return Math.min(since.filter((r) => !r.met).length, flatRounds(since, stage));
+    return since.filter((r) => !r.met).length;
+}
+export function targetFixes(root, stage) {
+    const g = stage?.gates.find((x) => x.gate.kind === 'score');
+    if (!g || g.state !== 'failing')
+        return null;
+    const fl = fixList(root), says = fixSummary(fl);
+    return says ? { says, at: fl.at } : null;
+}
+export function droppedOf(root, f, s = readProgress(root)) {
+    if (f?.dropped?.by === 'owner')
+        return f.dropped;
+    const p = readJson(join(root, 'design', 'pipeline.json'));
+    if (p?.dropped?.by === 'owner')
+        return { by: 'owner', words: String(p.dropped.words ?? ''), at: String(p.dropped.at ?? '') };
+    const c = s.dropped;
+    return c ? { by: 'owner', words: c.line.replace(/^Dropped by the owner:?\s*/, '').replace(/^"|"$/g, ''), at: c.at } : null;
+}
+const OWNER_WORD = /\b(?:until|till|wait(?:s|ing)? for)\s+(?:I|me|my|the owner)\b|\b(?:my|the owner'?s)\s+(?:sign-?off|go-?ahead|go|yes|ok(?:ay)?|approval)\b/i;
+export function noteParks(n, stage) {
+    const building = !!stage && !PLAN_STAGE_IDS.includes(stage.stage.id);
+    if (building && forbidsBuild(n))
+        return `the owner's note ${n.id} forbids the build, and ${stage.stage.title} is build work: only the design work the note names goes on; it closes on a commit that changes the GDD or design/ (\`${T} note close ${n.id} --evidence <commit sha>\`) or on the owner's word`;
+    if (OWNER_WORD.test(n.text))
+        return `the owner's note ${n.id} waits on the owner's own word: they close it (\`${T} note close ${n.id} --by owner --force "<their words>"\`) or say what to change`;
+    return null;
+}
+export function flowView(root, e, f, o = {}) {
+    const s = o.s ?? readProgress(root);
+    const settings = ownerSettings(root);
+    const autonomy = { value: settings.autonomy ?? 'plan-then-go', source: settings.autonomy ? 'owner' : 'default' };
+    const agreement = planAgreement(root, s);
+    const states = (sectionStates(root) ?? []).filter((x) => x.written && !x.vision);
+    if (!agreement.agreed && states.some((x) => x.agreed))
+        agreement.sections = { agreed: states.filter((x) => x.agreed).length, written: states.length, open: states.filter((x) => !x.agreed).map((x) => x.title) };
+    const stage = e.current ? { id: e.current.stage.id, title: e.current.stage.title, n: e.current.index + 1, of: e.stages.length } : null;
+    const planOpen = e.stages.some((st) => PLAN_STAGE_IDS.includes(st.stage.id) && !st.done);
+    const prototyping = e.stages.some((x) => x.stage.id === PROTOTYPE_STAGE && !x.skipped);
+    const builtEarly = !agreement.agreed && f && !prototyping ? pastScaffold(root, f) : [];
+    const start = o.sessionStart ?? 0;
+    const lastBefore = Math.max(0, ...s.cards.map((c) => ms(c.at)).filter((t) => !start || t < start));
+    const first = e.next.kind === 'owner-note' && e.next.note ? [e.next.note].map((n) => ({ id: n.id, text: n.text, stage: n.stage, between: !!start && ms(n.at) < start && ms(n.at) >= lastBefore })) : [];
+    const ln = lanesLine(root);
+    const laneHint = !ln && e.tier === 'deep' && e.current && LANE_STAGES.includes(e.current.stage.id) ? `this deep game's ${e.current.stage.title} can run as lanes at once: ${T} lanes plan` : null;
+    const budget = settledBudget(root, s);
+    const dropped = droppedOf(root, f, s);
+    const keepRec = readKeep(root);
+    const keep = { lines: keepLines(keepRec), lost: lostItems(keepRec).map((k) => ({ id: k.id, text: k.text, since: k.since })) };
+    const lanes = readLanes(root)?.lanes ?? [];
+    const look = { ...lookDue(root, f?.rounds ?? [], null, lanes), every: lookEvery(root) };
+    const stuck = stuckScores(root);
+    const board = (() => { try {
+        return boardLine(readBoard(root));
+    }
+    catch {
+        return null;
+    } })();
+    const base = { board, keep, look, stuck, autonomy, agreement, stage, builtEarly, first, session: sessionLive(root, o.now ?? Date.now()), lanes: ln?.line ?? laneHint, cap: settings.rounds, closedThisSession: closedSince(f, start), evidence: null, round: null, budget, refused: null, dropped, parked: null, hold: e.holds?.[0] ? { id: e.holds[0].id, text: e.holds[0].text } : null };
+    if (dropped)
+        return { ...base, builtEarly: [], first: [], phase: 'dropped', waitingOn: 'owner', ask: 'You set this game aside. Start a new idea whenever you like.', step: `the owner dropped this game (${dropped.at.slice(0, 10)}): "${short(dropped.words, 200)}"`, run: '', why: 'a drop is the owner\'s word: nothing more is built on this game; a new idea starts with `flow start`' };
+    const refusalRun = (rf) => rf.asking ? `ask the owner ${rf.asking} in the chat (a figure, or code-drawn) and record their words with progress answer` : rf.unset ? `${T} flow ask` : `the owner raises it (${T} assets budget <credits> --by owner) or chooses a code-drawn look on purpose; their act, never yours`;
+    const refusalFor = (id) => { const r = buildRefusal(root, id, s); return r ? { stage: id, says: r.says, asking: r.asking, unset: settledBudget(root, s).state === 'unset' } : null; };
+    const early = builtEarly.length ? ` (game code already changed past the scaffold before the plan is agreed: ${builtEarly.slice(0, 4).join(', ')}${builtEarly.length > 4 ? '…' : ''}; build no further until the owner agrees)` : '';
+    const note = e.next.kind === 'owner-note' ? e.next : null;
+    if (!agreement.agreed) {
+        if (agreement.change && !agreement.asking)
+            return { ...base, phase: 'plan', waitingOn: 'agent', step: `the owner asked for changes to the plan: "${short(agreement.change, 200)}"${early}`, run: `revise the plan (design/GDD.md, the frames), bump its version, then ${T} flow ask`, why: 'the plan is agreed by the owner, never by the agent; their changes come first' };
+        const rf = refusalFor(e.current?.stage.id);
+        if (rf)
+            return { ...base, refused: { stage: rf.stage, says: rf.says }, phase: 'plan', waitingOn: rf.asking ? 'owner' : 'agent', ...(rf.asking ? { ask: BUDGET_ASK } : {}), step: `${e.current.stage.title} does not start: ${rf.says}`, run: refusalRun(rf), why: REFUSAL_WHY };
+        if (note)
+            return { ...base, parked: noteParks(e.next.note, e.current), phase: 'plan', waitingOn: 'agent', step: `${e.next.step}${early}`, run: e.next.run, why: e.next.why };
+        if (autonomy.value !== 'go') {
+            const forks = s.open.filter((q) => q.kind !== 'plan');
+            if (forks.length) {
+                const named = forks.map((q) => `${q.id} (${q.kind}${q.topic ? `: ${q.topic.replace(/^pitch:/, '').replace(/^worth:.*/, 'worth building at this length?').replace(/^plan:override$/, 'see the plan as it stands?').replace(/^flow:budget$/, 'the budget')}` : ''})`).join(', ');
+                return { ...base, phase: 'plan', waitingOn: 'owner', ask: askForAnswers(forks), step: `the plan: waiting for the owner on ${named}${early}`, run: `ask the owner in the chat and record their answer: ${T} progress answer <Q> <option> "<their words>"; meanwhile only free plan work that does not depend on them (the invention, the hits, the GDD core), nothing paid`, why: `taste, spend and scope are the owner's to decide (autonomy ${autonomy.value}${autonomy.source === 'default' ? ', the default' : ''}); the agent proposes, the owner picks` };
+            }
+            const pitchDone = e.stages.find((x) => x.stage.id === 'pitch')?.done ?? true;
+            const studio = pitchDone ? readStudio(root) : null;
+            const pf = studio ? pitchForks(root, studio, s) : null;
+            if (pf?.needed && pf.unasked.length)
+                return { ...base, phase: 'plan', waitingOn: 'agent', step: `the plan: put the pitch's choices to the owner (${pf.unasked.map((c) => c.id).join(', ')})${early}`, run: `${T} pitch ask (each choice to the owner in the chat with your proposal and why), then ${T} pitch lock once they answer`, why: `the pitch's choices are the owner's (autonomy ${autonomy.value}); only their own "go" lets your proposals lock` };
+        }
+        const opening = e.current && (e.current.stage.id === 'key-look' || e.current.stage.id === PROTOTYPE_STAGE) ? e.current.stage.id : null;
+        if (opening) {
+            const ownerOnly = e.next.kind === 'gate' && e.next.gate?.gate.kind === 'owner' && e.current.gates.every((g) => g.state === 'met' || g.gate.kind === 'owner');
+            if (ownerOnly)
+                return { ...base, phase: 'plan', waitingOn: 'owner', ask: OPENING_ASK[opening], step: e.next.step, run: e.next.run, why: e.next.why };
+            return { ...base, phase: 'plan', waitingOn: 'agent', step: e.next.step, run: e.next.run, why: e.next.why };
+        }
+        if (planOpen)
+            return { ...base, phase: 'plan', waitingOn: 'agent', step: `the plan: ${e.next.step}${early}`, run: e.next.run, why: `the plan comes first, at the game's real size; the owner agrees it once, in the chat (${e.next.why})` };
+        if (agreement.asking)
+            return { ...base, phase: 'waiting', waitingOn: 'owner', ask: 'Read the plan, then say yes in the chat, or what to change.', step: `plan: waiting for the owner (${agreement.asking})${early}`, run: `show the plan in the chat; when the owner says yes, record it with their words: ${T} flow agree --by owner "<their words>"; meanwhile free plan work only`, why: 'the owner asked for this stop: the plan is agreed by them before the build (owner, 4 Oct)' };
+        return { ...base, phase: 'waiting', waitingOn: 'agent', step: `the plan is made: put it to the owner${early}`, run: `${T} flow ask (the plan and its price, ready to show in the chat)`, why: 'the owner agrees the plan before game code; the session may end once it is with them' };
+    }
+    const rounds = f?.rounds ?? [];
+    const closed = rounds.filter((r) => r.closed_at);
+    const kept = rounds.find((r) => !r.closed_at);
+    const keptStage = kept ? e.stages.find((x) => x.stage.id === kept.stage) : undefined;
+    const open = kept && keptStage && !keptStage.skipped ? kept : null;
+    const sinceGuess = ms(closed.at(-1)?.closed_at ?? agreement.at ?? f?.started_at);
+    const doneDuring = open ? undefined : e.stages.find((x) => !x.skipped && x.stage.status === 'done' && ms(x.stage.done_at) > sinceGuess && !closed.some((r) => r.stage === x.stage.id && r.met));
+    const isPlan = (x) => !!x && PLAN_STAGE_IDS.includes(x.stage.id);
+    const firstBuild = e.stages.find((x) => !isPlan(x) && !x.skipped && !x.done) ?? null;
+    const pick = open ? keptStage : doneDuring ?? e.current;
+    const sr = pick && isPlan(pick) ? (firstBuild ?? pick) : pick;
+    const evidence = sr ? roundEvidence(root, sr, ms(open?.opened_at ?? closed.at(-1)?.closed_at ?? agreement.at ?? f?.started_at), s) : null;
+    if (!sr || (e.next.kind === 'done' && !(open && evidence?.card !== null)))
+        return { ...base, phase: 'done', waitingOn: 'owner', ask: 'It is built. Play it, then say whether it is ready to publish.', step: 'every stage has its evidence: the owner plays it and says yes', run: `${T} progress report (the hand-back), then the owner's verdict: ${T} note verdict publish accept|reject`, why: e.next.why };
+    const since = open?.opened_at ?? closed.at(-1)?.closed_at ?? agreement.at ?? f?.started_at ?? new Date(0).toISOString();
+    const round = { n: open?.n ?? closed.length + 1, stage: sr.stage.id, since };
+    const lookNow = { ...lookDue(root, rounds, round.n, lanes), every: base.look.every };
+    const rb = { ...base, look: lookNow, round, evidence, phase: 'rounds', stage: { id: sr.stage.id, title: sr.stage.title, n: sr.index + 1, of: e.stages.length } };
+    const tag = `round ${round.n} · ${sr.stage.title}`;
+    const ev = evidence;
+    const blocking = s.open.filter((q) => q.kind !== 'plan' && (q.default === undefined || autonomy.value !== 'go'));
+    const rf = refusalFor(sr.stage.id);
+    if (rf)
+        return { ...rb, refused: { stage: rf.stage, says: rf.says }, waitingOn: rf.asking ? 'owner' : 'agent', ...(rf.asking ? { ask: BUDGET_ASK } : {}), step: `${tag}: does not start: ${rf.says}`, run: refusalRun(rf), why: REFUSAL_WHY };
+    if (e.next.kind === 'hold' && e.next.note)
+        return { ...rb, waitingOn: 'owner', ask: `Your note ${e.next.note.id} holds the build: say when it may go on.`, step: `${tag}: ${e.next.step}`, run: e.next.run, why: e.next.why };
+    if (note)
+        return { ...rb, parked: noteParks(e.next.note, sr), waitingOn: 'agent', step: `${tag}: ${e.next.step}${first.some((x) => x.between) ? ' — it came in between sessions: act on it first' : ''}`, run: e.next.run, why: e.next.why };
+    if (blocking.length) {
+        const q = blocking[0];
+        return { ...rb, waitingOn: 'owner', ask: askForAnswers(blocking), step: `${tag}: waiting for the owner on ${q.id} (${q.kind}): "${short(q.text, 120)}"`, run: `work on what does not depend on it; ask the owner in the chat and record their answer (${T} progress answer ${q.id} <option> "<their words>")`, why: 'a fork the owner asked to decide' };
+    }
+    if (keep.lost.length) {
+        const k = keep.lost[0];
+        return { ...rb, waitingOn: 'agent', step: `${tag}: a regression first: ${k.id} "${short(k.text, 160)}" worked (playtest ${k.since}) and is lost${keep.lost.length > 1 ? ` (also ${keep.lost.slice(1).map((x) => x.id).join(', ')})` : ''}`, run: `put it back (what the round showed: ${T} playtest keep), npm run build, then ${T} playtest; its ledger seat judges it again. If the owner wants it changed, only they take it off: ${T} playtest keep --drop ${k.id} --by owner "<their words>"`, why: 'a round that gains something and loses what already worked has not moved the game forward; the do-not-regress list is carried by every brief' };
+    }
+    if (stuck.length && ev.card === null) {
+        const k = stuck[0], last = k.playtests.at(-1);
+        const how = k.kind === 'experience'
+            ? `lift it one rung on the experience anchors (panel/experience.md: what the next number asks for; the seats' words in .funtools/playtest/${last}/)`
+            : `fix what the panel said holds it down (.funtools/playtest/${last}/report.md)`;
+        return { ...rb, waitingOn: 'agent', step: `${tag}: a critic score stuck low first: ${stuckLine(k)}; raising it is this round's fix${stuck.length > 1 ? ` (also stuck: ${stuck.slice(1).map((x) => x.label).join(', ')})` : ''}`, run: `${how}, npm run build, then the stage's gates and a card that names it: ${T} progress card --stage ${sr.stage.id} --shot last --line "${k.label}: <what changed>"; the next ${T} playtest scores it again`, why: `a score under ${STUCK_BELOW} for ${STUCK_PLAYTESTS} playtests means the rounds grow everything but it; a 2 is not a resting place` };
+    }
+    if (lookNow.state === 'due')
+        return { ...rb, waitingOn: 'agent', step: `${tag}: the whole-game look: would you ship this today?`, run: `${T} flow look (writes its brief; hand it to a fresh agent with only that file, who plays the whole game and files the answer), then ${T} flow look again to route each defect to its owner`, why: `${lookNow.why}. One look at the whole game while the parts are being built; it grades each defect and routes it to an owner, and never vetoes${lookNow.every ? ` (funpixel.json flow.look_every ${lookNow.every})` : ''}` };
+    if (lookNow.state === 'owed' && lookNow.last)
+        return { ...rb, waitingOn: 'agent', step: `${tag}: the whole-game look is owed: ${lookNow.why}`, run: `hand ${lookNow.last.brief} to a fresh agent with only that file; it writes ${lookNow.last.answer}; then ${T} flow look routes it`, why: 'the look routes the defects of the whole game to their owners; it never vetoes the round' };
+    if (ln?.active)
+        return { ...rb, waitingOn: 'agent', step: `${tag}: ${ln.line} — ${ln.next}`, run: ln.run, why: 'the stage runs as lanes: each merges on its own gate, a seat that did not build it, and the owner\'s picks; the round goes on when they have landed' };
+    const met = sr.gates.every((g) => g.state === 'met');
+    const fixes = targetFixes(root, sr);
+    if (fixes && ev.card === null && !ev.unrun.length && ms(fixes.at ?? undefined) <= ms(round.since)) {
+        return { ...rb, waitingOn: 'agent', step: `${tag}: build to the target — ${fixes.says}`, run: `apply those moves in the files they name (the whole list: ${T} score --fixes), npm run build, then ${T} score (same framing), ${T} capture, ${T} progress card --stage ${sr.stage.id} --shot last --line "<score before → after>", ${T} flow round`, why: `a round closes at the bar (funpixel.json accuracy_min, default 75) or on the owner's accept; the moves come from the measured gap, not taste${FLAT_ROUNDS ? `; ${FLAT_ROUNDS} rounds without a gain ask the owner about scope` : ''}` };
+    }
+    if (ev.unrun.length) {
+        const g = ev.unrun[0];
+        const raw = sr === e.current ? e.next.step : g.says;
+        const step = raw.startsWith(`${sr.stage.title}: `) ? raw.slice(sr.stage.title.length + 2) : raw;
+        return { ...rb, waitingOn: 'agent', step: `${tag}: ${step}`, run: `build it, then ${g.run}${ev.unrun.length > 1 ? `; also ${ev.unrun.slice(1).map((x) => x.gate.kind).join(', ')}` : ''}`, why: `a round closes on evidence: the stage's gates run on the current files (${sr.stage.why ?? (sr === e.current ? e.next.why : 'the plan\'s tests and the sim first')})` };
+    }
+    if (ev.card === null || ev.unpicked.length) {
+        return { ...rb, waitingOn: 'agent', step: `${tag}: ${met ? 'the gates are met: ' : ''}the look-dev loop, then show the owner this round`, run: `${T} capture at the target moments, ${T} compare --target <the plan's target frames>, fix the biggest difference, play it (${T} play); then update the GDD's ## Where we are (each capture beside its target, the gap left, the next step), show the captures in the chat, and record the round: ${T} progress card --stage ${sr.stage.id} --shot last --line "<what changed>" --next "<the next round>"${ev.unpicked.length ? ` (it picks up the owner's note${ev.unpicked.length > 1 ? 's' : ''} ${ev.unpicked.map((n) => n.id).join(', ')})` : ''}`, why: 'every round closes the gap between the game and its targets, with the built game in front of the owner in the chat and their new words picked up' };
+    }
+    return { ...rb, waitingOn: 'agent', step: `${tag}: the round has its evidence (gates ran, card ${ev.card})${met ? ' and the stage\'s gates are met' : ''}`, run: `${T} flow round (closes it${met ? '; the stage ends and the next round opens on the next stage' : '; the next round works on what the gates still name'})`, why: 'a round is closed on evidence, then the next one opens' };
+}
+export function keepRound(f, v) {
+    let rounds = f.rounds.filter((r) => r.closed_at || (v.round && r.stage === v.round.stage));
+    if (v.phase === 'rounds' && v.round && !rounds.some((r) => !r.closed_at))
+        rounds = [...rounds, { n: v.round.n, stage: v.round.stage, opened_at: v.round.since }];
+    return { ...f, rounds };
+}
+export function whereLine(v) {
+    const st = v.stage ? `${v.stage.title} (stage ${v.stage.n} of ${v.stage.of})` : 'every stage';
+    if (v.phase === 'plan')
+        return `the plan · ${st}`;
+    if (v.phase === 'waiting')
+        return `waiting for the owner to agree the plan${v.agreement.asking ? ` (${v.agreement.asking})` : ' (not asked yet)'}`;
+    if (v.phase === 'done')
+        return 'done: the owner plays it';
+    if (v.phase === 'dropped')
+        return `dropped by the owner (${v.dropped?.at.slice(0, 10) ?? ''})`;
+    return `rounds · round ${v.round.n} · ${st} · ${v.closedThisSession} of ${v.cap} this session`;
+}
+export function waitingLine(v) {
+    return v.waitingOn === 'owner' ? 'waiting on the owner (their word in the chat)' : 'your move, the agent\'s (nothing waits on the owner)';
+}
+export function ownerFirst(v) {
+    if (!v.agreement.agreed && v.agreement.change && !v.agreement.asking)
+        return `the owner asked for changes to the plan: "${short(v.agreement.change, 300)}" — revise the plan for every point, then \`${T} flow ask\``;
+    return null;
+}
+export function flowBlock(v) {
+    const out = ['## The flow (`npx @funpixel/tools flow` · .funtools/flow.json)'];
+    if (v.phase === 'dropped') {
+        out.push(`- where: ${whereLine(v)}`, `- the game is dropped: ${v.step}`, '- next: none. Nothing more is built on this game; do not suggest a next step.', `  why: ${v.why}`);
+        return out.join('\n');
+    }
+    const owner = ownerFirst(v);
+    if (owner)
+        out.push(`- FIRST: ${owner}`);
+    for (const k of v.keep.lost)
+        out.push(`- FIRST: a regression: ${k.id} "${short(k.text, 200)}" worked (playtest ${k.since}) and is lost; put it back before anything else`);
+    out.push(`- where: ${whereLine(v)}; ${waitingLine(v)}`);
+    if (v.board)
+        out.push(`- board: ${v.board} (\`${T} zero\`)`);
+    else if (v.phase === 'rounds' && v.board === null)
+        out.push(`- board: nothing measured yet — check, verify and profile stamp it (\`${T} zero\`)`);
+    out.push(`- plan: ${v.agreement.agreed ? `agreed — ${v.agreement.says}` : v.agreement.says}`);
+    const sec = v.agreement.sections;
+    if (sec)
+        out.push(sec.open.length
+            ? `  sections: the owner agreed ${sec.agreed} of ${sec.written} on the plan page; still open: ${sec.open.slice(0, 8).join(', ')}${sec.open.length > 8 ? ` and ${sec.open.length - 8} more` : ''}. Work those through with them; an agreed section reopens when you change its words`
+            : `  sections: the owner agreed every written section on the plan page; put the plan to them to lock (flow ask)`);
+    out.push(`- autonomy: ${v.autonomy.value} (${v.autonomy.source === 'owner' ? 'the owner\'s, funpixel.json flow.autonomy' : 'the default: the owner set none in funpixel.json flow.autonomy'})`);
+    out.push(`- budget: ${budgetLine(v.budget)}${v.refused ? ` — ${v.refused.stage} refused: ${v.refused.says}` : ''}`);
+    if (v.hold)
+        out.push(`- waiting on the owner: their note ${v.hold.id} holds the stage: "${short(v.hold.text, 200)}" (information, not a step: only they release it; never close it yourself)`);
+    for (const n of v.first)
+        out.push(`- first: the owner's note ${n.id}${n.between ? ' came in between sessions' : ''}: "${short(n.text, 200)}"`);
+    if (v.lanes)
+        out.push(`- ${v.lanes.startsWith('lanes:') ? v.lanes : `lanes: ${v.lanes}`}`);
+    const look = lookLines(v.look.last);
+    if (look.length)
+        out.push(`- ${look[0]}`, ...look.slice(1).map((l) => `  - ${l}`), ...(v.look.last?.defects.some((d) => d.routed === 'the owner') ? ['  the owner\'s are questions of taste or scope: put each to them in the chat'] : []));
+    for (const k of v.stuck)
+        out.push(`- stuck: ${stuckLine(k)}, under ${STUCK_BELOW} for ${STUCK_PLAYTESTS} playtests: a 2 is not a resting place`);
+    if (v.keep.lines.length)
+        out.push('- do not regress (what the whole-game review named as working; losing one is a regression):', ...v.keep.lines.map((l) => `  - ${l}`));
+    out.push(`- next: ${v.step}`);
+    out.push(`  run: ${v.run}`);
+    out.push(`  why: ${v.why}`);
+    if (v.parked)
+        out.push(`  held: ${v.parked}`);
+    out.push('', `Each turn, \`${T} flow\` names the one next step; you never need the other commands' names. The two stops are the owner's: the plan waits for their agreement, and after ${v.cap} round${v.cap === 1 ? '' : 's'} a session hands back with a card (resume with /fp:flow).`);
+    return out.join('\n');
+}
+export function stuckAsk(stage, title, n, says, now, id) {
+    return { type: 'ask', id, at: now.toISOString(), kind: 'scope', stage, text: `Stuck on ${title}: ${n} rounds without its gates (${short(says, 160)}). Skip it for now, cut it, or keep going?`, options: ['skip', 'cut', 'keep-going'], default: 'keep-going', timeout_ms: 10 * 60_000 };
+}
+export function flowAtStop(v) {
+    const key = `${v.phase}|${v.round?.n ?? ''}|${v.step}`;
+    if (v.phase === 'dropped')
+        return { key, warn: `Funpixel flow: the owner dropped this game. Nothing more is built; the session may end.` };
+    if (v.hold)
+        return { key: `hold|${v.hold.id}`, once: true, warn: `Funpixel flow: waiting on the owner: their note ${v.hold.id} holds the stage ("${short(v.hold.text, 160)}"). It is theirs to release, not a step to close; the turn may end here.` };
+    if (v.builtEarly.length && !v.agreement.agreed && !v.agreement.asking) {
+        return { key, warn: `Funpixel flow: game code changed before the plan was locked (${v.builtEarly.slice(0, 4).join(', ')}${v.builtEarly.length > 4 ? '…' : ''}). That is fine; when the plan is ready, put it to the owner once: \`${T} flow ask\`.` };
+    }
+    if (v.phase === 'waiting' && v.waitingOn === 'owner')
+        return { key, warn: `Funpixel flow: waiting for the owner to agree the plan (${v.agreement.asking}). The session may end here; the page has the plan and the Approve button. ${v.builtEarly.length ? `Game code already changed past the scaffold: ${v.builtEarly.slice(0, 4).join(', ')}.` : ''}`.trim() };
+    if (v.phase === 'done')
+        return { key, warn: 'Funpixel flow: every stage has its evidence; the owner plays it and says yes.' };
+    if (v.phase === 'rounds' && v.closedThisSession >= v.cap)
+        return { key, warn: `Funpixel flow: ${v.closedThisSession} round${v.closedThisSession === 1 ? '' : 's'} this session (the owner's cap, funpixel.json flow.rounds_per_session ${v.cap}). Hand back with the last card; the next session resumes with /fp:flow, the owner's new notes first.` };
+    if (v.parked)
+        return { key, once: true, warn: `Funpixel flow: ${v.parked}. Nothing the stage asks for can be done until then, so the turn may end here.` };
+    if (v.waitingOn === 'owner')
+        return { key, warn: `Funpixel flow: ${v.step}. The session may end; the owner's answer opens the next step.` };
+    const label = v.phase === 'rounds' ? `Round ${v.round.n} (${v.closedThisSession} of ${v.cap} this session)` : v.phase === 'waiting' ? 'The plan' : 'The plan';
+    const keep = v.keep.lines.length ? `\nDo not regress: ${v.keep.lines.map((l) => short(l, 90)).join('; ')}` : '';
+    return { key, block: `Funpixel flow — keep going. ${label}: ${v.step}\nrun: ${v.run}\nwhy: ${v.why}${keep}\nThe loop runs in this session until the owner's cap (${v.cap} rounds) or a question to the owner; \`${T} flow\` names each step.` };
+}

package/plugins/claude/hooks/vendor/flow/look.mjs

@@ -0,0 +1,140 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/flow/look.ts by the GDK build. Do not edit.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export const LOOK_DIR = join('.funtools', 'look');
+export const LOOK_INDEX = join(LOOK_DIR, 'index.json');
+export const LOOK_EVERY = 3;
+export const LOOK_MAX_DEFECTS = 8;
+export const SEVERITIES = ['blocker', 'major', 'minor'];
+export const OWNERS = ['rules', 'art', 'feel', 'audio', 'world', 'rooms', 'ui', 'owner'];
+export const OWNER_LANE = { rules: 'play', art: 'look', feel: 'feel', audio: 'audio', world: 'env', rooms: 'room' };
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return null;
+} };
+const short = (s, n = 200) => { const t = String(s ?? '').replace(/\s+/g, ' ').trim(); return t.length <= n ? t : `${t.slice(0, n - 1)}…`; };
+const T = 'npx @funpixel/tools';
+export const briefOf = (k) => join(LOOK_DIR, String(k), 'brief.md');
+export const answerOf = (k) => join(LOOK_DIR, String(k), 'look.json');
+export function lookEvery(root) {
+    const v = readJson(join(root, 'funpixel.json'))?.flow?.look_every;
+    const n = Number(v);
+    return v !== undefined && Number.isInteger(n) && n >= 0 && n <= 20 ? n : LOOK_EVERY;
+}
+export function playable(root, closedRounds) {
+    return closedRounds > 0 && readJson(join(root, 'verify.json'))?.verdict === 'pass';
+}
+export function routeOf(owner, lanes) {
+    if (owner === 'owner')
+        return 'the owner';
+    const kind = OWNER_LANE[owner];
+    const lane = kind ? lanes.find((l) => l.kind === kind && l.state !== 'dropped' && l.state !== 'merged') : undefined;
+    return lane ? `lane ${lane.id}` : 'the round';
+}
+export function readAnswer(file, lanes = []) {
+    if (!existsSync(file))
+        return { defects: [] };
+    let v;
+    try {
+        const raw = readFileSync(file, 'utf8');
+        v = JSON.parse(raw.slice(raw.indexOf('{'), raw.lastIndexOf('}') + 1));
+    }
+    catch {
+        return { defects: [], problem: 'no JSON in the answer' };
+    }
+    const ship = String(v?.ship ?? '').trim().toLowerCase();
+    if (ship !== 'yes' && ship !== 'no')
+        return { defects: [], problem: '"ship" is "yes" or "no"' };
+    const list = Array.isArray(v.defects) ? v.defects : [];
+    const bad = list.map((d, i) => {
+        const sev = String(d?.severity ?? '').toLowerCase(), own = String(d?.owner ?? '').toLowerCase();
+        if (!String(d?.what ?? '').trim())
+            return `defect ${i + 1} says nothing`;
+        if (!SEVERITIES.includes(sev))
+            return `defect ${i + 1}: severity is ${SEVERITIES.join(', ')}`;
+        if (!OWNERS.includes(own))
+            return `defect ${i + 1}: owner is one of ${OWNERS.join(', ')}`;
+        return null;
+    }).find(Boolean);
+    if (bad)
+        return { defects: [], problem: bad };
+    if (ship === 'no' && !list.length)
+        return { defects: [], problem: 'a "no" names what stands in the way (at least one defect)' };
+    const rank = (s) => SEVERITIES.indexOf(s);
+    const defects = list.map((d) => ({ what: short(d.what, 240), where: short(d.where ?? '', 160), severity: String(d.severity).toLowerCase(), owner: String(d.owner).toLowerCase() }))
+        .sort((a, b) => rank(a.severity) - rank(b.severity)).slice(0, LOOK_MAX_DEFECTS)
+        .map((d, i) => ({ id: `D${i + 1}`, ...d, routed: routeOf(d.owner, lanes) }));
+    return { ship, why: short(v.why ?? '', 400), defects };
+}
+export function readLooks(root, lanes = []) {
+    const idx = readJson(join(root, LOOK_INDEX));
+    const entries = Array.isArray(idx?.looks) ? idx.looks.filter((e) => Number.isInteger(e?.k)) : [];
+    return entries.map((e) => {
+        const a = readAnswer(join(root, answerOf(e.k)), lanes);
+        const filed = !!a.ship;
+        return { k: e.k, round: Number(e.round) || 0, prepared_at: String(e.prepared_at ?? ''), brief: briefOf(e.k), answer: answerOf(e.k), filed, ...(a.ship ? { ship: a.ship, why: a.why } : {}), defects: a.defects, ...(a.problem ? { problem: a.problem } : {}) };
+    });
+}
+export function lookDue(root, rounds, round, lanes = []) {
+    const every = lookEvery(root);
+    const looks = readLooks(root, lanes);
+    const last = looks.at(-1) ?? null;
+    if (last && !last.filed)
+        return { state: 'owed', why: last.problem ? `the answer cannot be read: ${last.problem}` : 'its brief is out and no answer is filed', last, next: null };
+    const lastFiled = [...looks].reverse().find((l) => l.filed) ?? null;
+    if (!every || round === null)
+        return { state: 'none', why: every ? 'no round open' : 'the owner turned it off (funpixel.json flow.look_every 0)', last: lastFiled, next: null };
+    const closed = rounds.filter((r) => r.closed_at);
+    if (!playable(root, closed.length))
+        return { state: 'none', why: 'the game does not play yet: the first look opens the round after the first playable (a round closed on a passing verify)', last: null, next: null };
+    if (!lastFiled)
+        return { state: 'due', why: 'the game plays and nobody has looked at it whole yet', last: null, next: round };
+    const since = closed.filter((r) => r.n >= lastFiled.round).length;
+    if (since >= every)
+        return { state: 'due', why: `${since} round${since === 1 ? '' : 's'} closed since the last look (round ${lastFiled.round}); one every ${every}`, last: lastFiled, next: round };
+    return { state: 'none', why: `the last look was in round ${lastFiled.round}; the next after ${every - since} more closed round${every - since === 1 ? '' : 's'}`, last: lastFiled, next: round + (every - since) };
+}
+export function lookBrief(o) {
+    const L = [];
+    L.push(`# The whole-game look · ${o.game} · round ${o.round}`, '');
+    L.push('You are not building this game. You look at ALL of it, the way a producer would before shipping, and answer one question: **would you ship this today?**', '');
+    L.push('## Look at the whole game', '');
+    L.push(`1. Read \`design/GDD.md\`: what the game promises (its hook, its target frames, its length), and its \`## The vision\` when it has one: the scale and set-pieces it grows toward, not owed yet (a defect is what is broken or thin, never the vision not reached).`);
+    L.push(`2. Play it from the title to an ending on a phone: \`${T} play --viewport phone\` (every screen, a win and a loss when you can reach them).`);
+    L.push(`3. Look at every view: \`${T} capture --all\`, then the frames in \`.funtools/capture/\` beside the plan's targets in \`design/first-look/\`.`);
+    L.push('4. Read the latest playtest report (`.funtools/playtest/<n>/report.md`) when there is one: what the panel and the blind player said.', '');
+    if (o.keep.length)
+        L.push('What already works (the do-not-regress list): check each still does; one that does not is a blocker owned by whoever broke it.', ...o.keep.map((k) => `- ${k}`), '');
+    if (o.previous?.defects.length)
+        L.push(`The last look (round ${o.previous.round}) said ${o.previous.ship === 'yes' ? 'ship' : 'not yet'}; its defects, to see whether each is still there:`, ...o.previous.defects.map((d) => `- ${d.id} (${d.severity}, ${d.owner}): ${d.what}`), '');
+    L.push('## Grade and route each defect', '');
+    L.push(`- **severity**: \`blocker\` (you would not ship with it), \`major\` (you would ship only out of time), \`minor\` (polish).`);
+    L.push(`- **owner**: who fixes it: ${OWNERS.filter((x) => x !== 'owner').map((x) => `\`${x}\``).join(', ')}, or \`owner\` for a question of taste or scope only the person who owns the game decides (cut it, change the look, grow the world).`);
+    if (o.lanes.length)
+        L.push(`- Lanes out on the game: ${o.lanes.map((l) => `${l.id} (${l.kind}${l.title ? `: ${l.title}` : ''})`).join(', ')}. A defect goes to the lane of its kind.`);
+    L.push(`- At most ${LOOK_MAX_DEFECTS}, worst first, each with where you saw it (a frame or a step). Name what you saw, not a fix.`);
+    L.push('- You route; you never veto. Your answer stops no round and fails no check: it decides who fixes what next.', '');
+    L.push('## Answer with ONLY this JSON', '', '```json');
+    L.push('{"ship": "yes|no", "why": "one or two sentences", "defects": [{"what": "…", "where": "frame or step", "severity": "blocker|major|minor", "owner": "rules|art|feel|audio|world|rooms|ui|owner"}]}');
+    L.push('```', '', '## Filing', '', `Write the JSON, and nothing else, to this file with your file-writing tool:\n${o.answer}`, `Then reply with one line: \`filed\`. The agent building the game runs \`${T} flow look\` to route it.`, '');
+    return L.join('\n');
+}
+export function prepareLook(root, round, brief, now = new Date()) {
+    const idx = readJson(join(root, LOOK_INDEX));
+    const entries = Array.isArray(idx?.looks) ? idx.looks : [];
+    const k = Math.max(0, ...entries.map((e) => Number(e.k) || 0)) + 1;
+    const file = join(root, briefOf(k));
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, brief(k, join(root, answerOf(k))));
+    const next = [...entries, { k, round, prepared_at: now.toISOString() }];
+    writeFileSync(join(root, LOOK_INDEX), JSON.stringify({ looks: next }, null, 2) + '\n');
+    return { k, round, prepared_at: now.toISOString(), brief: briefOf(k), answer: answerOf(k), filed: false, defects: [] };
+}
+export function lookLines(l) {
+    if (!l?.filed)
+        return [];
+    return [`the whole-game look (round ${l.round}): would you ship this today? ${l.ship}${l.why ? ` — ${short(l.why, 200)}` : ''}`, ...l.defects.map((d) => `${d.id} ${d.severity} → ${d.routed}${d.routed.startsWith('lane ') || d.routed === 'the owner' ? '' : ` (${d.owner})`}: ${short(d.what, 160)}`)];
+}
+export const laneDefects = (l, laneId) => (l?.filed ? l.defects.filter((d) => d.routed === `lane ${laneId}`).map((d) => `${d.id} (${d.severity}, the whole-game look in round ${l.round}): ${d.what}${d.where ? ` — ${d.where}` : ''}`) : []);