@funpixel/tools 0.0.0-stage → 0.1.1

package/plugins/codex/hooks/scope.mjs

@@ -0,0 +1,44 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { notePath } from './note.mjs';
+export const MARKER = join('.funtools', 'complete-game');
+const COMMAND = /(^|[\s>(])[/$]fp[:-]new\b/i;
+const NOT_WHOLE = String.raw `(?![- ]?(?:over|loop|screen|state|logic|ui|hud|menu|jam|engine|select|list|editor|complete|up))`;
+const REQUEST = new RegExp(String.raw `\b(?:finish|complete)\s+(?:the|this|my|our)\s+game\b${NOT_WHOLE}|\b(?:a|the)\s+(?:complete|finished|full)\s+game\b|\bmake\s+it\s+a\s+(?:complete|full|finished)\s+game\b`, 'i');
+const POLISHED = new RegExp(String.raw `\b(?:complete|finished|full)(?:\s*,\s*|\s+and\s+)polished\b|\b(?:complete|finished|polished)\s+(?:(?:little|small|short|mobile|phone|first|single|whole|playable)\s+)*(?:game|level)\b${NOT_WHOLE}`, 'i');
+export function scopeSignal(prompt) {
+    if (typeof prompt !== 'string' || !prompt)
+        return null;
+    if (COMMAND.test(prompt))
+        return 'command';
+    return REQUEST.test(prompt) || POLISHED.test(prompt) ? 'request' : null;
+}
+export const hasDesignNote = (root) => Boolean(root) && notePath(root) !== null;
+export function completeGameScope(state, root) {
+    if (!state.startedAt)
+        return null;
+    if (state.startGame === false)
+        return 'the session began without a game';
+    if (state.completeAsked)
+        return state.completeAsked === 'command' ? 'the new-game command was used' : 'the person asked for a complete game';
+    if (root && existsSync(join(root, MARKER)))
+        return `the game is marked in progress (${MARKER})`;
+    if (root && state.startNote === false && hasDesignNote(root))
+        return 'the session wrote the game\'s first design note';
+    return null;
+}
+export function markComplete(root, why) {
+    try {
+        if (existsSync(join(root, MARKER)))
+            return;
+        mkdirSync(join(root, '.funtools'), { recursive: true });
+        writeFileSync(join(root, MARKER), `${why}\n`);
+    }
+    catch { }
+}
+export function clearComplete(root) {
+    try {
+        rmSync(join(root, MARKER), { force: true });
+    }
+    catch { }
+}

package/plugins/codex/hooks/session-log.mjs

@@ -0,0 +1,101 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { GAME_DEVLOG } from './lib.mjs';
+export const REFUSED = /permission to use .* (?:has been|was) denied|haven't granted it yet|doesn't want to proceed with this tool use|tool use was rejected|denied by (?:the )?(?:user|policy|hook)|blocked by (?:a )?(?:pretooluse )?hook|not allowed by (?:the )?permission/i;
+const textOf = (c) => (typeof c === 'string' ? c : Array.isArray(c) ? c.map((x) => (typeof x === 'string' ? x : x?.text ?? '')).join(' ') : '');
+export function transcriptCounts(text) {
+    const seen = new Map();
+    let toolCalls = 0, refused = 0, failed = 0, lines = 0;
+    const refusedTools = {};
+    const names = new Map();
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        let e;
+        try {
+            e = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (e?.isSidechain)
+            continue;
+        const msg = e?.message;
+        if (e?.type === 'assistant' && msg) {
+            lines++;
+            const id = msg.id ?? e.uuid ?? `line${lines}`;
+            if (!seen.has(id))
+                seen.set(id, msg.usage ?? null);
+            else if (msg.usage && !seen.get(id))
+                seen.set(id, msg.usage);
+            for (const c of Array.isArray(msg.content) ? msg.content : []) {
+                if (c?.type === 'tool_use') {
+                    toolCalls++;
+                    if (c.id)
+                        names.set(c.id, c.name ?? 'tool');
+                }
+            }
+        }
+        else if (e?.type === 'user' && Array.isArray(msg?.content)) {
+            for (const c of msg.content) {
+                if (c?.type !== 'tool_result' || c.is_error !== true)
+                    continue;
+                if (REFUSED.test(textOf(c.content))) {
+                    refused++;
+                    const n = names.get(c.tool_use_id) ?? 'tool';
+                    refusedTools[n] = (refusedTools[n] ?? 0) + 1;
+                }
+                else
+                    failed++;
+            }
+        }
+    }
+    if (!seen.size)
+        return null;
+    const tokens = { input: 0, output: 0, cache_read: 0, cache_write: 0 };
+    for (const u of seen.values()) {
+        if (!u)
+            continue;
+        tokens.input += u.input_tokens ?? 0;
+        tokens.output += u.output_tokens ?? 0;
+        tokens.cache_read += u.cache_read_input_tokens ?? 0;
+        tokens.cache_write += u.cache_creation_input_tokens ?? 0;
+    }
+    return { num_turns: seen.size, tokens, tool_calls: toolCalls, refused, failed, ...(refused ? { refused_tools: refusedTools } : {}) };
+}
+export function logSession(input, root, now = new Date()) {
+    if (process.env.FUNPIXEL_GDK_DEVLOG === 'off')
+        return null;
+    const t = input?.transcript_path;
+    if (!t || !existsSync(t))
+        return null;
+    const counts = transcriptCounts(readFileSync(t, 'utf8'));
+    if (!counts)
+        return null;
+    const session = String(input.session_id ?? 'unknown');
+    const k = counts.tokens;
+    const entry = {
+        at: now.toISOString().replace(/\.\d+Z$/, 'Z'), kind: 'session', session, ...counts,
+        text: `session: ${counts.num_turns} turns, ${k.output} output tokens (${k.input} in, ${k.cache_read} cache read, ${k.cache_write} cache write), ${counts.tool_calls} tool calls, ${counts.refused} refused, ${counts.failed} failed`,
+        auto: true,
+    };
+    const file = GAME_DEVLOG(root);
+    let kept = [];
+    try {
+        kept = readFileSync(file, 'utf8').split('\n').filter((l) => {
+            if (!l.trim())
+                return false;
+            try {
+                const e = JSON.parse(l);
+                return !(e?.kind === 'session' && e.session === session);
+            }
+            catch {
+                return true;
+            }
+        });
+    }
+    catch { }
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, [...kept, JSON.stringify(entry)].join('\n') + '\n');
+    return entry;
+}

package/plugins/codex/hooks/session-start.mjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { sourceHashes } from './front-door.mjs';
+import { client, currentFingerprint, findGameRoot, forHost, readInput, readState, skillNamesLine, startDir, verifyStatus, writeState, isMain } from './lib.mjs';
+import { creatorContext, memoryContext, outsideChanges } from './memory.mjs';
+import { completeGameScope, hasDesignNote } from './scope.mjs';
+import { reachContext, skillsFor } from './reach.mjs';
+import { pipelineContext } from './pipeline.mjs';
+import { flowBeat, flowStart } from './flow.mjs';
+const HERE = dirname(fileURLToPath(import.meta.url));
+const MARKER = '<!-- funpixel-gdk:brief -->';
+function sourceText(root) {
+    const out = [];
+    const walk = (dir) => {
+        for (const e of readdirSync(dir, { withFileTypes: true })) {
+            const p = join(dir, e.name);
+            if (e.isDirectory())
+                walk(p);
+            else if (/\.(ts|tsx|js|jsx|mjs)$/.test(e.name))
+                out.push(readFileSync(p, 'utf8'));
+        }
+    };
+    if (existsSync(join(root, 'src')))
+        walk(join(root, 'src'));
+    if (existsSync(join(root, 'index.html')))
+        out.push(readFileSync(join(root, 'index.html'), 'utf8'));
+    return out.join('\n');
+}
+const VERDICT = {
+    missing: 'never verified',
+    stale: 'verify.json is stale: the files that ship changed since it ran',
+    fail: 'the last verify FAILED; read its FAIL lines before anything else',
+    not_observed: 'the last verify measured nothing (hooks missing or the page did not load)',
+    pass: 'the last verify passed on the current files',
+};
+const STOPS = {
+    ask: 'stop for the person at each pick (`funtools pitch ask`: every pitch card is theirs), the first look and each slice',
+    'plan-then-go': 'pick the pitch cards yourself into the plan, with why; the owner approves the plan and its price once, in the chat (`funtools flow ask`, then `flow agree --by owner`), then round after round',
+    go: 'do not stop: pick, record each pick with its reason (funtools decide), keep going; the person reviews what was made',
+};
+export function studioLine(studio) {
+    const picks = studio?.locked;
+    if (!picks || typeof picks !== 'object')
+        return '- studio pitch: not locked. Invent first (skill funpixel-gdd, references/invent-first.md: six forcing questions, a hit per axis), then pitch the choices (`npx @funpixel/tools pitch`) for the person to pick';
+    const list = (k) => (Array.isArray(picks[k]) ? picks[k].join(' + ') : '');
+    const parts = [['core', 'the core that burns'], ['depth', 'depth'], ['story', 'story'], ['genre', 'genre'], ['extras', 'extras'], ['budget', 'budget']].filter(([k]) => list(k)).map(([k, w]) => `${w} ${list(k)}`);
+    const auto = studio.autonomy in STOPS ? studio.autonomy : 'plan-then-go';
+    return `- studio pitch (locked): ${parts.join(' · ')}. Go hard on the core; what was not picked stays light. Autonomy ${auto}: ${STOPS[auto]}`;
+}
+export function projectState(root, fp) {
+    const lines = [`- verify: ${VERDICT[verifyStatus(root, fp)]}`];
+    let checks = 0, studio = null;
+    try {
+        const m = JSON.parse(readFileSync(join(root, 'funpixel.json'), 'utf8'));
+        checks = (m.checks ?? []).length;
+        studio = m.studio ?? null;
+    }
+    catch {
+        lines.push('- funpixel.json does not parse');
+    }
+    lines.push(`- funpixel.json checks: ${checks}${checks ? '' : '; coverage is missing: add checks for the requested task (skill funpixel-verify)'}`);
+    let owner = null;
+    try {
+        owner = JSON.parse(readFileSync(join(root, 'funpixel.json'), 'utf8')).flow?.autonomy ?? null;
+    }
+    catch { }
+    lines.push(studioLine(studio && owner in STOPS ? { ...studio, autonomy: owner } : studio));
+    const src = sourceText(root);
+    const missing = ['__FPX_STATE__', '__FPX_VERBS__', '__FPX_VIEWS__', '__FPX_KEYS__'].filter((h) => !src.includes(h));
+    if (missing.length)
+        lines.push(`- hooks not declared: ${missing.join(', ')}; verify cannot see what they would show`);
+    if (!src.includes('data-fpx-start'))
+        lines.push('- no start control marked data-fpx-start (skill funpixel-verify, the front door)');
+    return lines;
+}
+export function guidanceGap(root, stamp = join(HERE, 'guidance.json')) {
+    let recorded, current;
+    try {
+        recorded = JSON.parse(readFileSync(join(root, 'funpixel.json'), 'utf8')).guidance_hash;
+    }
+    catch {
+        return null;
+    }
+    try {
+        current = JSON.parse(readFileSync(stamp, 'utf8')).hash;
+    }
+    catch {
+        return null;
+    }
+    if (typeof recorded !== 'string' || typeof current !== 'string' || recorded === current)
+        return null;
+    return `- agent guidance: this game's AGENTS.md and .agents/skills are from an older GDK (${recorded}) than this plugin (${current}); the plugin's skills and the brief above are current. \`npx @funpixel/tools upgrade\` refreshes the game's copies and keeps your own edits`;
+}
+export function shelfLine(root) {
+    const shelf = join(root, '.agents', 'skills');
+    if (!existsSync(shelf))
+        return [];
+    const withRefs = readdirSync(shelf, { withFileTypes: true }).filter((e) => e.isDirectory() && existsSync(join(shelf, e.name, 'references'))).length;
+    if (!withRefs)
+        return [];
+    return [`- skills: this game holds every skill and its references at .agents/skills/funpixel-<name>/ (${withRefs} with references/*.md); a skill's \`references/x.md\` is readable there when the plugin's own folder is not`];
+}
+export function reachPicks(root, prompt = '') {
+    const picks = skillsFor(root, prompt);
+    if (!picks.some((p) => p.skill !== 'funpixel-game-feel'))
+        return null;
+    return { text: reachContext(picks, prompt ? 'its plan, funpixel.json and your first message' : 'its plan and funpixel.json'), skills: picks.map((p) => p.skill) };
+}
+export async function startContext(input) {
+    const root = findGameRoot(startDir(input));
+    const fp = root ? await currentFingerprint(root) : undefined;
+    const state = readState(input);
+    if (!state.startedAt) {
+        writeState(input, {
+            ...state, startedAt: Date.now(), startFingerprint: fp, startGame: Boolean(root),
+            startNote: hasDesignNote(root), startSources: sourceHashes(root),
+        });
+    }
+    if (!root)
+        return null;
+    flowBeat(root, 'start');
+    const kiro = client(input) === 'kiro';
+    if (kiro && readState(input).briefShown)
+        return null;
+    const agentsMd = join(root, 'AGENTS.md');
+    const gap = guidanceGap(root);
+    const hasBrief = !gap && existsSync(agentsMd) && readFileSync(agentsMd, 'utf8').includes(MARKER);
+    const parts = [];
+    const brief = join(HERE, 'brief.md');
+    if (!hasBrief && existsSync(brief))
+        parts.push(readFileSync(brief, 'utf8'));
+    const host = join(HERE, 'host.md');
+    if (existsSync(host))
+        parts.push(readFileSync(host, 'utf8'));
+    const scope = completeGameScope(readState(input), root);
+    const scopeLine = scope
+        ? `- scope: a complete game (${scope}): the complete-game checks apply (skill funpixel-gdd, references/floors.md)`
+        : '- scope: a focused change: verify what you change; the complete-game checks apply when the person asks for a complete game or runs the new-game command';
+    const names = skillNamesLine();
+    parts.push(`## This project now\n${[...projectState(root, fp), scopeLine, ...(gap ? [gap] : []), ...shelfLine(root), ...(names ? [names] : [])].join('\n')}`);
+    let ownerFirst = null;
+    let flowNamed = false;
+    try {
+        const flow = await flowStart(root, input);
+        if (flow.block)
+            parts.push(flow.block);
+        flowNamed = Boolean(flow.block || flow.quiet);
+        ownerFirst = flow.first;
+    }
+    catch { }
+    if (!flowNamed)
+        try {
+            parts.push(await pipelineContext(root, input));
+        }
+        catch { }
+    const named = reachPicks(root);
+    if (named) {
+        parts.push(named.text);
+        writeState(input, { ...readState(input), reachNamed: named.skills });
+    }
+    if (input.source !== 'compact')
+        await outsideChanges(root);
+    const creator = creatorContext(root);
+    if (creator)
+        parts.push(creator);
+    const memory = memoryContext(root);
+    if (memory) {
+        parts.push(memory);
+        writeState(input, { ...readState(input), motifsShown: true });
+    }
+    if (kiro)
+        writeState(input, { ...readState(input), briefShown: true });
+    if (ownerFirst)
+        parts.unshift(ownerFirst);
+    return parts.join('\n\n');
+}
+async function main() {
+    const input = await readInput();
+    const context = forHost(await startContext(input));
+    if (!context)
+        return;
+    if (client(input) === 'kiro') {
+        process.stdout.write(context);
+        return;
+    }
+    process.stdout.write(JSON.stringify(client(input) === 'cursor'
+        ? { additional_context: context }
+        : { hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: context } }));
+}
+if (isMain(import.meta.url)) {
+    main().catch((e) => process.stderr.write(`funpixel session-start: ${e instanceof Error ? e.message : e}\n`));
+}

package/plugins/codex/hooks/stop-gate.mjs

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto';
+import { client, deferForKiro, currentFingerprint, findGameRoot, forHost, gatePolicy, KIT_ASK, kitVerdictFiled, kitVerdictOn, openReport, readInput, readState, sessionStartMs, startDir, writeState, isMain } from './lib.mjs';
+import { rememberAgentFiles, rememberMotif } from './memory.mjs';
+import { clearComplete } from './scope.mjs';
+import { mobileNote } from './mobile-qa.mjs';
+import { logSession } from './session-log.mjs';
+import { durableNote } from './durable.mjs';
+import { BACKGROUND_WARNING, beforeSignOff, pipelineAtStop, ROUND_ASK } from './pipeline.mjs';
+import { lastAssistantText, lastPrompt } from './quality.mjs';
+import { flowBeat, flowQuiet, flowStop } from './flow.mjs';
+import { handBackHolds, holding, holdMessage } from './vendor/progress/holds.mjs';
+import { planAgreement, readFlow } from './vendor/flow/flow.mjs';
+import { readProgress } from './vendor/progress/progress.mjs';
+export const MAX_BLOCKS = 3;
+export const MAX_HOLDS = 6;
+export async function handBackHold(input, root, plan = NO_PLAN) {
+    const fp = await currentFingerprint(root).catch(() => null);
+    const s = readProgress(root);
+    const since = sessionStartMs(input);
+    const handedBack = s.cards.some((c) => (c.kind === 'done' || c.out?.length || c.standins?.length) && Date.parse(c.at) >= since);
+    const changed = fp !== readState(input).startFingerprint;
+    if (!changed && !handedBack)
+        return null;
+    const h = handBackHolds(root, fp, s);
+    const unread = holding(h).filter((x) => x.unread && !plan.lists('world'));
+    const held = holding(h).filter((x) => !unread.includes(x));
+    const notes = unread.map((x) => x.line);
+    if (!held.length) {
+        if (h.holds.length && !holding(h).length)
+            return { warn: `Funpixel: the hand-back carries stand-ins — ${h.released ?? h.waiting}. Say so in the hand-back; it is not done until the art is in.` };
+        return notes.length ? { notes } : null;
+    }
+    const state = readState(input);
+    const n = state.holdBlocks ?? 0;
+    if (n >= MAX_HOLDS)
+        return { warn: `Funpixel: held ${n} times and still handing back primitives — ending, NOT done:\n${held.map((x) => `- ${x.line}`).join('\n')}` };
+    writeState(input, { ...state, holdBlocks: n + 1 });
+    return { block: holdMessage(held), ...(notes.length ? { notes } : {}) };
+}
+export const NO_PLAN = { agreed: false, lists: () => false };
+export function agreedPlan(root, path) {
+    let agreed = false;
+    try {
+        agreed = planAgreement(root).agreed === true;
+    }
+    catch { }
+    const kinds = agreed ? (path?.planned ?? new Set()) : new Set();
+    return { agreed, lists: (kind) => kinds.has(kind) };
+}
+export function sortItems(items, tags, plan = NO_PLAN) {
+    const held = [], notes = [];
+    for (const i of items) {
+        const t = tags?.get(i);
+        (t && (t.fault || plan.lists(t.kind)) ? held : notes).push(i);
+    }
+    return { held, notes };
+}
+const noteKey = (n) => createHash('sha256').update(n.replace(/ Changed since the last pass: .*?\.(?= |$)/, '')).digest('hex').slice(0, 16);
+export function noteLines(input, notes, plan = NO_PLAN) {
+    const state = readState(input);
+    const said = state.notesSaid ?? {};
+    const fresh = [...new Set(notes)].filter((n) => !said[noteKey(n)]);
+    if (!fresh.length)
+        return [];
+    const first = !plan.agreed && !state.noPlanSaid;
+    writeState(input, { ...state, notesSaid: { ...said, ...Object.fromEntries(fresh.map((n) => [noteKey(n), 1])) }, ...(first ? { noPlanSaid: Date.now() } : {}) });
+    const head = plan.agreed ? 'Notes, not holds (the agreed plan does not list them; each said once):'
+        : first ? 'No plan agreed: these are suggestions, not holds (said once; the owner\'s agreed plan and the faults a player meets are what hold a hand-back):'
+            : 'Suggestions, not holds (each said once):';
+    return [head, ...fresh.map((n) => `- ${n}`)];
+}
+export async function decide(input) {
+    const root = findGameRoot(startDir(input));
+    if (!root)
+        return null;
+    writeState(input, { ...readState(input), spokeAt: Date.now() });
+    rememberMotif(root);
+    try {
+        logSession(input, root);
+    }
+    catch { }
+    await rememberAgentFiles(root);
+    const policy = gatePolicy(root);
+    if (policy === 'off')
+        return null;
+    const path = await pipelineAtStop(input, root).catch(() => null);
+    if (path && flowQuiet(input, root))
+        path.gates = [];
+    const flowed = await flowStop(input, root).catch(() => null);
+    const plan = agreedPlan(root, path);
+    const { notes: holdNotes = [], ...hold } = (await handBackHold(input, root, plan).catch(() => null)) ?? {};
+    const ownerHolds = path?.holds ?? [];
+    const gate = await gateDecision(input, root, policy, path, { flow: flowed !== null, plan, notes: [...(readFlow(root) ? [] : ownerHolds), ...holdNotes] });
+    const asked = await ownerQuestionOpen(root).catch(() => null);
+    const inChat = asked ? null : ownerAskedInChat(lastAssistantText(input));
+    const stopAsked = asked || inChat ? null : ownerAskedStop(lastPrompt(input, readState(input)));
+    const held = Object.keys(hold).length ? hold : null;
+    const all = merge(merge(gate, held), flowed);
+    const running = path?.running ?? [];
+    const owed = ownerHolds.length ? [`the owner holds the stage (${ownerHolds.length === 1 ? 'their note' : 'their notes'} ${(path?.holdIds ?? []).join(', ') || 'open'})`, 'as advice, for when they release it']
+        : beforeSignOff(root) ? ['the owner has not signed off the plan, and until they do the kit only advises', 'as advice (each said once)']
+            : running.length ? ['work is still running in the background, and its notification brings the session back', 'for when it finishes'] : null;
+    const out = asked ? released(all, `${asked} is with the owner`)
+        : inChat ? released(all, `the agent asked the owner in the chat ("${inChat}")`)
+            : stopAsked ? released(all, `the owner asked for the hand-back ("${stopAsked}")`, 'for the next session')
+                : owed ? releasedOnce(input, all, ...owed)
+                    : all;
+    if (!running.length)
+        return out;
+    const loud = BACKGROUND_WARNING(running);
+    const warn = [loud, out?.warn?.replace(/^Funpixel:\s*/, '')].filter(Boolean).join('\n\n');
+    return { ...(out ?? {}), warn };
+}
+export function releasedOnce(input, out, why, until) {
+    if (!why || !(out?.block || out?.ask))
+        return out;
+    const key = noteKey([out.block, out.ask].filter(Boolean).join('\n\n'));
+    const state = readState(input);
+    if (!state.releasedSaid?.[key]) {
+        writeState(input, { ...state, releasedSaid: { ...(state.releasedSaid ?? {}), [key]: 1 } });
+        return released(out, why, until);
+    }
+    const { block, ask, ...rest } = out;
+    return rest.warn ? rest : null;
+}
+export async function ownerQuestionOpen(root) {
+    const open = readProgress(root).open;
+    return open.length ? open[open.length - 1].id : null;
+}
+export function released(out, why, until = 'for when they answer') {
+    if (!why || !(out?.block || out?.ask))
+        return out;
+    const { block, ask, ...rest } = out;
+    const held = [block, ask].filter(Boolean).join('\n\n')
+        .replace(/Funpixel flow — keep going\. /g, 'Funpixel flow suggests: ')
+        .replace(/\nThe loop runs in this session until[^\n]*/g, '');
+    const warn = [`Funpixel: ${why}, so this hands back. Still open, ${until}:\n${held}`, rest.warn?.replace(/^Funpixel:\s*/, '')].filter(Boolean).join('\n');
+    return { ...rest, warn };
+}
+const LEAVE_ASK = /\b(?:shall|should|can|may|do you want|would you like|want)\s+(?:me|i|us|we)\s+(?:to\s+)?(?:continue|keep going|go on|proceed|carry on|move on|start the next)\b/i;
+const OWNER_PUT = /\b(?:(?:it'?s|that'?s|this is) your (?:call|decision|choice)|decisions? for you|(?:waiting (?:on|for)|needs?) your (?:word|answer|decision|yes|go-?ahead|sign-?off|pick|choice|accept)|up to you|if you(?:'d)? (?:want|like|prefer)|(?:let me know|tell me) (?:which|what|whether|if|how))\b/i;
+const CONTINUE = /\b(?:continue|keep going|go on|proceed|carry on|move on)\b/i;
+export function ownerAskedInChat(text) {
+    if (typeof text !== 'string' || !text.trim())
+        return null;
+    const prose = text.replace(/```[\s\S]*?```/g, '').replace(/`[^`\n]*`/g, '');
+    const tail = prose.trim().split(/\n\s*\n/).slice(-3).join('\n');
+    const clip = (s) => (s.length <= 120 ? s : `${s.slice(0, 119)}…`);
+    for (const q of tail.match(/[^.!?\n]*\?(?=\s|$)/g) ?? []) {
+        const said = q.trim().replace(/^[-*>#\d.)\s]+/, '').replace(/\*\*/g, '');
+        if (said.split(/\s+/).length < 3 || LEAVE_ASK.test(said))
+            continue;
+        return clip(said);
+    }
+    for (const line of tail.replace(/\*\*/g, '').split(/(?<=[.!])\s+|\n/)) {
+        const said = line.trim().replace(/^[-*>#\d.)\s]+/, '');
+        if (OWNER_PUT.test(said) && !CONTINUE.test(said))
+            return clip(said);
+    }
+    return null;
+}
+const STOP_REQUEST = new RegExp([
+    String.raw `(?:^|[.!?;:,]\s*|\b(?:you|please|then|and|just|so|ok|okay|now|let'?s|we)\s+)stop\s+(?:here|now|there|for (?:now|today|the day)|working)\b`,
+    String.raw `^\s*(?:ok(?:ay)?[, ]+|please[, ]+)?stop\b[.!]*\s*$`,
+    String.raw `\bhand(?:ing)? (?:it |this |the game |everything |that )?back\b`,
+    String.raw `\bwrap (?:it |this |things )?up\b`,
+    String.raw `\bpause (?:here|now|for now)\b`,
+    String.raw `\bthat'?s (?:enough|all|it) for (?:now|today|tonight)\b`,
+    String.raw `\bcall it (?:a day|a night|here|there)\b`,
+    String.raw `\bend (?:the|this) session\b`,
+    String.raw `\breport back\b`,
+].join('|'), 'gim');
+const NEGATED = /\b(?:don'?t|do not|never|no need to|not yet|without)\s+(?:\w+\s+){0,2}$|\b(?:the|a|your|my|each|every)\s+$/i;
+const CONDITIONAL = /^[^.!?\n]*?\b(?:when|once|if|until|after|before|as soon as)\b/i;
+export function ownerAskedStop(said) {
+    if (!said)
+        return null;
+    for (const m of said.matchAll(STOP_REQUEST)) {
+        if (NEGATED.test(said.slice(Math.max(0, m.index - 60), m.index)) || CONDITIONAL.test(said.slice(m.index + m[0].length)))
+            continue;
+        return m[0].trim().replace(/^(?:[.!?;:,]\s*|(?:you|please|then|and|just|so|ok|okay|now|let'?s|we)\s+)/i, '').slice(0, 80);
+    }
+    return null;
+}
+export function merge(a, b) {
+    if (!b)
+        return a;
+    if (!a)
+        return b;
+    const block = [b.block, a.block].filter(Boolean).join('\n\n');
+    const warn = [b.warn, a.warn?.replace(/^Funpixel:\s*/, '')].filter(Boolean).join('\n');
+    return { ...a, ...(block ? { block } : {}), ...(warn ? { warn } : {}) };
+}
+async function gateDecision(input, root, policy, path, o = {}) {
+    const plan = o.plan ?? NO_PLAN;
+    const { items: open, quality, tags } = await openReport(input, root, true);
+    const { held, notes } = sortItems(open, tags, plan);
+    const owner = path?.owner ?? [];
+    const items = [...held, ...owner];
+    const ownerPolicy = owner.length && policy === 'warn' ? 'block' : policy;
+    if (quality?.done)
+        clearComplete(root);
+    const mobile = mobileNote(root, readState(input), await currentFingerprint(root).catch(() => null));
+    if (mobile)
+        writeState(input, { ...readState(input), mobileNoted: mobile.key });
+    const changed = (await currentFingerprint(root).catch(() => null)) !== readState(input).startFingerprint;
+    const gateNotes = path?.gates.length && (!changed || !plan.agreed) ? path.gates.map((g) => `open on the path: ${g}`) : [];
+    const said = noteLines(input, [...(o.notes ?? []), ...notes, ...gateNotes], plan);
+    const verdict = await judge(input, root, ownerPolicy, items, quality, [...(mobile ? [mobile.line] : []), ...(path?.notes ?? []), ...said]);
+    const ask = stopAsks(input, root, changed, o.flow || !plan.agreed ? { ...(path ?? {}), gates: [] } : path, quality);
+    return ask ? { ...(verdict ?? {}), ask } : verdict;
+}
+export function stopAsks(input, root, changed, path, quality) {
+    const state = readState(input);
+    const asks = [];
+    const next = { ...state };
+    if (changed && path?.gates.length && !state.roundAsked) {
+        asks.push(ROUND_ASK(path.stage, path.gates));
+        next.roundAsked = Date.now();
+    }
+    if (quality?.scope && kitVerdictOn(root) && !state.kitAsked && !kitVerdictFiled(input, root, sessionStartMs(input))) {
+        asks.push(KIT_ASK);
+        next.kitAsked = Date.now();
+    }
+    if (!asks.length)
+        return null;
+    writeState(input, next);
+    return asks.join('\n\n');
+}
+async function judge(input, root, policy, items, quality, extra = []) {
+    const notes = [...(quality?.notes ?? []), ...extra].map((n) => `\n${n}`).join('');
+    if (!items.length) {
+        if (quality?.deferred.length) {
+            return { warn: `Funpixel: handed back unfinished — the design note's fix round defers ${quality.deferred.join('; ')}. Not accepted until a later round clears them.${notes}`, notice: true };
+        }
+        return notes ? { warn: `Funpixel:${notes}`, notice: true } : null;
+    }
+    const reason = items.join('\n');
+    const state = readState(input);
+    const now = await currentFingerprint(root);
+    const blocks = state.blocks ?? (state.blocked ? 1 : 0);
+    const sameFiles = blocks > 0 && (state.blockedOn === undefined || state.blockedOn === now);
+    const already = sameFiles || blocks >= MAX_BLOCKS || (blocks === 0 && (input.stop_hook_active === true || (input.loop_count ?? 0) > 0));
+    if (policy === 'warn' || already) {
+        return { warn: `Funpixel: finishing with open items —\n${reason}${notes}` };
+    }
+    writeState(input, { ...state, blocked: true, blocks: blocks + 1, blockedOn: now });
+    return { block: reason, ...(notes ? { warn: `Funpixel:${notes}` } : {}) };
+}
+export function render(input, out) {
+    if (!out)
+        return '';
+    const message = forHost([out.block, out.ask].filter(Boolean).join('\n\n'));
+    if (message) {
+        if (client(input) === 'cursor')
+            return JSON.stringify({ followup_message: message });
+        return JSON.stringify({ decision: 'block', reason: message, ...(out.warn ? { systemMessage: forHost(out.warn) } : {}) });
+    }
+    return client(input) === 'cursor' ? '' : JSON.stringify({ systemMessage: forHost(out.warn) });
+}
+export function withDurable(out, line) {
+    if (!line)
+        return out;
+    if (out?.block || out?.ask)
+        return { ...out, ask: [out.ask, line].filter(Boolean).join('\n\n'), warn: [out.warn, line].filter(Boolean).join('\n') };
+    return { ...(out ?? { notice: true }), warn: [out?.warn, line].filter(Boolean).join('\n') };
+}
+async function main() {
+    const input = await readInput();
+    const root = findGameRoot(startDir(input));
+    const decided = await decide(input);
+    const out = root && gatePolicy(root) !== 'off' ? withDurable(decided, (() => { try {
+        return durableNote(input, root);
+    }
+    catch {
+        return null;
+    } })()) : decided;
+    if (!out?.block || client(input) === 'kiro')
+        flowBeat(root, 'idle');
+    if (client(input) === 'kiro') {
+        if (!out)
+            return;
+        const open = out.block ?? (out.notice ? null : out.warn?.replace(/^Funpixel: finishing with open items —\n/, ''));
+        const handOver = [open && `Funpixel: the last turn ended with open items —\n${open}`, out.ask].filter(Boolean).join('\n\n');
+        if (handOver)
+            deferForKiro(input, 'pendingGate', handOver);
+        const shown = out.block ? `Funpixel: open items —\n${out.block}` : out.warn;
+        if (shown)
+            process.stderr.write(`${shown}\n`);
+        if (shown || out.ask)
+            process.exitCode = 1;
+        return;
+    }
+    if (out?.warn)
+        process.stderr.write(`${forHost(out.warn)}\n`);
+    process.stdout.write(render(input, out));
+}
+if (isMain(import.meta.url)) {
+    main().catch((e) => {
+        process.stderr.write(`funpixel stop-gate: ${e instanceof Error ? e.message : e}\n`);
+    });
+}