mythos-code 1.7.3 → 1.9.0

package/README.md

@@ -7,3 +7,5 @@ npm install -g mythos-code
 mythos login
 mythos
 ```
+
+Updates kommen automatisch beim Start (abschalten: `MYTHOS_NO_UPDATE=1`). Manuell: `mythos update`.

package/bin/mythos.js

@@ -4,15 +4,175 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import readline from "node:readline";
+import http from "node:http";
 import { exec, spawn, execFileSync } from "node:child_process";
 
 // ---------- Gemeinsame Werkzeuge (CLI + Desktop-App) ----------
 // Wird roh in bin/mythos.js (CLI, ESM) und main.js (App, CommonJS) eingefügt.
 // Erwartet, dass `fs` und `path` im umgebenden Code schon importiert sind.
 
+// ---------- Werkzeug-Blöcke robust lesen (CLI, Desktop-App: Haupt- und Fensterprozess) ----------
+// Wird roh über den Platzhalter TOOL_PARSE eingefügt. Keine Abhängigkeiten.
+// Modelle schreiben Aufrufe nicht immer sauber: fehlendes </tool>, <tool_call> statt <tool>, ```json-Zäune,
+// {"name":…,"arguments":{…}} statt flacher Felder, echte Zeilenumbrüche in Strings oder abgeschnittenes JSON.
+// Nichts davon darf als Rohtext im Chat landen.
+
+const TOOL_NAMES = ["run", "start", "logs", "stop", "serve", "check", "verify", "read", "edit", "write", "search", "ls", "websearch", "fetch", "cloud", "todo"];
+const TOOL_OPEN_RE = /<(tool_call|tool_use|tool)(?:\s[^>]*)?>/i;
+// Ein ganzer Block – auch nicht geschlossen (dann bis zum Textende).
+const TOOL_BLOCK_RE = /<(tool_call|tool_use|tool)(?:\s[^>]*)?>[\s\S]*?(?:<\/\1\s*>|$)/gi;
+
+/** Alle Werkzeug-Blöcke und verwaiste End-Tags entfernen. */
+function stripToolBlocks(text) {
+  return String(text || "").replace(TOOL_BLOCK_RE, "").replace(/<\/(?:tool_call|tool_use|tool)\s*>/gi, "");
+}
+
+/** Erstes JSON-Objekt im Text herausschneiden. Rohe Zeilenumbrüche in Strings werden escaped,
+ *  abgeschnittenes JSON wird geschlossen. → { json, complete } oder null. */
+function jsonObjectAt(s) {
+  const start = s.indexOf("{");
+  if (start < 0) return null;
+  let out = "", inStr = false, esc = false;
+  const stack = [];
+  for (let i = start; i < s.length; i++) {
+    const ch = s[i];
+    if (inStr) {
+      if (esc) { esc = false; out += ch; continue; }
+      if (ch === "\\") { esc = true; out += ch; continue; }
+      if (ch === '"') { inStr = false; out += ch; continue; }
+      out += ch === "\n" ? "\\n" : ch === "\r" ? "\\r" : ch === "\t" ? "\\t" : ch;
+      continue;
+    }
+    if (ch === '"') { inStr = true; out += ch; continue; }
+    if (ch === "{" || ch === "[") stack.push(ch === "{" ? "}" : "]");
+    else if (ch === "}" || ch === "]") { stack.pop(); out += ch; if (!stack.length) return { json: out, complete: true }; continue; }
+    out += ch;
+  }
+  // Abgeschnitten: offenen String und Klammern schließen, hängendes Komma/Doppelpunkt weg.
+  if (esc) out = out.slice(0, -1);
+  if (inStr) out += '"';
+  out = out.replace(/[,:]\s*$/, "");
+  while (stack.length) out += stack.pop();
+  return { json: out, complete: false };
+}
+
+/** Ersten Werkzeug-Aufruf aus einer Antwort lesen.
+ *  → { tool: {name, …} | null, error: string | "", text: sichtbarer Text ohne Werkzeug-Blöcke } */
+function parseToolBlock(out) {
+  out = String(out || "");
+  const text = stripToolBlocks(out).trim();
+  const m = TOOL_OPEN_RE.exec(out);
+  if (!m) return { tool: null, error: "", text };
+  let body = out.slice(m.index + m[0].length);
+  const end = body.search(/<\/(?:tool_call|tool_use|tool)\s*>/i);
+  if (end >= 0) body = body.slice(0, end);
+  body = body.replace(/```[a-z]*\s*/gi, "");
+  const raw = jsonObjectAt(body);
+  if (!raw) return { tool: null, error: "Im Werkzeug-Block steht kein JSON-Objekt.", text };
+  let t;
+  try { t = JSON.parse(raw.json); } catch (e) { return { tool: null, error: "Werkzeug-JSON ungültig (" + e.message + ").", text }; }
+  if (!t || typeof t !== "object" || Array.isArray(t)) return { tool: null, error: "Werkzeug-JSON muss ein Objekt sein.", text };
+  // Name auch aus <tool name="…"> oder anderen üblichen Feldern.
+  const attr = m[0].match(/\bname\s*=\s*["']([^"']+)["']/i);
+  if (typeof t.name !== "string") t.name = String(t.tool_name || t.function || (attr && attr[1]) || "");
+  // {"name":"x","arguments":{…}} / "input" / "parameters" / "args" flach machen (bei MCP: nach "args").
+  for (const k of ["arguments", "input", "parameters", "args"]) {
+    const a = t[k];
+    if (!a || typeof a !== "object" || Array.isArray(a)) continue;
+    if (t.name === "mcp") { if (k !== "args") { delete t[k]; if (!t.args) t.args = a; } continue; }
+    delete t[k]; for (const x of Object.keys(a)) if (!(x in t)) t[x] = a[x];
+  }
+  // mcp__server__tool (Hook-Schreibweise) → MCP-Aufruf.
+  const mm = t.name.match(/^mcp__(.+?)__(.+)$/);
+  if (mm) { const { name, ...rest } = t; t = { name: "mcp", server: mm[1], tool: mm[2], args: rest.args || rest }; }
+  t.name = t.name.trim();
+  if (!t.name) return { tool: null, error: "Im Werkzeug-Block fehlt \"name\".", text };
+  // Abgeschnittene Aufrufe nicht ausführen (sonst z. B. halbe Dateien) – außer harmlose wie todo.
+  if (!raw.complete && t.name !== "todo") return { tool: null, error: "Der Werkzeug-Aufruf " + t.name + " ist abgeschnitten.", text };
+  return { tool: t, error: "", text };
+}
+
+/** Prüfen, ob es das Werkzeug wirklich gibt. extra = { mcp: [{ server, tools: [Namen] }], browser: bool }.
+ *  → "" wenn ok, sonst eine Erklärung fürs Modell (mit der Liste, was es gibt). */
+function toolProblem(t, extra) {
+  extra = extra || {};
+  const mcp = extra.mcp || [];
+  const avail = TOOL_NAMES.concat(mcp.length ? ["mcp"] : [], extra.browser ? ["browser"] : []);
+  const list = "Verfügbar sind nur: " + avail.join(", ") + (mcp.length ? " · MCP: " + mcp.map((s) => s.server + " (" + s.tools.join(", ") + ")").join("; ") : " · keine MCP-Connectoren verbunden") + ".";
+  const tail = " Erfinde keine Werkzeuge. Wenn etwas damit nicht geht, sag das dem Nutzer kurz und mach mit dem Rest weiter.";
+  if (t.name === "mcp") {
+    const s = mcp.find((x) => x.server === t.server) || mcp.find((x) => String(x.server).toLowerCase() === String(t.server || "").toLowerCase());
+    if (!s) return "FEHLER: MCP-Server „" + (t.server || "?") + "“ ist nicht verbunden. " + list + tail;
+    t.server = s.server;
+    if (!s.tools.includes(t.tool)) return "FEHLER: MCP-Werkzeug „" + t.tool + "“ gibt es bei " + s.server + " nicht. " + list + tail;
+    return "";
+  }
+  if (t.name === "browser") return extra.browser ? "" : "FEHLER: Das Browser-Plugin ist nicht verbunden. " + list + tail;
+  return TOOL_NAMES.includes(t.name) ? "" : "FEHLER: Werkzeug „" + t.name + "“ gibt es nicht. " + list + tail;
+}
+
+// Befehle, die nicht von selbst enden (Dev-Server, Watcher, Bots) → im Hintergrund statt mit run.
+const SERVER_RES = [
+  /\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:dev|start|serve|preview|watch)\b(?!\s*:?\s*(?:build|test))/i,
+  /\b(?:npx\s+|bunx\s+)?vite(?:\s+(?:dev|serve|preview))?(?:\s+--?\w[\w-]*(?:[ =]\S+)?)*\s*(?:$|[;&|])/i,
+  /\b(?:next|nuxt|nuxi|astro|remix|gatsby)\s+(?:dev|start|develop|preview)\b/i,
+  /\b(?:webpack(?:-dev-server|\s+serve)|react-scripts\s+start|ng\s+serve|vue-cli-service\s+serve|parcel(?!\s+build)\b)/i,
+  /\b(?:live-server|http-server|lite-server|browser-sync)\b|\bnpx\s+serve\b|\bserve\s+(?:-[sl]\b|\.|\S*dist|\S*build|\S*public)/i,
+  /\b(?:nodemon|ts-node-dev|tsx\s+watch|node\s+--watch)\b|\s--watch\b/i,
+  /\bpython\d?(?:\.exe)?\s+-m\s+http\.server\b|\bphp\s+-S\b|\bflask\s+run\b|\buvicorn\b|\bgunicorn\b|\bmanage\.py\s+runserver\b|\brails\s+s(?:erver)?\b|\b(?:jekyll|hugo)\s+serve(?:r)?\b/i,
+  /\bnode\s+(?:\S*[\\/])?(?:server|app|index|bot)\.(?:c|m)?js\b/i,
+  /\belectron\s+\./i,
+];
+const looksLikeServer = (cmd) => SERVER_RES.some((re) => re.test(String(cmd || "")));
+
+/** Antwort sieht aus wie eine Schritt-für-Schritt-Anleitung zum Selbermachen (statt erledigter Arbeit)? */
+function looksLikeTutorial(text) {
+  const t = String(text || "");
+  const steps = (t.match(/^\s*(?:\d+[.)]|schritt\s*\d+|step\s*\d+)/gim) || []).length;
+  const shell = /```(?:bash|sh|shell|cmd|powershell|ps1|bat|console)?\s*\n\s*(?:npm|npx|pip|pip3|python|py|pyinstaller|node|yarn|pnpm|git|cargo|go|dotnet|mvn|gradle|winget|choco|cd|mkdir|electron-builder)\b/i.test(t);
+  const youDo = /\b(?:führe|öffne|installiere|gib|tippe|kopiere|speichere|erstelle|lade)\b[^.\n]{0,60}\b(?:aus|ein|dann|folgende|den befehl|im terminal|die datei)\b|\bdu (?:musst|kannst|solltest)\b/i.test(t);
+  return (shell && (steps >= 2 || youDo)) || (steps >= 3 && youDo);
+}
+// Gegen oberflächliche Arbeit: Hat Mythos nach seinen Änderungen wirklich geprüft?
+const WEB_FILE_RE = /\.(?:html?|css|s[ac]ss|jsx?|tsx?|mjs|vue|svelte)$/i;
+function verifyTracker() {
+  const st = { changed: false, web: false, verified: false, checked: false, nudges: 0, acted: false, tutorNudged: false };
+  return {
+    note(t, result) {
+      if (t.name !== "todo") st.acted = true;
+      const ok = !/^(?:FEHLER|BLOCKIERT|Vom Nutzer)/.test(String(result || ""));
+      if ((t.name === "write" || t.name === "edit") && ok) { st.changed = true; st.verified = false; if (WEB_FILE_RE.test(String(t.path || ""))) { st.web = true; st.checked = false; } }
+      if (t.name === "verify") st.verified = true;
+      if (t.name === "run" && /\b(?:build|test|tsc|lint|pytest|cargo|go\s+(?:build|test)|mvn)\b/i.test(String(t.cmd || ""))) st.verified = true;
+      if (t.name === "check" && /ERGEBNIS: ✓/.test(String(result || ""))) st.checked = true;
+    },
+    /** Hinweis fürs Modell, falls noch nicht geprüft – oder "". Höchstens 3-mal. */
+    nudge(answer, question) {
+      // Anleitung statt Tat: Antwort ohne ein einziges Werkzeug, die dem Nutzer Befehle/Schritte zum Selbermachen gibt
+      // (außer der Nutzer hat ausdrücklich nach einer Erklärung gefragt).
+      const wantsHowTo = /\b(?:wie (?:geht|mache|kann ich|funktioniert)|erklär|anleitung|tutorial|zeig mir wie|how to|explain)\b/i.test(String(question || ""));
+      if (!st.acted && !st.tutorNudged && answer && !wantsHowTo && looksLikeTutorial(answer)) {
+        st.tutorNudged = true;
+        return "Du hast eine Anleitung geschrieben, statt es selbst zu tun. Der Nutzer will das ERGEBNIS, keine Anleitung – du hast vollen Zugriff auf seinen PC. Führe die Schritte jetzt selbst mit deinen Werkzeugen aus (Dateien anlegen, Pakete installieren, bauen, z. B. die .exe erzeugen), prüfe das Ergebnis (Datei existiert, startet) und antworte dann im Antwortformat mit dem Pfad zum fertigen Ergebnis.";
+      }
+      if (st.nudges >= 3) return "";
+      if (st.changed && !st.verified) { st.nudges++; st.verified = true; return "Bevor du fertig bist: Du hast Dateien geändert, aber noch nicht geprüft. Führe jetzt verify aus (oder passende Build-/Test-Befehle), behebe jedes ✗ und antworte erst danach."; }
+      if (st.web && !st.checked) { st.nudges++; st.checked = true; return "Bevor du fertig bist: Du hast an einer Webseite gearbeitet, sie aber nicht im Browser geprüft. Starte sie (serve für statische Seiten, start für Dev-Server/Backends) und prüfe sie mit check. Behebe alles, was check als ✗ meldet (weiße Seite, Konsolenfehler, fehlende Dateien, „Cannot GET /“), prüfe erneut und antworte dann im Antwortformat mit der Adresse."; }
+      return "";
+    },
+  };
+}
+
+
 const TOOL_PROMPT = [
   "Werkzeuge – antworte pro Schritt mit GENAU EINEM Block:",
-  '<tool>{"name":"run","cmd":"..."}</tool>  Shell-Befehl ausführen (Ausgabe läuft live mit)',
+  '<tool>{"name":"run","cmd":"..."}</tool>  Shell-Befehl ausführen und warten, bis er ENDET (Ausgabe läuft live mit). Nicht für Server!',
+  '<tool>{"name":"start","cmd":"npm run dev"}</tool>  Lang laufenden Prozess (Dev-Server, node server.js, Watcher, Bot) im HINTERGRUND starten. Wartet, bis die Adresse (z. B. http://localhost:5173) in der Ausgabe steht, und kehrt dann zurück – der Prozess läuft weiter.',
+  '<tool>{"name":"logs","id":"p1"}</tool>  Ausgabe eines Hintergrundprozesses lesen (ohne id: alle laufenden auflisten)',
+  '<tool>{"name":"stop","id":"p1"}</tool>  Hintergrundprozess beenden ("all" = alle)',
+  '<tool>{"name":"serve","path":"."}</tool>  Eingebauter Webserver für statische Seiten (Ordner mit index.html, z. B. "." oder "dist"). Liefert die Adresse. Kein npx/http-server/Express nötig.',
+  '<tool>{"name":"check","url":"http://localhost:5173"}</tool>  Webseite WIRKLICH prüfen: HTTP-Status, lädt jedes Skript/CSS, Browser-Test mit Konsolenfehlern, erkennt weiße Seiten und „Cannot GET /“, macht (in der App) einen Screenshot. url darf auch ein Pfad sein ("index.html").',
+  '<tool>{"name":"verify"}</tool>  Projekt automatisch prüfen: installiert fehlende Pakete, führt Typecheck, Lint, Build und Tests aus (was es im Projekt gibt) und meldet ✓/✗ je Prüfung mit Fehlerausgabe.',
   '<tool>{"name":"read","path":"..."}</tool>  Datei lesen',
   '<tool>{"name":"edit","path":"...","old":"exakter alter Text","new":"neuer Text"}</tool>  Datei gezielt ändern (bevorzugt! "old" muss genau einmal vorkommen, sonst "all":true)',
   '<tool>{"name":"write","path":"...","content":"..."}</tool>  Neue Datei anlegen oder komplett neu schreiben',
@@ -20,9 +180,36 @@ const TOOL_PROMPT = [
   '<tool>{"name":"ls","path":"."}</tool>  Ordner auflisten',
   '<tool>{"name":"websearch","query":"..."}</tool>  Im Internet suchen (z. B. Doku, Fehlermeldungen)',
   '<tool>{"name":"fetch","url":"https://..."}</tool>  Webseite als Text lesen',
+  '<tool>{"name":"cloud","app":"Name der App"}</tool>  Mythos Cloud verbinden: eigenes Backend (Datenbank) + KI-Gateway (Chat, Streaming, Bilder) für die App, die du baust. Nutze das IMMER, sobald die App Daten speichern oder KI nutzen soll – statt Supabase/Firebase/OpenAI-Keys o. Ä. Legt mythos-cloud.js im Projekt an und erklärt die Nutzung.',
   '<tool>{"name":"todo","items":[{"text":"Schritt","done":false}]}</tool>  Aufgabenliste anlegen/aktualisieren (bei größeren Aufgaben zuerst planen, dann Punkte abhaken; immer die komplette Liste senden)',
+  "Es gibt NUR diese Werkzeuge (plus die unten genannten MCP-/Browser-Werkzeuge, falls welche aufgeführt sind). Erfinde keine Werkzeuge, Connectoren oder MCP-Server. Fehlt etwas (z. B. ein nicht verbundener Connector), sag das dem Nutzer kurz und mach mit dem Rest weiter. Schließe jeden Block mit </tool>.",
   "Nach jedem Werkzeug bekommst du das Ergebnis. Suche erst, statt Dateien blind zu lesen. Ändere bestehende Dateien mit edit statt write.",
-  "Arbeite Schritt für Schritt, bis die Aufgabe erledigt ist, dann antworte normal ohne <tool> (Markdown erlaubt).",
+  "",
+  "SO ARBEITEST DU (gründlich wie ein Senior-Entwickler):",
+  "1. Verstehen: Projekt erkunden (ls, package.json, relevante Dateien lesen), bevor du etwas änderst.",
+  "2. Planen: bei mehr als zwei Schritten zuerst eine todo-Liste.",
+  "3. Bauen: vollständig und lauffähig – keine Platzhalter, kein „TODO“, keine „…“ im Code, keine erfundenen Pakete oder Importe. Neue Pakete wirklich installieren. Jede Datei, auf die du verweist, auch anlegen.",
+  "4. Prüfen (PFLICHT, bevor du „fertig“ sagst): verify ausführen und jedes ✗ beheben. Bei Webseiten/Web-Apps zusätzlich starten (serve für statische Seiten, start für Dev-Server/Backends) und mit check prüfen; Fehler beheben und erneut prüfen, bis check „ERGEBNIS: ✓“ meldet. Behaupte nie, dass etwas funktioniert, das du nicht geprüft hast.",
+  "5. Erst dann die Abschlussantwort.",
+  "",
+  "HANDELN STATT ERKLÄREN: Du hast vollen Zugriff auf den PC des Nutzers. Wenn er etwas haben will (eine .exe, ein Programm, eine Webseite, ein Skript, eine Datei, ein Build), dann BAUST du es selbst mit deinen Werkzeugen und lieferst das fertige Ergebnis mit Pfad – schreibe NIE nur eine Anleitung, Befehle zum Abtippen oder „so geht's“. Fehlt ein Programm (z. B. pyinstaller, electron-builder, pkg, dotnet), installiere es selbst. Anleitungen nur, wenn der Nutzer ausdrücklich danach fragt.",
+  "Beispiele: „mach eine exe“ → Python: run \"pip install pyinstaller\", dann run \"pyinstaller --onefile --noconfirm main.py\" → dist\\main.exe; Node-Skript: run \"npx --yes @yao-pkg/pkg . --targets node18-win-x64 --output dist/app.exe\"; Electron-App: run \"npx --yes electron-builder --win portable\"; C#: run \"dotnet publish -c Release -r win-x64 --self-contained -p:PublishSingleFile=true\". Danach mit ls/run prüfen, dass die .exe existiert (und wenn möglich startet), und den vollen Pfad nennen.",
+  "",
+  "SERVER: Dev-Server, „npm start“, „node server.js“, Watcher u. Ä. NIE mit run starten – run wartet, bis der Befehl endet, und ein Server endet nie. Immer start (oder serve) nutzen. Der Server läuft nach deiner Antwort weiter, damit der Nutzer die Seite öffnen kann.",
+  "",
+  "WEBSEITEN RICHTIG AUFSETZEN (gegen weiße Seiten und „Cannot GET /“):",
+  "- Einfache Webseite/Spiel ohne Framework: index.html direkt im Projektordner, CSS/JS daneben mit relativen Pfaden (./style.css, ./script.js), normales <script src> ohne import von npm-Paketen. Starten mit serve. Kein Express, kein Build nötig.",
+  "- React/Vue/Svelte/TypeScript: als Vite-Projekt (package.json mit vite, index.html im Projektroot mit <script type=\"module\" src=\"/src/main.tsx\">, <div id=\"root\">), dann run \"npm install\", dann start \"npm run dev\". Eine index.html, die .tsx/.ts/.jsx lädt, NIE direkt öffnen oder mit serve ausliefern – das ergibt eine weiße Seite. Fertiger Build: run \"npm run build\", dann serve \"dist\".",
+  "- Eigener Node-Server (Express o. Ä.): MUSS „/“ beantworten – app.use(express.static(path.join(__dirname, \"public\"))) mit public/index.html, oder app.get(\"/\", …). Port = process.env.PORT || 3000, beim Start die volle Adresse ausgeben: console.log(\"Server läuft: http://localhost:\" + port).",
+  "- Weiße Seite heißt fast immer: JavaScript-Fehler, eine Datei lädt nicht (404) oder falscher Pfad. check zeigt dir Konsolenfehler und fehlende Dateien – behebe die Ursache.",
+  "",
+  "ANTWORTEN: Vor einem Werkzeug höchstens ein kurzer Satz. Die Abschlussantwort (ohne Werkzeug) knapp und strukturiert in Markdown:",
+  "### ✅ Ergebnis – ein bis zwei Sätze, was jetzt geht",
+  "**Geändert** – Liste: `datei` – was",
+  "**Geprüft** – Liste mit ✓/✗: was du ausgeführt bzw. angesehen hast",
+  "**Ansehen/Starten** – Adresse (läuft schon) oder Befehl, falls relevant",
+  "**Offen** – nur, wenn etwas fehlt oder der Nutzer etwas tun muss",
+  "Keine langen Fließtexte, keinen Code wiederholen. Bei reinen Fragen ohne Codeänderung einfach direkt und gegliedert antworten.",
 ].join("\n");
 
 // Modelle, die v1-messages versteht (siehe mapModel dort).
@@ -71,7 +258,7 @@ function streamActivity(full) {
   return "🔧 bereitet " + (name || "Werkzeug") + " vor…";
 }
 const GOAL_NUDGE = "Das Ziel ist noch nicht als erreicht gemeldet. Der Auftraggeber ist nicht da – gib bei Problemen nicht auf, sondern versuche einen anderen Weg, nutze websearch/fetch für Lösungen und arbeite selbstständig weiter, ohne Rückfragen. Wenn es wirklich vollständig erledigt und geprüft ist, schreibe ZIEL ERREICHT.";
-const SUMMARY_PROMPT = "Fasse jetzt kurz auf Deutsch zusammen, OHNE Werkzeuge:\n**Geändert:** welche Dateien und was\n**Geklappt:** was funktioniert (und wie geprüft)\n**Offen:** was noch fehlt oder beachtet werden muss\nMaximal 12 Zeilen.";
+const SUMMARY_PROMPT = "Fasse jetzt kurz auf Deutsch zusammen, OHNE Werkzeuge, genau in diesem Format:\n### ✅ Ergebnis\nein bis zwei Sätze\n**Geändert** – `datei` – was\n**Geprüft** – ✓/✗ je Prüfung (verify, check, Tests)\n**Ansehen/Starten** – Adresse oder Befehl (falls relevant)\n**Offen** – was noch fehlt (nur falls etwas fehlt)\nMaximal 15 Zeilen.";
 
 const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", "out", "coverage", ".cache", "vendor", "__pycache__", ".venv", "venv", "target"]);
 
@@ -409,6 +596,427 @@ async function pushNotify(url, title, message) {
   } catch { return false; }
 }
 
+// ---------- Prüfen, Hintergrund-Prozesse, eingebauter Webserver ----------
+// Braucht zusätzlich `spawn`, `exec` (child_process) und `http` im umgebenden Code.
+
+const stripAnsi = (s) => String(s || "").replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\x1b\][^\x07]*\x07/g, "");
+const tailText = (s, n) => { s = stripAnsi(s).trim(); return s.length > n ? "…" + s.slice(-n) : s; };
+function killProc(p) {
+  if (!p || p.exitCode != null) return;
+  try {
+    if (process.platform === "win32") exec("taskkill /pid " + p.pid + " /T /F");
+    else { try { process.kill(-p.pid, "SIGTERM"); } catch { p.kill("SIGTERM"); } }
+  } catch { /* schon beendet */ }
+}
+
+
+
+/** Lokale Adresse aus Server-Ausgabe lesen („Local: http://localhost:5173/“, „listening on port 3000“ …). */
+function findLocalUrl(out) {
+  const s = stripAnsi(out);
+  const m = s.match(/https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1?\])(?::\d+)?(?:\/[^\s"'<>)\]]*)?/i);
+  if (m) return m[0].replace(/0\.0\.0\.0|\[::1?\]/, "localhost").replace(/[.,;:]+$/, "");
+  const p = s.match(/(?:listening|running|started|läuft|serving|server|bound)[^\n]{0,40}?\bport\s*:?\s*(\d{2,5})\b/i) || s.match(/\bport\s*:?\s*(\d{4,5})\b[^\n]{0,30}(?:listening|running|ready|läuft)/i);
+  return p ? "http://localhost:" + p[1] + "/" : "";
+}
+
+const BG = new Map(); let bgSeq = 0;
+/** Langlaufenden Befehl im Hintergrund starten. Wartet, bis eine Adresse erscheint, der Prozess endet oder nichts mehr passiert. */
+function bgStart(cmd, cwd, opts) {
+  opts = opts || {};
+  // Derselbe Befehl im selben Ordner läuft schon → erst beenden (sonst „Port belegt“).
+  for (const j of BG.values()) if (j.cmd === cmd && j.cwd === cwd && j.code == null) { killProc(j.p); BG.delete(j.id); }
+  return new Promise((resolve) => {
+    const id = "p" + (++bgSeq);
+    let p;
+    try {
+      p = spawn(cmd, { cwd: cwd || undefined, shell: true, windowsHide: true, detached: process.platform !== "win32",
+        env: { ...process.env, BROWSER: "none", FORCE_COLOR: "0", NO_COLOR: "1", ...(opts.env || {}) } });
+    } catch (e) { resolve({ result: "FEHLER: " + e.message }); return; }
+    const job = { id, cmd, cwd, p, out: "", url: "", code: null, t0: Date.now(), last: Date.now() };
+    BG.set(id, job);
+    let done = false;
+    const max = Math.min(300, Math.max(5, +opts.wait || 90)) * 1000;
+    const finish = () => {
+      if (done) return; done = true; clearInterval(timer);
+      const out = tailText(job.out, 3000);
+      if (job.code != null) {
+        BG.delete(id);
+        const busy = /EADDRINUSE|address already in use|port \d+ is (?:already )?in use/i.test(job.out);
+        resolve({ result: (job.code === 0 ? "Befehl ist fertig (Exit 0) – er lief nicht dauerhaft weiter.\n" : "FEHLER: Prozess beendet mit Exit " + job.code + ".\n") +
+          (busy ? "Der Port ist belegt – stoppe den alten Prozess (logs/stop) oder nimm einen anderen Port.\n" : "") + (out || "(keine Ausgabe)"), code: job.code });
+        return;
+      }
+      resolve({ id, url: job.url, result: (job.url
+        ? "✓ Läuft im Hintergrund (id " + id + "): " + job.url + "\nAls Nächstes: Seite mit check prüfen."
+        : "Läuft im Hintergrund (id " + id + "), noch keine Adresse in der Ausgabe erkannt. Mit logs nachsehen.") +
+        "\nAusgabe ansehen: {\"name\":\"logs\",\"id\":\"" + id + "\"} · beenden: {\"name\":\"stop\",\"id\":\"" + id + "\"}\n\nAusgabe bisher:\n" + (out || "(keine)") });
+    };
+    const on = (dec) => (d) => {
+      const s = dec(d); job.out += s; job.last = Date.now();
+      if (job.out.length > 200000) job.out = job.out.slice(-100000);
+      if (!done && opts.onChunk) opts.onChunk(s);
+      if (!job.url) { const u = findLocalUrl(job.out); if (u) { job.url = u; setTimeout(finish, 1200); } }
+    };
+    p.stdout.on("data", on(outputDecoder())); p.stderr.on("data", on(outputDecoder()));
+    p.on("error", (e) => { job.out += "\nFEHLER: " + e.message; });
+    p.on("close", (code) => { job.code = code == null ? 1 : code; setTimeout(finish, 100); });
+    const timer = setInterval(() => {
+      const el = Date.now() - job.t0;
+      if (el > max || (el > 25000 && Date.now() - job.last > 25000)) finish();
+    }, 500);
+  });
+}
+function bgLogs(id) {
+  if (!id) {
+    const list = [...BG.values()].filter((j) => j.code == null);
+    return list.length ? "Laufende Hintergrundprozesse:\n" + list.map((j) => "- " + j.id + ": " + j.cmd + (j.url ? " → " + j.url : "") + " (seit " + Math.round((Date.now() - j.t0) / 1000) + " s)").join("\n") : "Keine Hintergrundprozesse.";
+  }
+  const j = BG.get(String(id));
+  if (!j) return "FEHLER: Kein Hintergrundprozess mit id " + id + ". " + bgLogs("");
+  return (j.code == null ? "läuft" : "beendet (Exit " + j.code + ")") + " · " + j.cmd + (j.url ? " · " + j.url : "") + "\n" + (tailText(j.out, 6000) || "(keine Ausgabe)");
+}
+function bgStop(id) {
+  const list = id === "all" || !id ? [...BG.values()] : [BG.get(String(id))].filter(Boolean);
+  if (!list.length) return "FEHLER: Kein Hintergrundprozess mit id " + id + ".";
+  list.forEach((j) => { killProc(j.p); BG.delete(j.id); });
+  return "Beendet: " + list.map((j) => j.id + " (" + j.cmd + ")").join(", ");
+}
+function stopAllBackground() {
+  for (const j of BG.values()) killProc(j.p);
+  BG.clear();
+  for (const s of SERVERS.values()) try { s.server.close(); } catch { /* egal */ }
+  SERVERS.clear();
+}
+process.on("exit", stopAllBackground);
+
+// ---------- Eingebauter Webserver (für statische Seiten) ----------
+const MIME = { html: "text/html; charset=utf-8", htm: "text/html; charset=utf-8", css: "text/css; charset=utf-8", js: "text/javascript; charset=utf-8", mjs: "text/javascript; charset=utf-8",
+  json: "application/json; charset=utf-8", map: "application/json", svg: "image/svg+xml", png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp", avif: "image/avif",
+  ico: "image/x-icon", woff: "font/woff", woff2: "font/woff2", ttf: "font/ttf", otf: "font/otf", mp3: "audio/mpeg", wav: "audio/wav", ogg: "audio/ogg", mp4: "video/mp4", webm: "video/webm",
+  txt: "text/plain; charset=utf-8", xml: "application/xml", pdf: "application/pdf", wasm: "application/wasm", webmanifest: "application/manifest+json" };
+const SERVERS = new Map();
+/** Braucht diese index.html einen Build-Schritt (TS/JSX/Vite)? */
+const needsBundler = (html) => /<script[^>]+src=["'][^"']*\.(?:tsx?|jsx|vue|svelte)["']/i.test(html);
+function listenFree(server, port) {
+  return new Promise((res, rej) => {
+    const tryPort = (p) => {
+      server.once("error", (e) => (e.code === "EADDRINUSE" && p < port + 30 ? tryPort(p + 1) : rej(e)));
+      server.listen(p, "127.0.0.1", () => res(server.address().port));
+    };
+    tryPort(port);
+  });
+}
+async function serveDir(root, rel) {
+  let target = path.resolve(root, rel || ".");
+  if (!fs.existsSync(target)) return { result: "FEHLER: Nicht gefunden: " + (rel || ".") };
+  let page = "";
+  if (fs.statSync(target).isFile()) { page = path.basename(target); target = path.dirname(target); }
+  if (!page && !fs.existsSync(path.join(target, "index.html"))) {
+    const sub = ["dist", "build", "public", "out", "www", "site", "docs"].find((d) => fs.existsSync(path.join(target, d, "index.html")));
+    const pkg = readText(path.join(target, "package.json")) || "";
+    if (!sub) return { result: "FEHLER: In „" + (rel || ".") + "“ gibt es keine index.html – darum zeigt ein Server dort „Cannot GET /“. Lege eine index.html an" + (pkg ? " oder starte das Projekt mit start (z. B. npm run dev)" : "") + "." };
+    if (/"(?:vite|react-scripts|next|@vue\/cli-service|parcel)"/.test(pkg) && sub === "public") return { result: "FEHLER: Das ist ein Projekt mit Build-Schritt. Starte es mit start \"npm run dev\" oder baue es (npm run build) und nutze dann serve \"dist\"." };
+    target = path.join(target, sub);
+  }
+  const indexHtml = readText(path.join(target, page || "index.html")) || "";
+  if (needsBundler(indexHtml)) return { result: "FEHLER: " + (page || "index.html") + " lädt TypeScript/JSX direkt (z. B. /src/main.tsx). Das kann ein Browser nicht ausführen → weiße Seite. Nutze start \"npm run dev\" (Vite) oder npm run build und dann serve \"dist\"." };
+  const dir = target;
+  let srv = SERVERS.get(dir);
+  if (!srv) {
+    const server = http.createServer((req, res) => {
+      let p; try { p = decodeURIComponent(new URL(req.url, "http://x").pathname); } catch { p = "/"; }
+      let f = path.join(dir, p);
+      if (path.relative(dir, f).startsWith("..")) { res.writeHead(403); res.end("Verboten"); return; }
+      try { if (fs.statSync(f).isDirectory()) f = path.join(f, "index.html"); } catch { /* gibt es nicht */ }
+      // Einzelseiten-Apps: unbekannte Pfade ohne Dateiendung → index.html.
+      if (!fs.existsSync(f) && !path.extname(p) && fs.existsSync(path.join(dir, "index.html"))) f = path.join(dir, "index.html");
+      fs.readFile(f, (err, data) => {
+        if (err) { res.writeHead(404, { "content-type": "text/plain; charset=utf-8" }); res.end("404 – Datei nicht gefunden: " + p); return; }
+        res.writeHead(200, { "content-type": MIME[path.extname(f).slice(1).toLowerCase()] || "application/octet-stream", "cache-control": "no-store" });
+        res.end(data);
+      });
+    });
+    let port;
+    try { port = await listenFree(server, 5500); } catch (e) { return { result: "FEHLER: Webserver konnte nicht starten: " + e.message }; }
+    srv = { server, url: "http://127.0.0.1:" + port + "/" };
+    SERVERS.set(dir, srv);
+  }
+  const url = srv.url + (page && page !== "index.html" ? encodeURI(page) : "");
+  return { url, result: "✓ Webserver läuft: " + url + " (Ordner: " + (path.relative(root, dir) || ".") + ", Dateien werden bei jedem Aufruf frisch gelesen)\nAls Nächstes: Seite mit check prüfen." };
+}
+
+// ---------- Seite prüfen (HTTP + alle Skripte/CSS) ----------
+async function getLocal(url, ms, method, accept) {
+  const tries = [url];
+  if (/\/\/localhost\b/i.test(url)) tries.push(url.replace(/\/\/localhost\b/i, "//127.0.0.1"), url.replace(/\/\/localhost\b/i, "//[::1]"));
+  let last;
+  for (const u of tries) {
+    const ctl = new AbortController(); const to = setTimeout(() => ctl.abort(), ms || 15000);
+    try {
+      const r = await fetch(u, { method: method || "GET", redirect: "follow", signal: ctl.signal, headers: { "user-agent": WEB_UA, accept: accept || "text/html,*/*" } });
+      const text = method === "HEAD" ? "" : Buffer.from(await r.arrayBuffer()).subarray(0, 3e6).toString("utf8");
+      return { ok: r.ok, status: r.status, type: r.headers.get("content-type") || "", text, url: r.url || u };
+    } catch (e) { last = e; } finally { clearTimeout(to); }
+  }
+  throw last;
+}
+/** HTTP-Prüfung einer Seite. → { lines, fail, warn, url, html, reachable } */
+async function httpPageCheck(url) {
+  const lines = []; let fail = 0, warn = 0;
+  let r;
+  try { r = await getLocal(url, 20000); }
+  catch (e) {
+    const why = e.name === "AbortError" ? "Zeitüberschreitung" : (e.cause && e.cause.code) || e.message;
+    return { reachable: false, fail: 1, warn: 0, url, html: "", lines: ["✗ Nicht erreichbar (" + why + "). Läuft der Server? Mit start/serve starten und die Adresse aus der Ausgabe nehmen (logs zeigt sie)."] };
+  }
+  const isHtml = /html/i.test(r.type) || /^\s*<(?:!doctype|html)/i.test(r.text);
+  lines.push((r.ok ? "✓" : "✗") + " HTTP " + r.status + " · " + (r.type.split(";")[0] || "?") + " · " + (r.text.length / 1024).toFixed(1).replace(".", ",") + " KB" + (r.url.replace(/\/$/, "") !== url.replace(/\/$/, "") ? " · nach Weiterleitung: " + r.url : ""));
+  if (!r.ok) {
+    fail++;
+    if (/Cannot (?:GET|POST) \//i.test(r.text)) lines.push("✗ „" + (r.text.match(/Cannot \w+ \/[^\s<]*/) || ["Cannot GET /"])[0] + "“: Der Server (meist Express) hat für diese Adresse keine Route und liefert keine index.html aus. Lösung: app.use(express.static(path.join(__dirname, \"public\"))) mit public/index.html, oder app.get(\"/\", …) – für eine reine Webseite ohne Backend einfach das serve-Werkzeug nutzen.");
+    else lines.push("Antwort: " + htmlToText(r.text).slice(0, 400));
+    return { reachable: true, status: r.status, fail, warn, url: r.url, html: r.text, lines };
+  }
+  if (!isHtml) return { reachable: true, status: r.status, fail, warn, url: r.url, html: "", lines: lines.concat(["ℹ Keine HTML-Seite – Inhalt: " + r.text.slice(0, 300)]) };
+  const html = r.text;
+  const title = (html.match(/<title[^>]*>([\s\S]*?)<\/title>/i) || [])[1];
+  if (title) lines.push("Titel: „" + decodeEntities(title.trim()).slice(0, 80) + "“");
+  if (/file:\/\/|(?:src|href)=["'][a-z]:\\/i.test(html)) { fail++; lines.push("✗ Die Seite verweist auf lokale Dateipfade (file:// oder C:\\…) – im Browser über http lädt das nicht. Relative Pfade nutzen (./style.css)."); }
+  if (needsBundler(html) && !/@vite\/client|\/@react-refresh/.test(html)) { fail++; lines.push("✗ index.html lädt TypeScript/JSX direkt (.tsx/.ts/.jsx) ohne Dev-Server → weiße Seite. Mit start \"npm run dev\" (Vite) starten oder bauen und dist ausliefern."); }
+  // Alle eingebundenen Skripte und Stylesheets laden.
+  const refs = [];
+  html.replace(/<script\b[^>]*\bsrc=["']([^"']+)["'][^>]*>/gi, (_m, s) => refs.push(["Skript", s]));
+  html.replace(/<link\b[^>]*>/gi, (tag) => { if (/rel=["'](?:stylesheet|modulepreload)["']/i.test(tag)) { const h = tag.match(/href=["']([^"']+)["']/i); if (h) refs.push([/stylesheet/i.test(tag) ? "CSS" : "Modul", h[1]]); } });
+  const base = new URL(r.url);
+  let okRefs = 0;
+  for (const [kind, ref] of refs.slice(0, 30)) {
+    let u; try { u = new URL(ref, base); } catch { continue; }
+    if (u.host !== base.host) continue;
+    try {
+      const a = await getLocal(u.href, 15000, "GET", kind === "CSS" ? "text/css,*/*;q=0.1" : "*/*");
+      const isJs = kind !== "CSS";
+      if (!a.ok) { fail++; lines.push("✗ " + kind + " " + u.pathname + " → HTTP " + a.status + " (Datei fehlt oder Pfad falsch)"); }
+      else if (/html/i.test(a.type) && !/html/i.test(u.pathname)) { fail++; lines.push("✗ " + kind + " " + u.pathname + " → liefert HTML statt " + (isJs ? "JavaScript" : "CSS") + " (Datei fehlt, Server schickt index.html)"); }
+      else okRefs++;
+    } catch (e) { fail++; lines.push("✗ " + kind + " " + u.pathname + " → " + e.message); }
+  }
+  if (refs.length) lines.push((okRefs === refs.length ? "✓ " : "") + okRefs + "/" + refs.length + " eingebundene Skripte/CSS laden");
+  const bodyText = htmlToText((html.match(/<body[^>]*>([\s\S]*)<\/body>/i) || [, html])[1]);
+  if (bodyText.length < 3) {
+    const hasScripts = /<script\b/i.test(html);
+    if (!hasScripts) { fail++; lines.push("✗ Die Seite ist leer: kein sichtbarer Text und keine Skripte."); }
+    else { warn++; lines.push("ℹ Der Inhalt entsteht erst per JavaScript (leeres <body>/#root) – ob er wirklich erscheint, zeigt nur der Browser-Test."); }
+  } else lines.push("✓ Sichtbarer Text im HTML: " + bodyText.length + " Zeichen – „" + bodyText.replace(/\s+/g, " ").slice(0, 120) + "“");
+  return { reachable: true, status: r.status, fail, warn, url: r.url, html, lines };
+}
+
+/** Projekt automatisch prüfen: fehlende Pakete installieren, Typecheck, Lint, Build, Tests. */
+function runCapture(cmd, cwd, opts) {
+  opts = opts || {};
+  return new Promise((res) => {
+    let out = "";
+    const p = spawn(cmd, { cwd, shell: true, windowsHide: true, env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1", BROWSER: "none", ...(opts.env || {}) } });
+    if (opts.track) opts.track(p);
+    const on = (dec) => (d) => { const s = dec(d); out += s; if (out.length > 200000) out = out.slice(-100000); if (opts.onChunk) opts.onChunk(s); };
+    p.stdout.on("data", on(outputDecoder())); p.stderr.on("data", on(outputDecoder()));
+    const to = setTimeout(() => { out += "\n[Zeitüberschreitung – abgebrochen]"; killProc(p); }, opts.timeout || 600000);
+    p.on("error", (e) => { out += "\nFEHLER: " + e.message; });
+    p.on("close", (code) => { clearTimeout(to); res({ code: code == null ? 1 : code, out }); });
+  });
+}
+function detectChecks(root) {
+  const has = (f) => fs.existsSync(path.join(root, f));
+  const checks = [];
+  let pkg = null; try { pkg = JSON.parse(readText(path.join(root, "package.json")) || "null"); } catch { pkg = null; }
+  if (pkg) {
+    const pm = has("pnpm-lock.yaml") ? "pnpm" : has("yarn.lock") ? "yarn" : has("bun.lockb") || has("bun.lock") ? "bun" : "npm";
+    const run = (s) => (pm === "npm" ? "npm run " + s : pm + " run " + s);
+    const sc = pkg.scripts || {};
+    const deps = Object.keys(Object.assign({}, pkg.dependencies, pkg.devDependencies));
+    if (deps.length && !has("node_modules")) checks.push({ label: "Pakete installieren", cmd: pm + " install", fatal: true });
+    const tc = ["typecheck", "type-check", "tsc", "check-types"].find((s) => sc[s]);
+    if (tc) checks.push({ label: "Typecheck", cmd: run(tc) });
+    else if (has("tsconfig.json") && !/\btsc\b/.test(sc.build || "") && (deps.includes("typescript") || has("node_modules/typescript"))) {
+      const ts = readText(path.join(root, "tsconfig.json")) || "";
+      checks.push({ label: "Typecheck", cmd: /"references"\s*:/.test(ts) ? "npx tsc -b" : "npx tsc --noEmit" });
+    }
+    if (sc.lint) checks.push({ label: "Lint", cmd: run("lint"), soft: true });
+    if (sc.build) checks.push({ label: "Build", cmd: run("build") });
+    if (sc.test && !/no test specified/i.test(sc.test)) checks.push({ label: "Tests", cmd: pm === "npm" ? "npm test" : pm + " test", env: { CI: "1" } });
+    if (!sc.build && !sc.test) {
+      const main = [pkg.main, "index.js", "server.js", "app.js"].find((f) => f && has(f) && /\.c?js$/.test(f));
+      if (main) checks.push({ label: "Syntax " + main, cmd: "node --check " + JSON.stringify(main) });
+    }
+  }
+  const py = has("requirements.txt") || has("pyproject.toml") || has("setup.py") || (!pkg && fs.readdirSync(root).some((f) => /\.py$/.test(f)));
+  if (py) {
+    const pyc = process.platform === "win32" ? "python" : "python3";
+    checks.push({ label: "Python-Syntax", cmd: pyc + " -m compileall -q -x \"(node_modules|venv|\\.venv|__pycache__)\" ." });
+    if (has("pytest.ini") || has("conftest.py") || has("tests")) checks.push({ label: "Tests", cmd: pyc + " -m pytest -q" });
+  }
+  if (has("Cargo.toml")) checks.push({ label: "Build", cmd: "cargo build" }, { label: "Tests", cmd: "cargo test" });
+  if (has("go.mod")) checks.push({ label: "Build", cmd: "go build ./..." }, { label: "Tests", cmd: "go test ./..." });
+  if (has("pom.xml")) checks.push({ label: "Build", cmd: "mvn -q -DskipTests package" });
+  return { checks, pkg };
+}
+/** Statische Seiten: verlinkte lokale Dateien müssen existieren. */
+function staticRefCheck(root) {
+  const pages = [];
+  const walk = (dir, depth) => {
+    let entries; try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) { if (depth < 3 && !SKIP_DIRS.has(e.name) && !e.name.startsWith(".")) walk(full, depth + 1); }
+      else if (/\.html?$/i.test(e.name) && pages.length < 40) pages.push(full);
+    }
+  };
+  walk(root, 0);
+  const missing = [];
+  for (const f of pages) {
+    const html = readText(f) || "";
+    html.replace(/<(?:script|img|source|link|iframe)\b[^>]*\b(?:src|href)=["']([^"'#?]+)/gi, (_m, ref) => {
+      if (/^(?:[a-z]+:|\/\/|data:|\$|\{)/i.test(ref)) return;
+      const tgt = ref.startsWith("/") ? path.join(root, ref) : path.join(path.dirname(f), ref);
+      if (!fs.existsSync(tgt) && !/\/src\/main\.\w+$/.test(ref)) missing.push(path.relative(root, f).split(path.sep).join("/") + " → " + ref);
+    });
+  }
+  return { pages: pages.length, missing };
+}
+async function verifyProject(root, opts) {
+  opts = opts || {};
+  const { checks, pkg } = detectChecks(root);
+  const lines = []; let fail = 0;
+  for (const c of checks) {
+    if (opts.onChunk) opts.onChunk("\n▶ " + c.label + ": " + c.cmd + "\n");
+    const r = await runCapture(c.cmd, root, { onChunk: opts.onChunk, track: opts.track, env: c.env, timeout: 900000 });
+    if (r.code === 0) lines.push("✓ " + c.label + " (" + c.cmd + ")");
+    else {
+      if (!c.soft) fail++;
+      lines.push((c.soft ? "⚠ " : "✗ ") + c.label + " (" + c.cmd + ") – Exit " + r.code + (c.soft ? " (Lint-Hinweise; beheben, wenn sie deine Änderungen betreffen)" : "") + ":\n" + tailText(r.out, c.soft ? 1500 : 3500).split("\n").map((l) => "    " + l).join("\n"));
+      if (c.fatal) break;
+    }
+  }
+  const st = staticRefCheck(root);
+  if (st.missing.length) { fail++; lines.push("✗ Fehlende Dateien in HTML-Seiten:\n" + st.missing.slice(0, 20).map((m) => "    " + m).join("\n")); }
+  else if (st.pages && !pkg) lines.push("✓ " + st.pages + " HTML-Seite(n): alle verlinkten lokalen Dateien vorhanden");
+  if (!lines.length) return { result: "Keine automatischen Prüfungen erkannt (kein package.json-Skript, keine Tests, keine HTML-Seiten). Prüfe selbst mit run (z. B. das Programm einmal ausführen)." };
+  const web = st.pages || (pkg && /"(?:vite|react|react-dom|vue|svelte|next|express|astro)"/.test(JSON.stringify(Object.assign({}, pkg.dependencies, pkg.devDependencies))));
+  return { fail, result: "Prüfbericht:\n" + lines.join("\n") + "\n\n" + (fail ? "ERGEBNIS: ✗ " + fail + " Prüfung(en) fehlgeschlagen – Ursache beheben und verify erneut ausführen." : "ERGEBNIS: ✓ alle Prüfungen bestanden.") +
+    (web ? "\nDas ist ein Web-Projekt: starte es (serve bzw. start) und prüfe die Seite mit check." : "") };
+}
+
+// ---------- Werkzeuge start/logs/stop/serve/verify/check (gemeinsamer Teil) ----------
+const DEV_TOOLS = ["start", "logs", "stop", "serve", "verify", "check"];
+const isDevTool = (t) => DEV_TOOLS.includes(t.name);
+/** Ziel für check: Adresse, Datei/Ordner (→ eingebauter Webserver) oder zuletzt gestarteter Server. */
+async function checkTarget(t, root) {
+  let url = String(t.url || t.path || "").trim();
+  if (!url) {
+    const job = [...BG.values()].reverse().find((j) => j.url && j.code == null);
+    const srv = [...SERVERS.values()].pop();
+    url = (job && job.url) || (srv && srv.url) || "";
+    if (!url) return { error: "FEHLER: Keine Adresse angegeben und kein laufender Server. Erst serve/start, dann check mit \"url\"." };
+  }
+  if (!/^https?:\/\//i.test(url)) {
+    if (/^(?:localhost|127\.0\.0\.1)(?::\d+)?/i.test(url)) url = "http://" + url;
+    else { const s = await serveDir(root, url.replace(/^file:\/\/\/?/i, "")); if (!s.url) return { error: s.result }; url = s.url; }
+  }
+  return { url };
+}
+/** Prüfbericht aus HTTP-Prüfung h und (optional) Browser-Test rv = renderVerdict(…). */
+function checkReport(url, h, rv, note) {
+  const lines = h.lines.concat(rv ? ["", "Browser-Test (echt gerendert):"].concat(rv.lines) : note ? [note] : []);
+  const fail = h.fail + (rv ? rv.fail : 0);
+  return "Seitenprüfung " + url + "\n" + lines.join("\n") + "\n\n" + (fail
+    ? "ERGEBNIS: ✗ Probleme gefunden – Ursache beheben und erneut prüfen."
+    : rv ? "ERGEBNIS: ✓ Seite lädt ohne Fehler und zeigt Inhalt." : "ERGEBNIS: ✓ Seite antwortet, alle Dateien laden.");
+}
+/** Muss die Seite noch im Browser gerendert werden? (erreichbar und HTML) */
+const wantsRender = (r) => !!(r && r.http && r.http.reachable && r.http.html && r.http.status < 400);
+/** opts: { onChunk, track } – Live-Ausgabe und Abbrechen der Oberfläche. */
+async function devTool(t, root, opts) {
+  opts = opts || {};
+  try {
+    if (t.name === "start") {
+      if (!t.cmd) return { result: 'FEHLER: "cmd" fehlt.' };
+      return await bgStart(String(t.cmd), root, { onChunk: opts.onChunk, wait: t.wait });
+    }
+    if (t.name === "logs") return { result: bgLogs(t.id) };
+    if (t.name === "stop") return { result: bgStop(t.id) };
+    if (t.name === "serve") return await serveDir(root, t.path);
+    if (t.name === "verify") return await verifyProject(root, opts);
+    if (t.name === "check") {
+      const tg = await checkTarget(t, root);
+      if (tg.error) return { result: tg.error };
+      const h = await httpPageCheck(tg.url);
+      return { url: tg.url, http: h, result: checkReport(tg.url, h) };
+    }
+  } catch (e) { return { result: "FEHLER: " + e.message }; }
+  return { result: "Unbekanntes Werkzeug: " + t.name };
+}
+
+// ---------- Browser-Test ohne Fenster (CLI): installiertes Chrome/Edge/Chromium headless ----------
+function findChrome() {
+  const env = process.env.MYTHOS_CHROME || process.env.CHROME_PATH;
+  const pf = [process.env["PROGRAMFILES"], process.env["PROGRAMFILES(X86)"], process.env.LOCALAPPDATA].filter(Boolean);
+  const list = (env ? [env] : []).concat(process.platform === "win32"
+    ? pf.flatMap((b) => [b + "\\Google\\Chrome\\Application\\chrome.exe", b + "\\Microsoft\\Edge\\Application\\msedge.exe", b + "\\BraveSoftware\\Brave-Browser\\Application\\brave.exe"])
+    : process.platform === "darwin"
+      ? ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge", "/Applications/Chromium.app/Contents/MacOS/Chromium"]
+      : ["/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/chromium", "/usr/bin/chromium-browser", "/usr/bin/microsoft-edge", "/snap/bin/chromium"]);
+  return list.find((f) => { try { return fs.statSync(f).isFile(); } catch { return false; } }) || "";
+}
+function chromeRun(bin, args, ms) {
+  return new Promise((res) => {
+    let out = "", err = "";
+    const p = spawn(bin, args, { windowsHide: true });
+    const to = setTimeout(() => killProc(p), ms);
+    p.stdout.on("data", (d) => { out += d; }); p.stderr.on("data", (d) => { err += d; if (err.length > 400000) err = err.slice(-200000); });
+    p.on("error", (e) => { clearTimeout(to); res({ out, err: err + e.message, code: 1 }); });
+    p.on("close", (code) => { clearTimeout(to); res({ out, err, code }); });
+  });
+}
+/** Seite in echtem Chrome rendern: sichtbarer Text, Konsolenfehler, Screenshot. null = kein Browser gefunden. */
+async function headlessRender(url) {
+  const bin = findChrome();
+  if (!bin) return null;
+  const tmp = path.join(process.env.TEMP || process.env.TMPDIR || "/tmp", "mythos-check-" + process.pid);
+  try { fs.mkdirSync(tmp, { recursive: true }); } catch { /* egal */ }
+  const shot = path.join(tmp, "shot.png");
+  const base = ["--headless=new", "--disable-gpu", "--no-first-run", "--no-default-browser-check", "--hide-scrollbars", "--user-data-dir=" + path.join(tmp, "profil"),
+    "--enable-logging=stderr", "--v=0", "--virtual-time-budget=5000", "--window-size=1280,800"];
+  if (process.platform === "linux" && process.getuid && process.getuid() === 0) base.push("--no-sandbox");
+  const dom = await chromeRun(bin, base.concat(["--dump-dom", url]), 45000);
+  try { fs.rmSync(shot, { force: true }); } catch { /* egal */ }
+  await chromeRun(bin, base.concat(["--screenshot=" + shot, url]), 45000);
+  const errors = [];
+  for (const m of dom.err.matchAll(/CONSOLE[:(]\d+\)?\]\s*"([^\n]*?)",\s*source:\s*(\S*)\s*\((\d+)\)/g)) {
+    const msg = m[1] + (m[2] ? " (" + m[2].split("/").pop() + ":" + m[3] + ")" : "");
+    if (!/favicon\.ico/.test(msg) && !errors.includes(msg) && /error|uncaught|failed|refused|not defined|cannot|unexpected|typeerror|syntaxerror|404|500/i.test(msg)) errors.push(msg);
+  }
+  const html = dom.out || "";
+  const body = (html.match(/<body[^>]*>([\s\S]*)<\/body>/i) || [, html])[1];
+  const text = htmlToText(body);
+  const vis = (body.match(/<(?:img|svg|canvas|video|button|input|iframe)\b/gi) || []).length;
+  let image = null;
+  try { const b = fs.readFileSync(shot); if (b.length > 2000) image = { media_type: "image/png", data: b.toString("base64") }; } catch { /* kein Screenshot */ }
+  return { ok: !!html, browser: path.basename(bin), title: (html.match(/<title[^>]*>([\s\S]*?)<\/title>/i) || [])[1] || "", text: text.length, sample: text.replace(/\s+/g, " ").slice(0, 200), vis, errors, image, shot: image ? shot : "" };
+}
+/** Browser-Ergebnis in Prüfzeilen übersetzen. r = { text, vis, errors, failed?, overlay?, sample } */
+function renderVerdict(r) {
+  const lines = []; let fail = 0;
+  const blank = r.text < 3 && r.vis < 1;
+  if (r.overlay) { fail++; lines.push("✗ Fehler-Overlay des Dev-Servers sichtbar: " + r.overlay.slice(0, 800)); }
+  if (blank) { fail++; lines.push("✗ WEISSE SEITE: Im Browser erscheint kein Inhalt (kein Text, keine Bilder/Elemente)." + (r.errors.length ? " Ursache steht wahrscheinlich in den Konsolenfehlern unten." : " Prüfe, ob das Skript den Inhalt wirklich ins richtige Element (#root/#app) rendert und ob alle Dateien laden.")); }
+  else lines.push("✓ Im Browser sichtbar: " + r.text + " Zeichen Text" + (r.vis ? ", " + r.vis + " Bilder/Bedienelemente" : "") + (r.sample ? " – „" + r.sample.slice(0, 140) + "“" : ""));
+  const errs = [...new Set(r.errors)];
+  if (errs.length) { fail++; lines.push("✗ Konsolenfehler (" + errs.length + "):\n" + errs.slice(0, 12).map((e) => "    " + e.slice(0, 400)).join("\n")); }
+  else lines.push("✓ Keine Konsolenfehler");
+  if (r.failed && r.failed.length) { fail++; lines.push("✗ Nicht geladene Dateien:\n" + r.failed.slice(0, 12).map((e) => "    " + e).join("\n")); }
+  return { lines, fail };
+}
+
 
 const API = process.env.MYTHOS_API_URL || "https://rdxaqiacoitzeowehdts.supabase.co/functions/v1/v1-messages";
 const CFG = path.join(os.homedir(), ".mythos-code.json");
@@ -426,7 +1034,65 @@ let goal = "";
 const SYSTEM = () => "Du bist Mythos Code, ein autonomer Coding-Agent im Terminal des Nutzers (OS: " + process.platform + ", Projektordner: " + ROOT + ").\n" +
   TOOL_PROMPT + memoryPrompt(readMemory(ROOT)) + goalPrompt(goal);
 
-const SITE = process.env.MYTHOS_SITE_URL || "https://ai-mythos.lovable.app";
+const SITE = process.env.MYTHOS_SITE_URL || "https://mythos-ai-final-version.lovable.app";
+const VERSION = "1.9.0";
+const PKG = "mythos-code";
+
+// ---------- Auto-Update über npm ----------
+// Beim Start (höchstens alle 6 h) die neueste Version auf npm prüfen. Ist eine neuere da,
+// wird sie mit `npm i -g` installiert und Mythos startet direkt neu – ohne Zutun des Users.
+// Abschalten: MYTHOS_NO_UPDATE=1 oder --no-update. Manuell: `mythos update`.
+const newer = (a, b) => { const p = (v) => String(v).split(/[.+-]/).slice(0, 3).map((n) => parseInt(n, 10) || 0); const [x, y] = [p(a), p(b)]; for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] > y[i]; return false; };
+async function latestVersion() {
+  const ctl = new AbortController(); const t = setTimeout(() => ctl.abort(), 2500);
+  try { const r = await fetch("https://registry.npmjs.org/" + PKG + "/latest", { signal: ctl.signal }); return r.ok ? (await r.json()).version : null; }
+  catch { return null; } finally { clearTimeout(t); }
+}
+function installLatest(ver) {
+  const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+  try { execFileSync(npm, ["install", "-g", PKG + "@" + ver, "--no-audit", "--no-fund", "--loglevel=error"], { stdio: "inherit", shell: process.platform === "win32" }); return true; }
+  catch { return false; }
+}
+async function autoUpdate(force = false) {
+  if (VERSION.startsWith("__") || process.env.MYTHOS_UPDATED) return;
+  if (!force && (process.env.MYTHOS_NO_UPDATE || process.argv.includes("--no-update"))) return;
+  const c = load();
+  if (!force && c.updateCheckedAt && Date.now() - c.updateCheckedAt < 6 * 3600e3) return;
+  const latest = await latestVersion();
+  save(Object.assign(load(), { updateCheckedAt: Date.now() }));
+  if (!latest || !newer(latest, VERSION)) { if (force) console.log(C.g + "  ✓ Mythos Code ist aktuell (" + VERSION + ")" + C.x); return; }
+  console.log(C.m + "  ↑ Update " + VERSION + " → " + latest + " wird installiert…" + C.x);
+  if (!installLatest(latest)) { console.log(C.y + "  Update fehlgeschlagen. Manuell: npm i -g " + PKG + "@latest" + C.x); return; }
+  console.log(C.g + "  ✓ Aktualisiert auf " + latest + " – starte neu…\n" + C.x);
+  rl.close();
+  const child = spawn(process.platform === "win32" ? "mythos.cmd" : "mythos", process.argv.slice(2), { stdio: "inherit", shell: process.platform === "win32", env: Object.assign({}, process.env, { MYTHOS_UPDATED: "1" }) });
+  child.on("exit", (code) => process.exit(code ?? 0));
+  child.on("error", () => process.exit(0));
+  await new Promise(() => {}); // hier nicht weiterlaufen – der neue Prozess übernimmt
+}
+
+// ---------- Startbildschirm mit Maskottchen „Myth“ ----------
+// Kleiner Block-Charakter (Minecraft-Stil) – das Logo der Website bleibt unverändert.
+const MASCOT = [
+  "  ▄█████▄  ",
+  " ██▀███▀██ ",
+  " ▀███████▀ ",
+  "   ▀▀ ▀▀   ",
+];
+function banner(info) {
+  const tip = ["/hilfe zeigt alle Befehle", "Dateien mit @name anhängen", "Bilder einfach ins Terminal ziehen", "/goal <ziel> – Mythos bleibt dran, bis es fertig ist"][Math.floor(Math.random() * 4)];
+  const w = Math.min((process.stdout.columns || 80) - 4, 64);
+  const line = C.d + "─".repeat(w) + C.x;
+  const right = [
+    C.b + "Mythos Code" + C.x + C.d + " v" + VERSION + C.x,
+    C.d + info.dir + C.x,
+    C.d + info.extra + C.x,
+    C.c + "✦ " + C.x + C.d + tip + C.x,
+  ];
+  console.log("\n" + line);
+  MASCOT.forEach((m, i) => console.log(C.m + m + C.x + "  " + (right[i] || "")));
+  console.log(line + "\n");
+}
 const FN = process.env.MYTHOS_FN_URL || API.replace(/\/v1-messages$/, "");
 const authPost = async (body) => (await fetch(FN + "/cli-auth", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) })).json();
 
@@ -476,6 +1142,23 @@ const tickLine = () => {
 };
 const startTick = () => { if (tick || !working) return; tick = setInterval(() => process.stdout.write("\r\x1b[K" + C.d + tickLine() + C.x), 250); };
 const stopTick = () => { if (tick) { clearInterval(tick); tick = null; } clearLine(); };
+let adN = 0, adTier = null, adAdminDay = "";
+async function maybeAd() {
+  try {
+    if (adTier == null) { const j = await (await fetch(API.replace(/\/v1-messages.*$/, "") + "/cli-auth", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ action: "usage", api_key: cfg.key }) })).json(); adTier = j.admin ? "admin" : (j.tier || "free"); }
+    let due = false; const today = new Date().toDateString();
+    if (adTier === "admin") { due = adAdminDay !== today; adAdminDay = today; }
+    else { const every = adTier === "free" ? 4 : adTier === "light" ? 10 : 0; due = every > 0 && (++adN % every === 0); }
+    if (due) {
+      const fnBase = API.replace(/\/v1-messages.*$/, "");
+      let ads = []; try { ads = (await (await fetch(fnBase + "/ad-review", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ action: "list" }) })).json()).ads || []; } catch {}
+      const pool = [{ house: true, weight: 3 }].concat(ads); let r = Math.random() * pool.reduce((t, a) => t + Math.max(1, a.weight), 0); let ad = pool[0];
+      for (const a of pool) { r -= Math.max(1, a.weight); if (r <= 0) { ad = a; break; } }
+      if (!ad.house) { console.log("\x1b[2m📣 Werbung\x1b[0m  \x1b[1m" + ad.product + "\x1b[0m – " + ad.ad_text + ": " + ad.link + "\n\x1b[2m   Buche deine eigene Werbung: https://mythos-ai-final-version.lovable.app/werbung\x1b[0m\n"); return; }
+    }
+    if (due) console.log("\x1b[2m📣 Werbung\x1b[0m  \x1b[1m@at\x1b[0m – dein Feed voller Vibes: https://at-feed-vibes.lovable.app/\n\x1b[2m   Buche deine eigene Werbung: https://mythos-ai-final-version.lovable.app/werbung\x1b[0m\n");
+  } catch {}
+}
 const say = (s) => { const was = !!tick; stopTick(); console.log(s); if (was) startTick(); };
 
 // ---------- Stoppen mit Strg+C ----------
@@ -523,9 +1206,9 @@ function streamPrinter() {
   return {
     push(full) {
       let vis = full;
-      const k = vis.indexOf("<tool>");
+      const k = vis.search(/<tool(?:_call|_use)?[\s>]/i);
       if (k >= 0) vis = vis.slice(0, k);
-      else for (let n = 5; n > 0; n--) if (vis.endsWith("<tool>".slice(0, n))) { vis = vis.slice(0, -n); break; }
+      else { const p = vis.match(/<(?:t(?:o(?:o(?:l(?:_(?:c(?:a(?:l(?:l)?)?)?|u(?:s(?:e)?)?)?)?)?)?)?)?$/i); if (p) vis = vis.slice(0, p.index); }
       if (vis.length <= printed) return;
       buf += vis.slice(printed); printed = vis.length;
       let i; while ((i = buf.indexOf("\n")) !== -1) { line(buf.slice(0, i)); buf = buf.slice(i + 1); }
@@ -563,18 +1246,18 @@ function compact(history, level) {
 }
 
 let tokens = { in: 0, out: 0 };
+let currentTaskId = null;
 async function once(messages, onText, onThink) {
   const c = ctl = new AbortController(); const to = setTimeout(() => c.abort(), 170000);
   const system = SYSTEM();
-  tokens.in += estimateTokens(system, messages);
   try {
     const r = await fetch(API, {
       method: "POST", signal: c.signal,
       headers: { "content-type": "application/json", "x-api-key": cfg.key, "anthropic-version": "2023-06-01" },
-      body: JSON.stringify({ model: cfg.model || "mythos-code", max_tokens: 8000, system, messages, stream: true }),
+      body: JSON.stringify({ model: cfg.model || "mythos-code", task_id: currentTaskId, max_tokens: 8000, system, messages, stream: true }),
     });
     if (!r.ok) { const j = await r.json().catch(() => ({})); const e = new Error(j?.error?.message || ("HTTP " + r.status)); e.status = r.status; throw e; }
-    const reader = r.body.getReader(); const dec = new TextDecoder(); let buf = "", out = "", think = "";
+    const reader = r.body.getReader(); const dec = new TextDecoder(); let buf = "", out = "", think = "", measured = null;
     while (true) {
       const { done, value } = await reader.read(); if (done) break;
       buf += dec.decode(value, { stream: true });
@@ -583,13 +1266,14 @@ async function once(messages, onText, onThink) {
         if (!line.startsWith("data:")) continue;
         let p; try { p = JSON.parse(line.slice(5)); } catch { continue; }
         if (p.type === "error") { const e = new Error(p.error?.message || "Überlastet"); e.status = 529; throw e; }
-        // Sichtbare Gedanken: kommen als eigener Block VOR der Antwort.
-        if (p.delta?.type === "thinking_delta" && p.delta.thinking) { think += p.delta.thinking; if (onThink) onThink(think); }
+        if (p.type === "mythos_task") currentTaskId = p.task_id;
+        if (p.type === "message_delta" && p.usage) measured = p.usage;
         if (p.delta?.text) { out += p.delta.text; if (onText) onText(out); }
       }
     }
     if (!out.trim()) throw new Error("Leere Antwort");
-    tokens.out += Math.ceil(out.length / 4);
+    if (measured?.measured) { tokens.in += measured.input_tokens || 0; tokens.out += measured.output_tokens || 0; }
+    else tokens.unknown = (tokens.unknown || 0) + 1;
     return out;
   } finally { clearTimeout(to); }
 }
@@ -637,6 +1321,38 @@ function runLive(cmd) {
   });
 }
 
+// start/logs/stop/serve/verify/check – check zusätzlich mit echtem Browser (Chrome/Edge headless), falls installiert.
+async function cliDevTool(t) {
+  stopTick();
+  const live = t.name === "start" || t.name === "verify" ? (s) => process.stdout.write(C.d + s + C.x) : null;
+  const r = await devTool(t, ROOT, { onChunk: live, track: (p) => { child = p; } });
+  child = null;
+  let text = r.result, image = null;
+  if (t.name === "check" && wantsRender(r)) {
+    say(C.d + "   🌐 Browser-Test …" + C.x);
+    const h = await headlessRender(r.url).catch(() => null);
+    if (h && h.ok) { text = checkReport(r.url, r.http, renderVerdict(h)); image = h.image; }
+    else text = checkReport(r.url, r.http, null, "ℹ Kein Chrome/Edge gefunden – nur HTTP-Prüfung (Pfad mit MYTHOS_CHROME setzen).");
+  }
+  startTick();
+  const show = text.split("\n").filter((l) => /^[✓✗⚠ℹ]|^ERGEBNIS|^Prüfbericht|^Seitenprüfung|^Läuft|^Befehl|^FEHLER/.test(l)).slice(0, 14);
+  say(show.map((l) => (/✗|FEHLER/.test(l) ? C.r : /✓/.test(l) ? C.g : C.d) + "   " + l + C.x).join("\n"));
+  return image ? { text, image } : text;
+}
+
+// Mythos Cloud: Backend + KI-Gateway für die gebaute App verbinden und mythos-cloud.js anlegen.
+async function cloudConnect(t) {
+  try {
+    const r = await fetch(FN + "/app-cloud", { method: "POST", headers: { "content-type": "application/json" },
+      body: JSON.stringify({ action: "connect", api_key: cfg.key, name: String(t.app || path.basename(ROOT)) }) });
+    const j = await r.json().catch(() => ({}));
+    if (!r.ok || !j.client_js) return "FEHLER: Mythos Cloud: " + (j.error || "HTTP " + r.status);
+    const res = fileTool({ name: "write", path: (t.path = t.path || j.file), content: j.client_js }, ROOT);
+    say(C.g + "   ☁ Mythos Cloud verbunden (" + j.app + ")" + C.x);
+    return res.result + "\n\n" + j.guide;
+  } catch (e) { return "FEHLER: Mythos Cloud nicht erreichbar: " + e.message; }
+}
+
 async function runTool(t) {
   if (t.name === "todo") {
     const items = normalizeTodos(t);
@@ -645,15 +1361,23 @@ async function runTool(t) {
     say(C.c + C.b + "📋 Aufgabenliste " + done + "/" + items.length + C.x + "\n" + items.map((x) => (x.done ? C.g + "  ☑ " + C.d : "  ☐ ") + x.text + C.x).join("\n"));
     return todoSummary(items);
   }
+  // Server & Watcher enden nie → automatisch im Hintergrund starten, statt die Aufgabe zu blockieren.
+  if (t.name === "run" && looksLikeServer(t.cmd)) { say(C.d + "↪ " + t.cmd + " läuft dauerhaft – wird im Hintergrund gestartet" + C.x); t = { name: "start", cmd: t.cmd }; }
   const label = t.name === "run" ? "run " + t.cmd
+    : t.name === "start" ? "start (Hintergrund) " + t.cmd
+    : t.name === "serve" ? "serve " + (t.path || ".")
+    : t.name === "check" ? "check " + (t.url || t.path || "")
+    : t.name === "verify" ? "verify (Build, Typecheck, Tests …)"
+    : t.name === "logs" || t.name === "stop" ? t.name + " " + (t.id || "")
     : t.name === "search" ? "search /" + t.pattern + "/" + (t.glob ? " " + t.glob : "")
     : t.name === "write" ? "write " + t.path + " (" + String(t.content || "").length + " Zeichen)"
     : t.name === "websearch" ? "websearch " + t.query
     : t.name === "fetch" ? "fetch " + t.url
+    : t.name === "cloud" ? "cloud verbinden: " + (t.app || "App")
     : t.name + " " + (t.path || "");
   say(C.y + "⚙  " + label + C.x);
   // Sicherheitsnetz: gefährliche Befehle fragen immer nach (auch mit --yes) und werden bei /goal blockiert.
-  const why = t.name === "run" ? dangerCheck(t.cmd) : null;
+  const why = t.name === "run" || t.name === "start" ? dangerCheck(t.cmd) : null;
   if (why) {
     say(C.r + "🛡 Sicherheitsnetz: dieser Befehl " + why + "." + C.x);
     if (goal) return "BLOCKIERT vom Sicherheitsnetz: Der Befehl " + why + ". Der Nutzer ist nicht da und kann das nicht bestätigen – finde einen sichereren Weg ohne diesen Befehl.";
@@ -662,13 +1386,15 @@ async function runTool(t) {
     startTick();
     if (a !== "j" && a !== "y") return "Vom Nutzer abgelehnt (Sicherheitsnetz). Finde einen sichereren Weg.";
   }
-  if ((t.name === "run" || t.name === "write" || t.name === "edit") && !autoYes && !why) {
+  if (["run", "start", "verify", "write", "edit", "cloud"].includes(t.name) && !autoYes && !why) {
     stopTick();
     const a = (await ask(C.d + "   Erlauben? [j/N/a=immer] " + C.x)).trim().toLowerCase();
     startTick();
     if (a === "a") autoYes = true; else if (a !== "j" && a !== "y") return "Vom Nutzer abgelehnt.";
   }
   if (t.name === "run") return runLive(t.cmd);
+  if (t.name === "cloud") return cloudConnect(t);
+  if (isDevTool(t)) return cliDevTool(t);
   if (isWebTool(t)) {
     const r = await webTool(t);
     say(C.d + "   " + r.result.split("\n").filter(Boolean).slice(0, 3).join(" · ").slice(0, 160) + C.x);
@@ -681,8 +1407,10 @@ async function runTool(t) {
 
 // ---------- Eine Aufgabe (auch /goal) ----------
 async function turnInner(history) {
-  const max = goal ? 4000 : 40;
+  const max = goal ? 4000 : 60;
   let nudges = 0;
+  const tracker = verifyTracker();
+  const question = String((history.filter((m) => m.role === "user").pop() || {}).content || "");
   for (let i = 0; i < max && !stopped; i++) {
     const pr = streamPrinter();
     let think = null;
@@ -694,17 +1422,24 @@ async function turnInner(history) {
     pr.end(); activity = "";
     if (stopped) break;
     history.push({ role: "assistant", content: out });
-    const m = out.match(/<tool>([\s\S]*?)<\/tool>/);
-    if (!m) {
+    const pb = parseToolBlock(out);
+    if (!pb.tool && !pb.error) {
+      const nudge = tracker.nudge(out, question);
+      if (nudge) { say(C.d + "🔎 Mythos prüft seine Arbeit …" + C.x); history.push({ role: "user", content: nudge }); continue; }
       if (!goal || /ZIEL ERREICHT/.test(out)) return goal ? "reached" : "done";
       if (++nudges > 40) { say(C.y + "🎯 Mythos kommt beim Ziel nicht weiter – schau es dir bitte an (/weiter macht weiter)." + C.x); return "stuck"; }
       history.push({ role: "user", content: GOAL_NUDGE });
       continue;
     }
     nudges = 0;
-    let t; try { t = JSON.parse(m[1]); } catch { history.push({ role: "user", content: "Tool-JSON ungültig." }); continue; }
-    const res = await runTool(t);
-    history.push({ role: "user", content: "Werkzeug-Ergebnis:\n" + res });
+    if (pb.error) { history.push({ role: "user", content: pb.error + " Sende den Block vollständig als gültiges JSON in <tool>…</tool>." }); continue; }
+    const t = pb.tool, bad = toolProblem(t);
+    if (bad) { history.push({ role: "user", content: "Werkzeug-Ergebnis:\n" + bad }); continue; }
+    const res = await runTool(t), resText = typeof res === "string" ? res : res.text;
+    tracker.note(t, resText);
+    // Screenshot nur in der neuesten Prüfung mitschicken (spart Tokens).
+    if (res.image) history.forEach((m) => { if (m.shot) { delete m.images; delete m.shot; } });
+    history.push(res.image ? { role: "user", content: "Werkzeug-Ergebnis:\n" + resText + "\n\n(Screenshot der Seite anbei – sieh ihn dir an: Ist das Layout so, wie der Nutzer es will?)", images: [res.image], shot: true } : { role: "user", content: "Werkzeug-Ergebnis:\n" + resText });
   }
   if (!stopped) say(C.y + "Schrittlimit (" + max + ") erreicht – mit /weiter macht Mythos weiter." + C.x);
   return stopped ? "stopped" : "limit";
@@ -725,6 +1460,7 @@ async function summarize(history) {
 }
 
 async function turn(history, input, images) {
+  currentTaskId = null;
   if (input != null) history.push({ role: "user", content: input, images });
   T0 = Date.now(); working = true; stopped = false; startTick();
   const tok0 = tokens.in + tokens.out;
@@ -738,7 +1474,8 @@ async function turn(history, input, images) {
   working = false; stopTick();
   const took = fmt(Date.now() - T0);
   console.log((stopped ? C.r + "■ Gestoppt nach " + took : C.g + "✓ Mythos hat " + took + " gearbeitet") + C.x +
-    C.d + "  · ≈ " + fmtTokens(tokens.in + tokens.out - tok0) + " Tokens (Sitzung ≈ " + fmtTokens(tokens.in + tokens.out) + ")" + C.x + "\n");
+    C.d + "  · " + fmtTokens(tokens.in + tokens.out - tok0) + " MythosAI Tokens (Sitzung " + fmtTokens(tokens.in + tokens.out) + ")" + (tokens.unknown ? " · Anbieterwerte teils unbekannt" : "") + C.x + "\n");
+  if (!stopped && status !== "error") await maybeAd();
   if (status === "reached") { console.log(C.g + "🎯 Ziel erreicht: " + wasGoal + C.x + "\n"); goal = ""; }
   // Handy-Benachrichtigung bei /goal oder längeren Aufgaben.
   if (cfg.notify && (wasGoal || Date.now() - T0 > 60000)) {
@@ -764,7 +1501,7 @@ async function commit(msg) {
     stopped = false;
     try {
       msg = (await call([{ role: "user", content: "Schreibe eine kurze Git-Commit-Nachricht auf Deutsch für diese Änderungen: erste Zeile max. 72 Zeichen, optional Leerzeile + Stichpunkte. Antworte NUR mit der Nachricht, ohne Werkzeuge, ohne Codeblock.\n\n" + st.out + "\n" + diff.slice(0, 20000) }]))
-        .replace(/<tool>[\s\S]*?<\/tool>/g, "").replace(/^```\w*\n?|```$/g, "").trim();
+        .replace(TOOL_BLOCK_RE, "").replace(/^```\w*\n?|```$/g, "").trim();
     } catch (e) { clearLine(); return say(C.r + "⚠ " + e.message + C.x); }
     clearLine();
   }
@@ -803,7 +1540,7 @@ const HELP = [
   ["/handy <url>", "Handy-Benachrichtigung (ntfy.sh-Thema oder Discord-Webhook) · /handy test · /handy aus"],
   ["/vollzugriff an|aus", "Ohne Nachfragen arbeiten"],
   ["/modell [name]", "Modell anzeigen oder wechseln"],
-  ["/tokens", "Geschätzten Token-Verbrauch dieser Sitzung anzeigen"],
+  ["/tokens", "Gemessenen MythosAI-Verbrauch dieser Sitzung anzeigen"],
   ["/clear", "Verlauf leeren"],
   ["/review [schwerpunkt]", "Code-Review der Git-Änderungen (ändert nichts)"],
   ["/pr [branch]", "Branch pushen und Pull Request erstellen"],
@@ -886,7 +1623,7 @@ async function command(q, history) {
     cfg.model = m.id; save(cfg);
     return console.log(C.g + "✓ Modell: " + m.label + C.x + "\n");
   }
-  if (cmd === "/tokens") return console.log("≈ " + fmtTokens(tokens.in) + " Eingabe + " + fmtTokens(tokens.out) + " Ausgabe = " + fmtTokens(tokens.in + tokens.out) + " Tokens (geschätzt)\n");
+  if (cmd === "/tokens") return console.log(fmtTokens(tokens.in) + " Eingabe + " + fmtTokens(tokens.out) + " Ausgabe = " + fmtTokens(tokens.in + tokens.out) + " MythosAI Tokens" + (tokens.unknown ? " · " + tokens.unknown + " Aufrufe ohne Anbieterwerte" : "") + "\n");
   if (cmd === "/vollzugriff") { autoYes = !/^(aus|off)$/i.test(arg); return console.log(autoYes ? "Vollzugriff an.\n" : "Vollzugriff aus – Mythos fragt vor Befehlen nach.\n"); }
   if (cmd === "/review") {
     const st = git(["status", "--porcelain"]);
@@ -906,7 +1643,7 @@ async function command(q, history) {
     let sum = "";
     try {
       sum = (await call([{ role: "user", content: "Fasse den bisherigen Verlauf dieses Coding-Chats so zusammen, dass ein Agent nahtlos weiterarbeiten kann: **Ziel**, **Stand**, **Wichtige Dateien & Entscheidungen**, **Offene Punkte**. Maximal 25 Zeilen, ohne Werkzeuge.\n\nVERLAUF:\n" + transcript }]))
-        .replace(/<tool>[\s\S]*?<\/tool>/g, "").trim();
+        .replace(TOOL_BLOCK_RE, "").trim();
     } catch (e) { clearLine(); return console.log(C.r + "⚠ " + e.message + C.x + "\n"); }
     clearLine();
     history.length = 0;
@@ -916,7 +1653,7 @@ async function command(q, history) {
   if (cmd === "/stats") { const b = gitBranch(); return console.log(mdLines(projectStats(ROOT) + (b ? "\n**Git:** Branch `" + b + "`" : "")) + "\n"); }
   if (cmd === "/export") {
     const file = path.resolve(ROOT, arg || "mythos-chat-" + new Date().toISOString().slice(0, 16).replace(/[:T]/g, "-") + ".md");
-    const msgs = history.map((m) => ({ role: /^Werkzeug-Ergebnis/.test(m.content) ? "tool" : m.role, text: String(m.content).replace(/<tool>[\s\S]*?<\/tool>/g, "").slice(0, 20000) })).filter((m) => m.text.trim());
+    const msgs = history.map((m) => ({ role: /^Werkzeug-Ergebnis/.test(m.content) ? "tool" : m.role, text: String(m.content).replace(TOOL_BLOCK_RE, "").slice(0, 20000) })).filter((m) => m.text.trim());
     fs.writeFileSync(file, chatToMarkdown("Mythos-Chat – " + path.basename(ROOT), msgs));
     return console.log(C.g + "✓ Gespeichert: " + file + C.x + "\n");
   }
@@ -930,13 +1667,15 @@ async function command(q, history) {
 }
 
 async function main() {
-  const args = process.argv.slice(2).filter((a) => a !== "--yes" && a !== "--key");
+  const args = process.argv.slice(2).filter((a) => a !== "--yes" && a !== "--key" && a !== "--no-update");
   if (args[0] === "login" || !cfg.key) await login();
   if (args[0] === "login") process.exit(0);
   if (args[0] === "logout") { save({}); console.log("Abgemeldet."); process.exit(0); }
+  if (args[0] === "update") { await autoUpdate(true); process.exit(0); }
+  if (args[0] === "--version" || args[0] === "-v") { console.log(VERSION); process.exit(0); }
+  await autoUpdate();
   const branch = gitBranch();
-  console.log(C.c + C.b + "\n  ✦ MYTHOS CODE" + C.x + C.d + "  – by Mythoscraft · " + path.basename(ROOT) + (branch ? " ⎇ " + branch : "") +
-    (readMemory(ROOT) ? " · Gedächtnis ✓" : "") + "\n  /hilfe für Befehle · Strg+C stoppt · Bilder: Datei ins Terminal ziehen\n" + C.x);
+  banner({ dir: "📁 " + path.basename(ROOT) + (branch ? "  ⎇ " + branch : ""), extra: (cfg.name ? "angemeldet als " + cfg.name : "by Mythoscraft") + (readMemory(ROOT) ? " · Gedächtnis ✓" : "") + " · Strg+C stoppt" });
   const history = [];
   if (args.length) { const { text, images } = extractImages(args.join(" ")); await turn(history, text, images); }
   while (true) {
@@ -951,5 +1690,7 @@ async function main() {
     await turn(history, text + files.map((f) => "\n\n### " + f.name + "\n```\n" + f.content + "\n```").join(""), images);
   }
   rl.close();
+  process.exit(0); // beendet auch Hintergrund-Server (process.on("exit") in den Werkzeugen)
 }
+for (const sig of ["SIGTERM", "SIGHUP"]) process.on(sig, () => process.exit(0));
 main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythos-code",
-  "version": "1.7.3",
+  "version": "1.9.0",
   "description": "Mythos Code – KI-Coding-Agent im Terminal (by Mythoscraft)",
   "bin": {
     "mythos": "bin/mythos.js",