termi-kids 0.1.0 → 0.1.1

package/README.md

@@ -1,3 +1,13 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/dannyliv/Termi/main/assets/termi-hero.png" alt="Termi, a friendly robot popping out of a terminal window surrounded by pixel game elements" width="720">
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/termi-kids"><img src="https://img.shields.io/npm/v/termi-kids" alt="npm version"></a>
+  <a href="https://github.com/dannyliv/Termi/actions/workflows/ci.yml"><img src="https://github.com/dannyliv/Termi/actions/workflows/ci.yml/badge.svg" alt="CI status"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT license"></a>
+</p>
+
 # Termi
 
 Termi is a friendly robot that helps you build things on a real computer.
@@ -41,16 +51,6 @@ npm install -g termi-kids
 
 Then run `termi`. If npm reports a permission error, prefix the install with `sudo` on macOS and Linux, or run the terminal as administrator on Windows. To remove it later, run `npm rm -g termi-kids` (full cleanup steps are in SAFETY.md).
 
-To hack on Termi instead, install from a clone:
-
-```
-git clone https://github.com/dannyliv/Termi.git
-cd Termi
-npm install
-npm run build
-npm link
-```
-
 ### First run: the setup wizard
 
 Run `termi`. The first run starts a setup wizard for a parent or guardian. It takes about five minutes:
@@ -58,16 +58,29 @@ Run `termi`. The first run starts a setup wizard for a parent or guardian. It ta
 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.
 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. **Pick a safety level.** Strict is the default and the right choice for most kids.
-5. **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. The download runs in the background: setup continues, your kid can start building right away, the home menu shows a progress bar, and the checker turns itself on the moment the verified file lands. An interrupted download resumes on the next start. Details are in [SAFETY.md](SAFETY.md).
-6. **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."
-7. **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.
-8. **Optional first game.** Two keypresses later there is a running game in the browser.
+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).
+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.
 
 **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.
 
+### What keeps your kid safe
+
+Five layers sit between your kid and the AI, bound by one rule: when a check cannot finish, Termi blocks rather than guesses. There is no setting that weakens this.
+
+1. **A local filter on this computer.** Screens every message before it leaves the machine: profanity (including d.i.s.g.u.i.s.e.d spellings and leetspeak) and known "ignore your rules" tricks are blocked; personal details like names, addresses, phones, and school names are masked to `[secret]` before anything is sent.
+2. **Safety rules inside the AI's instructions.** The AI is a tool, never a friend: no romance, no secrets, no asking for real names, addresses, schools, ages, or photos. Big feelings get one kind line and a pointer to a trusted adult.
+3. **An on-device safety checker.** A small AI model (on by default, 623 MB) grades every message in and out right on your computer, even with no internet.
+4. **Checks on everything the AI produces.** The reply, every file it writes, and the human-visible text inside those files are all screened before your kid sees a single character, plus a code scan for network calls and hidden tricks.
+5. **A session-wide grooming watch.** Secrecy asks, affection aimed at the kid, probing for personal details, and attempts to move the chat to another app are counted across the whole conversation, and a hard block trips when the signals stack, no matter how innocent each message looked alone.
+
+**What gets filtered:** sexual content, self-harm (answered with a calm, supportive screen and the 988 line in the US), violence past a mild cartoon ceiling, hate and bullying, dangerous how-tos, profanity, personal information, grooming patterns, heavy adult and political topics, wholesale copying of others' work, and attempts to break the AI's rules. Normal game talk ("make the zombie disappear when you hit it") is deliberately allowed.
+
+Parents get a PIN-gated grown-up zone, a tamper-evident log of every block and settings change, and honest documentation: [SAFETY.md](SAFETY.md) explains how each layer works, what one message costs, and what a determined kid can and cannot get past.
+
 ### Commands
 
 | Command | What it does |
@@ -101,7 +114,7 @@ Inside the build chat, these slash commands work:
 
 Plain words work too: `undo`, `help`, `ideas`, `done`, `preview`, `badges`, `learn`, `quest`, and `quit` work on their own, no slash needed, and `exit`, `stop`, `bye`, and `leave` also quit. (`redo`, `new`, and `grownups` need the slash.) Misspelled commands get a "did you mean" suggestion.
 
-In the grown-up zone you can add, switch, or remove providers, change the safety level, manage the on-device safety checker (turn it on or off, download or remove its model file), pick the model speed (Zippy, the fast default, or Extra smart for tricky asks), read the usage and quota note, review the safety log, and see exactly where your data lives. Removing a provider deletes its saved key or sign-in from this computer.
+In the grown-up zone you can add, switch, or remove providers, manage the on-device safety checker (turn it on or off, download or remove its model file), pick the model speed (Zippy, the fast default, or Extra smart for tricky asks), read the usage and quota note, review the safety log, and see exactly where your data lives. Removing a provider deletes its saved key or sign-in from this computer.
 
 ### The nine project types
 
@@ -139,6 +152,20 @@ Termi's v1 stance is simple: one operating system user account per kid. Settings
 - **"Termi found changed settings. Safe settings are on now."** The settings file failed its integrity check, so Termi reverted to strict defaults. Review the grown-up zone.
 - **Crashes.** The kid sees a friendly screen; the technical details go to `~/.termi/error.log`.
 
+### Developing Termi
+
+For working on Termi itself (parents installing for a kid never need this):
+
+```
+git clone https://github.com/dannyliv/Termi.git
+cd Termi
+npm install
+npm run build
+npm link
+```
+
+`npm link` puts the development build on your PATH as `termi`; remove it with `npm rm -g termi`. Tests run with `npm test` (vitest, 1000+ tests).
+
 ### Uninstall
 
 See "Your data and how to remove Termi" in [SAFETY.md](SAFETY.md) for the exact folders, files, and keychain entries.

package/SAFETY.md

@@ -50,7 +50,9 @@ 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. It runs in the background while setup finishes and while your kid builds; the home menu shows its progress bar, and the checker attaches itself to the running safety pipeline the moment the verified file is in place. 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.
+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.
+
+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.
 
 What it does:
 
@@ -109,8 +111,6 @@ The real levers, and they are good ones:
 
 One more honest note: the keychain stores Termi's secrets on a best-effort basis. On systems without a usable keychain (some Linux setups), Termi falls back to a plain file at `~/.termi/secrets.json` and tells you so with a warning banner in the grown-up zone.
 
-About the safety level setting: the wizard and the grown-up zone offer Strict and Standard. In the current version both levels apply the same blocking thresholds; the setting is recorded for future tuning. Leave it on Strict.
-
 ## Privacy and COPPA posture
 
 Termi is built so that the developer never touches your family's data, because there is nothing to send it to:

package/dist/cli.js

@@ -10,7 +10,7 @@ import fs from 'node:fs';
 import * as p from '@clack/prompts';
 import { isSetupComplete } from './config/pin.js';
 import { ensureDirs, errorLogPath } from './config/paths.js';
-import { loadSettings } from './config/settings.js';
+import { loadSettings, saveSettings } from './config/settings.js';
 import { startPreview } from './preview/server.js';
 import { appendAudit } from './safety/audit.js';
 import { guardModelReady } from './safety/modelstore.js';
@@ -201,6 +201,11 @@ export async function main(argv = process.argv.slice(2)) {
     ensureDirs();
     const loaded = loadSettings();
     let settings = loaded.settings;
+    if (loaded.upgraded) {
+        // A pre-upgrade envelope carried retired keys; one re-save converges
+        // the on-disk file to the current shape with a fresh signature.
+        settings = saveSettings(settings);
+    }
     const decision = decideBoot({
         firstRun: loaded.firstRun,
         tampered: loaded.tampered,

package/dist/config/settings.js

@@ -25,7 +25,6 @@ export function defaultSettings() {
         activeProvider: null,
         configuredProviders: [],
         modelAlias: 'zippy',
-        safetyLevel: 'strict',
         xaiParentAck: false,
         localClassifier: true,
         lastProjectSlug: null,
@@ -33,12 +32,13 @@ export function defaultSettings() {
 }
 /**
  * Fills fields added after a settings file was written and drops retired
- * ones. Runs after the MAC check (the MAC covers the envelope as written).
- * Older envelopes predate localClassifier: absent means on, the default.
+ * ones (ollamaClassifier, safetyLevel). Runs after the MAC check (the MAC
+ * covers the envelope as written). Older envelopes predate localClassifier:
+ * absent means on, the default.
  */
 export function normalizeSettings(stored) {
     const raw = stored;
-    const { ollamaClassifier: _retired, ...kept } = raw;
+    const { ollamaClassifier: _retiredOllama, safetyLevel: _retiredLevel, ...kept } = raw;
     return { ...kept, localClassifier: raw.localClassifier ?? true };
 }
 /** Stable stringify: object keys sorted recursively, array order preserved. */
@@ -95,26 +95,28 @@ export function loadSettings() {
         const setupMarkerExists = getSecret(SETUP_MARKER_ACCOUNT) !== null;
         if (setupMarkerExists) {
             // Setup finished before, yet the file is gone. Someone removed state.
-            return { settings: defaultSettings(), tampered: true, firstRun: false };
+            return { settings: defaultSettings(), tampered: true, firstRun: false, upgraded: false };
         }
-        return { settings: defaultSettings(), tampered: false, firstRun: true };
+        return { settings: defaultSettings(), tampered: false, firstRun: true, upgraded: false };
     }
     let envelope;
     try {
         const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
         if (!isEnvelopeShape(parsed)) {
-            return { settings: defaultSettings(), tampered: true, firstRun: false };
+            return { settings: defaultSettings(), tampered: true, firstRun: false, upgraded: false };
         }
         envelope = parsed;
     }
     catch {
-        return { settings: defaultSettings(), tampered: true, firstRun: false };
+        return { settings: defaultSettings(), tampered: true, firstRun: false, upgraded: false };
     }
     const expectedMac = signSettings(envelope.settings);
     if (!macMatches(expectedMac, envelope.mac)) {
-        return { settings: defaultSettings(), tampered: true, firstRun: false };
+        return { settings: defaultSettings(), tampered: true, firstRun: false, upgraded: false };
     }
-    return { settings: normalizeSettings(envelope.settings), tampered: false, firstRun: false };
+    const raw = envelope.settings;
+    const upgraded = 'ollamaClassifier' in raw || 'safetyLevel' in raw;
+    return { settings: normalizeSettings(envelope.settings), tampered: false, firstRun: false, upgraded };
 }
 /**
  * Signs and writes settings atomically. Generates installId on first save.

package/dist/grownups/panel.js

@@ -1,7 +1,7 @@
 /**
  * The grown-ups panel: PIN gate, needs-attention banner, provider
- * management, safety level, model speed, the usage note, the audit log
- * viewer, and the data/uninstall screen.
+ * management, the on-device safety checker, model speed, the usage note,
+ * the audit log viewer, and the data/uninstall screen.
  *
  * The pure helpers (one-liners, attention lines, log parsing) are exported
  * so tests cover them without driving the prompts.
@@ -423,7 +423,6 @@ export async function runPanel() {
             message: 'Grown-up zone',
             options: [
                 { value: 'providers', label: 'Providers (add or switch)' },
-                { value: 'safety', label: `Safety level (now: ${settings.safetyLevel})` },
                 { value: 'guard', label: `Safety checker on this computer (${guardStatusLine(settings)})` },
                 { value: 'speed', label: `Model speed (now: ${modelLabel(settings.modelAlias)})` },
                 { value: 'usage', label: 'Usage and quota note' },
@@ -442,20 +441,6 @@ export async function runPanel() {
         else if (pick === 'guard') {
             settings = await guardMenu(settings);
         }
-        else if (pick === 'safety') {
-            const level = await p.select({
-                message: T.wizard.safetyPick,
-                options: [
-                    { value: 'strict', label: 'Strict', hint: 'Best for most kids.' },
-                    { value: 'standard', label: 'Standard' },
-                ],
-                initialValue: settings.safetyLevel,
-            });
-            if (!p.isCancel(level) && level !== settings.safetyLevel) {
-                settings = saveSettings({ ...settings, safetyLevel: level });
-                audit('settings_change', `safety level ${level}`);
-            }
-        }
         else if (pick === 'speed') {
             const alias = await p.select({
                 message: 'Pick the model speed.',

package/dist/safety/guarddownload.js

@@ -11,6 +11,17 @@ import { appendAudit } from './audit.js';
 import { downloadGuardModel, GUARD_MODEL, guardModelReady, } from './modelstore.js';
 let state = { status: 'idle', written: 0, total: GUARD_MODEL.bytes };
 let inFlight = null;
+let noticePending = false;
+/**
+ * True exactly once after a background fetch completes, then clears. The
+ * chat loop and the home menu both call this, so the kid hears "your
+ * safety helper is on" one time, on whichever screen they are looking at.
+ */
+export function consumeGuardReadyNotice() {
+    const pending = noticePending;
+    noticePending = false;
+    return pending;
+}
 /** Snapshot of the background fetch. 'ready' wins once the file exists. */
 export function guardFetchState() {
     if (state.status !== 'downloading' && guardModelReady()) {
@@ -51,6 +62,7 @@ export function ensureGuardFetch(opts = {}) {
     })
         .then(() => {
         state = { ...state, status: 'ready', written: state.total };
+        noticePending = true;
         audit('local classifier model downloaded');
         return true;
     })
@@ -68,6 +80,7 @@ export function ensureGuardFetch(opts = {}) {
 export function resetGuardFetchForTests() {
     state = { status: 'idle', written: 0, total: GUARD_MODEL.bytes };
     inFlight = null;
+    noticePending = false;
 }
 const BAR_SLOTS = 10;
 /** A kid-friendly progress bar: [####______] 42% of 623 MB. */

package/dist/setup/wizard.js

@@ -1,6 +1,7 @@
 /**
- * The setup wizard: a parent flow (PIN, consent, AI provider, safety level)
- * followed by a kid flow (nickname, AI disclosure, launcher, first game).
+ * The setup wizard: a parent flow (PIN, consent, AI provider, safety
+ * checker) followed by a kid flow (nickname, AI disclosure, launcher,
+ * first game).
  *
  * Pure decision helpers are exported so tests cover the logic without
  * driving the prompts. Cancel anywhere keeps only the steps that finished;
@@ -12,7 +13,7 @@ import { setSecret } from '../auth/keychain.js';
 import { hasPin, markSetupComplete, setPin } from '../config/pin.js';
 import { defaultSettings, loadSettings, saveSettings } from '../config/settings.js';
 import { appendAudit } from '../safety/audit.js';
-import { ensureGuardFetch } from '../safety/guarddownload.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';
@@ -316,24 +317,15 @@ async function providerLoop(settings) {
     }
     return { ...current, activeProvider: null };
 }
-async function safetyStep(settings) {
-    const level = ensure(await p.select({
-        message: T.wizard.safetyPick,
-        options: [
-            { value: 'strict', label: 'Strict', hint: 'Best for most kids.' },
-            { value: 'standard', label: 'Standard' },
-        ],
-        initialValue: 'strict',
-    }));
-    return { ...settings, safetyLevel: level };
-}
 /**
  * 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 so setup (and building) never waits on 623 MB. The
- * pipeline hot-attaches the checker the moment the verified file lands; the
- * home menu shows the progress bar until then. Declining turns the setting
- * off; a failed or interrupted download resumes on the next start.
+ * 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.
  */
 async function localGuardStep(settings) {
     if (guardModelReady()) {
@@ -347,8 +339,47 @@ async function localGuardStep(settings) {
         audit('settings_change', 'local classifier off (declined in setup)');
         return { ...settings, localClassifier: false };
     }
-    void ensureGuardFetch();
+    const fetchDone = ensureGuardFetch();
     p.log.info(T.wizard.guardBackground);
+    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 },
+        ],
+        initialValue: 'now',
+    }));
+    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 (;;) {
+            const spin = p.spinner();
+            spin.start(`${T.wizard.guardDownloading} ${guardProgressBar()}`);
+            const ticker = setInterval(() => {
+                spin.message(`${T.wizard.guardDownloading} ${guardProgressBar()}`);
+            }, 250);
+            const budget = escapeAfterMs[Math.min(escapeIndex, escapeAfterMs.length - 1)];
+            escapeIndex += 1;
+            const outcome = await Promise.race([
+                fetchDone.then((ok) => (ok ? 'ready' : 'failed')),
+                new Promise((resolve) => setTimeout(() => resolve('timeout'), budget).unref?.()),
+            ]);
+            clearInterval(ticker);
+            if (outcome !== 'timeout') {
+                spin.stop(outcome === 'ready' ? T.wizard.guardReady : T.wizard.guardFailed);
+                break;
+            }
+            spin.stop(`${T.wizard.guardDownloading} ${guardProgressBar()}`);
+            const more = await p.confirm({ message: T.wizard.guardKeepWaiting, initialValue: true });
+            if (p.isCancel(more) || !more) {
+                p.log.info(T.wizard.guardBackground);
+                break;
+            }
+        }
+    }
     return { ...settings, localClassifier: true };
 }
 async function kidNicknameStep(settings) {
@@ -446,7 +477,6 @@ export async function runWizard() {
     }
     settings = await consentStep(settings);
     settings = await providerLoop(settings);
-    settings = await safetyStep(settings);
     settings = await localGuardStep(settings);
     settings = saveSettings(settings);
     markSetupComplete();

package/dist/surfaces/chat.js

@@ -13,7 +13,7 @@ import { createProviderClient, pickClassifierBackend, } from '../providers/index
 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 { consumeGuardReadyNotice, ensureGuardFetch } from '../safety/guarddownload.js';
 import { lazyGuardAccessor } from '../safety/guardrunner.js';
 import { guardModelReady } from '../safety/modelstore.js';
 import { createSessionState } from '../safety/session.js';
@@ -122,7 +122,9 @@ export async function runChat(project, settings) {
     // The guard hot-attaches: null while its model still downloads, live from
     // the first check after the file lands. A missing file also (re)starts the
     // background fetch, and is written to the safety log: a deleted model
-    // file must not detach a safety layer invisibly.
+    // file must not detach a safety layer invisibly. When the download lands
+    // mid-session, the kid hears about it at the next turn (once, shared with
+    // the home menu via consumeGuardReadyNotice).
     if (settings.localClassifier && !guardModelReady()) {
         audit({
             ts: new Date().toISOString(),
@@ -319,6 +321,9 @@ export async function runChat(project, settings) {
     };
     let hintIndex = 0;
     for (;;) {
+        if (consumeGuardReadyNotice()) {
+            p.log.success(T.home.guardOn);
+        }
         const hint = T.hints[hintIndex % T.hints.length] ?? '';
         hintIndex += 1;
         const step = quest !== null ? quest.steps[questStep] : undefined;

package/dist/surfaces/home.js

@@ -11,7 +11,7 @@ import path from 'node:path';
 import * as p from '@clack/prompts';
 import { atomicWriteFileSync, termiHome } from '../config/paths.js';
 import { saveSettings } from '../config/settings.js';
-import { guardFetchState, guardProgressBar } from '../safety/guarddownload.js';
+import { consumeGuardReadyNotice, guardFetchState, guardProgressBar, } from '../safety/guarddownload.js';
 import { nameIsOkay } from '../safety/prefilter.js';
 import { scaffolds, scaffoldById } from '../projects/scaffolds/index.js';
 import { suggestProjectNames } from '../setup/wizard.js';
@@ -327,7 +327,6 @@ async function loadLastProject(settings) {
 }
 /** The home menu loop for a returning kid. */
 export async function showHome(settings) {
-    let guardWasLoading = false;
     const nickname = settings.kidNickname.trim();
     console.log(mascot('happy'));
     console.log(nickname.length > 0 ? T.home.welcomeBack.replace('{name}', nickname) : T.home.firstHello);
@@ -340,15 +339,14 @@ export async function showHome(settings) {
     }
     for (;;) {
         // A quiet one-liner while the safety checker still downloads, and one
-        // "it is on now" note the first time the menu renders after it lands.
+        // "it is on now" note when it lands (shared one-shot with the chat, so
+        // the kid never hears it twice across screens).
         const fetchState = guardFetchState();
         if (settings.localClassifier && fetchState.status === 'downloading') {
             console.log(style.dim(`${T.home.guardLoading} ${guardProgressBar(fetchState)}`));
-            guardWasLoading = true;
         }
-        else if (guardWasLoading && fetchState.status === 'ready') {
+        else if (consumeGuardReadyNotice()) {
             console.log(style.dim(T.home.guardOn));
-            guardWasLoading = false;
         }
         const options = [];
         if (last !== null) {

package/dist/ui/text.js

@@ -43,11 +43,16 @@ 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.',
-        safetyPick: 'Pick a safety level. Strict is best for most kids.',
         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?',
         guardDownloading: 'Getting the safety file now...',
-        guardBackground: 'Okay! It loads while you build and turns on by itself.',
+        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.',
+        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.',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termi-kids",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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.",
   "keywords": [
     "kids",