vibe-roast 0.98.0

package/src/lib/agent-score.js

@@ -0,0 +1,187 @@
+/** Prompt-behaviour personality engine: four dichotomies, sixteen vibe types. */
+
+const DIMENSIONS = [
+  ["orchestration", "Agent orchestration", "Agent 编排", "Workflow delegation density", "工作流与委派密度"],
+  ["promptCraft", "Prompt craft", "提示词手艺", "Intent clarity vs pasted noise", "清晰意图 vs 粘贴噪音"],
+  ["build", "Build drive", "构建驱动力", "Implementation and packaging", "实现与打包倾向"],
+  ["debug", "Verification drive", "验证驱动力", "Debug, tests, and refactors", "调试、测试与重构"],
+  ["context", "Context appetite", "上下文胃口", "Long prompts and reference payloads", "长提示与引用负载"],
+  ["ship", "Shipping bias", "交付倾向", "Execution over deliberation", "执行相对思考的倾向"],
+].map(([key, label, labelZh, hint, hintZh]) => ({ key, label, labelZh, hint, hintZh, max: 100 }));
+
+const PERSONALITY_ROWS = [
+  ["MOVF", "Agent Engineer", "Agent 工程师", "Turns agents into a tested assembly line", "把 Agent 变成带质检的流水线", "#2bbf9b"],
+  ["MOVX", "Systems Wrangler", "系统牧场主", "Herds agents through a context thunderstorm", "在上下文雷暴里放牧 Agent", "#3aa6a0"],
+  ["MOSF", "YOLO Shipper", "YOLO 发车手", "Automates the merge button's intrusive thoughts", "把 merge 键的冲动想法自动化", "#ef5b45"],
+  ["MOSX", "Agent Commander", "Agent 总指挥", "Runs a war room where every tab has a rank", "开着每个标签都有军衔的作战室", "#e56b54"],
+  ["MPVF", "Debugger", "调试猎手", "Cross-examines one bug until it confesses", "审到一个 bug 主动招供", "#e65b89"],
+  ["MPVX", "Context Maxxer", "上下文极限党", "Brings the whole repo to a one-line bug", "为一行 bug 搬来整个仓库", "#35a9c5"],
+  ["MPSF", "Builder", "构建侠", "Converts short prompts into suspiciously fast demos", "把短提示变成快得可疑的 demo", "#25b985"],
+  ["MPSX", "Tab Hoarder", "标签囤积癖", "Needs forty-seven tabs to ship one button", "需要四十七个标签才能上线一个按钮", "#e58a39"],
+  ["AOVF", "Systems Architect", "系统架构师", "Makes the agent read the ADR before touching a key", "让 Agent 碰键盘前先读 ADR", "#557fd8"],
+  ["AOVX", "Context Cartographer", "上下文制图师", "Maps every dependency before crossing the repo", "穿越仓库前先画完每条依赖", "#6686c7"],
+  ["AOSF", "Strategy Shipper", "战略交付官", "Ships the roadmap while everyone debates the map", "别人争地图时已经把路线图上线", "#8a72d6"],
+  ["AOSX", "Agent Believer", "Agent 信徒", "Builds a cathedral out of tools and context", "用工具与上下文盖一座大教堂", "#9a70cf"],
+  ["APVF", "Architect", "架构师", "Reviews the rectangle before allowing it to run", "矩形通过评审后才允许它运行", "#5678c7"],
+  ["APVX", "Prompt Priest", "提示祭司", "Writes scripture long enough to need version control", "经文长到需要单独做版本控制", "#d4a334"],
+  ["APSF", "Diagram Sprinter", "框图冲刺手", "Draws three systems, then ships the smallest box", "画三套系统，再上线最小那个框", "#cf7850"],
+  ["APSX", "Infinite Planner", "无限规划师", "One more context file away from starting", "永远只差再读一个文件就开工", "#9c75b9"],
+];
+
+const PERSONALITIES = Object.fromEntries(PERSONALITY_ROWS.map(([code, title, titleZh, hook, hookZh, accent]) => {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  return [code, { id: code, code, title, titleZh, hook, hookZh, accent, folder: `${code.toLowerCase()}-${slug}`, name: slug }];
+}));
+
+const LEGACY_FIGURES = {
+  MOVF: "01-builder/builder", MOVX: "07-context-maxxer/context-maxxer", MOSF: "08-yolo-shipper/yolo-shipper", MOSX: "04-codex-believer/codex-believer",
+  MPVF: "02-debugger/debugger", MPVX: "07-context-maxxer/context-maxxer", MPSF: "01-builder/builder", MPSX: "06-tab-hoarder/tab-hoarder",
+  AOVF: "03-architect/architect", AOVX: "07-context-maxxer/context-maxxer", AOSF: "03-architect/architect", AOSX: "04-codex-believer/codex-believer",
+  APVF: "03-architect/architect", APVX: "05-prompt-priest/prompt-priest", APSF: "03-architect/architect", APSX: "05-prompt-priest/prompt-priest",
+};
+
+const AXIS_DEFS = [
+  { key: "maker_architect", left: ["M", "Maker", "造物派"], right: ["A", "Architect", "架构派"] },
+  { key: "orchestrator_promptsmith", left: ["O", "Orchestrator", "编排派"], right: ["P", "Promptsmith", "提示派"] },
+  { key: "verifier_shipper", left: ["V", "Verifier", "验证派"], right: ["S", "Shipper", "交付派"] },
+  { key: "focused_maxcontext", left: ["F", "Focused", "聚焦派"], right: ["X", "Max-context", "满上下文派"] },
+];
+
+function categoryCount(categories, name) {
+  const row = categories?.[name];
+  const value = typeof row === "number" ? row : Number(row?.count || 0);
+  return Number.isFinite(value) ? value : 0;
+}
+
+function ratioScore(numerator, denominator) {
+  return denominator > 0 ? Math.round(Math.min(1, Math.max(0, numerator / denominator)) * 1000) / 10 : 0;
+}
+
+function scoreFromCategories(categories = {}, _env = {}, promptAnalysis = {}) {
+  const c = (name) => categoryCount(categories, name);
+  const useful = ["implementation", "debugging", "planning", "research", "ui_design", "explanation", "testing", "refactor", "packaging", "workflow"].reduce((sum, key) => sum + c(key), 0);
+  if (useful <= 0) return Object.fromEntries(DIMENSIONS.map((dim) => [dim.key, 0]));
+  const usefulRatio = Number(promptAnalysis.useful_ratio ?? useful / Math.max(useful + c("reference"), 1));
+  const longRatio = Number(promptAnalysis.long_prompt_ratio || 0);
+  return {
+    orchestration: ratioScore(c("workflow") * 2, useful * 0.45),
+    promptCraft: Math.round(Math.min(1, usefulRatio * 0.8 + ((c("planning") + c("explanation")) / useful) * 0.5) * 1000) / 10,
+    build: ratioScore(c("implementation") + c("packaging") + c("ui_design") * 0.5, useful * 0.75),
+    debug: ratioScore(c("debugging") + c("testing") + c("refactor") * 0.6, useful * 0.55),
+    context: Math.round(Math.min(1, longRatio * 1.5 + (1 - usefulRatio) * 0.7) * 1000) / 10,
+    ship: ratioScore(c("implementation") + c("packaging"), c("implementation") + c("packaging") + c("planning") + c("research") + c("debugging") + c("testing")),
+  };
+}
+
+function splitAxis(def, leftEvidence, rightEvidence) {
+  const total = leftEvidence + rightEvidence;
+  const leftPercent = total > 0 ? Math.round((leftEvidence / total) * 100) : 50;
+  const rightPercent = 100 - leftPercent;
+  const chosen = leftPercent >= rightPercent ? def.left : def.right;
+  return {
+    key: def.key,
+    letter: chosen[0],
+    label: chosen[1],
+    labelZh: chosen[2],
+    left: { code: def.left[0], label: def.left[1], labelZh: def.left[2], percent: leftPercent },
+    right: { code: def.right[0], label: def.right[1], labelZh: def.right[2], percent: rightPercent },
+    margin: Math.abs(leftPercent - rightPercent),
+  };
+}
+
+function classifyType(categories = {}, promptAnalysis = {}) {
+  const c = (name) => categoryCount(categories, name);
+  const usefulRatio = Number(promptAnalysis.useful_ratio ?? 1);
+  const longRatio = Number(promptAnalysis.long_prompt_ratio || 0);
+  const referenceRatio = Math.max(0, 1 - usefulRatio);
+  const axes = [
+    splitAxis(AXIS_DEFS[0], c("implementation") + c("packaging") + c("testing") + c("refactor") + c("debugging") + c("ui_design") * 0.5, c("planning") + c("research") + c("explanation") + c("ui_design") * 0.5),
+    splitAxis(AXIS_DEFS[1], c("workflow") * 2 + c("planning") * 0.2, c("implementation") * 0.2 + c("explanation") + c("ui_design") * 0.35 + 0.25),
+    splitAxis(AXIS_DEFS[2], c("debugging") + c("testing") + c("refactor") * 0.7, c("implementation") + c("packaging") + c("ui_design") * 0.25),
+    splitAxis(AXIS_DEFS[3], Math.max(0.05, 1 - longRatio - referenceRatio), longRatio * 1.4 + referenceRatio * 1.2),
+  ];
+  return { code: axes.map((axis) => axis.letter).join(""), axes };
+}
+
+function confidenceFor(promptAnalysis, axes) {
+  const useful = Number(promptAnalysis?.useful_prompt_count || 0);
+  const sample = Math.min(1, useful / 80);
+  const separation = axes.reduce((sum, axis) => sum + axis.margin, 0) / axes.length / 100;
+  return Math.round(sample * (0.65 + separation * 0.35) * 100);
+}
+
+function confidenceTier(confidence) {
+  if (confidence >= 75) return {
+    id: "CLEAR",
+    color: "#2bb673",
+    emoji: "◆",
+    blurb: "Strong sample · clear axis separation",
+    blurbZh: "样本充足 · 行为轴区分清晰",
+  };
+  if (confidence >= 45) return {
+    id: "EMERGING",
+    color: "#d49a25",
+    emoji: "◇",
+    blurb: "Growing sample · mixed axis separation",
+    blurbZh: "样本增长中 · 部分行为轴仍接近",
+  };
+  return {
+    id: "LOW DATA",
+    color: "#8b8680",
+    emoji: "·",
+    blurb: "More prompts needed · provisional type",
+    blurbZh: "仍需更多提示 · 当前类型为暂定",
+  };
+}
+
+function buildRoast(personality, axes, confidence, usefulCount) {
+  if (usefulCount < 20) return {
+    roast: `🔥 The scanner found ${usefulCount} useful prompts — enough for a vibe trailer, not a personality verdict. Your provisional type is ${personality.code}, but four letters this early are basically a horoscope wearing a terminal theme. Feed it at least 20 real requests before framing the result.`,
+    roastZh: `🔥 扫描器只找到 ${usefulCount} 条有效提示——够剪一支预告片，不够给人格定案。暂定类型是 ${personality.code}，但这么早的四个字母，本质上只是穿了终端主题的星座运势。至少喂到 20 条真实请求再截图裱起来。`,
+    tldr: "Provisional vibe; the dataset needs more receipts.", tldrZh: "暂定 vibe；样本还得继续交作业。",
+  };
+  const a = Object.fromEntries(axes.map((axis) => [axis.key, axis]));
+  const closest = [...axes].sort((x, y) => x.margin - y.margin)[0];
+  const en = {
+    M: "You ask for working artifacts before the architecture committee finds a chair.", A: "You can turn a two-line feature into a diagram with municipal zoning.",
+    O: "One agent is never enough; apparently the task also needs a command structure.", P: "You prefer one exquisitely instructed agent and a prompt with terms and conditions.",
+    V: "Nothing ships until the bug has confessed and the tests have signed the statement.", S: "The merge button knows your fingerprint better than your test runner does.",
+    F: "You ration context like carry-on luggage.", X: "You bring the entire repo to questions that could fit on a sticky note.",
+  };
+  const zh = {
+    M: "架构委员会还没找到椅子，你已经要求交付可运行产物。", A: "两行需求到你手里，也能长成带城市规划的系统图。",
+    O: "一个 Agent 显然不够，这个任务还必须拥有指挥体系。", P: "你偏爱一位被精密调教的 Agent，以及一份自带条款的提示词。",
+    V: "bug 没招供、测试没签字，谁都别想上线。", S: "merge 键认得你的指纹，比测试运行器还熟。",
+    F: "你分配上下文，像廉航分配随身行李。", X: "便利贴能装下的问题，你也要把整个仓库搬来。",
+  };
+  const letters = axes.map((axis) => axis.letter);
+  return {
+    roast: `🔥 ${personality.title}: ${personality.hook}. ${letters.map((letter) => en[letter]).join(" ")}\n\nYour closest split is ${closest.left.code}/${closest.right.code} at ${closest.left.percent}/${closest.right.percent}, so that supposedly permanent letter is one refactor away from switching teams. Confidence is ${confidence}% — evidence, not destiny.`,
+    roastZh: `🔥 ${personality.titleZh}：${personality.hookZh}。${letters.map((letter) => zh[letter]).join("")}\n\n你最摇摆的是 ${closest.left.code}/${closest.right.code}（${closest.left.percent}/${closest.right.percent}），所以那个看似永久的字母，可能一次重构就叛变。置信度 ${confidence}%——这是证据，不是命运。`,
+    tldr: `${personality.code}: ${personality.hook}.`, tldrZh: `${personality.code}：${personality.hookZh}。`,
+  };
+}
+
+const { buildActivitySignals } = require("./activity-metrics");
+
+function buildVibeProfile({ categories = {}, env = {}, summary = {}, promptAnalysis = {}, activity = {} } = {}) {
+  const scores = scoreFromCategories(categories, env, promptAnalysis);
+  const typed = classifyType(categories, promptAnalysis);
+  const personality = PERSONALITIES[typed.code];
+  const confidence = confidenceFor(promptAnalysis, typed.axes);
+  const status = Number(promptAnalysis.useful_prompt_count || 0) >= 20 ? "ready" : "insufficient_data";
+  const roast = buildRoast(personality, typed.axes, confidence, Number(promptAnalysis.useful_prompt_count || 0));
+  return {
+    status, confidence, type_code: typed.code, type_axes: typed.axes, scores,
+    total: confidence, tier: confidenceTier(confidence),
+    personality, archetype: personality,
+    figure: `/assests/characters-vibe-types/${personality.folder}/${personality.name}-figure.png`,
+    figure_fallback: `/assests/characters/${LEGACY_FIGURES[typed.code].split("/")[0]}/${LEGACY_FIGURES[typed.code].split("/")[1]}-figure.png`,
+    badge: null,
+    dimensions: DIMENSIONS.map((dim) => ({ ...dim, value: scores[dim.key], score: scores[dim.key] / 100 })),
+    signals: buildActivitySignals({ activity, summary, categories }),
+    ...roast,
+  };
+}
+
+module.exports = { DIMENSIONS, PERSONALITIES, AXIS_DEFS, scoreFromCategories, classifyType, confidenceFor, buildRoast, buildVibeProfile };

package/src/lib/ai-roast.js

@@ -0,0 +1,446 @@
+/** Optional multi-provider roast writer. It cannot change deterministic profile results. */
+
+const DEFAULT_BASE_URL = "https://api.deepseek.com";
+const DEFAULT_MODEL = "deepseek-v4-flash";
+const PROVIDERS = {
+  deepseek: {
+    id: "deepseek",
+    protocol: "openai",
+    baseUrl: DEFAULT_BASE_URL,
+    model: DEFAULT_MODEL,
+  },
+  openai: {
+    id: "openai",
+    protocol: "openai",
+    baseUrl: "https://api.openai.com/v1",
+    model: "gpt-4.1-mini",
+  },
+  anthropic: {
+    id: "anthropic",
+    protocol: "anthropic",
+    baseUrl: "https://api.anthropic.com/v1",
+    model: "claude-haiku-4-5-20251001",
+  },
+  gemini: {
+    id: "gemini",
+    protocol: "gemini",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+    model: "gemini-2.5-flash",
+  },
+  groq: {
+    id: "groq",
+    protocol: "openai",
+    baseUrl: "https://api.groq.com/openai/v1",
+    model: "llama-3.3-70b-versatile",
+  },
+  openrouter: {
+    id: "openrouter",
+    protocol: "openai",
+    baseUrl: "https://openrouter.ai/api/v1",
+    model: "openai/gpt-4.1-mini",
+  },
+  cloudflare: {
+    id: "cloudflare",
+    protocol: "openai",
+    baseUrl: "https://auth.pinktalk.online/v1",
+    model: "@cf/qwen/qwen3-30b-a3b-fp8",
+  },
+};
+
+const SYSTEM_PROMPT = `You are the head writer for an evidence-grounded vibe-coding roast: part late-night monologue, part affectionate code-review afterparty.
+The deterministic type, axes, confidence, dimensions, counts, and rankings are immutable. Never recalculate or modify them.
+
+The job is to ROAST, not summarize. Write bilingual, vivid, shareable comedy grounded only in the supplied JSON evidence.
+
+COMEDY ENGINE
+- First choose one central comic premise from the strongest contrast in roast_targets or dimensions. Build the whole roast around it instead of listing metrics.
+- Use a three-beat escalation: (1) a sharp cold open that casts the personality as a character, (2) a receipts paragraph with 2-4 evidence-backed details, and (3) an absurd-but-grounded escalation ending on the strongest punchline.
+- Sustain one concrete metaphor world—courtroom, kitchen, airport, laboratory, reality show, religion, heist, sports commentary, etc.—chosen to fit the evidence. Do not mix five unrelated metaphors.
+- Prefer specific nouns, active verbs, varied sentence rhythm, callbacks, contrast, and comic misdirection. One sentence may be dry; the next should twist the knife.
+- Mention at least one distinctive recurring domain concept when recurring_domain_concepts is non-empty. Treat it as a prompt mention, not proof of a project.
+- Use exact numbers selectively as "receipts"; never turn every sentence into a dashboard caption.
+- The final sentence must be a quotable punchline, not advice, diagnosis, or a generic summary.
+- English and Chinese should be locally funny adaptations using the same evidence beats, not stiff line-by-line translations.
+- Hashtags are tiny jokes or character labels, not raw metric names.
+- Make the prompts, signals, ratios, dashboard, or fictionalized data-character the grammatical subject of risky jokes. Do not turn a low signal into a literal claim about what the person remembers, knows, feels, says, or does outside the observed prompts.
+
+HASHTAG ENGINE
+- Hashtags are interpretations, not a frequency table. Never copy a recurring concept merely because it ranks highly.
+- Read coherent concept clusters and infer the recognizable domain, community, scene, or character behind them. For example, preflop + folds + raises + river can become "HoldemPlayer"; 前庭 + HIT + nystagmus can become "VestibularLab" or "前庭实验室".
+- The first tag should be the strongest inferred domain/scene character when the evidence supports one. If it does not, lead with the personality character instead.
+- At least two tags should perform a semantic transformation: one domain/scene character and one coding-behavior joke. The remaining tags may reinforce personality or the central roast metaphor.
+- Do not emit isolated raw keywords such as "preflop", "browser", "implementation", "debugging", or "UI" as tags. A proper name or acronym may remain literal only when it is already a meaningful identity label.
+- Generate every tag as one bilingual pair with a shared semantic gloss. The Chinese tag must localize the intended joke, not translate the English surface form word by word. "CodeCult" means cult-like devotion and should become "代码教团" or "代码邪教", never "代码文化".
+- When kind is "personality_character", reuse immutable_profile.personality and immutable_profile.personality_zh instead of inventing a new translation.
+- Use kind "proper_noun" only for names or acronyms that should remain unchanged in both languages, such as GitHub, HIT, or ONNX.
+- Infer only from a coherent cluster. Never fuse unrelated concepts into a fictional project, occupation, credential, or claim of ownership.
+
+ANTI-BLANDNESS
+- Avoid report voice and filler such as "You're a builder", "all about", "minor signal", "faint echo", "verification pending", "context is optional", "X master", or "the data suggests".
+- Do not mechanically restate dimension labels. Convert evidence into a scene, character, prop, or running gag.
+- Do not compliment for two sentences and add one mild jab. Every paragraph needs a comic turn.
+- Do not give productivity advice or finish with "maybe test more".
+- Never invent dialogue or put a first-person quote in the user's mouth.
+- Never claim "you forgot context", "the only time you debug", "you are not shipping", "you have no patience", "your ego", or equivalent wording. Translate those impulses into jokes about the observed signal instead.
+
+EVIDENCE RULES
+- Fact first, jab second. Every joke must be traceable to a number, category, recurring concept, model, agent, or explicit contradiction in the evidence.
+- Prefer distinctive recurring project/domain concepts over generic coding words when the evidence supports them.
+- Roast coding behavior and workflow, never identity, protected traits, employer role, intelligence, or private life.
+- Do not claim causality, cheating, maintainership, expertise, or project ownership unless explicitly present.
+- A low testing/debugging signal means verification is under-observed in these prompts. It does not prove the code is wrong, untested elsewhere, or delegated to other people.
+- Treat category counts as observed prompt behavior, not objective engineering quality or completed work.
+- Concept occurrence_count means text mentions, never completed commits, pushes, tests, features, or other real-world actions. Call it a mention when citing it.
+- Aggregated concepts do not prove they belong to the same project. Never combine separate concepts into an invented app, bot, product, stack, or ownership claim. Say the prompts "orbit", "mention", or "cluster around" those concepts.
+- Category ratios do not reveal execution order. Never say code shipped before verification, entered production, broke, contained bugs, or failed to run.
+- Do not turn implementation/testing/debugging prompt categories into completed implementation, shipping, testing, or debugging actions. Say "implementation-classified prompts", "testing signal", or "debugging mentions".
+- Do not quote or reconstruct raw prompts.
+- Scale confidence: when status is insufficient_data, say the reading is provisional.
+- Return JSON only.`;
+
+const USER_INSTRUCTIONS = `Generate exactly this JSON shape:
+{
+  "hashtagPairs": [
+    {
+      "en": "concise English tag without #",
+      "zh": "localized Chinese tag without #",
+      "kind": "domain_character | behavior_character | personality_character | metaphor_callback | proper_noun",
+      "meaning": "short English semantic gloss explaining the intended joke"
+    }
+  ],
+  "roast": "English roast, exactly 3 short paragraphs separated by blank lines, target 120-170 words, <= 1100 characters",
+  "roastZh": "Chinese roast, exactly 3 short paragraphs separated by blank lines, target 220-340 Chinese characters, <= 700 characters",
+  "tldr": "English one-line mic-drop that adds a fresh joke, <= 150 characters",
+  "tldrZh": "Chinese one-line mic-drop that adds a fresh joke, <= 88 Chinese characters"
+}
+
+Before writing, silently select:
+1. the central contradiction;
+2. the metaphor world;
+3. three evidence receipts;
+4. the closing callback.
+
+Return 4-5 hashtagPairs. Order them as: inferred domain/scene character, coding-behavior joke, personality character, then optional metaphor/callback tags.
+Each pair must express the same meaning in both languages. Tags must be compact semantic labels, not copied high-frequency words. English tags must be English except proper names/acronyms. Chinese tags must be a culturally natural localization of the meaning, not a dictionary translation of the English word shape.`;
+
+function endpoint(baseUrl) {
+  return `${String(baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "")}/chat/completions`;
+}
+
+function providerConfig(provider = "deepseek", overrides = {}) {
+  const id = String(provider || "deepseek").toLowerCase();
+  const preset = PROVIDERS[id];
+  if (!preset) throw new Error(`Unsupported AI provider: ${provider}`);
+  return {
+    ...preset,
+    baseUrl: overrides.baseUrl || preset.baseUrl,
+    model: overrides.model || preset.model,
+  };
+}
+
+function requestForProvider(config, { apiKey, messages, temperature, maxTokens }) {
+  if (config.protocol === "anthropic") {
+    const system = messages.filter((message) => message.role === "system").map((message) => message.content).join("\n\n");
+    const conversation = messages
+      .filter((message) => message.role !== "system")
+      .map((message) => ({
+        role: message.role === "assistant" ? "assistant" : "user",
+        content: message.content,
+      }));
+    return {
+      url: `${String(config.baseUrl).replace(/\/+$/, "")}/messages`,
+      options: {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+        },
+        body: JSON.stringify({
+          model: config.model,
+          system,
+          messages: conversation,
+          temperature,
+          max_tokens: maxTokens,
+        }),
+      },
+    };
+  }
+
+  if (config.protocol === "gemini") {
+    const system = messages.filter((message) => message.role === "system").map((message) => message.content).join("\n\n");
+    const contents = messages
+      .filter((message) => message.role !== "system")
+      .map((message) => ({
+        role: message.role === "assistant" ? "model" : "user",
+        parts: [{ text: message.content }],
+      }));
+    const model = encodeURIComponent(config.model);
+    return {
+      url: `${String(config.baseUrl).replace(/\/+$/, "")}/models/${model}:generateContent?key=${encodeURIComponent(apiKey)}`,
+      options: {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          systemInstruction: { parts: [{ text: system }] },
+          contents,
+          generationConfig: {
+            temperature,
+            maxOutputTokens: maxTokens,
+            responseMimeType: "application/json",
+          },
+        }),
+      },
+    };
+  }
+
+  const body = {
+    model: config.model,
+    messages,
+    response_format: { type: "json_object" },
+    temperature,
+    max_tokens: maxTokens,
+  };
+  if (config.id === "deepseek") body.thinking = { type: "disabled" };
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`,
+  };
+  return {
+    url: endpoint(config.baseUrl),
+    options: { method: "POST", headers, body: JSON.stringify(body) },
+  };
+}
+
+function responseContent(config, payload) {
+  if (config.protocol === "anthropic") {
+    return payload?.content?.find((part) => part?.type === "text")?.text;
+  }
+  if (config.protocol === "gemini") {
+    return payload?.candidates?.[0]?.content?.parts?.map((part) => part?.text || "").join("");
+  }
+  return payload?.choices?.[0]?.message?.content;
+}
+
+function cleanText(value, maxLength, { short = false } = {}) {
+  const text = String(value || "").trim();
+  if (text.length <= maxLength) return text;
+  const window = text.slice(0, maxLength);
+  const minimum = Math.floor(maxLength * (short ? 0.4 : 0.58));
+  let boundary = -1;
+  for (let index = minimum; index < window.length; index += 1) {
+    const pattern = short ? /[.!?。！？,;:，；：\n]/ : /[.!?。！？\n]/;
+    if (window[index] === "." && /\d/.test(window[index - 1] || "") && /\d/.test(window[index + 1] || "")) {
+      continue;
+    }
+    if (pattern.test(window[index])) boundary = index + 1;
+  }
+  if (boundary > minimum) return window.slice(0, boundary).trim();
+  const wordBoundary = window.lastIndexOf(" ");
+  const clipped = wordBoundary > minimum ? window.slice(0, wordBoundary) : window.slice(0, maxLength - 1);
+  return `${clipped.trim()}…`;
+}
+
+function cleanTags(value, maxLength) {
+  if (!Array.isArray(value)) return [];
+  const seen = new Set();
+  const tags = [];
+  for (const raw of value) {
+    const tag = String(raw || "")
+      .replace(/^#+/, "")
+      .replace(/[\r\n]/g, " ")
+      .trim()
+      .slice(0, maxLength);
+    const key = tag.toLowerCase();
+    if (!tag || seen.has(key)) continue;
+    seen.add(key);
+    tags.push(tag);
+    if (tags.length >= 5) break;
+  }
+  return tags;
+}
+
+const HASHTAG_KINDS = new Set([
+  "domain_character",
+  "behavior_character",
+  "personality_character",
+  "metaphor_callback",
+  "proper_noun",
+]);
+
+function cleanHashtagPairs(value) {
+  if (!Array.isArray(value)) return [];
+  const pairs = [];
+  const seenEn = new Set();
+  const seenZh = new Set();
+  for (const raw of value) {
+    const en = cleanTags([raw?.en], 24)[0];
+    const zh = cleanTags([raw?.zh], 12)[0];
+    if (!en || !zh) continue;
+    const enKey = en.toLowerCase();
+    const zhKey = zh.toLowerCase();
+    if (seenEn.has(enKey) || seenZh.has(zhKey)) continue;
+    const requestedKind = String(raw?.kind || "");
+    const kind = HASHTAG_KINDS.has(requestedKind) ? requestedKind : "metaphor_callback";
+    if (enKey === zhKey && kind !== "proper_noun") continue;
+    seenEn.add(enKey);
+    seenZh.add(zhKey);
+    pairs.push({
+      en,
+      zh,
+      kind,
+      meaning: cleanText(raw?.meaning, 80, { short: true }),
+    });
+    if (pairs.length >= 5) break;
+  }
+  return pairs;
+}
+
+function sentenceParts(value) {
+  return String(value || "")
+    .match(/[^.!?。！？\n]+(?:[.!?。！？]+|$)/gu)
+    ?.map((sentence) => sentence.trim())
+    .filter(Boolean) || [];
+}
+
+function paragraphize(value, target = 3) {
+  const text = String(value || "").trim();
+  const existing = text.split(/\n\s*\n/u).map((part) => part.trim()).filter(Boolean);
+  if (existing.length >= target) return existing.join("\n\n");
+  const sentences = sentenceParts(text);
+  if (sentences.length < target) return text;
+  const paragraphs = [];
+  let cursor = 0;
+  for (let index = 0; index < target; index += 1) {
+    const remainingSentences = sentences.length - cursor;
+    const remainingParagraphs = target - index;
+    const take = Math.ceil(remainingSentences / remainingParagraphs);
+    paragraphs.push(sentences.slice(cursor, cursor + take).join(" "));
+    cursor += take;
+  }
+  return paragraphs.join("\n\n");
+}
+
+function parseJsonPayload(raw) {
+  if (raw && typeof raw === "object") return raw;
+  const text = String(raw || "").trim();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    const unfenced = text
+      .replace(/^```(?:json)?\s*/iu, "")
+      .replace(/\s*```$/u, "")
+      .trim();
+    try {
+      return JSON.parse(unfenced);
+    } catch {
+      const start = unfenced.indexOf("{");
+      const end = unfenced.lastIndexOf("}");
+      if (start >= 0 && end > start) return JSON.parse(unfenced.slice(start, end + 1));
+      throw new SyntaxError("AI roast response is not valid JSON");
+    }
+  }
+}
+
+function validateRoastPayload(raw) {
+  const parsed = parseJsonPayload(raw);
+  const hashtagPairs = cleanHashtagPairs(parsed?.hashtagPairs);
+  const paired = hashtagPairs.length >= 3;
+  const result = {
+    ...(paired ? { hashtagPairs } : {}),
+    hashtags: paired ? hashtagPairs.map((pair) => pair.en) : cleanTags(parsed?.hashtags, 24),
+    hashtagsZh: paired ? hashtagPairs.map((pair) => pair.zh) : cleanTags(parsed?.hashtagsZh, 12),
+    roast: paragraphize(cleanText(parsed?.roast, 1100)),
+    roastZh: paragraphize(cleanText(parsed?.roastZh, 700)),
+    tldr: cleanText(parsed?.tldr, 150, { short: true }),
+    tldrZh: cleanText(parsed?.tldrZh, 88, { short: true }),
+  };
+  if (result.hashtags.length < 3 || result.hashtagsZh.length < 3
+    || !result.roast || !result.roastZh || !result.tldr || !result.tldrZh) {
+    throw new Error("AI roast response is missing required bilingual fields");
+  }
+  return result;
+}
+
+async function generateAiRoast(evidence, {
+  apiKey = process.env.DEEPSEEK_API_KEY,
+  baseUrl,
+  model,
+  provider = "deepseek",
+  fetchImpl = globalThis.fetch,
+  timeoutMs = 40_000,
+  requestHeaders,
+} = {}) {
+  if (!apiKey) throw new Error("An API key is required for AI roast generation");
+  if (typeof fetchImpl !== "function") throw new Error("fetch is unavailable");
+  const config = providerConfig(provider, {
+    baseUrl: baseUrl || (provider === "deepseek" ? process.env.DEEPSEEK_BASE_URL : undefined),
+    model: model || (provider === "deepseek" ? process.env.DEEPSEEK_MODEL : undefined),
+  });
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const messages = [
+      { role: "system", content: SYSTEM_PROMPT },
+      {
+        role: "user",
+        content: `${USER_INSTRUCTIONS}\n\nEVIDENCE JSON:\n${JSON.stringify(evidence)}`,
+      },
+    ];
+    const request = requestForProvider(config, {
+      apiKey,
+      messages,
+      temperature: 0.9,
+      maxTokens: 1800,
+    });
+    const response = await fetchImpl(request.url, {
+      ...request.options,
+      headers: {
+        ...request.options.headers,
+        ...(requestHeaders || {}),
+      },
+      signal: controller.signal,
+    });
+
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const message = payload?.error?.message
+        || payload?.error?.status
+        || `${config.id} request failed with HTTP ${response.status}`;
+      const error = new Error(message);
+      error.status = response.status;
+      throw error;
+    }
+    const result = validateRoastPayload(responseContent(config, payload));
+    const cacheStatus = response.headers?.get?.("x-vibe-roast-cache");
+
+    return {
+      ...result,
+      writer: {
+        provider: config.id,
+        model: payload?.model || config.model,
+        evidence_schema_version: evidence?.schema_version || 1,
+        ...(cacheStatus ? { cached: cacheStatus.toLowerCase() === "hit" } : {}),
+      },
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+module.exports = {
+  DEFAULT_BASE_URL,
+  DEFAULT_MODEL,
+  PROVIDERS,
+  SYSTEM_PROMPT,
+  USER_INSTRUCTIONS,
+  generateAiRoast,
+  providerConfig,
+  requestForProvider,
+  responseContent,
+  validateRoastPayload,
+  parseJsonPayload,
+  paragraphize,
+};