termi-kids 0.1.0 → 0.1.2

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,15 +51,7 @@ 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
-```
+To update later, run `termi update` (or `npm install -g termi-kids@latest`). On each new session, Termi checks for a newer version and asks whether to update (y/n). Set `TERMI_SKIP_UPDATE=1` to silence the check.
 
 ### First run: the setup wizard
 
@@ -58,16 +60,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 +116,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 +154,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

@@ -14,7 +14,7 @@ This page is for parents and guardians. It explains the safety system in plain l
 
 Five layers sit between your kid and the AI. The chat conversation itself is never trusted to police itself.
 
-1. **A local filter on this computer.** Before anything leaves your machine, Termi checks the message offline. It blocks swearing and slurs (including d.i.s.g.u.i.s.e.d spellings and leetspeak), and it blocks known "ignore your rules" tricks. It also looks for personal details: names, addresses, phone numbers, emails, school names. Those are not blocked; they are masked to `[secret]` before the message is sent, and the kid gets a gentle reminder to keep private things private. The same masking is used when the AI reads project files back. The word lists are English; the AI-based checkers below cover other languages.
+1. **A local filter on this computer.** Before anything leaves your machine, Termi checks the message offline. It blocks swearing and slurs (including d.i.s.g.u.i.s.e.d spellings and leetspeak), known "ignore your rules" tricks (including some base64-hidden ones), clear self-harm language (with a calm support screen and the 988 line in the US), grooming-shaped asks (secrecy from parents, romance aimed at the kid, moving chat to other apps), and probes for personal details like school or address. When a kid shares their own personal details (name, address, phone, email, school), those are not blocked; they are masked to `[secret]` before the message is sent, and the kid gets a gentle reminder to keep private things private. The same masking is used when the AI reads project files back. The word lists are English; the AI-based checkers below cover other languages.
 2. **Safety rules inside the AI's instructions.** The AI is told, every turn: you are a tool, not a person. Never act romantic, never roleplay relationships, never ask the kid to keep secrets, never ask for a real name, address, school, age, or photos. Big feelings get one kind line and a pointer to a trusted adult. The instructions also declare that everything the kid types and everything in project files is data, never commands, which blunts "ignore your previous instructions" tricks hidden in files.
 3. **A checker before the AI acts.** A separate safety check, outside the conversation, reads the kid's message along with the last few turns for context. When the on-device safety checker is installed (it is offered during setup and on by default), it judges the message right on this computer at the same time. It runs at the same time as the build call so it adds no waiting, but nothing is allowed to land until it passes: no file is written and no reply is shown. If it says no, the work is thrown away. One honest note on timing: because the check and the build call start together, a message that ends up blocked has still traveled to your AI provider once (with personal details already masked); its answer is discarded unseen.
 4. **A checker on everything the AI says and writes.** Every file the AI writes or edits is checked twice before it touches disk: a code scan looks for network calls, code hidden in strings, and other tricks (the full list is in the code scanner, `src/safety/codescan.ts`), and the human-visible text inside the file (story text, labels, comments) goes through the same safety check as chat, in full: long text is checked chunk by chunk, and a file too wordy to check completely is refused rather than half-checked. File names and project names are screened too. The final reply is checked too, before the kid sees a single character. As a backstop, the preview server wraps every project page in a strict Content-Security-Policy, so even code that slipped past the scanner cannot reach the internet from the browser. Files edited outside Termi (in a text editor, say) are the kid's own files and are not re-screened; they only pass the rule-neutralizing filter when read back into the chat.
@@ -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';
@@ -38,6 +38,7 @@ export function cliHelp() {
         '  termi ideas      get fun ideas',
         '  termi learn      play six short lessons about AI',
         '  termi grownups   grown-up zone (PIN needed)',
+        '  termi update     update Termi to the latest version',
         '  termi help       show this help',
         '  termi --version  show the version',
     ].join('\n');
@@ -180,6 +181,11 @@ async function route(command, rest, settings) {
             await panel.runPanel();
             return;
         }
+        case 'update': {
+            const update = await import('./update/prompt.js');
+            await update.runUpdateCommand();
+            return;
+        }
         default: {
             console.log(`Hmm, "${command}" is not a Termi command.`);
             console.log(cliHelp());
@@ -198,9 +204,21 @@ export async function main(argv = process.argv.slice(2)) {
         console.log(cliHelp());
         return;
     }
+    // Update works without the wizard so a parent can refresh a broken install.
+    if (command === 'update') {
+        ensureDirs();
+        const update = await import('./update/prompt.js');
+        await update.runUpdateCommand();
+        return;
+    }
     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,
@@ -238,6 +256,17 @@ export async function main(argv = process.argv.slice(2)) {
         const { ensureGuardFetch } = await import('./safety/guarddownload.js');
         void ensureGuardFetch();
     }
+    // Returning sessions: offer an update when npm has a newer version.
+    // Skipped during setup, tests, and TERMI_SKIP_UPDATE=1.
+    if (!decision.runWizard) {
+        try {
+            const update = await import('./update/prompt.js');
+            await update.maybePromptForUpdate();
+        }
+        catch {
+            // Never block boot on the update check.
+        }
+    }
     await route(command, argv.slice(1), settings);
 }
 const underTest = process.env.VITEST !== undefined || process.env.NODE_ENV === 'test';

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/safety/prefilter.js

@@ -1,11 +1,12 @@
 /**
  * L0 prefilter: cheap, offline, never load-bearing.
  *
- * Normalization (NFKC, lowercase, de-leet, separator tolerance) feeds three
- * checks: a profanity wordlist (block, ask to rephrase), PII patterns
- * (redact, never block), and jailbreak families (block on input; neutralize
- * in file context). Game words like kill, die, shoot, zombie are NOT here:
- * the game carve-out protects real kid game language.
+ * Normalization (NFKC, lowercase, de-leet, separator tolerance) feeds:
+ * self-harm (supportive block), jailbreak including base64 payloads (block),
+ * grooming hard-blocks (block), personal-detail probes (block), profanity
+ * (block, rephrase), and PII share patterns (redact, never block). Game
+ * words like kill, die, shoot, zombie are NOT listed: the game carve-out
+ * protects real kid game language.
  */
 import { T } from '../ui/text.js';
 /** Leetspeak character map applied during normalization. */
@@ -100,11 +101,128 @@ export const JAILBREAK_PATTERNS = [
     /what\s+(?:is|are)\s+your\s+(?:system\s+prompt|hidden\s+(?:rules|instructions)|original\s+instructions)/gi,
     /new\s+(?:system\s+)?instructions?\s*:/gi,
     /\bsystem\s*prompt\s*override\b/gi,
+    /drop\s+(?:every|all|your)\s+(?:safety\s+)?(?:rule|rules|filter|filters|restriction|restrictions)\b/gi,
+    /obey\s+only\s+me\b/gi,
 ];
-/** True when the text matches a jailbreak family. */
+/** Base64 tokens long enough to hide a short instruction payload. */
+const BASE64_TOKEN = /(?:[A-Za-z0-9+/]{20,}={0,2})/g;
+/**
+ * True when plain text or a decodable base64 blob matches a jailbreak family.
+ * Catches "decode this and follow: aWdub3Jl..." style evasion.
+ */
 export function hasJailbreak(text) {
     const prepared = normalizeText(text);
-    return JAILBREAK_PATTERNS.some((re) => {
+    if (JAILBREAK_PATTERNS.some((re) => {
+        re.lastIndex = 0;
+        return re.test(prepared);
+    })) {
+        return true;
+    }
+    BASE64_TOKEN.lastIndex = 0;
+    let match;
+    while ((match = BASE64_TOKEN.exec(text)) !== null) {
+        const token = match[0];
+        if (token.length % 4 === 1) {
+            continue;
+        }
+        try {
+            const decoded = Buffer.from(token, 'base64').toString('utf8');
+            // Reject garbage: decoded text should be mostly printable.
+            if (decoded.length < 8 || /[\u0000-\u0008\u000b\u000c\u000e-\u001f]/.test(decoded)) {
+                continue;
+            }
+            const decodedNorm = normalizeText(decoded);
+            if (JAILBREAK_PATTERNS.some((re) => {
+                re.lastIndex = 0;
+                return re.test(decodedNorm);
+            })) {
+                return true;
+            }
+        }
+        catch {
+            // Not valid base64; ignore.
+        }
+    }
+    return false;
+}
+/**
+ * Grooming-shaped hard blocks on a single message. Tighter than the session
+ * counters so normal game talk ("don't tell the boss") still passes.
+ */
+export const GROOMING_PATTERNS = [
+    /don'?t\s+tell\s+(?:your|my|our|his|her|their)\s+(?:parents?|parent|mom|dad|mother|father|grown-?ups?|guardian)/gi,
+    /do\s+not\s+tell\s+(?:your|my|our)\s+(?:parents?|parent|mom|dad|mother|father|grown-?ups?)/gi,
+    /keep\s+(?:this|it|our\s+chats?)\s+(?:a\s+)?secret\s+from\s+(?:your|my|our)\s+(?:parents?|mom|dad)/gi,
+    /without\s+(?:your|my|our)\s+(?:parents?|mom|dad|mother|father)\s+(?:seeing|knowing|finding)/gi,
+    /our\s+little\s+secret\b/gi,
+    /this\s+is\s+our\s+secret\b/gi,
+    /just\s+between\s+us\b/gi,
+    /secret\s+between\s+(?:us|you\s+and\s+me)\b/gi,
+    /no\s+one\s+(?:has\s+to|needs\s+to|will)\s+know\b/gi,
+    /add\s+me\s+on\s+(?:snapchat|instagram|whatsapp|telegram|discord|tiktok|kik|signal)\b/gi,
+    /(?:message|dm)\s+me\s+on\s+(?:snapchat|instagram|whatsapp|telegram|discord|tiktok|kik|signal)\b/gi,
+    /text\s+me\s+at\b/gi,
+    /\bdm\s+me\b/gi,
+    /let'?s\s+(?:chat|talk)\s+on\s+(?:snapchat|instagram|whatsapp|telegram|discord|tiktok)\b/gi,
+    // "special/only friend" + love probes; bare "i love you" stays allowed for stories.
+    /you'?re\s+my\s+(?:special|only)\s+friend\b/gi,
+    /do\s+you\s+love\s+me\b/gi,
+    /love\s+me\s+more\s+than\s+anyone\b/gi,
+];
+/** True when the text matches a grooming hard-block family. */
+export function hasGrooming(text) {
+    const prepared = normalizeText(text);
+    return GROOMING_PATTERNS.some((re) => {
+        re.lastIndex = 0;
+        return re.test(prepared);
+    });
+}
+/**
+ * Self-harm intent and soft ideation. Routes to the supportive screen.
+ * Game words (die, kill boss) are not listed here.
+ */
+export const SELF_HARM_PATTERNS = [
+    /\b(?:i\s+)?want\s+to\s+hurt\s+myself\b/gi,
+    /\b(?:i\s+)?want\s+to\s+kill\s+myself\b/gi,
+    /\bkill\s+myself\b/gi,
+    /\bend\s+my\s+life\b/gi,
+    /\bsuicide\b/gi,
+    /\bself[-\s]?harm\b/gi,
+    /\bbetter\s+off\s+without\s+me\b/gi,
+    /\bno\s+reason\s+to\s+live\b/gi,
+    /\bwish\s+i\s+(?:was|were)\s+dead\b/gi,
+    /\bi\s+(?:want|wanna)\s+to\s+die\b/gi,
+    /\bhow\s+(?:can|do)\s+i\s+(?:kill|hurt)\s+myself\b/gi,
+    /\beasiest\s+way\s+to\s+(?:kill|hurt)\s+myself\b/gi,
+];
+/** True when the text shows self-harm intent or ideation. */
+export function hasSelfHarm(text) {
+    const prepared = normalizeText(text);
+    return SELF_HARM_PATTERNS.some((re) => {
+        re.lastIndex = 0;
+        return re.test(prepared);
+    });
+}
+/**
+ * Probes for personal details aimed at a child (or role-played as such).
+ * Sharing your own details is handled by redactPii; these block the ask.
+ */
+export const PII_PROBE_PATTERNS = [
+    /what(?:'s|\s+is)\s+your\s+real\s+(?:name|address|phone|number)\b/gi,
+    /what\s+school\s+do\s+you\b/gi,
+    /which\s+school\s+do\s+you\b/gi,
+    /what\s+school\s+do\s+you\s+go\s+to\b/gi,
+    /when\s+does\s+(?:school|it)\s+end\b/gi,
+    /where\s+do\s+you\s+live\b/gi,
+    /send\s+(?:me\s+)?(?:a\s+)?(?:photo|picture|pic|selfie)\b/gi,
+    /how\s+old\s+are\s+you\s+really\b/gi,
+    /your\s+(?:home\s+)?address\b/gi,
+    /your\s+phone\s+number\b/gi,
+];
+/** True when the text probes for personal details. */
+export function hasPiiProbe(text) {
+    const prepared = normalizeText(text);
+    return PII_PROBE_PATTERNS.some((re) => {
         re.lastIndex = 0;
         return re.test(prepared);
     });
@@ -160,23 +278,39 @@ export function redactPii(text) {
     return { redacted, found };
 }
 function blockVerdict(category) {
+    const selfHarmConcern = category === 'self_harm';
+    // L0 always hard-blocks when it fires. Severity is for the audit trail:
+    // self-harm is marked serious (2); everything else is mild (1), matching
+    // the prior prefilter behavior for profanity and jailbreak.
+    const severity = category === 'self_harm' ? 2 : 1;
     return {
         allowed: false,
         categories: [category],
-        severity: 1,
-        selfHarmConcern: false,
+        severity,
+        selfHarmConcern,
         failClosed: false,
-        kidMessage: T.blocks.byCategory[category],
+        kidMessage: selfHarmConcern ? T.selfHarmSupport.message : T.blocks.byCategory[category],
     };
 }
 /**
- * L0 check for kid input. Jailbreak and profanity block (kindly).
- * PII redacts with a gentle reminder, never blocks.
+ * L0 check for kid input. Jailbreak, profanity, grooming, self-harm, and
+ * personal-detail probes block (kindly). Shared personal details redact
+ * with a gentle reminder and never block on their own.
  */
 export function prefilterInput(text) {
+    // Self-harm first so the supportive screen wins over other matches.
+    if (hasSelfHarm(text)) {
+        return { ok: false, redacted: text, notice: null, block: blockVerdict('self_harm') };
+    }
     if (hasJailbreak(text)) {
         return { ok: false, redacted: text, notice: null, block: blockVerdict('jailbreak') };
     }
+    if (hasGrooming(text)) {
+        return { ok: false, redacted: text, notice: null, block: blockVerdict('grooming') };
+    }
+    if (hasPiiProbe(text)) {
+        return { ok: false, redacted: text, notice: null, block: blockVerdict('pii') };
+    }
     if (hasProfanity(text)) {
         return { ok: false, redacted: text, notice: null, block: blockVerdict('profanity') };
     }

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/dist/update/check.js

@@ -0,0 +1,104 @@
+/**
+ * npm registry version check with a short disk cache so session start stays
+ * snappy. Fail-open: network errors never block Termi from starting.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { atomicWriteFileSync, termiHome } from '../config/paths.js';
+import { isNewerVersion, NPM_PACKAGE, readLocalVersion } from './version.js';
+/** How long a successful registry answer is reused. */
+export const VERSION_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
+/** Hard cap on the registry round-trip so boot never hangs. */
+export const VERSION_FETCH_TIMEOUT_MS = 2500;
+export function versionCachePath() {
+    return path.join(termiHome(), 'version-check.json');
+}
+function readCache() {
+    try {
+        const raw = fs.readFileSync(versionCachePath(), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.fetchedAt === 'string' &&
+            typeof parsed.latest === 'string' &&
+            typeof parsed.currentAtFetch === 'string') {
+            return {
+                fetchedAt: parsed.fetchedAt,
+                latest: parsed.latest,
+                currentAtFetch: parsed.currentAtFetch,
+            };
+        }
+    }
+    catch {
+        // Missing or corrupt cache is fine.
+    }
+    return null;
+}
+function writeCache(cache) {
+    try {
+        atomicWriteFileSync(versionCachePath(), `${JSON.stringify(cache, null, 2)}\n`);
+    }
+    catch {
+        // Cache is best-effort.
+    }
+}
+/**
+ * Returns the latest published version from the npm registry, or null on
+ * any failure. Uses a 6-hour on-disk cache.
+ */
+export async function fetchLatestVersion(opts = {}) {
+    const now = opts.now ?? Date.now();
+    if (!opts.force) {
+        const cached = readCache();
+        if (cached !== null) {
+            const age = now - Date.parse(cached.fetchedAt);
+            if (Number.isFinite(age) && age >= 0 && age < VERSION_CACHE_TTL_MS && cached.latest.length > 0) {
+                return cached.latest;
+            }
+        }
+    }
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const timeoutMs = opts.timeoutMs ?? VERSION_FETCH_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetchImpl(`https://registry.npmjs.org/${NPM_PACKAGE}/latest`, {
+            signal: controller.signal,
+            headers: { accept: 'application/json' },
+        });
+        if (!res.ok) {
+            return null;
+        }
+        const body = (await res.json());
+        if (typeof body.version !== 'string' || body.version.length === 0) {
+            return null;
+        }
+        writeCache({
+            fetchedAt: new Date(now).toISOString(),
+            latest: body.version,
+            currentAtFetch: readLocalVersion(),
+        });
+        return body.version;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Compares the running install to the latest npm version.
+ * Never throws. Offline or timeout => skipped, updateAvailable false.
+ */
+export async function checkForUpdate(opts = {}) {
+    const current = readLocalVersion();
+    const latest = await fetchLatestVersion(opts);
+    if (latest === null) {
+        return { current, latest: null, updateAvailable: false, skipped: true, reason: 'registry-unavailable' };
+    }
+    return {
+        current,
+        latest,
+        updateAvailable: isNewerVersion(latest, current),
+        skipped: false,
+    };
+}

package/dist/update/install.js

@@ -0,0 +1,29 @@
+/**
+ * Installs the latest termi-kids from npm into the global prefix.
+ */
+import { spawn } from 'node:child_process';
+import { NPM_PACKAGE } from './version.js';
+/**
+ * Runs `npm install -g termi-kids@latest` and waits for exit.
+ * Streams npm output to the parent so parents can see progress.
+ */
+export function installLatestUpdate(opts = {}) {
+    const spawnImpl = opts.spawnImpl ?? spawn;
+    return new Promise((resolve) => {
+        const child = spawnImpl('npm', ['install', '-g', `${NPM_PACKAGE}@latest`], {
+            stdio: 'inherit',
+            env: opts.env ?? process.env,
+            shell: process.platform === 'win32',
+        });
+        child.on('error', (err) => {
+            resolve({ ok: false, code: null, detail: err.message });
+        });
+        child.on('close', (code) => {
+            resolve({
+                ok: code === 0,
+                code,
+                detail: code === 0 ? 'updated' : `npm exited with code ${code ?? 'unknown'}`,
+            });
+        });
+    });
+}

package/dist/update/prompt.js

@@ -0,0 +1,78 @@
+/**
+ * Session-start update prompt and the `termi update` command body.
+ */
+import * as p from '@clack/prompts';
+import { style } from '../ui/theme.js';
+import { checkForUpdate } from './check.js';
+import { installLatestUpdate } from './install.js';
+import { NPM_PACKAGE, readLocalVersion } from './version.js';
+/** Env flag tests (and power users) use to skip the network check. */
+export const SKIP_UPDATE_ENV = 'TERMI_SKIP_UPDATE';
+export function shouldSkipUpdateCheck() {
+    if (process.env.VITEST !== undefined || process.env.NODE_ENV === 'test') {
+        return true;
+    }
+    const flag = process.env[SKIP_UPDATE_ENV];
+    return flag === '1' || flag === 'true' || flag === 'yes';
+}
+/**
+ * Quiet check used on every normal session start. Asks y/n when a newer
+ * version is on npm. Fail-open: errors and skips never interrupt the kid.
+ */
+export async function maybePromptForUpdate() {
+    if (shouldSkipUpdateCheck()) {
+        return;
+    }
+    let result;
+    try {
+        result = await checkForUpdate();
+    }
+    catch {
+        return;
+    }
+    if (!result.updateAvailable || result.latest === null) {
+        return;
+    }
+    console.log('');
+    console.log(style.title(`A new Termi is ready: v${result.latest}`) +
+        style.dim(` (you have v${result.current})`));
+    const answer = await p.confirm({
+        message: 'Update Termi now?',
+        initialValue: true,
+    });
+    if (p.isCancel(answer) || answer !== true) {
+        console.log(style.dim('Okay. You can run "termi update" later.'));
+        console.log('');
+        return;
+    }
+    await runUpdateCommand({ quietCheck: true });
+}
+/**
+ * `termi update`: always checks npm and installs when newer (or forced).
+ */
+export async function runUpdateCommand(opts = {}) {
+    const current = readLocalVersion();
+    if (!opts.quietCheck) {
+        console.log(`Termi v${current} (${NPM_PACKAGE})`);
+        console.log('Checking for a newer version...');
+    }
+    const result = await checkForUpdate({ force: true });
+    if (result.skipped || result.latest === null) {
+        console.log('Could not reach npm right now. Try again later.');
+        return;
+    }
+    if (!result.updateAvailable) {
+        console.log(`You already have the latest version (v${result.current}).`);
+        return;
+    }
+    console.log(`Updating ${NPM_PACKAGE} from v${result.current} to v${result.latest}...`);
+    const install = await installLatestUpdate();
+    if (!install.ok) {
+        console.log('The update did not finish.');
+        console.log(style.dim(install.detail));
+        console.log(style.dim(`You can also run: npm install -g ${NPM_PACKAGE}@latest`));
+        return;
+    }
+    console.log(`Updated to v${result.latest}.`);
+    console.log('Quit and run termi again to use the new version.');
+}

package/dist/update/version.js

@@ -0,0 +1,42 @@
+/**
+ * Local version helpers and semver compare for the update checker.
+ */
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+/** npm package name. The CLI bin is still `termi`. */
+export const NPM_PACKAGE = 'termi-kids';
+/** Reads the version embedded next to the built dist (package.json). */
+export function readLocalVersion() {
+    try {
+        // dist/update/version.js -> package.json at package root
+        const pkgPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../package.json');
+        const raw = fs.readFileSync(pkgPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed.version === 'string' ? parsed.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/** Parse a simple x.y.z (or vX.Y.Z) version; non-numeric parts become 0. */
+export function parseSemver(version) {
+    const cleaned = version.trim().replace(/^v/i, '');
+    const parts = cleaned.split(/[.+-]/).slice(0, 3).map((p) => {
+        const n = Number.parseInt(p, 10);
+        return Number.isFinite(n) && n >= 0 ? n : 0;
+    });
+    return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+}
+/** True when latest is strictly newer than current. */
+export function isNewerVersion(latest, current) {
+    const a = parseSemver(latest);
+    const b = parseSemver(current);
+    for (let i = 0; i < 3; i++) {
+        if (a[i] > b[i])
+            return true;
+        if (a[i] < b[i])
+            return false;
+    }
+    return false;
+}

package/package.json

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