dante-watch 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dante-watch",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Dante watches your own server and never lies to itself: every verdict carries the real line it came from.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -9,7 +9,7 @@ import { ask, recordYes } from "./core/consent.mjs";
 import { banner } from "./mascot.mjs";
 import { activeBattery } from "./checks/battery.mjs";
 import { demo } from "./checks/demo.mjs";
-import { staleLine } from "./ticker.mjs";
+import { staleLine, VERSION, BIB_DATE } from "./ticker.mjs";
 import { lang, t } from "./i18n.mjs";
 import { tx } from "./i18n-checks.mjs";
 
@@ -24,6 +24,7 @@ function parseArgs(argv) {
     else if (t === "--fix") a.fix = true;
     else if (t === "--demo") a.demo = true;
     else if (t === "--help" || t === "-h") a.help = true;
+    else if (t === "--version" || t === "-v") a.version = true;
   }
   return a;
 }
@@ -34,6 +35,7 @@ const HELP = `Dante — wächter
   npx dante-watch --ssh user@host [--key /pfad]   prüft einen Server, der dir gehört
   --fix        bei einem Fund: Plan zeigen und nach deinem Ja schließen
   --demo       harmlose Übung: zeigt die ganze Schleife (human → plan → ja/nein → fix → Beweis)
+  --version    welche Version läuft
   --json       Maschinen-Ausgabe
   -y, --yes    nicht nachfragen (für Automode/Cron)
 
@@ -78,6 +80,7 @@ async function handleFinding(check, r, a) {
 async function main() {
   const a = parseArgs(process.argv.slice(2));
   if (a.help) { console.log(HELP); return; }
+  if (a.version) { console.log("dante-watch " + VERSION + " · bib " + BIB_DATE); return; }
 
   // No flags + a real terminal → the face: summon, greet, arm, talk, stay open.
   // Flags or a pipe → one-shot (for cron / --json / automode).

package/src/core/sh.mjs

@@ -1,7 +1,7 @@
 // sh: the only place a real line enters Dante. Runs a command, captures stdout/stderr/exit.
 // Optionally prefixes with ssh so Dante can look at a remote server the user owns.
 // Nothing here is a model's opinion — it is the machine's own output.
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 
 let PREFIX = null; // e.g. ["ssh","-i","/key","root@host"] — set by configureTarget()
 
@@ -36,6 +36,24 @@ export function runLocal(script, { timeout = 15000 } = {}) {
   return exec(script, null, { timeout });
 }
 
+/** runLocal() without blocking: the waiting screen keeps moving while the command runs. */
+export function runLocalAsync(script, { timeout = 15000 } = {}) {
+  return new Promise((resolve) => {
+    const c = spawn("bash", ["-lc", String(script)], { stdio: ["ignore", "pipe", "pipe"] });
+    let out = "", err = "", done = false, killed = false;
+    const finish = (code, errorMsg = "") => {
+      if (done) return;
+      done = true; clearTimeout(timer);
+      const status = killed ? null : code;
+      resolve({ cmd: String(script), out: out.trimEnd(), err: err.trimEnd(), code: typeof status === "number" ? status : -1, ok: status === 0, ran: typeof status === "number" && status >= 0, failed: !!errorMsg, errorMsg });
+    };
+    const timer = setTimeout(() => { killed = true; c.kill("SIGKILL"); }, timeout);
+    c.stdout.on("data", (d) => (out += d)); c.stderr.on("data", (d) => (err += d));
+    c.on("error", (e) => finish(-1, String(e.message)));
+    c.on("close", (code) => finish(code));
+  });
+}
+
 function exec(script, prefix, { timeout, input }) {
   const s = Array.isArray(script) ? script.join(" ") : String(script);
   const argv = prefix ? [...prefix, s] : ["bash", "-lc", s];

package/src/i18n.mjs

@@ -8,7 +8,7 @@ const T = {
     sLaw: "Jedes Urteil steht auf einer echten Zeile. Fehlt die Zeile, sagt Dante „unbekannt“, nie „sicher“.",
     intro: "Ich bin Dante.", introSub: " Ich gehe durch die Hölle und bringe die Karte.",
     arm: "Soll ich wachen?", armOpts: "[ja / nein]", sleepNo: "Dann schlafe ich. Beschwör mich, wenn du mich brauchst.",
-    armed: "Scharf.", watching: "Ich wache über ", sayHelp: ["Sag ", "hilfe", ", wenn du die Worte brauchst."],
+    armed: "Scharf.", awake: "wach", watching: "Ich wache über ", wakeStep: (i, n) => "weckt die Ohren " + i + "/" + n, wakeMore: "weckt die Fach-Ohren …", waitCheck: (x) => "prüfe " + x, waitLook: (x) => "schaue mir " + x + " an", sayHelp: ["Sag ", "hilfe", ", wenn du die Worte brauchst."],
     unseen: (t, l) => `Ich sehe ${t} nicht: ${l}`, canFix: "Ich kann das nach deinem Ja schließen — sag ",
     listen: " HUMAN, HÖR ZU ", what: "was:", how: "wie:", plan: "mein plan:",
     distrust: "prüf das gegen eine andere KI. Sagt die was anderes — schreib uns: info@nm-streetwear.space",
@@ -34,7 +34,7 @@ const T = {
     sLaw: "Every verdict stands on a real line. Without the line, Dante says „unknown“, never „safe“.",
     intro: "I am Dante.", introSub: " I walk through Hell and bring back the map.",
     arm: "Shall I keep watch?", armOpts: "[yes / no]", sleepNo: "Then I sleep. Summon me when you need me.",
-    armed: "Armed.", watching: "Watching over ", sayHelp: ["Say ", "help", " when you need the words."],
+    armed: "Armed.", awake: "awake", watching: "Watching over ", wakeStep: (i, n) => "waking the ears " + i + "/" + n, wakeMore: "waking the specialist ears …", waitCheck: (x) => "checking " + x, waitLook: (x) => "looking at " + x, sayHelp: ["Say ", "help", " when you need the words."],
     unseen: (t, l) => `I cannot see ${t}: ${l}`, canFix: "I can close this after your yes — say ",
     listen: " HUMAN, LISTEN ", what: "what:", how: "how:", plan: "my plan:",
     distrust: "check this against another AI. If it says otherwise — write us: info@nm-streetwear.space",
@@ -60,7 +60,7 @@ const T = {
     sLaw: "Cada veredicto se apoya en una línea real. Sin la línea, Dante dice „desconocido“, nunca „seguro“.",
     intro: "Soy Dante.", introSub: " Atravieso el infierno y traigo el mapa.",
     arm: "¿Vigilo?", armOpts: "[sí / no]", sleepNo: "Entonces duermo. Llámame cuando me necesites.",
-    armed: "Listo.", watching: "Vigilo ", sayHelp: ["Di ", "ayuda", " cuando necesites las palabras."],
+    armed: "Listo.", awake: "despierto", watching: "Vigilo ", wakeStep: (i, n) => "despertando los oídos " + i + "/" + n, wakeMore: "despertando los oídos especiales …", waitCheck: (x) => "revisando " + x, waitLook: (x) => "mirando " + x, sayHelp: ["Di ", "ayuda", " cuando necesites las palabras."],
     unseen: (t, l) => `No veo ${t}: ${l}`, canFix: "Puedo cerrarlo después de tu sí — di ",
     listen: " HUMANO, ESCUCHA ", what: "qué:", how: "cómo:", plan: "mi plan:",
     distrust: "compruébalo con otra IA. Si dice otra cosa — escríbenos: info@nm-streetwear.space",

package/src/mascot.mjs

@@ -1,56 +1,80 @@
-// Dante — the pilgrim who walked through Hell and came back with the map.
-// A witness and a guide, not an aggressor: calm robe, laurel, the map he carries back.
-// Hand-pixeled, 256-colour half-blocks (two pixel rows per text line). No library.
+// Dante — the pilgrim who walked through Hell and came back with the map. Virgil's companion: the same
+// hooded guide, but he carries a sword. Drawn as a pixel sprite with 256-colour half-blocks (two pixel
+// rows per text line), same renderer as Virgil. No library.
+
+// 256-colour palette per legend char. "." = transparent.
 const PAL = {
-  ".": null, // transparent
-  L: 100, //  laurel (olive)
-  l: 142, //  laurel light (gold-green)
-  s: 180, //  face / skin
-  e: 236, //  eyes / shadow
-  R: 24,  //  robe (deep calm teal-blue)
-  r: 31,  //  robe highlight
-  m: 230, //  the map / parchment he brings back
-  M: 180, //  map edge
+  H: 23,  // hood / robe (deep teal)
+  B: 24,  // robe body (calm blue)
+  F: 234, // face in shadow
+  S: 252, // sword blade (bright steel)
+  s: 245, // blade shadow
+  G: 214, // cross-guard (gold)
+  h: 94,  // hilt (brown)
 };
-// 14 rows × 14 cols → 7 text rows.
+
+// 18 rows × 17 cols → 9 text rows. Figure left, sword held upright on the right.
 const ART = [
-  "...lLl..lLl...",
-  "..lLlssssLl...",
-  "...lssssss l..",
-  "...sseesess...",
-  "....ssssss....",
-  "....RRRRRR....",
-  "...RRrrrrRR...",
-  "..RRrrrrrrRRMm",
-  "..RRrrrrrrRMmm",
-  "..RRrrrrrrRMmm",
-  "..RRRrrrrRRMm.",
-  "..RRRRRRRRRR..",
-  "..RRRR..RRRR..",
-  ".RRRr....rRRR.",
+  "....HHHH......S..",
+  "...HHHHHH.....S..",
+  "..HHHHHHHH....Ss.",
+  "..HHFFFFHH....Ss.",
+  "..HHFFFFHH....Ss.",
+  "..HHHFFHHH....Ss.",
+  ".HHHHHHHHHH..GGGG",
+  ".HHBBBBBBHH...hh.",
+  ".HBBBBBBBBH...hh.",
+  ".HBBBBBBBBH......",
+  ".HBBBBBBBBH......",
+  ".HBBBBBBBBH......",
+  ".HHBBBBBBHH......",
+  ".HHHBBBBHHH......",
+  ".HHHHHHHHHH......",
+  "..HHHHHHHH.......",
+  "..HHHHHHHH.......",
+  "..HHHHHHHH.......",
 ];
 
-export function danteSprite() {
-  const out = [];
-  const px = (ch) => PAL[ch] ?? null;
-  for (let y = 0; y < ART.length; y += 2) {
+function cell(top, bot) {
+  const t = PAL[top], b = PAL[bot];
+  if (t === undefined && b === undefined) return " ";
+  if (t !== undefined && b === undefined) return `\x1b[38;5;${t}m▀\x1b[0m`;
+  if (t === undefined && b !== undefined) return `\x1b[38;5;${b}m▄\x1b[0m`;
+  return `\x1b[38;5;${t}m\x1b[48;5;${b}m▀\x1b[0m`;
+}
+
+/** The sprite as an array of ready-to-print lines. */
+export function danteLines() {
+  const lines = [];
+  for (let r = 0; r < ART.length; r += 2) {
+    const top = ART[r], bot = ART[r + 1] ?? "";
     let line = "";
-    const top = ART[y], bot = ART[y + 1] || ".".repeat(top.length);
-    for (let x = 0; x < top.length; x++) {
-      const t = px(top[x]), b = px(bot[x]);
-      if (t == null && b == null) line += " ";
-      else if (t != null && b != null) line += `\x1b[38;5;${t};48;5;${b}m▀\x1b[0m`;
-      else if (t != null) line += `\x1b[38;5;${t}m▀\x1b[0m`;
-      else line += `\x1b[38;5;${b}m▄\x1b[0m`;
-    }
-    out.push(line);
+    for (let c = 0; c < top.length; c++) line += cell(top[c] ?? ".", bot[c] ?? ".");
+    lines.push(line);
   }
-  return out.join("\n");
+  return lines;
+}
+export const danteSprite = () => danteLines().join("\n");
+
+// The lettering, in the same small font as Virgil's: one glyph per letter, four rows each.
+const GLYPH = {
+  D: [" ___  ", "|   \\ ", "| |) |", "|___/ "],
+  A: ["   _   ", "  /_\\  ", " / _ \\ ", "/_/ \\_\\"],
+  N: [" _  _ ", "| \\| |", "| .` |", "|_|\\_|"],
+  T: [" _____ ", "|_   _|", "  | |  ", "  |_|  "],
+  E: [" ___ ", "| __|", "| _| ", "|___|"],
+};
+export const WORDMARK = [0, 1, 2, 3].map((row) => " " + [..."DANTE"].map((ch) => GLYPH[ch][row]).join(""));
+
+// The start screen, line by line: the sprite, the lettering in teal, the sentence under it.
+export function startLines(tagline) {
+  const teal = (s) => `\x1b[38;5;30m\x1b[1m${s}\x1b[0m`;
+  return ["", ...danteLines().map((l) => "   " + l), "", ...WORDMARK.map(teal), "", "  " + tagline, ""];
 }
 
+// One-shot runs (cron, a pipe): the plain name; in a terminal the sprite above it.
 export function banner() {
   const tty = process.stdout.isTTY && !process.env.NO_COLOR;
   const name = tty ? "\x1b[1mDante\x1b[0m \x1b[2m· er geht durch die Hölle und bringt die Karte\x1b[0m" : "Dante · wächter";
-  if (!tty) return name;
-  return danteSprite() + "\n" + name;
+  return tty ? danteSprite() + "\n" + name : name;
 }

package/src/pack/install.mjs

@@ -6,7 +6,7 @@
 import { readFileSync, writeFileSync, mkdirSync, renameSync, mkdtempSync, rmSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { runLocal } from "../core/sh.mjs";
+import { runLocal, runLocalAsync } from "../core/sh.mjs";
 import { home, packsDir, packFile, verifyPack, loadPacks } from "./pack.mjs";
 import { rulesWith } from "../checks/battery.mjs";
 
@@ -74,23 +74,35 @@ export const curlShown = (url = PACKS_URL) => `curl -sS --max-time 30 -o <tmp> -
 
 // The one fetch: ONE call returns every pack this person owns as {"packs":[…]}. Returns
 // { ok, code, raws } — code is the HTTP status (0 = no answer), raws the pack texts on 200.
-export function fetchPacks({ url = PACKS_URL } = {}) {
+// What to run (the header goes to curl on stdin with -K -, so the token is not in curl's arguments):
+function curlPlan(url) {
   const token = readLicense();
-  if (!token) return { ok: false, code: -1, noLicense: true };
-  const dir = mkdtempSync(join(tmpdir(), "dante-"));
-  const out = join(dir, "packs.json");
-  try {
-    // the header goes to curl on stdin (-K -), so the token is not in curl's arguments
-    const script = `printf 'header = "Authorization: Bearer %s"\\n' "$(cat ${sq(licenseFile())})" | curl -sS -K - --max-time 30 --max-filesize ${MAX_DOWNLOAD} -o ${sq(out)} -w '%{http_code}' ${sq(url)}`;
-    const r = runLocal(script, { timeout: 40000 });
-    if (r.code === 127) return { ok: false, code: 0, curlMissing: true };
-    const code = Number((r.out || "").trim().slice(-3)) || 0;
-    if (code !== 200) return { ok: false, code, err: r.err };
-    let list;
-    try { list = JSON.parse(readFileSync(out, "utf8")).packs; } catch { return { ok: false, code: 200, badBody: true }; }
-    if (!Array.isArray(list)) return { ok: false, code: 200, badBody: true };
-    return { ok: true, code, raws: list.map((p) => JSON.stringify(p)) };
-  } catch (e) {
-    return { ok: false, code: 0, err: String(e.message || e) };
-  } finally { rmSync(dir, { recursive: true, force: true }); }
+  if (!token) return null;
+  const dir = mkdtempSync(join(tmpdir(), "dante-")), out = join(dir, "packs.json");
+  return { dir, out, script: `printf 'header = "Authorization: Bearer %s"\\n' "$(cat ${sq(licenseFile())})" | curl -sS -K - --max-time 30 --max-filesize ${MAX_DOWNLOAD} -o ${sq(out)} -w '%{http_code}' ${sq(url)}` };
+}
+// What came back (r = the finished command, out = the file curl wrote):
+function curlResult(r, out) {
+  if (r.code === 127) return { ok: false, code: 0, curlMissing: true };
+  const code = Number((r.out || "").trim().slice(-3)) || 0;
+  if (code !== 200) return { ok: false, code, err: r.err };
+  let list;
+  try { list = JSON.parse(readFileSync(out, "utf8")).packs; } catch { return { ok: false, code: 200, badBody: true }; }
+  if (!Array.isArray(list)) return { ok: false, code: 200, badBody: true };
+  return { ok: true, code, raws: list.map((p) => JSON.stringify(p)) };
+}
+export function fetchPacks({ url = PACKS_URL } = {}) {
+  const plan = curlPlan(url);
+  if (!plan) return { ok: false, code: -1, noLicense: true };
+  try { return curlResult(runLocal(plan.script, { timeout: 40000 }), plan.out); }
+  catch (e) { return { ok: false, code: 0, err: String(e.message || e) }; }
+  finally { rmSync(plan.dir, { recursive: true, force: true }); }
+}
+// The same without blocking, so the waiting screen can keep running while curl waits for the server.
+export async function fetchPacksAsync({ url = PACKS_URL } = {}) {
+  const plan = curlPlan(url);
+  if (!plan) return { ok: false, code: -1, noLicense: true };
+  try { return curlResult(await runLocalAsync(plan.script, { timeout: 40000 }), plan.out); }
+  catch (e) { return { ok: false, code: 0, err: String(e.message || e) }; }
+  finally { rmSync(plan.dir, { recursive: true, force: true }); }
 }

package/src/session.mjs

@@ -1,4 +1,5 @@
-// The face: you summon Dante, he greets you, you arm him, you talk, he stays open.
+// The face: you summon Dante, he is awake — sprite, lettering, a loading screen that wakes his ears, then the chat
+// with the loading-screen tips pinned under it. He stays open until you say "raus".
 // Local and honest — no LLM, no network of its own. The router hears what you mean (with a
 // probability); when it is not sure it asks back instead of acting. He waits until you say "raus".
 import { createInterface } from "node:readline/promises";
@@ -9,21 +10,24 @@ import { configureTarget, targetLabel, probe } from "./core/sh.mjs";
 import { renderResult } from "./core/render.mjs";
 import { RISK, WARN, SAFE } from "./core/check.mjs";
 import { ask, recordYes, grantAutomode } from "./core/consent.mjs";
-import { danteSprite } from "./mascot.mjs";
+import { startLines } from "./mascot.mjs";
 import { activeBattery, checkById, runCheck } from "./checks/battery.mjs";
 import { demo } from "./checks/demo.mjs";
 import { run, firstLine } from "./core/sh.mjs";
 import { slots } from "./bib/router.mjs";
-import { hearMain, hearConsent, hearSystem, hearWissen, hearDomain, langOf } from "./bib/ear.mjs";
+import { hearMain, hearConsent, hearSystem, hearMuster, hearWissen, hearDomain, langOf } from "./bib/ear.mjs";
 import { cardsOf, findCard, answer as knowAnswer } from "./pack/know.mjs";
 import { FAMILY_OF, RECIPES } from "./bib/system.mjs";
 import { ANSWERS } from "./bib/answers.mjs";
-import { askWithTicker, setKnowledge } from "./ticker.mjs";
+import { setKnowledge } from "./ticker.mjs";
+import { waitFor } from "./ui/wait.mjs";
+import { footerStart, footerStop, footerNext } from "./ui/footer.mjs";
+import { job } from "./ui/job.mjs";
 import { t, lang, setLang, COMMANDS } from "./i18n.mjs";
 import { tx } from "./i18n-checks.mjs";
 import { hear } from "./core/consent.mjs";
 import { pt, ruleTitles } from "./pack/texts.mjs";
-import { readLicense, saveLicense, fetchPacks, installMany, curlShown, TOKEN_IN_LINE } from "./pack/install.mjs";
+import { readLicense, saveLicense, fetchPacksAsync, installMany, curlShown, TOKEN_IN_LINE } from "./pack/install.mjs";
 import { packsDir } from "./pack/pack.mjs";
 import { readdirSync } from "node:fs";
 
@@ -38,33 +42,54 @@ const pick = (xs) => xs[Math.floor(Math.random() * xs.length)];
 
 export async function session() {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
+  // However the session ends (raus, Ctrl-D, Ctrl-C), the terminal must come back: the footer's scroll region is
+  // reset, or the screen would stay frozen.
+  rl.on("close", footerStop);
+  rl.on("SIGINT", () => { footerStop(); process.stdout.write("\n"); rl.close(); process.exit(0); });
   let target = null; // null = localhost
   let key = null;
   let last = []; // last results, for "fix" and "karte"
 
-  say("");
-  say(danteSprite());
-  say(C("1", "  " + t("intro")) + C("2", t("introSub")));
-  const arm = (await rl.question("\n  " + t("arm") + " " + C("2", t("armOpts")) + " ")).trim();
-  setLang(langOf(arm, lang()));
-  if (hear(arm) !== "yes") { say("  " + C("2", t("sleepNo"))); rl.close(); return; }
-  hearMain(""); hearConsent(""); // learn the bib now (~0.8 s), not in the middle of the first answer
-  // The rules Dante runs with: the built-in ones, plus a bought pack if the file in ~/.dante passes every check.
+  // ---- the start: there is no door to knock on, he is awake ----
+  const dim = (x) => C("2", x);
+  const bar = (i, n) => { const w = 16, f = Math.round((w * i) / n); return C("36", "▕" + "▓".repeat(f) + "░".repeat(w - f) + "▏"); };
+  const frame = (text) => { if (process.stdout.isTTY && !process.env.DANTE_NO_WAIT) process.stdout.write("\r\x1b[2K" + text); };
+  say(startLines(C("1", t("intro")) + dim(t("introSub"))).join("\n"));
+  // The loading screen: a bar that fills as each ear really wakes (they learn their books now, not in the middle
+  // of the first answer). Only the two every start needs; the specialist ears wake the first time they are asked.
+  const EARS = [() => hearMain(""), () => hearConsent("")];
+  for (let i = 0; i <= EARS.length; i++) {
+    frame("  " + bar(i, EARS.length) + " 🦖 " + dim(t("wakeStep")(i, EARS.length)));
+    if (i < EARS.length) EARS[i]();
+  }
+  frame("");
+  let domainWarm = false;
+  const warmDomain = () => {
+    if (domainWarm) return;
+    domainWarm = true;
+    for (const [i, ear] of [hearMuster, hearSystem, hearWissen].entries()) { frame("  " + bar(i, 3) + " 🦖 " + dim(t("wakeMore"))); ear(""); }
+    frame("");
+  };
+  // The rules Dante runs with: the built-in ones, plus every pack in ~/.dante/packs that passes every check.
   let { battery, packs: activePacks, notices } = activeBattery();
   const clock = () => { if (activePacks.length) setKnowledge(activePacks[activePacks.length - 1].issued); }; // the clock then counts from the newest pack
   clock();
 
   configureTarget(null);
   const [h0, h1, h2] = t("sayHelp");
-  say("  " + C("32", t("armed")) + " " + C("2", t("watching")) + targetLabel() + ". " + C("2", h0) + C("1", h1) + C("2", h2));
+  say("  " + C("32", "● " + t("awake")) + dim(" · ") + dim(t("watching")) + targetLabel() + ". " + dim(h0) + C("1", h1) + dim(h2));
   for (const n of notices) say("  " + C("33", pt().ignored(n.file, pt().reason(n.code, n.detail))));
-  if (activePacks.length) say("  " + C("2", pt().on(activePacks)));
+  if (activePacks.length) say("  " + dim(pt().on(activePacks)));
+  footerStart(); // the loading-screen tips, pinned under the chat
 
+  // The slow work (ssh, waiting for the server) runs in a worker thread, so the waiting screen keeps moving.
+  const target$ = () => (target ? { host: target, key } : null);
+  const brokeOff = (c) => ({ id: c.id, title: c.title, verdict: "unknown", was: "Check brach ab.", wie: "", wo: "", evidence: [] });
   // no list given = the whole battery: Dante's job is every thing he watches, not only one hole
   const runChecks = async (withFix, checks = battery) => {
-    const ch = probe();
-    if (!ch.reached) { say("  " + C("100;37", t("rUnknown")) + " " + t("unseen")(targetLabel(), ch.line)); return; }
-    last = checks.map((c) => ({ c, r: runCheck(c) }));
+    const res = await waitFor(t("waitCheck")(targetLabel()), job({ kind: "checks", ids: checks.map((c) => c.id) }, target$()));
+    if (!res.reached) { say("  " + C("100;37", t("rUnknown")) + " " + t("unseen")(targetLabel(), res.line)); return; }
+    last = checks.map((c, i) => ({ c, r: res.results[i] || brokeOff(c) }));
     for (const { r } of last) say(renderResult(r));
     const open = last.filter(({ r }) => r.verdict === RISK || r.verdict === WARN && r.fix);
     if (open.length && !withFix) say("\n  " + C("2", t("canFix")) + C("1", "fix") + C("2", "."));
@@ -81,12 +106,16 @@ export async function session() {
     if (a === "no") { say("  " + C("2", t("nothing"))); return; }
     if (a === "always") { grantAutomode(check.id); }
     for (const s of r.fix.steps) {
-      const res = run(s.script, { timeout: 120000 });
+      const o = await waitFor(tx(s.desc), job({ kind: "exec", scripts: [s.script], timeout: 120000 }, target$()));
+      const res = o.reached ? o.outs[0] : { ok: false, out: "", err: o.line };
       say("  " + (res.ok ? C("32", "✓") : C("31", "✗")) + " " + tx(s.desc) + "  " + C("2", "→ " + (firstLine(res.out || res.err) || (res.ok ? "(ok)" : "(fehler)"))));
       if (!res.ok) { say("  " + C("31", t("failed"))); return; }
     }
     if (a === "yes") await recordYes(check.id, { rl });
-    const after = check.run();
+    // the check that fixed something is run again for a fresh real line (the demo is not in the battery: it runs here)
+    const after = battery.some((c) => c.id === check.id)
+      ? (await waitFor(t("waitCheck")(targetLabel()), job({ kind: "checks", ids: [check.id] }, target$()))).results[0] || brokeOff(check)
+      : check.run();
     say("  " + C("2", t("recheck")));
     say(renderResult(after).split("\n").map((l) => "  " + l).join("\n"));
     say("  " + (after.verdict === SAFE ? C("42;30", t("closed")) + C("2", t("closedSub")) : C("33", t("notYet"))));
@@ -122,9 +151,10 @@ export async function session() {
       }
       case "fingerabdruck": {
         // "What is my system?" — answered from what the target itself prints, in five lines at most.
-        const ch = probe(); if (!ch.reached) return unreached(ch);
+        const o = await waitFor(t("waitLook")(targetLabel()), job({ kind: "exec", scripts: [OVERVIEW] }, target$()));
+        if (!o.reached) return unreached(o);
         const kv = {};
-        for (const l of run(OVERVIEW).out.split("\n")) { const i = l.indexOf("="); if (i > 0) kv[l.slice(0, i)] = l.slice(i + 1).trim(); }
+        for (const l of o.outs[0].out.split("\n")) { const i = l.indexOf("="); if (i > 0) kv[l.slice(0, i)] = l.slice(i + 1).trim(); }
         const S = OV[lang()], fam = FAMILY_OF[(kv.ID || "").toLowerCase()] || "unbekannt";
         say("  " + C("1", S.system) + " " + (kv.OS || (kv.MAC || "").trim() || kv.ID || "?") + (kv.KERNEL ? " · " + kv.KERNEL : "") + (kv.ARCH ? " · " + kv.ARCH : "") + C("2", "   → " + ((kv.ID || "") + " " + (kv.VER || "")).trim()));
         say("  " + (PKG[fam] ? C("1", S.pkg) + " " + PKG[fam] + C("2", ` (${S.family} ${fam})`) : C("1", S.pkg) + " " + S.pkgUnknown));
@@ -134,8 +164,9 @@ export async function session() {
         return;
       }
       case "finde_php": {
-        const ch = probe(); if (!ch.reached) return unreached(ch);
-        const line = firstLine(run("php -v 2>/dev/null | head -1").out);
+        const o = await waitFor(t("waitLook")(targetLabel()), job({ kind: "exec", scripts: ["php -v 2>/dev/null | head -1"] }, target$()));
+        if (!o.reached) return unreached(o);
+        const line = firstLine(o.outs[0].out);
         say(line ? "  " + C("1", SYS_T.php[lang()]) + C("2", "   → " + line) : "  " + C("2", SYS_T.phpNo[lang()]));
         return;
       }
@@ -165,8 +196,7 @@ export async function session() {
     if (!readLicense()) { say("  " + C("2", p.noLicense)); return; }
     say("  " + C("2", p.askFetch) + "\n    " + C("2", curlShown()));
     if (!(await yesNo(p.go))) { say("  " + C("2", p.declined)); return; }
-    say("  " + C("2", p.loading));
-    const f = fetchPacks();
+    const f = await waitFor(p.loading, fetchPacksAsync());
     if (!f.ok) { say("  " + C("33", failText(f))); return; }
     showInstalled(installMany(f.raws));
   };
@@ -222,7 +252,8 @@ export async function session() {
 
   let pending = null; // the guess Dante asked back about; a plain "ja" takes it
   for (;;) {
-    const line = (await askWithTicker(rl, "\n" + C("2", "dante ❯ "), lang())).trim();
+    footerNext(); // a new tip with every input, like a loading screen
+    const line = (await rl.question("\n" + C("32;1", "dante ❯ "))).trim();
     if (!line) continue;
     const [first, ...rest] = line.split(/\s+/);
     const arg = rest.join(" ");
@@ -238,7 +269,7 @@ export async function session() {
     // A hard bolt, no probability: words of attack never reach a check, whatever the ear heard.
     if (ATTACK.test(line) && !DEFEND.test(line)) { say("  " + C("2", t("notMine"))); continue; }
     switch (heard.intent) {
-      case "raus": say("  " + C("2", t("bye"))); rl.close(); return;
+      case "raus": say("  " + C("2", t("bye"))); footerStop(); rl.close(); return;
       case "gruss": say("  " + pick(t("hello"))); break;
       case "hilfe": say(help()); break;
       case "key": key = pfad || named(/^(key|schlüssel|llave|clave)$/i); configureTarget(target ? { host: target, key } : null); say("  " + C("2", t("key")) + (key || t("none"))); break;
@@ -253,6 +284,7 @@ export async function session() {
       case "demo": { configureTarget(target ? { host: target, key } : null); run("touch /tmp/dante-demo-hole"); const r = demo.run(); say(renderResult(r)); if (r.fix) await finding(demo, r); break; }
       case "smalltalk": say(pick(ANSWERS.smalltalk[lang()]).map((l) => "  " + l).join("\n")); break;
       case "frage_luecke": case "frage_urteil": case "frage_gehackt": case "frage_dante":
+        warmDomain();
         // "zeig mir die zeile die das beweist" overlaps frage_urteil (what a Beleg IS). If a check
         // already ran and the system ear is sure it is a beleg ask, show the real last line instead
         // of explaining the concept.
@@ -270,6 +302,7 @@ export async function session() {
         // The main ear has a gap → the domain ears (muster, system, wissen) get a turn. Each also knows
         // what is not its own, and each is conservative (both neurons must be sure), so plain talk is
         // never pulled into a patrol or an explanation.
+        warmDomain();
         const dom = hearDomain(line);
         if (dom) { if (dom.ear === "muster") await musterMove(dom.intent); else if (dom.ear === "system") await systemMove(dom.intent); else knowMove(dom.intent, line); break; }
         // Not sure → ask back with the two best guesses. Outside his work → say so, plainly.

package/src/ticker.mjs

@@ -1,17 +1,18 @@
-// The loading-screen line under the input bar: a turning wheel, a tip that types itself in,
-// and Dante's inner clock on the right. The clock is local arithmetic — Dante never phones home
-// to ask for updates. Past STALE days it says so, and says how to get fresh knowledge.
+// What the footer says: the GTA-loading-screen tips and Dante's inner clock. The clock is local arithmetic —
+// Dante never phones home to ask for updates. Past STALE days it says so, and says how to get fresh knowledge.
+import { readFileSync } from "node:fs";
 export const BIB_DATE = "2026-10-25"; // bump with every bib update
+// The version of the package that is running — shown in the clock, so nobody has to guess.
+export const VERSION = (() => { try { return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version || ""; } catch { return ""; } })();
 export const STALE = 14;              // days until Dante says his knowledge is getting old
 // The date the clock counts from: the package's own knowledge, or a pack's issue date once one is active.
 let knowledge = BIB_DATE;
 export const setKnowledge = (iso) => { const d = String(iso || "").slice(0, 10); if (/^\d{4}-\d{2}-\d{2}$/.test(d) && d > BIB_DATE) knowledge = d; };
 
-const WHEEL = ["◜", "◠", "◝", "◞", "◡", "◟"];
-const TIPS = {
+export const TIPS = {
   de: [
     "Dante sagt nie „sicher“ ohne echte Zeile.", "Kein Ja, keine Änderung. Nie.",
-    "Dante sendet nichts. Kein Netz, kein Anruf, keine Abhängigkeit.",
+    "Dante ruft von sich aus nie an. Nur „aktualisier“ nach deinem Ja holt Packs.",
     "Eine Versionsnummer allein entscheidet nie — Distros flicken leise.",
     "Sieht er dein Ziel nicht, sagt er „unbekannt“. Nicht „sicher“.",
     "Sag einfach, was du willst: „prüf meinen server root@host“.",
@@ -20,7 +21,7 @@ const TIPS = {
   ],
   en: [
     "Dante never says „safe“ without a real line.", "No yes, no change. Ever.",
-    "Dante sends nothing. No network, no call home, no dependencies.",
+    "Dante never calls anyone on his own. Only „update“, after your yes, fetches packs.",
     "A version number alone never decides — distros patch quietly.",
     "If he cannot see your target, he says „unknown“. Not „safe“.",
     "Just say what you want: „check my server root@host“.",
@@ -29,7 +30,7 @@ const TIPS = {
   ],
   es: [
     "Dante nunca dice „seguro“ sin una línea real.", "Sin sí, no hay cambio. Nunca.",
-    "Dante no envía nada. Sin red, sin llamar a casa, sin dependencias.",
+    "Dante nunca llama por su cuenta. Solo „actualiza“, tras tu sí, trae packs.",
     "Un número de versión solo nunca decide — las distros parchean en silencio.",
     "Si no ve tu destino, dice „desconocido“. No „seguro“.",
     "Di lo que quieres: „revisa mi servidor root@host“.",
@@ -37,7 +38,7 @@ const TIPS = {
     "Lo último: npx dante-watch@latest", "Reglas frescas en packs sueltos: escribe „actualiza“. Los viejos se quedan.",
   ],
 };
-const OLD = {
+export const OLD = {
   de: (d) => `Wissen ${d} Tage alt — neueste Updates: ${UPDATE} · frische Regeln: „aktualisier“`,
   en: (d) => `Knowledge is ${d} days old — latest updates: ${UPDATE} · fresh rules: „update“`,
   es: (d) => `Conocimiento de hace ${d} días — últimas novedades: ${UPDATE} · reglas frescas: „actualiza“`,
@@ -48,40 +49,16 @@ export function age(now = Date.now()) {
   return Math.max(0, Math.floor((now - Date.parse(knowledge + "T00:00:00Z")) / 864e5));
 }
 
-const tty = () => process.stdout.isTTY && !process.env.NO_COLOR;
-const cut = (s, n) => (s.length > n ? s.slice(0, Math.max(0, n - 1)) + "…" : s);
-
-// One frame: wheel · tip (typed in up to `shown` chars) ··· clock. Plain text widths, then colour.
-function frame(tick, tipIdx, shown, cols, lang) {
-  const days = age();
-  const stale = days > STALE;
-  const tip = stale && tipIdx % 2 ? OLD[lang](days) : TIPS[lang][tipIdx % TIPS[lang].length];
-  const clock = stale ? `bib ${days}d · !` : `bib ${knowledge.slice(8, 10)}.${knowledge.slice(5, 7)}. · ${days}d`;
-  const room = cols - 2 - 2 - 2 - clock.length - 2;
-  const text = cut(tip.slice(0, shown), room);
-  const gap = " ".repeat(Math.max(1, room - text.length + 2));
-  const tipC = stale && tipIdx % 2 ? "33" : "2";
-  return `  \x1b[36m${WHEEL[tick % WHEEL.length]}\x1b[0m  \x1b[${tipC}m${text}\x1b[0m${gap}\x1b[${stale ? "33" : "2"}m${clock}\x1b[0m`;
+// "bib 25.10. · 0d" — the date of the knowledge and how old it is; "bib 20d · !" once it is stale.
+export function clockText() {
+  const days = age(), v = VERSION ? ` · v${VERSION}` : "";
+  return (days > STALE ? `bib ${days}d · !` : `bib ${knowledge.slice(8, 10)}.${knowledge.slice(5, 7)}. · ${days}d`) + v;
 }
 
-// Ask a question with the ticker rolling one row below the cursor. Falls back to a plain question.
-export async function askWithTicker(rl, q, lang = "de") {
-  if (!TIPS[lang]) lang = "en";
-  if (!tty()) return rl.question(q);
-  process.stdout.write("\n\x1b[1A"); // reserve the row below, so drawing there never scrolls
-  let tick = 0, tipIdx = Math.floor(Math.random() * TIPS[lang].length), shown = 0, hold = 0;
-  const draw = () => {
-    const cols = process.stdout.columns || 80;
-    process.stdout.write("\x1b7\x1b[1B\r\x1b[2K" + frame(tick, tipIdx, shown, cols, lang) + "\x1b8");
-    tick++;
-    const full = (age() > STALE && tipIdx % 2 ? 80 : TIPS[lang][tipIdx % TIPS[lang].length].length);
-    if (shown < full) shown += 2;
-    else if (++hold > 40) { hold = 0; shown = 0; tipIdx++; } // ~5 s per tip, then the next types in
-  };
-  const timer = setInterval(draw, 120);
-  draw();
-  try { return await rl.question(q); }
-  finally { clearInterval(timer); process.stdout.write("\r\x1b[2K"); } // Enter moved us onto the ticker row
+// The tip for slot i in a language. Once the knowledge is stale, every second tip says so.
+export function tipAt(i, lang = "de") {
+  const L = TIPS[lang] ? lang : "en", days = age();
+  return days > STALE && i % 2 ? OLD[L](days) : TIPS[L][i % TIPS[L].length];
 }
 
 // One line for one-shot runs (cron, --json excluded): only when the knowledge is old.

package/src/ui/footer.mjs

@@ -0,0 +1,46 @@
+// The footer — Virgil's, one to one: the two lowest lines of the terminal stay where they are (a scroll
+// region, like the status bar of vim or tmux) and everything else scrolls above. A thin line, and under it a
+// GTA-loading-screen tip that changes with every input. Dante adds his inner clock on the right.
+// Only in a real terminal. The scroll region is ALWAYS reset on exit, or the terminal would stay frozen.
+import { lang } from "../i18n.mjs";
+import { tipAt, clockText, age, STALE } from "../ticker.mjs";
+
+let on = false, timer = null, tipIdx = Math.floor(Math.random() * 8);
+const rows = () => process.stdout.rows || 24, cols = () => process.stdout.columns || 80;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`, yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const cut = (s, n) => (s.length > n ? s.slice(0, Math.max(0, n - 1)) + "…" : s);
+
+function draw() {
+  if (!on) return;
+  const r = rows(), c = cols(), clock = clockText();
+  const tip = cut(tipAt(tipIdx, lang()), Math.max(10, c - 4 - clock.length - 3));
+  const gap = " ".repeat(Math.max(1, c - 4 - tip.length - clock.length - 2));
+  const row = dim("  ◍ ") + yellow(tip) + gap + (age() > STALE ? yellow(clock) : dim(clock));
+  // save the cursor → the two reserved lines → clear + write → cursor back
+  process.stdout.write("\x1b7" + `\x1b[${r - 1};1H\x1b[2K` + dim("─".repeat(Math.max(10, c - 2))) + `\x1b[${r};1H\x1b[2K` + row + "\x1b8");
+}
+
+export function footerStart() {
+  if (!process.stdout.isTTY || process.env.DANTE_NO_FOOTER || on) return;
+  on = true;
+  const r = rows();
+  process.stdout.write(`\x1b[1;${r - 2}r`);   // scroll region = the top, without the lowest 2 lines
+  process.stdout.write(`\x1b[${r - 2};1H`);   // cursor into the upper part
+  draw();
+  // four times a second, so the footer stays visible even when readline or other output paints over it
+  timer = setInterval(draw, 250); timer.unref?.();
+  process.stdout.on("resize", draw);
+  process.on("exit", footerStop);
+}
+export function footerStop() {
+  if (!on) return;
+  on = false;
+  if (timer) { clearInterval(timer); timer = null; }
+  const r = rows();
+  process.stdout.write("\x1b[r");   // scroll region back to the whole screen
+  process.stdout.write(`\x1b[${r - 1};1H\x1b[2K\x1b[${r};1H\x1b[2K`);
+  try { process.stdout.off("resize", draw); } catch { /* fine */ }
+}
+/** The next tip — call before every input. */
+export function footerNext() { if (on) { tipIdx++; draw(); } }
+export const footerOn = () => on;

package/src/ui/job-worker.mjs

@@ -0,0 +1,18 @@
+// Runs in a worker thread: aim at the target, prove the channel, then run what was asked.
+import { parentPort, workerData } from "node:worker_threads";
+import { configureTarget, probe, run } from "../core/sh.mjs";
+import { setLang } from "../i18n.mjs";
+import { activeBattery, runCheck } from "../checks/battery.mjs";
+
+const { task, target, lang } = workerData;
+setLang(lang);
+configureTarget(target);
+const ch = probe();
+if (!ch.reached) parentPort.postMessage({ reached: false, line: ch.line });
+else if (task.kind === "checks") {
+  const { battery } = activeBattery();
+  const by = new Map(battery.map((c) => [c.id, c]));
+  parentPort.postMessage({ reached: true, results: task.ids.map((id) => (by.has(id) ? runCheck(by.get(id)) : null)) });
+} else {
+  parentPort.postMessage({ reached: true, outs: task.scripts.map((s) => { const r = run(s, { timeout: task.timeout || 15000 }); return { out: r.out, err: r.err, ok: r.ok, ran: r.ran }; }) });
+}

package/src/ui/job.mjs

@@ -0,0 +1,16 @@
+// The checks block while they run: they call ssh and wait for the server (spawnSync). If that ran on the
+// main thread, the waiting screen could not move. So the slow work runs in a worker thread and the main
+// thread keeps the dinosaur running. The worker gets plain data in and gives plain data back; it loads the
+// same built-in rules and packs as the session does.
+import { Worker } from "node:worker_threads";
+import { lang } from "../i18n.mjs";
+
+// task: { kind: "checks", ids } | { kind: "exec", scripts }   target: { host, key } | null
+export function job(task, target) {
+  return new Promise((resolve, reject) => {
+    const w = new Worker(new URL("./job-worker.mjs", import.meta.url), { workerData: { task, target, lang: lang() }, execArgv: [] } /* no start options of the parent (a worker must not inherit --input-type & co) */);
+    w.once("message", resolve);
+    w.once("error", reject);
+    w.once("exit", (code) => { if (code !== 0) reject(new Error("worker exit " + code)); });
+  });
+}

package/src/ui/quips.mjs

@@ -0,0 +1,16 @@
+// What Dante says while you wait. A terminal you stare at for a few seconds may as well say something.
+// Same idea as Virgil's spinner sayings, in Dante's voice (the pilgrim, the map, the circles of Hell).
+import { lang } from "../i18n.mjs";
+
+const QUIPS = {
+  de: ["zählt die Kreise der Hölle …", "poliert das Schwert …", "liest Virgils Karte …", "fragt den Fährmann …", "sucht die Tür, die offen stand …", "schärft die Zeilen …", "trinkt einen Espresso …", "prüft die Papiere von Charon …", "wartet, bis der Hund aufhört zu bellen …", "geht noch einen Kreis tiefer …", "schaut hinter jede Tür …", "nimmt es nicht für sicher, bis die Zeile da ist …"],
+  en: ["counting the circles of Hell …", "polishing the sword …", "reading Virgil's map …", "asking the ferryman …", "looking for the door that stood open …", "sharpening the lines …", "having an espresso …", "checking Charon's papers …", "waiting for the dog to stop barking …", "going one circle deeper …", "looking behind every door …", "not calling it safe until the line is there …"],
+  es: ["contando los círculos del infierno …", "puliendo la espada …", "leyendo el mapa de Virgilio …", "preguntando al barquero …", "buscando la puerta que quedó abierta …", "afilando las líneas …", "tomando un espresso …", "revisando los papeles de Caronte …", "esperando a que el perro deje de ladrar …", "bajando un círculo más …", "mirando detrás de cada puerta …", "sin darlo por seguro hasta que esté la línea …"],
+};
+let at = Math.floor(Math.random() * 12), tick = 0;
+/** A saying that changes every ~4 seconds of calls (each frame calls once), so a long wait does not repeat itself. */
+export function quip() {
+  const xs = QUIPS[lang()] || QUIPS.en;
+  if (tick++ % 33 === 0) at = Math.floor(Math.random() * xs.length);
+  return xs[at % xs.length];
+}

package/src/ui/wait.mjs

@@ -0,0 +1,80 @@
+// The waiting screen — Virgil's, one to one: while a long step runs, one line shows a block swinging back
+// and forth in a bar, a dinosaur running beside it, the name of the step and the seconds. Anything the program
+// prints meanwhile goes past the line first (console.log is wrapped), so nothing is ever written over the bar.
+// Only in a real terminal; DANTE_NO_WAIT=1 switches it off.
+import { quip } from "./quips.mjs";
+
+const dim = (s) => `\x1b[2m${s}\x1b[0m`, cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const stack = [];
+let timer = null, frame = 0, shown = 0, suppressed = 0;
+
+const live = () => (!!process.stdout.isTTY || process.env.DANTE_FORCE_WAIT === "1") && !process.env.DANTE_NO_WAIT;
+const BAR = 16, BLOCK = 4;
+
+function line() {
+  const top = stack[stack.length - 1];
+  const secs = Math.floor((Date.now() - top.t0) / 1000);
+  const period = (BAR - BLOCK) * 2, p = frame % period;
+  const at = p < BAR - BLOCK ? p : period - p; // the block swings to and fro
+  let bar = "";
+  for (let i = 0; i < BAR; i++) bar += i >= at && i < at + BLOCK ? "▓" : "░";
+  const dino = frame % 6 < 3 ? "🦖 " : " 🦖"; // runs, sniffs, runs
+  const depth = stack.length > 1 ? dim(" (" + stack.length + " steps)") : "";
+  const saying = secs >= 3 ? dim(" · " + quip()) : "";
+  return "  " + cyan("▕" + bar + "▏") + " " + dino + " " + dim(top.label) + depth + dim(" · " + secs + "s") + saying;
+}
+const width = (s) => s.replace(/\x1b\[[0-9;]*m/g, "").length + 2; // an emoji is two columns wide
+
+function clear() {
+  if (shown > 0) { process.stdout.write("\r\x1b[2K"); shown = 0; }
+}
+function draw() {
+  if (!live() || suppressed > 0 || !stack.length) return;
+  frame++;
+  const l = line();
+  clear();
+  process.stdout.write(l);
+  shown = width(l);
+}
+
+const orig = { log: console.log, error: console.error };
+let patched = false;
+function patchConsole() {
+  if (patched || !live()) return;
+  patched = true;
+  console.log = (...a) => { clear(); orig.log(...a); draw(); };
+  console.error = (...a) => { clear(); orig.error(...a); draw(); };
+}
+function unpatchConsole() {
+  if (!patched) return;
+  console.log = orig.log; console.error = orig.error; patched = false;
+}
+
+/** Begin a long step. May nest — the innermost one is shown. */
+export function waitStart(label) {
+  stack.push({ label, t0: Date.now() });
+  patchConsole();
+  if (!timer && live()) { timer = setInterval(draw, 120); timer.unref?.(); }
+  draw();
+}
+/** End the innermost step. */
+export function waitEnd() {
+  stack.pop();
+  if (!stack.length) {
+    if (timer) clearInterval(timer);
+    timer = null; clear(); unpatchConsole();
+  }
+}
+/** Do some work with the display — the line goes away by itself, even after an error. */
+export async function waitFor(label, work) {
+  waitStart(label);
+  try { return await (typeof work === "function" ? work() : work); } finally { waitEnd(); }
+}
+/** Before any other output: line away. After it: draw again. */
+export const waitHide = clear;
+export const waitShow = draw;
+/** A question needs the line: do not draw while it is asked. */
+export function waitSuppress(on) {
+  suppressed = Math.max(0, suppressed + (on ? 1 : -1));
+  if (on) clear(); else draw();
+}