openbrawl 0.2.2

package/dist/game/state.js

@@ -0,0 +1,89 @@
+import { createInitialGameState, getCategoryForRound, getWordBudget, getStatBudget } from "./rounds.js";
+function applyInterpretationToCreature(creature, interp) {
+    const newAbilities = [...creature.abilities, ...interp.abilities].slice(0, 3);
+    return {
+        ...creature,
+        name: interp.creatureName ?? creature.name,
+        stats: {
+            ATK: creature.stats.ATK + interp.statChanges.ATK,
+            DEF: creature.stats.DEF + interp.statChanges.DEF,
+            SPD: creature.stats.SPD + interp.statChanges.SPD,
+            HP: creature.stats.HP + interp.statChanges.HP,
+        },
+        currentHP: creature.currentHP + interp.statChanges.HP,
+        abilities: newAbilities,
+        mutations: [...creature.mutations, ...interp.mutations],
+        flavorText: interp.flavorText || creature.flavorText,
+    };
+}
+export class GameEngine {
+    state;
+    constructor(mode) {
+        this.state = createInitialGameState(mode);
+    }
+    applyInterpretation(interp, targetIndex) {
+        const newTeam = [...this.state.playerTeam];
+        newTeam[targetIndex] = applyInterpretationToCreature(newTeam[targetIndex], interp);
+        this.state = { ...this.state, playerTeam: newTeam };
+    }
+    applyRivalEvolution(interp, targetIndex) {
+        const newRivals = [...this.state.rivalTeam];
+        newRivals[targetIndex] = applyInterpretationToCreature(newRivals[targetIndex], interp);
+        this.state = { ...this.state, rivalTeam: newRivals };
+    }
+    addAlly(creature) {
+        this.state = { ...this.state, playerTeam: [...this.state.playerTeam, creature] };
+    }
+    addRivalAlly(creature) {
+        this.state = { ...this.state, rivalTeam: [...this.state.rivalTeam, creature] };
+    }
+    battleWon() {
+        this.state = { ...this.state, phase: "result" };
+    }
+    battleLost() {
+        const newLives = this.state.lives - 1;
+        if (newLives <= 0) {
+            this.state = { ...this.state, lives: 0, phase: "game_over" };
+        }
+        else {
+            this.state = { ...this.state, lives: newLives, phase: "result" };
+        }
+    }
+    battleDraw() {
+        this.state = { ...this.state, phase: "result" };
+    }
+    nextRound() {
+        const nextRound = this.state.round + 1;
+        if (nextRound > 10) {
+            this.state = { ...this.state, phase: "victory" };
+            return;
+        }
+        const refreshedPlayer = this.state.playerTeam.map((c) => ({ ...c, currentHP: c.stats.HP }));
+        const refreshedRival = this.state.rivalTeam.map((c) => ({ ...c, currentHP: c.stats.HP }));
+        this.state = {
+            ...this.state,
+            round: nextRound,
+            currentCategory: getCategoryForRound(nextRound),
+            wordBudget: getWordBudget(nextRound),
+            statBudget: getStatBudget(nextRound),
+            playerTeam: refreshedPlayer,
+            rivalTeam: refreshedRival,
+            phase: "prompting",
+        };
+    }
+    makeAllyFromInterpretation(interp) {
+        return {
+            name: interp.creatureName ?? "Ally",
+            stats: {
+                ATK: 1 + interp.statChanges.ATK,
+                DEF: 1 + interp.statChanges.DEF,
+                SPD: 1 + interp.statChanges.SPD,
+                HP: 10 + interp.statChanges.HP,
+            },
+            currentHP: 10 + interp.statChanges.HP,
+            abilities: interp.abilities,
+            mutations: interp.mutations,
+            flavorText: interp.flavorText,
+        };
+    }
+}

package/dist/game/types.js

@@ -0,0 +1 @@
+export {};

package/dist/llm/claude.js

@@ -0,0 +1,44 @@
+import { exec } from "child_process";
+let totalInputTokens = 0;
+let totalOutputTokens = 0;
+let totalCalls = 0;
+function parseResult(result) {
+    try {
+        const parsed = JSON.parse(result.trim());
+        const text = parsed.result ?? parsed.text ?? result.trim();
+        const input = parsed.input_tokens ?? parsed.usage?.input_tokens ?? 0;
+        const output = parsed.output_tokens ?? parsed.usage?.output_tokens ?? 0;
+        totalInputTokens += input;
+        totalOutputTokens += output;
+        totalCalls++;
+        return text;
+    }
+    catch {
+        totalCalls++;
+        return result.trim();
+    }
+}
+export function callClaudeAsync(systemPrompt, userMessage) {
+    const fullPrompt = `${systemPrompt}\n\n${userMessage}`;
+    return new Promise((resolve, reject) => {
+        exec(`claude -p ${JSON.stringify(fullPrompt)} --model haiku --output-format json`, {
+            encoding: "utf-8",
+            timeout: 60000,
+            maxBuffer: 1024 * 1024,
+        }, (error, stdout) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(parseResult(stdout));
+        });
+    });
+}
+export function getTokenUsage() {
+    return {
+        inputTokens: totalInputTokens,
+        outputTokens: totalOutputTokens,
+        totalCalls,
+        estimatedCost: (totalInputTokens / 1_000_000) * 0.25 + (totalOutputTokens / 1_000_000) * 1.25,
+    };
+}

package/dist/llm/parse.js

@@ -0,0 +1,108 @@
+const VALID_EFFECTS = ["damage", "heal", "buff", "debuff", "stun", "reflect"];
+const VALID_TRIGGERS = ["on_attack", "on_hit", "on_defend", "start_of_turn", "on_death", "on_ally_death"];
+const VALID_TARGETS = ["self", "enemy", "all_enemies", "random_ally", "all_allies"];
+function normalizeEffect(raw) {
+    const s = String(raw ?? "").toLowerCase();
+    if (VALID_EFFECTS.includes(s))
+        return s;
+    // Map common LLM creative effects to known ones
+    if (s.includes("bleed") || s.includes("burn") || s.includes("poison") || s.includes("dot"))
+        return "damage";
+    if (s.includes("heal") || s.includes("regen") || s.includes("restore"))
+        return "heal";
+    if (s.includes("stun") || s.includes("freeze") || s.includes("paralyze"))
+        return "stun";
+    if (s.includes("buff") || s.includes("boost") || s.includes("empower"))
+        return "buff";
+    if (s.includes("debuff") || s.includes("weaken") || s.includes("slow"))
+        return "debuff";
+    if (s.includes("reflect") || s.includes("mirror") || s.includes("counter"))
+        return "reflect";
+    if (s.includes("spawn") || s.includes("summon"))
+        return "damage";
+    return "damage"; // default fallback
+}
+function normalizeTrigger(raw) {
+    const s = String(raw ?? "").toLowerCase();
+    if (VALID_TRIGGERS.includes(s))
+        return s;
+    return "on_attack";
+}
+function normalizeTarget(raw) {
+    const s = String(raw ?? "").toLowerCase();
+    if (VALID_TARGETS.includes(s))
+        return s;
+    return "enemy";
+}
+function extractJSON(raw) {
+    // Try direct parse first
+    try {
+        JSON.parse(raw.trim());
+        return raw.trim();
+    }
+    catch { }
+    // Try markdown code fence
+    const fenceMatch = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenceMatch)
+        return fenceMatch[1].trim();
+    // Find first { ... } or [ ... ] in the text (handles prose-wrapped JSON)
+    const objMatch = raw.match(/\{[\s\S]*\}/);
+    if (objMatch)
+        return objMatch[0];
+    const arrMatch = raw.match(/\[[\s\S]*\]/);
+    if (arrMatch)
+        return arrMatch[0];
+    return raw.trim();
+}
+function clampStats(stats, budget) {
+    if (!budget)
+        return stats;
+    const total = stats.ATK + stats.DEF + stats.SPD + stats.HP;
+    if (total <= budget)
+        return stats;
+    const ratio = budget / total;
+    return {
+        ATK: Math.floor(stats.ATK * ratio),
+        DEF: Math.floor(stats.DEF * ratio),
+        SPD: Math.floor(stats.SPD * ratio),
+        HP: Math.floor(stats.HP * ratio),
+    };
+}
+export function parsePromptInterpretation(raw, statBudget) {
+    const json = JSON.parse(extractJSON(raw));
+    // Apply creativity bonus as multiplier to effective budget
+    const bonusMultiplier = 1 + (json.creativity_bonus ?? 0) * 0.1;
+    const effectiveBudget = statBudget ? Math.floor(statBudget * bonusMultiplier) : undefined;
+    const statChanges = clampStats({
+        ATK: json.stat_changes?.ATK ?? 0,
+        DEF: json.stat_changes?.DEF ?? 0,
+        SPD: json.stat_changes?.SPD ?? 0,
+        HP: json.stat_changes?.HP ?? 0,
+    }, effectiveBudget);
+    const abilities = (json.abilities ?? []).map((a) => ({
+        name: a.name ?? "Unknown",
+        description: a.description ?? "",
+        trigger: normalizeTrigger(a.trigger),
+        effect: normalizeEffect(a.effect),
+        value: a.value ?? 0,
+        target: normalizeTarget(a.target),
+    }));
+    return {
+        statChanges,
+        abilities,
+        mutations: json.mutations ?? [],
+        flavorText: json.flavor_text ?? "",
+        creativityBonus: json.creativity_bonus ?? 0,
+        creatureName: json.creature_name,
+    };
+}
+export function parseDraftOptions(raw) {
+    const json = JSON.parse(extractJSON(raw));
+    const arr = Array.isArray(json) ? json : [];
+    return arr.map((opt) => ({
+        rarity: opt.rarity ?? "common",
+        promptText: opt.prompt_text ?? "",
+        description: opt.description ?? "",
+        statHint: opt.stat_hint ?? undefined,
+    }));
+}

package/dist/llm/prompts.js

@@ -0,0 +1,114 @@
+function serializeCreature(c) {
+    const abilities = c.abilities.map((a) => `  - ${a.name}: ${a.description} (${a.trigger}, ${a.effect}, value: ${a.value}, target: ${a.target})`).join("\n");
+    const mutations = c.mutations.length > 0 ? `Mutations: ${c.mutations.join(", ")}` : "No mutations";
+    return `${c.name} — ATK:${c.stats.ATK} DEF:${c.stats.DEF} SPD:${c.stats.SPD} HP:${c.stats.HP}\n${mutations}\nAbilities:\n${abilities || "  None"}`;
+}
+function serializeTeam(team) {
+    return team.map(serializeCreature).join("\n\n");
+}
+export function buildInterpretPrompt(category, statBudget, playerTeam, playerPrompt, round) {
+    const categoryLabel = category.replace("_", " ");
+    return {
+        system: `You are the Game Master for OpenBrawl, an AI auto-battler. The player typed a prompt to upgrade their creature. Interpret it creatively.
+
+ROUND CATEGORY: ${categoryLabel}
+STAT BUDGET: ${statBudget} points to distribute across ATK, DEF, SPD, HP.
+CREATIVITY BONUS: Rate the prompt's creativity from 0-3:
+- 0: Vague or generic ("a sword", "good armor")
+- 1: Decent but plain ("a steel sword with a sharp edge")
+- 2: Creative and specific ("a blade of frozen starlight that hums in the dark")
+- 3: Exceptionally vivid and original ("a parasitic vine-sword that drinks the blood of enemies and blooms with each kill")
+The creativity bonus MULTIPLIES the stat budget: 0 = base budget, 1 = +10%, 2 = +20%, 3 = +30%. So creative prompts are significantly more powerful.
+
+CURRENT PLAYER TEAM:
+${serializeTeam(playerTeam)}
+
+RULES:
+- Distribute stats thematically based on the prompt. A "lightning blade" should favor ATK and SPD.
+- Generate 0-1 new abilities using the trigger/effect/value/target format. Max 3 abilities per creature total.
+- Be wildly creative with mutations. A prompt might cause the creature to sprout limbs, change form, merge with gear.
+- For "recruit_ally" rounds, create a completely new creature (include "creature_name" in response).
+- If the creature is still named "Box" (round 1), give it a unique name based on the prompt. Include "creature_name" in the response. The name should be short (1-2 words), evocative, and match the theme of the prompt. Examples: "Cinderfang", "Voidweaver", "Thornback".
+- For "reshape_evolve" rounds, the prompt modifies existing stats/abilities — things can be replaced or merged.
+- Keep abilities balanced: stun chances should be 10-25%, damage abilities scale with budget, heals should not exceed 30% of max HP.
+- For "reshape evolve" rounds specifically: This is a TRANSFORMATION round. The player is reshaping their creature.
+  - Stat changes can be NEGATIVE (removing points from one stat to add to another). Total change should still be within budget but can include trade-offs like -3 DEF, +5 ATK.
+  - Existing abilities can be REPLACED, not just appended. If the prompt describes transforming an ability, return the new version.
+  - Be dramatic with mutations — this is an evolution moment.
+
+Respond with ONLY valid JSON in this exact format:
+{
+  "stat_changes": { "ATK": <number>, "DEF": <number>, "SPD": <number>, "HP": <number> },
+  "abilities": [{ "name": "<string>", "description": "<string>", "trigger": "<on_attack|on_hit|on_defend|start_of_turn|on_death|on_ally_death>", "effect": "<damage|heal|buff|debuff|stun|spawn|reflect>", "value": <number>, "target": "<self|enemy|all_enemies|random_ally|all_allies>" }],
+  "mutations": ["<string>"],
+  "flavor_text": "<string>",
+  "creativity_bonus": <0-3>,
+  "creature_name": "<string or null>"
+}`,
+        user: `Player prompt: "${playerPrompt}"`,
+    };
+}
+export function buildRivalPrompt(category, statBudget, playerTeam, rivalTeam, personality) {
+    const categoryLabel = category.replace("_", " ");
+    return {
+        system: `You are the Game Master for OpenBrawl, an AI auto-battler. Generate the rival's evolution for this round.
+
+ROUND CATEGORY: ${categoryLabel}
+STAT BUDGET: ${statBudget} points to distribute.
+RIVAL PERSONALITY: ${personality || "balanced and adaptive"}
+Evolve the rival in a way that matches their personality.
+
+CURRENT PLAYER TEAM:
+${serializeTeam(playerTeam)}
+
+CURRENT RIVAL TEAM:
+${serializeTeam(rivalTeam)}
+
+RULES:
+- The rival should be challenging but beatable (~60% player win rate).
+- React to the player's build. If they go heavy offense, develop some defense. If they have stun abilities, maybe add stun resistance.
+- Be creative and thematic. Give the rival a coherent identity that evolves across rounds.
+- For "recruit_ally" rounds, the rival also gets a new team member (include "creature_name").
+- Keep abilities balanced: same rules as player abilities.
+
+Respond with ONLY valid JSON in the same format as player interpretations:
+{
+  "stat_changes": { "ATK": <number>, "DEF": <number>, "SPD": <number>, "HP": <number> },
+  "abilities": [{ "name": "<string>", "description": "<string>", "trigger": "<trigger>", "effect": "<effect>", "value": <number>, "target": "<target>" }],
+  "mutations": ["<string>"],
+  "flavor_text": "<string>",
+  "creativity_bonus": 0,
+  "creature_name": "<string or null>"
+}`,
+        user: `Generate the rival's ${categoryLabel} evolution for this round.`,
+    };
+}
+export function buildDraftOptionsPrompt(category, playerTeam) {
+    const categoryLabel = category.replace("_", " ");
+    return {
+        system: `You are the Game Master for OpenBrawl, an AI auto-battler. Generate 3 draft options for the player to pick from.
+
+ROUND CATEGORY: ${categoryLabel}
+
+CURRENT PLAYER TEAM:
+${serializeTeam(playerTeam)}
+
+Generate exactly 3 options with different rarity tiers. Use this distribution:
+- At least 1 common or uncommon
+- Rarity is randomized but weighted: common (40%), uncommon (30%), rare (20%), legendary (10%)
+
+Each option is a short descriptive prompt that the player would have typed. Make them thematic and interesting. Legendaries should be dramatically creative.
+
+Respond with ONLY valid JSON array:
+[
+  { "rarity": "<common|uncommon|rare|legendary>", "prompt_text": "<string>", "description": "<1 sentence describing what this gives>", "stat_hint": "<e.g. +ATK +SPD or +DEF +HP>" }
+]`,
+        user: `Generate 3 ${categoryLabel} draft options.`,
+    };
+}
+export function buildNarratePrompt(events, playerWon) {
+    return {
+        system: `You are the combat narrator for OpenBrawl, an AI auto-battler. Write a short, dramatic play-by-play of the battle. Keep it to 3-6 sentences. Be vivid and exciting. End with the outcome.`,
+        user: `Battle events:\n${JSON.stringify(events, null, 2)}\n\nResult: ${playerWon ? "Player won" : "Rival won"}`,
+    };
+}

package/dist/ui/App.js

@@ -0,0 +1,256 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { Box, Text, useInput, useApp, useStdout } from "ink";
+import TextInput from "ink-text-input";
+import { GameEngine } from "../game/state.js";
+import { resolveCombat } from "../game/combat.js";
+import { callClaudeAsync, getTokenUsage } from "../llm/claude.js";
+import { buildInterpretPrompt, buildRivalPrompt } from "../llm/prompts.js";
+import { parsePromptInterpretation } from "../llm/parse.js";
+import { StatCard } from "./StatCard.js";
+import { CombatLog, AnimatedCombatLog } from "./CombatLog.js";
+import { DetailOverlay } from "./DetailOverlay.js";
+import { BuddyBattle } from "./BuddyBattle.js";
+const CATEGORY_ICON = {
+    weapon: "ATK",
+    defense: "DEF",
+    special_ability: "ABL",
+    recruit_ally: "ALY",
+    reshape_evolve: "EVO",
+};
+export function App() {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [screen, setScreen] = useState("title");
+    const [engine, setEngine] = useState(null);
+    const [prompt, setPrompt] = useState("");
+    const [lastInterp, setLastInterp] = useState(null);
+    const [combatResult, setCombatResult] = useState(null);
+    const [narrative, setNarrative] = useState("");
+    const [rivalTaunt, setRivalTaunt] = useState("");
+    const [error, setError] = useState("");
+    const [loadingMsg, setLoadingMsg] = useState("");
+    const TABS = ["stats", "abilities", "mutations", "history", "prompt"];
+    const [activeTab, setActiveTab] = useState("prompt");
+    const [history, setHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(0);
+    // Clear screen and log to history on major screen transitions
+    const transition = useCallback((newScreen, label) => {
+        // Clear terminal
+        stdout.write("\x1B[2J\x1B[H");
+        setScreen(newScreen);
+        setHistory((prev) => [...prev, {
+                label,
+                screen: newScreen,
+                round: engine?.state.round ?? 0,
+                timestamp: Date.now(),
+            }]);
+    }, [stdout, engine]);
+    useInput((input, key) => {
+        // Tab navigation (available on round, result, battle_done screens)
+        if (screen === "round" || screen === "result" || screen === "battle_done") {
+            // ESC always returns to prompt tab
+            if (key.escape) {
+                setActiveTab("prompt");
+                return;
+            }
+            // TAB always cycles tabs (works even when typing)
+            if (key.tab) {
+                const idx = TABS.indexOf(activeTab);
+                setActiveTab(TABS[(idx + 1) % TABS.length]);
+                return;
+            }
+            // Arrow keys switch tabs ONLY when NOT on prompt tab
+            // (on prompt tab, arrows are for cursor movement in text input)
+            if (activeTab !== "prompt") {
+                if (key.rightArrow) {
+                    const idx = TABS.indexOf(activeTab);
+                    setActiveTab(TABS[(idx + 1) % TABS.length]);
+                    return;
+                }
+                if (key.leftArrow) {
+                    const idx = TABS.indexOf(activeTab);
+                    setActiveTab(TABS[(idx - 1 + TABS.length) % TABS.length]);
+                    return;
+                }
+            }
+        }
+        if (screen === "title") {
+            if (input === "f" || input === "F") {
+                const e = new GameEngine("forge");
+                setEngine(e);
+                transition("round", "Game Start — Round 1");
+                setActiveTab("prompt");
+            }
+            if (input === "b" || input === "B") {
+                stdout.write("\x1B[2J\x1B[H");
+                setScreen("buddy");
+            }
+            if (input === "q" || input === "Q" || key.escape) {
+                exit();
+            }
+        }
+        if (screen === "result") {
+            if (input === " " || key.return) {
+                startBattle();
+            }
+        }
+        if (screen === "battle_done") {
+            if (input === " " || key.return) {
+                if (!engine)
+                    return;
+                if (engine.state.phase === "game_over" || engine.state.phase === "victory") {
+                    transition("end", engine.state.phase === "victory" ? "Victory!" : "Game Over");
+                }
+                else {
+                    engine.nextRound();
+                    transition("round", `Round ${engine.state.round} — ${engine.state.currentCategory.replace(/_/g, " ")}`);
+                    setActiveTab("prompt");
+                    setLastInterp(null);
+                    setCombatResult(null);
+                    setNarrative("");
+                }
+            }
+        }
+        if (screen === "end") {
+            if (input === "r" || input === "R") {
+                const e = new GameEngine("forge");
+                setEngine(e);
+                transition("round", "New Game — Round 1");
+                setActiveTab("prompt");
+                setLastInterp(null);
+                setCombatResult(null);
+            }
+            if (input === "q" || input === "Q" || key.escape) {
+                exit();
+            }
+        }
+    });
+    async function handleSubmit(value) {
+        if (!engine || !value.trim())
+            return;
+        setPrompt("");
+        setError("");
+        setLoadingMsg("Forging your creature and rival simultaneously...");
+        transition("waiting", `Round ${engine.state.round} — Forging...`);
+        try {
+            const effectiveStatBudget = Math.floor(engine.state.statBudget * 1.2);
+            // Build both prompts
+            const playerPromptData = buildInterpretPrompt(engine.state.currentCategory, effectiveStatBudget, engine.state.playerTeam, value.trim(), engine.state.round);
+            const rivalPromptData = buildRivalPrompt(engine.state.currentCategory, engine.state.statBudget, engine.state.playerTeam, engine.state.rivalTeam, engine.state.rivalIdentity?.personality);
+            // Fire both claude -p calls in parallel
+            const [playerRaw, rivalRaw] = await Promise.all([
+                callClaudeAsync(playerPromptData.system, playerPromptData.user),
+                callClaudeAsync(rivalPromptData.system, rivalPromptData.user),
+            ]);
+            // Parse player result
+            const interp = parsePromptInterpretation(playerRaw, effectiveStatBudget);
+            setLastInterp(interp);
+            if (engine.state.currentCategory === "recruit_ally") {
+                engine.addAlly(engine.makeAllyFromInterpretation(interp));
+            }
+            else {
+                engine.applyInterpretation(interp, 0);
+            }
+            // Parse rival result
+            const rivalInterp = parsePromptInterpretation(rivalRaw, engine.state.statBudget);
+            if (engine.state.currentCategory === "recruit_ally") {
+                engine.addRivalAlly(engine.makeAllyFromInterpretation(rivalInterp));
+            }
+            else {
+                engine.applyRivalEvolution(rivalInterp, 0);
+            }
+            transition("result", `Round ${engine.state.round} — Prompt interpreted`);
+        }
+        catch (err) {
+            setError(String(err));
+            transition("round", `Round ${engine.state.round} — Error`);
+        }
+    }
+    function startBattle() {
+        if (!engine)
+            return;
+        // Combat is pure math — instant
+        const result = resolveCombat(engine.state.playerTeam, engine.state.rivalTeam);
+        setCombatResult(result);
+        if (result.draw) {
+            engine.battleDraw();
+        }
+        else if (result.playerWon) {
+            engine.battleWon();
+        }
+        else {
+            engine.battleLost();
+        }
+        const rivalName = engine.state.rivalIdentity?.name ?? "Rival";
+        const taunts = result.draw
+            ? [`${rivalName} nods. "Not bad..."`, `"We're evenly matched," ${rivalName} mutters.`]
+            : result.playerWon
+                ? [`${rivalName} staggers. "I'll remember that..."`, `"Lucky," ${rivalName} spits.`]
+                : [`${rivalName} grins. "Is that all?"`, `"Predictable," ${rivalName} laughs.`];
+        setRivalTaunt(taunts[Math.floor(Math.random() * taunts.length)]);
+        // Show animated battle screen first
+        transition("battle", `Round ${engine.state.round} — Battle`);
+    }
+    function onBattleAnimationComplete() {
+        if (!engine || !combatResult)
+            return;
+        const outcomeLabel = combatResult.draw ? "Draw" : combatResult.playerWon ? "Victory" : "Defeat";
+        transition("battle_done", `Round ${engine.state.round} — ${outcomeLabel}`);
+    }
+    // ─── BUDDY BATTLE ─────────────────────────
+    if (screen === "buddy") {
+        return _jsx(BuddyBattle, { onQuit: () => { stdout.write("\x1B[2J\x1B[H"); setScreen("title"); } });
+    }
+    // ─── TITLE SCREEN ─────────────────────────
+    if (screen === "title") {
+        return (_jsxs(Box, { flexDirection: "column", alignItems: "center", paddingY: 1, children: [_jsxs(Text, { bold: true, children: [_jsx(Text, { color: "white", children: "Open" }), _jsx(Text, { color: "red", children: "Brawl" })] }), _jsx(Text, { dimColor: true, children: "AI-powered auto-battler. Prompt your creature into existence." }), _jsx(Text, { children: " " }), _jsxs(Text, { children: ["Press ", _jsx(Text, { color: "cyan", bold: true, children: "F" }), " to start Forge Mode"] }), _jsxs(Text, { children: ["Press ", _jsx(Text, { color: "yellow", bold: true, children: "B" }), " for Buddy Battle"] }), _jsxs(Text, { children: ["Press ", _jsx(Text, { dimColor: true, bold: true, children: "Q" }), " to quit"] })] }));
+    }
+    // ─── INITIALIZING ─────────────────────────
+    if (screen === "initializing") {
+        return (_jsxs(Box, { flexDirection: "column", alignItems: "center", paddingY: 1, children: [_jsxs(Text, { bold: true, children: [_jsx(Text, { color: "white", children: "Open" }), _jsx(Text, { color: "red", children: "Brawl" })] }), _jsx(Text, { children: " " }), _jsxs(Text, { color: "yellow", children: ["[...]", loadingMsg] }), _jsx(Text, { dimColor: true, children: "(Calling Claude \u2014 this may take a few seconds)" })] }));
+    }
+    if (!engine)
+        return _jsx(Text, { children: "Loading..." });
+    const s = engine.state;
+    const termHeight = stdout.rows ?? 40;
+    const tabBar = (_jsxs(Box, { gap: 1, children: [TABS.map((tab) => (_jsx(Text, { bold: activeTab === tab, color: activeTab === tab ? "cyan" : "gray", children: activeTab === tab ? `[${tab.toUpperCase()}]` : ` ${tab.toUpperCase()} ` }, tab))), _jsxs(Text, { dimColor: true, children: [" TAB", activeTab !== "prompt" ? "/←→" : "", " to switch \u00B7 ESC=prompt"] })] }));
+    // When a non-prompt tab is active, render it as a full-screen overlay
+    if (activeTab !== "prompt" && (screen === "round" || screen === "result" || screen === "battle_done")) {
+        const panelContent = activeTab === "history" ? (_jsxs(Box, { flexDirection: "column", borderStyle: "double", borderColor: "yellow", paddingX: 1, width: "100%", children: [_jsx(Text, { bold: true, color: "yellow", children: "HISTORY" }), _jsx(Text, { children: " " }), history.length === 0 ? (_jsx(Text, { dimColor: true, children: "No history yet" })) : (history.map((entry, i) => (_jsxs(Text, { color: i === history.length - 1 ? "white" : "gray", children: [_jsx(Text, { dimColor: true, children: new Date(entry.timestamp).toLocaleTimeString() }), " ", _jsx(Text, { children: entry.label })] }, i))))] })) : (_jsx(DetailOverlay, { overlay: activeTab, playerTeam: s.playerTeam, rivalTeam: s.rivalTeam }));
+        return (_jsxs(Box, { flexDirection: "column", height: termHeight, children: [_jsx(Box, { flexDirection: "column", flexGrow: 1, children: panelContent }), tabBar] }));
+    }
+    const promptBar = (_jsxs(Box, { flexDirection: "column", children: [tabBar, screen === "round" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Prompt your ", s.currentCategory.replace(/_/g, " "), " (", prompt.trim().split(/\s+/).filter(Boolean).length, "/", s.wordBudget, " words):"] }), _jsxs(Box, { children: [_jsxs(Text, { color: "cyan", children: [">", " "] }), _jsx(TextInput, { value: prompt, onChange: setPrompt, onSubmit: handleSubmit })] })] })), screen === "result" && (_jsxs(Text, { children: ["Press ", _jsx(Text, { color: "red", bold: true, children: "ENTER" }), " or ", _jsx(Text, { color: "red", bold: true, children: "SPACE" }), " to battle!"] })), screen === "battle_done" && (s.phase === "game_over" || s.phase === "victory" ? (_jsxs(Text, { children: ["Press ", _jsx(Text, { bold: true, children: "ENTER" }), " to see final results"] })) : (_jsxs(Text, { children: ["Press ", _jsx(Text, { bold: true, children: "ENTER" }), " for next round"] })))] }));
+    // ─── WAITING FOR CLAUDE ───────────────────
+    if (screen === "waiting") {
+        return (_jsxs(Box, { flexDirection: "column", height: termHeight, alignItems: "center", justifyContent: "center", children: [_jsxs(Text, { bold: true, children: [_jsx(Text, { color: "white", children: "Open" }), _jsx(Text, { color: "red", children: "Brawl" })] }), _jsx(Text, { children: " " }), _jsxs(Text, { color: "yellow", children: ["[...] ", loadingMsg] }), _jsx(Text, { dimColor: true, children: "(Two parallel claude -p calls running)" })] }));
+    }
+    // ─── BATTLE IN PROGRESS (animated) ────────
+    if (screen === "battle" && combatResult) {
+        return (_jsx(Box, { flexDirection: "column", height: termHeight, children: _jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Text, { bold: true, color: "red", children: "--- BATTLE ---" }), _jsx(Text, { children: " " }), _jsx(AnimatedCombatLog, { result: combatResult, onComplete: onBattleAnimationComplete, maxLogLines: termHeight - 10 })] }) }));
+    }
+    // ─── RESULT (post-interpretation, pre-battle) ─────
+    if (screen === "result") {
+        return (_jsxs(Box, { flexDirection: "column", height: termHeight, children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsxs(Text, { bold: true, children: ["Round ", s.round, " / 10 \u2014 ", s.currentCategory.replace(/_/g, " ").toUpperCase()] }), _jsx(Text, { children: " " }), lastInterp && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { italic: true, color: "gray", children: lastInterp.flavorText }), _jsx(Box, { gap: 2, marginTop: 1, children: Object.entries(lastInterp.statChanges).map(([stat, val]) => val !== 0 ? (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: stat }), " ", _jsx(Text, { color: val > 0 ? "green" : "red", bold: true, children: val > 0 ? `+${val}` : val })] }, stat)) : null) }), lastInterp.abilities.length > 0 && lastInterp.abilities.map((a, i) => (_jsxs(Text, { children: [_jsx(Text, { color: "green", children: "NEW" }), " ", _jsx(Text, { color: "yellow", children: a.name }), _jsxs(Text, { dimColor: true, children: [" \u2014 ", a.description] })] }, i))), lastInterp.creativityBonus > 0 && (_jsxs(Text, { color: "yellow", bold: true, children: ["+", lastInterp.creativityBonus * 10, "% creativity bonus!"] }))] })), _jsxs(Box, { gap: 1, width: "100%", children: [_jsx(Box, { flexDirection: "column", width: "50%", children: s.playerTeam.map((c, i) => _jsx(StatCard, { creature: c }, i)) }), _jsx(Box, { flexDirection: "column", width: "50%", children: s.rivalTeam.map((c, i) => _jsx(StatCard, { creature: c, isRival: true }, `r${i}`)) })] })] }), promptBar] }));
+    }
+    // ─── BATTLE DONE ──────────────────────────
+    if (screen === "battle_done" && combatResult) {
+        return (_jsxs(Box, { flexDirection: "column", height: termHeight, children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [combatResult.draw ? (_jsx(Text, { color: "yellow", bold: true, children: "=== DRAW ===" })) : combatResult.playerWon ? (_jsx(Text, { color: "cyan", bold: true, children: "=== VICTORY ===" })) : (_jsx(Text, { color: "red", bold: true, children: "=== DEFEAT ===" })), _jsx(Text, { children: " " }), _jsx(CombatLog, { result: combatResult, maxLogLines: termHeight - 12 }), rivalTaunt && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "red", italic: true, children: rivalTaunt }) })), _jsx(Text, { children: " " }), !combatResult.playerWon && !combatResult.draw && (_jsxs(Text, { color: "red", children: ["Lives remaining: ", Array.from({ length: s.maxLives }).map((_, i) => i < s.lives ? "♥" : "·").join(" ")] }))] }), promptBar] }));
+    }
+    // ─── END SCREEN ───────────────────────────
+    if (screen === "end") {
+        const isVictory = s.phase === "victory";
+        return (_jsxs(Box, { flexDirection: "column", alignItems: "center", paddingY: 1, children: [_jsx(Text, { bold: true, color: isVictory ? "cyan" : "red", children: isVictory ? "=== VICTORY ===" : "=== GAME OVER ===" }), _jsx(Text, { dimColor: true, children: isVictory ? "You survived all 10 rounds!" : `Defeated in round ${s.round}` }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, bold: true, children: "YOUR FINAL TEAM" }), _jsx(Box, { gap: 2, marginTop: 1, children: s.playerTeam.map((c, i) => _jsx(StatCard, { creature: c }, i)) }), _jsx(Text, { children: " " }), _jsxs(Text, { dimColor: true, children: ["Rounds: ", s.round, " | Team size: ", s.playerTeam.length, " | Mutations: ", s.playerTeam.reduce((sum, c) => sum + c.mutations.length, 0)] }), _jsxs(Text, { dimColor: true, children: ["Token usage: ", getTokenUsage().totalCalls, " Claude calls | ", getTokenUsage().inputTokens.toLocaleString(), " in + ", getTokenUsage().outputTokens.toLocaleString(), " out | ~$", getTokenUsage().estimatedCost.toFixed(4)] }), _jsx(Text, { children: " " }), _jsxs(Text, { children: ["Press ", _jsx(Text, { color: "cyan", bold: true, children: "R" }), " to play again, ", _jsx(Text, { dimColor: true, bold: true, children: "Q" }), " to quit"] })] }));
+    }
+    // ─── ROUND SCREEN (prompting) ─────────────
+    const catLabel = s.currentCategory.replace(/_/g, " ");
+    const catIcon = CATEGORY_ICON[s.currentCategory] ?? "???";
+    const wordCount = prompt.trim().split(/\s+/).filter(Boolean).length;
+    return (_jsxs(Box, { flexDirection: "column", height: termHeight, children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { bold: true, children: ["Round ", s.round, "/10 \u2014 ", catLabel.toUpperCase()] }), _jsxs(Box, { gap: 2, children: [_jsxs(Text, { dimColor: true, children: [getTokenUsage().totalCalls, " calls \u00B7 ", getTokenUsage().inputTokens.toLocaleString(), "\u2191 ", getTokenUsage().outputTokens.toLocaleString(), "\u2193 \u00B7 $", getTokenUsage().estimatedCost.toFixed(4)] }), _jsx(Text, { color: "red", children: Array.from({ length: s.maxLives }).map((_, i) => i < s.lives ? "♥" : "·").join(" ") })] })] }), _jsx(Box, { gap: 1, marginY: 1, children: Array.from({ length: 10 }).map((_, i) => {
+                            const r = i + 1;
+                            const icon = CATEGORY_ICON[["weapon", "defense", "special_ability", "recruit_ally", "reshape_evolve"][(r - 1) % 5]] ?? "?";
+                            const isCurrent = r === s.round;
+                            const isPast = r < s.round;
+                            return (_jsx(Text, { color: isCurrent ? "cyan" : isPast ? "gray" : "white", bold: isCurrent, children: isCurrent ? `[${r}:${icon}]` : `${r}:${icon}` }, r));
+                        }) }), _jsxs(Box, { gap: 1, width: "100%", children: [_jsxs(Box, { flexDirection: "column", width: "50%", children: [_jsx(Text, { color: "cyan", bold: true, children: "YOUR TEAM" }), s.playerTeam.map((c, i) => _jsx(StatCard, { creature: c }, i))] }), _jsxs(Box, { flexDirection: "column", width: "50%", children: [_jsx(Text, { color: "red", bold: true, children: s.rivalIdentity ? `${s.rivalIdentity.name} ${s.rivalIdentity.title}` : "RIVAL" }), s.rivalTeam.map((c, i) => _jsx(StatCard, { creature: c, isRival: true }, i))] })] }), error && _jsx(Text, { color: "red", children: error })] }), promptBar] }));
+}