mythos-code 1.2.0 → 1.5.0

package/bin/mythos.js

@@ -1,62 +1,414 @@
 #!/usr/bin/env node
-// Mythos Code CLI – Agent mit Zugriff auf Dateien & Shell (mit Bestätigung)
+// Mythos Code CLI – KI-Coding-Agent im Terminal (by Mythoscraft)
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import readline from "node:readline";
-import { exec } from "node:child_process";
+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.
+
+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":"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',
+  '<tool>{"name":"search","pattern":"regex","path":".","glob":"*.ts"}</tool>  Im Projekt suchen (path und glob optional)',
+  '<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',
+  "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).",
+].join("\n");
+
+// Modelle, die v1-messages versteht (siehe mapModel dort).
+const MODELS = [
+  { id: "mythos-code", label: "MythosCode", desc: "Standard fürs Programmieren" },
+  { id: "mythos-v2", label: "Mythos v2", desc: "am stärksten, etwas langsamer" },
+  { id: "mythos-sonnet", label: "Mythos v1", desc: "ausgewogen" },
+  { id: "mythos-lite", label: "Mythos Lite", desc: "am schnellsten" },
+];
+/** Grobe Token-Schätzung (≈ 4 Zeichen pro Token, Bilder pauschal). */
+function estimateTokens(system, messages) {
+  let chars = String(system || "").length, images = 0;
+  for (const m of messages) {
+    if (typeof m.content === "string") chars += m.content.length;
+    else for (const b of m.content || []) { if (b.type === "image") images++; else chars += String(b.text || "").length; }
+  }
+  return Math.ceil(chars / 4) + images * 1500;
+}
+const fmtTokens = (n) => (n >= 1e6 ? (n / 1e6).toFixed(1) + " Mio." : n >= 1000 ? (n / 1000).toFixed(1) + "k" : String(n));
+
+const MEMORY_FILE = "MYTHOS.md";
+const memoryPrompt = (mem) => mem
+  ? "\n\nProjekt-Gedächtnis (" + MEMORY_FILE + " im Projektordner – halte dich daran, ergänze es bei wichtigen neuen Erkenntnissen per edit):\n" + mem
+  : "";
+const goalPrompt = (goal) => goal
+  ? "\n\nZIEL (/goal): " + goal + "\nDer Nutzer ist nicht am Rechner. Arbeite komplett selbstständig, ohne Rückfragen, bis das Ziel vollständig erreicht und überprüft ist. Erst dann schreibe in deiner letzten Antwort eine eigene Zeile: ZIEL ERREICHT"
+  : "";
+const GOAL_NUDGE = "Das Ziel ist noch nicht als erreicht gemeldet. 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 SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", "out", "coverage", ".cache", "vendor", "__pycache__", ".venv", "venv", "target"]);
+
+function readText(file) { try { return fs.readFileSync(file, "utf8"); } catch { return null; } }
+
+// Windows-Konsolenprogramme (cmd, dir, …) schreiben in Pipes im OEM-Zeichensatz (CP850), Node/Git in UTF-8.
+const CP850 = "ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜø£Ø׃áíóúñѪº¿®¬½¼¡«»░▒▓│┤ÁÂÀ©╣║╗╝¢¥┐└┴┬├─┼ãÃ╚╔╩╦╠═╬¤ðÐÊËÈıÍÎÏ┘┌█▄¦Ì▀ÓßÔÒõÕµþÞÚÛÙýݯ´­±‗¾¶§÷¸°¨·¹³²■ ";
+const fromCp850 = (b) => { let s = ""; for (const c of b) s += c < 128 ? String.fromCharCode(c) : CP850[c - 128]; return s; };
+/** Decoder für eine Ausgabe-Pipe: jedes Stück als UTF-8, sonst (Windows) als CP850. Angefangene UTF-8-Zeichen werden aufgehoben. */
+function outputDecoder() {
+  let pending = Buffer.alloc(0);
+  return (chunk) => {
+    let b = pending.length ? Buffer.concat([pending, chunk]) : chunk;
+    let i = b.length - 1, cont = 0;
+    while (i >= 0 && cont < 3 && (b[i] & 0xc0) === 0x80) { i--; cont++; }
+    const need = i >= 0 ? (b[i] >= 0xf0 ? 4 : b[i] >= 0xe0 ? 3 : b[i] >= 0xc0 ? 2 : 1) : 1;
+    const cut = need > 1 && b.length - i < need ? i : b.length;
+    pending = Buffer.from(b.subarray(cut)); b = b.subarray(0, cut);
+    try { return new TextDecoder("utf-8", { fatal: true }).decode(b); }
+    catch { return process.platform === "win32" ? fromCp850(b) : b.toString("latin1"); }
+  };
+}
+
+/** Zeilen-Diff mit Kontext: { added, removed, lines: [[op, text]] }, op = " " | "+" | "-" | "@" (Lücke). */
+function lineDiff(a, b, ctx = 3, maxLines = 400) {
+  // Zeilenumbruch am Dateiende ist keine eigene Zeile.
+  const toLines = (t) => (t ? t.replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n") : []);
+  const A = toLines(a), B = toLines(b);
+  let s = 0; while (s < A.length && s < B.length && A[s] === B[s]) s++;
+  let ea = A.length, eb = B.length; while (ea > s && eb > s && A[ea - 1] === B[eb - 1]) { ea--; eb--; }
+  const x = A.slice(s, ea), y = B.slice(s, eb);
+  let ops = [];
+  if (x.length * y.length <= 4e6) {
+    const n = x.length, m = y.length, L = [];
+    for (let i = 0; i <= n; i++) L.push(new Uint32Array(m + 1));
+    for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) L[i][j] = x[i] === y[j] ? L[i + 1][j + 1] + 1 : Math.max(L[i + 1][j], L[i][j + 1]);
+    let i = 0, j = 0;
+    while (i < n && j < m) {
+      if (x[i] === y[j]) { ops.push([" ", x[i]]); i++; j++; }
+      else if (L[i + 1][j] >= L[i][j + 1]) ops.push(["-", x[i++]]);
+      else ops.push(["+", y[j++]]);
+    }
+    while (i < n) ops.push(["-", x[i++]]);
+    while (j < m) ops.push(["+", y[j++]]);
+  } else ops = x.map((l) => ["-", l]).concat(y.map((l) => ["+", l]));
+  const all = A.slice(0, s).map((l) => [" ", l]).concat(ops, A.slice(ea).map((l) => [" ", l]));
+  const keep = new Uint8Array(all.length);
+  let added = 0, removed = 0;
+  all.forEach((o, k) => {
+    if (o[0] === " ") return;
+    if (o[0] === "+") added++; else removed++;
+    for (let d = Math.max(0, k - ctx); d <= Math.min(all.length - 1, k + ctx); d++) keep[d] = 1;
+  });
+  const lines = [];
+  let gap = false;
+  for (let k = 0; k < all.length; k++) {
+    if (!keep[k]) { gap = true; continue; }
+    if (lines.length >= maxLines) { lines.push(["@", "… (gekürzt)"]); break; }
+    if (gap && lines.length) lines.push(["@", "…"]);
+    gap = false; lines.push(all[k]);
+  }
+  return { added, removed, lines };
+}
+
+/** Gezieltes Ändern: `old` muss genau einmal vorkommen (oder all=true). */
+function editFile(file, oldText, newText, all) {
+  const cur = readText(file);
+  if (cur == null) return { error: "Datei nicht gefunden: " + file };
+  if (!oldText) return { error: '"old" fehlt – gib den exakten Text an, der ersetzt werden soll.' };
+  let o = String(oldText), n = String(newText ?? "");
+  // CRLF-Dateien mit LF-Suchtext trotzdem treffen.
+  if (!cur.includes(o) && cur.includes("\r\n")) { o = o.replace(/\r?\n/g, "\r\n"); n = n.replace(/\r?\n/g, "\r\n"); }
+  const count = cur.split(o).length - 1;
+  if (count === 0) return { error: "Text nicht gefunden in " + file + " – lies die Datei neu und nimm den exakten Text (inkl. Einrückung)." };
+  if (count > 1 && !all) return { error: "Text kommt " + count + "-mal vor in " + file + ' – nimm mehr umgebenden Kontext oder setze "all":true.' };
+  const at = cur.indexOf(o);
+  const next = all ? cur.split(o).join(n) : cur.slice(0, at) + n + cur.slice(at + o.length);
+  fs.writeFileSync(file, next);
+  return { diff: lineDiff(cur, next), count: all ? count : 1 };
+}
+
+function globToRe(glob) {
+  const g = String(glob).replace(/\\/g, "/").replace(/[.+^${}()|[\]]/g, "\\$&")
+    .replace(/\*\*\/?/g, "\u0001").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\u0001/g, ".*");
+  return new RegExp("(^|/)" + g + "$", "i");
+}
+
+/** Projekt durchsuchen (Regex, Groß-/Kleinschreibung egal, ohne node_modules & Co.). */
+function searchFiles(root, pattern, glob, max = 200) {
+  let re;
+  try { re = new RegExp(pattern, "i"); } catch { re = new RegExp(String(pattern).replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i"); }
+  const gre = glob ? globToRe(glob) : null;
+  const hits = [];
+  let files = 0;
+  const walk = (dir) => {
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (hits.length >= max || files > 20000) return;
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) { if (!SKIP_DIRS.has(e.name)) walk(full); continue; }
+      const rel = path.relative(root, full).split(path.sep).join("/");
+      if (gre && !gre.test(rel)) continue;
+      let st; try { st = fs.statSync(full); } catch { continue; }
+      if (st.size > 1e6) continue;
+      files++;
+      const text = readText(full);
+      if (text == null || text.includes("\u0000")) continue;
+      const lines = text.split(/\r?\n/);
+      for (let i = 0; i < lines.length && hits.length < max; i++) {
+        if (re.test(lines[i])) hits.push(rel + ":" + (i + 1) + ": " + lines[i].trim().slice(0, 200));
+      }
+    }
+  };
+  walk(root);
+  if (!hits.length) return "Keine Treffer für /" + pattern + "/" + (glob ? " in " + glob : "") + ".";
+  return hits.join("\n") + (hits.length >= max ? "\n… (mehr als " + max + " Treffer – Suche eingrenzen)" : "");
+}
+
+/** read/write/edit/search/ls ausführen. `run` macht jede Oberfläche selbst (Live-Ausgabe). */
+function fileTool(t, root) {
+  const P = (p) => path.resolve(root, p || ".");
+  try {
+    if (t.name === "read") {
+      const c = readText(P(t.path));
+      return { result: c == null ? "FEHLER: Datei nicht gefunden: " + t.path : c.slice(0, 20000) + (c.length > 20000 ? "\n…[gekürzt – Datei ist länger]" : "") };
+    }
+    if (t.name === "write") {
+      const file = P(t.path), before = readText(file) ?? "", content = String(t.content ?? "");
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      fs.writeFileSync(file, content);
+      const d = lineDiff(before, content);
+      return { result: "OK geschrieben: " + t.path + " (+" + d.added + " −" + d.removed + ")", diff: d };
+    }
+    if (t.name === "edit") {
+      const r = editFile(P(t.path), t.old, t.new, t.all);
+      if (r.error) return { result: "FEHLER: " + r.error };
+      return { result: "OK geändert: " + t.path + " (" + r.count + "×, +" + r.diff.added + " −" + r.diff.removed + ")", diff: r.diff };
+    }
+    if (t.name === "search") return { result: searchFiles(P(t.path), String(t.pattern || ""), t.glob) };
+    if (t.name === "ls") return { result: fs.readdirSync(P(t.path), { withFileTypes: true }).map((e) => (e.isDirectory() ? "[D] " : "    ") + e.name).join("\n") || "(leer)" };
+    return { result: "Unbekanntes Werkzeug: " + t.name };
+  } catch (e) { return { result: "FEHLER: " + e.message }; }
+}
+
+// ---------- Web: Seite lesen & Suche ----------
+const WEB_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126 Safari/537.36 MythosCode";
+const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " ", auml: "ä", ouml: "ö", uuml: "ü", Auml: "Ä", Ouml: "Ö", Uuml: "Ü", szlig: "ß" };
+const decodeEntities = (s) => s.replace(/&(#x[0-9a-f]+|#\d+|\w+);/gi, (m, e) =>
+  e[0] === "#" ? String.fromCodePoint(e[1] === "x" || e[1] === "X" ? parseInt(e.slice(2), 16) : +e.slice(1)) : ENTITIES[e] ?? m);
+function htmlToText(html) {
+  return decodeEntities(html
+    .replace(/<(script|style|noscript|svg|head)[\s\S]*?<\/\1>/gi, " ")
+    .replace(/<\/(p|div|li|h[1-6]|tr|section|article|header|footer|pre|blockquote)>|<br\s*\/?>/gi, "\n")
+    .replace(/<li[^>]*>/gi, "• ")
+    .replace(/<[^>]+>/g, " "))
+    .replace(/[ \t\f\v]+/g, " ").replace(/\n\s*\n\s*/g, "\n\n").trim();
+}
+async function webGet(url) {
+  const ctl = new AbortController(); const to = setTimeout(() => ctl.abort(), 20000);
+  try {
+    const r = await fetch(url, { headers: { "user-agent": WEB_UA, "accept-language": "de,en;q=0.8" }, redirect: "follow", signal: ctl.signal });
+    const type = r.headers.get("content-type") || "";
+    const buf = Buffer.from(await r.arrayBuffer()).subarray(0, 3e6);
+    return { ok: r.ok, status: r.status, type, text: buf.toString("utf8"), url: r.url };
+  } finally { clearTimeout(to); }
+}
+async function webTool(t) {
+  try {
+    if (t.name === "fetch") {
+      const url = String(t.url || "");
+      if (!/^https?:\/\//i.test(url)) return { result: "FEHLER: Bitte eine vollständige http(s)-URL angeben." };
+      const r = await webGet(url);
+      if (!r.ok) return { result: "FEHLER: HTTP " + r.status + " für " + url };
+      const text = /html/i.test(r.type) ? htmlToText(r.text) : r.text;
+      return { result: "Inhalt von " + r.url + ":\n\n" + text.slice(0, 20000) + (text.length > 20000 ? "\n…[gekürzt]" : "") };
+    }
+    if (t.name === "websearch") {
+      const q = String(t.query || "").trim();
+      if (!q) return { result: "FEHLER: query fehlt." };
+      const r = await webGet("https://html.duckduckgo.com/html/?q=" + encodeURIComponent(q));
+      const hits = [];
+      // Jeder Treffer ist ein eigener Block mit Titel-Link und (meist) Kurzbeschreibung.
+      for (const block of r.text.split(/<div[^>]+class="[^"]*\bresult\b/).slice(1)) {
+        if (hits.length >= 8) break;
+        const a = block.match(/class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/);
+        if (!a) continue;
+        let href = decodeEntities(a[1]);
+        const u = href.match(/[?&]uddg=([^&]+)/); if (u) href = decodeURIComponent(u[1]);
+        if (/duckduckgo\.com\/y\.js|result--ad/.test(href + block.slice(0, 200))) continue; // Werbung
+        const sn = block.match(/class="result__snippet"[^>]*>([\s\S]*?)<\/(?:a|div)>/);
+        hits.push((hits.length + 1) + ". " + htmlToText(a[2]) + "\n   " + href + (sn ? "\n   " + htmlToText(sn[1]).slice(0, 300) : ""));
+      }
+      return { result: hits.length ? "Suchergebnisse für „" + q + "“:\n\n" + hits.join("\n\n") + "\n\nMit fetch kannst du eine Seite genauer lesen." : "Keine Suchergebnisse für „" + q + "“." };
+    }
+    return { result: "Unbekanntes Werkzeug: " + t.name };
+  } catch (e) { return { result: "FEHLER: " + (e.name === "AbortError" ? "Zeitüberschreitung" : e.message) }; }
+}
+const isWebTool = (t) => t.name === "fetch" || t.name === "websearch";
+
+function readMemory(root) { const t = readText(path.join(root, MEMORY_FILE)); return t ? t.slice(0, 8000) : ""; }
+function addMemory(root, text) {
+  const f = path.join(root, MEMORY_FILE);
+  const cur = readText(f) || "# Projekt-Gedächtnis\n\nMythos liest diese Datei bei jeder Aufgabe mit.\n";
+  fs.writeFileSync(f, cur.replace(/\s*$/, "\n") + "- " + String(text).trim() + "\n");
+  return f;
+}
+
+/** Handy-Benachrichtigung: ntfy.sh-Thema, Discord-Webhook oder beliebige URL (JSON-POST). */
+async function pushNotify(url, title, message) {
+  if (!url) return false;
+  try {
+    const u = new URL(url);
+    let target = url, body;
+    if (/(^|\.)discord(app)?\.com$/.test(u.hostname)) body = { content: "**" + title + "**\n" + message };
+    else if (/ntfy/.test(u.hostname)) { target = u.origin; body = { topic: u.pathname.replace(/^\/+|\/+$/g, ""), title, message }; }
+    else body = { title, message };
+    const r = await fetch(target, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+    return r.ok;
+  } catch { return false; }
+}
+
 
 const API = process.env.MYTHOS_API_URL || "https://rdxaqiacoitzeowehdts.supabase.co/functions/v1/v1-messages";
 const CFG = path.join(os.homedir(), ".mythos-code.json");
-const C = { c: "\x1b[36m", g: "\x1b[32m", y: "\x1b[33m", r: "\x1b[31m", d: "\x1b[2m", b: "\x1b[1m", x: "\x1b[0m" };
+const ROOT = process.cwd();
+const C = { c: "\x1b[36m", g: "\x1b[32m", y: "\x1b[33m", r: "\x1b[31m", m: "\x1b[35m", d: "\x1b[2m", b: "\x1b[1m", x: "\x1b[0m" };
 const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
 const ask = (q) => new Promise((r) => rl.question(q, r));
 const load = () => { try { return JSON.parse(fs.readFileSync(CFG, "utf8")); } catch { return {}; } };
 const save = (c) => fs.writeFileSync(CFG, JSON.stringify(c, null, 2));
 let cfg = load();
 let autoYes = process.argv.includes("--yes");
+let goal = "";
 
-const SYSTEM = `Du bist Mythos Code, ein autonomer Coding-Agent im Terminal des Nutzers (OS: ${process.platform}, CWD: ${process.cwd()}).
-Du kannst Werkzeuge nutzen. Um ein Werkzeug aufzurufen, antworte mit GENAU EINEM Block:
-<tool>{"name":"run","cmd":"..."}</tool>          -> Shell-Befehl ausführen
-<tool>{"name":"read","path":"..."}</tool>        -> Datei lesen
-<tool>{"name":"write","path":"...","content":"..."}</tool> -> Datei schreiben/erstellen
-<tool>{"name":"ls","path":"."}</tool>            -> Ordner auflisten
-Nach jedem Werkzeug bekommst du das Ergebnis. Arbeite Schritt für Schritt, bis die Aufgabe erledigt ist, dann antworte normal ohne <tool>. Sei präzise.`;
+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);
 
-async function login() {
-  console.log(C.c + "Hol dir einen kostenlosen API-Key im Mythos Dashboard (sk-ant-mythos-...)." + C.x);
-  const k = (await ask("API-Key: ")).trim();
+const SITE = process.env.MYTHOS_SITE_URL || "https://ai-mythos.lovable.app";
+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();
+
+function openBrowser(url) {
+  const cmd = process.platform === "win32" ? `start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
+  exec(cmd, () => {});
+}
+
+async function loginWithKey() {
+  const k = (await ask("API-Key (sk-ant-mythos-...): ")).trim();
   if (!k.startsWith("sk-ant-mythos-")) { console.log(C.r + "Ungültiger Key." + C.x); process.exit(1); }
-  cfg.key = k; save(cfg); console.log(C.g + "✓ Gespeichert in " + CFG + C.x);
+  cfg.key = k; save(cfg); console.log(C.g + "✓ Angemeldet" + C.x);
+}
+
+// Anmeldung über die Website: Browser öffnet sich, dort auf "Authentifizieren" klicken.
+async function login() {
+  if (process.argv.includes("--key")) return loginWithKey();
+  let s;
+  try { s = await authPost({ action: "start", client: "cli" }); } catch { s = null; }
+  if (!s?.code) { console.log(C.r + "Anmeldung gerade nicht möglich – versuch es gleich nochmal." + C.x); process.exit(1); }
+  const url = SITE + "/cli-auth?code=" + s.code;
+  console.log(C.c + "\n  Anmeldung mit MythosAI" + C.x);
+  console.log("  Dein Browser öffnet sich. Klicke dort auf " + C.b + "Authentifizieren" + C.x + ".");
+  console.log(C.d + "  Code: " + s.code + "  ·  Falls sich nichts öffnet: " + url + C.x + "\n");
+  openBrowser(url);
+  const until = Date.now() + 15 * 60e3;
+  process.stdout.write(C.d + "  Warte auf Bestätigung…" + C.x);
+  while (Date.now() < until) {
+    await new Promise((r) => setTimeout(r, 2000));
+    let p; try { p = await authPost({ action: "poll", code: s.code, poll_secret: s.poll_secret }); } catch { continue; }
+    if (p.status === "ok") { cfg.key = p.api_key; cfg.name = p.name; save(cfg); clearLine(); console.log(C.g + "  ✓ Angemeldet als " + p.name + C.x + "\n"); return; }
+    if (p.status === "expired") break;
+  }
+  clearLine(); console.log(C.r + "  Anmeldung abgelaufen – starte nochmal mit: mythos login" + C.x); process.exit(1);
 }
 
 const fmt = (ms) => { const s = Math.floor(ms / 1000); return (s >= 60 ? Math.floor(s / 60) + "m " : "") + (s % 60) + "s"; };
 
-// Live-Timer: läuft während der ganzen Aufgabe (auch während Befehle laufen), pausiert nur für Rückfragen.
+// Live-Timer: läuft während der ganzen Aufgabe, pausiert für Ausgaben und Rückfragen.
 let T0 = 0, tick = null;
 const clearLine = () => process.stdout.write("\r\x1b[K");
-const startTick = () => { if (tick) return; tick = setInterval(() => process.stdout.write("\r" + C.d + "⏳ Mythos arbeitet… " + fmt(Date.now() - T0) + C.x + "   "), 250); };
+const startTick = () => { if (tick || !working) return; tick = setInterval(() => process.stdout.write("\r" + C.d + "⏳ Mythos arbeitet… " + fmt(Date.now() - T0) + "  (Strg+C = stoppen)" + C.x + "   "), 250); };
 const stopTick = () => { if (tick) { clearInterval(tick); tick = null; } clearLine(); };
 const say = (s) => { const was = !!tick; stopTick(); console.log(s); if (was) startTick(); };
 
+// ---------- Stoppen mit Strg+C ----------
+let working = false, stopped = false, ctl = null, child = null;
+function killChild() {
+  if (!child) return;
+  try { if (process.platform === "win32") exec("taskkill /pid " + child.pid + " /T /F"); else child.kill("SIGTERM"); } catch {}
+}
+rl.on("SIGINT", () => {
+  if (!working) { console.log(); rl.close(); process.exit(0); }
+  if (stopped) return;
+  stopped = true; killChild(); if (ctl) ctl.abort();
+  say(C.r + "■ Wird gestoppt…" + C.x);
+});
+
+// ---------- Markdown im Terminal ----------
+function mdLine(line, st) {
+  if (/^\s*```/.test(line)) { st.code = !st.code; return C.d + (st.code ? "┌─ " + line.trim().slice(3) : "└─") + C.x; }
+  if (st.code) return C.c + "│ " + line + C.x;
+  const h = line.match(/^(#{1,6})\s+(.*)/);
+  if (h) return C.b + C.m + h[2] + C.x;
+  return line
+    .replace(/^(\s*)[-*]\s+/, "$1• ")
+    .replace(/\*\*(.+?)\*\*/g, C.b + "$1" + C.x)
+    .replace(/`([^`]+)`/g, C.c + "$1" + C.x)
+    .replace(/\[([^\]]+)\]\((https?:[^)]+)\)/g, "$1 " + C.d + "($2)" + C.x);
+}
+
+// Antwort live mitlesen: fertige Zeilen sofort formatiert ausgeben, <tool>-Blöcke ausblenden.
+function streamPrinter() {
+  let printed = 0, buf = "", started = false;
+  const st = { code: false };
+  const line = (l) => {
+    stopTick();
+    if (!started) { if (!l.trim()) { startTick(); return; } started = true; process.stdout.write(C.b + "Mythos: " + C.x); }
+    console.log(mdLine(l, st));
+    startTick();
+  };
+  return {
+    push(full) {
+      let vis = full;
+      const k = vis.indexOf("<tool>");
+      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; }
+      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); }
+    },
+    end() { if (buf.trim()) line(buf); buf = ""; if (started) { stopTick(); console.log(); startTick(); } },
+  };
+}
+
+// ---------- Modell ----------
 // Verlauf kürzen, damit lange Aufgaben nicht an zu großem Kontext scheitern. level 0 = mild, 2 = stark.
 const shorten = (s, max) => s.length <= max ? s : s.slice(0, Math.floor(max * 0.7)) + "\n…[gekürzt]…\n" + s.slice(s.length - Math.floor(max * 0.3));
+const withImages = (m, content) => m.images && m.images.length
+  ? { role: m.role, content: [{ type: "text", text: content }].concat(m.images.map((i) => ({ type: "image", source: { type: "base64", media_type: i.media_type, data: i.data } }))) }
+  : { role: m.role, content };
 function compact(history, level) {
   const keep = [6, 8, 4][level], recentMax = [20000, 3000, 1500][level], oldMax = [1500, 800, 400][level];
   const cut = Math.max(0, history.length - keep);
   const older = level === 0 ? history.slice(0, cut) : history.slice(0, Math.min(1, cut));
   return older.map((m) => ({ role: m.role, content: shorten(m.content, oldMax) }))
-    .concat(history.slice(cut).map((m) => ({ role: m.role, content: shorten(m.content, recentMax) })));
+    .concat(history.slice(cut).map((m) => withImages(m, shorten(m.content, recentMax))));
 }
 
-async function once(messages) {
-  const ctl = new AbortController(); const to = setTimeout(() => ctl.abort(), 170000);
+let tokens = { in: 0, out: 0 };
+async function once(messages, onText) {
+  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: ctl.signal,
+      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: SYSTEM, messages, stream: true }),
+      body: JSON.stringify({ model: cfg.model || "mythos-code", 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 = "";
@@ -68,19 +420,22 @@ async function once(messages) {
         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; }
-        if (p.delta?.text) out += p.delta.text;
+        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);
     return out;
   } finally { clearTimeout(to); }
 }
 
-async function call(history) {
+async function call(history, onText) {
   for (let a = 0; a < 6; a++) {
-    try { return await once(compact(history, Math.min(2, Math.floor(a / 2)))); }
+    if (stopped) throw new Error("Gestoppt");
+    try { return await once(compact(history, Math.min(2, Math.floor(a / 2))), onText); }
     catch (e) {
-      if (e.status === 401) throw new Error("API-Key ungültig – bitte neu anmelden: mythos login");
+      if (stopped) throw e;
+      if (e.status === 401) throw new Error("Anmeldung ungültig – bitte neu anmelden: mythos login");
       if (/Daily limit/i.test(e.message)) throw new Error("Tageslimit erreicht – mit Pro unbegrenzt.");
       await new Promise((r) => setTimeout(r, Math.min(8000, 1500 * (a + 1))));
     }
@@ -88,60 +443,236 @@ async function call(history) {
   throw new Error("Mythos ist gerade nicht erreichbar – bitte gleich nochmal versuchen.");
 }
 
+// ---------- Werkzeuge ----------
+function diffText(d) {
+  const shown = d.lines.slice(0, 80).map(([op, l]) =>
+    op === "+" ? C.g + "  + " + l + C.x : op === "-" ? C.r + "  - " + l + C.x : op === "@" ? C.d + "  " + l + C.x : C.d + "    " + l + C.x);
+  if (d.lines.length > 80) shown.push(C.d + "  … (" + (d.lines.length - 80) + " weitere Zeilen)" + C.x);
+  return shown.join("\n");
+}
+
+// Befehl ausführen und die Ausgabe live im Terminal zeigen.
+function runLive(cmd) {
+  stopTick();
+  return new Promise((res) => {
+    let out = "";
+    child = spawn(cmd, { shell: true, cwd: ROOT, env: process.env });
+    const on = (decode) => (d) => { const s = decode(d); out += s; if (out.length > 200000) out = out.slice(-100000); process.stdout.write(C.d + s + C.x); };
+    child.stdout.on("data", on(outputDecoder())); child.stderr.on("data", on(outputDecoder()));
+    const to = setTimeout(() => { out += "\n[Nach 10 Minuten abgebrochen]"; killChild(); }, 600000);
+    child.on("error", (e) => { out += "\nFEHLER: " + e.message; });
+    child.on("close", (code) => {
+      clearTimeout(to); child = null;
+      if (out && !out.endsWith("\n")) process.stdout.write("\n");
+      startTick();
+      res((out + (code ? "\nExit: " + code : "")).slice(-8000) || "(keine Ausgabe)");
+    });
+  });
+}
+
 async function runTool(t) {
-  const show = t.name === "write" ? `write ${t.path} (${(t.content || "").length} Zeichen)` : `${t.name} ${t.cmd || t.path || ""}`;
-  say(C.y + "⚙  " + show + C.x);
-  if ((t.name === "run" || t.name === "write") && !autoYes) {
+  const label = t.name === "run" ? "run " + t.cmd
+    : 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 + " " + (t.path || "");
+  say(C.y + "⚙  " + label + C.x);
+  if ((t.name === "run" || t.name === "write" || t.name === "edit") && !autoYes) {
     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.";
   }
-  try {
-    if (t.name === "run") return await new Promise((res) => exec(t.cmd, { encoding: "utf8", timeout: 180000, maxBuffer: 1e7 },
-      (err, so, se) => res(((so || "") + (se || "") + (err ? "\nExit: " + (err.code ?? err.message) : "")).slice(-8000) || "(keine Ausgabe)")));
-    if (t.name === "read") return fs.readFileSync(t.path, "utf8").slice(0, 20000);
-    if (t.name === "write") { fs.mkdirSync(path.dirname(path.resolve(t.path)), { recursive: true }); fs.writeFileSync(t.path, t.content ?? ""); return "OK geschrieben: " + t.path; }
-    if (t.name === "ls") return fs.readdirSync(t.path || ".", { withFileTypes: true }).map((e) => (e.isDirectory() ? "📁 " : "   ") + e.name).join("\n");
-    return "Unbekanntes Werkzeug";
-  } catch (e) { return "FEHLER: " + (e.stdout || "") + (e.stderr || "") + e.message; }
-}
-
-async function turn(history, input) {
-  T0 = Date.now(); startTick();
-  try { await turnInner(history, input); }
-  catch (e) { say(C.r + "⚠ " + e.message + C.x); }
-  finally { stopTick(); console.log(C.g + "✓ Mythos hat " + fmt(Date.now() - T0) + " gearbeitet" + C.x + "\n"); }
-}
-async function turnInner(history, input) {
-  history.push({ role: "user", content: input });
-  for (let i = 0; i < 40; i++) {
-    const out = await call(history);
+  if (t.name === "run") return runLive(t.cmd);
+  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);
+    return r.result;
+  }
+  const r = fileTool(t, ROOT);
+  if (r.diff && r.diff.lines.length) say(diffText(r.diff));
+  return r.result;
+}
+
+// ---------- Eine Aufgabe (auch /goal) ----------
+async function turnInner(history) {
+  const max = goal ? 200 : 40;
+  let nudges = 0;
+  for (let i = 0; i < max && !stopped; i++) {
+    const pr = streamPrinter();
+    const out = await call(history, (full) => pr.push(full));
+    pr.end();
+    if (stopped) break;
     history.push({ role: "assistant", content: out });
     const m = out.match(/<tool>([\s\S]*?)<\/tool>/);
-    const text = out.replace(/<tool>[\s\S]*?<\/tool>/g, "").trim();
-    if (text) say(C.b + "Mythos: " + C.x + text + "\n");
-    if (!m) return;
+    if (!m) {
+      if (!goal || /ZIEL ERREICHT/.test(out)) return goal ? "reached" : "done";
+      if (++nudges > 5) { 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 (!stopped) say(C.y + "Schrittlimit (" + max + ") erreicht – mit /weiter macht Mythos weiter." + C.x);
+  return stopped ? "stopped" : "limit";
+}
+
+async function summarize(history) {
+  history.push({ role: "user", content: SUMMARY_PROMPT });
+  say(C.m + C.b + "📋 Zusammenfassung" + C.x);
+  const pr = streamPrinter();
+  const out = await call(history, (full) => pr.push(full));
+  pr.end();
+  history.push({ role: "assistant", content: out });
+  return out;
+}
+
+async function turn(history, input, images) {
+  if (input != null) history.push({ role: "user", content: input, images });
+  T0 = Date.now(); working = true; stopped = false; startTick();
+  const tok0 = tokens.in + tokens.out;
+  const wasGoal = goal;
+  let status = "error", summary = "";
+  try {
+    status = await turnInner(history);
+    if (wasGoal && status !== "stopped" && !stopped) summary = await summarize(history);
+  } catch (e) { if (!stopped) say(C.r + "⚠ " + e.message + C.x); }
+  if (stopped) { status = "stopped"; if (history[history.length - 1]?.role === "user") history.push({ role: "assistant", content: "(Vom Nutzer gestoppt.)" }); }
+  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");
+  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)) {
+    const title = status === "reached" ? "🎯 Ziel erreicht" : status === "done" ? "✓ Mythos ist fertig" : status === "stopped" ? "■ Gestoppt" : "⚠ Mythos braucht dich";
+    pushNotify(cfg.notify, "Mythos Code – " + path.basename(ROOT), title + " (" + took + ")" + (summary ? "\n\n" + summary.slice(0, 1500) : ""));
+  }
+}
+
+// ---------- Git ----------
+const git = (args) => {
+  try { return { ok: true, out: execFileSync("git", args, { cwd: ROOT, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 1e7 }) }; }
+  catch (e) { return { ok: false, out: ((e.stdout || "") + (e.stderr || "")) || e.message }; }
+};
+const gitBranch = () => { const b = git(["rev-parse", "--abbrev-ref", "HEAD"]); return b.ok ? b.out.trim() : ""; };
+
+async function commit(msg) {
+  const st = git(["status", "--porcelain"]);
+  if (!st.ok) return say(C.r + "Kein Git-Repository: " + st.out.trim() + C.x);
+  if (!st.out.trim()) return say(C.d + "Nichts zu committen – alles sauber." + C.x);
+  if (!msg) {
+    const diff = git(["diff", "HEAD"]).out || git(["diff"]).out;
+    process.stdout.write(C.d + "Mythos schreibt die Commit-Nachricht…" + C.x);
+    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();
+    } catch (e) { clearLine(); return say(C.r + "⚠ " + e.message + C.x); }
+    clearLine();
+  }
+  console.log(C.b + "Commit-Nachricht:" + C.x + "\n" + C.c + msg + C.x);
+  if (!autoYes && !/^[jy]/i.test((await ask(C.d + "Committen? [j/N] " + C.x)).trim())) return say("Abgebrochen.");
+  git(["add", "-A"]);
+  const c = git(["commit", "-m", msg]);
+  say((c.ok ? C.g : C.r) + c.out.trim() + C.x);
+}
+
+// ---------- Bilder: Pfade zu Bilddateien in der Eingabe (z. B. per Drag & Drop ins Terminal) ----------
+const IMG = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp" };
+function extractImages(input) {
+  const images = [];
+  const text = input.replace(/"([^"]+\.(png|jpe?g|gif|webp))"|'([^']+\.(png|jpe?g|gif|webp))'|(\S+\.(png|jpe?g|gif|webp))/gi, (all, a, _1, b, _2, c) => {
+    const p = path.resolve(ROOT, a || b || c);
+    try {
+      const st = fs.statSync(p);
+      if (!st.isFile() || st.size > 5e6 || images.length >= 5) return all;
+      images.push({ media_type: IMG[p.split(".").pop().toLowerCase()], data: fs.readFileSync(p).toString("base64") });
+      return "[Bild: " + path.basename(p) + "]";
+    } catch { return all; }
+  });
+  return { text, images };
+}
+
+const HELP = [
+  ["/goal <ziel>", "Mythos arbeitet selbstständig, bis das Ziel erreicht ist (+ Zusammenfassung)"],
+  ["/goal stop", "Ziel beenden"],
+  ["/weiter", "Unterbrochene Arbeit fortsetzen"],
+  ["/merken <text>", "Etwas ins Projekt-Gedächtnis (MYTHOS.md) schreiben"],
+  ["/gedaechtnis", "Projekt-Gedächtnis anzeigen"],
+  ["/git", "Git-Status anzeigen"],
+  ["/commit [nachricht]", "Alles committen (ohne Nachricht schreibt Mythos sie)"],
+  ["/push", "git push"],
+  ["/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"],
+  ["/clear", "Verlauf leeren"],
+  ["/exit", "Beenden"],
+];
+
+async function command(q, history) {
+  const cmd = q.split(/\s+/)[0].toLowerCase(), arg = q.slice(cmd.length).trim();
+  if (cmd === "/hilfe" || cmd === "/help") return console.log(HELP.map(([c, d]) => "  " + C.c + c.padEnd(22) + C.x + d).join("\n") + "\n");
+  if (cmd === "/clear") { history.length = 0; goal = ""; return console.log("Verlauf geleert.\n"); }
+  if (cmd === "/goal" || cmd === "/ziel") {
+    if (!arg) return console.log(goal ? "🎯 Aktuelles Ziel: " + goal : "So geht's: /goal <was Mythos erreichen soll>");
+    if (/^(stop|aus|ende|beenden)$/i.test(arg)) { goal = ""; return console.log("🎯 Ziel beendet.\n"); }
+    if (!autoYes) { autoYes = true; console.log(C.d + "Vollzugriff für /goal eingeschaltet – Mythos fragt nicht mehr nach." + C.x); }
+    goal = arg;
+    return turn(history, "Neues Ziel: " + arg + "\nArbeite jetzt komplett selbstständig daran, bis es erreicht und geprüft ist.");
+  }
+  if (cmd === "/weiter") {
+    if (!history.length) return console.log("Hier gibt es noch nichts zum Weitermachen.");
+    return turn(history, history[history.length - 1].role === "assistant" ? "Mach bitte genau dort weiter, wo du aufgehört hast." : null);
+  }
+  if (cmd === "/merken") { if (!arg) return console.log("So geht's: /merken <text>"); addMemory(ROOT, arg); return console.log(C.g + "✓ In " + MEMORY_FILE + " gemerkt." + C.x + "\n"); }
+  if (cmd === "/gedaechtnis" || cmd === "/gedächtnis") return console.log(readMemory(ROOT) || "Noch kein Projekt-Gedächtnis. Mit /merken <text> anlegen.", "\n");
+  if (cmd === "/git") { const s = git(["status", "--short", "--branch"]); return console.log((s.ok ? s.out : C.r + s.out + C.x).trim() + "\n"); }
+  if (cmd === "/commit") return commit(arg);
+  if (cmd === "/push") { const p = git(["push"]); return console.log((p.ok ? C.g : C.r) + p.out.trim() + C.x + "\n"); }
+  if (cmd === "/handy") {
+    if (/^(aus|off)$/i.test(arg)) { delete cfg.notify; save(cfg); return console.log("Handy-Benachrichtigung aus.\n"); }
+    if (/^test$/i.test(arg)) return console.log(cfg.notify && await pushNotify(cfg.notify, "Mythos Code", "Test – Benachrichtigungen funktionieren ✓") ? C.g + "✓ Gesendet." + C.x : C.r + "Senden fehlgeschlagen – URL prüfen." + C.x);
+    if (!/^https:\/\//i.test(arg)) return console.log("So geht's: App „ntfy“ aufs Handy, Thema abonnieren, dann:\n  /handy https://ntfy.sh/dein-geheimes-thema\nOder einen Discord-Webhook-Link angeben.\n");
+    cfg.notify = arg; save(cfg);
+    return console.log(C.g + "✓ Gespeichert. Bei /goal und Aufgaben über 1 Minute bekommst du eine Nachricht. Test: /handy test" + C.x + "\n");
+  }
+  if (cmd === "/modell" || cmd === "/model") {
+    const cur = cfg.model || "mythos-code";
+    if (!arg) return console.log(MODELS.map((m) => (m.id === cur ? C.g + "● " : "  ") + m.id.padEnd(15) + C.x + m.label + C.d + " – " + m.desc + C.x).join("\n") + "\n\nWechseln mit /modell <name>\n");
+    const m = MODELS.find((x) => x.id === arg.toLowerCase() || x.label.toLowerCase() === arg.toLowerCase());
+    if (!m) return console.log(C.r + "Unbekanntes Modell. Verfügbar: " + MODELS.map((x) => x.id).join(", ") + C.x + "\n");
+    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 === "/vollzugriff") { autoYes = !/^(aus|off)$/i.test(arg); return console.log(autoYes ? "Vollzugriff an.\n" : "Vollzugriff aus – Mythos fragt vor Befehlen nach.\n"); }
+  console.log("Unbekannter Befehl: " + cmd + " – /hilfe zeigt alle Befehle.\n");
 }
 
 async function main() {
-  const args = process.argv.slice(2).filter((a) => a !== "--yes");
+  const args = process.argv.slice(2).filter((a) => a !== "--yes" && a !== "--key");
   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); }
-  console.log(C.c + C.b + "\n  ✦ MYTHOS CODE" + C.x + C.d + "  – by Mythoscraft · /exit zum Beenden · /clear leeren\n" + C.x);
+  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);
   const history = [];
-  if (args.length) { await turn(history, args.join(" ")); }
+  if (args.length) { const { text, images } = extractImages(args.join(" ")); await turn(history, text, images); }
   while (true) {
-    const q = (await ask(C.c + "› " + C.x)).trim();
+    const q = (await ask(C.c + (goal ? "🎯 " : "") + "› " + C.x)).trim();
     if (!q) continue;
     if (q === "/exit") break;
-    if (q === "/clear") { history.length = 0; console.log("Verlauf geleert."); continue; }
-    await turn(history, q);
+    if (q.startsWith("/")) { await command(q, history); continue; }
+    const { text, images } = extractImages(q);
+    if (images.length) console.log(C.d + "🖼 " + images.length + " Bild(er) angehängt" + C.x);
+    await turn(history, text, images);
   }
   rl.close();
 }

package/package.json

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