diff --git a/.env.example b/.env.example
index e0a1ee0..76d8fea 100644
--- a/.env.example
+++ b/.env.example
@@ -60,7 +60,7 @@ FORENSIC_AUDIT_MAX_ENTRIES=50
 
 # === AI SEMANTIC SEARCH ===
 # Enable semantic search (highly recommended for better results)
-AI_EMBEDDINGS_ENABLED=true
+REMOVE_AI_EMBEDDINGS_ENABLED=true
 AI_EMBEDDINGS_ENDPOINT=https://api.mistral.ai/v1/embeddings
 AI_EMBEDDINGS_API_KEY=your-embeddings-api-key-here
 AI_EMBEDDINGS_MODEL=mistral-embed
@@ -122,8 +122,8 @@ AI_EMBEDDINGS_BATCH_SIZE=10
 AI_EMBEDDINGS_BATCH_DELAY_MS=1000
 
 # === Context Management ===
-AI_MAX_CONTEXT_TOKENS=4000
-AI_MAX_PROMPT_TOKENS=2500
+REMOVE_AI_MAX_CONTEXT_TOKENS=4000
+REMOVE_AI_MAX_PROMPT_TOKENS=2500
 
 # === Confidence Scoring ===
 CONFIDENCE_SEMANTIC_WEIGHT=0.5
diff --git a/find-duplicates.mjs b/find-duplicates.mjs
new file mode 100644
index 0000000..00dfa39
--- /dev/null
+++ b/find-duplicates.mjs
@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+// find-duplicate-functions.mjs
+// Usage:
+//   node find-duplicate-functions.mjs [rootDir] [--mode exact|struct] [--min-lines N] [--json]
+// Example:
+//   node find-duplicate-functions.mjs . --mode struct --min-lines 3
+
+import fs from "fs";
+import path from "path";
+import * as url from "url";
+import ts from "typescript";
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+
+/** -------- CLI OPTIONS -------- */
+const args = process.argv.slice(2);
+let rootDir = ".";
+let mode = "struct"; // "exact" | "struct"
+let minLines = 3;
+let outputJson = false;
+
+for (let i = 0; i < args.length; i++) {
+  const a = args[i];
+  if (!a.startsWith("--") && rootDir === ".") {
+    rootDir = a;
+  } else if (a === "--mode") {
+    mode = (args[++i] || "struct").toLowerCase();
+    if (!["exact", "struct"].includes(mode)) {
+      console.error("Invalid --mode. Use 'exact' or 'struct'.");
+      process.exit(1);
+    }
+  } else if (a === "--min-lines") {
+    minLines = parseInt(args[++i] || "3", 10);
+  } else if (a === "--json") {
+    outputJson = true;
+  }
+}
+
+/** -------- FILE DISCOVERY -------- */
+const DEFAULT_IGNORES = new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".vercel",
+  "dist",
+  "build",
+  ".astro", // Astro's generated cache dir
+]);
+
+const VALID_EXTS = new Set([".ts", ".tsx", ".astro", ".mts", ".cts"]);
+
+function walk(dir) {
+  /** @type {string[]} */
+  const out = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const e of entries) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) {
+      if (DEFAULT_IGNORES.has(e.name)) continue;
+      out.push(...walk(p));
+    } else if (e.isFile() && VALID_EXTS.has(path.extname(e.name))) {
+      out.push(p);
+    }
+  }
+  return out;
+}
+
+/** -------- ASTRO CODE EXTRACTION --------
+ * Extract TS/JS code from:
+ * - frontmatter: --- ... ---
+ * - <script ...> ... </script>
+ */
+function extractCodeFromAstro(source) {
+  /** @type {{code:string, offset:number}[]} */
+  const blocks = [];
+
+  // Frontmatter (must be at top in Astro)
+  // Match the FIRST pair of --- ... ---
+  const fm = source.startsWith("---")
+    ? (() => {
+        const end = source.indexOf("\n---", 3);
+        if (end !== -1) {
+          const front = source.slice(3, end + 1); // include trailing \n
+          return { start: 0, end: end + 4, code: front };
+        }
+        return null;
+      })()
+    : null;
+  if (fm) {
+    // offset for line numbers is after the first '---\n'
+    blocks.push({ code: fm.code, offset: 4 }); // rough; we’ll fix line numbers via positions later
+  }
+
+  // <script ...> ... </script>
+  const scriptRe = /<script\b[^>]*>([\s\S]*?)<\/script>/gi;
+  let m;
+  while ((m = scriptRe.exec(source))) {
+    const code = m[1] || "";
+    blocks.push({ code, offset: indexToLine(source, m.index) });
+  }
+
+  return blocks;
+}
+
+/** -------- UTIL: index -> 1-based line -------- */
+function indexToLine(text, idx) {
+  let line = 1;
+  for (let i = 0; i < idx && i < text.length; i++) {
+    if (text.charCodeAt(i) === 10) line++;
+  }
+  return line;
+}
+
+/** -------- AST HELPERS -------- */
+function createSourceFile(virtualPath, code) {
+  return ts.createSourceFile(
+    virtualPath,
+    code,
+    ts.ScriptTarget.Latest,
+    /*setParentNodes*/ true,
+    virtualPath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+}
+
+// Normalize AST to a structural signature string
+function structuralSignature(node) {
+  /** @type {string[]} */
+  const parts = [];
+  const visit = (n) => {
+    // Skip trivia: comments/whitespace are already not in AST
+    const kindName = ts.SyntaxKind[n.kind] || `K${n.kind}`;
+    switch (n.kind) {
+      case ts.SyntaxKind.Identifier:
+        parts.push("Id");
+        return;
+      case ts.SyntaxKind.PrivateIdentifier:
+        parts.push("PrivId");
+        return;
+      case ts.SyntaxKind.StringLiteral:
+      case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
+      case ts.SyntaxKind.TemplateHead:
+      case ts.SyntaxKind.TemplateMiddle:
+      case ts.SyntaxKind.TemplateTail:
+        parts.push("Str");
+        return;
+      case ts.SyntaxKind.NumericLiteral:
+        parts.push("Num");
+        return;
+      case ts.SyntaxKind.TrueKeyword:
+      case ts.SyntaxKind.FalseKeyword:
+        parts.push("Bool");
+        return;
+      case ts.SyntaxKind.NullKeyword:
+      case ts.SyntaxKind.UndefinedKeyword:
+        parts.push("Nil");
+        return;
+      case ts.SyntaxKind.PropertyAssignment:
+      case ts.SyntaxKind.ShorthandPropertyAssignment:
+      case ts.SyntaxKind.MethodDeclaration:
+      case ts.SyntaxKind.MethodSignature:
+        parts.push("Prop");
+        break;
+      default:
+        parts.push(kindName);
+    }
+    n.forEachChild(visit);
+  };
+  visit(node);
+  return parts.join("|");
+}
+
+function getFunctionInfo(sf, filePath) {
+  /** @type {Array<{
+    name: string,
+    bodyText: string,
+    structKey: string,
+    start: number,
+    end: number,
+    startLine: number,
+    endLine: number
+  }>} */
+  const out = [];
+
+  const addFunc = (nameNode, bodyNode) => {
+    if (!bodyNode) return;
+    const bodyText = bodyNode.getText(sf).trim();
+    const start = bodyNode.getStart(sf);
+    const end = bodyNode.getEnd();
+    const { line: startLine } = sf.getLineAndCharacterOfPosition(start);
+    const { line: endLine } = sf.getLineAndCharacterOfPosition(end);
+    const name =
+      nameNode && ts.isIdentifier(nameNode) ? nameNode.escapedText.toString() : "(anonymous)";
+
+    // min-lines filter
+    const lines = bodyText.split(/\r?\n/).filter(Boolean);
+    if (lines.length < minLines) return;
+
+    // structural signature from the body
+    const structKey = structuralSignature(bodyNode);
+
+    out.push({
+      name,
+      bodyText,
+      structKey,
+      start,
+      end,
+      startLine: startLine + 1,
+      endLine: endLine + 1,
+    });
+  };
+
+  const visit = (node) => {
+    if (ts.isFunctionDeclaration(node) && node.body) {
+      addFunc(node.name ?? null, node.body);
+    } else if (
+      ts.isFunctionExpression(node) ||
+      ts.isArrowFunction(node)
+    ) {
+      // find name if it’s assigned: const foo = () => {}
+      let name = null;
+      if (node.parent && ts.isVariableDeclaration(node.parent) && node.parent.name) {
+        name = node.parent.name;
+      } else if (
+        node.parent &&
+        ts.isPropertyAssignment(node.parent) &&
+        ts.isIdentifier(node.parent.name)
+      ) {
+        name = node.parent.name;
+      } else if (node.name) {
+        name = node.name;
+      }
+      if (node.body) addFunc(name, node.body);
+    } else if (ts.isMethodDeclaration(node) && node.body) {
+      addFunc(node.name, node.body);
+    }
+    node.forEachChild(visit);
+  };
+
+  visit(sf);
+  return out;
+}
+
+/** -------- MAIN SCAN -------- */
+const files = walk(path.resolve(process.cwd(), rootDir));
+
+/** Maps from hash -> occurrences */
+const groups = new Map();
+/** Helper for exact hash */
+import crypto from "crypto";
+const exactHash = (text) => crypto.createHash("sha1").update(text.replace(/\s+/g, " ").trim()).digest("hex");
+
+for (const file of files) {
+  try {
+    const ext = path.extname(file).toLowerCase();
+    const raw = fs.readFileSync(file, "utf8");
+
+    /** @type {Array<{virtualPath:string, code:string, lineOffset:number}>} */
+    const codeUnits = [];
+
+    if (ext === ".astro") {
+      const blocks = extractCodeFromAstro(raw);
+      blocks.forEach((b, i) => {
+        codeUnits.push({
+          virtualPath: file + `#astro${i + 1}.ts`,
+          code: b.code,
+          lineOffset: b.offset || 1,
+        });
+      });
+    } else {
+      codeUnits.push({ virtualPath: file, code: raw, lineOffset: 1 });
+    }
+
+    for (const { virtualPath, code, lineOffset } of codeUnits) {
+      const sf = createSourceFile(virtualPath, code);
+      const funcs = getFunctionInfo(sf, file);
+      for (const f of funcs) {
+        const key =
+          mode === "exact" ? exactHash(f.bodyText) : crypto.createHash("sha1").update(f.structKey).digest("hex");
+        const item = {
+          file,
+          where:
+            ext === ".astro"
+              ? `${path.relative(process.cwd(), file)}:${f.startLine + lineOffset - 1}-${f.endLine + lineOffset - 1}`
+              : `${path.relative(process.cwd(), file)}:${f.startLine}-${f.endLine}`,
+          name: f.name,
+          lines: f.endLine - f.startLine + 1,
+          preview: f.bodyText.split(/\r?\n/).slice(0, 5).join("\n") + (f.endLine - f.startLine + 1 > 5 ? "\n..." : ""),
+        };
+        if (!groups.has(key)) groups.set(key, []);
+        groups.get(key).push(item);
+      }
+    }
+  } catch (e) {
+    console.warn(`⚠️ Skipping ${file}: ${e.message}`);
+  }
+}
+
+/** -------- REPORT -------- */
+const dupes = [...groups.entries()]
+  .map(([key, arr]) => ({ key, items: arr }))
+  .filter((g) => g.items.length > 1)
+  .sort((a, b) => b.items.length - a.items.length);
+
+if (outputJson) {
+  console.log(JSON.stringify({ mode, minLines, groups: dupes }, null, 2));
+  process.exit(0);
+}
+
+if (dupes.length === 0) {
+  console.log(`✅ No duplicate functions found (mode=${mode}, min-lines=${minLines}).`);
+  process.exit(0);
+}
+
+console.log(`\nFound ${dupes.length} duplicate group(s) (mode=${mode}, min-lines=${minLines}):\n`);
+dupes.forEach((g, i) => {
+  console.log(`== Group ${i + 1} (${g.items.length} matches) ==`);
+  const example = g.items[0];
+  console.log(`   Sample (${example.lines} lines) from ${example.where}${example.name ? ` [${example.name}]` : ""}`);
+  console.log("   ---");
+  console.log(indent(example.preview, "   "));
+  console.log("   ---");
+  g.items.forEach((it) => {
+    console.log(` • ${it.where}${it.name ? ` [${it.name}]` : ""} (${it.lines} lines)`);
+  });
+  console.log();
+});
+
+function indent(s, pre) {
+  return s
+    .split("\n")
+    .map((l) => pre + l)
+    .join("\n");
+}
diff --git a/src/components/AIQueryInterface.astro b/src/components/AIQueryInterface.astro
index b513a6c..3053541 100644
--- a/src/components/AIQueryInterface.astro
+++ b/src/components/AIQueryInterface.astro
@@ -12,20 +12,20 @@ const domainAgnosticSoftware = data['domain-agnostic-software'] || [];
 <section id="ai-interface" class="ai-interface hidden">
   <div class="ai-query-section">
     <div class="content-center-lg">
-      <h2 style="margin-bottom: 1rem; color: var(--color-primary);">
-        <svg width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" style="margin-right: 0.75rem; vertical-align: middle;">
+      <h2 class="mb-4 text-primary">
+        <svg width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" class="mr-3 align-middle">
           <path d="M9 11H5a2 2 0 0 0-2 2v7a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7a2 2 0 0 0-2-2h-4"/>
           <path d="M9 11V7a3 3 0 0 1 6 0v4"/>
         </svg>
         Forensic AI
       </h2>
-      <p id="ai-description" class="text-muted" style="max-width: 700px; margin: 0 auto; line-height: 1.6;">
+      <p id="ai-description" class="text-muted mx-auto leading-relaxed max-w-lg">
         Beschreiben Sie Ihr forensisches Szenario und erhalten Sie maßgeschneiderte Workflow-Empfehlungen 
         basierend auf bewährten DFIR-Workflows und der verfügbaren Software-Datenbank.
       </p>
     </div>
 
-    <div class="ai-input-container" style="max-width: 1000px; margin: 0 auto;">
+    <div class="ai-input-container mx-auto max-w-6xl">
       <!-- Mode Toggle -->
       <div class="ai-mode-toggle">
         <span id="workflow-label" class="toggle-label active">
@@ -54,10 +54,9 @@ const domainAgnosticSoftware = data['domain-agnostic-software'] || [];
           <textarea 
             id="ai-query-input" 
             placeholder="Beschreiben Sie Ihr forensisches Szenario..."
-            style="min-height: 220px; resize: vertical; font-size: 0.9375rem; line-height: 1.5;"
             maxlength="2000"
           ></textarea>
-          <div id="ai-char-counter" style="font-size: 0.75rem; color: var(--color-text-secondary); text-align: right; margin-top: 0.25rem;">0/2000</div>
+          <div id="ai-char-counter" class="text-xs text-secondary text-right mt-1">0/2000</div>
         </div>
         
         <div class="ai-suggestions-section">
@@ -113,35 +112,63 @@ const domainAgnosticSoftware = data['domain-agnostic-software'] || [];
       </div>
       
       <!-- Privacy Notice -->
-      <div style="margin-top: 0.5rem; margin-bottom: 1rem;">
-        <p style="font-size: 0.75rem; color: var(--color-text-secondary); text-align: center; line-height: 1.4;">
-          <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" style="margin-right: 0.25rem; vertical-align: middle;">
+      <div class="mt-2 mb-4">
+        <p class="text-xs text-secondary text-center leading-normal">
+          <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" class="mr-1 align-middle">
             <circle cx="12" cy="12" r="10"/>
             <line x1="12" y1="8" x2="12" y2="12"/>
             <line x1="12" y1="16" x2="12.01" y2="16"/>
           </svg>
           Ihre Anfrage wird über die API von mistral.ai übertragen.
-          <a href="https://mistral.ai/privacy-policy/" target="_blank" rel="noopener noreferrer" style="color: var(--color-primary);">Datenschutzrichtlinien</a>
+          <a href="https://mistral.ai/privacy-policy/" target="_blank" rel="noopener noreferrer" class="text-primary">Datenschutzrichtlinien</a>
         </p>
       </div>
+
+      <div class="ai-restore-section">
+        <div class="flex items-center justify-center gap-4 p-3 bg-secondary border rounded-lg">
+          <div class="flex items-center gap-2 text-secondary text-sm">
+            <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+              <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
+              <polyline points="17 8 12 3 7 8"/>
+              <line x1="12" y1="3" x2="12" y2="15"/>
+            </svg>
+            Vorherige Analyse wiederherstellen:
+          </div>
+          
+          <label for="upload-previous-analysis" class="btn btn-secondary btn-sm">
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" class="mr-2">
+              <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
+              <polyline points="14 2 14 8 20 8"/>
+              <path d="M16 13H8"/>
+              <path d="M16 17H8"/>
+              <path d="M10 9H8"/>
+            </svg>
+            JSON-Datei hochladen
+            <input type="file" id="upload-previous-analysis" accept=".json" class="hidden" />
+          </label>
+        </div>
+        
+        <div class="mt-2 text-xs text-secondary text-center">
+          Laden Sie eine zuvor heruntergeladene Analyse-Datei, um Ergebnisse und Audit-Trail anzuzeigen
+        </div>
+      </div>
       
       <!-- Submit Button -->
-      <div style="display: flex; justify-content: center; gap: 1rem;">
-        <button id="ai-submit-btn" class="btn btn-accent" style="padding: 0.75rem 2rem;">
-          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" style="margin-right: 0.5rem;">
+      <div class="flex justify-center gap-4 mt-4">
+        <button id="ai-submit-btn" class="btn btn-accent btn-lg">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" class="mr-2">
             <path d="M14.828 14.828a4 4 0 0 1-5.656 0"/>
             <path d="M9 9a3 3 0 1 1 6 0c0 .749-.269 1.433-.73 1.96L11 14v1a1 1 0 0 1-1 1h-1a1 1 0 0 1-1-1v-1l-3.27-3.04A3 3 0 0 1 5 9a3 3 0 0 1 6 0"/>
           </svg>
           <span id="submit-btn-text">Empfehlungen generieren</span>
         </button>
       </div>
-    </div>
 
     <!-- Loading State -->
     <div id="ai-loading" class="ai-loading hidden">
-      <div style="text-align: center; padding: 2rem;">
-        <div style="margin-bottom: 1rem;">
-          <svg width="32" height="32" viewBox="0 0 24 24" fill="none" stroke="var(--color-primary)" stroke-width="2" style="animation: pulse 2s ease-in-out infinite;">
+      <div class="text-center p-8">
+        <div class="mb-4">
+          <svg width="32" height="32" viewBox="0 0 24 24" fill="none" stroke="var(--color-primary)" stroke-width="2" class="ai-pulse-icon">
             <path d="M14.828 14.828a4 4 0 0 1-5.656 0"/>
             <path d="M9 9a3 3 0 1 1 6 0c0 .749-.269 1.433-.73 1.96L11 14v1a1 1 0 0 1-1 1h-1a1 1 0 0 1-1-1v-1l-3.27-3.04A3 3 0 0 1 5 9a3 3 0 0 1 6 0"/>
           </svg>
@@ -199,10 +226,10 @@ const domainAgnosticSoftware = data['domain-agnostic-software'] || [];
 
     <!-- Error State -->
     <div id="ai-error" class="ai-error hidden">
-      <div style="text-align: center; padding: 2rem;">
-        <div style="background-color: var(--color-error); color: white; padding: 1rem; border-radius: 0.5rem; max-width: 600px; margin: 0 auto;">
-          <h3 style="margin-bottom: 0.5rem;">Fehler bei der KI-Anfrage</h3>
-          <p id="ai-error-message" style="margin: 0;">Ein unerwarteter Fehler ist aufgetreten.</p>
+      <div class="text-center p-8">
+        <div class="bg-error text-white p-4 rounded-lg max-w-6xl mx-auto">
+          <h3 class="mb-2">Fehler bei der KI-Anfrage</h3>
+          <p id="ai-error-message" class="mb-0">Ein unerwarteter Fehler ist aufgetreten.</p>
         </div>
       </div>
     </div>
@@ -216,6 +243,94 @@ const domainAgnosticSoftware = data['domain-agnostic-software'] || [];
 
 <script type="module" define:vars={{ tools, phases, domainAgnosticSoftware }}>
 
+function showElement(element) {
+  if (element) {
+    element.style.display = 'block';
+    element.classList.remove('hidden');
+  }
+}
+
+function hideElement(element) {
+  if (element) {
+    element.style.display = 'none';
+    element.classList.add('hidden');
+  }
+}
+
+function sanitizeText(text) {
+  if (typeof text !== 'string') return '';
+  
+  return text
+    .replace(/^#{1,6}\s+/gm, '')
+    .replace(/^\s*[-*+]\s+/gm, '')
+    .replace(/^\s*\d+\.\s+/gm, '')
+    .replace(/\*\*(.+?)\*\*/g, '$1')
+    .replace(/\*(.+?)\*/g, '$1')
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+    .replace(/```[\s\S]*?```/g, '[CODE BLOCK]')
+    .replace(/`([^`]+)`/g, '$1')
+    .replace(/<[^>]+>/g, '')
+    .replace(/\n\s*\n\s*\n/g, '\n\n')
+    .trim();
+}
+
+function escapeHtml(text) {
+  if (typeof text !== 'string') return String(text);
+  const div = document.createElement('div');
+  div.textContent = text;
+  return div.innerHTML;
+}
+
+function truncateText(text, maxLength) {
+  if (!text || text.length <= maxLength) return text;
+  return text.slice(0, maxLength) + '...';
+}
+
+function formatDuration(ms) {
+  if (ms < 1000) return '< 1s';
+  if (ms < 60000) return `${Math.ceil(ms / 1000)}s`;
+  const minutes = Math.floor(ms / 60000);
+  const seconds = Math.ceil((ms % 60000) / 1000);
+  return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+}
+
+function getConfidenceColor(confidence) {
+  if (confidence >= 80) return 'var(--color-accent)';
+  if (confidence >= 60) return 'var(--color-warning)';
+  return 'var(--color-error)';
+}
+
+function isToolHosted(tool) {
+  return tool.projectUrl !== undefined && 
+         tool.projectUrl !== null && 
+         tool.projectUrl !== "" && 
+         tool.projectUrl.trim() !== "";
+}
+
+function summarizeData(data) {
+  if (data === null || data === undefined) return 'null';
+  if (typeof data === 'string') {
+    return data.length > 100 ? data.slice(0, 100) + '...' : data;
+  }
+  if (typeof data === 'number' || typeof data === 'boolean') {
+    return data.toString();
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) return '[]';
+    if (data.length <= 3) return JSON.stringify(data);
+    return `[${data.slice(0, 3).map(i => typeof i === 'string' ? i : JSON.stringify(i)).join(', ')}, ...+${data.length - 3}]`;
+  }
+  if (typeof data === 'object') {
+    const keys = Object.keys(data);
+    if (keys.length === 0) return '{}';
+    if (keys.length <= 3) {
+      return '{' + keys.map(k => `${k}: ${typeof data[k] === 'string' ? data[k].slice(0, 20) + (data[k].length > 20 ? '...' : '') : JSON.stringify(data[k])}`).join(', ') + '}';
+    }
+    return `{${keys.slice(0, 3).join(', ')}, ...+${keys.length - 3} keys}`;
+  }
+  return String(data);
+}
+
 const Utils = {
   phaseConfig: {
     'initialization': { icon: '🚀', displayName: 'Initialisierung' },
@@ -240,517 +355,9 @@ const Utils = {
 
   getActionDisplayName(action) {
     return this.actionTranslations[action] || action;
-  },
-
-  formatDuration(ms) {
-    if (ms < 1000) return '< 1s';
-    if (ms < 60000) return `${Math.ceil(ms / 1000)}s`;
-    const minutes = Math.floor(ms / 60000);
-    const seconds = Math.ceil((ms % 60000) / 1000);
-    return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
-  },
-
-  getConfidenceColor(confidence) {
-    if (confidence >= 80) return 'var(--color-accent)';
-    if (confidence >= 60) return 'var(--color-warning)';
-    return 'var(--color-error)';
-  },
-
-  escapeHtml(text) {
-    if (typeof text !== 'string') return String(text);
-    const div = document.createElement('div');
-    div.textContent = text;
-    return div.innerHTML;
-  },
-
-  truncateText(text, maxLength) {
-    if (!text || text.length <= maxLength) return text;
-    return text.slice(0, maxLength) + '...';
-  },
-
-  sanitizeText(text) {
-    if (typeof text !== 'string') return '';
-    
-    return text
-      .replace(/^#{1,6}\s+/gm, '')
-      .replace(/^\s*[-*+]\s+/gm, '')
-      .replace(/^\s*\d+\.\s+/gm, '')
-      .replace(/\*\*(.+?)\*\*/g, '$1')
-      .replace(/\*(.+?)\*/g, '$1')
-      .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
-      .replace(/```[\s\S]*?```/g, '[CODE BLOCK]')
-      .replace(/`([^`]+)`/g, '$1')
-      .replace(/<[^>]+>/g, '')
-      .replace(/\n\s*\n\s*\n/g, '\n\n')
-      .trim();
-  },
-
-  summarizeData(data) {
-    if (data === null || data === undefined) return 'null';
-    if (typeof data === 'string') {
-      return data.length > 100 ? data.slice(0, 100) + '...' : data;
-    }
-    if (typeof data === 'number' || typeof data === 'boolean') {
-      return data.toString();
-    }
-    if (Array.isArray(data)) {
-      if (data.length === 0) return '[]';
-      if (data.length <= 3) return JSON.stringify(data);
-      return `[${data.slice(0, 3).map(i => typeof i === 'string' ? i : JSON.stringify(i)).join(', ')}, ...+${data.length - 3}]`;
-    }
-    if (typeof data === 'object') {
-      const keys = Object.keys(data);
-      if (keys.length === 0) return '{}';
-      if (keys.length <= 3) {
-        return '{' + keys.map(k => `${k}: ${typeof data[k] === 'string' ? data[k].slice(0, 20) + (data[k].length > 20 ? '...' : '') : JSON.stringify(data[k])}`).join(', ') + '}';
-      }
-      return `{${keys.slice(0, 3).join(', ')}, ...+${keys.length - 3} keys}`;
-    }
-    return String(data);
-  },
-
-  showElement(element) {
-    if (element) {
-      element.style.display = 'block';
-      element.classList.remove('hidden');
-    }
-  },
-
-  hideElement(element) {
-    if (element) {
-      element.style.display = 'none';
-      element.classList.add('hidden');
-    }
   }
 };
 
-class AuditTrailProcessor {
-  static processAuditTrail(rawAuditTrail) {
-    if (!rawAuditTrail || !Array.isArray(rawAuditTrail) || rawAuditTrail.length === 0) {
-      console.log('[AUDIT] No audit trail data provided');
-      return null;
-    }
-
-    try {
-      console.log('[AUDIT] Processing', rawAuditTrail.length, 'audit entries');
-
-      const totalTime = rawAuditTrail.reduce((sum, entry) => sum + (entry.processingTimeMs || 0), 0);
-      const validConfidenceEntries = rawAuditTrail.filter(entry => typeof entry.confidence === 'number');
-      const avgConfidence = validConfidenceEntries.length > 0 
-        ? Math.round(validConfidenceEntries.reduce((sum, entry) => sum + entry.confidence, 0) / validConfidenceEntries.length)
-        : 0;
-      
-      const highConfidenceSteps = rawAuditTrail.filter(entry => (entry.confidence || 0) >= 80).length;
-      const lowConfidenceSteps = rawAuditTrail.filter(entry => (entry.confidence || 0) < 60).length;
-
-      const groupedEntries = rawAuditTrail.reduce((groups, entry) => {
-        const phase = entry.phase || 'unknown';
-        if (!groups[phase]) groups[phase] = [];
-        groups[phase].push(entry);
-        return groups;
-      }, {});
-
-      const phases = Object.entries(groupedEntries).map(([phase, entries]) => {
-        const phaseConfig = Utils.phaseConfig[phase] || { icon: '📋', displayName: phase };
-        const validEntries = entries.filter(entry => entry && typeof entry === 'object');
-        
-        const phaseAvgConfidence = validEntries.length > 0 
-          ? Math.round(validEntries.reduce((sum, entry) => sum + (entry.confidence || 0), 0) / validEntries.length)
-          : 0;
-        
-        const phaseTotalTime = validEntries.reduce((sum, entry) => sum + (entry.processingTimeMs || 0), 0);
-
-        return {
-          name: phase,
-          icon: phaseConfig.icon,
-          displayName: phaseConfig.displayName,
-          avgConfidence: phaseAvgConfidence,
-          totalTime: phaseTotalTime,
-          entries: validEntries.map(e => this.compressEntry(e)).filter(e => e !== null)
-        };
-      }).filter(phase => phase.entries.length > 0);
-
-      return {
-        totalTime,
-        avgConfidence,
-        stepCount: rawAuditTrail.length,
-        highConfidenceSteps,
-        lowConfidenceSteps,
-        phases,
-        summary: this.generateSummary(rawAuditTrail, avgConfidence, lowConfidenceSteps)
-      };
-      
-    } catch (error) {
-      console.error('[AUDIT] Error processing audit trail:', error);
-      return null;
-    }
-  }
-
-  static compressEntry(entry) {
-    if (!entry || typeof entry !== 'object') {
-      console.warn('[AUDIT] Invalid audit entry:', entry);
-      return null;
-    }
-
-    try {
-      return {
-        timestamp: entry.timestamp || Date.now(),
-        phase: entry.phase || 'unknown',
-        action: entry.action || 'unknown',
-        inputSummary: Utils.summarizeData(entry.input),
-        outputSummary: Utils.summarizeData(entry.output),
-        confidence: entry.confidence || 0,
-        processingTimeMs: entry.processingTimeMs || 0,
-        metadata: entry.metadata || {}
-      };
-    } catch (error) {
-      console.error('[AUDIT] Error compressing entry:', error);
-      return null;
-    }
-  }
-
-  static generateSummary(entries, avgConfidence, lowConfidenceSteps) {
-    let analysisQuality;
-    if (avgConfidence >= 85 && lowConfidenceSteps === 0) {
-      analysisQuality = 'excellent';
-    } else if (avgConfidence >= 70 && lowConfidenceSteps <= 1) {
-      analysisQuality = 'good';
-    } else if (avgConfidence >= 60 && lowConfidenceSteps <= 3) {
-      analysisQuality = 'fair';
-    } else {
-      analysisQuality = 'poor';
-    }
-
-    const keyInsights = [];
-    const embeddingsUsed = entries.some(e => e.action === 'embeddings-search');
-    if (embeddingsUsed) {
-      keyInsights.push('Semantische Suche wurde erfolgreich eingesetzt');
-    }
-
-    const toolSelectionEntries = entries.filter(e => e.action === 'ai-tool-selection');
-    if (toolSelectionEntries.length > 0) {
-      const avgSelectionConfidence = toolSelectionEntries.reduce((sum, e) => sum + e.confidence, 0) / toolSelectionEntries.length;
-      if (avgSelectionConfidence >= 80) {
-        keyInsights.push('Hohe Konfidenz bei der Tool-Auswahl');
-      }
-    }
-
-    const potentialIssues = [];
-    if (lowConfidenceSteps > 2) {
-      potentialIssues.push(`${lowConfidenceSteps} Analyseschritte mit niedriger Konfidenz`);
-    }
-
-    const longSteps = entries.filter(e => e.processingTimeMs > 5000);
-    if (longSteps.length > 0) {
-      potentialIssues.push(`${longSteps.length} Schritte benötigten mehr als 5 Sekunden`);
-    }
-
-    return { analysisQuality, keyInsights, potentialIssues };
-  }
-}
-
-class AuditTrailRenderer {
-  constructor(containerId, options = {}) {
-    this.containerId = containerId;
-    this.options = {
-      title: options.title || 'KI-Entscheidungspfad',
-      collapsible: options.collapsible !== false,
-      defaultExpanded: options.defaultExpanded || false,
-      ...options
-    };
-    this.componentId = `audit-trail-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`;
-  }
-
-  render(rawAuditTrail) {
-    const container = document.getElementById(this.containerId);
-    if (!container) {
-      console.error(`[AUDIT RENDERER] Container ${this.containerId} not found`);
-      return;
-    }
-
-    if (!rawAuditTrail || !Array.isArray(rawAuditTrail) || rawAuditTrail.length === 0) {
-      this.renderEmpty(container);
-      return;
-    }
-
-    try {
-      const processedAudit = AuditTrailProcessor.processAuditTrail(rawAuditTrail);
-      
-      if (processedAudit && processedAudit.phases && processedAudit.phases.length > 0) {
-        this.renderProcessed(container, processedAudit);
-        setTimeout(() => this.attachEventHandlers(), 0);
-      } else {
-        this.renderEmpty(container);
-      }
-    } catch (error) {
-      console.error('[AUDIT RENDERER] Failed to render audit trail:', error);
-      this.renderError(container, error);
-    }
-  }
-
-  renderProcessed(container, processedAudit) {
-    const detailsId = `${this.componentId}-details`;
-    
-    container.innerHTML = `
-      <div class="audit-trail-container">
-        <div class="audit-trail-header ${this.options.collapsible ? 'clickable' : ''}" 
-             ${this.options.collapsible ? `data-target="${detailsId}"` : ''}>
-          <div class="audit-trail-title">
-            <div class="audit-icon">
-              <div class="audit-icon-gradient">✓</div>
-              <h4>${this.options.title}</h4>
-            </div>
-            
-            <div class="audit-stats">
-              <div class="stat-item">
-                <div class="stat-dot stat-time"></div>
-                <span>${Utils.formatDuration(processedAudit.totalTime)}</span>
-              </div>
-              <div class="stat-item">
-                <div class="stat-dot" style="background-color: ${Utils.getConfidenceColor(processedAudit.avgConfidence)}"></div>
-                <span>${processedAudit.avgConfidence}% Vertrauen</span>
-              </div>
-              <div class="stat-item">
-                <span>${processedAudit.stepCount} Schritte</span>
-              </div>
-            </div>
-          </div>
-          
-          ${this.options.collapsible ? `
-            <div class="toggle-icon">
-              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-                <polyline points="6 9 12 15 18 9"/>
-              </svg>
-            </div>
-          ` : ''}
-        </div>
-        
-        <div id="${detailsId}" class="audit-trail-details ${this.options.collapsible && !this.options.defaultExpanded ? 'collapsed' : ''}">
-          ${this.renderSummary(processedAudit)}
-          ${this.renderProcessFlow(processedAudit)}
-          ${this.renderTechnicalDetails(processedAudit)}
-        </div>
-      </div>
-    `;
-  }
-
-  renderSummary(audit) {
-    return `
-      <div class="audit-summary">
-        <div class="summary-header">📊 Analyse-Qualität</div>
-        <div class="summary-grid">
-          <div class="summary-stat">
-            <div class="summary-value success">${audit.highConfidenceSteps}</div>
-            <div class="summary-label">Hohe Sicherheit</div>
-          </div>
-          <div class="summary-stat">
-            <div class="summary-value ${audit.lowConfidenceSteps > 0 ? 'warning' : 'success'}">
-              ${audit.lowConfidenceSteps}
-            </div>
-            <div class="summary-label">Unsichere Schritte</div>
-          </div>
-          <div class="summary-stat">
-            <div class="summary-value">${Utils.formatDuration(audit.totalTime)}</div>
-            <div class="summary-label">Verarbeitungszeit</div>
-          </div>
-        </div>
-        
-        ${audit.summary.keyInsights && audit.summary.keyInsights.length > 0 ? `
-          <div class="insights-section">
-            <div class="insights-header success">✓ Erkenntnisse:</div>
-            <ul class="insights-list">
-              ${audit.summary.keyInsights.map(insight => `<li>${Utils.escapeHtml(insight)}</li>`).join('')}
-            </ul>
-          </div>
-        ` : ''}
-        
-        ${audit.summary.potentialIssues && audit.summary.potentialIssues.length > 0 ? `
-          <div class="insights-section">
-            <div class="insights-header warning">⚠ Hinweise:</div>
-            <ul class="insights-list">
-              ${audit.summary.potentialIssues.map(issue => `<li>${Utils.escapeHtml(issue)}</li>`).join('')}
-            </ul>
-          </div>
-        ` : ''}
-      </div>
-    `;
-  }
-
-  renderProcessFlow(audit) {
-    if (!audit.phases || audit.phases.length === 0) {
-      return '<div class="audit-process-flow"><p>Keine Phasen verfügbar</p></div>';
-    }
-
-    return `
-      <div class="audit-process-flow">
-        ${audit.phases.map((phase, index) => `
-          <div class="phase-group ${index === audit.phases.length - 1 ? 'last-phase' : ''}">
-            <div class="phase-header" style="display: flex; align-items: center; gap: 1rem; margin-bottom: 0.75rem;">
-              <div class="phase-info" style="display: flex; align-items: center; gap: 0.75rem;">
-                <span class="phase-icon" style="font-size: 1rem;">${phase.icon || '📋'}</span>
-                <span class="phase-name" style="font-size: 0.875rem; font-weight: 500; color: var(--color-text);">${phase.displayName || phase.name}</span>
-              </div>
-              <div class="phase-divider" style="flex: 1; height: 1px; background-color: var(--color-border);"></div>
-              <div class="phase-stats" style="display: flex; align-items: center; gap: 0.5rem; flex-shrink: 0;">
-                <div class="confidence-bar" style="width: 48px; height: 8px; background-color: var(--color-bg-tertiary); border-radius: 4px; overflow: hidden;">
-                  <div class="confidence-fill" 
-                      style="height: 100%; width: ${phase.avgConfidence || 0}%; background-color: ${Utils.getConfidenceColor(phase.avgConfidence || 0)}; border-radius: 4px; transition: var(--transition-fast);">
-                  </div>
-                </div>
-                <span class="confidence-text" style="font-size: 0.75rem; color: var(--color-text-secondary); min-width: 28px;">${phase.avgConfidence || 0}%</span>
-              </div>
-            </div>
-            
-            <div class="phase-entries" style="margin-left: 1.5rem; display: grid; gap: 0.5rem;">
-              ${(phase.entries || []).map(entry => this.renderAuditEntry(entry)).join('')}
-            </div>
-          </div>
-        `).join('')}
-      </div>
-    `;
-  }
-
-  renderAuditEntry(entry) {
-    return `
-      <div class="audit-entry" style="background-color: var(--color-bg); border: 1px solid var(--color-border); border-radius: 0.375rem; padding: 0.75rem; transition: var(--transition-fast);" 
-           onmouseover="this.style.backgroundColor='var(--color-bg-secondary)'" 
-           onmouseout="this.style.backgroundColor='var(--color-bg)'">
-        <div class="entry-main" style="display: flex; align-items: center; justify-content: space-between; margin-bottom: 0.5rem;">
-          <span class="entry-action" style="font-size: 0.875rem; font-weight: 500; color: var(--color-text);">
-            ${Utils.getActionDisplayName(entry.action)}
-          </span>
-          <div class="entry-meta" style="display: flex; align-items: center; gap: 0.5rem; font-size: 0.75rem; color: var(--color-text-secondary);">
-            <div class="confidence-indicator" 
-                style="width: 8px; height: 8px; border-radius: 50%; background-color: ${Utils.getConfidenceColor(entry.confidence || 0)};">
-            </div>
-            <span class="confidence-value" style="min-width: 28px; text-align: right;">${entry.confidence || 0}%</span>
-            <span class="processing-time" style="min-width: 40px; text-align: right;">${entry.processingTimeMs || 0}ms</span>
-          </div>
-        </div>
-        
-        ${(entry.inputSummary && entry.inputSummary !== 'null') || (entry.outputSummary && entry.outputSummary !== 'null') ? `
-          <div class="entry-details" style="font-size: 0.75rem; color: var(--color-text-secondary); padding-top: 0.5rem; border-top: 1px solid var(--color-border);">
-            ${entry.inputSummary && entry.inputSummary !== 'null' ? `
-              <div class="detail-item" style="margin-bottom: 0.25rem; word-break: break-word;">
-                <strong>Input:</strong> ${Utils.escapeHtml(entry.inputSummary)}
-              </div>
-            ` : ''}
-            ${entry.outputSummary && entry.outputSummary !== 'null' ? `
-              <div class="detail-item" style="margin-bottom: 0.25rem; word-break: break-word;">
-                <strong>Output:</strong> ${Utils.escapeHtml(entry.outputSummary)}
-              </div>
-            ` : ''}
-          </div>
-        ` : ''}
-      </div>
-    `;
-  }
-
-  renderTechnicalDetails(audit) {
-    const technicalId = `${this.componentId}-technical`;
-    
-    return `
-      <div class="technical-toggle">
-        <button class="technical-toggle-btn" data-target="${technicalId}">
-          🔧 Technische Details anzeigen
-        </button>
-        <div id="${technicalId}" class="technical-details collapsed">
-          ${(audit.phases || []).map(phase => 
-            (phase.entries || []).map(entry => `
-              <div class="technical-entry">
-                <div class="technical-header">
-                  <span class="technical-phase">${entry.phase}/${entry.action}</span>
-                  <span class="technical-time">
-                    ${new Date(entry.timestamp).toLocaleTimeString('de-DE', { 
-                      hour: '2-digit', 
-                      minute: '2-digit', 
-                      second: '2-digit' 
-                    })} • ${entry.processingTimeMs || 0}ms
-                  </span>
-                </div>
-                <div class="technical-content">
-                  <div class="technical-row">
-                    <strong>Confidence:</strong> ${entry.confidence || 0}%
-                  </div>
-                  ${entry.metadata && Object.keys(entry.metadata).length > 0 ? `
-                    <div class="technical-row">
-                      <strong>Metadata:</strong> ${Utils.escapeHtml(JSON.stringify(entry.metadata))}
-                    </div>
-                  ` : ''}
-                </div>
-              </div>
-            `).join('')
-          ).join('')}
-        </div>
-      </div>
-    `;
-  }
-
-  renderEmpty(container) {
-    container.innerHTML = `
-      <div class="audit-trail-container">
-        <div class="audit-trail-header">
-          <div class="audit-trail-title">
-            <div class="audit-icon">
-              <div class="audit-icon-gradient">ⓘ</div>
-              <h4>Kein Audit-Trail verfügbar</h4>
-            </div>
-          </div>
-        </div>
-      </div>
-    `;
-  }
-
-  renderError(container, error) {
-    container.innerHTML = `
-      <div class="audit-trail-container">
-        <div class="audit-trail-header">
-          <div class="audit-trail-title">
-            <div class="audit-icon">
-              <div class="audit-icon-gradient" style="background: var(--color-error);">✗</div>
-              <h4>Audit-Trail Fehler</h4>
-            </div>
-          </div>
-        </div>
-        <div class="audit-summary">
-          <p style="color: var(--color-error);">
-            Fehler beim Laden der Audit-Informationen: ${Utils.escapeHtml(error.message)}
-          </p>
-        </div>
-      </div>
-    `;
-  }
-
-  attachEventHandlers() {
-    if (this.options.collapsible) {
-      const header = document.querySelector(`[data-target="${this.componentId}-details"]`);
-      const details = document.getElementById(`${this.componentId}-details`);
-      const toggleIcon = header?.querySelector('.toggle-icon svg');
-      
-      if (header && details && toggleIcon) {
-        header.addEventListener('click', () => {
-          const isCollapsed = details.classList.contains('collapsed');
-          details.classList.toggle('collapsed');
-          toggleIcon.style.transform = isCollapsed ? 'rotate(180deg)' : 'rotate(0deg)';
-        });
-      }
-    }
-    
-    const technicalBtn = document.querySelector(`[data-target="${this.componentId}-technical"]`);
-    const technicalDetails = document.getElementById(`${this.componentId}-technical`);
-    
-    if (technicalBtn && technicalDetails) {
-      technicalBtn.addEventListener('click', () => {
-        const isCollapsed = technicalDetails.classList.contains('collapsed');
-        technicalDetails.classList.toggle('collapsed');
-        technicalBtn.textContent = isCollapsed ? 
-          '🔧 Technische Details ausblenden' : 
-          '🔧 Technische Details anzeigen';
-      });
-    }
-  }
-}
-
 class AIQueryInterface {
   constructor() {
     this.currentMode = 'workflow';
@@ -760,10 +367,14 @@ class AIQueryInterface {
     this.statusInterval = null;
     this.microTaskInterval = null;
     this.currentMicroTaskStep = 0;
+    this.lastApiResponse = null;
     
+    console.log('[AI Interface] Initializing...');
     this.initializeElements();
     this.setupEventListeners();
+    this.setupUnifiedUploadSystem();
     this.updateModeUI();
+    console.log('[AI Interface] Initialized successfully');
   }
 
   initializeElements() {
@@ -802,10 +413,16 @@ class AIQueryInterface {
       microTaskCounter: document.getElementById('micro-task-counter')
     };
 
+    console.log('[AI Interface] Elements initialized:', {
+      submitBtn: !!this.elements.submitBtn,
+      input: !!this.elements.input,
+      results: !!this.elements.results
+    });
+
     return Object.values(this.elements).some(el => el !== null);
   }
 
-  setupEventListeners() {
+  setupEventListeners() {   
     this.elements.toggleSwitch?.addEventListener('click', () => this.toggleMode());
     this.elements.workflowLabel?.addEventListener('click', () => this.setMode('workflow'));
     this.elements.toolLabel?.addEventListener('click', () => this.setMode('tool'));
@@ -818,8 +435,18 @@ class AIQueryInterface {
       }
     });
 
-    this.elements.submitBtn?.addEventListener('click', () => this.handleSubmit());
+    if (this.elements.submitBtn) {
+      this.elements.submitBtn.addEventListener('click', () => {
+        this.handleSubmit();
+      });
+    } else {
+    }
+
     this.elements.dismissSuggestions?.addEventListener('click', () => this.hideSmartPrompting());
+    
+    this.setupPreviousAnalysisUpload();
+    
+    console.log('[AI Interface] Event listeners setup complete');
   }
 
   getModeConfig() {
@@ -994,35 +621,35 @@ class AIQueryInterface {
 
     statusText.textContent = config.text || '';
     
-    if (config.showContainer) Utils.showElement(this.elements.promptingContainer);
-    else Utils.hideElement(this.elements.promptingContainer);
+    if (config.showContainer) showElement(this.elements.promptingContainer);
+    else hideElement(this.elements.promptingContainer);
     
-    if (config.hideHint) Utils.hideElement(this.elements.smartHint);
-    else Utils.showElement(this.elements.smartHint);
+    if (config.hideHint) hideElement(this.elements.smartHint);
+    else showElement(this.elements.smartHint);
     
-    if (config.showSpinner) Utils.showElement(this.elements.promptingSpinner);
-    else Utils.hideElement(this.elements.promptingSpinner);
+    if (config.showSpinner) showElement(this.elements.promptingSpinner);
+    else hideElement(this.elements.promptingSpinner);
     
-    if (config.showSuggestions) Utils.showElement(this.elements.suggestedQuestions);
-    else Utils.hideElement(this.elements.suggestedQuestions);
+    if (config.showSuggestions) showElement(this.elements.suggestedQuestions);
+    else hideElement(this.elements.suggestedQuestions);
   }
 
   displaySuggestions(suggestions) {
     if (!this.elements.questionsList || !suggestions?.length) return;
     
     this.elements.questionsList.innerHTML = suggestions.map(question => 
-      `<div class="suggestion-item">${Utils.escapeHtml(question)}</div>`
+      `<div class="suggestion-item">${escapeHtml(question)}</div>`
     ).join('');
     
     this.showPromptingStatus('suggestions');
   }
 
   hideSmartPrompting() {
-    if (this.elements.promptingContainer) Utils.hideElement(this.elements.promptingContainer);
-    if (this.elements.smartHint) Utils.showElement(this.elements.smartHint);
+    if (this.elements.promptingContainer) hideElement(this.elements.promptingContainer);
+    if (this.elements.smartHint) showElement(this.elements.smartHint);
   }
 
-  async handleSubmit() {
+  async handleSubmit() {   
     const query = this.elements.input.value.trim();
     
     if (!query) {
@@ -1037,6 +664,8 @@ class AIQueryInterface {
 
     const taskId = `ai_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`;
     
+    console.log('[AI Interface] Starting AI query with taskId:', taskId);
+    
     this.hideSmartPrompting();
     this.hideResults();
     this.hideError();
@@ -1048,6 +677,8 @@ class AIQueryInterface {
       'Generiere Empfehlungen...' : 'Suche passende Methode...';
 
     try {
+      console.log('[AI Interface] Sending request to /api/ai/query');
+      
       const response = await fetch('/api/ai/query', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
@@ -1059,6 +690,14 @@ class AIQueryInterface {
       });
       
       const data = await response.json();
+      this.lastApiResponse = data;
+      this.currentRecommendation = data.recommendation;
+      
+      console.log('[AI Interface] Received response:', { 
+        ok: response.ok, 
+        status: response.status, 
+        success: data.success 
+      });
       
       if (!response.ok) {
         throw new Error(data.error || `HTTP ${response.status}`);
@@ -1104,7 +743,7 @@ class AIQueryInterface {
   }
 
   startQueueMonitoring(taskId) {
-    if (this.elements.queueStatus) Utils.showElement(this.elements.queueStatus);
+    if (this.elements.queueStatus) showElement(this.elements.queueStatus);
     if (this.elements.taskIdDisplay) {
       this.elements.taskIdDisplay.textContent = taskId.slice(-8);
     }
@@ -1127,7 +766,7 @@ class AIQueryInterface {
       if (this.elements.queueLength) this.elements.queueLength.textContent = data.queueLength || 0;
       if (this.elements.estimatedTime) {
         this.elements.estimatedTime.textContent = data.estimatedWaitTime > 0 ? 
-          Utils.formatDuration(data.estimatedWaitTime) : 'Verarbeitung läuft...';
+          formatDuration(data.estimatedWaitTime) : 'Verarbeitung läuft...';
       }
       
       if (this.elements.positionBadge) {
@@ -1162,14 +801,14 @@ class AIQueryInterface {
       this.microTaskInterval = null;
     }
     
-    if (this.elements.queueStatus) Utils.hideElement(this.elements.queueStatus);
-    if (this.elements.microTaskProgress) Utils.hideElement(this.elements.microTaskProgress);
+    if (this.elements.queueStatus) hideElement(this.elements.queueStatus);
+    if (this.elements.microTaskProgress) hideElement(this.elements.microTaskProgress);
   }
 
   startMicroTaskProgress() {
     if (!this.elements.microTaskProgress) return;
     
-    Utils.showElement(this.elements.microTaskProgress);
+    showElement(this.elements.microTaskProgress);
     this.currentMicroTaskStep = 0;
     
     const steps = ['scenario', 'approach', 'considerations', 'tools', 'knowledge', 'final'];
@@ -1294,37 +933,910 @@ class AIQueryInterface {
 
   renderAuditTrail(rawAuditTrail) {
     const container = document.getElementById('audit-trail-container');
-    if (!container) {
-      console.error('[AI Interface] Audit container not found');
+    if (!container || !rawAuditTrail || !Array.isArray(rawAuditTrail)) {
+      console.warn('[AI Interface] Cannot render audit trail: invalid container or data');
       return;
     }
-
-    container.innerHTML = '';
-
-    if (!rawAuditTrail || !Array.isArray(rawAuditTrail) || rawAuditTrail.length === 0) {
-      console.log('[AI Interface] No audit trail data to render');
-      return;
-    }
-
+    
+    console.log('[AI Interface] Rendering detailed audit trail with', rawAuditTrail.length, 'entries');
+    
     try {
-      const renderer = new AuditTrailRenderer('audit-trail-container', {
-        title: 'KI-Entscheidungspfad',
-        collapsible: true,
-        defaultExpanded: false
+      const stats = this.calculateAuditStats(rawAuditTrail);
+      
+      container.innerHTML = `
+        <div class="audit-trail-container">
+          <div class="audit-trail-header clickable" onclick="this.parentElement.querySelector('.audit-trail-details').classList.toggle('collapsed'); this.querySelector('.toggle-icon').style.transform = this.parentElement.querySelector('.audit-trail-details').classList.contains('collapsed') ? 'rotate(0deg)' : 'rotate(90deg)';">
+            <div class="audit-trail-title">
+              <div class="audit-icon">
+                <div class="audit-icon-gradient">🔍</div>
+                <h4>KI-Entscheidungspfad</h4>
+              </div>
+              <div class="audit-stats">
+                <div class="stat-item">
+                  <div class="stat-dot stat-time"></div>
+                  <span>${formatDuration(stats.totalTime)}</span>
+                </div>
+                <div class="stat-item">
+                  <div class="stat-dot" style="background-color: ${getConfidenceColor(stats.avgConfidence)};"></div>
+                  <span>${stats.avgConfidence}% Vertrauen</span>
+                </div>
+                <div class="stat-item">
+                  <span>${rawAuditTrail.length} Schritte</span>
+                </div>
+              </div>
+            </div>
+            <svg class="toggle-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" style="transform: rotate(0deg);">
+              <polyline points="9 18 15 12 9 6"/>
+            </svg>
+          </div>
+
+          <div class="audit-trail-details collapsed">
+            <!-- Audit Summary -->
+            <div class="audit-summary">
+              <div class="summary-header">📊 Analyse-Zusammenfassung</div>
+              <div class="summary-grid">
+                <div class="summary-stat">
+                  <div class="summary-value success">${stats.aiDecisionCount}</div>
+                  <div class="summary-label">KI-Entscheidungen</div>
+                </div>
+                <div class="summary-stat">
+                  <div class="summary-value ${stats.embeddingsUsageCount > 0 ? 'success' : 'warning'}">${stats.embeddingsUsageCount}</div>
+                  <div class="summary-label">Semantische Suchen</div>
+                </div>
+                <div class="summary-stat">
+                  <div class="summary-value success">${stats.toolSelectionCount}</div>
+                  <div class="summary-label">Tool-Auswahlen</div>
+                </div>
+              </div>
+              
+              <div class="insights-section">
+                ${stats.keyInsights && stats.keyInsights.length > 0 ? `
+                  <div class="insights-header success">✅ Erkenntnisse</div>
+                  <ul class="insights-list">
+                    ${stats.keyInsights.map(insight => `<li>${insight}</li>`).join('')}
+                  </ul>
+                ` : ''}
+                
+                ${stats.potentialIssues && stats.potentialIssues.length > 0 ? `
+                  <div class="insights-header warning">⚠️ Hinweise</div>
+                  <ul class="insights-list">
+                    ${stats.potentialIssues.map(issue => `<li>${issue}</li>`).join('')}
+                  </ul>
+                ` : ''}
+              </div>
+            </div>
+
+            <!-- Process Flow -->
+            <div class="audit-process-flow">
+              ${this.renderPhaseGroups(rawAuditTrail, stats)}
+            </div>
+            <div style="margin: 0.5rem 0 1rem 0;">
+              <button id="download-results-btn" class="btn btn-secondary">
+                <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" style="margin-right: 0.5rem;">
+                  <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
+                  <polyline points="7 10 12 15 17 10"/>
+                  <line x1="12" y1="15" x2="12" y2="3"/>
+                </svg>
+                Download Analyse (JSON)
+              </button>
+            </div>
+          </div>
+        </div>
+      `;
+      
+    } catch (error) {
+      console.error('[AI Interface] Error rendering audit trail:', error);
+      container.innerHTML = `
+        <div class="audit-trail-container">
+          <div class="audit-trail-header">
+            <div class="audit-trail-title">
+              <div class="audit-icon">
+                <div class="audit-icon-gradient">⚠️</div>
+                <h4>Audit Trail Fehler</h4>
+              </div>
+            </div>
+          </div>
+          <div class="audit-trail-details">
+            <p style="color: var(--color-error); padding: 1rem;">
+              Fehler beim Rendern des Audit Trails. Details in der Konsole.
+            </p>
+          </div>
+        </div>
+      `;
+    }
+  }
+
+  getQualityDisplayText(analysisQuality) {
+    const qualityMap = {
+      'excellent': 'Ausgezeichnet',
+      'good': 'Gut', 
+      'fair': 'Zufriedenstellend',
+      'poor': 'Verbesserungswürdig',
+      'unknown': 'Unbekannt'
+    };
+    return qualityMap[analysisQuality] || 'Unbekannt';
+  }
+
+  setupUnifiedUploadSystem() {
+    const previousUploadInput = document.getElementById('upload-previous-analysis');
+    if (previousUploadInput) {
+      previousUploadInput.addEventListener('change', (event) => {
+        const files = event.target.files;
+        const file = files ? files[0] : null;
+        if (file) {
+          this.handlePreviousAnalysisUpload(file);
+        }
+        event.target.value = '';
+      });
+      console.log('[AI Interface] Previous analysis upload setup complete');
+    }
+
+    const setupDownloadBtn = () => {
+      const downloadBtn = document.getElementById('download-results-btn');
+      if (downloadBtn && !downloadBtn.hasAttribute('data-setup')) {
+        downloadBtn.setAttribute('data-setup', 'true');
+        downloadBtn.addEventListener('click', () => this.downloadResults());
+      }
+    };
+
+    setupDownloadBtn();
+
+    const observer = new MutationObserver(() => {
+      setupDownloadBtn();
+    });
+
+    observer.observe(document.body, { 
+      childList: true, 
+      subtree: true 
+    });
+
+    this.uploadObserver = observer;
+
+    console.log('[AI Interface] Unified upload system setup complete');
+  }
+
+  calculateAuditStats(auditTrail) {
+    if (!auditTrail || auditTrail.length === 0) {
+      return {
+        totalTime: 0,
+        avgConfidence: 0,
+        stepCount: 0,
+        highConfidenceSteps: 0,
+        lowConfidenceSteps: 0,
+        phaseBreakdown: {},
+        aiDecisionCount: 0,
+        embeddingsUsageCount: 0,
+        toolSelectionCount: 0,
+        qualityMetrics: {
+          avgProcessingTime: 0,
+          confidenceDistribution: { high: 0, medium: 0, low: 0 }
+        },
+        analysisQuality: 'excellent',
+        keyInsights: [
+          'Vollständige Dokumentation aller Analyseschritte',
+          'Transparente KI-Entscheidungsfindung'
+        ],
+        potentialIssues: []
+      };
+    }
+
+    const totalTime = auditTrail.reduce((sum, entry) => sum + (entry.processingTimeMs || 0), 0);
+    const validConfidenceEntries = auditTrail.filter(entry => typeof entry.confidence === 'number');
+    const avgConfidence = validConfidenceEntries.length > 0 
+      ? Math.round(validConfidenceEntries.reduce((sum, entry) => sum + entry.confidence, 0) / validConfidenceEntries.length)
+      : 0;
+    
+    const highConfidenceSteps = auditTrail.filter(entry => (entry.confidence || 0) >= 80).length;
+    const lowConfidenceSteps = auditTrail.filter(entry => (entry.confidence || 0) < 60).length;
+    const mediumConfidenceSteps = auditTrail.length - highConfidenceSteps - lowConfidenceSteps;
+
+    // FIX 1: Count actual AI decision actions only
+    const aiDecisionCount = auditTrail.filter(entry => entry.action === 'ai-decision').length;
+    
+    // FIX 2: Count actual similarity search actions, not metadata flags
+    const embeddingsUsageCount = auditTrail.filter(entry => entry.action === 'similarity-search').length;
+    
+    // FIX 3: Maintain tool selection count (this was correct)
+    const toolSelectionCount = auditTrail.filter(entry => entry.action === 'selection-decision').length;
+
+    // Additional diagnostic counts for debugging
+    const microTaskCount = auditTrail.filter(entry => 
+      entry.action === 'ai-decision' && entry.metadata?.microTaskType
+    ).length;
+    
+    const phaseToolSelectionCount = auditTrail.filter(entry => 
+      entry.action === 'phase-tool-selection'
+    ).length;
+    
+    const phaseEnhancementCount = auditTrail.filter(entry => 
+      entry.action === 'phase-enhancement'
+    ).length;
+
+    // Enhanced insights with diagnostic information
+    const keyInsights = [];
+    const potentialIssues = [];
+    
+    if (embeddingsUsageCount > 0) {
+      keyInsights.push(`Semantische Suche wurde ${embeddingsUsageCount}x erfolgreich eingesetzt`);
+    } else {
+      potentialIssues.push('Keine semantischen Suchen dokumentiert - möglicherweise fehlerhafte Auditierung');
+    }
+
+    if (aiDecisionCount >= 5) {
+      keyInsights.push(`${aiDecisionCount} KI-Entscheidungen mit detaillierter Begründung`);
+    } else {
+      potentialIssues.push(`Nur ${aiDecisionCount} KI-Entscheidungen dokumentiert - erwartet mindestens 5 für Vollständigkeit`);
+    }
+
+    if (microTaskCount > 0) {
+      keyInsights.push(`${microTaskCount} spezialisierte Micro-Task-Analysen durchgeführt`);
+    }
+
+    // Detect mode-specific patterns for validation
+    if (phaseToolSelectionCount > 0 || phaseEnhancementCount > 0) {
+      keyInsights.push('Workflow-Modus: Phasenspezifische Analyse durchgeführt');
+    } else if (microTaskCount >= 3) {
+      keyInsights.push('Tool-Modus: Detaillierte Einzelbewertungen durchgeführt');
+    }
+
+    const phaseBreakdown = {};
+    auditTrail.forEach(entry => {
+      const phase = entry.phase || 'unknown';
+      if (!phaseBreakdown[phase]) {
+        phaseBreakdown[phase] = { count: 0, avgConfidence: 0, totalTime: 0 };
+      }
+      
+      phaseBreakdown[phase].count++;
+      phaseBreakdown[phase].totalTime += entry.processingTimeMs || 0;
+    });
+
+    Object.keys(phaseBreakdown).forEach(phase => {
+      const phaseEntries = auditTrail.filter(entry => entry.phase === phase);
+      const validEntries = phaseEntries.filter(entry => typeof entry.confidence === 'number');
+      
+      if (validEntries.length > 0) {
+        phaseBreakdown[phase].avgConfidence = Math.round(
+          validEntries.reduce((sum, entry) => sum + entry.confidence, 0) / validEntries.length
+        );
+      }
+    });
+
+    let analysisQuality;
+    if (avgConfidence >= 85 && lowConfidenceSteps === 0) {
+      analysisQuality = 'excellent';
+    } else if (avgConfidence >= 70 && lowConfidenceSteps <= 1) {
+      analysisQuality = 'good';
+    } else if (avgConfidence >= 60 && lowConfidenceSteps <= 3) {
+      analysisQuality = 'fair';
+    } else {
+      analysisQuality = 'poor';
+    }
+
+    if (highConfidenceSteps > auditTrail.length * 0.7) {
+      keyInsights.push('Mehrheit der Analyseschritte mit hoher Sicherheit');
+    }
+
+    // Validate expected counts based on mode detection
+    const isWorkflowMode = phaseToolSelectionCount > 0 || phaseEnhancementCount > 0;
+    const expectedMinAI = isWorkflowMode ? 11 : 8; // Workflow: 5 common + 6 phase selections, Tool: 5 common + 3 evaluations
+    const expectedMinEmbeddings = 1; // Both modes should have initial search
+
+    if (aiDecisionCount < expectedMinAI) {
+      potentialIssues.push(`${expectedMinAI - aiDecisionCount} fehlende KI-Entscheidungen für ${isWorkflowMode ? 'Workflow' : 'Tool'}-Modus`);
+    }
+
+    if (embeddingsUsageCount < expectedMinEmbeddings) {
+      potentialIssues.push(`${expectedMinEmbeddings - embeddingsUsageCount} fehlende semantische Suchen`);
+    }
+
+    return {
+      totalTime,
+      avgConfidence,
+      stepCount: auditTrail.length,
+      highConfidenceSteps,
+      lowConfidenceSteps,
+      phaseBreakdown,
+      aiDecisionCount,
+      embeddingsUsageCount,
+      toolSelectionCount,
+      qualityMetrics: {
+        avgProcessingTime: auditTrail.length > 0 ? totalTime / auditTrail.length : 0,
+        confidenceDistribution: { 
+          high: highConfidenceSteps, 
+          medium: mediumConfidenceSteps, 
+          low: lowConfidenceSteps 
+        }
+      },
+      analysisQuality,
+      keyInsights,
+      potentialIssues,
+      // Debug information
+      debugCounts: {
+        microTaskCount,
+        phaseToolSelectionCount, 
+        phaseEnhancementCount,
+        detectedMode: isWorkflowMode ? 'workflow' : 'tool'
+      }
+    };
+  }
+
+  renderPhaseGroups(auditTrail, stats) {
+    const phaseGroups = new Map();
+    
+    auditTrail.forEach(entry => {
+      const phase = entry.phase || 'unknown';
+      if (!phaseGroups.has(phase)) {
+        phaseGroups.set(phase, []);
+      }
+      const phaseEntries = phaseGroups.get(phase);
+      if (phaseEntries) {
+        phaseEntries.push(entry);
+      }
+    });
+
+    let html = '';
+    let groupIndex = 0;
+    
+    for (const [phaseName, entries] of phaseGroups) {
+      const isLastPhase = groupIndex === phaseGroups.size - 1;
+      const phaseAvgConfidence = entries.reduce((sum, e) => sum + (e.confidence || 0), 0) / entries.length;
+      
+      html += `
+        <div class="phase-group ${isLastPhase ? 'last-phase' : ''}">
+          <div class="phase-header" style="display: flex; align-items: center; gap: 1rem; margin-bottom: 1rem;">
+            <div style="display: flex; align-items: center; gap: 0.75rem;">
+              <div class="phase-icon">${this.getPhaseIcon(phaseName)}</div>
+              <div class="phase-name">${this.getPhaseDisplayName(phaseName)}</div>
+            </div>
+            <div class="phase-divider"></div>
+            <div class="phase-stats">
+              <div class="confidence-bar">
+                <div class="confidence-fill" style="width: ${phaseAvgConfidence}%; background-color: ${getConfidenceColor(phaseAvgConfidence)};"></div>
+              </div>
+              <span class="confidence-text">${Math.round(phaseAvgConfidence)}%</span>
+            </div>
+          </div>
+          
+          <div class="phase-entries">
+            ${entries.map(entry => this.renderAuditEntry(entry)).join('')}
+          </div>
+        </div>
+      `;
+      
+      groupIndex++;
+    }
+    
+    return html;
+  }
+
+  renderAuditEntry(entry) {
+    const confidenceColor = getConfidenceColor(entry.confidence || 0);
+    const processingTime = formatDuration(entry.processingTimeMs || 0);
+    const decisionBasis = entry.metadata?.decisionBasis || 'unknown';
+    
+    return `
+      <div class="audit-entry">
+        <div class="entry-main">
+          <div class="entry-action">
+            <div style="display: flex; align-items: center; gap: 0.5rem;">
+              <span>${this.getDetailedActionName(entry)}</span>
+              <span class="decision-basis-badge" style="background-color: ${this.getDecisionBasisColor(decisionBasis)}; color: white; padding: 0.125rem 0.375rem; border-radius: 0.25rem; font-size: 0.625rem; font-weight: 500;">
+                ${this.getDecisionBasisText(decisionBasis)}
+              </span>
+            </div>
+          </div>
+          <div class="entry-meta">
+            <div class="confidence-indicator" style="background-color: ${confidenceColor};"></div>
+            <span class="confidence-value">${entry.confidence || 0}%</span>
+            <span class="processing-time">${processingTime}</span>
+          </div>
+        </div>
+        
+        ${this.renderDetailedEntryInfo(entry)}
+      </div>
+    `;
+  }
+
+  getDecisionBasisColor(basis) {
+    const colors = {
+      'ai-analysis': 'var(--color-primary)',
+      'semantic-search': 'var(--color-accent)', 
+      'hybrid': 'var(--color-warning)',
+      'rule-based': 'var(--color-text-secondary)'
+    };
+    return colors[basis] || 'var(--color-text-secondary)';
+  }
+
+  getDecisionBasisText(basis) {
+    const texts = {
+      'ai-analysis': 'KI-Analyse',
+      'semantic-search': 'Semantik',
+      'hybrid': 'Hybrid',
+      'rule-based': 'Regel-basiert'
+    };
+    return texts[basis] || 'Unbekannt';
+  }
+
+  renderDetailedEntryInfo(entry) {
+    const details = [];
+    const metadata = entry.metadata || {};
+    
+    if (metadata.inputSummary && metadata.inputSummary !== 'Leer') {
+      details.push(`<div class="detail-item"><strong>Eingabe:</strong> ${escapeHtml(metadata.inputSummary)}</div>`);
+    }
+    
+    if (metadata.outputSummary && metadata.outputSummary !== 'Leer') {
+      details.push(`<div class="detail-item"><strong>Ausgabe:</strong> ${escapeHtml(metadata.outputSummary)}</div>`);
+    }
+    
+    if (metadata.reasoning && !metadata.reasoning.includes('completed with')) {
+      details.push(`<div class="detail-item"><strong>Begründung:</strong> ${escapeHtml(metadata.reasoning)}</div>`);
+    }
+    
+    if (entry.action === 'similarity-search' && metadata.similarityScores) {
+      const topScores = Object.entries(metadata.similarityScores)
+        .sort(([,a], [,b]) => (b) - (a))
+        .slice(0, 3)
+        .map(([name, score]) => `${name} (${((score) * 100).toFixed(1)}%)`)
+        .join(', ');
+      if (topScores) {
+        details.push(`<div class="detail-item"><strong>Top Treffer:</strong> ${topScores}</div>`);
+      }
+    }
+    
+    if (entry.action === 'ai-decision' && metadata.aiModel) {
+      details.push(`<div class="detail-item"><strong>KI-Modell:</strong> ${metadata.aiModel}</div>`);
+      if (metadata.promptTokens && metadata.completionTokens) {
+        details.push(`<div class="detail-item"><strong>Token-Nutzung:</strong> ${metadata.promptTokens} + ${metadata.completionTokens} = ${metadata.promptTokens + metadata.completionTokens}</div>`);
+      }
+    }
+    
+    if (entry.action === 'selection-decision') {
+      if (metadata.selectionMethod) {
+        const methodDisplay = metadata.selectionMethod === 'embeddings_candidates' ? 'Semantische Filterung' : 'Vollständige Analyse';
+        details.push(`<div class="detail-item"><strong>Methode:</strong> ${methodDisplay}</div>`);
+      }
+      if (metadata.reductionRatio) {
+        details.push(`<div class="detail-item"><strong>Filterung:</strong> ${(metadata.reductionRatio * 100).toFixed(1)}% der verfügbaren Tools</div>`);
+      }
+    }
+    
+    if (entry.action === 'tool-confidence') {
+      const confidence = entry.output || {};
+      if (confidence.strengthIndicators && confidence.strengthIndicators.length > 0) {
+        details.push(`<div class="detail-item"><strong>Stärken:</strong> ${confidence.strengthIndicators.slice(0, 2).join(', ')}</div>`);
+      }
+      if (confidence.uncertaintyFactors && confidence.uncertaintyFactors.length > 0) {
+        details.push(`<div class="detail-item"><strong>Unsicherheiten:</strong> ${confidence.uncertaintyFactors.slice(0, 2).join(', ')}</div>`);
+      }
+    }
+    
+    if (entry.action === 'phase-tool-selection') {
+      if (metadata.availableToolsCount && metadata.selectedToolsCount) {
+        const ratio = (metadata.selectedToolsCount / metadata.availableToolsCount * 100).toFixed(1);
+        details.push(`<div class="detail-item"><strong>Auswahlrate:</strong> ${ratio}% der verfügbaren Phase-Tools</div>`);
+      }
+    }
+    
+    if (entry.action === 'phase-enhancement') {
+      if (metadata.semanticSimilarity) {
+        details.push(`<div class="detail-item"><strong>Semantische Ähnlichkeit:</strong> ${(metadata.semanticSimilarity * 100).toFixed(1)}%</div>`);
+      }
+      if (metadata.aiReasoningUsed) {
+        details.push(`<div class="detail-item"><strong>KI-Begründung:</strong> Verwendet für Auswahl</div>`);
+      }
+    }
+    
+    if (details.length === 0) return '';
+    
+    return `
+      <div class="entry-details">
+        ${details.join('')}
+      </div>
+    `;
+  }
+
+  getDetailedActionName(entry) {
+    const action = entry.action;
+    const metadata = entry.metadata || {};
+    
+    switch (action) {
+      case 'selection-decision':
+        return `Tool-Auswahl: ${metadata.selectedToolsCount || 0} von ${metadata.availableToolsCount || 0} Tools gewählt`;
+      
+      case 'ai-decision':
+        if (metadata.microTaskType) {
+          const taskTypes = {
+            'scenario-analysis': 'Szenario-Analyse',
+            'investigation-approach': 'Untersuchungsansatz',
+            'critical-considerations': 'Kritische Überlegungen',
+            'tool-evaluation': 'Tool-Bewertung',
+            'background-knowledge': 'Hintergrundwissen-Auswahl',
+            'final-recommendations': 'Abschließende Empfehlungen'
+          };
+          return `KI-Analyse: ${taskTypes[metadata.microTaskType] || metadata.microTaskType}`;
+        }
+        return 'KI-Entscheidung';
+      
+      case 'similarity-search':
+        return `Semantische Suche: ${entry.output?.resultsCount || 0} ähnliche Items gefunden`;
+      
+      case 'phase-enhancement':
+        const actualCount = entry.output?.toolsAddedCount || metadata.toolsAdded?.length || 0;
+        const phaseName = entry.input?.phaseName || metadata.phaseId || 'unbekannte Phase';
+        return `Phasen-Vervollständigung: ${actualCount} Tools für ${phaseName} hinzugefügt`;
+      
+      case 'tool-confidence':
+        return `Vertrauenswertung: ${entry.input?.toolName || 'Tool'} bewertet`;
+      
+      case 'phase-tool-selection':
+        const phaseId = metadata.phaseId || entry.input?.phaseId;
+        const phasesToDisplay = {
+          'preparation': 'Vorbereitung', 
+          'acquisition': 'Datensammlung',
+          'examination': 'Untersuchung', 
+          'analysis': 'Analyse',
+          'reporting': 'Dokumentation',
+          'presentation': 'Präsentation'
+        };
+        const displayPhase = phasesToDisplay[phaseId] || phaseId || 'Phase';
+        return `${displayPhase}: ${metadata.selectedToolsCount || 0} Tools ausgewählt`;
+      
+      case 'tool-added-to-phase':
+        const toolName = entry.input?.toolName || 'Tool';
+        const phase = entry.input?.phaseId || 'Phase';
+        const priority = entry.input?.priority || metadata.priority || 'medium';
+        return `${toolName} als ${priority}-Priorität für ${phase} ausgewählt`;
+      
+      case 'concept-selection':
+        return `Hintergrundwissen: ${metadata.selectedConceptsCount || 0} Konzepte ausgewählt`;
+      
+      default:
+        return this.getActionDisplayName(action);
+    }
+  }
+
+  renderEntryDetails(entry) {
+    const details = [];
+    
+    if (entry.action === 'ai-decision' && entry.metadata?.reasoning) {
+      details.push(`<div class="detail-item"><strong>Begründung:</strong> ${truncateText(entry.metadata.reasoning, 200)}</div>`);
+    }
+    
+    if (entry.action === 'selection-decision') {
+      if (entry.metadata?.selectedToolsCount && entry.metadata?.availableToolsCount) {
+        details.push(`<div class="detail-item"><strong>Auswahl:</strong> ${entry.metadata.selectedToolsCount} von ${entry.metadata.availableToolsCount} Tools</div>`);
+      }
+      if (entry.metadata?.selectionMethod) {
+        details.push(`<div class="detail-item"><strong>Methode:</strong> ${entry.metadata.selectionMethod}</div>`);
+      }
+    }
+    
+    if (entry.metadata?.embeddingsUsed && entry.metadata?.totalMatches) {
+      details.push(`<div class="detail-item"><strong>Semantische Treffer:</strong> ${entry.metadata.totalMatches}</div>`);
+    }
+    
+    if (entry.metadata?.confidenceFactors?.length > 0) {
+      const factors = entry.metadata.confidenceFactors.slice(0, 2).join(', ');
+      details.push(`<div class="detail-item"><strong>Faktoren:</strong> ${factors}</div>`);
+    }
+    
+    if (details.length === 0) return '';
+    
+    return `
+      <div class="entry-details">
+        ${details.join('')}
+      </div>
+    `;
+  }
+
+  getPhaseDisplayName(phase) {
+    const names = {
+      'tool-selection': 'Tool-Auswahl',
+      'contextual-analysis': 'Kontext-Analyse', 
+      'workflow-phase': 'Workflow-Phase',
+      'tool-reasoning': 'Tool-Bewertung',
+      'tool-evaluation': 'Tool-Bewertung',
+      'knowledge-synthesis': 'Wissens-Synthese',
+      'confidence-scoring': 'Vertrauenswertung',
+      'phase-completion': 'Phasen-Vervollständigung',
+      'embeddings': 'Semantische Suche',
+      'synthesis': 'Empfehlungs-Synthese',
+      'unknown': 'Unbekannt'
+    };
+    return names[phase] || phase;
+  }
+
+  getPhaseIcon(phase) {
+    const icons = {
+      'tool-selection': '🔧',
+      'contextual-analysis': '🧠',
+      'workflow-phase': '⚡',
+      'tool-reasoning': '💭',
+      'tool-evaluation': '💭',
+      'knowledge-synthesis': '📚',
+      'confidence-scoring': '📊',
+      'phase-completion': '✅',
+      'embeddings': '🔍',
+      'synthesis': '🎯',
+      'unknown': '❓'
+    };
+    return icons[phase] || icons['unknown'];
+  }
+
+  getActionDisplayName(action) {
+    const actions = {
+      'selection-decision': 'Tools ausgewählt',
+      'ai-decision': 'KI-Entscheidung',
+      'phase-tool-selection': 'Phasen-Tools evaluiert',
+      'tool-added-to-phase': 'Tool zur Phase hinzugefügt',
+      'concept-selection': 'Konzepte ausgewählt',
+      'tool-confidence': 'Vertrauen berechnet',
+      'phase-enhancement': 'Phase vervollständigt',
+      'similarity-search': 'Ähnlichkeitssuche'
+    };
+    return actions[action] || action;
+  }
+
+  downloadResults() {
+    if (!this.currentRecommendation) {
+      alert('Keine Analyse zum Herunterladen verfügbar.');
+      return;
+    }
+    
+    const inputValue = this.elements.input ? this.elements.input.value : '';
+    
+    const processingStats = this.currentRecommendation.processingStats || {};
+    const aiModel = processingStats.aiModel || 'unknown';
+    const toolsDataHash = processingStats.toolsDataHash || 'unknown';
+    
+    const aiParameters = {
+      maxTokens: processingStats.maxTokensUsed || 0,
+      temperature: processingStats.temperature || 0.3,
+      totalTokensUsed: processingStats.totalAITokensUsed || 0,
+      microTasksCompleted: processingStats.microTasksCompleted || 0,
+      microTasksFailed: processingStats.microTasksFailed || 0,
+      embeddingsUsed: processingStats.embeddingsUsed || false
+    };
+    
+    const rawContext = {
+      selectedTools: this.currentRecommendation.recommended_tools?.map(tool => ({
+        name: tool.name,
+        type: tool.type,
+        phase: tool.phase,
+        priority: tool.priority,
+        confidence: tool.confidence,
+        justification: tool.justification
+      })) || [],
+      backgroundKnowledge: this.currentRecommendation.background_knowledge?.map(bg => ({
+        concept_name: bg.concept_name,
+        relevance: bg.relevance
+      })) || [],
+      contextHistory: [],
+      embeddingsSimilarities: {}
+    };
+    
+    const exportData = {
+      metadata: {
+        timestamp: new Date().toISOString(),
+        version: '2.0',
+        toolsDataHash: toolsDataHash,
+        aiModel: aiModel,
+        aiParameters: aiParameters,
+        userQuery: inputValue,
+        mode: this.currentMode,
+        processingStats: processingStats,
+        exportedBy: 'ForensicPathways',
+      },
+      recommendation: {
+        ...this.currentRecommendation,
+        auditTrail: undefined
+      },
+      auditTrail: this.currentRecommendation.auditTrail || [],
+      rawContext: rawContext
+    };
+    
+    const blob = new Blob([JSON.stringify(exportData, null, 2)], {
+      type: 'application/json'
+    });
+    
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = `forensic-ai-analysis-${Date.now()}.json`;
+    a.click();
+    URL.revokeObjectURL(url);
+    
+    console.log('[AI Interface] Analysis downloaded with verified hash structure:', {
+      version: '2.0',
+      aiModel,
+      toolsDataHash: toolsDataHash.slice(0, 12) + '...',
+      tokensUsed: aiParameters.totalTokensUsed,
+      auditEntries: exportData.auditTrail.length,
+      hashVerifiable: toolsDataHash !== 'unknown'
+    });
+  }
+
+  validateUploadStructure(data) {
+    try {
+      const isValid = !!(
+        data &&
+        typeof data === 'object' &&
+        data.metadata &&
+        typeof data.metadata === 'object' &&
+        typeof data.metadata.timestamp === 'string' &&
+        data.recommendation &&
+        typeof data.recommendation === 'object' &&
+        Array.isArray(data.auditTrail)
+      );
+      
+      if (!isValid) {
+        return false;
+      }
+      
+      if (data.auditTrail.length > 0) {
+        const sampleEntry = data.auditTrail[0];
+        const hasRequiredFields = !!(
+          sampleEntry &&
+          typeof sampleEntry === 'object' &&
+          typeof sampleEntry.timestamp === 'number' &&
+          typeof sampleEntry.phase === 'string' &&
+          typeof sampleEntry.action === 'string' &&
+          typeof sampleEntry.confidence === 'number'
+        );
+        
+        if (!hasRequiredFields) {
+          console.warn('[AI Interface] Audit trail entries missing required fields');
+          return false;
+        }
+      }
+      
+      return true;
+    } catch (error) {
+      console.error('[AI Interface] Structure validation error:', error);
+      return false;
+    }
+  }
+
+  displayUploadedResults(data) {
+    try {
+      console.log('[AI Interface] Displaying uploaded results');
+      
+      this.showUploadedBanner(data.metadata);
+      
+      this.currentRecommendation = {
+        ...data.recommendation,
+        auditTrail: data.auditTrail
+      };
+      
+      this.showResults();
+      
+      if (data.metadata.mode === 'workflow') {
+        this.displayWorkflowResults(data.recommendation, data.metadata.userQuery);
+      } else {
+        this.displayToolResults(data.recommendation, data.metadata.userQuery);
+      }
+      
+      setTimeout(() => {
+        try {
+          this.renderAuditTrail(data.auditTrail);
+          console.log('[AI Interface] Audit trail from upload rendered successfully');
+        } catch (error) {
+          console.error('[AI Interface] Failed to render uploaded audit trail:', error);
+        }
+      }, 200);
+      
+      console.log('[AI Interface] Uploaded analysis displayed successfully');
+    } catch (error) {
+      console.error('[AI Interface] Error displaying uploaded results:', error);
+      this.showError('Fehler beim Anzeigen der hochgeladenen Analyse: ' + error.message);
+    }
+  }
+
+  showUploadedBanner(metadata) {
+    const banner = `
+      <div class="uploaded-results-banner" style="background: var(--color-bg-secondary); border: 1px solid var(--color-warning); border-radius: 0.5rem; padding: 1rem; margin-bottom: 1rem; display: flex; align-items: center; gap: 1rem;">
+        <div style="font-size: 1.5rem;">📁</div>
+        <div style="flex: 1;">
+          <strong style="color: var(--color-warning);">Hochgeladene Analyse</strong>
+          <div style="font-size: 0.875rem; color: var(--color-text-secondary); margin-top: 0.25rem;">
+            Erstellt: ${new Date(metadata.timestamp).toLocaleString('de-DE')} | 
+            Modus: ${metadata.mode} | 
+            ${metadata.toolsDataHash ? `Hash: ${metadata.toolsDataHash.slice(0, 8)}...` : ''}
+          </div>
+        </div>
+        <button onclick="this.parentElement.remove()" style="background: none; border: none; color: var(--color-text-secondary); cursor: pointer; font-size: 1.25rem;">&times;</button>
+      </div>
+    `;
+    
+    if (this.elements && this.elements.results) {
+      this.elements.results.insertAdjacentHTML('afterbegin', banner);
+    }
+  }
+
+  setupPreviousAnalysisUpload() {
+    const uploadInput = document.getElementById('upload-previous-analysis');
+    
+    if (uploadInput) {
+      uploadInput.addEventListener('change', (event) => {
+        const files = event.target.files;
+        const file = files ? files[0] : null;
+        if (file) {
+          this.handlePreviousAnalysisUpload(file);
+        }
+        event.target.value = '';
       });
       
-      renderer.render(rawAuditTrail);
+      console.log('[AI Interface] Previous analysis upload setup complete');
+    } else {
+      console.warn('[AI Interface] Previous analysis upload input not found');
+    }
+  }
+
+  async handlePreviousAnalysisUpload(file) {
+    console.log('[AI Interface] Handling previous analysis upload:', file.name);
+    
+    try {
+      if (file.size > 10 * 1024 * 1024) {
+        throw new Error('Datei zu groß (max 10MB)');
+      }
+      
+      if (!file.name.endsWith('.json')) {
+        throw new Error('Ungültiger Dateityp - nur JSON-Dateien werden unterstützt');
+      }
+      
+      const text = await file.text();
+      let data;
+      
+      try {
+        data = JSON.parse(text);
+      } catch (error) {
+        throw new Error('Ungültiges JSON-Format');
+      }
+      
+      if (!this.validateUploadStructure(data)) {
+        throw new Error('Ungültiges Analyse-Dateiformat');
+      }
+      
+      this.uploadedAuditTrail = data.auditTrail;
+      
+      console.log('[AI Interface] Valid previous analysis file uploaded:', {
+        version: data.metadata.version || '1.0',
+        auditEntries: data.auditTrail?.length || 0,
+        toolsCount: data.recommendation.recommended_tools?.length || 0,
+        checksum: data.checksum?.slice(0, 8) + '...' || 'none',
+        originalMode: data.metadata.mode,
+        currentMode: this.currentMode
+      });
+      
+      this.hideResults();
+      this.hideError();
+      this.hideLoading();
+      
+      if (data.metadata.mode && data.metadata.mode !== this.currentMode) {
+        console.log(`[AI Interface] Switching from ${this.currentMode} to ${data.metadata.mode} mode for uploaded analysis`);
+        this.setMode(data.metadata.mode);
+      }
+      
+      this.displayUploadedResults(data);
+      
+      if (data.metadata.userQuery && this.elements.input) {
+        this.elements.input.value = data.metadata.userQuery;
+        this.updateCharacterCount();
+      }
+      
     } catch (error) {
-      console.error('[AI Interface] Failed to render audit trail:', error);
+      console.error('[AI Interface] Previous analysis upload failed:', error);
+      this.showError(`Upload fehlgeschlagen: ${error.message}`);
     }
   }
 
   renderHeader(title, query) {
     return `
-      <div style="text-align: center; margin-bottom: 2rem; padding: 1.5rem; background: linear-gradient(135deg, var(--color-primary) 0%, #525252 100%); color: white; border-radius: 0.75rem;">
-        <h3 style="margin: 0 0 0.75rem 0; font-size: 1.5rem;">${title}</h3>
-        <p style="margin: 0; opacity: 0.9; line-height: 1.5;">
-          Basierend auf Ihrer Anfrage: "<em>${Utils.truncateText(query, 100)}</em>"
+      <div class="header-center header-primary rounded-xl mb-8">
+        <h3 class="text-2xl mb-3">${title}</h3>
+        <p class="mb-0 leading-relaxed">
+          Basierend auf Ihrer Anfrage: "<em>${truncateText(query, 100)}</em>"
         </p>
       </div>
     `;
@@ -1336,33 +1848,33 @@ class AIQueryInterface {
     const analysisField = mode === 'workflow' ? recommendation.scenario_analysis : recommendation.problem_analysis;
     if (analysisField) {
       html += `
-        <div class="card contextual-analysis-card scenario">
-          <h4 style="margin: 0 0 1rem 0; color: var(--color-primary);">
+        <div class="card contextual-analysis-card scenario mb-6">
+          <h4 class="mb-4 text-primary">
             ${mode === 'workflow' ? 'Szenario-Analyse' : 'Problem-Analyse'}
           </h4>
-          <div style="margin: 0; line-height: 1.6; white-space: pre-wrap; word-wrap: break-word;">${Utils.sanitizeText(analysisField)}</div>
+          <div class="leading-relaxed">${sanitizeText(analysisField)}</div>
         </div>
       `;
     }
 
     if (recommendation.investigation_approach) {
       html += `
-        <div class="card contextual-analysis-card approach">
-          <h4 style="margin: 0 0 1rem 0; color: var(--color-accent);">
+        <div class="card contextual-analysis-card approach mb-6">
+          <h4 class="mb-4 text-accent">
             ${mode === 'workflow' ? 'Untersuchungsansatz' : 'Lösungsansatz'}
           </h4>
-          <div style="margin: 0; line-height: 1.6; white-space: pre-wrap; word-wrap: break-word;">${Utils.sanitizeText(recommendation.investigation_approach)}</div>
+          <div class="leading-relaxed">${sanitizeText(recommendation.investigation_approach)}</div>
         </div>
       `;
     }
 
     if (recommendation.critical_considerations) {
       html += `
-        <div class="card contextual-analysis-card critical">
-          <h4 style="margin: 0 0 1rem 0; color: var(--color-warning);">
+        <div class="card contextual-analysis-card critical mb-6">
+          <h4 class="mb-4 text-warning">
             ${mode === 'workflow' ? 'Kritische Überlegungen' : 'Wichtige Voraussetzungen'}
           </h4>
-          <div style="margin: 0; line-height: 1.6; white-space: pre-wrap; word-wrap: break-word;">${Utils.sanitizeText(recommendation.critical_considerations)}</div>
+          <div class="leading-relaxed">${sanitizeText(recommendation.critical_considerations)}</div>
         </div>
       `;
     }
@@ -1374,28 +1886,77 @@ class AIQueryInterface {
     if (!backgroundKnowledge?.length) return '';
     
     const conceptLinks = backgroundKnowledge.map(concept => `
-      <div style="background-color: var(--color-concept-bg); border: 1px solid var(--color-concept); border-radius: 0.5rem; padding: 1rem; margin-bottom: 0.75rem;">
-        <div style="display: flex; align-items: center; gap: 0.75rem; margin-bottom: 0.5rem;">
+      <div class="card-info-sm mb-3 border-l-4" style="border-left-color: var(--color-concept);">
+        <div class="flex items-center gap-3 mb-2">
           <button onclick="window.showToolDetails('${concept.concept_name}', 'secondary')" 
-                  style="background: none; border: none; color: var(--color-concept); font-weight: 600; cursor: pointer; text-decoration: underline;">
+                  class="btn-icon text-concept font-semibold">
             📚 ${concept.concept_name}
           </button>
-          <span class="badge" style="background-color: var(--color-concept); color: white; font-size: 0.625rem;">Hintergrundwissen</span>
+          <span class="badge" style="background-color: var(--color-concept); color: white;">Hintergrundwissen</span>
         </div>
-        <div style="margin: 0; font-size: 0.8125rem; line-height: 1.5; color: var(--color-text-secondary); white-space: pre-wrap; word-wrap: break-word;">
-          ${Utils.sanitizeText(concept.relevance)}
+        <div class="text-sm leading-relaxed text-secondary">
+          ${sanitizeText(concept.relevance)}
         </div>
       </div>
     `).join('');
     
     return `
-      <div class="card" style="margin-bottom: 2rem; border-left: 4px solid var(--color-concept);">
-        <h4 style="margin: 0 0 1rem 0; color: var(--color-concept);">Empfohlenes Hintergrundwissen</h4>
+      <div class="card mb-8 border-l-4" style="border-left-color: var(--color-concept);">
+        <h4 class="mb-4 text-concept">Empfohlenes Hintergrundwissen</h4>
         ${conceptLinks}
       </div>
     `;
   }
 
+  renderWorkflowTool(tool) {
+    const priorityColors = {
+      high: 'var(--color-error)',
+      medium: 'var(--color-warning)', 
+      low: 'var(--color-accent)'
+    };
+
+    const priority = tool.recommendation ? tool.recommendation.priority : tool.priority;
+    const confidenceTooltip = tool.confidence ? this.renderConfidenceTooltip(tool.confidence) : '';
+    
+    const cardClass = this.getToolClass(tool, 'recommendation');
+    
+    return `
+      <div class="tool-recommendation ${cardClass}" onclick="window.showToolDetails('${tool.name}')" 
+          style="position: relative; cursor: pointer; transition: var(--transition-fast);"
+          onmouseover="this.style.transform='translateY(-2px)'; this.style.boxShadow='var(--shadow-md)';"
+          onmouseout="this.style.transform='translateY(0)'; this.style.boxShadow='';">
+        
+        <div class="tool-rec-header" style="display: flex; justify-content: space-between; align-items: flex-start; margin-bottom: 0.75rem;">
+          <h4 class="tool-rec-name" style="font-weight: 600; font-size: 1rem; margin: 0; color: var(--color-text); flex: 1; margin-right: 0.75rem;">
+            ${tool.icon ? `<span style="margin-right: 0.5rem; font-size: 1.125rem;">${tool.icon}</span>` : ''}
+            ${tool.name}
+          </h4>
+          <div style="display: flex; align-items: center; gap: 0.375rem; flex-shrink: 0;">
+            <span class="tool-rec-priority ${priority}" 
+                  style="background-color: ${priorityColors[priority]}; color: white; padding: 0.25rem 0.5rem; border-radius: 1rem; font-size: 0.75rem; font-weight: 500; text-transform: uppercase; position: relative; display: flex; align-items: center; gap: 0.25rem;">
+              ${priority}
+              ${confidenceTooltip}
+            </span>
+          </div>
+        </div>
+        
+        <div class="tool-rec-justification" style="background-color: var(--color-bg-tertiary); padding: 0.75rem; border-radius: 0.375rem; border-left: 3px solid var(--color-primary); margin: 0.75rem 0; font-style: italic; white-space: pre-wrap; word-wrap: break-word; font-size: 0.875rem; line-height: 1.5; color: var(--color-text-secondary);">
+          "${sanitizeText(tool.justification || (tool.recommendation && tool.recommendation.justification) || `Empfohlen für ${tool.phase}`)}"
+        </div>
+        
+        <div style="font-size: 0.75rem; color: var(--color-text-secondary); margin-top: auto;">
+          <div style="display: flex; flex-wrap: wrap; gap: 0.375rem; margin-bottom: 0.5rem;">
+            ${this.renderToolBadges(tool)}
+          </div>
+          <div style="display: flex; justify-content: space-between; align-items: center;">
+            <span>${tool.type === 'method' ? 'Methode' : tool.platforms.slice(0, 2).join(', ')}</span>
+            <span>${tool.skillLevel}</span>
+          </div>
+        </div>
+      </div>
+    `;
+  }
+
   renderWorkflowPhases(toolsByPhase, phaseOrder, phaseNames) {
     const phaseColors = [
       'var(--color-primary)', 
@@ -1413,28 +1974,25 @@ class AIQueryInterface {
       const phaseColor = phaseColors[index % phaseColors.length];
 
       return `
-        <div class="workflow-phase" style="margin-bottom: 2rem;">
-          <div class="phase-header" style="display: flex; align-items: flex-start; gap: 1rem; padding: 1.5rem; background-color: var(--color-bg); border: 2px solid var(--color-border); border-radius: 0.75rem; transition: var(--transition-medium);" 
-               onmouseover="this.style.borderColor='${phaseColor}'; this.style.boxShadow='var(--shadow-md)';"
-               onmouseout="this.style.borderColor='var(--color-border)'; this.style.boxShadow='';">
-            
-            <div class="phase-number" style="width: 2rem; height: 2rem; background: ${phaseColor}; color: white; border-radius: 50%; display: flex; align-items: center; justify-content: center; font-weight: 600; flex-shrink: 0; box-shadow: var(--shadow-sm);">
+        <div class="workflow-phase mb-8">
+          <div class="phase-header" style="--phase-color: ${phaseColor};">
+            <div class="phase-number" style="background: ${phaseColor};">
               ${index + 1}
             </div>
             
-            <div class="phase-info" style="display: flex; flex-direction: column; gap: 0.75rem; flex: 1; min-width: 0;">
-              <h3 class="phase-title" style="font-weight: 600; margin: 0; color: var(--color-text); font-size: 1.25rem;">
+            <div class="phase-info">
+              <h3 class="phase-title">
                 ${phaseNames[phase]}
               </h3>
               
-              <div class="phase-tools" style="display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 1rem;">
+              <div class="phase-tools">
                 ${phaseTools.map(tool => this.renderWorkflowTool(tool)).join('')}
               </div>
             </div>
           </div>
           
           ${index < phaseOrder.length - 1 ? `
-            <div class="workflow-arrow" style="display: flex; justify-content: center; margin: 1rem 0; color: ${phaseColor};">
+            <div class="workflow-arrow" style="color: ${phaseColor};">
               <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                 <line x1="12" y1="5" x2="12" y2="19"/>
                 <polyline points="19 12 12 19 5 12"/>
@@ -1446,55 +2004,6 @@ class AIQueryInterface {
     }).join('');
   }
 
-  renderWorkflowTool(tool) {
-    const priorityColors = {
-      high: 'var(--color-error)',
-      medium: 'var(--color-warning)', 
-      low: 'var(--color-accent)'
-    };
-
-    const priority = tool.recommendation ? tool.recommendation.priority : tool.priority;
-    const confidenceTooltip = tool.confidence ? this.renderConfidenceTooltip(tool.confidence) : '';
-    
-    const cardClass = this.getToolClass(tool, 'recommendation');
-    
-    return `
-      <div class="tool-recommendation ${cardClass}" onclick="window.showToolDetails('${tool.name}')" 
-           style="position: relative; cursor: pointer; transition: var(--transition-fast);"
-           onmouseover="this.style.transform='translateY(-2px)'; this.style.boxShadow='var(--shadow-md)';"
-           onmouseout="this.style.transform='translateY(0)'; this.style.boxShadow='';">
-        
-        <div class="tool-rec-header" style="display: flex; justify-content: space-between; align-items: flex-start; margin-bottom: 0.75rem;">
-          <h4 class="tool-rec-name" style="font-weight: 600; font-size: 1rem; margin: 0; color: var(--color-text); flex: 1; margin-right: 0.75rem;">
-            ${tool.icon ? `<span style="margin-right: 0.5rem; font-size: 1.125rem;">${tool.icon}</span>` : ''}
-            ${tool.name}
-          </h4>
-          <div style="display: flex; align-items: center; gap: 0.375rem; flex-shrink: 0;">
-            <span class="tool-rec-priority ${priority}" 
-                  style="background-color: ${priorityColors[priority]}; color: white; padding: 0.25rem 0.5rem; border-radius: 1rem; font-size: 0.75rem; font-weight: 500; text-transform: uppercase; position: relative; display: flex; align-items: center; gap: 0.25rem;">
-              ${priority}
-              ${confidenceTooltip}
-            </span>
-          </div>
-        </div>
-        
-        <div class="tool-rec-justification" style="background-color: var(--color-bg-tertiary); padding: 0.75rem; border-radius: 0.375rem; border-left: 3px solid var(--color-primary); margin: 0.75rem 0; font-style: italic; white-space: pre-wrap; word-wrap: break-word; font-size: 0.875rem; line-height: 1.5; color: var(--color-text-secondary);">
-          "${Utils.sanitizeText(tool.justification || (tool.recommendation && tool.recommendation.justification) || `Empfohlen für ${tool.phase}`)}"
-        </div>
-        
-        <div style="font-size: 0.75rem; color: var(--color-text-secondary); margin-top: auto;">
-          <div style="display: flex; flex-wrap: wrap; gap: 0.375rem; margin-bottom: 0.5rem;">
-            ${this.renderToolBadges(tool)}
-          </div>
-          <div style="display: flex; justify-content: space-between; align-items: center;">
-            <span>${tool.type === 'method' ? 'Methode' : tool.platforms.slice(0, 2).join(', ')}</span>
-            <span>${tool.skillLevel}</span>
-          </div>
-        </div>
-      </div>
-    `;
-  }
-
   renderToolRecommendations(recommendedTools) {
     if (!recommendedTools?.length) return '';
     
@@ -1535,11 +2044,11 @@ class AIQueryInterface {
 
         <div style="margin-bottom: 1.5rem;">
           <h4 style="margin: 0.8rem 0 0.75rem 0; color: var(--color-accent);">Warum diese Methode?</h4>
-          <div style="margin: 0; line-height: 1.6; white-space: pre-wrap; word-wrap: break-word;">${Utils.sanitizeText(recommendation.detailed_explanation)}</div>
+          <div style="margin: 0; line-height: 1.6; white-space: pre-wrap; word-wrap: break-word;">${sanitizeText(recommendation.detailed_explanation)}</div>
           
           ${recommendation.implementation_approach ? `
             <h4 style="margin: 0.8rem 0 0.75rem 0; color: var(--color-primary);">Anwendungsansatz</h4>
-            <div style="margin: 0; line-height: 1.6; white-space: pre-wrap; word-wrap: break-word;">${Utils.sanitizeText(recommendation.implementation_approach)}</div>
+            <div style="margin: 0; line-height: 1.6; white-space: pre-wrap; word-wrap: break-word;">${sanitizeText(recommendation.implementation_approach)}</div>
           ` : ''}
         </div>
 
@@ -1553,7 +2062,7 @@ class AIQueryInterface {
   renderConfidenceTooltip(confidence) {
     if (!confidence || typeof confidence.overall !== 'number') return '';
     
-    const confidenceColor = Utils.getConfidenceColor(confidence.overall);
+    const confidenceColor = getConfidenceColor(confidence.overall);
     const tooltipId = `tooltip-${Math.random().toString(36).substr(2, 9)}`;
     
     return `
@@ -1566,7 +2075,7 @@ class AIQueryInterface {
         <span style="font-size: 0.625rem; color: white; font-weight: 600; text-shadow: 0 1px 2px rgba(0,0,0,0.5);">${confidence.overall}%</span>
         
         <div class="confidence-tooltip" 
-             style="display: none; position: absolute; top: 100%; right: 0; z-index: 1001; background: var(--color-bg); border: 1px solid var(--color-border); border-radius: 0.5rem; padding: 1rem; min-width: 320px; max-width: 400px; box-shadow: var(--shadow-lg); font-size: 0.75rem; color: var(--color-text); margin-top: 0.5rem;">
+            style="display: none; position: absolute; top: 100%; right: 0; z-index: 1001; background: var(--color-bg); border: 1px solid var(--color-border); border-radius: 0.5rem; padding: 1rem; min-width: 320px; max-width: 400px; box-shadow: var(--shadow-lg); font-size: 0.75rem; color: var(--color-text); margin-top: 0.5rem;">
           <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 0.75rem;">
             <strong style="font-size: 0.875rem; color: var(--color-primary);">KI-Vertrauenswertung</strong>
             <span style="background-color: ${confidenceColor}; color: white; font-weight: 600; padding: 0.125rem 0.375rem; border-radius: 0.25rem; font-size: 0.625rem;">${confidence.overall}%</span>
@@ -1600,7 +2109,7 @@ class AIQueryInterface {
                 <span>✓</span> Stärken dieser Empfehlung:
               </strong>
               <ul style="margin: 0; padding-left: 1rem; font-size: 0.625rem; line-height: 1.4; color: var(--color-text);">
-                ${confidence.strengthIndicators.slice(0, 3).map(s => `<li style="margin-bottom: 0.25rem;">${Utils.sanitizeText(s)}</li>`).join('')}
+                ${confidence.strengthIndicators.slice(0, 3).map(s => `<li style="margin-bottom: 0.25rem;">${sanitizeText(s)}</li>`).join('')}
               </ul>
             </div>
           ` : ''}
@@ -1611,7 +2120,7 @@ class AIQueryInterface {
                 <span>⚠</span> Mögliche Einschränkungen:
               </strong>
               <ul style="margin: 0; padding-left: 1rem; font-size: 0.625rem; line-height: 1.4; color: var(--color-text);">
-                ${confidence.uncertaintyFactors.slice(0, 3).map(f => `<li style="margin-bottom: 0.25rem;">${Utils.sanitizeText(f)}</li>`).join('')}
+                ${confidence.uncertaintyFactors.slice(0, 3).map(f => `<li style="margin-bottom: 0.25rem;">${sanitizeText(f)}</li>`).join('')}
               </ul>
             </div>
           ` : ''}
@@ -1628,9 +2137,9 @@ class AIQueryInterface {
     if (!suggestion) return '';
     
     return `
-      <div class="card" style="margin-top: 2rem; border-left: 4px solid var(--color-accent);">
-        <h4 style="margin: 0 0 1rem 0; color: var(--color-accent);">Workflow-Empfehlung</h4>
-        <div style="margin: 0; line-height: 1.6; white-space: pre-wrap; word-wrap: break-word;">${Utils.sanitizeText(suggestion)}</div>
+      <div class="card mt-8 border-l-4" style="border-left-color: var(--color-accent);">
+        <h4 class="mb-4 text-accent">Workflow-Empfehlung</h4>
+        <div class="leading-relaxed">${sanitizeText(suggestion)}</div>
       </div>
     `;
   }
@@ -1639,9 +2148,9 @@ class AIQueryInterface {
     if (!considerations) return '';
     
     return `
-      <div class="card" style="margin-top: 2rem; background-color: var(--color-bg-secondary); border-left: 4px solid var(--color-text-secondary);">
-        <h4 style="margin: 0 0 1rem 0; color: var(--color-text-secondary);">Zusätzliche Überlegungen</h4>
-        <div style="margin: 0; line-height: 1.6; white-space: pre-wrap; word-wrap: break-word;">${Utils.sanitizeText(considerations)}</div>
+      <div class="card mt-8 bg-secondary border-l-4" style="border-left-color: var(--color-text-secondary);">
+        <h4 class="mb-4 text-secondary">Zusätzliche Überlegungen</h4>
+        <div class="leading-relaxed">${sanitizeText(considerations)}</div>
       </div>
     `;
   }
@@ -1655,7 +2164,7 @@ class AIQueryInterface {
           <div style="background-color: var(--color-oss-bg); padding: 1rem; border-radius: 0.5rem; border-left: 3px solid var(--color-accent);">
             <h5 style="margin: 0 0 0.5rem 0; color: var(--color-accent); font-size: 0.875rem;">✓ Vorteile</h5>
             <ul style="margin: 0; padding-left: 1rem;">
-              ${pros.map(pro => `<li style="margin-bottom: 0.25rem;">${Utils.sanitizeText(pro)}</li>`).join('')}
+              ${pros.map(pro => `<li style="margin-bottom: 0.25rem;">${sanitizeText(pro)}</li>`).join('')}
             </ul>
           </div>
         ` : ''}
@@ -1663,7 +2172,7 @@ class AIQueryInterface {
           <div style="background-color: var(--color-hosted-bg); padding: 1rem; border-radius: 0.5rem; border-left: 3px solid var(--color-warning);">
             <h5 style="margin: 0 0 0.5rem 0; color: var(--color-warning); font-size: 0.875rem;">✗ Nachteile</h5>
             <ul style="margin: 0; padding-left: 1rem;">
-              ${cons.map(con => `<li style="margin-bottom: 0.25rem;">${Utils.sanitizeText(con)}</li>`).join('')}
+              ${cons.map(con => `<li style="margin-bottom: 0.25rem;">${sanitizeText(con)}</li>`).join('')}
             </ul>
           </div>
         ` : ''}
@@ -1688,7 +2197,7 @@ class AIQueryInterface {
     return `
       <div style="background-color: var(--color-bg-secondary); padding: 1rem; border-radius: 0.5rem; margin-bottom: 1rem;">
         <h5 style="margin: 0 0 0.5rem 0; color: var(--color-text-secondary); font-size: 0.875rem;">Alternative Ansätze</h5>
-        <div style="margin: 0; line-height: 1.6; white-space: pre-wrap; word-wrap: break-word;">${Utils.sanitizeText(alternatives)}</div>
+        <div style="margin: 0; line-height: 1.6; white-space: pre-wrap; word-wrap: break-word;">${sanitizeText(alternatives)}</div>
       </div>
     `;
   }
@@ -1740,44 +2249,48 @@ class AIQueryInterface {
   }
 
   showLoading() {
-    Utils.showElement(this.elements.loading);
+    showElement(this.elements.loading);
   }
 
   hideLoading() {
-    Utils.hideElement(this.elements.loading);
+    hideElement(this.elements.loading);
   }
 
   showResults() {
-    Utils.showElement(this.elements.results);
+    showElement(this.elements.results);
   }
 
   hideResults() {
-    Utils.hideElement(this.elements.results);
-    Utils.hideElement(this.elements.error);
+    hideElement(this.elements.results);
+    hideElement(this.elements.error);
   }
 
   showError(message) {
     if (this.elements.errorMessage) this.elements.errorMessage.textContent = message;
-    Utils.showElement(this.elements.error);
+    showElement(this.elements.error);
   }
 
   hideError() {
-    Utils.hideElement(this.elements.error);
+    hideElement(this.elements.error);
   }
 
   restoreAIResults() {
     if (this.currentRecommendation && this.elements.results) {
       this.showResults();
       
-      if (this.currentRecommendation.auditTrail) {
+      const auditTrail = this.currentRecommendation.auditTrail || this.uploadedAuditTrail;
+      
+      if (auditTrail && Array.isArray(auditTrail) && auditTrail.length > 0) {
         setTimeout(() => {
           try {
-            this.renderAuditTrail(this.currentRecommendation.auditTrail);
-            console.log('[AI Interface] Audit trail restored successfully');
+            this.renderAuditTrail(auditTrail);
+            console.log('[AI Interface] Audit trail restored successfully:', auditTrail.length, 'entries');
           } catch (error) {
             console.error('[AI Interface] Audit trail restore failed:', error);
           }
         }, 100);
+      } else {
+        console.warn('[AI Interface] No audit trail available for restore');
       }
       
       this.hideLoading();
@@ -1792,5 +2305,7 @@ document.addEventListener('DOMContentLoaded', () => {
   window.restoreAIResults = () => aiInterface.restoreAIResults();
   window.isToolHosted = window.isToolHosted || isToolHosted;
   
-  console.log('[AI Interface] Initialized successfully');
-});
\ No newline at end of file
+  console.log('[AI Interface] Setup complete');
+});
+
+</script>
\ No newline at end of file
diff --git a/src/components/ContributionButton.astro b/src/components/ContributionButton.astro
index 5434ff6..1b1a610 100644
--- a/src/components/ContributionButton.astro
+++ b/src/components/ContributionButton.astro
@@ -1,5 +1,5 @@
 ---
-// src/components/ContributionButton.astro - CLEANED: Removed duplicate auth script
+// src/components/ContributionButton.astro
 export interface Props {
   type: 'edit' | 'new' | 'write';
   toolName?: string;
diff --git a/src/components/ShareButton.astro b/src/components/ShareButton.astro
index ef041f4..47aca10 100644
--- a/src/components/ShareButton.astro
+++ b/src/components/ShareButton.astro
@@ -1,5 +1,5 @@
 ---
-import { createToolSlug } from '../utils/toolHelpers.js';
+import { createToolSlug } from '../utils/clientUtils.js';
 
 export interface Props {
   toolName: string;
diff --git a/src/components/TargetedScenarios.astro b/src/components/TargetedScenarios.astro
index 2a4eb4f..8db7a33 100644
--- a/src/components/TargetedScenarios.astro
+++ b/src/components/TargetedScenarios.astro
@@ -4,7 +4,6 @@ import { getToolsData } from '../utils/dataService.js';
 const data = await getToolsData();
 const scenarios = data.scenarios || [];
 
-// Configuration
 const maxDisplayed = 9;
 const displayedScenarios = scenarios.slice(0, maxDisplayed);
 ---
diff --git a/src/components/ToolFilters.astro b/src/components/ToolFilters.astro
index c8ba300..502ae3f 100644
--- a/src/components/ToolFilters.astro
+++ b/src/components/ToolFilters.astro
@@ -306,8 +306,7 @@ const sortedTags = Object.entries(tagFrequency)
 </div>
 
 <script define:vars={{ toolsData: data.tools, tagFrequency, sortedTags }}>
-  window.toolsData = toolsData;
-  
+  window.toolsData = toolsData;  
   document.addEventListener('DOMContentLoaded', () => {
     const elements = {
       searchInput: document.getElementById('search-input'),
@@ -393,6 +392,13 @@ const sortedTags = Object.entries(tagFrequency)
         return null;
       }
     }
+
+    function isToolHosted(tool) {
+      return tool.projectUrl !== undefined && 
+            tool.projectUrl !== null && 
+            tool.projectUrl !== "" && 
+            tool.projectUrl.trim() !== "";
+    }
     
     function toggleCollapsible(toggleBtn, content, storageKey) {
       const isCollapsed = toggleBtn.getAttribute('data-collapsed') === 'true';
@@ -433,13 +439,6 @@ const sortedTags = Object.entries(tagFrequency)
       }
     }
     
-    function isToolHosted(tool) {
-      return tool.projectUrl !== undefined && 
-             tool.projectUrl !== null && 
-             tool.projectUrl !== "" && 
-             tool.projectUrl.trim() !== "";
-    }
-    
     function initTagCloud() {
       const visibleCount = 20;
       elements.tagCloudItems.forEach((item, index) => {
diff --git a/src/config/prompts.ts b/src/config/prompts.ts
index a1babec..710e2e4 100644
--- a/src/config/prompts.ts
+++ b/src/config/prompts.ts
@@ -2,17 +2,15 @@
 
 export const AI_PROMPTS = {
   
-  toolSelection: (mode: string, userQuery: string, selectionMethod: string, maxSelectedItems: number) => {
+  toolSelection: (mode: string, userQuery: string, maxSelectedItems: number) => {
     const modeInstruction = mode === 'workflow' 
       ? 'Workflow mit 15-25 Items über alle Phasen. PFLICHT: Mindestens 40% Methoden, Rest Tools/Konzepte.'
       : 'Spezifische Lösung mit 4-10 Items. PFLICHT: Mindestens 30% Methoden wenn verfügbar.';
 
     return `Du bist ein DFIR-Experte. Wähle die BESTEN Items aus dem vorgefilterten Set.
 
-AUSWAHLMETHODE: ${selectionMethod}
-${selectionMethod === 'embeddings_candidates' ? 
-  '✓ Semantisch relevante Items bereits vorgefiltert\n✓ Wähle die BESTEN für die konkrete Aufgabe' :
-  '✓ Vollständige Datenbank verfügbar\n✓ Wähle die relevantesten Items'}
+AUSWAHLMETHODE:
+  '✓ Semantisch relevante Items bereits vorgefiltert\n✓ Wähle die BESTEN für die konkrete Aufgabe'}
 
 ${modeInstruction}
 
@@ -36,6 +34,11 @@ AUSWAHLSTRATEGIE:
   - Lieber weniger perfekte Items als viele mittelmäßige
   - Jedes Item muss begründbar sein
 
+4. **TASK RELEVANCE REALISM**
+  - Gib realistische Bewertungen (50-85% typisch)
+  - Vermeide übertriebene 90-100% Scores
+  - Nur bei perfekter Übereinstimmung >85%
+
 AUSWAHLREGELN:
 - Wähle ${mode === 'workflow' ? '15-25' : '4-10'} Items total, max ${maxSelectedItems}
 - BEIDE Arrays füllen: selectedTools UND selectedConcepts
@@ -59,7 +62,13 @@ ${JSON.stringify(toolsToSend, null, 2)}
 VERFÜGBARE KONZEPTE (${conceptsToSend.length} Items - theoretisches Wissen):
 ${JSON.stringify(conceptsToSend, null, 2)}
 
-WICHTIGER HINWEIS: Wähle sowohl aus TOOLS als auch aus KONZEPTEN aus! Konzepte sind essentiell für methodische Fundierung.`;
+WICHTIGER HINWEIS: Wähle sowohl aus TOOLS als auch aus KONZEPTEN aus! Konzepte sind essentiell für methodische Fundierung.
+
+TASK RELEVANCE GUIDELINES:
+- 50-65%: Grundlegend relevant, aber nicht optimal
+- 66-75%: Gut geeignet für die Aufgabe
+- 76-85%: Sehr gut geeignet, klare Vorteile
+- 86-100%: NUR für perfekte Übereinstimmung verwenden`;
   },
 
   scenarioAnalysis: (isWorkflow: boolean, userQuery: string) => {
@@ -148,13 +157,19 @@ AUSWAHLREGELN FÜR PHASE "${phase.name}":
 3. Mindestens 1 Methode wenn verfügbar, Rest Software-Tools
 4. Begründe WARUM jedes Item für diese Phase optimal ist
 
+TASK RELEVANCE GUIDELINES:
+- 60-70%: Grundlegend für diese Phase geeignet
+- 71-80%: Gut geeignet, klare Phasenrelevanz
+- 81-90%: Sehr gut geeignet, optimal für Phase
+- 91-100%: NUR für perfekte Phasenübereinstimmung
+
 WICHTIG: Verwende EXAKT die Namen wie oben aufgelistet (ohne Präfixe wie M1./T2.)!
 
 ANTWORT AUSSCHLIESSLICH IM JSON-FORMAT OHNE JEGLICHEN TEXT AUSSERHALB:
 [
   {
     "toolName": "Exakter Name aus der Liste oben",
-    "taskRelevance": 85,
+    "taskRelevance": 75,
     "justification": "Detaillierte Begründung (60-80 Wörter) warum optimal für ${phase.name} - erkläre Anwendung, Vorteile und spezifische Relevanz",
     "limitations": ["Mögliche Einschränkung für diese Phase"]
   }
@@ -266,6 +281,7 @@ AUSWAHLREGELN FÜR NACHERGÄNZUNG:
 1. Wähle 1-2 BESTE Methoden/Tools die die ${phase.name}-Phase optimal ergänzen
 2. Methoden/Tools müssen für die ursprüngliche Anfrage relevant sein
 3. Ergänzen, nicht ersetzen - erweitere die zu spezifische Erstauswahl
+4. Realistische Task Relevance (70-85% typisch für Nachergänzungen)
 
 ANTWORT AUSSCHLIESSLICH IM JSON-FORMAT:
 {
@@ -291,7 +307,7 @@ Antwort: Fließtext ohne Listen, max ${isWorkflow ? '100' : '80'} Wörter.`;
   }
 } as const;
 
-export function getPrompt(key: 'toolSelection', mode: string, userQuery: string, selectionMethod: string, maxSelectedItems: number): string;
+export function getPrompt(key: 'toolSelection', mode: string, userQuery: string, maxSelectedItems: number): string;
 export function getPrompt(key: 'toolSelectionWithData', basePrompt: string, toolsToSend: any[], conceptsToSend: any[]): string;
 export function getPrompt(key: 'scenarioAnalysis', isWorkflow: boolean, userQuery: string): string;
 export function getPrompt(key: 'investigationApproach', isWorkflow: boolean, userQuery: string): string;
diff --git a/src/content/config.ts b/src/content/config.ts
index 32bc781..bbaede6 100644
--- a/src/content/config.ts
+++ b/src/content/config.ts
@@ -16,7 +16,7 @@ const knowledgebaseCollection = defineCollection({
     tags: z.array(z.string()).default([]),
     
     published: z.boolean().default(true),
-    gated_content: z.boolean().default(false), // NEW: Gated content flag
+    gated_content: z.boolean().default(false),
     
   })
 });
diff --git a/src/pages/api/ai/embeddings-status.ts b/src/pages/api/ai/embeddings-status.ts
index 9d9b9c8..1346b18 100644
--- a/src/pages/api/ai/embeddings-status.ts
+++ b/src/pages/api/ai/embeddings-status.ts
@@ -1,17 +1,19 @@
 // src/pages/api/ai/embeddings-status.ts
 import type { APIRoute } from 'astro';
+import { embeddingsService } from '../../../utils/embeddings.js';
 
 export const prerender = false;
 
 export const GET: APIRoute = async () => {
   try {
-    const { embeddingsService } = await import('../../../utils/embeddings.js');
     await embeddingsService.waitForInitialization();
     
     const stats = embeddingsService.getStats();
     const status = stats.enabled && stats.initialized ? 'ready' : 
                   stats.enabled && !stats.initialized ? 'initializing' : 'disabled';
     
+    console.log(`[EMBEDDINGS-STATUS-API] Service status: ${status}, stats:`, stats);
+    
     return new Response(JSON.stringify({
       success: true,
       embeddings: stats,
@@ -23,6 +25,8 @@ export const GET: APIRoute = async () => {
     });
     
   } catch (error) {
+    console.error('[EMBEDDINGS-STATUS-API] Error checking embeddings status:', error);
+    
     return new Response(JSON.stringify({
       success: false,
       embeddings: { enabled: false, initialized: false, count: 0 },
diff --git a/src/pages/api/ai/enhance-input.ts b/src/pages/api/ai/enhance-input.ts
index 9eccb1c..6de1167 100644
--- a/src/pages/api/ai/enhance-input.ts
+++ b/src/pages/api/ai/enhance-input.ts
@@ -1,23 +1,13 @@
-// src/pages/api/ai/enhance-input.ts - Enhanced AI service compatibility
+// src/pages/api/ai/enhance-input.ts
 import type { APIRoute } from 'astro';
 import { withAPIAuth } from '../../../utils/auth.js';
 import { apiError, apiServerError, createAuthErrorResponse } from '../../../utils/api.js';
 import { enqueueApiCall } from '../../../utils/rateLimitedQueue.js';
+import { aiService } from '../../../utils/aiService.js';
+import { JSONParser } from '../../../utils/jsonUtils.js';
 
 export const prerender = false;
 
-function getEnv(key: string): string {
-  const value = process.env[key];
-  if (!value) {
-    throw new Error(`Missing environment variable: ${key}`);
-  }
-  return value;
-}
-
-const AI_ENDPOINT = getEnv('AI_ANALYZER_ENDPOINT');
-const AI_ANALYZER_API_KEY = getEnv('AI_ANALYZER_API_KEY');
-const AI_ANALYZER_MODEL = getEnv('AI_ANALYZER_MODEL');
-
 const rateLimitStore = new Map<string, { count: number; resetTime: number }>();
 const RATE_LIMIT_WINDOW = 60 * 1000;
 const RATE_LIMIT_MAX = 5;
@@ -49,7 +39,7 @@ function checkRateLimit(userId: string): boolean {
   return true;
 }
 
-function cleanupExpiredRateLimits() {
+function cleanupExpiredRateLimits(): void {
   const now = Date.now();
   for (const [userId, limit] of rateLimitStore.entries()) {
     if (now > limit.resetTime) {
@@ -61,7 +51,7 @@ function cleanupExpiredRateLimits() {
 setInterval(cleanupExpiredRateLimits, 5 * 60 * 1000);
 
 function createEnhancementPrompt(input: string): string {
-  return `Sie sind ein DFIR-Experte mit Spezialisierung auf forensische Methodik. Ein Nutzer beschreibt ein forensisches Szenario oder Problem. Analysieren Sie die Eingabe auf Vollständigkeit für eine wissenschaftlich fundierte forensische Untersuchung.
+  return `Sie sind ein DFIR-Experte mit Spezialisierung auf forensische Methodik. Ein Nutzer beschreibt ein Szenario oder Problem. Analysieren Sie die Eingabe auf Vollständigkeit für eine wissenschaftlich fundierte Untersuchung.
 
 ANALYSIEREN SIE DIESE FORENSISCHEN KATEGORIEN:
 1. **Incident Context**: Was ist passiert? Welche Angriffsvektoren oder technischen Probleme liegen vor?
@@ -74,12 +64,12 @@ ANALYSIEREN SIE DIESE FORENSISCHEN KATEGORIEN:
 
 WENN die Beschreibung alle kritischen forensischen Aspekte abdeckt: Geben Sie eine leere Liste [] zurück.
 
-WENN wichtige forensische Details fehlen: Formulieren Sie 2-3 präzise Fragen, die die kritischsten Lücken für eine wissenschaftlich fundierte forensische Analyse schließen.
+WENN wichtige Details fehlen: Formulieren Sie 2-3 präzise Fragen, die die kritischsten Lücken für eine wissenschaftlich fundierte Analyse schließen.
 
 QUALITÄTSKRITERIEN FÜR FRAGEN:
 - Forensisch spezifisch, nicht allgemein (NICHT: "Mehr Details?")
 - Methodisch relevant (NICHT: "Wann passierte das?")
-- Priorisiert nach Auswirkung auf die forensische Untersuchungsqualität
+- Priorisiert nach Auswirkung auf die Untersuchungsqualität
 - Die Frage soll maximal 20 Wörter umfassen
 
 ANTWORTFORMAT (NUR JSON, KEIN ZUSÄTZLICHER TEXT):
@@ -94,39 +84,6 @@ ${input}
   `.trim();
 }
 
-async function callAIService(prompt: string): Promise<Response> {
-  const endpoint = AI_ENDPOINT;
-  const apiKey = AI_ANALYZER_API_KEY;
-  const model = AI_ANALYZER_MODEL;
-  
-  let headers: Record<string, string> = {
-    'Content-Type': 'application/json'
-  };
-  
-  if (apiKey) {
-    headers['Authorization'] = `Bearer ${apiKey}`;
-    console.log('[ENHANCE API] Using API key authentication');
-  } else {
-    console.log('[ENHANCE API] No API key - making request without authentication');
-  }
-  
-  const requestBody = {
-    model,
-    messages: [{ role: 'user', content: prompt }],
-    max_tokens: 300,
-    temperature: 0.7,
-    top_p: 0.9,
-    frequency_penalty: 0.2,
-    presence_penalty: 0.1
-  };
-  
-  return fetch(`${endpoint}/v1/chat/completions`, {
-    method: 'POST',
-    headers,
-    body: JSON.stringify(requestBody)
-  });
-}
-
 export const POST: APIRoute = async ({ request }) => {
   try {
     const authResult = await withAPIAuth(request, 'ai');
@@ -155,28 +112,25 @@ export const POST: APIRoute = async ({ request }) => {
     const systemPrompt = createEnhancementPrompt(sanitizedInput);
     const taskId = `enhance_${userId}_${Date.now()}_${Math.random().toString(36).substr(2, 4)}`;
     
-    const aiResponse = await enqueueApiCall(() => callAIService(systemPrompt), taskId);
+    console.log(`[ENHANCE-API] Processing enhancement request for user: ${userId}`);
+    
+    const aiResponse = await enqueueApiCall(() => 
+      aiService.callAI(systemPrompt, { 
+        temperature: 0.7 
+      }), taskId);
 
-    if (!aiResponse.ok) {
-      const errorText = await aiResponse.text();
-      console.error('[ENHANCE API] AI enhancement error:', errorText, 'Status:', aiResponse.status);
-      return apiServerError.unavailable('Enhancement service unavailable');
-    }
-
-    const aiData = await aiResponse.json();
-    const aiContent = aiData.choices?.[0]?.message?.content;
-
-    if (!aiContent) {
+    if (!aiResponse.content) {
       return apiServerError.unavailable('No enhancement response');
     }
 
     let questions;
     try {
-      const cleanedContent = aiContent
+      const cleanedContent = aiResponse.content
         .replace(/^```json\s*/i, '')
         .replace(/\s*```\s*$/, '')
         .trim();
-      questions = JSON.parse(cleanedContent);
+      
+      questions = JSONParser.safeParseJSON(cleanedContent, []);
       
       if (!Array.isArray(questions)) {
         throw new Error('Response is not an array');
@@ -198,11 +152,11 @@ export const POST: APIRoute = async ({ request }) => {
       }
 
     } catch (error) {
-      console.error('Failed to parse enhancement response:', aiContent);
+      console.error('[ENHANCE-API] Failed to parse enhancement response:', aiResponse.content);
       questions = [];
     }
 
-    console.log(`[ENHANCE API] User: ${userId}, Forensics Questions: ${questions.length}, Input length: ${sanitizedInput.length}`);
+    console.log(`[ENHANCE-API] User: ${userId}, Questions generated: ${questions.length}, Input length: ${sanitizedInput.length}`);
 
     return new Response(JSON.stringify({
       success: true,
@@ -215,7 +169,7 @@ export const POST: APIRoute = async ({ request }) => {
     });
 
   } catch (error) {
-    console.error('Enhancement error:', error);
+    console.error('[ENHANCE-API] Enhancement error:', error);
     return apiServerError.internal('Enhancement processing failed');
   }
 };
\ No newline at end of file
diff --git a/src/pages/api/ai/query.ts b/src/pages/api/ai/query.ts
index 85379fd..1617bbb 100644
--- a/src/pages/api/ai/query.ts
+++ b/src/pages/api/ai/query.ts
@@ -20,15 +20,14 @@ const MAIN_RATE_LIMIT_MAX = parseInt(process.env.AI_RATE_LIMIT_MAX_REQUESTS || '
 const MICRO_TASK_TOTAL_LIMIT = parseInt(process.env.AI_MICRO_TASK_TOTAL_LIMIT || '50', 10); 
 
 function sanitizeInput(input: string): string {
-  let sanitized = input
+  return input
     .replace(/```[\s\S]*?```/g, '[CODE_BLOCK_REMOVED]')
     .replace(/\<\/?[^>]+(>|$)/g, '')
     .replace(/\b(system|assistant|user)\s*[:]/gi, '[ROLE_REMOVED]')
     .replace(/\b(ignore|forget|disregard)\s+(previous|all|your)\s+(instructions?|context|rules?)/gi, '[INSTRUCTION_REMOVED]')
-    .trim();
-  
-  sanitized = sanitized.slice(0, 2000).replace(/\s+/g, ' ');
-  return sanitized;
+    .trim()
+    .slice(0, 2000)
+    .replace(/\s+/g, ' ');
 }
 
 function checkRateLimit(userId: string): { allowed: boolean; reason?: string; microTasksRemaining?: number } {
@@ -77,7 +76,7 @@ function incrementMicroTaskCount(userId: string, aiCallsMade: number): void {
   }
 }
 
-function cleanupExpiredRateLimits() {
+function cleanupExpiredRateLimits(): void {
   const now = Date.now();
   const maxStoreSize = 1000; 
   
@@ -117,51 +116,52 @@ export const POST: APIRoute = async ({ request }) => {
     const body = await request.json();
     const { query, mode = 'workflow', taskId: clientTaskId } = body;
 
-    console.log(`[MICRO-TASK API] Received request - TaskId: ${clientTaskId}, Mode: ${mode}, Query length: ${query?.length || 0}`);
-    console.log(`[MICRO-TASK API] Micro-task calls remaining: ${rateLimitResult.microTasksRemaining}`);
+    console.log(`[AI-API] Received request - TaskId: ${clientTaskId}, Mode: ${mode}, Query length: ${query?.length || 0}`);
+    console.log(`[AI-API] Micro-task calls remaining: ${rateLimitResult.microTasksRemaining}`);
 
     if (!query || typeof query !== 'string') {
-      console.log(`[MICRO-TASK API] Invalid query for task ${clientTaskId}`);
+      console.log(`[AI-API] Invalid query for task ${clientTaskId}`);
       return apiError.badRequest('Query required');
     }
 
     if (!['workflow', 'tool'].includes(mode)) {
-      console.log(`[MICRO-TASK API] Invalid mode for task ${clientTaskId}: ${mode}`);
+      console.log(`[AI-API] Invalid mode for task ${clientTaskId}: ${mode}`);
       return apiError.badRequest('Invalid mode. Must be "workflow" or "tool"');
     }
 
     const sanitizedQuery = sanitizeInput(query);
     if (sanitizedQuery.includes('[FILTERED]')) {
-      console.log(`[MICRO-TASK API] Filtered input detected for task ${clientTaskId}`);
+      console.log(`[AI-API] Filtered input detected for task ${clientTaskId}`);
       return apiError.badRequest('Invalid input detected');
     }
 
     const taskId = clientTaskId || `ai_${userId}_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`;
     
-    console.log(`[MICRO-TASK API] About to enqueue micro-task pipeline ${taskId}`);
+    console.log(`[AI-API] Enqueueing pipeline task ${taskId}`);
     
     const result = await enqueueApiCall(() => 
       aiPipeline.processQuery(sanitizedQuery, mode)
     , taskId);
 
     if (!result || !result.recommendation) {
-      return apiServerError.unavailable('No response from micro-task AI pipeline');
+      return apiServerError.unavailable('No response from AI pipeline');
     }
 
     const stats = result.processingStats;
     const estimatedAICallsMade = stats.microTasksCompleted + stats.microTasksFailed;
     incrementMicroTaskCount(userId, estimatedAICallsMade);
 
-    console.log(`[MICRO-TASK API] Pipeline completed for ${taskId}:`);
-    console.log(`  - Mode: ${mode}`);
-    console.log(`  - User: ${userId}`);
-    console.log(`  - Query length: ${sanitizedQuery.length}`);
-    console.log(`  - Processing time: ${stats.processingTimeMs}ms`);
-    console.log(`  - Micro-tasks completed: ${stats.microTasksCompleted}`);
-    console.log(`  - Micro-tasks failed: ${stats.microTasksFailed}`);
-    console.log(`  - Estimated AI calls: ${estimatedAICallsMade}`);
-    console.log(`  - Embeddings used: ${stats.embeddingsUsed}`);
-    console.log(`  - Final items: ${stats.finalSelectedItems}`);
+    console.log(`[AI-API] Pipeline completed for ${taskId}:`, {
+      mode,
+      user: userId,
+      queryLength: sanitizedQuery.length,
+      processingTime: stats.processingTimeMs,
+      microTasksCompleted: stats.microTasksCompleted,
+      microTasksFailed: stats.microTasksFailed,
+      estimatedAICalls: estimatedAICallsMade,
+      embeddingsUsed: stats.embeddingsUsed,
+      finalItems: stats.finalSelectedItems
+    });
 
     const currentLimit = rateLimitStore.get(userId);
     const remainingMicroTasks = currentLimit ? 
@@ -175,7 +175,7 @@ export const POST: APIRoute = async ({ request }) => {
       query: sanitizedQuery,
       processingStats: {
         ...result.processingStats,
-        pipelineType: 'micro-task',
+        pipelineType: 'refactored',
         microTasksSuccessRate: stats.microTasksCompleted / (stats.microTasksCompleted + stats.microTasksFailed),
         averageTaskTime: stats.processingTimeMs / (stats.microTasksCompleted + stats.microTasksFailed),
         estimatedAICallsMade
@@ -191,18 +191,16 @@ export const POST: APIRoute = async ({ request }) => {
     });
 
   } catch (error) {
-    console.error('[MICRO-TASK API] Pipeline error:', error);
+    console.error('[AI-API] Pipeline error:', error);
     
     if (error.message.includes('embeddings')) {
-      return apiServerError.unavailable('Embeddings service error - using AI fallback');
-    } else if (error.message.includes('micro-task')) {
-      return apiServerError.unavailable('Micro-task pipeline error - some analysis steps failed');
-    } else if (error.message.includes('selector')) {
-      return apiServerError.unavailable('AI selector service error');
+      return apiServerError.unavailable('Embeddings service error');
+    } else if (error.message.includes('AI')) {
+      return apiServerError.unavailable('AI service error');
     } else if (error.message.includes('rate limit')) {
-      return apiError.rateLimit('AI service rate limits exceeded during micro-task processing');
+      return apiError.rateLimit('AI service rate limits exceeded');
     } else {
-      return apiServerError.internal('Micro-task AI pipeline error');
+      return apiServerError.internal('AI pipeline error');
     }
   }
 };
\ No newline at end of file
diff --git a/src/pages/contribute/index.astro b/src/pages/contribute/index.astro
index c24081b..47d8e30 100644
--- a/src/pages/contribute/index.astro
+++ b/src/pages/contribute/index.astro
@@ -1,5 +1,5 @@
 ---
-// src/pages/contribute/index.astro - Consolidated Auth
+// src/pages/contribute/index.astro
 import BaseLayout from '../../layouts/BaseLayout.astro';
 import { withAuth } from '../../utils/auth.js'; 
 
diff --git a/src/pages/index.astro b/src/pages/index.astro
index 0fc3b3f..28e64fe 100644
--- a/src/pages/index.astro
+++ b/src/pages/index.astro
@@ -510,9 +510,7 @@ if (aiAuthRequired) {
       }, 500);
     };
 
-    function handleSharedURL() {
-      console.log('[SHARE] Handling shared URL:', window.location.search);
-      
+    function handleSharedURL() {     
       const urlParams = new URLSearchParams(window.location.search);
       const toolParam = urlParams.get('tool');
       const viewParam = urlParams.get('view');
diff --git a/src/styles/global.css b/src/styles/global.css
index c940f8d..bfa694c 100644
--- a/src/styles/global.css
+++ b/src/styles/global.css
@@ -675,6 +675,7 @@ input[type="checkbox"] {
   border-radius: 0.25rem;
   font-size: 0.75rem;
   margin: 0.125rem;
+  max-height: 1.5rem;
 }
 
 /* ===================================================================
@@ -1806,11 +1807,44 @@ input[type="checkbox"] {
 .ai-textarea-section {
   flex: 1;
   min-width: 0;
+  display: flex;
+  flex-direction: column;
+}
+
+.ai-textarea-section textarea {
+  width: 100%;
+  height: 180px;
+  min-height: 180px;
+  max-height: 300px;
+  resize: vertical;
+  font-size: 0.9375rem;
+  line-height: 1.5;
+  padding: 0.75rem;
+  border: 1px solid var(--color-border);
+  border-radius: 0.375rem;
+  background-color: var(--color-bg);
+  color: var(--color-text);
+  transition: var(--transition-fast);
+  flex: 1;
+}
+
+.confidence-tooltip {
+  background: var(--color-bg) !important;
+  border: 2px solid var(--color-border) !important;
+  box-shadow: 0 8px 25px rgba(0, 0, 0, 0.15) !important;
+  z-index: 2000 !important;
+}
+
+.ai-textarea-section textarea:focus {
+  outline: none;
+  border-color: var(--color-primary);
+  box-shadow: 0 0 0 3px rgb(37 99 235 / 10%);
 }
 
 .ai-suggestions-section {
   flex: 0 0 320px;
-  min-height: 120px;
+  min-height: 180px;
+  height: auto;
 }
 
 .ai-input-container textarea {
@@ -2186,12 +2220,20 @@ input[type="checkbox"] {
   border-radius: 1rem;
   font-weight: 500;
   text-transform: uppercase;
+  position: relative;
+  z-index: 1;
 }
 
 .tool-rec-priority.high { background-color: var(--color-error); color: white; }
 .tool-rec-priority.medium { background-color: var(--color-warning); color: white; }
 .tool-rec-priority.low { background-color: var(--color-accent); color: white; }
 
+[data-theme="dark"] .confidence-tooltip {
+  background: var(--color-bg-secondary) !important;
+  border-color: var(--color-border) !important;
+  box-shadow: 0 8px 25px rgba(0, 0, 0, 0.4) !important;
+}
+
 .tool-rec-justification {
   font-size: 0.875rem;
   line-height: 1.5;
@@ -2610,7 +2652,8 @@ footer {
    ================================================================= */
 
 .smart-prompting-container {
-  height: 100%;
+  height: auto;
+  min-height: 180px;
   animation: smartPromptSlideIn 0.4s cubic-bezier(0.4, 0, 0.2, 1);
 }
 
@@ -2619,8 +2662,10 @@ footer {
   border: 1px solid var(--color-border);
   border-radius: 0.5rem;
   padding: 1rem;
-  height: 100%;
-  min-height: 120px;
+  height: auto;
+  min-height: 180px;
+  max-height: 400px;
+  overflow-y: auto;
   display: flex;
   flex-direction: column;
   opacity: 0.85;
@@ -2660,8 +2705,8 @@ footer {
 
 /* Smart Prompting Hint */
 .smart-prompting-hint {
-  height: 100%;
-  min-height: 120px;
+  height: 180px;
+  min-height: 180px;
   display: flex;
   align-items: center;
   animation: hintFadeIn 0.3s ease-in-out;
@@ -3375,8 +3420,8 @@ footer {
   
   .ai-suggestions-section {
     flex: 0 0 auto;
-    width: 100%;
-    max-width: none;
+    height: auto;
+    min-height: 120px;
   }
   
   .ai-textarea-section {
@@ -3386,6 +3431,11 @@ footer {
     min-height: 100px;
   }
 
+  .ai-textarea-section textarea {
+    height: 150px;
+    min-height: 150px;
+  }
+
   .ai-spotlight-content {
     flex-direction: column;
     gap: 0.75rem;
diff --git a/src/utils/aiPipeline.ts b/src/utils/aiPipeline.ts
index fbd64a9..2304838 100644
--- a/src/utils/aiPipeline.ts
+++ b/src/utils/aiPipeline.ts
@@ -1,18 +1,20 @@
 // src/utils/aiPipeline.ts
+import { getCompressedToolsDataForAI, getDataVersion } from './dataService.js';
+import { aiService } from './aiService.js';
+import { toolSelector, type SelectionContext } from './toolSelector.js';
+import { confidenceScoring, type AnalysisContext } from './confidenceScoring.js';
+import { embeddingsService } from './embeddings.js';
+import { auditService } from './auditService.js';
+import { JSONParser } from './jsonUtils.js';
+import { getPrompt } from '../config/prompts.js';
 
-import { getCompressedToolsDataForAI } from './dataService.js';
-import { embeddingsService, type EmbeddingData, type SimilarityResult } from './embeddings.js';
-import { AI_PROMPTS, getPrompt } from '../config/prompts.js';
-import { isToolHosted } from './toolHelpers.js';
-import { auditService, type AuditEntry } from './auditService.js';
-import dotenv from 'dotenv';
-
-dotenv.config();
-
-interface AIConfig {
-  endpoint: string;
-  apiKey: string;
-  model: string;
+interface PipelineConfig {
+  microTaskDelay: number;
+  taskRelevanceModeration: {
+    maxInitialScore: number;
+    maxWithPhaseBonus: number;
+    moderationThreshold: number;
+  };
 }
 
 interface MicroTaskResult {
@@ -21,27 +23,36 @@ interface MicroTaskResult {
   processingTimeMs: number;
   success: boolean;
   error?: string;
+  aiUsage?: {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+  };
 }
 
 interface AnalysisResult {
   recommendation: any;
   processingStats: {
-    embeddingsUsed: boolean;
     candidatesFromEmbeddings: number;
     finalSelectedItems: number;
     processingTimeMs: number;
     microTasksCompleted: number;
     microTasksFailed: number;
     contextContinuityUsed: boolean;
+    totalAITokensUsed: number;
+    auditEntriesGenerated: number;
+    aiModel: string;
+    toolsDataHash: string;
+    temperature: number;
+    maxTokensUsed: number;
   };
 }
 
-interface AnalysisContext {
+interface PipelineContext {
   userQuery: string;
   mode: string;
   filteredData: any;
   contextHistory: string[];
-  maxContextLength: number;
   currentContextLength: number;
   scenarioAnalysis?: string;
   problemAnalysis?: string;
@@ -61,948 +72,481 @@ interface AnalysisContext {
   }>;
   seenToolNames: Set<string>;
   embeddingsSimilarities: Map<string, number>;
-  aiSelectedTools?: any[];
-  aiSelectedConcepts?: any[];
-}
-
-interface ConfidenceMetrics {
-  overall: number;
-  semanticRelevance: number;
-  taskSuitability: number;
-  uncertaintyFactors: string[];
-  strengthIndicators: string[];
-}
-
-class ImprovedMicroTaskAIPipeline {
-  private config: AIConfig;
-  private maxSelectedItems: number;
-  private embeddingCandidates: number;
-  private similarityThreshold: number;
-  private microTaskDelay: number;
-  private embeddingSelectionLimit: number;
-  private embeddingConceptsLimit: number;
-  private noEmbeddingsToolLimit: number;
-  private noEmbeddingsConceptLimit: number;
-  private embeddingsMinTools: number;
-  private embeddingsMaxReductionRatio: number;
-  private methodSelectionRatio: number;
-  private softwareSelectionRatio: number;
-  private maxContextTokens: number;
-  private maxPromptTokens: number;
-  private confidenceConfig: {
-    semanticWeight: number;
-    suitabilityWeight: number;
-    minimumThreshold: number;
-    mediumThreshold: number;
-    highThreshold: number;
+  phaseMetadata?: {
+    phases: any[];
+    criticalPhaseIds: string[];
+    phaseComplexity: Map<string, number>;
   };
+}
+
+class AIPipeline {
+  private config: PipelineConfig;
+  private totalTokensUsed: number = 0;
 
   constructor() {
     this.config = {
-      endpoint: this.getRequiredEnv('AI_ANALYZER_ENDPOINT'),
-      apiKey: this.getRequiredEnv('AI_ANALYZER_API_KEY'),
-      model: this.getRequiredEnv('AI_ANALYZER_MODEL')
+      microTaskDelay: parseInt(process.env.AI_MICRO_TASK_DELAY_MS || '500', 10),
+      taskRelevanceModeration: {
+        maxInitialScore: 85,
+        maxWithPhaseBonus: 95,
+        moderationThreshold: 80
+      }
     };
-
-    this.maxSelectedItems = this.getEnvInt('AI_MAX_SELECTED_ITEMS', 25);
-    this.embeddingCandidates = this.getEnvInt('AI_EMBEDDING_CANDIDATES', 50);
-    this.similarityThreshold = this.getEnvFloat('AI_SIMILARITY_THRESHOLD', 0.3);
-    this.microTaskDelay = this.getEnvInt('AI_MICRO_TASK_DELAY_MS', 500);
-    this.embeddingSelectionLimit = this.getEnvInt('AI_EMBEDDING_SELECTION_LIMIT', 30);
-    this.embeddingConceptsLimit = this.getEnvInt('AI_EMBEDDING_CONCEPTS_LIMIT', 15);
-    this.noEmbeddingsToolLimit = this.getEnvInt('AI_NO_EMBEDDINGS_TOOL_LIMIT', 25);
-    this.noEmbeddingsConceptLimit = this.getEnvInt('AI_NO_EMBEDDINGS_CONCEPT_LIMIT', 10);
-    this.embeddingsMinTools = this.getEnvInt('AI_EMBEDDINGS_MIN_TOOLS', 8);
-    this.embeddingsMaxReductionRatio = this.getEnvFloat('AI_EMBEDDINGS_MAX_REDUCTION_RATIO', 0.75);
-    this.methodSelectionRatio = this.getEnvFloat('AI_METHOD_SELECTION_RATIO', 0.4);
-    this.softwareSelectionRatio = this.getEnvFloat('AI_SOFTWARE_SELECTION_RATIO', 0.5);
-    this.maxContextTokens = this.getEnvInt('AI_MAX_CONTEXT_TOKENS', 4000);
-    this.maxPromptTokens = this.getEnvInt('AI_MAX_PROMPT_TOKENS', 1500);
-
-    this.confidenceConfig = {
-      semanticWeight: this.getEnvFloat('CONFIDENCE_SEMANTIC_WEIGHT', 0.3),
-      suitabilityWeight: this.getEnvFloat('CONFIDENCE_SUITABILITY_WEIGHT', 0.7),
-      minimumThreshold: this.getEnvInt('CONFIDENCE_MINIMUM_THRESHOLD', 40),
-      mediumThreshold: this.getEnvInt('CONFIDENCE_MEDIUM_THRESHOLD', 60),
-      highThreshold: this.getEnvInt('CONFIDENCE_HIGH_THRESHOLD', 80)
-    };
-
-    console.log('[AI-PIPELINE] Initialized with audit service integration');
   }
 
-  private getRequiredEnv(key: string): string {
-    const value = process.env[key];
-    if (!value) {
-      throw new Error(`Missing required environment variable: ${key}`);
-    }
-    return value;
-  }
+  async processQuery(userQuery: string, mode: string): Promise<AnalysisResult> {
+    const startTime = Date.now();
+    let completedTasks = 0;
+    let failedTasks = 0;
+    this.totalTokensUsed = 0;
 
-  private getEnvInt(key: string, defaultValue: number): number {
-    const value = process.env[key];
-    return value ? parseInt(value, 10) : defaultValue;
-  }
+    auditService.clearAuditTrail();
 
-  private getEnvFloat(key: string, defaultValue: number): number {
-    const value = process.env[key];
-    return value ? parseFloat(value) : defaultValue;
-  }
-
-  // SIMPLIFIED AUDIT INTEGRATION - Use auditService instead of local implementation
-  private addAuditEntry(
-    context: AnalysisContext,
-    phase: string,
-    action: string,
-    input: any,
-    output: any,
-    confidence: number,
-    startTime: number,
-    metadata: Record<string, any> = {}
-  ): void {
-    auditService.addEntry(phase, action, input, output, confidence, startTime, metadata);
-  }
-
-  private calculateSelectionConfidence(result: any, candidateCount: number): number {
-    if (!result?.selectedTools) return 30;
-    
-    const selectionRatio = result.selectedTools.length / candidateCount;
-    const hasReasoning = result.reasoning && result.reasoning.length > 50;
-    
-    let confidence = 60;
-    
-    if (selectionRatio > 0.05 && selectionRatio < 0.3) confidence += 20;
-    else if (selectionRatio <= 0.05) confidence -= 10;
-    else confidence -= 15;
-    
-    if (hasReasoning) confidence += 15;
-    if (result.selectedConcepts?.length > 0) confidence += 5;
-    
-    return Math.min(95, Math.max(25, confidence));
-  }
-
-  private estimateTokens(text: string): number {
-    return Math.ceil(text.length / 4);
-  }
-
-  private addToContextHistory(context: AnalysisContext, newEntry: string): void {
-    const entryTokens = this.estimateTokens(newEntry);
-    
-    context.contextHistory.push(newEntry);
-    context.currentContextLength += entryTokens;
-    
-    while (context.currentContextLength > this.maxContextTokens && context.contextHistory.length > 1) {
-      const removed = context.contextHistory.shift()!;
-      context.currentContextLength -= this.estimateTokens(removed);
-    }
-  }
-
-  private safeParseJSON(jsonString: string, fallback: any = null): any {
     try {
-      let cleaned = jsonString.trim();
+      const toolsData = await getCompressedToolsDataForAI();
+      const aiConfig = aiService.getConfig();
+      const toolsDataHash = getDataVersion?.() || 'unknown';
       
-      const jsonBlockPatterns = [
-        /```json\s*([\s\S]*?)\s*```/i,
-        /```\s*([\s\S]*?)\s*```/i,
-        /\{[\s\S]*\}/,
-      ];
-      
-      for (const pattern of jsonBlockPatterns) {
-        const match = cleaned.match(pattern);
-        if (match) {
-          cleaned = match[1] || match[0];
-          break;
+      auditService.addEntry(
+        'initialization',
+        'tools-data-loaded',
+        { 
+          toolsFile: 'tools.yaml',
+          hashAlgorithm: 'SHA256'
+        },
+        { 
+          toolsDataHash: toolsDataHash,
+          toolsCount: toolsData.tools.length,
+          conceptsCount: toolsData.concepts.length,
+          domainsCount: toolsData.domains.length,
+          phasesCount: toolsData.phases.length
+        },
+        100,
+        Date.now(),
+        {
+          toolsDataHash: toolsDataHash,
+          verification: `Users can verify with: sha256sum src/data/tools.yaml`,
+          dataVersion: toolsDataHash.slice(0, 12),
+          reasoning: `Geladen: ${toolsData.tools.length} Tools, ${toolsData.concepts.length} Konzepte aus tools.yaml (Hash: ${toolsDataHash.slice(0, 12)}...)`
         }
-      }
+      );
       
-      if (!cleaned.endsWith('}') && !cleaned.endsWith(']')) {
-        console.warn('[AI-PIPELINE] JSON appears truncated, attempting recovery');
-        
-        let braceCount = 0;
-        let bracketCount = 0;
-        let inString = false;
-        let escaped = false;
-        let lastCompleteStructure = '';
-        
-        for (let i = 0; i < cleaned.length; i++) {
-          const char = cleaned[i];
-          
-          if (escaped) {
-            escaped = false;
-            continue;
-          }
-          
-          if (char === '\\') {
-            escaped = true;
-            continue;
-          }
-          
-          if (char === '"' && !escaped) {
-            inString = !inString;
-            continue;
-          }
-          
-          if (!inString) {
-            if (char === '{') braceCount++;
-            if (char === '}') braceCount--;
-            if (char === '[') bracketCount++;
-            if (char === ']') bracketCount--;
-            
-            if (braceCount === 0 && bracketCount === 0 && (char === '}' || char === ']')) {
-              lastCompleteStructure = cleaned.substring(0, i + 1);
-            }
-          }
-        }
-        
-        if (lastCompleteStructure) {
-          cleaned = lastCompleteStructure;
-        } else {
-          if (braceCount > 0) cleaned += '}';
-          if (bracketCount > 0) cleaned += ']';
-        }
-      }
-      
-      const parsed = JSON.parse(cleaned);
-      
-      if (parsed && typeof parsed === 'object') {
-        if (!parsed.selectedTools) parsed.selectedTools = [];
-        if (!parsed.selectedConcepts) parsed.selectedConcepts = [];
-        if (!Array.isArray(parsed.selectedTools)) parsed.selectedTools = [];
-        if (!Array.isArray(parsed.selectedConcepts)) parsed.selectedConcepts = [];
-      }
-      
-      return parsed;
-      
-    } catch (error) {
-      console.warn('[AI-PIPELINE] JSON parsing failed:', error.message);
-      
-      if (jsonString.includes('selectedTools') || jsonString.includes('selectedConcepts')) {
-        const selectedTools: string[] = [];
-        const selectedConcepts: string[] = [];
-        
-        const toolsMatch = jsonString.match(/"selectedTools"\s*:\s*\[([\s\S]*?)\]/i);
-        if (toolsMatch) {
-          const toolMatches = toolsMatch[1].match(/"([^"]+)"/g);
-          if (toolMatches) {
-            selectedTools.push(...toolMatches.map(match => match.replace(/"/g, '')));
-          }
-        }
-        
-        const conceptsMatch = jsonString.match(/"selectedConcepts"\s*:\s*\[([\s\S]*?)\]/i);
-        if (conceptsMatch) {
-          const conceptMatches = conceptsMatch[1].match(/"([^"]+)"/g);
-          if (conceptMatches) {
-            selectedConcepts.push(...conceptMatches.map(match => match.replace(/"/g, '')));
-          }
-        }
-        
-        if (selectedTools.length === 0 && selectedConcepts.length === 0) {
-          const allMatches = jsonString.match(/"([^"]+)"/g);
-          if (allMatches) {
-            const possibleNames = allMatches
-              .map(match => match.replace(/"/g, ''))
-              .filter(name => 
-                name.length > 2 && 
-                !['selectedTools', 'selectedConcepts', 'reasoning'].includes(name) &&
-                !name.includes(':') &&
-                !name.match(/^\d+$/)
-              )
-              .slice(0, 15);
-            
-            selectedTools.push(...possibleNames);
-          }
-        }
-        
-        if (selectedTools.length > 0 || selectedConcepts.length > 0) {
-          console.log('[AI-PIPELINE] JSON recovery successful:', selectedTools.length, 'tools,', selectedConcepts.length, 'concepts');
-          return {
-            selectedTools,
-            selectedConcepts,
-            reasoning: 'Recovered from malformed JSON response'
-          };
-        }
-      }
-      
-      return fallback;
-    }
-  }
-
-  private addToolToSelection(
-    context: AnalysisContext,
-    tool: any,
-    phase: string,
-    priority: string,
-    justification?: string,
-    taskRelevance?: number,
-    limitations?: string[]
-  ): boolean {
-    context.seenToolNames.add(tool.name);
-    if (!context.selectedTools) context.selectedTools = [];
-    
-    context.selectedTools.push({
-      tool,
-      phase,
-      priority,
-      justification,
-      taskRelevance,
-      limitations
-    });
-    
-    return true;
-  }
-
-  private generatePhaseQueryTemplates(phases: any[]): Record<string, string> {
-    const templates: Record<string, string> = {};
-    
-    phases.forEach((phase: any) => {
-      if (phase?.id && phase?.name) {
-        const phaseKeywords = [
-          'forensic',
-          phase.name.toLowerCase(),
-          ...(phase.description ? phase.description.toLowerCase().split(' ').filter((word: string) => word.length > 3) : []),
-          ...(phase.key_activities || []).map((activity: string) => activity.toLowerCase()),
-          ...(phase.typical_tools || []).map((tool: string) => tool.toLowerCase())
-        ].join(' ');
-        
-        templates[phase.id] = phaseKeywords;
-      }
-    });
-    
-    return templates;
-  }
-
-  private async getIntelligentCandidates(
-    userQuery: string,
-    toolsData: any,
-    mode: string,
-    context: AnalysisContext
-  ) {
-    let candidateTools: any[] = [];
-    let candidateConcepts: any[] = [];
-    let selectionMethod = 'unknown';
-    
-    context.embeddingsSimilarities = new Map<string, number>();
-    
-    try {
-      await embeddingsService.waitForInitialization();
-    } catch (error) {
-      console.error('[AI-PIPELINE] Embeddings initialization failed:', error);
-    }
-    
-    if (embeddingsService.isEnabled()) {
-      const embeddingsStart = Date.now();
-      const similarItems = await embeddingsService.findSimilar(
+      const context: PipelineContext = {
         userQuery,
-        this.embeddingCandidates,
-        this.similarityThreshold
-      ) as SimilarityResult[];
+        mode,
+        filteredData: {},
+        contextHistory: [],
+        currentContextLength: 0,
+        seenToolNames: new Set<string>(),
+        embeddingsSimilarities: new Map<string, number>(),
+        phaseMetadata: this.initializePhaseMetadata(toolsData.phases)
+      };
+
+      const candidateSelectionStart = Date.now();
+      const candidateData = await toolSelector.getIntelligentCandidates(userQuery, toolsData, mode, context);
       
-      console.log('[AI-PIPELINE] Embeddings found', similarItems.length, 'similar items');
+      const selectionConfidence = this.calculateToolSelectionConfidence(
+        candidateData.tools.length,
+        toolsData.tools.length,
+        candidateData.concepts.length
+      );
       
-      similarItems.forEach(item => {
-        context.embeddingsSimilarities.set(item.name, item.similarity);
-      });
+      auditService.addToolSelection(
+        candidateData.tools.map(t => t.name),
+        toolsData.tools.map(t => t.name),
+        selectionConfidence,
+        candidateSelectionStart,
+        {
+          toolsDataHash: toolsDataHash,
+          totalCandidatesFound: candidateData.tools.length + candidateData.concepts.length,
+          reductionRatio: candidateData.tools.length / toolsData.tools.length
+        }
+      );
       
-      const toolsMap = new Map(toolsData.tools.map((tool: any) => [tool.name, tool]));
-      const conceptsMap = new Map(toolsData.concepts.map((concept: any) => [concept.name, concept]));
-      
-      const similarTools = similarItems
-        .filter((item: any) => item.type === 'tool')
-        .map((item: any) => toolsMap.get(item.name))
-        .filter((tool: any): tool is NonNullable<any> => tool !== undefined && tool !== null);
-      
-      const similarConcepts = similarItems
-        .filter((item: any) => item.type === 'concept')
-        .map((item: any) => conceptsMap.get(item.name))
-        .filter((concept: any): concept is NonNullable<any> => concept !== undefined && concept !== null);
-      
-      const totalAvailableTools = toolsData.tools.length;
-      const reductionRatio = similarTools.length / totalAvailableTools;
-      
-      if (similarTools.length >= this.embeddingsMinTools && reductionRatio <= this.embeddingsMaxReductionRatio) {
-        candidateTools = similarTools;
-        candidateConcepts = similarConcepts;
-        selectionMethod = 'embeddings_candidates';
-        
-        console.log('[AI-PIPELINE] Using embeddings filtering:', totalAvailableTools, '→', similarTools.length, 'tools');
+      context.filteredData = candidateData;
+
+      const analysisResult = await this.analyzeScenario(context, startTime, toolsDataHash);
+      if (analysisResult.success) completedTasks++; else failedTasks++;
+      this.trackTokenUsage(analysisResult.aiUsage);
+      await this.delay(this.config.microTaskDelay);
+
+      const approachResult = await this.generateApproach(context, startTime, toolsDataHash);
+      if (approachResult.success) completedTasks++; else failedTasks++;
+      this.trackTokenUsage(approachResult.aiUsage);
+      await this.delay(this.config.microTaskDelay);
+
+      const considerationsResult = await this.generateCriticalConsiderations(context, startTime, toolsDataHash);
+      if (considerationsResult.success) completedTasks++; else failedTasks++;
+      this.trackTokenUsage(considerationsResult.aiUsage);
+      await this.delay(this.config.microTaskDelay);
+
+      if (mode === 'workflow') {
+        const workflowResults = await this.processWorkflowMode(context, toolsData, completedTasks, failedTasks, startTime, toolsDataHash);
+        completedTasks = workflowResults.completed;
+        failedTasks = workflowResults.failed;
       } else {
-        console.log('[AI-PIPELINE] Embeddings filtering insufficient, using full dataset');
-        candidateTools = toolsData.tools;
-        candidateConcepts = toolsData.concepts;
-        selectionMethod = 'full_dataset';
+        const toolResults = await this.processToolMode(context, completedTasks, failedTasks, startTime, toolsDataHash);
+        completedTasks = toolResults.completed;
+        failedTasks = toolResults.failed;
       }
-      
-      this.addAuditEntry(
-        context,
-        'retrieval',
-        'embeddings-search',
-        { query: userQuery, threshold: this.similarityThreshold, candidates: this.embeddingCandidates },
-        {
-          candidatesFound: similarItems.length,
-          reductionRatio: reductionRatio,
-          usingEmbeddings: selectionMethod === 'embeddings_candidates',
-          totalAvailable: totalAvailableTools,
-          filtered: similarTools.length
+
+      const knowledgeResult = await this.selectBackgroundKnowledge(context, startTime, toolsDataHash);
+      if (knowledgeResult.success) completedTasks++; else failedTasks++;
+      this.trackTokenUsage(knowledgeResult.aiUsage);
+      await this.delay(this.config.microTaskDelay);
+
+      const finalResult = await this.generateFinalRecommendations(context, startTime, toolsDataHash);
+      if (finalResult.success) completedTasks++; else failedTasks++;
+      this.trackTokenUsage(finalResult.aiUsage);
+
+      const recommendation = this.buildRecommendation(context, mode, finalResult.content, toolsDataHash);
+
+      const processingStats = {
+        candidatesFromEmbeddings: candidateData.tools.length,
+        finalSelectedItems: (context.selectedTools?.length || 0) + (context.backgroundKnowledge?.length || 0),
+        processingTimeMs: Date.now() - startTime,
+        microTasksCompleted: completedTasks,
+        microTasksFailed: failedTasks,
+        contextContinuityUsed: true,
+        totalAITokensUsed: this.totalTokensUsed,
+        auditEntriesGenerated: auditService.getCurrentAuditTrail().length,
+        aiModel: aiConfig.model,
+        toolsDataHash,
+        temperature: 0.3,
+        maxTokensUsed: 32768
+      };
+
+      const finalAuditTrail = auditService.finalizeAuditTrail();
+
+      return {
+        recommendation: {
+          ...recommendation,
+          auditTrail: auditService.isEnabled() ? finalAuditTrail : undefined,
+          processingStats
         },
-        selectionMethod === 'embeddings_candidates' ? 85 : 60,
-        embeddingsStart,
-        { selectionMethod, embeddingsEnabled: true }
-      );
-    } else {
-      console.log('[AI-PIPELINE] Embeddings disabled, using full dataset');
-      candidateTools = toolsData.tools;
-      candidateConcepts = toolsData.concepts;
-      selectionMethod = 'full_dataset';
-    }
-
-    const finalSelection = await this.aiSelectionWithFullData(
-      userQuery,
-      candidateTools,
-      candidateConcepts,
-      mode,
-      selectionMethod,
-      context
-    );
-    
-    return {
-      tools: finalSelection.selectedTools,
-      concepts: finalSelection.selectedConcepts,
-      domains: toolsData.domains,
-      phases: toolsData.phases,
-      'domain-agnostic-software': toolsData['domain-agnostic-software']
-    };
-  }
-
-  private async aiSelectionWithFullData(
-    userQuery: string,
-    candidateTools: any[],
-    candidateConcepts: any[],
-    mode: string,
-    selectionMethod: string,
-    context: AnalysisContext
-  ) {
-    const selectionStart = Date.now();
-    
-    const candidateMethods = candidateTools.filter((tool: any) => tool && tool.type === 'method');
-    const candidateSoftware = candidateTools.filter((tool: any) => tool && tool.type === 'software');
-    
-    console.log('[AI-PIPELINE] Tool selection candidates:', candidateMethods.length, 'methods,', candidateSoftware.length, 'software,', candidateConcepts.length, 'concepts');
-    
-    const methodsWithFullData = candidateMethods.map(this.createToolData);
-    const softwareWithFullData = candidateSoftware.map(this.createToolData);
-    const conceptsWithFullData = candidateConcepts.map(this.createConceptData);
-
-    let toolsToSend: any[];
-    let conceptsToSend: any[];
-    
-    if (selectionMethod === 'embeddings_candidates') {
-      const totalLimit = this.embeddingSelectionLimit;
-      const methodLimit = Math.ceil(totalLimit * this.methodSelectionRatio);
-      const softwareLimit = Math.floor(totalLimit * this.softwareSelectionRatio);
-      
-      toolsToSend = [
-        ...methodsWithFullData.slice(0, methodLimit),
-        ...softwareWithFullData.slice(0, softwareLimit)
-      ];
-      
-      const remainingCapacity = totalLimit - toolsToSend.length;
-      if (remainingCapacity > 0) {
-        if (methodsWithFullData.length > methodLimit) {
-          toolsToSend.push(...methodsWithFullData.slice(methodLimit, methodLimit + remainingCapacity));
-        } else if (softwareWithFullData.length > softwareLimit) {
-          toolsToSend.push(...softwareWithFullData.slice(softwareLimit, softwareLimit + remainingCapacity));
-        }
-      }
-      
-      conceptsToSend = conceptsWithFullData.slice(0, this.embeddingConceptsLimit);
-    } else {
-      const maxTools = this.noEmbeddingsToolLimit;
-      const maxConcepts = this.noEmbeddingsConceptLimit;
-      const methodLimit = Math.ceil(maxTools * 0.4);
-      const softwareLimit = Math.floor(maxTools * 0.5);
-      
-      toolsToSend = [
-        ...methodsWithFullData.slice(0, methodLimit),
-        ...softwareWithFullData.slice(0, softwareLimit)
-      ];
-      
-      const remainingCapacity = maxTools - toolsToSend.length;
-      if (remainingCapacity > 0) {
-        if (methodsWithFullData.length > methodLimit) {
-          toolsToSend.push(...methodsWithFullData.slice(methodLimit, methodLimit + remainingCapacity));
-        } else if (softwareWithFullData.length > softwareLimit) {
-          toolsToSend.push(...softwareWithFullData.slice(softwareLimit, softwareLimit + remainingCapacity));
-        }
-      }
-      
-      conceptsToSend = conceptsWithFullData.slice(0, maxConcepts);
-    }
-
-    const basePrompt = getPrompt('toolSelection', mode, userQuery, selectionMethod, this.maxSelectedItems);
-    const prompt = getPrompt('toolSelectionWithData', basePrompt, toolsToSend, conceptsToSend);
-
-    const estimatedTokens = this.estimateTokens(prompt);
-    console.log('[AI-PIPELINE] Sending to AI:', toolsToSend.filter((t: any) => t.type === 'method').length, 'methods,', toolsToSend.filter((t: any) => t.type === 'software').length, 'software,', conceptsToSend.length, 'concepts');
-
-    if (estimatedTokens > 35000) {
-      console.warn('[AI-PIPELINE] WARNING: Prompt tokens may exceed model limits:', estimatedTokens);
-    }
-
-    try {
-      const response = await this.callAI(prompt, 2500);
-      const result = this.safeParseJSON(response, null);
-      
-      if (!result || !Array.isArray(result.selectedTools) || !Array.isArray(result.selectedConcepts)) {
-        console.error('[AI-PIPELINE] AI selection returned invalid structure');
-        
-        this.addAuditEntry(
-          context,
-          'selection',
-          'ai-tool-selection-failed',
-          { candidateCount: candidateTools.length, mode },
-          { error: 'Invalid JSON structure' },
-          10,
-          selectionStart,
-          { aiModel: this.config.model, selectionMethod }
-        );
-        
-        throw new Error('AI selection failed to return valid tool and concept selection');
-      }
-
-      const totalSelected = result.selectedTools.length + result.selectedConcepts.length;
-      if (totalSelected === 0) {
-        throw new Error('AI selection returned empty selection');
-      }
-      
-      const toolsMap = new Map(candidateTools.map((tool: any) => [tool.name, tool]));
-      const conceptsMap = new Map(candidateConcepts.map((concept: any) => [concept.name, concept]));
-      
-      const selectedTools = result.selectedTools
-        .map((name: string) => toolsMap.get(name))
-        .filter((tool: any): tool is NonNullable<any> => tool !== undefined && tool !== null);
-      
-      const selectedConcepts = result.selectedConcepts
-        .map((name: string) => conceptsMap.get(name))
-        .filter((concept: any): concept is NonNullable<any> => concept !== undefined && concept !== null);
-      
-      const selectedMethods = selectedTools.filter((t: any) => t && t.type === 'method');
-      const selectedSoftware = selectedTools.filter((t: any) => t && t.type === 'software');
-      
-      console.log('[AI-PIPELINE] AI selected:', selectedMethods.length, 'methods,', selectedSoftware.length, 'software,', selectedConcepts.length, 'concepts');
-
-      const confidence = this.calculateSelectionConfidence(result, candidateTools.length + candidateConcepts.length);
-      
-      this.addAuditEntry(
-        context,
-        'selection',
-        'ai-tool-selection',
-        { candidateCount: candidateTools.length, mode },
-        {
-          selectedMethodCount: selectedMethods.length,
-          selectedSoftwareCount: selectedSoftware.length,
-          selectedConceptCount: selectedConcepts.length,
-          reasoning: result.reasoning?.slice(0, 200),
-          methodBalance: `${((selectedMethods.length / (selectedTools.length || 1)) * 100).toFixed(0)}%`
-        },
-        confidence,
-        selectionStart,
-        { aiModel: this.config.model, selectionMethod }
-      );
-      
-      return { selectedTools, selectedConcepts };
+        processingStats
+      };
 
     } catch (error) {
-      console.error('[AI-PIPELINE] AI selection failed:', error);
-      
-      this.addAuditEntry(
-        context,
-        'selection',
-        'ai-tool-selection-error',
-        { candidateCount: candidateTools.length, mode },
-        { error: error.message },
-        5,
-        selectionStart,
-        { aiModel: this.config.model, selectionMethod }
-      );
+      console.error('[AI-PIPELINE] Pipeline failed:', error);
       throw error;
     }
   }
 
-  private createToolData = (tool: any) => ({
-    name: tool.name,
-    type: tool.type,
-    description: tool.description,
-    domains: tool.domains,
-    phases: tool.phases,
-    platforms: tool.platforms || [],
-    tags: tool.tags || [],
-    skillLevel: tool.skillLevel,
-    license: tool.license,
-    accessType: tool.accessType,
-    projectUrl: tool.projectUrl,
-    knowledgebase: tool.knowledgebase,
-    related_concepts: tool.related_concepts || [],
-    related_software: tool.related_software || []
-  });
-
-  private createConceptData = (concept: any) => ({
-    name: concept.name,
-    type: 'concept',
-    description: concept.description,
-    domains: concept.domains,
-    phases: concept.phases,
-    tags: concept.tags || [],
-    skillLevel: concept.skillLevel,
-    related_concepts: concept.related_concepts || [],
-    related_software: concept.related_software || []
-  });
-
-  private async delay(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  private async callMicroTaskAI(
-    prompt: string,
-    context: AnalysisContext,
-    maxTokens: number = 500
-  ): Promise<MicroTaskResult> {
-    const startTime = Date.now();
-    
-    let contextPrompt = prompt;
-    if (context.contextHistory.length > 0) {
-      const contextSection = `BISHERIGE ANALYSE:\n${context.contextHistory.join('\n\n')}\n\nAKTUELLE AUFGABE:\n`;
-      const combinedPrompt = contextSection + prompt;
-      
-      if (this.estimateTokens(combinedPrompt) <= this.maxPromptTokens) {
-        contextPrompt = combinedPrompt;
-      }
-    }
-    
-    try {
-      const response = await this.callAI(contextPrompt, maxTokens);
-      
-      const result = {
-        taskType: 'micro-task',
-        content: response.trim(),
-        processingTimeMs: Date.now() - startTime,
-        success: true
+  private initializePhaseMetadata(phases: any[]): {
+    phases: any[];
+    criticalPhaseIds: string[];
+    phaseComplexity: Map<string, number>;
+  } {
+    if (!phases || !Array.isArray(phases)) {
+      return {
+        phases: [],
+        criticalPhaseIds: [],
+        phaseComplexity: new Map()
       };
-      
-      this.addAuditEntry(
-        context,
-        'micro-task',
-        'ai-analysis',
-        { promptLength: contextPrompt.length, maxTokens },
-        { responseLength: response.length },
-        response.length > 50 ? 80 : 60,
-        startTime,
-        { aiModel: this.config.model, contextUsed: context.contextHistory.length > 0 }
-      );
-      
-      return result;
-
-    } catch (error) {
-      const result = {
-        taskType: 'micro-task',
-        content: '',
-        processingTimeMs: Date.now() - startTime,
-        success: false,
-        error: error.message
-      };
-      
-      this.addAuditEntry(
-        context,
-        'micro-task',
-        'ai-analysis-failed',
-        { promptLength: contextPrompt.length, maxTokens },
-        { error: error.message },
-        5,
-        startTime,
-        { aiModel: this.config.model }
-      );
-      
-      return result;
     }
-  }
 
-  private calculateRecommendationConfidence(
-    tool: any,
-    context: AnalysisContext,
-    taskRelevance: number = 70,
-    limitations: string[] = []
-  ): ConfidenceMetrics {
-    const rawSemanticRelevance = context.embeddingsSimilarities.has(tool.name) ?
-      context.embeddingsSimilarities.get(tool.name)! * 100 : 50;
-    
-    let enhancedTaskSuitability = taskRelevance;
-    
-    if (context.mode === 'workflow') {
-      const toolSelection = context.selectedTools?.find((st: any) => st.tool && st.tool.name === tool.name);
-      if (toolSelection && tool.phases && Array.isArray(tool.phases) && tool.phases.includes(toolSelection.phase)) {
-        const phaseBonus = Math.min(15, 100 - taskRelevance);
-        enhancedTaskSuitability = Math.min(100, taskRelevance + phaseBonus);
-      }
-    }
-    
-    const overall = (
-      rawSemanticRelevance * this.confidenceConfig.semanticWeight +
-      enhancedTaskSuitability * this.confidenceConfig.suitabilityWeight
-    );
+    const criticalPhaseIds = phases
+      .filter(phase => {
+        const typicalToolsCount = phase.typical_tools?.length || 0;
+        const keyActivitiesCount = phase.key_activities?.length || 0;
+        return typicalToolsCount >= 3 || keyActivitiesCount >= 2;
+      })
+      .map(phase => phase.id);
 
-    const uncertaintyFactors = this.identifyUncertaintyFactors(tool, context, limitations, overall);
-    const strengthIndicators = this.identifyStrengthIndicators(tool, context, overall);
+    const phaseComplexity = new Map<string, number>();
+    phases.forEach(phase => {
+      let complexity = 1;
+      if (phase.typical_tools?.length > 5) complexity += 1;
+      if (phase.key_activities?.length > 3) complexity += 1;
+      if (phase.description?.length > 100) complexity += 1;
+      phaseComplexity.set(phase.id, complexity);
+    });
 
     return {
-      overall: Math.round(overall),
-      semanticRelevance: Math.round(rawSemanticRelevance),
-      taskSuitability: Math.round(enhancedTaskSuitability),
-      uncertaintyFactors,
-      strengthIndicators
+      phases,
+      criticalPhaseIds,
+      phaseComplexity
     };
   }
 
-  private identifyUncertaintyFactors(
-    tool: any,
-    context: AnalysisContext,
-    limitations: string[],
-    confidence: number
-  ): string[] {
-    const factors: string[] = [];
+  private calculateToolSelectionConfidence(
+    selectedCount: number,
+    totalCount: number,
+    conceptsCount: number
+  ): number {
+    let confidence = 50;
+    const selectionRatio = selectedCount / totalCount;
     
-    if (limitations?.length > 0) {
-      factors.push(...limitations.slice(0, 2));
+    if (selectionRatio >= 0.05 && selectionRatio <= 0.20) {
+      confidence += 25;
+    } else if (selectionRatio < 0.05) {
+      confidence += 15;
+    } else if (selectionRatio > 0.30) {
+      confidence -= 15;
     }
     
-    const similarity = context.embeddingsSimilarities.get(tool.name) || 0.5;
-    if (similarity < 0.7) {
-      factors.push('Geringe semantische Ähnlichkeit zur Anfrage');
+    if (conceptsCount > 0) confidence += 10;
+    if (selectedCount >= 8 && selectedCount <= 25) confidence += 10;
+    
+    return Math.min(95, Math.max(40, confidence));
+  }
+
+  private async processWorkflowMode(
+    context: PipelineContext, 
+    toolsData: any, 
+    completedTasks: number, 
+    failedTasks: number,
+    pipelineStart: number,
+    toolsDataHash: string
+  ): Promise<{ completed: number; failed: number }> {
+    const phases = toolsData.phases || [];
+    
+    for (const phase of phases) {
+      const phaseStart = Date.now();
+      const phaseTools = context.filteredData.tools.filter((tool: any) =>
+        tool && tool.phases && Array.isArray(tool.phases) && tool.phases.includes(phase.id)
+      );
+      
+      if (phaseTools.length === 0) continue;
+      
+      const selections = await toolSelector.selectToolsForPhase(context.userQuery, phase, phaseTools, context);
+      
+      const phaseConfidence = this.calculatePhaseSelectionConfidence(
+        selections.length,
+        phaseTools.length,
+        phase.id,
+        selections,
+        context.phaseMetadata
+      );
+      
+      auditService.addEntry(
+        'workflow-phase',
+        'phase-tool-selection',
+        { 
+          phaseId: phase.id, 
+          phaseName: phase.name, 
+          availableTools: phaseTools.map(t => t.name),
+          toolCount: phaseTools.length
+        },
+        { 
+          selectedTools: selections.map(s => s.toolName),
+          selectionCount: selections.length,
+          avgTaskRelevance: selections.length > 0 ? 
+            Math.round(selections.reduce((sum, s) => sum + (s.taskRelevance || 70), 0) / selections.length) : 0
+        },
+        phaseConfidence,
+        phaseStart,
+        {
+          toolsDataHash: toolsDataHash,
+          phaseId: phase.id,
+          availableToolsCount: phaseTools.length,
+          selectedToolsCount: selections.length,
+          microTaskType: 'phase-tool-selection',
+          reasoning: `${selections.length} von ${phaseTools.length} verfügbaren Tools für ${phase.name} ausgewählt - KI bewertete Eignung für spezifische Phasenaufgaben`
+        }
+      );
+      
+      selections.forEach((sel: any) => {
+        const tool = phaseTools.find((t: any) => t && t.name === sel.toolName);
+        if (tool) {
+          const moderatedTaskRelevance = this.moderateTaskRelevance(sel.taskRelevance);
+          const priority = this.derivePriorityFromScore(moderatedTaskRelevance);
+          const dynamicLimitations = this.generateDynamicLimitations(tool, phase, sel);
+          
+          this.addToolToSelection(context, tool, phase.id, priority, sel.justification, moderatedTaskRelevance, dynamicLimitations);
+          
+          auditService.addEntry(
+            'tool-reasoning',
+            'tool-added-to-phase',
+            { 
+              toolName: tool.name, 
+              phaseId: phase.id, 
+              taskRelevance: moderatedTaskRelevance,
+              priority: priority
+            },
+            { 
+              justification: sel.justification, 
+              limitations: dynamicLimitations,
+              addedToPhase: phase.name
+            },
+            moderatedTaskRelevance || 70,
+            phaseStart,
+            {
+              toolsDataHash: toolsDataHash,
+              toolType: tool.type,
+              priority,
+              moderationApplied: sel.taskRelevance !== moderatedTaskRelevance,
+              reasoning: `${tool.name} als ${priority}-Priorität für ${phase.name} ausgewählt: ${sel.justification?.slice(0, 100)}...`
+            }
+          );
+        }
+      });
+      
+      if (selections.length > 0) completedTasks++; else failedTasks++;
+      await this.delay(this.config.microTaskDelay);
     }
     
-    if (tool.skillLevel === 'expert' && /schnell|rapid|triage|urgent|sofort/i.test(context.userQuery)) {
-      factors.push('Experten-Tool für zeitkritisches Szenario');
+    const completionResult = await this.completeUnderrepresentedPhases(context, toolsData, pipelineStart, toolsDataHash);
+    completedTasks += completionResult.completed;
+    failedTasks += completionResult.failed;
+    
+    return { completed: completedTasks, failed: failedTasks };
+  }
+
+  private calculatePhaseSelectionConfidence(
+    selectedCount: number,
+    availableCount: number,
+    phaseId: string,
+    selections: any[],
+    phaseMetadata?: {
+      phases: any[];
+      criticalPhaseIds: string[];
+      phaseComplexity: Map<string, number>;
+    }
+  ): number {
+    let confidence = 60;
+    const isCritical = phaseMetadata?.criticalPhaseIds.includes(phaseId) || false;
+    const phaseComplexity = phaseMetadata?.phaseComplexity.get(phaseId) || 1;
+    
+    if (selectedCount > 0) {
+      confidence += 20;
+    } else {
+      return 30;
     }
     
-    if (tool.skillLevel === 'novice' && /komplex|erweitert|tiefgehend|advanced|forensisch/i.test(context.userQuery)) {
-      factors.push('Einsteiger-Tool für komplexe Analyse');
+    const ratio = selectedCount / availableCount;
+    if (ratio >= 0.2 && ratio <= 0.5) {
+      confidence += 15;
+    } else if (ratio < 0.2 && selectedCount >= 1) {
+      confidence += 10;
     }
     
-    if (tool.type === 'software' && !isToolHosted(tool) && tool.accessType === 'download') {
-      factors.push('Installation und Setup erforderlich');
+    if (isCritical && selectedCount >= 2) confidence += 10;
+    if (phaseComplexity > 2 && selectedCount >= phaseComplexity) confidence += 5;
+    
+    const avgRelevance = selections.length > 0 ? 
+      selections.reduce((sum, s) => sum + (s.taskRelevance || 70), 0) / selections.length : 0;
+    
+    if (avgRelevance >= 75) {
+      confidence += 10;
+    } else if (avgRelevance >= 65) {
+      confidence += 5;
+    }
+    
+    return Math.min(95, Math.max(30, confidence));
+  }
+
+  private generateDynamicLimitations(tool: any, phase: any, selection: any): string[] {
+    const limitations: string[] = [];
+    
+    if (selection.limitations && Array.isArray(selection.limitations)) {
+      limitations.push(...selection.limitations);
+    }
+    
+    if (tool.type === 'software' && !tool.projectUrl) {
+      limitations.push('Installation und Konfiguration erforderlich');
+    }
+    
+    if (tool.skillLevel === 'expert') {
+      limitations.push('Erfordert spezialisierte Kenntnisse');
     }
     
     if (tool.license === 'Proprietary') {
-      factors.push('Kommerzielle Software - Lizenzkosten zu beachten');
+      limitations.push('Kommerzielle Lizenz erforderlich');
     }
     
-    if (confidence < 60) {
-      factors.push('Moderate Gesamtbewertung - alternative Ansätze empfohlen');
+    if (phase.id === 'acquisition' && tool.type === 'method') {
+      limitations.push('Sorgfältige Dokumentation für Chain of Custody erforderlich');
     }
     
-    return factors.slice(0, 4);
+    return limitations.slice(0, 3);
   }
 
-  private identifyStrengthIndicators(tool: any, context: AnalysisContext, confidence: number): string[] {
-    const indicators: string[] = [];
+  private async processToolMode(
+    context: PipelineContext, 
+    completedTasks: number, 
+    failedTasks: number,
+    pipelineStart: number,
+    toolsDataHash: string
+  ): Promise<{ completed: number; failed: number }> {
+    const topTools = context.filteredData.tools.slice(0, 3);
     
-    const similarity = context.embeddingsSimilarities.get(tool.name) || 0.5;
-    if (similarity >= 0.7) {
-      indicators.push('Sehr gute semantische Übereinstimmung mit Ihrer Anfrage');
+    for (let i = 0; i < topTools.length; i++) {
+      const evaluationResult = await this.evaluateSpecificTool(context, topTools[i], i + 1, pipelineStart, toolsDataHash);
+      if (evaluationResult.success) completedTasks++; else failedTasks++;
+      this.trackTokenUsage(evaluationResult.aiUsage);
+      await this.delay(this.config.microTaskDelay);
     }
     
-    if (tool.knowledgebase === true) {
-      indicators.push('Umfassende Dokumentation und Wissensbasis verfügbar');
-    }
-    
-    if (isToolHosted(tool)) {
-      indicators.push('Sofort verfügbar über gehostete Lösung');
-    }
-    
-    if (tool.skillLevel === 'intermediate' || tool.skillLevel === 'advanced') {
-      indicators.push('Ausgewogenes Verhältnis zwischen Funktionalität und Benutzerfreundlichkeit');
-    }
-    
-    if (tool.type === 'method' && /methodik|vorgehen|prozess|ansatz/i.test(context.userQuery)) {
-      indicators.push('Methodischer Ansatz passt zu Ihrer prozeduralen Anfrage');
-    }
-    
-    return indicators.slice(0, 4);
-  }
-
-  private async analyzeScenario(context: AnalysisContext): Promise<MicroTaskResult> {
-    console.log('[AI-PIPELINE] Starting scenario analysis micro-task');
-    const isWorkflow = context.mode === 'workflow';
-    const prompt = getPrompt('scenarioAnalysis', isWorkflow, context.userQuery);
-
-    const result = await this.callMicroTaskAI(prompt, context, 400);
-    
-    if (result.success) {
-      if (isWorkflow) {
-        context.scenarioAnalysis = result.content;
-      } else {
-        context.problemAnalysis = result.content;
-      }
-      
-      this.addToContextHistory(context, `${isWorkflow ? 'Szenario' : 'Problem'}-Analyse: ${result.content.slice(0, 200)}...`);
-    }
-    
-    return result;
-  }
-
-  private async generateApproach(context: AnalysisContext): Promise<MicroTaskResult> {
-    console.log('[AI-PIPELINE] Starting investigation approach micro-task');
-    const isWorkflow = context.mode === 'workflow';
-    const prompt = getPrompt('investigationApproach', isWorkflow, context.userQuery);
-
-    const result = await this.callMicroTaskAI(prompt, context, 400);
-    
-    if (result.success) {
-      context.investigationApproach = result.content;
-      this.addToContextHistory(context, `${isWorkflow ? 'Untersuchungs' : 'Lösungs'}ansatz: ${result.content.slice(0, 200)}...`);
-    }
-    
-    return result;
-  }
-
-  private async generateCriticalConsiderations(context: AnalysisContext): Promise<MicroTaskResult> {
-    console.log('[AI-PIPELINE] Starting critical considerations micro-task');
-    const isWorkflow = context.mode === 'workflow';
-    const prompt = getPrompt('criticalConsiderations', isWorkflow, context.userQuery);
-
-    const result = await this.callMicroTaskAI(prompt, context, 350);
-    
-    if (result.success) {
-      context.criticalConsiderations = result.content;
-      this.addToContextHistory(context, `Kritische Überlegungen: ${result.content.slice(0, 200)}...`);
-    }
-    
-    return result;
-  }
-
-  private async selectToolsForPhase(context: AnalysisContext, phase: any): Promise<MicroTaskResult> {
-    console.log('[AI-PIPELINE] Starting phase tool selection micro-task for:', phase.id);
-    const phaseTools = context.filteredData.tools.filter((tool: any) =>
-      tool && tool.phases && Array.isArray(tool.phases) && tool.phases.includes(phase.id)
-    );
-
-    if (phaseTools.length === 0) {
-      console.log('[AI-PIPELINE] No tools available for phase:', phase.id);
-      return {
-        taskType: 'tool-selection',
-        content: JSON.stringify([]),
-        processingTimeMs: 0,
-        success: true
-      };
-    }
-
-    const phaseMethods = phaseTools.filter((t: any) => t && t.type === 'method');
-    const phaseSoftware = phaseTools.filter((t: any) => t && t.type === 'software');
-
-    console.log('[AI-PIPELINE] Phase tools available:', phaseMethods.length, 'methods,', phaseSoftware.length, 'software');
-
-    const prompt = getPrompt('phaseToolSelection', context.userQuery, phase, phaseTools);
-    const result = await this.callMicroTaskAI(prompt, context, 1000);
-    
-    if (result.success) {
-      const selections = this.safeParseJSON(result.content, []);
-      
-      if (Array.isArray(selections)) {
-        const validSelections = selections.filter((sel: any) => {
-          const matchingTool = phaseTools.find((tool: any) => tool && tool.name === sel.toolName);
-          if (!matchingTool) {
-            console.warn('[AI-PIPELINE] Invalid tool selection for phase:', phase.id, sel.toolName);
-          }
-          return !!matchingTool;
-        });
-        
-        console.log('[AI-PIPELINE] Valid selections for phase:', phase.id, validSelections.length);
-        
-        validSelections.forEach((sel: any) => {
-          const tool = phaseTools.find((t: any) => t && t.name === sel.toolName);
-          if (tool) {
-            const taskRelevance = typeof sel.taskRelevance === 'number' ?
-              sel.taskRelevance : parseInt(String(sel.taskRelevance)) || 70;
-            
-            const priority = this.derivePriorityFromScore(taskRelevance);
-            
-            this.addToolToSelection(context, tool, phase.id, priority, sel.justification, taskRelevance, sel.limitations);
-          }
-        });
-        
-        this.addAuditEntry(
-          context,
-          'micro-task',
-          'phase-tool-selection',
-          { phase: phase.id, availableTools: phaseTools.length },
-          {
-            validSelections: validSelections.length,
-            selectedTools: validSelections.map((s: any) => ({
-              name: s.toolName,
-              taskRelevance: s.taskRelevance,
-              derivedPriority: this.derivePriorityFromScore(s.taskRelevance)
-            }))
-          },
-          validSelections.length > 0 ? 75 : 30,
-          Date.now() - result.processingTimeMs,
-          { phaseName: phase.name }
-        );
-      }
-    }
-    
-    return result;
+    return { completed: completedTasks, failed: failedTasks };
   }
 
   private async completeUnderrepresentedPhases(
-    context: AnalysisContext,
-    toolsData: any,
-    originalQuery: string
-  ): Promise<void> {
+    context: PipelineContext, 
+    toolsData: any, 
+    pipelineStart: number,
+    toolsDataHash: string
+  ): Promise<{ completed: number; failed: number }> {
     const phases = toolsData.phases || [];
     const selectedPhases = new Map<string, number>();
+    let completedTasks = 0;
+    let failedTasks = 0;
     
     context.selectedTools?.forEach((st: any) => {
       const count = selectedPhases.get(st.phase) || 0;
       selectedPhases.set(st.phase, count + 1);
     });
     
-    console.log('[AI-PIPELINE] Phase coverage analysis complete');
-    
-    const phaseQueryTemplates = this.generatePhaseQueryTemplates(phases);
-    
     const underrepresentedPhases = phases.filter((phase: any) => {
       const count = selectedPhases.get(phase.id) || 0;
       return count <= 1;
     });
     
-    if (underrepresentedPhases.length === 0) {
-      console.log('[AI-PIPELINE] All phases adequately represented');
-      return;
-    }
-    
-    console.log('[AI-PIPELINE] Completing underrepresented phases:', underrepresentedPhases.map((p: any) => p.id).join(', '));
+    if (underrepresentedPhases.length === 0) return { completed: 0, failed: 0 };
     
     for (const phase of underrepresentedPhases) {
-      await this.completePhaseWithSemanticSearch(context, phase, phaseQueryTemplates, toolsData, originalQuery);
-      await this.delay(this.microTaskDelay);
+      const result = await this.completePhaseWithSemanticSearchAndAI(context, phase, toolsData, pipelineStart, toolsDataHash);
+      if (result.success) completedTasks++; else failedTasks++;
+      await this.delay(this.config.microTaskDelay);
     }
+    
+    return { completed: completedTasks, failed: failedTasks };
   }
 
-  private async completePhaseWithSemanticSearch(
-    context: AnalysisContext,
-    phase: any,
-    phaseQueryTemplates: Record<string, string>,
-    toolsData: any,
-    originalQuery: string
-  ): Promise<void> {
+  private async completePhaseWithSemanticSearchAndAI(
+    context: PipelineContext, 
+    phase: any, 
+    toolsData: any, 
+    pipelineStart: number,
+    toolsDataHash: string
+  ): Promise<MicroTaskResult> {
     const phaseStart = Date.now();
-    const phaseQuery = phaseQueryTemplates[phase.id] || `forensic ${phase.name.toLowerCase()} tools methods`;
-    
-    console.log('[AI-PIPELINE] Starting enhanced phase completion micro-task for:', phase.id);
+    const phaseQuery = `forensic ${phase.name.toLowerCase()} tools methods`;
     
     try {
       const phaseResults = await embeddingsService.findSimilar(phaseQuery, 20, 0.2);
       
+      auditService.addEmbeddingsSearch(
+        phaseQuery,
+        phaseResults,
+        0.2,
+        phaseStart,
+        {
+          toolsDataHash: toolsDataHash,
+          phaseId: phase.id,
+          phaseName: phase.name,
+          completionPurpose: 'underrepresented-phase-enhancement'
+        }
+      );
+      
       if (phaseResults.length === 0) {
-        console.log('[AI-PIPELINE] No semantic results for phase:', phase.id);
-        return;
+        return {
+          taskType: 'phase-completion',
+          content: '',
+          processingTimeMs: Date.now() - phaseStart,
+          success: true
+        };
       }
       
       const toolsMap = new Map(toolsData.tools.map((tool: any) => [tool.name, tool]));
@@ -1028,19 +572,28 @@ class ImprovedMicroTaskAIPipeline {
         .slice(0, 2);
       
       if (phaseTools.length === 0) {
-        console.log('[AI-PIPELINE] No suitable tools for phase completion:', phase.id);
-        return;
+        return {
+          taskType: 'phase-completion',
+          content: '',
+          processingTimeMs: Date.now() - phaseStart,
+          success: true
+        };
       }
       
-      const selectionPrompt = AI_PROMPTS.generatePhaseCompletionPrompt(originalQuery, phase, phaseTools, phaseConcepts);
-      const selectionResult = await this.callMicroTaskAI(selectionPrompt, context, 800);
+      const selectionPrompt = getPrompt('generatePhaseCompletionPrompt', context.userQuery, phase, phaseTools, phaseConcepts);
+      const selectionResult = await this.callMicroTaskAI(selectionPrompt, context, 'phase-completion-selection');
       
       if (!selectionResult.success) {
-        console.error('[AI-PIPELINE] Phase completion selection failed for:', phase.id);
-        return;
+        return {
+          taskType: 'phase-completion',
+          content: '',
+          processingTimeMs: Date.now() - phaseStart,
+          success: false,
+          error: 'Selection micro-task failed'
+        };
       }
       
-      const selection = this.safeParseJSON(selectionResult.content, { 
+      const selection = JSONParser.safeParseJSON(selectionResult.content, { 
         selectedTools: [], 
         selectedConcepts: [],
         completionReasoning: ''
@@ -1052,99 +605,260 @@ class ImprovedMicroTaskAIPipeline {
         .slice(0, 2);
       
       if (validTools.length === 0) {
-        console.log('[AI-PIPELINE] No valid tools selected for phase completion:', phase.id);
-        return;
+        return {
+          taskType: 'phase-completion',
+          content: selection.completionReasoning || '',
+          processingTimeMs: Date.now() - phaseStart,
+          success: true
+        };
       }
       
+      const actualToolsAdded = validTools.map(tool => tool.name);
+      
       for (const tool of validTools) {
-        console.log('[AI-PIPELINE] Generating reasoning for phase completion tool:', tool.name);
-        
         const reasoningPrompt = getPrompt(
           'phaseCompletionReasoning',
-          originalQuery,
+          context.userQuery,
           phase,
           tool.name,
           tool,
           selection.completionReasoning || 'Nachergänzung zur Vervollständigung der Phasenabdeckung'
         );
         
-        const reasoningResult = await this.callMicroTaskAI(reasoningPrompt, context, 400);
+        const reasoningResult = await this.callMicroTaskAI(reasoningPrompt, context, 'phase-completion-reasoning');
         
         let detailedJustification: string;
-        if (reasoningResult.success) {
+        let moderatedTaskRelevance = 75;
+        
+        if (reasoningResult.success && reasoningResult.content.trim()) {
           detailedJustification = reasoningResult.content.trim();
+          moderatedTaskRelevance = this.moderateTaskRelevance(80);
         } else {
           detailedJustification = `Nachträglich hinzugefügt zur Vervollständigung der ${phase.name}-Phase. Die ursprüngliche KI-Auswahl war zu spezifisch und hat wichtige Tools für diese Phase übersehen.`;
+          moderatedTaskRelevance = this.moderateTaskRelevance(75);
         }
         
+        const dynamicLimitations = this.generateCompletionLimitations(tool, phase, selection);
+        
         this.addToolToSelection(
           context,
           tool,
           phase.id,
           'medium',
           detailedJustification,
-          75,
-          ['Nachträgliche Ergänzung via semantische Phasensuche']
+          moderatedTaskRelevance,
+          dynamicLimitations
         );
-        
-        console.log('[AI-PIPELINE] Added phase completion tool with reasoning:', tool.name);
       }
       
-      this.addAuditEntry(
-        context,
-        'validation',
-        'phase-completion',
-        { 
-          phase: phase.id, 
-          phaseQuery, 
-          candidatesFound: phaseTools.length,
-          selectionReasoning: selection.completionReasoning
-        },
-        { 
-          toolsAdded: validTools.length, 
-          addedTools: validTools.map((t: any) => ({
-            name: t.name,
-            type: t.type,
-            reasoning: 'Generated via micro-task'
-          }))
-        },
-        validTools.length > 0 ? 80 : 40,
+      auditService.addPhaseCompletion(
+        phase.id,
+        actualToolsAdded,
+        selection.completionReasoning || `${actualToolsAdded.length} Tools für ${phase.name} hinzugefügt`,
         phaseStart,
-        { 
-          phaseCompletion: true, 
-          semanticSearch: true,
-          microTaskReasoning: true,
-          contextualExplanation: true
+        {
+          toolsDataHash: toolsDataHash,
+          toolsAdded: actualToolsAdded,
+          toolType: validTools[0]?.type,
+          semanticSimilarity: phaseResults.find(r => r.name === validTools[0]?.name)?.similarity,
+          completionReason: 'underrepresented-phase',
+          originalSelectionMissed: true,
+          aiReasoningUsed: true,
+          moderatedTaskRelevance: 75
         }
       );
       
-    } catch (error) {
-      console.error('[AI-PIPELINE] Enhanced phase completion failed for:', phase.id, error);
+      return {
+        taskType: 'phase-completion',
+        content: selection.completionReasoning || '',
+        processingTimeMs: Date.now() - phaseStart,
+        success: true
+      };
       
-      this.addAuditEntry(
-        context,
-        'validation',
-        'phase-completion-failed',
-        { phase: phase.id, phaseQuery },
-        { error: error.message },
-        10,
-        phaseStart,
-        { phaseCompletion: true, failed: true }
-      );
+    } catch (error) {
+      return {
+        taskType: 'phase-completion',
+        content: '',
+        processingTimeMs: Date.now() - phaseStart,
+        success: false,
+        error: error.message
+      };
     }
   }
 
-  private async evaluateSpecificTool(context: AnalysisContext, tool: any, rank: number): Promise<MicroTaskResult> {
-    console.log('[AI-PIPELINE] Starting tool evaluation micro-task for:', tool.name);
-    const existingSelection = context.selectedTools?.find((st: any) => st.tool && st.tool.name === tool.name);
-    const taskRelevance = existingSelection?.taskRelevance || 70;
-    const priority = this.derivePriorityFromScore(taskRelevance);
+  private generateCompletionLimitations(tool: any, phase: any, selection: any): string[] {
+    const limitations: string[] = [];
     
-    const prompt = getPrompt('toolEvaluation', context.userQuery, tool, rank, taskRelevance);
-    const result = await this.callMicroTaskAI(prompt, context, 1000);
+    limitations.push('Nachträgliche Ergänzung - ursprünglich nicht als Hauptmethode identifiziert');
+    
+    if (tool.skillLevel === 'expert') {
+      limitations.push('Erfordert Expertenwissen für optimale Nutzung');
+    }
+    
+    if (tool.type === 'software' && !tool.projectUrl) {
+      limitations.push('Zusätzliche Setup-Zeit erforderlich');
+    }
+    
+    if (phase.typical_tools && !phase.typical_tools.includes(tool.name)) {
+      limitations.push(`Nicht typisch für ${phase.name}-Phase - alternative Anwendung`);
+    }
+    
+    return limitations.slice(0, 3);
+  }
+
+  private moderateTaskRelevance(taskRelevance: number): number {
+    if (typeof taskRelevance !== 'number') return 70;
+    
+    let moderated = Math.min(taskRelevance, this.config.taskRelevanceModeration.maxInitialScore);
+    
+    if (moderated > this.config.taskRelevanceModeration.moderationThreshold) {
+      const excess = moderated - this.config.taskRelevanceModeration.moderationThreshold;
+      moderated = this.config.taskRelevanceModeration.moderationThreshold + (excess * 0.7);
+    }
+    
+    return Math.round(Math.min(moderated, this.config.taskRelevanceModeration.maxInitialScore));
+  }
+
+  private async analyzeScenario(context: PipelineContext, pipelineStart: number, toolsDataHash: string): Promise<MicroTaskResult> {
+    const taskStart = Date.now();
+    const isWorkflow = context.mode === 'workflow';
+    const prompt = getPrompt('scenarioAnalysis', isWorkflow, context.userQuery);
+
+    const result = await this.callMicroTaskAI(prompt, context, 'scenario-analysis');
     
     if (result.success) {
-      const evaluation = this.safeParseJSON(result.content, {
+      if (isWorkflow) {
+        context.scenarioAnalysis = result.content;
+      } else {
+        context.problemAnalysis = result.content;
+      }
+      
+      this.addToContextHistory(context, `${isWorkflow ? 'Szenario' : 'Problem'}-Analyse: ${result.content.slice(0, 200)}...`);
+      
+      const confidence = auditService.calculateAIResponseConfidence(
+        result.content,
+        { min: 50, max: 300 },
+        'scenario-analysis'
+      );
+      
+      auditService.addAIDecision(
+        'contextual-analysis',
+        prompt,
+        result.content,
+        confidence,
+        `Analysierte ${isWorkflow ? 'Szenario' : 'Problem'} basierend auf Nutzereingabe: "${context.userQuery.slice(0, 100)}..." - Identifizierte Kernaspekte und Herausforderungen für Untersuchung`,
+        taskStart,
+        {
+          toolsDataHash: toolsDataHash,
+          microTaskType: 'scenario-analysis',
+          analysisType: isWorkflow ? 'scenario' : 'problem',
+          contentLength: result.content.length,
+          decisionBasis: 'ai-analysis',
+          aiModel: aiService.getConfig().model,
+          ...result.aiUsage
+        }
+      );
+    }
+    
+    return result;
+  }
+
+  private async generateApproach(context: PipelineContext, pipelineStart: number, toolsDataHash: string): Promise<MicroTaskResult> {
+    const taskStart = Date.now();
+    const isWorkflow = context.mode === 'workflow';
+    const prompt = getPrompt('investigationApproach', isWorkflow, context.userQuery);
+
+    const result = await this.callMicroTaskAI(prompt, context, 'investigation-approach');
+    
+    if (result.success) {
+      context.investigationApproach = result.content;
+      this.addToContextHistory(context, `${isWorkflow ? 'Untersuchungs' : 'Lösungs'}ansatz: ${result.content.slice(0, 200)}...`);
+      
+      const confidence = auditService.calculateAIResponseConfidence(
+        result.content,
+        { min: 50, max: 300 },
+        'investigation-approach'
+      );
+      
+      auditService.addAIDecision(
+        'contextual-analysis',
+        prompt,
+        result.content,
+        confidence,
+        `Entwickelte ${isWorkflow ? 'Untersuchungs' : 'Lösungs'}ansatz unter Berücksichtigung der Szenario-Analyse - Strukturierte Herangehensweise für forensische Methodik`,
+        taskStart,
+        {
+          toolsDataHash: toolsDataHash,
+          microTaskType: 'investigation-approach',
+          approachType: isWorkflow ? 'investigation' : 'solution',
+          contentLength: result.content.length,
+          contextHistoryLength: context.contextHistory.length,
+          decisionBasis: 'ai-analysis',
+          aiModel: aiService.getConfig().model,
+          ...result.aiUsage
+        }
+      );
+    }
+    
+    return result;
+  }
+
+  private async generateCriticalConsiderations(context: PipelineContext, pipelineStart: number, toolsDataHash: string): Promise<MicroTaskResult> {
+    const taskStart = Date.now();
+    const isWorkflow = context.mode === 'workflow';
+    const prompt = getPrompt('criticalConsiderations', isWorkflow, context.userQuery);
+
+    const result = await this.callMicroTaskAI(prompt, context, 'critical-considerations');
+    
+    if (result.success) {
+      context.criticalConsiderations = result.content;
+      this.addToContextHistory(context, `Kritische Überlegungen: ${result.content.slice(0, 200)}...`);
+      
+      const confidence = auditService.calculateAIResponseConfidence(
+        result.content,
+        { min: 40, max: 250 },
+        'critical-considerations'
+      );
+      
+      auditService.addAIDecision(
+        'contextual-analysis',
+        prompt,
+        result.content,
+        confidence,
+        'Identifizierte kritische Überlegungen für forensische Untersuchung - Berücksichtigung von Beweissicherung, Chain of Custody und methodischen Herausforderungen',
+        taskStart,
+        {
+          toolsDataHash: toolsDataHash,
+          microTaskType: 'critical-considerations',
+          contentLength: result.content.length,
+          decisionBasis: 'ai-analysis',
+          aiModel: aiService.getConfig().model,
+          ...result.aiUsage
+        }
+      );
+    }
+    
+    return result;
+  }
+
+  private async evaluateSpecificTool(
+    context: PipelineContext, 
+    tool: any, 
+    rank: number,
+    pipelineStart: number,
+    toolsDataHash: string
+  ): Promise<MicroTaskResult> {
+    const taskStart = Date.now();
+    const existingSelection = context.selectedTools?.find((st: any) => st.tool && st.tool.name === tool.name);
+    const originalTaskRelevance = existingSelection?.taskRelevance || 70;
+    const moderatedTaskRelevance = this.moderateTaskRelevance(originalTaskRelevance);
+    const priority = this.derivePriorityFromScore(moderatedTaskRelevance);
+    
+    const prompt = getPrompt('toolEvaluation', context.userQuery, tool, rank, moderatedTaskRelevance);
+    const result = await this.callMicroTaskAI(prompt, context, 'tool-evaluation');
+    
+    if (result.success) {
+      const evaluation = JSONParser.safeParseJSON(result.content, {
         detailed_explanation: 'Evaluation failed',
         implementation_approach: '',
         pros: [],
@@ -1157,33 +871,51 @@ class ImprovedMicroTaskAIPipeline {
         evaluation: {
           ...evaluation,
           rank,
-          task_relevance: taskRelevance
+          task_relevance: moderatedTaskRelevance
         }
-      }, 'evaluation', priority, evaluation.detailed_explanation,
-      taskRelevance, evaluation.limitations);
+      }, 'evaluation', priority, evaluation.detailed_explanation, moderatedTaskRelevance, evaluation.limitations);
       
-      this.addAuditEntry(
-        context,
-        'micro-task',
+      const responseConfidence = auditService.calculateAIResponseConfidence(
+        result.content,
+        { min: 200, max: 800 },
+        'tool-evaluation'
+      );
+      
+      const finalConfidence = Math.max(responseConfidence, moderatedTaskRelevance);
+      
+      auditService.addAIDecision(
         'tool-evaluation',
-        { toolName: tool.name, rank, existingTaskRelevance: taskRelevance },
+        prompt,
+        result.content,
+        finalConfidence,
+        `Bewertete Tool "${tool.name}" (Rang ${rank}) - Analysierte Eignung für spezifische Aufgabenstellung mit Fokus auf praktische Anwendbarkeit und methodische Integration`,
+        taskStart,
         {
-          hasExplanation: !!evaluation.detailed_explanation,
-          hasImplementationApproach: !!evaluation.implementation_approach,
+          toolsDataHash: toolsDataHash,
+          microTaskType: 'tool-evaluation',
+          toolName: tool.name,
+          toolType: tool.type,
+          rank,
+          originalTaskRelevance,
+          moderatedTaskRelevance,
+          responseConfidence,
+          finalConfidence,
+          moderationApplied: originalTaskRelevance !== moderatedTaskRelevance,
+          evaluationParsed: !!evaluation.detailed_explanation,
           prosCount: evaluation.pros?.length || 0,
-          limitationsCount: evaluation.limitations?.length || 0
-        },
-        70,
-        Date.now() - result.processingTimeMs,
-        { toolType: tool.type }
+          limitationsCount: evaluation.limitations?.length || 0,
+          decisionBasis: 'ai-analysis',
+          aiModel: aiService.getConfig().model,
+          ...result.aiUsage
+        }
       );
     }
     
     return result;
   }
 
-  private async selectBackgroundKnowledge(context: AnalysisContext): Promise<MicroTaskResult> {
-    console.log('[AI-PIPELINE] Starting background knowledge selection micro-task');
+  private async selectBackgroundKnowledge(context: PipelineContext, pipelineStart: number, toolsDataHash: string): Promise<MicroTaskResult> {
+    const taskStart = Date.now();
     const availableConcepts = context.filteredData.concepts;
     
     if (availableConcepts.length === 0) {
@@ -1197,10 +929,10 @@ class ImprovedMicroTaskAIPipeline {
 
     const selectedToolNames = context.selectedTools?.map((st: any) => st.tool && st.tool.name).filter(Boolean) || [];
     const prompt = getPrompt('backgroundKnowledgeSelection', context.userQuery, context.mode, selectedToolNames, availableConcepts);
-    const result = await this.callMicroTaskAI(prompt, context, 700);
+    const result = await this.callMicroTaskAI(prompt, context, 'background-knowledge');
     
     if (result.success) {
-      const selections = this.safeParseJSON(result.content, []);
+      const selections = JSONParser.safeParseJSON(result.content, []);
       
       if (Array.isArray(selections)) {
         context.backgroundKnowledge = selections.filter((sel: any) =>
@@ -1210,15 +942,42 @@ class ImprovedMicroTaskAIPipeline {
           relevance: sel.relevance
         }));
         
-        this.addAuditEntry(
-          context,
-          'micro-task',
-          'background-knowledge-selection',
-          { availableConcepts: availableConcepts.length },
-          { selectedConcepts: context.backgroundKnowledge?.length || 0 },
-          context.backgroundKnowledge && context.backgroundKnowledge.length > 0 ? 75 : 40,
-          Date.now() - result.processingTimeMs,
-          {}
+        const responseConfidence = auditService.calculateAIResponseConfidence(
+          result.content,
+          { min: 100, max: 500 },
+          'background-knowledge'
+        );
+        
+        const selectionQualityBonus = this.calculateKnowledgeSelectionBonus(context.backgroundKnowledge, availableConcepts);
+        const finalConfidence = Math.min(95, responseConfidence + selectionQualityBonus);
+        
+        auditService.addEntry(
+          'knowledge-synthesis',
+          'concept-selection',
+          { 
+            availableConcepts: availableConcepts.map(c => c.name),
+            selectedToolsContext: selectedToolNames,
+            selectionCriteria: 'methodische Fundierung'
+          },
+          { 
+            selectedConcepts: context.backgroundKnowledge.map(bk => bk.concept.name),
+            selectionReasonings: context.backgroundKnowledge.map(bk => bk.relevance)
+          },
+          finalConfidence,
+          taskStart,
+          {
+            toolsDataHash: toolsDataHash,
+            microTaskType: 'background-knowledge',
+            availableConceptsCount: availableConcepts.length,
+            selectedConceptsCount: context.backgroundKnowledge.length,
+            selectionRatio: context.backgroundKnowledge.length / availableConcepts.length,
+            responseConfidence,
+            selectionQualityBonus,
+            decisionBasis: 'ai-analysis',
+            reasoning: `Wählte ${context.backgroundKnowledge.length} von ${availableConcepts.length} verfügbaren Konzepten für methodische Fundierung der Empfehlungen`,
+            aiModel: aiService.getConfig().model,
+            ...result.aiUsage
+          }
         );
       }
     }
@@ -1226,245 +985,81 @@ class ImprovedMicroTaskAIPipeline {
     return result;
   }
 
-  private async generateFinalRecommendations(context: AnalysisContext): Promise<MicroTaskResult> {
-    console.log('[AI-PIPELINE] Starting final recommendations micro-task');
+  private calculateKnowledgeSelectionBonus(
+    selectedKnowledge: Array<{concept: any; relevance: string}>,
+    availableConcepts: any[]
+  ): number {
+    let bonus = 0;
+    
+    if (selectedKnowledge.length > 0) bonus += 10;
+    
+    const ratio = selectedKnowledge.length / availableConcepts.length;
+    if (ratio >= 0.1 && ratio <= 0.3) bonus += 15;
+    
+    const hasGoodReasonings = selectedKnowledge.some(bk => 
+      bk.relevance && bk.relevance.length > 30
+    );
+    if (hasGoodReasonings) bonus += 10;
+    
+    return bonus;
+  }
+
+  private async generateFinalRecommendations(context: PipelineContext, pipelineStart: number, toolsDataHash: string): Promise<MicroTaskResult> {
+    const taskStart = Date.now();
     const selectedToolNames = context.selectedTools?.map((st: any) => st.tool && st.tool.name).filter(Boolean) || [];
     const prompt = getPrompt('finalRecommendations', context.mode === 'workflow', context.userQuery, selectedToolNames);
     
-    const result = await this.callMicroTaskAI(prompt, context, 350);
+    const result = await this.callMicroTaskAI(prompt, context, 'final-recommendations');
+    
+    if (result.success) {
+      const confidence = auditService.calculateAIResponseConfidence(
+        result.content,
+        { min: 60, max: 250 },
+        'final-recommendations'
+      );
+      
+      const contextBonus = this.calculateSynthesisBonus(selectedToolNames, context);
+      const finalConfidence = Math.min(95, confidence + contextBonus);
+      
+      auditService.addAIDecision(
+        'synthesis',
+        prompt,
+        result.content,
+        finalConfidence,
+        `Generierte abschließende ${context.mode}-Empfehlungen basierend auf ausgewählten ${selectedToolNames.length} Tools - Synthese aller Analyseschritte zu kohärenter Handlungsempfehlung`,
+        taskStart,
+        {
+          toolsDataHash: toolsDataHash,
+          microTaskType: 'final-recommendations',
+          mode: context.mode,
+          selectedToolsCount: selectedToolNames.length,
+          contentLength: result.content.length,
+          responseConfidence: confidence,
+          contextBonus,
+          decisionBasis: 'ai-analysis',
+          aiModel: aiService.getConfig().model,
+          ...result.aiUsage
+        }
+      );
+    }
+    
     return result;
   }
 
-  private async callAI(prompt: string, maxTokens: number = 1500): Promise<string> {
-    const endpoint = this.config.endpoint;
-    const apiKey = this.config.apiKey;
-    const model = this.config.model;
+  private calculateSynthesisBonus(selectedToolNames: string[], context: PipelineContext): number {
+    let bonus = 0;
     
-    let headers: Record<string, string> = {
-      'Content-Type': 'application/json'
-    };
+    if (selectedToolNames.length >= 3) bonus += 10;
+    if (context.backgroundKnowledge && context.backgroundKnowledge.length > 0) bonus += 10;
+    if (context.scenarioAnalysis || context.problemAnalysis) bonus += 5;
+    if (context.investigationApproach) bonus += 5;
     
-    if (apiKey) {
-      headers['Authorization'] = `Bearer ${apiKey}`;
-    }
-    
-    const requestBody = {
-      model,
-      messages: [{ role: 'user', content: prompt }],
-      max_tokens: maxTokens,
-      temperature: 0.3
-    };
-    
-    try {
-      const response = await fetch(`${endpoint}/v1/chat/completions`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(requestBody)
-      });
-
-      if (!response.ok) {
-        const errorText = await response.text();
-        console.error('[AI-PIPELINE] AI API Error:', response.status, errorText);
-        throw new Error(`AI API error: ${response.status} - ${errorText}`);
-      }
-
-      const data = await response.json();
-      const content = data.choices?.[0]?.message?.content;
-      
-      if (!content) {
-        console.error('[AI-PIPELINE] No response content from AI model');
-        throw new Error('No response from AI model');
-      }
-
-      return content;
-      
-    } catch (error) {
-      console.error('[AI-PIPELINE] AI service call failed:', error.message);
-      throw error;
-    }
+    return bonus;
   }
 
-  private derivePriorityFromScore(taskRelevance: number): string {
-    if (taskRelevance >= 80) return 'high';
-    if (taskRelevance >= 60) return 'medium';
-    return 'low';
-  }
-
-  private async performAISelection(
-    filteredData: any,
-    userQuery: string,
-    mode: string,
-    context: AnalysisContext
-  ): Promise<{ tools: any[], concepts: any[] }> {
-    const result = await this.aiSelectionWithFullData(
-      userQuery,
-      filteredData.tools,
-      filteredData.concepts,
-      mode,
-      embeddingsService.isEnabled() ? 'embeddings_candidates' : 'full_dataset',
-      context
-    );
-    
-    console.log('[AI-PIPELINE] AI selection complete:', result.selectedTools.length, 'tools,', result.selectedConcepts.length, 'concepts');
-    
-    return {
-      tools: result.selectedTools,
-      concepts: result.selectedConcepts
-    };
-  }
-
-  async processQuery(userQuery: string, mode: string): Promise<AnalysisResult> {
-    const startTime = Date.now();
-    let completeTasks = 0;
-    let failedTasks = 0;
-    
-    console.log('[AI-PIPELINE] Starting', mode, 'query processing');
-
-    // CLEAR AUDIT TRAIL for new analysis
-    auditService.clearAuditTrail();
-
-    try {
-      const toolsData = await getCompressedToolsDataForAI();
-      
-      const context: AnalysisContext = {
-        userQuery,
-        mode,
-        filteredData: {},
-        contextHistory: [],
-        maxContextLength: this.maxContextTokens,
-        currentContextLength: 0,
-        seenToolNames: new Set<string>(),
-        embeddingsSimilarities: new Map<string, number>(),
-        aiSelectedTools: [],
-        aiSelectedConcepts: []
-      };
-
-      const filteredData = await this.getIntelligentCandidates(userQuery, toolsData, mode, context);
-      const aiSelection = await this.performAISelection(filteredData, userQuery, mode, context);
-      
-      context.aiSelectedTools = aiSelection.tools;
-      context.aiSelectedConcepts = aiSelection.concepts;
-      
-      context.filteredData = {
-        tools: aiSelection.tools,
-        concepts: aiSelection.concepts,
-        domains: filteredData.domains,
-        phases: filteredData.phases,
-        'domain-agnostic-software': filteredData['domain-agnostic-software']
-      };
-
-      this.addAuditEntry(
-        context,
-        'initialization',
-        'pipeline-start',
-        { userQuery, mode, toolsDataLoaded: !!toolsData },
-        { candidateTools: filteredData.tools.length, candidateConcepts: filteredData.concepts.length },
-        90,
-        startTime,
-        { auditEnabled: auditService.isEnabled() }
-      );
-   
-      const analysisResult = await this.analyzeScenario(context);
-      if (analysisResult.success) completeTasks++; else failedTasks++;
-      await this.delay(this.microTaskDelay);
-
-      const approachResult = await this.generateApproach(context);
-      if (approachResult.success) completeTasks++; else failedTasks++;
-      await this.delay(this.microTaskDelay);
-
-      const considerationsResult = await this.generateCriticalConsiderations(context);
-      if (considerationsResult.success) completeTasks++; else failedTasks++;
-      await this.delay(this.microTaskDelay);
-
-      if (mode === 'workflow') {
-        const phases = toolsData.phases || [];
-        
-        for (const phase of phases) {
-          const toolSelectionResult = await this.selectToolsForPhase(context, phase);
-          if (toolSelectionResult.success) completeTasks++; else failedTasks++;
-          await this.delay(this.microTaskDelay);
-        }
-        
-        await this.completeUnderrepresentedPhases(context, toolsData, userQuery);
-        
-      } else {
-        const topTools = filteredData.tools.slice(0, 3);
-        for (let i = 0; i < topTools.length; i++) {
-          const evaluationResult = await this.evaluateSpecificTool(context, topTools[i], i + 1);
-          if (evaluationResult.success) completeTasks++; else failedTasks++;
-          await this.delay(this.microTaskDelay);
-        }
-      }
-
-      const knowledgeResult = await this.selectBackgroundKnowledge(context);
-      if (knowledgeResult.success) completeTasks++; else failedTasks++;
-      await this.delay(this.microTaskDelay);
-
-      const finalResult = await this.generateFinalRecommendations(context);
-      if (finalResult.success) completeTasks++; else failedTasks++;
-
-      const recommendation = this.buildRecommendation(context, mode, finalResult.content);
-
-      this.addAuditEntry(
-        context,
-        'completion',
-        'pipeline-end',
-        { completedTasks: completeTasks, failedTasks },
-        { finalRecommendation: !!recommendation, auditEntriesGenerated: auditService.getCurrentAuditTrail().length },
-        completeTasks > failedTasks ? 85 : 60,
-        startTime,
-        { totalProcessingTimeMs: Date.now() - startTime }
-      );
-
-      const processingStats = {
-        embeddingsUsed: embeddingsService.isEnabled(),
-        candidatesFromEmbeddings: filteredData.tools.length,
-        finalSelectedItems: (context.selectedTools?.length || 0) + (context.backgroundKnowledge?.length || 0),
-        processingTimeMs: Date.now() - startTime,
-        microTasksCompleted: completeTasks,
-        microTasksFailed: failedTasks,
-        contextContinuityUsed: true
-      };
-
-      console.log('[AI-PIPELINE] Processing complete. Tasks completed:', completeTasks, 'failed:', failedTasks);
-
-      // FINALIZE AUDIT TRAIL and get final trail
-      const finalAuditTrail = auditService.finalizeAuditTrail();
-
-      return {
-        recommendation: {
-          ...recommendation,
-          auditTrail: auditService.isEnabled() ? finalAuditTrail : undefined
-        },
-        processingStats
-      };
-
-    } catch (error) {
-      console.error('[AI-PIPELINE] Processing failed:', error);
-      throw error;
-    }
-  }
-
-  private buildRecommendation(context: AnalysisContext, mode: string, finalContent: string): any {
+  private buildRecommendation(context: PipelineContext, mode: string, finalContent: string, toolsDataHash: string): any {
     const isWorkflow = mode === 'workflow';
     
-    console.log('[AI-PIPELINE] Building recommendation for', mode, 'mode with', context.selectedTools?.length || 0, 'tools');
-    
-    if (context.selectedTools && context.selectedTools.length > 0) {
-      const methods = context.selectedTools.filter((st: any) => st.tool && st.tool.type === 'method');
-      const software = context.selectedTools.filter((st: any) => st.tool && st.tool.type === 'software');
-      
-      console.log('[AI-PIPELINE] Final selection breakdown:', methods.length, 'methods,', software.length, 'software');
-      console.log('[AI-PIPELINE] Method names:', methods.map((m: any) => m.tool.name).join(', '));
-      console.log('[AI-PIPELINE] Software names:', software.map((s: any) => s.tool.name).join(', '));
-      
-      context.selectedTools.forEach((st: any, index: number) => {
-        console.log('[AI-PIPELINE] Selected tool', index + 1, ':', st.tool.name, '(' + st.tool.type + ') - Phase:', st.phase, ', Priority:', st.priority);
-      });
-    } else {
-      console.warn('[AI-PIPELINE] WARNING: No tools in selectedTools array!');
-    }
-    
     const base = {
       [isWorkflow ? 'scenario_analysis' : 'problem_analysis']: 
         isWorkflow ? context.scenarioAnalysis : context.problemAnalysis,
@@ -1478,28 +1073,31 @@ class ImprovedMicroTaskAIPipeline {
 
     if (isWorkflow) {
       const recommendedToolsWithConfidence = context.selectedTools?.map((st: any) => {
-        const confidence = this.calculateRecommendationConfidence(
+        const analysisContext: AnalysisContext = {
+          userQuery: context.userQuery,
+          mode: context.mode,
+          embeddingsSimilarities: context.embeddingsSimilarities,
+          selectedTools: context.selectedTools
+        };
+        
+        const confidence = confidenceScoring.calculateRecommendationConfidence(
           st.tool,
-          context,
+          analysisContext,
           st.taskRelevance || 70,
           st.limitations || []
         );
-        
-        this.addAuditEntry(
-          context,
-          'validation',
-          'confidence-scoring',
-          { toolName: st.tool.name, toolType: st.tool.type, phase: st.phase },
-          {
-            overall: confidence.overall,
-            components: {
-              semantic: confidence.semanticRelevance,
-              suitability: confidence.taskSuitability,
-            }
-          },
-          confidence.overall,
+
+        auditService.addConfidenceCalculation(
+          st.tool.name,
+          confidence,
           Date.now(),
-          { uncertaintyCount: confidence.uncertaintyFactors.length, strengthCount: confidence.strengthIndicators.length }
+          {
+            toolsDataHash: toolsDataHash,
+            phase: st.phase,
+            priority: st.priority,
+            toolType: st.tool.type,
+            moderatedTaskRelevance: st.taskRelevance
+          }
         );
 
         return {
@@ -1509,8 +1107,7 @@ class ImprovedMicroTaskAIPipeline {
           priority: st.priority,
           justification: st.justification || `Empfohlen für ${st.phase}`,
           confidence: confidence,
-          recommendationStrength: confidence.overall >= this.confidenceConfig.highThreshold ? 'strong' : 
-                                confidence.overall >= this.confidenceConfig.mediumThreshold ? 'moderate' : 'weak'
+          recommendationStrength: confidenceScoring.getConfidenceLevel(confidence.overall)
         };
       }) || [];
 
@@ -1521,25 +1118,30 @@ class ImprovedMicroTaskAIPipeline {
       };
     } else {
       const recommendedToolsWithConfidence = context.selectedTools?.map((st: any) => {
-        const confidence = this.calculateRecommendationConfidence(
+        const analysisContext: AnalysisContext = {
+          userQuery: context.userQuery,
+          mode: context.mode,
+          embeddingsSimilarities: context.embeddingsSimilarities,
+          selectedTools: context.selectedTools
+        };
+        
+        const confidence = confidenceScoring.calculateRecommendationConfidence(
           st.tool,
-          context,
+          analysisContext,
           st.taskRelevance || 70,
           st.limitations || []
         );
-        
-        this.addAuditEntry(
-          context,
-          'validation',
-          'confidence-scoring',
-          { toolName: st.tool.name, toolType: st.tool.type, rank: st.tool.evaluation?.rank || 1 },
-          {
-            overall: confidence.overall,
-            suitabilityAlignment: st.priority === 'high' && confidence.overall >= this.confidenceConfig.highThreshold
-          },
-          confidence.overall,
+
+        auditService.addConfidenceCalculation(
+          st.tool.name,
+          confidence,
           Date.now(),
-          { strengthCount: confidence.strengthIndicators.length }
+          {
+            toolsDataHash: toolsDataHash,
+            rank: st.tool.evaluation?.rank || 1,
+            toolType: st.tool.type,
+            moderatedTaskRelevance: st.taskRelevance
+          }
         );
 
         return {
@@ -1553,8 +1155,7 @@ class ImprovedMicroTaskAIPipeline {
           cons: st.tool.evaluation?.limitations || [],
           alternatives: st.tool.evaluation?.alternatives || '',
           confidence: confidence,
-          recommendationStrength: confidence.overall >= this.confidenceConfig.highThreshold ? 'strong' : 
-                                confidence.overall >= this.confidenceConfig.mediumThreshold ? 'moderate' : 'weak'
+          recommendationStrength: confidenceScoring.getConfidenceLevel(confidence.overall)
         };
       }) || [];
 
@@ -1565,8 +1166,189 @@ class ImprovedMicroTaskAIPipeline {
       };
     }
   }
+
+  private async callMicroTaskAI(
+    prompt: string, 
+    context: PipelineContext, 
+    taskType: string = 'micro-task'
+  ): Promise<MicroTaskResult> {
+    const startTime = Date.now();
+    
+    let contextPrompt = prompt;
+    if (context.contextHistory.length > 0) {
+      const contextSection = `BISHERIGE ANALYSE:\n${context.contextHistory.join('\n\n')}\n\nAKTUELLE AUFGABE:\n`;
+      contextPrompt = contextSection + prompt;
+    }
+    
+    try {
+      const response = await aiService.callMicroTaskAI(contextPrompt);
+      
+      const toolsDataHash = getDataVersion?.() || 'unknown';
+      const aiConfig = aiService.getConfig();
+      
+      const responseConfidence = auditService.calculateAIResponseConfidence(
+        response.content,
+        this.getExpectedLengthForTaskType(taskType),
+        taskType
+      );
+      
+      auditService.addAIDecision(
+        this.getPhaseForTaskType(taskType),
+        prompt,
+        response.content,
+        responseConfidence,
+        this.getReasoningForTaskType(taskType, response.content),
+        startTime,
+        {
+          toolsDataHash: toolsDataHash,
+          microTaskType: taskType,
+          aiModel: aiConfig.model,
+          contextLength: contextPrompt.length,
+          originalPromptLength: prompt.length,
+          contextHistoryUsed: context.contextHistory.length > 0,
+          decisionBasis: 'ai-analysis',
+          ...response.usage
+        }
+      );
+      
+      return {
+        taskType,
+        content: response.content,
+        processingTimeMs: Date.now() - startTime,
+        success: true,
+        aiUsage: response.usage
+      };
+
+    } catch (error) {
+      auditService.addEntry(
+        this.getPhaseForTaskType(taskType),
+        'ai-decision-failed',
+        { 
+          prompt: prompt.slice(0, 200) + '...',
+          taskType: taskType,
+          error: error.message
+        },
+        { 
+          error: error.message,
+          success: false
+        },
+        0,
+        startTime,
+        {
+          toolsDataHash: getDataVersion?.() || 'unknown',
+          microTaskType: taskType,
+          failed: true,
+          decisionBasis: 'ai-analysis'
+        }
+      );
+      
+      return {
+        taskType,
+        content: '',
+        processingTimeMs: Date.now() - startTime,
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  private getPhaseForTaskType(taskType: string): string {
+    const phaseMap: Record<string, string> = {
+      'scenario-analysis': 'contextual-analysis',
+      'investigation-approach': 'contextual-analysis',
+      'critical-considerations': 'contextual-analysis',
+      'tool-evaluation': 'tool-evaluation',
+      'background-knowledge': 'knowledge-synthesis',
+      'final-recommendations': 'synthesis',
+      'phase-completion-selection': 'phase-completion',
+      'phase-completion-reasoning': 'phase-completion'
+    };
+    return phaseMap[taskType] || 'contextual-analysis';
+  }
+
+  private getExpectedLengthForTaskType(taskType: string): { min: number; max: number } {
+    const lengthMap: Record<string, { min: number; max: number }> = {
+      'scenario-analysis': { min: 100, max: 500 },
+      'investigation-approach': { min: 100, max: 400 },
+      'critical-considerations': { min: 80, max: 300 },
+      'tool-evaluation': { min: 200, max: 800 },
+      'background-knowledge': { min: 50, max: 300 },
+      'final-recommendations': { min: 150, max: 600 },
+      'phase-completion-selection': { min: 50, max: 200 },
+      'phase-completion-reasoning': { min: 100, max: 300 }
+    };
+    return lengthMap[taskType] || { min: 50, max: 300 };
+  }
+
+  private getReasoningForTaskType(taskType: string, response: string): string {
+    const responseLength = response.length;
+    const taskNames: Record<string, string> = {
+      'scenario-analysis': 'Szenario-Analyse',
+      'investigation-approach': 'Untersuchungsansatz',
+      'critical-considerations': 'Kritische Überlegungen',
+      'tool-evaluation': 'Tool-Bewertung',
+      'background-knowledge': 'Hintergrundwissen-Auswahl',
+      'final-recommendations': 'Abschließende Empfehlungen',
+      'phase-completion-selection': 'Phasen-Vervollständigung',
+      'phase-completion-reasoning': 'Phasen-Begründung'
+    };
+    
+    const taskName = taskNames[taskType] || taskType;
+    return `KI generierte ${taskName} (${responseLength} Zeichen) - Analyse mit methodischer Begründung`;
+  }
+
+  private addToContextHistory(context: PipelineContext, newEntry: string): void {
+    const entryTokens = aiService.estimateTokens(newEntry);
+    
+    context.contextHistory.push(newEntry);
+    context.currentContextLength += entryTokens;
+    
+    if (context.contextHistory.length > 1) {
+      const removed = context.contextHistory.shift()!;
+      context.currentContextLength -= aiService.estimateTokens(removed);
+    }
+  }
+
+  private addToolToSelection(
+    context: PipelineContext,
+    tool: any,
+    phase: string,
+    priority: string,
+    justification?: string,
+    taskRelevance?: number,
+    limitations?: string[]
+  ): boolean {
+    context.seenToolNames.add(tool.name);
+    if (!context.selectedTools) context.selectedTools = [];
+    
+    context.selectedTools.push({
+      tool,
+      phase,
+      priority,
+      justification,
+      taskRelevance,
+      limitations
+    });
+    
+    return true;
+  }
+
+  private derivePriorityFromScore(taskRelevance: number): string {
+    if (taskRelevance >= 80) return 'high';
+    if (taskRelevance >= 60) return 'medium';
+    return 'low';
+  }
+
+  private trackTokenUsage(usage?: { promptTokens?: number; completionTokens?: number; totalTokens?: number }): void {
+    if (usage?.totalTokens) {
+      this.totalTokensUsed += usage.totalTokens;
+    }
+  }
+
+  private async delay(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
 }
 
-const aiPipeline = new ImprovedMicroTaskAIPipeline();
-
-export { aiPipeline, type AnalysisResult };
\ No newline at end of file
+export const aiPipeline = new AIPipeline();
+export type { AnalysisResult };
\ No newline at end of file
diff --git a/src/utils/aiService.ts b/src/utils/aiService.ts
new file mode 100644
index 0000000..41b66e7
--- /dev/null
+++ b/src/utils/aiService.ts
@@ -0,0 +1,137 @@
+// src/utils/aiService.ts
+import 'dotenv/config';
+
+export interface AIServiceConfig {
+  endpoint: string;
+  apiKey: string;
+  model: string;
+}
+
+export interface AICallOptions {
+  temperature?: number;
+  timeout?: number;
+}
+
+export interface AIResponse {
+  content: string;
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+}
+
+class AIService {
+  private config: AIServiceConfig;
+  private defaultOptions: AICallOptions;
+
+  constructor() {
+    this.config = {
+      endpoint: this.getRequiredEnv('AI_ANALYZER_ENDPOINT'),
+      apiKey: this.getRequiredEnv('AI_ANALYZER_API_KEY'),
+      model: this.getRequiredEnv('AI_ANALYZER_MODEL')
+    };
+
+    this.defaultOptions = {
+      temperature: 0.3,
+      timeout: 60000
+    };
+
+    console.log('[AI-SERVICE] Initialized with model:', this.config.model);
+  }
+
+  private getRequiredEnv(key: string): string {
+    const value = process.env[key];
+    if (!value) {
+      throw new Error(`Missing required environment variable: ${key}`);
+    }
+    return value;
+  }
+
+  async callAI(prompt: string, options: AICallOptions = {}): Promise<AIResponse> {
+    const mergedOptions = { ...this.defaultOptions, ...options };
+    
+    console.log('[AI-SERVICE] Making API call:', {
+      promptLength: prompt.length,
+      temperature: mergedOptions.temperature
+    });
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json'
+    };
+    
+    if (this.config.apiKey) {
+      headers['Authorization'] = `Bearer ${this.config.apiKey}`;
+    }
+    
+    const requestBody = {
+      model: this.config.model,
+      messages: [{ role: 'user', content: prompt }],
+      temperature: mergedOptions.temperature
+    };
+    
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), mergedOptions.timeout);
+
+      const response = await fetch(`${this.config.endpoint}/v1/chat/completions`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(requestBody),
+        signal: controller.signal
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error('[AI-SERVICE] API Error:', response.status, errorText);
+        throw new Error(`AI API error: ${response.status} - ${errorText}`);
+      }
+
+      const data = await response.json();
+      const content = data.choices?.[0]?.message?.content;
+      
+      if (!content) {
+        console.error('[AI-SERVICE] No response content from AI model');
+        throw new Error('No response from AI model');
+      }
+
+      console.log('[AI-SERVICE] API call successful:', {
+        responseLength: content.length,
+        usage: data.usage
+      });
+
+      return {
+        content: content.trim(),
+        usage: data.usage
+      };
+      
+    } catch (error) {
+      if (error.name === 'AbortError') {
+        console.error('[AI-SERVICE] Request timeout');
+        throw new Error('AI request timeout');
+      }
+      
+      console.error('[AI-SERVICE] API call failed:', error.message);
+      throw error;
+    }
+  }
+
+  async callMicroTaskAI(prompt: string): Promise<AIResponse> {
+    return this.callAI(prompt, { 
+      temperature: 0.3,
+      timeout: 30000 
+    });
+  }
+
+  estimateTokens(text: string): number {
+    return Math.ceil(text.length / 4);
+  }
+
+  getConfig(): AIServiceConfig {
+    return { ...this.config };
+  }
+}
+
+export const aiService = new AIService();
\ No newline at end of file
diff --git a/src/utils/api.ts b/src/utils/api.ts
index d7b675b..390695a 100644
--- a/src/utils/api.ts
+++ b/src/utils/api.ts
@@ -83,26 +83,21 @@ export const apiServerError = {
 };
 
 export const apiSpecial = {
-  // JSON parsing error
   invalidJSON: (): Response => 
     apiError.badRequest('Invalid JSON in request body'),
   
-  // Missing required fields
   missingRequired: (fields: string[]): Response => 
     apiError.badRequest(`Missing required fields: ${fields.join(', ')}`),
   
-  // Empty request body
   emptyBody: (): Response => 
     apiError.badRequest('Request body cannot be empty'),
   
-  // File upload responses
   uploadSuccess: (data: { url: string; filename: string; size: number; storage: string }): Response => 
     apiResponse.created(data),
   
   uploadFailed: (error: string): Response => 
     apiServerError.internal(`Upload failed: ${error}`),
   
-  // Contribution responses
   contributionSuccess: (data: { prUrl?: string; branchName?: string; message: string }): Response => 
     apiResponse.created({ success: true, ...data }),
   
@@ -114,7 +109,6 @@ export const apiWithHeaders = {
   successWithHeaders: (data: any, headers: Record<string, string>): Response => 
     createAPIResponse(data, 200, headers),
   
-  // Redirect response
   redirect: (location: string, temporary: boolean = true): Response => 
     new Response(null, {
       status: temporary ? 302 : 301,
diff --git a/src/utils/auditService.ts b/src/utils/auditService.ts
index 8f3e9d7..facaba2 100644
--- a/src/utils/auditService.ts
+++ b/src/utils/auditService.ts
@@ -1,4 +1,4 @@
-// src/utils/auditService.ts 
+// src/utils/auditService.ts
 import 'dotenv/config';
 
 function env(key: string, fallback: string | undefined = undefined): string | undefined {
@@ -11,7 +11,6 @@ function env(key: string, fallback: string | undefined = undefined): string | un
   return fallback;
 }
 
-// CONSOLIDATED AUDIT INTERFACES - Single source of truth
 export interface AuditEntry {
   timestamp: number;
   phase: string;
@@ -20,97 +19,60 @@ export interface AuditEntry {
   output: any;
   confidence: number;
   processingTimeMs: number;
-  metadata: Record<string, any>;
+  metadata: {
+    aiModel?: string;
+    aiParameters?: any;
+    promptTokens?: number;
+    completionTokens?: number;
+    toolsDataHash?: string;
+    embeddingsUsed?: boolean;
+    microTaskType?: string;
+    confidenceFactors?: string[];
+    reasoning?: string;
+    aiPrompt?: string;
+    aiResponse?: string;
+    toolSelectionCriteria?: string;
+    availableToolsCount?: number;
+    selectedToolsCount?: number;
+    phaseId?: string;
+    toolsAdded?: string[];
+    completionReasoning?: string;
+    similarityScores?: Record<string, number>;
+    contextLength?: number;
+    decisionBasis?: 'ai-analysis' | 'semantic-search' | 'hybrid' | 'rule-based';
+    inputSummary?: string;
+    outputSummary?: string;
+    [key: string]: any;
+  };
 }
 
 interface AuditConfig {
   enabled: boolean;
-  detailLevel: 'minimal' | 'standard' | 'verbose';
   retentionHours: number;
   maxEntries: number;
 }
 
-interface CompressedAuditEntry {
-  timestamp: number;
-  phase: string;
-  action: string;
-  inputSummary: string;
-  outputSummary: string;
-  confidence: number;
-  processingTimeMs: number;
-  metadata: Record<string, any>;
-}
-
-export interface ProcessedAuditTrail {
-  totalTime: number;
-  avgConfidence: number;
-  stepCount: number;
-  highConfidenceSteps: number;
-  lowConfidenceSteps: number;
-  phases: Array<{
-    name: string;
-    icon: string;
-    displayName: string;
-    avgConfidence: number;
-    totalTime: number;
-    entries: CompressedAuditEntry[];
-  }>;
-  summary: {
-    analysisQuality: 'excellent' | 'good' | 'fair' | 'poor';
-    keyInsights: string[];
-    potentialIssues: string[];
-  };
-}
-
 class AuditService {
   private config: AuditConfig;
   private activeAuditTrail: AuditEntry[] = [];
-  
-  private readonly phaseConfig = {
-    'initialization': { icon: '🚀', displayName: 'Initialisierung' },
-    'retrieval': { icon: '🔍', displayName: 'Datensuche' },
-    'selection': { icon: '🎯', displayName: 'Tool-Auswahl' },
-    'micro-task': { icon: '⚡', displayName: 'Detail-Analyse' },
-    'validation': { icon: '✓', displayName: 'Validierung' },
-    'completion': { icon: '✅', displayName: 'Finalisierung' }
-  };
-
-  private readonly actionTranslations = {
-    'pipeline-start': 'Analyse gestartet',
-    'embeddings-search': 'Ähnliche Tools gesucht', 
-    'ai-tool-selection': 'Tools automatisch ausgewählt',
-    'ai-analysis': 'KI-Analyse durchgeführt',
-    'phase-tool-selection': 'Phasen-Tools evaluiert',
-    'tool-evaluation': 'Tool-Bewertung erstellt',
-    'background-knowledge-selection': 'Hintergrundwissen ausgewählt',
-    'confidence-scoring': 'Vertrauenswertung berechnet',
-    'phase-completion': 'Phasenergänzung durchgeführt',
-    'pipeline-end': 'Analyse abgeschlossen'
-  };
 
   constructor() {
     this.config = this.loadConfig();
-    console.log('[AUDIT-SERVICE] Initialized:', { 
-      enabled: this.config.enabled, 
-      detailLevel: this.config.detailLevel 
-    });
+    console.log('[AUDIT-SERVICE] Initialized with meaningful audit logging');
   }
 
   private loadConfig(): AuditConfig {
-    const enabledFlag = env('FORENSIC_AUDIT_ENABLED', 'false');
-    const detailLevel = env('FORENSIC_AUDIT_DETAIL_LEVEL', 'standard') as 'minimal' | 'standard' | 'verbose';
+    const enabled = env('FORENSIC_AUDIT_ENABLED', 'true') === 'true';
     const retentionHours = parseInt(env('FORENSIC_AUDIT_RETENTION_HOURS', '72') || '72', 10);
     const maxEntries = parseInt(env('FORENSIC_AUDIT_MAX_ENTRIES', '50') || '50', 10);
 
     return {
-      enabled: enabledFlag === 'true',
-      detailLevel,
+      enabled,
       retentionHours,
       maxEntries
     };
   }
 
-  // CONSOLIDATED AUDIT ENTRY CREATION - Single method for all audit operations
   addEntry(
     phase: string,
     action: string,
@@ -122,27 +84,513 @@ class AuditService {
   ): void {
     if (!this.config.enabled) return;
 
+    if (action === 'pipeline-start' || action === 'pipeline-end') {
+      return;
+    }
+
+    const enhancedMetadata = {
+      ...metadata,
+      inputSummary: this.createSpecificSummary(input, action, 'input'),
+      outputSummary: this.createSpecificSummary(output, action, 'output'),
+      decisionBasis: metadata.decisionBasis || this.inferDecisionBasis(metadata),
+      reasoning: metadata.reasoning || this.generateSpecificReasoning(action, input, output, metadata, confidence)
+    };
+
     const entry: AuditEntry = {
       timestamp: Date.now(),
       phase,
       action,
-      input: this.compressData(input),
-      output: this.compressData(output),
+      input: input,
+      output: output,
       confidence: Math.round(confidence),
       processingTimeMs: Date.now() - startTime,
-      metadata
+      metadata: enhancedMetadata
     };
 
     this.activeAuditTrail.push(entry);
+    
+    if (this.activeAuditTrail.length > this.config.maxEntries) {
+      this.activeAuditTrail.shift();
+    }
+    
     console.log(`[AUDIT-SERVICE] ${phase}/${action}: ${confidence}% confidence, ${entry.processingTimeMs}ms`);
   }
 
-  // GET CURRENT AUDIT TRAIL - For integration with AI pipeline
+  addAIDecision(
+    phase: string,
+    aiPrompt: string,
+    aiResponse: string,
+    confidence: number,
+    reasoning: string,
+    startTime: number,
+    metadata: Record<string, any> = {}
+  ): void {
+    this.addEntry(
+      phase,
+      'ai-decision',
+      { prompt: this.createPromptSummary(aiPrompt) },
+      { response: aiResponse },
+      confidence,
+      startTime,
+      {
+        ...metadata,
+        reasoning,
+        aiPrompt: aiPrompt,
+        aiResponse: aiResponse,
+        decisionBasis: 'ai-analysis'
+      }
+    );
+  }
+
+  addToolSelection(
+    selectedTools: string[],
+    availableTools: string[],
+    confidence: number,
+    startTime: number,
+    metadata: Record<string, any> = {}
+  ): void {
+    const calculatedConfidence = this.calculateSelectionConfidence(
+      selectedTools, 
+      availableTools, 
+      metadata
+    );
+
+    const decisionBasis =
+      metadata.embeddingsUsed || metadata.similarityScores
+        ? 'semantic-search'
+        : (metadata.aiPrompt || metadata.microTaskType ? 'ai-analysis' : 'rule-based');
+
+    this.addEntry(
+      'tool-selection',
+      'selection-decision',
+      { 
+        availableTools: availableTools.slice(0, 10),
+        totalAvailable: availableTools.length,
+      },
+      { 
+        selectedTools: selectedTools,
+        selectionRatio: selectedTools.length / availableTools.length
+      },
+      calculatedConfidence,
+      startTime,
+      {
+        ...metadata,
+        availableToolsCount: availableTools.length,
+        selectedToolsCount: selectedTools.length,
+        decisionBasis
+      }
+    );
+  }
+
+  addPhaseCompletion(
+    phaseId: string,
+    addedTools: string[],
+    reasoning: string,
+    startTime: number,
+    metadata: Record<string, any> = {}
+  ): void {
+    if (!addedTools || addedTools.length === 0) {
+      console.log(`[AUDIT-SERVICE] Skipping phase completion for ${phaseId} - no tools added`);
+      return;
+    }
+
+    const calculatedConfidence = this.calculatePhaseCompletionConfidence(addedTools, reasoning, metadata);
+
+    this.addEntry(
+      'phase-completion',
+      'phase-enhancement',
+      {
+        phaseId: phaseId,
+        phaseName: this.getPhaseDisplayName(phaseId),
+        searchStrategy: 'semantic-search-with-ai-reasoning'
+      },
+      {
+        addedTools: addedTools,
+        toolsAddedCount: addedTools.length
+      },
+      calculatedConfidence,
+      startTime,
+      {
+        ...metadata,
+        reasoning: reasoning,
+        decisionBasis: 'hybrid'
+      }
+    );
+  }
+
+  addEmbeddingsSearch(
+    query: string,
+    similarResults: any[],
+    threshold: number,
+    startTime: number,
+    metadata: Record<string, any> = {}
+  ): void {
+    const calculatedConfidence = this.calculateEmbeddingsConfidence(similarResults, threshold);
+
+    this.addEntry(
+      'embeddings',
+      'similarity-search',
+      { 
+        query: query, 
+        threshold: threshold
+      },
+      { 
+        resultsCount: similarResults.length,
+        topMatches: similarResults.slice(0, 5).map(r => `${r.name} (${Math.round(r.similarity * 100)}%)`)
+      },
+      calculatedConfidence,
+      startTime,
+      {
+        ...metadata,
+        embeddingsUsed: true,
+        searchThreshold: threshold,
+        totalMatches: similarResults.length,
+        decisionBasis: 'semantic-search'
+      }
+    );
+  }
+
+  addConfidenceCalculation(
+    toolName: string,
+    confidence: any,
+    startTime: number,
+    metadata: Record<string, any> = {}
+  ): void {
+    this.addEntry(
+      'confidence-scoring',
+      'tool-confidence',
+      {
+        toolName: toolName,
+        semanticSimilarity: confidence.semanticRelevance,
+        taskRelevance: confidence.taskSuitability
+      },
+      {
+        overallConfidence: confidence.overall,
+        strengthIndicators: confidence.strengthIndicators?.slice(0, 2) || [],
+        uncertaintyFactors: confidence.uncertaintyFactors?.slice(0, 2) || []
+      },
+      confidence.overall,
+      startTime,
+      {
+        ...metadata,
+        confidenceCalculation: true,
+        decisionBasis: 'ai-analysis'
+      }
+    );
+  }
+
+  private calculateSelectionConfidence(
+    selectedTools: string[], 
+    availableTools: string[], 
+    metadata: Record<string, any>
+  ): number {
+    let confidence = 50;
+    
+    const selectionRatio = selectedTools.length / availableTools.length;
+    
+    if (selectionRatio >= 0.05 && selectionRatio <= 0.20) {
+      confidence += 25;
+    } else if (selectionRatio < 0.05) {
+      confidence += 15;
+    } else if (selectionRatio > 0.30) {
+      confidence -= 20;
+    }
+    
+    if (selectedTools.length >= 5 && selectedTools.length <= 25) {
+      confidence += 10;
+    }
+    
+    return Math.min(95, Math.max(40, confidence));
+  }
+
+  private calculatePhaseCompletionConfidence(
+    addedTools: string[], 
+    reasoning: string, 
+    metadata: Record<string, any>
+  ): number {
+    let confidence = 60;
+    
+    if (addedTools.length > 0) {
+      confidence += 20;
+    }
+    
+    if (reasoning && reasoning.length > 50) {
+      confidence += 15;
+    }
+    
+    if (metadata.aiReasoningUsed) {
+      confidence += 10;
+    }
+    
+    if (addedTools.length <= 2) {
+      confidence += 5;
+    }
+    
+    return Math.min(90, Math.max(50, confidence));
+  }
+
+  private calculateEmbeddingsConfidence(similarResults: any[], threshold: number): number {
+    let confidence = 50;
+    
+    if (similarResults.length > 0) {
+      confidence += 20;
+    }
+    
+    if (similarResults.length >= 5 && similarResults.length <= 30) {
+      confidence += 15;
+    }
+    
+    const avgSimilarity = similarResults.length > 0 ? 
+      similarResults.reduce((sum, r) => sum + r.similarity, 0) / similarResults.length : 0;
+    
+    if (avgSimilarity > 0.7) {
+      confidence += 15;
+    } else if (avgSimilarity > 0.5) {
+      confidence += 10;
+    }
+    
+    if (threshold >= 0.3 && threshold <= 0.5) {
+      confidence += 5;
+    }
+    
+    return Math.min(95, Math.max(30, confidence));
+  }
+
+  private createSpecificSummary(data: any, action: string, type: 'input' | 'output'): string {
+    if (!data) return 'Leer';
+    
+    switch (action) {
+      case 'selection-decision':
+        if (type === 'input') {
+          if (data.availableTools && Array.isArray(data.availableTools)) {
+            const preview = data.availableTools.slice(0, 3).join(', ');
+            return `${data.totalAvailable || data.availableTools.length} Tools: ${preview}${data.availableTools.length > 3 ? '...' : ''}`;
+          } else if (data.totalAvailable) {
+            return `${data.totalAvailable} Tools verfügbar, Methode: ${data.selectionMethod}`;
+          }
+          return `${data.candidateCount || 0} Kandidaten für Auswahl`;
+        } else {
+          if (Array.isArray(data.selectedTools)) {
+            return `${data.selectedTools.length} ausgewählt: ${data.selectedTools.slice(0, 3).join(', ')}${data.selectedTools.length > 3 ? '...' : ''}`;
+          }
+          return `Auswahl: ${data.selectionRatio ? Math.round(data.selectionRatio * 100) + '%' : 'unbekannt'}`;
+        }
+        
+      case 'phase-tool-selection':
+        if (type === 'input') {
+          if (Array.isArray(data.availableTools)) {
+            const toolPreview = data.availableTools.slice(0, 3).join(', ');
+            return `${data.availableTools.length} Tools für ${data.phaseName || data.phaseId}: ${toolPreview}${data.availableTools.length > 3 ? '...' : ''}`;
+          }
+          return `Phase: ${data.phaseName || data.phaseId} (${data.toolCount || 0} Tools)`;
+        } else {
+          if (Array.isArray(data.selectedTools)) {
+            return `${data.selectedTools.length} ausgewählt: ${data.selectedTools.join(', ')}`;
+          }
+          return `${data.selectionCount || 0} Tools, Ø ${data.avgTaskRelevance || 0}% Relevanz`;
+        }
+        
+      case 'similarity-search':
+        if (type === 'input') {
+          return `Suche: "${data.query}" (Min. ${data.threshold} Ähnlichkeit)`;
+        } else {
+          if (Array.isArray(data.topMatches)) {
+            return `${data.resultsCount} Treffer: ${data.topMatches.slice(0, 2).join(', ')}${data.topMatches.length > 2 ? '...' : ''}`;
+          }
+          return `${data.resultsCount || 0} semantische Treffer gefunden`;
+        }
+        
+      case 'phase-enhancement':
+        if (type === 'input') {
+          return `Vervollständige Phase: ${data.phaseName || data.phaseId}`;
+        } else {
+          if (Array.isArray(data.addedTools) && data.addedTools.length > 0) {
+            return `${data.addedTools.length} hinzugefügt: ${data.addedTools.join(', ')}`;
+          }
+          return `${data.toolsAddedCount || 0} Tools für Phase hinzugefügt`;
+        }
+        
+      case 'ai-decision':
+        if (type === 'input') {
+          if (data.prompt) {
+            const promptPreview = data.prompt.slice(0, 80).replace(/\n/g, ' ');
+            return `KI-Prompt: ${promptPreview}${data.prompt.length > 80 ? ' [Vorschau]' : ''}`;
+          }
+          return 'KI-Analyse angefordert';
+        } else {
+          if (data.response) {
+            const responsePreview = data.response.slice(0, 80).replace(/\n/g, ' ');
+            return `KI-Antwort: ${responsePreview}${data.response.length > 80 ? ' [Vorschau]' : ''}`;
+          }
+          return 'KI-Analyse abgeschlossen';
+        }
+        
+      case 'tool-confidence':
+        if (type === 'input') {
+          return `Tool: ${data.toolName} (Sem: ${data.semanticSimilarity}%, Task: ${data.taskRelevance}%)`;
+        } else {
+          const strengthCount = data.strengthIndicators?.length || 0;
+          const uncertaintyCount = data.uncertaintyFactors?.length || 0;
+          return `${data.overallConfidence}% Vertrauen (${strengthCount} Stärken, ${uncertaintyCount} Unsicherheiten)`;
+        }
+        
+      case 'tool-added-to-phase':
+        if (type === 'output') {
+          const justificationPreview = data.justification ? 
+            data.justification.slice(0, 60).replace(/\n/g, ' ') + (data.justification.length > 60 ? ' [Vorschau]' : '') : 'Hinzugefügt';
+          return `Begründung: ${justificationPreview}`;
+        } else {
+          const justificationPreview = data.justification ? 
+            data.justification.slice(0, 60).replace(/\n/g, ' ') + '...' : 'Hinzugefügt';
+          return `Begründung: ${justificationPreview}`;
+        }
+        
+      case 'concept-selection':
+        if (type === 'input') {
+          const conceptCount = Array.isArray(data.availableConcepts) ? data.availableConcepts.length : 0;
+          const toolContext = Array.isArray(data.selectedToolsContext) ? data.selectedToolsContext.length : 0;
+          return `${conceptCount} Konzepte verfügbar, ${toolContext} Tools als Kontext`;
+        } else {
+          if (Array.isArray(data.selectedConcepts)) {
+            return `${data.selectedConcepts.length} ausgewählt: ${data.selectedConcepts.slice(0, 2).join(', ')}${data.selectedConcepts.length > 2 ? '...' : ''}`;
+          }
+          return `Konzeptauswahl abgeschlossen`;
+        }
+    }
+    
+    if (typeof data === 'string') {
+      return data.length > 100 ? data.slice(0, 100) + '...' : data;
+    }
+    
+    if (Array.isArray(data)) {
+      if (data.length === 0) return 'Leeres Array';
+      if (data.length <= 3) return data.join(', ');
+      return `${data.slice(0, 3).join(', ')} + ${data.length - 3} weitere`;
+    }
+    
+    if (typeof data === 'object') {
+      const keys = Object.keys(data);
+      if (keys.length === 0) return 'Leeres Objekt';
+      
+      if (keys.length <= 2) {
+        const pairs = keys.map(key => {
+          const value = data[key];
+          if (typeof value === 'string' && value.length > 30) {
+            return `${key}: ${value.slice(0, 30)}...`;
+          } else if (Array.isArray(value)) {
+            return `${key}: [${value.length} Items]`;
+          } else {
+            return `${key}: ${value}`;
+          }
+        });
+        return pairs.join(', ');
+      } else {
+        const sampleKeys = keys.slice(0, 3);
+        const sampleValues = sampleKeys.map(key => {
+          const value = data[key];
+          if (typeof value === 'string' && value.length > 20) {
+            return `${key}: ${value.slice(0, 20)}...`;
+          } else if (Array.isArray(value)) {
+            return `${key}: [${value.length}]`;
+          } else {
+            return `${key}: ${value}`;
+          }
+        });
+        return `${sampleValues.join(', ')}${keys.length > 3 ? ` + ${keys.length - 3} weitere` : ''}`;
+      }
+    }
+    
+    return String(data);
+  }
+
+  private createPromptSummary(prompt: string): string {
+    if (!prompt || prompt.length <= 200) return prompt;
+    return prompt.slice(0, 200) + ' [Eingabe-Vorschau]';
+  }
+
+  private generateSpecificReasoning(
+    action: string, 
+    input: any, 
+    output: any, 
+    metadata: Record<string, any>, 
+    confidence: number
+  ): string {
+    if (metadata.reasoning && metadata.reasoning.length > 20 && !metadata.reasoning.includes('completed with')) {
+      return metadata.reasoning;
+    }
+    
+    switch (action) {
+      case 'selection-decision':
+        const selectionRatio = metadata.selectedToolsCount / metadata.availableToolsCount;
+        const method = metadata.selectionMethod === 'embeddings_candidates' ? 'Semantische Analyse' : 'KI-Analyse';
+        return `${method} wählte ${metadata.selectedToolsCount} von ${metadata.availableToolsCount} Tools (${Math.round(selectionRatio * 100)}%) - ausgewogene Auswahl für forensische Aufgabenstellung`;
+      
+      case 'similarity-search': {
+        const totalMatches =
+          typeof metadata.totalMatches === 'number' ? metadata.totalMatches : 0;
+
+        const scoresObj = (metadata.similarityScores ?? {}) as Record<string, number>;
+        const scores = Object.values(scoresObj) as number[];
+
+        const denom = totalMatches > 0 ? totalMatches : scores.length;
+
+        const sum = scores.reduce((acc, v) => acc + (typeof v === 'number' ? v : 0), 0);
+        const avgSim = denom > 0 ? sum / denom : 0;
+
+        return `Semantische Suche fand ${totalMatches} relevante Items mit durchschnittlicher Ähnlichkeit von ${Math.round(avgSim * 100)}%`;
+      }
+
+      case 'ai-decision':
+        const taskType = metadata.microTaskType;
+        if (taskType) {
+          const typeNames = {
+            'scenario-analysis': 'Szenario-Analyse',
+            'investigation-approach': 'Untersuchungsansatz', 
+            'critical-considerations': 'Kritische Überlegungen',
+            'tool-evaluation': 'Tool-Bewertung',
+            'background-knowledge': 'Hintergrundwissen-Auswahl',
+            'final-recommendations': 'Abschließende Empfehlungen'
+          };
+          return `KI analysierte ${typeNames[taskType] || taskType} mit ${confidence}% Vertrauen - fundierte Empfehlung`;
+        }
+        return `KI-Entscheidung mit ${confidence}% Vertrauen basierend auf agentischer Expertenanalyse`;
+      
+      case 'phase-enhancement':
+        const phaseData = input?.phaseName || input?.phaseId;
+        const toolCount = output?.toolsAddedCount || 0;
+        return `${phaseData}-Phase durch ${toolCount} zusätzliche Tools vervollständigt - ursprüngliche Auswahl war zu spezifisch und übersah wichtige Methoden`;
+      
+      case 'tool-confidence':
+        return `Vertrauenswertung für ${input?.toolName}: ${confidence}% basierend auf semantischer Relevanz (${input?.semanticSimilarity}%) und Aufgabeneignung (${input?.taskRelevance}%)`;
+      
+      default:
+        return `${action} mit ${confidence}% Vertrauen abgeschlossen`;
+    }
+  }
+
+  private getPhaseDisplayName(phaseId: string): string {
+    const phaseNames: Record<string, string> = {
+      'preparation': 'Vorbereitung',
+      'acquisition': 'Datensammlung', 
+      'examination': 'Untersuchung',
+      'analysis': 'Analyse',
+      'reporting': 'Dokumentation',
+      'presentation': 'Präsentation'
+    };
+    return phaseNames[phaseId] || phaseId;
+  }
+
+  private inferDecisionBasis(metadata: Record<string, any>): string {
+    if (metadata.embeddingsUsed) return 'semantic-search';
+    if (metadata.aiPrompt || metadata.microTaskType) return 'ai-analysis';
+    if (metadata.semanticQuery && metadata.aiReasoningUsed) return 'hybrid';
+    return 'rule-based';
+  }
+
   getCurrentAuditTrail(): AuditEntry[] {
     return [...this.activeAuditTrail];
   }
 
-  // CLEAR AUDIT TRAIL - Start fresh for new analysis
   clearAuditTrail(): void {
     if (this.activeAuditTrail.length > 0) {
       console.log(`[AUDIT-SERVICE] Cleared ${this.activeAuditTrail.length} audit entries`);
@@ -150,229 +598,13 @@ class AuditService {
     }
   }
 
-  // FINALIZE AUDIT TRAIL - Complete analysis and return final trail
   finalizeAuditTrail(): AuditEntry[] {
     const finalTrail = [...this.activeAuditTrail];
-    console.log(`[AUDIT-SERVICE] Finalized audit trail with ${finalTrail.length} entries`);
+    console.log(`[AUDIT-SERVICE] Finalized audit trail with ${finalTrail.length} meaningful entries`);
     this.clearAuditTrail();
     return finalTrail;
   }
 
-  processAuditTrail(rawAuditTrail: AuditEntry[]): ProcessedAuditTrail | null {
-    if (!this.config.enabled) {
-        console.log('[AUDIT-SERVICE] Processing disabled');
-        return null;
-    }
-    
-    if (!rawAuditTrail || !Array.isArray(rawAuditTrail) || rawAuditTrail.length === 0) {
-        console.log('[AUDIT-SERVICE] No audit trail data to process');
-        return null;
-    }
-
-    try {
-        console.log(`[AUDIT-SERVICE] Processing ${rawAuditTrail.length} audit entries`);
-
-        const totalTime = rawAuditTrail.reduce((sum, entry) => sum + (entry.processingTimeMs || 0), 0);
-        const validConfidenceEntries = rawAuditTrail.filter(entry => typeof entry.confidence === 'number');
-        const avgConfidence = validConfidenceEntries.length > 0 
-        ? Math.round(validConfidenceEntries.reduce((sum, entry) => sum + entry.confidence, 0) / validConfidenceEntries.length)
-        : 0;
-        
-        const highConfidenceSteps = rawAuditTrail.filter(entry => (entry.confidence || 0) >= 80).length;
-        const lowConfidenceSteps = rawAuditTrail.filter(entry => (entry.confidence || 0) < 60).length;
-
-        const groupedEntries = rawAuditTrail.reduce((groups, entry) => {
-        const phase = entry.phase || 'unknown';
-        if (!groups[phase]) groups[phase] = [];
-        groups[phase].push(entry);
-        return groups;
-        }, {} as Record<string, AuditEntry[]>);
-
-        const phases = Object.entries(groupedEntries).map(([phase, entries]) => {
-        const phaseConfig = this.phaseConfig[phase] || { icon: '📋', displayName: phase };
-        const validEntries = entries.filter(entry => entry && typeof entry === 'object');
-        
-        const phaseAvgConfidence = validEntries.length > 0 
-            ? Math.round(validEntries.reduce((sum, entry) => sum + (entry.confidence || 0), 0) / validEntries.length)
-            : 0;
-        
-        const phaseTotalTime = validEntries.reduce((sum, entry) => sum + (entry.processingTimeMs || 0), 0);
-
-        return {
-            name: phase,
-            icon: phaseConfig.icon,
-            displayName: phaseConfig.displayName,
-            avgConfidence: phaseAvgConfidence,
-            totalTime: phaseTotalTime,
-            entries: validEntries
-              .map(e => this.compressEntry(e))
-              .filter((e): e is CompressedAuditEntry => e !== null)
-        };
-        }).filter(phase => phase.entries.length > 0);
-
-        const summary = this.generateSummary(rawAuditTrail, avgConfidence, lowConfidenceSteps);
-
-        const result: ProcessedAuditTrail = {
-        totalTime,
-        avgConfidence,
-        stepCount: rawAuditTrail.length,
-        highConfidenceSteps,
-        lowConfidenceSteps,
-        phases,
-        summary
-        };
-
-        console.log(`[AUDIT-SERVICE] Successfully processed audit trail: ${result.phases.length} phases, ${result.avgConfidence}% avg confidence`);
-        return result;
-        
-    } catch (error) {
-        console.error('[AUDIT-SERVICE] Error processing audit trail:', error);
-        return null;
-    }
-  }
-
-  private compressEntry(entry: AuditEntry): CompressedAuditEntry | null {
-    if (!entry || typeof entry !== 'object') {
-        console.warn('[AUDIT-SERVICE] Invalid audit entry skipped');
-        return null;
-    }
-
-    try {
-        return {
-        timestamp: entry.timestamp || Date.now(),
-        phase: entry.phase || 'unknown',
-        action: entry.action || 'unknown',
-        inputSummary: this.summarizeData(entry.input),
-        outputSummary: this.summarizeData(entry.output),
-        confidence: entry.confidence || 0,
-        processingTimeMs: entry.processingTimeMs || 0,
-        metadata: entry.metadata || {}
-        };
-    } catch (error) {
-        console.error('[AUDIT-SERVICE] Error compressing entry:', error);
-        return null;
-    }
-  }
-
-  private compressData(data: any): any {
-    if (this.config.detailLevel === 'verbose') {
-      return data; 
-    } else if (this.config.detailLevel === 'standard') {
-      return this.summarizeForStorage(data);
-    } else {
-      return this.minimalSummary(data);
-    }
-  }
-
-  private summarizeData(data: any): string {
-    if (data === null || data === undefined) return 'null';
-    if (typeof data === 'string') {
-      return data.length > 100 ? data.slice(0, 100) + '...' : data;
-    }
-    if (typeof data === 'number' || typeof data === 'boolean') {
-      return data.toString();
-    }
-    if (Array.isArray(data)) {
-      if (data.length === 0) return '[]';
-      if (data.length <= 3) return JSON.stringify(data);
-      return `[${data.slice(0, 3).map(i => typeof i === 'string' ? i : JSON.stringify(i)).join(', ')}, ...+${data.length - 3}]`;
-    }
-    if (typeof data === 'object') {
-      const keys = Object.keys(data);
-      if (keys.length === 0) return '{}';
-      if (keys.length <= 3) {
-        return '{' + keys.map(k => `${k}: ${typeof data[k] === 'string' ? data[k].slice(0, 20) + (data[k].length > 20 ? '...' : '') : JSON.stringify(data[k])}`).join(', ') + '}';
-      }
-      return `{${keys.slice(0, 3).join(', ')}, ...+${keys.length - 3} keys}`;
-    }
-    return String(data);
-  }
-
-  private summarizeForStorage(data: any): any {
-    if (typeof data === 'string' && data.length > 500) {
-      return data.slice(0, 500) + '...[truncated]';
-    }
-    if (Array.isArray(data) && data.length > 10) {
-      return [...data.slice(0, 10), `...[${data.length - 10} more items]`];
-    }
-    return data;
-  }
-
-  private minimalSummary(data: any): any {
-    if (typeof data === 'string' && data.length > 100) {
-      return data.slice(0, 100) + '...[truncated]';
-    }
-    if (Array.isArray(data) && data.length > 3) {
-      return [...data.slice(0, 3), `...[${data.length - 3} more items]`];
-    }
-    return data;
-  }
-
-  private generateSummary(entries: AuditEntry[], avgConfidence: number, lowConfidenceSteps: number): {
-    analysisQuality: 'excellent' | 'good' | 'fair' | 'poor';
-    keyInsights: string[];
-    potentialIssues: string[];
-  } {
-    let analysisQuality: 'excellent' | 'good' | 'fair' | 'poor';
-    if (avgConfidence >= 85 && lowConfidenceSteps === 0) {
-      analysisQuality = 'excellent';
-    } else if (avgConfidence >= 70 && lowConfidenceSteps <= 1) {
-      analysisQuality = 'good';
-    } else if (avgConfidence >= 60 && lowConfidenceSteps <= 3) {
-      analysisQuality = 'fair';
-    } else {
-      analysisQuality = 'poor';
-    }
-
-    const keyInsights: string[] = [];
-    const embeddingsUsed = entries.some(e => e.action === 'embeddings-search');
-    if (embeddingsUsed) {
-      keyInsights.push('Semantische Suche wurde erfolgreich eingesetzt');
-    }
-
-    const toolSelectionEntries = entries.filter(e => e.action === 'ai-tool-selection');
-    if (toolSelectionEntries.length > 0) {
-      const avgSelectionConfidence = toolSelectionEntries.reduce((sum, e) => sum + e.confidence, 0) / toolSelectionEntries.length;
-      if (avgSelectionConfidence >= 80) {
-        keyInsights.push('Hohe Konfidenz bei der Tool-Auswahl');
-      }
-    }
-
-    const potentialIssues: string[] = [];
-    if (lowConfidenceSteps > 2) {
-      potentialIssues.push(`${lowConfidenceSteps} Analyseschritte mit niedriger Konfidenz`);
-    }
-
-    const longSteps = entries.filter(e => e.processingTimeMs > 5000);
-    if (longSteps.length > 0) {
-      potentialIssues.push(`${longSteps.length} Schritte benötigten mehr als 5 Sekunden`);
-    }
-
-    return {
-      analysisQuality,
-      keyInsights,
-      potentialIssues
-    };
-  }
-
-  getActionDisplayName(action: string): string {
-    return this.actionTranslations[action] || action;
-  }
-
-  formatDuration(ms: number): string {
-    if (ms < 1000) return '< 1s';
-    if (ms < 60000) return `${Math.ceil(ms / 1000)}s`;
-    const minutes = Math.floor(ms / 60000);
-    const seconds = Math.ceil((ms % 60000) / 1000);
-    return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
-  }
-
-  getConfidenceColor(confidence: number): string {
-    if (confidence >= 80) return 'var(--color-accent)';
-    if (confidence >= 60) return 'var(--color-warning)';
-    return 'var(--color-error)';
-  }
-
   isEnabled(): boolean {
     return this.config.enabled;
   }
@@ -380,7 +612,149 @@ class AuditService {
   getConfig(): AuditConfig {
     return { ...this.config };
   }
+
+  calculateAIResponseConfidence(
+    response: string, 
+    expectedLength: { min: number; max: number },
+    taskType: string
+  ): number {
+    let confidence = 50;
+    
+    if (response.length >= expectedLength.min) {
+      confidence += 20;
+      if (response.length <= expectedLength.max) {
+        confidence += 10;
+      }
+    } else {
+      confidence -= 20;
+    }
+    
+    if (response.includes('...') || response.endsWith('...')) {
+      confidence -= 10;
+    }
+    
+    switch (taskType) {
+      case 'scenario-analysis':
+      case 'investigation-approach':
+      case 'critical-considerations':
+        const forensicTerms = ['forensisch', 'beweis', 'evidence', 'analyse', 'untersuchung', 'methodik'];
+        const termsFound = forensicTerms.filter(term => 
+          response.toLowerCase().includes(term)
+        ).length;
+        confidence += Math.min(15, termsFound * 3);
+        break;
+        
+      case 'tool-evaluation':
+        if (response.includes('detailed_explanation') || response.includes('implementation_approach')) {
+          confidence += 15;
+        }
+        if (response.includes('pros') && response.includes('limitations')) {
+          confidence += 10;
+        }
+        break;
+        
+      case 'background-knowledge':
+        try {
+          const parsed = JSON.parse(response);
+          if (Array.isArray(parsed) && parsed.length > 0) {
+            confidence += 20;
+          }
+        } catch {
+          confidence -= 20;
+        }
+        break;
+    }
+    
+    return Math.min(95, Math.max(25, confidence));
+  }
+
+  getAuditStatistics(auditTrail: AuditEntry[]): any {
+    if (!auditTrail || auditTrail.length === 0) {
+      return {
+        totalTime: 0,
+        avgConfidence: 0,
+        stepCount: 0,
+        highConfidenceSteps: 0,
+        lowConfidenceSteps: 0,
+        phaseBreakdown: {},
+        aiDecisionCount: 0,
+        embeddingsUsageCount: 0,
+        toolSelectionCount: 0,
+        qualityMetrics: {
+          avgProcessingTime: 0,
+          confidenceDistribution: { high: 0, medium: 0, low: 0 }
+        }
+      };
+    }
+
+    const totalTime = auditTrail.reduce((sum, entry) => sum + (entry.processingTimeMs || 0), 0);
+    const validConfidenceEntries = auditTrail.filter(entry => typeof entry.confidence === 'number');
+    const avgConfidence = validConfidenceEntries.length > 0 
+      ? Math.round(validConfidenceEntries.reduce((sum, entry) => sum + entry.confidence, 0) / validConfidenceEntries.length)
+      : 0;
+    
+    return {
+      totalTime,
+      avgConfidence,
+      stepCount: auditTrail.length,
+      highConfidenceSteps: auditTrail.filter(entry => (entry.confidence || 0) >= 80).length,
+      lowConfidenceSteps: auditTrail.filter(entry => (entry.confidence || 0) < 60).length,
+      phaseBreakdown: {},
+      aiDecisionCount: auditTrail.filter(entry => entry.action === 'ai-decision').length,
+      embeddingsUsageCount: auditTrail.filter(entry => entry.metadata?.embeddingsUsed).length,
+      toolSelectionCount: auditTrail.filter(entry => entry.action === 'selection-decision').length,
+      qualityMetrics: {
+        avgProcessingTime: auditTrail.length > 0 ? totalTime / auditTrail.length : 0,
+        confidenceDistribution: { 
+          high: auditTrail.filter(entry => (entry.confidence || 0) >= 80).length,
+          medium: auditTrail.filter(entry => (entry.confidence || 0) >= 60 && (entry.confidence || 0) < 80).length,
+          low: auditTrail.filter(entry => (entry.confidence || 0) < 60).length
+        }
+      }
+    };
+  }
+
+  validateAuditTrail(auditTrail: AuditEntry[]): {
+    isValid: boolean;
+    issues: string[];
+    warnings: string[];
+  } {
+    const issues: string[] = [];
+    const warnings: string[] = [];
+
+    if (!Array.isArray(auditTrail)) {
+      issues.push('Audit trail is not an array');
+      return { isValid: false, issues, warnings };
+    }
+
+    if (auditTrail.length === 0) {
+      warnings.push('Audit trail is empty');
+    }
+
+    auditTrail.forEach((entry, index) => {
+      if (!entry || typeof entry !== 'object') {
+        issues.push(`Entry ${index} is not a valid object`);
+        return;
+      }
+
+      const requiredFields = ['timestamp', 'phase', 'action'];
+      requiredFields.forEach(field => {
+        if (!(field in entry)) {
+          issues.push(`Entry ${index} missing required field: ${field}`);
+        }
+      });
+
+      if (typeof entry.confidence !== 'number' || entry.confidence < 0 || entry.confidence > 100) {
+        warnings.push(`Entry ${index} has invalid confidence value: ${entry.confidence}`);
+      }
+    });
+
+    return {
+      isValid: issues.length === 0,
+      issues,
+      warnings
+    };
+  }
 }
 
-export const auditService = new AuditService();
-export type { CompressedAuditEntry };
\ No newline at end of file
+export const auditService = new AuditService();
\ No newline at end of file
diff --git a/src/utils/clientUtils.ts b/src/utils/clientUtils.ts
index f0a6796..b82c874 100644
--- a/src/utils/clientUtils.ts
+++ b/src/utils/clientUtils.ts
@@ -1,9 +1,8 @@
 // src/utils/clientUtils.ts
 
-
 export function createToolSlug(toolName: string): string {
   if (!toolName || typeof toolName !== 'string') {
-    console.warn('[toolHelpers] Invalid toolName provided to createToolSlug:', toolName);
+    console.warn('[CLIENT-UTILS] Invalid toolName provided to createToolSlug:', toolName);
     return '';
   }
   
@@ -30,6 +29,81 @@ export function isToolHosted(tool: any): boolean {
          tool.projectUrl.trim() !== "";
 }
 
+export function sanitizeText(text: string): string {
+  if (typeof text !== 'string') return '';
+  
+  return text
+    .replace(/^#{1,6}\s+/gm, '')
+    .replace(/^\s*[-*+]\s+/gm, '')
+    .replace(/^\s*\d+\.\s+/gm, '')
+    .replace(/\*\*(.+?)\*\*/g, '$1')
+    .replace(/\*(.+?)\*/g, '$1')
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+    .replace(/```[\s\S]*?```/g, '[CODE BLOCK]')
+    .replace(/`([^`]+)`/g, '$1')
+    .replace(/<[^>]+>/g, '')
+    .replace(/\n\s*\n\s*\n/g, '\n\n')
+    .trim();
+}
+
+export function escapeHtml(text: string): string {
+  if (typeof text !== 'string') return String(text);
+  const div = document.createElement('div');
+  div.textContent = text;
+  return div.innerHTML;
+}
+
+export function truncateText(text: string, maxLength: number): string {
+  if (!text || text.length <= maxLength) return text;
+  return text.slice(0, maxLength) + '...';
+}
+
+export function summarizeData(data: any): string {
+  if (data === null || data === undefined) return 'null';
+  if (typeof data === 'string') {
+    return data.length > 100 ? data.slice(0, 100) + '...' : data;
+  }
+  if (typeof data === 'number' || typeof data === 'boolean') {
+    return data.toString();
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) return '[]';
+    if (data.length <= 3) return JSON.stringify(data);
+    return `[${data.slice(0, 3).map(i => typeof i === 'string' ? i : JSON.stringify(i)).join(', ')}, ...+${data.length - 3}]`;
+  }
+  if (typeof data === 'object') {
+    const keys = Object.keys(data);
+    if (keys.length === 0) return '{}';
+    if (keys.length <= 3) {
+      return '{' + keys.map(k => `${k}: ${typeof data[k] === 'string' ? data[k].slice(0, 20) + (data[k].length > 20 ? '...' : '') : JSON.stringify(data[k])}`).join(', ') + '}';
+    }
+    return `{${keys.slice(0, 3).join(', ')}, ...+${keys.length - 3} keys}`;
+  }
+  return String(data);
+}
+
+export function formatDuration(ms: number): string {
+  if (ms < 1000) return '< 1s';
+  if (ms < 60000) return `${Math.ceil(ms / 1000)}s`;
+  const minutes = Math.floor(ms / 60000);
+  const seconds = Math.ceil((ms % 60000) / 1000);
+  return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+}
+
+export function showElement(element: HTMLElement | null): void {
+  if (element) {
+    element.style.display = 'block';
+    element.classList.remove('hidden');
+  }
+}
+
+export function hideElement(element: HTMLElement | null): void {
+  if (element) {
+    element.style.display = 'none';
+    element.classList.add('hidden');
+  }
+}
+
 interface AutocompleteOptions {
   minLength?: number;
   maxResults?: number;
@@ -202,7 +276,7 @@ export class AutocompleteManager {
   
   defaultRender(item: any): string {
     const text = typeof item === 'string' ? item : item.name || item.label || item.toString();
-    return `<div class="autocomplete-item">${this.escapeHtml(text)}</div>`;
+    return `<div class="autocomplete-item">${escapeHtml(text)}</div>`;
   }
   
   renderDropdown(): void {
@@ -284,8 +358,8 @@ export class AutocompleteManager {
           align-items: center;
           gap: 0.25rem;
         ">
-          ${this.escapeHtml(item)}
-          <button type="button" class="autocomplete-remove" data-item="${this.escapeHtml(item)}" style="
+          ${escapeHtml(item)}
+          <button type="button" class="autocomplete-remove" data-item="${escapeHtml(item)}" style="
             background: none;
             border: none;
             color: white;
@@ -327,12 +401,6 @@ export class AutocompleteManager {
     this.selectedIndex = -1;
   }
   
-  escapeHtml(text: string): string {
-    const div = document.createElement('div');
-    div.textContent = text;
-    return div.innerHTML;
-  }
-  
   setDataSource(newDataSource: any[]): void {
     this.dataSource = newDataSource;
   }
diff --git a/src/utils/confidenceScoring.ts b/src/utils/confidenceScoring.ts
new file mode 100644
index 0000000..4f4fd0a
--- /dev/null
+++ b/src/utils/confidenceScoring.ts
@@ -0,0 +1,225 @@
+// src/utils/confidenceScoring.ts
+import { isToolHosted } from './clientUtils.js';
+import 'dotenv/config';
+
+export interface ConfidenceMetrics {
+  overall: number;
+  semanticRelevance: number;
+  taskSuitability: number;
+  uncertaintyFactors: string[];
+  strengthIndicators: string[];
+}
+
+export interface ConfidenceConfig {
+  semanticWeight: number;
+  suitabilityWeight: number;
+  minimumThreshold: number;
+  mediumThreshold: number;
+  highThreshold: number;
+}
+
+export interface AnalysisContext {
+  userQuery: string;
+  mode: string;
+  embeddingsSimilarities: Map<string, number>;
+  selectedTools?: Array<{
+    tool: any;
+    phase: string;
+    priority: string;
+    justification?: string;
+    taskRelevance?: number;
+    limitations?: string[];
+  }>;
+}
+
+class ConfidenceScoring {
+  private config: ConfidenceConfig;
+
+  constructor() {
+    this.config = {
+      semanticWeight: this.getEnvFloat('CONFIDENCE_SEMANTIC_WEIGHT', 0.3),
+      suitabilityWeight: this.getEnvFloat('CONFIDENCE_SUITABILITY_WEIGHT', 0.7), 
+      minimumThreshold: this.getEnvInt('CONFIDENCE_MINIMUM_THRESHOLD', 40),
+      mediumThreshold: this.getEnvInt('CONFIDENCE_MEDIUM_THRESHOLD', 60),
+      highThreshold: this.getEnvInt('CONFIDENCE_HIGH_THRESHOLD', 80)
+    };
+
+    console.log('[CONFIDENCE-SCORING] Initialized with restored config:', this.config);
+  }
+
+  private getEnvFloat(key: string, defaultValue: number): number {
+    const value = process.env[key];
+    return value ? parseFloat(value) : defaultValue;
+  }
+
+  private getEnvInt(key: string, defaultValue: number): number {
+    const value = process.env[key];
+    return value ? parseInt(value, 10) : defaultValue;
+  }
+
+  calculateRecommendationConfidence(
+    tool: any,
+    context: AnalysisContext,
+    taskRelevance: number = 70,
+    limitations: string[] = []
+  ): ConfidenceMetrics {
+    console.log('[CONFIDENCE-SCORING] Calculating confidence for tool:', tool.name);
+
+    const rawSemanticRelevance = context.embeddingsSimilarities.has(tool.name) ?
+      context.embeddingsSimilarities.get(tool.name)! * 100 : 50;
+    
+    let enhancedTaskSuitability = taskRelevance;
+    
+    if (context.mode === 'workflow') {
+      const toolSelection = context.selectedTools?.find((st: any) => st.tool && st.tool.name === tool.name);
+      if (toolSelection && tool.phases && Array.isArray(tool.phases) && tool.phases.includes(toolSelection.phase)) {
+        const phaseBonus = Math.min(15, 100 - taskRelevance);
+        enhancedTaskSuitability = Math.min(100, taskRelevance + phaseBonus);
+        console.log('[CONFIDENCE-SCORING] Phase alignment bonus applied:', phaseBonus);
+      }
+    }
+    
+    const overall = (
+      rawSemanticRelevance * this.config.semanticWeight +
+      enhancedTaskSuitability * this.config.suitabilityWeight
+    );
+
+    const uncertaintyFactors = this.identifyUncertaintyFactors(tool, context, limitations, overall);
+    const strengthIndicators = this.identifyStrengthIndicators(tool, context, overall);
+
+    const result = {
+      overall: Math.round(overall),
+      semanticRelevance: Math.round(rawSemanticRelevance),
+      taskSuitability: Math.round(enhancedTaskSuitability),
+      uncertaintyFactors,
+      strengthIndicators
+    };
+
+    console.log('[CONFIDENCE-SCORING] Confidence calculated:', {
+      tool: tool.name,
+      overall: result.overall,
+      semantic: result.semanticRelevance,
+      task: result.taskSuitability,
+      uncertaintyCount: uncertaintyFactors.length,
+      strengthCount: strengthIndicators.length
+    });
+
+    return result;
+  }
+
+  private identifyUncertaintyFactors(
+    tool: any,
+    context: AnalysisContext,
+    limitations: string[],
+    confidence: number
+  ): string[] {
+    const factors: string[] = [];
+    
+    if (limitations?.length > 0) {
+      factors.push(...limitations.slice(0, 2));
+    }
+    
+    const similarity = context.embeddingsSimilarities.get(tool.name) || 0.5;
+    if (similarity < 0.7) {
+      factors.push('Geringe semantische Ähnlichkeit zur Anfrage');
+    }
+    
+    if (tool.skillLevel === 'expert' && /schnell|rapid|triage|urgent|sofort/i.test(context.userQuery)) {
+      factors.push('Experten-Tool für zeitkritisches Szenario');
+    }
+    
+    if (tool.skillLevel === 'novice' && /komplex|erweitert|tiefgehend|advanced|forensisch/i.test(context.userQuery)) {
+      factors.push('Einsteiger-Tool für komplexe Analyse');
+    }
+    
+    if (tool.type === 'software' && !isToolHosted(tool) && tool.accessType === 'download') {
+      factors.push('Installation und Setup erforderlich');
+    }
+    
+    if (tool.license === 'Proprietary') {
+      factors.push('Kommerzielle Software - Lizenzkosten zu beachten');
+    }
+    
+    if (confidence < 60) {
+      factors.push('Moderate Gesamtbewertung - alternative Ansätze empfohlen');
+    }
+    
+    return factors.slice(0, 4);
+  }
+
+  private identifyStrengthIndicators(tool: any, context: AnalysisContext, confidence: number): string[] {
+    const indicators: string[] = [];
+    
+    const similarity = context.embeddingsSimilarities.get(tool.name) || 0.5;
+    if (similarity >= 0.7) {
+      indicators.push('Sehr gute semantische Übereinstimmung mit Ihrer Anfrage');
+    }
+    
+    if (tool.knowledgebase === true) {
+      indicators.push('Umfassende Dokumentation und Wissensbasis verfügbar');
+    }
+    
+    if (isToolHosted(tool)) {
+      indicators.push('Sofort verfügbar über gehostete Lösung');
+    }
+    
+    if (tool.skillLevel === 'intermediate' || tool.skillLevel === 'advanced') {
+      indicators.push('Ausgewogenes Verhältnis zwischen Funktionalität und Benutzerfreundlichkeit');
+    }
+    
+    if (tool.type === 'method' && /methodik|vorgehen|prozess|ansatz/i.test(context.userQuery)) {
+      indicators.push('Methodischer Ansatz passt zu Ihrer prozeduralen Anfrage');
+    }
+    
+    return indicators.slice(0, 4);
+  }
+
+  calculateSelectionConfidence(result: any, candidateCount: number): number {
+    if (!result?.selectedTools) {
+      console.log('[CONFIDENCE-SCORING] No selected tools for confidence calculation');
+      return 30;
+    }
+    
+    const selectionRatio = result.selectedTools.length / candidateCount;
+    const hasReasoning = result.reasoning && result.reasoning.length > 50;
+    
+    let confidence = 60;
+    
+    if (selectionRatio > 0.05 && selectionRatio < 0.3) confidence += 20;
+    else if (selectionRatio <= 0.05) confidence -= 10;
+    else confidence -= 15;
+    
+    if (hasReasoning) confidence += 15;
+    if (result.selectedConcepts?.length > 0) confidence += 5;
+    
+    const finalConfidence = Math.min(95, Math.max(25, confidence));
+    
+    console.log('[CONFIDENCE-SCORING] Selection confidence calculated:', {
+      candidateCount,
+      selectedCount: result.selectedTools.length,
+      selectionRatio: selectionRatio.toFixed(3),
+      hasReasoning,
+      confidence: finalConfidence
+    });
+    
+    return finalConfidence;
+  }
+
+  getConfidenceLevel(confidence: number): 'weak' | 'moderate' | 'strong' {
+    if (confidence >= this.config.highThreshold) return 'strong';
+    if (confidence >= this.config.mediumThreshold) return 'moderate';
+    return 'weak';
+  }
+
+  getConfidenceColor(confidence: number): string {
+    if (confidence >= this.config.highThreshold) return 'var(--color-accent)';
+    if (confidence >= this.config.mediumThreshold) return 'var(--color-warning)';
+    return 'var(--color-error)';
+  }
+
+  getConfig(): ConfidenceConfig {
+    return { ...this.config };
+  }
+}
+
+export const confidenceScoring = new ConfidenceScoring();
\ No newline at end of file
diff --git a/src/utils/dataService.ts b/src/utils/dataService.ts
index bd8ceb5..427a295 100644
--- a/src/utils/dataService.ts
+++ b/src/utils/dataService.ts
@@ -85,7 +85,7 @@ let cachedData: ToolsData | null = null;
 let cachedRandomizedData: ToolsData | null = null;
 let cachedCompressedData: EnhancedCompressedToolsData | null = null;
 let lastRandomizationDate: string | null = null;
-let dataVersion: string | null = null;
+let cachedToolsHash: string | null = null;
 
 function seededRandom(seed: number): () => number {
   let x = Math.sin(seed) * 10000;
@@ -110,17 +110,6 @@ function shuffleArray<T>(array: T[], randomFn: () => number): T[] {
   return shuffled;
 }
 
-function generateDataVersion(data: any): string {
-  const str = JSON.stringify(data, Object.keys(data).sort());
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = ((hash << 5) - hash) + char;
-    hash = hash & hash;
-  }
-  return Math.abs(hash).toString(36);
-}
-
 async function loadRawData(): Promise<ToolsData> {
   if (!cachedData) {
     const yamlPath = path.join(process.cwd(), 'src/data/tools.yaml');
@@ -142,8 +131,9 @@ async function loadRawData(): Promise<ToolsData> {
         };
       }
       
-      dataVersion = generateDataVersion(cachedData);
-      console.log(`[DATA SERVICE] Loaded enhanced data version: ${dataVersion}`);
+      const { getToolsFileHash } = await import('./hashUtils.js');
+    cachedToolsHash = await getToolsFileHash();
+    console.log(`[DATA SERVICE] Loaded data with hash: ${cachedToolsHash.slice(0, 12)}...`);
       
     } catch (error) {
       if (error instanceof z.ZodError) {
@@ -234,7 +224,7 @@ export async function getCompressedToolsDataForAI(): Promise<EnhancedCompressedT
 }
 
 export function getDataVersion(): string | null {
-  return dataVersion;
+  return cachedToolsHash;
 }
 
 export function clearCache(): void {
@@ -242,7 +232,7 @@ export function clearCache(): void {
   cachedRandomizedData = null;
   cachedCompressedData = null;
   lastRandomizationDate = null;
-  dataVersion = null;
+  cachedToolsHash = null;
   
   console.log('[DATA SERVICE] Enhanced cache cleared');
 }
\ No newline at end of file
diff --git a/src/utils/embeddings.ts b/src/utils/embeddings.ts
index edd9ed9..ddbe7ad 100644
--- a/src/utils/embeddings.ts
+++ b/src/utils/embeddings.ts
@@ -1,11 +1,11 @@
-// src/utils/embeddings.ts
+// src/utils/embeddings.ts - Refactored
 import { promises as fs } from 'fs';
 import path from 'path';
 import { getCompressedToolsDataForAI } from './dataService.js';
 import 'dotenv/config';
 import crypto from 'crypto';
 
-interface EmbeddingData {
+export interface EmbeddingData {
   id: string;
   type: 'tool' | 'concept';
   name: string;
@@ -20,14 +20,22 @@ interface EmbeddingData {
   };
 }
 
+export interface SimilarityResult extends EmbeddingData {
+  similarity: number;
+}
+
 interface EmbeddingsDatabase {
   version: string;
   lastUpdated: number;
   embeddings: EmbeddingData[];
 }
 
-interface SimilarityResult extends EmbeddingData {
-  similarity: number;
+interface EmbeddingsConfig {
+  endpoint?: string;
+  apiKey?: string;
+  model?: string;
+  batchSize: number;
+  batchDelay: number;
 }
 
 class EmbeddingsService {
@@ -35,48 +43,30 @@ class EmbeddingsService {
   private isInitialized = false;
   private initializationPromise: Promise<void> | null = null;
   private readonly embeddingsPath = path.join(process.cwd(), 'data', 'embeddings.json');
-  private readonly batchSize: number;
-  private readonly batchDelay: number;
-  private enabled: boolean = false;
+  private config: EmbeddingsConfig;
 
   constructor() {
-    this.batchSize = parseInt(process.env.AI_EMBEDDINGS_BATCH_SIZE || '20', 10);
-    this.batchDelay = parseInt(process.env.AI_EMBEDDINGS_BATCH_DELAY_MS || '1000', 10);
-    
-    this.enabled = true;
+    this.config = this.loadConfig();
+    console.log('[EMBEDDINGS-SERVICE] Initialized:', {
+      hasEndpoint: !!this.config.endpoint,
+      hasModel: !!this.config.model
+    });
   }
 
-  private async checkEnabledStatus(): Promise<void> {
-    try {   
-      const envEnabled = process.env.AI_EMBEDDINGS_ENABLED;
-      
-      if (envEnabled === 'true') {
-        const endpoint = process.env.AI_EMBEDDINGS_ENDPOINT;
-        const model = process.env.AI_EMBEDDINGS_MODEL;
-        
-        if (!endpoint || !model) {
-          console.warn('[EMBEDDINGS] Embeddings enabled but API configuration missing - disabling');
-          this.enabled = false;
-          return;
-        }
-        
-        console.log('[EMBEDDINGS] All requirements met - enabling embeddings');
-        this.enabled = true;
-        return;
-      }
-      
-      try {
-        await fs.stat(this.embeddingsPath);
-        console.log('[EMBEDDINGS] Existing embeddings file found - enabling');
-        this.enabled = true;
-      } catch {
-        console.log('[EMBEDDINGS] Embeddings not explicitly enabled - disabling');
-        this.enabled = false;
-      }
-    } catch (error) {
-      console.error('[EMBEDDINGS] Error checking enabled status:', error);
-      this.enabled = false;
-    }
+  private loadConfig(): EmbeddingsConfig {
+    const endpoint = process.env.AI_EMBEDDINGS_ENDPOINT;
+    const apiKey = process.env.AI_EMBEDDINGS_API_KEY;
+    const model = process.env.AI_EMBEDDINGS_MODEL;
+    const batchSize = parseInt(process.env.AI_EMBEDDINGS_BATCH_SIZE || '20', 10);
+    const batchDelay = parseInt(process.env.AI_EMBEDDINGS_BATCH_DELAY_MS || '1000', 10);
+
+    return {
+      endpoint,
+      apiKey,
+      model,
+      batchSize,
+      batchDelay
+    };
   }
 
   async initialize(): Promise<void> {
@@ -93,63 +83,55 @@ class EmbeddingsService {
   }
 
   private async performInitialization(): Promise<void> {
-    await this.checkEnabledStatus();
-    if (!this.enabled) {
-      console.log('[EMBEDDINGS] Embeddings disabled, skipping initialization');
-      return;
-    }
-
     const initStart = Date.now();
+    
     try {
-      console.log('[EMBEDDINGS] Initializing embeddings system…');
+      console.log('[EMBEDDINGS-SERVICE] Starting initialization');
+
+      /*if (!this.config.enabled) {
+        console.log('[EMBEDDINGS-SERVICE] Service disabled via configuration');
+        return;
+      }*/
 
       await fs.mkdir(path.dirname(this.embeddingsPath), { recursive: true });
 
-      const toolsData        = await getCompressedToolsDataForAI();
-      const currentDataHash  = await this.hashToolsFile();
+      const toolsData = await getCompressedToolsDataForAI();
+      const { getToolsFileHash } = await import('./hashUtils.js');
+      const currentDataHash = await getToolsFileHash();
 
-      const existing         = await this.loadEmbeddings();
-      console.log('[EMBEDDINGS] Current hash:', currentDataHash);
-      console.log('[EMBEDDINGS] Existing file version:', existing?.version);
-      console.log('[EMBEDDINGS] Existing embeddings length:', existing?.embeddings?.length);
-
-      const cacheIsUsable =
-        existing &&
+      const existing = await this.loadEmbeddings();
+      
+      const cacheIsUsable = existing && 
         existing.version === currentDataHash &&
         Array.isArray(existing.embeddings) &&
         existing.embeddings.length > 0;
 
       if (cacheIsUsable) {
-        console.log('[EMBEDDINGS] Using cached embeddings');
-        this.embeddings    = existing.embeddings;
+        console.log('[EMBEDDINGS-SERVICE] Using cached embeddings');
+        this.embeddings = existing.embeddings;
       } else {
-        console.log('[EMBEDDINGS] Generating new embeddings…');
+        console.log('[EMBEDDINGS-SERVICE] Generating new embeddings');
         await this.generateEmbeddings(toolsData, currentDataHash);
       }
 
       this.isInitialized = true;
-      console.log(`[EMBEDDINGS] Initialized with ${this.embeddings.length} embeddings in ${Date.now() - initStart} ms`);
-    } catch (err) {
-      console.error('[EMBEDDINGS] Failed to initialize:', err);
+      console.log(`[EMBEDDINGS-SERVICE] Initialized successfully with ${this.embeddings.length} embeddings in ${Date.now() - initStart}ms`);
+      
+    } catch (error) {
+      console.error('[EMBEDDINGS-SERVICE] Initialization failed:', error);
       this.isInitialized = false;
-      throw err;
+      throw error;
     } finally {
       this.initializationPromise = null;
     }
   }
 
-  private async hashToolsFile(): Promise<string> {
-    const file = path.join(process.cwd(), 'src', 'data', 'tools.yaml');
-    const raw  = await fs.readFile(file, 'utf8');
-    return crypto.createHash('sha256').update(raw).digest('hex');
-  }
-
   private async loadEmbeddings(): Promise<EmbeddingsDatabase | null> {
     try {
       const data = await fs.readFile(this.embeddingsPath, 'utf8');
       return JSON.parse(data);
     } catch (error) {
-      console.log('[EMBEDDINGS] No existing embeddings found');
+      console.log('[EMBEDDINGS-SERVICE] No existing embeddings file found');
       return null;
     }
   }
@@ -162,7 +144,7 @@ class EmbeddingsService {
     };
     
     await fs.writeFile(this.embeddingsPath, JSON.stringify(database, null, 2));
-    console.log(`[EMBEDDINGS] Saved ${this.embeddings.length} embeddings to disk`);
+    console.log(`[EMBEDDINGS-SERVICE] Saved ${this.embeddings.length} embeddings to disk`);
   }
 
   private createContentString(item: any): string {
@@ -178,30 +160,23 @@ class EmbeddingsService {
   }
 
   private async generateEmbeddingsBatch(contents: string[]): Promise<number[][]> {
-    const endpoint = process.env.AI_EMBEDDINGS_ENDPOINT;
-    const apiKey = process.env.AI_EMBEDDINGS_API_KEY;
-    const model = process.env.AI_EMBEDDINGS_MODEL;
-
-    if (!endpoint || !model) {
-      const missing: string[] = [];
-      if (!endpoint) missing.push('AI_EMBEDDINGS_ENDPOINT');
-      if (!model) missing.push('AI_EMBEDDINGS_MODEL');
-      throw new Error(`Missing embeddings API configuration: ${missing.join(', ')}`);
+    if (!this.config.endpoint || !this.config.model) {
+      throw new Error('Missing embeddings API configuration');
     }
 
     const headers: Record<string, string> = {
       'Content-Type': 'application/json'
     };
 
-    if (apiKey) {
-      headers['Authorization'] = `Bearer ${apiKey}`;
+    if (this.config.apiKey) {
+      headers['Authorization'] = `Bearer ${this.config.apiKey}`;
     }
 
-    const response = await fetch(endpoint, {
+    const response = await fetch(this.config.endpoint, {
       method: 'POST',
       headers,
       body: JSON.stringify({
-        model,
+        model: this.config.model,
         input: contents
       })
     });
@@ -233,11 +208,16 @@ class EmbeddingsService {
     const contents = allItems.map(item => this.createContentString(item));
     this.embeddings = [];
 
-    for (let i = 0; i < contents.length; i += this.batchSize) {
-      const batch = contents.slice(i, i + this.batchSize);
-      const batchItems = allItems.slice(i, i + this.batchSize);
+    console.log(`[EMBEDDINGS-SERVICE] Generating embeddings for ${contents.length} items`);
+
+    for (let i = 0; i < contents.length; i += this.config.batchSize) {
+      const batch = contents.slice(i, i + this.config.batchSize);
+      const batchItems = allItems.slice(i, i + this.config.batchSize);
       
-      console.log(`[EMBEDDINGS] Processing batch ${Math.ceil((i + 1) / this.batchSize)} of ${Math.ceil(contents.length / this.batchSize)}`);
+      const batchNumber = Math.ceil((i + 1) / this.config.batchSize);
+      const totalBatches = Math.ceil(contents.length / this.config.batchSize);
+      
+      console.log(`[EMBEDDINGS-SERVICE] Processing batch ${batchNumber}/${totalBatches}`);
       
       try {
         const embeddings = await this.generateEmbeddingsBatch(batch);
@@ -260,12 +240,12 @@ class EmbeddingsService {
           });
         });
         
-        if (i + this.batchSize < contents.length) {
-          await new Promise(resolve => setTimeout(resolve, this.batchDelay));
+        if (i + this.config.batchSize < contents.length) {
+          await new Promise(resolve => setTimeout(resolve, this.config.batchDelay));
         }
         
       } catch (error) {
-        console.error(`[EMBEDDINGS] Failed to process batch ${Math.ceil((i + 1) / this.batchSize)}:`, error);
+        console.error(`[EMBEDDINGS-SERVICE] Batch ${batchNumber} failed:`, error);
         throw error;
       }
     }
@@ -273,18 +253,21 @@ class EmbeddingsService {
     await this.saveEmbeddings(version);
   }
 
-  public async embedText(text: string): Promise<number[]> {
-    if (!this.enabled || !this.isInitialized) {
+  async embedText(text: string): Promise<number[]> {
+    if (!this.isInitialized) {
       throw new Error('Embeddings service not available');
     }
+    
     const [embedding] = await this.generateEmbeddingsBatch([text.toLowerCase()]);
     return embedding;
   }
 
   async waitForInitialization(): Promise<void> {
-    await this.checkEnabledStatus();
-    
-    if (!this.enabled || this.isInitialized) {
+    /*if (!this.config.enabled) {
+      return Promise.resolve();
+    }*/
+
+    if (this.isInitialized) {
       return Promise.resolve();
     }
 
@@ -296,13 +279,6 @@ class EmbeddingsService {
     return this.initialize();
   }
 
-  async forceRecheckEnvironment(): Promise<void> {
-    this.enabled = false;
-    this.isInitialized = false;
-    await this.checkEnabledStatus();
-    console.log('[EMBEDDINGS] Environment status re-checked, enabled:', this.enabled);
-  }
-
   private cosineSimilarity(a: number[], b: number[]): number {
     let dotProduct = 0;
     let normA = 0;
@@ -318,145 +294,62 @@ class EmbeddingsService {
   }
 
   async findSimilar(query: string, maxResults: number = 30, threshold: number = 0.3): Promise<SimilarityResult[]> {
-    if (!this.enabled) {
-      console.log('[EMBEDDINGS] Service disabled for similarity search');
+    /*if (!this.config.enabled) {
+      console.log('[EMBEDDINGS-SERVICE] Service disabled, returning empty results');
+      return [];
+    }*/
+
+    if (!this.isInitialized || this.embeddings.length === 0) {
+      console.log('[EMBEDDINGS-SERVICE] Not initialized or no embeddings available');
       return [];
     }
 
     try {
-      if (this.isInitialized && this.embeddings.length > 0) {
-        console.log(`[EMBEDDINGS] Using embeddings data for similarity search: ${query}`);
-        
-        const queryEmbeddings = await this.generateEmbeddingsBatch([query.toLowerCase()]);
-        const queryEmbedding = queryEmbeddings[0];
+      console.log(`[EMBEDDINGS-SERVICE] Finding similar items for query: "${query}"`);
+      
+      const queryEmbeddings = await this.generateEmbeddingsBatch([query.toLowerCase()]);
+      const queryEmbedding = queryEmbeddings[0];
 
-        console.log(`[EMBEDDINGS] Computing similarities for ${this.embeddings.length} items`);
+      const similarities: SimilarityResult[] = this.embeddings.map(item => ({
+        ...item,
+        similarity: this.cosineSimilarity(queryEmbedding, item.embedding)
+      }));
 
-        const similarities: SimilarityResult[] = this.embeddings.map(item => ({
-          ...item,
-          similarity: this.cosineSimilarity(queryEmbedding, item.embedding)
-        }));
+      const topScore = Math.max(...similarities.map(s => s.similarity));
+      const dynamicThreshold = Math.max(threshold, topScore * 0.85);
 
-        const topScore      = Math.max(...similarities.map(s => s.similarity));
-        const dynamicCutOff = Math.max(threshold, topScore * 0.85);
+      const results = similarities
+        .filter(item => item.similarity >= dynamicThreshold)
+        .sort((a, b) => b.similarity - a.similarity)
+        .slice(0, maxResults);
 
-        const results = similarities
-          .filter(item => item.similarity >= dynamicCutOff)
-          .sort((a, b) => b.similarity - a.similarity)
-          .slice(0, maxResults);
-
-
-        const orderingValid = results.every((item, index) => {
-          if (index === 0) return true;
-          return item.similarity <= results[index - 1].similarity;
+      console.log(`[EMBEDDINGS-SERVICE] Found ${results.length} similar items (threshold: ${dynamicThreshold.toFixed(3)})`);
+      
+      if (results.length > 0) {
+        console.log('[EMBEDDINGS-SERVICE] Top 5 matches:');
+        results.slice(0, 5).forEach((item, idx) => {
+          console.log(`  ${idx + 1}. ${item.name} (${item.type}) = ${item.similarity.toFixed(4)}`);
         });
-
-        if (!orderingValid) {
-          console.error('[EMBEDDINGS] CRITICAL: Similarity ordering is broken!');
-          results.forEach((item, idx) => {
-            console.error(`  ${idx}: ${item.name} = ${item.similarity.toFixed(4)}`);
-          });
-        }
-
-        console.log(`[EMBEDDINGS] Found ${results.length} similar items (threshold: ${threshold})`);
-        if (results.length > 0) {
-          console.log('[EMBEDDINGS] Top 10 similarity matches:');
-          results.slice(0, 10).forEach((item, idx) => {
-            console.log(`  ${idx + 1}. ${item.name} (${item.type}) = ${item.similarity.toFixed(4)}`);
-          });
-          
-          const topSimilarity = results[0].similarity;
-          const hasHigherSimilarity = results.some(item => item.similarity > topSimilarity);
-          if (hasHigherSimilarity) {
-            console.error('[EMBEDDINGS] CRITICAL: Top result is not actually the highest similarity!');
-          }
-        }
-
-        return results;
-
-      } else {
-        console.log(`[EMBEDDINGS] No embeddings data, using fallback text matching: ${query}`);
-        
-        const { getToolsData } = await import('./dataService.js');
-        const toolsData = await getToolsData();
-        
-        const queryLower = query.toLowerCase();
-        const queryWords = queryLower.split(/\s+/).filter(w => w.length > 2);
-        
-        const similarities: SimilarityResult[] = toolsData.tools
-          .map((tool: any) => {
-            let similarity = 0;
-            
-            if (tool.name.toLowerCase().includes(queryLower)) {
-              similarity += 0.8;
-            }
-            
-            if (tool.description && tool.description.toLowerCase().includes(queryLower)) {
-              similarity += 0.6;
-            }
-            
-            if (tool.tags && Array.isArray(tool.tags)) {
-              const matchingTags = tool.tags.filter((tag: string) => 
-                tag.toLowerCase().includes(queryLower) || queryLower.includes(tag.toLowerCase())
-              );
-              if (tool.tags.length > 0) {
-                similarity += (matchingTags.length / tool.tags.length) * 0.4;
-              }
-            }
-            
-            const toolText = `${tool.name} ${tool.description || ''} ${(tool.tags || []).join(' ')}`.toLowerCase();
-            const matchingWords = queryWords.filter(word => toolText.includes(word));
-            if (queryWords.length > 0) {
-              similarity += (matchingWords.length / queryWords.length) * 0.3;
-            }
-            
-            return {
-              id: `tool_${tool.name.replace(/[^a-zA-Z0-9]/g, '_').toLowerCase()}`,
-              type: 'tool' as const,
-              name: tool.name,
-              content: toolText,
-              embedding: [],
-              metadata: {
-                domains: tool.domains || [],
-                phases: tool.phases || [],
-                tags: tool.tags || [],
-                skillLevel: tool.skillLevel,
-                type: tool.type
-              },
-              similarity: Math.min(similarity, 1.0)
-            };
-          })
-          .filter(item => item.similarity >= threshold)
-          .sort((a, b) => b.similarity - a.similarity)
-          .slice(0, maxResults);
-
-        console.log(`[EMBEDDINGS] Fallback found ${similarities.length} similar items`);
-        return similarities;
       }
 
+      return results;
+
     } catch (error) {
-      console.error('[EMBEDDINGS] Failed to find similar items:', error);
+      console.error('[EMBEDDINGS-SERVICE] Similarity search failed:', error);
       return [];
     }
   }
 
-  isEnabled(): boolean {
-    if (!this.enabled && !this.isInitialized) {
-      this.checkEnabledStatus().catch(console.error);
-    }
-    
-    return this.enabled;
-  }
-
-  getStats(): { enabled: boolean; initialized: boolean; count: number } {
+  getStats(): {initialized: boolean; count: number } {
     return {
-      enabled: this.enabled,
       initialized: this.isInitialized,
       count: this.embeddings.length
     };
   }
+
+  getConfig(): EmbeddingsConfig {
+    return { ...this.config };
+  }
 }
 
-const embeddingsService = new EmbeddingsService();
-
-export { embeddingsService, type EmbeddingData, type SimilarityResult };
\ No newline at end of file
+export const embeddingsService = new EmbeddingsService();
\ No newline at end of file
diff --git a/src/utils/hashUtils.ts b/src/utils/hashUtils.ts
new file mode 100644
index 0000000..fb7ef0b
--- /dev/null
+++ b/src/utils/hashUtils.ts
@@ -0,0 +1,20 @@
+// src/utils/hashUtils.ts
+import { promises as fs } from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+
+export async function getToolsFileHash(): Promise<string> {
+  const file = path.join(process.cwd(), 'src', 'data', 'tools.yaml');
+  const raw = await fs.readFile(file, 'utf8');
+  return crypto.createHash('sha256').update(raw).digest('hex');
+}
+
+export function getToolsFileHashSync(): string | null {
+  try {
+    const file = path.join(process.cwd(), 'src', 'data', 'tools.yaml');
+    const raw = require('fs').readFileSync(file, 'utf8');
+    return crypto.createHash('sha256').update(raw).digest('hex');
+  } catch {
+    return null;
+  }
+}
\ No newline at end of file
diff --git a/src/utils/jsonUtils.ts b/src/utils/jsonUtils.ts
new file mode 100644
index 0000000..26fc0af
--- /dev/null
+++ b/src/utils/jsonUtils.ts
@@ -0,0 +1,356 @@
+// src/utils/jsonUtils.ts
+export class JSONParser {
+  static safeParseJSON(jsonString: string, fallback: any = null): any {
+    try {
+      let cleaned = jsonString.trim();
+      
+      const jsonBlockPatterns = [
+        /```json\s*([\s\S]*?)\s*```/i,
+        /```\s*([\s\S]*?)\s*```/i,
+        /\{[\s\S]*\}/,
+      ];
+      
+      for (const pattern of jsonBlockPatterns) {
+        const match = cleaned.match(pattern);
+        if (match) {
+          cleaned = match[1] || match[0];
+          break;
+        }
+      }
+      
+      if (!cleaned.endsWith('}') && !cleaned.endsWith(']')) {
+        console.warn('[JSON-PARSER] JSON appears truncated, attempting recovery');
+        cleaned = this.repairTruncatedJSON(cleaned);
+      }
+      
+      const parsed = JSON.parse(cleaned);
+      
+      if (parsed && typeof parsed === 'object') {
+        if (!parsed.selectedTools) parsed.selectedTools = [];
+        if (!parsed.selectedConcepts) parsed.selectedConcepts = [];
+        if (!Array.isArray(parsed.selectedTools)) parsed.selectedTools = [];
+        if (!Array.isArray(parsed.selectedConcepts)) parsed.selectedConcepts = [];
+      }
+      
+      return parsed;
+      
+    } catch (error) {
+      console.warn('[JSON-PARSER] JSON parsing failed:', error.message);
+      return fallback;
+    }
+  }
+
+  private static repairTruncatedJSON(cleaned: string): string {
+    let braceCount = 0;
+    let bracketCount = 0;
+    let inString = false;
+    let escaped = false;
+    let lastCompleteStructure = '';
+    
+    for (let i = 0; i < cleaned.length; i++) {
+      const char = cleaned[i];
+      
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      
+      if (char === '\\') {
+        escaped = true;
+        continue;
+      }
+      
+      if (char === '"' && !escaped) {
+        inString = !inString;
+        continue;
+      }
+      
+      if (!inString) {
+        if (char === '{') braceCount++;
+        if (char === '}') braceCount--;
+        if (char === '[') bracketCount++;
+        if (char === ']') bracketCount--;
+        
+        if (braceCount === 0 && bracketCount === 0 && (char === '}' || char === ']')) {
+          lastCompleteStructure = cleaned.substring(0, i + 1);
+        }
+      }
+    }
+    
+    if (lastCompleteStructure) {
+      return lastCompleteStructure;
+    } else {
+      if (braceCount > 0) cleaned += '}';
+      if (bracketCount > 0) cleaned += ']';
+      return cleaned;
+    }
+  }
+
+  static extractToolsFromMalformedJSON(jsonString: string): { selectedTools: string[]; selectedConcepts: string[] } {
+    const selectedTools: string[] = [];
+    const selectedConcepts: string[] = [];
+    
+    const toolsMatch = jsonString.match(/"selectedTools"\s*:\s*\[([\s\S]*?)\]/i);
+    if (toolsMatch) {
+      const toolMatches = toolsMatch[1].match(/"([^"]+)"/g);
+      if (toolMatches) {
+        selectedTools.push(...toolMatches.map(match => match.replace(/"/g, '')));
+      }
+    }
+    
+    const conceptsMatch = jsonString.match(/"selectedConcepts"\s*:\s*\[([\s\S]*?)\]/i);
+    if (conceptsMatch) {
+      const conceptMatches = conceptsMatch[1].match(/"([^"]+)"/g);
+      if (conceptMatches) {
+        selectedConcepts.push(...conceptMatches.map(match => match.replace(/"/g, '')));
+      }
+    }
+    
+    if (selectedTools.length === 0 && selectedConcepts.length === 0) {
+      const allMatches = jsonString.match(/"([^"]+)"/g);
+      if (allMatches) {
+        const possibleNames = allMatches
+          .map(match => match.replace(/"/g, ''))
+          .filter(name => 
+            name.length > 2 && 
+            !['selectedTools', 'selectedConcepts', 'reasoning'].includes(name) &&
+            !name.includes(':') &&
+            !name.match(/^\d+$/)
+          )
+          .slice(0, 15);
+        
+        selectedTools.push(...possibleNames);
+      }
+    }
+    
+    return { selectedTools, selectedConcepts };
+  }
+
+  static secureParseJSON(jsonString: string, maxSize: number = 10 * 1024 * 1024): any {
+    if (typeof jsonString !== 'string') {
+      throw new Error('Input must be a string');
+    }
+
+    if (jsonString.length > maxSize) {
+      throw new Error(`JSON string too large (${jsonString.length} bytes, max ${maxSize})`);
+    }
+
+    const suspiciousPatterns = [
+      /<script/i,
+      /javascript:/i,
+      /eval\(/i,
+      /function\s*\(/i,
+      /__proto__/i,
+      /constructor/i
+    ];
+
+    for (const pattern of suspiciousPatterns) {
+      if (pattern.test(jsonString)) {
+        throw new Error('Potentially malicious content detected in JSON');
+      }
+    }
+
+    try {
+      const parsed = JSON.parse(jsonString);
+      
+      if (typeof parsed !== 'object' || parsed === null) {
+        throw new Error('JSON must be an object');
+      }
+
+      return parsed;
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new Error(`Invalid JSON syntax: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  static sanitizeForAudit(obj: any, maxDepth: number = 5, currentDepth: number = 0): any {
+    if (currentDepth >= maxDepth) {
+      return '[Max depth reached]';
+    }
+
+    if (obj === null || obj === undefined) {
+      return obj;
+    }
+
+    if (typeof obj === 'string') {
+      if (obj.length > 500) {
+        return obj.slice(0, 500) + '...[truncated]';
+      }
+      return obj.replace(/<script[\s\S]*?<\/script>/gi, '[script removed]');
+    }
+
+    if (typeof obj === 'number' || typeof obj === 'boolean') {
+      return obj;
+    }
+
+    if (Array.isArray(obj)) {
+      if (obj.length > 20) {
+        return [
+          ...obj.slice(0, 20).map(item => this.sanitizeForAudit(item, maxDepth, currentDepth + 1)),
+          `...[${obj.length - 20} more items]`
+        ];
+      }
+      return obj.map(item => this.sanitizeForAudit(item, maxDepth, currentDepth + 1));
+    }
+
+    if (typeof obj === 'object') {
+      const keys = Object.keys(obj);
+      if (keys.length > 50) {
+        const sanitized: any = {};
+        keys.slice(0, 50).forEach(key => {
+          sanitized[key] = this.sanitizeForAudit(obj[key], maxDepth, currentDepth + 1);
+        });
+        sanitized['[truncated]'] = `${keys.length - 50} more properties`;
+        return sanitized;
+      }
+
+      const sanitized: any = {};
+      keys.forEach(key => {
+        if (['__proto__', 'constructor', 'prototype'].includes(key)) {
+          return;
+        }
+        sanitized[key] = this.sanitizeForAudit(obj[key], maxDepth, currentDepth + 1);
+      });
+      return sanitized;
+    }
+
+    return String(obj);
+  }
+
+  static validateAuditExportStructure(data: any): { isValid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (!data || typeof data !== 'object') {
+      errors.push('Export data must be an object');
+      return { isValid: false, errors };
+    }
+
+    const requiredProps = ['metadata', 'recommendation', 'auditTrail'];
+    for (const prop of requiredProps) {
+      if (!(prop in data)) {
+        errors.push(`Missing required property: ${prop}`);
+      }
+    }
+
+    if (data.metadata && typeof data.metadata === 'object') {
+      const requiredMetadataProps = ['timestamp', 'version', 'userQuery', 'mode'];
+      for (const prop of requiredMetadataProps) {
+        if (!(prop in data.metadata)) {
+          errors.push(`Missing required metadata property: ${prop}`);
+        }
+      }
+    } else {
+      errors.push('Invalid metadata structure');
+    }
+
+    if (!Array.isArray(data.auditTrail)) {
+      errors.push('auditTrail must be an array');
+    } else {
+      data.auditTrail.forEach((entry: any, index: number) => {
+        if (!entry || typeof entry !== 'object') {
+          errors.push(`Audit entry ${index} is not a valid object`);
+          return;
+        }
+
+        const requiredEntryProps = ['timestamp', 'phase', 'action', 'confidence', 'processingTimeMs'];
+        for (const prop of requiredEntryProps) {
+          if (!(prop in entry)) {
+            errors.push(`Audit entry ${index} missing required property: ${prop}`);
+          }
+        }
+      });
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+
+  static prepareAuditExport(
+    recommendation: any,
+    userQuery: string,
+    mode: string,
+    auditTrail: any[] = [],
+    additionalMetadata: any = {}
+  ): any {
+    return {
+      metadata: {
+        timestamp: new Date().toISOString(),
+        version: "1.0",
+        userQuery: userQuery.slice(0, 1000),
+        mode,
+        exportedBy: 'ForensicPathways',
+        toolsDataHash: additionalMetadata.toolsDataHash || 'unknown',
+        aiModel: additionalMetadata.aiModel || 'unknown',
+        aiParameters: additionalMetadata.aiParameters || {},
+        processingStats: additionalMetadata.processingStats || {}
+      },
+      recommendation: this.sanitizeForAudit(recommendation, 6),
+      auditTrail: auditTrail.map(entry => this.sanitizeForAudit(entry, 4)),
+      rawContext: {
+        selectedTools: additionalMetadata.selectedTools || [],
+        backgroundKnowledge: additionalMetadata.backgroundKnowledge || [],
+        contextHistory: additionalMetadata.contextHistory || [],
+        embeddingsSimilarities: additionalMetadata.embeddingsSimilarities || {}
+      }
+    };
+  }
+
+  static validateUploadedAnalysis(data: any): { isValid: boolean; issues: string[]; warnings: string[] } {
+    const issues: string[] = [];
+    const warnings: string[] = [];
+
+    const structureValidation = this.validateAuditExportStructure(data);
+    if (!structureValidation.isValid) {
+      issues.push(...structureValidation.errors);
+      return { isValid: false, issues, warnings };
+    }
+
+    if (data.metadata) {
+      const timestamp = new Date(data.metadata.timestamp);
+      if (isNaN(timestamp.getTime())) {
+        warnings.push('Invalid timestamp in metadata');
+      } else {
+        const age = Date.now() - timestamp.getTime();
+        const maxAge = 30 * 24 * 60 * 60 * 1000; // 30 days
+        if (age > maxAge) {
+          warnings.push(`Analysis is ${Math.floor(age / (24 * 60 * 60 * 1000))} days old`);
+        }
+      }
+
+      if (!['workflow', 'tool'].includes(data.metadata.mode)) {
+        warnings.push(`Unknown analysis mode: ${data.metadata.mode}`);
+      }
+    }
+
+    if (Array.isArray(data.auditTrail)) {
+      const aiDecisions = data.auditTrail.filter(e => e.action === 'ai-decision').length;
+      const toolSelections = data.auditTrail.filter(e => e.action === 'selection-decision').length;
+      
+      if (aiDecisions === 0) {
+        warnings.push('No AI decisions found in audit trail');
+      }
+      
+      if (toolSelections === 0) {
+        warnings.push('No tool selections found in audit trail');
+      }
+
+      const entriesWithConfidence = data.auditTrail.filter(e => typeof e.confidence === 'number').length;
+      const confidenceRatio = entriesWithConfidence / data.auditTrail.length;
+      
+      if (confidenceRatio < 0.8) {
+        warnings.push(`Only ${Math.round(confidenceRatio * 100)}% of audit entries have confidence scores`);
+      }
+    }
+
+    return {
+      isValid: issues.length === 0,
+      issues,
+      warnings
+    };
+  }
+}
\ No newline at end of file
diff --git a/src/utils/toolHelpers.ts b/src/utils/toolHelpers.ts
deleted file mode 100644
index 5f8edae..0000000
--- a/src/utils/toolHelpers.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-// src/utils/toolHelpers.ts
-
-export interface Tool {
-  name: string;
-  type?: 'software' | 'method' | 'concept';
-  projectUrl?: string | null;
-  license?: string;
-  knowledgebase?: boolean;
-  domains?: string[];
-  phases?: string[];
-  platforms?: string[];
-  skillLevel?: string;
-  description?: string;
-  tags?: string[];
-  related_concepts?: string[];
-}
-
-export { 
-  createToolSlug, 
-  findToolByIdentifier, 
-  isToolHosted 
-} from './clientUtils.js';
\ No newline at end of file
diff --git a/src/utils/toolSelector.ts b/src/utils/toolSelector.ts
new file mode 100644
index 0000000..1d94c6f
--- /dev/null
+++ b/src/utils/toolSelector.ts
@@ -0,0 +1,346 @@
+// src/utils/toolSelector.ts
+import { aiService } from './aiService.js';
+import { embeddingsService, type SimilarityResult } from './embeddings.js';
+import { confidenceScoring } from './confidenceScoring.js';
+import { JSONParser } from './jsonUtils.js';
+import { getPrompt } from '../config/prompts.js';
+import 'dotenv/config';
+
+export interface ToolSelectionConfig {
+  maxSelectedItems: number;
+  embeddingCandidates: number;
+  similarityThreshold: number;
+  embeddingSelectionLimit: number;
+  embeddingConceptsLimit: number;
+  noEmbeddingsToolLimit: number;
+  noEmbeddingsConceptLimit: number;
+  embeddingsMinTools: number;
+  embeddingsMaxReductionRatio: number;
+  methodSelectionRatio: number;
+  softwareSelectionRatio: number;
+}
+
+export interface SelectionContext {
+  userQuery: string;
+  mode: string;
+  embeddingsSimilarities: Map<string, number>;
+  seenToolNames: Set<string>;
+  selectedTools?: Array<{
+    tool: any;
+    phase: string;
+    priority: string;
+    justification?: string;
+    taskRelevance?: number;
+    limitations?: string[];
+  }>;
+}
+
+export interface ToolSelectionResult {
+  selectedTools: any[];
+  selectedConcepts: any[];
+  confidence: number;
+}
+
+class ToolSelector {
+  private config: ToolSelectionConfig;
+
+  constructor() {
+    this.config = {
+      maxSelectedItems: this.getEnvInt('AI_MAX_SELECTED_ITEMS', 25),
+      embeddingCandidates: this.getEnvInt('AI_EMBEDDING_CANDIDATES', 50),
+      similarityThreshold: this.getEnvFloat('AI_SIMILARITY_THRESHOLD', 0.3),
+      embeddingSelectionLimit: this.getEnvInt('AI_EMBEDDING_SELECTION_LIMIT', 30),
+      embeddingConceptsLimit: this.getEnvInt('AI_EMBEDDING_CONCEPTS_LIMIT', 15),
+      noEmbeddingsToolLimit: this.getEnvInt('AI_NO_EMBEDDINGS_TOOL_LIMIT', 25),
+      noEmbeddingsConceptLimit: this.getEnvInt('AI_NO_EMBEDDINGS_CONCEPT_LIMIT', 10),
+      embeddingsMinTools: this.getEnvInt('AI_EMBEDDINGS_MIN_TOOLS', 8),
+      embeddingsMaxReductionRatio: this.getEnvFloat('AI_EMBEDDINGS_MAX_REDUCTION_RATIO', 0.75),
+      methodSelectionRatio: this.getEnvFloat('AI_METHOD_SELECTION_RATIO', 0.4),
+      softwareSelectionRatio: this.getEnvFloat('AI_SOFTWARE_SELECTION_RATIO', 0.5)
+    };
+
+    console.log('[TOOL-SELECTOR] Initialized with config:', this.config);
+  }
+
+  private getEnvInt(key: string, defaultValue: number): number {
+    const value = process.env[key];
+    return value ? parseInt(value, 10) : defaultValue;
+  }
+
+  private getEnvFloat(key: string, defaultValue: number): number {
+    const value = process.env[key];
+    return value ? parseFloat(value) : defaultValue;
+  }
+
+  async getIntelligentCandidates(
+    userQuery: string,
+    toolsData: any,
+    mode: string,
+    context: SelectionContext
+  ): Promise<{
+    tools: any[];
+    concepts: any[];
+    domains: any[];
+    phases: any[];
+    'domain-agnostic-software': any[];
+  }> {
+    console.log('[TOOL-SELECTOR] Getting intelligent candidates for query');
+    
+    let candidateTools: any[] = [];
+    let candidateConcepts: any[] = [];
+    
+    context.embeddingsSimilarities.clear();
+    
+    try {
+      await embeddingsService.waitForInitialization();
+    } catch (error) {
+      console.error('[TOOL-SELECTOR] Embeddings initialization failed:', error);
+    }
+    
+    console.log('[TOOL-SELECTOR] Using embeddings for candidate selection');
+    
+    const embeddingsSearchStart = Date.now();
+    
+    const similarItems = await embeddingsService.findSimilar(
+      userQuery,
+      this.config.embeddingCandidates,
+      this.config.similarityThreshold
+    ) as SimilarityResult[];
+    
+    console.log('[TOOL-SELECTOR] Embeddings found', similarItems.length, 'similar items');
+    
+    const { auditService } = await import('./auditService.js');
+    const { getDataVersion } = await import('./dataService.js');
+    
+    const toolsDataHash = getDataVersion() || 'unknown';
+    
+    auditService.addEmbeddingsSearch(
+      userQuery,
+      similarItems,
+      this.config.similarityThreshold,
+      embeddingsSearchStart,
+      {
+        toolsDataHash: toolsDataHash,
+        selectionPhase: 'initial-candidate-selection',
+        candidateLimit: this.config.embeddingCandidates,
+        mode: mode,
+        reasoning: `Initiale semantische Suche für ${mode}-Modus - Reduzierung der ${toolsData.tools.length} verfügbaren Tools auf ${similarItems.length} relevante Kandidaten`
+      }
+    );
+    
+    similarItems.forEach(item => {
+      context.embeddingsSimilarities.set(item.name, item.similarity);
+    });
+    
+    const toolsMap = new Map(toolsData.tools.map((tool: any) => [tool.name, tool]));
+    const conceptsMap = new Map(toolsData.concepts.map((concept: any) => [concept.name, concept]));
+    
+    const similarTools = similarItems
+      .filter((item: any) => item.type === 'tool')
+      .map((item: any) => toolsMap.get(item.name))
+      .filter((tool: any): tool is NonNullable<any> => tool !== undefined && tool !== null);
+    
+    const similarConcepts = similarItems
+      .filter((item: any) => item.type === 'concept')
+      .map((item: any) => conceptsMap.get(item.name))
+      .filter((concept: any): concept is NonNullable<any> => concept !== undefined && concept !== null);
+    
+    const totalAvailableTools = toolsData.tools.length;
+    const reductionRatio = similarTools.length / totalAvailableTools;
+    
+    if (similarTools.length >= this.config.embeddingsMinTools && reductionRatio <= this.config.embeddingsMaxReductionRatio) {
+      candidateTools = similarTools;
+      candidateConcepts = similarConcepts;
+      
+      console.log('[TOOL-SELECTOR] Using embeddings filtering:', totalAvailableTools, '→', similarTools.length, 'tools');
+    } else {
+      console.log('[TOOL-SELECTOR] Embeddings filtering insufficient, using full dataset');
+      candidateTools = toolsData.tools;
+      candidateConcepts = toolsData.concepts;
+    }
+
+    const selection = await this.performAISelection(
+      userQuery,
+      candidateTools,
+      candidateConcepts,
+      mode,
+      context
+    );
+    
+    return {
+      tools: selection.selectedTools,
+      concepts: selection.selectedConcepts,
+      domains: toolsData.domains,
+      phases: toolsData.phases,
+      'domain-agnostic-software': toolsData['domain-agnostic-software']
+    };
+  }
+
+  private async performAISelection(
+    userQuery: string,
+    candidateTools: any[],
+    candidateConcepts: any[],
+    mode: string,
+    context: SelectionContext
+  ): Promise<ToolSelectionResult> {
+    console.log('[TOOL-SELECTOR] Performing AI selection');
+
+    const candidateMethods = candidateTools.filter((tool: any) => tool && tool.type === 'method');
+    const candidateSoftware = candidateTools.filter((tool: any) => tool && tool.type === 'software');
+
+    console.log('[TOOL-SELECTOR] Candidates:', candidateMethods.length, 'methods,', candidateSoftware.length, 'software,', candidateConcepts.length, 'concepts');
+
+    const methodsWithFullData = candidateMethods.map(this.createToolData);
+    const softwareWithFullData = candidateSoftware.map(this.createToolData);
+    const conceptsWithFullData = candidateConcepts.map(this.createConceptData);
+
+    const maxTools = Math.min(this.config.embeddingSelectionLimit, this.config.noEmbeddingsToolLimit);
+    const maxConcepts = Math.min(this.config.embeddingConceptsLimit, this.config.noEmbeddingsConceptLimit);
+    const methodLimit = Math.ceil(maxTools * this.config.methodSelectionRatio);
+    const softwareLimit = Math.floor(maxTools * this.config.softwareSelectionRatio);
+
+    const toolsToSend: any[] = [
+      ...methodsWithFullData.slice(0, methodLimit),
+      ...softwareWithFullData.slice(0, softwareLimit),
+    ];
+
+    const remainingCapacity = maxTools - toolsToSend.length;
+    if (remainingCapacity > 0) {
+      const extraMethods = methodsWithFullData.slice(methodLimit, methodLimit + remainingCapacity);
+      const extraSoftware = softwareWithFullData.slice(softwareLimit, softwareLimit + (remainingCapacity - extraMethods.length));
+      toolsToSend.push(...extraMethods, ...extraSoftware);
+    }
+
+    const conceptsToSend = conceptsWithFullData.slice(0, maxConcepts);
+
+    const basePrompt = getPrompt('toolSelection', mode, userQuery, this.config.maxSelectedItems);
+    const prompt = getPrompt('toolSelectionWithData', basePrompt, toolsToSend, conceptsToSend);
+
+    console.log('[TOOL-SELECTOR] Sending to AI:',
+      toolsToSend.filter((t: any) => t.type === 'method').length, 'methods,',
+      toolsToSend.filter((t: any) => t.type === 'software').length, 'software,',
+      conceptsToSend.length, 'concepts'
+    );
+
+    try {
+      const response = await aiService.callAI(prompt);
+      const result = JSONParser.safeParseJSON(response.content, null);
+
+      if (!result || !Array.isArray(result.selectedTools) || !Array.isArray(result.selectedConcepts)) {
+        console.error('[TOOL-SELECTOR] AI selection returned invalid structure');
+        throw new Error('AI selection failed to return valid tool and concept selection');
+      }
+
+      const totalSelected = result.selectedTools.length + result.selectedConcepts.length;
+      if (totalSelected === 0) {
+        throw new Error('AI selection returned empty selection');
+      }
+
+      const toolsMap = new Map(candidateTools.map((tool: any) => [tool.name, tool]));
+      const conceptsMap = new Map(candidateConcepts.map((concept: any) => [concept.name, concept]));
+
+      const selectedTools = result.selectedTools
+        .map((name: string) => toolsMap.get(name))
+        .filter((tool: any): tool is NonNullable<any> => tool !== undefined && tool !== null);
+
+      const selectedConcepts = result.selectedConcepts
+        .map((name: string) => conceptsMap.get(name))
+        .filter((concept: any): concept is NonNullable<any> => concept !== undefined && concept !== null);
+
+      const selectedMethods = selectedTools.filter((t: any) => t && t.type === 'method');
+      const selectedSoftware = selectedTools.filter((t: any) => t && t.type === 'software');
+
+      console.log('[TOOL-SELECTOR] AI selected:', selectedMethods.length, 'methods,', selectedSoftware.length, 'software,', selectedConcepts.length, 'concepts');
+
+      const confidence = confidenceScoring.calculateSelectionConfidence(
+        result,
+        candidateTools.length + candidateConcepts.length
+      );
+
+      return { selectedTools, selectedConcepts, confidence };
+    } catch (error) {
+      console.error('[TOOL-SELECTOR] AI selection failed:', error);
+      throw error;
+    }
+  }
+
+  async selectToolsForPhase(
+    userQuery: string,
+    phase: any,
+    availableTools: any[],
+    context: SelectionContext
+  ): Promise<Array<{
+    toolName: string;
+    taskRelevance: number;
+    justification: string;
+    limitations: string[];
+  }>> {
+    console.log('[TOOL-SELECTOR] Selecting tools for phase:', phase.id);
+    
+    if (availableTools.length === 0) {
+      console.log('[TOOL-SELECTOR] No tools available for phase:', phase.id);
+      return [];
+    }
+
+    const prompt = getPrompt('phaseToolSelection', userQuery, phase, availableTools);
+    
+    try {
+      const response = await aiService.callMicroTaskAI(prompt);
+      const selections = JSONParser.safeParseJSON(response.content, []);
+      
+      if (Array.isArray(selections)) {
+        const validSelections = selections.filter((sel: any) => {
+          const matchingTool = availableTools.find((tool: any) => tool && tool.name === sel.toolName);
+          if (!matchingTool) {
+            console.warn('[TOOL-SELECTOR] Invalid tool selection for phase:', phase.id, sel.toolName);
+          }
+          return !!matchingTool;
+        });
+        
+        console.log('[TOOL-SELECTOR] Valid selections for phase:', phase.id, validSelections.length);
+        return validSelections;
+      }
+      
+      return [];
+      
+    } catch (error) {
+      console.error('[TOOL-SELECTOR] Phase tool selection failed:', error);
+      return [];
+    }
+  }
+
+  private createToolData = (tool: any) => ({
+    name: tool.name,
+    type: tool.type,
+    description: tool.description,
+    domains: tool.domains,
+    phases: tool.phases,
+    platforms: tool.platforms || [],
+    tags: tool.tags || [],
+    skillLevel: tool.skillLevel,
+    license: tool.license,
+    accessType: tool.accessType,
+    projectUrl: tool.projectUrl,
+    knowledgebase: tool.knowledgebase,
+    related_concepts: tool.related_concepts || [],
+    related_software: tool.related_software || []
+  });
+
+  private createConceptData = (concept: any) => ({
+    name: concept.name,
+    type: 'concept',
+    description: concept.description,
+    domains: concept.domains,
+    phases: concept.phases,
+    tags: concept.tags || [],
+    skillLevel: concept.skillLevel,
+    related_concepts: concept.related_concepts || [],
+    related_software: concept.related_software || []
+  });
+
+  getConfig(): ToolSelectionConfig {
+    return { ...this.config };
+  }
+}
+
+export const toolSelector = new ToolSelector();
\ No newline at end of file