@funpixel/tools 0.0.0-stage → 0.1.1

package/plugins/robin/claude/hooks/durable.mjs

@@ -0,0 +1,56 @@
+import { spawnSync } from 'node:child_process';
+import { realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { readState, writeState } from './lib.mjs';
+const git = (root, ...args) => spawnSync('git', ['-C', root, ...args], { encoding: 'utf8', timeout: 5000 });
+const real = (p) => { try {
+    return realpathSync(p);
+}
+catch {
+    return p;
+} };
+export function inTemp(root) {
+    const r = real(root);
+    return [real(tmpdir()), '/tmp', '/private/tmp', '/var/folders', '/private/var/folders'].some((t) => r === t || r.startsWith(`${t}/`));
+}
+export function gitState(root) {
+    const inside = git(root, 'rev-parse', '--is-inside-work-tree');
+    if (inside.error)
+        return { repo: null };
+    if (inside.status !== 0 || inside.stdout.trim() !== 'true')
+        return { repo: false };
+    const status = git(root, 'status', '--porcelain', '--untracked-files=all', '--', '.');
+    const files = status.status === 0 ? status.stdout.split('\n').filter((l) => l.trim()).map((l) => l.slice(3)) : [];
+    const remote = git(root, 'remote').stdout.trim().length > 0;
+    const ahead = git(root, 'rev-list', '--count', '@{u}..HEAD');
+    return { repo: true, files, remote, unpushed: ahead.status === 0 ? Number(ahead.stdout.trim()) || 0 : null };
+}
+export function durableLine(root, st = gitState(root)) {
+    const parts = [];
+    if (inTemp(root))
+        parts.push(`the game lives in a temp folder (${root}), which the system wipes — move it to a folder of its own`);
+    if (st.repo === false)
+        parts.push('the game is not in git — `git init`, commit, and push to a remote so it cannot be lost');
+    else if (st.repo) {
+        const n = st.files.length;
+        if (n)
+            parts.push(`${n} file${n === 1 ? '' : 's'} not committed — commit and push (\`git add -A\`, \`git commit\`, \`git push\`)`);
+        if (!st.remote)
+            parts.push('no remote — push the game somewhere it survives this machine (`git remote add origin …`, then `git push -u origin HEAD`)');
+        else if (!n && st.unpushed)
+            parts.push(`${st.unpushed} commit${st.unpushed === 1 ? '' : 's'} not pushed — \`git push\``);
+    }
+    return parts.length ? `Funpixel: keep the game — ${parts.join('; ')}.` : null;
+}
+export function durableNote(input, root) {
+    if (process.env.FUNPIXEL_GDK_DURABLE === 'off')
+        return null;
+    const state = readState(input);
+    if (state.durableNoted)
+        return null;
+    const line = durableLine(root);
+    if (!line)
+        return null;
+    writeState(input, { ...readState(input), durableNoted: Date.now() });
+    return line;
+}

package/plugins/robin/claude/hooks/fence.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { forHost, isMain, readInput, readState, startDir, writeState } from './lib.mjs';
+import { fence } from './vendor/lanes/fence.mjs';
+export function fenceAnswer(input) {
+    let a = null;
+    try {
+        a = fence({ cwd: startDir(input), agentType: input.agent_type, tool: String(input.tool_name ?? ''), input: input.tool_input ?? {} });
+    }
+    catch {
+        return null;
+    }
+    if (!a)
+        return null;
+    if ('deny' in a)
+        return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: a.deny } };
+    const state = readState(input);
+    const noted = Array.isArray(state.fenceNoted) ? state.fenceNoted : [];
+    if (noted.includes(a.lane))
+        return null;
+    writeState(input, { ...state, fenceNoted: [...noted, a.lane] });
+    return { hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: a.note } };
+}
+async function main() {
+    const out = fenceAnswer(await readInput());
+    if (out)
+        process.stdout.write(forHost(JSON.stringify(out)));
+}
+if (isMain(import.meta.url)) {
+    main().catch((e) => process.stderr.write(`funpixel fence: ${e instanceof Error ? e.message : e}\n`));
+}

package/plugins/robin/claude/hooks/floors.mjs

@@ -0,0 +1,181 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { declaredActors, judgeMotion, recordProblems } from './vendor/look/roles.mjs';
+import { readsUnchanged } from './vendor/verify/reads.mjs';
+const FLOOR_VIEWS = [
+    { what: 'win', re: /win|won|victor|clear|complete|success|result/i, unless: /\bendless\b|\bno win\b/i,
+        fix: 'the screen a won round ends on (or say "endless" in the design note when no round is won)' },
+    { what: 'how-to', re: /how|help|tutorial|controls|guide|learn/i,
+        fix: 'the objective and the real controls on keyboard and touch, in pictures, reachable from the title and pause' },
+    { what: 'settings', re: /setting|option/i,
+        fix: 'at least sound on or off and screen shake and flashes on or off (reduced motion), reachable from the title and pause' },
+];
+export function declaredViews(index, fingerprint) {
+    const names = new Set();
+    for (const c of Object.values(index ?? {})) {
+        if (c && c.fingerprint === fingerprint && Array.isArray(c.views))
+            for (const v of c.views)
+                names.add(String(v));
+    }
+    return [...names];
+}
+export function viewFloors(views, note) {
+    if (!views.length)
+        return [];
+    return FLOOR_VIEWS.filter((f) => !views.some((v) => f.re.test(v)) && !(f.unless && f.unless.test(note)))
+        .map((f) => `The game declares no ${f.what} view in __FPX_VIEWS__ (declared: ${views.join(', ')}). Add ${f.fix}, declare it, and capture it (skill funpixel-gdd, floors).`);
+}
+export function momentFloor(index, fingerprint) {
+    const fresh = Object.values(index ?? {}).filter((c) => c && c.fingerprint === fingerprint && c.entered === true);
+    const listed = fresh.filter((c) => Array.isArray(c.moments));
+    if (!listed.length)
+        return [];
+    const moments = [...new Set(listed.flatMap((c) => c.moments.map(String)))];
+    if (!moments.length) {
+        return ['The game declares no signature moment: add one __FPX_VIEWS__ entry marked `moment: true` whose enter() drives the game into its payoff through its own rules (the swarm mid-fight, the chain popping, the boss hit), call __FPX_MOMENT__ where the payoff plays, and capture it at both sizes (skill funpixel-verify).'];
+    }
+    const shotAt = (vp) => fresh.some((c) => moments.includes(c.view) && c.viewport === vp);
+    return shotAt('desktop') && shotAt('phone') ? [] : [
+        `The signature moment (${moments.join(', ')}) was not captured at both sizes on this build: run \`npx @funpixel/tools capture --view ${moments[0]} --viewport desktop|phone\` (it plays as a burst) before the panel.`,
+    ];
+}
+const MOTION_RUN = 'npx @funpixel/tools scene --motion --view playing';
+export function motionFloor(record, fingerprint, note, root = null) {
+    if (!record || (record.fingerprint !== fingerprint && !(root && readsUnchanged(root, record)))) {
+        return { items: [`No motion check on this build: run \`${MOTION_RUN}\` (it judges each actor against the Motion column of the design document's ## Actors).`], unseen: [] };
+    }
+    const problems = recordProblems(record);
+    if (problems.length) {
+        return { items: [`The motion check is unreadable (${problems.slice(0, 3).join('; ')}): run \`${MOTION_RUN}\` again. An unreadable sample is not evidence.`], unseen: [] };
+    }
+    const { defects, unobserved } = judgeMotion(record, declaredActors(note ?? ''));
+    return {
+        items: defects.length ? [`Motion by role: ${defects.join('; ')}. Give each the motion its role declares, or mark it \`still\` in the ## Actors table if it should rest (skill funpixel-art, references/animation.md).`] : [],
+        unseen: unobserved,
+        fault: defects.length > 0,
+    };
+}
+const TEST_FILE = /\.(test|spec)\.[cm]?[jt]sx?$/;
+export function playerFloor(root, fingerprint) {
+    const { item, findings } = playerState(root, fingerprint);
+    return item ? { items: [item], findings: findings ?? [] } : { items: [], findings: [] };
+}
+function playerState(root, fingerprint) {
+    const dir = join(root, '.funtools', 'play');
+    const retry = 'Run the blind player through `npx @funpixel/tools play --viewport phone` on the game folder for this build, then file its report (skill funpixel-verify).';
+    const rounds = existsSync(dir) ? readdirSync(dir).filter((s) => /^round-\d+$/.test(s))
+        .sort((a, b) => Number(b.slice(6)) - Number(a.slice(6))) : [];
+    let report;
+    for (const round of rounds) {
+        const path = join(dir, round, 'report.json');
+        if (!existsSync(path))
+            continue;
+        try {
+            const r = JSON.parse(readFileSync(path, 'utf8'));
+            if (r?.viewport === 'desktop')
+                continue;
+            report = r;
+            break;
+        }
+        catch {
+            return { item: `The latest player report is unreadable. ${retry}` };
+        }
+    }
+    if (report && report.viewport === 'phone' && typeof report.fingerprint !== 'string') {
+        return { item: `The latest phone round played a URL (${report.target ?? 'unknown'}) with no local source identity, so it cannot stand for this build. ${retry}` };
+    }
+    if (!report || report.viewport !== 'phone' || report.fingerprint !== fingerprint || report.source_changed !== false) {
+        return { item: `No fresh phone player report tied to the build actually played. ${retry}` };
+    }
+    if (!Number.isInteger(report.steps) || report.steps < 1 || !Array.isArray(report.defects) || !Array.isArray(report.criteria)) {
+        return { item: `The phone player report is incomplete. ${retry}` };
+    }
+    const unresolved = ['start', 'goal', 'act'].filter((k) => report[k]?.answer !== 'yes');
+    const high = report.defects.filter((d) => d?.severity === 'high');
+    const failed = report.criteria.filter((c) => c?.verdict === 'fail');
+    if (report.blocked === true || unresolved.length || high.length || failed.length) {
+        const named = [...unresolved, ...high.map((d) => String(d.title ?? '')), ...failed.map((c) => String(c.id ?? ''))].filter(Boolean);
+        const said = [...unresolved.map((k) => `${k} not understood or working`), ...high.map((d) => d.title),
+            ...failed.map((c) => `${c.id}: ${c.note || 'criterion failed'}`)].filter(Boolean).join('; ');
+        return {
+            item: `The phone player still has open findings: ${said || report.blocking || 'see its report'}. Fix them, verify and replay; to hand back before they are fixed, record each in the design note's \`## Fix round\` table (skill funpixel-verify).`,
+            findings: named.length ? named : ['blocked'],
+        };
+    }
+    return {};
+}
+function hasTestFile(dir, depth = 0) {
+    if (depth > 4 || !existsSync(dir))
+        return false;
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+        if (e.name === 'node_modules' || e.name.startsWith('.') || e.name === 'dist')
+            continue;
+        if (e.isDirectory() ? hasTestFile(join(dir, e.name), depth + 1) : TEST_FILE.test(e.name))
+            return true;
+    }
+    return false;
+}
+const TEST_RUN = 'npx @funpixel/tools test';
+export function testSuiteItem(root, fingerprint) {
+    let script = '';
+    try {
+        script = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).scripts?.test ?? '';
+    }
+    catch { }
+    if (!script || /no test specified/.test(script) || !hasTestFile(root)) {
+        return `No test suite for the rules: add test/*.test.ts (a test named after each rule, run under Node) and "test": "node --test test/*.test.ts" in package.json, then run \`${TEST_RUN}\` (skill funpixel-game-logic).`;
+    }
+    let run = null;
+    try {
+        run = JSON.parse(readFileSync(join(root, '.funtools', 'tests.json'), 'utf8'));
+    }
+    catch { }
+    if (!run || !Number.isInteger(run.exit) || run.fingerprint !== fingerprint) {
+        return `The rules suite has no recorded run on these files: run \`${TEST_RUN}\` (it runs npm test and records its exit with the build fingerprint).`;
+    }
+    return run.exit === 0 ? null : `The rules suite FAILED on these files (npm test exit ${run.exit}): fix the failing rules or tests, then run \`${TEST_RUN}\` again (skill funpixel-game-logic).`;
+}
+const AUDIT = 'npx @funpixel/tools audit-screens --viewport phone';
+export function phoneLayoutFloor(record, fingerprint) {
+    const out = { items: [], unseen: [] };
+    for (const [surface, how, flag] of [['phone-portrait', 'portrait', ''], ['phone-landscape', 'landscape', ' --orientation landscape']]) {
+        const r = record?.[surface];
+        if (!r || r.fingerprint !== fingerprint) {
+            out.unseen.push(`${how} layout (never measured on this build: \`${AUDIT}${flag}\`)`);
+            continue;
+        }
+        if (r.verdict !== 'fail')
+            continue;
+        const where = (r.failing ?? []).map((f) => `${f.view} (${(f.failed ?? []).join(', ').replace(/_/g, ' ')})`).join('; ');
+        out.items.push(`audit-screens on the phone held ${how} (${r.size}) fails on this build: ${where}. Fix the layout (skill funpixel-mobile-ui: safe areas, tap targets, text) and run \`${AUDIT}${flag}\` again.`);
+    }
+    return out;
+}
+const LOOK_3D = 'npx @funpixel/tools look --3d';
+export function isThreeGame(root) {
+    try {
+        const m = JSON.parse(readFileSync(join(root, 'funpixel.json'), 'utf8')).metadata ?? {};
+        return m.dimension === '3d' || m.framework === 'threejs';
+    }
+    catch {
+        return false;
+    }
+}
+export function heroMakeFloor(root, record, fingerprint, said) {
+    const out = { items: [], unseen: [] };
+    if (!isThreeGame(root))
+        return out;
+    if (!record || record.fingerprint !== fingerprint) {
+        out.unseen.push(`3D heroes (what they are made of was not read on this build: \`${LOOK_3D}\`)`);
+        return out;
+    }
+    if (record.verdict !== 'fail' || said === null)
+        return out;
+    const text = said.toLowerCase();
+    const stem = (f) => String(f).replace(/\.[^.]+$/, '').toLowerCase();
+    const missing = (record.unnamed ?? []).filter((f) => (f === 'the scene' ? !/scene|everything/.test(text) : !text.includes(stem(f))));
+    if (/stand-?ins?\b/.test(text) && !missing.length)
+        return out;
+    out.items.push(`${LOOK_3D} says ${record.says ?? 'the heroes are code primitives'}. Name each as a stand-in in the hand-back (${missing.length ? `not named: ${missing.join(', ')}` : 'say "stand-in"'}) with what will replace it, or take the hero route (skill funpixel-3d, references/hero-route.md), or declare the style in funpixel.json "art3d" with its reason and a proof frame.`);
+    return out;
+}

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

@@ -0,0 +1,154 @@
+import { readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { currentFingerprint, readState, sessionStartMs, writeState } from './lib.mjs';
+import { pipelineEval } from './pipeline.mjs';
+import { FLOW_FILE, beat, flowAtStop, flowBlock, flowView, ownerFirst, planAgreement, readFlow } from './vendor/flow/flow.mjs';
+import { OPENING_STAGES, readPipeline } from './vendor/pipeline/pipeline.mjs';
+export function flowBeat(root, kind) {
+    try {
+        if (root && readFlow(root))
+            beat(root, kind, { by: 'gdk' });
+    }
+    catch { }
+}
+export async function flowStart(root, input) {
+    if (input && flowQuiet(input, root))
+        return { block: adoptionOffer(input, root, await flowNow(root, input).catch(() => null)), first: null, quiet: true };
+    const v = await flowNow(root, input);
+    if (!v)
+        return { block: null, first: null };
+    const line = ownerFirst(v);
+    return { block: flowBlock(v), first: line ? `## The owner first\n- ${line}` : null };
+}
+export const BUILT_FILES = 10;
+export function builtGame(root) {
+    const f = readFlow(root);
+    if (!f || f.dropped)
+        return null;
+    const p = readPipeline(root);
+    if (p?.stages.some((st) => OPENING_STAGES.includes(st.id)))
+        return null;
+    const files = Object.keys(f.scaffold ?? {}).length;
+    if (files < BUILT_FILES)
+        return null;
+    let verdict = null;
+    try {
+        verdict = JSON.parse(readFileSync(join(root, 'verify.json'), 'utf8')).verdict;
+    }
+    catch {
+        return null;
+    }
+    if (verdict !== 'pass')
+        return null;
+    try {
+        if (planAgreement(root).agreed)
+            return null;
+    }
+    catch {
+        return null;
+    }
+    return { files };
+}
+export function flowQuiet(input, root) {
+    if (!root || !readFlow(root))
+        return false;
+    if (readState(input).flowBuilt) {
+        try {
+            return !planAgreement(root).agreed;
+        }
+        catch {
+            return true;
+        }
+    }
+    const b = builtGame(root);
+    if (b)
+        writeState(input, { ...readState(input), flowBuilt: b.files });
+    return Boolean(b);
+}
+export function adoptionOffer(input, root, v = null) {
+    const state = readState(input);
+    if (state.flowOffered)
+        return null;
+    writeState(input, { ...state, flowOffered: Date.now() });
+    const at = v?.stage ? `"stage ${v.stage.n} of ${v.stage.of}: ${v.stage.title}"` : 'its first stage';
+    return [
+        '## The flow (`npx @funpixel/tools flow` · .funtools/flow.json)',
+        `- this game was built before its flow began (verify passed; ${state.flowBuilt ? `${state.flowBuilt} code files` : 'its code'} when the flow started; its path has no first look or first playable), so the flow's ${at} does not describe it. The flow stays silent on this game: work on what the owner asks.`,
+        '- offer the owner once, in one line, to put the game on the flow from where it stands. On their yes: `npx @funpixel/tools note verdict <stage> accept "<their words>"` for each stage the game already has, then `npx @funpixel/tools flow agree --by owner "<their words>"`; the flow then runs its rounds from the first stage still open.',
+    ].join('\n');
+}
+export const FLOW_MAX_BLOCKS = 12;
+export const FLOW_MAX_HOLDS = 4;
+export async function flowNow(root, input) {
+    const f = readFlow(root);
+    if (!f)
+        return null;
+    const { e } = await pipelineEval(root);
+    return flowView(root, e, f, { sessionStart: input ? sessionStartMs(input) : 0 });
+}
+export async function flowContext(root, input) {
+    const v = await flowNow(root, input);
+    return v ? flowBlock(v) : null;
+}
+const CODE = /(^|\/)(src\/.+\.(ts|tsx|js|jsx|mjs|css|html|glsl|wgsl)|index\.html)$/;
+export async function flowEditLine(input, root) {
+    if (!/^(Write|Edit|MultiEdit)$/.test(String(input.tool_name ?? '')))
+        return null;
+    const file = String(input.tool_input?.file_path ?? input.tool_input?.path ?? '');
+    if (!CODE.test(file) || !readFlow(root) || flowQuiet(input, root))
+        return null;
+    if (readState(input).flowEditSaid)
+        return null;
+    const v = await flowNow(root, input);
+    if (!v || v.agreement.agreed || !v.builtEarly.length)
+        return null;
+    writeState(input, { ...readState(input), flowEditSaid: Date.now() });
+    const where = v.stage ? `the current stage (${v.stage.title})` : 'the flow';
+    return `Funpixel flow: the plan is not agreed yet (${v.agreement.says}) and ${where} builds no game code, so game code waits for the owner's yes: finish the plan and put it to them once (\`npx @funpixel/tools flow ask\`). Code written before then is not held at the Stop; it is named there.`;
+}
+async function signature(root) {
+    const t = (rel) => { try {
+        return statSync(join(root, rel)).mtimeMs;
+    }
+    catch {
+        return 0;
+    } };
+    const fp = await currentFingerprint(root).catch(() => '');
+    return [fp, t(FLOW_FILE), t(join('.funtools', 'progress.jsonl')), t(join('design', 'pipeline.json')), t(join('design', 'GDD.md')), t(join('design', 'plan-notes.json'))].join(':');
+}
+export async function flowStop(input, root) {
+    const f = readFlow(root);
+    if (!f || flowQuiet(input, root))
+        return null;
+    const state = readState(input);
+    const start = sessionStartMs(input);
+    const fp = await currentFingerprint(root).catch(() => null);
+    const worked = fp !== state.startFingerprint || Date.parse(f.at?.said_at ?? '') >= start || (f.rounds ?? []).some((r) => Date.parse(r.closed_at ?? '') >= start);
+    if (!worked)
+        return null;
+    const v = await flowNow(root, input);
+    if (!v)
+        return null;
+    const verdict = flowAtStop(v);
+    if (verdict.hold) {
+        const n = state.flowHolds ?? 0;
+        if (n >= FLOW_MAX_HOLDS)
+            return { warn: `Funpixel flow: held ${n} times — ending with game code past the scaffold and the plan NOT agreed.` };
+        writeState(input, { ...readState(input), flowHolds: n + 1 });
+        return { block: verdict.hold };
+    }
+    if (verdict.block) {
+        const sig = `${verdict.key}|${await signature(root)}`;
+        const n = state.flowBlocks ?? 0;
+        if (state.flowLast === sig || n >= FLOW_MAX_BLOCKS)
+            return { warn: `Funpixel flow: ${v.step}. Nothing moved since the last Stop, so the session hands back here; resume with /fp:flow.` };
+        writeState(input, { ...readState(input), flowBlocks: n + 1, flowLast: sig });
+        return { block: verdict.block };
+    }
+    if (verdict.once) {
+        if (state.flowOnce === verdict.key)
+            return null;
+        writeState(input, { ...readState(input), flowOnce: verdict.key });
+    }
+    return verdict.warn ? { warn: verdict.warn } : null;
+}

package/plugins/robin/claude/hooks/front-door.mjs

@@ -0,0 +1,68 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+const START_PATH = /(^|\/)(index\.html|(main|app)\.[cm]?[jt]sx?|[^/]*(title|menu|screen|start|input|control|touch|sound|audio)[^/]*\.[cm]?[jt]sx?)$/i;
+const START_CODE = /data-fpx-start|\bunlock\w*\s*\(|new\s+(webkit)?AudioContext|\.resume\s*\(\s*\)|addEventListener\(\s*['"`](key|pointer|touch|click|mouse)/;
+const NO_START = /\bno (dom |html )?(start|play|title)( screen| button| control)?\b|\bstarts? (straight|directly) (in|into) play\b/i;
+const SOURCE = /\.(m?[jt]sx?|html)$/i;
+const sha = (text) => createHash('sha256').update(text).digest('hex').slice(0, 16);
+export function sourceHashes(root) {
+    const out = {};
+    if (!root)
+        return out;
+    const walk = (dir) => {
+        if (!existsSync(dir))
+            return;
+        for (const e of readdirSync(dir, { withFileTypes: true })) {
+            const p = join(dir, e.name);
+            if (e.isDirectory())
+                walk(p);
+            else if (SOURCE.test(e.name))
+                out[relative(root, p).split(sep).join('/')] = sha(readFileSync(p, 'utf8'));
+        }
+    };
+    walk(join(root, 'src'));
+    if (existsSync(join(root, 'index.html')))
+        out['index.html'] = sha(readFileSync(join(root, 'index.html'), 'utf8'));
+    return out;
+}
+export function startFlowEdits(root, state) {
+    if (!state.startedAt || !state.startSources)
+        return [];
+    const before = state.startSources;
+    return Object.entries(sourceHashes(root))
+        .filter(([path, hash]) => before[path] !== hash)
+        .map(([path]) => path)
+        .filter((path) => START_PATH.test(path) || START_CODE.test(readFileSync(join(root, path), 'utf8')));
+}
+export function frontDoor(root, fingerprint) {
+    let record;
+    try {
+        record = JSON.parse(readFileSync(join(root, 'verify.json'), 'utf8'));
+    }
+    catch {
+        return 'not run';
+    }
+    const f = record?.report?.front_door;
+    if (record?.fingerprint !== fingerprint || !f)
+        return 'not run';
+    return f.found && f.pressed && f.changed === true ? 'passed' : 'failed';
+}
+const source = (root) => Object.keys(sourceHashes(root)).map((p) => readFileSync(join(root, p), 'utf8')).join('\n');
+const marksStart = (root) => source(root).includes('data-fpx-start');
+const hasTitle = (root) => { const s = source(root); return s.includes('data-fpx-start') || /\btitle\s*:\s*\{[^}]*\benter\b/.test(s); };
+export function frontDoorItem(root, state, fingerprint, said = '') {
+    const edits = startFlowEdits(root, state);
+    if (!edits.length || !hasTitle(root))
+        return null;
+    const door = frontDoor(root, fingerprint);
+    if (door === 'passed')
+        return null;
+    if (NO_START.test(said) && !marksStart(root))
+        return null;
+    const why = door === 'failed' ? 'the last front-door verify FAILED: the real start control did nothing' : 'no verify on the current files pressed the real start control';
+    return `This session changed the start flow (${edits.slice(0, 4).join(', ')}${edits.length > 4 ? ', …' : ''}) and ${why}. ` +
+        'Mark the start control data-fpx-start (a start drawn in the canvas gets a transparent DOM button over it carrying the attribute) and run ' +
+        '`npm run build`, then `npx @funpixel/tools verify --front-door` (or `npx @funpixel/tools check --front-door`), until it passes (skill funpixel-verify). ' +
+        'A game with no start control at all says so in the hand-back ("no start screen: it opens in play").';
+}

package/plugins/robin/claude/hooks/guidance.json

@@ -0,0 +1,3 @@
+{
+  "hash": "47443d9a284e95f9"
+}