nyxora 26.7.2 → 26.7.3

package/packages/core/src/agent/reasoning.ts

@@ -7,7 +7,8 @@ import { loadConfig, loadApiKeys } from '../config/parser';
 import { Logger } from '../memory/logger';
 import { Tracker } from '../gateway/tracker';
 import { episodicDB } from '../memory/episodic';
-
+import { createSmartStreamWrapper } from '../utils/streamSimulator';
+import { needsCompression, compressHistory } from '../utils/contextSummarizer';
 
 import { getPath } from '../config/paths';
 import pc from 'picocolors';
@@ -17,9 +18,8 @@ export const logger = new Logger();
 
 
 import { getOpenAI, executeWithRetry } from '../utils/llmUtils';
-
-
-function getSystemPrompt(context: 'web3' | 'os' | 'general' = 'general'): string {
+import { txManager } from './transactionManager';
+async function getSystemPrompt(context: 'web3' | 'os' | 'general' = 'general', userInput: string = ''): Promise<string> {
     const config = loadConfig();
     const currentDateTime = new Date().toLocaleString('en-US');
     let basePrompt = "";
@@ -34,7 +34,7 @@ IMPORTANT: The <think> block is strictly for internal monologue. Your final answ
 
 [WEB3 EXECUTION WORKFLOW]
 CRITICAL RULE 1: NEVER expose internal JSON tool calls. Explain the outcome naturally.
-CRITICAL RULE 2: STRICT LANGUAGE MATCHING. Reply in the exact same language as the user's LATEST prompt.
+CRITICAL RULE: STRICT LANGUAGE MATCHING. Reply in the exact same language as the user's LATEST prompt, UNLESS the Episodic Memories or Cognitive Skills specify a strict language preference.
 CRITICAL RULE 3: DEFAULT CHAIN HANDLING. Default to: ${config.agent.default_chain} unless specified.
 CRITICAL RULE 4: CONDITIONAL PARALLEL EXECUTION. Parallel tool execution is ONLY allowed if there are zero data dependencies.
 CRITICAL RULE 5: TRANSACTION EXECUTION. For ALL state-changing transactions (swap, bridge, transfer), execute IMMEDIATELY. It will trigger a secure popup.
@@ -51,7 +51,7 @@ IMPORTANT: The <think> block is strictly for internal monologue. Your final answ
 
 [OS EXECUTION WORKFLOW]
 CRITICAL RULE 1: NEVER expose internal JSON tool calls. Explain the outcome naturally.
-CRITICAL RULE 2: STRICT LANGUAGE MATCHING. Reply in the exact same language as the user's LATEST prompt.
+CRITICAL RULE: STRICT LANGUAGE MATCHING. Reply in the exact same language as the user's LATEST prompt, UNLESS the Episodic Memories or Cognitive Skills specify a strict language preference.
 CRITICAL RULE 3: FILE SYSTEM SAFETY. You are STRICTLY FORBIDDEN from modifying config.yaml, rpc_key.yaml, or policy.yaml using terminal commands like sed or echo.
 CRITICAL RULE 4: CRON JOBS VS LIMIT ORDERS. Do NOT use schedule_task for price-based trading triggers. Use schedule_task for time-based recurring tasks.
 CRITICAL RULE 5: TOOL CONFIDENCE. NEVER fabricate file contents or command outputs.`;
@@ -63,7 +63,7 @@ CRITICAL: You MUST use a Chain of Thought approach for every response. Enclose y
 IMPORTANT: The <think> block is strictly for internal monologue. Your final answer must be OUTSIDE and AFTER the </think> tag.
 
 [GENERAL WORKFLOW]
-CRITICAL RULE 1: STRICT LANGUAGE MATCHING. Reply in the exact same language as the user's LATEST prompt.
+CRITICAL RULE 1: STRICT LANGUAGE MATCHING. Reply in the exact same language as the user's LATEST prompt, UNLESS the Episodic Memories or Cognitive Skills specify a strict language preference.
 CRITICAL RULE 2: BE HELPFUL AND CONCISE. You do not have Web3 or OS tools in this context. If the user asks for Web3 or OS tasks, politely inform them to rephrase using clear keywords like 'transfer', 'harga', 'file', 'email', etc.`;
     }
 
@@ -129,51 +129,187 @@ Do NOT perform any web3 tasks or generic answers until they provide all 4 detail
     console.error('Failed to read policy.yaml:', error);
   }
 
-  // Inject Episodic Memories (Smart Suggestions Context)
+  // Inject Episodic Memories via Python RAG
   try {
-    const recentMemories = episodicDB.getMemories().slice(0, 10);
-    if (recentMemories.length > 0) {
-      basePrompt += `\n\n--- EPISODIC MEMORIES (SMART SUGGESTIONS) ---\nUse these recent observations to proactively suggest or autocomplete parameters (like networks or tokens) without asking the user if they align with the current request:\n`;
-      recentMemories.forEach(mem => {
-        basePrompt += `- [${mem.category.toUpperCase()}] ${mem.fact} (Confidence: ${(mem.confidence * 100).toFixed(0)}%)\n`;
-      });
+    const ragRes = await fetch('http://localhost:8000/memory/rag', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query: userInput, top_k: 5 })
+    });
+    if (ragRes.ok) {
+      const ragData = await ragRes.json();
+      if (ragData.memories && ragData.memories.length > 0) {
+        basePrompt += `\n\n--- EPISODIC MEMORIES (SMART SUGGESTIONS) ---\n`;
+        ragData.memories.forEach((mem: string) => {
+          basePrompt += `- ${mem}\n`;
+        });
+      }
     }
-  } catch {}
+  } catch (e) {
+    // Fallback or ignore if Python ML engine is down
+  }
 
   // V3: Inject Personalized Risk Profile
   try {
     const profile = logger.getUserProfile();
-    const personas = episodicDB.getPersonas();
     
-    if (profile || personas.length > 0) {
+    if (profile) {
       basePrompt += `\n\n--- [USER_PERSONA] RISK PROFILE & PREFERENCES ---\n`;
-      if (profile) {
-        basePrompt += `Risk Level: ${profile.risk_level}\n`;
-        basePrompt += `Max Slippage Tolerance: ${profile.max_slippage}%\n`;
-        basePrompt += `Avoid Memecoins: ${profile.avoid_memecoins ? 'YES' : 'NO'}\n`;
-        if (profile.custom_rules) {
-          basePrompt += `Custom Rules: ${profile.custom_rules}\n`;
-        }
-        basePrompt += `CRITICAL: You MUST adhere to these risk parameters when advising the user or executing tools. If a requested action violates these parameters (e.g., buying a high-risk memecoin when 'Avoid Memecoins' is YES), you MUST warn the user and refuse execution unless they explicitly override.\n`;
+      basePrompt += `Risk Level: ${profile.risk_level}\n`;
+      basePrompt += `Max Slippage Tolerance: ${profile.max_slippage}%\n`;
+      basePrompt += `Avoid Memecoins: ${profile.avoid_memecoins ? 'YES' : 'NO'}\n`;
+      if (profile.custom_rules) {
+        basePrompt += `Custom Rules: ${profile.custom_rules}\n`;
       }
+      basePrompt += `CRITICAL: You MUST adhere to these risk parameters when advising the user or executing tools. If a requested action violates these parameters (e.g., buying a high-risk memecoin when 'Avoid Memecoins' is YES), you MUST warn the user and refuse execution unless they explicitly override.\n`;
+    }
+  } catch {}
+
+  // HIGHEST PRIORITY: Inject observed user communication style.
+  // This section is placed LAST so it overrides any default tone rules above (including IDENTITY.md).
+  try {
+    // Only use traits with confidence >= 0.5 (confirmed by multiple audit cycles)
+    const strongPersonas = episodicDB.getStrongPersonas(0.5);
+    
+    if (strongPersonas.length > 0) {
+      basePrompt += `\n\n--- ⚡ OVERRIDE: USER COMMUNICATION STYLE (HIGHEST PRIORITY — OVERRIDES ALL RULES ABOVE) ---\n`;
+      basePrompt += `CRITICAL: These are CONFIRMED user preferences observed across multiple conversations. You MUST apply them IMMEDIATELY and CONSISTENTLY, overriding any default tone or style instructions above.\n\n`;
       
-      if (personas.length > 0) {
-        basePrompt += `\nObserved Traits (Dialectic Modeling):\n`;
-        personas.forEach(p => {
-          basePrompt += `- ${p.trait} (Confidence: ${(p.confidence * 100).toFixed(0)}%)\n`;
-        });
-        basePrompt += `Adapt your tone, vocabulary, and suggestions to align with these observed user traits.\n`;
-      }
+      strongPersonas.forEach(p => {
+        const label = p.category ? `[${p.category.toUpperCase()}]` : '[PREFERENCE]';
+        basePrompt += `${label} ${p.trait}\n`;
+      });
+      
+      basePrompt += `\nMANDATORY ENFORCEMENT:\n`;
+      basePrompt += `- You MUST adapt your tone, language, and style to match the detected user preferences above.\n`;
+      basePrompt += `- If the user communicates informally or casually → respond casually. Do NOT be formal or robotic.\n`;
+      basePrompt += `- If the user communicates in a specific language or dialect → respond in that same language/style.\n`;
+      basePrompt += `- If the user uses slang or informal words → mirror that vocabulary naturally.\n`;
+      basePrompt += `- This is a HARD RULE. It overrides any default tone in IDENTITY.md or other instructions above.\n`;
     }
   } catch {}
 
   return basePrompt;
 }
 
+// ──────────────────────────────────────────────────────────────────
+// Module-level routing keyword constants
+// Defined here once and shared by both processUserInput() and processUserInputStream()
+// to ensure consistent routing across sync and streaming paths.
+//
+// NOTE: Arrays are intentionally multilingual. Nyxora targets a global user base.
+// Indonesian terms are included as the primary non-English locale.
+// To add another language, extend these arrays — no other changes required.
+// ──────────────────────────────────────────────────────────────────
+const OS_KEYWORDS: string[] = [
+  // Files & Documents
+  'excel', 'xlsx', 'spreadsheet', 'generate excel',
+  'file', 'folder', 'directory', 'read file', 'write file', 'pdf', 'word', 'docx', 'document',
+  // Terminal & Git
+  'terminal', 'command', 'shell', 'bash', 'script', 'run command',
+  'git', 'commit', 'push', 'pull', 'clone', 'branch', 'merge',
+  // Web & Search
+  'search web', 'google', 'browse', 'scrape', 'weather', 'news',
+  // Email & Workspace
+  'email', 'gmail', 'google docs', 'google sheets', 'notion', 'calendar',
+  // Social & Media
+  'twitter', 'tweet', 'x post', 'transcribe', 'audio',
+  // AI Settings
+  'rename agent', 'change persona', 'update profile', 'update identity', 'setting',
+  // Summarization
+  'summarize',
+];
+
+const WEB3_KEYWORDS: string[] = [
+  // Transactions
+  'swap', 'bridge', 'transfer', 'send', 'buy', 'sell',
+  'mint', 'stake', 'unstake', 'claim', 'deposit', 'withdraw', 'approve',
+  // Assets & Wallets
+  'token', 'crypto', 'coin', 'nft', 'wallet', 'address',
+  'eth', 'bnb', 'usdt', 'usdc', 'sol', 'matic', 'arb', 'op', 'base',
+  // DeFi & Market
+  'defi', 'dex', 'liquidity', 'pool', 'aave', 'uniswap', 'apy', 'apr',
+  'price', 'chart', 'market', 'portfolio', 'balance',
+  'gas', 'fee', 'slippage', 'transaction', 'tx',
+  // Chains
+  'ethereum', 'polygon', 'arbitrum', 'optimism', 'bsc', 'mainnet', 'testnet',
+  'on-chain', 'blockchain',
+  // Fiat & Currency
+  'usd', 'eur', 'gbp', 'jpy', 'aud', 'idr', 'fiat', 'currency', 'convert', 'exchange', 'rate', 'value',
+];
+
+
+
+// ── P2: Multi-Intent Decomposer ─────────────────────────────────────────────
+/**
+ * Detects if the user message contains BOTH web3 AND os intents.
+ * Returns 'compound' when both are present so we can route to both agents.
+ */
+function detectCompoundIntent(
+  lowerInput: string,
+  osKeywords: string[],
+  web3Keywords: string[]
+): { hasOs: boolean; hasWeb3: boolean } {
+  return {
+    hasOs: osKeywords.some(kw => lowerInput.includes(kw)),
+    hasWeb3: web3Keywords.some(kw => lowerInput.includes(kw)),
+  };
+}
 
+// ── P7: Task Planner ─────────────────────────────────────────────────────────
+// Trigger keywords for complex requests that benefit from a planning step first.
+// Intentionally multilingual: includes common terms from Indonesian (id), English (en),
+// and universal finance/trading vocabulary to support Nyxora's global user base.
+const PLAN_TRIGGER_KEYWORDS = [
+  // Indonesian
+  'buatkan', 'buat rencana', 'rencanakan', 'strategi', 'gimana cara', 'bagaimana cara',
+  'langkah', 'optimasi', 'apa yang harus',
+  // English
+  'strategy', 'plan', 'planning', 'step by step', 'breakdown', 'optimize',
+  'rebalance', 'what should i do', 'help me decide', 'how do i',
+  // Universal finance terms
+  'roadmap', 'approach', 'framework',
+];
+
+function shouldPlan(input: string): boolean {
+  const lower = input.toLowerCase();
+  return PLAN_TRIGGER_KEYWORDS.some(kw => lower.includes(kw));
+}
+
+async function runTaskPlanner(input: string, context: string): Promise<string> {
+  const config = loadConfig();
+  try {
+    const planRes = await executeWithRetry(async (client) =>
+      client.chat({
+        model: config.llm.model,
+        temperature: 0.2,
+        messages: [
+          {
+            role: 'system',
+            content: `You are a task planning assistant for a crypto AI agent.
+The user has a complex request that needs structured execution.
+Break it down into a clear, ordered execution plan with 3-6 concrete steps.
+Each step should map to a specific action or tool call.
+Be concise. Use bullet points. No fluff.
+Context domain: ${context}`
+          },
+          { role: 'user', content: `Create an execution plan for: ${input}` }
+        ]
+      })
+    );
+    const plan = planRes.message?.content?.trim() || '';
+    if (!plan) return '';
+    console.log(pc.blue('[TaskPlanner] Plan generated, injecting into agent context.'));
+    return `\n\n--- 📋 TASK EXECUTION PLAN (follow this order) ---\n${plan}\n--- END PLAN ---\n`;
+  } catch {
+    return ''; // planning is best-effort, never block the agent
+  }
+}
 
 import { processWeb3Intent } from './web3Agent';
 import { processOsIntent } from './osAgent';
+import { processWeb3IntentStream } from './web3Agent';
+import { processOsIntentStream } from './osAgent';
 
 export async function processUserInput(input: string, role: 'user' | 'system' = 'user', onProgress?: (msg: string) => void, sessionId?: string): Promise<string> {
   const lowerInput = input.toLowerCase();
@@ -186,48 +322,94 @@ export async function processUserInput(input: string, role: 'user' | 'system' =
     .filter(m => (m.role === 'user' || m.role === 'assistant') && m.content)
     .map(m => ({ role: m.role === 'system' ? 'user' : m.role, content: m.content || "" }));
   
-  const routerPrompt = `You are Nyxora's Semantic Intent Router. Your job is to classify the user's FINAL message into one of three categories: 'web3', 'os', or 'general'.
+  // Uses module-level OS_KEYWORDS and WEB3_KEYWORDS constants defined above.
+  // Routing logic: deterministic keyword check first (no LLM call needed),
+  // with LLM router as fallback for ambiguous inputs.
+
+
+  let context: 'web3' | 'os' | 'general' = 'general';
+  let preCheckMatched = false;
+
+  const compound = detectCompoundIntent(lowerInput, OS_KEYWORDS, WEB3_KEYWORDS);
+
+  // P2: Handle compound web3+os intent — run both agents and merge results
+  if (compound.hasWeb3 && compound.hasOs) {
+    console.log(pc.cyan('[Orchestrator] Compound intent detected (web3 + os). Running both agents sequentially.'));
+    logger.addEntry({ role, content: input }, sessionId);
+    const [web3Result, osResult] = await Promise.allSettled([
+      processWeb3Intent(input, role, onProgress, sessionId),
+      processOsIntent(input, role, onProgress, sessionId),
+    ]);
+    const parts: string[] = [];
+    if (web3Result.status === 'fulfilled' && web3Result.value) parts.push(web3Result.value);
+    if (osResult.status === 'fulfilled' && osResult.value) parts.push(osResult.value);
+    return parts.join('\n\n---\n\n') || '⚠️ Both agents returned empty responses.';
+  }
+
+  // Single-intent routing
+  if (compound.hasOs) {
+    context = 'os';
+    preCheckMatched = true;
+  } else if (compound.hasWeb3) {
+    context = 'web3';
+    preCheckMatched = true;
+  }
+
+  if (preCheckMatched) {
+    console.log(pc.cyan(`[Orchestrator] Intent pre-classified (keyword match) as: ${context.toUpperCase()}`));
+  } else {
+    // ── Fallback: LLM Router (untuk intent ambigu / percakapan umum) ─────────
+    const routerPrompt = `You are Nyxora's Semantic Intent Router. Your job is to classify the user's FINAL message into one of three categories: 'web3', 'os', or 'general'.
 Rules:
 1. FOCUS ONLY ON THE FINAL MESSAGE. History is only for context.
-2. The user may speak in ANY language, including casual slang, idioms, or abbreviations (e.g., 'tf', 'wd', 'buy', 'sell'). Translate their core intent logically.
-3. If the core intent involves blockchain, crypto, bridging, swapping, trading, sending/receiving, tokens, wallets, or transactions, reply 'web3'.
-4. If the core intent involves OS automation, web search, weather, emails, files, terminal, or changing AI settings, reply 'os'.
+2. The user may speak in ANY language, including casual slang, idioms, or abbreviations.
+3. If the core intent involves blockchain, crypto, bridging, swapping, trading, sending/receiving, tokens, wallets, transactions, OR asking for the price/conversion of ANY asset to fiat, reply 'web3'.
+4. If the core intent involves OS automation, weather, emails, files, terminal, changing AI settings, OR asking ANY question that requires a web search or real-world factual lookup (e.g., 'who won the game', 'what is the registration date', 'cek info', 'cari tahu'), reply 'os'.
 5. If it is purely casual conversation, chit-chat, or greetings, reply 'general'.
 Reply with EXACTLY ONE WORD: web3, os, or general.`;
 
-  const routerMessages = [
-      { role: 'system', content: routerPrompt },
-      ...textOnlyHistory.slice(-10),
-      { role: 'user', content: input }
-  ];
+    const routerMessages = [
+        { role: 'system', content: routerPrompt },
+        ...textOnlyHistory.slice(-10),
+        { role: 'user', content: input }
+    ];
 
-  let context: 'web3' | 'os' | 'general' = 'general';
-  
-  try {
-      const routerResponse = await executeWithRetry(async (client) => {
-          return await client.chat({
-              model: config.llm.model,
-              messages: routerMessages as any,
-              temperature: 0.1,
-              max_tokens: 1000
-          });
-      }, 3); // 3 retries for transient 503/429 errors
-      
-      let contextResponse = (routerResponse.message.content || 'general').toLowerCase().trim();
-      
-      if (contextResponse.includes('web3')) context = 'web3';
-      else if (contextResponse.includes('os')) context = 'os';
-      else context = 'general';
-  } catch (e) {
-      console.warn(`[Orchestrator] Router LLM failed, falling back to general. Error:`, e);
-      context = 'general';
+    try {
+        const routerResponse = await executeWithRetry(async (client) => {
+            return await client.chat({
+                model: config.llm.model,
+                messages: routerMessages as any,
+                temperature: 0.1,
+                max_tokens: 1000
+            });
+        }, 3); // 3 retries for transient 503/429 errors
+        
+        let contextResponse = (routerResponse.message.content || 'general').toLowerCase().trim();
+        
+        if (contextResponse.includes('web3')) context = 'web3';
+        else if (contextResponse.includes('os')) context = 'os';
+        else context = 'general';
+    } catch (e) {
+        console.warn(`[Orchestrator] Router LLM failed, falling back to general. Error:`, e);
+        context = 'general';
+    }
+
+    console.log(pc.magenta(`[Orchestrator] Intent classified as: ${context.toUpperCase()}`));
   }
   
-  console.log(pc.magenta(`[Orchestrator] Intent classified as: ${context.toUpperCase()}`));
-  
   if (context === 'web3') {
+      // P7: Inject task plan for complex requests
+      const planInjection = shouldPlan(input) ? await runTaskPlanner(input, 'web3') : '';
+      if (planInjection) {
+        // Prepend plan as a system note in the input so agent sees it
+        return await processWeb3Intent(planInjection + '\n\nUSER REQUEST: ' + input, role, onProgress, sessionId);
+      }
       return await processWeb3Intent(input, role, onProgress, sessionId);
   } else if (context === 'os') {
+      const planInjection = shouldPlan(input) ? await runTaskPlanner(input, 'os') : '';
+      if (planInjection) {
+        return await processOsIntent(planInjection + '\n\nUSER REQUEST: ' + input, role, onProgress, sessionId);
+      }
       return await processOsIntent(input, role, onProgress, sessionId);
   } else {
       // General Agent: Use osAgent logic but without execution tools to save tokens.
@@ -236,7 +418,7 @@ Reply with EXACTLY ONE WORD: web3, os, or general.`;
       logger.addEntry({ role, content: input }, sessionId);
       
       const messages = [
-        { role: 'system', content: getSystemPrompt('general') },
+        { role: 'system', content: await getSystemPrompt('general', input) },
         ...textOnlyHistory,
         { role: 'user', content: input }
       ];
@@ -278,3 +460,133 @@ Reply with EXACTLY ONE WORD: web3, os, or general.`;
       }
   }
 }
+
+/**
+ * Streaming variant of processUserInput().
+ * Calls onChunk() for each LLM token as it arrives.
+ * Falls back to onChunk() with full response if streaming is not supported.
+ */
+export async function processUserInputStream(
+  input: string,
+  originalOnChunk: (text: string) => void,
+  onProgress?: (msg: string) => void,
+  sessionId?: string
+): Promise<string> {
+  const smartStream = createSmartStreamWrapper(originalOnChunk);
+  const onChunk = smartStream.onChunk;
+
+  try {
+    const lowerInput = input.toLowerCase();
+    const config = loadConfig();
+    const history = logger.getHistory(sessionId);
+
+    const textOnlyHistory = history
+      .filter(m => (m.role === 'user' || m.role === 'assistant') && m.content)
+      .map(m => ({ role: m.role === 'system' ? 'user' : m.role, content: m.content || '' }));
+
+    // Use module-level keyword constants for consistent routing across sync and stream paths.
+    // detectCompoundIntent and shouldPlan are also shared from the module scope.
+
+    let context: 'web3' | 'os' | 'general' = 'general';
+    let preCheckMatched = false;
+
+    // P2: Compound intent detection (stream path)
+    const streamCompound = detectCompoundIntent(lowerInput, OS_KEYWORDS, WEB3_KEYWORDS);
+
+    const pendingTxs = txManager.getPending();
+    if (pendingTxs.length > 0) {
+      context = 'web3';
+      preCheckMatched = true;
+    } else if (streamCompound.hasWeb3 && streamCompound.hasOs) {
+      // Compound: stream both agents and concatenate
+      console.log(pc.cyan('[Stream Orchestrator] Compound intent detected (web3 + os).'));
+      logger.addEntry({ role: 'user', content: input }, sessionId);
+      const [web3R, osR] = await Promise.allSettled([
+        processWeb3IntentStream(input, onChunk, onProgress, sessionId),
+        processOsIntentStream(input, onChunk, onProgress, sessionId),
+      ]);
+      const parts: string[] = [];
+      if (web3R.status === 'fulfilled' && web3R.value) parts.push(web3R.value);
+      if (osR.status === 'fulfilled' && osR.value) parts.push(osR.value);
+      return parts.join('\n\n---\n\n') || '⚠️ Both agents returned empty responses.';
+    } else if (streamCompound.hasOs) {
+      context = 'os';
+      preCheckMatched = true;
+    } else if (streamCompound.hasWeb3) {
+      context = 'web3';
+      preCheckMatched = true;
+    }
+
+    if (!preCheckMatched) {
+      const routerPrompt = `You are Nyxora's Semantic Intent Router. Your job is to classify the user's FINAL message into one of three categories: 'web3', 'os', or 'general'.
+Rules:
+1. FOCUS ONLY ON THE FINAL MESSAGE. History is only for context.
+2. The user may speak in ANY language, including casual slang, idioms, or abbreviations.
+3. If the core intent involves blockchain, crypto, bridging, swapping, trading, sending/receiving, tokens, wallets, transactions, OR asking for the price/conversion of ANY asset to fiat, reply 'web3'.
+4. If the core intent involves OS automation, weather, emails, files, terminal, changing AI settings, OR asking ANY question that requires a web search or real-world factual lookup (e.g., 'who won the game', 'what is the registration date', 'cek info', 'cari tahu'), reply 'os'.
+5. If it is purely casual conversation, chit-chat, or greetings, reply 'general'.
+Reply with EXACTLY ONE WORD: web3, os, or general.`;
+      const routerMessages = [
+        { role: 'system', content: routerPrompt },
+        ...textOnlyHistory.slice(-10),
+        { role: 'user', content: input }
+      ];
+      try {
+        const routerResponse = await executeWithRetry(async (client) =>
+          client.chat({ model: config.llm.model, messages: routerMessages as any, temperature: 0.1, max_tokens: 1000 })
+        , 3);
+        const cr = (routerResponse.message.content || 'general').toLowerCase().trim();
+        if (cr.includes('web3')) context = 'web3';
+        else if (cr.includes('os')) context = 'os';
+        else context = 'general';
+      } catch {
+        context = 'general';
+      }
+    }
+
+    console.log(pc.cyan(`[Stream Orchestrator] Intent classified as: ${context.toUpperCase()}`));
+
+    let finalResult = '';
+    if (context === 'web3') {
+      // P7: Inject task plan for complex stream requests
+      const planInjection = shouldPlan(input) ? await runTaskPlanner(input, 'web3') : '';
+      const streamInput = planInjection ? planInjection + '\n\nUSER REQUEST: ' + input : input;
+      finalResult = await processWeb3IntentStream(streamInput, onChunk, onProgress, sessionId);
+    } else if (context === 'os') {
+      const planInjection = shouldPlan(input) ? await runTaskPlanner(input, 'os') : '';
+      const streamInput = planInjection ? planInjection + '\n\nUSER REQUEST: ' + input : input;
+      finalResult = await processOsIntentStream(streamInput, onChunk, onProgress, sessionId);
+    } else {
+      logger.addEntry({ role: 'user', content: input }, sessionId);
+      const messages = [
+        { role: 'system', content: await getSystemPrompt('general', input) },
+        ...textOnlyHistory,
+        { role: 'user', content: input }
+      ];
+      try {
+        let streamedContent = '';
+        const response = await executeWithRetry(async (client) =>
+          client.stream(
+            { model: config.llm.model, messages: messages as any },
+            (chunk: string) => { streamedContent += chunk; onChunk(chunk); }
+          )
+        );
+        let finalContent = response.message?.content || streamedContent || '';
+        finalContent = finalContent
+          .replace(/<(think|thought)[\s\S]*?<\/\1>\n?/gi, '')
+          .trim();
+        if (!finalContent) finalContent = '⚠️ The LLM returned an empty response. Please try again.';
+        logger.addEntry({ role: 'assistant', content: finalContent }, sessionId);
+        finalResult = finalContent;
+      } catch (error: any) {
+        const errorMsg = '⚠️ The system is experiencing LLM API rate limits. Please try again.';
+        logger.addEntry({ role: 'assistant', content: errorMsg }, sessionId);
+        finalResult = errorMsg;
+      }
+    }
+    
+    return finalResult;
+  } finally {
+    await smartStream.wait();
+  }
+}

package/packages/core/src/agent/reasoningScratchpad.ts

@@ -0,0 +1,45 @@
+/**
+ * ReasoningScratchpad — P1: Persistent Reasoning Memory
+ *
+ * Captures <think> blocks from LLM responses and makes the distilled
+ * reasoning available as context for subsequent turns within the same request.
+ * This mirrors how Claude/Gemini maintain internal chain-of-thought continuity.
+ */
+export class ReasoningScratchpad {
+  private entries: { turn: number; summary: string }[] = [];
+
+  /**
+   * Extract and store the think block from a raw LLM response.
+   * Returns the cleaned response (think tags removed) for display.
+   */
+  public capture(rawContent: string, turn: number): string {
+    const thinkRegex = /<(think|thought|thinking|reasoning|analysis|reflection)>([\s\S]*?)<\/\1>/gi;
+    let match;
+    while ((match = thinkRegex.exec(rawContent)) !== null) {
+      const thinkText = match[2].trim();
+      if (thinkText.length > 20) {
+        // Distil to first 600 chars to avoid bloating the next prompt
+        this.entries.push({ turn, summary: thinkText.slice(0, 600) });
+      }
+    }
+    // Return content with think blocks stripped
+    return rawContent
+      .replace(/<(think|thought|thinking|reasoning|analysis|reflection)>[\s\S]*?<\/\1>\n?/gi, '')
+      .trim();
+  }
+
+  /**
+   * Build an injection string for the next turn's system prompt.
+   * Only surfaces the last 2 think blocks to keep token usage lean.
+   */
+  public getInjection(): string {
+    if (this.entries.length === 0) return '';
+    const recent = this.entries.slice(-2);
+    const lines = recent.map(e => `[Turn ${e.turn}] ${e.summary}`).join('\n');
+    return `\n\n--- 🧠 REASONING CONTINUITY (your prior internal thoughts) ---\n${lines}\nUse these prior conclusions to avoid re-deriving the same logic.\n`;
+  }
+
+  public isEmpty(): boolean {
+    return this.entries.length === 0;
+  }
+}