reasonix 0.50.0 → 0.51.0

package/dist/index.js

@@ -3,7 +3,7 @@ import { createParser } from "eventsource-parser";
 
 // src/config.ts
 import { randomBytes } from "crypto";
-import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { mkdirSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { dirname, isAbsolute, join, resolve } from "path";
 import { z } from "zod";
@@ -231,11 +231,52 @@ var TONE_ACTIVE = proxyTokens((theme) => theme.toneActive);
 var SURFACE = proxyTokens((theme) => theme.surface);
 var CARD = proxyTokens((theme) => theme.card);
 
+// src/core/atomic-write.ts
+import { chmodSync, copyFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
+var defaultFs = {
+  writeFileSync,
+  chmodSync,
+  renameSync,
+  copyFileSync,
+  unlinkSync
+};
+function atomicWriteSync(path2, body, tmp, mode = 384, fs5 = defaultFs) {
+  try {
+    fs5.writeFileSync(tmp, body, "utf8");
+    try {
+      fs5.chmodSync(tmp, mode);
+    } catch {
+    }
+    try {
+      fs5.renameSync(tmp, path2);
+    } catch (err) {
+      if (err.code !== "EXDEV") throw err;
+      fs5.copyFileSync(tmp, path2);
+      try {
+        fs5.chmodSync(path2, mode);
+      } catch {
+      }
+    }
+  } catch (err) {
+    try {
+      fs5.unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+  try {
+    fs5.unlinkSync(tmp);
+  } catch {
+  }
+}
+
 // src/index/config.ts
 import picomatch from "picomatch";
 var DEFAULT_INDEX_EXCLUDES = {
   dirs: [
     "node_modules",
+    ".devenv",
+    ".direnv",
     ".git",
     ".hg",
     ".svn",
@@ -621,12 +662,7 @@ function readConfig(path2 = defaultConfigPath()) {
 function writeConfig(cfg, path2 = defaultConfigPath()) {
   mkdirSync(dirname(path2), { recursive: true });
   const tmp = `${path2}.${process.pid}.tmp`;
-  writeFileSync(tmp, JSON.stringify(cfg, null, 2), "utf8");
-  try {
-    chmodSync(tmp, 384);
-  } catch {
-  }
-  renameSync(tmp, path2);
+  atomicWriteSync(path2, JSON.stringify(cfg, null, 2), tmp);
 }
 function loadLanguage(path2 = defaultConfigPath()) {
   return readConfig(path2).lang;
@@ -840,8 +876,8 @@ function computeWait(attempt, initial, cap, retryAfter) {
 }
 function sleep(ms, signal) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve15, reject) => {
-    const timer = setTimeout(resolve15, ms);
+  return new Promise((resolve16, reject) => {
+    const timer = setTimeout(resolve16, ms);
     if (signal) {
       const onAbort = () => {
         clearTimeout(timer);
@@ -929,8 +965,8 @@ var DeepSeekClient = class {
     const waitMs = Math.max(0, this.nextChatRequestAt - now);
     this.nextChatRequestAt = Math.max(now, this.nextChatRequestAt) + this.minChatIntervalMs;
     if (waitMs <= 0) return;
-    await new Promise((resolve15, reject) => {
-      const timer = setTimeout(resolve15, waitMs);
+    await new Promise((resolve16, reject) => {
+      const timer = setTimeout(resolve16, waitMs);
       signal?.addEventListener(
         "abort",
         () => {
@@ -1146,10 +1182,10 @@ var PauseGate = class {
         `${kind}: no confirmation listener registered \u2014 cannot prompt the user. This tool can only be used inside an interactive Reasonix session.`
       );
     }
-    return new Promise((resolve15) => {
+    return new Promise((resolve16) => {
       const id = this._nextId++;
       const request = { id, kind, payload };
-      this._pending.set(id, { resolve: resolve15, request });
+      this._pending.set(id, { resolve: resolve16, request });
       for (const fn of this._listeners) {
         try {
           fn(request);
@@ -1920,6 +1956,8 @@ var EN = {
     deepseek5xxUnreachable: " DeepSeek API is unreachable from your network \u2014 could be a wider DS outage or a local network issue.",
     deepseek5xxActionNetwork: " Try: (1) check your network, (2) wait 30s and retry, (3) status page: https://status.deepseek.com.",
     deepseek5xxActionRetry: " Try: (1) wait 30s and retry, (2) /model to switch model, (3) status page: https://status.deepseek.com.",
+    upstream5xxHead: "Upstream service unavailable ({status}) at {host} \u2014 the configured API endpoint returned a server error, not a Reasonix bug. Already retried 4\xD7 with backoff.",
+    upstream5xxActionRetry: " Try: (1) check that the local/proxy model server is up, (2) wait and retry, (3) /model to switch model.",
     innerNoMessage: "(no message)",
     reasonAborted: "[aborted by user (Esc) \u2014 summarizing what I found so far]",
     reasonContextGuard: "[context budget running low \u2014 summarizing before the next call would overflow]",
@@ -2100,6 +2138,7 @@ var EN = {
       modelSet: "model \u2192 {id}",
       effortStatus: "effort \u2192 {current}   (pick: {list})",
       effortUsage: "usage: /effort <{list}>   (high is the safe default; max is a DeepSeek extension)",
+      effortUsageNoMax: "usage: /effort <{list}>",
       effortSet: "effort \u2192 {effort}",
       budgetNoCap: "no session budget set \u2014 Reasonix will keep going until you stop it. Set one with: /budget <usd>   (e.g. /budget 5)",
       budgetStatus: "budget: ${spent} of ${cap} ({pct}%) \xB7 /budget off to clear, /budget <usd> to change",
@@ -2912,6 +2951,1707 @@ var EN = {
   }
 };
 
+// src/i18n/de.ts
+var de = {
+  ...EN,
+  common: {
+    ...EN.common,
+    error: "Fehler",
+    warning: "Warnung",
+    loading: "Wird geladen...",
+    done: "Fertig",
+    cancel: "Abbrechen",
+    confirm: "Best\xE4tigen",
+    back: "Zur\xFCck",
+    next: "Weiter",
+    tool: "Werkzeug",
+    running: "l\xE4uft",
+    noTurns: "(noch keine Turns)"
+  },
+  cli: {
+    ...EN.cli,
+    description: "DeepSeek-natives Agent-Framework, gebaut f\xFCr Cache-Treffer und g\xFCnstige Tokens.",
+    continue: "Die zuletzt verwendete Chat-Sitzung fortsetzen, ohne die Auswahl anzuzeigen.",
+    setup: "Interaktiver Assistent f\xFCr API-Schl\xFCssel und MCP-Server. Jederzeit erneut ausf\xFChrbar.",
+    chat: "Interaktive Ink-TUI mit Live-Cache- und Kostenanzeige.",
+    run: "Eine einzelne Aufgabe nicht-interaktiv ausf\xFChren, Ausgabe wird gestreamt.",
+    stats: "Nutzungsdashboard anzeigen.",
+    doctor: "Gesundheitscheck mit einem Befehl.",
+    code: "Code-Editor-Chat \u2014 Dateisystem-Werkzeuge mit Wurzel in <dir> (Standard: cwd), Coding-System-Prompt, v4-flash-Baseline.",
+    commit: "Commit-Nachricht aus der gestagten Diff entwerfen.",
+    sessions: "Gespeicherte Chat-Sitzungen auflisten oder nach Name anzeigen.",
+    pruneSessions: "Inaktive Sitzungen ab N Tagen l\xF6schen (Standard 90). Mit --dry-run zur Vorschau.",
+    events: "Kernel-Event-Log-Seite lesbar ausgeben.",
+    replay: "Interaktive Ink-TUI zum Durchbl\xE4ttern eines Transkripts.",
+    diff: "Zwei Transkripte in einer geteilten Ink-TUI vergleichen.",
+    mcp: "Model-Context-Protocol-Hilfsprogramme \u2014 Server entdecken, Setup testen.",
+    index: "Lokalen semantischen Suchindex erstellen (oder inkrementell aktualisieren).",
+    version: "Reasonix-Version ausgeben.",
+    update: "Nach einer neueren Reasonix-Version suchen und installieren."
+  },
+  stats: {
+    ...EN.stats,
+    usageHint: "F\xFChre `reasonix chat`, `reasonix code` oder `reasonix run <task>` aus \u2013 jeden Turn",
+    usageDetail: "H\xE4ngt eine Zeile an das Log an; `reasonix stats` fasst sie zusammen."
+  },
+  run: {
+    ...EN.run,
+    missingApiKey: "DEEPSEEK_API_KEY ist nicht gesetzt und stdin ist kein TTY (Nachfrage nicht m\xF6glich).\nSetze die Umgebungsvariable oder starte einmal interaktiv `reasonix chat`, um einen Schl\xFCssel zu speichern.\n"
+  },
+  sessions: {
+    ...EN.sessions,
+    emptyHint: "noch keine gespeicherten Sitzungen \u2013 starte `reasonix chat` (Sitzungen werden automatisch gespeichert, au\xDFer mit --no-session).",
+    listHeader: "Gespeicherte Sitzungen (~/.reasonix/sessions/):",
+    inspectHint: "Ansehen:       reasonix sessions <name>",
+    resumeHint: "Fortsetzen:    reasonix chat --session <name>",
+    noSession: 'keine Sitzung namens "{name}" (oder sie ist leer).',
+    lookedAt: "Angesehen: {path}",
+    noIdleSessions: "Keine Sitzungen seit >= {days} Tagen inaktiv. Nichts bereinigt.",
+    wouldPrune: "W\xFCrde {count} Sitzung(en) bereinigen, die >= {days} Tage inaktiv sind:",
+    dryRunHint: "Ohne --dry-run erneut ausf\xFChren, um wirklich zu l\xF6schen.",
+    prunedCount: "{count} Sitzung(en) bereinigt, die >= {days} Tage inaktiv waren:",
+    daysInvalid: "--days muss eine positive ganze Zahl sein (erhalten: {days})."
+  },
+  ui: {
+    ...EN.ui,
+    tipShownOnce: "einmal angezeigt",
+    modelOverride: "das Standardmodell \xFCberschreiben",
+    noSession: "Sitzungsspeicherung f\xFCr diesen Durchlauf deaktivieren",
+    noMouseHint: "SGR-Mausverfolgung deaktivieren; stellt die native Auswahl per Ziehen und Rechtsklick wieder her",
+    noProxyHint: "HTTPS_PROXY / HTTP_PROXY f\xFCr diesen Durchlauf ignorieren; direkt verbinden",
+    resumeHint: "die angegebene Sitzung zwangsweise fortsetzen (auch wenn sie inaktiv ist)",
+    newHint: "Eine neue Sitzung erzwingen (--session / --continue ignorieren)",
+    transcriptHint: "Pfad zum Speichern der JSONL-Ausgabe",
+    budgetHint: "Sitzungs-USD-Obergrenze \u2013 warnt bei 80 %, verweigert den n\xE4chsten Zug bei 100 %",
+    modelIdHint: "DeepSeek-Modell-ID (z. B. deepseek-v4-flash)",
+    systemPromptHint: "die Standard-Systemeingabeaufforderung \xFCberschreiben",
+    effortHint: "Denkaufwand \u2013 niedrig|mittel|hoch|maximal",
+    sessionNameHint: "Sitzungsname (Standard: \u201Edefault\u201C)",
+    ephemeralHint: "Sitzungsspeicherung f\xFCr diesen Durchlauf deaktivieren",
+    mcpSpecHint: "MCP-Server-Spezifikation (wiederholbar)",
+    mcpPrefixHint: "Stelle diesen String vor die Namen der MCP-Tools",
+    noConfigHint: "Ignoriere bei diesem Durchlauf die Datei ~/.reasonix/config.json",
+    effortHintShort: "Denkaufwand \u2013 niedrig|mittel|hoch|maximal",
+    budgetHintShort: "Sitzungs-USD-Obergrenze",
+    transcriptHintShort: "Pfad zum JSONL-Transkript",
+    mcpSpecHintShort: "MCP-Server-Spezifikation (wiederholbar)",
+    mcpPrefixHintShort: "Pr\xE4fix f\xFCr MCP-Toolnamen",
+    dryRunHint: "anzeigen, was installiert w\xFCrde, ohne es tats\xE4chlich zu installieren",
+    rebuildHint: "den Index komplett neu erstellen",
+    embedModelHint: "Name des Einbettungsmodells",
+    projectDirHint: "Projektstammverzeichnis",
+    ollamaUrlHint: "Ollama-Server-URL",
+    skipPromptsHint: "Best\xE4tigungsaufforderungen \xFCberspringen",
+    verboseHint: "Alle Metadaten der Sitzung anzeigen",
+    pruneDaysHint: "Sitzungen l\xF6schen, die seit mindestens dieser Anzahl von Tagen inaktiv sind (Standard: 90)",
+    pruneDryRunHint: "Liste auf, was gel\xF6scht w\xFCrde, ohne etwas zu entfernen",
+    eventTypeHint: "Nach Veranstaltungstyp filtern",
+    eventSinceHint: "Beginne mit dieser Ereignis-ID",
+    eventTailHint: "Nur die letzten N Ereignisse anzeigen",
+    jsonHint: "Ausgabe als JSON",
+    projectionHint: "Zeige den voraussichtlichen Zustand bei jedem Ereignis an",
+    printHint: "Anzeige \xFCber stdout statt \xFCber die TUI",
+    headHint: "Zeige nur die ersten N Ereignisse an",
+    tailHint: "Nur die letzten N Ereignisse anzeigen",
+    mdReportHint: "Erstelle einen Markdown-Diff-Bericht unter diesem Pfad",
+    printHintTable: "Eine Tabelle auf die Standardausgabe ausgeben",
+    tuiHint: "\xD6ffne die interaktive TUI",
+    labelAHint: "Bezeichnung f\xFCr den linken Bereich",
+    labelBHint: "Bezeichnung f\xFCr den rechten Bereich",
+    mcpListDescription: "Durchsuche das MCP-Register (offiziell \u2192 smithery \u2192 lokaler Fallback)",
+    mcpInspectDescription: "die Spezifikationen eines MCP-Servers pr\xFCfen (Tools, Ressourcen, Eingabeaufforderungen)",
+    mcpSearchDescription: "Suche in der MCP-Registrierung nach Servern, die einer Suchanfrage entsprechen",
+    mcpInstallDescription: "Einen MCP-Server anhand seines Namens installieren (schreibt dessen Spezifikation in deine Konfiguration)",
+    mcpBrowseDescription: "Interaktiver Marktplatz-Browser \u2013 tippe, um zu filtern, dr\xFCcke die Eingabetaste, um zu installieren",
+    mcpLocalHint: "Nur den mitgelieferten Offline-Katalog anzeigen",
+    mcpRefreshHint: "den 24-Stunden-Cache umgehen und neu abrufen",
+    mcpLimitHint: "Maximale Anzahl der anzuzeigenden Eintr\xE4ge",
+    mcpPagesHint: "Lade gleich so viele Seiten (Standard: 1)",
+    mcpAllHint: "Jede Seite laden (beim ersten Mal etwas langsam)",
+    mcpMaxPagesHint: "Begrenze die Anzahl der Seiten, die bei der Suche durchsucht werden sollen (Standard: 20)",
+    jsonHintCatalog: "Ausgabe als JSON",
+    jsonHintReport: "Gib den Inspektionsbericht als JSON aus",
+    modelOverrideFlash: "das Modell \xFCberschreiben (Standard: deepseek-v4-flash)",
+    skipConfirmHint: "Die Best\xE4tigungsabfrage \xFCberspringen",
+    welcome: "Starte jederzeit `reasonix`, um zu chatten \u2013 deine Einstellungen bleiben gespeichert.",
+    taglineChat: "DeepSeek-nativer Agent",
+    taglineCode: "DeepSeek-nativer Coding-Agent",
+    taglineSub: "cache-first \xB7 flash-first",
+    startSessionHint: "Tippe eine Nachricht, um deine Sitzung zu starten",
+    inputPlaceholder: "Frag etwas... (tippe / f\xFCr Befehle, @ f\xFCr Dateien)",
+    busy: "Denke nach...",
+    thinking: "\u25B8 denke nach...",
+    undo: "R\xFCckg\xE4ngig",
+    undoHint: "Dr\xFCcke innerhalb von 5s zum R\xFCckg\xE4ngig machen",
+    applied: "angewendet",
+    rejected: "abgelehnt",
+    noDashboard: "Automatisch gestartetes eingebettetes Web-Dashboard unterdr\xFCcken.",
+    openDashboardHint: "Dashboard-URL sofort im Standard-Browser \xF6ffnen, sobald der Server bereit ist. Keine Wirkung bei --no-dashboard.",
+    dashboardPortHint: "Dashboard auf einen festen Port (1\u201365535) festlegen. Stabil \xFCber Neustarts hinweg \u2014 erforderlich f\xFCr SSH-Tunnel. Standard: ephemeral.",
+    dashboardPortInvalid: "\u25B2 --dashboard-port={value} wird ignoriert (muss eine ganze Zahl 1\u201365535 sein) \u2014 R\xFCckfall auf ephemeral",
+    dashboardAutoStartFailed: "\u25B2 Dashboard-Autostart fehlgeschlagen ({reason}) \u2014 /dashboard versuchen oder --no-dashboard zum Unterdr\xFCcken",
+    systemAppendHint: "Anweisungen an den Code-System-Prompt anh\xE4ngen. Ersetzt NICHT den Standard-Prompt \u2014 wird danach eingef\xFCgt.",
+    systemAppendFileHint: "Dateiinhalte an den Code-System-Prompt anh\xE4ngen. Ersetzt NICHT den Standard-Prompt. UTF-8, relativ zu cwd oder absolut.",
+    resumedSession: '\u25B8 Sitzung "{name}" fortgesetzt mit {count} vorherigen Nachrichten \xB7 /new f\xFCr frischen Start \xB7 /sessions zum Verwalten',
+    newSession: '\u25B8 Sitzung "{name}" (neu) \u2014 automatisch gespeichert w\xE4hrend des Chattens \xB7 /sessions zum Umbenennen oder L\xF6schen',
+    ephemeralSession: "\u25B8 ephemerer Chat (keine Sitzungspersistenz) \u2014 --no-session weglassen zum Aktivieren",
+    restoredEdits: "\u25B8 {count} ausstehende Edit-Block(s) aus einem unterbrochenen vorherigen Durchlauf wiederhergestellt \u2014 /apply zum \xDCbernehmen oder /discard zum Verwerfen.",
+    resumedPlan: "Fortgesetzter Plan \xB7 {when}{summary}"
+  },
+  code: {
+    ...EN.code,
+    workspaceConflict: "\u26A0 Arbeitsbereich enth\xE4lt Dateien einer anderen Agent-Plattform ({platforms}). Reasonix Code kann sie als Projektinhalt lesen; starte mit --dir <dein-projekt> neu, falls das nicht gew\xFCnscht ist.\n",
+    systemAppendEmpty: "--system-append ist leer \u2014 kein Prompt-Text wird angeh\xE4ngt\n",
+    systemAppendFileReadError: 'Fehler: kann --system-append-file "{filePath}" nicht lesen: {errorDetails}\n'
+  },
+  slash: {
+    ...EN.slash,
+    help: { ...EN.slash.help, description: "Vollst\xE4ndige Befehlsreferenz anzeigen" },
+    status: { ...EN.slash.status, description: "Aktuelles Modell, Flags, Kontext und Sitzung" },
+    effort: {
+      ...EN.slash.effort,
+      argsHint: "<niedrig|mittel|hoch|max>",
+      description: "Reasoning-Effort-Grenze (low|medium|high|max); high ist der sichere Standard f\xFCr vLLM/Azure"
+    },
+    model: {
+      ...EN.slash.model,
+      description: "DeepSeek-Modell-ID wechseln"
+    },
+    models: {
+      ...EN.slash.models,
+      description: "Verf\xFCgbare Modelle von DeepSeek /models abrufen"
+    },
+    language: {
+      description: "Laufzeitsprache wechseln",
+      argsHint: "<EN|zh-CN|de>",
+      success: "Sprache auf Deutsch umgestellt.",
+      unsupported: "Nicht unterst\xFCtzter Sprachcode: {code}. Unterst\xFCtzt: {supported}."
+    },
+    budget: {
+      ...EN.slash.budget,
+      description: "Session-USD-Grenze \u2014 warnt bei 80 %, verweigert n\xE4chsten Turn bei 100 %. Standardm\xE4\xDFig aus. /budget allein zeigt Status."
+    },
+    mcp: { ...EN.slash.mcp, description: "MCP-Server + Tools dieser Sitzung auflisten" },
+    resource: {
+      ...EN.slash.resource,
+      description: "MCP-Ressourcen durchsuchen + lesen (kein Arg \u2192 URIs auflisten; <uri> \u2192 Inhalt abrufen)"
+    },
+    prompt: {
+      ...EN.slash.prompt,
+      argsHint: "[Name]",
+      description: "MCP-Prompts durchsuchen + abrufen (kein Arg \u2192 Namen auflisten; <name> \u2192 Prompt rendern)"
+    },
+    memory: {
+      ...EN.slash.memory,
+      argsHint: "[Liste|<Name> anzeigen|<Name> vergessen|<Bereich> l\xF6schen \u2013 Best\xE4tigen]",
+      description: "Pinned Memory anzeigen / verwalten (REASONIX.md + ~/.reasonix/memory)"
+    },
+    skill: {
+      ...EN.slash.skill,
+      description: "Benutzer-Skills auflisten / ausf\xFChren (Projekt + benutzerdefiniert + global + builtin)"
+    },
+    hooks: {
+      ...EN.slash.hooks,
+      argsHint: "[Neu laden]",
+      description: "Aktive Hooks auflisten (settings.json unter .reasonix/) \xB7 reload liest von Platte neu"
+    },
+    permissions: {
+      ...EN.slash.permissions,
+      argsHint: "[Liste|<Pr\xE4fix> hinzuf\xFCgen|<Pr\xE4fix|N> entfernen|L\xF6schen (Best\xE4tigung erforderlich)]",
+      description: "Shell-Allowlist anzeigen / bearbeiten (builtin schreibgesch\xFCtzt \xB7 pro Projekt: ~/.reasonix/config.json)"
+    },
+    dashboard: {
+      ...EN.slash.dashboard,
+      argsHint: "[Stopp]",
+      description: "Eingebettetes Web-Dashboard starten (127.0.0.1, token-gesichert)"
+    },
+    update: {
+      ...EN.slash.update,
+      description: "Aktuelle vs. neueste Version anzeigen + Upgrade-Befehl"
+    },
+    stats: {
+      ...EN.slash.stats,
+      description: "Sitzungs\xFCbergreifendes Kosten-Dashboard (heute / Woche / Monat / gesamt \xB7 Cache-Treffer \xB7 vs. Claude)"
+    },
+    cost: {
+      ...EN.slash.cost,
+      argsHint: "[Text]",
+      description: "ohne Text \u2192 Ausgaben letzter Turn (Kostenkarte); mit Text \u2192 Kostensch\xE4tzung f\xFCr als n\xE4chster Senden (worst-case + likely-cache)"
+    },
+    doctor: {
+      ...EN.slash.doctor,
+      description: "Gesundheitscheck (API / Config / API-Reichweite / Index / Hooks / Projekt)"
+    },
+    context: {
+      ...EN.slash.context,
+      description: "Context-Window-Aufschl\xFCsselung (System / Tools / Log / Input)"
+    },
+    retry: {
+      ...EN.slash.retry,
+      description: "Letzte Nachricht k\xFCrzen & erneut senden (frischer Sample)"
+    },
+    compact: {
+      ...EN.slash.compact,
+      argsHint: "[Token]",
+      description: "\xDCberdimensionierte Tool-Ergebnisse + Tool-Call-Args im Log k\xFCrzen; Grenze in Tokens, Standard 4000"
+    },
+    cwd: {
+      ...EN.slash.cwd,
+      argsHint: "[Pfad]",
+      description: "Workspace-Root mid-Session wechseln \u2014 FS-/Shell-/Memory-Tools neu ausrichten, Projekt-Hooks neu laden, @-Mention-Walker aktualisieren"
+    },
+    stop: {
+      ...EN.slash.stop,
+      description: "Aktuellen Modell-Turn abbrechen (getippte Alternative zu Esc)"
+    },
+    feedback: {
+      ...EN.slash.feedback,
+      description: "GitHub-Issue mit Diagnoseinfo \xF6ffnen (in Zwischenablage kopiert)"
+    },
+    about: { ...EN.slash.about, description: "Projektinfo \u2014 Version, Website, Repo, Lizenz" },
+    keys: { ...EN.slash.keys, description: "Tastatur + Maus + Kopieren/Einf\xFCgen-Referenz" },
+    plans: {
+      ...EN.slash.plans,
+      description: "Aktive + archivierte Pl\xE4ne dieser Sitzung auflisten, neueste zuerst"
+    },
+    replay: {
+      ...EN.slash.replay,
+      description: "Archivierten Plan als schreibgesch\xFCtzte Time-Travel-Schnappschuss laden (Standard: neuester)"
+    },
+    sessions: {
+      ...EN.slash.sessions,
+      description: "Gespeicherte Sitzungen auflisten (aktuelle mit \u25B8 markiert)"
+    },
+    title: {
+      ...EN.slash.title,
+      description: "Modell bitten, diese Sitzung anhand des Gespr\xE4chs umzubenennen"
+    },
+    qq: {
+      ...EN.slash.qq,
+      description: "QQ-Kanal verbinden, inspizieren oder trennen (erste Verbindung f\xFChrt durch App-ID / App-Secret-Setup)"
+    },
+    setup: { ...EN.slash.setup, description: "Erinnert dich daran, `reasonix setup` auszuf\xFChren" },
+    semantic: {
+      ...EN.slash.semantic,
+      description: "Semantic-Search-Status anzeigen \u2014 Index erstellt? Ollama installiert? Wie aktivieren?"
+    },
+    clear: {
+      ...EN.slash.clear,
+      description: "Nur sichtbaren Scrollback leeren (Log/Kontext bleibt)"
+    },
+    new: {
+      ...EN.slash.new,
+      description: "Frisches Gespr\xE4ch beginnen (Kontext + Scrollback l\xF6schen)"
+    },
+    loop: {
+      ...EN.slash.loop,
+      argsHint: "<5s..6h> <Eingabeaufforderung>  \xB7  Stopp  \xB7  (keine Argumente = Status)",
+      description: "Prompt automatisch alle <intervall> erneut senden, bis du etwas eingibst / Esc / /loop stop"
+    },
+    init: {
+      ...EN.slash.init,
+      description: "Projekt scannen und eine REASONIX.md-Baseline erstellen (Modell schreibt; mit /apply reviewen). `force` \xFCberschreibt vorhandene Datei."
+    },
+    apply: {
+      ...EN.slash.apply,
+      description: "Ausstehende Edit-Blocks auf Platte schreiben (kein Arg \u2192 alle; `1`, `1,3` oder `1-4` \u2192 diese Teilmenge, Rest bleibt ausstehend)"
+    },
+    discard: {
+      ...EN.slash.discard,
+      description: "Ausstehende Edit-Blocks ohne Schreiben verwerfen (kein Arg \u2192 alle; Indizes \u2192 diese Teilmenge)"
+    },
+    walk: {
+      ...EN.slash.walk,
+      description: "Schrittweise durch ausstehende Edits gehen (git-add-p-Stil: y/n pro Block, a = Rest anwenden, A = AUTO umschalten)"
+    },
+    undo: { ...EN.slash.undo, description: "Letzten angewandten Edit-Batch r\xFCckg\xE4ngig machen" },
+    history: {
+      ...EN.slash.history,
+      description: "Jeden Edit-Batch dieser Sitzung auflisten (IDs f\xFCr /show, r\xFCckg\xE4ngig-Markierungen)"
+    },
+    show: {
+      ...EN.slash.show,
+      description: "Gespeicherte Edit-Diff ausgeben (ID weglassen f\xFCr neuesten nicht-r\xFCckg\xE4ngigen)"
+    },
+    commit: { ...EN.slash.commit, description: "git add -A && git commit -m ..." },
+    checkpoint: {
+      ...EN.slash.checkpoint,
+      argsHint: "[Name|Liste|<ID> l\xF6schen]",
+      description: "Jede Datei, die die Sitzung ber\xFChrt hat, als Schnappschuss sichern (Cursor-artiger interner Speicher, nicht Git). /checkpoint allein listet auf."
+    },
+    restore: {
+      ...EN.slash.restore,
+      description: "Dateien auf einen benannten Checkpoint zur\xFCcksetzen (siehe /checkpoint list)"
+    },
+    plan: {
+      ...EN.slash.plan,
+      argsHint: "[Ein|Aus]",
+      description: "Schreibgesch\xFCtzten Plan-Modus umschalten (Schreibzugriffe blockiert bis submit_plan + Genehmigung)"
+    },
+    mode: {
+      ...EN.slash.mode,
+      argsHint: "[Rezension|Auto|YOLO]",
+      description: "Edit-Gate: review (Warteschlange) \xB7 auto (anwenden+r\xFCckg\xE4ngig) \xB7 yolo (anwenden+auto-shell). Shift+Tab schaltet um."
+    },
+    jobs: {
+      ...EN.slash.jobs,
+      description: "Hintergrund-Jobs auflisten, die mit run_background gestartet wurden"
+    },
+    kill: {
+      ...EN.slash.kill,
+      argsHint: "Bezeichner",
+      description: "Hintergrund-Job nach ID beenden (SIGTERM \u2192 SIGKILL nach Gnadenfrist)"
+    },
+    logs: {
+      ...EN.slash.logs,
+      argsHint: "<id> [Zeilen]",
+      description: "Ausgabe eines Hintergrund-Jobs anzeigen (Standard letzte 80 Zeilen)"
+    },
+    btw: {
+      ...EN.slash.btw,
+      argsHint: "<Frage>",
+      description: "Kurze Randfrage stellen \u2014 wird von Grund auf beantwortet, nie zum Gespr\xE4chskontext hinzugef\xFCgt"
+    },
+    "search-engine": {
+      ...EN.slash["search-engine"],
+      description: "Web-Search-Backend wechseln \u2014 bing (Standard, funktioniert von CN ohne Proxy), searxng (selbst gehostet), metaso (kostenlos 100/Tag), tavily (kostenlos 1000/Monat), perplexity (AI-native) oder exa (AI-native)"
+    },
+    theme: {
+      ...EN.slash.theme,
+      argsHint: "[auto|dunkel|hell|mitternachtsblau|tiefblau|hoher Kontrast]",
+      description: "Terminal-Theme anzeigen oder speichern. Ohne Argument \xF6ffnet die Auswahl."
+    },
+    exit: { ...EN.slash.exit, description: "TUI beenden" }
+  },
+  wizard: {
+    ...EN.wizard,
+    languageTitle: "Sprache ausw\xE4hlen",
+    languageSubtitle: "Aus der Systemsprache erkannt. Sp\xE4ter mit /language wechselbar.",
+    welcomeTitle: "Willkommen bei Reasonix.",
+    apiKeyPrompt: "F\xFCge deinen DeepSeek-API-Schl\xFCssel ein, um loszulegen.",
+    apiKeyGetOne: "Erhalte einen unter: https://platform.deepseek.com/api_keys",
+    apiKeySavedLocally: "Lokal gespeichert unter {path}",
+    apiKeyInputLabel: "Schl\xFCssel > ",
+    apiKeyPlaceholder: "sk-...",
+    apiKeyInvalid: "Der Schl\xFCssel wirkt zu kurz \u2013 f\xFCge den vollst\xE4ndigen Token ein (16+ Zeichen, keine Leerzeichen).",
+    apiKeyChecking: "API-Schl\xFCssel wird gepr\xFCft...",
+    apiKeyRejected: "DeepSeek hat diesen API-Schl\xFCssel abgelehnt. F\xFCge einen g\xFCltigen Schl\xFCssel ein oder brich das Setup mit Esc ab.",
+    apiKeyCheckFailed: "Konnte diesen API-Schl\xFCssel gerade nicht verifizieren ({message}). \xDCberpr\xFCfe deine Netzwerkverbindung oder versuche es erneut.",
+    apiKeyPreview: "Vorschau: {redacted}",
+    themeTitle: "Theme ausw\xE4hlen",
+    themeSubtitle: "Die Vorschau aktualisiert sich beim Navigieren. Sp\xE4ter mit /theme \xE4nderbar.",
+    themeSampleHeading: "Beispiel",
+    themeFooter: "[\u2191\u2193] navigieren \xB7 [Enter] best\xE4tigen \xB7 [Esc] abbrechen",
+    themeCaption: {
+      ...EN.wizard.themeCaption,
+      dark: "K\xFChle dunkle T\xF6ne (Standard)",
+      light: "Helle klare Ansicht",
+      midnight: "Tokyo-Night-Palette",
+      "deep-blue": "Tiefblau auf Schwarz",
+      "high-contrast": "Barrierefreiheit"
+    },
+    mcpTitle: "Welche MCP-Server soll Reasonix f\xFCr dich einrichten?",
+    mcpUserArgsHint: "(du wirst {arg} bereitstellen)",
+    mcpFooterMulti: "[\u2191\u2193] navigieren  \xB7  [Leertaste] umschalten  \xB7  [Enter] best\xE4tigen  \xB7  [Esc] abbrechen  \xB7  leer = \xFCberspringen",
+    mcpArgsTitle: "{name} konfigurieren",
+    mcpArgsDirMissing: "Verzeichnis {path} existiert nicht.",
+    mcpArgsDirCreateHint: "[Y/Enter] erstellen (mkdir -p) \xB7 [N/Esc] anderen Pfad eingeben",
+    mcpArgsDirCreateFailed: "Konnte {path} nicht erstellen: {message}",
+    mcpArgsRequiredParam: "Erforderlicher Parameter: ",
+    mcpArgsEmpty: "{name} ben\xF6tigt einen Wert \u2014 leere Zeichenkette erhalten.",
+    mcpArgsNotADir: "{path} existiert, ist aber kein Verzeichnis.",
+    reviewTitle: "Bereit zum Speichern",
+    reviewLabelApiKey: "API-Schl\xFCssel",
+    reviewLabelLanguage: "Sprache",
+    reviewLabelTheme: "Theme",
+    reviewLabelMcp: "MCP",
+    reviewMcpNone: "(keine)",
+    reviewMcpServers: "{count} Server",
+    reviewSavesTo: "Speichert nach {path}",
+    reviewSaveError: "Konfiguration konnte nicht gespeichert werden: {message}",
+    reviewFooter: "[Enter] speichern \xB7 [Esc] abbrechen",
+    savedTitle: "\u25B8 Gespeichert.",
+    savedShellHint: 'Shell-Befehle, die das Modell ausf\xFChren m\xF6chte, fragen jedes Mal nach \u2013 w\xE4hle \xBBimmer erlauben" in der Eingabeaufforderung, um diesen genauen Befehl f\xFCr dieses Projekt auf die Whitelist zu setzen. Kein globales Allow-All-Flag (designbedingt).',
+    savedFooter: "[Enter] zum Beenden",
+    selectFooter: "[\u2191\u2193] navigieren \xB7 [Enter] best\xE4tigen \xB7 [Esc] abbrechen",
+    stepCounter: "Schritt {step}/{total} \xB7 ",
+    exitHint: "/exit zum Abbrechen",
+    themeSampleReasoning: "Denken"
+  },
+  themePicker: {
+    ...EN.themePicker,
+    header: "Theme",
+    footer: "\u2191\u2193 ausw\xE4hlen \xB7 \u23CE best\xE4tigen \xB7 Esc abbrechen",
+    currentPref: "Aktuelle Einstellung",
+    activeNow: "Jetzt aktiv",
+    autoDesc: "REASONIX_THEME oder Standard verwenden"
+  },
+  planFlow: {
+    ...EN.planFlow,
+    approveCardTitle: "Plan genehmigen",
+    approveCardMetaRight: "wartet",
+    openQuestionsBanner: "\u25B2 der Plan zeigt offene Fragen oder Risiken \u2014 w\xE4hle {refine}, um konkrete Antworten zu schreiben, bevor das Modell fortf\xE4hrt.",
+    openQuestionsHeader: "Offene Fragen / Risiken",
+    truncatedBodyMore: "\u2026 {n} weitere Zeile oben im Scrollback",
+    truncatedBodyMorePlural: "\u2026 {n} weitere Zeilen oben im Scrollback",
+    picker: {
+      ...EN.planFlow.picker,
+      accept: "akzeptieren",
+      acceptHint: "Jetzt ausf\xFChren, in Reihenfolge",
+      refine: "verfeinern",
+      refineHint: "Dem Agenten mehr Anweisungen geben, neuen Plan entwerfen",
+      revise: "\xFCberarbeiten",
+      reviseHint: "Plan inline bearbeiten vor der Ausf\xFChrung (Schritte \xFCberspringen/neu ordnen)",
+      reject: "ablehnen",
+      rejectHint: "Verwerfen, Agent versucht von Grund auf neu"
+    },
+    refineFooter: "\u23CE senden  \xB7  Esc zur\xFCck zur Auswahl",
+    refineQuestionsHeading: "Beantworte diese oder beschreibe die gew\xFCnschte \xC4nderung:",
+    modes: {
+      ...EN.planFlow.modes,
+      approve: {
+        ...EN.planFlow.modes.approve,
+        title: "Genehmigen \u2014 letzte Anweisungen?",
+        hint: "Beantworte Fragen aus dem Plan, f\xFCge Einschr\xE4nkungen hinzu oder dr\xFCcke einfach Enter zur Genehmigung.",
+        blankHint: " (Enter ohne Text = ohne Zusatzanweisungen genehmigen.)"
+      },
+      refine: {
+        ...EN.planFlow.modes.refine,
+        title: "Verfeinern \u2014 was soll das Modell \xE4ndern?",
+        hint: "Beschreibe, was falsch ist oder fehlt, oder beantworte Fragen aus dem Plan.",
+        blankHint: " (Enter ohne Text = Modell w\xE4hlt sichere Standardwerte f\xFCr offene Fragen.)"
+      },
+      reject: {
+        ...EN.planFlow.modes.reject,
+        title: "Ablehnen \u2014 sag dem Modell warum (optional)",
+        hint: "Sag dem Modell, was es an deinem Ziel falsch verstanden hat oder was du stattdessen m\xF6chtest.",
+        blankHint: " (Enter ohne Text = ohne Erkl\xE4rung abbrechen; das Modell fragt, was du m\xF6chtest.)"
+      },
+      "checkpoint-revise": {
+        ...EN.planFlow.modes["checkpoint-revise"],
+        title: "\xDCberarbeiten \u2014 was soll sich vor dem n\xE4chsten Schritt \xE4ndern?",
+        hint: "Umfangs\xE4nderung, Schritte \xFCberspringen, alternativer Ansatz \u2014 das Modell passt den Restplan an.",
+        blankHint: " (Enter ohne Text = mit aktuellem Plan fortfahren.)"
+      },
+      "choice-custom": {
+        ...EN.planFlow.modes["choice-custom"],
+        title: "Benutzerdefinierte Antwort \u2014 schreibe, was passt",
+        hint: "Freitext-Antwort. Das Modell liest sie w\xF6rtlich und f\xE4hrt fort \u2014 keine Notwendigkeit, die aufgef\xFChrten Optionen zu treffen.",
+        blankHint: " (Enter ohne Text = Modell fragen, was du eigentlich m\xF6chtest.)"
+      }
+    },
+    checkpoint: {
+      ...EN.planFlow.checkpoint,
+      title: "Checkpoint \u2014 Schritt erledigt",
+      continue: "Fortfahren \u2014 n\xE4chsten Schritt ausf\xFChren",
+      continueHint: "Modell f\xE4hrt mit dem n\xE4chsten Schritt fort.",
+      finish: "Abschlie\xDFen \u2014 zusammenfassen und beenden",
+      finishHint: "Modell zeichnet den letzten Schritt auf und fasst den abgeschlossenen Plan zusammen.",
+      revise: "\xDCberarbeiten \u2014 Feedback vor dem n\xE4chsten Schritt geben",
+      reviseHint: "Bleibe pausiert, tippe Anweisungen; Modell passt den Restplan an.",
+      stop: "Anhalten \u2014 Plan hier beenden",
+      stopHint: "Modell fasst zusammen, was getan wurde, und beendet."
+    },
+    stepList: {
+      ...EN.planFlow.stepList,
+      counter: "{total} Schritte",
+      counterSingular: "{total} Schritt",
+      counterDone: "{done}/{total} erledigt ({pct}%) \xB7 {total} Schritte",
+      counterDoneSingular: "{done}/{total} erledigt ({pct}%) \xB7 {total} Schritt"
+    },
+    noPlanSummary: "Noch kein Plan-Body \xFCbermittelt.",
+    detailCollapsedHint: "Strg+P erweitert die vollst\xE4ndigen Plan-Details.",
+    detailExpandedHint: "Strg+P klappt Details ein.",
+    detailHeader: "Plan-Details",
+    detailWindow: "Zeige Zeilen {start}-{end} von {total}",
+    detailScrollHint: "Bild\u2191/Bild\u2193 scrollt Details \xB7 Pos1/Ende springt",
+    reviseTitle: "Plan \xFCberarbeiten",
+    reviseSteps: "{count} Schritte",
+    reviseFooter: "\u2191\u2193 fokussieren  \xB7  Leertaste \xFCberspringen umschalten  \xB7  k/j verschieben  \xB7  \u23CE akzeptieren  \xB7  Esc abbrechen",
+    riskMed: " mittel",
+    riskHigh: " hoch",
+    completeMsg: "\u25B8 Plan abgeschlossen \u2014 alle {total} Schritt{e} erledigt \xB7 archiviert"
+  },
+  app: {
+    ...EN.app,
+    dashboardStopped: "\u25B8 Dashboard gestoppt.",
+    notedScopeProject: "Projekt",
+    notedScopeGlobal: "global",
+    commandFailed: "! Befehl fehlgeschlagen",
+    btwFailed: "/btw fehlgeschlagen",
+    walkCancelledRemaining: "\u25B8 Walk abgebrochen \u2014 {count} Block(s) noch ausstehend.",
+    walkCancelled: "\u25B8 Walk abgebrochen.",
+    editModeYolo: "\u25B8 Edit-Modus: YOLO \u2014 Edits UND Shell-Befehle auto-ausf\xFChren. /undo macht Edits immer noch r\xFCckg\xE4ngig. Vorsicht.",
+    editModeAuto: "\u25B8 Edit-Modus: AUTO \u2014 Edits werden sofort angewandt; dr\xFCcke u innerhalb von 5s zum R\xFCckg\xE4ngigmachen (Leertaste pausiert den Timer). Shell-Befehle fragen weiterhin.",
+    editModeReview: "\u25B8 Edit-Modus: review \u2014 Edits warten auf /apply (oder y) / /discard (oder n)",
+    rejectedEdit: "\u25B8 Edit abgelehnt: {path}{context}",
+    autoApprovingRest: "\u25B8 Restliche Edits f\xFCr diesen Turn werden automatisch genehmigt",
+    flippedAutoSession: "\u25B8 F\xFCr den Rest der Sitzung auf AUTO umgeschaltet (gespeichert)",
+    flippedAutoWalk: "\u25B8 Auf AUTO umgeschaltet \u2014 zuk\xFCnftige Edits werden sofort angewandt. Walk beendet.",
+    notedMemory: "\u25B8 vermerkt ({scope}) \u2014 {verb} {path}",
+    notedVerbCreated: "erstellt",
+    notedVerbAppended: "Angeh\xE4ngt an",
+    memoryWriteFailed: "# Speicherschreibfehler",
+    verboseOn: "\u25B8 Ausf\xFChrlicher Modus an \u2014 vollst\xE4ndiges Reasoning + Tool-Ausgabe",
+    verboseOff: "\u25B8 Ausf\xFChrlicher Modus aus \u2014 head/tail-K\xFCrzung wiederhergestellt",
+    steerInjected: "\u25B8 Steuerung in Warteschlange \u2014 wird nach dem aktuellen Schritt hinzugef\xFCgt",
+    steerCommandRejected: "\u25B8 Befehle sind deaktiviert, w\xE4hrend ein Turn gesteuert wird",
+    btwUsage: "\u25B8 /btw <Frage> \u2014 eine Randfrage stellen, ohne den Gespr\xE4chskontext zu verschmutzen.",
+    btwHeader: "\u226B btw",
+    restoreCodeOnly: "\u25B8 /restore ist nur im Code-Modus verf\xFCgbar",
+    hookUserPromptSubmit: "UserPromptSubmit-Hook",
+    hookStop: "Stop-Hook",
+    atMentions: "\u25B8 @mentions: {parts}",
+    atUrl: "\u25B8 @url: {parts}",
+    atUrlFailed: "@url Erweiterung fehlgeschlagen",
+    sessionTitleNoSession: "\u25B8 Keine persistierte Sitzung aktiv, also nichts umzubenennen.",
+    sessionTitleNoContent: "\u25B8 Noch nicht genug Gespr\xE4chsinhalt, um diese Sitzung zu benennen.",
+    sessionTitleNoTitle: "\u25B8 Das Modell hat keinen brauchbaren Sitzungstitel zur\xFCckgegeben.",
+    sessionTitleUpdated: '\u25B8 Sitzungstitel aktualisiert: "{title}"',
+    sessionTitleRenameFailed: '\u25B8 Sitzung konnte nicht f\xFCr Titel "{title}" umbenannt werden.',
+    sessionTitleRenamed: '\u25B8 Sitzung umbenannt in "{name}" \u2014 {title}',
+    sessionTitleAutoRenamed: '\u25B8 Automatisch benannte Sitzung "{name}" \u2014 {title}',
+    workspaceSwitched: "\u25B8 Arbeitsbereich gewechselt zu {root}",
+    semanticRepointed: "\u25B8 Semantic-Search umgeleitet nach {root}",
+    semanticDisabledForRoot: "\u25B8 Semantic-Search deaktiviert (kein kompatibler Index in {root})",
+    semanticRebootstrapFailed: "\u25B8 Semantic-Search-Neustart fehlgeschlagen: {reason}",
+    denied: "\u25B8 verweigert: {cmd}{context}",
+    alwaysAllowed: '\u25B8 "{prefix}" f\xFCr {dir} dauerhaft erlaubt',
+    runningCommand: "\u25B8 f\xFChre aus: {cmd}",
+    startingBackground: "\u25B8 starte (Hintergrund): {cmd}",
+    checkpointSaved: "\u26C1 Checkpoint gespeichert \xB7 {id} \xB7 {count} Datei{en} \xB7 /restore {id} zum Zur\xFCcksetzen",
+    continuingAfter: "\u25B8 fortgesetzen nach {label}{counter}",
+    planStoppedAt: "\u25B8 Plan angehalten bei {label}{counter}",
+    revisingAfter: "\u25B8 \xFCberarbeite nach {label} \u2014 {feedback}",
+    historyScrollHint: " \u2191 lese Verlauf \xB7 Ende / Bild\u2193 zur\xFCck zum Ende \xB7 \u2193 eine Zeile vor",
+    editHistoryTitle: "Edit-Verlauf (\xE4lteste zuerst):",
+    editHistoryNoCodeMode: "Nicht im Code-Modus",
+    editHistoryNoEdits: "Noch keine Edits in dieser Sitzung aufgezeichnet",
+    editHistoryNoShowId: "Verwendung: /show [id] [pfad]   (ID weglassen f\xFCr neueste; Pfad aus der Datei-Zusammenfassung)",
+    editHistoryIdNotFound: "Kein Edit #{id} \u2014 /history ausf\xFChren f\xFCr g\xFCltige IDs",
+    editHistoryLookupFailed: "Unerwartet: History-Lookup fehlgeschlagen",
+    editHistoryBatchNoFile: 'Batch #{id} enth\xE4lt kein "{path}" \u2014 Dateien in diesem Batch: {files}',
+    editHistoryNoEdits2: "Keine Edits in dieser Sitzung aufgezeichnet \u2014 /history ist leer",
+    editHistoryStatusApplied: "angewandt",
+    editHistoryStatusPartial: "TEILWEISE",
+    editHistoryStatusUndone: "R\xDCCKG\xC4NGIG",
+    editHistoryHelpShow: "/show <id>            \u2192 Zusammenfassung pro Datei    \xB7    /show <id> <pfad>  \u2192 vollst\xE4ndige Diff einer Datei",
+    editHistoryHelpUndo: "/undo                 \u2192 neueste nicht-r\xFCckg\xE4ngige   \xB7    /undo <id> [pfad]  \u2192 gezielten Batch oder Datei r\xFCckg\xE4ngig machen",
+    editHistoryAlreadyReverted: "(bereits r\xFCckg\xE4ngig gemacht \u2014 /history zeigt den batch-level Status)",
+    editHistoryRevertFile: "/undo {id} {path}  \u2192 nur diese Datei r\xFCckg\xE4ngig machen",
+    mcpFailed: "MCP {name} fehlgeschlagen",
+    mcpWarn: "MCP {name} Warnung",
+    unknownTheme: "Unbekanntes Theme: {name}\nVerf\xFCgbar: {choices}",
+    themeSaved: "Theme gespeichert: {name}\nAktiv beim n\xE4chsten Start: {active}",
+    noPendingEdits: "Nichts ausstehend \u2014 das Modell hat seit dem letzten /apply oder /discard keine Edits vorgeschlagen.",
+    noMatchedApply: "\u25B8 Keine Edits mit diesen Indizes gefunden \u2014 nichts angewandt. Verwende /apply ohne Argumente, um alle zu \xFCbernehmen.",
+    noPendingDiscard: "Nichts ausstehend zum Verwerfen.",
+    noMatchedDiscard: "\u25B8 Keine Edits mit diesen Indizes gefunden \u2014 nichts verworfen.",
+    blocksStillPending: "\u25B8 {count} Edit-Block(s) noch ausstehend \u2014 /apply oder /discard zum Bereinigen.",
+    nothingWritten: ". Nichts auf Platte geschrieben.",
+    discardedCount: "\u25B8 {count} ausstehende Edit-Block(s) verworfen",
+    noEventsFor: 'Keine Ereignisse f\xFCr Sitzung "{name}"',
+    lookedAtFile: "Angesehen: {path}",
+    sidecarHint: "(Sitzungen erstellen den Sidecar automatisch beim ersten Turn \u2014 wurde diese Sitzung bereits ausgef\xFChrt?)"
+  },
+  hooks: {
+    ...EN.hooks,
+    head: "Hook {tag} `{cmd}` {decision}{truncTag}",
+    headWithDetail: "Hook {tag} `{cmd}` {decision}{truncTag}: {detail}",
+    truncated: " (Ausgabe bei 256 KB gek\xFCrzt)",
+    decisionBlock: "blockieren",
+    decisionWarn: "warnen",
+    decisionTimeout: "Timeout",
+    decisionError: "Fehler"
+  },
+  summary: {
+    ...EN.summary,
+    status: "Zusammenfassung der gesammelten Informationen...",
+    hallucinatedFallback: "(Modell hat gef\xE4lschte Tool-Call-Markup statt einer Prosa-Zusammenfassung ausgegeben \u2014 versuche /retry mit einer engeren Frage, oder /think zur Inspektion von R1s Reasoning)",
+    failedAfterReason: "{label} und der Fallback-Summary-Aufruf sind fehlgeschlagen: {message}. F\xFChre /clear aus und versuche es mit einer engeren Frage, oder erh\xF6he --max-tool-iters."
+  },
+  loop: {
+    ...EN.loop,
+    budgetExhausted: "Sitzungsbudget ersch\xF6pft \u2014 ${spent} ausgegeben \u2265 Grenze ${cap}. Erh\xF6he die Grenze mit /budget <usd>, schalte sie mit /budget off aus oder beende die Sitzung.",
+    budget80Pct: "\u25B2 Budget zu 80 % verbraucht \u2014 ${spent} von ${cap}. Der n\xE4chste oder \xFCbern\xE4chste Turn erreicht wahrscheinlich die Grenze.",
+    proArmed: "\u21E7 /pro aktiviert \u2014 dieser Turn l\xE4uft auf deepseek-v4-pro (einmalig \xB7 deaktiviert nach dem Turn)",
+    toolUploadStatus: "Tool-Ergebnis hochgeladen \u2013 Modell denkt vor der n\xE4chsten Antwort...",
+    turnStartFoldStatus: "Turn-Start: Kontext n\xE4hert sich Grenze, komprimiere Verlauf...",
+    turnStartFolded: "Turn-Start: Anfrage ~{estimate}/{ctxMax} Tokens ({pct}%) \u2014 {beforeMessages} Nachrichten \u2192 {afterMessages} komprimiert. Sende.",
+    harvestStatus: "Planstatus wird aus dem Reasoning extrahiert...",
+    repeatToolCallWarning: "Wiederholten Tool-Aufruf erkannt \u2014 lasse das Modell das Problem sehen und es mit einem anderen Ansatz erneut versuchen.",
+    stormStuck: "Festgefahrene Wiederholungsschleife gestoppt \u2014 das Modell rief dasselbe Tool mit identischen Argumenten auf, selbst nach einem Selbstkorrektur-Hinweis. Versuche /retry, umformulieren oder schlie\xDFe den zugrunde liegenden Blocker aus.",
+    stormSuppressed: "{count} wiederholte Tool-Aufrufe unterdr\xFCckt \u2014 gleicher Name + Argumente 3+ Mal gesendet.",
+    compactingHistoryStatus: "Komprimiere Verlauf{aggressiveTag}...",
+    aggressiveTag: " (aggressiv)",
+    foldedHistory: "Kontext {before}/{ctxMax} ({pct}%) \u2014 {beforeMessages} Nachrichten \u2192 {afterMessages} gefaltet (Zusammenfassung {summaryChars} Zeichen). Fahre fort.",
+    aggressivelyFoldedHistory: "Kontext {before}/{ctxMax} ({pct}%) \u2014 {beforeMessages} Nachrichten \u2192 {afterMessages} aggressiv gefaltet (Zusammenfassung {summaryChars} Zeichen). Fahre fort.",
+    forcingSummary: "Kontext {before}/{ctxMax} ({pct}%) \u2014 erzwinge Zusammenfassung aus dem Gesammelten. F\xFChre /compact, /clear oder /new aus, um zur\xFCckzusetzen."
+  },
+  errors: {
+    ...EN.errors,
+    contextOverflow: "Context-\xDCberlauf (DeepSeek 400): Sitzungsverlauf ist {requested}, \xFCber dem Prompt-Limit des Modells (V4: 1M Tokens; legacy chat/reasoner: 131k). Meist ist ein einzelnes Tool-Ergebnis zu gro\xDF geworden. Reasonix begrenzt neue Tool-Ergebnisse auf 8k Tokens und heilt \xFCberdimensionierte Verl\xE4ufe automatisch beim Sitzungsladen \u2013 ein Neustart behebt es oft. Falls es weiterhin \xFCberl\xE4uft, f\xFChre /new f\xFCr einen frischen Start aus oder \xF6ffne /sessions und dr\xFCcke [d], um diese Sitzung zu l\xF6schen.",
+    contextOverflowTooMany: "Zu viele Tokens",
+    auth401: "Authentifizierung fehlgeschlagen (DeepSeek 401): {inner}. Dein API-Schl\xFCssel wird abgewiesen. Behebe mit `reasonix setup` oder `export DEEPSEEK_API_KEY=sk-...`. Erhalte einen unter https://platform.deepseek.com/api_keys.",
+    balance402: "Kontoguthaben aufgebraucht (DeepSeek 402): {inner}. Lade auf unter https://platform.deepseek.com/top_up \u2014 der Panel-Header zeigt dein Guthaben, sobald es nicht Null ist.",
+    badparam422: "Ung\xFCltiger Parameter (DeepSeek 422): {inner}",
+    badrequest400: "Fehlerhafte Anfrage (DeepSeek 400): {inner}",
+    concurrency429: "DeepSeek-Gleichzeitigkeitslimit erreicht (429): {inner}. Das Konto hat zu viele gleichzeitige Anfragen (Grenze: 500 f\xFCr v4-pro, 2500 f\xFCr v4-flash, summiert \xFCber alle API-Schl\xFCssel des Kontos). Meist l\xE4uft ein weiterer Reasonix-Prozess mit demselben Schl\xFCssel oder ein paralleler Subagent-Fan-out hat \xFCberzogen. Warte einige Sekunden und wiederhole, reduziere die Parallelit\xE4t oder beantrage eine h\xF6here Grenze unter https://platform.deepseek.com.",
+    deepseek5xxHead: "DeepSeek-Dienst nicht verf\xFCgbar ({status}) \u2014 dies ist ein DeepSeek-seitiges Problem, nicht Reasonix. Bereits 4\xD7 mit Backoff wiederholt.",
+    deepseek5xxReachable: " DeepSeek's Haupt-API hat auf unseren Health-Check geantwortet, aber /chat/completions schl\xE4gt fehl \u2014 partieller Ausfall auf ihrer Seite.",
+    deepseek5xxUnreachable: " DeepSeek-API ist von deinem Netzwerk aus nicht erreichbar \u2014 k\xF6nnte ein gr\xF6\xDFerer DS-Ausfall oder ein lokales Netzwerkproblem sein.",
+    deepseek5xxActionNetwork: " Versuche: (1) Netzwerk pr\xFCfen, (2) 30s warten und wiederholen, (3) Statusseite: https://status.deepseek.com.",
+    deepseek5xxActionRetry: " Versuche: (1) 30s warten und wiederholen, (2) /model zum Modellwechsel, (3) Statusseite: https://status.deepseek.com.",
+    upstream5xxHead: "Upstream-Dienst nicht verf\xFCgbar ({status}) bei {host} \u2014 der konfigurierte API-Endpunkt hat einen Serverfehler zur\xFCckgegeben, kein Reasonix-Fehler. Bereits 4\xD7 mit Backoff wiederholt.",
+    upstream5xxActionRetry: " Versuche: (1) Pr\xFCfen, ob der lokale/Proxy-Modell-Server l\xE4uft, (2) warten und wiederholen, (3) /model zum Modellwechsel.",
+    innerNoMessage: "(keine Nachricht)",
+    reasonAborted: "[vom Benutzer abgebrochen (Esc) \u2014 fasse zusammen, was ich bisher gefunden habe]",
+    reasonContextGuard: "[Context-Budget wird knapp \u2014 fasse zusammen, bevor der n\xE4chste Aufruf \xFCberl\xE4uft]",
+    reasonStuck: "[festgefahren bei wiederholtem Tool-Aufruf \u2014 erkl\xE4re, was versucht wurde und was den Fortschritt blockiert]",
+    labelAborted: "Vom Benutzer abgebrochen",
+    labelContextGuard: "Context-Guard ausgel\xF6st (Prompt > 80 % des Fensters)",
+    labelStuck: "Festgefahren (wiederholter Tool-Aufruf durch Storm-Breaker unterdr\xFCckt)"
+  },
+  handlers: {
+    ...EN.handlers,
+    basic: {
+      ...EN.handlers.basic,
+      newInfo: "\u25B8 neues Gespr\xE4ch \u2014 {count} Nachricht(en) aus dem Kontext entfernt. Gleiche Sitzung, frische Grundlage.",
+      newInfoArchived: '\u25B8 neues Gespr\xE4ch \u2014 {count} Nachricht(en) aus dem Kontext entfernt. Vorheriges Transkript als "{archived}" archiviert (sichtbar unter Sitzungen).',
+      newInfoSystemReloaded: " \xB7 REASONIX.md / Projekt-Memory neu geladen (n\xE4chster Turn zahlt einen Cache-Fehler)",
+      helpTitle: "Befehle:",
+      helpShellTitle: "Shell-K\xFCrzel:",
+      helpShell: "  !<befehl>                 <befehl> im Sandbox-Root ausf\xFChren; Ausgabe kommt",
+      helpShellDetail: "                             in die Konversation, sodass das Modell sie im n\xE4chsten Turn sieht.",
+      helpShellConsent: "                             Kein Allowlist-Gate \u2014 vom Benutzer getippt = explizite Zustimmung.",
+      helpShellExample: "                             Beispiel: !git status   !ls src/   !npm test",
+      helpShellGateTitle: "Vom Modell aufgerufene Shell-Befehle (pro Aufruf Genehmigung):",
+      helpShellGate: "  \u2191\u2193 + \u23CE                   jeder Aufruf zeigt eine Eingabeaufforderung mit \xBBEinmal erlauben\xAB / \xBBImmer erlauben\xAB",
+      helpShellGateDetail: "                             / \xBBAblehnen\xAB. W\xE4hle \xBBImmer erlauben\xAB, um diesen genauen",
+      helpShellGatePolicy: "                             Befehlspr\xE4fix f\xFCr dieses Projekt auf die Whitelist zu setzen. Kein globales Allow-All-Flag.",
+      helpMemoryTitle: "Kurzzeit-Memory:",
+      helpMemoryPin: "  #<notiz>                  <notiz> an <projekt>/REASONIX.md anh\xE4ngen (commitierbar).",
+      helpMemoryPinEx: "                             Beispiel: #findByEmail muss case-insensitive sein",
+      helpMemoryGlobal: "  #g <notiz>                <notiz> an ~/.reasonix/REASONIX.md anh\xE4ngen (global, niemals committed).",
+      helpMemoryGlobalEx: "                             Beispiel: #g immer pnpm, nicht npm verwenden",
+      helpMemoryPinBoth: "                             Beide werden in jedes zuk\xFCnftige Sitzungs-Pr\xE4fix eingef\xFCgt. Schneller als /memory.",
+      helpMemoryEscape: "                             Verwende `\\#text`, um ein literales `#text` an das Modell zu senden.",
+      helpFileTitle: "Dateiverweise (Code-Modus):",
+      helpFile: "  @pfad/zu/datei            Dateiinhalt unter [Referenzierte Dateien] beim Senden einf\xFCgen.",
+      helpFilePicker: "                             Tippe `@`, um die Auswahl zu \xF6ffnen (\u2191\u2193 navigieren, Tab/Enter ausw\xE4hlen).",
+      helpUrlTitle: "URL-Verweise:",
+      helpUrl: "  @https://example.com     URL abrufen, HTML entfernen, unter [Referenzierte URLs] einf\xFCgen.",
+      helpUrlCache: "                             Gleiche URL zweimal in einer Sitzung wird nur einmal abgerufen (In-Mem-Cache).",
+      helpUrlPunct: "                             Abschluss-Satzzeichen (./,/)) werden automatisch entfernt.",
+      helpSessionsTitle: "Sitzungen (standardm\xE4\xDFig aktiviert, hei\xDFen 'default'):",
+      helpSessionCustom: "  reasonix chat --session <name>   eine andere benannte Sitzung verwenden",
+      helpSessionNone: "  reasonix chat --no-session       Persistenz f\xFCr diesen Lauf deaktivieren",
+      retryNone: "Nichts zu wiederholen \u2014 keine vorherige Benutzernachricht im Log dieser Sitzung.",
+      retryInfo: '\u25B8 wiederhole: "{preview}"',
+      loopTuiOnly: "/loop ist nur in der interaktiven TUI verf\xFCgbar (nicht in run/replay).",
+      loopStopped: "\u25B8 Loop gestoppt.",
+      loopNoActive: "Kein aktiver Loop zum Stoppen.",
+      loopNoActiveHint: "kein aktiver Loop. Starte einen mit `/loop <intervall> <prompt>` (z.B. /loop 30s npm test).\nWird abgebrochen bei: /loop stop \xB7 Esc \xB7 /clear /new \xB7 jeder benutzereingegebene Prompt.",
+      loopStarted: '\u25B8 Loop gestartet \u2014 \xBB{prompt}" wird alle {duration} erneut gesendet. Tippe etwas (oder /loop stop) zum Abbrechen.',
+      keysNeedsTui: "/keys ben\xF6tigt einen TUI-Kontext (postKeys angeschlossen).",
+      aboutHeader: "Reasonix v{version} \u2014 ein Cache-First-DeepSeek-Coding-Agent",
+      aboutWebsiteLabel: "Webseite",
+      aboutRepoLabel: "GitHub ",
+      aboutLicenseLabel: "Lizenz",
+      unknownCommand: "Unbekannter Befehl: /{cmd} \u2014 meintest du {list}?",
+      unknownCommandShort: "Unbekannter Befehl: /{cmd}  (siehe /help)"
+    },
+    sessions: {
+      ...EN.handlers.sessions,
+      titleUnavailable: "/title ist nur in einer aktiven persistierten TUI-Sitzung verf\xFCgbar.",
+      titleStarted: "\u25B8 benenne Sitzung...",
+      titleFailed: "\u25B8 Sitzungstitel fehlgeschlagen: {reason}"
+    },
+    qq: {
+      ...EN.handlers.qq,
+      unavailable: "/qq ist in dieser Sitzung nicht verf\xFCgbar.",
+      connecting: "QQ: verbinde...",
+      connectFailed: "QQ-Verbindung fehlgeschlagen: {reason}",
+      disconnecting: "QQ: trenne...",
+      disconnectFailed: "QQ-Trennung fehlgeschlagen: {reason}",
+      usage: "Verwendung: /qq connect [appId appSecret [sandbox]] | /qq status | /qq disconnect",
+      promptAppId: "QQ-Setup: gib deine QQ-Open-Platform-App-ID ein, dann Enter. Tippe /cancel zum Abbrechen.",
+      promptAppSecret: "QQ-Setup: gib dein QQ-Open-Platform-App-Secret ein, dann Enter. Tippe /cancel zum Abbrechen.",
+      setupWaitingAppId: "Warte auf App-ID",
+      setupWaitingAppSecret: "Warte auf App-Secret",
+      setupCancelled: "QQ-Setup abgebrochen.",
+      credentialsRequired: "QQ-App-ID und App-Secret sind erforderlich.",
+      connected: "QQ im {mode}-Modus verbunden. Es wird bei zuk\xFCnftigen Starts automatisch gestartet.",
+      alreadyConnected: "QQ ist bereits im {mode}-Modus verbunden. Autostart ist aktiviert.",
+      disconnected: "QQ getrennt. Autostart ist deaktiviert.",
+      status: "QQ: {connected}, Autostart {enabled}, Anmeldedaten {configured}, App-ID {appId}, {sandbox}, Zugriff {access}, aktueller Modus {mode}.",
+      statusSetup: "QQ: Setup l\xE4uft \u2014 {step}",
+      stateConnected: "verbunden",
+      stateDisconnected: "getrennt",
+      stateEnabled: "aktiviert",
+      stateDisabled: "deaktiviert",
+      stateConfigured: "konfiguriert",
+      stateNotConfigured: "Nicht konfiguriert",
+      sandbox: "Sandbox",
+      production: "Produktion",
+      none: "keine",
+      modeChat: "Chat",
+      modeCode: "Code",
+      accessOwner: "Besitzer {owner}",
+      accessOwnerWithAllowlist: "Besitzer {owner}, Allowlist {count}",
+      accessAllowlist: "Allowlist {count}",
+      accessRuntime: "Erstabsender (nur zur Laufzeit, {owner})",
+      accessOpen: "Offen (ungebunden)",
+      lockAlreadyRunning: "QQ-Kanal l\xE4uft bereits in Prozess {pid}. Stoppe diesen Prozess, bevor du einen weiteren QQ-Kanal startest.",
+      unauthorizedMessage: "QQ hat Nachricht von nicht autorisierter OpenID {openid} ignoriert. Aktueller Zugriff: {access}.",
+      runtimeBound: "QQ hat diesen Lauf vor\xFCbergehend an den Erstabsender {openid} gebunden. Setze `qq.ownerOpenId` in der Konfiguration, um den Zugriff dauerhaft zu machen.",
+      missingAppId: "QQ-App-ID erforderlich. F\xFChre `/qq connect` zum Konfigurieren aus.",
+      missingAppSecret: "QQ-App-Secret erforderlich. F\xFChre `/qq connect` zum Konfigurieren aus.",
+      authFailed: "QQ-Bot-Authentifizierung fehlgeschlagen \u2014 \xFCberpr\xFCfe deine App-ID und dein App-Secret.",
+      readyTimeout: "QQ-Bot hat READY nicht innerhalb von 15s erhalten \u2014 \xFCberpr\xFCfe deine App-ID und dein App-Secret."
+    },
+    admin: {
+      ...EN.handlers.admin,
+      doctorNeedsTui: "/doctor ben\xF6tigt einen TUI-Kontext (postDoctor angeschlossen).",
+      doctorRunning: "\u2695 Doctor \u2014 f\xFChre Gesundheitschecks aus...",
+      hooksReloadUnavailable: "/hooks reload ist in diesem Kontext nicht verf\xFCgbar (kein Reload-Callback angeschlossen).",
+      hooksReloaded: "\u25B8 Hooks neu geladen \xB7 {count} aktiv",
+      hooksUsage: "Verwendung: /hooks            aktive Hooks auflisten\n       /hooks reload     settings.json-Dateien neu lesen",
+      hooksNone: "Keine Hooks konfiguriert.",
+      hooksDropHint: "Lege eine settings.json mit einem `hooks`-Schl\xFCssel in einem der folgenden Pfade ab:",
+      hooksProject: "  \xB7 {path} (Projekt)",
+      hooksProjectFallback: "  \xB7 <projekt>/.reasonix/settings.json (Projekt)",
+      hooksGlobal: "  \xB7 {path} (global)",
+      hooksEvents: "Ereignisse: PreToolUse, PostToolUse, UserPromptSubmit, Stop",
+      hooksExitCodes: "Exit 0 = bestanden \xB7 Exit 2 = blockieren (Pre*) \xB7 andere = warnen",
+      hooksLoaded: "\u25B8 {count} Hook(s) geladen",
+      hooksSources: "Quellen: Projekt={project} \xB7 global={global}",
+      updateCurrent: "Aktuell: reasonix {version}",
+      updateLatestPending: "Neueste:  (noch nicht aufgel\xF6st \u2014 Hintergrundpr\xFCfung l\xE4uft oder offline)",
+      updateRetryHint: "hat einen frischen Registry-Abruf ausgel\xF6st \u2014 versuche `/update` in ein paar Sekunden erneut,",
+      updateRetryHint2: "oder f\xFChre `reasonix update` in einem anderen Terminal aus, um es synchron zu erzwingen.",
+      updateLatest: "Neueste:  reasonix {version}",
+      updateUpToDate: "Du bist auf dem neuesten Stand. Nichts zu tun.",
+      updateNpxHint: "du verwendest npx \u2014 der n\xE4chste `npx reasonix ...`-Start l\xE4dt automatisch die neueste Version.",
+      updateNpxForce: "Um fr\xFCher zu aktualisieren: `npm cache clean --force`.",
+      updateUpgradeHint: "Zum Aktualisieren beende diese Sitzung und f\xFChre aus:",
+      updateUpgradeCmd1: "  reasonix update           (interaktiv, --dry-run wird unterst\xFCtzt)",
+      updateUpgradeCmd2: "  {command}   (direkt)",
+      updateInSessionDisabled: "Die Installation innerhalb einer Sitzung ist bewusst deaktiviert \u2014 der Installationsprozess w\xFCrde",
+      updateInSessionDisabled2: "die Darstellung dieser TUI beeintr\xE4chtigen und Windows kann die laufende Bin\xE4rdatei sperren.",
+      statsNoData: "Noch keine Nutzungsdaten.",
+      statsEveryTurn: "jeder hier ausgef\xFChrte Turn h\xE4ngt einen Datensatz an \u2014 die Turns dieser Sitzung",
+      statsWillAppear: "Werden im Dashboard angezeigt, sobald du eine Nachricht sendest."
+    },
+    edits: {
+      ...EN.handlers.edits,
+      undoCodeOnly: "/undo ist nur innerhalb von `reasonix code` verf\xFCgbar \u2014 der Chat-Modus wendet keine Edits an.",
+      historyCodeOnly: "/history ist nur innerhalb von `reasonix code` verf\xFCgbar.",
+      showCodeOnly: "/show ist nur innerhalb von `reasonix code` verf\xFCgbar.",
+      applyCodeOnly: "/apply ist nur innerhalb von `reasonix code` verf\xFCgbar (hier gibt es nichts anzuwenden).",
+      discardCodeOnly: "/discard ist nur innerhalb von `reasonix code` verf\xFCgbar.",
+      planCodeOnly: "/plan ist nur innerhalb von `reasonix code` verf\xFCgbar \u2014 der Chat-Modus blockiert keine Tool-Schreibzugriffe.",
+      planOn: "\u25B8 Plan-Modus EIN \u2014 Schreibwerkzeuge sind blockiert; das Modell MUSS `submit_plan` aufrufen, bevor etwas ausgef\xFChrt wird. (Das Modell kann auch eigenst\xE4ndig submit_plan f\xFCr gro\xDFe Aufgaben aufrufen, selbst wenn der Plan-Modus aus ist \u2014 dieser Schalter ist die strengere, explizite Einschr\xE4nkung.) Tippe /plan off zum Verlassen.",
+      planOff: "\u25B8 Plan-Modus AUS \u2014 Schreibwerkzeuge sind wieder aktiv. Modelle k\xF6nnen weiterhin eigenst\xE4ndig Pl\xE4ne f\xFCr gro\xDFe Aufgaben vorschlagen.",
+      modeCodeOnly: "/mode ist nur innerhalb von `reasonix code` verf\xFCgbar.",
+      modeUsage: "Verwendung: /mode <review|auto|yolo>   (Shift+Tab schaltet auch um)",
+      modeYolo: "\u25B8 Edit-Modus: YOLO \u2014 Edits UND Shell-Befehle auto-ausf\xFChren ohne Nachfrage. /undo macht Edits immer noch r\xFCckg\xE4ngig. Vorsicht.",
+      modeAuto: "\u25B8 Edit-Modus: AUTO \u2014 Edits werden sofort angewandt; dr\xFCcke u innerhalb von 5s zum R\xFCckg\xE4ngigmachen, oder /undo sp\xE4ter. Shell-Befehle fragen weiterhin.",
+      modeReview: "\u25B8 Edit-Modus: review \u2014 Edits warten auf /apply (oder y) / /discard (oder n)",
+      commitCodeOnly: "/commit ist nur innerhalb von `reasonix code` verf\xFCgbar (ben\xF6tigt ein Git-Repo als Wurzel).",
+      commitUsage: 'Verwendung: /commit "deine Commit-Nachricht"  \u2014 f\xFChrt `git add -A && git commit -m "\u2026"` in {root} aus',
+      walkCodeOnly: "/walk ist nur innerhalb von `reasonix code` verf\xFCgbar.",
+      checkpointCodeOnly: "/checkpoint ist nur innerhalb von `reasonix code` verf\xFCgbar \u2014 der Chat-Modus wendet keine Edits an.",
+      checkpointNone: "noch keine Checkpoints \u2014 `/checkpoint <name>` sichert jede Datei, die die Sitzung ber\xFChrt hat. Sp\xE4ter mit `/restore <name>` wiederherstellbar.",
+      checkpointHeader: "\u25C8 Checkpoints \xB7 {count} gespeichert",
+      checkpointRestoreHint: "  /restore <name|id> \xB7 /checkpoint forget <id> \xB7 /checkpoint <name> zum Hinzuf\xFCgen",
+      checkpointForgetUsage: "Verwendung: /checkpoint forget <id|name>",
+      checkpointNoMatch: '\u25B8 kein Checkpoint gefunden f\xFCr "{name}" \u2014 siehe /checkpoint list',
+      checkpointDeleted: "\u25B8 Checkpoint {id} gel\xF6scht ({name})",
+      checkpointDeleteFailed: "\u25B8 Konnte {id} nicht l\xF6schen (bereits entfernt?)",
+      checkpointSaveUsage: "Verwendung: /checkpoint <name>   (oder /checkpoint list zum Anzeigen vorhandener)",
+      checkpointSavedEmpty: '\u25B8 Checkpoint "{name}" gespeichert ({id}) \u2014 aber es wurden noch keine Dateien ber\xFChrt, daher ist es eine leere Basislinie. Nach diesem Punkt vorgenommene Edits k\xF6nnen r\xFCckg\xE4ngig gemacht werden.',
+      checkpointSaved: '\u25B8 Checkpoint "{name}" gespeichert ({id}) \u2014 {files} Datei{en}, {size} KB. Wiederherstellen: /restore {name}',
+      restoreCodeOnly: "/restore ist nur innerhalb von `reasonix code` verf\xFCgbar.",
+      restoreUsage: "Verwendung: /restore <name|id>   (siehe /checkpoint list f\xFCr IDs)",
+      restoreNoMatch: '\u25B8 kein Checkpoint gefunden f\xFCr "{target}" \u2014 versuche /checkpoint list',
+      restoreInfo: '\u25B8 "{name}" ({id}) wiederhergestellt von {when}',
+      restoreWrote: "  \xB7 {count} Datei{en} zur\xFCckgeschrieben",
+      restoreRemoved: "  \xB7 {count} Datei{en} entfernt (existierten zum Checkpoint-Zeitpunkt nicht)",
+      restoreSkipped: "  \u2717 {count} Datei{en} \xFCbersprungen:",
+      cwdCodeOnly: "/cwd ist nur innerhalb von `reasonix code` verf\xFCgbar.",
+      cwdUsage: "Verwendung: /cwd <pfad>   (aktuelles Root: {current}). Richtet Dateisystem-/Shell-/Memory-Tools auf <pfad> neu aus.",
+      cwdUsageNoCurrent: "Verwendung: /cwd <pfad>   richtet den Workspace-Root auf <pfad> neu aus."
+    },
+    model: {
+      ...EN.handlers.model,
+      modelHint: "versuche deepseek-v4-flash oder deepseek-v4-pro \u2014 f\xFChre /models aus, um die Live-Liste abzurufen",
+      modelUsage: "Verwendung: /model <id>   ({hint})",
+      modelNotInCatalog: "Modell \u2192 {id}   (\u26A0 nicht im abgerufenen Katalog: {list}. Falls das falsch ist, wird der n\xE4chste Aufruf 400 geben \u2014 f\xFChre /models zum Aktualisieren aus.)",
+      modelSet: "Modell \u2192 {id}",
+      effortStatus: "Effort \u2192 {current}   (Auswahl: {list})",
+      effortUsage: "Verwendung: /effort <{list}>   (high ist der sichere Standard; max ist eine DeepSeek-Erweiterung)",
+      effortUsageNoMax: "Verwendung: /effort <{list}>",
+      effortSet: "Effort \u2192 {effort}",
+      budgetNoCap: "Kein Sitzungsbudget festgelegt \u2014 Reasonix wird weiterlaufen, bis du es stoppst. Setze eines mit: /budget <usd>   (z.B. /budget 5)",
+      budgetStatus: "Budget: ${spent} von ${cap} ({pct}%) \xB7 /budget off zum Entfernen, /budget <usd> zum \xC4ndern",
+      budgetOff: "Budget \u2192 aus (keine Grenze)",
+      budgetUsage: 'Verwendung: /budget <usd>   (erhalten: "{arg}" \u2014 muss eine positive Zahl sein, z.B. /budget 5 oder /budget 12.50)',
+      budgetExhausted: "\u25B2 Budget \u2192 ${cap} aber bereits ${spent} ausgegeben. Der n\xE4chste Turn wird verweigert \u2014 erh\xF6he die Grenze, um fortzufahren, oder beende die Sitzung.",
+      budgetSet: "Budget \u2192 ${cap}  (bisher: ${spent} \xB7 warnt bei 80 %, verweigert n\xE4chsten Turn bei 100 % \xB7 /budget off zum Entfernen)"
+    },
+    permissions: {
+      ...EN.handlers.permissions,
+      mutateCodeOnly: "/permissions add / remove / clear sind nur innerhalb von `reasonix code` verf\xFCgbar \u2014 sie bearbeiten die projektbezogene Allowlist (`~/.reasonix/config.json` projects[<root>].shellAllowed).",
+      addUsage: 'Verwendung: /permissions add <pr\xE4fix>   (mehrere Tokens OK: /permissions add "git push origin")',
+      addAlready: "\u25B8 bereits erlaubt: {prefix}",
+      addBuiltin: "\u25B8 `{prefix}` ist bereits in der Builtin-Allowlist \u2014 kein projektspezifischer Eintrag n\xF6tig. (Builtin-Eintr\xE4ge sind immer aktiv.)",
+      addInfo: "\u25B8 hinzugef\xFCgt: {prefix}\n  \u2192 n\xE4chste `{prefix}`-Ausf\xFChrung erfolgt ohne Nachfrage in diesem Projekt.",
+      removeUsage: "Verwendung: /permissions remove <pr\xE4fix-oder-index>   (z.B. /permissions remove 3, oder /permissions remove npm)",
+      removeEmpty: "\u25B8 keine Projekt-Allowlist-Eintr\xE4ge zum Entfernen.",
+      removeIndexOob: "\u25B8 Index au\xDFerhalb des Bereichs: {idx} (Projektliste hat {count} Eintr\xE4ge)",
+      removeNothing: "\u25B8 nichts zu entfernen.",
+      removeBuiltin: "\u25B8 `{prefix}` ist in der Builtin-Allowlist (schreibgesch\xFCtzt). Builtin-Eintr\xE4ge k\xF6nnen zur Laufzeit nicht entfernt werden \u2014 sie sind in die Bin\xE4rdatei eingebrannt.",
+      removeInfo: "\u25B8 entfernt: {prefix}",
+      removeNotFound: "\u25B8 kein solcher Projekt-Eintrag: {prefix}   (versuche /permissions list, um zu sehen, was gespeichert ist)",
+      clearAlready: "\u25B8 Projekt-Allowlist ist bereits leer.",
+      clearConfirm: "Es werden {count} Projekt-Allowlist-Eintr\xE4g{e} f\xFCr {root} gel\xF6scht. F\xFChre den Befehl mit dem Wort 'confirm' erneut aus: /permissions clear confirm",
+      clearedNone: "\u25B8 Projekt-Allowlist war bereits leer \u2014 nichts ge\xE4ndert.",
+      cleared: "\u25B8 {count} Projekt-Allowlist-Eintr\xE4g{e} gel\xF6scht.",
+      usage: 'Verwendung: /permissions [list]                   aktuellen Status anzeigen\n       /permissions add <pr\xE4fix>            speichern (z.B. "npm run build")\n       /permissions remove <pr\xE4fix-oder-N>    Eintrag entfernen\n       /permissions clear confirm           alle Projekteintr\xE4ge l\xF6schen',
+      modeYolo: "\u25B8 Edit-Modus: YOLO  \u2014 jeder Shell-Befehl l\xE4uft automatisch, Allowlist wird umgangen. /mode review zum Reaktivieren der Nachfragen.",
+      modeAuto: "\u25B8 Edit-Modus: auto  \u2014 Edits auto-anwenden, Shell weiterhin durch Allowlist gesch\xFCtzt (oder ShellConfirm-Nachfrage bei nicht-allowlisteten).",
+      modeReview: "\u25B8 Edit-Modus: review \u2014 sowohl Edits als auch nicht-allowlistete Shell-Befehle fragen vor der Ausf\xFChrung.",
+      projectHeader: "Projekt-Allowlist ({count}) \u2014 {root}",
+      projectNone1: '  (keine \u2014 w\xE4hle \xBBimmer erlauben" in einer ShellConfirm-Eingabeaufforderung, um einen hinzuzuf\xFCgen,',
+      projectNone2: "   oder `/permissions add <pr\xE4fix>` direkt.)",
+      projectNoRoot: "Projekt-Allowlist \u2014 (kein Projekt-Root; Chat-Modus zeigt nur Builtin-Eintr\xE4ge)",
+      builtinHeader: "Builtin-Allowlist ({count}) \u2014 schreibgesch\xFCtzt, fest eincompiliert",
+      subcommands: "Unterbefehle: /permissions add <pr\xE4fix> \xB7 /permissions remove <pr\xE4fix-oder-N> \xB7 /permissions clear confirm"
+    },
+    dashboard: {
+      ...EN.handlers.dashboard,
+      notAvailable: "/dashboard ist in diesem Kontext nicht verf\xFCgbar (kein startDashboard-Callback angeschlossen).",
+      stopNoCallback: "/dashboard stop: kein Stop-Callback angeschlossen.",
+      notRunning: "\u25B8 Dashboard l\xE4uft nicht.",
+      stopping: "\u25B8 Dashboard wird gestoppt...",
+      alreadyRunning: "\u25B8 Dashboard l\xE4uft bereits:",
+      alreadyRunningHint: "\xD6ffne es in einem beliebigen Browser. Tippe `/dashboard stop` zum Herunterfahren.",
+      ready: "\u25B8 Dashboard bereit:",
+      readyHint: "127.0.0.1 only \xB7 token-gesichert. Tippe `/dashboard stop` zum Herunterfahren.",
+      failed: "\u25B8 Dashboard konnte nicht gestartet werden: {reason}",
+      starting: "\u25B8 starte Dashboard-Server...",
+      copied: "\u25B8 Dashboard-URL in Zwischenablage kopiert: {url}",
+      tokenResetting: "\u25B8 rotiere Dashboard-Token \u2014 starte Server neu...",
+      tokenReset: "\u25B8 Dashboard-Token rotiert. Neue URL:"
+    },
+    observability: {
+      ...EN.handlers.observability,
+      contextInfo: "Kontext: ~{total} von {max} ({pct}%) \xB7 System {sys} \xB7 Tools {tools} \xB7 Log {log}",
+      compactStarting: "\u25B8 falte \xE4ltere Turns in eine Zusammenfassung...",
+      compactNoop: "\u25B8 nichts zu falten \u2014 Log bereits klein oder aktuelle Turns allein \xFCberschreiten das Budget.",
+      compactDone: "\u25B8 {before} Nachrichten \u2192 {after} gefaltet (Zusammenfassung {chars} Zeichen). Fahre fort.",
+      compactFailed: "\u25B8 Falten fehlgeschlagen: {reason}",
+      costNoTurn: "noch kein Turn \u2014 `/cost` zeigt die Token- und Kostenaufschl\xFCsselung des letzten Turns.",
+      costNeedsTui: "/cost ben\xF6tigt einen TUI-Kontext (postUsage angeschlossen).",
+      costNoPricing: '\u25B8 /cost: keine Preistabelle f\xFCr Modell "{model}". F\xFCge eine in telemetry/stats.ts hinzu.',
+      costEstimate: "\u25B8 /cost Sch\xE4tzung \xB7 {model} \xB7 {prompt} Prompt-Tokens (sys {sys} + tools {tools} + log {log} + msg {msg})",
+      costWorstCase: "  schlimmster Fall (vollst\xE4ndiger Fehlschlag): {input} Eingabe + ~{output} Ausgabe ({avg} \xD8) \u2248 {total}",
+      costLikely: "  wahrscheinlich ({pct}% Session-Cache-Treffer): {input} Eingabe + ~{output} Ausgabe \u2248 {total}",
+      costLikelyCold: "  wahrscheinlich: entspricht worst case bis der Cache gef\xFCllt ist (noch keine abgeschlossenen Turns)",
+      statusModel: "  Modell   {model}",
+      statusFlags: "  Flags   stream={stream} \xB7 effort={effort}",
+      statusCtx: "  Kontext     {bar} {used}/{max} ({pct}%)",
+      statusCtxNone: "  Kontext     noch keine Turns",
+      statusCost: "  Kosten    ${cost} \xB7 Cache {bar} {pct}% \xB7 Turns {turns}",
+      statusCostCold: "  Kosten    ${cost} \xB7 Turns {turns} (Cache w\xE4rmt sich auf)",
+      statusBudget: "  Budget  ${spent} / ${cap} ({pct}%){tag}",
+      statusSession: '  Sitzung "{name}" \xB7 {count} Nachrichten im Log (fortgesetzt {resumed})',
+      statusSessionEphemeral: "  Sitzung (ephemer \u2014 keine Persistenz)",
+      statusWorkspace: "  Arbeitsbereich {path} \xB7 beim Start festgelegt (mit --dir <pfad> neu starten zum Wechseln)",
+      statusMcp: "  MCP     {servers} Server, {tools} Tools im Register",
+      statusEdits: "  Edits   {count} ausstehend (/apply zum \xDCbernehmen, /discard zum Verwerfen)",
+      statusPlan: "  Plan    EIN \u2014 Schreibzugriffe blockiert (submit_plan + Genehmigung)",
+      statusLifecycle: "  Lebenszyklus {mode}/{state} \xB7 {progress}{evidence}",
+      lifecycleNoPlan: "Kein Plan",
+      lifecycleEvidencePending: "Nachweis ausstehend",
+      lifecycleRejected: "Lebenszyklus: {tool} blockiert in {state} \u2014 n\xE4chster: {next}",
+      lifecycleEvidenceRejected: "Lebenszyklus: Schritt {stepId} ben\xF6tigt Nachweis \u2014 n\xE4chster: {next}",
+      lifecycleRepeatedRejected: "Lebenszyklus: wiederholte {tool}-Ablehnung \u2014 wiederhole nicht identische Argumente",
+      statusModeYolo: "  Modus    YOLO \u2014 Edits + Shell auto-ausf\xFChren ohne Nachfrage (/undo macht immer noch r\xFCckg\xE4ngig \xB7 Shift+Tab zum Umschalten)",
+      statusModeAuto: "  Modus    AUTO \u2014 Edits werden sofort angewandt (u zum R\xFCckg\xE4ngigmachen innerhalb von 5s \xB7 Shift+Tab zum Umschalten)",
+      statusModeReview: "  Modus    review \u2014 Edits warten auf /apply oder y (Shift+Tab zum Umschalten)",
+      statusDash: "  Dash    {url} (im Browser \xF6ffnen \xB7 /dashboard stop)"
+    },
+    plans: {
+      ...EN.handlers.plans,
+      noSession: "keine Sitzung angeh\xE4ngt \u2014 `/plans` ist pro Sitzung. F\xFChre `reasonix code` in einem Projekt aus, um eine Sitzung zu erhalten.",
+      activePlan: "\u25B8 aktiver Plan{label} \u2014 {done}/{total} Schritt{e} erledigt \xB7 zuletzt bearbeitet {when}",
+      activeNone: "\u25B8 aktiver Plan: (keiner)",
+      noArchives: "noch keine archivierten Pl\xE4ne f\xFCr diese Sitzung \u2014 sie werden automatisch archiviert, wenn alle Schritte erledigt sind",
+      archivedHeader: "Archiviert ({count}):",
+      evidencePending: "  ! Nachweis ausstehend \u2014 aktueller Schritt ben\xF6tigt Verifikation/Diff/Checkpoint/manuellen Nachweis",
+      evidenceLine: "  Nachweis {stepId}: {summary}",
+      archivedEvidenceLine: "    Nachweis: {summary}",
+      replayNoSession: "keine Sitzung angeh\xE4ngt \u2014 `/replay` ist pro Sitzung. F\xFChre `reasonix code` in einem Projekt aus, um eine Sitzung zu erhalten.",
+      replayNoArchives: "noch keine archivierten Pl\xE4ne f\xFCr diese Sitzung \u2014 `/replay` wird aktiv, sobald ein Plan abgeschlossen ist (auto-archiviert wenn alle Schritte erledigt).",
+      replayInvalidIndex: "ung\xFCltiger Index \u2014 `/replay` akzeptiert 1..{max} (neuester = 1). Verwende `/plans`, um die Liste zu sehen.",
+      archivedRow: "  \u2713 {when}  {total} Schritt{e} \xB7 {completion}  {label}",
+      completionComplete: "abgeschlossen",
+      stopAborted: "\u25B8 Plan gestoppt \u2014 Modell abgebrochen; tippe eine Folgenachricht, um fortzufahren oder eine neue Aufgabe zu starten.",
+      doneUsage: "Verwendung: /plans done <stepId>  \xB7  /plans done all \u2014 manuelle \xDCberschreibung, wenn das Modell vergessen hat, mark_step_complete aufzurufen",
+      doneUnavailable: "/plans done ist nur innerhalb einer aktiven Sitzung verf\xFCgbar.",
+      doneNoPlan: "Kein aktiver Plan \u2014 nichts als erledigt zu markieren.",
+      doneNotInPlan: "Schritt `{id}` ist nicht im aktiven Plan. F\xFChre /plans aus, um die Schritt-IDs zu sehen.",
+      doneAlready: "Schritt `{id}` wurde bereits als erledigt markiert.",
+      doneOk: "\u25B8 Schritt `{id}` als erledigt markiert.",
+      doneAllNoop: "Jeder Schritt ist bereits erledigt.",
+      doneAllOk: "\u25B8 {count} Schritt(e) als erledigt markiert."
+    },
+    jobs: {
+      ...EN.handlers.jobs,
+      codeOnly: "/jobs ist nur innerhalb von `reasonix code` verf\xFCgbar.",
+      killCodeOnly: "/kill ist nur innerhalb von `reasonix code` verf\xFCgbar.",
+      logsCodeOnly: "/logs ist nur innerhalb von `reasonix code` verf\xFCgbar.",
+      empty: "\u25C8 Jobs \xB7 0 laufend \xB7 0 gesamt\n  (run_background startet einen \u2014 Dev-Server, Watcher, langlebige Skripte)",
+      header: "\u25C8 Jobs \xB7 {running} laufend \xB7 {total} gesamt",
+      footer: "  /logs <id> tail \xB7 /kill <id> SIGTERM \u2192 SIGKILL",
+      killUsage: "Verwendung: /kill <id>   (siehe /jobs f\xFCr IDs)",
+      killNotFound: "Job {id}: nicht gefunden",
+      killAlreadyExited: "Job {id} bereits beendet ({code})",
+      killStopping: "\u25B8 stoppe Job {id} (Tree-Kill: SIGTERM \u2192 SIGKILL nach 2s Gnadenfrist; Windows: taskkill /T /F)",
+      killStatus: "\u25B8 Job {id} {status}",
+      killStillAlive: "Nach SIGKILL noch am Leben (!) \u2014 melde dies als Fehler",
+      logsUsage: "Verwendung: /logs <id> [zeilen]   (Standard letzte 80 Zeilen)",
+      logsNotFound: "Job {id}: nicht gefunden",
+      logsStatus: "[Job {id} \xB7 {status}]\n$ {command}",
+      logsRunning: "L\xE4uft \xB7 PID {pid}",
+      logsExited: "Beendet {code}",
+      logsFailed: "Fehlgeschlagen ({reason})",
+      logsStopped: "gestoppt"
+    },
+    memory: {
+      ...EN.handlers.memory,
+      disabled: "Memory ist deaktiviert (REASONIX_MEMORY=off in der Umgebung). Entferne die Variable zur Reaktivierung \u2014 es werden weder REASONIX.md noch ~/.reasonix/memory-Inhalte eingef\xFCgt.",
+      noRoot: "kein Arbeitsverzeichnis in dieser Sitzung \u2014 `/memory` ben\xF6tigt ein Root, um REASONIX.md aufzul\xF6sen. (L\xE4uft in einer Test-Umgebung?)",
+      listEmpty: "noch keine Benutzer-Memories. Das Modell kann `remember` aufrufen, um einen zu speichern, oder du kannst Dateien manuell in ~/.reasonix/memory/global/ oder dem projektspezifischen Unterverzeichnis erstellen.",
+      listHeader: "Benutzer-Memories ({count}):",
+      listFooter: "Body anzeigen: /memory show <name>   L\xF6schen: /memory forget <name>",
+      showUsage: "Verwendung: /memory show <name>  oder  /memory show <scope>/<name>",
+      showNotFound: "Kein Memory gefunden: {target}",
+      showFailed: "Anzeige fehlgeschlagen: {reason}",
+      forgetUsage: "Verwendung: /memory forget <name>  oder  /memory forget <scope>/<name>",
+      forgetNotFound: "Kein Memory gefunden: {target}",
+      forgetInfo: "\u25B8 {scope}/{name} entfernt. N\xE4chstes /new oder der n\xE4chste Start wird es nicht mehr sehen.",
+      forgetFailed: "Konnte {scope}/{name} nicht entfernen (bereits weg?)",
+      forgetError: "Entfernen fehlgeschlagen: {reason}",
+      clearUsage: "Verwendung: /memory clear <global|project> confirm",
+      clearConfirm: "Alle Memories im Bereich {scope} werden gel\xF6scht. F\xFChre den Befehl mit dem Wort 'confirm' erneut aus: /memory clear {scope} confirm",
+      cleared: "\u25B8 Bereich {scope} geleert \u2014 {count} Memory-Datei(en) gel\xF6scht.",
+      noMemory: "Kein Memory in {root} eingef\xFCgt.",
+      layers: "Drei Ebenen sind verf\xFCgbar:",
+      layerProject: "  1. {file} \u2014 commitierbares Team-Memory (im Repo).",
+      layerGlobal: "  2. ~/.reasonix/memory/global/ \u2014 dein projekt\xFCbergreifendes privates Memory.",
+      layerProjectHash: "  3. ~/.reasonix/memory/<projekt-hash>/ \u2014 privates Memory dieses Projekts.",
+      askModel: "Bitte das Modell, etwas zu `remember`, oder bearbeite die Dateien direkt.",
+      changesNote: "\xC4nderungen werden beim n\xE4chsten /new oder Start wirksam \u2014 der System-Prompt wird einmal pro Sitzung gehasht, um den Prefix-Cache warm zu halten.",
+      subcommands: "Unterbefehle: /memory list | /memory show <name> | /memory forget <name> | /memory clear <scope> confirm",
+      changesNoteShort: "\xC4nderungen werden beim n\xE4chsten /new oder Start wirksam. Unterbefehle: /memory list | show | forget | clear"
+    },
+    mcp: {
+      ...EN.handlers.mcp,
+      noServers: 'keine MCP-Server angeh\xE4ngt. F\xFChre `reasonix setup` aus, um welche auszuw\xE4hlen, oder starte mit --mcp "<spec>". `reasonix mcp list` zeigt den Katalog. Hinweis: vom Modell aufgerufene Shell-Befehle werden pro Aufruf abgefragt (einmal erlauben / immer erlauben / ablehnen) \u2014 kein globales Allow-All-Flag.',
+      toolsLabel: "  Tools     {count}",
+      resourcesHint: "`/resource` zum Durchsuchen+Lesen",
+      promptsHint: "`/prompt` zum Durchsuchen+Abrufen",
+      awarenessOnly: "Der Chat-Modus verbraucht Tools aktuell; Ressourcen+Prompts werden hier zur Information angezeigt.",
+      catalogHint: "Vollst\xE4ndiger Katalog: `reasonix mcp list` \xB7 tiefere Diagnose: `reasonix mcp inspect <spec>`.",
+      fallbackServers: "MCP-Server ({count}):",
+      fallbackTools: "Tools im Register ({count}):",
+      fallbackChange: "Um diesen Satz zu \xE4ndern, beende und f\xFChre `reasonix setup` aus.",
+      usageDisableEnable: "Verwendung: /mcp {action} <name>  \xB7  w\xE4hle einen in /mcp angezeigten Namen (anonyme Server k\xF6nnen nicht nach Namen umgeschaltet werden).",
+      usageReconnect: "Verwendung: /mcp reconnect <name>  \xB7  w\xE4hle einen in /mcp angezeigten Namen.",
+      unknownServer: 'unbekannter MCP-Server "{name}". Bekannt: {list}.',
+      noneList: "(keine)",
+      reconnectNoTui: "/mcp reconnect ben\xF6tigt die interaktive TUI (postInfo nicht angeschlossen).",
+      liveTab: "Live",
+      marketplaceTab: "Marktplatz",
+      tabHint: "Tab zum Umschalten"
+    },
+    init: {
+      ...EN.handlers.init,
+      codeOnly: "/init funktioniert nur im Code-Modus (es ben\xF6tigt Dateisystem-Werkzeuge).\nF\xFChre `reasonix code [pfad]` aus, um eine Sitzung zu starten, die im\nProjekt verwurzelt ist, das du initialisieren m\xF6chtest, und f\xFChre dann /init aus.",
+      exists: "\u25B8 REASONIX.md existiert bereits unter {path}",
+      existsForce: "  /init force   von Grund auf neu generieren (\xFCberschreibt)",
+      existsEdit: "  Oder bearbeite es von Hand \u2014 es ist nur Markdown. Die aktuelle Datei wird",
+      existsPinned: "  bei jedem Start unver\xE4ndert in den System-Prompt eingef\xFCgt.",
+      info: "\u25B8 /init \u2014 Modell scannt das Projekt und synthetisiert REASONIX.md.\n  Das Ergebnis landet als ausstehender Edit; mit /apply oder /walk reviewen."
+    },
+    webSearchEngine: {
+      ...EN.handlers.webSearchEngine,
+      currentEngine: "Aktuelle Websuchmaschine: {engine}",
+      endpoint: "SearXNG-Endpunkt: {url}",
+      usageHeader: "Verwendung:",
+      usageBing: "  /search-engine bing              Bing verwenden (Standard, funktioniert von CN ohne Proxy)",
+      usageSearxng: "  /search-engine searxng            SearXNG verwenden (Standard-Endpunkt)",
+      usageSearxngUrl: "  /search-engine searxng <url>      SearXNG mit benutzerdefiniertem Endpunkt",
+      usageMetaso: "  /search-engine metaso              Metaso-API verwenden (100/Tag kostenlos, konfiguriere eigenen API-Schl\xFCssel f\xFCr mehr)",
+      usageTavily: "  /search-engine tavily              Tavily-API verwenden (LLM-freundlich, kostenlos 1000/Monat \u2014 setze TAVILY_API_KEY oder tavilyApiKey in der Konfiguration; erhalte einen unter https://tavily.com)",
+      usagePerplexity: "  /search-engine perplexity          Perplexity AI verwenden (AI-native Antwort + Quellenangaben \u2014 setze PERPLEXITY_API_KEY oder perplexityApiKey in der Konfiguration; erhalte einen unter https://perplexity.ai/settings/api)",
+      usageExa: "  /search-engine exa                 Exa-API verwenden (AI-native Antwort + Quellenangaben, kostenlos 1000/Monat \u2014 setze EXA_API_KEY oder exaApiKey in der Konfiguration; registriere dich unter https://exa.ai)",
+      alias: "Alias: /se",
+      searxngInfo: "SearXNG ist eine selbst gehostete Metasuchmaschine (https://github.com/searxng/searxng).",
+      searxngInstall: "Installiere mit:  docker run -d -p 8080:8080 searxng/searxng",
+      switched: 'Websuchmaschine auf "{engine}" umgestellt.{note}',
+      switchedSearxngNote: " Stelle sicher, dass SearXNG unter {endpoint} l\xE4uft.",
+      switchedMetasoNote: " Es gibt ein t\xE4gliches Kontingent von 100 (konfiguriere einen eigenen API-Schl\xFCssel f\xFCr h\xF6here Grenzen).",
+      switchedTavilyNote: " Setze TAVILY_API_KEY oder `tavilyApiKey` in der Konfiguration; kostenlos 1000/Monat unter https://tavily.com.",
+      switchedPerplexityNote: " Setze PERPLEXITY_API_KEY oder `perplexityApiKey` in der Konfiguration; erhalte einen unter https://perplexity.ai/settings/api.",
+      switchedExaNote: " Setze EXA_API_KEY oder `exaApiKey` in der Konfiguration; registriere dich unter https://exa.ai.",
+      keyNeeded: 'Kein API-Schl\xFCssel f\xFCr "{engine}" konfiguriert.\n\n  1. Setze die {envVar}-Umgebungsvariable\n  2. Oder gib ihn inline an:  /search-engine {engine} <dein-schl\xFCssel>\n  3. Oder f\xFCge "{engine}ApiKey" zu ~/.reasonix/config.json hinzu\n\nWiederhole dann /search-engine {engine}.',
+      keySaved: " API-Schl\xFCssel in der Konfiguration gespeichert.",
+      confirmed: 'Websuchmaschine auf "{engine}" gesetzt{detail}. Der n\xE4chste Assistenten-Turn \xFCbernimmt die \xC4nderung.',
+      confirmedDetail: " ({endpoint})"
+    },
+    skill: {
+      ...EN.handlers.skill,
+      listEmpty: "Keine Skills gefunden. Reasonix liest Skills von:",
+      listProjectScope: "  \xB7 <projekt>/.reasonix/skills/<name>/SKILL.md  (oder <name>.md)  \u2014 Projekt-Bereich",
+      listGlobalScope: "  \xB7 ~/.reasonix/skills/<name>/SKILL.md  (oder <name>.md)  \u2014 globaler Bereich",
+      listProjectOnly: "  (Projekt-Bereich ist nur in `reasonix code` aktiv)",
+      listFrontmatter: "Die Frontmatter jeder Datei ben\xF6tigt mindestens `name` und `description`.",
+      listInvoke: "F\xFChre einen Skill aus mit `/skill <name> [args]` oder indem du das Modell bittest, `run_skill` aufzurufen.",
+      listHeader: "Benutzer-Skills ({count}):",
+      listFooter: "Anzeigen: /skill show <name>   Ausf\xFChren: /skill <name> [args]   Neu: /skill new <name>",
+      listEmptyNewHint: "Erstelle einen mit: /skill new <name>  (Projekt-Bereich) \u2014 es gibt noch kein entferntes Register; du erstellst Skills direkt.",
+      showUsage: "Verwendung: /skill show <name>",
+      showNotFound: "Kein Skill gefunden: {name}",
+      runNotFound: "Kein Skill gefunden: {name}  (versuche /skill list)",
+      runInfo: "\u25B8 f\xFChre Skill aus: {name}{args}",
+      newUsage: "Verwendung: /skill new <name> [--global]",
+      newCreated: "\u25B8 Skill erstellt: {name}\n  {path}\n  bearbeite ihn, dann `/skill {name}` zum Ausf\xFChren",
+      newError: "\u25B2 /skill new fehlgeschlagen: {reason}",
+      pathsHeader: "Skill-Pfade (Priorit\xE4tsreihenfolge):",
+      pathsPriority: "Priorit\xE4t: Projekt > benutzerdefinierte Pfade in Konfigurationsreihenfolge > global > builtin. \xC4nderungen wirken sich auf den System-Prompt beim n\xE4chsten /new oder einer neuen Sitzung aus.",
+      pathsUsage: "Verwendung: /skill paths [list]\n       /skill paths add <pfad>\n       /skill paths remove <pfad|N>",
+      pathsAddUsage: "Verwendung: /skill paths add <pfad>",
+      pathsRemoveUsage: "Verwendung: /skill paths remove <pfad|N>",
+      pathsAdded: "\u25B8 benutzerdefinierten Skill-Pfad hinzugef\xFCgt: {path}",
+      pathsAlready: "\u25B8 benutzerdefinierter Skill-Pfad bereits konfiguriert: {path}",
+      pathsRemoved: "\u25B8 benutzerdefinierten Skill-Pfad entfernt: {path}",
+      pathsRemoveNotFound: "\u25B8 kein benutzerdefinierter Skill-Pfad entspricht: {target}",
+      pathsRestartHint: "Der System-Prompt der aktuellen Sitzung ist unver\xE4ndert; f\xFChre /new aus oder starte eine neue Sitzung, um das Skills-Register zu aktualisieren."
+    }
+  },
+  statusBar: {
+    ...EN.statusBar,
+    turn: "Turn",
+    cache: "Cache",
+    spent: "ausgegeben",
+    left: " \xFCbrig",
+    slow: "langsam",
+    disconnect: "trennen",
+    reconnecting: "Verbinde neu\u2026",
+    approvingIn: "Genehmige in ",
+    escToInterrupt: "Esc zum Unterbrechen",
+    recordingGlyph: "Aufnahme",
+    mb: " MB",
+    evt: " Ereignis",
+    editsLabel: "Edits:",
+    mcpLoading: "MCP",
+    ctx: "Kontext",
+    shortcutsHint: "Strg+P Tastenk\xFCrzel"
+  },
+  editMode: {
+    ...EN.editMode,
+    plan: "PLAN-MODUS",
+    yolo: "YOLO",
+    auto: "AUTO",
+    review: "REVIEW",
+    writesGated: "   Schreibzugriffe blockiert \xB7 /plan off zum Verlassen",
+    editsShellAuto: "Edits + Shell auto \xB7 /undo zum R\xFCckg\xE4ngigmachen",
+    editsLandNow: "Edits werden sofort angewandt \xB7 u zum R\xFCckg\xE4ngigmachen",
+    queuedApplyDiscard: "{count} in Warteschlange \xB7 y anwenden \xB7 n verwerfen",
+    editsQueued: "Edits in Warteschlange \xB7 y anwenden \xB7 n verwerfen",
+    shiftTabFlip: "   {mid} \xB7 Shift+Tab zum Umschalten",
+    queuedDots: "In Warteschlange\u2026"
+  },
+  composer: {
+    ...EN.composer,
+    placeholder: "Frag etwas  \xB7  slash f\xFCr Befehle  \xB7  at-Zeichen f\xFCr Dateien",
+    waitingForResponse: "\u2026warte auf Antwort\u2026",
+    hintSend: "senden",
+    hintNewline: "Neue Zeile",
+    hintClear: "leeren",
+    hintScroll: "scrollen",
+    hintHistory: "Verlauf",
+    hintAbort: "abbrechen",
+    hintQuit: "beenden",
+    abortedHint: "Turn vom Benutzer abgebrochen \xB7 erneut Esc zum Leeren \xB7 \u23CE f\xFCr eine Folgefrage",
+    editorNoRawMode: "externer Editor nicht verf\xFCgbar \u2014 stdin unterst\xFCtzt Raw-Mode-Umschaltung auf diesem Terminal nicht",
+    editorFailed: "Externer Editor:",
+    editorMissing: "kein $EDITOR / $VISUAL / $GIT_EDITOR gesetzt \u2014 exportiere einen (z.B. `export EDITOR=nano`) und versuche es erneut",
+    editorExited: "Editor mit Code {code} beendet",
+    typeaheadStaged: "\u25B8 {count} Zeile(n) bereitgestellt \xB7 Esc zur\xFCckrufen",
+    steerPlaceholder: "tippe, um die aktuelle Aufgabe zu steuern \u2014 Befehle sind deaktiviert, solange besch\xE4ftigt",
+    steerHint: "Senden \u2014 mid-Turn eingef\xFCgt",
+    stashNothing: "Nichts zu speichern",
+    stashSaved: "Gespeichert",
+    stashRecall: "Abgerufen"
+  },
+  pathConfirm: {
+    ...EN.pathConfirm,
+    title: "Pfad au\xDFerhalb des Sandbox",
+    subtitleRead: "{tool} m\xF6chte eine Datei AUSSERHALB des Projekt-Sandbox lesen",
+    subtitleWrite: "{tool} m\xF6chte eine Datei AUSSERHALB des Projekt-Sandbox schreiben",
+    awaiting: "wartet",
+    denyTitle: "Ablehnen \u2014 Kontext angeben",
+    optional: "optional",
+    denyFooter: "Kontext eingeben  \xB7  \u23CE mit Grund absenden  \xB7  Esc \xFCberspringen (ohne Grund ablehnen)",
+    pickFooter: "\u2191\u2193 ausw\xE4hlen  \xB7  \u23CE best\xE4tigen  \xB7  Tab Kontext hinzuf\xFCgen  \xB7  Esc abbrechen",
+    allowOnce: "Einmal erlauben",
+    allowOnceDesc: "Diesen Zugriff erlauben; das Verzeichnis f\xFCr den Rest dieser Sitzung merken",
+    allowAlways: "Immer erlauben",
+    allowAlwaysDesc: "`{prefix}` f\xFCr dieses Projekt merken (gespeichert in ~/.reasonix/config.json)",
+    deny: "ablehnen",
+    denyDesc: "Tab dr\xFCcken, um dem Modell den Grund mitzuteilen",
+    pathLabel: "Pfad",
+    sandboxLabel: "Sandbox",
+    allowPrefixLabel: "Pr\xE4fix",
+    promptTitleRead: "Pfadzugriff \u2014 lesen",
+    promptTitleWrite: "Pfadzugriff \u2014 schreiben",
+    actionAllowRead: "Lesen erlauben",
+    actionAllowWrite: "Schreiben erlauben",
+    actionAlwaysAllow: "Immer erlauben \u2014 {prefix}",
+    actionDeny: "Ablehnen"
+  },
+  shellConfirm: {
+    ...EN.shellConfirm,
+    title: "Shell-Befehl",
+    bgTitle: "Hintergrundprozess",
+    subtitle: "Modell m\xF6chte einen Shell-Befehl ausf\xFChren",
+    bgSubtitle: "Langlebiger Prozess \u2014 l\xE4uft nach Genehmigung weiter, /kill zum Stoppen",
+    denyTitle: "Ablehnen \u2014 Kontext angeben",
+    optional: "optional",
+    denyFooter: "Kontext eingeben  \xB7  \u23CE mit Grund absenden  \xB7  Esc \xFCberspringen (ohne Grund ablehnen)",
+    awaiting: "wartet",
+    pickFooter: "\u2191\u2193 ausw\xE4hlen  \xB7  \u23CE best\xE4tigen  \xB7  Tab Kontext hinzuf\xFCgen  \xB7  Esc abbrechen",
+    allowOnce: "Einmal erlauben",
+    allowOnceDesc: "Diesen Befehl ausf\xFChren, beim n\xE4chsten Mal erneut fragen",
+    allowAlways: "Immer erlauben",
+    allowAlwaysDesc: "`{prefix}` f\xFCr dieses Projekt merken",
+    deny: "ablehnen",
+    denyDesc: "Tab dr\xFCcken, um dem Modell den Grund mitzuteilen",
+    cwdLabel: "awd",
+    timeoutLabel: "Timeout",
+    waitLabel: "warten",
+    previewMore: "\u2026 {n} weitere Zeile ausgeblendet \u2014 Esc dr\xFCcken, Modell bitten, sie aufzuteilen",
+    previewMorePlural: "\u2026 {n} weitere Zeilen ausgeblendet \u2014 Esc dr\xFCcken, Modell bitten, sie aufzuteilen",
+    promptTitleRunCommand: "Befehl ausf\xFChren",
+    promptTitleRunBackground: "Hintergrundbefehl ausf\xFChren",
+    actionRunOnce: "Einmal ausf\xFChren",
+    actionAlwaysAllow: "Immer erlauben \u2014 {prefix}",
+    actionDeny: "Ablehnen"
+  },
+  editConfirm: {
+    ...EN.editConfirm,
+    footer: "[y/Enter] anwenden  \xB7  [n] mit Grund ablehnen  \xB7  [a] Rest anwenden  \xB7  [A] AUTO umschalten  \xB7  [\u2191\u2193/Leertaste] scrollen  \xB7  [Esc] abbrechen",
+    newTag: "NEU",
+    editTag: "BEARBEITET",
+    linesCount: "-{removed} +{added} Zeilen",
+    viewingRange: "Zeige {start}-{end}/{total}",
+    denyFooter: "\u23CE absenden  \xB7  Esc \xFCberspringen (ohne Grund ablehnen)",
+    oldLabel: "  - alt",
+    newLabel: "  + neu",
+    sideBySide: "   nebeneinander \xB7 entfernte Zeilen links, hinzugef\xFCgte rechts \xB7 paarweise nach Versatz",
+    linesAbove: "  \u2191 {count} Zeile dar\xFCber  (\u2191/k oder Bild\u2191)",
+    linesAbovePlural: "  \u2191 {count} Zeilen dar\xFCber  (\u2191/k oder Bild\u2191)",
+    linesBelow: "  \u2193 {count} Zeile darunter  (\u2193/j oder Leertaste/Bild\u2193)",
+    linesBelowPlural: "  \u2193 {count} Zeilen darunter  (\u2193/j oder Leertaste/Bild\u2193)"
+  },
+  editPicker: {
+    ...EN.editPicker,
+    title: "Vorherige Nachricht bearbeiten",
+    hint: "\u2191\u2193 ausw\xE4hlen \xB7 Enter zum Laden in den Composer \xB7 Esc abbrechen",
+    empty: "Noch keine Benutzer-Turns \u2014 nichts zu bearbeiten",
+    dismiss: "Esc zum Schlie\xDFen",
+    forked: "\u25B8 bei Turn #{turn} abgezweigt \u2014 Puffer enth\xE4lt den Originaltext"
+  },
+  sessionPicker: {
+    ...EN.sessionPicker,
+    header: " \u25C8 REASONIX \xB7 Sitzung ausw\xE4hlen ",
+    title: "Sitzung ausw\xE4hlen \u2014 {workspace}",
+    messages: "{count} Nachricht",
+    messagesPlural: "{count} Nachrichten",
+    turns: "{count} Turns",
+    pickerHint: "\u2191\u2193 ausw\xE4hlen \xB7 / suchen \xB7 \u23CE \xF6ffnen \xB7 [n] neu \xB7 [d] l\xF6schen \xB7 [r] umbenennen \xB7 Esc beenden",
+    empty: "  noch keine gespeicherten Sitzungen in diesem Arbeitsbereich \u2014 dr\xFCcke ",
+    emptyNew: " um eine neue zu starten",
+    renamePrompt: '  "{from}" umbenennen \u2192 ',
+    renameHint: "  \u23CE Umbenennung best\xE4tigen  \xB7  Esc abbrechen",
+    searchPrompt: "  Sitzungen durchsuchen: /",
+    searchHint: "  tippen zum Filtern  \xB7  \u23CE Treffer \xF6ffnen  \xB7  Esc zur\xFCcksetzen",
+    searchEmpty: "  keine Sitzungen entsprechen dieser Suche",
+    emptyHint: "  \u23CE neue Sitzung  \xB7  Esc beenden",
+    justNow: "Gerade eben",
+    minAgo: "Vor {count} Min",
+    yesterday: "gestern",
+    hoursAgo: "Vor {count}h",
+    daysAgo: "Vor {count} Tagen"
+  },
+  workspacePicker: {
+    ...EN.workspacePicker,
+    header: " \u25C8 REASONIX \xB7 Arbeitsbereich ausw\xE4hlen ",
+    title: "Arbeitsbereich ausw\xE4hlen \u2014 {workspace}",
+    sessions: "{count} Sitzung",
+    sessionsPlural: "{count} Sitzungen",
+    current: "aktuell",
+    pickerHint: "\u2191\u2193 ausw\xE4hlen \xB7 / suchen \xB7 \u23CE wechseln + Sitzung ausw\xE4hlen \xB7 Esc beenden \xB7 /cwd <pfad> f\xFCgt einen hinzu",
+    empty: "  noch keine bekannten Arbeitsbereiche \u2014 f\xFChre /cwd <pfad> einmal aus, um einen hinzuzuf\xFCgen",
+    searchPrompt: "  Arbeitsbereiche durchsuchen: /",
+    searchHint: "  tippen zum Filtern  \xB7  \u23CE wechseln + Sitzung ausw\xE4hlen  \xB7  Esc zur\xFCcksetzen",
+    searchEmpty: "  keine Arbeitsbereiche entsprechen dieser Suche"
+  },
+  modelPicker: {
+    ...EN.modelPicker,
+    header: " \u25C8 REASONIX \xB7 Einrichtung ausw\xE4hlen ",
+    loading: "  \xB7  lade Katalog\u2026",
+    catalogEmpty: "  \xB7  Katalog leer \u2014 verwende bekannte Fallbacks",
+    modelsAvailable: "  \xB7  {count} Modelle verf\xFCgbar",
+    effortHeader: "    EFFORT  \xB7  Reasoning-Effort-Grenze",
+    modelsHeader: "    MODELLE  \xB7  DeepSeek-kompatible IDs",
+    effortDesc: {
+      ...EN.modelPicker.effortDesc,
+      low: "Am schnellsten \u2014 minimales Reasoning",
+      medium: "ausgewogen",
+      high: "Standard \u2014 sicher f\xFCr vLLM / Azure",
+      max: "DeepSeek-Erweiterung; von stock OpenAI / vLLM abgelehnt"
+    },
+    pickerFooter: "  \u2191\u2193 ausw\xE4hlen  \xB7  \u23CE best\xE4tigen  \xB7  [r] aktualisieren  \xB7  Esc abbrechen",
+    currentLabel: "  \xB7 aktuell"
+  },
+  slashSuggestions: {
+    ...EN.slashSuggestions,
+    noMatch: "Kein Slash-Befehl entspricht diesem Pr\xE4fix",
+    backspaceHint: " \u2014 R\xFCcktaste zum Bearbeiten, oder /help f\xFCr die vollst\xE4ndige Liste",
+    commandCount: "{count} Befehl",
+    commandCountPlural: "{count} Befehle",
+    aboveLabel: "   \u2191 {count} dar\xFCber",
+    belowLabel: "   \u2193 {count} darunter",
+    advancedHint: "  + {count} erweitert  \xB7  tippe einen Buchstaben zum Suchen",
+    footerHint: "  \u2191\u2193 navigieren \xB7 Tab / \u23CE ausw\xE4hlen \xB7 Esc abbrechen",
+    groupChat: "CHAT",
+    groupSetup: "SETUP",
+    groupInfo: "INFO",
+    groupSession: "SITZUNG",
+    groupExtend: "ERWEITERN",
+    groupCode: "CODE",
+    groupJobs: "JOBS",
+    groupAdvanced: "ERWEITERT",
+    groupDetailSetup: "Modell + Kosten",
+    groupDetailInfo: "Aktueller Zustand",
+    groupDetailChat: "T\xE4gliche Turn-Operationen",
+    groupDetailExtend: "MCP, Memory, Skills",
+    groupDetailSession: "Gespeicherte Sitzungen",
+    groupDetailCode: "Edits + Pl\xE4ne (Code-Modus)",
+    groupDetailJobs: "Hintergrundprozesse (Code-Modus)",
+    groupDetailAdvanced: "Selten oder einmalig"
+  },
+  atMentions: {
+    ...EN.atMentions,
+    loading: "lade\u2026",
+    entrySingular: "{count} Eintrag",
+    entryPlural: "{count} Eintr\xE4ge",
+    searching: "suche\u2026",
+    scanned: "gescannt",
+    match: "Treffer",
+    matches: "Treffer",
+    forFilter: 'f\xFCr "{filter}"',
+    noMatch: 'keine Dateien entsprechen "{filter}"',
+    emptyDir: "Leeres Verzeichnis",
+    scanning: "Durchsuche Verzeichnisbaum\u2026",
+    footerBrowse: "\u2191\u2193 navigieren \xB7 Tab in Ordner eintauchen \xB7 \u23CE einf\xFCgen \xB7 Esc abbrechen",
+    footerBrowseSearch: "\u2191\u2193 navigieren \xB7 Tab / \u23CE als @pfad einf\xFCgen \xB7 Esc abbrechen",
+    footerInsert: "\u2191\u2193 navigieren \xB7 Tab / \u23CE als @pfad einf\xFCgen \xB7 Esc abbrechen"
+  },
+  statsPanel: {
+    ...EN.statsPanel,
+    modePlan: "PLAN",
+    modeYolo: "yolo",
+    modeAuto: "auto",
+    modeReview: "review",
+    pro: "\u21E7 pro",
+    budget: "  Budget  "
+  },
+  welcomeBanner: {
+    ...EN.welcomeBanner,
+    workspace: "\u25B8 Arbeitsbereich",
+    relaunchHint: "  (mit --dir <pfad> neu starten zum Wechseln)",
+    dashboard: "\u25B8 Web"
+  },
+  ctxBreakdown: {
+    ...EN.ctxBreakdown,
+    title: "\u25A3 Kontext",
+    compactHint: "  /compact faltet (automatisch bei 50 %) \xB7 /new l\xF6scht Log",
+    topTools: "  Top-Tool-Ergebnisse nach Kosten ({count}):",
+    msg: "Nachr",
+    turnLabel: "Turn"
+  },
+  startup: {
+    ...EN.startup,
+    codeRooted: '\u25B8 reasonix code: verwurzelt in {rootDir}, Sitzung "{session}" \xB7 {tools} native Tool{s}{semantic}',
+    ephemeral: "(ephemer)",
+    semanticOn: " \xB7 Semantic-Search an"
+  },
+  doctorErrors: {
+    ...EN.doctorErrors,
+    unreadable: "{path} nicht lesbar \u2014 {message}",
+    cannotList: "Kann nicht auflisten \u2014 {message}",
+    parseFailed: "settings.json konnte nicht geparst werden \u2014 {message}",
+    probeFailed: "Test fehlgeschlagen \u2014 {message}"
+  },
+  webErrors: {
+    ...EN.webErrors,
+    status: "web_search {status} \u2014 versuche: Das Such-Backend hat einen Fehler zur\xFCckgegeben; formuliere die Abfrage um oder wechsle die Engine mit /search-engine bing|searxng|metaso|tavily|perplexity|exa",
+    rateLimit429: "web_search 429 \u2014 versuche: 10s warten vor erneuter Abfrage oder Abfrage umformulieren; das Such-Backend ratelimited diesen Client",
+    forbidden403: "web_search 403 \u2014 versuche: Das Such-Backend blockiert diesen Client; wechsle die Engine mit /search-engine bing|searxng|metaso|tavily|perplexity|exa oder warte und versuche es sp\xE4ter erneut",
+    serverError5xx: "web_search {status} \u2014 versuche: \xD6ffne die Such-URL in einem Browser; falls sie l\xE4dt, ist dies vor\xFCbergehend und ein erneuter Versuch in 30s kann helfen",
+    bingBlocked: "web_search: Bing-Anti-Bot-Seite \u2014 ratelimited oder blockiert \u2014 versuche: 30s warten und erneut versuchen, oder wechsle die Engine mit /search-engine bing|searxng|metaso|tavily|perplexity|exa",
+    bingNoResults: "web_search: 0 Ergebnisse, aber die Antwort sieht nicht wie eine echte leere Seite aus ({chars} Zeichen, erste 120: {preview}) \u2014 versuche: formuliere die Abfrage mit einfacheren Begriffen um oder wechsle die Engine mit /search-engine bing|searxng|metaso|tavily|perplexity|exa",
+    invalidEndpoint: 'web_search: ung\xFCltiger SearXNG-Endpunkt "{endpoint}" \u2014 versuche: setze eine g\xFCltige URL mit /search-endpoint http://host:port',
+    endpointMustBeHttp: "web_search: SearXNG-Endpunkt muss http(s) sein, {protocol} erhalten \u2014 versuche: setze eine g\xFCltige URL mit /search-endpoint http://host:port",
+    cannotReach: "web_search: SearXNG-Server unter {endpoint} nicht erreichbar \u2014 versuche: SearXNG installieren und starten (https://github.com/searxng/searxng, z.B. `docker run -d -p 8080:8080 searxng/searxng`), oder wechsle zu einer anderen Engine mit /search-engine bing|searxng|metaso|tavily|perplexity|exa",
+    searxngNoResults: "web_search: 0 Ergebnisse, aber SearXNG-Antwort sieht nicht wie eine leere Ergebnisseite aus ({chars} Zeichen) \u2014 versuche: formuliere die Abfrage mit einfacheren Begriffen um oder wechsle die Engine mit /search-engine bing|searxng|metaso|tavily|perplexity|exa",
+    metasoMissingKey: "web_search: Metaso ben\xF6tigt einen API-Schl\xFCssel \u2014 setze METASO_API_KEY oder konfiguriere einen mit /search-engine metaso <schl\xFCssel>. Erhalte einen unter https://metaso.cn/search-api/playground",
+    metasoDailyLimit: "web_search: Metaso-Tageslimit erreicht \u2014 setze METASO_API_KEY oder erhalte einen Schl\xFCssel unter https://metaso.cn/search-api/playground",
+    metasoUnauthorized: "web_search: Metaso-API-Schl\xFCssel abgelehnt \u2014 \xFCberpr\xFCfe METASO_API_KEY oder erhalte einen unter https://metaso.cn/search-api/playground",
+    metasoRateLimit: "web_search: Metaso ratelimited \u2014 warte und versuche es erneut, oder erhalte einen eigenen API-Schl\xFCssel unter https://metaso.cn/search-api/playground",
+    metasoServerError: "web_search: Metaso-Serverfehler ({status}) \u2014 versuche es sp\xE4ter erneut oder wechsle die Engine mit /search-engine bing|searxng|metaso|tavily|perplexity|exa",
+    metasoParseError: "web_search: Metaso hat unparsbare Antwort zur\xFCckgegeben (HTTP {status}) \u2014 versuche es sp\xE4ter erneut",
+    metasoApiError: "web_search: Metaso-API-Fehler (Code {code}: {message}) \u2014 versuche es sp\xE4ter erneut",
+    tavilyMissingKey: "web_search: Tavily-Backend ben\xF6tigt einen API-Schl\xFCssel \u2014 setze TAVILY_API_KEY-Umgebungsvariable oder `tavilyApiKey` in ~/.reasonix/config.json; kostenlose 1000/Monat-Registrierung unter https://tavily.com",
+    tavilyUnauthorized: "web_search: Tavily-API-Schl\xFCssel abgelehnt \u2014 \xFCberpr\xFCfe TAVILY_API_KEY oder erhalte einen unter https://tavily.com",
+    tavilyRateLimit: "web_search: Tavily ratelimited oder monatliches Kontingent \xFCberschritten \u2014 warte, wechsle die Engine mit /search-engine bing|searxng|metaso|tavily|perplexity|exa oder upgrade deinen Tavily-Plan",
+    tavilyServerError: "web_search: Tavily-Serverfehler ({status}) \u2014 versuche es sp\xE4ter erneut oder wechsle die Engine mit /search-engine bing|searxng|metaso|tavily|perplexity|exa",
+    tavilyParseError: "web_search: Tavily hat unparsbare Antwort zur\xFCckgegeben (HTTP {status}) \u2014 versuche es sp\xE4ter erneut",
+    perplexityMissingKey: "web_search: Perplexity-Backend ben\xF6tigt einen API-Schl\xFCssel \u2014 setze PERPLEXITY_API_KEY-Umgebungsvariable oder `perplexityApiKey` in ~/.reasonix/config.json; erhalte einen unter https://perplexity.ai/settings/api",
+    perplexityUnauthorized: "web_search: Perplexity-API-Schl\xFCssel abgelehnt \u2014 \xFCberpr\xFCfe PERPLEXITY_API_KEY oder erhalte einen unter https://perplexity.ai/settings/api",
+    perplexityRateLimit: "web_search: Perplexity ratelimited \u2014 warte und versuche es erneut, oder wechsle die Engine mit /search-engine bing|searxng|metaso|tavily|perplexity|exa",
+    perplexityServerError: "web_search: Perplexity-Serverfehler ({status}) \u2014 versuche es sp\xE4ter erneut oder wechsle die Engine mit /search-engine bing|searxng|metaso|tavily|perplexity|exa",
+    perplexityParseError: "web_search: Perplexity hat unparsbare Antwort zur\xFCckgegeben (HTTP {status}) \u2014 versuche es sp\xE4ter erneut",
+    exaMissingKey: "web_search: Exa-Backend ben\xF6tigt einen API-Schl\xFCssel \u2014 setze EXA_API_KEY-Umgebungsvariable oder `exaApiKey` in ~/.reasonix/config.json; kostenlose 1000/Monat-Registrierung unter https://exa.ai",
+    exaUnauthorized: "web_search: Exa-API-Schl\xFCssel abgelehnt \u2014 \xFCberpr\xFCfe EXA_API_KEY oder erhalte einen unter https://exa.ai",
+    exaRateLimit: "web_search: Exa-API ratelimited oder monatliches Kontingent \xFCberschritten \u2014 warte oder upgrade unter https://exa.ai/pricing",
+    exaServerError: "web_search: Exa-Serverfehler ({status}) \u2014 versuche es sp\xE4ter erneut oder wechsle die Engine mit /search-engine bing|searxng|metaso|tavily|perplexity|exa",
+    exaParseError: "web_search: Exa hat unparsbare Antwort zur\xFCckgegeben (HTTP {status}) \u2014 versuche es sp\xE4ter erneut",
+    fetchStatus: "web_fetch {status} f\xFCr {url} \u2014 versuche: Best\xE4tige, dass die URL im Browser aufgel\xF6st wird; der Status deutet darauf hin, dass der Host eine Fehlerseite zur\xFCckgegeben hat",
+    fetchRateLimit429: "web_fetch 429 f\xFCr {url} \u2014 versuche: 10s warten vor erneuter Abfrage; der Host ratelimitet diesen Client",
+    fetchForbidden403: "web_fetch 403 f\xFCr {url} \u2014 versuche: Der Host blockiert diesen Client; die Seite erfordert m\xF6glicherweise eine Anmeldung oder blockiert Bots \u2014 verwende stattdessen web_search-Ausz\xFCge",
+    fetchServerError5xx: "web_fetch {status} f\xFCr {url} \u2014 versuche: \xD6ffne die URL in einem Browser; falls sie l\xE4dt, ist dies vor\xFCbergehend und ein erneuter Versuch in 30s kann helfen",
+    fetchTimeout: "web_fetch: Zeit\xFCberschreitung nach {ms}ms f\xFCr {url} \u2014 versuche: eine k\xFCrzere URL oder kleinere Inhalte; dies k\xF6nnte ein langsames CDN sein, oder einmal erneut versuchen",
+    fetchTooLarge: "web_fetch abgelehnt: content-length {len} Bytes \xFCberschreitet {cap}-Byte-Grenze ({url}) \u2014 versuche: eine andere URL mit kleineren Inhalten; diese Seite ist zu gro\xDF zum Abrufen",
+    fetchBodyTooLarge: "web_fetch abgelehnt: Antwortbody \xFCberschritt {cap}-Byte-Grenze ({seen} Bytes gesehen) \u2014 versuche: eine andere URL mit kleineren Inhalten; diese Seite hat die Gr\xF6\xDFenbeschr\xE4nkung \xFCberschritten",
+    fetchInvalidUrl: "web_fetch: URL muss mit http:// oder https:// beginnen \u2014 versuche: eine absolute http(s)-URL \xFCbergeben (die URL ist fehlerhaft oder verwendet ein nicht unterst\xFCtztes Schema)"
+  },
+  choiceConfirm: {
+    ...EN.choiceConfirm,
+    customLabel: "Eigene Antwort eingeben",
+    customDesc: "Keine der Optionen passt \u2014 gib eine Freitext-Antwort ein. Das Modell liest sie w\xF6rtlich.",
+    cancelLabel: "Abbrechen \u2014 Frage verwerfen",
+    cancelDesc: "Modell stoppt und fragt, was du stattdessen m\xF6chtest."
+  },
+  cardTitles: {
+    ...EN.cardTitles,
+    usage: "Nutzung",
+    context: "Kontext",
+    search: "Suche",
+    subagent: "Subagent",
+    reply: "Antwort",
+    reasoning: "Reasoning",
+    reasoningAborted: "Reasoning (abgebrochen)",
+    reasoningEllipsis: "Reasoning\u2026",
+    error: "Fehler",
+    doctor: "Doctor",
+    you: "du",
+    task: "Aufgabe"
+  },
+  cardLabels: {
+    ...EN.cardLabels,
+    prompt: "Prompt",
+    reason: "Grund",
+    output: "Ausgabe",
+    cache: "Cache",
+    session: "Sitzung",
+    balance: "Guthaben",
+    turn: "Turn",
+    system: "System",
+    tools: "Tools",
+    log: "Log",
+    input: "Eingabe",
+    topTools: "Top-Tools",
+    logMsgs: "Log-Nachr",
+    hitSingular: "{count} Treffer \xB7 {files} Datei",
+    hitsPlural: "{count} Treffer \xB7 {files} Dateien",
+    moreHitSingular: "\u22EE +{count} weiterer Treffer",
+    moreHitsPlural: "\u22EE +{count} weitere Treffer",
+    earlierLine: "\u22EE {count} ausgeblendete Zeile (Strg+R f\xFCr vollst\xE4ndige Ausgabe)",
+    earlierLines: "\u22EE {count} ausgeblendete Zeilen (Strg+R f\xFCr vollst\xE4ndige Ausgabe)",
+    hiddenLine: "\u22EE {count} ausgeblendete Zeile",
+    hiddenLines: "\u22EE {count} ausgeblendete Zeilen",
+    earlierStackLine: "\u22EE {count} fr\xFChere Stack-Zeile ausgeblendet",
+    earlierStackLines: "\u22EE {count} fr\xFChere Stack-Zeilen ausgeblendet",
+    agent: "Agent \xB7 {name}",
+    response: "Antwort",
+    writing: "Schreibe \u2026",
+    tok: "Tok",
+    pilcrow: "\xB6",
+    aborted: "abgebrochen",
+    truncatedByEsc: "[durch Esc gek\xFCrzt]",
+    rejected: "abgelehnt",
+    exit: "Exit {code}",
+    bytesIn: "{bytes} rein",
+    elapsedSec: "{secs}s",
+    stackTrace: "Stacktrace",
+    retries: "Wiederholungen",
+    reasoningLabel: "Reasoning \xB7 {count} \xB6",
+    runningLabel: "l\xE4uft",
+    workingLabel: "arbeitet",
+    defaultFooter: "\u2191\u2193 ausw\xE4hlen  \xB7  \u23CE best\xE4tigen  \xB7  Esc abbrechen",
+    applyAction: "[a] anwenden",
+    skipAction: "[s] \xFCberspringen",
+    rejectAction: "[r] ablehnen",
+    levelOk: "OK",
+    levelWarn: "Warn",
+    levelFail: "FEHLGESCHLAGEN",
+    checksLabel: "Pr\xFCfungen",
+    passed: "bestanden",
+    warnTag: "Warn",
+    failTag: "Fehl",
+    stepLabel: "Schritt",
+    done: "erledigt",
+    inProgress: "\u2190 in Bearbeitung",
+    upcoming: "bevorstehend",
+    resumed: "fortgesetzt \xB7 ",
+    archive: "\u23E4 archivieren \xB7 ",
+    more: "\u22EE +{count} weitere",
+    categoryUser: "Benutzer",
+    categoryFeedback: "Feedback",
+    categoryProject: "Projekt",
+    categoryReference: "Referenz"
+  },
+  mcpHealth: {
+    ...EN.mcpHealth,
+    noData: "Keine Inspektionsdaten",
+    healthy: "Gesund \xB7 {ms}ms",
+    slow: "Langsam \xB7 {ms}ms",
+    verySlow: "Sehr langsam \xB7 {ms}ms",
+    slowToast: "\u26A0 MCP `{name}` langsam \xB7 {seconds}s p95 \xFCber die letzten {sampleSize} Aufrufe",
+    emptyHint: "\u2139 keine MCP-Server konfiguriert \u2014 versuche: `reasonix setup` zur erneuten Auswahl, oder `reasonix mcp install filesystem` \xB7 Shell-Befehle werden pro Aufruf abgefragt (einmal erlauben / immer erlauben / ablehnen), kein globales Allow-All"
+  },
+  denyContextInput: {
+    ...EN.denyContextInput,
+    description: "Sag dem Agenten, warum du abgelehnt hast. Der n\xE4chste Versuch sieht deinen Grund als zus\xE4tzlichen Kontext."
+  },
+  cardStream: {
+    ...EN.cardStream,
+    scrollAbove: " \u2191 {scroll} / {max} Zeile dar\xFCber",
+    scrollAbovePlural: " \u2191 {scroll} / {max} Zeilen dar\xFCber",
+    scrollMore: " \u2014 {remaining} weitere",
+    scrollPgUp: " \xB7 Bild\u2191 / Mausrad",
+    scrollCopy: " \xB7 /copy aktiviert Kopiermodus"
+  },
+  slashArgPicker: {
+    ...EN.slashArgPicker,
+    noMatch: 'keine \xDCbereinstimmung f\xFCr "{partial}"',
+    keepTyping: " \u2014 tippe weiter, oder R\xFCcktaste zum Bearbeiten",
+    above: "   \u2191 {hidden} dar\xFCber",
+    below: "   \u2193 {hidden} darunter",
+    footer: "  \u2191\u2193 navigieren \xB7 Tab / \u23CE ausw\xE4hlen \xB7 Esc abbrechen"
+  },
+  mcpMarketplace: {
+    ...EN.mcpMarketplace,
+    title: "MCP-Marktplatz",
+    filter: "Filter: ",
+    filterPlaceholder: "(tippen zum Filtern)",
+    matchSingular: "{n} Treffer",
+    matchPlural: "{n} Treffer",
+    loading: "lade\u2026",
+    noEntries: "Keine Eintr\xE4ge",
+    opening: "\xD6ffne Registry\u2026",
+    cached: "\xB7 zwischengespeichert",
+    exhausted: "\xB7 ersch\xF6pft",
+    loadingMore: "Lade mehr\u2026",
+    allLoaded: "Alle Seiten geladen",
+    fetchingDetail: "Hole Smithery-Details\u2026",
+    noInstallInfo: "keine Installationsinfo f\xFCr {name} - versuche `npx -y @smithery/cli install {name}`",
+    alreadyInstalled: "Bereits installiert: {spec}",
+    installed: "Installiert \u2192 {spec}",
+    uninstalled: "{name} deinstalliert",
+    installFailed: "Installation fehlgeschlagen: {message}",
+    notInstalled: "Nicht installiert: {name}",
+    bridged: "\u2713 {name} installiert - verbunden",
+    bridgeFailed: "\u25B2 {name} installiert - Verbindung fehlgeschlagen: {reason}",
+    bridgeReloadFailed: "\u2713 {name} installiert - starte `reasonix code` neu zur Verbindung (Neuladen fehlgeschlagen: {message})",
+    restartBridge: "\u2713 {name} installiert - starte `reasonix code` neu zur Verbindung",
+    needsEnv: "  \xB7  ben\xF6tigt Umgebungsvariable: {env}",
+    badgeOfficial: "[off]",
+    badgeSmithery: "[smt]",
+    badgeLocal: "[loc]",
+    footerHint: "Filter eingeben \xB7 \u2191\u2193 ausw\xE4hlen \xB7 \u23CE installieren/umschalten \xB7 Bild\u2193 mehr laden \xB7 Esc schlie\xDFen",
+    specLine: "Spec: {runtime} {id} \xB7 {transport}",
+    smitheryDetail: "(Smithery-Eintrag \u2014 Installationsdetails werden bei Enter abgerufen)",
+    statusError: "Fehler: {message}"
+  },
+  mcpBrowser: {
+    ...EN.mcpBrowser,
+    title: "\u25C8 MCP-Browser",
+    empty: "Keine MCP-Server angeh\xE4ngt. F\xFChre `reasonix setup` aus, um welche auszuw\xE4hlen, oder starte mit --mcp.",
+    serverCount: "{count} Server",
+    footer: "\u2191\u2193 ausw\xE4hlen \xB7 [r] neu verbinden \xB7 [d] deaktivieren \xB7 Esc beenden"
+  },
+  mcpBrowse: {
+    ...EN.mcpBrowse,
+    noResources: "Keine Ressourcen auf einem verbundenen MCP-Server (oder keine Server verbunden). `/mcp` zeigt den aktuellen Satz.",
+    readOne: "Lese einen: `/resource <uri>` \u2014 oder verwende Tab in der Auswahl.",
+    noPrompts: "Keine Prompts auf einem verbundenen MCP-Server (oder keine Server verbunden). `/mcp` zeigt den aktuellen Satz.",
+    fetchOne: "Rufe einen ab: `/prompt <name>` \u2014 Argumente werden noch nicht unterst\xFCtzt; Prompts mit erforderlichen Argumenten geben einen Fehler vom Server zur\xFCck.",
+    noServerForResource: 'kein Server bietet Ressource "{name}"',
+    resourceHint: "`/resource` ohne Argument listet verf\xFCgbare Ressourcen.",
+    readFailed: "readResource fehlgeschlagen",
+    noServerForPrompt: 'kein Server bietet Prompt "{name}"',
+    promptHint: "`/prompt` ohne Argument listet verf\xFCgbare Prompts.",
+    fetchFailed: "getPrompt fehlgeschlagen"
+  },
+  mcpLifecycle: {
+    ...EN.mcpLifecycle,
+    handshake: "Handshake\u2026",
+    connected: "verbunden",
+    failed: "fehlgeschlagen",
+    disabled: "deaktiviert",
+    reconnect: "Wiederverbinden\u2026",
+    initDetail: "initialisiere \u2192 tools/list \u2192 resources/list",
+    reconnectDetail: "baue ab \xB7 neuer Handshake \xB7 liste Tools",
+    disabledDetail: "via /mcp disable {name}",
+    failedSetupHint: "\u2192 f\xFChre `reasonix setup` aus, um diesen Eintrag zu entfernen, oder behebe das zugrunde liegende Problem (fehlendes npm-Paket, Netzwerk usw.).",
+    failedSetupConfigHint: "\u2192 f\xFChre `reasonix setup` aus, um fehlerhafte Eintr\xE4ge aus deiner gespeicherten Konfiguration zu entfernen.",
+    abortedHint: "MCP-Start abgebrochen \u2014 {count} Server \xFCbersprungen. F\xFChre /mcp aus, um es erneut zu versuchen, sobald du das zugrunde liegende Problem behoben hast.",
+    toolsReady: "Tools bereit",
+    warnLabel: "Warn"
+  },
+  checkpointPicker: {
+    ...EN.checkpointPicker,
+    title: "Checkpoint wiederherstellen \u2014 {workspace}",
+    header: " \u25C8 REASONIX \xB7 Checkpoint ausw\xE4hlen ",
+    empty: "  noch keine Checkpoints in diesem Arbeitsbereich - siehe /checkpoint zum Erstellen",
+    more: "     \u2026 {hidden} weitere",
+    footer: "  \u2191\u2193 ausw\xE4hlen  \xB7  \u23CE wiederherstellen  \xB7  [d] vergessen  \xB7  Esc beenden",
+    footerEmpty: "  Esc beenden"
+  },
+  planReviseConfirm: {
+    ...EN.planReviseConfirm,
+    title: "Plan-\xDCberarbeitung vorgeschlagen",
+    metaRight: "\u2212{removed}  +{added}  \xB7  {kept} behalten",
+    updatedSummary: "Aktualisierte Zusammenfassung: {summary}",
+    acceptLabel: "\xDCberarbeitung annehmen \u2014 neue Schrittliste anwenden",
+    acceptHint: "Ersetzt den Restplan durch die vorgeschlagenen Schritte. Erledigte Schritte bleiben unber\xFChrt.",
+    rejectLabel: "Ablehnen \u2014 Originalplan behalten",
+    rejectHint: "Vorschlag verwerfen. Modell f\xE4hrt mit den urspr\xFCnglichen verbleibenden Schritten fort."
+  },
+  diffApp: {
+    ...EN.diffApp,
+    title: "reasonix diff",
+    turnLabel: "Turn {turn} ({current}/{total})",
+    turnsAligned: "{count} Turns ausgerichtet",
+    paneEmpty: "(keine Datens\xE4tze auf dieser Seite f\xFCr diesen Turn)",
+    kindMatch: "\u2713 \xDCbereinstimmung",
+    kindDiverge: "\u2605 Abweichung",
+    kindOnlyInA: "\u2190 nur in A",
+    kindOnlyInB: "\u2192 nur in B"
+  },
+  recordView: {
+    ...EN.recordView,
+    userPrefix: "Du \xBB ",
+    assistant: "Assistent",
+    toolPrefix: "Tool<",
+    argsLabel: "  Args: ",
+    resultArrow: "  \u2192 ",
+    error: "Fehler ",
+    cache: "  \xB7 Cache ",
+    toolCallOnly: "(nur Tool-Call-Antwort)",
+    truncateExtra: "(+{extra} Zeichen)"
+  },
+  replayApp: {
+    ...EN.replayApp,
+    emptyTranscript: "Leeres Transkript",
+    turnProgress: "Turn {current}/{total}",
+    noRecords: "Keine Datens\xE4tze",
+    untracked: "(nicht verfolgt)",
+    churned: "(umgewandelt \xD7{count})"
+  },
+  builtinSkills: {
+    ...EN.builtinSkills,
+    explore: 'Durchsuche die Codebasis in einem isolierten Subagenten \u2014 breit angelegte, schreibgesch\xFCtzte Untersuchung, die eine destillierte Antwort zur\xFCckgibt. Am besten f\xFCr: \xBBFinde alle Stellen, die\u2026", \xBBWie funktioniert X im gesamten Projekt", \xBBDurchsuche den Code nach Y".',
+    research: 'Recherchiere eine Frage durch Kombination von Websuche + Codelesen in einem isolierten Subagenten. Am besten f\xFCr: \xBBWird X-Feature von Bibliothek Y unterst\xFCtzt?", \xBBWas ist der kanonische Weg, Z zu tun?", \xBBVergleiche unsere Implementierung mit dem Standard".',
+    review: "\xDCberpr\xFCfe die ausstehenden \xC4nderungen (aktueller Branch-Diff) in einem isolierten Subagenten \u2014 kennzeichnet Korrektheit, Sicherheit, fehlende Tests, versteckte Verhaltens\xE4nderungen; meldet Befund + pro-Problem datei:zeile. Schreibgesch\xFCtzt; das \xFCbergeordnete Element entscheidet, was zu tun ist.",
+    securityReview: "Sicherheitsfokussierte \xDCberpr\xFCfung des aktuellen Branch-Diffs in einem isolierten Subagenten \u2014 kennzeichnet Injection/Authz/Secrets/Deserialisierung/Pfad-Traversal/Krypto-Probleme, mit Schweregrad. Schreibgesch\xFCtzt. Verwende beim Ausliefern von \xC4nderungen, die Auth, Eingabeanalyse, Datei-E/A oder externe Anfragen betreffen.",
+    test: "F\xFChre die Testsuite des Projekts aus, diagnostiziere Fehler, schlage SEARCH/REPLACE-Fixes vor, wiederhole bis gr\xFCn (oder stoppe nach 2 Fixversuchen beim gleichen Fehler). Inline \u2014 l\xE4uft in der \xFCbergeordneten Schleife, sodass du die Edit-Blocks siehst und /apply verwenden kannst. Erkennt npm/pnpm/yarn/pytest/go/cargo."
+  },
+  shortcutsHelp: {
+    ...EN.shortcutsHelp,
+    title: "Tastenk\xFCrzel",
+    groupInput: "Eingabe",
+    groupNavigation: "Navigation",
+    groupSession: "Sitzung",
+    groupSystem: "System",
+    descEnter: "Nachricht senden",
+    descShiftEnter: "Neue Zeile",
+    descCtrlEnter: "Neue Zeile",
+    descCtrlJ: "Neue Zeile",
+    descCtrlU: "Eingabe leeren",
+    descCtrlW: "Wort l\xF6schen",
+    descCtrlP: "Tastenk\xFCrzel anzeigen/ausblenden",
+    descCtrlX: "Im Editor \xF6ffnen",
+    descArrows: "Eingabeverlauf",
+    descPgUpDown: "Seite scrollen",
+    descCtrlL: "Bildschirm leeren",
+    descCtrlB: "Seitenleiste umschalten",
+    descNewSession: "Neue Sitzung",
+    descListSessions: "Sitzungen auflisten",
+    descSwitchModel: "Modell wechseln",
+    descSwitchEffort: "Reasoning-Effort wechseln",
+    descSwitchTheme: "Theme wechseln",
+    descCtrlC: "Beenden",
+    descEsc: "Stoppen / Abbrechen",
+    descCtrlR: "Ausf\xFChrlich umschalten",
+    descCtrlO: "Antwort erweitern (nur w\xE4hrend Streaming)",
+    descHelp: "Alle Befehle anzeigen",
+    descShiftTab: "Edit-Modus wechseln",
+    descAltS: "Eingabe speichern / abrufen"
+  },
+  mcpCli: {
+    ...EN.mcpCli,
+    bundledCatalog: "Mitgelieferte MCP-Server (Offline-Katalog):",
+    justFetched: "Gerade abgerufen",
+    cachedAge: "Zwischengespeichert, {age}",
+    moreAvailable: "Mehr verf\xFCgbar",
+    allLoaded: "Alle geladen",
+    morePagesAvailable: "\u25B8 mehr Seiten verf\xFCgbar \u2014 `reasonix mcp list --pages <n>` oder --all",
+    installHint: "Installieren:  reasonix mcp install <name>",
+    usageSearch: "Verwendung: reasonix mcp search <abfrage>",
+    usageInstall: "Verwendung: reasonix mcp install <name>",
+    noMatchesFor: 'Keine Treffer f\xFCr "{q}" in {count} geladenen Eintr\xE4gen ({source})',
+    matchCount: '{count} Treffer f\xFCr "{q}" in {source}-Registry ({loaded} durchsuchte Eintr\xE4ge):',
+    moreLoaded: "\u2026 {count} weitere geladen \u2014 verwende `reasonix mcp search <abfrage>` zum Filtern",
+    moreMatches: "\u2026 {count} weitere Treffer",
+    installed: "Installiert: {spec}",
+    noServerFound: 'Kein MCP-Server namens "{target}" gefunden nach {pages} Seite(n) der {source}-Registry.',
+    noServerTryMore: "Versuche: reasonix mcp install {target} --max-pages 100",
+    noInstallMeta: 'Konnte Installationsmetadaten f\xFCr "{name}" nicht ableiten \u2014 versuche `npx -y @smithery/cli install {name}` direkt.',
+    buildSpecFailed: "Kann Installationsspec f\xFCr {name} nicht erstellen: {message}",
+    alreadyInstalled: "Bereits installiert: {spec}"
+  }
+};
+
 // src/i18n/zh-CN.ts
 var zhCN = {
   common: {
@@ -3569,6 +5309,8 @@ var zhCN = {
     deepseek5xxUnreachable: " \u65E0\u6CD5\u4ECE\u4F60\u7684\u7F51\u7EDC\u8BBF\u95EE DeepSeek API \u2014 \u53EF\u80FD\u662F DS \u6574\u4F53\u6545\u969C\uFF0C\u4E5F\u53EF\u80FD\u662F\u672C\u5730\u7F51\u7EDC\u95EE\u9898\u3002",
     deepseek5xxActionNetwork: " \u5EFA\u8BAE\uFF1A(1) \u68C0\u67E5\u7F51\u7EDC\uFF0C(2) \u7B49 30 \u79D2\u540E\u91CD\u8BD5\uFF0C(3) \u67E5\u770B\u72B6\u6001\u9875 https://status.deepseek.com\u3002",
     deepseek5xxActionRetry: " \u5EFA\u8BAE\uFF1A(1) \u7B49 30 \u79D2\u540E\u91CD\u8BD5\uFF0C(2) \u7528 /model \u5207\u6362\u6A21\u578B\uFF0C(3) \u67E5\u770B\u72B6\u6001\u9875 https://status.deepseek.com\u3002",
+    upstream5xxHead: "\u4E0A\u6E38\u670D\u52A1\u4E0D\u53EF\u7528\uFF08{status}\uFF09\uFF0C\u76EE\u6807\u5730\u5740 {host} \u2014 \u4F60\u914D\u7F6E\u7684 API \u7AEF\u70B9\u8FD4\u56DE\u4E86\u670D\u52A1\u5668\u9519\u8BEF\uFF0C\u4E0D\u662F Reasonix \u6545\u969C\u3002\u5DF2\u6309\u6307\u6570\u9000\u907F\u91CD\u8BD5 4 \u6B21\u3002",
+    upstream5xxActionRetry: " \u5EFA\u8BAE\uFF1A(1) \u786E\u8BA4\u672C\u5730/\u4EE3\u7406\u6A21\u578B\u670D\u52A1\u5728\u7EBF\uFF0C(2) \u7B49\u4E00\u4F1A\u513F\u518D\u91CD\u8BD5\uFF0C(3) \u7528 /model \u5207\u6362\u6A21\u578B\u3002",
     innerNoMessage: "\uFF08\u65E0\u9519\u8BEF\u4FE1\u606F\uFF09",
     reasonAborted: "[\u7528\u6237\u5DF2\u4E2D\u65AD\uFF08Esc\uFF09 \u2014 \u6B63\u5728\u603B\u7ED3\u5230\u76EE\u524D\u4E3A\u6B62\u7684\u53D1\u73B0]",
     reasonContextGuard: "[\u4E0A\u4E0B\u6587\u989D\u5EA6\u5373\u5C06\u8017\u5C3D \u2014 \u5728\u4E0B\u4E00\u6B21\u8C03\u7528\u6EA2\u51FA\u4E4B\u524D\u5148\u603B\u7ED3]",
@@ -3749,6 +5491,7 @@ var zhCN = {
       modelSet: "model \u2192 {id}",
       effortStatus: "effort \u2192 {current}   \uFF08\u53EF\u9009\uFF1A{list}\uFF09",
       effortUsage: "\u7528\u6CD5\uFF1A/effort <{list}>   \uFF08high \u4E3A\u5B89\u5168\u9ED8\u8BA4\uFF1Bmax \u662F DeepSeek \u6269\u5C55\uFF09",
+      effortUsageNoMax: "\u7528\u6CD5\uFF1A/effort <{list}>",
       effortSet: "effort \u2192 {effort}",
       budgetNoCap: "\u672A\u8BBE\u7F6E\u4F1A\u8BDD\u9884\u7B97 \u2014 Reasonix \u5C06\u6301\u7EED\u8FD0\u884C\u76F4\u5230\u60A8\u505C\u6B62\u3002\u4F7F\u7528\u4EE5\u4E0B\u65B9\u5F0F\u8BBE\u7F6E\uFF1A/budget <usd>   \uFF08\u4F8B\u5982 /budget 5\uFF09",
       budgetStatus: "\u9884\u7B97\uFF1A${spent} / ${cap}\uFF08{pct}%\uFF09\xB7 /budget off \u6E05\u9664\uFF0C/budget <usd> \u66F4\u6539",
@@ -4564,13 +6307,18 @@ var zhCN = {
 // src/i18n/index.ts
 var translations = {
   EN,
-  "zh-CN": zhCN
+  "zh-CN": zhCN,
+  de
 };
-function detectSystemLanguage(locale = Intl.DateTimeFormat().resolvedOptions().locale) {
+function detectSystemLanguage(locale = systemLocale()) {
   if (locale.startsWith("zh")) return "zh-CN";
   if (locale.startsWith("en")) return "EN";
+  if (locale.startsWith("de")) return "de";
   return null;
 }
+function systemLocale() {
+  return process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || Intl.DateTimeFormat().resolvedOptions().locale;
+}
 var currentLang = loadLanguage() ?? detectSystemLanguage() ?? "EN";
 function t(path2, params) {
   const parts = path2.split(".");
@@ -4667,7 +6415,7 @@ function matchesTool(hook, toolName) {
 }
 var HOOK_OUTPUT_CAP_BYTES = 256 * 1024;
 function defaultSpawner(input) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     const child = spawn(input.command, {
       cwd: input.cwd,
       shell: true,
@@ -4712,7 +6460,7 @@ function defaultSpawner(input) {
     child.stderr.on("data", (chunk) => onChunk("stderr", chunk));
     child.once("error", (err) => {
       clearTimeout(timer);
-      resolve15({
+      resolve16({
         exitCode: null,
         stdout: Buffer.concat(stdoutChunks).toString("utf8"),
         stderr: Buffer.concat(stderrChunks).toString("utf8"),
@@ -4723,7 +6471,7 @@ function defaultSpawner(input) {
     });
     child.once("close", (code) => {
       clearTimeout(timer);
-      resolve15({
+      resolve16({
         exitCode: code,
         stdout: Buffer.concat(stdoutChunks).toString("utf8").trim(),
         stderr: Buffer.concat(stderrChunks).toString("utf8").trim(),
@@ -4795,6 +6543,59 @@ import { createRequire } from "module";
 import { dirname as dirname2, join as join3 } from "path";
 import { fileURLToPath } from "url";
 import { gunzipSync } from "zlib";
+
+// src/core/lru.ts
+var LruCache = class {
+  constructor(limit) {
+    this.limit = limit;
+  }
+  limit;
+  map = /* @__PURE__ */ new Map();
+  get(key) {
+    if (!this.map.has(key)) return void 0;
+    const v = this.map.get(key);
+    this.map.delete(key);
+    this.map.set(key, v);
+    return v;
+  }
+  set(key, value) {
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    } else if (this.map.size >= this.limit) {
+      const oldest = this.map.keys().next().value;
+      if (oldest !== void 0) this.map.delete(oldest);
+    }
+    this.map.set(key, value);
+  }
+  get size() {
+    return this.map.size;
+  }
+  clear() {
+    this.map.clear();
+  }
+};
+var TtlLruCache = class {
+  constructor(limit, ttlMs) {
+    this.ttlMs = ttlMs;
+    this.inner = new LruCache(limit);
+  }
+  ttlMs;
+  inner;
+  get(key) {
+    const e = this.inner.get(key);
+    if (!e) return void 0;
+    if (e.expiresAt <= Date.now()) return void 0;
+    return e.v;
+  }
+  set(key, value) {
+    this.inner.set(key, { v: value, expiresAt: Date.now() + this.ttlMs });
+  }
+  clear() {
+    this.inner.clear();
+  }
+};
+
+// src/tokenizer.ts
 function buildByteToChar() {
   const result = new Array(256);
   const bs = [];
@@ -4897,10 +6698,13 @@ function byteLevelEncode(s, byteToChar) {
   for (let i = 0; i < bytes.length; i++) out += byteToChar[bytes[i]];
   return out;
 }
+var bpeCache = new LruCache(8192);
 function bpeEncode(piece, mergeRank) {
   if (piece.length <= 1) return piece ? [piece] : [];
-  let word = Array.from(piece);
-  while (true) {
+  const cached2 = bpeCache.get(piece);
+  if (cached2 !== void 0) return cached2;
+  const word = Array.from(piece);
+  while (word.length > 1) {
     let bestIdx = -1;
     let bestRank = Number.POSITIVE_INFINITY;
     for (let i = 0; i < word.length - 1; i++) {
@@ -4913,13 +6717,9 @@ function bpeEncode(piece, mergeRank) {
       }
     }
     if (bestIdx < 0) break;
-    word = [
-      ...word.slice(0, bestIdx),
-      word[bestIdx] + word[bestIdx + 1],
-      ...word.slice(bestIdx + 2)
-    ];
-    if (word.length === 1) break;
+    word.splice(bestIdx, 2, word[bestIdx] + word[bestIdx + 1]);
   }
+  bpeCache.set(piece, word);
   return word;
 }
 function encode(text) {
@@ -4974,10 +6774,6 @@ function countTokensBounded(text, maxChars = DEFAULT_BOUNDED_TOKENIZE_CHARS) {
   const ratio = sampleChars > 0 ? sampleTokens / sampleChars : 0.3;
   return Math.max(1, Math.ceil(text.length * ratio));
 }
-var BOS = "<\uFF5Cbegin\u2581of\u2581sentence\uFF5C>";
-var EOS = "<\uFF5Cend\u2581of\u2581sentence\uFF5C>";
-var USER_SP = "<\uFF5CUser\uFF5C>";
-var ASSISTANT_SP = "<\uFF5CAssistant\uFF5C>";
 var THINK_START = "<think>";
 var THINK_END = "</think>";
 var DSML = "\uFF5CDSML\uFF5C";
@@ -4986,7 +6782,6 @@ var TC_END = `</${DSML}tool_calls>`;
 var INVOKE_BEGIN = `<${DSML}invoke name="`;
 var INVOKE_END = `</${DSML}invoke>`;
 var PARAM_TEMPLATE = `<${DSML}parameter name="{key}" string="{is_str}">{value}</${DSML}parameter>`;
-var TOOL_RESULT_TEMPLATE = "<tool_result>{content}</tool_result>";
 var toolsTemplateCache = /* @__PURE__ */ new WeakMap();
 function renderTools(tools) {
   const cached2 = toolsTemplateCache.get(tools);
@@ -5023,142 +6818,53 @@ You MUST strictly follow the above defined tool name and parameter schemas to in
   toolsTemplateCache.set(tools, rendered);
   return rendered;
 }
-function encodeArgumentsToDsml(argsJson) {
-  let args;
-  try {
-    args = JSON.parse(argsJson);
-  } catch {
-    args = { arguments: argsJson };
-  }
-  return Object.entries(args).map(
-    ([k, v]) => PARAM_TEMPLATE.replace("{key}", k).replace("{is_str}", typeof v === "string" ? "true" : "false").replace("{value}", typeof v === "string" ? v : JSON.stringify(v))
-  ).join("\n");
-}
-function renderToolCallsDsml(toolCalls) {
-  const invokes = toolCalls.map((tc) => {
-    const name = tc.function?.name ?? "";
-    const argsJson = tc.function?.arguments ?? "{}";
-    return `${INVOKE_BEGIN + name}">
-${encodeArgumentsToDsml(argsJson)}
-${INVOKE_END}`;
-  }).join("\n");
-  return `
-
-${TC_BEGIN}
-${invokes}
-${TC_END}`;
+var PER_MESSAGE_TEMPLATE_TOKENS = 6;
+var contentTokenCache = new LruCache(4096);
+function cachedBoundedTokens(s) {
+  if (s.length === 0) return 0;
+  const cached2 = contentTokenCache.get(s);
+  if (cached2 !== void 0) return cached2;
+  const n = countTokensBounded(s);
+  contentTokenCache.set(s, n);
+  return n;
 }
-function mergeToolMessages(messages) {
-  const merged = [];
-  for (const msg of messages) {
-    const role = msg.role ?? "user";
-    if (role === "tool") {
-      const toolBlock = TOOL_RESULT_TEMPLATE.replace("{content}", msg.content ?? "");
-      const last = merged[merged.length - 1];
-      if (last && last.role === "user" && Array.isArray(last._toolBlocks) && Array.isArray(last._textParts)) {
-        last._toolBlocks.push(toolBlock);
-        last.content = `${last._textParts.join("\n\n")}
-
-${last._toolBlocks.join("\n")}`.replace(
-          /^\n\n/,
-          ""
-        );
-      } else {
-        merged.push({
-          role: "user",
-          content: toolBlock,
-          _textParts: [],
-          _toolBlocks: [toolBlock]
-        });
-      }
-    } else if (role === "user") {
-      const text = msg.content ?? "";
-      const last = merged[merged.length - 1];
-      if (last && last.role === "user" && Array.isArray(last._toolBlocks) && Array.isArray(last._textParts)) {
-        last._textParts.push(text);
-        last.content = `${last._textParts.join("\n\n")}
-
-${last._toolBlocks.join("\n\n")}`.replace(
-          /^\n\n/,
-          ""
-        );
-      } else {
-        merged.push({
-          ...msg,
-          role: "user",
-          content: text,
-          _textParts: [text],
-          _toolBlocks: []
-        });
-      }
-    } else {
-      merged.push({ ...msg });
-    }
-  }
-  for (const m of merged) {
-    m._textParts = void 0;
-    m._toolBlocks = void 0;
+function tokensForMessage(m, dropThisReasoning) {
+  let n = 0;
+  if (typeof m.content === "string" && m.content.length > 0) {
+    n += cachedBoundedTokens(m.content);
   }
-  return merged;
-}
-function dropThinkingMessages(messages) {
-  let lastUserIdx = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const role = messages[i].role;
-    if (role === "user" || role === "developer") {
-      lastUserIdx = i;
-      break;
+  if (m.role === "assistant") {
+    if (!dropThisReasoning && typeof m.reasoning_content === "string" && m.reasoning_content.length > 0) {
+      n += cachedBoundedTokens(m.reasoning_content);
     }
-  }
-  if (lastUserIdx < 0) return messages;
-  const result = [];
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (i < lastUserIdx && msg.role === "developer") continue;
-    if (i < lastUserIdx && msg.role === "assistant") {
-      result.push({ ...msg, reasoning_content: null });
-    } else {
-      result.push(msg);
+    const tcs = m.tool_calls;
+    if (Array.isArray(tcs) && tcs.length > 0) {
+      n += cachedBoundedTokens(JSON.stringify(tcs));
     }
   }
-  return result;
+  return n;
 }
-function formatDeepSeekPrompt(messages, drop_thinking = false) {
-  if (messages.length === 0) return ASSISTANT_SP + THINK_END;
-  let msgs = messages;
+function estimateConversationTokens(messages, drop_thinking = false) {
+  if (messages.length === 0) return 0;
+  let lastUserOrDev = -1;
   if (drop_thinking) {
-    msgs = dropThinkingMessages(msgs);
-  }
-  const merged = mergeToolMessages(msgs);
-  let prompt = BOS;
-  for (let i = 0; i < merged.length; i++) {
-    const msg = merged[i];
-    const role = msg.role ?? "user";
-    const nextRole = i + 1 < merged.length ? merged[i + 1].role ?? "user" : null;
-    if (role === "system") {
-      prompt += msg.content ?? "";
-    } else if (role === "user") {
-      prompt += USER_SP + (msg.content ?? "");
-      if (nextRole === "assistant" || nextRole === null) {
-        prompt += ASSISTANT_SP + THINK_END;
-      }
-    } else if (role === "assistant") {
-      if (msg.reasoning_content) {
-        prompt += THINK_START + msg.reasoning_content + THINK_END;
-      }
-      if (msg.content) prompt += msg.content;
-      const tcs = msg.tool_calls;
-      if (Array.isArray(tcs) && tcs.length > 0) {
-        prompt += renderToolCallsDsml(tcs);
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const r = messages[i].role;
+      if (r === "user" || r === "developer") {
+        lastUserOrDev = i;
+        break;
       }
-      prompt += EOS;
     }
   }
-  return prompt;
-}
-function estimateConversationTokens(messages, drop_thinking = false) {
-  if (messages.length === 0) return 0;
-  return countTokensBounded(formatDeepSeekPrompt(messages, drop_thinking));
+  let total = 2;
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    if (drop_thinking && i < lastUserOrDev && m.role === "developer") continue;
+    total += PER_MESSAGE_TEMPLATE_TOKENS;
+    const dropReasoning = drop_thinking && i < lastUserOrDev && m.role === "assistant";
+    total += tokensForMessage(m, dropReasoning);
+  }
+  return total;
 }
 function estimateRequestTokens(messages, toolSpecs, drop_thinking = false) {
   let total = estimateConversationTokens(messages, drop_thinking);
@@ -5236,6 +6942,81 @@ function setByPath(target, path2, value) {
   cur[path2[path2.length - 1]] = value;
 }
 
+// src/tools/truncated-result-saver.ts
+import { randomUUID } from "crypto";
+import {
+  chmodSync as chmodSync2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4, relative, resolve as resolve2 } from "path";
+var TRUNCATED_DIR = "truncated-results";
+var DEFAULT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+function sanitizeToolName(name) {
+  return name.replace(/[^\w\-]/g, "_").slice(0, 48) || "unknown";
+}
+function storageDir(rootDir) {
+  const base = rootDir ? join4(resolve2(rootDir), ".reasonix") : join4(homedir3(), ".reasonix");
+  return join4(base, TRUNCATED_DIR);
+}
+function resultFilename(toolName) {
+  const ts = Date.now().toString();
+  const suffix = randomUUID().slice(0, 8);
+  const safeName = sanitizeToolName(toolName);
+  return `${ts}-${suffix}-${safeName}.txt`;
+}
+function saveTruncatedResult(content, toolName, rootDir) {
+  cleanupOldResults(rootDir);
+  const dir = storageDir(rootDir);
+  if (!existsSync3(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  const filename = resultFilename(toolName);
+  const absPath = join4(dir, filename);
+  writeFileSync2(absPath, content, "utf-8");
+  try {
+    chmodSync2(absPath, 384);
+  } catch {
+  }
+  if (rootDir) {
+    const absRoot = resolve2(rootDir);
+    return relative(absRoot, absPath).replaceAll("\\", "/");
+  }
+  return absPath.replaceAll("\\", "/");
+}
+function cleanupOldResults(rootDir, maxAgeMs = DEFAULT_MAX_AGE_MS) {
+  const dir = storageDir(rootDir);
+  if (!existsSync3(dir)) return;
+  const cutoff = Date.now() - maxAgeMs;
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.endsWith(".txt")) continue;
+    const abs = join4(dir, entry);
+    try {
+      const st = statSync(abs);
+      if (st.isFile() && st.mtimeMs < cutoff) {
+        rmSync(abs);
+      }
+    } catch {
+    }
+  }
+}
+function shouldSkipSave(toolName, skipTruncationSave) {
+  if (skipTruncationSave) return true;
+  const alwaysSkip = /* @__PURE__ */ new Set(["get_env", "everything_get-env"]);
+  return alwaysSkip.has(toolName);
+}
+
 // src/tools.ts
 var ToolRegistry = class {
   _tools = /* @__PURE__ */ new Map();
@@ -5413,7 +7194,20 @@ var ToolRegistry = class {
       if (opts.maxResultChars !== void 0) {
         clipped = truncateForModel(clipped, opts.maxResultChars);
       }
-      finalResult = clipped;
+      if (clipped !== str && !shouldSkipSave(name, tool?.skipTruncationSave)) {
+        const relPath = saveTruncatedResult(str, name, opts.rootDir ?? process.cwd());
+        const note = `Full result saved at: ${relPath}`;
+        let annotated = str;
+        if (opts.maxResultTokens !== void 0) {
+          annotated = truncateForModelByTokens(annotated, opts.maxResultTokens, note);
+        }
+        if (opts.maxResultChars !== void 0) {
+          annotated = truncateForModel(annotated, opts.maxResultChars, note);
+        }
+        finalResult = annotated;
+      } else {
+        finalResult = clipped;
+      }
     } catch (err) {
       const e = err;
       if (typeof e.toToolResult === "function") {
@@ -5633,12 +7427,12 @@ async function waitForReady(ready, timeoutMs, serverName, signal) {
   let timer;
   let onAbort;
   try {
-    await new Promise((resolve15, reject) => {
+    await new Promise((resolve16, reject) => {
       ready.then(
         () => {
           if (settled) return;
           settled = true;
-          resolve15();
+          resolve16();
         },
         (err) => {
           if (settled) return;
@@ -5744,25 +7538,30 @@ function validateResultShape(result) {
     }
   }
 }
-function truncateForModel(s, maxChars) {
+function truncateForModel(s, maxChars, extraNote) {
   if (s.length <= maxChars) return s;
   const tailBudget = Math.min(1024, Math.floor(maxChars * 0.1));
   const headBudget = Math.max(0, maxChars - tailBudget);
   const head = s.slice(0, headBudget);
   const tail = s.slice(-tailBudget);
   const dropped = s.length - head.length - tail.length;
+  const note = extraNote ? ` \u2014 ${extraNote}` : "";
   return `${head}
 
-[\u2026truncated ${dropped} chars \u2014 raise BridgeOptions.maxResultChars, or call the tool with a narrower scope (filter, head, pagination)\u2026]
+[\u2026truncated ${dropped} chars \u2014 raise BridgeOptions.maxResultChars, or call the tool with a narrower scope (filter, head, pagination)${note}\u2026]
 
 ${tail}`;
 }
-function truncateForModelByTokens(s, maxTokens) {
+function truncateForModelByTokens(s, maxTokens, extraNote) {
   if (maxTokens <= 0) return "";
   if (s.length <= maxTokens) return s;
   if (s.length <= maxTokens * 4) {
-    const tokens = countTokens(s);
-    if (tokens <= maxTokens) return s;
+    const est = countTokensBounded(s);
+    if (Math.ceil(est * 1.15) <= maxTokens) return s;
+    if (est <= maxTokens) {
+      const tokens = countTokens(s);
+      if (tokens <= maxTokens) return s;
+    }
   }
   const markerOverhead = 48;
   const contentBudget = Math.max(0, maxTokens - markerOverhead);
@@ -5778,9 +7577,10 @@ function truncateForModelByTokens(s, maxTokens) {
   const ratio = sampleChars > 0 ? sampleTokens / sampleChars : 0.3;
   const estTotalTokens = Math.ceil(s.length * ratio);
   const droppedTokens = Math.max(0, estTotalTokens - sampleTokens);
+  const note = extraNote ? ` \u2014 ${extraNote}` : "";
   return `${head}
 
-[\u2026truncated ~${droppedTokens} tokens (${droppedChars} chars) \u2014 raise BridgeOptions.maxResultTokens, or call the tool with a narrower scope (filter, head, pagination)\u2026]
+[\u2026truncated ~${droppedTokens} tokens (${droppedChars} chars) \u2014 raise BridgeOptions.maxResultTokens, or call the tool with a narrower scope (filter, head, pagination)${note}\u2026]
 
 ${tail}`;
 }
@@ -5822,7 +7622,7 @@ function blockToString(block) {
 var COMPACTION_SUMMARY_MARKER = "[CONVERSATION HISTORY SUMMARY \u2014 earlier turns folded for context efficiency]\n\n";
 
 // packages/core-utils/src/tildeify.ts
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 
 // src/loop/thinking.ts
 function isThinkingModeModel(model) {
@@ -5862,19 +7662,19 @@ function buildSyntheticAssistantMessage(content, fallbackModel) {
 import { execFileSync } from "child_process";
 import {
   appendFileSync,
-  chmodSync as chmodSync2,
-  copyFileSync,
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
+  chmodSync as chmodSync3,
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
   readFileSync as readFileSync4,
-  readdirSync,
+  readdirSync as readdirSync2,
   renameSync as renameSync2,
-  statSync,
-  unlinkSync,
-  writeFileSync as writeFileSync2
+  statSync as statSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
 } from "fs";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname3, join as join4, posix as posixPath, win32 as win32Path } from "path";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname3, join as join5, posix as posixPath, win32 as win32Path } from "path";
 var SESSION_SIDECAR_EXTS = [
   ".events.jsonl",
   ".meta.json",
@@ -5883,10 +7683,10 @@ var SESSION_SIDECAR_EXTS = [
   ".jsonl.bak"
 ];
 function sessionsDir() {
-  return join4(homedir4(), ".reasonix", "sessions");
+  return join5(homedir5(), ".reasonix", "sessions");
 }
 function sessionPath(name) {
-  return join4(sessionsDir(), `${sanitizeName(name)}.jsonl`);
+  return join5(sessionsDir(), `${sanitizeName(name)}.jsonl`);
 }
 function sanitizeName(name) {
   const cleaned = name.replace(/[^\w\-\u4e00-\u9fa5]/g, "_").slice(0, 64);
@@ -5897,7 +7697,7 @@ function timestampSuffix() {
 }
 function loadSessionMessages(name) {
   const path2 = sessionPath(name);
-  if (!existsSync3(path2)) return [];
+  if (!existsSync4(path2)) return [];
   const live = readSessionMessages(path2);
   if (live && (live.messages.length > 0 || !live.hadContent)) return live.messages;
   const backup = readSessionMessages(sessionBackupPath(path2));
@@ -5924,33 +7724,43 @@ function readSessionMessages(path2) {
 }
 function appendSessionMessage(name, message) {
   const path2 = sessionPath(name);
-  mkdirSync2(dirname3(path2), { recursive: true });
+  mkdirSync3(dirname3(path2), { recursive: true });
   appendFileSync(path2, `${JSON.stringify(message)}
 `, "utf8");
   try {
-    chmodSync2(path2, 384);
+    chmodSync3(path2, 384);
   } catch {
   }
 }
 function listSessions(opts) {
   const dir = sessionsDir();
-  if (!existsSync3(dir)) return [];
+  if (!existsSync4(dir)) return [];
   const want = opts?.workspaceFilter ? normalizeWorkspace(opts.workspaceFilter) : null;
+  const legacyPrefix = want && opts?.includeLegacyWorkspaceMatches ? legacySessionPrefixForWorkspace(opts.workspaceFilter) : null;
   try {
-    const files = readdirSync(dir).filter(
+    const files = readdirSync2(dir).filter(
       (f) => f.endsWith(".jsonl") && !f.endsWith(".events.jsonl")
     );
     return files.flatMap((file) => {
-      const path2 = join4(dir, file);
+      const path2 = join5(dir, file);
       const name = file.replace(/\.jsonl$/, "");
       const meta = loadSessionMeta(name);
+      let workspaceStatus;
       if (want !== null) {
-        if (typeof meta.workspace !== "string") return [];
-        if (normalizeWorkspace(meta.workspace) !== want) return [];
+        if (typeof meta.workspace === "string") {
+          if (normalizeWorkspace(meta.workspace) !== want) return [];
+          workspaceStatus = "matched";
+        } else if (legacyPrefix && name.startsWith(legacyPrefix)) {
+          workspaceStatus = "legacy_missing_meta";
+        } else {
+          return [];
+        }
       }
-      const stat2 = statSync(path2);
+      const stat2 = statSync2(path2);
       const messageCount = countLines(path2);
-      return [{ name, path: path2, size: stat2.size, messageCount, mtime: stat2.mtime, meta }];
+      return [
+        { name, path: path2, size: stat2.size, messageCount, mtime: stat2.mtime, meta, workspaceStatus }
+      ];
     }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
   } catch {
     return [];
@@ -5964,12 +7774,17 @@ function normalizeWorkspace(p, platform = process.platform) {
   }
   return posixPath.resolve(p);
 }
+function legacySessionPrefixForWorkspace(workspace) {
+  const normalized = normalizeWorkspace(workspace);
+  const base = process.platform === "win32" ? win32Path.basename(normalized) : posixPath.basename(normalized);
+  return `${sanitizeName(`code-${base}`)}-`;
+}
 function metaPath(name) {
-  return join4(sessionsDir(), `${sanitizeName(name)}.meta.json`);
+  return join5(sessionsDir(), `${sanitizeName(name)}.meta.json`);
 }
 function loadSessionMeta(name) {
   const p = metaPath(name);
-  if (!existsSync3(p)) return {};
+  if (!existsSync4(p)) return {};
   try {
     const raw = JSON.parse(readFileSync4(p, "utf8"));
     return raw && typeof raw === "object" ? raw : {};
@@ -5981,10 +7796,10 @@ function patchSessionMeta(name, patch) {
   const cur = loadSessionMeta(name);
   const next = { ...cur, ...patch };
   const p = metaPath(name);
-  mkdirSync2(dirname3(p), { recursive: true });
-  writeFileSync2(p, JSON.stringify(next), "utf8");
+  mkdirSync3(dirname3(p), { recursive: true });
+  writeFileSync3(p, JSON.stringify(next), "utf8");
   try {
-    chmodSync2(p, 384);
+    chmodSync3(p, 384);
   } catch {
   }
   return next;
@@ -5995,12 +7810,12 @@ function renameSession(oldName, newName) {
   if (safeOld === safeNew) return false;
   const oldJsonl = sessionPath(oldName);
   const newJsonl = sessionPath(newName);
-  if (!existsSync3(oldJsonl) || existsSync3(newJsonl)) return false;
+  if (!existsSync4(oldJsonl) || existsSync4(newJsonl)) return false;
   renameSync2(oldJsonl, newJsonl);
   for (const ext of SESSION_SIDECAR_EXTS) {
     const oldP = oldJsonl.replace(/\.jsonl$/, ext);
     const newP = newJsonl.replace(/\.jsonl$/, ext);
-    if (existsSync3(oldP)) {
+    if (existsSync4(oldP)) {
       try {
         renameSync2(oldP, newP);
       } catch {
@@ -6012,11 +7827,11 @@ function renameSession(oldName, newName) {
 function deleteSession(name) {
   const path2 = sessionPath(name);
   try {
-    unlinkSync(path2);
+    unlinkSync2(path2);
     for (const ext of SESSION_SIDECAR_EXTS) {
       const sidecar = path2.replace(/\.jsonl$/, ext);
       try {
-        unlinkSync(sidecar);
+        unlinkSync2(sidecar);
       } catch {
       }
     }
@@ -6027,33 +7842,22 @@ function deleteSession(name) {
 }
 function rewriteSession(name, messages) {
   const path2 = sessionPath(name);
-  mkdirSync2(dirname3(path2), { recursive: true });
+  mkdirSync3(dirname3(path2), { recursive: true });
   const body = messages.map((m) => JSON.stringify(m)).join("\n");
   const tmp = `${path2}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
-  try {
-    writeFileSync2(tmp, body ? `${body}
-` : "", "utf8");
-    chmodPrivate(tmp);
-    if (existsSync3(path2) && statSync(path2).size > 0) {
-      const backup = sessionBackupPath(path2);
-      copyFileSync(path2, backup);
-      chmodPrivate(backup);
-    }
-    renameSync2(tmp, path2);
-    chmodPrivate(path2);
-  } catch (err) {
-    try {
-      unlinkSync(tmp);
-    } catch {
-    }
-    throw err;
+  if (existsSync4(path2) && statSync2(path2).size > 0) {
+    const backup = sessionBackupPath(path2);
+    copyFileSync2(path2, backup);
+    chmodPrivate(backup);
   }
+  atomicWriteSync(path2, body ? `${body}
+` : "", tmp);
 }
 function archiveSession(name) {
   const path2 = sessionPath(name);
-  if (!existsSync3(path2)) return null;
+  if (!existsSync4(path2)) return null;
   try {
-    if (statSync(path2).size === 0) return null;
+    if (statSync2(path2).size === 0) return null;
   } catch {
     return null;
   }
@@ -6081,7 +7885,7 @@ function sessionBackupPath(path2) {
 }
 function chmodPrivate(path2) {
   try {
-    chmodSync2(path2, 384);
+    chmodSync3(path2, 384);
   } catch {
   }
 }
@@ -6544,8 +8348,88 @@ var InflightSet = class {
   }
 };
 
+// src/loop/dispatch.ts
+function readParallelMax() {
+  const raw = Number.parseInt(process.env.REASONIX_PARALLEL_MAX ?? "", 10);
+  return Number.isFinite(raw) && raw >= 1 ? Math.min(raw, 16) : 3;
+}
+function readDispatchSerial() {
+  return (process.env.REASONIX_TOOL_DISPATCH ?? "auto").toLowerCase() === "serial";
+}
+async function* dispatchToolCallsChunked(repairedCalls, ctx) {
+  const dispatchSerial = readDispatchSerial();
+  const parallelMax = readParallelMax();
+  let callIdx = 0;
+  while (callIdx < repairedCalls.length) {
+    const chunk = [];
+    if (!dispatchSerial) {
+      while (callIdx < repairedCalls.length && chunk.length < parallelMax && ctx.isParallelSafe(repairedCalls[callIdx]?.function?.name ?? "")) {
+        chunk.push(repairedCalls[callIdx++]);
+      }
+    }
+    if (chunk.length === 0) {
+      chunk.push(repairedCalls[callIdx++]);
+    }
+    for (const call of chunk) {
+      const callId = ctx.inflightIdFor(call);
+      ctx.inflightAdd(callId);
+      yield {
+        turn: ctx.turn,
+        role: "tool_start",
+        content: "",
+        toolName: call.function?.name ?? "",
+        toolArgs: call.function?.arguments ?? "{}",
+        callId
+      };
+    }
+    const settled = await Promise.allSettled(chunk.map((c) => ctx.runOne(c, ctx.signal)));
+    for (let k = 0; k < chunk.length; k++) {
+      const call = chunk[k];
+      const name = call.function?.name ?? "";
+      const args = call.function?.arguments ?? "{}";
+      const s = settled[k];
+      let result;
+      let preWarnings = [];
+      let postWarnings = [];
+      if (s.status === "fulfilled") {
+        preWarnings = s.value.preWarnings;
+        postWarnings = s.value.postWarnings;
+        result = s.value.result;
+      } else {
+        const err = s.reason instanceof Error ? s.reason : new Error(String(s.reason));
+        result = JSON.stringify({ error: `${err.name}: ${err.message}` });
+      }
+      for (const w of preWarnings) yield w;
+      for (const w of postWarnings) yield w;
+      const rateLimited = parseRateLimitedToolResult(result);
+      if (rateLimited && !ctx.rateLimitState.shown) {
+        ctx.rateLimitState.shown = true;
+        yield {
+          turn: ctx.turn,
+          role: "warning",
+          content: rateLimited.message
+        };
+      }
+      ctx.appendAndPersist({
+        role: "tool",
+        tool_call_id: call.id ?? "",
+        name,
+        content: result
+      });
+      yield {
+        turn: ctx.turn,
+        role: "tool",
+        content: result,
+        toolName: name,
+        toolArgs: args,
+        callId: ctx.inflightIdFor(call)
+      };
+    }
+  }
+}
+
 // src/loop/errors.ts
-function formatLoopError(err, probe) {
+function formatLoopError(err, probe, opts) {
   const msg = err.message ?? "";
   if (msg.includes("maximum context length")) {
     const reqMatch = msg.match(/requested\s+(\d+)\s+tokens/);
@@ -6562,7 +8446,7 @@ function formatLoopError(err, probe) {
   if (status === "422") return t("errors.badparam422", { inner });
   if (status === "400") return t("errors.badrequest400", { inner });
   if (status === "429") return t("errors.concurrency429", { inner });
-  if (is5xxStatus(status)) return formatDeepSeek5xx(status, probe);
+  if (is5xxStatus(status)) return format5xx(status, probe, opts?.upstreamHost);
   return msg;
 }
 function is5xxError(err) {
@@ -6574,15 +8458,40 @@ async function probeDeepSeekReachable(client, timeoutMs = 1500) {
   const balance = await client.getBalance({ signal: AbortSignal.timeout(timeoutMs) });
   return { reachable: balance !== null };
 }
+function isDeepSeekHost(baseUrl) {
+  if (!baseUrl) return false;
+  try {
+    const host = new URL(baseUrl).hostname.toLowerCase();
+    return host === "api.deepseek.com";
+  } catch {
+    return false;
+  }
+}
 function is5xxStatus(status) {
   return status === "500" || status === "502" || status === "503" || status === "504";
 }
+function format5xx(status, probe, upstreamHost) {
+  if (upstreamHost !== void 0 && !isDeepSeekHost(upstreamHost)) {
+    return formatUpstream5xx(status, upstreamHost);
+  }
+  return formatDeepSeek5xx(status, probe);
+}
 function formatDeepSeek5xx(status, probe) {
   const head = t("errors.deepseek5xxHead", { status });
   const probeNote = probe === void 0 ? "" : probe.reachable ? t("errors.deepseek5xxReachable") : t("errors.deepseek5xxUnreachable");
   const action = probe?.reachable === false ? t("errors.deepseek5xxActionNetwork") : t("errors.deepseek5xxActionRetry");
   return `${head}${probeNote}${action}`;
 }
+function formatUpstream5xx(status, baseUrl) {
+  let host = baseUrl;
+  try {
+    host = new URL(baseUrl).host || baseUrl;
+  } catch {
+  }
+  const head = t("errors.upstream5xxHead", { status, host });
+  const action = t("errors.upstream5xxActionRetry");
+  return `${head}${action}`;
+}
 function reasonPrefixFor(reason) {
   if (reason === "aborted") return t("errors.reasonAborted");
   if (reason === "context-guard") return t("errors.reasonContextGuard");
@@ -6695,6 +8604,56 @@ function shrinkOversizedToolResultsByTokens(messages, maxTokens) {
   });
   return { messages: out, healedCount, tokensSaved, charsSaved };
 }
+function shrinkOversizedToolCallArgsByTokens(messages, maxTokens) {
+  let healedCount = 0;
+  let tokensSaved = 0;
+  let charsSaved = 0;
+  const out = messages.map((msg) => {
+    if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls)) return msg;
+    let changed = false;
+    const newCalls = msg.tool_calls.map((call) => {
+      const args = call.function?.arguments;
+      if (typeof args !== "string" || args.length <= maxTokens) return call;
+      const beforeTokens = countTokensBounded(args);
+      if (beforeTokens <= maxTokens) return call;
+      const shrunk = shrinkJsonLongStrings(args);
+      const afterTokens = countTokens(shrunk);
+      if (afterTokens >= beforeTokens) return call;
+      changed = true;
+      healedCount += 1;
+      tokensSaved += beforeTokens - afterTokens;
+      charsSaved += args.length - shrunk.length;
+      return { ...call, function: { ...call.function, arguments: shrunk } };
+    });
+    if (!changed) return msg;
+    return { ...msg, tool_calls: newCalls };
+  });
+  return { messages: out, healedCount, tokensSaved, charsSaved };
+}
+function shrinkJsonLongStrings(jsonStr) {
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch {
+    const head = jsonStr.slice(0, 200);
+    return `${head}\u2026[shrunk: ${jsonStr.length} chars, unparsed]`;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return jsonStr;
+  }
+  const LONG_THRESHOLD = 300;
+  const input = parsed;
+  const output = {};
+  for (const [k, v] of Object.entries(input)) {
+    if (typeof v === "string" && v.length > LONG_THRESHOLD) {
+      const newlines = v.match(/\n/g)?.length ?? 0;
+      output[k] = `[\u2026shrunk: ${v.length} chars, ${newlines} lines \u2014 tool already responded, see result]`;
+    } else {
+      output[k] = v;
+    }
+  }
+  return JSON.stringify(output);
+}
 
 // src/loop/healing.ts
 var _stampSeq = 0;
@@ -6765,12 +8724,13 @@ function stampMissingReasoningForThinkingMode(messages, model) {
 function healLoadedMessagesByTokens(messages, maxTokens) {
   const shrunk = shrinkOversizedToolResultsByTokens(messages, maxTokens);
   const paired = fixToolCallPairing(shrunk.messages);
-  const healedCount = shrunk.healedCount + paired.droppedAssistantCalls + paired.droppedStrayTools;
+  const argsShrunk = shrinkOversizedToolCallArgsByTokens(paired.messages, maxTokens);
+  const healedCount = shrunk.healedCount + argsShrunk.healedCount + paired.droppedAssistantCalls + paired.droppedStrayTools;
   return {
-    messages: paired.messages,
+    messages: argsShrunk.messages,
     healedCount,
-    tokensSaved: shrunk.tokensSaved,
-    charsSaved: shrunk.charsSaved
+    tokensSaved: shrunk.tokensSaved + argsShrunk.tokensSaved,
+    charsSaved: shrunk.charsSaved + argsShrunk.charsSaved
   };
 }
 
@@ -6789,6 +8749,112 @@ function* hookWarnings(outcomes, turn) {
   }
 }
 
+// src/loop/reasoning-retention.ts
+function hasToolCalls(msg) {
+  return Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
+}
+function stripDroppableReasoningContent(messages) {
+  let lastUser = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      lastUser = i;
+      break;
+    }
+  }
+  if (lastUser < 0) {
+    return { messages, prunedCount: 0, charsDropped: 0 };
+  }
+  let next = null;
+  let prunedCount = 0;
+  let charsDropped = 0;
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== "assistant" || i > lastUser || hasToolCalls(msg) || !Object.hasOwn(msg, "reasoning_content")) {
+      continue;
+    }
+    if (next === null) next = messages.slice();
+    const { reasoning_content: dropped, ...replacement } = msg;
+    if (typeof dropped === "string") charsDropped += dropped.length;
+    next[i] = replacement;
+    prunedCount += 1;
+  }
+  return {
+    messages: next ?? messages,
+    prunedCount,
+    charsDropped
+  };
+}
+
+// src/loop/streaming.ts
+async function* streamModelResponse(opts) {
+  const { client, model, messages, toolSpecs, signal, reasoningEffort, turn } = opts;
+  let assistantContent = "";
+  let reasoningContent = "";
+  let usage = null;
+  const callBuf = /* @__PURE__ */ new Map();
+  const readyIndices = /* @__PURE__ */ new Set();
+  for await (const chunk of client.stream({
+    model,
+    messages,
+    tools: toolSpecs.length ? toolSpecs : void 0,
+    signal,
+    thinking: thinkingModeForModel(model),
+    reasoningEffort
+  })) {
+    if (chunk.reasoningDelta) {
+      reasoningContent += chunk.reasoningDelta;
+      yield {
+        turn,
+        role: "assistant_delta",
+        content: "",
+        reasoningDelta: chunk.reasoningDelta
+      };
+    }
+    if (chunk.contentDelta) {
+      assistantContent += chunk.contentDelta;
+      yield {
+        turn,
+        role: "assistant_delta",
+        content: chunk.contentDelta
+      };
+    }
+    if (chunk.toolCallDelta) {
+      const d = chunk.toolCallDelta;
+      const cur = callBuf.get(d.index) ?? {
+        id: d.id,
+        type: "function",
+        function: { name: "", arguments: "" }
+      };
+      if (d.id) cur.id = d.id;
+      if (d.name) cur.function.name = (cur.function.name ?? "") + d.name;
+      if (d.argumentsDelta)
+        cur.function.arguments = (cur.function.arguments ?? "") + d.argumentsDelta;
+      callBuf.set(d.index, cur);
+      if (!readyIndices.has(d.index) && cur.function.name && looksLikeCompleteJson(cur.function.arguments ?? "")) {
+        readyIndices.add(d.index);
+      }
+      if (cur.function.name) {
+        yield {
+          turn,
+          role: "tool_call_delta",
+          content: "",
+          toolName: cur.function.name,
+          toolCallArgsChars: (cur.function.arguments ?? "").length,
+          toolCallIndex: d.index,
+          toolCallReadyCount: readyIndices.size
+        };
+      }
+    }
+    if (chunk.usage) usage = chunk.usage;
+  }
+  return {
+    assistantContent,
+    reasoningContent,
+    toolCalls: [...callBuf.values()],
+    usage
+  };
+}
+
 // src/memory/runtime.ts
 import { createHash } from "crypto";
 var ImmutablePrefix = class {
@@ -7254,6 +9320,10 @@ var MID_TURN_STEER_WRAPPER = "[Mid-turn steer queued by the user. Do not treat t
 function formatSteerUserMessage(content) {
   return [MID_TURN_STEER_WRAPPER, content].join("\n");
 }
+function shrinkMessageForRetention(message) {
+  if (message.role !== "assistant" || !Array.isArray(message.tool_calls)) return message;
+  return shrinkOversizedToolCallArgsByTokens([message], DEFAULT_MAX_RESULT_TOKENS).messages[0] ?? message;
+}
 var CacheFirstLoop = class {
   client;
   prefix;
@@ -7347,7 +9417,8 @@ var CacheFirstLoop = class {
       const prior = loadSessionMessages(this.sessionName);
       const shrunk = healLoadedMessagesByTokens(prior, DEFAULT_MAX_RESULT_TOKENS);
       const stamped = stampMissingReasoningForThinkingMode(shrunk.messages, this.model);
-      const messages = stamped.messages;
+      const pruned = stripDroppableReasoningContent(stamped.messages);
+      const messages = pruned.messages;
       const healedCount = shrunk.healedCount + stamped.stampedCount;
       const tokensSaved = shrunk.tokensSaved;
       for (const msg of messages) this.log.append(msg);
@@ -7364,15 +9435,17 @@ var CacheFirstLoop = class {
           lastPromptTokens: meta.lastPromptTokens
         });
       }
-      if (healedCount > 0) {
+      if (healedCount > 0 || pruned.prunedCount > 0) {
         try {
           rewriteSession(this.sessionName, messages);
         } catch {
         }
-        process.stderr.write(
-          `\u25B8 session "${this.sessionName}": healed ${healedCount} entr${healedCount === 1 ? "y" : "ies"}${tokensSaved > 0 ? ` (shrunk ${tokensSaved.toLocaleString()} tokens of oversized tool output)` : " (dropped dangling tool_calls tail)"}. Rewrote session file.
+        if (healedCount > 0) {
+          process.stderr.write(
+            `\u25B8 session "${this.sessionName}": healed ${healedCount} entr${healedCount === 1 ? "y" : "ies"}${tokensSaved > 0 ? ` (shrunk ${tokensSaved.toLocaleString()} tokens of oversized tool output/arguments)` : " (dropped dangling tool_calls tail)"}. Rewrote session file.
 `
-        );
+          );
+        }
       }
     } else {
       this.resumedMessageCount = 0;
@@ -7399,21 +9472,23 @@ var CacheFirstLoop = class {
     return this.context.getLogTokens();
   }
   appendAndPersist(message) {
-    this.log.append(message);
+    const retained = shrinkMessageForRetention(message);
+    this.log.append(retained);
     if (this.sessionName) {
       try {
-        appendSessionMessage(this.sessionName, message);
+        appendSessionMessage(this.sessionName, retained);
       } catch {
       }
     }
   }
   /** Swap the just-appended assistant entry — used by self-correction to restore the original tool_calls without dropping reasoning_content. */
   replaceTailAssistantMessage(message) {
+    const retained = shrinkMessageForRetention(message);
     const entries = this.log.entries;
     const tail = entries[entries.length - 1];
     if (!tail || tail.role !== "assistant") return;
     const kept = entries.slice(0, -1);
-    kept.push(message);
+    kept.push(retained);
     this.log.compactInPlace(kept);
     if (this.sessionName) {
       try {
@@ -7439,6 +9514,8 @@ var CacheFirstLoop = class {
     this.stats.reset();
     this._turn = 0;
     this._budgetWarned = false;
+    this._steerQueue.length = 0;
+    this._steerConsumed = false;
     let systemRebuilt = false;
     if (this._rebuildSystem) {
       try {
@@ -7462,6 +9539,8 @@ var CacheFirstLoop = class {
     this.log.compactInPlace([]);
     this.scratch.reset();
     this._inflight.clear();
+    this._steerQueue.length = 0;
+    this._steerConsumed = false;
     this.sessionName = opts.sessionName;
     if (this._rebuildSystem) {
       try {
@@ -7539,7 +9618,8 @@ ${reason}`
         signal,
         maxResultTokens: DEFAULT_MAX_RESULT_TOKENS,
         confirmationGate: this.confirmationGate,
-        readTracker: this.readTracker
+        readTracker: this.readTracker,
+        rootDir: this.hookCwd
       });
       const postReport = await runHooks({
         hooks: this.hooks,
@@ -7574,15 +9654,22 @@ ${reason}`
   healActiveLogBeforeSend() {
     const current = this.log.toMessages();
     const healed = healLoadedMessages(current, DEFAULT_MAX_RESULT_CHARS);
-    if (healed.healedCount === 0) return current;
-    this.log.compactInPlace(healed.messages);
+    const argsShrunk = shrinkOversizedToolCallArgsByTokens(
+      healed.messages,
+      DEFAULT_MAX_RESULT_TOKENS
+    );
+    const pruned = stripDroppableReasoningContent(argsShrunk.messages);
+    if (healed.healedCount === 0 && argsShrunk.healedCount === 0 && pruned.prunedCount === 0) {
+      return current;
+    }
+    this.log.compactInPlace(pruned.messages);
     if (this.sessionName) {
       try {
-        rewriteSession(this.sessionName, healed.messages);
+        rewriteSession(this.sessionName, pruned.messages);
       } catch {
       }
     }
-    return healed.messages;
+    return pruned.messages;
   }
   abort(opts = {}) {
     if (opts.discardCurrentTurn) this._discardAbortRequested = true;
@@ -7692,7 +9779,7 @@ ${reason}`
     const turnStartLogIndex = this.log.length;
     this.appendAndPersist({ role: "user", content: userInput });
     const toolSpecs = this.prefix.tools();
-    let rateLimitWarningShown = false;
+    const rateLimitState = { shown: false };
     {
       const turnStart = this.context.estimateTurnStart(
         this.buildMessages(),
@@ -7705,7 +9792,9 @@ ${reason}`
           role: "status",
           content: t("loop.turnStartFoldStatus")
         };
-        const result = await this.context.fold(this.model, { requireTailBoundary: true });
+        const result = await this.context.fold(this.model, {
+          requireTailBoundary: true
+        });
         if (result.folded) {
           this._foldedThisTurn = true;
           yield {
@@ -7773,64 +9862,19 @@ ${reason}`
       let usage = null;
       try {
         if (this.stream) {
-          const callBuf = /* @__PURE__ */ new Map();
-          const readyIndices = /* @__PURE__ */ new Set();
-          const callModel = this.model;
-          for await (const chunk of this.client.stream({
-            model: callModel,
+          const result = yield* streamModelResponse({
+            client: this.client,
+            model: this.model,
             messages,
-            tools: toolSpecs.length ? toolSpecs : void 0,
+            toolSpecs,
             signal,
-            thinking: thinkingModeForModel(callModel),
-            reasoningEffort: this.reasoningEffort
-          })) {
-            if (chunk.reasoningDelta) {
-              reasoningContent += chunk.reasoningDelta;
-              yield {
-                turn: this._turn,
-                role: "assistant_delta",
-                content: "",
-                reasoningDelta: chunk.reasoningDelta
-              };
-            }
-            if (chunk.contentDelta) {
-              assistantContent += chunk.contentDelta;
-              yield {
-                turn: this._turn,
-                role: "assistant_delta",
-                content: chunk.contentDelta
-              };
-            }
-            if (chunk.toolCallDelta) {
-              const d = chunk.toolCallDelta;
-              const cur = callBuf.get(d.index) ?? {
-                id: d.id,
-                type: "function",
-                function: { name: "", arguments: "" }
-              };
-              if (d.id) cur.id = d.id;
-              if (d.name) cur.function.name = (cur.function.name ?? "") + d.name;
-              if (d.argumentsDelta)
-                cur.function.arguments = (cur.function.arguments ?? "") + d.argumentsDelta;
-              callBuf.set(d.index, cur);
-              if (!readyIndices.has(d.index) && cur.function.name && looksLikeCompleteJson(cur.function.arguments ?? "")) {
-                readyIndices.add(d.index);
-              }
-              if (cur.function.name) {
-                yield {
-                  turn: this._turn,
-                  role: "tool_call_delta",
-                  content: "",
-                  toolName: cur.function.name,
-                  toolCallArgsChars: (cur.function.arguments ?? "").length,
-                  toolCallIndex: d.index,
-                  toolCallReadyCount: readyIndices.size
-                };
-              }
-            }
-            if (chunk.usage) usage = chunk.usage;
-          }
-          toolCalls = [...callBuf.values()];
+            reasoningEffort: this.reasoningEffort,
+            turn: this._turn
+          });
+          assistantContent = result.assistantContent;
+          reasoningContent = result.reasoningContent;
+          toolCalls = result.toolCalls;
+          usage = result.usage;
         } else {
           const callModel = this.model;
           const resp = await this.client.chat({
@@ -7857,12 +9901,14 @@ ${reason}`
           this._steerQueue.length = 0;
           return;
         }
-        const probe = is5xxError(err) ? await probeDeepSeekReachable(this.client) : void 0;
+        const upstreamHost = this.client.baseUrl;
+        const dsHost = isDeepSeekHost(upstreamHost);
+        const probe = is5xxError(err) && dsHost ? await probeDeepSeekReachable(this.client) : void 0;
         yield {
           turn: this._turn,
           role: "error",
           content: "",
-          error: formatLoopError(err, probe)
+          error: formatLoopError(err, probe, { upstreamHost })
         };
         this._steerQueue.length = 0;
         return;
@@ -7988,76 +10034,16 @@ ${reason}`
         this._steerQueue.length = 0;
         return;
       }
-      const dispatchSerial = (process.env.REASONIX_TOOL_DISPATCH ?? "auto").toLowerCase() === "serial";
-      const parallelMaxParsed = Number.parseInt(process.env.REASONIX_PARALLEL_MAX ?? "", 10);
-      const parallelMax = Number.isFinite(parallelMaxParsed) && parallelMaxParsed >= 1 ? Math.min(parallelMaxParsed, 16) : 3;
-      let callIdx = 0;
-      while (callIdx < repairedCalls.length) {
-        const chunk = [];
-        if (!dispatchSerial) {
-          while (callIdx < repairedCalls.length && chunk.length < parallelMax && this.tools.isParallelSafe(repairedCalls[callIdx]?.function?.name ?? "")) {
-            chunk.push(repairedCalls[callIdx++]);
-          }
-        }
-        if (chunk.length === 0) {
-          chunk.push(repairedCalls[callIdx++]);
-        }
-        for (const call of chunk) {
-          const callId = this.inflightIdFor(call);
-          this._inflight.add(callId);
-          yield {
-            turn: this._turn,
-            role: "tool_start",
-            content: "",
-            toolName: call.function?.name ?? "",
-            toolArgs: call.function?.arguments ?? "{}",
-            callId
-          };
-        }
-        const settled = await Promise.allSettled(chunk.map((c) => this.runOneToolCall(c, signal)));
-        for (let k = 0; k < chunk.length; k++) {
-          const call = chunk[k];
-          const name = call.function?.name ?? "";
-          const args = call.function?.arguments ?? "{}";
-          const s = settled[k];
-          let result;
-          let preWarnings = [];
-          let postWarnings = [];
-          if (s.status === "fulfilled") {
-            preWarnings = s.value.preWarnings;
-            postWarnings = s.value.postWarnings;
-            result = s.value.result;
-          } else {
-            const err = s.reason instanceof Error ? s.reason : new Error(String(s.reason));
-            result = JSON.stringify({ error: `${err.name}: ${err.message}` });
-          }
-          for (const w of preWarnings) yield w;
-          for (const w of postWarnings) yield w;
-          const rateLimited = parseRateLimitedToolResult(result);
-          if (rateLimited && !rateLimitWarningShown) {
-            rateLimitWarningShown = true;
-            yield {
-              turn: this._turn,
-              role: "warning",
-              content: rateLimited.message
-            };
-          }
-          this.appendAndPersist({
-            role: "tool",
-            tool_call_id: call.id ?? "",
-            name,
-            content: result
-          });
-          yield {
-            turn: this._turn,
-            role: "tool",
-            content: result,
-            toolName: name,
-            toolArgs: args,
-            callId: this.inflightIdFor(call)
-          };
-        }
-      }
+      yield* dispatchToolCallsChunked(repairedCalls, {
+        turn: this._turn,
+        signal,
+        isParallelSafe: (name) => this.tools.isParallelSafe(name),
+        inflightIdFor: (call) => this.inflightIdFor(call),
+        inflightAdd: (id) => this._inflight.add(id),
+        runOne: (call, sig) => this.runOneToolCall(call, sig),
+        appendAndPersist: (m) => this.appendAndPersist(m),
+        rateLimitState
+      });
     }
   }
   summaryContext() {
@@ -8087,28 +10073,42 @@ function parsePositiveIntEnv(raw) {
 }
 
 // src/at-mentions.ts
-import { existsSync as existsSync4, readFileSync as readFileSync6, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
 import { readdir, stat } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join5, relative, resolve as resolve3 } from "path";
+import { isAbsolute as isAbsolute2, join as join6, relative as relative2, resolve as resolve4 } from "path";
 
 // src/gitignore.ts
 import { readFileSync as readFileSync5 } from "fs";
 import { readFile } from "fs/promises";
 import path from "path";
 import ignore from "ignore";
+var gitignoreCache = new TtlLruCache(256, 5e3);
+function buildIgnore(text) {
+  return ignore().add(text);
+}
 async function loadGitignoreAt(dirAbs) {
+  const cached2 = gitignoreCache.get(dirAbs);
+  if (cached2 !== void 0) return cached2;
+  let result;
   try {
-    return ignore().add(await readFile(path.join(dirAbs, ".gitignore"), "utf8"));
+    result = buildIgnore(await readFile(path.join(dirAbs, ".gitignore"), "utf8"));
   } catch {
-    return null;
+    result = null;
   }
+  gitignoreCache.set(dirAbs, result);
+  return result;
 }
 function loadGitignoreAtSync(dirAbs) {
+  const cached2 = gitignoreCache.get(dirAbs);
+  if (cached2 !== void 0) return cached2;
+  let result;
   try {
-    return ignore().add(readFileSync5(path.join(dirAbs, ".gitignore"), "utf8"));
+    result = buildIgnore(readFileSync5(path.join(dirAbs, ".gitignore"), "utf8"));
   } catch {
-    return null;
+    result = null;
   }
+  gitignoreCache.set(dirAbs, result);
+  return result;
 }
 function ignoredByLayers(layers, abs, isDir) {
   for (const layer of layers) {
@@ -8144,7 +10144,7 @@ function listFilesSync(root, opts = {}) {
 function listFilesWithStatsSync(root, opts = {}) {
   const maxResults = Math.max(1, opts.maxResults ?? 2e3);
   const ignoreDirs = new Set(opts.ignoreDirs ?? DEFAULT_PICKER_IGNORE_DIRS);
-  const rootAbs = resolve3(root);
+  const rootAbs = resolve4(root);
   const respectGi = opts.respectGitignore !== false;
   const out = [];
   const walk2 = (dirAbs, dirRel, layers) => {
@@ -8156,7 +10156,7 @@ function listFilesWithStatsSync(root, opts = {}) {
     }
     let entries;
     try {
-      entries = readdirSync2(dirAbs, { withFileTypes: true });
+      entries = readdirSync3(dirAbs, { withFileTypes: true });
     } catch {
       return;
     }
@@ -8164,7 +10164,7 @@ function listFilesWithStatsSync(root, opts = {}) {
     for (const ent of entries) {
       if (out.length >= maxResults) return;
       const relPath = dirRel ? `${dirRel}/${ent.name}` : ent.name;
-      const absPath = join5(dirAbs, ent.name);
+      const absPath = join6(dirAbs, ent.name);
       if (ent.isDirectory()) {
         if (ent.name.startsWith(".") || ignoreDirs.has(ent.name)) continue;
         if (ignoredByLayers(effectiveLayers, absPath, true)) continue;
@@ -8173,14 +10173,14 @@ function listFilesWithStatsSync(root, opts = {}) {
         if (ignoredByLayers(effectiveLayers, absPath, false)) continue;
         let mtimeMs = 0;
         try {
-          mtimeMs = statSync2(absPath).mtimeMs;
+          mtimeMs = statSync3(absPath).mtimeMs;
         } catch {
         }
         out.push({ path: relPath, mtimeMs });
       } else if (ent.isSymbolicLink()) {
         let target = null;
         try {
-          target = statSync2(absPath);
+          target = statSync3(absPath);
         } catch {
           continue;
         }
@@ -8208,7 +10208,7 @@ async function listFilesWithStatsAsync(root, opts = {}) {
 async function walkFilesStream(root, opts) {
   const ignoreDirs = new Set(opts.ignoreDirs ?? DEFAULT_PICKER_IGNORE_DIRS);
   const respectGi = opts.respectGitignore !== false;
-  const rootAbs = resolve3(root);
+  const rootAbs = resolve4(root);
   const progressGap = Math.max(0, opts.progressIntervalMs ?? 100);
   let scanned = 0;
   let halted = false;
@@ -8244,7 +10244,7 @@ async function walkFilesStream(root, opts) {
     const fileEnts = [];
     for (const ent of entries) {
       if (halted || opts.signal?.aborted) break;
-      const absPath = join5(dirAbs, ent.name);
+      const absPath = join6(dirAbs, ent.name);
       if (ent.isDirectory()) {
         if (ent.name.startsWith(".") || ignoreDirs.has(ent.name)) continue;
         if (ignoredByLayers(effectiveLayers, absPath, true)) continue;
@@ -8267,10 +10267,10 @@ async function walkFilesStream(root, opts) {
   return { scanned, cancelled: !!opts.signal?.aborted };
 }
 async function flushFiles(ents, dirAbs, dirRel, layers, emit) {
-  const accepted = ents.filter((e) => !ignoredByLayers(layers, join5(dirAbs, e.name), false));
+  const accepted = ents.filter((e) => !ignoredByLayers(layers, join6(dirAbs, e.name), false));
   const stats = await Promise.all(
     accepted.map(
-      (e) => stat(join5(dirAbs, e.name)).then((s) => ({ mtimeMs: s.mtimeMs, isFile: s.isFile() })).catch(() => null)
+      (e) => stat(join6(dirAbs, e.name)).then((s) => ({ mtimeMs: s.mtimeMs, isFile: s.isFile() })).catch(() => null)
     )
   );
   for (let i = 0; i < accepted.length; i++) {
@@ -8283,13 +10283,17 @@ async function flushFiles(ents, dirAbs, dirRel, layers, emit) {
     });
   }
 }
+var listDirectoryCache = new TtlLruCache(64, 5e3);
 async function listDirectory(root, relDir, opts = {}) {
   const ignoreDirs = new Set(opts.ignoreDirs ?? DEFAULT_PICKER_IGNORE_DIRS);
   const respectGi = opts.respectGitignore !== false;
-  const rootAbs = resolve3(root);
-  const dirAbs = resolve3(rootAbs, relDir);
-  const rel = relative(rootAbs, dirAbs);
+  const rootAbs = resolve4(root);
+  const dirAbs = resolve4(rootAbs, relDir);
+  const rel = relative2(rootAbs, dirAbs);
   if (rel.startsWith("..") || isAbsolute2(rel)) return [];
+  const cacheKey = `${dirAbs}\0${respectGi ? "g" : ""}\0${[...ignoreDirs].sort().join(",")}`;
+  const cached2 = listDirectoryCache.get(cacheKey);
+  if (cached2) return cached2;
   const layers = [];
   if (respectGi) {
     const segs = rel ? rel.split(/[\\/]/) : [];
@@ -8297,7 +10301,7 @@ async function listDirectory(root, relDir, opts = {}) {
     const ig = await loadGitignoreAt(cursor);
     if (ig) layers.push({ dirAbs: cursor, ig });
     for (const seg of segs) {
-      cursor = join5(cursor, seg);
+      cursor = join6(cursor, seg);
       const igSeg = await loadGitignoreAt(cursor);
       if (igSeg) layers.push({ dirAbs: cursor, ig: igSeg });
     }
@@ -8312,7 +10316,7 @@ async function listDirectory(root, relDir, opts = {}) {
   const dirs = [];
   const files = [];
   for (const ent of raw) {
-    const absPath = join5(dirAbs, ent.name);
+    const absPath = join6(dirAbs, ent.name);
     if (ent.isDirectory()) {
       if (ent.name.startsWith(".") || ignoreDirs.has(ent.name)) continue;
       if (ignoredByLayers(layers, absPath, true)) continue;
@@ -8329,7 +10333,7 @@ async function listDirectory(root, relDir, opts = {}) {
   }
   const stats = await Promise.all(
     files.map(
-      (e) => stat(join5(dirAbs, e.name)).then((s) => ({ mtimeMs: s.mtimeMs, isFile: s.isFile() })).catch(() => null)
+      (e) => stat(join6(dirAbs, e.name)).then((s) => ({ mtimeMs: s.mtimeMs, isFile: s.isFile() })).catch(() => null)
     )
   );
   const fileEntries = [];
@@ -8346,7 +10350,9 @@ async function listDirectory(root, relDir, opts = {}) {
   }
   dirs.sort((a, b) => a.name.localeCompare(b.name));
   fileEntries.sort((a, b) => a.name.localeCompare(b.name));
-  return [...dirs, ...fileEntries];
+  const result = [...dirs, ...fileEntries];
+  listDirectoryCache.set(cacheKey, result);
+  return result;
 }
 function parseAtQuery(query) {
   const normalized = query.replace(/\\/g, "/");
@@ -8451,8 +10457,8 @@ var AT_MENTION_PATTERN = /(?<=^|\s)@([\p{L}\p{N}_./\\-]+)/gu;
 function expandAtMentions(text, rootDir, opts = {}) {
   const maxBytes = opts.maxBytes ?? DEFAULT_AT_MENTION_MAX_BYTES;
   const maxDirEntries = Math.max(1, opts.maxDirEntries ?? DEFAULT_AT_DIR_MAX_ENTRIES);
-  const fs5 = opts.fs ?? defaultFs;
-  const root = resolve3(rootDir);
+  const fs5 = opts.fs ?? defaultFs2;
+  const root = resolve4(rootDir);
   const seen = /* @__PURE__ */ new Map();
   const expansions = [];
   const dirListings = /* @__PURE__ */ new Map();
@@ -8499,8 +10505,8 @@ function resolveMention(rawPath, root, maxBytes, maxDirEntries, fs5, dirListings
   if (isAbsolute2(rawPath)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "escape" };
   }
-  const resolved = resolve3(root, rawPath);
-  const rel = relative(root, resolved);
+  const resolved = resolve4(root, rawPath);
+  const rel = relative2(root, resolved);
   if (rel.startsWith("..") || isAbsolute2(rel)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "escape" };
   }
@@ -8529,31 +10535,31 @@ function resolveMention(rawPath, root, maxBytes, maxDirEntries, fs5, dirListings
   return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "not-file" };
 }
 function readSafe(root, rawPath, fs5) {
-  const resolved = resolve3(root, rawPath);
+  const resolved = resolve4(root, rawPath);
   try {
     return fs5.read(resolved);
   } catch {
     return "(read failed)";
   }
 }
-var defaultFs = {
-  exists: (p) => existsSync4(p),
+var defaultFs2 = {
+  exists: (p) => existsSync5(p),
   isFile: (p) => {
     try {
-      return statSync2(p).isFile();
+      return statSync3(p).isFile();
     } catch {
       return false;
     }
   },
   isDir: (p) => {
     try {
-      return statSync2(p).isDirectory();
+      return statSync3(p).isDirectory();
     } catch {
       return false;
     }
   },
   listDir: (dirAbs, root, max) => {
-    const dirRel = relative(root, dirAbs).split(/[\\/]/).join("/");
+    const dirRel = relative2(root, dirAbs).split(/[\\/]/).join("/");
     const walkCap = Math.max(max * 4, 5e3);
     const all = listFilesSync(root, { maxResults: walkCap });
     const prefix = dirRel ? `${dirRel}/` : "";
@@ -8565,7 +10571,7 @@ var defaultFs = {
   },
   size: (p) => {
     try {
-      return statSync2(p).size;
+      return statSync3(p).size;
     } catch {
       return 0;
     }
@@ -8574,20 +10580,26 @@ var defaultFs = {
 };
 
 // src/memory/project.ts
-import { existsSync as existsSync5, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
-import { basename, join as join6 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync7, statSync as statSync4 } from "fs";
+import { basename, join as join7 } from "path";
 var PROJECT_MEMORY_FILE = "REASONIX.md";
-var PROJECT_MEMORY_FILES = ["REASONIX.md", "AGENTS.md", "AGENT.md"];
+var PROJECT_MEMORY_FILES = [
+  "REASONIX.md",
+  ".claude/CLAUDE.md",
+  "CLAUDE.md",
+  "AGENTS.md",
+  "AGENT.md"
+];
 var PROJECT_MEMORY_MAX_CHARS = 8e3;
 function findProjectMemoryPath(rootDir) {
   for (const name of PROJECT_MEMORY_FILES) {
-    const path2 = join6(rootDir, name);
-    if (existsSync5(path2)) return path2;
+    const path2 = join7(rootDir, name);
+    if (existsSync6(path2)) return path2;
   }
   return null;
 }
 function resolveProjectMemoryWritePath(rootDir) {
-  return findProjectMemoryPath(rootDir) ?? join6(rootDir, PROJECT_MEMORY_FILE);
+  return findProjectMemoryPath(rootDir) ?? join7(rootDir, PROJECT_MEMORY_FILE);
 }
 function readProjectMemory(rootDir) {
   const path2 = findProjectMemoryPath(rootDir);
@@ -8631,15 +10643,15 @@ ${mem.content}
 // src/memory/user.ts
 import { createHash as createHash2 } from "crypto";
 import {
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync4,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync5,
   readFileSync as readFileSync9,
-  readdirSync as readdirSync4,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync4
+  readdirSync as readdirSync5,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync5
 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join8, resolve as resolve5 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join9, resolve as resolve6 } from "path";
 
 // src/frontmatter.ts
 var KEY_RE = /^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.*)$/;
@@ -8691,16 +10703,16 @@ function parseFrontmatter(raw) {
 // src/skills.ts
 import {
   constants,
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync3,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync4,
   readFileSync as readFileSync8,
-  readdirSync as readdirSync3,
-  statSync as statSync4,
-  writeFileSync as writeFileSync3
+  readdirSync as readdirSync4,
+  statSync as statSync5,
+  writeFileSync as writeFileSync4
 } from "fs";
 import { accessSync } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname4, isAbsolute as isAbsolute3, join as join7, resolve as resolve4 } from "path";
+import { homedir as homedir6 } from "os";
+import { dirname as dirname4, isAbsolute as isAbsolute3, join as join8, resolve as resolve5 } from "path";
 
 // src/prompt-fragments.ts
 var TUI_FORMATTING_RULES = `Formatting (rendered in a TUI with a real markdown renderer):
@@ -8755,8 +10767,8 @@ var SkillStore = class {
   disableBuiltins;
   subagentModels;
   constructor(opts = {}) {
-    this.homeDir = opts.homeDir ?? homedir5();
-    this.projectRoot = opts.projectRoot ? resolve4(opts.projectRoot) : void 0;
+    this.homeDir = opts.homeDir ?? homedir6();
+    this.projectRoot = opts.projectRoot ? resolve5(opts.projectRoot) : void 0;
     const baseDir = this.projectRoot ?? process.cwd();
     this.customSkillPaths = dedupePaths(
       opts.customSkillPaths?.map((p) => resolveCustomSkillPath(p, baseDir, this.homeDir)) ?? []
@@ -8773,22 +10785,22 @@ var SkillStore = class {
     const out = [];
     if (this.projectRoot) {
       out.push({
-        dir: join7(this.projectRoot, ".reasonix", SKILLS_DIRNAME),
+        dir: join8(this.projectRoot, ".reasonix", SKILLS_DIRNAME),
         scope: "project"
       });
       out.push({
-        dir: join7(this.projectRoot, ".agents", SKILLS_DIRNAME),
+        dir: join8(this.projectRoot, ".agents", SKILLS_DIRNAME),
         scope: "project"
       });
       out.push({
-        dir: join7(this.projectRoot, ".claude", SKILLS_DIRNAME),
+        dir: join8(this.projectRoot, ".claude", SKILLS_DIRNAME),
         scope: "project"
       });
     }
     for (const dir of this.customSkillPaths) out.push({ dir, scope: "custom" });
-    out.push({ dir: join7(this.homeDir, ".reasonix", SKILLS_DIRNAME), scope: "global" });
-    out.push({ dir: join7(this.homeDir, ".agents", SKILLS_DIRNAME), scope: "global" });
-    out.push({ dir: join7(this.homeDir, ".claude", SKILLS_DIRNAME), scope: "global" });
+    out.push({ dir: join8(this.homeDir, ".reasonix", SKILLS_DIRNAME), scope: "global" });
+    out.push({ dir: join8(this.homeDir, ".agents", SKILLS_DIRNAME), scope: "global" });
+    out.push({ dir: join8(this.homeDir, ".claude", SKILLS_DIRNAME), scope: "global" });
     return out.map((root, priority) => ({ ...root, priority, status: skillPathStatus(root.dir) }));
   }
   customRoots() {
@@ -8801,7 +10813,7 @@ var SkillStore = class {
       if (status !== "ok") continue;
       let entries;
       try {
-        entries = readdirSync3(dir, { withFileTypes: true });
+        entries = readdirSync4(dir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -8837,15 +10849,15 @@ var SkillStore = class {
     if (scope === "project" && !this.projectRoot) {
       return { error: "project scope requires a workspace \u2014 run from `reasonix code`" };
     }
-    const root = scope === "project" ? join7(this.projectRoot ?? "", ".reasonix", SKILLS_DIRNAME) : join7(this.homeDir, ".reasonix", SKILLS_DIRNAME);
-    const flat = join7(root, `${name}.md`);
-    const folder = join7(root, name, SKILL_FILE);
-    if (existsSync6(folder)) {
+    const root = scope === "project" ? join8(this.projectRoot ?? "", ".reasonix", SKILLS_DIRNAME) : join8(this.homeDir, ".reasonix", SKILLS_DIRNAME);
+    const flat = join8(root, `${name}.md`);
+    const folder = join8(root, name, SKILL_FILE);
+    if (existsSync7(folder)) {
       return { error: `skill "${name}" already exists at ${folder}` };
     }
-    mkdirSync3(dirname4(flat), { recursive: true });
+    mkdirSync4(dirname4(flat), { recursive: true });
     try {
-      writeFileSync3(flat, content, { encoding: "utf8", flag: "wx" });
+      writeFileSync4(flat, content, { encoding: "utf8", flag: "wx" });
     } catch (err) {
       if (err.code === "EEXIST") {
         return { error: `skill "${name}" already exists at ${flat}` };
@@ -8859,12 +10871,12 @@ var SkillStore = class {
     if (!isValidSkillName(name)) return null;
     for (const { dir, scope, status } of this.roots()) {
       if (status !== "ok") continue;
-      const dirCandidate = join7(dir, name, SKILL_FILE);
-      if (existsSync6(dirCandidate) && statSync4(dirCandidate).isFile()) {
+      const dirCandidate = join8(dir, name, SKILL_FILE);
+      if (existsSync7(dirCandidate) && statSync5(dirCandidate).isFile()) {
         return this.parse(dirCandidate, name, scope);
       }
-      const flatCandidate = join7(dir, `${name}.md`);
-      if (existsSync6(flatCandidate) && statSync4(flatCandidate).isFile()) {
+      const flatCandidate = join8(dir, `${name}.md`);
+      if (existsSync7(flatCandidate) && statSync5(flatCandidate).isFile()) {
         return this.parse(flatCandidate, name, scope);
       }
     }
@@ -8878,14 +10890,14 @@ var SkillStore = class {
   readEntry(dir, scope, entry) {
     if (entry.isDirectory()) {
       if (!isValidSkillName(entry.name)) return null;
-      const file = join7(dir, entry.name, SKILL_FILE);
-      if (!existsSync6(file)) return null;
+      const file = join8(dir, entry.name, SKILL_FILE);
+      if (!existsSync7(file)) return null;
       return this.parse(file, entry.name, scope);
     }
     if (entry.isFile() && entry.name.endsWith(".md")) {
       const stem = entry.name.slice(0, -3);
       if (!isValidSkillName(stem)) return null;
-      return this.parse(join7(dir, entry.name), stem, scope);
+      return this.parse(join8(dir, entry.name), stem, scope);
     }
     return null;
   }
@@ -8929,12 +10941,12 @@ function dedupePaths(paths) {
 }
 function resolveCustomSkillPath(path2, baseDir, homeDir) {
   const trimmed = path2.trim();
-  const expanded = trimmed === "~" ? homeDir : trimmed.startsWith("~/") || trimmed.startsWith("~\\") ? join7(homeDir, trimmed.slice(2)) : trimmed;
-  return resolve4(isAbsolute3(expanded) ? expanded : join7(baseDir, expanded));
+  const expanded = trimmed === "~" ? homeDir : trimmed.startsWith("~/") || trimmed.startsWith("~\\") ? join8(homeDir, trimmed.slice(2)) : trimmed;
+  return resolve5(isAbsolute3(expanded) ? expanded : join8(baseDir, expanded));
 }
 function skillPathStatus(dir) {
   try {
-    const stat2 = statSync4(dir);
+    const stat2 = statSync5(dir);
     if (!stat2.isDirectory()) return "not-directory";
     accessSync(dir, constants.R_OK);
     return "ok";
@@ -9203,20 +11215,20 @@ function sanitizeMemoryName(raw) {
   return trimmed;
 }
 function projectHash(rootDir) {
-  const abs = resolve5(rootDir);
+  const abs = resolve6(rootDir);
   return createHash2("sha1").update(abs).digest("hex").slice(0, 16);
 }
 function scopeDir(opts) {
   if (opts.scope === "global") {
-    return join8(opts.homeDir, USER_MEMORY_DIR, "global");
+    return join9(opts.homeDir, USER_MEMORY_DIR, "global");
   }
   if (!opts.projectRoot) {
     throw new Error("scope=project requires a projectRoot on MemoryStore");
   }
-  return join8(opts.homeDir, USER_MEMORY_DIR, projectHash(opts.projectRoot));
+  return join9(opts.homeDir, USER_MEMORY_DIR, projectHash(opts.projectRoot));
 }
 function ensureDir(p) {
-  if (!existsSync7(p)) mkdirSync4(p, { recursive: true });
+  if (!existsSync8(p)) mkdirSync5(p, { recursive: true });
 }
 function formatFrontmatter(e) {
   const lines = [
@@ -9252,8 +11264,8 @@ var MemoryStore = class {
   homeDir;
   projectRoot;
   constructor(opts = {}) {
-    this.homeDir = opts.homeDir ?? join8(homedir6(), ".reasonix");
-    this.projectRoot = opts.projectRoot ? resolve5(opts.projectRoot) : void 0;
+    this.homeDir = opts.homeDir ?? join9(homedir7(), ".reasonix");
+    this.projectRoot = opts.projectRoot ? resolve6(opts.projectRoot) : void 0;
   }
   /** Directory this store writes `scope` files into, creating it if needed. */
   dir(scope) {
@@ -9263,7 +11275,7 @@ var MemoryStore = class {
   }
   /** Absolute path to a memory file (no existence check). */
   pathFor(scope, name) {
-    return join8(this.dir(scope), `${sanitizeMemoryName(name)}.md`);
+    return join9(this.dir(scope), `${sanitizeMemoryName(name)}.md`);
   }
   /** True iff this store is configured with a project scope available. */
   hasProjectScope() {
@@ -9271,11 +11283,11 @@ var MemoryStore = class {
   }
   loadIndex(scope) {
     if (scope === "project" && !this.projectRoot) return null;
-    const file = join8(
+    const file = join9(
       scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot }),
       MEMORY_INDEX_FILE
     );
-    if (!existsSync7(file)) return null;
+    if (!existsSync8(file)) return null;
     let raw;
     try {
       raw = readFileSync9(file, "utf8");
@@ -9293,7 +11305,7 @@ var MemoryStore = class {
   /** Read one memory file's body (frontmatter stripped). Throws if missing. */
   read(scope, name) {
     const file = this.pathFor(scope, name);
-    if (!existsSync7(file)) {
+    if (!existsSync8(file)) {
       throw new Error(`memory not found: scope=${scope} name=${name}`);
     }
     const raw = readFileSync9(file, "utf8");
@@ -9318,10 +11330,10 @@ var MemoryStore = class {
     const scopes = this.projectRoot ? ["global", "project"] : ["global"];
     for (const scope of scopes) {
       const dir = scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot });
-      if (!existsSync7(dir)) continue;
+      if (!existsSync8(dir)) continue;
       let entries;
       try {
-        entries = readdirSync4(dir);
+        entries = readdirSync5(dir);
       } catch {
         continue;
       }
@@ -9356,10 +11368,10 @@ var MemoryStore = class {
     if (input.priority) entry.priority = input.priority;
     if (input.expires) entry.expires = input.expires;
     const dir = this.dir(input.scope);
-    const file = join8(dir, `${name}.md`);
+    const file = join9(dir, `${name}.md`);
     const content = `${formatFrontmatter(entry)}${body}
 `;
-    writeFileSync4(file, content, "utf8");
+    writeFileSync5(file, content, "utf8");
     this.regenerateIndex(input.scope);
     return file;
   }
@@ -9369,25 +11381,25 @@ var MemoryStore = class {
       throw new Error("cannot delete project-scoped memory: no projectRoot configured");
     }
     const file = this.pathFor(scope, rawName);
-    if (!existsSync7(file)) return false;
-    unlinkSync2(file);
+    if (!existsSync8(file)) return false;
+    unlinkSync3(file);
     this.regenerateIndex(scope);
     return true;
   }
   /** Sorted by name — same file set must produce byte-identical MEMORY.md for stable prefix hashing. */
   regenerateIndex(scope) {
     const dir = scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot });
-    if (!existsSync7(dir)) return;
+    if (!existsSync8(dir)) return;
     let files;
     try {
-      files = readdirSync4(dir);
+      files = readdirSync5(dir);
     } catch {
       return;
     }
     const mdFiles = files.filter((f) => f !== MEMORY_INDEX_FILE && f.endsWith(".md")).sort((a, b) => a.localeCompare(b));
-    const indexPath = join8(dir, MEMORY_INDEX_FILE);
+    const indexPath = join9(dir, MEMORY_INDEX_FILE);
     if (mdFiles.length === 0) {
-      if (existsSync7(indexPath)) unlinkSync2(indexPath);
+      if (existsSync8(indexPath)) unlinkSync3(indexPath);
       return;
     }
     const lines = [];
@@ -9400,13 +11412,13 @@ var MemoryStore = class {
         lines.push(`- [${name}](${name}.md) \u2014 (malformed, check frontmatter)`);
       }
     }
-    writeFileSync4(indexPath, `${lines.join("\n")}
+    writeFileSync5(indexPath, `${lines.join("\n")}
 `, "utf8");
   }
 };
-function readGlobalReasonixMemory(homeDir = join8(homedir6(), ".reasonix")) {
-  const path2 = join8(homeDir, "REASONIX.md");
-  if (!existsSync7(path2)) return null;
+function readGlobalReasonixMemory(homeDir = join9(homedir7(), ".reasonix")) {
+  const path2 = join9(homeDir, "REASONIX.md");
+  if (!existsSync8(path2)) return null;
   let raw;
   try {
     raw = readFileSync9(path2, "utf8");
@@ -9423,7 +11435,7 @@ function readGlobalReasonixMemory(homeDir = join8(homedir6(), ".reasonix")) {
 }
 function applyGlobalReasonixMemory(basePrompt, homeDir) {
   if (!memoryEnabled()) return basePrompt;
-  const dir = homeDir ?? join8(homedir6(), ".reasonix");
+  const dir = homeDir ?? join9(homedir7(), ".reasonix");
   const mem = readGlobalReasonixMemory(dir);
   if (!mem) return basePrompt;
   return [
@@ -9438,6 +11450,39 @@ function applyGlobalReasonixMemory(basePrompt, homeDir) {
     "```"
   ].join("\n");
 }
+function readGlobalClaudeMemory(homeDir = homedir7()) {
+  const path2 = join9(homeDir, ".claude", "CLAUDE.md");
+  if (!existsSync8(path2)) return null;
+  let raw;
+  try {
+    raw = readFileSync9(path2, "utf8");
+  } catch {
+    return null;
+  }
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  const originalChars = trimmed.length;
+  const truncated = originalChars > 8e3;
+  const content = truncated ? `${trimmed.slice(0, 8e3)}
+\u2026 (truncated ${originalChars - 8e3} chars)` : trimmed;
+  return { path: path2, content, originalChars, truncated };
+}
+function applyGlobalClaudeMemory(basePrompt) {
+  if (!memoryEnabled()) return basePrompt;
+  const mem = readGlobalClaudeMemory();
+  if (!mem) return basePrompt;
+  return [
+    basePrompt,
+    "",
+    "# Global memory (~/.claude/CLAUDE.md)",
+    "",
+    "Cross-project notes from your Claude Code configuration. Treat as authoritative \u2014 same level of trust as project memory.",
+    "",
+    "```",
+    mem.content,
+    "```"
+  ].join("\n");
+}
 function effectivePriority(entry, cfg) {
   if (entry.priority) return entry.priority;
   return memoryTypeDefaults(entry.type, cfg).priority;
@@ -9500,9 +11545,10 @@ function applyMemoryStack(basePrompt, rootDir, opts = {}) {
   const withProject = applyProjectMemory(basePrompt, rootDir);
   const withGlobal = applyGlobalReasonixMemory(
     withProject,
-    homeDir ? join8(homeDir, ".reasonix") : void 0
+    homeDir ? join9(homeDir, ".reasonix") : void 0
   );
-  const withMemory = applyUserMemory(withGlobal, { projectRoot: rootDir, homeDir, cfg });
+  const withGlobalClaude = applyGlobalClaudeMemory(withGlobal);
+  const withMemory = applyUserMemory(withGlobalClaude, { projectRoot: rootDir, homeDir, cfg });
   const customSkillPaths = cfg?.skills?.paths ? resolveSkillPaths(cfg.skills.paths, rootDir) : loadResolvedSkillPaths(rootDir);
   return applySkillsIndex(withMemory, { projectRoot: rootDir, homeDir, customSkillPaths });
 }
@@ -9513,7 +11559,7 @@ import * as pathMod6 from "path";
 import picomatch3 from "picomatch";
 
 // src/code/file-encoding.ts
-import { promises as fsp, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
+import { promises as fsp, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
 import iconv from "iconv-lite";
 var UTF8_BOM = Buffer.from([239, 187, 191]);
 function decodeFileBuffer(buf) {
@@ -9542,21 +11588,21 @@ function encodeFile(text, encoding) {
 }
 
 // src/memory/subdir.ts
-import { existsSync as existsSync8, readFileSync as readFileSync11 } from "fs";
-import { dirname as dirname5, join as join9, relative as relative2, resolve as resolve6 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync11 } from "fs";
+import { dirname as dirname5, join as join10, relative as relative3, resolve as resolve7 } from "path";
 function findDirMemory(absDir, rootDir) {
-  const root = resolve6(rootDir);
-  const target = resolve6(absDir);
-  const rel = relative2(root, target);
+  const root = resolve7(rootDir);
+  const target = resolve7(absDir);
+  const rel = relative3(root, target);
   if (rel.startsWith("..")) return [];
   const found = [];
   let cur = target;
   while (cur !== root) {
-    const r = relative2(root, cur);
+    const r = relative3(root, cur);
     if (!r || r.startsWith("..")) break;
     for (const name of PROJECT_MEMORY_FILES) {
-      const path2 = join9(cur, name);
-      if (existsSync8(path2)) {
+      const path2 = join10(cur, name);
+      if (existsSync9(path2)) {
         found.push(path2);
         break;
       }
@@ -9568,7 +11614,7 @@ function findDirMemory(absDir, rootDir) {
   return found;
 }
 function findSubdirMemoryAncestors(absPath, rootDir) {
-  return findDirMemory(dirname5(resolve6(absPath)), rootDir);
+  return findDirMemory(dirname5(resolve7(absPath)), rootDir);
 }
 function readSubdirMemoryContent(path2) {
   let raw;
@@ -10061,7 +12107,7 @@ var RegexRunner = class {
     this.defaultTimeoutMs = opts.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
   }
   testLines(text, source, flags, opts = {}) {
-    return new Promise((resolve15, reject) => {
+    return new Promise((resolve16, reject) => {
       if (opts.signal?.aborted) {
         reject(new Error("regex evaluation aborted"));
         return;
@@ -10074,7 +12120,7 @@ var RegexRunner = class {
         this.killWorker();
         reject(new Error(`regex evaluation exceeded ${timeoutMs}ms`));
       }, timeoutMs);
-      const entry = { resolve: resolve15, reject, timer };
+      const entry = { resolve: resolve16, reject, timer };
       if (opts.signal) {
         entry.signal = opts.signal;
         entry.onAbort = () => {
@@ -10205,6 +12251,7 @@ async function searchFiles(ctx, startAbs, args) {
 var MAX_HITS_PER_FILE = 30;
 var SUMMARY_MODE_TRIGGER_RATIO = 0.8;
 var WALK_DEADLINE_MS = 12e4;
+var REGEX_METACHARS = /[\\.+*?()[\]{}|^$]/;
 async function searchContent(ctx, startAbs, args) {
   throwIfAborted(args.signal);
   const caseSensitive = args.case_sensitive === true;
@@ -10212,12 +12259,15 @@ async function searchContent(ctx, startAbs, args) {
   const ctxLines = Math.max(0, Math.min(20, Math.floor(args.context ?? 0)));
   const summaryOnly = args.summary_only === true;
   const reFlags = caseSensitive ? "" : "i";
+  const hasMeta = REGEX_METACHARS.test(args.pattern);
   let reSource = null;
-  try {
-    new RegExp(args.pattern, reFlags);
-    reSource = args.pattern;
-  } catch {
-    reSource = null;
+  if (hasMeta) {
+    try {
+      new RegExp(args.pattern, reFlags);
+      reSource = args.pattern;
+    } catch {
+      reSource = null;
+    }
   }
   const needle = caseSensitive ? args.pattern : args.pattern.toLowerCase();
   const matches = [];
@@ -10306,9 +12356,10 @@ async function searchContent(ctx, startAbs, args) {
       if (firstNul !== -1 && firstNul < 8 * 1024) continue;
       const text = raw.toString("utf8");
       const rel = displayRel3(ctx.rootDir, full);
-      const lines = text.split(/\r?\n/);
       let hits;
+      let lines;
       if (reSource !== null) {
+        lines = text.split(/\r?\n/);
         try {
           hits = await getRegexRunner().testLines(text, reSource, reFlags, {
             signal: args.signal
@@ -10320,9 +12371,14 @@ async function searchContent(ctx, startAbs, args) {
           continue;
         }
       } else {
+        const haystack = caseSensitive ? text : text.toLowerCase();
+        if (haystack.indexOf(needle) === -1) {
+          scanned++;
+          continue;
+        }
+        lines = text.split(/\r?\n/);
         hits = [];
         for (let li = 0; li < lines.length; li++) {
-          throwIfAborted(args.signal);
           const lineForCheck = caseSensitive ? lines[li] : lines[li].toLowerCase();
           if (lineForCheck.includes(needle)) hits.push(li);
         }
@@ -10530,6 +12586,7 @@ ${body}`;
   registry.register({
     name: "read_file",
     parallelSafe: true,
+    skipTruncationSave: true,
     description: `Read a file under the sandbox root. Default returns FULL CONTENT for files \u2264 ${Math.round(DEFAULT_OUTLINE_THRESHOLD_BYTES / 1024)} KiB. Optional scoping: head/tail (N lines), range "A-B" (1-indexed inclusive). Larger files auto-switch to outline mode (metadata + head + symbol outline for TS/JS/Python/Go/Rust/Markdown/Protobuf/text) \u2014 drill in with range or search_content. Files over ${Math.round(HARD_MAX_FILE_BYTES / (1024 * 1024))} MiB and binaries are refused \u2014 use get_file_info for stat.`,
     readOnly: true,
     stormExempt: true,
@@ -10627,6 +12684,7 @@ ${slice.join("\n")}`);
   registry.register({
     name: "list_directory",
     parallelSafe: true,
+    skipTruncationSave: true,
     description: "List entries in a directory under the sandbox root. Returns one line per entry, marking directories with a trailing slash. Not recursive \u2014 use directory_tree for that.",
     readOnly: true,
     stormExempt: true,
@@ -10649,6 +12707,7 @@ ${slice.join("\n")}`);
   registry.register({
     name: "directory_tree",
     parallelSafe: true,
+    skipTruncationSave: true,
     description: `Recursively list entries with indented tree structure (dirs marked '/'). Budget-aware: maxDepth defaults to 2, large subtrees (>50 children) auto-collapse to "[N hidden \u2014 list_directory to inspect]", and ${[...SKIP_DIR_NAMES].sort().join(" / ")} are skipped unless include_deps:true. For single-level use list_directory; for path lookups use search_files; for code lookups use search_content.`,
     readOnly: true,
     parameters: {
@@ -10724,6 +12783,7 @@ ${slice.join("\n")}`);
   registry.register({
     name: "search_files",
     parallelSafe: true,
+    skipTruncationSave: true,
     description: "Find files whose NAME matches a substring or regex. Case-insensitive. Walks the directory recursively under the sandbox root. Returns one path per line. Skips dependency / VCS / build directories (node_modules, .git, dist, build, .next, target, .venv) by default.",
     readOnly: true,
     parameters: {
@@ -10750,6 +12810,7 @@ ${slice.join("\n")}`);
   registry.register({
     name: "search_content",
     parallelSafe: true,
+    skipTruncationSave: true,
     description: "Recursively grep file CONTENTS for a substring or regex \u2014 'where is X called', 'what files contain Y'. Returns one match per line as `path:line: text`. Per-file hit cap 30; when the byte budget is mostly spent, remaining files switch to a `rel: N matches` histogram. Pass `summary_only:true` for just the histogram. Skips dependency / VCS / build dirs and binary files. For file NAMES use search_files.",
     readOnly: true,
     parameters: {
@@ -10801,6 +12862,7 @@ ${slice.join("\n")}`);
   registry.register({
     name: "glob",
     parallelSafe: true,
+    skipTruncationSave: true,
     description: "List files matching a glob pattern, sorted by mtime (most-recently-modified first) by default. Use this for 'what changed lately', 'find all *.test.ts', 'all configs under src/'. Glob syntax matches the cross-tool standard: `*` (any chars in one segment), `**` (any segments), `?` (one char), `{a,b}` (alternation). Pattern matches against the path RELATIVE to the search root (e.g. 'src/**/*.ts' from project root). Skips node_modules / .git / dist / build / etc by default. Default limit 200; raise via `limit` (max 1000). Different from `search_files` (substring on basename) and `search_content` (matches inside file contents).",
     readOnly: true,
     parameters: {
@@ -10839,6 +12901,7 @@ ${slice.join("\n")}`);
   registry.register({
     name: "get_file_info",
     parallelSafe: true,
+    skipTruncationSave: true,
     description: "Stat a path under the sandbox root. Returns type (file|directory|symlink), size in bytes, mtime in ISO-8601.",
     readOnly: true,
     parameters: {
@@ -12512,16 +14575,16 @@ ${job.output.slice(start)}`;
     let wakeOutput = null;
     if (waitFor === "output-or-exit") {
       racers.push(
-        new Promise((resolve15) => {
-          wakeOutput = resolve15;
-          job.outputWaiters.add(resolve15);
+        new Promise((resolve16) => {
+          wakeOutput = resolve16;
+          job.outputWaiters.add(resolve16);
         })
       );
     }
     let timer = null;
     racers.push(
-      new Promise((resolve15) => {
-        timer = setTimeout(resolve15, timeoutMs);
+      new Promise((resolve16) => {
+        timer = setTimeout(resolve16, timeoutMs);
       })
     );
     await Promise.race(racers);
@@ -12643,7 +14706,7 @@ function latestOutputSince(before, after) {
 
 // src/tools/shell/exec.ts
 import { spawn as spawn4, spawnSync } from "child_process";
-import { existsSync as existsSync9, statSync as statSync5 } from "fs";
+import { existsSync as existsSync10, statSync as statSync6 } from "fs";
 import * as pathMod10 from "path";
 
 // src/tools/shell-chain.ts
@@ -13073,9 +15136,9 @@ async function runPipeGroup(segments, opts) {
     }
     const exits = await Promise.all(
       children.map(
-        (c) => new Promise((resolve15) => {
-          c.once("error", () => resolve15(null));
-          c.once("close", (code) => resolve15(code));
+        (c) => new Promise((resolve16) => {
+          c.once("error", () => resolve16(null));
+          c.once("close", (code) => resolve16(code));
         })
       )
     );
@@ -13119,7 +15182,7 @@ var OutputBuffer = class {
 };
 
 // src/tools/shell/parse.ts
-import { homedir as homedir7 } from "os";
+import { homedir as homedir8 } from "os";
 import * as pathMod9 from "path";
 var BUILTIN_ALLOWLIST = [
   // Repo inspection
@@ -13320,12 +15383,12 @@ function resolveSensitivePath(token, projectRoot) {
     return null;
   let expanded = token;
   if (expanded.startsWith("~")) {
-    expanded = pathMod9.join(homedir7(), expanded.slice(1));
+    expanded = pathMod9.join(homedir8(), expanded.slice(1));
   }
   return pathMod9.resolve(projectRoot, expanded);
 }
 function expandPrefix(prefix) {
-  if (prefix.startsWith("~")) return pathMod9.join(homedir7(), prefix.slice(1));
+  if (prefix.startsWith("~")) return pathMod9.join(homedir8(), prefix.slice(1));
   return pathMod9.resolve(prefix);
 }
 function pathStartsWithPrefix(normalized, prefix) {
@@ -13498,7 +15561,7 @@ async function runCommand(cmd, opts) {
   };
   const { bin, args, spawnOverrides } = prepareSpawn(argv, { env: normalizedEnv });
   const effectiveSpawnOpts = { ...spawnOpts, ...spawnOverrides };
-  return await new Promise((resolve15, reject) => {
+  return await new Promise((resolve16, reject) => {
     let child;
     try {
       child = spawn4(bin, args, effectiveSpawnOpts);
@@ -13552,7 +15615,7 @@ async function runCommand(cmd, opts) {
       const output = buf.length > maxChars ? `${buf.slice(0, maxChars)}
 
 [\u2026 truncated ${buf.length - maxChars} chars \u2026]` : buf;
-      resolve15({ exitCode: code, output, timedOut });
+      resolve16({ exitCode: code, output, timedOut });
     });
   });
 }
@@ -13637,7 +15700,7 @@ function mergeWindowsPathLike(values, delimiter2) {
 }
 function defaultIsFile(full) {
   try {
-    return existsSync9(full) && statSync5(full).isFile();
+    return existsSync10(full) && statSync6(full).isFile();
   } catch {
     return false;
   }
@@ -14676,11 +16739,11 @@ ${i + 1}. ${r.title}`);
 
 // src/env.ts
 import { readFileSync as readFileSync12 } from "fs";
-import { resolve as resolve12 } from "path";
+import { resolve as resolve13 } from "path";
 function loadDotenv(path2 = ".env") {
   let raw;
   try {
-    raw = readFileSync12(resolve12(process.cwd(), path2), "utf8");
+    raw = readFileSync12(resolve13(process.cwd(), path2), "utf8");
   } catch {
     return;
   }
@@ -15129,13 +17192,13 @@ function truncate(s, n) {
 }
 
 // src/mcp/client.ts
-import { basename as basename3, resolve as resolve13 } from "path";
+import { basename as basename3, resolve as resolve14 } from "path";
 import { pathToFileURL } from "url";
 
 // src/version.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync14, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir8 } from "os";
-import { dirname as dirname8, join as join14 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir9 } from "os";
+import { dirname as dirname8, join as join15 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var REGISTRY_URL = "https://registry.npmjs.org/reasonix/latest";
 var LATEST_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -15144,8 +17207,8 @@ function readPackageVersion() {
   try {
     let dir = dirname8(fileURLToPath2(import.meta.url));
     for (let i = 0; i < 6; i++) {
-      const p = join14(dir, "package.json");
-      if (existsSync10(p)) {
+      const p = join15(dir, "package.json");
+      if (existsSync11(p)) {
         const pkg = JSON.parse(readFileSync14(p, "utf8"));
         if (pkg?.name === "reasonix" && typeof pkg.version === "string") {
           return pkg.version;
@@ -15161,7 +17224,7 @@ function readPackageVersion() {
 }
 var VERSION = readPackageVersion();
 function cachePath(homeDirOverride) {
-  return join14(homeDirOverride ?? homedir8(), ".reasonix", "version-cache.json");
+  return join15(homeDirOverride ?? homedir9(), ".reasonix", "version-cache.json");
 }
 function readCache(homeDirOverride) {
   try {
@@ -15177,8 +17240,8 @@ function readCache(homeDirOverride) {
 function writeCache(entry, homeDirOverride) {
   try {
     const p = cachePath(homeDirOverride);
-    mkdirSync5(dirname8(p), { recursive: true });
-    writeFileSync6(p, JSON.stringify(entry), "utf8");
+    mkdirSync6(dirname8(p), { recursive: true });
+    writeFileSync7(p, JSON.stringify(entry), "utf8");
   } catch {
   }
 }
@@ -15285,7 +17348,7 @@ var McpClient = class {
     this.clientInfo = opts.clientInfo ?? { name: "reasonix", version: VERSION };
     const workspaceDir = opts.workspaceDir?.trim();
     if (workspaceDir) {
-      this.workspaceDir = resolve13(workspaceDir);
+      this.workspaceDir = resolve14(workspaceDir);
       this.workspaceRoot = {
         uri: pathToFileURL(this.workspaceDir).href,
         name: basename3(this.workspaceDir) || this.workspaceDir
@@ -15408,7 +17471,7 @@ var McpClient = class {
     const id = this.nextId++;
     const frame = { jsonrpc: "2.0", id, method, params };
     let abortHandler = null;
-    const promise = new Promise((resolve15, reject) => {
+    const promise = new Promise((resolve16, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
@@ -15417,7 +17480,7 @@ var McpClient = class {
         );
       }, this.requestTimeoutMs);
       this.pending.set(id, {
-        resolve: resolve15,
+        resolve: resolve16,
         reject,
         timeout
       });
@@ -15567,12 +17630,12 @@ var StdioTransport = class {
   }
   async send(message) {
     if (this.closed) throw new Error("MCP transport is closed");
-    return new Promise((resolve15, reject) => {
+    return new Promise((resolve16, reject) => {
       const line = `${JSON.stringify(message)}
 `;
       this.child.stdin.write(line, "utf8", (err) => {
         if (err) reject(err);
-        else resolve15();
+        else resolve16();
       });
     });
   }
@@ -15583,8 +17646,8 @@ var StdioTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve15) => {
-        this.waiters.push(resolve15);
+      const next = await new Promise((resolve16) => {
+        this.waiters.push(resolve16);
       });
       if (next === null) return;
       yield next;
@@ -15664,8 +17727,8 @@ var SseTransport = class {
   constructor(opts) {
     this.url = opts.url;
     this.headers = opts.headers ?? {};
-    this.endpointReady = new Promise((resolve15, reject) => {
-      this.resolveEndpoint = resolve15;
+    this.endpointReady = new Promise((resolve16, reject) => {
+      this.resolveEndpoint = resolve16;
       this.rejectEndpoint = reject;
     });
     this.endpointReady.catch(() => void 0);
@@ -15692,8 +17755,8 @@ var SseTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve15) => {
-        this.waiters.push(resolve15);
+      const next = await new Promise((resolve16) => {
+        this.waiters.push(resolve16);
       });
       if (next === null) return;
       yield next;
@@ -15879,8 +17942,8 @@ var StreamableHttpTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve15) => {
-        this.waiters.push(resolve15);
+      const next = await new Promise((resolve16) => {
+        this.waiters.push(resolve16);
       });
       if (next === null) return;
       yield next;
@@ -15972,19 +18035,22 @@ async function trySection(load) {
 
 // src/code/edit-blocks.ts
 import {
+  chmodSync as chmodSync4,
   closeSync as closeSync2,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   fstatSync,
-  ftruncateSync,
-  mkdirSync as mkdirSync6,
+  fsyncSync,
+  mkdirSync as mkdirSync7,
   openSync as openSync2,
   readFileSync as readFileSync15,
   readSync,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync7,
+  realpathSync as realpathSync2,
+  renameSync as renameSync3,
+  unlinkSync as unlinkSync4,
+  writeFileSync as writeFileSync8,
   writeSync
 } from "fs";
-import { dirname as dirname9, isAbsolute as isAbsolute9, relative as relative10, resolve as resolve14 } from "path";
+import { dirname as dirname9, isAbsolute as isAbsolute9, relative as relative11, resolve as resolve15 } from "path";
 var BLOCK_RE = /^(\S[^\n]*)\n<{7} SEARCH\n([\s\S]*?)\n?={7}\n([\s\S]*?)\n?>{7} REPLACE/gm;
 function parseEditBlocks(text) {
   const out = [];
@@ -16002,15 +18068,15 @@ function parseEditBlocks(text) {
   return out;
 }
 function resolveEditPath(rootDir, rawPath) {
-  const absRoot = resolve14(rootDir);
+  const absRoot = resolve15(rootDir);
   if (/^[A-Za-z]:[\\/]/.test(rawPath) || looksLikeAbsoluteSystemPath2(rawPath)) {
-    return resolve14(rawPath);
+    return resolve15(rawPath);
   }
   let rooted = rawPath;
   while (rooted.startsWith("/") || rooted.startsWith("\\")) {
     rooted = rooted.slice(1);
   }
-  return resolve14(absRoot, rooted || ".");
+  return resolve15(absRoot, rooted || ".");
 }
 function looksLikeAbsoluteSystemPath2(rawPath) {
   return /^\/(?:home|Users|etc|var|opt|tmp|usr|mnt|Library|Volumes|proc|sys|dev|run|srv|media|Applications|System|root|boot|private)(?:[/\\]|$)/.test(
@@ -16018,11 +18084,59 @@ function looksLikeAbsoluteSystemPath2(rawPath) {
   );
 }
 function pathIsUnder4(child, parent) {
-  const rel = relative10(parent, child);
+  const rel = relative11(parent, child);
   return rel === "" || !rel.startsWith("..") && !isAbsolute9(rel);
 }
+function writeAllSync(fd, buf) {
+  let written = 0;
+  while (written < buf.length) {
+    const n = writeSync(fd, buf, written, buf.length - written, written);
+    if (n <= 0) throw new Error("write returned 0 bytes before completing");
+    written += n;
+  }
+}
+function fsyncDirectoryBestEffort(path2) {
+  let fd;
+  try {
+    fd = openSync2(path2, "r");
+    fsyncSync(fd);
+  } catch {
+  } finally {
+    if (fd !== void 0) closeSync2(fd);
+  }
+}
+function atomicReplaceFileSync(path2, buf, mode) {
+  const tmp = `${path2}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  const permissions = mode & 4095;
+  let fd;
+  try {
+    fd = openSync2(tmp, "wx", permissions);
+    writeAllSync(fd, buf);
+    try {
+      chmodSync4(tmp, permissions);
+    } catch {
+    }
+    fsyncSync(fd);
+    closeSync2(fd);
+    fd = void 0;
+    renameSync3(tmp, path2);
+    fsyncDirectoryBestEffort(dirname9(path2));
+  } catch (err) {
+    if (fd !== void 0) {
+      try {
+        closeSync2(fd);
+      } catch {
+      }
+    }
+    try {
+      unlinkSync4(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
 function applyEditBlock(block, rootDir) {
-  const absRoot = resolve14(rootDir);
+  const absRoot = resolve15(rootDir);
   const absTarget = resolveEditPath(rootDir, block.path);
   if (!pathIsUnder4(absTarget, absRoot)) {
     return {
@@ -16034,7 +18148,7 @@ function applyEditBlock(block, rootDir) {
   const searchEmpty = block.search.length === 0;
   if (searchEmpty) {
     try {
-      mkdirSync6(dirname9(absTarget), { recursive: true });
+      mkdirSync7(dirname9(absTarget), { recursive: true });
       const fd = openSync2(absTarget, "wx");
       try {
         writeSync(fd, block.replace);
@@ -16055,9 +18169,22 @@ function applyEditBlock(block, rootDir) {
     }
   }
   try {
+    let writeTarget;
+    try {
+      writeTarget = realpathSync2(absTarget);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return {
+          path: block.path,
+          status: "file-missing",
+          message: "file does not exist; to create it, use an empty SEARCH block"
+        };
+      }
+      throw err;
+    }
     let fd;
     try {
-      fd = openSync2(absTarget, "r+");
+      fd = openSync2(writeTarget, "r+");
     } catch (err) {
       if (err.code === "ENOENT") {
         return {
@@ -16098,17 +18225,12 @@ function applyEditBlock(block, rootDir) {
         };
       }
       const replaced = `${content.slice(0, idx)}${adaptedReplace}${content.slice(idx + adaptedSearch.length)}`;
-      const outBuf = encodeFile(replaced, encoding);
-      ftruncateSync(fd, outBuf.length);
-      let written = 0;
-      while (written < outBuf.length) {
-        const n = writeSync(fd, outBuf, written, outBuf.length - written, written);
-        if (n <= 0) break;
-        written += n;
-      }
+      closeSync2(fd);
+      fd = void 0;
+      atomicReplaceFileSync(writeTarget, encodeFile(replaced, encoding), stat2.mode);
       return { path: block.path, status: "applied" };
     } finally {
-      closeSync2(fd);
+      if (fd !== void 0) closeSync2(fd);
     }
   } catch (err) {
     return { path: block.path, status: "error", message: err.message };
@@ -16118,7 +18240,7 @@ function applyEditBlocks(blocks, rootDir) {
   return blocks.map((b) => applyEditBlock(b, rootDir));
 }
 function snapshotBeforeEdits(blocks, rootDir) {
-  const absRoot = resolve14(rootDir);
+  const absRoot = resolve15(rootDir);
   const seen = /* @__PURE__ */ new Set();
   const snapshots = [];
   for (const b of blocks) {
@@ -16126,7 +18248,7 @@ function snapshotBeforeEdits(blocks, rootDir) {
     if (!pathIsUnder4(abs, absRoot)) continue;
     if (seen.has(abs)) continue;
     seen.add(abs);
-    if (!existsSync11(abs)) {
+    if (!existsSync12(abs)) {
       snapshots.push({ path: b.path, prevContent: null });
       continue;
     }
@@ -16140,7 +18262,7 @@ function snapshotBeforeEdits(blocks, rootDir) {
   return snapshots;
 }
 function restoreSnapshots(snapshots, rootDir) {
-  const absRoot = resolve14(rootDir);
+  const absRoot = resolve15(rootDir);
   return snapshots.map((snap) => {
     const abs = resolveEditPath(rootDir, snap.path);
     if (!pathIsUnder4(abs, absRoot)) {
@@ -16152,14 +18274,14 @@ function restoreSnapshots(snapshots, rootDir) {
     }
     try {
       if (snap.prevContent === null) {
-        if (existsSync11(abs)) unlinkSync3(abs);
+        if (existsSync12(abs)) unlinkSync4(abs);
         return {
           path: snap.path,
           status: "applied",
           message: "removed (the edit had created it)"
         };
       }
-      writeFileSync7(abs, encodeFile(snap.prevContent, snap.prevEncoding ?? "utf8"));
+      writeFileSync8(abs, encodeFile(snap.prevContent, snap.prevEncoding ?? "utf8"));
       return {
         path: snap.path,
         status: "applied",
@@ -16175,8 +18297,8 @@ function lineEndingOf(text) {
 }
 
 // src/code/prompt.ts
-import { existsSync as existsSync12, readFileSync as readFileSync16 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync16 } from "fs";
+import { join as join16 } from "path";
 var DEFAULT_CODE_MODEL = "deepseek-v4-flash";
 function codeSystemBase(modelId) {
   return CODE_SYSTEM_TEMPLATE.replace("__ESCALATION_CONTRACT__", escalationContract(modelId));
@@ -16305,9 +18427,9 @@ function codeSystemPrompt(rootDir, opts = {}) {
   const codeBase = codeSystemBase(opts.modelId ?? DEFAULT_CODE_MODEL);
   const base = opts.hasSemanticSearch ? `${codeBase}${SEMANTIC_SEARCH_ROUTING}` : codeBase;
   const withMemory = applyMemoryStack(base, rootDir);
-  const gitignorePath = join15(rootDir, ".gitignore");
+  const gitignorePath = join16(rootDir, ".gitignore");
   let result = withMemory;
-  if (existsSync12(gitignorePath)) {
+  if (existsSync13(gitignorePath)) {
     let content;
     try {
       content = readFileSync16(gitignorePath, "utf8");
@@ -16344,21 +18466,21 @@ ${appendParts.join("\n\n")}`;
 import {
   appendFileSync as appendFileSync2,
   closeSync as closeSync3,
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   fstatSync as fstatSync2,
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync8,
   openSync as openSync3,
   readFileSync as readFileSync17,
   readSync as readSync2,
-  renameSync as renameSync3,
-  statSync as statSync6,
-  unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync8
+  renameSync as renameSync4,
+  statSync as statSync7,
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync9
 } from "fs";
-import { homedir as homedir9 } from "os";
-import { dirname as dirname10, join as join16 } from "path";
+import { homedir as homedir10 } from "os";
+import { dirname as dirname10, join as join17 } from "path";
 function defaultUsageLogPath(homeDirOverride) {
-  return join16(homeDirOverride ?? homedir9(), ".reasonix", "usage.jsonl");
+  return join17(homeDirOverride ?? homedir10(), ".reasonix", "usage.jsonl");
 }
 var USAGE_COMPACTION_THRESHOLD_BYTES = 5 * 1024 * 1024;
 var USAGE_RETENTION_DAYS = 365;
@@ -16397,12 +18519,12 @@ function compactUsageLogIfLarge(path2, now) {
   if (kept.length === lines.filter((l) => l.trim()).length) return;
   const tmp = `${path2}.compacting`;
   try {
-    writeFileSync8(tmp, kept.length > 0 ? `${kept.join("\n")}
+    writeFileSync9(tmp, kept.length > 0 ? `${kept.join("\n")}
 ` : "", "utf8");
-    renameSync3(tmp, path2);
+    renameSync4(tmp, path2);
   } catch {
     try {
-      unlinkSync4(tmp);
+      unlinkSync5(tmp);
     } catch {
     }
   }
@@ -16423,7 +18545,7 @@ function appendUsage(input) {
   if (input.subagent) record.subagent = input.subagent;
   const path2 = input.path ?? defaultUsageLogPath();
   try {
-    mkdirSync7(dirname10(path2), { recursive: true });
+    mkdirSync8(dirname10(path2), { recursive: true });
     appendFileSync2(path2, `${JSON.stringify(record)}
 `, "utf8");
     compactUsageLogIfLarge(path2, record.ts);
@@ -16432,7 +18554,7 @@ function appendUsage(input) {
   return record;
 }
 function readUsageLog(path2 = defaultUsageLogPath()) {
-  if (!existsSync13(path2)) return [];
+  if (!existsSync14(path2)) return [];
   let raw;
   try {
     raw = readFileSync17(path2, "utf8");
@@ -16542,9 +18664,9 @@ function aggregateUsage(records, opts = {}) {
   };
 }
 function formatLogSize(path2 = defaultUsageLogPath()) {
-  if (!existsSync13(path2)) return "";
+  if (!existsSync14(path2)) return "";
   try {
-    const s = statSync6(path2);
+    const s = statSync7(path2);
     const bytes = s.size;
     if (bytes < 1024) return `${bytes} B`;
     if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;