@funpixel/tools 0.0.0-stage → 0.1.1

package/plugins/cursor/hooks/vendor/lanes/lanes.mjs

@@ -0,0 +1,356 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/lanes/lanes.ts by the GDK build. Do not edit.
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { isOpenDecision, readDecisions } from '../memory/decisions.mjs';
+import { readProgress } from '../progress/progress.mjs';
+export const LANES_DIR = join('.funtools', 'lanes');
+export const LANES_FILE = join(LANES_DIR, 'lanes.json');
+export const LANE_COSTS = join(LANES_DIR, 'costs.jsonl');
+export const WORKTREES_DIR = join('.funtools', 'worktrees');
+export const CHECKPOINT_MIN = 45;
+export const LOOK_FLOOR = 75;
+export const USD_PER_CREDIT = 0.01;
+const T = 'npx @funpixel/tools';
+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 = 160) => (s.length <= n ? s : `${s.slice(0, n - 1)}…`);
+const posix = (p) => p.split('\\').join('/');
+export function readLanes(root) {
+    const f = readJson(join(root, LANES_FILE));
+    if (!f || !Array.isArray(f.lanes))
+        return null;
+    return { version: 1, planned_at: String(f.planned_at ?? ''), lanes: f.lanes.map((l) => ({ ...l, verdicts: Array.isArray(l.verdicts) ? l.verdicts : [] })) };
+}
+export function writeLanes(root, f) {
+    const p = join(root, LANES_FILE);
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify(f, null, 2) + '\n');
+}
+export const laneGame = (root, l) => join(root, l.worktree, l.prefix ?? '');
+export const laneDir = (root, id) => join(root, LANES_DIR, id);
+export const briefPath = (root, id) => join(root, LANES_DIR, id, 'brief.md');
+export const verifyPath = (root, id) => join(root, LANES_DIR, id, 'verify.md');
+export function logMaking(root, e) {
+    const p = join(laneDir(root, e.lane), 'making.jsonl');
+    mkdirSync(dirname(p), { recursive: true });
+    appendFileSync(p, JSON.stringify({ at: e.at ?? new Date().toISOString(), ...e }) + '\n');
+}
+export function readMaking(root, id) {
+    let text = '';
+    try {
+        text = readFileSync(join(laneDir(root, id), 'making.jsonl'), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    return text.split('\n').filter((l) => l.trim()).flatMap((l) => { try {
+        return [JSON.parse(l)];
+    }
+    catch {
+        return [];
+    } });
+}
+export function readCosts(root) {
+    let text = '';
+    try {
+        text = readFileSync(join(root, LANE_COSTS), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    return text.split('\n').filter((l) => l.trim()).flatMap((l) => { try {
+        return [JSON.parse(l)];
+    }
+    catch {
+        return [];
+    } });
+}
+export function spentUsd(root, id) {
+    const paid = readCosts(root).filter((c) => c.lane === id && !c.est).reduce((n, c) => n + (Number(c.usd) || 0), 0);
+    const said = readMaking(root, id).filter((e) => e.kind === 'checkpoint' || e.kind === 'final').reduce((n, e) => n + (Number(e.cost_usd) || 0), 0);
+    return Math.round((paid + said) * 100) / 100;
+}
+export function recordLaneCost(root, c) {
+    const line = { at: c.at ?? new Date().toISOString(), lane: c.lane, kind: c.kind, ...(c.tool ? { tool: c.tool } : {}), credits: c.credits, usd: c.usd ?? Math.round(c.credits * USD_PER_CREDIT * 100) / 100, ...(c.job_id ? { job_id: c.job_id } : {}), ...(c.est ? { est: true } : {}) };
+    mkdirSync(join(root, LANES_DIR), { recursive: true });
+    appendFileSync(join(root, LANE_COSTS), JSON.stringify(line) + '\n');
+    logMaking(root, { lane: c.lane, kind: 'cost', line: `${line.kind}${line.tool ? ` (${line.tool})` : ''}: ${line.credits} credit(s), $${line.usd.toFixed(2)}${line.job_id ? ` · job ${line.job_id}` : ''}`, cost_usd: 0, at: line.at });
+    return line;
+}
+export function capRefusal(root, lane, estimateCredits) {
+    const spent = spentUsd(root, lane.id);
+    const next = Math.max(0, estimateCredits) * USD_PER_CREDIT;
+    if (spent < lane.cap_usd - 1e-9 && spent + next <= lane.cap_usd + 1e-9)
+        return null;
+    return `lane ${lane.id} has spent $${spent.toFixed(2)} of its $${lane.cap_usd.toFixed(2)} cap; this call (about $${next.toFixed(2)}) would pass it. Paused and reported: the owner raises it with \`${T} lanes cap ${lane.id} <usd> --by owner\``;
+}
+const BASE_GATES = [{ kind: 'synced' }, { kind: 'owns' }, { kind: 'tests' }];
+const TAIL_GATES = [{ kind: 'report' }, { kind: 'verifier' }];
+export const KINDS = {
+    play: {
+        title: 'Play: the rules and the core verb', scope: 'the rules as data and code, the controls, the session: what the player does and what it does back',
+        owns: ['src/rules.ts', 'src/input.ts', 'src/session.ts', 'src/sim/**', 'test/rules.test.ts', 'test/probes.ts', 'test/*.rules.test.ts'],
+        evidence: ['the GDD\'s named behaviour tests pass (npm test)', 'the bots play the rules: the naive bot loses runs, a careful player at a human pace wins some (funtools sim)'],
+        do: ['Read the GDD\'s numbers and behaviour tests; write each missing test first, red', 'Change the rules until the tests pass, numbers from the GDD (never invented)', 'Run the bots (`' + T + ' sim`) and tune until the challenge bites at a human pace'],
+        read: ['design/GDD.md (## The numbers, ### Behaviour tests)', 'test/probes.ts'],
+        gates: [...BASE_GATES, { kind: 'sim' }, ...TAIL_GATES], cap_usd: 5, timebox_min: 240,
+    },
+    look: {
+        title: 'Look: palette, HUD and screens against the target frames', scope: 'how the game looks in play: the palette roles, the HUD, the title and end screens, held beside the target frames',
+        owns: ['src/look.json', 'src/look.ts', 'src/styles.css', 'src/screens.tsx', 'src/screens.css', 'src/hud.tsx', 'src/hud-kit.tsx', 'src/hud-kit.css', 'src/icons.tsx', 'design/look/**', 'design/picks/**', 'public/assets/ui/**'],
+        evidence: [`each target frame this lane owns scores ${LOOK_FLOOR}+ beside its capture at the same framing (\`${T} score --target\`; 90 is the stretch)`, 'where the look is the owner\'s taste, they picked between two or three candidates (`' + T + ' pick`)', 'the owner\'s eye on the frames is the floor; the score is the compass'],
+        do: ['Capture the play view at the target\'s framing; put it beside the target (`' + T + ' compare --target`)', 'Name the biggest difference, fix it, capture again; repeat until the floor', 'For a taste call (hero, hands, title), make two or three candidate stills under .funtools/picks/ and put them to the owner: `' + T + ' pick <topic> a.png b.png c.png --lane <this lane>`'],
+        read: ['design/first-look/ (the target frames)', 'design/GDD.md (## AD rules, ## Identity lock)', 'src/look.json'],
+        gates: [...BASE_GATES, { kind: 'look', min: LOOK_FLOOR }, { kind: 'pick' }, ...TAIL_GATES], cap_usd: 12, timebox_min: 300,
+    },
+    feel: {
+        title: 'Feel: the response to every event', scope: 'what each event the player causes or suffers looks and feels like: the juice table, hit stop, shake, timing',
+        owns: ['src/juice.ts', 'src/feel.ts', 'src/strike.ts', 'test/feel.json'],
+        evidence: ['every row of the GDD\'s ## Juice table has its response in code', 'the feel windows hold (`' + T + ' feel`) and the tests pass'],
+        do: ['Read ## Juice; build each row\'s response', 'Measure it (`' + T + ' feel`); fix what it names'],
+        read: ['design/GDD.md (## Juice)', 'test/feel.json'],
+        gates: [...BASE_GATES, ...TAIL_GATES], cap_usd: 3, timebox_min: 180,
+    },
+    audio: {
+        title: 'Audio: the sound of every event', scope: 'the sound of each event in the juice table, the music, the mix',
+        owns: ['src/sound.ts', 'public/assets/audio/**', 'assets/audio/**'],
+        evidence: ['each juice-table event has its cue (or a chosen silence)', 'the cues are mastered and loud enough (`' + T + ' loudness`)'],
+        do: ['List the cues from ## Juice', 'Make or generate each (`' + T + ' gen sound`), wire it in src/sound.ts', 'Check the levels (`' + T + ' loudness`)'],
+        read: ['design/GDD.md (## Juice, ## Audio)'],
+        gates: [...BASE_GATES, ...TAIL_GATES], cap_usd: 5, timebox_min: 180,
+    },
+    env: {
+        title: 'World: the places, ground, props and the living cast', scope: 'the world the game is played in: ground, structures, props, the creatures and people that live in it',
+        owns: ['src/living.ts', 'src/characters.ts', 'src/world/**', 'public/assets/env/**', 'assets/env/**'],
+        evidence: ['the world read holds (`' + T + ' check --world`): nothing floating, no flat boxes near the camera, everything alive animated', `the places' target frames score ${LOOK_FLOOR}+`],
+        do: ['Build the places from the kit sheets in design/first-look', 'Read the world (`' + T + ' check --world`) and fix what it names', 'Score each place against its target'],
+        read: ['design/first-look/ (the kit sheets, the places\' frames)', 'design/GDD.md (## World)'],
+        gates: [...BASE_GATES, { kind: 'look', min: LOOK_FLOOR }, ...TAIL_GATES], cap_usd: 10, timebox_min: 300,
+    },
+};
+function roomSpec(room) {
+    return {
+        title: `Room ${room}: one place, its par, what it teaches, its exit`, scope: `room ${room} as data: its layout, its par time, the one thing it teaches, its exit into the next`,
+        owns: [`design/levels/${room}.json`, `design/spec/rooms/${room}.json`, `src/levels/${room}.ts`, `test/${room}.test.ts`],
+        evidence: [`the bots clear room ${room} over 5 seeds within its par (\`${T} sim\`)`, 'the tests pass'],
+        do: [`Write room ${room} as data (never hand-placed in code)`, 'Give it a par, a teaches line and an exit', `Run the bots on it (\`${T} sim\`) until they clear it at a human pace`],
+        read: ['design/GDD.md (## Levels, ## The numbers)', 'design/levels/ (the rooms already made)'],
+        gates: [...BASE_GATES, { kind: 'sim' }, ...TAIL_GATES], cap_usd: 8, timebox_min: 240,
+    };
+}
+export const STAGE_LANES = {
+    'core-test': ['play', 'feel'],
+    slice: ['play', 'look', 'audio'],
+    hook: ['feel', 'look', 'audio'],
+    accuracy: ['look', 'env'],
+    walk: ['env', 'play'],
+    'blind-play': ['play', 'look'],
+    panel: ['look', 'feel', 'play'],
+};
+export function roomIds(root, list) {
+    for (const d of [join('design', 'spec', 'rooms'), join('design', 'levels')]) {
+        const ids = list(join(root, d)).filter((n) => n.endsWith('.json')).map((n) => n.replace(/\.json$/, ''));
+        if (ids.length)
+            return ids;
+    }
+    return [];
+}
+export function extraGates(root, has) {
+    const m = readJson(join(root, 'funpixel.json')) ?? {};
+    const own = Array.isArray(m?.lanes?.gates) ? m.lanes.gates.filter((g) => g && g.kind === 'command' && typeof g.run === 'string').map((g) => ({ kind: 'command', name: String(g.name ?? g.run), run: String(g.run) })) : [];
+    if (existsSync(join(root, 'design', 'spec')) && has('spec') && !own.some((g) => /spec lint/.test(g.run ?? '')))
+        own.push({ kind: 'command', name: 'spec lint', run: `${T} spec lint` });
+    return own;
+}
+export function makeLane(id, stage, i, o = {}) {
+    const room = /^room-(.+)$/.exec(id)?.[1];
+    const kind = (room ? 'room' : id);
+    const spec = room ? roomSpec(room) : KINDS[kind];
+    if (!spec)
+        throw new Error(`no lane kind "${id}": one of ${Object.keys(KINDS).join(', ')}, or room-<id>`);
+    const gates = [...spec.gates];
+    gates.splice(gates.findIndex((g) => g.kind === 'report'), 0, ...(o.extra ?? []));
+    return {
+        id, kind, title: spec.title, stage, scope: spec.scope, owns: spec.owns, evidence: spec.evidence, do: spec.do, read: spec.read,
+        cap_usd: o.cap ?? spec.cap_usd, timebox_min: o.timebox ?? spec.timebox_min, checkpoint_min: CHECKPOINT_MIN,
+        branch: `lane/${id}`, worktree: posix(join(WORKTREES_DIR, id)), port: 5200 + i * 10, gates, state: 'planned', verdicts: [],
+    };
+}
+const globRe = (g) => new RegExp(`^${g.split('/**')[0].replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '[^/]*')}${g.endsWith('/**') ? '(/.*)?' : ''}$`);
+export const owned = (patterns, path) => patterns.some((g) => globRe(g).test(posix(path)));
+export function outside(f, lane, changed) {
+    return changed.filter((p) => !owned(lane.owns, p)).map((path) => ({ path, owner: f.lanes.find((l) => l.id !== lane.id && owned(l.owns, path))?.id ?? null }));
+}
+export function touchesLane(d, lane) {
+    if (!d.touches.length)
+        return true;
+    return d.touches.some((t) => t === 'all' || t === lane.id || t === lane.kind || owned(lane.owns, t) || lane.owns.some((p) => owned([t], p)));
+}
+export const openDecisionsFor = (root, lane) => readDecisions(root).filter((d) => isOpenDecision(d) && touchesLane(d, lane));
+export const picksFor = (root, id) => readProgress(root).questions.filter((q) => q.lane === id && q.frames);
+export const pickedByOwner = (q) => !!q.answer && q.answer.by === 'owner';
+export function touchesOfWords(text) {
+    const t = text.toLowerCase();
+    const out = [];
+    if (/\b(look\w*|colou?rs?|palette|hud|button|font|title|screen|menu|ugly|art|style|sprite|icon|gun|hands?|pose|hold|big|small|size|bright|dark|grey|gray)\b/.test(t))
+        out.push('look');
+    if (/\b(sounds?|music|audio|sfx|voices?|loud|quiet|silent|mix)\b/.test(t))
+        out.push('audio');
+    if (/\b(rules?|jump\w*|speed|fast|slow|hard|easy|controls?|lose|win|score|enemy|enemies|bots?|difficulty|pass(ed)? (through )?(doors?|walls?))\b/.test(t))
+        out.push('play');
+    if (/\b(feel\w*|juice|hit|shake|impact|snappy|floaty|weight|punch)\b/.test(t))
+        out.push('feel');
+    if (/\b(world|rooms?|levels?|places?|ground|trees?|props?|floor|walls?|creatures?|people)\b/.test(t))
+        out.push('env');
+    return [...new Set(out)];
+}
+export function laneView(root, f, lane, head, now) {
+    const spent = spentUsd(root, lane.id);
+    const making = readMaking(root, lane.id);
+    const lastCp = [...making].reverse().find((e) => e.kind === 'checkpoint' || e.kind === 'final' || e.kind === 'start');
+    const minutes = lane.started_at ? Math.round((now - ms(lane.started_at)) / 60_000) : null;
+    const base = { lane, spent, minutes, lastCheckpoint: lastCp ? lastCp.line : null, head };
+    const id = lane.id;
+    if (lane.state === 'merged')
+        return { ...base, status: 'merged', says: `merged ${lane.merged_at?.slice(0, 16) ?? ''} (${lane.merge_sha?.slice(0, 7) ?? ''})`, next: '' };
+    if (lane.state === 'dropped')
+        return { ...base, status: 'dropped', says: 'dropped', next: '' };
+    if (lane.state === 'planned')
+        return { ...base, status: 'planned', says: 'not started', next: `${T} lanes start ${id}` };
+    if (spent > lane.cap_usd + 1e-9)
+        return { ...base, status: 'stuck', says: `over its cap: $${spent.toFixed(2)} of $${lane.cap_usd.toFixed(2)}; paid calls are refused`, next: `the owner raises it (${T} lanes cap ${id} <usd> --by owner) or drops the lane` };
+    const fresh = (sha) => !!sha && !!head && sha === head;
+    if (lane.state === 'running') {
+        if (minutes !== null && minutes > lane.timebox_min)
+            return { ...base, status: 'stuck', says: `past its time-box (${minutes} of ${lane.timebox_min} min)`, next: `hand back what plays: ${T} lanes done ${id}, or the owner gives it more time` };
+        const quiet = lastCp ? (now - ms(lastCp.at)) / 60_000 : null;
+        if (quiet !== null && quiet > lane.checkpoint_min * 2)
+            return { ...base, status: 'stuck', says: `no checkpoint for ${Math.round(quiet)} min (due every ${lane.checkpoint_min})`, next: `${T} lanes checkpoint ${id} --line "<what changed>" --shot <still>` };
+        return { ...base, status: 'running', says: lastCp ? short(lastCp.line, 100) : 'started', next: `the lane's agent works its brief; ${T} lanes done ${id} runs the gate` };
+    }
+    const verdict = [...lane.verdicts].reverse().find((v) => fresh(v.sha));
+    if (!lane.gate || !fresh(lane.gate.sha))
+        return { ...base, status: 'waiting gate', says: lane.gate ? 'the gate ran on an older commit' : 'the gate has not run', next: `${T} lanes gate ${id}` };
+    if (!lane.gate.passed) {
+        const bad = lane.gate.checks.filter((c) => c.state !== 'pass');
+        return { ...base, status: 'gate failed', says: bad.map((c) => `${c.name}: ${short(c.says, 90)}`).slice(0, 3).join('; '), next: `the lane fixes it in its worktree, then ${T} lanes gate ${id}` };
+    }
+    if (verdict?.says === 'fail')
+        return { ...base, status: 'reopened', says: `the verifier (${verdict.by}) failed it: ${short(verdict.words ?? '', 120)}`, next: `the lane fixes what the verifier named, then ${T} lanes done ${id}` };
+    if (!verdict)
+        return { ...base, status: 'waiting verifier', says: 'the gate passed; a seat that did not build it has not judged it', next: `a verifier reads ${posix(join(LANES_DIR, id, 'verify.md'))}, then ${T} lanes verdict ${id} pass|fail --by <seat>` };
+    const open = picksFor(root, id).filter((q) => !pickedByOwner(q));
+    if (open.length)
+        return { ...base, status: 'waiting owner', says: `the owner has not picked: ${open.map((q) => `${q.id} ${q.topic ?? ''}`.trim()).join(', ')}`, next: 'show the owner the candidates in the chat and record their pick: `' + T + ' pick choose <topic> <option> --by owner`' };
+    return { ...base, status: 'ready', says: `gate passed, verified by ${verdict.by}`, next: `${T} lanes merge ${id}` };
+}
+export function lanesLine(root, now = Date.now()) {
+    const f = readLanes(root);
+    if (!f || !f.lanes.length)
+        return null;
+    const views = f.lanes.map((l) => laneView(root, f, l, l.gate?.sha ?? null, now));
+    const active = views.filter((v) => !['merged', 'dropped'].includes(v.status));
+    if (!active.length)
+        return { active: 0, line: `lanes: all ${views.filter((v) => v.status === 'merged').length} merged`, next: '', run: '' };
+    const counts = new Map();
+    for (const v of active)
+        counts.set(v.status, (counts.get(v.status) ?? 0) + 1);
+    const order = ['ready', 'gate failed', 'reopened', 'stuck', 'waiting gate', 'waiting verifier', 'waiting owner', 'planned', 'running'];
+    const first = order.map((s) => active.find((v) => v.status === s)).find(Boolean);
+    return { active: active.length, line: `lanes: ${[...counts].map(([s, n]) => `${n} ${s}`).join(', ')}`, next: `lane ${first.lane.id} (${first.status}): ${first.says}`, run: first.next || `${T} lanes status` };
+}
+export const BRIEF_MAX_CHARS = 12_000;
+export const BRIEF_DROP_ORDER = ['before', 'others', 'bar', 'read', 'why', 'look'];
+export function renderBrief(f, lane, x, cap = BRIEF_MAX_CHARS) {
+    const others = f.lanes.filter((l) => l.id !== lane.id && l.state !== 'dropped').map((o) => `- Lane ${o.id} owns (stay out): ${o.owns.map((p) => `\`${p}\``).join(', ')}`);
+    const parts = { before: [...x.before], others, bar: [...(x.bar ?? [])], read: [...lane.read], why: [...x.why], look: [...(x.look ?? [])] };
+    const cut = {};
+    let text = briefText(lane, x, parts, cut, cap);
+    for (const k of BRIEF_DROP_ORDER) {
+        while (text.length > cap && parts[k].length) {
+            parts[k].pop();
+            cut[k] = (cut[k] ?? 0) + 1;
+            text = briefText(lane, x, parts, cut, cap);
+        }
+    }
+    return text;
+}
+function briefText(lane, x, p, cut, cap) {
+    const left = (k, where) => (cut[k] ? [`- ${cut[k]} more left out (this brief is capped at ${cap} characters): ${where}`] : []);
+    const checks = lane.gates.map((g) => `- ${checkWords(g)}`);
+    const L = [];
+    L.push(`# Lane ${lane.id} · ${lane.title}`, '');
+    L.push(`**1. What this lane is.** You are the ${lane.id.toUpperCase()} lane of ${x.game}, on stage \`${lane.stage}\`: ${lane.scope}. You work only in this lane's checkout and only on the paths it owns. Other lanes run at the same time.`, '');
+    L.push('**2. Where.**', `- Game: \`${x.home}\` (branch \`${x.homeBranch}\`${x.base ? `, base \`${x.base.slice(0, 10)}\`` : ''})`, `- Your checkout: \`${x.worktreeAbs}\` on branch \`${lane.branch}\``, `- Your ports: ${lane.port}–${lane.port + 9} (a dev server: \`npm run dev -- --port ${lane.port}\`)`, '');
+    L.push('**3. Read first.**', '- design/decisions.md (the live decisions; never re-argue one)', ...p.read.map((r) => `- ${r}`), ...left('read', `the lane's whole list is in ${LANES_FILE}`), '- This brief, to the end', '');
+    L.push('**4. The owner\'s words.**');
+    if (x.decisions.length)
+        for (const d of x.decisions)
+            L.push(`- ${d.id} (${d.date}): "${d.owner ?? d.choice}"${d.shot ? ` · their screenshot: \`${d.shot}\`` : ''}${d.from ? ` · from ${d.from}` : ''}`, `  The decision: ${d.choice.replace(/[.\s]+$/, '')}${d.over ? `, over ${d.over}` : ''}. ${d.because ? `Because: ${d.because}.` : ''} Build it in this lane and say in your report how it shows.`);
+    else
+        L.push('- None open on this lane. New owner notes become decisions (`' + T + ' decide --from N<n>`) and reach the next brief.');
+    if (p.bar.length || cut.bar)
+        L.push('- Their standing bar, carried from every earlier game (never make them say it again; build to the lines your lane touches):', ...p.bar.map((b) => `  - ${b}`), ...left('bar', 'the whole bar is in design/owner-bar.json').map((l) => `  ${l}`));
+    if (x.keep?.length)
+        L.push('- Do not regress: what already works, named by the whole-game review. Losing one is a regression, whatever else the lane gains; one marked LOST comes back first:', ...x.keep.map((k) => `  - ${k}`));
+    L.push('');
+    L.push('**5. Why now, and what failed before.**', ...(p.why.length || cut.why ? p.why.map((w) => `- ${w}`) : ['- The stage\'s gates name nothing missing; build to the evidence below.']), ...left('why', `the stage's gates: \`${T} flow\``), ...p.before.map((b) => `- Before: ${b}`), ...left('before', `\`${T} lanes gate ${lane.id}\` and the verifier's verdicts`), ...p.look.map((d) => `- The whole-game look routed to this lane: ${d}`), ...left('look', `\`${T} flow look\``), '');
+    L.push('**6. You own; you stay out.**', `- You own: ${lane.owns.map((q) => `\`${q}\``).join(', ')}`);
+    L.push(...p.others, ...left('others', `other lanes' paths: stay out of every path not listed as yours (the gate refuses them; \`${T} lanes status\`)`));
+    L.push('- Everything else (src/main.tsx, package.json, funpixel.json, design/GDD.md, design/decisions.md) is the integrator\'s. Need a change there? Say so in a checkpoint; the gate refuses a commit that touches it, and a write outside your paths is refused as you make it. A shared list\'s `fp:union` block (the level list in src/levels.ts) is the one exception: add your one line inside the block, change nothing else.', '');
+    L.push('**7. Setup.**', `- \`cd ${x.worktreeAbs}\` (node_modules is linked from the game; never reinstall it)`, '- Never `git stash` (it is shared across worktrees), never rewrite history, never push or merge: the integrator merges.', `- Keep your own game running while you work: \`${T} dev\` in your checkout (it records its address there), so the owner watches your part live beside the others.`, '');
+    L.push('**8. Rules.**', `- Spend cap: $${lane.cap_usd.toFixed(2)}. Every paid funtools call made in this checkout is logged against this lane; past the cap they are refused and the owner is told. Log spend made any other way: \`${T} lanes checkpoint ${lane.id} --cost <usd> --line "…"\`.`, `- Time-box: ${lane.timebox_min} min from the start. Past it, hand back what plays.`, '- Commit only your own paths (`git add <path>`), never `git add -A`; records under .funtools/ stay out of your commits.', '');
+    L.push('**9. Do.**', ...lane.do.map((d, i) => `${i + 1}. ${d}`), '');
+    L.push('**10. Checkpoints.**', `- At least every ${lane.checkpoint_min} min: \`${T} lanes checkpoint ${lane.id} --line "<what changed, what you tried>" --shot <a still beside its target>\` (\`--minutes\`, \`--cost\` when you know them). Show each in the chat; silence for two cadences reads as stuck.`, '');
+    L.push('**11. The evidence that closes it.**', ...lane.evidence.map((e) => `- ${e}`), '', 'The gate checks, in order:', ...checks, '', 'A verifier seat that did not build your lane judges it: it runs the same checks and looks at the stills.', '');
+    L.push('**12. Hand back.**', `- Commit your work in the checkout, then \`${T} lanes done ${lane.id}\` (it runs the gate). A failing check names what to fix: fix it and run it again.`, `- Behind the landed work? \`${T} lanes sync ${lane.id}\` takes it first.`, '- Do not merge; the integrator runs `' + T + ' lanes merge ' + lane.id + '` once the gate, the verifier and the owner\'s picks pass.', '');
+    L.push('**13. Report.**', `- \`${T} lanes checkpoint ${lane.id} --final --line "<what plays now, the spend, what is still weak>" --shot <the best still>\`, then a short reply: the stills, the spend, what is still weak.`, '');
+    return L.join('\n');
+}
+export function renderVerifyBrief(lane, x) {
+    return [
+        `# Verify lane ${lane.id}`, '',
+        `You did not build this lane and you do not read its making-of or its report. In \`${x.worktreeAbs}\`:`, '',
+        `1. Run \`${T} lanes gate ${lane.id}\` and read each check.`,
+        '2. Build it and look at the play view yourself (`npm run build`, then `' + T + ' capture --view playing --viewport phone`); hold each still beside its target in design/first-look.',
+        '3. Hold it to the evidence that closes it:', ...lane.evidence.map((e) => `   - ${e}`),
+        `4. Record your verdict: \`${T} lanes verdict ${lane.id} pass|fail --by <your seat name> "<what you saw>"\`. A fail names the one thing to fix; it reopens the lane.`, '',
+    ].join('\n');
+}
+export function checkWords(g) {
+    switch (g.kind) {
+        case 'synced': return 'synced: the lane has the landed work (the game\'s branch is in its history)';
+        case 'owns': return 'owns: every changed file is one this lane owns; nothing uncommitted';
+        case 'tests': return 'tests: `npm test` exits 0 in the checkout';
+        case 'sim': return `sim: the bots play the rules on the lane's files (\`${T} sim\`)`;
+        case 'look': return `look: each owned target frame at ${g.min ?? LOOK_FLOOR}+ on the lane's files (design/look/scores.json); not scored is not a pass`;
+        case 'command': return `${g.name ?? g.run}: \`${g.run}\` exits 0`;
+        case 'report': return 'report: at least one checkpoint from the lane (what it tried)';
+        case 'verifier': return 'verifier: a seat that did not build it passed it, on this commit';
+        case 'pick': return 'pick: the owner chose between the lane\'s candidates (when it put any)';
+    }
+}
+export function makingSection(root, lane, o) {
+    const m = readMaking(root, lane.id);
+    const tried = m.filter((e) => e.kind === 'checkpoint').map((e) => `  - ${e.at.slice(11, 16)} ${e.line}${e.evidence ? ` (${e.evidence})` : ''}`);
+    const final = [...m].reverse().find((e) => e.kind === 'final');
+    const v = [...lane.verdicts].reverse().find((x) => x.says === 'pass');
+    const refused = m.filter((e) => e.kind === 'refused').map((e) => `  - ${e.line}`);
+    const minutes = lane.started_at ? Math.round((o.at.getTime() - ms(lane.started_at)) / 60_000) : null;
+    return [
+        `## Lane ${lane.id} · ${lane.title} (merged ${o.at.toISOString().slice(0, 10)}, ${o.sha.slice(0, 7)})`, '',
+        `- Built by ${lane.builder ?? lane.id}; verified by ${v?.by ?? '?'}${v?.words ? `: "${v.words}"` : ''}`,
+        `- Spend: $${spentUsd(root, lane.id).toFixed(2)} of $${lane.cap_usd.toFixed(2)} · time: ${minutes ?? '?'} of ${lane.timebox_min} min`,
+        ...(o.carried.length ? [`- The owner's words it built: ${o.carried.map((d) => `${d.id} "${short(d.owner ?? d.choice, 80)}"`).join('; ')}`] : []),
+        ...(tried.length ? ['- What it tried:', ...tried] : []),
+        ...(refused.length ? ['- What the gate refused first:', ...refused] : []),
+        `- Evidence: ${(lane.gate?.checks ?? []).map((c) => `${c.name} ${c.state}`).join(' · ')}`,
+        ...(final ? [`- Still weak: ${final.line}`] : []),
+        '',
+    ].join('\n');
+}

package/plugins/cursor/hooks/vendor/lanes/union.mjs

@@ -0,0 +1,63 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/lanes/union.ts by the GDK build. Do not edit.
+const OPEN = /\bfp:union\b(?!\s+end\b)/;
+const CLOSE = /\bfp:union\s+end\b/;
+export const hasUnion = (text) => text.split('\n').some((l) => OPEN.test(l));
+export function outsideUnion(text) {
+    const out = [];
+    let inside = false;
+    for (const line of text.split('\n')) {
+        if (inside) {
+            if (CLOSE.test(line)) {
+                inside = false;
+                out.push(line);
+            }
+            continue;
+        }
+        if (OPEN.test(line))
+            inside = true;
+        out.push(line);
+    }
+    return inside ? null : out.join('\n');
+}
+export function unionOnlyChange(before, after) {
+    if (typeof before !== 'string' || !hasUnion(before))
+        return false;
+    const a = outsideUnion(before);
+    return a !== null && a === outsideUnion(after);
+}
+export function resolveUnion(text) {
+    const lines = text.split('\n');
+    const out = [];
+    let inside = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.startsWith('<<<<<<<')) {
+            if (!inside)
+                return null;
+            const ours = [], theirs = [];
+            let part = ours;
+            let j = i + 1;
+            for (; j < lines.length && !lines[j].startsWith('>>>>>>>'); j++) {
+                const l = lines[j];
+                if (l.startsWith('|||||||'))
+                    part = null;
+                else if (l.startsWith('======='))
+                    part = theirs;
+                else
+                    part?.push(l);
+            }
+            if (j >= lines.length)
+                return null;
+            if ([...ours, ...theirs].some((l) => OPEN.test(l) || CLOSE.test(l)))
+                return null;
+            const have = new Set(ours.map((l) => l.trim()));
+            out.push(...ours, ...theirs.filter((l) => !have.has(l.trim())));
+            i = j;
+            continue;
+        }
+        if (inside ? CLOSE.test(line) : OPEN.test(line))
+            inside = !inside;
+        out.push(line);
+    }
+    return out.join('\n');
+}

package/plugins/cursor/hooks/vendor/lessons/motifs.mjs

@@ -0,0 +1,98 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/lessons/motifs.ts by the GDK build. Do not edit.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+import { signatureOf } from '../wow/picks.mjs';
+export const motifsPath = (home = homedir()) => join(home, '.funpixel', 'lessons', 'motifs.jsonl');
+const KEEP = 50;
+const NOUNS = 10;
+const STOP = new Set(('about above after again against all also and any are around as at away back be because been before being below between both but by can ' +
+    'come comes could down each every few for from game games get gets has have her here him his how into its just keep like make makes more ' +
+    'most must near never new not now off once one only onto other our out over own play player players plays same should side some such ' +
+    'than that the their them then there these they this those through too under until upon very was were what when where which while who ' +
+    'why will with without would you your yours style look looks flat palette colour colours color colors light lit shading outline ' +
+    'outlines tone tones ink inks two three four five single first last each world screen screens small big large bright dark deep soft ' +
+    'across guide dodge dodges swirl swirls hard warm cool rule rules frame target accepted provisional ruled because reflex merely avoided reason medium roles hero harm help surface background').split(' '));
+function field(note, label) {
+    const m = new RegExp(`\\*\\*${label}:\\*\\*\\s*(.+)`, 'i').exec(note);
+    return m ? m[1].trim() : '';
+}
+function lookLine(note) {
+    const m = /^##\s*Look\s*\n+([^\n]+)/im.exec(note);
+    return m ? m[1].trim() : '';
+}
+export function nounsOf(text, n = NOUNS) {
+    const out = [];
+    for (const raw of text.toLowerCase().replace(/#[0-9a-f]{3,8}\b/g, ' ').match(/[a-z]{4,}/g) ?? []) {
+        const w = raw.replace(/ies$/, 'y').replace(/(?<=[^s])s$/, '');
+        if (STOP.has(w) || STOP.has(raw) || out.includes(w) || (w.length > 5 && /ing$/.test(w)) || /(?<!f)ly$/.test(w))
+            continue;
+        out.push(w);
+        if (out.length === n)
+            break;
+    }
+    return out;
+}
+export function motifOf(root) {
+    const notePath = ['GDD.md', 'README.md'].map((f) => join(root, 'design', f)).find((p) => existsSync(p));
+    if (!notePath)
+        return null;
+    const note = readFileSync(notePath, 'utf8');
+    const read = (p) => { try {
+        return JSON.parse(readFileSync(join(root, p), 'utf8'));
+    }
+    catch {
+        return {};
+    } };
+    const manifest = read('funpixel.json'), style = read(join('assets', 'style.json'));
+    const title = (/^#\s+(.+)$/m.exec(note)?.[1] ?? manifest.name ?? basename(root)).trim();
+    const roles = {};
+    for (const [k, v] of Object.entries(style.roles ?? {}))
+        if (typeof v === 'string')
+            roles[k] = v;
+    const nouns = nounsOf([title, field(note, 'Pitch'), field(note, 'The 6-second ad'), lookLine(note)].join(' '));
+    if (!nouns.length && !Object.keys(roles).length)
+        return null;
+    const sig = signatureOf(note);
+    return { at: new Date().toISOString(), game: resolve(root), title, genre: String(manifest.metadata?.genre ?? ''), roles, nouns, ...(sig ? { wow: { signature: sig.id, expression: sig.expression } } : {}) };
+}
+export function allMotifs(home = homedir()) {
+    const p = motifsPath(home);
+    if (!existsSync(p))
+        return [];
+    return readFileSync(p, 'utf8').split('\n').flatMap((l) => { try {
+        const m = JSON.parse(l);
+        return m?.game ? [m] : [];
+    }
+    catch {
+        return [];
+    } });
+}
+const readAll = allMotifs;
+export function recordMotif(root, home = homedir(), extra = {}) {
+    const found = motifOf(root);
+    if (!found)
+        return null;
+    const all = readAll(home);
+    const prev = all.find((x) => x.game === found.game);
+    const verb = extra.verb || prev?.verb, stills = extra.stills && Object.keys(extra.stills).length ? extra.stills : prev?.stills;
+    const m = { ...found, ...(verb ? { verb } : {}), ...(stills ? { stills } : {}) };
+    const same = (x) => JSON.stringify([x.title, x.roles, x.nouns, x.verb ?? '', x.stills ?? {}, x.wow ?? null]);
+    if (prev && same(prev) === same(m))
+        return prev;
+    const kept = [...all.filter((x) => x.game !== m.game), m].slice(-KEEP);
+    mkdirSync(join(home, '.funpixel', 'lessons'), { recursive: true });
+    writeFileSync(motifsPath(home), kept.map((x) => JSON.stringify(x)).join('\n') + '\n');
+    return m;
+}
+export function recentMotifs(exceptRoot, n = 5, home = homedir()) {
+    const self = exceptRoot ? resolve(exceptRoot) : '';
+    return readAll(home).filter((m) => m.game !== self).sort((a, b) => b.at.localeCompare(a.at)).slice(0, n);
+}
+export function motifLines(motifs) {
+    return motifs.map((m) => {
+        const roles = Object.entries(m.roles).slice(0, 4).map(([k, v]) => `${k} ${v}`).join(', ');
+        return `- ${m.title}${m.genre ? ` (${m.genre})` : ''}: ${m.nouns.join(', ')}${roles ? ` · palette ${roles}` : ''}`;
+    });
+}
+export const MOTIF_HEADING = 'Recently used in other games on this machine: context, not a ban on motifs or palettes';

package/plugins/cursor/hooks/vendor/lessons/store.mjs

@@ -0,0 +1,57 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/lessons/store.ts by the GDK build. Do not edit.
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+export const LESSONS_FILE = join('.funtools', 'lessons.jsonl');
+export const sharedDir = (home = homedir()) => join(home, '.funpixel', 'lessons');
+const slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'any';
+export const lessonKey = (finding) => finding.toLowerCase().replace(/[^a-z0-9 ]+/g, ' ').split(/\s+/).filter(Boolean).join(' ');
+function readLines(path) {
+    if (!existsSync(path))
+        return [];
+    const out = [];
+    for (const line of readFileSync(path, 'utf8').split('\n')) {
+        try {
+            const l = JSON.parse(line);
+            if (l && typeof l.finding === 'string' && typeof l.fix === 'string')
+                out.push(l);
+        }
+        catch { }
+    }
+    return out;
+}
+export function addLesson(root, lesson, share = false, home = homedir()) {
+    const full = { at: new Date().toISOString(), game: basename(root), ...lesson };
+    mkdirSync(join(root, '.funtools'), { recursive: true });
+    appendFileSync(join(root, LESSONS_FILE), JSON.stringify(full) + '\n');
+    if (share) {
+        mkdirSync(sharedDir(home), { recursive: true });
+        appendFileSync(join(sharedDir(home), `${slug(lesson.genre)}.jsonl`), JSON.stringify(full) + '\n');
+    }
+    return full;
+}
+export function rankLessons(root, genre, home = homedir()) {
+    const shared = existsSync(sharedDir(home))
+        ? readdirSync(sharedDir(home)).filter((f) => f.endsWith('.jsonl')).flatMap((f) => readLines(join(sharedDir(home), f)))
+        : [];
+    const local = root ? readLines(join(root, LESSONS_FILE)) : [];
+    const mine = new Set(local.map((l) => `${l.at}|${l.game}|${l.finding}`));
+    const groups = new Map();
+    for (const l of [...local, ...shared.filter((l) => !mine.has(`${l.at}|${l.game}|${l.finding}`))]) {
+        if (slug(l.genre) !== slug(genre) && slug(l.genre) !== 'any')
+            continue;
+        const k = lessonKey(l.finding);
+        groups.set(k, [...(groups.get(k) ?? []), l]);
+    }
+    return [...groups.values()].map((ls) => {
+        const newest = ls.reduce((a, b) => (b.at >= a.at ? b : a));
+        const deltas = ls.map((l) => l.delta).filter((d) => typeof d === 'number');
+        return {
+            finding: newest.finding, fix: newest.fix, genre: newest.genre, seen: ls.length, games: new Set(ls.map((l) => l.game)).size,
+            delta: deltas.length ? Math.max(...deltas) : null, last: newest.at,
+        };
+    }).sort((a, b) => b.games - a.games || b.seen - a.seen || (b.delta ?? 0) - (a.delta ?? 0) || b.last.localeCompare(a.last));
+}
+export function lessonLines(ranked, n = 3) {
+    return ranked.slice(0, n).map((l) => `- ${l.finding} → ${l.fix} (${l.games > 1 ? `${l.games} games` : `seen ${l.seen}×`}${l.delta !== null ? `, +${l.delta}` : ''})`);
+}