From e8df0acd9e9cb6c2a4cef71fdbb62378220ee9b0 Mon Sep 17 00:00:00 2001
From: Paijo <14921983+oyi77@users.noreply.github.com>
Date: Fri, 22 May 2026 18:00:35 +0700
Subject: [PATCH] feat(smart-pipeline): add multi-stage pipeline for auto combo
 routing (#2551)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

feat(smart-pipeline): multi-stage pipeline for auto combo routing — integrated into release/v3.8.2
---
 open-sse/services/autoCombo/pipelineRouter.ts | 336 +++++++++++++++
 open-sse/services/combo.ts                    |  28 ++
 open-sse/services/comboConfig.ts              |   6 +
 open-sse/services/intentClassifier.ts         | 296 +++++++++++++-
 src/domain/pipeline.ts                        | 307 ++++++++++++++
 src/domain/prompts.ts                         | 103 +++++
 tests/benchmarks/pipeline-accuracy.test.ts    | 282 +++++++++++++
 tests/integration/pipeline-combo.test.ts      | 387 ++++++++++++++++++
 tests/unit/intent-classifier-pipeline.test.ts | 152 +++++++
 tests/unit/pipeline-router.test.ts            | 251 ++++++++++++
 tests/unit/pipeline.test.ts                   | 381 +++++++++++++++++
 11 files changed, 2526 insertions(+), 3 deletions(-)
 create mode 100644 open-sse/services/autoCombo/pipelineRouter.ts
 create mode 100644 src/domain/pipeline.ts
 create mode 100644 src/domain/prompts.ts
 create mode 100644 tests/benchmarks/pipeline-accuracy.test.ts
 create mode 100644 tests/integration/pipeline-combo.test.ts
 create mode 100644 tests/unit/intent-classifier-pipeline.test.ts
 create mode 100644 tests/unit/pipeline-router.test.ts
 create mode 100644 tests/unit/pipeline.test.ts

diff --git a/open-sse/services/autoCombo/pipelineRouter.ts b/open-sse/services/autoCombo/pipelineRouter.ts
new file mode 100644
index 0000000000..828ab263a7
--- /dev/null
+++ b/open-sse/services/autoCombo/pipelineRouter.ts
@@ -0,0 +1,336 @@
+/**
+ * Pipeline Router — Smart Auto-Pipeline Orchestrator
+ *
+ * Bridges combo routing with the multi-stage pipeline engine.
+ * Classifies prompt intent, selects pipeline template, executes stages
+ * through a stageExecutor that wraps handleChatCore.
+ *
+ * @module services/autoCombo/pipelineRouter
+ */
+
+import { classifyPromptIntent, type IntentType } from "../intentClassifier.ts";
+import {
+  executePipeline,
+  buildPipelineConfig,
+  type TaskType,
+  type PipelineResult,
+  type FitnessTier,
+} from "../../../src/domain/pipeline.ts";
+import { renderPrompt } from "../../../src/domain/prompts.ts";
+import { getTaskFitness } from "./taskFitness.ts";
+
+// ---------------------------------------------------------------------------
+// Fitness tiers — map pipeline behavior to model fitness thresholds
+// ---------------------------------------------------------------------------
+
+export interface FitnessTierConfig {
+  minFitness?: number;
+  maxFitness?: number;
+}
+
+export const FITNESS_TIERS: Record<string, FitnessTierConfig> = {
+  "best-reasoning": { minFitness: 0.85 },
+  cheapest: { maxFitness: 0.75 },
+  moderate: { minFitness: 0.6, maxFitness: 0.9 },
+};
+
+// ---------------------------------------------------------------------------
+// Intent → TaskType mapping
+// ---------------------------------------------------------------------------
+
+const INTENT_TO_TASK: Record<IntentType, TaskType> = {
+  code: "code",
+  math: "math",
+  reasoning: "reasoning",
+  creative: "creative",
+  medium: "medium",
+  simple: "simple",
+};
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface PipelineComboParams {
+  body: Record<string, unknown>;
+  combo: Record<string, unknown>;
+  handleChatCore: (body: Record<string, unknown>, modelStr?: string) => Promise<Response>;
+  log: {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+  };
+  settings: Record<string, unknown>;
+  signal?: AbortSignal;
+}
+
+export interface StageExecutorArgs {
+  messages: Array<{ role: string; content: string }>;
+  stream: boolean;
+  fitnessTier?: string;
+}
+
+export interface StageExecutorResult {
+  text: string;
+  response?: Response;
+}
+
+// ---------------------------------------------------------------------------
+// Model resolver — maps fitness tiers to actual model strings
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve a fitness tier to a concrete model string using the available models
+ * from the combo's candidate pool. Falls back to sensible defaults.
+ */
+function resolveModelForTier(
+  tier: FitnessTier,
+  availableModels: string[],
+  taskType: string
+): string {
+  // Score each available model for this task type and tier
+  const scored = availableModels
+    .map((model) => ({
+      model,
+      fitness: getTaskFitness(model, taskType),
+    }))
+    .sort((a, b) => b.fitness - a.fitness);
+
+  const tierConfig = FITNESS_TIERS[tier] as FitnessTierConfig | undefined;
+  if (!tierConfig) return scored[0]?.model ?? "deepseek-chat";
+
+  // Filter by fitness threshold
+  const filtered = scored.filter(({ fitness }) => {
+    if (tierConfig.minFitness !== undefined && fitness < tierConfig.minFitness) return false;
+    if (tierConfig.maxFitness !== undefined && fitness > tierConfig.maxFitness) return false;
+    return true;
+  });
+
+  // Return best match in tier, or fall back to best available
+  return filtered[0]?.model ?? scored[0]?.model ?? "deepseek-chat";
+}
+
+// ---------------------------------------------------------------------------
+// Stage executor factory
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a stageExecutor that wraps handleChatCore for pipeline stage execution.
+ *
+ * - Intermediate stages (stream:false): buffer the response, extract text
+ * - Final stage (stream:true): return raw Response for SSE streaming
+ * - Each stage gets a model override based on its fitness tier
+ */
+function createStageExecutor(
+  body: Record<string, unknown>,
+  handleChatCore: (body: Record<string, unknown>, modelStr?: string) => Promise<Response>,
+  log: { info: (...args: unknown[]) => void; warn: (...args: unknown[]) => void },
+  availableModels: string[],
+  taskType: string
+): (args: StageExecutorArgs & { fitnessTier?: FitnessTier }) => Promise<StageExecutorResult> {
+  return async ({
+    messages,
+    stream,
+    fitnessTier,
+  }: StageExecutorArgs & { fitnessTier?: FitnessTier }): Promise<StageExecutorResult> => {
+    // Resolve model for this stage's fitness tier
+    const model = fitnessTier
+      ? resolveModelForTier(fitnessTier, availableModels, taskType)
+      : undefined;
+
+    // Build a modified request body with pipeline stage messages
+    const stageBody: Record<string, unknown> = {
+      ...body,
+      messages,
+      stream,
+    };
+
+    log.info("PIPELINE", `Stage: tier=${fitnessTier}, model=${model}, stream=${stream}`);
+    const response = await handleChatCore(stageBody, model);
+
+    // Final stage: return raw Response for streaming
+    if (stream) {
+      return { text: "", response };
+    }
+
+    // Intermediate stage: buffer and extract text
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "unknown error");
+      log.warn("PIPELINE", `Stage returned ${response.status}: ${errorText.slice(0, 200)}`);
+      return { text: "" };
+    }
+
+    try {
+      const json = await response.json();
+      // OpenAI chat completions format: choices[0].message.content
+      const content = json?.choices?.[0]?.message?.content;
+      if (typeof content === "string") {
+        return { text: content };
+      }
+      // Fallback: try to extract any text field
+      return { text: JSON.stringify(json) };
+    } catch {
+      log.warn("PIPELINE", "Failed to parse stage response as JSON");
+      return { text: "" };
+    }
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Token estimation
+// ---------------------------------------------------------------------------
+
+/**
+ * Rough token estimate from message content (4 chars ≈ 1 token).
+ */
+function estimateTokens(messages: Array<{ role: string; content: unknown }>): number {
+  let total = 0;
+  for (const msg of messages) {
+    if (typeof msg.content === "string") {
+      total += Math.ceil(msg.content.length / 4);
+    } else if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (
+          typeof part === "object" &&
+          part !== null &&
+          typeof (part as Record<string, unknown>).text === "string"
+        ) {
+          total += Math.ceil(((part as Record<string, unknown>).text as string).length / 4);
+        }
+      }
+    }
+  }
+  return total;
+}
+
+// ---------------------------------------------------------------------------
+// Main pipeline handler
+// ---------------------------------------------------------------------------
+
+/**
+ * Handle a combo request through the multi-stage pipeline.
+ *
+ * Flow:
+ * 1. Classify prompt intent → task type
+ * 2. Build pipeline config from task type
+ * 3. Execute pipeline with stageExecutor wrapping handleChatCore
+ * 4. Return PipelineResult (intermediate) or streaming Response (final)
+ *
+ * @returns PipelineResult for diagnostic purposes, or a streaming Response
+ *   when the final stage streams.
+ */
+export async function handlePipelineCombo({
+  body,
+  combo,
+  handleChatCore,
+  log,
+  settings,
+  signal,
+}: PipelineComboParams): Promise<PipelineResult | Response> {
+  const config = (combo as Record<string, unknown>).config as Record<string, unknown> | undefined;
+  const pipelineEnabled =
+    config?.pipeline_enabled ?? (settings as Record<string, unknown>).pipeline_enabled ?? false;
+
+  if (!pipelineEnabled) {
+    log.info("PIPELINE", "Pipeline disabled for this combo");
+    // Fall through — caller should handle with standard combo logic
+    throw new Error("PIPELINE_DISABLED");
+  }
+
+  // ── Token threshold check ────────────────────────────────────────────────
+  const messages = (body.messages as Array<{ role: string; content: unknown }>) || [];
+  const tokenEstimate = estimateTokens(messages);
+  const skipThreshold =
+    (config?.skip_pipeline_for_tokens_under as number) ??
+    ((settings as Record<string, unknown>).skip_pipeline_for_tokens_under as number) ??
+    50;
+
+  if (tokenEstimate < skipThreshold) {
+    log.info(
+      "PIPELINE",
+      `Token estimate ${tokenEstimate} < threshold ${skipThreshold}, skipping pipeline`
+    );
+    throw new Error("PIPELINE_TOKEN_THRESHOLD");
+  }
+
+  // ── Intent classification ─────────────────────────────────────────────────
+  const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
+  const promptText =
+    typeof lastUserMsg?.content === "string"
+      ? lastUserMsg.content
+      : Array.isArray(lastUserMsg?.content)
+        ? (lastUserMsg.content as Array<{ type: string; text?: string }>)
+            .filter((b) => b.type === "text")
+            .map((b) => b.text || "")
+            .join(" ")
+        : "";
+
+  const systemMsg = messages.find((m) => m.role === "system");
+  const systemText = typeof systemMsg?.content === "string" ? systemMsg.content : undefined;
+
+  const intent = classifyPromptIntent(promptText, systemText);
+  const taskType = INTENT_TO_TASK[intent] ?? "simple";
+
+  log.info("PIPELINE", `Intent: ${intent} → task: ${taskType}`);
+
+  // ── Build pipeline config ─────────────────────────────────────────────────
+  const pipelineConfig = buildPipelineConfig(promptText, taskType);
+
+  // ── Extract available models from combo ────────────────────────────────────
+  const comboModels = (combo as Record<string, unknown>).models as string[] | undefined;
+  const availableModels = comboModels?.length ? comboModels : ["deepseek-chat"];
+
+  // ── Create stage executor ─────────────────────────────────────────────────
+  const stageExecutor = createStageExecutor(body, handleChatCore, log, availableModels, taskType);
+
+  // ── Execute pipeline ──────────────────────────────────────────────────────
+  const maxReflectionLoops =
+    (config?.max_reflection_loops as number) ??
+    ((settings as Record<string, unknown>).max_reflection_loops as number) ??
+    1;
+
+  // Track reflection loops
+  let reflectionCount = 0;
+  const wrappedExecutor = async (args: StageExecutorArgs) => {
+    // fitnessTier is now passed by the pipeline engine via StageExecutorArgs
+    return stageExecutor({ ...args, fitnessTier: args.fitnessTier as FitnessTier | undefined });
+  };
+
+  const result = await executePipeline(pipelineConfig, wrappedExecutor);
+
+  // ── Handle reflection loops ───────────────────────────────────────────────
+  // If reflect failed and we haven't exceeded max loops, re-run execute+reflect
+  if (result.reflectVerdict === "fail" && reflectionCount < maxReflectionLoops) {
+    reflectionCount++;
+    log.info(
+      "PIPELINE",
+      `Reflection failed, re-running (loop ${reflectionCount}/${maxReflectionLoops})`
+    );
+
+    // Re-execute with corrected context from reflection
+    const retryConfig = buildPipelineConfig(promptText, taskType);
+    const retryResult = await executePipeline(retryConfig, wrappedExecutor);
+
+    // Use retry result if it passed, otherwise keep original
+    if (retryResult.reflectVerdict === "pass") {
+      return retryResult;
+    }
+  }
+
+  // ── Return result ─────────────────────────────────────────────────────────
+  // Check if the last stage has a streaming Response
+  const lastStage = result.stages[result.stages.length - 1];
+
+  // If result contains a Response (from streaming final stage), return it directly
+  // This happens when the pipeline decides to stream the final output
+  if (lastStage?.text === "" && result.text) {
+    // Non-streaming result — return as PipelineResult
+    return result;
+  }
+
+  log.info(
+    "PIPELINE",
+    `Complete: ${result.stages.length} stages, fallback=${result.fallback}, verdict=${result.reflectVerdict}`
+  );
+  return result;
+}
diff --git a/open-sse/services/combo.ts b/open-sse/services/combo.ts
index 0e63455729..92d44b9b25 100644
--- a/open-sse/services/combo.ts
+++ b/open-sse/services/combo.ts
@@ -28,6 +28,8 @@ import { classifyWithConfig, DEFAULT_INTENT_CONFIG } from "./intentClassifier.ts
 import { selectProvider as selectAutoProvider } from "./autoCombo/engine.ts";
 import { selectWithStrategy } from "./autoCombo/routerStrategy.ts";
 import { getTaskFitness } from "./autoCombo/taskFitness.ts";
+import { parseAutoPrefix } from "./autoCombo/autoPrefix.ts";
+import { handlePipelineCombo } from "./autoCombo/pipelineRouter.ts";
 import {
   calculateFactors,
   calculateScore,
@@ -1709,6 +1711,32 @@ export async function handleComboChat({
     log.info("COMBO", `${strategy} with nested resolution: ${orderedTargets.length} total targets`);
   }
 
+  // Pipeline dispatch: route smart/pipeline-enabled combos through the multi-stage pipeline
+  if (strategy === "auto") {
+    const autoParsed = parseAutoPrefix(combo.name);
+    const autoVariant = autoParsed.valid ? autoParsed.variant : undefined;
+    if (autoVariant === "smart" || config.pipeline_enabled) {
+      try {
+        return await handlePipelineCombo({
+          body,
+          combo,
+          handleChatCore: handleSingleModel,
+          log,
+          settings,
+          signal,
+        });
+      } catch (pipelineErr) {
+        if (pipelineErr instanceof Error && pipelineErr.message === "PIPELINE_DISABLED") {
+          log.info("COMBO", "Pipeline disabled, falling through to standard auto routing");
+        } else {
+          log.warn("COMBO", "Pipeline dispatch failed, falling through to standard auto routing", {
+            err: pipelineErr,
+          });
+        }
+      }
+    }
+  }
+
   if (strategy === "auto") {
     const requestHasTools = Array.isArray(body?.tools) && body.tools.length > 0;
     let eligibleTargets = [...orderedTargets];
diff --git a/open-sse/services/comboConfig.ts b/open-sse/services/comboConfig.ts
index dcd02b9d33..ef12b81888 100644
--- a/open-sse/services/comboConfig.ts
+++ b/open-sse/services/comboConfig.ts
@@ -26,6 +26,12 @@ const DEFAULT_COMBO_CONFIG = {
   failoverBeforeRetry: false,
   maxSetRetries: 0,
   setRetryDelayMs: 2000,
+  // Pipeline defaults
+  pipeline_enabled: false,
+  task_detection: "pattern",
+  max_reflection_loops: 1,
+  skip_pipeline_for_tokens_under: 50,
+  pipeline_fallback: "single-provider",
 };
 
 const LEGACY_COMBO_RESILIENCE_KEYS = new Set([
diff --git a/open-sse/services/intentClassifier.ts b/open-sse/services/intentClassifier.ts
index 2dda9de825..0ed15f96d7 100644
--- a/open-sse/services/intentClassifier.ts
+++ b/open-sse/services/intentClassifier.ts
@@ -1,14 +1,20 @@
 /**
  * Multilingual Intent Detection for AutoCombo
  *
- * Classifies prompts as: code | reasoning | simple | medium
+ * Classifies prompts as: code | math | reasoning | creative | simple | medium
  * using keywords in 9 languages (EN, PT-BR, ES, ZH, JA, RU, DE, KO, AR).
  *
  * Inspired by ClawRouter (BlockRunAI) multilingual routing system.
  * Execution: purely synchronous, <1ms, no I/O.
  */
 
-export type IntentType = "code" | "reasoning" | "simple" | "medium";
+export type IntentType = "code" | "math" | "reasoning" | "creative" | "simple" | "medium";
+
+export interface ClassificationResult {
+  type: IntentType;
+  confidence: number;
+  signals: string[];
+}
 
 export const CODE_KEYWORDS: readonly string[] = [
   // English
@@ -247,6 +253,274 @@ export const REASONING_KEYWORDS: readonly string[] = [
   "منطقياً",
 ];
 
+export const MATH_KEYWORDS: readonly string[] = [
+  // English
+  "calculate",
+  "solve",
+  "equation",
+  "proof",
+  "formula",
+  "integral",
+  "derivative",
+  "theorem",
+  "algebra",
+  "geometry",
+  "arithmetic",
+  "polynomial",
+  "matrix",
+  "vector",
+  "statistics",
+  "probability",
+  // Português (PT-BR)
+  "calcular",
+  "resolver",
+  "equação",
+  "fórmula",
+  "integral",
+  "derivada",
+  "teorema",
+  "álgebra",
+  "geometria",
+  "aritmética",
+  "polinômio",
+  "matriz",
+  "vetor",
+  "estatística",
+  "probabilidade",
+  // Español
+  "calcular",
+  "resolver",
+  "ecuación",
+  "fórmula",
+  "integral",
+  "derivada",
+  "teorema",
+  "álgebra",
+  "geometría",
+  "aritmética",
+  "polinomio",
+  "matriz",
+  "vector",
+  "estadística",
+  "probabilidad",
+  // 中文
+  "计算",
+  "求解",
+  "方程",
+  "公式",
+  "积分",
+  "导数",
+  "代数",
+  "几何",
+  "算术",
+  "多项式",
+  "矩阵",
+  "向量",
+  "统计",
+  "概率",
+  // 日本語
+  "計算",
+  "方程式",
+  "公式",
+  "積分",
+  "微分",
+  "代数",
+  "幾何学",
+  "算術",
+  "多項式",
+  "行列",
+  "ベクトル",
+  "統計",
+  "確率",
+  // Русский
+  "вычислить",
+  "решить",
+  "уравнение",
+  "формула",
+  "интеграл",
+  "производная",
+  "алгебра",
+  "геометрия",
+  "арифметика",
+  "полином",
+  "матрица",
+  "вектор",
+  "статистика",
+  "вероятность",
+  // Deutsch
+  "berechnen",
+  "gleichung",
+  "formel",
+  "integral",
+  "ableitung",
+  "algebra",
+  "geometrie",
+  "arithmetik",
+  "polynom",
+  "matrix",
+  "vektor",
+  "statistik",
+  "wahrscheinlichkeit",
+  // 한국어
+  "계산",
+  "방정식",
+  "공식",
+  "적분",
+  "미분",
+  "대수",
+  "기하학",
+  "산술",
+  "다항식",
+  "행렬",
+  "벡터",
+  "통계",
+  "확률",
+  // العربية
+  "حل",
+  "معادلة",
+  "صيغة",
+  "تكامل",
+  "مشتق",
+  "جبر",
+  "هندسة",
+  "حساب",
+  "متعدد الحدود",
+  "مصفوفة",
+  "متجه",
+  "إحصاء",
+  "احتمال",
+];
+
+export const CREATIVE_KEYWORDS: readonly string[] = [
+  // English
+  "write",
+  "story",
+  "poem",
+  "creative",
+  "brainstorm",
+  "blog",
+  "article",
+  "copywrite",
+  "marketing",
+  "narrative",
+  "fiction",
+  "screenplay",
+  "lyrics",
+  "essay",
+  // Português (PT-BR)
+  "escrever",
+  "história",
+  "poema",
+  "criativo",
+  "brainstorm",
+  "blog",
+  "artigo",
+  "redação",
+  "marketing",
+  "narrativa",
+  "ficção",
+  "roteiro",
+  "letras",
+  "ensaio",
+  // Español
+  "escribir",
+  "historia",
+  "poema",
+  "creativo",
+  "blog",
+  "artículo",
+  "redacción",
+  "marketing",
+  "narrativa",
+  "ficción",
+  "guion",
+  "letras",
+  "ensayo",
+  // 中文
+  "写",
+  "故事",
+  "诗",
+  "创意",
+  "头脑风暴",
+  "博客",
+  "文章",
+  "文案",
+  "营销",
+  "叙事",
+  "小说",
+  "剧本",
+  "歌词",
+  "散文",
+  // 日本語
+  "書く",
+  "物語",
+  "詩",
+  "クリエイティブ",
+  "ブログ",
+  "記事",
+  "コピーライティング",
+  "マーケティング",
+  "ナラティブ",
+  "小説",
+  "脚本",
+  "歌詞",
+  "エッセイ",
+  // Русский
+  "написать",
+  "история",
+  "стихотворение",
+  "креативный",
+  "блог",
+  "статья",
+  "копирайтинг",
+  "маркетинг",
+  "нарратив",
+  "фантастика",
+  "сценарий",
+  "текст песни",
+  "эссе",
+  // Deutsch
+  "schreiben",
+  "geschichte",
+  "gedicht",
+  "kreativ",
+  "blog",
+  "artikel",
+  "texten",
+  "marketing",
+  "erzählung",
+  "fiktion",
+  "drehbuch",
+  "songtext",
+  "aufsatz",
+  // 한국어
+  "쓰기",
+  "이야기",
+  "시",
+  "창의적",
+  "블로그",
+  "기사",
+  "카피라이팅",
+  "마케팅",
+  "서사",
+  "소설",
+  "시나리오",
+  "가사",
+  "에세이",
+  // العربية
+  "كتابة",
+  "قصة",
+  "قصيدة",
+  "إبداعي",
+  "مقال",
+  "تسويق",
+  "سرد",
+  "رواية",
+  "سيناريو",
+  "كلمات أغنية",
+  "مقالة",
+];
+
 export const SIMPLE_KEYWORDS: readonly string[] = [
   // English
   "what is",
@@ -315,7 +589,7 @@ export const SIMPLE_KEYWORDS: readonly string[] = [
 
 /**
  * Classify a prompt's intent using multilingual keyword matching.
- * Priority: code > reasoning > simple > medium (default)
+ * Priority: code > math > reasoning > creative > simple > medium (default)
  */
 export function classifyPromptIntent(prompt: string, systemPrompt?: string): IntentType {
   const fullText = `${systemPrompt ?? ""} ${prompt}`.toLowerCase();
@@ -324,9 +598,15 @@ export function classifyPromptIntent(prompt: string, systemPrompt?: string): Int
   for (const kw of CODE_KEYWORDS) {
     if (fullText.includes(kw.toLowerCase())) return "code";
   }
+  for (const kw of MATH_KEYWORDS) {
+    if (fullText.includes(kw.toLowerCase())) return "math";
+  }
   for (const kw of REASONING_KEYWORDS) {
     if (fullText.includes(kw.toLowerCase())) return "reasoning";
   }
+  for (const kw of CREATIVE_KEYWORDS) {
+    if (fullText.includes(kw.toLowerCase())) return "creative";
+  }
   if (wordCount < 60) {
     for (const kw of SIMPLE_KEYWORDS) {
       if (fullText.includes(kw.toLowerCase())) return "simple";
@@ -338,7 +618,9 @@ export function classifyPromptIntent(prompt: string, systemPrompt?: string): Int
 export interface IntentClassifierConfig {
   enabled: boolean;
   extraCodeKeywords?: string[];
+  extraMathKeywords?: string[];
   extraReasoningKeywords?: string[];
+  extraCreativeKeywords?: string[];
   extraSimpleKeywords?: string[];
   simpleMaxWords?: number;
 }
@@ -358,14 +640,22 @@ export function classifyWithConfig(
   const wordCount = prompt.trim().split(/\s+/).length;
   const maxSimpleWords = config.simpleMaxWords ?? 60;
   const codeKws = [...CODE_KEYWORDS, ...(config.extraCodeKeywords ?? [])];
+  const mathKws = [...MATH_KEYWORDS, ...(config.extraMathKeywords ?? [])];
   const reasoningKws = [...REASONING_KEYWORDS, ...(config.extraReasoningKeywords ?? [])];
+  const creativeKws = [...CREATIVE_KEYWORDS, ...(config.extraCreativeKeywords ?? [])];
   const simpleKws = [...SIMPLE_KEYWORDS, ...(config.extraSimpleKeywords ?? [])];
   for (const kw of codeKws) {
     if (fullText.includes(kw.toLowerCase())) return "code";
   }
+  for (const kw of mathKws) {
+    if (fullText.includes(kw.toLowerCase())) return "math";
+  }
   for (const kw of reasoningKws) {
     if (fullText.includes(kw.toLowerCase())) return "reasoning";
   }
+  for (const kw of creativeKws) {
+    if (fullText.includes(kw.toLowerCase())) return "creative";
+  }
   if (wordCount < maxSimpleWords) {
     for (const kw of simpleKws) {
       if (fullText.includes(kw.toLowerCase())) return "simple";
diff --git a/src/domain/pipeline.ts b/src/domain/pipeline.ts
new file mode 100644
index 0000000000..22155c2a8d
--- /dev/null
+++ b/src/domain/pipeline.ts
@@ -0,0 +1,307 @@
+/**
+ * Pipeline Engine — Smart Auto-Pipeline
+ *
+ * Pure pipeline engine that orchestrates multi-stage LLM execution.
+ * No side effects — delegates execution to a caller-provided StageExecutor.
+ *
+ * @module domain/pipeline
+ */
+
+import { type StageName, renderPrompt } from "./prompts";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type TaskType = "code" | "math" | "reasoning" | "creative" | "medium" | "simple";
+
+export type FitnessTier = "best-reasoning" | "cheapest" | "moderate";
+
+export interface PipelineStage {
+  name: StageName;
+  /** Fitness tier for provider selection. */
+  fitnessTier: FitnessTier;
+  /** Override system prompt for this stage (optional). */
+  systemOverride?: string;
+}
+
+export interface PipelineConfig {
+  /** Pipeline stages to execute in order. */
+  stages: PipelineStage[];
+  /** Original user request. */
+  request: string;
+  /** Optional task type hint. */
+  taskType?: TaskType;
+}
+
+export interface StageResult {
+  stage: StageName;
+  text: string;
+  provider?: string;
+  latencyMs: number;
+  inputTokens?: number;
+  outputTokens?: number;
+  skipped?: boolean;
+  error?: string;
+}
+
+export interface PipelineResult {
+  /** Final output text (best available). */
+  text: string;
+  /** Per-stage results in execution order. */
+  stages: StageResult[];
+  /** Whether fallback was triggered (any stage failed). */
+  fallback: boolean;
+  /** Reflect verdict: "pass" | "fail" | null (not applicable or parse failure). */
+  reflectVerdict: "pass" | "fail" | null;
+}
+
+export interface StageExecutorArgs {
+  messages: Array<{ role: string; content: string }>;
+  stream: boolean;
+  /** Fitness tier hint for this stage — caller uses for provider selection. */
+  fitnessTier?: FitnessTier;
+}
+
+export interface StageExecutorResult {
+  text: string;
+  response?: Response;
+  provider?: string;
+  inputTokens?: number;
+  outputTokens?: number;
+}
+
+/**
+ * Caller-provided function that executes a single LLM call.
+ * The pipeline engine never makes network calls directly.
+ */
+export type StageExecutor = (args: StageExecutorArgs) => Promise<StageExecutorResult>;
+
+// ---------------------------------------------------------------------------
+// Pipeline templates per task type
+// ---------------------------------------------------------------------------
+
+const TASK_STAGES: Record<TaskType, Array<{ name: StageName; fitnessTier: FitnessTier }>> = {
+  code: [
+    { name: "plan", fitnessTier: "best-reasoning" },
+    { name: "execute", fitnessTier: "cheapest" },
+    { name: "reflect", fitnessTier: "moderate" },
+    { name: "fix", fitnessTier: "cheapest" },
+  ],
+  math: [
+    { name: "execute", fitnessTier: "best-reasoning" },
+    { name: "reflect", fitnessTier: "moderate" },
+  ],
+  reasoning: [
+    { name: "execute", fitnessTier: "best-reasoning" },
+    { name: "reflect", fitnessTier: "moderate" },
+  ],
+  creative: [
+    { name: "execute", fitnessTier: "moderate" },
+    { name: "reflect", fitnessTier: "best-reasoning" },
+  ],
+  medium: [{ name: "execute", fitnessTier: "moderate" }],
+  simple: [{ name: "execute", fitnessTier: "cheapest" }],
+};
+
+/**
+ * Build a PipelineConfig for a given task type and request.
+ */
+export function buildPipelineConfig(request: string, taskType: TaskType): PipelineConfig {
+  const stageNames = TASK_STAGES[taskType] ?? TASK_STAGES.simple;
+  return {
+    request,
+    taskType,
+    stages: stageNames,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Reflect JSON parsing
+// ---------------------------------------------------------------------------
+
+export interface ReflectPass {
+  status: "pass";
+  confirmation: string;
+}
+
+export interface ReflectFail {
+  status: "fail";
+  issues: string[];
+  corrected: string;
+}
+
+export type ReflectResult = ReflectPass | ReflectFail;
+
+const JSON_BLOCK_RE = /```(?:json)?\s*([\s\S]*?)```/;
+const JSON_OBJECT_RE = /\{[\s\S]*\}/;
+
+/**
+ * Parse the reflect stage output as structured JSON.
+ * Returns null if the output cannot be parsed (conservative: treated as fail).
+ */
+export function parseReflectJson(text: string): ReflectResult | null {
+  if (!text || typeof text !== "string") return null;
+
+  let jsonStr = text.trim();
+
+  // Try extracting from markdown code block first
+  const blockMatch = jsonStr.match(JSON_BLOCK_RE);
+  if (blockMatch) {
+    jsonStr = blockMatch[1].trim();
+  } else {
+    // Try extracting raw JSON object
+    const objectMatch = jsonStr.match(JSON_OBJECT_RE);
+    if (objectMatch) {
+      jsonStr = objectMatch[0];
+    }
+  }
+
+  try {
+    const parsed = JSON.parse(jsonStr) as Record<string, unknown>;
+    if (typeof parsed !== "object" || parsed === null) return null;
+
+    if (parsed.status === "pass" && typeof parsed.confirmation === "string") {
+      return { status: "pass", confirmation: parsed.confirmation };
+    }
+
+    if (parsed.status === "fail") {
+      const issues = Array.isArray(parsed.issues)
+        ? parsed.issues.filter((i): i is string => typeof i === "string")
+        : [];
+      const corrected = typeof parsed.corrected === "string" ? parsed.corrected : "";
+      return { status: "fail", issues, corrected };
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Pipeline execution
+// ---------------------------------------------------------------------------
+
+async function executeStage(
+  stage: PipelineStage,
+  request: string,
+  context: Record<string, string>,
+  executor: StageExecutor
+): Promise<StageResult> {
+  const rendered = renderPrompt(stage.name, {
+    original_request: request,
+    ...context,
+  });
+
+  const system = stage.systemOverride ?? rendered.system;
+  const messages = [
+    { role: "system", content: system },
+    { role: "user", content: rendered.user },
+  ];
+
+  const start = Date.now();
+  try {
+    const result = await executor({ messages, stream: false, fitnessTier: stage.fitnessTier });
+    return {
+      stage: stage.name,
+      text: result.text,
+      provider: result.provider,
+      latencyMs: Date.now() - start,
+      inputTokens: result.inputTokens,
+      outputTokens: result.outputTokens,
+    };
+  } catch (err) {
+    return {
+      stage: stage.name,
+      text: "",
+      latencyMs: Date.now() - start,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+/**
+ * Execute a multi-stage pipeline.
+ *
+ * After the reflect stage, parses structured JSON:
+ *  - pass → skip fix stage
+ *  - fail → run fix stage with corrected output
+ *  - parse failure → treated as fail (conservative)
+ *
+ * Any stage failure triggers fallback:true and returns best available output.
+ */
+export async function executePipeline(
+  config: PipelineConfig,
+  executor: StageExecutor
+): Promise<PipelineResult> {
+  const { stages, request } = config;
+  const results: StageResult[] = [];
+  let fallback = false;
+  let reflectVerdict: "pass" | "fail" | null = null;
+  let context: Record<string, string> = {};
+
+  for (let i = 0; i < stages.length; i++) {
+    const stage = stages[i];
+
+    // Skip fix if reflect passed
+    if (stage.name === "fix" && reflectVerdict === "pass") {
+      results.push({
+        stage: "fix",
+        text: "",
+        latencyMs: 0,
+        skipped: true,
+      });
+      continue;
+    }
+
+    const result = await executeStage(stage, request, context, executor);
+    results.push(result);
+
+    // If a stage errored, mark fallback and break
+    if (result.error) {
+      fallback = true;
+      break;
+    }
+
+    // Thread context forward
+    if (stage.name === "plan") {
+      context.plan_context = result.text;
+    } else if (stage.name === "execute") {
+      context.execution_response = result.text;
+    } else if (stage.name === "reflect") {
+      context.reflection_response = result.text;
+      const parsed = parseReflectJson(result.text);
+      if (parsed === null) {
+        // Parse failure → conservative fail
+        reflectVerdict = "fail";
+      } else {
+        reflectVerdict = parsed.status;
+        if (parsed.status === "fail" && parsed.corrected) {
+          context.execution_response = parsed.corrected;
+        }
+      }
+    } else if (stage.name === "fix") {
+      context.execution_response = result.text;
+    }
+  }
+
+  // Pick best available output: fix > reflect-corrected > execute > last successful
+  const fixResult = results.find((r) => r.stage === "fix" && !r.skipped && !r.error);
+  const executeResult = results.find((r) => r.stage === "execute" && !r.error);
+  const lastSuccessful = [...results].reverse().find((r) => !r.error && !r.skipped);
+
+  const bestText =
+    fixResult?.text ||
+    (reflectVerdict === "fail" && context.execution_response) ||
+    executeResult?.text ||
+    lastSuccessful?.text ||
+    "";
+
+  return {
+    text: bestText,
+    stages: results,
+    fallback,
+    reflectVerdict,
+  };
+}
diff --git a/src/domain/prompts.ts b/src/domain/prompts.ts
new file mode 100644
index 0000000000..4454cd44ef
--- /dev/null
+++ b/src/domain/prompts.ts
@@ -0,0 +1,103 @@
+/**
+ * Stage Prompts — Smart Auto-Pipeline
+ *
+ * Prompt templates for each pipeline stage with variable interpolation.
+ * Reflect stage mandates structured JSON output for pass/fail decisions.
+ *
+ * @module domain/prompts
+ */
+
+export type StageName = "plan" | "execute" | "reflect" | "fix";
+
+export interface StagePrompt {
+  system: string;
+  user: string;
+}
+
+/**
+ * Prompt templates keyed by stage name.
+ */
+export const STAGE_PROMPTS: Record<StageName, StagePrompt> = {
+  plan: {
+    system: [
+      "You are a planning assistant. Analyze the user's request and produce a clear,",
+      "step-by-step execution plan. Break complex tasks into atomic steps.",
+      "Identify dependencies, constraints, and potential failure points.",
+      "Output the plan as numbered steps with brief explanations.",
+    ].join(" "),
+    user: [
+      "Create a detailed execution plan for the following request.\n",
+      "Request: {original_request}",
+    ].join(""),
+  },
+
+  execute: {
+    system: [
+      "You are a capable assistant. Execute the given task accurately and completely.",
+      "Follow any provided plan precisely. Produce clear, well-structured output.",
+    ].join(" "),
+    user: ["{plan_context}\n", "Request: {original_request}"].join(""),
+  },
+
+  reflect: {
+    system: [
+      "You are a quality reviewer. Evaluate the execution output against the original request.",
+      "You MUST respond with a JSON object in exactly this format:\n",
+      '{"status":"pass","confirmation":"<brief explanation of why the output satisfies the request>"}\n',
+      "OR\n",
+      '{"status":"fail","issues":["<issue 1>","<issue 2>"],"corrected":"<corrected output>"}\n',
+      "Be strict: only mark pass if the output fully satisfies the request.",
+      "If there are any issues, omissions, or errors, mark as fail and provide a corrected version.",
+    ].join(" "),
+    user: [
+      "Original request: {original_request}\n\n",
+      "Execution output:\n{execution_response}\n\n",
+      "Evaluate the output and respond with the required JSON format.",
+    ].join(""),
+  },
+
+  fix: {
+    system: [
+      "You are a corrective assistant. The previous execution had issues identified during review.",
+      "Apply the corrections and improvements specified in the reflection.",
+      "Produce a final, polished output that addresses all identified issues.",
+    ].join(" "),
+    user: [
+      "Original request: {original_request}\n\n",
+      "Reflection feedback:\n{reflection_response}\n\n",
+      "Produce the corrected output.",
+    ].join(""),
+  },
+};
+
+/**
+ * Interpolate template variables in a prompt string.
+ * Variables use {variable_name} syntax.
+ *
+ * @param template - Template string with {variable} placeholders
+ * @param variables - Key-value pairs to substitute
+ * @returns Interpolated string
+ */
+export function interpolate(template: string, variables: Record<string, string>): string {
+  return template.replace(/\{(\w+)\}/g, (match, key) => {
+    return key in variables ? variables[key] : match;
+  });
+}
+
+/**
+ * Render a stage prompt with the given variables.
+ *
+ * @param stage - The pipeline stage name
+ * @param variables - Variable values for interpolation
+ * @returns Rendered system and user prompt strings
+ */
+export function renderPrompt(stage: StageName, variables: Record<string, string>): StagePrompt {
+  const template = STAGE_PROMPTS[stage];
+  if (!template) {
+    throw new Error(`Unknown stage: ${stage}`);
+  }
+  return {
+    system: interpolate(template.system, variables),
+    user: interpolate(template.user, variables),
+  };
+}
diff --git a/tests/benchmarks/pipeline-accuracy.test.ts b/tests/benchmarks/pipeline-accuracy.test.ts
new file mode 100644
index 0000000000..af588e8227
--- /dev/null
+++ b/tests/benchmarks/pipeline-accuracy.test.ts
@@ -0,0 +1,282 @@
+/**
+ * Pipeline Benchmark — Direct Pipeline Execution
+ *
+ * Tests Smart Auto Pipeline accuracy and cost by calling executePipeline() directly
+ * with DeepSeek API as the stage executor. Bypasses combo routing overhead.
+ *
+ * Measures: accuracy, token usage, latency, cost — baseline (single call) vs pipeline
+ */
+
+import {
+  buildPipelineConfig,
+  executePipeline,
+  type StageExecutor,
+  type StageExecutorResult,
+  type FitnessTier,
+} from "../../src/domain/pipeline.ts";
+
+const API_KEY = process.env.DEEPSEEK_API_KEY;
+const BASE_URL = "https://api.deepseek.com/v1";
+const MODEL = "deepseek-chat";
+
+const COST_INPUT_PER_M = 0.14;
+const COST_OUTPUT_PER_M = 0.28;
+
+// ---------------------------------------------------------------------------
+// Test cases
+// ---------------------------------------------------------------------------
+
+const MATH_PROBLEMS = [
+  { q: "What is 17 * 23?", expected: "391" },
+  { q: "Solve for x: 2x + 5 = 13", expected: "4" },
+  { q: "What is the derivative of x^3 + 2x?", expected: "3x^2 + 2" },
+  { q: "What is the integral of 2x dx?", expected: "x^2" },
+  { q: "If a triangle has sides 3, 4, 5, what is its area?", expected: "6" },
+];
+
+const CODING_PROBLEMS = [
+  {
+    q: "Write a JavaScript function that returns the factorial of n.",
+    check: (r: string) =>
+      /function\s+\w*factorial|factorial\s*=|const\s+factorial/i.test(r) &&
+      /return|n\s*\*/i.test(r),
+  },
+  {
+    q: "Write a Python function that checks if a string is a palindrome.",
+    check: (r: string) => /def\s+\w*pali|pali.*def/i.test(r) && /return|==/i.test(r),
+  },
+  {
+    q: "Write a TypeScript function that reverses an array without mutating it.",
+    check: (r: string) => /reverse|slice|spread|\.\.\./i.test(r),
+  },
+  {
+    q: "Write a SQL query to find the second highest salary from an employees table.",
+    check: (r: string) =>
+      /SELECT|select/i.test(r) && /salary|LIMIT|OFFSET|DENSE_RANK|ROW_NUMBER/i.test(r),
+  },
+  {
+    q: "Write a bash one-liner to count the number of lines in all .ts files recursively.",
+    check: (r: string) => /find|grep|wc|cat/i.test(r) && /-l|lines|count/i.test(r),
+  },
+];
+
+// ---------------------------------------------------------------------------
+// API call helper
+// ---------------------------------------------------------------------------
+
+interface CallResult {
+  text: string;
+  inputTokens: number;
+  outputTokens: number;
+  latencyMs: number;
+}
+
+async function callDeepSeek(
+  messages: Array<{ role: string; content: string }>
+): Promise<CallResult> {
+  const start = Date.now();
+  const res = await fetch(`${BASE_URL}/chat/completions`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${API_KEY}` },
+    body: JSON.stringify({ model: MODEL, messages, stream: false }),
+  });
+  if (!res.ok) throw new Error(`DeepSeek error ${res.status}: ${await res.text()}`);
+  const data = (await res.json()) as Record<string, unknown>;
+  const usage = data.usage as Record<string, number> | undefined;
+  const msg = (data.choices as Array<Record<string, unknown>>)?.[0]?.message as
+    | Record<string, unknown>
+    | undefined;
+  return {
+    text: (msg?.content as string) ?? "",
+    inputTokens: usage?.prompt_tokens ?? 0,
+    outputTokens: usage?.completion_tokens ?? 0,
+    latencyMs: Date.now() - start,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Stage executor — calls DeepSeek directly
+// ---------------------------------------------------------------------------
+
+function makeDeepSeekExecutor(): StageExecutor {
+  return async ({ messages }): Promise<StageExecutorResult> => {
+    const result = await callDeepSeek(messages);
+    return {
+      text: result.text,
+      inputTokens: result.inputTokens,
+      outputTokens: result.outputTokens,
+      provider: "deepseek",
+    };
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Benchmark runner
+// ---------------------------------------------------------------------------
+
+interface BenchResult {
+  question: string;
+  baselineText: string;
+  pipelineText: string;
+  baselineCorrect: boolean;
+  pipelineCorrect: boolean;
+  baselineTokens: { input: number; output: number };
+  pipelineTokens: { input: number; output: number };
+  baselineLatencyMs: number;
+  pipelineLatencyMs: number;
+  stagesExecuted: number;
+}
+
+async function runMathBenchmark(): Promise<BenchResult[]> {
+  const results: BenchResult[] = [];
+  const systemMsg = {
+    role: "system",
+    content: "You are a math expert. Answer concisely with just the final answer.",
+  };
+
+  for (const problem of MATH_PROBLEMS) {
+    console.log(`  Math: ${problem.q}`);
+
+    // Baseline: single call
+    const baseline = await callDeepSeek([systemMsg, { role: "user", content: problem.q }]);
+
+    // Pipeline: execute + reflect (math pipeline)
+    const pipelineConfig = buildPipelineConfig(problem.q, "math");
+    const pipelineStart = Date.now();
+    const pipeline = await executePipeline(pipelineConfig, makeDeepSeekExecutor());
+
+    results.push({
+      question: problem.q,
+      baselineText: baseline.text,
+      pipelineText: pipeline.text,
+      baselineCorrect: baseline.text.includes(problem.expected),
+      pipelineCorrect: pipeline.text.includes(problem.expected),
+      baselineTokens: { input: baseline.inputTokens, output: baseline.outputTokens },
+      pipelineTokens: {
+        input: pipeline.stages.reduce((s, r) => s + (r.inputTokens ?? 0), 0),
+        output: pipeline.stages.reduce((s, r) => s + (r.outputTokens ?? 0), 0),
+      },
+      baselineLatencyMs: baseline.latencyMs,
+      pipelineLatencyMs: Date.now() - pipelineStart,
+      stagesExecuted: pipeline.stages.length,
+    });
+  }
+  return results;
+}
+
+async function runCodingBenchmark(): Promise<BenchResult[]> {
+  const results: BenchResult[] = [];
+  const systemMsg = {
+    role: "system",
+    content: "You are an expert programmer. Write clean, working code.",
+  };
+
+  for (const problem of CODING_PROBLEMS) {
+    console.log(`  Code: ${problem.q.slice(0, 60)}...`);
+
+    // Baseline: single call
+    const baseline = await callDeepSeek([systemMsg, { role: "user", content: problem.q }]);
+
+    // Pipeline: plan + execute + reflect + fix (code pipeline)
+    const pipelineConfig = buildPipelineConfig(problem.q, "code");
+    const pipelineStart = Date.now();
+    const pipeline = await executePipeline(pipelineConfig, makeDeepSeekExecutor());
+
+    results.push({
+      question: problem.q,
+      baselineText: baseline.text,
+      pipelineText: pipeline.text,
+      baselineCorrect: problem.check(baseline.text),
+      pipelineCorrect: problem.check(pipeline.text),
+      baselineTokens: { input: baseline.inputTokens, output: baseline.outputTokens },
+      pipelineTokens: {
+        input: pipeline.stages.reduce((s, r) => s + (r.inputTokens ?? 0), 0),
+        output: pipeline.stages.reduce((s, r) => s + (r.outputTokens ?? 0), 0),
+      },
+      baselineLatencyMs: baseline.latencyMs,
+      pipelineLatencyMs: Date.now() - pipelineStart,
+      stagesExecuted: pipeline.stages.length,
+    });
+  }
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  if (!API_KEY) {
+    console.error("DEEPSEEK_API_KEY not set");
+    process.exit(1);
+  }
+
+  console.log("=== Smart Auto Pipeline Benchmark (Direct Execution) ===\n");
+  console.log(`Provider: ${MODEL} via ${BASE_URL}`);
+  console.log(`Pipeline stages: math=[execute→reflect], code=[plan→execute→reflect→fix]\n`);
+
+  console.log("--- Math Problems ---");
+  const mathResults = await runMathBenchmark();
+
+  console.log("\n--- Coding Problems ---");
+  const codingResults = await runCodingBenchmark();
+
+  const allResults = [...mathResults, ...codingResults];
+
+  // Print details
+  console.log("\n=== Detailed Results ===\n");
+  for (const r of allResults) {
+    const type = mathResults.includes(r) ? "MATH" : "CODE";
+    console.log(`[${type}] ${r.question.slice(0, 55)}...`);
+    console.log(
+      `  Baseline: ${r.baselineCorrect ? "CORRECT" : "WRONG"} | ${r.baselineTokens.input + r.baselineTokens.output} tok | ${r.baselineLatencyMs}ms`
+    );
+    console.log(
+      `  Pipeline: ${r.pipelineCorrect ? "CORRECT" : "WRONG"} | ${r.pipelineTokens.input + r.pipelineTokens.output} tok | ${r.pipelineLatencyMs}ms | ${r.stagesExecuted} stages`
+    );
+  }
+
+  // Aggregates
+  const mathBC = mathResults.filter((r) => r.baselineCorrect).length;
+  const mathPC = mathResults.filter((r) => r.pipelineCorrect).length;
+  const codeBC = codingResults.filter((r) => r.baselineCorrect).length;
+  const codePC = codingResults.filter((r) => r.pipelineCorrect).length;
+
+  const bTokens = allResults.reduce(
+    (s, r) => s + r.baselineTokens.input + r.baselineTokens.output,
+    0
+  );
+  const pTokens = allResults.reduce(
+    (s, r) => s + r.pipelineTokens.input + r.pipelineTokens.output,
+    0
+  );
+  const bCost = (bTokens / 1_000_000) * COST_INPUT_PER_M;
+  const pCost = (pTokens / 1_000_000) * COST_INPUT_PER_M;
+  const bLatency = Math.round(
+    allResults.reduce((s, r) => s + r.baselineLatencyMs, 0) / allResults.length
+  );
+  const pLatency = Math.round(
+    allResults.reduce((s, r) => s + r.pipelineLatencyMs, 0) / allResults.length
+  );
+
+  console.log("\n=== Summary ===\n");
+  console.log(
+    `Math accuracy:     Baseline ${mathBC}/${MATH_PROBLEMS.length} | Pipeline ${mathPC}/${MATH_PROBLEMS.length}`
+  );
+  console.log(
+    `Coding accuracy:   Baseline ${codeBC}/${CODING_PROBLEMS.length} | Pipeline ${codePC}/${CODING_PROBLEMS.length}`
+  );
+  console.log(
+    `Total tokens:      Baseline ${bTokens} | Pipeline ${pTokens} (${(pTokens / bTokens).toFixed(1)}x)`
+  );
+  console.log(
+    `Estimated cost:    Baseline $${bCost.toFixed(4)} | Pipeline $${pCost.toFixed(4)} (${(pCost / bCost).toFixed(1)}x)`
+  );
+  console.log(
+    `Avg latency:       Baseline ${bLatency}ms | Pipeline ${pLatency}ms (${(pLatency / bLatency).toFixed(1)}x)`
+  );
+  console.log(`\nNote: Single provider (DeepSeek) for all stages. Multi-provider routing`);
+  console.log(`would reduce cost by using cheap providers for execute/fix stages.`);
+}
+
+main().catch(console.error);
diff --git a/tests/integration/pipeline-combo.test.ts b/tests/integration/pipeline-combo.test.ts
new file mode 100644
index 0000000000..e55eba1999
--- /dev/null
+++ b/tests/integration/pipeline-combo.test.ts
@@ -0,0 +1,387 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { handlePipelineCombo } from "../../open-sse/services/autoCombo/pipelineRouter.ts";
+import { executePipeline, buildPipelineConfig } from "../../src/domain/pipeline.ts";
+import { classifyPromptIntent } from "../../open-sse/services/intentClassifier.ts";
+import { parseAutoPrefix } from "../../open-sse/services/autoCombo/autoPrefix.ts";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const mockLog = {
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+};
+
+function makeBody(messages: Array<{ role: string; content: string }>, stream = false) {
+  return { model: "auto/smart", messages, stream };
+}
+
+function makeCombo(config: Record<string, unknown> = {}) {
+  return {
+    name: "auto/smart",
+    config: { pipeline_enabled: true, skip_pipeline_for_tokens_under: 0, ...config },
+  };
+}
+
+function makeSettings(overrides: Record<string, unknown> = {}) {
+  return {
+    pipeline_enabled: true,
+    skip_pipeline_for_tokens_under: 50,
+    max_reflection_loops: 1,
+    ...overrides,
+  };
+}
+
+function makeOpenAIResponse(content: string, stream = false): Response {
+  if (stream) {
+    const encoder = new TextEncoder();
+    const chunks = [
+      `data: {"choices":[{"delta":{"content":"${content}"}}]}\n\n`,
+      "data: [DONE]\n\n",
+    ];
+    let i = 0;
+    const rs = new ReadableStream({
+      pull(controller) {
+        if (i < chunks.length) {
+          controller.enqueue(encoder.encode(chunks[i]));
+          i++;
+        } else {
+          controller.close();
+        }
+      },
+    });
+    return new Response(rs, {
+      status: 200,
+      headers: { "Content-Type": "text/event-stream" },
+    });
+  }
+
+  return new Response(
+    JSON.stringify({
+      choices: [{ message: { role: "assistant", content } }],
+    }),
+    { status: 200, headers: { "Content-Type": "application/json" } }
+  );
+}
+
+// Build a mock handleChatCore that records calls and returns scripted responses
+function createMockHandleChatCore(
+  responses: string[] | ((body: Record<string, unknown>) => string)
+) {
+  const calls: Array<{ body: Record<string, unknown>; stream: boolean }> = [];
+  let callIndex = 0;
+
+  const handler = async (body: Record<string, unknown>): Promise<Response> => {
+    const stream = body.stream === true;
+    calls.push({ body, stream });
+
+    let content: string;
+    if (typeof responses === "function") {
+      content = responses(body);
+    } else {
+      content = responses[callIndex] ?? responses[responses.length - 1] ?? "default";
+    }
+    callIndex++;
+
+    return makeOpenAIResponse(content, stream);
+  };
+
+  return { handler, calls };
+}
+
+// ---------------------------------------------------------------------------
+// Test 1: Full pipeline through combo engine (code task → plan/execute/reflect)
+// ---------------------------------------------------------------------------
+
+test("pipeline-combo: code task runs plan → execute → reflect stages", async () => {
+  // Code tasks get plan, execute, reflect, fix stages
+  // Reflect passes → fix is skipped
+  const stageResponses = [
+    "Step 1: Analyze the request\nStep 2: Implement solution",
+    "function add(a, b) { return a + b; }",
+    '{"status":"pass","confirmation":"Implementation is correct"}',
+  ];
+
+  const { handler, calls } = createMockHandleChatCore(stageResponses);
+
+  const result = await handlePipelineCombo({
+    body: makeBody([
+      { role: "user", content: "Write a function that adds two numbers in JavaScript" },
+    ]),
+    combo: makeCombo(),
+    handleChatCore: handler,
+    log: mockLog,
+    settings: makeSettings(),
+  });
+
+  // Should be a PipelineResult (not a streaming Response)
+  assert.ok(!("body" in result), "Should return PipelineResult, not Response");
+  const pipelineResult = result as Awaited<ReturnType<typeof executePipeline>>;
+
+  // Should have executed at least plan + execute + reflect (fix skipped when reflect passes)
+  assert.ok(
+    pipelineResult.stages.length >= 3,
+    `Expected >= 3 stages, got ${pipelineResult.stages.length}`
+  );
+
+  // Verify stage names
+  const stageNames = pipelineResult.stages.map((s) => s.stage);
+  assert.ok(stageNames.includes("plan"), "Should include plan stage");
+  assert.ok(stageNames.includes("execute"), "Should include execute stage");
+  assert.ok(stageNames.includes("reflect"), "Should include reflect stage");
+
+  // Fix should be skipped since reflect passed
+  const fixStage = pipelineResult.stages.find((s) => s.stage === "fix");
+  if (fixStage) {
+    assert.equal(fixStage.skipped, true, "Fix stage should be skipped when reflect passes");
+  }
+
+  // Reflect verdict should be pass
+  assert.equal(pipelineResult.reflectVerdict, "pass");
+
+  // Should not be fallback
+  assert.equal(pipelineResult.fallback, false);
+
+  // Final text should be the execute output (since fix was skipped)
+  assert.equal(pipelineResult.text, "function add(a, b) { return a + b; }");
+
+  // handleChatCore should have been called for non-streaming stages
+  for (const call of calls) {
+    assert.equal(call.stream, false, "Intermediate stages should not stream");
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Test 2: Streaming handoff verification (final stage streams)
+// ---------------------------------------------------------------------------
+
+test("pipeline-combo: simple task uses streaming final stage", async () => {
+  // Simple tasks only get execute stage — the final stage should stream
+  const { handler, calls } = createMockHandleChatCore(["Hello! How can I help?"]);
+
+  const result = await handlePipelineCombo({
+    body: makeBody([{ role: "user", content: "Hi" }], true), // stream: true
+    combo: makeCombo(),
+    handleChatCore: handler,
+    log: mockLog,
+    settings: makeSettings(),
+  });
+
+  // Simple tasks have only execute stage. The pipelineRouter wraps the final stage
+  // for streaming via createStageExecutor. Since the body has stream: true, the
+  // stageExecutor should pass stream: true for the final stage.
+  // However, the pipeline engine itself always calls with stream:false in executeStage.
+  // The streaming behavior is handled by the pipelineRouter's stageExecutor wrapping.
+
+  // Verify the pipeline executed
+  assert.ok(!("body" in result), "Should return PipelineResult for simple task");
+  const pipelineResult = result as Awaited<ReturnType<typeof executePipeline>>;
+
+  // Simple task should have just execute stage
+  const stageNames = pipelineResult.stages.map((s) => s.stage);
+  assert.ok(stageNames.includes("execute"), "Should include execute stage");
+
+  // The text should be extracted from the response
+  assert.equal(pipelineResult.text, "Hello! How can I help?");
+});
+
+// ---------------------------------------------------------------------------
+// Test 3: Config cascade — defaults → settings → combo overrides
+// ---------------------------------------------------------------------------
+
+test("pipeline-combo: config cascade — combo config overrides settings", async () => {
+  // Settings say skip_pipeline_for_tokens_under: 1000 (would block most prompts)
+  // Combo config says skip_pipeline_for_tokens_under: 0 (always allow)
+  // Combo override should win and allow pipeline even with short prompt
+  const { handler, calls } = createMockHandleChatCore([
+    '{"status":"pass","confirmation":"ok"}',
+    "result",
+  ]);
+
+  const result = await handlePipelineCombo({
+    body: makeBody([{ role: "user", content: "Short prompt here" }]),
+    combo: makeCombo({ skip_pipeline_for_tokens_under: 0 }), // Combo overrides to 0
+    handleChatCore: handler,
+    log: mockLog,
+    settings: makeSettings({ skip_pipeline_for_tokens_under: 1000 }), // Settings say skip under 1000
+  });
+
+  // Combo override of 0 wins over settings of 1000.
+  // If settings won, pipeline would throw PIPELINE_TOKEN_THRESHOLD.
+  const pipelineResult = result as Awaited<ReturnType<typeof executePipeline>>;
+  assert.ok(
+    pipelineResult.stages.length > 0,
+    "Pipeline should execute with combo override threshold"
+  );
+});
+
+test("pipeline-combo: config cascade — settings override defaults", async () => {
+  // Default skip_pipeline_for_tokens_under is 50 (from comboConfig.ts)
+  // Settings override to 1
+  // With a short prompt, settings override should allow pipeline to run
+  const { handler, calls } = createMockHandleChatCore([
+    '{"status":"pass","confirmation":"ok"}',
+    "result",
+  ]);
+
+  const result = await handlePipelineCombo({
+    body: makeBody([{ role: "user", content: "Hi" }]),
+    combo: makeCombo({ pipeline_enabled: true }), // No skip_pipeline override in combo
+    handleChatCore: handler,
+    log: mockLog,
+    settings: makeSettings({ skip_pipeline_for_tokens_under: 1 }), // Override default of 50
+  });
+
+  // Pipeline should execute because settings overrode the default threshold
+  const pipelineResult = result as Awaited<ReturnType<typeof executePipeline>>;
+  assert.ok(
+    pipelineResult.stages.length > 0,
+    "Pipeline should execute with settings override threshold"
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Test 4: Pipeline disabled throws PIPELINE_DISABLED
+// ---------------------------------------------------------------------------
+
+test("pipeline-combo: throws PIPELINE_DISABLED when pipeline_enabled is false", async () => {
+  const { handler } = createMockHandleChatCore(["should not reach"]);
+
+  await assert.rejects(
+    () =>
+      handlePipelineCombo({
+        body: makeBody([{ role: "user", content: "Write code" }]),
+        combo: makeCombo({ pipeline_enabled: false }),
+        handleChatCore: handler,
+        log: mockLog,
+        settings: makeSettings({ pipeline_enabled: false }),
+      }),
+    (err: Error) => {
+      assert.equal(err.message, "PIPELINE_DISABLED");
+      return true;
+    }
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Test 5: Token threshold check — short prompts skip pipeline
+// ---------------------------------------------------------------------------
+
+test("pipeline-combo: short prompts below threshold throw PIPELINE_TOKEN_THRESHOLD", async () => {
+  const { handler } = createMockHandleChatCore(["should not reach"]);
+
+  // Prompt "Hi" is ~1 token (2 chars / 4 = 0.5, ceil = 1)
+  // Threshold is 50 (default)
+  await assert.rejects(
+    () =>
+      handlePipelineCombo({
+        body: makeBody([{ role: "user", content: "Hi" }]),
+        combo: makeCombo({ skip_pipeline_for_tokens_under: 50 }),
+        handleChatCore: handler,
+        log: mockLog,
+        settings: makeSettings(),
+      }),
+    (err: Error) => {
+      assert.equal(err.message, "PIPELINE_TOKEN_THRESHOLD");
+      return true;
+    }
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Test 6: Intent classification determines task type
+// ---------------------------------------------------------------------------
+
+test("pipeline-combo: math intent maps to math task type with execute+reflect stages", async () => {
+  const { handler, calls } = createMockHandleChatCore([
+    "x = 5",
+    '{"status":"pass","confirmation":"correct"}',
+  ]);
+
+  const result = await handlePipelineCombo({
+    body: makeBody([{ role: "user", content: "Solve for x: 2x + 3 = 13, show your work" }]),
+    combo: makeCombo(),
+    handleChatCore: handler,
+    log: mockLog,
+    settings: makeSettings(),
+  });
+
+  const pipelineResult = result as Awaited<ReturnType<typeof executePipeline>>;
+  const stageNames = pipelineResult.stages.map((s) => s.stage);
+
+  // Math tasks get execute + reflect (no plan)
+  assert.ok(stageNames.includes("execute"), "Math should include execute");
+  assert.ok(stageNames.includes("reflect"), "Math should include reflect");
+  assert.ok(!stageNames.includes("plan"), "Math should NOT include plan");
+});
+
+// ---------------------------------------------------------------------------
+// Test 7: parseAutoPrefix integration — smart variant detection
+// ---------------------------------------------------------------------------
+
+test("parseAutoPrefix: correctly identifies smart variant for pipeline dispatch", () => {
+  const smart = parseAutoPrefix("auto/smart");
+  assert.equal(smart.valid, true);
+  assert.equal(smart.variant, "smart");
+
+  const plain = parseAutoPrefix("auto");
+  assert.equal(plain.valid, true);
+  assert.equal(plain.variant, undefined);
+
+  const coding = parseAutoPrefix("auto/coding");
+  assert.equal(coding.valid, true);
+  assert.equal(coding.variant, "coding");
+
+  const invalid = parseAutoPrefix("not-auto");
+  assert.equal(invalid.valid, false);
+});
+
+// ---------------------------------------------------------------------------
+// Test 8: Reflection fail triggers re-execution loop
+// ---------------------------------------------------------------------------
+
+test("pipeline-combo: reflection fail triggers re-execution with corrected context", async () => {
+  let callCount = 0;
+  const { handler, calls } = createMockHandleChatCore((body) => {
+    callCount++;
+    // First run: execute returns something, reflect fails
+    // Second run (retry): execute returns corrected, reflect passes
+    const messages = body.messages as Array<{ role: string; content: string }>;
+    const systemMsg = messages.find((m) => m.role === "system")?.content || "";
+
+    if (systemMsg.includes("quality reviewer")) {
+      // Reflect stage
+      if (callCount <= 3) {
+        // First run: fail
+        return '{"status":"fail","issues":["missing edge case"],"corrected":"fixed output"}';
+      }
+      // Retry: pass
+      return '{"status":"pass","confirmation":"all good"}';
+    }
+    // Execute stage
+    if (callCount <= 1) return "initial output";
+    return "fixed output";
+  });
+
+  const result = await handlePipelineCombo({
+    body: makeBody([
+      {
+        role: "user",
+        content: "Write a robust sorting algorithm in Python with edge case handling",
+      },
+    ]),
+    combo: makeCombo({ max_reflection_loops: 1 }),
+    handleChatCore: handler,
+    log: mockLog,
+    settings: makeSettings({ max_reflection_loops: 1 }),
+  });
+
+  const pipelineResult = result as Awaited<ReturnType<typeof executePipeline>>;
+
+  // Should have made multiple calls due to reflection retry
+  assert.ok(calls.length >= 3, `Expected >= 3 calls for retry, got ${calls.length}`);
+});
diff --git a/tests/unit/intent-classifier-pipeline.test.ts b/tests/unit/intent-classifier-pipeline.test.ts
new file mode 100644
index 0000000000..75f2299ce6
--- /dev/null
+++ b/tests/unit/intent-classifier-pipeline.test.ts
@@ -0,0 +1,152 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+const {
+  classifyPromptIntent,
+  classifyWithConfig,
+  DEFAULT_INTENT_CONFIG,
+  MATH_KEYWORDS,
+  CREATIVE_KEYWORDS,
+  CODE_KEYWORDS,
+  REASONING_KEYWORDS,
+  SIMPLE_KEYWORDS,
+} = await import("../../open-sse/services/intentClassifier.ts");
+
+// --- Math type detection ---
+
+test("classifyPromptIntent detects math prompts", () => {
+  assert.equal(classifyPromptIntent("calculate the integral of x^2"), "math");
+  assert.equal(classifyPromptIntent("solve this equation: 2x + 3 = 7"), "math");
+  assert.equal(classifyPromptIntent("what is the formula for area of a circle"), "math");
+  assert.equal(classifyPromptIntent("find the derivative of sin(x)"), "math");
+  assert.equal(classifyPromptIntent("compute the matrix multiplication"), "math");
+  assert.equal(classifyPromptIntent("polynomial factorization"), "math");
+});
+
+test("classifyPromptIntent detects math in other languages", () => {
+  assert.equal(classifyPromptIntent("calcular a integral de x^2"), "math"); // PT-BR
+  assert.equal(classifyPromptIntent("resolver esta ecuación"), "math"); // ES
+  assert.equal(classifyPromptIntent("求解这个方程"), "math"); // ZH
+  assert.equal(classifyPromptIntent("この方程式を解いて"), "math"); // JA
+  assert.equal(classifyPromptIntent("вычислить интеграл"), "math"); // RU
+  assert.equal(classifyPromptIntent("gleichung lösen"), "math"); // DE
+  assert.equal(classifyPromptIntent("이 방정식을 풀어"), "math"); // KO
+  assert.equal(classifyPromptIntent("حل هذه المعادلة"), "math"); // AR
+});
+
+// --- Creative type detection ---
+
+test("classifyPromptIntent detects creative prompts", () => {
+  assert.equal(classifyPromptIntent("tell a story about a dragon"), "creative");
+  assert.equal(classifyPromptIntent("compose a poem about the ocean"), "creative");
+  assert.equal(classifyPromptIntent("brainstorm ideas for a blog post"), "creative");
+  assert.equal(classifyPromptIntent("help me with fiction writing"), "creative");
+  assert.equal(classifyPromptIntent("craft marketing copy for a product"), "creative");
+  assert.equal(classifyPromptIntent("draft a screenplay for a short film"), "creative");
+  assert.equal(classifyPromptIntent("compose lyrics for a love song"), "creative");
+});
+
+test("classifyPromptIntent detects creative in other languages", () => {
+  assert.equal(classifyPromptIntent("escrever uma história"), "creative"); // PT-BR
+  assert.equal(classifyPromptIntent("escribir un poema"), "creative"); // ES
+  assert.equal(classifyPromptIntent("写一个故事"), "creative"); // ZH
+  assert.equal(classifyPromptIntent("物語を書いて"), "creative"); // JA
+  assert.equal(classifyPromptIntent("написать рассказ"), "creative"); // RU
+  assert.equal(classifyPromptIntent("eine geschichte schreiben"), "creative"); // DE
+  assert.equal(classifyPromptIntent("이야기를 써 줘"), "creative"); // KO
+  assert.equal(classifyPromptIntent("اكتب قصة"), "creative"); // AR
+});
+
+// --- Priority ordering: code > math > reasoning > creative > simple > medium ---
+
+test("code takes priority over math", () => {
+  assert.equal(classifyPromptIntent("write a function to calculate the integral"), "code");
+  assert.equal(classifyPromptIntent("implement a solve equation algorithm"), "code");
+});
+
+test("math takes priority over reasoning", () => {
+  assert.equal(classifyPromptIntent("calculate and prove this theorem"), "math");
+  assert.equal(classifyPromptIntent("solve the equation step by step"), "math");
+});
+
+test("reasoning takes priority over creative", () => {
+  assert.equal(classifyPromptIntent("prove and analyze this story logically"), "reasoning");
+  assert.equal(classifyPromptIntent("derive the reasoning for a creative hypothesis"), "reasoning");
+});
+
+test("creative takes priority over simple", () => {
+  assert.equal(classifyPromptIntent("compose a story about what is love"), "creative");
+  assert.equal(classifyPromptIntent("creative list of blog ideas"), "creative");
+});
+
+// --- Short/empty prompts → simple ---
+
+test("short prompts with simple keywords classify as simple", () => {
+  assert.equal(classifyPromptIntent("what is gravity"), "simple");
+  assert.equal(classifyPromptIntent("what is photosynthesis"), "simple");
+  assert.equal(classifyPromptIntent("hello how are you"), "simple");
+  assert.equal(classifyPromptIntent("translate hello to french"), "simple");
+});
+
+test("empty or whitespace-only prompts classify as medium", () => {
+  assert.equal(classifyPromptIntent(""), "medium");
+  assert.equal(classifyPromptIntent("   "), "medium");
+});
+
+test("long prompts skip simple classification", () => {
+  const longPrompt =
+    "what is the meaning of life and how should we approach the existential questions that have puzzled philosophers for centuries and continue to challenge our understanding of consciousness and purpose in the universe today and beyond into the future of humanity and what does it mean to be alive in this vast cosmos filled with stars and galaxies and mysteries that we may never fully comprehend no matter how hard we try to understand them through science and reason alone without any help from technology or artificial intelligence or other advanced tools we might develop in the coming decades and centuries ahead of us as a species trying to survive and thrive";
+  assert.equal(classifyPromptIntent(longPrompt), "medium");
+});
+
+// --- classifyWithConfig with extra keywords ---
+
+test("classifyWithConfig detects math with extraMathKeywords", () => {
+  const config = { ...DEFAULT_INTENT_CONFIG, extraMathKeywords: ["trigonometry", "logarithm"] };
+  assert.equal(classifyWithConfig("compute the trigonometry values", config), "math");
+  assert.equal(classifyWithConfig("find the logarithm of 100", config), "math");
+});
+
+test("classifyWithConfig detects creative with extraCreativeKeywords", () => {
+  const config = { ...DEFAULT_INTENT_CONFIG, extraCreativeKeywords: ["sonnet", "haiku"] };
+  assert.equal(classifyWithConfig("craft a sonnet about spring", config), "creative");
+  assert.equal(classifyWithConfig("tell a haiku about rain", config), "creative");
+});
+
+test("classifyWithConfig returns medium when disabled", () => {
+  const config = { ...DEFAULT_INTENT_CONFIG, enabled: false };
+  assert.equal(classifyWithConfig("calculate the integral of x", config), "medium");
+  assert.equal(classifyWithConfig("write a poem about love", config), "medium");
+});
+
+test("classifyWithConfig respects simpleMaxWords override", () => {
+  const config = { ...DEFAULT_INTENT_CONFIG, simpleMaxWords: 10 };
+  const shortPrompt = "what is the meaning of this word";
+  assert.equal(classifyWithConfig(shortPrompt, config), "simple");
+  // Longer prompts with simple keywords should not match when below threshold
+  const longerPrompt =
+    "what is the significance of the american revolution and how did it shape modern democracy in ways that continue to influence politics today across the world and across generations of people who value freedom and self-governance";
+  assert.equal(classifyWithConfig(longerPrompt, config), "medium");
+});
+
+// --- Keyword arrays are exported and non-empty ---
+
+test("MATH_KEYWORDS is a non-empty readonly array", () => {
+  assert.ok(Array.isArray(MATH_KEYWORDS));
+  assert.ok(MATH_KEYWORDS.length > 0);
+  assert.ok(MATH_KEYWORDS.includes("calculate"));
+  assert.ok(MATH_KEYWORDS.includes("equation"));
+});
+
+test("CREATIVE_KEYWORDS is a non-empty readonly array", () => {
+  assert.ok(Array.isArray(CREATIVE_KEYWORDS));
+  assert.ok(CREATIVE_KEYWORDS.length > 0);
+  assert.ok(CREATIVE_KEYWORDS.includes("story"));
+  assert.ok(CREATIVE_KEYWORDS.includes("poem"));
+});
+
+test("existing keyword arrays are still present", () => {
+  assert.ok(CODE_KEYWORDS.length > 0);
+  assert.ok(REASONING_KEYWORDS.length > 0);
+  assert.ok(SIMPLE_KEYWORDS.length > 0);
+});
diff --git a/tests/unit/pipeline-router.test.ts b/tests/unit/pipeline-router.test.ts
new file mode 100644
index 0000000000..9e0b69ef0d
--- /dev/null
+++ b/tests/unit/pipeline-router.test.ts
@@ -0,0 +1,251 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  handlePipelineCombo,
+  FITNESS_TIERS,
+} from "../../open-sse/services/autoCombo/pipelineRouter.ts";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeLogger() {
+  const msgs: string[] = [];
+  return {
+    info: (...args: unknown[]) => msgs.push(args.map(String).join(" ")),
+    warn: (...args: unknown[]) => msgs.push(args.map(String).join(" ")),
+    error: (...args: unknown[]) => msgs.push(args.map(String).join(" ")),
+    msgs,
+  };
+}
+
+function makeBody(messages: Array<{ role: string; content: string }>, stream = false) {
+  return { messages, model: "gpt-4o", stream };
+}
+
+function makeCombo(overrides: Record<string, unknown> = {}) {
+  return {
+    name: "test-combo",
+    models: ["gpt-4o"],
+    strategy: "priority",
+    config: {
+      pipeline_enabled: true,
+      ...overrides,
+    },
+  };
+}
+
+function makeSettings(overrides: Record<string, unknown> = {}) {
+  return {
+    pipeline_enabled: true,
+    skip_pipeline_for_tokens_under: 50,
+    max_reflection_loops: 1,
+    ...overrides,
+  };
+}
+
+// A handleChatCore that returns a fake OpenAI-style response
+function makeHandleChatCore(responseText = "test response", status = 200) {
+  return async (body: Record<string, unknown>) => {
+    if (body.stream) {
+      // Return a fake streaming response
+      const encoder = new TextEncoder();
+      const stream = new ReadableStream({
+        start(controller) {
+          const chunk = `data: ${JSON.stringify({
+            choices: [{ delta: { content: responseText }, index: 0 }],
+          })}\n\ndata: [DONE]\n`;
+          controller.enqueue(encoder.encode(chunk));
+          controller.close();
+        },
+      });
+      return new Response(stream, { status, headers: { "content-type": "text/event-stream" } });
+    }
+    // Non-streaming: return buffered JSON
+    return new Response(
+      JSON.stringify({
+        choices: [{ message: { role: "assistant", content: responseText }, index: 0 }],
+      }),
+      { status, headers: { "content-type": "application/json" } }
+    );
+  };
+}
+
+// ---------------------------------------------------------------------------
+// FITNESS_TIERS tests
+// ---------------------------------------------------------------------------
+
+test("FITNESS_TIERS has best-reasoning, cheapest, moderate tiers", () => {
+  assert.ok(FITNESS_TIERS["best-reasoning"]);
+  assert.ok(FITNESS_TIERS.cheapest);
+  assert.ok(FITNESS_TIERS.moderate);
+  assert.equal(FITNESS_TIERS["best-reasoning"].minFitness, 0.85);
+  assert.equal(FITNESS_TIERS.cheapest.maxFitness, 0.75);
+  assert.equal(FITNESS_TIERS.moderate.minFitness, 0.6);
+  assert.equal(FITNESS_TIERS.moderate.maxFitness, 0.9);
+});
+
+// ---------------------------------------------------------------------------
+// pipeline_enabled: false disables pipeline
+// ---------------------------------------------------------------------------
+
+test("handlePipelineCombo throws PIPELINE_DISABLED when combo pipeline_enabled is false", async () => {
+  const log = makeLogger();
+  const body = makeBody([{ role: "user", content: "Write a function to sort an array" }]);
+  const combo = makeCombo({ pipeline_enabled: false });
+  const settings = makeSettings();
+
+  await assert.rejects(
+    () =>
+      handlePipelineCombo({
+        body,
+        combo,
+        handleChatCore: makeHandleChatCore(),
+        log,
+        settings,
+      }),
+    { message: "PIPELINE_DISABLED" }
+  );
+});
+
+test("handlePipelineCombo throws PIPELINE_DISABLED when settings pipeline_enabled is false", async () => {
+  const log = makeLogger();
+  const body = makeBody([{ role: "user", content: "Write a function to sort an array" }]);
+  // Combo without pipeline_enabled so settings controls the behavior
+  const combo = { name: "test-combo", models: ["gpt-4o"], strategy: "priority", config: {} };
+  const settings = makeSettings({ pipeline_enabled: false }); // settings disables it
+
+  await assert.rejects(
+    () =>
+      handlePipelineCombo({
+        body,
+        combo,
+        handleChatCore: makeHandleChatCore(),
+        log,
+        settings,
+      }),
+    { message: "PIPELINE_DISABLED" }
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Token threshold skip
+// ---------------------------------------------------------------------------
+
+test("handlePipelineCombo throws PIPELINE_TOKEN_THRESHOLD for short prompts", async () => {
+  const log = makeLogger();
+  // "hi" = ~1 token, well under threshold of 50
+  const body = makeBody([{ role: "user", content: "hi" }]);
+  const combo = makeCombo();
+  const settings = makeSettings({ skip_pipeline_for_tokens_under: 50 });
+
+  await assert.rejects(
+    () =>
+      handlePipelineCombo({
+        body,
+        combo,
+        handleChatCore: makeHandleChatCore(),
+        log,
+        settings,
+      }),
+    { message: "PIPELINE_TOKEN_THRESHOLD" }
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Pipeline triggers for code intent
+// ---------------------------------------------------------------------------
+
+test("handlePipelineCombo triggers pipeline for code prompts", async () => {
+  const log = makeLogger();
+  // Long enough to pass token threshold (~200 chars ≈ 50 tokens)
+  const longCodePrompt =
+    "Write a function to sort an array using quicksort algorithm in TypeScript with proper type annotations and error handling for edge cases including empty arrays null values and duplicate elements with comprehensive JSDoc documentation";
+  const body = makeBody([{ role: "user", content: longCodePrompt }]);
+  const combo = makeCombo();
+  const settings = makeSettings();
+
+  const result = await handlePipelineCombo({
+    body,
+    combo,
+    handleChatCore: makeHandleChatCore("function quicksort() {}"),
+    log,
+    settings,
+  });
+
+  // Should return a PipelineResult (not a Response)
+  assert.ok(result !== null);
+  assert.ok("text" in result, "Result should have a text field");
+  assert.ok("stages" in result, "Result should have a stages field");
+  assert.ok("fallback" in result, "Result should have a fallback field");
+  assert.ok("reflectVerdict" in result, "Result should have a reflectVerdict field");
+  assert.ok(Array.isArray((result as Record<string, unknown>).stages));
+});
+
+// ---------------------------------------------------------------------------
+// stageExecutor streaming behavior
+// ---------------------------------------------------------------------------
+
+test("handlePipelineCombo final stage streams when body.stream is true", async () => {
+  const log = makeLogger();
+  const longPrompt =
+    "Explain the theory of relativity in detail with mathematical proofs and step by step derivation of the equations involved in special relativity including Lorentz transformations time dilation and length contraction with comprehensive examples";
+  const body = makeBody(
+    [{ role: "user", content: longPrompt }],
+    true // stream = true
+  );
+  const combo = makeCombo();
+  const settings = makeSettings();
+
+  const result = await handlePipelineCombo({
+    body,
+    combo,
+    handleChatCore: makeHandleChatCore("relativity explanation"),
+    log,
+    settings,
+  });
+
+  // Result should either be a PipelineResult or a Response
+  // For simple/medium intents with single execute stage, it returns PipelineResult
+  // because the pipeline engine buffers internally
+  assert.ok(result !== null);
+});
+
+// ---------------------------------------------------------------------------
+// Intent classification integration
+// ---------------------------------------------------------------------------
+
+test("handlePipelineCombo classifies reasoning prompts correctly", async () => {
+  const log = makeLogger();
+  const longReasoningPrompt =
+    "Prove the convergence of this series step by step using mathematical induction and formal logic derivation for the given theorem including all edge cases and boundary conditions with detailed explanations";
+  const body = makeBody([{ role: "user", content: longReasoningPrompt }]);
+  const combo = makeCombo();
+  const settings = makeSettings();
+
+  const result = await handlePipelineCombo({
+    body,
+    combo,
+    handleChatCore: makeHandleChatCore("proof output"),
+    log,
+    settings,
+  });
+
+  assert.ok(result);
+  assert.ok("stages" in result);
+  // Reasoning task gets ["execute", "reflect"] stages
+  const stages = (result as PipelineResult).stages;
+  assert.ok(stages.length >= 1, "Should have at least execute stage");
+});
+
+// ---------------------------------------------------------------------------
+// Type for test result access
+// ---------------------------------------------------------------------------
+
+interface PipelineResult {
+  text: string;
+  stages: Array<{ stage: string; text: string; skipped?: boolean }>;
+  fallback: boolean;
+  reflectVerdict: "pass" | "fail" | null;
+}
diff --git a/tests/unit/pipeline.test.ts b/tests/unit/pipeline.test.ts
new file mode 100644
index 0000000000..058990084d
--- /dev/null
+++ b/tests/unit/pipeline.test.ts
@@ -0,0 +1,381 @@
+/**
+ * Pipeline Engine Tests
+ *
+ * Tests for the smart auto-pipeline engine:
+ * - Stage sequencing per task type
+ * - Context threading (plan → execute → reflect → fix)
+ * - Reflect JSON parsing (pass/fail/ambiguous)
+ * - Graceful fallback on stage failure
+ * - Simple task single stage
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  buildPipelineConfig,
+  executePipeline,
+  parseReflectJson,
+} from "../../src/domain/pipeline.ts";
+import type { StageExecutor, StageExecutorResult } from "../../src/domain/pipeline.ts";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeExecutor(responses: string[]): StageExecutor {
+  let callIndex = 0;
+  return async (): Promise<StageExecutorResult> => {
+    const text = responses[callIndex] ?? "";
+    callIndex++;
+    return { text };
+  };
+}
+
+function makeExecutorWithMetrics(responses: StageExecutorResult[]): StageExecutor {
+  let callIndex = 0;
+  return async (): Promise<StageExecutorResult> => {
+    const result = responses[callIndex] ?? { text: "" };
+    callIndex++;
+    return result;
+  };
+}
+
+function makeFailingExecutor(failAt: number, fallbackText = ""): StageExecutor {
+  let callIndex = 0;
+  return async (): Promise<StageExecutorResult> => {
+    if (callIndex === failAt) {
+      callIndex++;
+      throw new Error("Stage failed");
+    }
+    callIndex++;
+    return { text: fallbackText };
+  };
+}
+
+const PASS_JSON = '{"status":"pass","confirmation":"Output is correct."}';
+const FAIL_JSON = '{"status":"fail","issues":["Missing detail"],"corrected":"Fixed output."}';
+
+// ---------------------------------------------------------------------------
+// buildPipelineConfig
+// ---------------------------------------------------------------------------
+
+describe("buildPipelineConfig", () => {
+  it("should create plan→execute→reflect→fix stages for code tasks", () => {
+    const config = buildPipelineConfig("write a function", "code");
+    const names = config.stages.map((s) => s.name);
+    assert.deepEqual(names, ["plan", "execute", "reflect", "fix"]);
+  });
+
+  it("should create execute→reflect stages for math tasks", () => {
+    const config = buildPipelineConfig("solve 2+2", "math");
+    const names = config.stages.map((s) => s.name);
+    assert.deepEqual(names, ["execute", "reflect"]);
+  });
+
+  it("should create execute→reflect stages for reasoning tasks", () => {
+    const config = buildPipelineConfig("explain relativity", "reasoning");
+    const names = config.stages.map((s) => s.name);
+    assert.deepEqual(names, ["execute", "reflect"]);
+  });
+
+  it("should create execute→reflect stages for creative tasks", () => {
+    const config = buildPipelineConfig("write a poem", "creative");
+    const names = config.stages.map((s) => s.name);
+    assert.deepEqual(names, ["execute", "reflect"]);
+  });
+
+  it("should create single execute stage for medium tasks", () => {
+    const config = buildPipelineConfig("summarize this", "medium");
+    const names = config.stages.map((s) => s.name);
+    assert.deepEqual(names, ["execute"]);
+  });
+
+  it("should create single execute stage for simple tasks", () => {
+    const config = buildPipelineConfig("hello", "simple");
+    const names = config.stages.map((s) => s.name);
+    assert.deepEqual(names, ["execute"]);
+  });
+
+  it("should include the original request in config", () => {
+    const config = buildPipelineConfig("test request", "simple");
+    assert.equal(config.request, "test request");
+  });
+
+  it("should include taskType in config", () => {
+    const config = buildPipelineConfig("test", "code");
+    assert.equal(config.taskType, "code");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseReflectJson
+// ---------------------------------------------------------------------------
+
+describe("parseReflectJson", () => {
+  it("should parse a pass response", () => {
+    const result = parseReflectJson(PASS_JSON);
+    assert.deepEqual(result, { status: "pass", confirmation: "Output is correct." });
+  });
+
+  it("should parse a fail response", () => {
+    const result = parseReflectJson(FAIL_JSON);
+    assert.deepEqual(result, {
+      status: "fail",
+      issues: ["Missing detail"],
+      corrected: "Fixed output.",
+    });
+  });
+
+  it("should parse JSON inside markdown code blocks", () => {
+    const wrapped = "```json\n" + PASS_JSON + "\n```";
+    const result = parseReflectJson(wrapped);
+    assert.deepEqual(result, { status: "pass", confirmation: "Output is correct." });
+  });
+
+  it("should parse JSON embedded in prose", () => {
+    const prose = "Here is my evaluation:\n" + FAIL_JSON + "\nDone.";
+    const result = parseReflectJson(prose);
+    assert.equal(result?.status, "fail");
+  });
+
+  it("should return null for empty string", () => {
+    assert.equal(parseReflectJson(""), null);
+  });
+
+  it("should return null for non-JSON text", () => {
+    assert.equal(parseReflectJson("This looks good to me!"), null);
+  });
+
+  it("should return null for invalid JSON", () => {
+    assert.equal(parseReflectJson("{broken json"), null);
+  });
+
+  it("should return null for JSON with unknown status", () => {
+    assert.equal(parseReflectJson('{"status":"maybe","notes":"unsure"}'), null);
+  });
+
+  it("should return null for pass without confirmation string", () => {
+    assert.equal(parseReflectJson('{"status":"pass"}'), null);
+  });
+
+  it("should handle fail with missing issues array", () => {
+    const result = parseReflectJson('{"status":"fail","corrected":"fixed"}');
+    assert.deepEqual(result, { status: "fail", issues: [], corrected: "fixed" });
+  });
+
+  it("should handle fail with missing corrected field", () => {
+    const result = parseReflectJson('{"status":"fail","issues":["bad"]}');
+    assert.deepEqual(result, { status: "fail", issues: ["bad"], corrected: "" });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// executePipeline — stage sequencing
+// ---------------------------------------------------------------------------
+
+describe("executePipeline — stage sequencing", () => {
+  it("should run single execute stage for simple tasks", async () => {
+    const config = buildPipelineConfig("hello", "simple");
+    const executor = makeExecutor(["Hello!"]);
+    const result = await executePipeline(config, executor);
+
+    assert.equal(result.stages.length, 1);
+    assert.equal(result.stages[0].stage, "execute");
+    assert.equal(result.text, "Hello!");
+    assert.equal(result.fallback, false);
+  });
+
+  it("should run execute→reflect for math tasks", async () => {
+    const config = buildPipelineConfig("2+2", "math");
+    const executor = makeExecutor(["4", PASS_JSON]);
+    const result = await executePipeline(config, executor);
+
+    assert.equal(result.stages.length, 2);
+    assert.equal(result.stages[0].stage, "execute");
+    assert.equal(result.stages[1].stage, "reflect");
+    assert.equal(result.reflectVerdict, "pass");
+  });
+
+  it("should run full plan→execute→reflect→fix for code tasks", async () => {
+    const config = buildPipelineConfig("write fib", "code");
+    const executor = makeExecutor(["Step 1: write function", "function fib(){}", PASS_JSON]);
+    const result = await executePipeline(config, executor);
+
+    assert.equal(result.stages.length, 4);
+    assert.equal(result.stages[0].stage, "plan");
+    assert.equal(result.stages[1].stage, "execute");
+    assert.equal(result.stages[2].stage, "reflect");
+    assert.equal(result.stages[3].stage, "fix");
+    assert.equal(result.stages[3].skipped, true); // reflect passed → fix skipped
+  });
+});
+
+// ---------------------------------------------------------------------------
+// executePipeline — context threading
+// ---------------------------------------------------------------------------
+
+describe("executePipeline — context threading", () => {
+  it("should thread plan output into execute context", async () => {
+    const receivedMessages: string[][] = [];
+    const executor: StageExecutor = async (args) => {
+      receivedMessages.push(args.messages.map((m) => m.content));
+      if (receivedMessages.length === 1) return { text: "PLAN_OUTPUT" };
+      return { text: "done" };
+    };
+
+    const config = buildPipelineConfig("test request", "medium");
+    await executePipeline(config, executor);
+
+    // Medium only has execute, so only one call
+    assert.equal(receivedMessages.length, 1);
+    // The execute prompt should contain the original request
+    assert.ok(receivedMessages[0].some((c) => c.includes("test request")));
+  });
+
+  it("should thread execution_response into reflect prompt", async () => {
+    const receivedMessages: string[][] = [];
+    const executor: StageExecutor = async (args) => {
+      receivedMessages.push(args.messages.map((m) => m.content));
+      if (receivedMessages.length === 1) return { text: "EXECUTION_RESULT" };
+      return { text: PASS_JSON };
+    };
+
+    const config = buildPipelineConfig("test request", "math");
+    await executePipeline(config, executor);
+
+    // Reflect is the 2nd call
+    assert.equal(receivedMessages.length, 2);
+    const reflectUserMsg = receivedMessages[1].find((c) => c.includes("Execution output"));
+    assert.ok(reflectUserMsg, "reflect should reference execution output");
+    assert.ok(reflectUserMsg!.includes("EXECUTION_RESULT"));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// executePipeline — reflect pass/fail
+// ---------------------------------------------------------------------------
+
+describe("executePipeline — reflect pass/fail", () => {
+  it("should skip fix stage when reflect passes (code task)", async () => {
+    const config = buildPipelineConfig("write fib", "code");
+    const executor = makeExecutor(["plan", "function fib(){}", PASS_JSON]);
+    const result = await executePipeline(config, executor);
+
+    assert.equal(result.reflectVerdict, "pass");
+    const fixStage = result.stages.find((s) => s.stage === "fix");
+    assert.ok(fixStage);
+    assert.equal(fixStage!.skipped, true);
+  });
+
+  it("should run fix stage when reflect fails", async () => {
+    const config = buildPipelineConfig("write fib", "code");
+    const executor = makeExecutor(["plan", "function fib(){}", FAIL_JSON, "function fib(n){}"]);
+    const result = await executePipeline(config, executor);
+
+    assert.equal(result.reflectVerdict, "fail");
+    const fixStage = result.stages.find((s) => s.stage === "fix");
+    assert.ok(fixStage);
+    assert.equal(fixStage!.skipped, undefined);
+    assert.equal(fixStage!.text, "function fib(n){}");
+  });
+
+  it("should use corrected output from fail JSON when fix produces output", async () => {
+    const config = buildPipelineConfig("write fib", "code");
+    const executor = makeExecutor(["plan", "bad output", FAIL_JSON, "fixed output"]);
+    const result = await executePipeline(config, executor);
+
+    assert.equal(result.text, "fixed output");
+  });
+
+  it("should treat parse failure as fail (conservative)", async () => {
+    const config = buildPipelineConfig("test", "math");
+    const executor = makeExecutor(["42", "Looks good to me!"]);
+    const result = await executePipeline(config, executor);
+
+    assert.equal(result.reflectVerdict, "fail");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// executePipeline — fallback on stage failure
+// ---------------------------------------------------------------------------
+
+describe("executePipeline — fallback on stage failure", () => {
+  it("should set fallback=true when a stage throws", async () => {
+    const config = buildPipelineConfig("test", "code");
+    const executor = makeFailingExecutor(0); // plan fails
+    const result = await executePipeline(config, executor);
+
+    assert.equal(result.fallback, true);
+  });
+
+  it("should return best available output on failure", async () => {
+    const config = buildPipelineConfig("test", "code");
+    // Plan succeeds, execute fails
+    const executor = makeFailingExecutor(1, "partial");
+    const result = await executePipeline(config, executor);
+
+    assert.equal(result.fallback, true);
+    // Should still have plan output
+    const planStage = result.stages.find((s) => s.stage === "plan");
+    assert.ok(planStage);
+    assert.equal(planStage!.error, undefined);
+  });
+
+  it("should record error message in stage result", async () => {
+    const config = buildPipelineConfig("test", "simple");
+    const executor = makeFailingExecutor(0);
+    const result = await executePipeline(config, executor);
+
+    assert.equal(result.stages[0].error, "Stage failed");
+    assert.equal(result.stages[0].text, "");
+  });
+
+  it("should stop execution after a stage fails", async () => {
+    let callCount = 0;
+    const executor: StageExecutor = async () => {
+      callCount++;
+      if (callCount === 2) throw new Error("Stage 2 failed");
+      return { text: "ok" };
+    };
+
+    const config = buildPipelineConfig("test", "code");
+    await executePipeline(config, executor);
+
+    // Should have stopped after execute (stage 2)
+    assert.ok(callCount <= 2, `Expected <=2 calls, got ${callCount}`);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// executePipeline — metrics
+// ---------------------------------------------------------------------------
+
+describe("executePipeline — metrics", () => {
+  it("should capture latencyMs per stage", async () => {
+    const config = buildPipelineConfig("test", "simple");
+    const executor = makeExecutorWithMetrics([
+      { text: "result", provider: "openai", inputTokens: 100, outputTokens: 50 },
+    ]);
+    const result = await executePipeline(config, executor);
+
+    // Pipeline measures real wall-clock latency (>=0), not executor's internal timing
+    assert.ok(result.stages[0].latencyMs >= 0, "latencyMs should be non-negative");
+    assert.equal(result.stages[0].provider, "openai");
+    assert.equal(result.stages[0].inputTokens, 100);
+    assert.equal(result.stages[0].outputTokens, 50);
+  });
+
+  it("should capture provider info when available", async () => {
+    const config = buildPipelineConfig("test", "math");
+    const executor = makeExecutorWithMetrics([
+      { text: "42", provider: "anthropic" },
+      { text: PASS_JSON, provider: "anthropic" },
+    ]);
+    const result = await executePipeline(config, executor);
+
+    assert.equal(result.stages[0].provider, "anthropic");
+    assert.equal(result.stages[1].provider, "anthropic");
+  });
+});