termi-kids 0.1.2 → 0.2.0

package/README.md

@@ -10,17 +10,15 @@
 
 # Termi
 
-Termi is a friendly robot that helps you build things on a real computer.
+Termi is a friendly robot that helps you build browser games on a real computer.
 
-You type what you want. Termi writes the code with you. Your game opens in the browser right away.
+You pick a game idea (or invent your own). You write a prompt, or ask Termi to help write one. Termi builds the game with you. Your game opens in the browser and updates after every prompt.
 
-You can make dodge games, platform games, pixel art, dance music, virtual pets, adventure stories, quizzes, your own web page, and talking characters. If you change your mind, type `undo` and the last change is gone. When something works, you earn badges.
+There are 30 ready game ideas plus "Build my own idea". When you finish, Termi can run a short test pass and suggest one last improvement. Games save in your local library on this computer.
 
-Termi is a computer program, an AI tool. It is not a person. A grown-up sets it up first.
-
-Not sure what to say first? Type `/quest` inside any project. Termi walks you through a real build, step by step, with a ready idea at every step. Press Enter to use it, or type your own. Finish a quest and you earn the Quest Hero badge.
+Want to get better at prompting? Open **Learn AI**. Six short lessons teach you how to boss your AI helper. Each one earns a badge, and you can replay them any time.
 
-Want to get good at building with AI? Type `termi learn`. Six short lessons teach you how to be the boss of your AI helper. Each one earns a badge, and you can replay them any time.
+Termi is a computer program, an AI tool. It is not a person. A grown-up sets it up first.
 
 Ready? Ask a grown-up to read the next part.
 
@@ -37,7 +35,7 @@ Please read [SAFETY.md](SAFETY.md) before handing the keyboard to your kid. It e
 - Node.js 20.19 or newer: https://nodejs.org
 - macOS, Windows, or Linux
 - An AI account you own (one of: a ChatGPT account, a Claude API key, an OpenAI API key, or a Grok API key)
-- About 700 MB of free disk space for the on-device safety checker (recommended, on by default)
+- About 700 MB of free disk space for the on-device safety checker (installed during setup)
 
 If Node is too old, Termi prints a plain message with the download link instead of starting.
 
@@ -58,16 +56,14 @@ To update later, run `termi update` (or `npm install -g termi-kids@latest`). On
 Run `termi`. The first run starts a setup wizard for a parent or guardian. It takes about five minutes:
 
 1. **Create a grown-up PIN** (at least 4 characters). It guards the grown-up zone. Your kid should not know it.
-2. **Age band and consent.** You pick "Under 13" or "13 or older" and confirm that Termi uses an AI account you own and that you agree to watch how your kid uses it. This consent is recorded in the local safety log.
+2. **Consent.** You confirm that Termi uses an AI account you own and that you agree to watch how your kid uses it. One safety bar applies for every age (no under-13 / over-13 split). Consent is recorded in the local safety log.
 3. **Pick an AI provider.** The default is "ChatGPT sign-in": your browser opens, you sign in to your own ChatGPT account, and no API key is needed. The other options are a Claude API key, an OpenAI API key, or a Grok API key. Grok requires an extra confirmation because the xAI API terms are adults-only (details in SAFETY.md). You can add several providers and choose which one is active.
-4. **Safety checker download.** Termi offers a small safety model (623 MB) that screens every message right on your computer, even with no internet. It is on by default and worth keeping. While it downloads, Termi tells you plainly that basic safety (the local filter plus the online checks) is already running, and asks whether you want to start building now or wait and watch the progress bar. Either way, the checker turns itself on the moment the verified file lands and Termi says so, even mid-session. The download is anonymous (no account or token needed) and resumes if interrupted. Details are in [SAFETY.md](SAFETY.md).
+4. **Safety checker install.** Setup always starts the on-device safety model download (about 623 MB). It screens every message on this computer, even offline. You can wait for the progress bar or keep setting up while it finishes in the background. Basic safety is already on during the download. The download is anonymous and resumes if interrupted. Details are in [SAFETY.md](SAFETY.md).
 5. **Hand the keyboard to your kid.** The kid picks a made-up nickname (Termi asks them not to use their real name) and sees a clear disclosure: "Termi is a computer program, an AI. It is a tool a grown-up set up for you. It is not a person."
 6. **Desktop shortcut.** Termi offers to write a double-clickable launcher on the Desktop (`Termi.command` on macOS, `Termi.bat` on Windows, `Termi.desktop` on Linux) so your kid can come back tomorrow without typing commands.
-7. **Optional first game.** Two keypresses later there is a running game in the browser.
-
-If you skip the provider step, Termi runs in offline mode: your kid can still create projects, play them in the preview, undo changes, and browse ideas. The chat shows a kind "ask a grown-up to set up the AI helper" screen.
+7. **Optional first game.** The kid can jump straight into **Build a game** (pick an idea or invent one).
 
-**If your kid does not know where to start:** every project type has a Build Quest (`/quest` in the chat), a five-step guided build with a ready prompt at each step, and a large idea deck (`/ideas`). Quest steps go through the same safety pipeline as any other message.
+If you skip the provider step, Termi runs in offline mode: your kid can still open the library and Learn AI. Building with the AI helper needs a provider.
 
 ### What keeps your kid safe
 
@@ -87,13 +83,13 @@ Parents get a PIN-gated grown-up zone, a tamper-evident log of every block and s
 
 | Command | What it does |
 |---|---|
-| `termi` | First run: setup wizard. After that: the home menu. |
-| `termi new` | Start a new project. |
-| `termi go [name]` | Open a project and build. With no name, pick from a list. |
-| `termi preview [name]` | Open a project in the browser without the chat. |
-| `termi ideas` | Print fun project ideas. |
-| `termi learn` | Six short, replayable lessons on building with AI. Fully offline, no AI calls. |
+| `termi` | First run: setup wizard. After that: home (Build a game, My games, Learn AI). |
+| `termi new` | Build a game (idea list + prompt loop). |
+| `termi go [name]` | Open a game from your library. With no name, pick from a list. |
+| `termi preview [name]` | Open a game in the browser without the chat. |
+| `termi learn` | Learn AI: six short offline lessons on prompting. |
 | `termi grownups` | The grown-up zone. PIN required. |
+| `termi update` | Update Termi to the latest npm version. |
 | `termi help` | Show the command list. |
 | `termi --version` | Show the version. |
 

package/SAFETY.md

@@ -50,7 +50,7 @@ Grooming, personal info, and rule-breaking tricks block at a lower threshold tha
 
 Termi includes an on-device safety checker: a small AI model (Qwen3Guard 0.6B, published by the Qwen team under the Apache 2.0 license) that runs entirely on your computer. Setup offers the download (623 MB) with a yes as the default; you can decline and add it later from the grown-up zone (`termi grownups`, then **Safety checker**).
 
-The download never blocks anyone. Setup says, in plain words, that basic safety (the local filter plus the online checks) is already on, then asks whether you want to start building now or wait and watch the progress bar. If you start now, the download continues in the background while your kid builds, the home menu shows its bar, and the checker attaches itself to the running safety pipeline the moment the verified file is in place; Termi announces it on screen ("Your safety helper is on."), even in the middle of a build session. If the download is interrupted (a closed laptop, a dropped connection), it resumes from where it stopped the next time Termi starts. Until the file lands, the online checks carry the load exactly as they would with the checker turned off.
+Setup always starts the download (it is part of install, not an easy skip). Setup says, in plain words, that basic safety (the local filter plus the online checks) is already on, then asks whether you want to wait and watch the progress bar or keep setting up while it finishes. Either way the download continues, the home menu can show its bar, and the checker attaches itself to the running safety pipeline the moment the verified file is in place; Termi announces it on screen ("Your safety helper is on."), even in the middle of a build session. If the download is interrupted (a closed laptop, a dropped connection), it resumes from where it stopped the next time Termi starts. Until the file lands, the online checks carry the load.
 
 The download itself is anonymous. The model file comes over HTTPS from a public model repository, with no account, sign-in, or token of any kind; nothing about you or your kid is sent with the request, and the file is checked against a pinned cryptographic fingerprint before it is used.
 

package/dist/cli.js

@@ -19,7 +19,6 @@ import { installGlobalHandlers, renderCrash } from './ui/errors.js';
 import { mascot } from './ui/mascot.js';
 import { style } from './ui/theme.js';
 import { T } from './ui/text.js';
-import { executeIdeas } from './surfaces/commands.js';
 /** Pure boot branch logic: settings state in, actions out. */
 export function decideBoot(state) {
     return {
@@ -32,11 +31,10 @@ export function cliHelp() {
     return [
         'How to use Termi:',
         '  termi            open the home menu',
-        '  termi new        start a new project',
-        '  termi go [name]  open a project and build',
-        '  termi preview    watch a project run',
-        '  termi ideas      get fun ideas',
-        '  termi learn      play six short lessons about AI',
+        '  termi new        build a game',
+        '  termi go [name]  open a game from your library',
+        '  termi preview    watch a game run',
+        '  termi learn      Learn AI (prompting lessons)',
         '  termi grownups   grown-up zone (PIN needed)',
         '  termi update     update Termi to the latest version',
         '  termi help       show this help',
@@ -124,24 +122,6 @@ async function routePreview(nameArg, settings) {
         // Held open on purpose; Ctrl+C ends it through the global handler.
     });
 }
-async function routeIdeas(settings) {
-    let scaffoldId = 'games';
-    if (settings.lastProjectSlug !== null) {
-        try {
-            const store = await import('./projects/store.js');
-            const last = store.openProject(settings.lastProjectSlug);
-            if (last !== null) {
-                scaffoldId = last.meta.scaffoldId;
-            }
-        }
-        catch {
-            // Fall back to game ideas.
-        }
-    }
-    await executeIdeas(scaffoldId, (text) => {
-        console.log(text);
-    });
-}
 async function route(command, rest, settings) {
     const home = await import('./surfaces/home.js');
     switch (command) {
@@ -150,10 +130,8 @@ async function route(command, rest, settings) {
             return;
         }
         case 'new': {
-            const project = await home.runNewProject(settings);
-            if (project !== null) {
-                await home.openChatLoop(project, settings);
-            }
+            const build = await import('./surfaces/buildGame.js');
+            await build.runBuildGame(settings);
             return;
         }
         case 'go': {
@@ -168,7 +146,9 @@ async function route(command, rest, settings) {
             return;
         }
         case 'ideas': {
-            await routeIdeas(settings);
+            // Ideas live inside Build a game now.
+            const build = await import('./surfaces/buildGame.js');
+            await build.runBuildGame(settings);
             return;
         }
         case 'learn': {

package/dist/learn/runner.js

@@ -164,7 +164,7 @@ export async function runLesson(lesson, say = defaultSay) {
  */
 export async function runLearnMenu() {
     console.log(mascot('happy'));
-    console.log('Welcome to Termi school! Six tiny lessons, zero homework.');
+    console.log('Learn AI: six tiny lessons on how to prompt. Zero homework.');
     for (;;) {
         const done = new Set(loadProgress().completed);
         const options = [

package/dist/projects/blankGame.js

@@ -0,0 +1,100 @@
+/**
+ * Minimal blank game project: no stock playable game, just a local HTML
+ * shell the model fills in. Used by the Build a game flow.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { projectsDir } from '../config/paths.js';
+import { slugifyName } from './create.js';
+import { notesFileName, openProject, renderTermiMd, saveProjectMeta, } from './store.js';
+const BLANK_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>__TITLE__</title>
+  <link rel="stylesheet" href="style.css" />
+</head>
+<body>
+  <main>
+    <h1 id="title">__TITLE__</h1>
+    <p id="hint">Your game will show up here after you build with Termi.</p>
+    <canvas id="game" width="480" height="320" aria-label="game"></canvas>
+  </main>
+  <script src="game.js"></script>
+</body>
+</html>
+`;
+const BLANK_CSS = `* { box-sizing: border-box; }
+body {
+  margin: 0;
+  font-family: system-ui, sans-serif;
+  background: #0f172a;
+  color: #e2e8f0;
+  min-height: 100vh;
+  display: grid;
+  place-items: center;
+}
+main { text-align: center; padding: 1rem; }
+h1 { font-size: 1.4rem; margin: 0 0 0.5rem; }
+#hint { opacity: 0.8; margin-bottom: 1rem; }
+canvas {
+  background: #1e293b;
+  border: 2px solid #38bdf8;
+  border-radius: 12px;
+  max-width: 100%;
+}
+`;
+const BLANK_JS = `// Blank starter. Termi and the kid fill this in.
+const canvas = document.getElementById('game');
+const ctx = canvas.getContext('2d');
+function frame() {
+  ctx.fillStyle = '#1e293b';
+  ctx.fillRect(0, 0, canvas.width, canvas.height);
+  ctx.fillStyle = '#94a3b8';
+  ctx.font = '16px system-ui, sans-serif';
+  ctx.textAlign = 'center';
+  ctx.fillText('Ready to build!', canvas.width / 2, canvas.height / 2);
+}
+frame();
+`;
+function writeRel(dir, relPath, content) {
+    const target = path.join(dir, ...relPath.split('/'));
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, content, 'utf8');
+}
+/**
+ * Creates an empty local-browser game shell under the projects library.
+ * scaffoldId stays "games" so existing badges and quests still recognize it.
+ */
+export function createBlankGameProject(prettyNameInput, ideaLabel = 'My game') {
+    const trimmed = prettyNameInput.trim();
+    const prettyName = trimmed.length > 0 ? trimmed : 'My Game';
+    const { slug } = slugifyName(prettyName);
+    const dir = path.join(projectsDir(), slug);
+    fs.mkdirSync(dir, { recursive: true });
+    const html = BLANK_HTML.replaceAll('__TITLE__', prettyName);
+    writeRel(dir, 'index.html', html);
+    writeRel(dir, 'style.css', BLANK_CSS);
+    writeRel(dir, 'game.js', BLANK_JS);
+    writeRel(dir, notesFileName, renderTermiMd(prettyName, {
+        whatThisIs: `A browser game: ${ideaLabel}. Built with Termi.`,
+        files: ['index.html', 'style.css', 'game.js'],
+        builtSoFar: ['Blank game shell ready for the first prompt'],
+        recapLine: `We started ${prettyName}.`,
+    }));
+    const now = new Date().toISOString();
+    saveProjectMeta({
+        slug,
+        prettyName,
+        scaffoldId: 'games',
+        themeId: 'blank',
+        createdAt: now,
+        lastOpenedAt: now,
+    });
+    const project = openProject(slug);
+    if (project === null) {
+        throw new Error('Something went wrong while making the project. Try again.');
+    }
+    return project;
+}

package/dist/projects/gameIdeas.js

@@ -0,0 +1,216 @@
+/**
+ * Kid-facing Build-a-game idea bank.
+ *
+ * Exactly 31 entries: "Build my own idea" first, then 30 browser HTML games.
+ * Every idea is local-preview only (HTML/CSS/JS), no image generation, no
+ * native installs. Pure data for tests and the Build a game menu.
+ */
+/** True for the custom entry that asks the kid for their own concept. */
+export function isOwnIdea(idea) {
+    return idea.id === 'own';
+}
+/**
+ * Menu order is fixed. First entry is always Build my own idea.
+ * The remaining 30 are distinct local-browser game concepts.
+ */
+export const GAME_IDEAS = [
+    {
+        id: 'own',
+        label: 'Build my own idea',
+        blurb: 'You invent the game. Termi helps you build it.',
+        seedPrompt: '',
+    },
+    {
+        id: 'dodge-rain',
+        label: 'Dodge the rain',
+        blurb: 'Move left and right. Catch drops or dodge them.',
+        seedPrompt: 'Make a simple canvas game where I move left and right to dodge falling rain drops. Add a score and a restart key.',
+    },
+    {
+        id: 'catch-stars',
+        label: 'Catch the stars',
+        blurb: 'Catch falling stars before they hit the ground.',
+        seedPrompt: 'Make a canvas catch game. Stars fall from the top. I move a basket to catch them. Show the score and lives.',
+    },
+    {
+        id: 'memory-cards',
+        label: 'Memory cards',
+        blurb: 'Flip cards and match pairs.',
+        seedPrompt: 'Make a memory match card game with 12 cards (6 pairs) using emoji. Click to flip. Count moves. Show a win message.',
+    },
+    {
+        id: 'click-targets',
+        label: 'Click the targets',
+        blurb: 'Click circles before they vanish.',
+        seedPrompt: 'Make a click target game. Circles appear for a short time. Click them for points. Add a 30 second timer and a final score.',
+    },
+    {
+        id: 'maze-escape',
+        label: 'Maze escape',
+        blurb: 'Find the exit in a simple maze.',
+        seedPrompt: 'Make a keyboard maze game on a canvas grid. Arrow keys move a square. Reach the green exit. Keep walls solid.',
+    },
+    {
+        id: 'snake-lite',
+        label: 'Snake lite',
+        blurb: 'Grow a snake by eating dots.',
+        seedPrompt: 'Make a simple snake game on a grid. Arrow keys move. Eat food to grow. Hitting a wall or yourself restarts.',
+    },
+    {
+        id: 'pong-solo',
+        label: 'Pong solo',
+        blurb: 'Bounce a ball with one paddle.',
+        seedPrompt: 'Make a one player pong game. Move the paddle with the mouse or arrows. Ball bounces. Score points. Restart on miss.',
+    },
+    {
+        id: 'whack-moles',
+        label: 'Whack a mole',
+        blurb: 'Tap moles as they pop up.',
+        seedPrompt: 'Make a whack a mole game with a 3 by 3 grid of holes. Moles pop up briefly. Click them for points. Add a timer.',
+    },
+    {
+        id: 'color-match',
+        label: 'Color match',
+        blurb: 'Match the word color to the right button.',
+        seedPrompt: 'Make a color word game. Show a color name in a random ink color. Kid clicks the button that matches the WORD meaning. Score streaks.',
+    },
+    {
+        id: 'typing-race',
+        label: 'Typing race',
+        blurb: 'Type the word before time runs out.',
+        seedPrompt: 'Make a typing race. Show a simple word. Kid types it and presses Enter. Track speed and accuracy for 10 words.',
+    },
+    {
+        id: 'platform-jump',
+        label: 'Platform jumper',
+        blurb: 'Jump across platforms to the flag.',
+        seedPrompt: 'Make a side view platformer on canvas. Arrow keys move and jump. Reach a flag on the right. Simple gravity and platforms.',
+    },
+    {
+        id: 'balloon-pop',
+        label: 'Balloon pop',
+        blurb: 'Pop balloons before they float away.',
+        seedPrompt: 'Make a balloon pop game. Balloons float up. Click to pop them. Missed balloons cost a life. Show score.',
+    },
+    {
+        id: 'quiz-sprint',
+        label: 'Quiz sprint',
+        blurb: 'Answer fun multiple choice questions.',
+        seedPrompt: 'Make a 5 question multiple choice quiz about animals. Show score at the end. Use big clear buttons.',
+    },
+    {
+        id: 'simon-says',
+        label: 'Simon says lights',
+        blurb: 'Repeat the light pattern.',
+        seedPrompt: 'Make a Simon style memory game with 4 colored buttons. Play a growing pattern. Kid repeats it. Score the longest streak.',
+    },
+    {
+        id: 'rock-paper',
+        label: 'Rock paper scissors',
+        blurb: 'Play against the computer. Pick rock, paper, or scissors.',
+        seedPrompt: 'Make rock paper scissors with three big buttons. Computer picks at random. Track wins, losses, and ties.',
+    },
+    {
+        id: 'number-guess',
+        label: 'Number guess',
+        blurb: 'Guess the secret number.',
+        seedPrompt: 'Make a number guess game from 1 to 50. Kid types a guess. Say higher or lower. Count tries until they win.',
+    },
+    {
+        id: 'breakout-lite',
+        label: 'Breakout lite',
+        blurb: 'Bounce a ball to break bricks.',
+        seedPrompt: 'Make a simple breakout game. Paddle at the bottom, ball, and one row of bricks. Clear the bricks to win.',
+    },
+    {
+        id: 'flappy-lite',
+        label: 'Flappy lite',
+        blurb: 'Tap to flap between gaps.',
+        seedPrompt: 'Make a flappy style game. Space or click flaps up. Gravity pulls down. Fly through gaps in pipes. Score each pipe.',
+    },
+    {
+        id: 'tic-tac-toe',
+        label: 'Tic tac toe',
+        blurb: 'Play X and O on a 3 by 3 board.',
+        seedPrompt: 'Make tic tac toe for two players on one keyboard. Click cells. Detect win and draw. Add a new game button.',
+    },
+    {
+        id: 'collect-coins',
+        label: 'Collect coins',
+        blurb: 'Run around and grab all the coins.',
+        seedPrompt: 'Make a top down collect game. Arrow keys move a player. Coins sit on a small map. Collect all coins to win.',
+    },
+    {
+        id: 'avoid-cars',
+        label: 'Avoid the cars',
+        blurb: 'Cross the road safely.',
+        seedPrompt: 'Make a cross the road game. Player moves up. Cars move left and right. Reach the top without hitting a car.',
+    },
+    {
+        id: 'reaction-test',
+        label: 'Reaction test',
+        blurb: 'Click when the screen turns green.',
+        seedPrompt: 'Make a reaction time test. Screen starts red, then turns green after a random wait. Click as fast as you can. Show ms time.',
+    },
+    {
+        id: 'word-scramble',
+        label: 'Word scramble',
+        blurb: 'Unscramble the letters.',
+        seedPrompt: 'Make a word scramble game with 8 easy words. Show mixed letters. Kid types the word. Track score out of 8.',
+    },
+    {
+        id: 'tower-stack',
+        label: 'Tower stack',
+        blurb: 'Stack blocks as high as you can.',
+        seedPrompt: 'Make a stack game. A block slides left and right. Click or press space to drop it. Stack as high as you can without missing.',
+    },
+    {
+        id: 'balloon-math',
+        label: 'Balloon math',
+        blurb: 'Pop the balloon with the right answer.',
+        seedPrompt: 'Make a math balloon game. Show a simple add or subtract problem. Three balloons show answers. Click the correct one.',
+    },
+    {
+        id: 'day-night',
+        label: 'Day and night runner',
+        blurb: 'Run while the world switches day and night.',
+        seedPrompt: 'Make a runner where the player auto runs right. Jump over rocks. Every 10 seconds switch day and night colors. Track distance.',
+    },
+    {
+        id: 'fruit-slice',
+        label: 'Fruit slice',
+        blurb: 'Swipe or click fruit, avoid bombs.',
+        seedPrompt: 'Make a fruit slice style game. Fruit flies up. Click fruit for points. Clicking a bomb ends the round. Show score.',
+    },
+    {
+        id: 'hide-seek',
+        label: 'Hide and seek dots',
+        blurb: 'Find the odd color in the crowd.',
+        seedPrompt: 'Make a find the odd one out game. Show many colored dots. One is a slightly different color. Click it. Levels get harder.',
+    },
+    {
+        id: 'space-lander',
+        label: 'Soft lander',
+        blurb: 'Land the ship gently on the pad.',
+        seedPrompt: 'Make a lander game. Ship falls with gravity. Arrow keys thrust and steer. Land softly on a pad. Crash if too fast.',
+    },
+    {
+        id: 'story-choice',
+        label: 'Choice adventure',
+        blurb: 'A short story with choices you click.',
+        seedPrompt: 'Make a short click adventure with 4 scenes. Each scene has text and 2 choice buttons. End with a happy finish screen.',
+    },
+];
+/** Exactly one own-idea entry plus 30 game ideas. */
+export const GAME_IDEA_COUNT = GAME_IDEAS.length;
+/** Menu options for selects: value is idea id. */
+export function gameIdeaMenuOptions() {
+    return GAME_IDEAS.map((idea) => ({
+        value: idea.id,
+        label: idea.label,
+        hint: idea.blurb,
+    }));
+}
+export function gameIdeaById(id) {
+    return GAME_IDEAS.find((idea) => idea.id === id);
+}

package/dist/setup/wizard.js

@@ -16,7 +16,6 @@ import { appendAudit } from '../safety/audit.js';
 import { ensureGuardFetch, guardProgressBar } from '../safety/guarddownload.js';
 import { guardModelReady } from '../safety/modelstore.js';
 import { nameIsOkay } from '../safety/prefilter.js';
-import { scaffoldById } from '../projects/scaffolds/index.js';
 import { renderBanner } from '../ui/banner.js';
 import { mascot } from '../ui/mascot.js';
 import { style } from '../ui/theme.js';
@@ -262,14 +261,7 @@ async function createPinStep() {
     }
 }
 async function consentStep(settings) {
-    const ageBand = ensure(await p.select({
-        message: 'How old is your kid?',
-        options: [
-            { value: 'under13', label: 'Under 13' },
-            { value: 'teen', label: '13 or older' },
-        ],
-        initialValue: 'under13',
-    }));
+    // One safety bar for every age. No under-13 / over-13 split.
     const agreed = ensure(await p.confirm({ message: `${T.wizard.consentIntro} Do you agree?`, initialValue: true }));
     if (!agreed) {
         bail();
@@ -280,13 +272,13 @@ async function consentStep(settings) {
             ts: attestedAt,
             layer: 'system',
             event: 'consent',
-            excerpt: `parent consent, age band ${ageBand}`,
+            excerpt: 'parent consent, one safety bar for all ages',
         });
     }
     catch {
         // Consent still counts; the audit line is best effort.
     }
-    return { ...settings, ageBand, consentAttestedAt: attestedAt };
+    return { ...settings, ageBand: 'under13', consentAttestedAt: attestedAt };
 }
 async function providerLoop(settings) {
     let current = settings;
@@ -318,41 +310,27 @@ async function providerLoop(settings) {
     return { ...current, activeProvider: null };
 }
 /**
- * Offers the on-device safety checker download. Default is yes: the
- * classifier setting ships on, and this step starts fetching its model file
- * in the background. The parent hears, plainly, that basic safety (the
- * local filter plus the online checks) is already on and that the checker
- * strengthens it when the download lands, then chooses to start building
- * now or wait and watch the bar. Either way the pipeline hot-attaches the
- * checker the moment the verified file is in place. Declining turns the
- * setting off; a failed or interrupted download resumes on the next start.
+ * Installs the on-device safety checker as part of setup. Always on: the
+ * model download starts here (and resumes on later boots). Parent can wait
+ * for the bar or keep going; declining is not offered.
  */
 async function localGuardStep(settings) {
     if (guardModelReady()) {
-        // Model already present: keep whatever the parent chose before. A
-        // wizard re-run must not silently flip a deliberate off back to on.
-        return settings;
-    }
-    const wants = ensure(await p.confirm({ message: T.wizard.guardOffer, initialValue: true }));
-    if (!wants) {
-        p.log.info(T.wizard.guardDeclined);
-        audit('settings_change', 'local classifier off (declined in setup)');
-        return { ...settings, localClassifier: false };
+        return { ...settings, localClassifier: true };
     }
+    p.log.info(T.wizard.guardOffer);
     const fetchDone = ensureGuardFetch();
     p.log.info(T.wizard.guardBackground);
+    audit('settings_change', 'local classifier install started in setup');
     const wait = ensure(await p.select({
         message: T.wizard.guardWaitPick,
         options: [
-            { value: 'now', label: T.wizard.guardStartNow, hint: T.wizard.guardStartNowHint },
             { value: 'wait', label: T.wizard.guardWaitHere, hint: T.wizard.guardWaitHereHint },
+            { value: 'now', label: T.wizard.guardStartNow, hint: T.wizard.guardStartNowHint },
         ],
-        initialValue: 'now',
+        initialValue: 'wait',
     }));
     if (wait === 'wait') {
-        // The wait shows a live bar with periodic escape hatches (after one
-        // minute, then every ten): a slow connection must not trap the parent
-        // in setup when the download finishes fine in the background anyway.
         const escapeAfterMs = [60_000, 600_000];
         let escapeIndex = 0;
         for (;;) {
@@ -406,64 +384,12 @@ async function firstGameStep(settings) {
     if (p.isCancel(wants) || !wants) {
         return;
     }
-    const games = scaffoldById('games');
-    if (games === undefined) {
-        return;
-    }
-    const themeId = await p.select({
-        message: 'Pick a style for your game.',
-        options: games.themes.map((t) => ({ value: t.id, label: `${t.emoji} ${t.label}` })),
-    });
-    if (p.isCancel(themeId)) {
-        return;
-    }
-    const theme = games.themes.find((t) => t.id === themeId);
-    if (theme === undefined) {
-        return;
-    }
-    const CUSTOM = '__custom__';
-    const suggestions = suggestProjectNames(theme.label);
-    const namePick = await p.select({
-        message: 'Pick a name for it.',
-        options: [
-            ...suggestions.map((n) => ({ value: n, label: n })),
-            { value: CUSTOM, label: 'Type my own name' },
-        ],
-    });
-    if (p.isCancel(namePick)) {
-        return;
-    }
-    let prettyName = namePick;
-    if (namePick === CUSTOM) {
-        const typed = await p.text({
-            message: 'What is its name?',
-            validate: (value) => {
-                const trimmed = (value ?? '').trim();
-                if (trimmed.length === 0)
-                    return 'It needs a name.';
-                if (!nameIsOkay(trimmed))
-                    return 'That name will not work. Try another one.';
-                return undefined;
-            },
-        });
-        if (p.isCancel(typed)) {
-            return;
-        }
-        prettyName = typed.trim();
-    }
     try {
-        const create = await import('../projects/create.js');
-        const home = await import('../surfaces/home.js');
-        const made = create.createProject('games', theme.id, prettyName);
-        await home.awardBadge('first-project');
-        const starters = made.starterPrompts.slice(0, 2);
-        if (starters.length > 0) {
-            p.note(starters.map((line) => `- ${line}`).join('\n'), 'Try saying');
-        }
-        await home.openChatLoop(made.project, settings);
+        const build = await import('../surfaces/buildGame.js');
+        await build.runBuildGame(settings);
     }
     catch {
-        p.log.warn('I could not start the game yet. Try "termi new" next time.');
+        p.log.warn('I could not start the game yet. Try Build a game next time.');
     }
 }
 /** Runs the full setup wizard, parent flow then kid flow. */

package/dist/surfaces/buildGame.js

@@ -0,0 +1,335 @@
+/**
+ * Build a game: pick an idea, prompt loop, live preview, done/improve,
+ * final polish. Projects save in the local library under TERMI_PROJECTS_DIR.
+ */
+import * as p from '@clack/prompts';
+import { getSecret } from '../auth/keychain.js';
+import { hasTokens } from '../auth/tokens.js';
+import { startPreview } from '../preview/server.js';
+import { createProviderClient, pickClassifierBackend, } from '../providers/index.js';
+import { classifyProviderError } from '../providers/errors.js';
+import { appendAudit } from '../safety/audit.js';
+import { createSafetyPipeline } from '../safety/classifier.js';
+import { ensureGuardFetch } from '../safety/guarddownload.js';
+import { lazyGuardAccessor } from '../safety/guardrunner.js';
+import { guardModelReady } from '../safety/modelstore.js';
+import { createSessionState } from '../safety/session.js';
+import { nameIsOkay } from '../safety/prefilter.js';
+import { createBlankGameProject } from '../projects/blankGame.js';
+import { GAME_IDEAS, gameIdeaById, gameIdeaMenuOptions, isOwnIdea, } from '../projects/gameIdeas.js';
+import { providerLabel } from '../setup/wizard.js';
+import { renderProviderError } from '../ui/errors.js';
+import { style } from '../ui/theme.js';
+import { T } from '../ui/text.js';
+import { completenessHint, defaultNameForIdea, helpQuestions, parseDoneChoice, polishPrompt, seedPromptForIdea, suggestPromptFromAnswers, summarizeProjectFiles, } from './buildLoop.js';
+import { awardBadge } from './home.js';
+function audit(event) {
+    try {
+        appendAudit(event);
+    }
+    catch {
+        // Never break the kid flow for the log.
+    }
+}
+function providerAvailability(settings) {
+    return {
+        'openai-chatgpt': hasTokens(),
+        'openai-api': (getSecret('api-key-openai-api') ?? '').length > 0,
+        anthropic: (getSecret('api-key-anthropic') ?? '').length > 0,
+        xai: (getSecret('api-key-xai') ?? '').length > 0 && settings.xaiParentAck,
+    };
+}
+async function pickIdea() {
+    const pick = await p.select({
+        message: 'Build a game. What do you want to make?',
+        options: gameIdeaMenuOptions(),
+        initialValue: GAME_IDEAS[0].id,
+    });
+    if (p.isCancel(pick)) {
+        return null;
+    }
+    return gameIdeaById(pick) ?? null;
+}
+async function pickProjectName(idea) {
+    const suggested = defaultNameForIdea(idea);
+    const typed = await p.text({
+        message: 'Name your game.',
+        placeholder: suggested,
+        defaultValue: suggested,
+        validate: (value) => {
+            const trimmed = (value ?? '').trim() || suggested;
+            if (trimmed.length === 0)
+                return 'It needs a name.';
+            if (!nameIsOkay(trimmed))
+                return 'That name will not work. Try another one.';
+            return undefined;
+        },
+    });
+    if (p.isCancel(typed)) {
+        return null;
+    }
+    const name = typed.trim() || suggested;
+    return name;
+}
+async function gatherHelpAnswers(idea) {
+    const questions = helpQuestions(idea);
+    const answers = [];
+    for (const question of questions) {
+        const ans = await p.text({
+            message: question,
+            validate: (value) => (value ?? '').trim().length > 0 ? undefined : 'Say a little so I can help.',
+        });
+        if (p.isCancel(ans)) {
+            return null;
+        }
+        answers.push(ans.trim());
+    }
+    return answers;
+}
+async function obtainPrompt(idea) {
+    const path = await p.select({
+        message: 'How do you want to tell Termi what to build?',
+        options: [
+            { value: 'write', label: 'I will write my own prompt' },
+            { value: 'help', label: 'Help me with a prompt for my idea' },
+            ...(seedPromptForIdea(idea).length > 0
+                ? [{ value: 'seed', label: 'Use the ready idea prompt' }]
+                : []),
+        ],
+    });
+    if (p.isCancel(path)) {
+        return null;
+    }
+    let draft = '';
+    if (path === 'seed') {
+        draft = seedPromptForIdea(idea);
+    }
+    else if (path === 'help') {
+        const answers = await gatherHelpAnswers(idea);
+        if (answers === null) {
+            return null;
+        }
+        draft = suggestPromptFromAnswers(idea, answers);
+        p.note(draft, 'Suggested prompt');
+    }
+    const text = await p.text({
+        message: path === 'write' ? 'Type your prompt.' : 'Edit the prompt, or press Enter to run it.',
+        defaultValue: draft,
+        placeholder: draft || 'Make a fun browser game where...',
+        validate: (value) => (value ?? '').trim().length > 0 ? undefined : 'Need a prompt to build.',
+    });
+    if (p.isCancel(text)) {
+        return null;
+    }
+    return text.trim();
+}
+function listKidFileSummaries(project) {
+    const out = [];
+    for (const file of project.listKidFiles()) {
+        const content = project.readFile(file.relPath);
+        if (content !== null) {
+            out.push({ relPath: file.relPath, content });
+        }
+    }
+    return out;
+}
+async function runOneTurn(kidMessage, deps) {
+    const loop = await import('../agent/loop.js');
+    const spin = p.spinner();
+    spin.start(T.chat.thinking);
+    let result;
+    try {
+        result = await loop.runTurn(kidMessage, {
+            provider: deps.provider,
+            modelAlias: deps.settings.modelAlias,
+            safety: deps.safety,
+            session: deps.session,
+            project: deps.project,
+            snapshots: deps.snapshots,
+            preview: deps.preview,
+            audit,
+            ui: {
+                onActivity(line) {
+                    spin.message(line);
+                },
+            },
+        });
+    }
+    catch (err) {
+        spin.stop();
+        const label = deps.settings.activeProvider !== null
+            ? providerLabel(deps.settings.activeProvider)
+            : 'AI helper';
+        console.log(renderProviderError(classifyProviderError(err), label));
+        return 'error';
+    }
+    spin.stop(T.chat.working);
+    if (result.status === 'ok') {
+        if (result.replyText) {
+            console.log(result.replyText);
+        }
+        try {
+            deps.preview.notifyChange();
+        }
+        catch {
+            // Preview may already be closed.
+        }
+        return 'ok';
+    }
+    if (result.status === 'blocked') {
+        if (result.screen !== null) {
+            console.log(result.screen.body);
+        }
+        else {
+            console.log(T.blocks.generic);
+        }
+        return 'blocked';
+    }
+    if (result.screen !== null) {
+        console.log(result.screen.body);
+    }
+    else {
+        console.log(T.errors.oops);
+    }
+    return 'error';
+}
+/**
+ * Full Build a game session for one project from idea pick to library save.
+ * Returns the project when something was saved, null on cancel at the start.
+ */
+export async function runBuildGame(settings) {
+    const idea = await pickIdea();
+    if (idea === null) {
+        return null;
+    }
+    const prettyName = await pickProjectName(idea);
+    if (prettyName === null) {
+        return null;
+    }
+    let project;
+    try {
+        project = createBlankGameProject(prettyName, idea.label);
+    }
+    catch (err) {
+        p.log.error(err instanceof Error ? err.message : 'Could not create the game folder.');
+        return null;
+    }
+    await awardBadge('first-project');
+    let provider = null;
+    if (settings.activeProvider !== null) {
+        try {
+            provider = createProviderClient(settings.activeProvider);
+        }
+        catch {
+            provider = null;
+        }
+    }
+    if (provider === null) {
+        p.log.warn(`${T.offline.noProvider} ${T.offline.stillWorks}`);
+        p.log.info(`Your game folder is ready: ${project.meta.prettyName}`);
+        return project;
+    }
+    if (settings.localClassifier && !guardModelReady()) {
+        void ensureGuardFetch();
+    }
+    const backend = pickClassifierBackend(settings, providerAvailability(settings));
+    const safety = createSafetyPipeline({
+        classifierModel: () => backend.classifierClient !== null
+            ? backend.classifierClient.languageModel('classifier', settings.modelAlias)
+            : null,
+        moderationKey: () => backend.moderationKey,
+        localGuard: lazyGuardAccessor(settings.localClassifier),
+        audit,
+    });
+    const session = createSessionState();
+    let snapshots = {
+        beginTurn() { },
+        undo() {
+            return false;
+        },
+        redo() {
+            return false;
+        },
+    };
+    try {
+        const snapMod = await import('../projects/snapshots.js');
+        snapshots = snapMod.createSnapshotStore(project);
+    }
+    catch {
+        // undo optional
+    }
+    const preview = await startPreview(project.dir, { openBrowser: true });
+    console.log(`${T.chat.previewOpened} ${style.dim(preview.url)}`);
+    console.log(style.dim('The browser will update after each build.'));
+    const turnDeps = { provider, settings, project, preview, safety, session, snapshots };
+    // First build
+    for (;;) {
+        const prompt = await obtainPrompt(idea);
+        if (prompt === null) {
+            break;
+        }
+        const status = await runOneTurn(prompt, turnDeps);
+        if (status === 'ok') {
+            try {
+                preview.notifyChange();
+            }
+            catch {
+                //
+            }
+        }
+        const next = await p.select({
+            message: 'Do you think you are done, or want to improve the idea?',
+            options: [
+                { value: 'improve', label: 'Improve' },
+                { value: 'done', label: 'I am done' },
+            ],
+            initialValue: 'improve',
+        });
+        if (p.isCancel(next)) {
+            break;
+        }
+        const choice = parseDoneChoice(next);
+        if (choice === 'improve') {
+            continue;
+        }
+        if (choice === 'done') {
+            console.log(style.title('Testing your game and making final fixes...'));
+            const summary = summarizeProjectFiles(listKidFileSummaries(project));
+            const hint = completenessHint(summary);
+            console.log(style.dim(`Suggestion: ${hint}`));
+            const approve = await p.confirm({
+                message: 'Apply this final improvement?',
+                initialValue: true,
+            });
+            if (!p.isCancel(approve) && approve) {
+                const finalPrompt = polishPrompt(`${hint}. Project: ${summary}`);
+                await runOneTurn(finalPrompt, turnDeps);
+                try {
+                    preview.notifyChange();
+                }
+                catch {
+                    //
+                }
+                console.log(style.good('Final fixes applied. Check the browser!'));
+            }
+            else {
+                console.log('Okay. Your game is saved as is.');
+            }
+            break;
+        }
+    }
+    p.log.success(`Saved in your game library: ${project.meta.prettyName}`);
+    // Keep preview open so the kid can keep playing; they Ctrl+C later or return home.
+    return project;
+}
+/** Exported for tests that assert the catalog is wired. */
+export function buildGameIdeaCount() {
+    return GAME_IDEAS.length;
+}
+export function buildGameFirstLabel() {
+    return GAME_IDEAS[0]?.label ?? '';
+}
+export function buildGameIsOwnFirst() {
+    const first = GAME_IDEAS[0];
+    return first !== undefined && isOwnIdea(first);
+}

package/dist/surfaces/buildLoop.js

@@ -0,0 +1,114 @@
+/**
+ * Pure helpers for the Build a game prompt loop.
+ * UI and network live in buildGame.ts; tests cover this module fully.
+ */
+import { isOwnIdea } from '../projects/gameIdeas.js';
+/** Clarifying questions when the kid picks Help me with a prompt. */
+export function helpQuestions(idea) {
+    if (isOwnIdea(idea)) {
+        return [
+            'What is your game about in one short line?',
+            'How does the player win or finish?',
+            'What keys or clicks should control it?',
+        ];
+    }
+    return [
+        `What should feel special about "${idea.label}"?`,
+        'Do you want easy mode, normal, or hard?',
+    ];
+}
+/** Builds a starter prompt from a catalog idea (not own-idea). */
+export function seedPromptForIdea(idea) {
+    if (isOwnIdea(idea) || idea.seedPrompt.trim().length === 0) {
+        return '';
+    }
+    return idea.seedPrompt.trim();
+}
+/**
+ * Turns help-question answers into a suggested build prompt the kid can
+ * edit. Works offline without a model call.
+ */
+export function suggestPromptFromAnswers(idea, answers) {
+    const cleaned = answers.map((a) => a.trim()).filter((a) => a.length > 0);
+    if (isOwnIdea(idea)) {
+        const about = cleaned[0] ?? 'a fun browser game';
+        const win = cleaned[1] ?? 'reach a high score';
+        const controls = cleaned[2] ?? 'arrow keys or click';
+        return (`Make a complete local browser game about ${about}. ` +
+            `The player wins when they ${win}. ` +
+            `Controls: ${controls}. ` +
+            `Use only HTML, CSS, and JavaScript in index.html, style.css, and game.js. ` +
+            `No images from the internet. Keep it kid friendly and playable after one load.`);
+    }
+    const special = cleaned[0] ?? idea.blurb;
+    const difficulty = cleaned[1] ?? 'normal';
+    const base = seedPromptForIdea(idea) || `Make a ${idea.label} browser game.`;
+    return (`${base} ` +
+        `Make it feel special by: ${special}. ` +
+        `Difficulty: ${difficulty}. ` +
+        `Use only HTML, CSS, and JavaScript files. No outside images.`);
+}
+/** Final polish instruction after the kid says they are done. */
+export function polishPrompt(projectSummary) {
+    const summary = projectSummary.trim().length > 0
+        ? projectSummary.trim().slice(0, 800)
+        : 'the current game files';
+    return (`You are doing final testing and fixes for this kid game. ` +
+        `Read the project files. Based on ${summary}, make ONE clear improvement ` +
+        `so the game feels more complete (for example a start screen, score, ` +
+        `restart key, win or lose message, or clearer controls). ` +
+        `Apply the change in the files. Keep it simple and kid friendly. ` +
+        `No internet images. Then briefly say what you fixed.`);
+}
+/** Summarize kid files for the polish prompt (pure). */
+export function summarizeProjectFiles(files) {
+    if (files.length === 0) {
+        return 'no files yet';
+    }
+    return files
+        .map((f) => {
+        const lines = f.content.split('\n').length;
+        const hasCanvas = /canvas/i.test(f.content);
+        const hasScore = /score/i.test(f.content);
+        const flags = [
+            hasCanvas ? 'canvas' : null,
+            hasScore ? 'score' : null,
+            lines < 20 ? 'short' : null,
+        ]
+            .filter(Boolean)
+            .join(',');
+        return `${f.relPath}(${lines} lines${flags ? `; ${flags}` : ''})`;
+    })
+        .join('; ');
+}
+/** Maps select values to done/improve. */
+export function parseDoneChoice(value) {
+    if (value === 'done' || value === 'improve') {
+        return value;
+    }
+    return null;
+}
+/** Default project name from an idea label. */
+export function defaultNameForIdea(idea) {
+    if (isOwnIdea(idea)) {
+        return 'My Game';
+    }
+    return idea.label;
+}
+/**
+ * One completeness suggestion line for the terminal (before the kid
+ * approves a polish apply). Pure heuristic from file summary text.
+ */
+export function completenessHint(summary) {
+    const s = summary.toLowerCase();
+    if (!s.includes('score')) {
+        return 'Add a clear score the player can see.';
+    }
+    if (!s.includes('canvas') && !s.includes('button')) {
+        return 'Add a start screen with a Play button.';
+    }
+    if (s.includes('short')) {
+        return 'Add a win or lose message and a restart key.';
+    }
+    return 'Add clearer control hints on the start screen.';
+}

package/dist/surfaces/home.js

@@ -15,11 +15,10 @@ import { consumeGuardReadyNotice, guardFetchState, guardProgressBar, } from '../
 import { nameIsOkay } from '../safety/prefilter.js';
 import { scaffolds, scaffoldById } from '../projects/scaffolds/index.js';
 import { suggestProjectNames } from '../setup/wizard.js';
-import { BADGES, celebrate, confetti, renderBadgeShelf } from '../ui/celebrate.js';
+import { BADGES, celebrate, confetti } from '../ui/celebrate.js';
 import { mascot } from '../ui/mascot.js';
 import { style } from '../ui/theme.js';
 import { T } from '../ui/text.js';
-import { executeIdeas } from './commands.js';
 /** Where the earned-badge list lives. */
 export function badgesFilePath() {
     return path.join(termiHome(), 'badges.json');
@@ -325,6 +324,31 @@ async function loadLastProject(settings) {
         return null;
     }
 }
+/** Kid home menu values (simplified product surface). */
+export const HOME_MENU_VALUES = [
+    'build',
+    'library',
+    'learn',
+    'continue',
+    'grownups',
+    'quit',
+];
+/**
+ * Pure home option list for tests. Build a game and Learn AI are always
+ * present; continue and library depend on whether projects exist.
+ */
+export function homeMenuOptions(hasLast, hasLibrary) {
+    const options = [];
+    if (hasLast) {
+        options.push({ value: 'continue', label: T.home.menuContinue });
+    }
+    options.push({ value: 'build', label: T.home.menuBuild }, { value: 'library', label: T.home.menuLibrary }, { value: 'learn', label: T.home.menuLearn }, { value: 'grownups', label: T.home.menuGrownups }, { value: 'quit', label: T.home.menuQuit });
+    if (!hasLibrary) {
+        // Library stays listed so kids discover where games are saved.
+        void hasLibrary;
+    }
+    return options;
+}
 /** The home menu loop for a returning kid. */
 export async function showHome(settings) {
     const nickname = settings.kidNickname.trim();
@@ -348,15 +372,19 @@ export async function showHome(settings) {
         else if (consumeGuardReadyNotice()) {
             console.log(style.dim(T.home.guardOn));
         }
-        const options = [];
-        if (last !== null) {
-            options.push({ value: 'continue', label: `Keep building ${last.context.meta.prettyName}` });
+        let hasLibrary = false;
+        try {
+            const store = await import('../projects/store.js');
+            hasLibrary = store.listProjects().length > 0;
+        }
+        catch {
+            hasLibrary = false;
         }
-        options.push({ value: 'open', label: T.home.menuGo }, { value: 'new', label: T.home.menuNew }, { value: 'ideas', label: T.home.menuIdeas }, { value: 'learn', label: 'Learn AI tricks' }, { value: 'badges', label: T.home.menuBadges }, { value: 'grownups', label: T.home.menuGrownups }, { value: 'quit', label: T.home.menuQuit });
+        const options = homeMenuOptions(last !== null, hasLibrary);
         const pick = await p.select({
             message: 'What now?',
             options,
-            initialValue: last !== null ? 'continue' : 'new',
+            initialValue: last !== null ? 'continue' : 'build',
         });
         if (p.isCancel(pick) || pick === 'quit') {
             p.outro(T.home.goodbye);
@@ -365,20 +393,26 @@ export async function showHome(settings) {
         if (pick === 'continue' && last !== null) {
             await openChatLoop(last.context, settings);
         }
-        else if (pick === 'open') {
+        else if (pick === 'library') {
             await openPicked(settings);
         }
-        else if (pick === 'new') {
-            const made = await runNewProject(settings);
-            if (made !== null) {
-                await openChatLoop(made, settings);
+        else if (pick === 'build') {
+            try {
+                const build = await import('./buildGame.js');
+                const made = await build.runBuildGame(settings);
+                if (made !== null) {
+                    settings.lastProjectSlug = made.meta.slug;
+                    try {
+                        saveSettings(settings);
+                    }
+                    catch {
+                        //
+                    }
+                }
+            }
+            catch {
+                p.log.warn('Build a game is taking a nap. Try again soon.');
             }
-        }
-        else if (pick === 'ideas') {
-            const scaffoldId = last !== null ? last.context.meta.scaffoldId : 'games';
-            await executeIdeas(scaffoldId, (text) => {
-                console.log(text);
-            });
         }
         else if (pick === 'learn') {
             try {
@@ -389,9 +423,6 @@ export async function showHome(settings) {
                 p.log.warn('Learn mode is taking a nap. Try again soon.');
             }
         }
-        else if (pick === 'badges') {
-            console.log(renderBadgeShelf(loadBadges()));
-        }
         else if (pick === 'grownups') {
             try {
                 const panel = await import('../grownups/panel.js');
@@ -412,7 +443,7 @@ async function openPicked(settings) {
     }
     const metas = mods.store.listProjects();
     if (metas.length === 0) {
-        p.log.info('No projects yet. Pick "Make something new"!');
+        p.log.info('No games yet. Pick "Build a game"!');
         return;
     }
     const first = metas[0];

package/dist/ui/text.js

@@ -24,10 +24,14 @@ export const T = {
         welcomeBack: 'Welcome back, {name}!',
         recapIntro: 'Last time: {recap}',
         nextStep: 'Want to keep going? I saved your spot.',
-        menuNew: 'Make something new',
-        menuGo: 'Open a project',
-        menuPreview: 'Watch a project run',
-        menuIdeas: 'Get ideas',
+        menuBuild: 'Build a game',
+        menuLibrary: 'My games',
+        menuLearn: 'Learn AI',
+        menuContinue: 'Keep building',
+        menuNew: 'Build a game',
+        menuGo: 'My games',
+        menuPreview: 'Watch a game run',
+        menuIdeas: 'Game ideas',
         menuBadges: 'See your badges',
         menuGrownups: 'Grown-up zone',
         menuHelp: 'Help',
@@ -43,25 +47,25 @@ export const T = {
         consentIntro: 'Termi uses an AI account you own. You agree to watch how your kid uses it.',
         providerPick: 'Pick the AI helper account Termi will use.',
         xaiAck: 'This provider is for adults only. A parent must own it and watch it.',
-        guardOffer: 'Termi includes a safety checker that runs on this computer (a 623 MB download). ' +
-            'It screens every message even when the internet is down. Download it now?',
+        guardOffer: 'Termi will install a safety helper on this computer. ' +
+            'It is about 623 MB. It checks messages even offline.',
         guardDownloading: 'Getting the safety file now...',
         guardBackground: 'Basic safety is on right now. It gets stronger when the download is done.',
-        guardWaitPick: 'Start building now, or wait for it?',
-        guardStartNow: 'Start now',
-        guardStartNowHint: 'The checker turns on by itself later.',
+        guardWaitPick: 'Wait for the safety helper, or keep setting up?',
+        guardStartNow: 'Keep setting up',
+        guardStartNowHint: 'The helper turns on by itself when ready.',
         guardWaitHere: 'Wait here',
         guardWaitHereHint: 'Watch the download finish first.',
         guardKeepWaiting: 'Still going. Keep waiting?',
-        guardReady: 'Your safety checker is set.',
-        guardFailed: 'The safety checker download did not finish. Termi still works; ' +
-            'you can retry from the grown-up zone any time.',
-        guardDeclined: 'Okay, skipping it. You can turn it on in the grown-up zone later.',
+        guardReady: 'Your safety helper is set.',
+        guardFailed: 'The safety download did not finish. Termi still works. ' +
+            'It will keep trying in the background.',
+        guardDeclined: 'The safety helper stays on. Termi will download it now.',
         handToKid: 'All set! Now hand the keyboard to your kid.',
-        kidHello: 'Hi! I am Termi. I help you build games and more.',
+        kidHello: 'Hi! I am Termi. I help you build games.',
         nicknamePrompt: 'Pick a fun made-up name. Not your real name!',
         aiDisclosure: 'Termi is a computer program, an AI. It is a tool a grown-up set up for you. It is not a person.',
-        firstGameOffer: 'Want to make your first game right now?',
+        firstGameOffer: 'Want to build your first game right now?',
         launcherMade: 'I made a Termi shortcut so you can come back fast.',
         nodeTooOld: 'Termi needs a newer Node. Ask a grown-up to install it from nodejs.org.',
     },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "termi-kids",
-  "version": "0.1.2",
-  "description": "Termi is a friendly coding buddy for kids. Build games, art, stories, and websites right from your computer, with a grown-up approved AI helper and strong safety rails.",
+  "version": "0.2.0",
+  "description": "Termi is a friendly coding buddy for kids. Build browser games with AI prompts, Learn AI lessons, and strong local safety rails.",
   "keywords": [
     "kids",
     "coding",