blun-king-cli 4.1.1 → 5.0.0

package/api.js

@@ -0,0 +1,965 @@
+const express = require("express");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const runtime = require("./runtime");
+const tools = require("./tools");
+const memory = require("./chat-memory");
+const palace = require("./palace-memory");
+const fileHelper = require("./file-helper");
+const browser = require("./browser-controller");
+const taskExecutor = require("./task-executor");
+const userProfile = require("./user-profile");
+const jobs = require("./job-manager");
+const { evaluateNoisyIntentCorpus } = require("./noisy-evals");
+const { buildConversationMessages } = require("./message-builder");
+const { inspectReference, extractUrls, autoReferenceChain, buildReferencePromptBlock, shouldAutoReference, screenshotUrl } = require("./reference-inspector");
+const { findFacts, storeFact } = require("./local-data");
+const { buildWebsiteProject, validateWebsiteOutput } = require("./website-builder");
+
+const PORT = Number(process.env.BLUN_PORT || 3200);
+const MODEL = process.env.BLUN_MODEL || "blun-king-v500";
+const FAST_MODEL = process.env.BLUN_FAST_MODEL || MODEL;
+const OLLAMA_URL = process.env.OLLAMA_URL || "http://127.0.0.1:11434/api/chat";
+const TOKENS = String(process.env.BLUN_API_TOKENS || process.env.BLUN_API_TOKEN || "")
+  .split(",")
+  .map((value) => value.trim())
+  .filter(Boolean);
+
+function isLoopback(ip = "") {
+  return ["127.0.0.1", "::1", "::ffff:127.0.0.1"].includes(ip);
+}
+
+function auth(req, res, next) {
+  if (req.path === "/health") return next();
+
+  if (TOKENS.length === 0) {
+    if (isLoopback(req.ip) || isLoopback(req.socket?.remoteAddress)) return next();
+    return res.status(503).json({ error: "Remote access requires BLUN_API_TOKEN or BLUN_API_TOKENS." });
+  }
+
+  const authHeader = req.headers.authorization || "";
+  const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : null;
+  if (!token || !TOKENS.includes(token)) return res.status(401).json({ error: "Unauthorized" });
+  next();
+}
+
+function requireLoopback(req, res, next) {
+  if (isLoopback(req.ip) || isLoopback(req.socket?.remoteAddress)) return next();
+  return res.status(403).json({ error: "Browser control is local-only." });
+}
+
+async function ollamaChat(messages, model = MODEL) {
+  const resp = await fetch(OLLAMA_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ model, messages, stream: false })
+  });
+  if (!resp.ok) throw new Error(`Ollama error ${resp.status}`);
+  const data = await resp.json();
+  return String(data.message?.content || "").replace(/<think>[\s\S]*?<\/think>/gi, "").trim();
+}
+
+async function generateRecoveredAnswer({ task, session, message, identityId, sessionId, previousAnswer, reasons, model }) {
+  const prompt = composePromptWithPalace(task, session, message, identityId, sessionId);
+  const retryPrompt = runtime.buildRetryPrompt(reasons);
+  const messages = buildConversationMessages({
+    prompt,
+    session,
+    message
+  });
+  messages.push({ role: "assistant", content: previousAnswer });
+  messages.push({ role: "user", content: retryPrompt });
+  return ollamaChat(messages, model);
+}
+
+async function generateVettedAnswer({ task, session, message, identityId, sessionId, model, history, extraPrompt }) {
+  const promptBase = composePromptWithPalace(task, session, message, identityId, sessionId);
+  const prompt = [promptBase, extraPrompt].filter(Boolean).join("\n\n");
+  const messages = buildConversationMessages({
+    prompt,
+    session,
+    history,
+    message
+  });
+
+  let answer = await ollamaChat(messages, model);
+  let quality = runtime.selfCheckResponse(answer, task, message);
+  let retries = 0;
+
+  while (task.type !== "chat" && quality.blocked && retries < 2) {
+    answer = await generateRecoveredAnswer({
+      task,
+      session,
+      message,
+      identityId,
+      sessionId,
+      previousAnswer: answer,
+      reasons: quality.reasons.length ? quality.reasons : ["action_mismatch"],
+      model
+    });
+    quality = runtime.selfCheckResponse(answer, task, message);
+    retries += 1;
+  }
+
+  if (task.type !== "chat" && quality.blocked) {
+    answer = runtime.buildBlockedActionReply(task, quality.reasons);
+    quality = runtime.selfCheckResponse(answer, { ...task, type: "chat" }, message);
+  }
+
+  return { prompt, answer, quality, retried: retries > 0, retries };
+}
+
+async function ollamaStream(messages, onToken, model = MODEL) {
+  const resp = await fetch(OLLAMA_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ model, messages, stream: true })
+  });
+  if (!resp.ok) throw new Error(`Ollama error ${resp.status}`);
+
+  const decoder = new TextDecoder();
+  const reader = resp.body.getReader();
+  let buffer = "";
+  let full = "";
+
+  while (true) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    buffer += decoder.decode(chunk.value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const payload = JSON.parse(trimmed);
+        const token = String(payload.message?.content || "");
+        if (!token) continue;
+        full += token;
+        const visible = token.replace(/<think>[\s\S]*?<\/think>/gi, "");
+        if (visible && onToken) onToken(visible);
+      } catch {
+        // Ignore malformed stream lines.
+      }
+    }
+  }
+
+  return full.replace(/<think>[\s\S]*?<\/think>/gi, "").trim();
+}
+
+function referenceQueryCandidates(message) {
+  const stripped = String(message || "")
+    .replace(/https?:\/\/[^\s]+/gi, " ")
+    .replace(/[^\p{L}\p{N}.\s-]/gu, " ")
+    .split(/\s+/)
+    .filter(Boolean);
+
+  const stop = new Set([
+    "bitte", "baue", "bau", "erstelle", "mach", "mache", "webseite", "website", "seite", "landingpage",
+    "landing", "referenz", "vorlage", "wie", "bei", "orientier", "orientiere", "angelehnt", "inspiriert",
+    "von", "mir", "eine", "einen", "ein", "fuer", "für", "und", "oder", "mit", "aus"
+  ]);
+
+  return stripped
+    .filter((part) => !stop.has(part.toLowerCase()))
+    .slice(0, 5)
+    .join(" ");
+}
+
+async function searchReferenceUrls(query) {
+  const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+  const resp = await fetch(searchUrl, {
+    headers: { "User-Agent": "BLUN-King/5.0 (+reference-search)" }
+  });
+  if (!resp.ok) return [];
+
+  const html = await resp.text();
+  const found = [...html.matchAll(/result__url[^>]*>\s*([^<\s]+)\s*</gi)]
+    .map((match) => match[1])
+    .map((value) => {
+      if (/^https?:\/\//i.test(value)) return value;
+      if (/^[a-z0-9.-]+\.[a-z]{2,}/i.test(value)) return `https://${value}`;
+      return null;
+    })
+    .filter(Boolean);
+
+  return [...new Set(found)].slice(0, 2);
+}
+
+async function resolveReferenceTargets(input, limit = 2) {
+  const direct = extractUrls(input).slice(0, limit);
+  if (direct.length > 0) return direct;
+
+  if (!/\b(referenz|vorlage|wie|bei|inspiriert|angelehnt)\b/i.test(String(input || ""))) {
+    return [];
+  }
+
+  const query = referenceQueryCandidates(input);
+  if (!query) return [];
+
+  try {
+    return await searchReferenceUrls(`${query} website`);
+  } catch {
+    return [];
+  }
+}
+
+async function collectReferenceContext(input) {
+  const urls = await resolveReferenceTargets(input, 2);
+  const references = [];
+
+  for (const url of urls) {
+    try {
+      const result = await inspectReference(url, { screenshot: true });
+      references.push({
+        url,
+        title: result.summary.title,
+        h1s: result.summary.h1s,
+        links: result.summary.links,
+        images: result.summary.images,
+        responsive: result.summary.responsive,
+        text: result.summary.text,
+        html: result.html,
+        screenshotPath: result.screenshotPath,
+        storage: result.storage,
+        error: result.error
+      });
+    } catch (error) {
+      references.push({ url, error: error.message });
+    }
+  }
+
+  return references;
+}
+
+async function collectAutoReferencePrompt(input, task) {
+  if (!shouldAutoReference(input, task)) return { references: [], promptBlock: "" };
+  const references = await autoReferenceChain(input, { screenshot: true, limit: 2 });
+  return {
+    references,
+    promptBlock: buildReferencePromptBlock(references)
+  };
+}
+
+async function buildWebsiteArtifact(goal, workdir) {
+  const references = await collectReferenceContext(goal);
+  const built = buildWebsiteProject(goal, references);
+  const validation = validateWebsiteOutput(built.files, built);
+
+  if (!validation.ok) {
+    throw new Error(`Website build blocked: ${validation.issues.join(", ")}`);
+  }
+
+  const create = await tools.executeTool("create_project", { name: built.projectName, files: built.files }, workdir);
+  const artifact = fileHelper.writeArtifact(`${built.projectName}.json`, JSON.stringify(built.files, null, 2), "utf8");
+
+  return {
+    brand: built.brand,
+    industry: built.industry,
+    validation,
+    projectRoot: create.projectRoot,
+    verified: create.verified,
+    references,
+    files: create.fileObjects.map((file) => ({
+      path: file.path,
+      content: file.content
+    })),
+    artifact: {
+      artifact_id: artifact.artifact_id,
+      filename: artifact.filename,
+      download: `/download/${artifact.artifact_id}`
+    }
+  };
+}
+
+function getIdentityId(req) {
+  return req.body.identity && req.body.identity !== "auto" ? String(req.body.identity) : undefined;
+}
+
+function composePromptWithPalace(task, session, message, identityId, sessionId) {
+  const palaceContext = palace.palaceWakeUp(sessionId);
+  const learnedContext = userProfile.buildPromptContext(sessionId, message);
+  const basePrompt = runtime.composeSystemPrompt(task, session, message, identityId);
+  const parts = [basePrompt];
+
+  if (learnedContext) {
+    parts.push(`[Gelerntes Nutzerwissen]\n${learnedContext.slice(0, 1500)}`);
+  }
+
+  if (palaceContext) {
+    parts.push(`[Langzeitgedaechtnis]\n${palaceContext.slice(0, 2000)}`);
+  }
+
+  return parts.join("\n\n");
+}
+
+function updateSession(sessionId, task, identityId, message, answer, workdir) {
+  memory.appendHistory(sessionId, "user", message);
+  memory.appendHistory(sessionId, "assistant", answer);
+  palace.palaceLogChat(sessionId, "user", message);
+  palace.palaceLogChat(sessionId, "assistant", answer);
+
+  if ((task.type === "website_builder" || task.type === "file_generation" || task.type === "browser_capture" || task.type === "installation") && !task.followup) {
+    memory.setActiveTask(sessionId, {
+      type: task.type,
+      role: task.role,
+      output: task.output,
+      workdir,
+      lastUserIntent: message,
+      identityId
+    });
+  } else if (!task.followup && task.type === "chat") {
+    memory.clearActiveTask(sessionId);
+  }
+}
+
+async function handleChatRequest(body = {}) {
+  const message = String(body.message || "").trim();
+  const sessionId = String(body.session_id || "default");
+  const workdir = path.resolve(body.workdir || process.cwd());
+  const preferredIdentity = body.identity && body.identity !== "auto" ? String(body.identity) : undefined;
+
+  const session = memory.loadSession(sessionId);
+  const routing = runtime.classifyTaskDetailed(message, session);
+  const task = routing.task;
+  const identity = runtime.resolveIdentity(message, task, session, preferredIdentity);
+  const autoReference = await collectAutoReferencePrompt(message, task);
+
+  if (taskExecutor.isDirectActionTask(task)) {
+    const direct = await taskExecutor.executeDirectTask({ task, message, session, workdir });
+    updateSession(sessionId, task, identity.id, message, direct.answer, workdir);
+    return {
+      answer: direct.answer,
+      task_type: task.type,
+      role: task.role,
+      identity: identity.id,
+      routing,
+      status: direct.status,
+      steps: direct.steps || [],
+      files: direct.files || [],
+      references: direct.references || [],
+      artifact: direct.artifact || null,
+      install: direct.install,
+      quality: { score: 100, flags: [], retried: false },
+      tokens: { input: 0, output: 0, total: 0 }
+    };
+  }
+
+  const model = task.type === "chat" && message.length < 50 ? FAST_MODEL : MODEL;
+  const generated = await generateVettedAnswer({
+    task,
+    session,
+    message,
+    identityId: identity.id,
+    sessionId,
+    model,
+    history: body.history,
+    extraPrompt: autoReference.promptBlock
+  });
+  const answer = generated.answer;
+  const quality = generated.quality;
+  const retried = generated.retried;
+
+  updateSession(sessionId, task, identity.id, message, answer, workdir);
+
+  const inputTokens = runtime.estimateTokens(generated.prompt + "\n" + message);
+  const outputTokens = runtime.estimateTokens(answer);
+
+  return {
+    answer,
+    task_type: task.type,
+    role: task.role,
+    identity: identity.id,
+    routing,
+    references: autoReference.references,
+    quality: { score: quality.score, flags: quality.reasons, retried, blocked: quality.blocked || false, critical: quality.critical || false },
+    tokens: { input: inputTokens, output: outputTokens, total: inputTokens + outputTokens }
+  };
+}
+
+async function handleAgentRequest(body = {}) {
+  const goal = String(body.goal || body.message || "").trim();
+  const sessionId = String(body.session_id || "default");
+  const workdir = path.resolve(body.workdir || process.cwd());
+  const preferredIdentity = body.identity && body.identity !== "auto" ? String(body.identity) : undefined;
+  const session = memory.loadSession(sessionId);
+  const routing = runtime.classifyTaskDetailed(goal, session);
+  const task = routing.task;
+  const identity = runtime.resolveIdentity(goal, task, session, preferredIdentity);
+  const autoReference = await collectAutoReferencePrompt(goal, task);
+
+  let status = "completed";
+  let steps = [];
+  let files = [];
+  let artifact = null;
+  let answer = "";
+  let references = autoReference.references;
+  let validation = null;
+
+  if (taskExecutor.isDirectActionTask(task)) {
+    const direct = await taskExecutor.executeDirectTask({ task, message: goal, session, workdir });
+    status = direct.status;
+    steps = direct.steps || [];
+    answer = direct.answer;
+    files = direct.files || [];
+    references = direct.references || [];
+    artifact = direct.artifact || null;
+  } else if (task.type === "website_builder") {
+    steps.push({ step: 1, action: "intent_detected", detail: "website_builder" });
+    steps.push({ step: 2, action: "identity_selected", detail: identity.id });
+    const built = await buildWebsiteArtifact(goal, workdir);
+    files = built.files;
+    artifact = built.artifact;
+    references = built.references;
+    validation = built.validation;
+    steps.push({ step: 3, action: "business_type_lock", detail: built.industry });
+    steps.push({ step: 4, action: "reference_analysis", detail: `${references.length} reference(s)` });
+    steps.push({ step: 5, action: "validity_gate", detail: validation.issues.length ? validation.issues.join(", ") : "passed" });
+    steps.push({ step: 6, action: "writing_files", files: files.map((file) => file.path) });
+    answer = `Landingpage gebaut. Business-Type-Lock: ${built.industry}. Referenzlogik und Validity-Gate wurden geprueft.`;
+    status = built.verified ? "completed" : "partial";
+  } else if (task.type === "file_generation") {
+    const filename = body.filename || "artifact.txt";
+    const write = await tools.executeTool("write_file", { path: filename, content: goal }, workdir);
+    files = [{ path: path.relative(workdir, write.path), content: goal }];
+    artifact = fileHelper.writeArtifact(filename, goal);
+    steps.push({ step: 1, action: "writing_file", files: [files[0].path] });
+    status = write.verified ? "completed" : "partial";
+    answer = "Datei erstellt.";
+  } else {
+    const generated = await generateVettedAnswer({
+      task,
+      session,
+      message: goal,
+      identityId: identity.id,
+      sessionId,
+      model: MODEL,
+      extraPrompt: autoReference.promptBlock
+    });
+    answer = generated.answer;
+    steps.push({ step: 1, action: "intent_detected", detail: task.type });
+    steps.push({ step: 2, action: "identity_selected", detail: identity.id });
+    steps.push({ step: 3, action: "response_generated" });
+    if (generated.retried) {
+      steps.push({ step: 4, action: "self_check_retry", detail: `${generated.retries} retry` });
+    }
+  }
+
+  updateSession(sessionId, task, identity.id, goal, answer, workdir);
+
+  return {
+    status,
+    task_type: task.type,
+    role: task.role,
+    identity: identity.id,
+    routing,
+    steps,
+    answer,
+    workdir,
+    validation,
+    references,
+    files,
+    artifact,
+    verified: status === "completed"
+  };
+}
+
+function runBackgroundJob(jobId, endpoint, handler, body) {
+  queueMicrotask(async () => {
+    jobs.updateJob(jobId, { status: "running", startedAt: Date.now(), error: null });
+    jobs.appendJobLog(jobId, "started", {
+      endpoint,
+      hasResumeContext: Boolean(body?.resume_context),
+      workdir: body?.workdir || process.cwd()
+    });
+    try {
+      const result = await handler(body);
+      jobs.appendJobLog(jobId, "completed", {
+        task_type: result.task_type,
+        status: result.status || "completed",
+        answer: String(result.answer || "").slice(0, 300),
+        fileCount: Array.isArray(result.files) ? result.files.length : 0,
+        referenceCount: Array.isArray(result.references) ? result.references.length : 0,
+        artifact: result.artifact?.filename || null
+      });
+      jobs.updateJob(jobId, { status: "completed", finishedAt: Date.now(), result });
+    } catch (error) {
+      jobs.appendJobLog(jobId, "failed", { error: error.message });
+      jobs.updateJob(jobId, { status: "failed", finishedAt: Date.now(), error: error.message, result: null });
+    }
+  });
+}
+
+function createApp() {
+  const app = express();
+  app.use(express.json({ limit: "10mb" }));
+  app.use(auth);
+
+  app.get("/identities", (req, res) => {
+    res.json({ identities: runtime.listIdentities() });
+  });
+
+  app.get("/memory/facts", (req, res) => {
+    res.json({ facts: findFacts(String(req.query.q || "")) });
+  });
+
+  app.post("/memory/facts", (req, res) => {
+    const record = storeFact({
+      scope: String(req.body.scope || "global"),
+      key: String(req.body.key || ""),
+      value: req.body.value,
+      tags: Array.isArray(req.body.tags) ? req.body.tags : []
+    });
+    res.json({ stored: true, record });
+  });
+
+  app.get("/memory/palace", (req, res) => {
+    const sessionId = String(req.query.session_id || "default");
+    res.json({
+      session_id: sessionId,
+      stats: palace.palaceStats(sessionId),
+      wake_up: palace.palaceWakeUp(sessionId)
+    });
+  });
+
+  app.post("/memory/palace/search", (req, res) => {
+    const sessionId = String(req.body.session_id || "default");
+    res.json({
+      session_id: sessionId,
+      result: palace.palaceSearch(String(req.body.query || ""), Number(req.body.limit || 5), sessionId)
+    });
+  });
+
+  app.post("/reference/inspect", async (req, res) => {
+    try {
+      const url = String(req.body.url || "").trim();
+      if (!url) return res.status(400).json({ error: "url is required" });
+      res.json(await inspectReference(url, { screenshot: req.body.screenshot !== false }));
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.post("/reference/screenshot", async (req, res) => {
+    try {
+      const url = String(req.body.url || "").trim();
+      if (!url) return res.status(400).json({ error: "url is required" });
+      res.json(await screenshotUrl(url, { timeout: req.body.timeout }));
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.get("/browser/status", requireLoopback, async (req, res) => {
+    try {
+      res.json(await browser.snapshot());
+    } catch (error) {
+      res.json({ url: null, title: "", text: "", error: error.message });
+    }
+  });
+
+  app.post("/browser/open", requireLoopback, async (req, res) => {
+    try {
+      res.json(await browser.open(String(req.body.url || "")));
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.post("/browser/click", requireLoopback, async (req, res) => {
+    try {
+      res.json(await browser.click(String(req.body.selector || "")));
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.post("/browser/type", requireLoopback, async (req, res) => {
+    try {
+      res.json(await browser.type(String(req.body.selector || ""), String(req.body.text || "")));
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.post("/browser/press", requireLoopback, async (req, res) => {
+    try {
+      res.json(await browser.press(String(req.body.key || "Enter")));
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.post("/browser/screenshot", requireLoopback, async (req, res) => {
+    try {
+      const targetPath = path.resolve(String(req.body.path || path.join(process.cwd(), `browser-shot-${Date.now()}.png`)));
+      res.json(await browser.screenshot(targetPath));
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.post("/browser/close", requireLoopback, async (req, res) => {
+    try {
+      res.json(await browser.close());
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.post("/chat", async (req, res) => {
+    try {
+      if (req.body.background) {
+        const job = jobs.createJob({
+          endpoint: "/chat",
+          sessionId: String(req.body.session_id || "default"),
+          payload: req.body,
+          mode: "chat"
+        });
+        jobs.appendJobLog(job.id, "queued", { mode: "chat", message: String(req.body.message || "").slice(0, 200) });
+        runBackgroundJob(job.id, "/chat", handleChatRequest, req.body);
+        return res.json({ status: "queued", job_id: job.id });
+      }
+
+      res.json(await handleChatRequest(req.body));
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.post("/chat/stream", async (req, res) => {
+    try {
+      const message = String(req.body.message || "").trim();
+      const sessionId = String(req.body.session_id || "default");
+      const preferredIdentity = getIdentityId(req);
+      const session = memory.loadSession(sessionId);
+      const routing = runtime.classifyTaskDetailed(message, session);
+      const task = routing.task;
+      const identity = runtime.resolveIdentity(message, task, session, preferredIdentity);
+
+      if (taskExecutor.isDirectActionTask(task)) {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        });
+
+        const sendEvent = (type, payload) => {
+          res.write(`event: ${type}\n`);
+          res.write(`data: ${JSON.stringify(payload)}\n\n`);
+        };
+
+        const direct = await taskExecutor.executeDirectTask({ task, message, session, workdir: process.cwd() });
+        updateSession(sessionId, task, identity.id, message, direct.answer, process.cwd());
+        sendEvent("meta", { task_type: task.type, role: task.role, identity: identity.id, routing });
+        sendEvent("done", {
+          answer: direct.answer,
+          install: direct.install,
+          files: direct.files || [],
+          references: direct.references || [],
+          artifact: direct.artifact || null,
+          quality: { score: 100, flags: [] }
+        });
+        res.end();
+        return;
+      }
+
+      const model = task.type === "chat" && message.length < 50 ? FAST_MODEL : MODEL;
+
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+
+      const sendEvent = (type, payload) => {
+        res.write(`event: ${type}\n`);
+        res.write(`data: ${JSON.stringify(payload)}\n\n`);
+      };
+
+      const prompt = composePromptWithPalace(task, session, message, identity.id, sessionId);
+      const messages = buildConversationMessages({
+        prompt,
+        session,
+        history: req.body.history,
+        message
+      });
+      sendEvent("meta", { task_type: task.type, role: task.role, identity: identity.id, routing });
+      let answer = await ollamaStream(messages, (token) => sendEvent("token", { text: token }), model);
+      let quality = runtime.selfCheckResponse(answer, task, message);
+      let retries = 0;
+
+      while (task.type !== "chat" && quality.blocked && retries < 2) {
+        answer = await generateRecoveredAnswer({
+          task,
+          session,
+          message,
+          identityId: identity.id,
+          sessionId,
+          previousAnswer: answer,
+          reasons: quality.reasons.length ? quality.reasons : ["action_mismatch"],
+          model
+        });
+        quality = runtime.selfCheckResponse(answer, task, message);
+        retries += 1;
+      }
+
+      if (task.type !== "chat" && quality.blocked) {
+        answer = runtime.buildBlockedActionReply(task, quality.reasons);
+        quality = runtime.selfCheckResponse(answer, { ...task, type: "chat" }, message);
+      }
+
+      updateSession(sessionId, task, identity.id, message, answer, process.cwd());
+      sendEvent("done", { answer, quality: { ...quality, retried: retries > 0 } });
+      res.end();
+    } catch (error) {
+      res.write(`event: error\ndata: ${JSON.stringify({ error: error.message })}\n\n`);
+      res.end();
+    }
+  });
+
+  app.post("/agent", async (req, res) => {
+    try {
+      if (req.body.background) {
+        const job = jobs.createJob({
+          endpoint: "/agent",
+          sessionId: String(req.body.session_id || "default"),
+          payload: req.body,
+          mode: "agent"
+        });
+        jobs.appendJobLog(job.id, "queued", { mode: "agent", goal: String(req.body.goal || req.body.message || "").slice(0, 200) });
+        runBackgroundJob(job.id, "/agent", handleAgentRequest, req.body);
+        return res.json({ status: "queued", job_id: job.id });
+      }
+
+      res.json(await handleAgentRequest(req.body));
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.post("/analyze", async (req, res) => {
+    try {
+      const type = req.body.type || "website";
+      let source = "";
+
+      if (req.body.html) source = String(req.body.html);
+      else if (req.body.url) source = await (await fetch(String(req.body.url))).text();
+      else return res.status(400).json({ error: "Provide html or url" });
+
+      const title = (source.match(/<title[^>]*>([\s\S]*?)<\/title>/i) || [, ""])[1].trim();
+      const h1s = [...source.matchAll(/<h1[^>]*>([\s\S]*?)<\/h1>/ig)]
+        .map((match) => match[1].replace(/<[^>]+>/g, "").trim())
+        .filter(Boolean);
+      const links = [...source.matchAll(/<a\b/ig)].length;
+      const images = [...source.matchAll(/<img\b/ig)].length;
+      const analysis = [
+        `Seitentyp: ${type}`,
+        h1s.length ? `H1-Fokus: ${h1s[0]}` : "H1-Fokus: unklar",
+        "Kurzbewertung: Fokus auf Ziel, Hierarchie, CTA und Conversion statt technischem Head-Audit."
+      ].join("\n");
+
+      res.json({
+        analysis,
+        meta: { title, h1s, links, images, responsive: /viewport/i.test(source), frameworks: [] }
+      });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.post("/classify", (req, res) => {
+    const routing = runtime.classifyTaskDetailed(String(req.body.message || ""), null);
+    const task = routing.task;
+    const identity = runtime.resolveIdentity(String(req.body.message || ""), task, null, getIdentityId(req));
+    res.json({
+      type: task.type,
+      role: task.role,
+      output: task.output,
+      reason: task.reason,
+      identity: identity.id,
+      confidence: routing.confidence,
+      scores: routing.scores
+    });
+  });
+
+  app.post("/learn", async (req, res) => {
+    try {
+      const content = req.body.url ? await (await fetch(String(req.body.url))).text() : String(req.body.content || "");
+      const title = String(req.body.title || "learn-input");
+      const category = String(req.body.category || "general");
+      const userId = String(req.body.user_id || req.body.session_id || "default");
+      const filePath = path.join(process.env.BLUN_HOME || path.join(os.homedir(), ".blun"), "knowledge", `${Date.now()}_${title.replace(/[^\w.-]/g, "_")}.txt`);
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(filePath, content, "utf8");
+      palace.palaceLearn(content.slice(0, 8000), category, userId);
+
+      const learned = userProfile.learnFromText(userId, content, { title, category });
+      if (title || category) {
+        storeFact({
+          scope: userId,
+          key: `learn:${category}:${title}`,
+          value: {
+            title,
+            category,
+            aliasesLearned: learned.aliasesLearned,
+            snippetsLearned: learned.snippetsLearned,
+            types: learned.types,
+            preview: learned.snippets.slice(0, 2)
+          },
+          tags: ["learn", category]
+        });
+      }
+
+      res.json({
+        stored: true,
+        category,
+        user_id: userId,
+        file: filePath,
+        content_length: content.length,
+        learned
+      });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.get("/eval/noisy-intents", (req, res) => {
+    res.json(evaluateNoisyIntentCorpus());
+  });
+
+  app.get("/jobs", (req, res) => {
+    res.json({
+      jobs: jobs.listJobs({
+        sessionId: req.query.session_id ? String(req.query.session_id) : undefined,
+        limit: Number(req.query.limit || 20)
+      }).map((job) => ({
+        ...job,
+        summary: jobs.summarizeJob(job)
+      }))
+    });
+  });
+
+  app.get("/jobs/:id", (req, res) => {
+    const job = jobs.getJob(String(req.params.id || ""));
+    if (!job) return res.status(404).json({ error: "Job not found" });
+    res.json({
+      ...job,
+      summary: jobs.summarizeJob(job)
+    });
+  });
+
+  app.get("/jobs/:id/logs", (req, res) => {
+    const job = jobs.getJob(String(req.params.id || ""));
+    if (!job) return res.status(404).json({ error: "Job not found" });
+    res.json({ logs: jobs.getJobLogs(job.id) });
+  });
+
+  app.post("/jobs/:id/resume", (req, res) => {
+    const cloned = jobs.cloneJobForResume(String(req.params.id || ""));
+    if (!cloned) return res.status(404).json({ error: "Job not found" });
+    const handler = cloned.endpoint === "/chat" ? handleChatRequest : handleAgentRequest;
+    jobs.appendJobLog(cloned.id, "resumed", { from: req.params.id });
+    runBackgroundJob(cloned.id, cloned.endpoint, handler, cloned.payload);
+    res.json({ status: "queued", job_id: cloned.id, resumed_from: req.params.id });
+  });
+
+  app.post("/generate-file", async (req, res) => {
+    try {
+      const prompt = String(req.body.prompt || "").trim();
+      const format = String(req.body.format || "txt").toLowerCase();
+      const filename = String(req.body.filename || `artifact.${format}`);
+      const workdir = path.resolve(req.body.workdir || process.cwd());
+
+      let content = prompt;
+      if (format === "html") {
+        content = buildWebsiteProject(prompt, []).files["index.html"];
+      }
+
+      const write = await tools.executeTool("write_file", { path: filename, content }, workdir);
+      const artifact = fileHelper.writeArtifact(filename, content);
+
+      res.json({
+        artifact_id: artifact.artifact_id,
+        filename,
+        format,
+        size: artifact.size,
+        download: `/download/${artifact.artifact_id}`,
+        content,
+        files: [{ path: path.relative(workdir, write.path), content }],
+        workdir,
+        verified: write.verified
+      });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.get("/download/:id", (req, res) => {
+    const artifact = fileHelper.findArtifact(req.params.id);
+    if (!artifact) return res.status(404).json({ error: "Artifact not found" });
+    res.download(artifact.full, artifact.filename);
+  });
+
+  app.get("/artifacts", (req, res) => {
+    res.json({ artifacts: fileHelper.listArtifacts() });
+  });
+
+  app.post("/score", (req, res) => {
+    const task = { type: req.body.task_type || "chat", role: "default", output: "text" };
+    const result = runtime.scoreResponse(String(req.body.answer || ""), task, String(req.body.userMessage || ""));
+    res.json({ score: result.score, reasons: result.reasons });
+  });
+
+  app.post("/tools", async (req, res) => {
+    try {
+      const result = await tools.executeTool(req.body.tool, req.body.params || {}, req.body.workdir || process.cwd());
+      res.json(result);
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.get("/runtime/status", (req, res) => {
+    res.json({
+      model: MODEL,
+      fast_model: FAST_MODEL,
+      ollama: OLLAMA_URL,
+      uptime: process.uptime(),
+      prompt_registry: runtime.REGISTRY,
+      identities: runtime.listIdentities().map(({ id, name }) => ({ id, name })),
+      token_mode: TOKENS.length ? "token" : "local-only",
+      endpoints: ["/chat", "/chat/stream", "/agent", "/analyze", "/classify", "/learn", "/jobs", "/jobs/:id", "/jobs/:id/logs", "/jobs/:id/resume", "/generate-file", "/download/:id", "/artifacts", "/score", "/tools", "/runtime/status", "/versions", "/identities", "/memory/facts", "/memory/palace", "/memory/palace/search", "/reference/inspect", "/reference/screenshot", "/browser/status", "/browser/open", "/browser/click", "/browser/type", "/browser/press", "/browser/screenshot", "/browser/close", "/eval/noisy-intents", "/health"]
+    });
+  });
+
+  app.get("/versions", (req, res) => {
+    res.json(runtime.REGISTRY);
+  });
+
+  app.get("/health", (req, res) => {
+    res.json({ status: "ok", model: MODEL, uptime: Math.round(process.uptime()) });
+  });
+
+  return app;
+}
+
+function startServer(port = PORT) {
+  const app = createApp();
+  const server = app.listen(port, "0.0.0.0", () => {
+    const authMode = TOKENS.length ? "token" : "local-only";
+    console.log(`BLUN King API listening on http://0.0.0.0:${port} (${authMode})`);
+  });
+  return { app, server };
+}
+
+if (require.main === module) {
+  startServer();
+}
+
+module.exports = {
+  createApp,
+  startServer
+};