mythos-code 1.3.0 → 1.7.1

package/bin/mythos.js

@@ -1,28 +1,416 @@
 #!/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',
+  '<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)',
+  "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 Auftraggeber ist NICHT am Rechner und liest erst viel später mit, was hier im Chat passiert ist – frage ihn nichts, er kann nicht antworten. Behandle jede Entscheidung, jede Rückfrage und jedes Hindernis als etwas, das du selbst lösen musst:" +
+    "\n- Gib bei Fehlern NIEMALS auf. Ein fehlgeschlagener Befehl, eine fehlende Abhängigkeit, ein kaputter Build sind Aufgaben, keine Endstationen: lies die Fehlermeldung genau, versuche eine andere Vorgehensweise, installiere Fehlendes selbst (z. B. per npm/pip/winget), nutze bei Bedarf websearch/fetch um die Lösung nachzuschlagen, und probiere es erneut. Erst wenn du wirklich mehrere grundverschiedene Ansätze erfolglos versucht hast, notierst du das Problem knapp und machst mit dem Rest der Aufgabe weiter." +
+    "\n- Triff sinnvolle Annahmen statt zu fragen, und schreib kurz dazu, welche Annahme du getroffen hast." +
+    "\n- Teile deinen Fortschritt normal im Chat mit (was du tust und warum), aber warte nicht auf eine Antwort." +
+    "\n- Das ist eine große, langlaufende Aufgabe: Plane für 1 bis 5 Stunden durchgehende Arbeit in vielen kleinen Schritten, nicht für ein paar Minuten. Höre nicht zu früh auf – arbeite lieber zu gründlich als zu knapp." +
+    "\nArbeite komplett selbstständig weiter, 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. 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 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)" : "");
+}
+
+// ---------- Sicherheitsnetz für Befehle ----------
+// Diese Befehle fragen IMMER nach (auch mit Vollzugriff) und werden im /goal-Modus blockiert,
+// weil dann niemand da ist, der sie bestätigen könnte.
+const DANGER = [
+  [/\brm\s+-[a-z]*(?:rf|fr)[a-z]*\s+(?:--no-preserve-root\s+)?(?:\/|~|\*|\$HOME|%USERPROFILE%)(?:\s|$)/i, "löscht rekursiv ein System- oder Home-Verzeichnis"],
+  [/\bformat(?:\.com)?\s+[a-z]:/i, "formatiert ein Laufwerk"],
+  [/\b(?:rd|rmdir)\s+\/s\b[^&|;]*\b[a-z]:\\?\s*(?:$|[&|;])/i, "löscht ein ganzes Laufwerk"],
+  [/\b(?:del|erase)\b[^&|;]*\/s\b[^&|;]*\b[a-z]:\\\*?\s*(?:$|[&|;])/i, "löscht ein ganzes Laufwerk"],
+  [/Remove-Item\b[^|;]*-Recurse[^|;]*\s["']?[a-z]:\\?["']?(?:\s|$|;)/i, "löscht rekursiv ein ganzes Laufwerk"],
+  [/\bgit\s+push\b[^;&|]*\s(?:--force(?:-with-lease)?|-f)\b/i, "überschreibt die Git-Historie auf dem Server (Force-Push)"],
+  [/\bgit\s+reset\s+--hard\b|\bgit\s+clean\s+-[a-z]*f/i, "verwirft lokale Änderungen unwiderruflich"],
+  [/\b(?:shutdown|restart-computer|stop-computer)\b/i, "fährt den PC herunter oder startet ihn neu"],
+  [/\breg(?:\.exe)?\s+delete\b|Remove-Item(?:Property)?\b[^|;]*\bHK(?:LM|CU):/i, "löscht Einträge in der Windows-Registry"],
+  [/\b(?:curl|wget|iwr|irm|invoke-webrequest|invoke-restmethod)\b[^|]*\|\s*(?:sh|bash|zsh|iex|invoke-expression|powershell|pwsh)\b/i, "lädt ein Skript aus dem Internet und führt es sofort aus"],
+  [/\bmkfs(?:\.\w+)?\b|\bdd\s+[^|;]*\bof=\/dev\//i, "überschreibt ein Laufwerk"],
+  [/:\(\)\s*\{\s*:\|:&\s*\};:/, "startet eine Fork-Bombe"],
+  [/\b(?:npm|pnpm|yarn)\s+publish\b|\bgh\s+release\s+create\b|\bgh\s+repo\s+delete\b/i, "veröffentlicht oder löscht etwas öffentlich"],
+  [/\b(?:Set-MpPreference|netsh\s+advfirewall\s+set)\b/i, "ändert Windows-Sicherheitseinstellungen (Virenschutz/Firewall)"],
+];
+/** Grund, warum ein Befehl gefährlich ist, oder null. */
+function dangerCheck(cmd) {
+  const c = String(cmd || "");
+  for (const [re, why] of DANGER) if (re.test(c)) return why;
+  return null;
+}
+
+/** Liegt `p` (relativ zu root) innerhalb des Projektordners? */
+function insideRoot(root, p) {
+  const r = path.relative(path.resolve(root), path.resolve(root, p || "."));
+  return !(r.startsWith("..") || path.isAbsolute(r));
+}
+
+/** 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 || ".");
+  // Schreiben nur innerhalb des Projekts – und nie in Gits interne Dateien.
+  if (t.name === "write" || t.name === "edit") {
+    if (!insideRoot(root, t.path)) return { result: "FEHLER: Schreiben außerhalb des Projektordners ist gesperrt (" + t.path + "). Arbeite nur mit Dateien im Projekt." };
+    if (/^\.git(?:[\\/]|$)/.test(path.relative(path.resolve(root), P(t.path)))) return { result: "FEHLER: Gits interne Dateien (.git/) werden nicht direkt bearbeitet – nutze git-Befehle." };
+  }
+  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";
+
+// ---------- Aufgabenliste (todo) ----------
+/** Werkzeug-Eingabe prüfen → saubere Liste [{ text, done }]. */
+function normalizeTodos(t) {
+  const items = Array.isArray(t && t.items) ? t.items : [];
+  return items.slice(0, 40).map((x) => (typeof x === "string" ? { text: x, done: false } : { text: String((x && x.text) || "").slice(0, 200), done: !!(x && x.done) })).filter((x) => x.text);
+}
+const todoSummary = (items) => "Aufgabenliste aktualisiert (" + items.filter((x) => x.done).length + "/" + items.length + " erledigt).";
+
+// ---------- Eigene Befehle: .mythos/commands/<name>.md ----------
+// Erste Zeile = Beschreibung (optional mit "# "), Rest = Anweisung an Mythos. $ARGUMENTS wird ersetzt.
+function loadCommands(dirs) {
+  const out = new Map();
+  for (const dir of dirs) {
+    let names = [];
+    try { names = fs.readdirSync(dir).filter((f) => /\.md$/i.test(f)); } catch { continue; }
+    for (const f of names) {
+      const text = readText(path.join(dir, f));
+      if (!text || !text.trim()) continue;
+      const name = f.replace(/\.md$/i, "").toLowerCase().replace(/[^a-z0-9äöüß_-]/g, "-");
+      const lines = text.replace(/\r\n/g, "\n").split("\n");
+      const desc = lines[0].replace(/^#+\s*/, "").trim().slice(0, 100);
+      out.set(name, { name: "/" + name, desc: desc || "Eigener Befehl", body: text.trim(), file: path.join(dir, f) });
+    }
+  }
+  return [...out.values()];
+}
+const fillCommand = (cmd, args) => (cmd.body.includes("$ARGUMENTS") ? cmd.body.split("$ARGUMENTS").join(args || "") : cmd.body + (args ? "\n\n" + args : ""));
+const COMMAND_TEMPLATE = "# Tests schreiben für eine Datei\nSchreibe gründliche Tests für $ARGUMENTS.\nNutze das Test-Framework, das im Projekt schon verwendet wird, und führe die Tests am Ende aus.\n";
+
+// ---------- Code-Review ----------
+const REVIEW_PROMPT = "Führe ein gründliches Code-Review der folgenden Änderungen durch. ÄNDERE KEINE DATEIEN – nur lesen und bewerten.\n" +
+  "Gliedere die Antwort so:\n**🐞 Fehler** (echte Bugs, mit Datei:Zeile)\n**⚠️ Risiken** (Sicherheit, Randfälle, Performance)\n**💡 Verbesserungen** (Lesbarkeit, Vereinfachung)\n**✅ Gut gelöst**\n" +
+  "Wenn eine Kategorie leer ist, schreib „nichts gefunden“. Sei konkret, keine allgemeinen Floskeln.";
+
+// ---------- Projektstatistik ----------
+const LANG = { js: "JavaScript", mjs: "JavaScript", cjs: "JavaScript", jsx: "JavaScript (JSX)", ts: "TypeScript", tsx: "TypeScript (TSX)", py: "Python", java: "Java", kt: "Kotlin", cs: "C#", cpp: "C++", cc: "C++", c: "C", h: "C/C++ Header", go: "Go", rs: "Rust", rb: "Ruby", php: "PHP", swift: "Swift", html: "HTML", css: "CSS", scss: "SCSS", vue: "Vue", svelte: "Svelte", json: "JSON", md: "Markdown", yml: "YAML", yaml: "YAML", sql: "SQL", sh: "Shell", ps1: "PowerShell", bat: "Batch", lua: "Lua", dart: "Dart", xml: "XML", toml: "TOML" };
+function projectStats(root) {
+  const byLang = new Map(), big = [];
+  let files = 0, lines = 0, bytes = 0, skipped = 0;
+  const walk = (dir) => {
+    let entries; try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (files > 30000) return;
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) { if (!SKIP_DIRS.has(e.name)) walk(full); continue; }
+      const ext = path.extname(e.name).slice(1).toLowerCase(), lang = LANG[ext];
+      if (!lang) { skipped++; continue; }
+      let st; try { st = fs.statSync(full); } catch { continue; }
+      if (st.size > 2e6) { skipped++; continue; }
+      const text = readText(full); if (text == null) continue;
+      const n = text ? text.split("\n").length : 0;
+      files++; lines += n; bytes += st.size;
+      const l = byLang.get(lang) || { files: 0, lines: 0 }; l.files++; l.lines += n; byLang.set(lang, l);
+      big.push({ file: path.relative(root, full).split(path.sep).join("/"), lines: n });
+    }
+  };
+  walk(root);
+  big.sort((a, b) => b.lines - a.lines);
+  const langs = [...byLang.entries()].sort((a, b) => b[1].lines - a[1].lines);
+  const fmt = (n) => n.toLocaleString("de-DE");
+  let md = "### 📊 Projektstatistik: " + path.basename(root) + "\n\n";
+  md += "**" + fmt(files) + " Code-Dateien · " + fmt(lines) + " Zeilen · " + (bytes / 1024 / 1024).toFixed(1) + " MB**" + (skipped ? " (" + fmt(skipped) + " andere Dateien übersprungen)" : "") + "\n\n";
+  if (langs.length) {
+    md += "| Sprache | Dateien | Zeilen | Anteil |\n|---|---:|---:|---:|\n";
+    md += langs.slice(0, 12).map(([name, v]) => "| " + name + " | " + fmt(v.files) + " | " + fmt(v.lines) + " | " + Math.round((v.lines / Math.max(1, lines)) * 100) + " % |").join("\n") + "\n\n";
+  }
+  if (big.length) md += "**Größte Dateien:**\n" + big.slice(0, 5).map((b) => "- `" + b.file + "` – " + fmt(b.lines) + " Zeilen").join("\n") + "\n";
+  return md;
+}
+
+// ---------- Chat als Markdown ----------
+function chatToMarkdown(title, messages) {
+  const date = new Date().toLocaleString("de-DE");
+  let md = "# " + (title || "Mythos-Chat") + "\n\n_Exportiert aus Mythos Code am " + date + "_\n\n---\n\n";
+  for (const m of messages) md += (m.role === "user" ? "## 🧑 Du\n\n" : m.role === "tool" ? "#### ⚙ " : "## ✦ Mythos\n\n") + String(m.text || "").trim() + "\n\n";
+  return md;
+}
+
+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));
+// Konfiguration (mit API-Schlüssel) nur für den eigenen Benutzer lesbar.
+const save = (c) => { fs.writeFileSync(CFG, JSON.stringify(c, null, 2), { mode: 0o600 }); try { fs.chmodSync(CFG, 0o600); } catch { /* Windows: Benutzerordner ist ohnehin privat */ } };
 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);
 
 const SITE = process.env.MYTHOS_SITE_URL || "https://ai-mythos.lovable.app";
 const FN = process.env.MYTHOS_FN_URL || API.replace(/\/v1-messages$/, "");
@@ -63,30 +451,93 @@ async function login() {
 
 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;
+  // Markdown-Tabellen: Trennzeile als Linie, Zellen als ausgerichtete Spalten.
+  if (/^\s*\|.*\|\s*$/.test(line)) {
+    if (/^\s*\|[\s:|-]+\|\s*$/.test(line)) return C.d + "  " + "─".repeat(52) + C.x;
+    const cells = line.trim().replace(/^\||\|$/g, "").split("|").map((c) => c.trim().replace(/\*\*(.+?)\*\*/g, "$1"));
+    return "  " + cells.map((c, i) => (i === 0 ? c.padEnd(22) : c.padStart(9))).join(" ");
+  }
+  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 = "";
@@ -98,18 +549,21 @@ 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 (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))));
@@ -118,44 +572,313 @@ 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) {
+  if (t.name === "todo") {
+    const items = normalizeTodos(t);
+    if (!items.length) return 'FEHLER: "items" fehlt – sende die komplette Liste.';
+    const done = items.filter((x) => x.done).length;
+    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);
+  }
+  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);
+  // Sicherheitsnetz: gefährliche Befehle fragen immer nach (auch mit --yes) und werden bei /goal blockiert.
+  const why = t.name === "run" ? 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.";
+    stopTick();
+    const a = (await ask(C.r + "   Wirklich ausführen? [j/N] " + C.x)).trim().toLowerCase();
+    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) {
     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 ? 4000 : 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 > 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 (!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"],
+  ["/review [schwerpunkt]", "Code-Review der Git-Änderungen (ändert nichts)"],
+  ["/pr [branch]", "Branch pushen und Pull Request erstellen"],
+  ["/stats", "Projektstatistik: Dateien, Zeilen, Sprachen"],
+  ["/export [datei]", "Chat als Markdown-Datei speichern"],
+  ["/kompakt", "Langen Chat zusammenfassen und Tokens sparen"],
+  ["@pfad/datei", "Datei in der Nachricht erwähnen – ihr Inhalt geht mit"],
+  ["/befehle", "Eigene Befehle (.mythos/commands/*.md) anzeigen"],
+  ["/exit", "Beenden"],
+];
+
+/** @pfad in der Eingabe → Dateien im Projekt, die es gibt (max. 8, je 60.000 Zeichen). */
+function mentionedFiles(text) {
+  const paths = [...new Set([...text.matchAll(/(?:^|\s)@([^\s@]+)/g)].map((m) => m[1].replace(/[.,;:!?)]+$/, "")))].slice(0, 8);
+  const out = [];
+  for (const p of paths) {
+    const full = path.resolve(ROOT, p);
+    if (path.relative(ROOT, full).startsWith("..")) continue;
+    try { if (fs.statSync(full).isFile()) { const c = readText(full); if (c != null && !c.includes("\u0000")) out.push({ name: p, content: c.slice(0, 60000) }); } } catch { /* gibt es nicht */ }
+  }
+  return out;
+}
+const COMMAND_DIRS = [path.join(os.homedir(), ".mythos", "commands"), path.join(ROOT, ".mythos", "commands")];
+const mdLines = (md) => { const st = { code: false }; return md.split("\n").map((l) => mdLine(l, st)).join("\n"); };
+async function pullRequest(name) {
+  const head = git(["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (!head.ok) return console.log(C.r + "Kein Git-Repository." + C.x + "\n");
+  if (git(["status", "--porcelain"]).out.trim()) return console.log(C.y + "Es gibt noch nicht committete Änderungen – erst /commit, dann /pr." + C.x + "\n");
+  if (!git(["remote", "get-url", "origin"]).out.trim()) return console.log(C.y + "Kein Remote „origin“ eingerichtet – verbinde das Projekt zuerst mit GitHub (git remote add origin <url>)." + C.x + "\n");
+  let branch = head.out.trim();
+  if (!autoYes && !/^[jy]/i.test((await ask(C.d + "Branch pushen und Pull Request erstellen? [j/N] " + C.x)).trim())) return console.log("Abgebrochen.\n");
+  if (/^(main|master)$/.test(branch)) {
+    branch = name ? name.replace(/\s+/g, "-") : "mythos/" + new Date().toISOString().slice(0, 16).replace(/[-:T]/g, "");
+    const co = git(["checkout", "-b", branch]); if (!co.ok) return console.log(C.r + co.out + C.x);
+  }
+  const push = git(["push", "-u", "origin", branch]); if (!push.ok) return console.log(C.r + push.out.trim() + C.x + "\n");
+  try { const out = execFileSync("gh", ["pr", "create", "--fill"], { cwd: ROOT, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }); return console.log(C.g + "🔀 " + out.trim() + C.x + "\n"); }
+  catch (e) {
+    const m = git(["remote", "get-url", "origin"]).out.trim().match(/github\.com[:/](.+?)(?:\.git)?$/);
+    if (!m) return console.log(C.r + ((e.stderr || "") + "" || "Kein GitHub-Remote gefunden.") + C.x + "\n");
+    const url = "https://github.com/" + m[1] + "/compare/" + branch + "?expand=1";
+    openBrowser(url);
+    return console.log(C.g + "🔀 Branch „" + branch + "“ gepusht. PR-Seite im Browser: " + url + C.x + (e.code === "ENOENT" ? C.d + "\n   (Mit der GitHub-CLI „gh“ würde der PR direkt erstellt.)" + C.x : "") + "\n");
+  }
+}
+
+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"); }
+  if (cmd === "/review") {
+    const st = git(["status", "--porcelain"]);
+    if (!st.ok) return console.log(C.r + "Kein Git-Repository." + C.x + "\n");
+    const diff = (git(["diff", "HEAD"]).out || git(["diff"]).out).trim();
+    if (!diff && !st.out.trim()) return console.log("🔍 Keine Änderungen – nichts zu prüfen.\n");
+    return turn(history, REVIEW_PROMPT + (arg ? "\n\nBesonders beachten: " + arg : "") + "\n\n" + st.out + "\n```diff\n" + diff.slice(0, 60000) + "\n```");
+  }
+  if (cmd === "/pr") return pullRequest(arg);
+  if (cmd === "/kompakt") {
+    if (history.length < 4) return console.log("🗜 Der Chat ist noch kurz – Komprimieren lohnt sich erst später.\n");
+    const before = Math.ceil(history.reduce((a, m) => a + String(m.content).length, 0) / 4);
+    if (before < 1500) return console.log("🗜 Der Verlauf hat erst ≈ " + fmtTokens(before) + " Tokens – Komprimieren lohnt sich ab etwa 1,5k.\n");
+    const transcript = history.map((m) => (m.role === "user" ? "NUTZER/WERKZEUG: " : "MYTHOS: ") + String(m.content).slice(0, 3000)).join("\n\n").slice(-60000);
+    process.stdout.write(C.d + "🗜 Fasse den Chat zusammen…" + C.x);
+    stopped = false;
+    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();
+    } catch (e) { clearLine(); return console.log(C.r + "⚠ " + e.message + C.x + "\n"); }
+    clearLine();
+    history.length = 0;
+    history.push({ role: "user", content: "Zusammenfassung des bisherigen Chats (komprimiert):\n\n" + sum }, { role: "assistant", content: "Verstanden – ich arbeite auf Basis dieser Zusammenfassung weiter." });
+    return console.log(mdLines(sum) + "\n" + C.g + "🗜 Komprimiert: ≈ " + fmtTokens(before) + " → ≈ " + fmtTokens(Math.ceil(sum.length / 4)) + " Tokens" + C.x + "\n");
+  }
+  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());
+    fs.writeFileSync(file, chatToMarkdown("Mythos-Chat – " + path.basename(ROOT), msgs));
+    return console.log(C.g + "✓ Gespeichert: " + file + C.x + "\n");
+  }
+  if (cmd === "/befehle") {
+    const list = loadCommands(COMMAND_DIRS);
+    return console.log(list.length ? list.map((c) => "  " + C.c + c.name.padEnd(20) + C.x + c.desc).join("\n") + "\n" : "Noch keine eigenen Befehle. Leg eine Markdown-Datei in .mythos/commands/ an, z. B. tests.md → /tests.\nErste Zeile = Beschreibung, Rest = Anweisung an Mythos, $ARGUMENTS = was du dahinter schreibst.\n");
+  }
+  const own = loadCommands(COMMAND_DIRS).find((c) => c.name === cmd);
+  if (own) return turn(history, fillCommand(own, arg));
+  console.log("Unbekannter Befehl: " + cmd + " – /hilfe zeigt alle Befehle.\n");
 }
 
 async function main() {
@@ -163,15 +886,21 @@ async function main() {
   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);
+    const files = mentionedFiles(text);
+    if (files.length) console.log(C.d + "📎 " + files.map((f) => f.name).join(", ") + C.x);
+    await turn(history, text + files.map((f) => "\n\n### " + f.name + "\n```\n" + f.content + "\n```").join(""), images);
   }
   rl.close();
 }

package/package.json

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