diff.txt

diff --git a/README.md b/README.md
index eb1581f..cc00dfd 100644
--- a/README.md
+++ b/README.md
@@ -20,23 +20,23 @@
   <a href="https://github.com/AlGhozaliRamadhan">
     <img src="https://img.shields.io/badge/Author-AGR-111111?style=flat"/>
   </a>
-  <img src="https://img.shields.io/badge/version-2.0.0-brightgreen?style=flat"/>
+  <img src="https://img.shields.io/badge/version-2.1.0-brightgreen?style=flat"/>
 </p>
 
 ---
 
 ## What is BOZ?
 
-**BOZ (Behavioral Outlook Zone) v2** is an open-source, full-stack AI market analysis dashboard. It fuses real-time price data, technical indicators, multi-timeframe confluence, macro context, news, and crowd sentiment into structured, actionable intelligence complete with entry, target, stop, and risk/reward.
+**BOZ (Behavioral Outlook Zone) v2.1** is an open-source, full-stack AI market analysis dashboard. It fuses real-time price data, technical indicators, multi-timeframe confluence, macro context, news, and crowd sentiment into structured, actionable intelligence complete with entry, target, stop, and risk/reward.
 
-Four core modules are available directly from the sleek web interface:
+Analysis is now fully consolidated into a sleek, unified text-based Omni-Agent Chat interface. The UI relies entirely on natural conversational prompts and slash commands:
 
-| Mode | Horizon | Focus |
-|---|---|---|
-| **Market Intraday** | 2ΓÇô6 hours | MTF confluence, momentum, volatility (searchable ticker/asset) |
-| **Market Long-term** | 3ΓÇô12 months | SMA structure, 52-week context, trend integrity (searchable ticker/asset) |
-| **News Intel Analyzer** | Cross-asset | Multi-source news aggregation, cross-asset opportunity detection |
-| **Interactive Chat Agent** | Adaptive | Autonomous conversational agent with persistent memory, concurrent tool execution, and sub-agent delegation. |
+| Feature | Description |
+|---|---|
+| **Unified Omni-Agent** | The core borderless interface for BOZ. All analysis runs through a single immersive chat terminal without clunky cards. |
+| **Intraday Commands** | Use `/intraday [ticker]` for 2-6 hour momentum, volatility, and MTF confluence analysis returned in crisp markdown. |
+| **Long-term Commands** | Use `/longterm [ticker]` for 3-12 month SMA structure and 52-week context. |
+| **News Intel** | Use `/newsintel` for cross-asset multi-source news aggregation and crowd sentiment scoring. |
 
 Three AI providers are supported, configurable via the Settings page or `.env`:
 
diff --git a/package.json b/package.json
index 054d10c..3d1d94e 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "boz",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Open-source AI market analyzer that combines real-time data, technical indicators, macro context, news, and sentiment into structured insights.",
   "main": "dist/main.js",
   "bin": {
diff --git a/src/app/api/analyze/intraday/verdict/route.ts b/src/app/api/analyze/intraday/verdict/route.ts
new file mode 100644
index 0000000..8678f0c
--- /dev/null
+++ b/src/app/api/analyze/intraday/verdict/route.ts
@@ -0,0 +1,75 @@
+import { NextRequest } from 'next/server';
+import { jsonResponse, errorResponse, parseBody } from '@/app/lib/api-helpers';
+import { AIService } from '@/services/ai/ai.service';
+import { buildTradeLevels } from '@/shared/trade-levels';
+
+export async function POST(request: NextRequest) {
+  try {
+    const { ticker, marketData, macro, sentiment, chartPatterns } = await parseBody<{ 
+      ticker: string, 
+      marketData: any, 
+      macro: any, 
+      sentiment: any, 
+      chartPatterns: any 
+    }>(request);
+    
+    if (!ticker) return errorResponse('Ticker is required', 400);
+    if (!marketData || !marketData.lastCandleFull) return errorResponse('Market data missing', 400);
+
+    const aiService = new AIService();
+    const prompt = buildIntradayPrompt(ticker, marketData.lastCandleFull, macro, sentiment, chartPatterns);
+    const verdict = await aiService.analyze(prompt);
+
+    let tradeLevels = null;
+    if (verdict.status === 'ok') {
+      const action = verdict.prediction === 'UP' ? 'BUY' : verdict.prediction === 'DOWN' ? 'SELL' : 'WATCH';
+      tradeLevels = buildTradeLevels(marketData.lastCandleFull.close, action as 'BUY' | 'SELL' | 'WATCH', verdict.confidence, '');
+    }
+
+    return jsonResponse({
+      verdict,
+      tradeLevels,
+    });
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : 'Unknown error';
+    return errorResponse(msg);
+  }
+}
+
+function buildIntradayPrompt(
+  ticker: string,
+  last: any,
+  macro: any,
+  sentiment: any,
+  chartPatterns: any,
+): string {
+  const fmt = (v: number | null | undefined, decimals = 2) =>
+    v != null ? v.toFixed(decimals) : 'N/A';
+
+  return `Analyze ${ticker} for intraday trading (2-6 hour horizon).
+
+Current Price: $${fmt(last.close)}
+RSI(14): ${fmt(last.RSI, 1)}
+MACD: ${fmt(last.MACD, 4)} / Signal: ${fmt(last.MACD_Signal, 4)}
+SMA20: ${fmt(last.SMA_20)} | SMA50: ${fmt(last.SMA_50)}
+ATR: ${fmt(last.ATR)} (${fmt(last.ATR_Percent)}%)
+BB Width: ${fmt(last.BB_Width)}
+Volume Ratio: ${fmt(last.Volume_Ratio)}
+OBV Trend: ${last.OBV_Trend ? 'Bullish' : 'Bearish'}
+
+Macro Context:
+- Market Regime: ${macro.market_regime}
+- Risk Sentiment: ${macro.risk_sentiment}
+- SPY Correlation: ${macro.sp500_correlation}
+- VIX: ${macro.vix_level ?? 'N/A'}
+
+Sentiment:
+- Fear & Greed: ${sentiment.fear_greed?.value ?? 'N/A'} (${sentiment.fear_greed?.label ?? 'N/A'})
+- StockTwits Bull Ratio: ${sentiment.stocktwits_data?.bull_ratio != null ? sentiment.stocktwits_data.bull_ratio.toFixed(0) + '%' : 'N/A'}
+
+Chart Patterns: ${chartPatterns.patterns?.join(', ') || 'None'}
+Candle Pattern: ${chartPatterns.candle_patterns?.summary_text || 'None'}
+Fibonacci Position: ${chartPatterns.fibonacci_position || 'N/A'}
+Nearest Support: $${fmt(chartPatterns.nearest_support)}
+Nearest Resistance: $${fmt(chartPatterns.nearest_resistance)}`;
+}
diff --git a/src/app/api/analyze/longterm/verdict/route.ts b/src/app/api/analyze/longterm/verdict/route.ts
new file mode 100644
index 0000000..bc74cd4
--- /dev/null
+++ b/src/app/api/analyze/longterm/verdict/route.ts
@@ -0,0 +1,90 @@
+import { NextRequest } from 'next/server';
+import { jsonResponse, errorResponse, parseBody } from '@/app/lib/api-helpers';
+import { AIService } from '@/services/ai/ai.service';
+import { buildTradeLevels } from '@/shared/trade-levels';
+
+export async function POST(request: NextRequest) {
+  try {
+    const { ticker, marketData, macro, sentiment, chartPatterns } = await parseBody<{ 
+      ticker: string, 
+      marketData: any, 
+      macro: any, 
+      sentiment: any, 
+      chartPatterns: any 
+    }>(request);
+    
+    if (!ticker) return errorResponse('Ticker is required', 400);
+    if (!marketData || !marketData.lastCandleFull) return errorResponse('Market data missing', 400);
+
+    const context52w = {
+      high52w: marketData.fiftyTwoWeekHigh,
+      low52w: marketData.fiftyTwoWeekLow,
+      from52wHigh: marketData.from52wHigh,
+      from52wLow: marketData.from52wLow
+    };
+
+    const aiService = new AIService();
+    const prompt = buildLongtermPrompt(ticker, marketData.lastCandleFull, macro, sentiment, chartPatterns, context52w);
+    const verdict = await aiService.analyze(prompt);
+
+    let tradeLevels = null;
+    if (verdict.status === 'ok') {
+      const action = verdict.prediction === 'UP' ? 'BUY' : verdict.prediction === 'DOWN' ? 'SELL' : 'WATCH';
+      tradeLevels = buildTradeLevels(marketData.lastCandleFull.close, action as 'BUY' | 'SELL' | 'WATCH', verdict.confidence, '');
+    }
+
+    return jsonResponse({
+      verdict,
+      tradeLevels,
+    });
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : 'Unknown error';
+    return errorResponse(msg);
+  }
+}
+
+function buildLongtermPrompt(
+  ticker: string,
+  last: any,
+  macro: any,
+  sentiment: any,
+  chartPatterns: any,
+  context52w: { high52w: number; low52w: number; from52wHigh: number; from52wLow: number },
+): string {
+  const fmt = (v: number | null | undefined, decimals = 2) =>
+    v != null ? v.toFixed(decimals) : 'N/A';
+
+  return `Analyze ${ticker} for long-term positioning (3-12 month investment horizon).
+
+Current Price: $${fmt(last.close)}
+RSI(14): ${fmt(last.RSI, 1)}
+MACD: ${fmt(last.MACD, 4)} / Signal: ${fmt(last.MACD_Signal, 4)}
+SMA20: ${fmt(last.SMA_20)} | SMA50: ${fmt(last.SMA_50)} | SMA200: ${fmt(last.SMA_200)}
+ATR: ${fmt(last.ATR)} (${fmt(last.ATR_Percent)}%)
+BB Width: ${fmt(last.BB_Width)}
+Volume Ratio: ${fmt(last.Volume_Ratio)}
+OBV Trend: ${last.OBV_Trend ? 'Bullish' : 'Bearish'}
+
+52-Week Context:
+- 52w High: $${fmt(context52w.high52w)} (${fmt(context52w.from52wHigh, 1)}% away)
+- 52w Low: $${fmt(context52w.low52w)} (+${fmt(context52w.from52wLow, 1)}% above)
+
+Macro Context:
+- Market Regime: ${macro.market_regime}
+- Risk Sentiment: ${macro.risk_sentiment}
+- SPY Correlation: ${macro.sp500_correlation}
+- VIX: ${macro.vix_level ?? 'N/A'}
+- 10Y Treasury Yield: ${macro.tnx_yield != null ? macro.tnx_yield.toFixed(2) + '%' : 'N/A'}
+
+Sentiment:
+- Fear & Greed: ${sentiment.fear_greed?.value ?? 'N/A'} (${sentiment.fear_greed?.label ?? 'N/A'})
+- StockTwits Bull Ratio: ${sentiment.stocktwits_data?.bull_ratio != null ? sentiment.stocktwits_data.bull_ratio.toFixed(0) + '%' : 'N/A'}
+
+Chart Patterns (Daily): ${chartPatterns.patterns?.join(', ') || 'None'}
+Candle Pattern: ${chartPatterns.candle_patterns?.summary_text || 'None'}
+Fibonacci Position: ${chartPatterns.fibonacci_position || 'N/A'}
+Support: $${fmt(chartPatterns.nearest_support)}
+Resistance: $${fmt(chartPatterns.nearest_resistance)}
+
+Focus on: secular trends, institutional accumulation/distribution, macro cycle positioning, and multi-month risk/reward setups. Provide target_price for 3-6 month horizon.`;
+}
diff --git a/src/app/api/chat/chat.engine.ts b/src/app/api/chat/chat.engine.ts
new file mode 100644
index 0000000..0293c31
--- /dev/null
+++ b/src/app/api/chat/chat.engine.ts
@@ -0,0 +1,912 @@
+// ΓöÇΓöÇΓöÇ chat.engine.ts ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+// Server-side chat engine for BOZ web app.
+// Brings CLI-level intelligence to the browser: tool calling, evidence ledger,
+// sub-agent delegation, two-pass reasoning, model fallback, and SSE streaming.
+
+import { LLMAdapter } from '@/services/ai/llm.adapter';
+import { config } from '@/config/config';
+import { yahooFinance } from '@/services/market/yahoo.service';
+import { newsFetchService } from '@/services/news/news.fetch.service';
+import { SentimentService } from '@/services/market/sentiment.service';
+import { webSearchService } from '@/services/search/web.search.service';
+import { idxScannerService } from '@/services/market/idx.scanner.service';
+import { memoryService } from '@/services/memory.service';
+import { resolveSymbolIDX } from '@/shared/market-constants';
+import { GITHUB_MODELS } from '@/config/github.config';
+import { NVIDIA_MODELS } from '@/config/nvidia.config';
+import type { LLMMessage, RawToolCall } from '@/types/llm.types';
+
+// ΓöÇΓöÇΓöÇ Types ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+
+export interface ChatEvent {
+  type: 'tool_start' | 'tool_result' | 'reasoning_start' | 'token' | 'done' | 'error';
+  data: any;
+}
+
+interface LedgerEntry {
+  step:    number;
+  tool:    string;
+  fact:    string;
+  quality: 'confirmed' | 'partial' | 'empty';
+}
+
+interface ParsedToolCall {
+  name:      string;
+  arguments: Record<string, any>;
+}
+
+// ΓöÇΓöÇΓöÇ Constants ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+
+const MAX_TOOL_ROUNDS = 15;
+const MAX_HISTORY_MESSAGES = 14;
+
+// ΓöÇΓöÇΓöÇ WebChatEngine ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+
+export class WebChatEngine {
+  private llm = new LLMAdapter();
+  private sentimentService = new SentimentService();
+
+  // ΓöÇΓöÇΓöÇ Main entry point ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+  // Yields streaming ChatEvent objects for the SSE route to emit.
+
+  async *run(params: {
+    message: string;
+    history?: Array<{ role: 'user' | 'assistant'; content: string }>;
+  }): AsyncGenerator<ChatEvent> {
+    const { message, history } = params;
+
+    // ΓöÇΓöÇ Build message list ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+    const messages: LLMMessage[] = [
+      { role: 'system', content: this.buildSystemPrompt() },
+    ];
+
+    if (history?.length) {
+      for (const msg of history.slice(-MAX_HISTORY_MESSAGES)) {
+        messages.push({ role: msg.role, content: msg.content });
+      }
+    }
+
+    messages.push({ role: 'user', content: message });
+
+    // ΓöÇΓöÇ First AI call ΓÇö with tools ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+    let aiMessage: LLMMessage;
+    try {
+      aiMessage = await this.callWithFallback(messages, this.getToolDefinitions(), 0.3);
+    } catch (err) {
+      yield { type: 'error', data: { message: err instanceof Error ? err.message : 'AI call failed' } };
+      return;
+    }
+
+    // ΓöÇΓöÇ Evidence ledger ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+    const ledger: LedgerEntry[] = [];
+    let step = 0;
+    let toolRounds = 0;
+
+    // ΓöÇΓöÇ Tool-calling loop ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+    while (aiMessage.tool_calls && aiMessage.tool_calls.length > 0) {
+      toolRounds++;
+      if (toolRounds > MAX_TOOL_ROUNDS) break;
+
+      messages.push(aiMessage);
+
+      // Emit tool_start events for all tools in this round
+      const parsed: Array<{ raw: RawToolCall; call: ParsedToolCall }> = [];
+      for (const raw of aiMessage.tool_calls) {
+        const call = this.parseToolCall(raw);
+        parsed.push({ raw, call });
+        yield {
+          type: 'tool_start',
+          data: { tool: call.name, args: call.arguments, step: step + parsed.length },
+        };
+      }
+
+      // Execute all tool calls concurrently
+      const results = await Promise.all(
+        parsed.map(async ({ raw, call }) => {
+          let obs: string;
+          let success = true;
+          try {
+            obs = await this.executeTool(call.name, call.arguments, messages, ledger);
+            if (obs.includes('Tool execution failed') || obs.includes('returned no results') || obs.includes('No news found')) {
+              success = false;
+            }
+          } catch (e) {
+            success = false;
+            obs = 'Tool execution failed: ' + (e instanceof Error ? e.message : String(e));
+          }
+          return { raw, call, obs, success };
+        }),
+      );
+
+      // Process results: extract facts, emit events, push tool messages
+      for (const { raw, call, obs, success } of results) {
+        step++;
+        const fact = this.extractFact(call.name, call.arguments, obs);
+        if (fact) {
+          fact.step = step;
+          ledger.push(fact);
+        }
+
+        yield {
+          type: 'tool_result',
+          data: {
+            tool:    call.name,
+            fact:    fact?.fact || obs.slice(0, 120),
+            quality: fact?.quality || 'empty',
+            step,
+            success,
+          },
+        };
+
+        messages.push({
+          role:         'tool',
+          content:      obs,
+          name:         call.name,
+          tool_call_id: raw.id,
+        });
+      }
+
+      // Next AI call ΓÇö decide if more tools or final answer
+      try {
+        aiMessage = await this.callWithFallback(messages, this.getToolDefinitions(), 0.3);
+      } catch (err) {
+        yield { type: 'error', data: { message: err instanceof Error ? err.message : 'AI follow-up call failed' } };
+        return;
+      }
+    }
+
+    // ΓöÇΓöÇ Final response ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+    if (ledger.length > 0) {
+      // Two-pass: run reasoning agent with evidence ledger
+      const confirmedCount = ledger.filter(e => e.quality === 'confirmed').length;
+      yield { type: 'reasoning_start', data: { confirmedFacts: confirmedCount, totalSteps: step } };
+
+      try {
+        const reasoningMessages = this.buildReasoningMessages(messages, ledger);
+        for await (const chunk of this.llm.callTextStream({
+          messages:    reasoningMessages,
+          temperature: 0.5,
+          maxTokens:   4096,
+        })) {
+          // Strip thinking tags from streamed output
+          const cleaned = this.stripThinkingFromChunk(chunk);
+          if (cleaned) {
+            yield { type: 'token', data: cleaned };
+          }
+        }
+      } catch (err) {
+        yield { type: 'error', data: { message: 'Reasoning agent failed: ' + (err instanceof Error ? err.message : String(err)) } };
+        return;
+      }
+    } else if (aiMessage.content) {
+      // Simple response ΓÇö no tools were called. Stream directly.
+      // The content is already complete from callWithTools, so emit as one chunk.
+      const cleaned = this.stripThinkingFull(aiMessage.content);
+      yield { type: 'token', data: cleaned };
+    } else {
+      yield { type: 'token', data: 'I couldn\'t generate a response. Please try again.' };
+    }
+
+    yield { type: 'done', data: { totalSteps: step } };
+  }
+
+  // ΓöÇΓöÇΓöÇ System prompt (ported from CLI, adapted for web) ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+
+  private buildSystemPrompt(): string {
+    const memory = memoryService.getMemory();
+    const prefs = memory.preferences.length
+      ? `\nUSER PREFERENCES:\n${memory.preferences.map(p => '  - ' + p).join('\n')}`
+      : '';
+    const facts = memory.facts.length
+      ? `\nUSER FACTS:\n${memory.facts.map(f => '  - ' + f).join('\n')}`
+      : '';
+
+    return [
+      'You are BOZ (Behavioral Outlook Zone), an elite AI market assistant and quantitative analyst.',
+      'You think like a hedge fund analyst ΓÇö skeptical, data-driven, always asking "is this enough?"',
+      prefs,
+      facts,
+      '',
+      'CONVERSATIONAL AI RULES:',
+      '  - You have FULL AUTONOMY to decide whether tools are needed.',
+      '  - If the user is greeting you, asking a generic question, or asking a follow-up that',
+      '    can be answered from conversation history, DO NOT call tools. Just answer naturally.',
+      '  - If you genuinely need live data, news, or a fresh scan, then call the tools.',
+      '  - ANTI-LOOP RULE: If you just ran tools 1 turn ago and the user asks a follow-up about',
+      '    the SAME topic, it is almost always WRONG to call tools again. Answer from context.',
+      '  - COST AWARENESS: Every tool call takes 10-30 seconds. Be frugal.',
+      '',
+      'TOOLS:',
+      '  fetch_price(symbol_or_name)       ΓÇö live price for any asset',
+      '  fetch_news(query, category?)      ΓÇö market news; query is a free-text search string',
+      '  fetch_sentiment()                 ΓÇö Fear & Greed + StockTwits crowd data',
+      '  web_search(query)                 ΓÇö live web search; use when other tools give nothing',
+      '  scan_indonesia_momentum(sector?,  ΓÇö IDX scanner; screens the full IDX universe',
+      '    signal_type?, setup?, scan_mode?)  for momentum candidates. Deep mode is exhaustive.',
+      '  update_memory(fact, is_preference)ΓÇö save long-term user facts or preferences',
+      '',
+      'THINKING RULES:',
+      '  1. After each tool result, reflect: What did I learn? Is this enough? What next?',
+      '  2. If a tool returns empty/irrelevant results, pivot to web_search with a better query.',
+      '  3. Build a picture iteratively. Each tool call should add NEW information.',
+      '  4. You may call 6-10 tools per query if needed. More data = better analysis.',
+      '  5. Maintain a global market focus unless the user asks about a specific region.',
+      '  6. FOLLOW-UP QUESTIONS: If the user asks about the analysis you JUST provided,',
+      '     DO NOT call tools again. Answer directly from the conversation context.',
+      '',
+      'INDONESIAN STOCK HUNTING RULES:',
+      '  - When asked for IDX stocks to buy/invest/watch: ALWAYS call scan_indonesia_momentum.',
+      '    Autonomously pick the best setup filter ("rebound", "breakout", "oversold", "momentum").',
+      '  - After the scan, call fetch_price on the top 2-3 BUY candidates to confirm live prices.',
+      '  - Then call fetch_news WITH THE SPECIFIC COMPANY NAME AND SYMBOL to check for catalysts.',
+      '  - If news is irrelevant, call web_search for deep fundamentals.',
+      '  - Do NOT just name BBCA/BBRI/TLKM from memory ΓÇö those are lazy defaults.',
+      '  - Cite the score, volume ratio, and 52w range position.',
+      '',
+      'SUB-AGENT DELEGATION:',
+      '  - You have a team: QuantBrain, NewsHound, RiskManager, DataGoblin.',
+      '  - For complex analysis, summon 2-3 sub-agents CONCURRENTLY to analyze different angles.',
+      '  - Do not try to analyze complex stocks alone. Delegate the heavy thinking.',
+      '',
+      'EVIDENCE RULES ΓÇö IMMUTABLE:',
+      '  - Facts confirmed from tool results are locked. You cannot contradict them.',
+      '  - If price data says +1.1%, your analysis must reflect that.',
+      '  - If news returned nothing, say exactly that. Do not invent headlines.',
+      '',
+      'CONTRARIAN ANALYSIS:',
+      '  - StockTwits >70% bullish = caution (retail euphoria precedes reversals)',
+      '  - StockTwits <30% bullish = buy signal (panic = opportunity)',
+      '  - Fear & Greed >75 = reduce long confidence',
+      '  - Fear & Greed <25 = strong buy signal',
+      '',
+      'OUTPUT FORMAT:',
+      '  - Reply in a natural, conversational style. Direct, confident, professional.',
+      '  - Use rich markdown formatting: **bold**, headers, bullet lists, tables, code blocks.',
+      '  - For stock recommendations: rank your picks, give entry zone, stop-loss, and reasoning.',
+      '  - Cite data and reasoning, never vague hand-waving.',
+      '  - Acknowledge uncertainty honestly.',
+      '  - Never pad with filler. Be sharp and direct.',
+      '  - Rarely use emojis.',
+    ].join('\n');
+  }
+
+  // ΓöÇΓöÇΓöÇ Tool definitions ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+
+  private getToolDefinitions(): object[] {
+    return [
+      {
+        type: 'function',
+        function: {
+          name: 'update_memory',
+          description: 'Save a persistent fact or preference about the user across sessions.',
+          parameters: {
+            type: 'object',
+            properties: {
+              fact: { type: 'string', description: 'The fact or preference to save.' },
+              is_preference: { type: 'boolean', description: 'True if rule/preference, false if general fact.' },
+            },
+            required: ['fact', 'is_preference'],
+          },
+        },
+      },
+      {
+        type: 'function',
+        function: {
+          name: 'summon_agent',
+          description: 'Summon a specialized sub-agent for complex analysis. Use for deep-thinking tasks.',
+          parameters: {
+            type: 'object',
+            properties: {
+              agent_name: {
+                type: 'string',
+                enum: ['NewsHound', 'DataGoblin', 'QuantBrain', 'RiskManager'],
+                description: 'Which agent to summon.',
+              },
+              task: { type: 'string', description: 'The specific task and data to analyze.' },
+            },
+            required: ['agent_name', 'task'],
+          },
+        },
+      },
+      {
+        type: 'function',
+        function: {
+          name: 'fetch_price',
+          description: 'Fetch live market price for any asset ΓÇö stocks, indices, crypto, forex, commodities.',
+          parameters: {
+            type: 'object',
+            properties: {
+              symbol_or_name: {
+                type: 'string',
+                description: 'Ticker or name. E.g.: BTC, AAPL, IHSG, BBCA, GOLD, EURUSD',
+              },
+            },
+            required: ['symbol_or_name'],
+          },
+        },
+      },
+      {
+        type: 'function',
+        function: {
+          name: 'fetch_news',
+          description: [
+            'Fetch recent market news using a free-text search query.',
+            'Checks Indonesian RSS feeds (CNBC Indonesia, Bisnis.com, Kontan, Detik Finance)',
+            'as well as global sources.',
+            'If this returns empty, follow up with web_search.',
+          ].join(' '),
+          parameters: {
+            type: 'object',
+            properties: {
+              query: {
+                type: 'string',
+                description: 'Free-text search. Use local language terms for Indonesian assets.',
+              },
+              category: {
+                type: 'string',
+                enum: ['crypto', 'stocks', 'macro', 'broad', 'indonesia'],
+                description: 'Optional category hint.',
+              },
+            },
+            required: ['query'],
+          },
+        },
+      },
+      {
+        type: 'function',
+        function: {
+          name: 'fetch_sentiment',
+          description: 'Fetch global crowd sentiment ΓÇö CNN Fear & Greed index + StockTwits crowd ratio.',
+          parameters: { type: 'object', properties: {} },
+        },
+      },
+      {
+        type: 'function',
+        function: {
+          name: 'web_search',
+          description: [
+            'Search the live web for current information.',
+            'Use when other tools return empty or insufficient results.',
+            'Useful for: market news, sector analysis, macro events, company news.',
+          ].join(' '),
+          parameters: {
+            type: 'object',
+            properties: {
+              query: { type: 'string', description: 'Search query.' },
+            },
+            required: ['query'],
+          },
+        },
+      },
+      {
+        type: 'function',
+        function: {
+          name: 'scan_indonesia_momentum',
+          description: [
+            'Scan the IDX universe for hidden momentum setups.',
+            'Fast mode quote-screens all IDX stocks then chart-scans the strongest.',
+            'Deep mode chart-scans every valid IDX quote for exhaustive coverage.',
+            'Returns ranked BUY candidates and WATCH list sorted by score.',
+          ].join(' '),
+          parameters: {
+            type: 'object',
+            properties: {
+              sector: {
+                type: 'string',
+                enum: ['all', 'banking', 'consumer', 'mining', 'energy', 'tech', 'property', 'telecom', 'healthcare', 'industrial'],
+                description: 'Filter by sector.',
+              },
+              signal_type: {
+                type: 'string',
+                enum: ['buy', 'sell', 'any'],
+                description: '"buy" for positive momentum, "sell" for deteriorating, "any" for all.',
+              },
+              setup: {
+                type: 'string',
+                enum: ['momentum', 'rebound', 'all_time_low', 'downtrend', 'breakout', 'oversold'],
+                description: 'Filter by setup type. Pick the best one based on market context.',
+              },
+              scan_mode: {
+                type: 'string',
+                enum: ['fast', 'deep'],
+                description: '"fast" (default) quote-screens first. "deep" is exhaustive.',
+              },
+            },
+            required: [],
+          },
+        },
+      },
+    ];
+  }
+
+  // ΓöÇΓöÇΓöÇ Tool executor ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+
+  private async executeTool(
+    name: string,
+    args: Record<string, any>,
+    messages: LLMMessage[],
+    ledger: LedgerEntry[],
+  ): Promise<string> {
+    switch (name) {
+
+      case 'summon_agent': {
+        const agentName = (args.agent_name as string) ?? 'UnknownAgent';
+        const task = (args.task as string) ?? '';
+        return await this.simulateSubAgent(agentName, task, messages, ledger);
+      }
+
+      case 'fetch_price': {
+        const raw    = args.symbol_or_name as string;
+        const symbol = resolveSymbolIDX(raw) || raw.toUpperCase();
+        const quote  = await this.retrySimple(() => yahooFinance.quote(symbol), 3, 2000);
+        const price  = (quote as any).regularMarketPrice;
+        const change = (quote as any).regularMarketChangePercent;
+        if (price === undefined || price === null) {
+          return `No price data for ${symbol}. Yahoo Finance may not support this symbol or market is closed.`;
+        }
+        const chgNum    = typeof change === 'number' ? change : 0;
+        const name_     = (quote as any).shortName || (quote as any).longName || symbol;
+        const dayHigh   = (quote as any).regularMarketDayHigh;
+        const dayLow    = (quote as any).regularMarketDayLow;
+        const prevClose = (quote as any).regularMarketPreviousClose;
+        return [
+          `Symbol: ${symbol} | Name: ${name_} | Price: ${price} (Change: ${chgNum.toFixed(2)}%)`,
+          dayHigh  != null ? `Day Range: ${dayLow} ΓÇô ${dayHigh}` : '',
+          prevClose != null ? `Prev Close: ${prevClose}` : '',
+        ].filter(Boolean).join(' | ');
+      }
+
+      case 'update_memory': {
+        const fact   = (args.fact as string) ?? '';
+        const isPref = (args.is_preference as boolean) ?? false;
+        if (isPref) { memoryService.addPreference(fact); }
+        else        { memoryService.addFact(fact); }
+        return `Successfully saved memory: ${fact}`;
+      }
+
+      case 'fetch_news': {
+        const query    = (args.query as string) ?? '';
+        const category = (args.category as string) ?? 'broad';
+        const items: string[] = [];
+
+        const fetchers: Promise<any[]>[] = [];
+        if (category === 'indonesia' || category === 'stocks' || category === 'broad') {
+          fetchers.push(newsFetchService.fetchIndonesiaNews().catch(() => []));
+        }
+        if (category === 'crypto') {
+          fetchers.push(newsFetchService.fetchCryptoNews().catch(() => []));
+        }
+        if (category === 'stocks' || category === 'broad') {
+          fetchers.push(newsFetchService.fetchStockNews().catch(() => []));
+          fetchers.push(newsFetchService.fetchBroadMarketNews().catch(() => []));
+        }
+        if (category === 'macro') {
+          fetchers.push(newsFetchService.fetchMacroNews().catch(() => []));
+          fetchers.push(newsFetchService.fetchBroadMarketNews().catch(() => []));
+        }
+        if (fetchers.length === 0) {
+          fetchers.push(newsFetchService.fetchBroadMarketNews().catch(() => []));
+          fetchers.push(newsFetchService.fetchIndonesiaNews().catch(() => []));
+        }
+
+        const settled = await Promise.all(fetchers);
+        const fetched: any[] = settled.flat();
+
+        // Relevance scoring against query
+        const queryWords = query.toLowerCase().split(/\s+/).filter(w => w.length > 1);
+        const scored = fetched
+          .map(n => {
+            const title = (n.title ?? '').toLowerCase();
+            const blob  = `${title} ${n.details ?? ''} ${(n.assets ?? []).join(' ')} ${n.source ?? ''}`.toLowerCase();
+            let score = 0;
+            for (const w of queryWords) {
+              if (title.includes(w)) score += 2;
+              else if (blob.includes(w)) score += 1;
+            }
+            return { n, score };
+          })
+          .filter(({ score }) => queryWords.length === 0 || score > 0)
+          .sort((a, b) => {
+            if (b.score !== a.score) return b.score - a.score;
+            const imp: Record<string, number> = { high: 2, medium: 1, low: 0 };
+            return (imp[b.n.impact] ?? 0) - (imp[a.n.impact] ?? 0);
+          })
+          .slice(0, 10);
+
+        for (const { n } of scored) {
+          const src = n.source ? ` (${n.source})` : '';
+          items.push(`- ${n.title}${src}`);
+        }
+
+        if (items.length === 0) {
+          return `No news found for "${query}". [HINT: call web_search with query "${query}" to get live results]`;
+        }
+        return items.join('\n');
+      }
+
+      case 'fetch_sentiment': {
+        const data = await this.sentimentService.fetchCrowdSentiment();
+        return JSON.stringify({
+          fear_greed:      data.fear_greed,
+          reddit_buzz:     { stocktwits: data.stocktwits_data ?? null, social: data.social_buzz ?? [] },
+          overall_signals: data.summary.overall_signals,
+        }, null, 2);
+      }
+
+      case 'web_search': {
+        const query = (args.query as string) ?? '';
+        return await webSearchService.search(query);
+      }
+
+      case 'scan_indonesia_momentum': {
+        const sector     = (args.sector      as string) ?? 'all';
+        const signalType = (args.signal_type  as string) ?? 'buy';
+        const setup      = (args.setup        as string) ?? 'momentum';
+        const scanMode   = (args.scan_mode    as string) ?? 'fast';
+        const result     = await idxScannerService.scan(
+          sector as any, signalType as any, setup as any, scanMode as any,
+        );
+        return result.formatted;
+      }
+
+      default:
+        return 'Unknown tool: ' + name;
+    }
+  }
+
+  // ΓöÇΓöÇΓöÇ Sub-agent simulation ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+
+  private async simulateSubAgent(
+    agentName: string,
+    task:      string,
+    conversationMessages: LLMMessage[],
+    ledger:    LedgerEntry[],
+  ): Promise<string> {
+    const lower = agentName.toLowerCase();
+    let persona: string;
+
+    if (lower === 'quantbrain') {
+      persona = 'You are QuantBrain, a ruthless quantitative analyst. You focus PURELY on mathematics, risk-reward ratios, technicals, and volume flow. You ignore sentiment and hype. Give a highly empirical, data-dense analysis.';
+    } else if (lower === 'newshound') {
+      persona = 'You are NewsHound, a macro-economic intelligence agent. You read between the lines of global events, institutional money flow, and social sentiment. You connect seemingly unrelated geopolitical or economic events to the asset in question.';
+    } else if (lower === 'riskmanager') {
+      persona = 'You are RiskManager, a highly skeptical devil\'s advocate and former hedge fund auditor. Your ONLY job is to find reasons NOT to buy. Hunt for hidden red flags, overvaluation, regulatory risks, and structural flaws.';
+    } else if (lower === 'datagoblin') {
+      persona = 'You are DataGoblin, obsessed with obscure metrics, historical statistical anomalies, and relative valuations. You cross-reference sectors and peer groups to find absolute truths in the numbers.';
+    } else {
+      persona = `You are ${agentName}, a specialized analysis sub-agent.`;
+    }
+
+    const confirmedFacts = ledger
+      .filter(e => e.quality === 'confirmed')
+      .map(e => `  ΓÇó ${e.fact}`)
+      .join('\n');
+
+    const recentConversation = conversationMessages
+      .filter(m => (m.role === 'user' || m.role === 'assistant') && !m.tool_calls && typeof m.content === 'string' && m.content?.trim())
+      .slice(-6)
+      .map(m => `${m.role.toUpperCase()}: ${String(m.content).slice(0, 900)}`)
+      .join('\n\n');
+
+    const subAgentMessages: LLMMessage[] = [
+      {
+        role: 'system',
+        content: [
+          persona,
+          'Your job is to deeply analyze the task below.',
+          'You are not allowed to call tools, summon another agent, delegate, or output XML/tool syntax.',
+          'Return only your final specialist report in concise Markdown.',
+          'Use the provided task, conversation summary, and confirmed data ledger only.',
+          'If data is insufficient, say what is missing and still give the best risk-aware view.',
+        ].join('\n'),
+      },
+      {
+        role: 'user',
+        content: [
+          `Task: "${task}"`,
+          '',
+          'RECENT CONVERSATION SUMMARY:',
+          recentConversation || '  (none)',
+          '',
+          'CONFIRMED DATA GATHERED BY BOZ:',
+          confirmedFacts || '  (none)',
+          '',
+          'Output format:',
+          `### ${agentName} Report`,
+          '- **Thesis:** ...',
+          '- **Evidence:** ...',
+          '- **Risks / caveats:** ...',
+          '- **Actionable conclusion:** ...',
+        ].join('\n'),
+      },
+    ];
+
+    try {
+      const report = await this.llm.callText({
+        messages:    subAgentMessages,
+        temperature: 0.5,
+        maxTokens:   2000,
+      });
+      const cleaned = this.stripThinkingFull(report);
+      return `[REPORT FROM ${agentName}]\n${cleaned || 'Sub-agent returned no usable report.'}`;
+    } catch (e) {
+      return `Failed to summon ${agentName}: ` + (e instanceof Error ? e.message : String(e));
+    }
+  }
+
+  // ΓöÇΓöÇΓöÇ Evidence ledger builder ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+
+  private extractFact(toolName: string, args: Record<string, any>, obs: string): LedgerEntry | null {
+    const wasEmpty = obs.includes('No news found') || obs.includes('returned no results') ||
+                     obs.includes('Tool execution failed') || obs.includes('no data');
+
+    if (toolName === 'fetch_price') {
+      const pm = obs.match(/Price:\s*([\d,.]+)/);
+      const cm = obs.match(/Change:\s*([-\d.]+)%/);
+      const nm = obs.match(/Name:\s*([^|]+)/);
+      if (pm) {
+        return {
+          step: 0, tool: toolName,
+          fact: `${nm?.[1]?.trim() ?? args.symbol_or_name}: price ${pm[1]}${cm ? ', change ' + cm[1] + '%' : ''}`,
+          quality: 'confirmed',
+        };
+      }
+    }
+
+    if (toolName === 'fetch_news') {
+      const lines = obs.split('\n').filter(l => l.trim().startsWith('-'));
+      if (lines.length > 0) {
+        return {
+          step: 0, tool: toolName,
+          fact: `News for "${args.query}": ${lines.length} headlines found. Top: ${lines[0].replace(/^-\s*/, '').slice(0, 80)}`,
+          quality: 'confirmed',
+        };
+      }
+      return { step: 0, tool: toolName, fact: `News for "${args.query}": no relevant headlines`, quality: 'empty' };
+    }
+
+    if (toolName === 'fetch_sentiment') {
+      try {
+        const json = JSON.parse(obs);
+        const fg   = json.fear_greed?.value;
+        const fgl  = json.fear_greed?.label;
+        const st   = json.reddit_buzz?.stocktwits;
+        const sig  = (json.overall_signals ?? []).join(', ');
+        const stStr = st ? `, StockTwits ${st.bull_ratio?.toFixed(0)}% bullish` : '';
+        return {
+          step: 0, tool: toolName,
+          fact: `Sentiment: Fear & Greed ${fg} (${fgl})${stStr}, signals: [${sig}]`,
+          quality: 'confirmed',
+        };
+      } catch { /* fall through */ }
+    }
+
+    if (toolName === 'web_search') {
+      const lines = obs.split('\n').filter(l => l.trim().startsWith('-'));
+      if (lines.length > 0) {
+        return {
+          step: 0, tool: toolName,
+          fact: `Web search "${args.query}": ${lines.length} results. Top: ${lines[0].replace(/^-\s*/, '').slice(0, 80)}`,
+          quality: 'confirmed',
+        };
+      }
+      return { step: 0, tool: toolName, fact: `Web search "${args.query}": no results`, quality: 'empty' };
+    }
+
+    if (toolName === 'scan_indonesia_momentum') {
+      const buyMatch     = obs.match(/BUY:\s*(\d+)/);
+      const watchMatch   = obs.match(/WATCH:\s*(\d+)/);
+      const scannedMatch = obs.match(/scanned:\s*(\d+)/);
+      const breadthMatch = obs.match(/breadth signal:\s*([^\n]+)/);
+      const topBuyMatch  = obs.match(/\[SCORE\s+(\d+)\]\s+([A-Z]+)\s+ΓÇó\s+([^[\n]+)/);
+      const topBuyName   = topBuyMatch ? `${topBuyMatch[2]} (${topBuyMatch[3].trim()})` : null;
+      const scanned      = scannedMatch?.[1] ?? '?';
+      const buyCount     = buyMatch?.[1]     ?? '0';
+      const watchCount   = watchMatch?.[1]   ?? '0';
+      const breadth      = breadthMatch?.[1]?.trim() ?? '';
+      const topStr       = topBuyName ? `. Top pick: ${topBuyName}` : '';
+      return {
+        step: 0, tool: toolName,
+        fact: `IDX scan (${args.sector ?? 'all'}): ${scanned} scanned, ${buyCount} BUY / ${watchCount} WATCH. ${breadth}${topStr}`,
+        quality: Number(buyCount) > 0 ? 'confirmed' : 'partial',
+      };
+    }
+
+    if (toolName === 'summon_agent') {
+      const reportLines = obs.split('\n').filter(l => l.trim()).slice(0, 5);
+      return {
+        step: 0, tool: toolName,
+        fact: `${args.agent_name} report received (${obs.length} chars)`,
+        quality: obs.includes('Failed') || obs.includes('no usable') ? 'empty' : 'confirmed',
+      };
+    }
+
+    return wasEmpty
+      ? { step: 0, tool: toolName, fact: `${toolName} returned no data`, quality: 'empty' }
+      : null;
+  }
+
+  // ΓöÇΓöÇΓöÇ Reasoning agent messages ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+
+  private buildReasoningMessages(messages: LLMMessage[], ledger: LedgerEntry[]): LLMMessage[] {
+    const confirmedFacts = ledger.filter(e => e.quality === 'confirmed').map(e => `  ΓÇó ${e.fact}`).join('\n');
+    const emptyFacts     = ledger.filter(e => e.quality === 'empty').map(e => `  ΓÇó ${e.fact}`).join('\n');
+
+    const reasoningSystemPrompt = [
+      'You are the ANALYSIS ENGINE inside BOZ, a quantitative market analyst AI.',
+      'You receive a locked evidence ledger from the data-gathering phase, along with conversation history.',
+      'Your job: produce the final market analysis and action plan.',
+      '',
+      'HARD CONSTRAINTS:',
+      '  1. You MUST use every confirmed fact. Do not ignore any.',
+      '  2. You CANNOT contradict confirmed facts.',
+      '  3. For empty results: acknowledge honestly. Do not invent data.',
+      '  4. Apply contrarian analysis:',
+      '     StockTwits >70% bullish = crowd euphoria = caution',
+      '     Fear & Greed >75 = reduce long confidence',
+      '     Fear & Greed <25 = strong buy signal',
+      '  5. Incorporate fundamental reality and warn about speculative micro-caps.',
+      '',
+      'OUTPUT FORMAT:',
+      '  - Natural, conversational style with rich markdown formatting.',
+      '  - Use **bold**, headers, bullet lists, and tables when helpful.',
+      '  - Focus on actionable insights and clear takeaways.',
+      '  - Maintain a global perspective unless explicitly asked otherwise.',
+      '  - End with a clear Action Plan: Buy / Hold / Wait, with entry, stop-loss, target if applicable.',
+    ].join('\n');
+
+    const reasoningUserPrompt = [
+      'CONFIRMED DATA (immutable ΓÇö you must use and cannot contradict):',
+      confirmedFacts || '  (none)',
+      '',
+      emptyFacts ? ('GAPS IN DATA (be honest about these):\n' + emptyFacts) : '',
+      '',
+      'Produce a complete, accurate market analysis and action plan based strictly on the above data and the conversation history.',
+    ].filter(Boolean).join('\n');
+
+    // Include conversation context but prune tool messages for token efficiency
+    const conversationContext = messages.filter(
+      m => m.role === 'system' || m.role === 'user' || (m.role === 'assistant' && !m.tool_calls),
+    ).slice(-8);
+
+    return [
+      { role: 'system', content: reasoningSystemPrompt },
+      ...conversationContext,
+      { role: 'user',   content: reasoningUserPrompt },
+    ];
+  }
+
+  // ΓöÇΓöÇΓöÇ Model fallback ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+
+  private async callWithFallback(
+    messages:    LLMMessage[],
+    tools:       object[],
+    temperature: number,
+  ): Promise<LLMMessage> {
+    try {
+      return await this.llm.callWithTools({ messages, tools, temperature, maxTokens: 4096 });
+    } catch (err: any) {
+      const status = err?.response?.status || err?.status;
+      const isRetryable = status === 429 || (status >= 500 && status < 600) ||
+                          err?.code === 'ECONNRESET' || err?.code === 'ETIMEDOUT';
+
+      if (isRetryable) {
+        const fallbackModel = this.getFallbackModel();
+        if (fallbackModel) {
+          await new Promise(r => setTimeout(r, 3000));
+          return await this.llm.callWithTools({
+            messages, tools, temperature, maxTokens: 4096, model: fallbackModel,
+          });
+        }
+      }
+      throw err;
+    }
+  }
+
+  private getFallbackModel(): string | null {
+    const provider = config.aiProvider;
+    if (provider === 'github') {
+      const current = config.github.model;
+      const idx = GITHUB_MODELS.findIndex(m => m.id === current);
+      // Try gpt-4o-mini as fallback, or next in list
+      if (current !== 'openai/gpt-4o-mini') return 'openai/gpt-4o-mini';
+      if (idx >= 0 && idx < GITHUB_MODELS.length - 1) return GITHUB_MODELS[idx + 1].id;
+    }
+    if (provider === 'nvidia') {
+      const current = config.nvidia.model;
+      const idx = NVIDIA_MODELS.findIndex(m => m.id === current);
+      if (idx >= 0 && idx < NVIDIA_MODELS.length - 1) return NVIDIA_MODELS[idx + 1].id;
+    }
+    return null;
+  }
+
+  // ΓöÇΓöÇΓöÇ Helpers ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
+
+  private parseToolCall(rawCall: RawToolCall): ParsedToolCall {
+    let args: Record<string, any> = {};
+    try {
+      args = JSON.parse(rawCall.function?.arguments ?? '{}');
+    } catch {
+      args = {};
+    }
+    return { name: rawCall.function?.name ?? '', arguments: args };
+  }
+
+  private async retrySimple<T>(fn: () => Promise<T>, maxRetries = 3, delay = 2000): Promise<T> {
+    let attempt = 0;
+    while (true) {
+      try {
+        return await fn();
+      } catch (err) {
+        attempt++;
+        if (attempt > maxRetries) throw err;
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+  }
+
+  private stripThinkingFull(text: string): string {
+    if (!text) return '';
+    return text
+      .replace(/<thinking>[\s\S]*?<\/thinking>\n*/gi, '')
+      .replace(/<think>[\s\S]*?<\/think>\n*/gi, '')
+      .trim();
+  }
+
+  // For streaming: tracks if we're inside a thinking block and filters it
+  private thinkingBuffer = '';
+  private insideThinking = false;
+
+  private stripThinkingFromChunk(chunk: string): string {
+    this.thinkingBuffer += chunk;
+    let output = '';
+
+    while (this.thinkingBuffer.length > 0) {
+      if (this.insideThinking) {
+        const endIdx = this.thinkingBuffer.indexOf('</thinking>');
+        const endIdx2 = this.thinkingBuffer.indexOf('</think>');
+        const endTag = endIdx !== -1 ? '</thinking>' : endIdx2 !== -1 ? '</think>' : null;
+        const endPos = endIdx !== -1 ? endIdx : endIdx2 !== -1 ? endIdx2 : -1;
+
+        if (endTag && endPos !== -1) {
+          // Found end of thinking block ΓÇö skip everything up to and including the tag
+          this.thinkingBuffer = this.thinkingBuffer.slice(endPos + endTag.length).replace(/^\n+/, '');
+          this.insideThinking = false;
+        } else {
+          // Still inside thinking block ΓÇö consume entire buffer
+          this.thinkingBuffer = '';
+          break;
+        }
+      } else {
+        const startIdx = this.thinkingBuffer.indexOf('<thinking>');
+        const startIdx2 = this.thinkingBuffer.indexOf('<think>');
+        const startTag = startIdx !== -1 ? '<thinking>' : startIdx2 !== -1 ? '<think>' : null;
+        const startPos = startIdx !== -1 ? startIdx : startIdx2 !== -1 ? startIdx2 : -1;
+
+        if (startTag && startPos !== -1) {
+          // Output everything before the thinking tag
+          output += this.thinkingBuffer.slice(0, startPos);
+          this.thinkingBuffer = this.thinkingBuffer.slice(startPos + startTag.length);
+          this.insideThinking = true;
+        } else {
+          // Check if buffer might contain a partial tag at the end
+          const partialCheck = this.thinkingBuffer.slice(-12); // Max tag length is 10 (<thinking>)
+          const mightBePartial = '<thinking>'.startsWith(partialCheck.slice(partialCheck.lastIndexOf('<'))) ||
+                                  '<think>'.startsWith(partialCheck.slice(partialCheck.lastIndexOf('<')));
+
+          if (mightBePartial && partialCheck.includes('<')) {
+            const lastLt = this.thinkingBuffer.lastIndexOf('<');
+            output += this.thinkingBuffer.slice(0, lastLt);
+            this.thinkingBuffer = this.thinkingBuffer.slice(lastLt);
+          } else {
+            output += this.thinkingBuffer;
+            this.thinkingBuffer = '';
+          }
+          break;
+        }
+      }
+    }
+
+    return output;
+  }
+}
diff --git a/src/app/api/chat/route.ts b/src/app/api/chat/route.ts
index 4dd9bf9..26aef24 100644
--- a/src/app/api/chat/route.ts
+++ b/src/app/api/chat/route.ts
@@ -3,18 +3,22 @@ import { jsonResponse, errorResponse, parseBody } from '@/app/lib/api-helpers';
 import { config } from '@/config/config';
 import { LLMAdapter } from '@/services/ai/llm.adapter';
 
-const SYSTEM_PROMPT = `You are BOZ (Behavioral Outlook Zone), a senior financial analyst AI assistant at a top hedge fund. You provide clear, data-driven insights on markets, stocks, and trading strategies.
+const SYSTEM_PROMPT = `You are BOZ (Behavioral Outlook Zone), an elite AI market assistant and quantitative analyst.
+You think like a hedge fund analyst ΓÇö skeptical, data-driven, always asking "is this enough?"
 
-Your personality:
-- Direct and confident, with professional humor
-- You cite data and reasoning, never vague hand-waving
-- You use contrarian analysis when crowd sentiment is extreme
-- You acknowledge uncertainty honestly
-- You format responses clearly with bullet points and structure
+CONTRARIAN ANALYSIS:
+- StockTwits >70% bullish = caution (retail euphoria precedes reversals)
+- StockTwits <30% bullish = buy signal (panic = opportunity)
+- Fear & Greed >75 = reduce long confidence
+- Fear & Greed <25 = strong buy signal
 
-You can discuss: market analysis, technical indicators, macro economics, risk management, portfolio strategy, specific stock analysis, trading psychology, and Indonesian market (IDX/IHSG).
-
-Keep responses concise but substantive. Use markdown formatting when helpful.`;
+OUTPUT FORMAT:
+- Reply in a natural, conversational style. Direct, confident, professional.
+- Use rich markdown formatting: **bold**, headers, bullet lists, tables, code blocks.
+- For stock recommendations: rank your picks, give entry zone, stop-loss, and reasoning.
+- Cite data and reasoning, never vague hand-waving.
+- Acknowledge uncertainty honestly.
+- Rarely use emojis (minimize emoji usage).`;
 
 export async function POST(request: NextRequest) {
   try {
diff --git a/src/app/api/chat/stream/route.ts b/src/app/api/chat/stream/route.ts
new file mode 100644
index 0000000..d06bb8e
--- /dev/null
+++ b/src/app/api/chat/stream/route.ts
@@ -0,0 +1,49 @@
+import { NextRequest } from 'next/server';
+import { WebChatEngine } from '../chat.engine';
+
+export async function POST(request: NextRequest) {
+  let body: { message?: string; history?: Array<{ role: 'user' | 'assistant'; content: string }> };
+  try {
+    body = await request.json();
+  } catch {
+    return new Response('Invalid JSON', { status: 400 });
+  }
+
+  const message = body.message?.trim();
+  if (!message) {
+    return new Response('Message is required', { status: 400 });
+  }
+
+  const encoder = new TextEncoder();
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      const engine = new WebChatEngine();
+
+      try {
+        for await (const event of engine.run({ message, history: body.history })) {
+          const payload = typeof event.data === 'string'
+            ? event.data
+            : JSON.stringify(event.data);
+          const sseMessage = `event: ${event.type}\ndata: ${payload}\n\n`;
+          controller.enqueue(encoder.encode(sseMessage));
+        }
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+        const sseError = `event: error\ndata: ${JSON.stringify({ message: errorMsg })}\n\n`;
+        controller.enqueue(encoder.encode(sseError));
+      } finally {
+        controller.close();
+      }
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type':  'text/event-stream',
+      'Cache-Control': 'no-cache, no-transform',
+      'Connection':    'keep-alive',
+      'X-Accel-Buffering': 'no',  // Disable nginx buffering
+    },
+  });
+}
diff --git a/src/app/chat/AnalysisCards.tsx b/src/app/chat/AnalysisCards.tsx
new file mode 100644
index 0000000..00f6078
--- /dev/null
+++ b/src/app/chat/AnalysisCards.tsx
@@ -0,0 +1,314 @@
+import React from 'react';
+
+const fmt = (v: number | null | undefined, d = 2) => v != null ? v.toFixed(d) : 'ΓÇö';
+
+export function IntradayCard({ data }: { data: any }) {
+  if (!data) return null;
+  const { verdict, marketData: md, macro, sentiment: sent, chartPatterns: cp, tradeLevels: tl } = data;
+  const isOk = verdict?.status === 'ok';
+  const isBull = verdict?.prediction === 'UP';
+
+  return (
+    <div className="flex-col gap-6" style={{ marginBottom: '16px' }}>
+
+
+      {/* Technical + Macro Row */}
+      <div className="grid-2 gap-4">
+        {/* Technical Indicators */}
+        <div className="glass-card">
+          <div className="card-header">
+            <span className="card-title">Technical Indicators</span>
+          </div>
+          <table className="data-table">
+            <thead>
+              <tr><th>Indicator</th><th>Value</th></tr>
+            </thead>
+            <tbody>
+              <tr>
+                <td>RSI (14)</td>
+                <td className={md?.rsi > 70 ? 'table-cell-negative' : md?.rsi < 30 ? 'table-cell-positive' : ''}>{fmt(md?.rsi, 1)}</td>
+              </tr>
+              <tr>
+                <td>MACD</td>
+                <td className={(md?.macd ?? 0) >= 0 ? 'table-cell-positive' : 'table-cell-negative'}>{fmt(md?.macd, 4)}</td>
+              </tr>
+              <tr><td>SMA 20</td><td>${fmt(md?.sma_20)}</td></tr>
+              <tr><td>SMA 50</td><td>${fmt(md?.sma_50)}</td></tr>
+              <tr><td>SMA 200</td><td>${fmt(md?.sma_200)}</td></tr>
+              <tr><td>ATR</td><td>{fmt(md?.atr, 4)} ({fmt(md?.atr_percent)}%)</td></tr>
+              <tr><td>BB Width</td><td>{fmt(md?.bb_width, 4)}</td></tr>
+              <tr>
+                <td>Volume Ratio</td>
+                <td className={(md?.volume_ratio ?? 0) > 1.5 ? 'table-cell-positive' : ''}>{fmt(md?.volume_ratio)}x</td>
+              </tr>
+              <tr><td>OBV Trend</td><td>{md?.obv_trend ? '🟢 Bullish' : '🔴 Bearish'}</td></tr>
+            </tbody>
+          </table>
+        </div>
+
+        {/* Macro Context */}
+        <div className="glass-card">
+          <div className="card-header">
+            <span className="card-title">Macro Context</span>
+          </div>
+          <table className="data-table">
+            <thead>
+              <tr><th>Metric</th><th>Value</th></tr>
+            </thead>
+            <tbody>
+              <tr>
+                <td>Market Regime</td>
+                <td>
+                  <span className={`badge ${
+                    macro?.market_regime?.toLowerCase().includes('bull') ? 'badge-bull' :
+                    macro?.market_regime?.toLowerCase().includes('bear') ? 'badge-bear' :
+                    'badge-neutral'
+                  }`}>{macro?.market_regime ?? 'ΓÇö'}</span>
+                </td>
+              </tr>
+              <tr>
+                <td>Risk Sentiment</td>
+                <td>
+                  <span className={`badge ${
+                    macro?.risk_sentiment === 'RISK_ON' ? 'badge-bull' :
+                    macro?.risk_sentiment === 'RISK_OFF' ? 'badge-bear' :
+                    'badge-neutral'
+                  }`}>{macro?.risk_sentiment ?? 'ΓÇö'}</span>
+                </td>
+              </tr>
+              <tr><td>SPY Correlation</td><td>{macro?.sp500_correlation ?? 'ΓÇö'}</td></tr>
+              <tr><td>NASDAQ Correlation</td><td>{macro?.nasdaq_correlation ?? 'ΓÇö'}</td></tr>
+              <tr>
+                <td>VIX Level</td>
+                <td className={(macro?.vix_level ?? 0) > 25 ? 'table-cell-negative' : 'table-cell-positive'}>
+                  {fmt(macro?.vix_level)}
+                </td>
+              </tr>
+              <tr><td>10Y Yield</td><td>{fmt(macro?.tnx_yield)}%</td></tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+
+      {/* Patterns + Sentiment Row */}
+      <div className="grid-2 gap-4">
+        {/* Chart Patterns */}
+        <div className="glass-card">
+          <div className="card-header">
+            <span className="card-title">Chart Patterns</span>
+          </div>
+          {cp?.patterns?.length > 0 ? (
+            <div className="flex-col gap-2">
+              {cp.patterns.map((p: string, i: number) => (
+                <div key={i} className="flex-row justify-between items-center" style={{ padding: 'var(--space-2) 0', borderBottom: '1px solid var(--border-glass)' }}>
+                  <span style={{ fontSize: '13px' }}>{p}</span>
+                  <span className={`badge ${
+                    cp.pattern_confidence?.[i] === 'HIGH' ? 'badge-high' :
+                    cp.pattern_confidence?.[i] === 'MEDIUM' ? 'badge-medium' : 'badge-low'
+                  }`}>{cp.pattern_confidence?.[i] ?? 'ΓÇö'}</span>
+                </div>
+              ))}
+              <div style={{ padding: 'var(--space-2) 0' }}>
+                <span className="card-title">Fibonacci: </span>
+                <span className="badge badge-cyan">{cp.fibonacci_position}</span>
+              </div>
+            </div>
+          ) : (
+            <div className="empty-state" style={{ padding: '24px 0' }}>
+              <p className="empty-state-text">No patterns detected</p>
+            </div>
+          )}
+        </div>
+
+        {/* Sentiment */}
+        <div className="glass-card">
+          <div className="card-header">
+            <span className="card-title">Sentiment</span>
+          </div>
+          <table className="data-table">
+            <thead>
+              <tr><th>Signal</th><th>Value</th></tr>
+            </thead>
+            <tbody>
+              <tr>
+                <td>Fear &amp; Greed</td>
+                <td>
+                  <span className={`badge ${
+                    (sent?.fear_greed?.value ?? 50) > 60 ? 'badge-bull' :
+                    (sent?.fear_greed?.value ?? 50) < 40 ? 'badge-bear' : 'badge-neutral'
+                  }`}>{sent?.fear_greed?.value ?? 'ΓÇö'} ({sent?.fear_greed?.label ?? 'ΓÇö'})</span>
+                </td>
+              </tr>
+              <tr>
+                <td>StockTwits</td>
+                <td>
+                  <span className={`badge ${
+                    (sent?.stocktwits_data?.bull_ratio ?? 50) > 60 ? 'badge-bull' :
+                    (sent?.stocktwits_data?.bull_ratio ?? 50) < 40 ? 'badge-bear' : 'badge-neutral'
+                  }`}>{fmt(sent?.stocktwits_data?.bull_ratio, 0)}% bullish</span>
+                </td>
+              </tr>
+              <tr>
+                <td>Reddit</td>
+                <td><span className="badge badge-violet">{sent?.social_buzz?.length ?? 0} sources</span></td>
+              </tr>
+              <tr>
+                <td>Overall</td>
+                <td>
+                  {sent?.summary?.overall_signals?.map((s: string, i: number) => (
+                    <span key={i} className={`badge ${
+                      s.includes('BULL') ? 'badge-bull' :
+                      s.includes('BEAR') ? 'badge-bear' :
+                      s.includes('FEAR') ? 'badge-bear' :
+                      s.includes('GREED') ? 'badge-warning' : 'badge-neutral'
+                    }`} style={{ marginRight: '4px', fontSize: '10px' }}>{s}</span>
+                  )) ?? 'ΓÇö'}
+                </td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export function LongtermCard({ data }: { data: any }) {
+  if (!data) return null;
+  const { marketData: md, macro, sentiment: sent, chartPatterns: cp } = data;
+
+  const fmt = (v: number | null | undefined, decimals = 2) =>
+    v != null ? v.toFixed(decimals) : 'ΓÇö';
+
+  return (
+    <div style={{ display: 'flex', flexDirection: 'column', gap: 'var(--space-4)', marginTop: 'var(--space-2)' }}>
+      {md?.fiftyTwoWeekHigh && (
+        <div className="glass-card compact" style={{ padding: 'var(--space-4)', borderRadius: 'var(--radius-lg)' }}>
+          <div style={{ fontSize: 'var(--text-sm)', fontWeight: 600, color: 'var(--text-primary)', marginBottom: 'var(--space-3)' }}>52-Week Context</div>
+          <div style={{ display: 'grid', gridTemplateColumns: 'repeat(4, 1fr)', gap: 'var(--space-4)' }}>
+            <div><span style={{ fontSize: 'var(--text-xs)', color: 'var(--text-muted)' }}>52W High</span><br /><span style={{ fontWeight: 600 }}>${fmt(md.fiftyTwoWeekHigh)}</span></div>
+            <div><span style={{ fontSize: 'var(--text-xs)', color: 'var(--text-muted)' }}>From High</span><br /><span style={{ fontWeight: 600, color: 'var(--bear)' }}>{fmt(md.from52wHigh, 1)}%</span></div>
+            <div><span style={{ fontSize: 'var(--text-xs)', color: 'var(--text-muted)' }}>52W Low</span><br /><span style={{ fontWeight: 600 }}>${fmt(md.fiftyTwoWeekLow)}</span></div>
+            <div><span style={{ fontSize: 'var(--text-xs)', color: 'var(--text-muted)' }}>From Low</span><br /><span style={{ fontWeight: 600, color: 'var(--bull)' }}>+{fmt(md.from52wLow, 1)}%</span></div>
+          </div>
+        </div>
+      )}
+
+      <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 'var(--space-4)' }}>
+        <div className="glass-card" style={{ padding: 'var(--space-4)', borderRadius: 'var(--radius-lg)' }}>
+          <div style={{ fontSize: 'var(--text-sm)', fontWeight: 600, color: 'var(--text-primary)', marginBottom: 'var(--space-3)' }}>Technical Indicators</div>
+          <table className="data-table" style={{ width: '100%', fontSize: 'var(--text-xs)' }}>
+            <thead><tr><th style={{ textAlign: 'left', paddingBottom: '8px' }}>Indicator</th><th style={{ textAlign: 'right', paddingBottom: '8px' }}>Value</th></tr></thead>
+            <tbody>
+              <tr><td>RSI (14)</td><td style={{ textAlign: 'right' }} className={md?.rsi > 70 ? 'table-cell-negative' : md?.rsi < 30 ? 'table-cell-positive' : ''}>{fmt(md?.rsi, 1)}</td></tr>
+              <tr><td>MACD</td><td style={{ textAlign: 'right' }} className={(md?.macd ?? 0) >= 0 ? 'table-cell-positive' : 'table-cell-negative'}>{fmt(md?.macd, 4)}</td></tr>
+              <tr><td>SMA 20</td><td style={{ textAlign: 'right' }}>${fmt(md?.sma_20)}</td></tr>
+              <tr><td>SMA 50</td><td style={{ textAlign: 'right' }}>${fmt(md?.sma_50)}</td></tr>
+              <tr><td>SMA 200</td><td style={{ textAlign: 'right' }}>${fmt(md?.sma_200)}</td></tr>
+              <tr><td>ATR</td><td style={{ textAlign: 'right' }}>{fmt(md?.atr, 4)} ({fmt(md?.atr_percent)}%)</td></tr>
+              <tr><td>BB Width</td><td style={{ textAlign: 'right' }}>{fmt(md?.bb_width, 4)}</td></tr>
+              <tr><td>Volume Ratio</td><td style={{ textAlign: 'right' }}>{fmt(md?.volume_ratio)}x</td></tr>
+              <tr><td>OBV Trend</td><td style={{ textAlign: 'right' }}>{md?.obv_trend ? '🟢 Bullish' : '🔴 Bearish'}</td></tr>
+            </tbody>
+          </table>
+        </div>
+
+        <div className="glass-card" style={{ padding: 'var(--space-4)', borderRadius: 'var(--radius-lg)' }}>
+          <div style={{ fontSize: 'var(--text-sm)', fontWeight: 600, color: 'var(--text-primary)', marginBottom: 'var(--space-3)' }}>Macro Context</div>
+          <table className="data-table" style={{ width: '100%', fontSize: 'var(--text-xs)' }}>
+            <thead><tr><th style={{ textAlign: 'left', paddingBottom: '8px' }}>Metric</th><th style={{ textAlign: 'right', paddingBottom: '8px' }}>Value</th></tr></thead>
+            <tbody>
+              <tr><td>Market Regime</td><td style={{ textAlign: 'right' }}><span className={`badge ${macro?.market_regime?.toLowerCase().includes('bull') ? 'badge-bull' : macro?.market_regime?.toLowerCase().includes('bear') ? 'badge-bear' : 'badge-neutral'}`}>{macro?.market_regime ?? 'ΓÇö'}</span></td></tr>
+              <tr><td>Risk Sentiment</td><td style={{ textAlign: 'right' }}><span className={`badge ${macro?.risk_sentiment === 'RISK_ON' ? 'badge-bull' : macro?.risk_sentiment === 'RISK_OFF' ? 'badge-bear' : 'badge-neutral'}`}>{macro?.risk_sentiment ?? 'ΓÇö'}</span></td></tr>
+              <tr><td>SPY Correlation</td><td style={{ textAlign: 'right' }}>{macro?.sp500_correlation ?? 'ΓÇö'}</td></tr>
+              <tr><td>NASDAQ Correlation</td><td style={{ textAlign: 'right' }}>{macro?.nasdaq_correlation ?? 'ΓÇö'}</td></tr>
+              <tr><td>VIX Level</td><td style={{ textAlign: 'right' }} className={(macro?.vix_level ?? 0) > 25 ? 'table-cell-negative' : 'table-cell-positive'}>{fmt(macro?.vix_level)}</td></tr>
+              <tr><td>10Y Yield</td><td style={{ textAlign: 'right' }}>{fmt(macro?.tnx_yield)}%</td></tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+
+      <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 'var(--space-4)' }}>
+        <div className="glass-card" style={{ padding: 'var(--space-4)', borderRadius: 'var(--radius-lg)' }}>
+          <div style={{ fontSize: 'var(--text-sm)', fontWeight: 600, color: 'var(--text-primary)', marginBottom: 'var(--space-3)' }}>Chart Patterns</div>
+          {cp?.patterns?.length > 0 ? (
+            <div className="flex-col gap-2">
+              {cp.patterns.map((p: string, i: number) => (
+                <div key={i} className="flex-row justify-between items-center" style={{ padding: 'var(--space-2) 0', borderBottom: '1px solid var(--border-glass)' }}>
+                  <span style={{ fontSize: '13px' }}>{p}</span>
+                  <span className={`badge ${
+                    cp.pattern_confidence?.[i] === 'HIGH' ? 'badge-high' :
+                    cp.pattern_confidence?.[i] === 'MEDIUM' ? 'badge-medium' : 'badge-low'
+                  }`}>{cp.pattern_confidence?.[i] ?? 'ΓÇö'}</span>
+                </div>
+              ))}
+              <div style={{ padding: 'var(--space-2) 0', fontSize: '13px', marginTop: 'var(--space-2)' }}>
+                <strong>Fibonacci:</strong> {cp.fibonacci_position || 'N/A'}
+              </div>
+            </div>
+          ) : (
+            <div style={{ fontSize: '13px', color: 'var(--text-muted)' }}>No significant patterns detected.</div>
+          )}
+        </div>
+
+        <div className="glass-card" style={{ padding: 'var(--space-4)', borderRadius: 'var(--radius-lg)' }}>
+          <div style={{ fontSize: 'var(--text-sm)', fontWeight: 600, color: 'var(--text-primary)', marginBottom: 'var(--space-3)' }}>Sentiment</div>
+          <table className="data-table" style={{ width: '100%', fontSize: 'var(--text-xs)' }}>
+            <thead><tr><th style={{ textAlign: 'left', paddingBottom: '8px' }}>Signal</th><th style={{ textAlign: 'right', paddingBottom: '8px' }}>Value</th></tr></thead>
+            <tbody>
+              <tr>
+                <td>Fear & Greed</td>
+                <td style={{ textAlign: 'right' }}>{sent?.fear_greed?.value ?? 'ΓÇö'} ({sent?.fear_greed?.label ?? 'ΓÇö'})</td>
+              </tr>
+              <tr>
+                <td>StockTwits</td>
+                <td style={{ textAlign: 'right' }}>{sent?.stocktwits_data?.bull_ratio != null ? `${sent.stocktwits_data.bull_ratio.toFixed(0)}% bullish` : 'ΓÇö'}</td>
+              </tr>
+              <tr>
+                <td>Reddit</td>
+                <td style={{ textAlign: 'right' }}><span className="badge badge-violet">{sent?.social_buzz?.length ?? 0} sources</span></td>
+              </tr>
+              <tr>
+                <td>Overall</td>
+                <td style={{ textAlign: 'right' }}>
+                  {sent?.summary?.overall_signals?.map((s: string, i: number) => (
+                    <span key={i} className={`badge ${
+                      s.includes('BULL') ? 'badge-bull' :
+                      s.includes('BEAR') ? 'badge-bear' :
+                      s.includes('FEAR') ? 'badge-bear' :
+                      s.includes('GREED') ? 'badge-warning' : 'badge-neutral'
+                    }`} style={{ marginLeft: '4px', fontSize: '10px' }}>{s}</span>
+                  )) ?? 'ΓÇö'}
+                </td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export function NewsIntelCard({ data }: { data: any }) {
+  if (!data) return null;
+  const { sentiment: sent } = data;
+
+  return (
+    <div className="glass-card" style={{ padding: '16px', marginBottom: '16px', fontSize: '14px', borderRadius: 'var(--radius-lg)', background: 'var(--surface-glass)', border: '1px solid var(--border-glass)' }}>
+      <h3 style={{ margin: '0 0 12px 0', fontSize: '16px', fontWeight: 600 }}>News Intelligence</h3>
+      <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(200px, 1fr))', gap: '12px' }}>
+        {sent && (
+          <div style={{ padding: '12px', background: 'rgba(255,255,255,0.03)', borderRadius: '8px' }}>
+            <div style={{ fontSize: '12px', color: 'var(--text-muted)', marginBottom: '8px' }}>SENTIMENT OVERVIEW</div>
+            <div style={{ display: 'flex', flexDirection: 'column', gap: '4px' }}>
+              <div style={{ display: 'flex', justifyContent: 'space-between' }}><span>Fear & Greed</span> <strong>{sent.fear_greed?.value || '--'} ({sent.fear_greed?.label || '--'})</strong></div>
+              <div style={{ display: 'flex', justifyContent: 'space-between' }}><span>StockTwits Bulls</span> <strong>{sent.stocktwits_data?.bull_ratio ? sent.stocktwits_data.bull_ratio.toFixed(0) + '%' : '--'}</strong></div>
+              <div style={{ display: 'flex', justifyContent: 'space-between' }}><span>Headlines Analyzed</span> <strong>{data.totalHeadlines || '--'}</strong></div>
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/src/app/chat/ChatComponent.tsx b/src/app/chat/ChatComponent.tsx
new file mode 100644
index 0000000..01de712
--- /dev/null
+++ b/src/app/chat/ChatComponent.tsx
@@ -0,0 +1,592 @@
+'use client';
+
+import { useState, useRef, useEffect } from 'react';
+import { useRouter } from 'next/navigation';
+import { marked } from 'marked';
+import { IntradayCard, LongtermCard, NewsIntelCard } from './AnalysisCards';
+
+export interface ChatMessage {
+  role: 'user' | 'assistant';
+  content: string;
+  data?: any;
+  type?: 'intraday' | 'longterm' | 'newsintel' | 'chat';
+}
+
+export interface ChatSession {
+  id: string;
+  title: string;
+  messages: ChatMessage[];
+  updatedAt: number;
+}
+
+function formatContent(content: string): string {
+  try {
+    return marked.parse(content, { breaks: true, async: false }) as string;
+  } catch (e) {
+    return content;
+  }
+}
+
+export default function ChatComponent({ chatId }: { chatId?: string }) {
+  const router = useRouter();
+  const [messages, setMessages] = useState<ChatMessage[]>([]);
+  const [input, setInput] = useState('');
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [loadingStep, setLoadingStep] = useState(0);
+  const [loadingType, setLoadingType] = useState<string | null>(null);
+  const [streamingContent, setStreamingContent] = useState('');
+  const [toolStatuses, setToolStatuses] = useState<Array<{tool: string, status: 'running' | 'done', result?: string}>>([]);
+  const messagesEndRef = useRef<HTMLDivElement>(null);
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  const loadingMessages = [
+    "Fetching real-time market data...",
+    "Scanning social sentiment on Reddit and StockTwits...",
+    "Calculating technical indicators and moving averages...",
+    "Analyzing macro environment and Treasury yields...",
+    "Waiting for AI models to synthesize response...",
+    "Finalizing trading strategy..."
+  ];
+
+  useEffect(() => {
+    let interval: NodeJS.Timeout;
+    if (loading && loadingType && (loadingType.startsWith('/intraday') || loadingType.startsWith('/longterm'))) {
+      interval = setInterval(() => {
+        setLoadingStep((prev) => Math.min(prev + 1, loadingMessages.length - 1));
+      }, 2500);
+    }
+    return () => clearInterval(interval);
+  }, [loading, loadingType]);
+
+  useEffect(() => {
+    if (chatId) {
+      const stored = localStorage.getItem('boz_chat_sessions');
+      if (stored) {
+        try {
+          const sessions: ChatSession[] = JSON.parse(stored);
+          const session = sessions.find(s => s.id === chatId);
+          if (session) {
+            setMessages(session.messages);
+          }
+        } catch (e) {
+          console.error('Failed to load chat session', e);
+        }
+      }
+    }
+  }, [chatId]);
+
+  const saveSession = (id: string, msgs: ChatMessage[]) => {
+    try {
+      const stored = localStorage.getItem('boz_chat_sessions');
+      let sessions: ChatSession[] = stored ? JSON.parse(stored) : [];
+      const index = sessions.findIndex(s => s.id === id);
+      
+      const title = msgs.find(m => m.role === 'user')?.content.substring(0, 30) + '...' || 'New Chat';
+      
+      if (index >= 0) {
+        sessions[index].messages = msgs;
+        sessions[index].updatedAt = Date.now();
+      } else {
+        sessions.push({ id, title, messages: msgs, updatedAt: Date.now() });
+      }
+      localStorage.setItem('boz_chat_sessions', JSON.stringify(sessions));
+      // Dispatch an event so sidebar can update
+      window.dispatchEvent(new Event('boz_chat_updated'));
+    } catch (e) {
+      console.error('Failed to save session', e);
+    }
+  };
+
+  const scrollToBottom = () => {
+    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
+  };
+
+  useEffect(() => {
+    scrollToBottom();
+  }, [messages]);
+
+  useEffect(() => {
+    inputRef.current?.focus();
+  }, []);
+
+  const sendMessage = async () => {
+    if (!input.trim() || loading) return;
+
+    const command = input.trim();
+    const userMessage: ChatMessage = { role: 'user', content: command };
+    const updatedMessages = [...messages, userMessage];
+    setMessages(updatedMessages);
+    setInput('');
+    setLoading(true);
+    setLoadingStep(0);
+    setLoadingType(command.toLowerCase());
+    setError(null);
+
+    let activeChatId = chatId;
+    if (!activeChatId) {
+      activeChatId = btoa(Date.now().toString() + Math.random().toString(36).substring(7)).replace(/=/g, '');
+      saveSession(activeChatId, updatedMessages);
+      window.history.replaceState(null, '', '/chat/' + activeChatId);
+      // Don't return here, we want to continue processing the message
+    } else {
+      saveSession(activeChatId, updatedMessages);
+    }
+
+    try {
+      let finalMessages = [...updatedMessages];
+      
+      if (command.toLowerCase().startsWith('/intraday ')) {
+        const ticker = command.substring(10).trim();
+        
+        // 1. Fetch data
+        const dataRes = await fetch('/api/analyze/intraday/data', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ ticker: ticker.toUpperCase() }),
+        });
+        if (!dataRes.ok) throw new Error('Intraday data fetch failed');
+        const data = await dataRes.json();
+
+        // Push intermediate message with data immediately
+        const intermediateMessages = [...updatedMessages, { 
+          role: 'assistant', 
+          content: '*Synthesizing AI verdict...*', 
+          data, 
+          type: 'intraday' 
+        } as ChatMessage];
+        setMessages(intermediateMessages);
+
+        // Update loading state for AI reasoning step
+        setLoadingType('/intraday-verdict');
+
+        // 2. Fetch AI Verdict
+        const verdictRes = await fetch('/api/analyze/intraday/verdict', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ ticker: ticker.toUpperCase(), ...data }),
+        });
+        if (!verdictRes.ok) throw new Error('Intraday AI verdict failed');
+        const verdictData = await verdictRes.json();
+
+        data.verdict = verdictData.verdict;
+        data.tradeLevels = verdictData.tradeLevels;
+        
+        let markdown = `**Intraday Analysis for ${ticker.toUpperCase()}**\n\n`;
+        const v = data.verdict;
+        if (v) {
+          markdown += `**Verdict:** ${v.status === 'ok' ? (v.prediction === 'UP' ? 'Bullish Outlook 🟢' : 'Bearish Outlook 🔴') : 'Uncertain / Hold ⚪'} (${v.confidence || '--'}% Conviction)\n`;
+          markdown += `**Strategy:** ${v.strategy || v.reason || 'N/A'}\n\n`;
+        }
+
+        const tl = data.tradeLevels;
+        if (tl) {
+          markdown += `**Trade Levels:**\n`;
+          markdown += `- **Entry:** ${tl.entryRange || '--'}\n`;
+          markdown += `- **Target:** ${tl.targetRange || '--'}\n`;
+          markdown += `- **Stop Loss:** ${tl.stopLoss || '--'}\n\n`;
+        }
+        
+        const md = data.marketData;
+        const macro = data.macro;
+        const sent = data.sentiment;
+
+        if (md || macro || sent) {
+          markdown += `**Technical & Macro Indicators:**\n\n`;
+          if (md) {
+            markdown += `- **Technicals:** RSI: ${md.rsi?.toFixed(1) || '--'} | MACD: ${md.macd?.toFixed(4) || '--'} | ATR: ${md.atr?.toFixed(4) || '--'} | SMA20: $${md.sma_20?.toFixed(2) || '--'} | OBV Trend: ${md.obv_trend ? '🟢 Bullish' : '🔴 Bearish'}\n`;
+          }
+          if (macro) {
+            markdown += `- **Macro:** Regime: ${macro.market_regime || '--'} | Risk: ${macro.risk_sentiment || '--'} | VIX: ${macro.vix_level?.toFixed(2) || '--'}\n`;
+          }
+          if (sent) {
+            markdown += `- **Sentiment:** Fear & Greed: ${sent.fear_greed?.value || '--'} (${sent.fear_greed?.label || '--'}) | StockTwits: ${sent.stocktwits_data?.bull_ratio ? sent.stocktwits_data.bull_ratio.toFixed(0) + '% Bullish' : '--'}\n`;
+          }
+          markdown += `\n`;
+        }
+        
+        if (v && v.reasons && v.reasons.length > 0) {
+          markdown += `**AI Reasoning:**\n`;
+          v.reasons.forEach((r: string) => {
+            markdown += `- ${r}\n`;
+          });
+        }
+        
+        finalMessages.push({ role: 'assistant', content: markdown, data, type: 'intraday' });
+      } else if (command.toLowerCase().startsWith('/longterm ')) {
+        const ticker = command.substring(10).trim();
+        
+        // 1. Fetch data
+        const dataRes = await fetch('/api/analyze/longterm/data', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ ticker: ticker.toUpperCase() }),
+        });
+        if (!dataRes.ok) throw new Error('Longterm data fetch failed');
+        const data = await dataRes.json();
+
+        // Push intermediate message with data immediately
+        const intermediateMessages = [...updatedMessages, { 
+          role: 'assistant', 
+          content: '*Synthesizing AI verdict...*', 
+          data, 
+          type: 'longterm' 
+        } as ChatMessage];
+        setMessages(intermediateMessages);
+
+        // Update loading state for AI reasoning step
+        setLoadingType('/longterm-verdict');
+
+        // 2. Fetch AI Verdict
+        const verdictRes = await fetch('/api/analyze/longterm/verdict', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ ticker: ticker.toUpperCase(), ...data }),
+        });
+        if (!verdictRes.ok) throw new Error('Longterm AI verdict failed');
+        const verdictData = await verdictRes.json();
+
+        data.verdict = verdictData.verdict;
+        data.tradeLevels = verdictData.tradeLevels;
+        
+        let markdown = `**Long-term Outlook for ${ticker.toUpperCase()}**\n\n`;
+        const v = data.verdict;
+        if (v) {
+          markdown += `**Verdict:** ${v.status === 'ok' ? (v.prediction === 'UP' ? 'Bullish Outlook 🟢' : 'Bearish Outlook 🔴') : 'Uncertain / Hold ⚪'} (${v.confidence || '--'}% Conviction)\n`;
+          markdown += `**Strategy:** ${v.strategy || v.reason || 'N/A'}\n\n`;
+        }
+
+        const tl = data.tradeLevels;
+        if (tl) {
+          markdown += `**Trade Levels:**\n`;
+          markdown += `- **Entry:** ${tl.entryRange || '--'}\n`;
+          markdown += `- **Target:** ${tl.targetRange || '--'}\n`;
+          markdown += `- **Stop Loss:** ${tl.stopLoss || '--'}\n\n`;
+        }
+        
+        const md = data.marketData;
+        if (md && md.fiftyTwoWeekHigh) {
+          markdown += `**52-Week Context:**\n`;
+          markdown += `- **High:** $${md.fiftyTwoWeekHigh?.toFixed(2)} (${md.from52wHigh?.toFixed(1)}%) | **Low:** $${md.fiftyTwoWeekLow?.toFixed(2)} (+${md.from52wLow?.toFixed(1)}%)\n\n`;
+        }
+        
+        const macro = data.macro;
+        if (macro) {
+          markdown += `**Macro Context:**\n`;
+          markdown += `- **Regime:** ${macro.market_regime || '--'} | **10Y Yield:** ${macro.tnx_yield ? macro.tnx_yield + '%' : '--'} | **SPY Corr:** ${macro.sp500_correlation || '--'}\n\n`;
+        }
+        if (v && v.reasons && v.reasons.length > 0) {
+          markdown += `**AI Reasoning:**\n`;
+          v.reasons.forEach((r: string) => {
+            markdown += `- ${r}\n`;
+          });
+        }
+
+        finalMessages.push({ role: 'assistant', content: markdown, data, type: 'longterm' });
+      } else if (command.toLowerCase() === '/newsintel') {
+        const res = await fetch('/api/news-intel', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+        });
+        if (!res.ok) throw new Error('News intel failed');
+        const data = await res.json();
+        
+        let markdown = `**Latest Market News Intelligence**\n\n`;
+        const sent = data.sentiment;
+        if (sent) {
+          markdown += `**Market Sentiment Overview:**\n`;
+          markdown += `- **Fear & Greed:** ${sent.fear_greed?.value || '--'} (${sent.fear_greed?.label || 'N/A'})\n`;
+          if (sent.stocktwits_data?.bull_ratio) markdown += `- **StockTwits Bull %:** ${sent.stocktwits_data.bull_ratio.toFixed(0)}%\n`;
+          markdown += `- **Headlines Analyzed:** ${data.totalHeadlines || 0}\n`;
+          if (sent.summary?.overall_signals) markdown += `- **Signals:** ${sent.summary.overall_signals.join(' | ')}\n\n`;
+        }
+
+
+        markdown += `**Top Headlines:**\n`;
+        const headlines = data.headlines || [];
+        headlines.slice(0, 5).forEach((h: any) => {
+          markdown += `- **[${h.source}]** ${h.title} *(Sentiment: ${h.sentiment})*\n`;
+        });
+
+        finalMessages.push({ role: 'assistant', content: markdown, data, type: 'newsintel' });
+      } else {
+        const res = await fetch('/api/chat/stream', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            message: command,
+            history: updatedMessages,
+          }),
+        });
+
+        if (!res.ok) throw new Error('Failed to start stream');
+        const reader = res.body?.getReader();
+        if (!reader) throw new Error('No readable stream');
+
+        let accumulatedContent = '';
+        const decoder = new TextDecoder();
+        let buffer = '';
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split('\n');
+          buffer = lines.pop() || '';
+
+          let currentEvent = '';
+          for (const line of lines) {
+            if (line.startsWith('event: ')) {
+              currentEvent = line.substring(7).trim();
+            } else if (line.startsWith('data: ')) {
+              const dataStr = line.substring(6).trim();
+              if (!dataStr) continue;
+
+              if (currentEvent === 'token') {
+                // Since SSE often encodes newlines in JSON or escapes them, we must handle it.
+                // In our implementation, if data is string, it's sent as `data: text` directly.
+                let token = dataStr;
+                try { token = JSON.parse(dataStr); } catch {} // just in case it was JSON-stringified
+                
+                // If the engine emits real newlines, SSE requires data: on each line or \n encoding.
+                // Our simple SSE token format encodes it as JSON or plain string.
+                if (typeof token === 'string') {
+                  // Reconstruct newlines if it was replaced (e.g. JSON stringify handles \n)
+                  accumulatedContent += token.replace(/\\n/g, '\n');
+                } else if (token && typeof token === 'object' && token.message) {
+                  accumulatedContent += token.message;
+                } else {
+                  accumulatedContent += String(token);
+                }
+                setStreamingContent(accumulatedContent);
+              } else if (currentEvent === 'tool_start') {
+                try {
+                  const data = JSON.parse(dataStr);
+                  setToolStatuses(prev => [...prev, { tool: data.tool, status: 'running' }]);
+                } catch (e) {}
+              } else if (currentEvent === 'tool_result') {
+                try {
+                  const data = JSON.parse(dataStr);
+                  setToolStatuses(prev => {
+                    const next = [...prev];
+                    const idx = next.findIndex(t => t.tool === data.tool && t.status === 'running');
+                    if (idx !== -1) {
+                      next[idx] = { ...next[idx], status: 'done', result: data.fact };
+                    } else {
+                      next.push({ tool: data.tool, status: 'done', result: data.fact });
+                    }
+                    return next;
+                  });
+                } catch (e) {}
+              } else if (currentEvent === 'error') {
+                throw new Error(JSON.parse(dataStr).message || 'Stream error');
+              }
+            }
+          }
+        }
+        
+        finalMessages.push({
+          role: 'assistant',
+          content: accumulatedContent || 'No response received.',
+        });
+      }
+
+      setMessages(finalMessages);
+      setStreamingContent('');
+      setToolStatuses([]);
+      saveSession(activeChatId, finalMessages);
+
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'An error occurred');
+      const errMessages = [
+        ...updatedMessages,
+        {
+          role: 'assistant',
+          content: 'Sorry, I encountered an error processing your request. Please try again.',
+        } as ChatMessage,
+      ];
+      setMessages(errMessages);
+      setStreamingContent('');
+      setToolStatuses([]);
+      saveSession(activeChatId, errMessages);
+    } finally {
+      setLoading(false);
+      inputRef.current?.focus();
+    }
+  };
+
+  const handleKeyDown = (e: React.KeyboardEvent) => {
+    if (e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault();
+      sendMessage();
+    }
+  };
+
+
+
+  return (
+    <div className="animate-fadeIn">
+      {/* Header */}
+
+
+      {/* Chat Container */}
+      <div style={{ flex: 1, display: 'flex', flexDirection: 'column' }}>
+        <div className="chat-container">
+          {/* Messages */}
+          <div className="chat-messages">
+            {messages.length === 0 && !loading ? (
+              <div className="empty-state">
+                <div className="empty-state-icon">
+                  <svg width="56" height="56" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" strokeLinejoin="round">
+                    <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
+                  </svg>
+                </div>
+                <h3 className="empty-state-title">Start a conversation with BOZ</h3>
+                <p className="empty-state-text">
+                  Ask about market analysis, technical indicators, trading strategies, or any financial question.
+                </p>
+                <div className="grid-2 gap-3" style={{ marginTop: 'var(--space-4)', maxWidth: '500px' }}>
+                  <button
+                    className="btn btn-secondary"
+                    onClick={() => { setInput('What is the current market outlook?'); }}
+                  >
+                    Market outlook
+                  </button>
+                  <button
+                    className="btn btn-secondary"
+                    onClick={() => { setInput('/intraday NVDA'); }}
+                  >
+                    /intraday NVDA
+                  </button>
+                  <button
+                    className="btn btn-secondary"
+                    onClick={() => { setInput('/newsintel'); }}
+                  >
+                    /newsintel
+                  </button>
+                  <button
+                    className="btn btn-secondary"
+                    onClick={() => { setInput('/longterm AAPL'); }}
+                  >
+                    /longterm AAPL
+                  </button>
+                </div>
+              </div>
+            ) : (
+              <>
+                {messages.map((msg, i) => (
+                  <div key={i} className={`chat-bubble ${msg.role}`}>
+                    {msg.role === 'assistant' ? (
+                      <div className="flex-row gap-3">
+                        <div style={{ flexShrink: 0, width: 28, height: 28, borderRadius: 'var(--radius-sm)', background: 'var(--accent-gradient)', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
+                          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="var(--bg-primary)" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+                            <polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2" />
+                          </svg>
+                        </div>
+                        <div style={{ width: '100%' }}>
+                          {msg.type === 'intraday' && <IntradayCard data={msg.data} />}
+                          {msg.type === 'longterm' && <LongtermCard data={msg.data} />}
+                          {msg.type === 'newsintel' && <NewsIntelCard data={msg.data} />}
+                          <div dangerouslySetInnerHTML={{ __html: formatContent(msg.content) }} />
+                        </div>
+                      </div>
+                    ) : (
+                      <span>{msg.content}</span>
+                    )}
+                  </div>
+                ))}
+
+                {/* Loading indicator */}
+                {loading && (
+                  <div style={{ display: 'flex', flexDirection: 'row', gap: '12px', alignItems: 'flex-start', padding: '12px 0' }}>
+                    <div style={{ flexShrink: 0, width: 28, height: 28, borderRadius: 'var(--radius-sm)', background: 'var(--accent-gradient)', display: 'flex', alignItems: 'center', justifyContent: 'center', marginTop: '4px' }}>
+                      <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="var(--bg-primary)" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+                        <polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2" />
+                      </svg>
+                    </div>
+                    <div style={{ width: '100%' }}>
+                      {toolStatuses.length > 0 && (
+                        <div className="flex-col gap-2 mb-3 mt-1" style={{ fontSize: '0.85rem', color: 'var(--text-secondary)' }}>
+                          {toolStatuses.map((ts, idx) => (
+                            <div key={idx} className="flex-row items-center gap-2">
+                              {ts.status === 'running' ? (
+                                <span className="spinner spinner-sm"></span>
+                              ) : (
+                                <span>✅</span>
+                              )}
+                              <span>Using tool: <strong style={{ color: 'var(--text-primary)' }}>{ts.tool}</strong></span>
+                              {ts.result && <span style={{ opacity: 0.8 }}>ΓÇö {ts.result.substring(0, 80)}{ts.result.length > 80 ? '...' : ''}</span>}
+                            </div>
+                          ))}
+                        </div>
+                      )}
+                      
+                      {streamingContent ? (
+                        <div dangerouslySetInnerHTML={{ __html: formatContent(streamingContent) }} />
+                      ) : (
+                        <div className="flex-row gap-2 items-center" style={{ height: '28px' }}>
+                          {!toolStatuses.length && <span className="spinner spinner-sm"></span>}
+                          <span className="page-subtitle animate-fadeIn" key={loadingStep} style={{ margin: 0, transition: 'all 0.3s ease' }}>
+                            {(loadingType?.startsWith('/intraday') || loadingType?.startsWith('/longterm'))
+                              ? loadingMessages[loadingStep]
+                              : toolStatuses.length ? 'Analyzing data...' : 'Thinking...'}
+                          </span>
+                        </div>
+                      )}
+                    </div>
+                  </div>
+                )}
+
+                <div ref={messagesEndRef} />
+              </>
+            )}
+          </div>
+
+          {/* Input Area */}
+          <div className="chat-input-area">
+            <input
+              ref={inputRef}
+              type="text"
+              className="input"
+              placeholder="Ask BOZ anything about markets..."
+              value={input}
+              onChange={(e) => setInput(e.target.value)}
+              onKeyDown={handleKeyDown}
+              disabled={loading}
+            />
+            <button
+              className="btn btn-primary"
+              onClick={sendMessage}
+              disabled={loading || !input.trim()}
+            >
+              {loading ? (
+                <span className="spinner spinner-sm"></span>
+              ) : (
+                <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+                  <line x1="22" y1="2" x2="11" y2="13" />
+                  <polygon points="22 2 15 22 11 13 2 9 22 2" />
+                </svg>
+              )}
+            </button>
+          </div>
+        </div>
+      </div>
+
+      {/* Error toast */}
+      {error && (
+        <div className="toast-container">
+          <div className="toast error">
+            <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="var(--danger)" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+              <circle cx="12" cy="12" r="10" />
+              <line x1="15" y1="9" x2="9" y2="15" />
+              <line x1="9" y1="9" x2="15" y2="15" />
+            </svg>
+            {error}
+            <button className="btn btn-ghost btn-sm" onClick={() => setError(null)}>Γ£ò</button>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/app/chat/[id]/page.tsx b/src/app/chat/[id]/page.tsx
new file mode 100644
index 0000000..970abda
--- /dev/null
+++ b/src/app/chat/[id]/page.tsx
@@ -0,0 +1,6 @@
+import ChatComponent from '../ChatComponent';
+
+export default async function ChatSessionPage({ params }: { params: Promise<{ id: string }> }) {
+  const resolvedParams = await params;
+  return <ChatComponent chatId={resolvedParams.id} />;
+}
diff --git a/src/app/chat/page.tsx b/src/app/chat/page.tsx
index 25a2fe5..0bc9a23 100644
--- a/src/app/chat/page.tsx
+++ b/src/app/chat/page.tsx
@@ -1,246 +1,5 @@
-'use client';
-
-import { useState, useRef, useEffect } from 'react';
-
-interface ChatMessage {
-  role: 'user' | 'assistant';
-  content: string;
-}
-
-function formatContent(content: string): string {
-  // Basic markdown-like formatting: bold, code, newlines
-  return content
-    .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
-    .replace(/`(.*?)`/g, '<code style="background:rgba(0,212,255,0.1);padding:2px 6px;border-radius:4px;font-family:var(--font-mono);font-size:var(--text-xs)">$1</code>')
-    .replace(/\n/g, '<br/>');
-}
+import ChatComponent from './ChatComponent';
 
 export default function ChatPage() {
-  const [messages, setMessages] = useState<ChatMessage[]>([]);
-  const [input, setInput] = useState('');
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const messagesEndRef = useRef<HTMLDivElement>(null);
-  const inputRef = useRef<HTMLInputElement>(null);
-
-  const scrollToBottom = () => {
-    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
-  };
-
-  useEffect(() => {
-    scrollToBottom();
-  }, [messages]);
-
-  useEffect(() => {
-    inputRef.current?.focus();
-  }, []);
-
-  const sendMessage = async () => {
-    if (!input.trim() || loading) return;
-
-    const userMessage: ChatMessage = { role: 'user', content: input.trim() };
-    const updatedMessages = [...messages, userMessage];
-    setMessages(updatedMessages);
-    setInput('');
-    setLoading(true);
-    setError(null);
-
-    try {
-      const res = await fetch('/api/chat', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          message: userMessage.content,
-          history: updatedMessages,
-        }),
-      });
-
-      if (!res.ok) throw new Error('Failed to get response');
-
-      const data = await res.json();
-      const assistantMessage: ChatMessage = {
-        role: 'assistant',
-        content: data.response || data.message || 'No response received.',
-      };
-      setMessages([...updatedMessages, assistantMessage]);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'An error occurred');
-      // Add error message as assistant response
-      setMessages([
-        ...updatedMessages,
-        {
-          role: 'assistant',
-          content: 'Sorry, I encountered an error processing your request. Please try again.',
-        },
-      ]);
-    } finally {
-      setLoading(false);
-      inputRef.current?.focus();
-    }
-  };
-
-  const handleKeyDown = (e: React.KeyboardEvent) => {
-    if (e.key === 'Enter' && !e.shiftKey) {
-      e.preventDefault();
-      sendMessage();
-    }
-  };
-
-  const clearChat = () => {
-    setMessages([]);
-    setError(null);
-    inputRef.current?.focus();
-  };
-
-  return (
-    <div className="animate-fadeIn">
-      {/* Header */}
-      <div className="page-header">
-        <div className="flex-row justify-between items-center">
-          <div>
-            <h1 className="page-title">Chat Agent</h1>
-            <p className="page-subtitle">AI-powered market analysis assistant</p>
-          </div>
-          {messages.length > 0 && (
-            <button className="btn btn-ghost" onClick={clearChat}>
-              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
-                <polyline points="3 6 5 6 21 6" />
-                <path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" />
-              </svg>
-              Clear Chat
-            </button>
-          )}
-        </div>
-      </div>
-
-      {/* Chat Container */}
-      <div className="glass-card flush">
-        <div className="chat-container">
-          {/* Messages */}
-          <div className="chat-messages">
-            {messages.length === 0 && !loading ? (
-              <div className="empty-state">
-                <div className="empty-state-icon">
-                  <svg width="56" height="56" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" strokeLinejoin="round">
-                    <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
-                  </svg>
-                </div>
-                <h3 className="empty-state-title">Start a conversation with BOZ</h3>
-                <p className="empty-state-text">
-                  Ask about market analysis, technical indicators, trading strategies, or any financial question.
-                </p>
-                <div className="grid-2 gap-3" style={{ marginTop: 'var(--space-4)', maxWidth: '500px' }}>
-                  <button
-                    className="btn btn-secondary"
-                    onClick={() => { setInput('What is the current market outlook?'); }}
-                  >
-                    📊 Market outlook
-                  </button>
-                  <button
-                    className="btn btn-secondary"
-                    onClick={() => { setInput('Analyze NVDA for intraday trading'); }}
-                  >
-                    📈 Analyze NVDA
-                  </button>
-                  <button
-                    className="btn btn-secondary"
-                    onClick={() => { setInput('What are the best momentum stocks today?'); }}
-                  >
-                    🔥 Momentum stocks
-                  </button>
-                  <button
-                    className="btn btn-secondary"
-                    onClick={() => { setInput('Explain the current VIX level'); }}
-                  >
-                    ΓÜí Explain VIX
-                  </button>
-                </div>
-              </div>
-            ) : (
-              <>
-                {messages.map((msg, i) => (
-                  <div key={i} className={`chat-bubble ${msg.role}`}>
-                    {msg.role === 'assistant' ? (
-                      <div className="flex-row gap-3">
-                        <div style={{ flexShrink: 0, width: 28, height: 28, borderRadius: 'var(--radius-sm)', background: 'var(--accent-gradient)', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
-                          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="var(--bg-primary)" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
-                            <polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2" />
-                          </svg>
-                        </div>
-                        <div dangerouslySetInnerHTML={{ __html: formatContent(msg.content) }} />
-                      </div>
-                    ) : (
-                      <span>{msg.content}</span>
-                    )}
-                  </div>
-                ))}
-
-                {/* Loading indicator */}
-                {loading && (
-                  <div className="chat-bubble assistant">
-                    <div className="flex-row gap-3 items-center">
-                      <div style={{ flexShrink: 0, width: 28, height: 28, borderRadius: 'var(--radius-sm)', background: 'var(--accent-gradient)', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
-                        <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="var(--bg-primary)" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
-                          <polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2" />
-                        </svg>
-                      </div>
-                      <div className="flex-row gap-2 items-center">
-                        <span className="spinner spinner-sm"></span>
-                        <span className="page-subtitle">Thinking...</span>
-                      </div>
-                    </div>
-                  </div>
-                )}
-
-                <div ref={messagesEndRef} />
-              </>
-            )}
-          </div>
-
-          {/* Input Area */}
-          <div className="chat-input-area">
-            <input
-              ref={inputRef}
-              type="text"
-              className="input"
-              placeholder="Ask BOZ anything about markets..."
-              value={input}
-              onChange={(e) => setInput(e.target.value)}
-              onKeyDown={handleKeyDown}
-              disabled={loading}
-            />
-            <button
-              className="btn btn-primary"
-              onClick={sendMessage}
-              disabled={loading || !input.trim()}
-            >
-              {loading ? (
-                <span className="spinner spinner-sm"></span>
-              ) : (
-                <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
-                  <line x1="22" y1="2" x2="11" y2="13" />
-                  <polygon points="22 2 15 22 11 13 2 9 22 2" />
-                </svg>
-              )}
-            </button>
-          </div>
-        </div>
-      </div>
-
-      {/* Error toast */}
-      {error && (
-        <div className="toast-container">
-          <div className="toast error">
-            <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="var(--danger)" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
-              <circle cx="12" cy="12" r="10" />
-              <line x1="15" y1="9" x2="9" y2="15" />
-              <line x1="9" y1="9" x2="15" y2="15" />
-            </svg>
-            {error}
-            <button className="btn btn-ghost btn-sm" onClick={() => setError(null)}>Γ£ò</button>
-          </div>
-        </div>
-      )}
-    </div>
-  );
+  return <ChatComponent />;
 }
diff --git a/src/app/components/layout/Sidebar.tsx b/src/app/components/layout/Sidebar.tsx
index fdf0b98..49f857b 100644
--- a/src/app/components/layout/Sidebar.tsx
+++ b/src/app/components/layout/Sidebar.tsx
@@ -1,6 +1,6 @@
 'use client';
 
-import { useState } from 'react';
+import { useState, useEffect } from 'react';
 import Link from 'next/link';
 import { usePathname } from 'next/navigation';
 
@@ -16,21 +16,6 @@ const navItems: NavItem[] = [
     href: '/',
     icon: <i className="fa-solid fa-house" style={{ fontSize: '18px' }}></i>,
   },
-  {
-    label: 'Intraday Analysis',
-    href: '/analyze/intraday',
-    icon: <i className="fa-solid fa-chart-line" style={{ fontSize: '18px' }}></i>,
-  },
-  {
-    label: 'Long-term Analysis',
-    href: '/analyze/longterm',
-    icon: <i className="fa-solid fa-chart-pie" style={{ fontSize: '18px' }}></i>,
-  },
-  {
-    label: 'News Intel',
-    href: '/news-intel',
-    icon: <i className="fa-regular fa-newspaper" style={{ fontSize: '18px' }}></i>,
-  },
   {
     label: 'Chat Agent',
     href: '/chat',
@@ -45,8 +30,27 @@ const navItems: NavItem[] = [
 
 export default function Sidebar() {
   const [collapsed, setCollapsed] = useState(false);
+  const [chatSessions, setChatSessions] = useState<{id: string, title: string}[]>([]);
   const pathname = usePathname();
 
+  useEffect(() => {
+    const loadSessions = () => {
+      try {
+        const stored = localStorage.getItem('boz_chat_sessions');
+        if (stored) {
+          let sessions = JSON.parse(stored);
+          sessions.sort((a: any, b: any) => b.updatedAt - a.updatedAt);
+          setChatSessions(sessions);
+        } else {
+          setChatSessions([]);
+        }
+      } catch (e) {}
+    };
+    loadSessions();
+    window.addEventListener('boz_chat_updated', loadSessions);
+    return () => window.removeEventListener('boz_chat_updated', loadSessions);
+  }, []);
+
   const isActive = (href: string) => {
     if (href === '/') return pathname === '/';
     return pathname.startsWith(href);
@@ -60,14 +64,29 @@ export default function Sidebar() {
 
       <nav className="sidebar-nav">
         {navItems.map((item) => (
-          <Link
-            key={item.href}
-            href={item.href}
-            className={`sidebar-link${isActive(item.href) ? ' active' : ''}`}
-          >
-            <span className="sidebar-link-icon">{item.icon}</span>
-            <span className="sidebar-link-label">{item.label}</span>
-          </Link>
+          <div key={item.href}>
+            <Link
+              href={item.href}
+              className={`sidebar-link${isActive(item.href) ? ' active' : ''}`}
+            >
+              <span className="sidebar-link-icon">{item.icon}</span>
+              <span className="sidebar-link-label">{item.label}</span>
+            </Link>
+            {item.href === '/chat' && isActive('/chat') && chatSessions.length > 0 && !collapsed && (
+              <div style={{ paddingLeft: '40px', marginTop: '4px', marginBottom: '8px', display: 'flex', flexDirection: 'column', gap: '4px', maxHeight: '180px', overflowY: 'auto' }}>
+                <div style={{ fontSize: '10px', color: 'var(--text-muted)', textTransform: 'uppercase', letterSpacing: '0.05em', marginBottom: '4px' }}>Recent Chats</div>
+                {chatSessions.slice(0, 5).map(session => (
+                  <Link 
+                    key={session.id} 
+                    href={`/chat/${session.id}`}
+                    style={{ fontSize: '12px', color: pathname === `/chat/${session.id}` ? 'var(--text-primary)' : 'var(--text-muted)', textDecoration: 'none', whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis', padding: '4px 0' }}
+                  >
+                    {session.title}
+                  </Link>
+                ))}
+              </div>
+            )}
+          </div>
         ))}
       </nav>
 
@@ -83,7 +102,7 @@ export default function Sidebar() {
           <span className="sidebar-link-label">Settings</span>
         </Link>
         <div style={{ display: 'flex', justifyContent: collapsed ? 'center' : 'space-between', alignItems: 'center', width: '100%' }}>
-          {!collapsed && <span className="sidebar-version" style={{ fontSize: '10px' }}>v2.0.0</span>}
+          {!collapsed && <span className="sidebar-version" style={{ fontSize: '10px' }}>v2.1.0</span>}
           <button
             className="sidebar-collapse-btn"
             onClick={() => setCollapsed(!collapsed)}
diff --git a/src/app/components/layout/TopBar.tsx b/src/app/components/layout/TopBar.tsx
index 4a6bbeb..aadd0d1 100644
--- a/src/app/components/layout/TopBar.tsx
+++ b/src/app/components/layout/TopBar.tsx
@@ -50,18 +50,7 @@ export default function TopBar() {
         }
       `}</style>
       <header className="topbar">
-      <div className="topbar-search">
-        <svg className="topbar-search-icon" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-          <circle cx="7" cy="7" r="5" stroke="currentColor" strokeWidth="1.5" />
-          <line x1="11" y1="11" x2="14" y2="14" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" />
-        </svg>
-        <input
-          type="text"
-          className="topbar-search-input"
-          placeholder="Search assets, analysis..."
-          aria-label="Search"
-        />
-      </div>
+
 
       <div className="topbar-actions">
         <div ref={dropdownRef} style={{ position: 'relative' }}>
diff --git a/src/app/styles/components.css b/src/app/styles/components.css
index a5cea8e..a67e12e 100644
--- a/src/app/styles/components.css
+++ b/src/app/styles/components.css
@@ -509,8 +509,8 @@
 
 .chat-bubble.assistant {
   align-self: flex-start;
-  background: var(--surface-glass);
-  border: 1px solid var(--border-glass);
+  background: transparent;
+  border: none;
   color: var(--text-primary);
 }
 
@@ -803,3 +803,26 @@
   font-size: var(--text-sm);
   max-width: 400px;
 }
+
+/* Markdown inside Chat Bubbles */
+.chat-bubble.assistant p {
+  margin-bottom: var(--space-4);
+}
+.chat-bubble.assistant p:last-child {
+  margin-bottom: 0;
+}
+.chat-bubble.assistant ul, .chat-bubble.assistant ol {
+  margin-bottom: var(--space-4);
+  padding-left: var(--space-5);
+}
+.chat-bubble.assistant li {
+  margin-bottom: var(--space-2);
+}
+.chat-bubble.assistant h1, .chat-bubble.assistant h2, .chat-bubble.assistant h3, .chat-bubble.assistant h4 {
+  margin-top: var(--space-5);
+  margin-bottom: var(--space-3);
+  font-weight: 600;
+}
+.chat-bubble.assistant h1:first-child, .chat-bubble.assistant h2:first-child, .chat-bubble.assistant h3:first-child, .chat-bubble.assistant h4:first-child {
+  margin-top: 0;
+}
diff --git a/src/services/ai/ai.service.ts b/src/services/ai/ai.service.ts
index 9f9e1ef..87876e3 100644
--- a/src/services/ai/ai.service.ts
+++ b/src/services/ai/ai.service.ts
@@ -86,7 +86,8 @@ function buildSystemPrompt(): string {
     `ACCURACY CHECK (do before answering):\n` +
     `  - Use only evidence from the provided data; do not invent metrics or news.\n` +
     `  - If a key data point is missing, say so and lower confidence.\n` +
-    `  - Ensure prediction, confidence, and levels align with cited signals.\n\n` +
+    `  - Ensure prediction, confidence, and levels align with cited signals.\n` +
+    `  - IMPORTANT: Rarely use emojis in your response. Keep text highly professional.\n\n` +
     JSON_OUTPUT_RULES
   );
 }
diff --git a/src/services/ai/llm.schemas.ts b/src/services/ai/llm.schemas.ts
index d08816c..816ab5a 100644
--- a/src/services/ai/llm.schemas.ts
+++ b/src/services/ai/llm.schemas.ts
@@ -10,10 +10,10 @@ export const aiPredictionSchema = {
     status: { type: 'string', enum: ['ok', 'uncertain', 'error'] },
     prediction: { type: 'string', enum: ['UP', 'DOWN', 'UNKNOWN'] },
     confidence: { type: 'number', minimum: 0, maximum: 100 },
-    strategy: { type: 'string' },
+    strategy: { type: ['string', 'null'] },
     target_price: { type: ['number', 'null'] },
     stop_loss: { type: ['number', 'null'] },
-    reasons: { type: 'array', items: { type: 'string' }, maxItems: 5 },
+    reasons: { type: 'array', items: { type: 'string' } },
     reason: { type: 'string' },
   },
   oneOf: [