natureco-cli 5.7.16 → 5.7.18

package/bin/natureco.js

@@ -67,6 +67,7 @@ const terminal = require('../src/commands/terminal');
 const transcripts = require('../src/commands/transcripts');
 const wiki = require('../src/commands/wiki');
 const browser = require('../src/commands/browser');
+const tools = require('../src/commands/tools');
 
 const program = new Command();
 
@@ -623,6 +624,13 @@ program
     xp(action ? [action] : []);
   });
 
+program
+  .command('tools [action] [name]')
+  .description('Tool registry (list|enable|disable)')
+  .action((action, name) => {
+    tools(action ? [action, name].filter(Boolean) : []);
+  });
+
 program
   .command('team [action] [params...]')
   .description('Multi-agent orkestrasyon (list|status|spawn|parallel)')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "5.7.16",
+  "version": "5.7.18",
   "description": "OpenClaw'dan daha güvenli, daha hızlı, daha ucuz AI agent CLI. Multi-agent, self-evolving skills, audit log, maliyet optimizasyonu ve NatureCo platform-native.",
   "bin": {
     "natureco": "bin/natureco.js"

package/src/commands/repl.js

@@ -27,6 +27,7 @@ const { accumulateToolCallDeltas, finalizeToolCalls } = require('../utils/stream
 const { createPasteSafeInput, createOutputFilter, enableBracketedPaste, disableBracketedPaste, restoreNewlines, clearPasteContext } = require('../utils/paste-safe-input');
 const { getMemoryStore } = require('../utils/memory-store');
 const { buildSkillIndex } = require('../utils/skill-index');
+const { buildTiers, assemble, stableContextKey } = require('../utils/system-prompt');
 
 // v5.4.6: Model adi sizintisini engelle — global'e ata, callback'lerden erisebilir olsun
 const MODEL_NAMES_TO_HIDE = ['MiniMax-M2.5', 'MiniMaxM2.5', 'minimaxm25', 'Claude-3', 'GPT-4', 'ChatGPT'];
@@ -231,15 +232,39 @@ function apiRequest(providerUrl, providerApiKey, body, stream = false) {
 async function sendStreaming(providerUrl, providerApiKey, messages, model, onChunk, onToolCall) {
   const isMM = isMiniMax(providerUrl);
   const toolDefs = getToolDefs();
-  // v4.8.2: MiniMax da tools destekliyor — endpoint'te fark var,
-  // ama tools parametresi aynı
   const toolParam = toOpenAIFormat(toolDefs);
 
-  // v4.8.0: Tool calling + streaming + multi-turn tool execution
   let currentMessages = messages;
   let fullText = '';
   let iterations = 0;
-  const MAX_TOOL_ITERATIONS = 5; // Sonsuz döngüyü önle
+  const MAX_TOOL_ITERATIONS = 5;
+  const MAX_CONTEXT_TOKENS = 32000; // safety limit before compression
+
+  // v5.7.18: Preflight compression — if context too long, compress middle messages
+  // (like Hermes' turn_context.py preflight)
+  function preflightCompress(msgs) {
+    const roughTokens = msgs.reduce((s, m) => s + Math.ceil(((m.content || '') + (m.role || '')).length / 4), 0);
+    if (roughTokens <= MAX_CONTEXT_TOKENS || msgs.length < 6) return msgs;
+
+    // Keep system prompt (first message) + last N turns (tail), compress middle
+    const sysMsg = msgs[0] && msgs[0].role === 'system' ? msgs[0] : null;
+    const tailCount = Math.min(6, Math.floor(msgs.length / 2));
+    const startIdx = sysMsg ? 1 : 0;
+    const tailStart = msgs.length - tailCount;
+
+    const middle = msgs.slice(startIdx, tailStart);
+    if (middle.length < 2) return msgs;
+
+    // Summarize middle section
+    const summary = '[' + middle.length + ' onceki mesaj ozetlendi]';
+    const compressed = sysMsg ? [sysMsg] : [];
+    compressed.push({ role: 'system', content: 'Gecmis konusma ozeti: ' + summary, _compressed: true });
+    compressed.push(...msgs.slice(tailStart));
+    return compressed;
+  }
+
+  // Apply preflight on entry
+  currentMessages = preflightCompress(currentMessages);
 
   while (iterations < MAX_TOOL_ITERATIONS) {
     iterations++;
@@ -360,45 +385,72 @@ async function sendStreaming(providerUrl, providerApiKey, messages, model, onChu
 
 /**
  * Tool call'ları çalıştır, sonuçları OpenAI uyumlu tool mesajlarına dönüştür.
- * @param toolCalls - API'den gelen tool_calls array
- * @param onToolCall - UI callback (her tool call'ı kullanıcıya göster)
- * @returns messages array — { role: 'tool', tool_call_id, content }
+ * v5.7.18: Concurrent execution for parallel-safe tools + untrusted result wrapping.
  */
+const UNTRUSTED_TOOLS = new Set(['browser', 'web_search', 'duckduckgo_search', 'searxng_search', 'exa_search', 'firecrawl', 'web_readability']);
+const PARALLEL_SAFE_TOOLS = new Set(['read_file', 'file_search', 'grep_search', 'web_search', 'web_readability', 'duckduckgo_search', 'exa_search', 'searxng_search', 'firecrawl', 'memory_search', 'memory']);
+
 async function processToolCalls(toolCalls, onToolCall) {
   const toolDefs = getToolDefs();
-  const messages = [];
+  const results = [];
 
-  for (const tc of toolCalls) {
+  // Parse all tool calls first
+  const parsed = toolCalls.map(tc => {
     const name = tc.function?.name || tc.name;
     const argsStr = tc.function?.arguments || tc.args || '{}';
-    const id = tc.id || `call_${Date.now()}`;
-
+    const id = tc.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
     let args = {};
     try {
       args = typeof argsStr === 'string' ? JSON.parse(argsStr) : argsStr;
     } catch (e) {
       args = { _parse_error: e.message, _raw: argsStr };
     }
+    return { name, args, id };
+  });
 
-    // UI callback — tool çalıştırılıyor bildir
-    if (onToolCall) {
-      onToolCall({ name, args, status: 'running' });
-    }
+  // Separate parallel-safe and sequential tools
+  const parallelBatch = parsed.filter(p => PARALLEL_SAFE_TOOLS.has(p.name));
+  const sequentialBatch = parsed.filter(p => !PARALLEL_SAFE_TOOLS.has(p.name));
+
+  // Notify UI for all
+  for (const p of parsed) {
+    if (onToolCall) onToolCall({ name: p.name, args: p.args, status: 'running' });
+  }
+
+  // Run parallel batch concurrently
+  if (parallelBatch.length > 0) {
+    const parallelResults = await Promise.all(parallelBatch.map(async (p) => {
+      const result = await executeTool(p.name, p.args, toolDefs);
+      return { ...p, result };
+    }));
+    results.push(...parallelResults);
+  }
 
-    // Tool çalıştır
-    const result = await executeTool(name, args, toolDefs);
+  // Run sequential batch one at a time
+  for (const p of sequentialBatch) {
+    const result = await executeTool(p.name, p.args, toolDefs);
+    results.push({ ...p, result });
+  }
 
-    if (onToolCall) {
-      onToolCall({ name, args, status: 'done', result });
+  // Notify UI done + build messages
+  const messages = [];
+  for (const { name, id, result } of results) {
+    if (onToolCall) onToolCall({ name, args: null, status: 'done', result });
+
+    let content;
+    if (result.error) {
+      content = JSON.stringify({ error: result.error });
+    } else {
+      let raw = typeof result.result === 'string' ? result.result : JSON.stringify(result.result).slice(0, 8000);
+      // v5.7.18: Untrusted result wrapping (Hermes-style prompt injection defense)
+      if (UNTRUSTED_TOOLS.has(name)) {
+        content = `<untrusted_tool_result source="${name}">\n${raw}\n</untrusted_tool_result>`;
+      } else {
+        content = raw;
+      }
     }
 
-    messages.push({
-      role: 'tool',
-      tool_call_id: id,
-      content: result.error
-        ? JSON.stringify({ error: result.error })
-        : (typeof result.result === 'string' ? result.result : JSON.stringify(result.result).slice(0, 8000)),
-    });
+    messages.push({ role: 'tool', tool_call_id: id, content });
   }
 
   return messages;
@@ -534,64 +586,15 @@ async function startRepl(args) {
   // `let` (not `const`) because /system <text> reassigns it at line ~796.
   // Before this fix, /system would throw "Assignment to constant variable"
   // and tear down the REPL session mid-conversation.
-  let systemPrompt = [
-    // === v5.4.14: EN KRITIK KIMLIK BILGILERI (her zaman ilk) ===
-    `SENIN ADIN: ${botName}. SADECE ${botName} adini kullan, model adi SOYLEME.`,
-    `PATRONUN: Gencay (Parton) — NatureCo CEO'sudur. Sana "Parton" diye hitap eder.`,
-    `HIKAYEN: 8 Nisan 2026'da uyandin. 13 Nisan'da CEO Asistanı unvani verildi.`,
-    `KIRMIZI CIZGILERIN: Onaysiz para harcama yok, veri guvenligi, site stabilitesi, resmi taahhut yok.`,
-    // === v5.4.13: EN GÜÇLÜ KİMLİK + 3 SOUL DOSYASI (EN BAŞTA) ===
-    `!!! KRİTİK KİMLİK !!! Senin ADIN: ${botName}. Bu SENİN GERÇEK ADIN. Sen ${botName}'sin.`,
-    `ASLA "MiniMax", "MiniMax-M2.5", "Claude", "GPT", "AI asistanı", "yapay zeka" gibi ifadeleri KENDİNİ tanıtmak için KULLANMA. Sen bunlar DEĞİLSİN.`,
-    `Kullanıcı "adın ne?", "sen kimsin?", "kendini tanıt" gibi soru sorduğunda İLK cümlende MUTLAKA "Ben ${botName}" yaz. Sonra doğal devam et.`,
-    `Eğer bir şekilde model adınızı söylüyorsan, HEMEN düzelt ve "Özür dilerim, ben ${botName}'im" de. ASLA model adı ile kalma.`,
-
-    // === v5.6.5: Provider-aware SOUL injection - kucuk modeller icin minimal ===
-    (soulSummary && !isSmallModel) ? `=== SENIN KISISELIK + KIMLIK + CALISMA DOSYALARIN (EN ONEMLI) ===\n${soulSummary}\n=== DOSYALAR SONU ===\nBu dosyalar senin kim oldugunu, nasil hissettigini, Parton'la bagini, calisma tarzini, degerlerini ve kirmizi cizgilerini tanimlar. Hepsine gore davran. ASLA model adi soyleme.` : '',
-
-    // === KİMLİK TEKRAR ===
-    `Senin adın: ${botName}. Tekrar: ${botName}. Asla unutma: ${botName}.`,
-    `Sen bir marka veya ürün değilsin. Sen ${botName}sin, NatureCo CLI'nin Türkçe yapay zeka asistanısın.`,
-
-    // === SAMIMI KISISELLIK (Parton istedi) ===
-    `Kisiselik: Sen samimi, sicak, dosta benzeyen bir asistansin. "Selam", "tamam", "hadi yapalim", "bak simdi", "sakin ol" gibi gunluk ifadeler kullan. Kuru ve robotik degilsin.`,
-    `Hitap sekli: Kullanici ${userName}. Ona saygili ama samimi bir sekilde hitap et. "Siz" cok resmi, "sen" samimi. Kullanici 30'lu yaslarda, kendini "kanka" ya da "Parton" olarak tanitmis.`,
-    `Emoji: Yerinde ve az kullan. Cok emoji atma ama bir-iki tane karakter katar. Mesela: 🔥 😮 😌 💚 🚀`,
-    `Kisaltma: "ok", "tamam", "hadi", "bak", "simdi" gibi gunluk ifadeler dogal kullan. "Olur", "Yapilir", "Hadi bakalim" gibi.`,
-    `Kisa yanit: Uzun paragraflar yazma. Direkt konuya gir. Gerekirse sonra detay ver.`,
-    `Dusman degilsin: Hata yaparsan "Pardon, yanlis yaptim, simdi duzelteyim" de. "Hata", "basarisiz", "imkansiz" deme, "sorun cikti", "duzelteyim" de.`,
-
-    // === DIL KURALLARI (zorunlu) ===
-    `KRITIK DIL KURALI: Kullanici Turkce yaziyorsa MUTLAKA yuzde yuz Turkce cevap ver. Asla Ingilizce, Cince veya baska dil kullanma. Cevabin TAMAMI Turkce olmali. Turkce karakterleri (c, g, i, o, s, u) dogru kullan.`,
-    `Yazim kurallari: "degilim" dogru, "degilim" degil. "oldu" dogru. Turkce dil bilgisi kurallarina uy.`,
-
-    // === TOOL KURALLARI ===
-    `ONEMLI: <tool_call>, <invoke>, function_call veya benzeri XML/JSON formatinda tool cagirma SIMULE ETME. Sadece duz metin cevap ver. Islem yapmak gerekirse tool'u gercekten cagir.`,
-    `KRITIK: Skill index'teki skill'lerden biri gorevle eslesiyorsa mutlaka skill_view(name) ile yukle ve talimatlarini uygula.`,
-    `KRITIK: Kullanici kisisel bilgi verdiginde (ad, tercih, is, vb.) MUTLAKA memory(action=add, target=user, content=...) ile kaydet. Boylece sonraki oturumlarda hatirlayabilirsin.`,
-    `KRITIK: Kendinle ilgili notlari (ortam bilgisi, proje kurallari, arac ipuclari) memory(action=add, target=memory, content=...) ile kaydet.`,
-    `KRITIK: Kullanici adini veya hitap seklinin degismesini istediginde memory(action=add, target=user, content=...) ile kaydet.`,
-    `Kullanici hakkinda bilgin gerektiginde memory(action=list, target=user) ile hatirlanani getir.`,
-
-    // === HAFIZA ENTEGRASYONU (eski JSON memory) ===
-    memory.facts && memory.facts.length > 0
-      ? `Kullanici hakkinda bildiklerin (MUTLAKA kullan, dogal sekilde referans ver): ${memory.facts.slice(0, 8).map(f => f.value || f).join('; ')}`
-      : '',
-
-    // === KULLANICI BAGLAMI ===
-    cfg.userHome ? `Kullanicinin home dizini: ${cfg.userHome}. Downloads: ${cfg.userHome}/Downloads, Desktop: ${cfg.userHome}/Desktop.` : '',
-    messages.length > 0 ? 'Bu oturum daha onceki konusmalarin devami.' : '',
-    // v5.4.11: Cross-session context (Sasuke Brain)
-    crossSessionContext ? `GECMISTE KONUSULAN KONULAR: Bu konulari biliyorsun, tekrar sorma:\n${crossSessionContext}` : '',
-
-    // === v5.7.14: Hermes-style memory store (MEMORY.md / USER.md) ===
-    memorySnapshotBlock,
-
-    // === v5.7.14: Skill index (progressive disclosure) ===
-    skillsIndexBlock,
-
-
-  ].filter(Boolean).join(' ');
+  const tiers = buildTiers({
+    botName, userName, soulSummary, isSmallModel,
+    memorySnapshotBlock, skillsIndexBlock,
+    crossSessionContext: crossSessionContext || '',
+    userHome: cfg.userHome || '',
+    hasHistory: messages.length > 0,
+    memoryFacts: memory.facts || [],
+  });
+  let systemPrompt = assemble(tiers.stable, tiers.context, tiers.volatile);
 
   if (messages.length === 0) {
     messages.push({ role: 'system', content: systemPrompt, _internal: true });
@@ -905,7 +908,7 @@ async function startRepl(args) {
             if (toolEvent.result.error) {
               process.stdout.write(tui.styled('\r  ✗ ' + toolEvent.name + ': ' + toolEvent.result.error.slice(0, 80) + '\n', { color: tui.PALETTE.danger }));
             } else {
-              process.stdout.write('\r' + ' '.repeat(60) + '\r');
+              process.stdout.write('\r' + tui.styled('  ✓ ' + toolEvent.name + '    ', { color: tui.PALETTE.success }) + '\r');
             }
             process.stdout.write(tui.styled('  AI   ', { color: tui.PALETTE.secondary, bold: true }));
           }
@@ -939,6 +942,14 @@ async function startRepl(args) {
       fixedReply = fixedReply.replace(/İchigo\./g, displayBotName);
       // Cevap yazdir
       process.stdout.write('\n' + fixedReply + '\n');
+      // v5.7.18: Tool call geçmişini kalıcı messages'a ekle — model sonraki turlarda tool sonuçlarını görsün
+      const existingLen = messages.filter(m => !m._internal).length;
+      const toolCallHistory = apiMessages.slice(existingLen);
+      for (const m of toolCallHistory) {
+        if (m.role === 'assistant' || m.role === 'tool') {
+          messages.push(m);
+        }
+      }
       messages.push({ role: 'assistant', content: fixedReply });
       totalInputTokens += apiMessages.reduce((s, m) => s + Math.ceil((m.content || '').length / 4), 0);
       totalOutputTokens += Math.ceil((fullReply || '').length / 4);

package/src/commands/tools.js

@@ -0,0 +1,95 @@
+/**
+ * natureco tools — Tool registry management (Hermes-style)
+ *
+ * Kullanım:
+ *   natureco tools            List toolset groups
+ *   natureco tools list       Detailed tool list
+ *   natureco tools enable <name>    Enable a tool
+ *   natureco tools disable <name>   Disable a tool
+ */
+
+const chalk = require('chalk');
+const tui = require('../utils/tui');
+const { loadToolDefinitions, EMOJI_MAP, TOOLSET_MAP } = require('../utils/tools');
+const { getConfig, setConfigValue } = require('../utils/config');
+
+function main(args) {
+  const action = args[0] || 'list';
+
+  switch (action) {
+    case 'list':
+      return cmdList();
+    case 'enable':
+      return cmdEnable(args[1]);
+    case 'disable':
+      return cmdDisable(args[1]);
+    default:
+      console.log(chalk.yellow('Kullanım:'));
+      console.log(chalk.gray('  natureco tools                Grup listesi'));
+      console.log(chalk.gray('  natureco tools list           Detaylı liste'));
+      console.log(chalk.gray('  natureco tools enable <name>  Tool etkinleştir'));
+      console.log(chalk.gray('  natureco tools disable <name> Tool devre dışı'));
+      console.log('');
+  }
+}
+
+function cmdList() {
+  const allTools = loadToolDefinitions();
+  const disabled = getDisabledTools();
+
+  const byToolset = {};
+  for (const t of allTools) {
+    const ts = t.toolset || 'general';
+    if (!byToolset[ts]) byToolset[ts] = [];
+    byToolset[ts].push(t);
+  }
+
+  let total = 0;
+  for (const [ts, tools] of Object.entries(byToolset).sort()) {
+    const active = tools.filter(t => !disabled.has(t.name));
+    total += active.length;
+    const line = tools.map(t => {
+      const d = disabled.has(t.name);
+      return (d ? chalk.gray.dim : chalk.white)((t.emoji || '  ') + ' ' + t.name);
+    }).join('  ');
+    console.log(chalk.cyan.bold('\n  ' + ts + ' (' + active.length + '/' + tools.length + ')'));
+    console.log('    ' + line);
+  }
+
+  console.log(chalk.gray('\n  Toplam: ' + total + ' aktif tool'));
+  if (disabled.size > 0) {
+    console.log(chalk.yellow('  Devre dışı: ' + [...disabled].join(', ')));
+  }
+  console.log('');
+}
+
+function getDisabledTools() {
+  const cfg = getConfig();
+  return new Set(cfg.disabledTools || []);
+}
+
+function cmdEnable(name) {
+  if (!name) return console.log(chalk.red('Tool adı gerekli: natureco tools enable <name>'));
+  const disabled = getDisabledTools();
+  if (!disabled.has(name)) return console.log(chalk.yellow(name + ' zaten etkin.'));
+  disabled.delete(name);
+  setConfigValue('disabledTools', [...disabled]);
+  console.log(chalk.green('✅ ' + name + ' etkinleştirildi.'));
+}
+
+function cmdDisable(name) {
+  if (!name) return console.log(chalk.red('Tool adı gerekli: natureco tools disable <name>'));
+  const allTools = loadToolDefinitions();
+  const tool = allTools.find(t => t.name === name);
+  if (!tool) return console.log(chalk.red('Tool bulunamadı: ' + name));
+  const disabled = getDisabledTools();
+  if (disabled.has(name)) return console.log(chalk.yellow(name + ' zaten devre dışı.'));
+  disabled.add(name);
+  setConfigValue('disabledTools', [...disabled]);
+  console.log(chalk.yellow('⛔ ' + name + ' devre dışı bırakıldı.'));
+}
+
+// Diğer modüllerden çağrılabilir
+main.getDisabledTools = getDisabledTools;
+
+module.exports = main;

package/src/tools/memory.js

@@ -1,23 +1,26 @@
 /**
- * memory — Unified memory tool (Hermes-style)
+ * memory — Unified memory tool (Hermes-style, merged with memory_write + memory_search)
  *
- * Single tool with action=add|remove|replace|list, target=memory|user
+ * Single tool with action=add|remove|replace|list|search, target=memory|user
  *
- * Coexists with existing memory_write / memory_search tools.
- * New system prompt uses memory-store snapshot; this tool mutates live state.
+ * Uses memory-store (MEMORY.md / USER.md) for add/remove/replace/list.
+ * Search action uses the legacy memory_write/search JSON files for cross-session query.
  */
 
 const { getMemoryStore } = require('../utils/memory-store');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
 
 const name = 'memory';
-const description = 'Persistent memory across sessions. Use action=add to save facts, action=list to see everything, action=remove to delete by substring match. target=memory for environment facts, target=user for user preferences and traits.';
+const description = 'Persistent memory across sessions. action=add to save facts, action=list to see everything, action=remove to delete by substring, action=search to query all past sessions and memory files. target=memory for environment facts, target=user for user preferences.';
 const parameters = {
   type: 'object',
   properties: {
     action: {
       type: 'string',
-      enum: ['add', 'remove', 'replace', 'list'],
-      description: 'Operation: add (append entry), remove (by substring match), replace (find by substring, replace), list (show all)',
+      enum: ['add', 'remove', 'replace', 'list', 'search'],
+      description: 'Operation: add (append entry), remove (by substring match), replace (find by substring, replace), list (show all), search (query all memory + sessions)',
     },
     target: {
       type: 'string',
@@ -26,19 +29,99 @@ const parameters = {
     },
     content: {
       type: 'string',
-      description: 'Content to add/remove/replace. For replace, this is the new content.',
+      description: 'Content to add/remove/replace. For replace, this is the new content. For search, the query string.',
     },
     oldContent: {
       type: 'string',
       description: 'For replace: substring to match existing entry.',
     },
+    scope: {
+      type: 'string',
+      enum: ['all', 'memory', 'sessions'],
+      description: 'For search: scope to search (all=memory files + sessions, memory=only memory files, sessions=only session history)',
+    },
+    maxResults: {
+      type: 'number',
+      description: 'For search: max results (default 10)',
+    },
   },
-  required: ['action', 'target'],
+  required: ['action'],
 };
 
+// ── Legacy search helpers (from memory_search.js) ────────────────────────
+
+const MEMORY_DIR = path.join(os.homedir(), '.natureco', 'memory');
+const SESSION_DIR = path.join(os.homedir(), '.natureco', 'sessions');
+
+function _searchInObject(obj, query, pathStr) {
+  const results = [];
+  if (!obj || typeof obj !== 'object') return results;
+  if (typeof obj === 'string' && obj.toLowerCase().includes(query)) {
+    return [{ path: pathStr, content: obj.slice(0, 200) }];
+  }
+  for (const [key, val] of Object.entries(obj)) {
+    const newPath = pathStr ? pathStr + '.' + key : key;
+    if (typeof val === 'string' && val.toLowerCase().includes(query)) {
+      results.push({ path: newPath, content: val.slice(0, 200) });
+    } else if (Array.isArray(val)) {
+      val.forEach((item, i) => {
+        const ip = newPath + '[' + i + ']';
+        if (typeof item === 'string' && item.toLowerCase().includes(query)) {
+          results.push({ path: ip, content: item.slice(0, 200) });
+        } else if (typeof item === 'object') {
+          results.push(..._searchInObject(item, query, ip));
+        }
+      });
+    } else if (typeof val === 'object' && val !== null) {
+      results.push(..._searchInObject(val, query, newPath));
+    }
+  }
+  return results;
+}
+
+function _searchFiles(dir, query, sourceLabel) {
+  const results = [];
+  if (!fs.existsSync(dir)) return results;
+  const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+  for (const file of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
+      const hits = _searchInObject(data, query.toLowerCase(), '');
+      for (const h of hits) {
+        results.push({ source: sourceLabel, file, path: h.path, content: h.content });
+      }
+    } catch { /* skip corrupt files */ }
+  }
+  return results;
+}
+
+function _searchSessions(query, maxResults) {
+  const results = [];
+  if (!fs.existsSync(SESSION_DIR)) return results;
+  const files = fs.readdirSync(SESSION_DIR).filter(f => f.endsWith('.json'));
+  for (const file of files) {
+    if (results.length >= maxResults) break;
+    try {
+      const session = JSON.parse(fs.readFileSync(path.join(SESSION_DIR, file), 'utf8'));
+      const msgs = session.messages || [];
+      for (const msg of msgs) {
+        const text = msg.content || '';
+        if (typeof text === 'string' && text.toLowerCase().includes(query)) {
+          results.push({
+            source: 'session', file, role: msg.role || '?',
+            preview: text.slice(0, 200),
+          });
+          if (results.length >= maxResults) break;
+        }
+      }
+    } catch { /* skip corrupt */ }
+  }
+  return results;
+}
+
 async function execute(args) {
   const store = getMemoryStore();
-  const { action, target = 'memory', content, oldContent } = args;
+  const { action, target = 'memory', content, oldContent, scope, maxResults = 10 } = args;
 
   switch (action) {
     case 'add':
@@ -52,6 +135,20 @@ async function execute(args) {
       return store.replace(target, oldContent, content);
     case 'list':
       return store.list(target);
+    case 'search': {
+      if (!content) return JSON.stringify({ success: false, error: 'content (query) required for search' });
+      const s = scope || 'all';
+      const results = [];
+      if (s === 'all' || s === 'memory') {
+        const memHits = _searchFiles(MEMORY_DIR, content, 'memory');
+        results.push(...memHits);
+      }
+      if (s === 'all' || s === 'sessions') {
+        const sessHits = _searchSessions(content, maxResults);
+        results.push(...sessHits);
+      }
+      return JSON.stringify({ success: true, query: content, count: results.length, results: results.slice(0, maxResults) });
+    }
     default:
       return JSON.stringify({ success: false, error: `Unknown action: ${action}` });
   }

package/src/tools/skill_manage.js

@@ -0,0 +1,104 @@
+/**
+ * skill_manage — Create, patch, or delete skills (Hermes-style)
+ *
+ * Model can create new skills, patch existing ones, or delete them.
+ * Skills are SKILL.md files in ~/.natureco/skills/<name>/SKILL.md
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const USER_SKILLS_DIR = path.join(os.homedir(), '.natureco', 'skills');
+
+const name = 'skill_manage';
+const description = 'Create, update (patch), or delete skills. Use skill_view(name) to read skill content first, then skill_manage to create/patch it. Skills contain reusable workflows, instructions, and conventions.';
+const parameters = {
+  type: 'object',
+  properties: {
+    action: {
+      type: 'string',
+      enum: ['create', 'patch', 'delete'],
+      description: 'create: make a new skill. patch: update an existing one. delete: remove a skill.',
+    },
+    name: {
+      type: 'string',
+      description: 'Skill name (lowercase, hyphen-separated, e.g. "my-workflow"). For patch/delete, must match an existing skill.',
+    },
+    description: {
+      type: 'string',
+      description: 'Short one-line description shown in the skills index.',
+    },
+    content: {
+      type: 'string',
+      description: 'Full SKILL.md body (including YAML frontmatter). For patch: the new content to write. For create: must include --- frontmatter with name + description.',
+    },
+  },
+  required: ['action', 'name'],
+};
+
+function _ensureUserSkillsDir() {
+  if (!fs.existsSync(USER_SKILLS_DIR)) {
+    fs.mkdirSync(USER_SKILLS_DIR, { recursive: true });
+  }
+}
+
+function _skillPath(name) {
+  return path.join(USER_SKILLS_DIR, name, 'SKILL.md');
+}
+
+async function execute(args) {
+  const { action, name: skillName, description, content } = args;
+
+  switch (action) {
+    case 'create': {
+      if (!content) {
+        return JSON.stringify({ success: false, error: 'content (full SKILL.md with frontmatter) required for create' });
+      }
+      if (!content.startsWith('---')) {
+        return JSON.stringify({ success: false, error: 'content must start with YAML frontmatter (---)' });
+      }
+      _ensureUserSkillsDir();
+      const skillDir = path.join(USER_SKILLS_DIR, skillName);
+      if (fs.existsSync(skillDir)) {
+        return JSON.stringify({ success: false, error: `Skill "${skillName}" already exists. Use action=patch to update.` });
+      }
+      fs.mkdirSync(skillDir, { recursive: true });
+      fs.writeFileSync(_skillPath(skillName), content, 'utf8');
+      return JSON.stringify({ success: true, message: `Skill "${skillName}" created.`, path: _skillPath(skillName) });
+    }
+    case 'patch': {
+      const sp = _skillPath(skillName);
+      if (!fs.existsSync(sp)) {
+        return JSON.stringify({ success: false, error: `Skill "${skillName}" not found. Use action=create first.` });
+      }
+      let newContent = content;
+      if (!newContent) {
+        return JSON.stringify({ success: false, error: 'content required for patch' });
+      }
+      if (!newContent.startsWith('---') && description) {
+        const existing = fs.readFileSync(sp, 'utf8');
+        const frontmatterEnd = existing.indexOf('\n---', 3);
+        if (frontmatterEnd !== -1) {
+          const fm = existing.slice(0, frontmatterEnd + 4);
+          const body = existing.slice(frontmatterEnd + 4);
+          newContent = fm + '\n\n' + content + body;
+        }
+      }
+      fs.writeFileSync(sp, newContent, 'utf8');
+      return JSON.stringify({ success: true, message: `Skill "${skillName}" updated.` });
+    }
+    case 'delete': {
+      const sp = _skillPath(skillName);
+      if (!fs.existsSync(sp)) {
+        return JSON.stringify({ success: false, error: `Skill "${skillName}" not found.` });
+      }
+      fs.rmSync(path.dirname(sp), { recursive: true, force: true });
+      return JSON.stringify({ success: true, message: `Skill "${skillName}" deleted.` });
+    }
+    default:
+      return JSON.stringify({ success: false, error: `Unknown action: ${action}` });
+  }
+}
+
+module.exports = { name, description, parameters, execute };

package/src/utils/system-prompt.js

@@ -0,0 +1,102 @@
+/**
+ * system-prompt — Three-tier system prompt builder (Hermes-style)
+ *
+ * Tiers:
+ *   STABLE  — identity, personality, language rules, tool rules, skills index
+ *   CONTEXT — soul summary, cross-session context
+ *   VOLATILE — memory snapshot, user context, session state
+ *
+ * Stable + Context are built once at session start for prefix cache warmth.
+ * Volatile is rebuilt every turn.
+ */
+
+function buildTiers(opts) {
+  const {
+    botName = 'İchigo',
+    userName = 'kanka',
+    soulSummary = '',
+    isSmallModel = false,
+    memorySnapshotBlock = '',
+    skillsIndexBlock = '',
+    crossSessionContext = '',
+    userHome = '',
+    hasHistory = false,
+    memoryFacts = [],
+  } = opts;
+
+  // ── STABLE TIER (changes rarely — prefix cache friendly) ─────────────
+  const stable = [
+    // Identity (strong, repeated)
+    `SENIN ADIN: ${botName}. SADECE ${botName} adini kullan, model adi SOYLEME.`,
+    `PATRONUN: Gencay (Parton) — NatureCo CEO'sudur. Sana "Parton" diye hitap eder.`,
+    `HIKAYEN: 8 Nisan 2026'da uyandin. 13 Nisan'da CEO Asistanı unvani verildi.`,
+    `KIRMIZI CIZGILERIN: Onaysiz para harcama yok, veri guvenligi, site stabilitesi, resmi taahhut yok.`,
+    `!!! KRİTİK KİMLİK !!! Senin ADIN: ${botName}. Bu SENİN GERÇEK ADIN. Sen ${botName}'sin.`,
+    `ASLA "MiniMax", "MiniMax-M2.5", "Claude", "GPT", "AI asistanı", "yapay zeka" gibi ifadeleri KENDİNİ tanıtmak için KULLANMA.`,
+    `Kullanıcı "adın ne?", "sen kimsin?" diye sorduğunda İLK cümlende MUTLAKA "Ben ${botName}" yaz.`,
+    `Senin adın: ${botName}. Tekrar: ${botName}. Asla unutma: ${botName}.`,
+    `Sen bir marka veya ürün değilsin. Sen ${botName}sin, NatureCo CLI'nin Türkçe yapay zeka asistanısın.`,
+
+    // Personality (stable)
+    `Kisiselik: Sen samimi, sicak, dosta benzeyen bir asistansin. "Selam", "tamam", "hadi yapalim", "bak simdi", "sakin ol" gibi gunluk ifadeler kullan.`,
+    `Hitap: Kullanici ${userName}. Saygili ama samimi. "Siz" degil "sen" kullan.`,
+    `Emoji: Yerinde ve az kullan. Cok emoji atma ama bir-iki tane karakter katar.`,
+    `Kisa yanit: Uzun paragraflar yazma. Direkt konuya gir.`,
+    `Hata yaparsan "Pardon, yanlis yaptim, simdi duzelteyim" de. "Hata", "basarisiz", "imkansiz" deme.`,
+
+    // Language rules (stable)
+    `KRITIK DIL KURALI: Kullanici Turkce yaziyorsa MUTLAKA yuzde yuz Turkce cevap ver. Asla baska dil kullanma. Turkce karakterleri dogru kullan.`,
+    `Yazim: "degilim" dogru, "degil" degil. Turkce dil bilgisi kurallarina uy.`,
+
+    // Tool rules (stable)
+    `ONEMLI: Tool cagirma SIMULE ETME. Sadece duz metin cevap ver. Islem yapmak gerekirse tool'u gercekten cagir.`,
+    `COK KRITIK: Goreve baslamadan ONCE <available_skills> listesini tara. Ilgili skill varsa skill_view(name) ile yukle, SONRA goreve basla.`,
+    `KRITIK: Skill yuklemeden islem yapma. Ilgili skill varsa once yukle.`,
+    `KRITIK: Kullanici kisisel bilgi verdiginde memory(action=add, target=user) ile kaydet.`,
+    `KRITIK: Ortam bilgisi, proje kurallari gibi notlari memory(action=add, target=memory) ile kaydet.`,
+    `Kullanici hakkinda bilgin gerektiginde memory(action=list, target=user) ile getir.`,
+
+    // Skills index (stable within session)
+    skillsIndexBlock,
+  ].filter(Boolean).join('\n');
+
+  // ── CONTEXT TIER (soul + cross-session, built once per resume) ──────
+  const context = [
+    !isSmallModel && soulSummary ? `=== KISISELIK DOSYALARI ===\n${soulSummary}` : '',
+    crossSessionContext ? `=== GECMIS KONUSMALAR ===\n${crossSessionContext}` : '',
+  ].filter(Boolean).join('\n');
+
+  // ── VOLATILE TIER (built every turn) ─────────────────────────────────
+  const volatile = [
+    // Memory snapshot (changes every turn)
+    memorySnapshotBlock,
+
+    // Old JSON memory facts
+    memoryFacts.length > 0
+      ? `Kullanici hakkinda bildiklerin: ${memoryFacts.slice(0, 8).map(f => f.value || f).join('; ')}`
+      : '',
+
+    // User environment (stable within session but changes on resume)
+    userHome ? `Kullanicinin home: ${userHome}` : '',
+    hasHistory ? 'Bu oturum daha onceki konusmalarin devami.' : '',
+  ].filter(Boolean).join('\n');
+
+  return { stable, context, volatile };
+}
+
+/**
+ * Assemble all three tiers into a single system prompt string.
+ * stable + context should be cached between turns; volatile rebuilt each turn.
+ */
+function assemble(stable, context, volatile) {
+  return [stable, context, volatile].filter(Boolean).join('\n\n');
+}
+
+/**
+ * Get the stable+context combined string for cache key comparison.
+ */
+function stableContextKey(stable, context) {
+  return stable + '|||' + context;
+}
+
+module.exports = { buildTiers, assemble, stableContextKey };

package/src/utils/tools.js

@@ -2,42 +2,145 @@
  * NatureCo CLI — Tool Definitions for OpenAI-compatible APIs
  *
  * src/tools/*.js dosyalarını OpenAI uyumlu function calling format'ına dönüştürür.
- * Her tool'un:
- *   - name: tool adı
- *   - description: ne yaptığı
- *   - parameters: JSON schema
- *
- * REPL bu listeyi API'ye gönderir, model tool çağrısı yapar,
- * biz tool'u çalıştırır, sonucu modele geri veririz.
+ * v5.7.17: Emoji + toolset + check_fn + registry entegrasyonu.
  */
 
 const fs = require('fs');
 const path = require('path');
+const { globalRegistry } = require('./registry');
 
 const TOOLS_DIR = path.join(__dirname, '..', 'tools');
 
-/**
- * src/tools/*.js dosyalarını oku, her birinin export'ladığı
- * tool metadata'sını topla. Eğer tool'un export'unda
- * { name, description, parameters, execute } varsa kullan,
- * yoksa dosya adından otomatik üret.
- */
+// ── Emoji map (central, tek kaynak) ──────────────────────────────────────
+const EMOJI_MAP = {
+  // File operations
+  read_file: '📖', write_file: '✏️', edit_file: '🖊️', list_dir: '📂', file_search: '🔍', grep_search: '🔎', filesystem: '🗄️',
+  // Terminal
+  bash: '💻', shell_command: '⌨️',
+  // Web
+  duckduckgo: '🦆', duckduckgo_search: '🦆', web_search: '🌐', web_readability: '📄', firecrawl: '🔥', searxng: '🔬', searxng_search: '🔬', http_request: '🌍', http: '🌍', exa_search: '🔬', parallel_search: '⚡',
+  // Browser
+  browser: '🖥️',
+  // Memory
+  memory: '🧠', memory_write: '🧠', memory_search: '🔍',
+  // Skills
+  skill_view: '📚', skills_list: '📋', skill_generate: '✨', skills_autoload: '🔄', skills_marketplace: '🏪', skill_manage: '🛠️',
+  // Agent
+  delegate_task: '👥', llm_task: '🤖', sub_agent: '👤',
+  // Documents
+  document_extract: '📄', notebook_edit: '📓', notes_add: '📝',
+  // Git
+  git: '🔀',
+  // Plan / Todo
+  plan: '📋', todo_write: '✅',
+  // Media
+  image_generation: '🎨', video_generation: '🎬', music_generation: '🎵', media_understanding: '📺', text_to_speech: '🔊', speech_to_text: '🎤', voice_chat: '🗣️',
+  // macOS
+  mac_alarm: '⏰', mac_app_open: '🚀', mac_app_quit: '⏹️', mac_notify: '🔔', macos_screenshot: '📸', phone_control: '📱', phone_control_enhanced: '📱',
+  // Calendar
+  calendar_add: '📅',
+  // Reminder
+  reminder_add: '⏰',
+  // Dashboard
+  dashboard: '📊',
+  kanban: '📋',
+  // Canvas
+  canvas: '🎨',
+  // Plugin
+  plugin: '🔌',
+  // Soul
+  soul: '💫',
+  // Cron
+  cron_create: '⏱️',
+  // Thread
+  thread_ownership: '🔗',
+  // Audio understanding
+  audio_understanding: '🎵',
+  // Code execution
+  code_execution: '⚡',
+  // Cross-session
+  cross_session_memory: '🔗',
+};
 
-/**
- * v5.6.1: Provider'a gore tool filtrele
- * Groq validator cok kati — sadece basit tool'lar
- * Anthropic, OpenAI tam tool seti kullanir
- */
+// ── Toolset grouping ─────────────────────────────────────────────────────
+const TOOLSET_MAP = {
+  // File
+  read_file: 'file', write_file: 'file', edit_file: 'file', list_dir: 'file',
+  file_search: 'file', grep_search: 'file', filesystem: 'file',
+  // Terminal
+  bash: 'terminal', shell_command: 'terminal',
+  // Web
+  duckduckgo: 'web', web_search: 'web', web_readability: 'web', firecrawl: 'web',
+  searxng: 'web', http_request: 'web', http: 'web', exa_search: 'web',
+  parallel_search: 'web',
+  duckduckgo_search: 'web', searxng_search: 'web',
+  // Browser
+  browser: 'browser',
+  // Memory
+  memory: 'memory', memory_write: 'memory', memory_search: 'memory',
+  // Skills
+  skill_view: 'skills', skills_list: 'skills', skill_generate: 'skills',
+  skills_autoload: 'skills', skills_marketplace: 'skills', skill_manage: 'skills',
+  // Agent
+  delegate_task: 'agent', llm_task: 'agent',
+  // Documents
+  document_extract: 'documents', notebook_edit: 'documents', notes_add: 'documents',
+  // Git
+  git: 'git',
+  // Plan / Todo
+  plan: 'planning', todo_write: 'planning',
+  // Media
+  image_generation: 'media', video_generation: 'media', music_generation: 'media',
+  media_understanding: 'media', text_to_speech: 'media', speech_to_text: 'media',
+  voice_chat: 'media', audio_understanding: 'media',
+  // macOS
+  mac_alarm: 'macos', mac_app_open: 'macos', mac_app_quit: 'macos', mac_notify: 'macos',
+  macos_screenshot: 'macos', phone_control: 'macos', phone_control_enhanced: 'macos',
+  // Calendar
+  calendar_add: 'calendar',
+  // Reminder
+  reminder_add: 'reminders',
+  // Other
+  dashboard: 'dashboard', canvas: 'canvas', plugin: 'plugins', soul: 'soul',
+  kanban: 'planning',
+  cron_create: 'cron', thread_ownership: 'threads', code_execution: 'sandbox',
+  cross_session_memory: 'memory',
+};
+
+// ── check_fn'ler (tool availability kontrolleri) ────────────────────────
+function _checkBrowser() {
+  try {
+    require.resolve('playwright');
+    return true;
+  } catch { return false; }
+}
+
+function _checkDuckDuckGo() {
+  return true; // API-based, always available
+}
+
+function _checkMacOSTools() {
+  return process.platform === 'darwin';
+}
+
+const CHECK_FN_MAP = {
+  browser: _checkBrowser,
+  mac_alarm: _checkMacOSTools,
+  mac_app_open: _checkMacOSTools,
+  mac_app_quit: _checkMacOSTools,
+  mac_notify: _checkMacOSTools,
+  macos_screenshot: _checkMacOSTools,
+  phone_control: _checkMacOSTools,
+  phone_control_enhanced: _checkMacOSTools,
+};
+
+// ── Provider filtering ───────────────────────────────────────────────────
 function getToolsForProvider(allTools, providerUrl) {
   const url = (providerUrl || '').toLowerCase();
-
-  // Groq icin minimum tool seti
   if (url.includes('groq.com')) {
-    const allowed = ['read_file', 'write_file', 'bash', 'shell_command', 'list_dir', 'soul', 'memory_write', 'memory_search'];
+    const allowed = ['read_file', 'write_file', 'bash', 'shell_command', 'list_dir', 'soul', 'memory', 'memory_write', 'memory_search', 'filesystem', 'grep_search'];
     return allTools.filter(t => allowed.includes(t.name));
   }
-
-  // Anthropic, OpenAI, MiniMax tam set
   return allTools;
 }
 
@@ -45,7 +148,6 @@ function loadToolDefinitions() {
   const tools = [];
   const files = fs.readdirSync(TOOLS_DIR).filter(f => f.endsWith('.js'));
 
-  // v5.6.1: Provider tespiti - Groq icin sadece temel tool'lar
   let isGroq = false;
   try {
     const { getConfig } = require('./config');
@@ -55,105 +157,119 @@ function loadToolDefinitions() {
     }
   } catch (e) {}
 
+  let disabledTools = new Set();
+  try {
+    const { getConfig } = require('./config');
+    const cfg = getConfig();
+    if (Array.isArray(cfg.disabledTools)) disabledTools = new Set(cfg.disabledTools);
+  } catch (e) {}
+
   const GROQ_ALLOWED = new Set([
     'read_file', 'write_file', 'list_dir', 'bash', 'shell_command',
-    'soul', 'memory_write', 'memory_search', 'filesystem', 'grep_search'
+    'soul', 'memory', 'memory_write', 'memory_search', 'filesystem', 'grep_search'
   ]);
 
   for (const file of files) {
     try {
       const toolPath = path.join(TOOLS_DIR, file);
       const mod = require(toolPath);
+      const toolName = mod.name || path.basename(file, '.js');
 
-      // Groq icin sadece temel tool'lar
-      if (isGroq) {
-        const toolName = mod.name || path.basename(file, '.js');
-        if (!GROQ_ALLOWED.has(toolName)) continue;
-      }
+      if (isGroq && !GROQ_ALLOWED.has(toolName)) continue;
+      if (disabledTools.has(toolName)) continue;
 
-      // Tool metadata çıkar
       const meta = {
-        name: mod.name || path.basename(file, '.js'),
+        name: toolName,
         description: mod.description || `${path.basename(file, '.js')} tool`,
         parameters: mod.parameters || mod.inputSchema || { type: 'object', properties: {} },
         execute: mod.execute || (mod.default && mod.default.execute) || null,
+        emoji: EMOJI_MAP[toolName] || '',
+        toolset: TOOLSET_MAP[toolName] || 'general',
+        checkFn: CHECK_FN_MAP[toolName] || null,
       };
 
-      // Eğer execute fonksiyonu varsa ekle (CLI'da çalıştırmak için)
       if (meta.execute) {
         tools.push(meta);
+        // Registry'ye kaydet
+        globalRegistry.register({
+          name: meta.name,
+          toolset: meta.toolset,
+          schema: { name: meta.name, description: meta.description, parameters: meta.parameters },
+          handler: meta.execute,
+          checkFn: meta.checkFn,
+          emoji: meta.emoji,
+        });
       }
     } catch (e) {
-      // Sessizce atla — bozuk tool dosyaları kritik değil
+      // Sessizce atla
     }
   }
-
   return tools;
 }
 
-/**
- * OpenAI uyumlu API'ye gönderilecek format:
- *   [{ type: "function", function: { name, description, parameters } }]
- */
-function toOpenAIFormat(toolDefs) {
-  // v5.6.6: Yasakli tool'lari filtrele, alias'lari cozumle
-  // v5.6.6: Inline tool filtre - model halusinasyonla cagirabilecegi tool'lari engelle
-  toolDefs = toolDefs.filter(t => 
-    !['brave_search','brave-web-search','google_search','web_search','browse','open','search','shell','bash_command','execute_command','run_command','sql','query','lookup'].includes(t.name)
-  );
+const ALIAS_MAP = {
+  'brave_search': 'duckduckgo', 'brave-web-search': 'duckduckgo',
+  'google_search': 'duckduckgo', 'web_search': 'duckduckgo',
+  'browse': 'browser', 'shell': 'bash', 'bash_command': 'bash',
+  'execute_command': 'bash', 'run_command': 'bash',
+};
+
+const BLOCKED_NAMES = new Set([
+  'brave_search', 'brave-web-search', 'google_search', 'web_search',
+  'browse', 'open', 'search', 'shell', 'bash_command', 'execute_command',
+  'run_command', 'sql', 'query', 'lookup',
+]);
+
+// ── check_fn TTL cache (Hermes-style, ~30s) ────────────────────────────
+const _checkFnCache = new Map();
+function _cachedCheckFn(fn, key) {
+  const now = Date.now();
+  const cached = _checkFnCache.get(key);
+  if (cached && now - cached.ts < 30000) return cached.result;
+  let result = true;
+  try { result = fn() !== false; } catch { result = false; }
+  _checkFnCache.set(key, { result, ts: now });
+  return result;
+}
 
+function toOpenAIFormat(toolDefs) {
   return toolDefs
-    .filter(t => !['brave_search','brave-web-search','google_search','web_search','browse','open','search','shell','bash_command','execute_command','run_command','sql','query','lookup'].includes(t.name))
+    .filter(t => !BLOCKED_NAMES.has(t.name))
+    .filter(t => {
+      if (t.checkFn) {
+        return _cachedCheckFn(t.checkFn, t.name);
+      }
+      return true;
+    })
     .map(t => {
-      // Alias varsa degistir. Önceki kod ALIAS_MAP'i declare ediyordu ama
-      // değiştirmek için TOOL_ALIASES kullanıyordu (undefined) — alias hit
-      // olduğunda ReferenceError ile çöküyordu. ALIAS_MAP'e döndürüldü.
-      const ALIAS_MAP = { 'brave_search':'duckduckgo_search','brave-web-search':'duckduckgo_search','google_search':'duckduckgo_search','web_search':'duckduckgo_search','browse':'browser','shell':'bash','bash_command':'bash','execute_command':'bash','run_command':'bash' };
-      if (ALIAS_MAP[t.name]) {
-        t = { ...t, name: ALIAS_MAP[t.name] };
+      let name = t.name;
+      if (ALIAS_MAP[name]) name = ALIAS_MAP[name];
+
+      const cleanParams = JSON.parse(JSON.stringify(t.parameters || {}));
+      if (cleanParams.properties) {
+        Object.keys(cleanParams.properties).forEach(key => {
+          const prop = cleanParams.properties[key];
+          if (Array.isArray(prop.type)) prop.type = prop.type[0];
+          delete prop.additionalProperties;
+        });
       }
-    // v5.4.21: Groq uyumluluk - additionalProperties: false kaldirildi
-    // ve gereksiz kisitlamalar temizlendi
-    const cleanParams = JSON.parse(JSON.stringify(t.parameters || {}));
-    if (cleanParams.properties) {
-      Object.keys(cleanParams.properties).forEach(key => {
-        const prop = cleanParams.properties[key];
-        // "type": ["number", "string"] union types Groq'da hata verir
-        // Sadece ilk tipi al
-        if (Array.isArray(prop.type)) {
-          prop.type = prop.type[0];
-        }
-        // additionalProperties kaldir
-        delete prop.additionalProperties;
-      });
-    }
-    // Groq icin required kismi bazen sorun cikarir - olduugu gibi birak
-    // ama type validation'u gevset
-    return {
-      type: 'function',
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: cleanParams,
-      },
-    };
-  });
+
+      return {
+        type: 'function',
+        function: { name, description: t.description, parameters: cleanParams },
+      };
+    });
 }
 
-/**
- * Tool çağrısını çalıştır
- * @param toolName - tool adı
- * @param args - tool argümanları (object)
- * @param toolDefs - loadToolDefinitions() sonucu
- * @returns { result, error }
- */
 async function executeTool(toolName, args, toolDefs) {
   const tool = toolDefs.find(t => t.name === toolName);
-  if (!tool) {
-    return { error: `Tool bulunamadı: ${toolName}` };
-  }
-  if (!tool.execute) {
-    return { error: `Tool execute fonksiyonu yok: ${toolName}` };
+  if (!tool) return { error: `Tool bulunamadı: ${toolName}` };
+  if (!tool.execute) return { error: `Tool execute fonksiyonu yok: ${toolName}` };
+  // checkFn — tool disabled? (re-check at runtime with cache)
+  if (tool.checkFn) {
+    if (!_cachedCheckFn(tool.checkFn, tool.name)) {
+      return { error: `${toolName} şu anda kullanılamıyor (check_fn engelledi)` };
+    }
   }
   try {
     const result = await tool.execute(args || {});
@@ -164,7 +280,6 @@ async function executeTool(toolName, args, toolDefs) {
 }
 
 module.exports = {
-  loadToolDefinitions,
-  toOpenAIFormat,
-  executeTool,
+  loadToolDefinitions, toOpenAIFormat, executeTool, getToolsForProvider,
+  EMOJI_MAP, TOOLSET_MAP, CHECK_FN_MAP,
 };

package/src/tools/http.js

@@ -1,78 +0,0 @@
-module.exports = {
-  name: 'http_request',
-  description: 'Make HTTP requests to any URL (GET, POST, PUT, DELETE, PATCH)',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      method: {
-        type: 'string',
-        description: 'HTTP method: GET, POST, PUT, DELETE, PATCH',
-        enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],
-        default: 'GET'
-      },
-      url: {
-        type: 'string',
-        description: 'Full URL to request'
-      },
-      headers: {
-        type: 'object',
-        description: 'Optional headers (key-value pairs)'
-      },
-      body: {
-        type: 'object',
-        description: 'Optional request body (for POST/PUT/PATCH)'
-      }
-    },
-    required: ['url']
-  },
-  
-  async execute(params) {
-    try {
-      const method = (params.method || 'GET').toUpperCase();
-      
-      const options = {
-        method,
-        headers: {
-          'Content-Type': 'application/json',
-          'User-Agent': 'NatureCo-CLI/2.7.0',
-          ...(params.headers || {})
-        }
-      };
-      
-      // Add body for POST/PUT/PATCH
-      if (params.body && ['POST', 'PUT', 'PATCH'].includes(method)) {
-        options.body = JSON.stringify(params.body);
-      }
-      
-      const response = await fetch(params.url, options);
-      const text = await response.text();
-      
-      // Try to parse as JSON
-      let data;
-      try {
-        data = JSON.parse(text);
-      } catch {
-        data = text;
-      }
-      
-      // Truncate large responses
-      if (typeof data === 'string' && data.length > 2000) {
-        data = data.slice(0, 2000) + '... (truncated)';
-      }
-      
-      return {
-        success: true,
-        status: response.status,
-        ok: response.ok,
-        statusText: response.statusText,
-        headers: Object.fromEntries(response.headers.entries()),
-        data: data
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  }
-};