natureco-cli 5.23.0 → 5.25.0

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable changes to NatureCo CLI will be documented in this file.
 
+## [5.25.0] - 2026-07-04 — "PROVIDER-AGNOSTİK + STREAMING ALTYAPISI"
+
+### ✨ İyileştirme
+- **Provider-agnostik**: agentic düzeltmeler MiniMax'e özel DEĞİL — `workflow.js`'in paylaşılan non-tool-calling dalında çalışır (MiniMax, Groq, Ollama, yerel modeller). Tool-calling sağlayıcıları (OpenAI, Anthropic, Gemini) kendi native `tool_calls` yolunu kullanır (dokunulmadı). `agentic-runner` hem native `tool_calls` hem native XML parse eder → sağlayıcıdan bağımsız çalışır.
+- **Streaming altyapısı**: canlı akışta tool-call/skill protokol jetonlarını (`<minimax:tool_call>`, `<invoke>`, `<skill>`) gizleyip düz metni gösteren, chunk sınırında bölünen tag'leri doğru işleyen akış filtresi (`makeStreamFilter`, 4 test). Tam devreye alma (streaming-güvenli model-adı temizleme ile birlikte) sonraki adım.
+
+> Not: v5.24.0'daki büyük düzeltmeler (MiniMax dosya yazma, komut çalıştırma, memory recall) bu sürümde de yer alır.
+
+## [5.24.0] - 2026-07-04 — "AGENTIC SERTLEŞTİRME" (MiniMax native tool-call + komut çalıştırma)
+
+Kök neden: **MiniMax M2.5 agentic bir model** — tool call'ları OpenAI `tool_calls` JSON'u yerine metin içinde native XML olarak üretir (`<minimax:tool_call><invoke name="write_file">...`) ve skill'i `<skill>ad</skill>` ile yükler. 5.23.0'ın tek-atış JSON planı bunu yakalayamıyordu; `JSON.parse` patlayıp boş `catch{}` yutunca dosya sessizce yazılmıyordu ("masaüstünde yarış oyunu yapamadı").
+
+### ✨ Yeni
+- **`src/tools/agentic-runner.js`**: MiniMax'in native XML/skill protokolünü parse edip gerçek araçları çalıştıran bounded agentic döngü (parse→execute→sonucu geri besle→dur, max 15 iterasyon). `workflow.js`'in non-tool-calling dalı buna bağlandı. 13 yeni birim testi.
+- **Komut çalıştırma (onaylı)**: ajan artık `bash` ile npm/git/node/test çalıştırıp çıktıya göre devam edebilir — gerçek **yaz→çalıştır→test→düzelt** döngüsü.
+
+### 🐛 Düzeltme
+- **MiniMax dosya yazma**: native `<invoke>`/`<skill>` parse edilip gerçek araçlara yönlendiriliyor; büyük içerikteki JSON-kaçış sorunu ortadan kalktı.
+- **Memory recall split-brain**: hafıza `default.json`'da tutulurken okuyucular `<userName>.json` arıyordu → chat/code kullanıcıyı hiç hatırlamıyordu ("adım ne?"→"bilmiyorum"). `loadUserMemory` + `repl.loadMemory` artık `<user>.json` + legacy `default.json`'ı birleştirir (isim-eşleşme guard'ı).
+- **Bot personası**: jenerik "Asistan" placeholder'ı gerçek persona (örn. "Hinata") ile eziliyor.
+
+### 🔒 Güvenlik
+- **Ajan modunda yıkıcı komut guard'ı**: varsayılan 'full' politika `rm -rf /`'i bile geçiriyordu (insan için bilinçli olabilir, model için değil). Agentic-runner artık `isDangerousCommand`'ı politikadan bağımsız uygular — yıkıcı komutlar ajan tarafından **çalıştırılmaz**. Diğer ~85 araç allowlist dışı (yalnızca write_file/read_file/edit_file/skill_view/bash).
+
+Doğrulama: gerçek MiniMax API ile uçtan uca (yarış oyunu + "node script yaz&çalıştır"→42); **474 test yeşil**.
+
 ## [5.23.0] - 2026-07-02 — "NON-TOOL-CALLING FIX" (MiniMax dosya yazma)
 
 ### 🐛 Düzeltme

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "5.23.0",
+  "version": "5.25.0",
   "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

@@ -145,11 +145,36 @@ function getConfig() {
 const { isMiniMax, isGemini, buildChatEndpoint } = require('../utils/provider-detect');
 
 function loadMemory(username) {
-  const file = path.join(MEMORY_DIR, `${(username || 'default').toLowerCase()}.json`);
-  try {
-    if (fs.existsSync(file)) return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {}
-  return { name: username || 'Kullanıcı', nickname: null, botName: 'Asistan', facts: [], preferences: [], history: [] };
+  const uname = (username || 'default').toLowerCase();
+  const base = { name: username || 'Kullanıcı', nickname: null, botName: null, facts: [], preferences: [], history: [] };
+  const readJson = (f) => { try { return fs.existsSync(f) ? JSON.parse(fs.readFileSync(f, 'utf8')) : null; } catch { return null; } };
+
+  const userMem = readJson(path.join(MEMORY_DIR, `${uname}.json`));
+  const merged = userMem
+    ? { ...base, ...userMem, facts: [...(userMem.facts || [])], preferences: [...(userMem.preferences || [])], history: [...(userMem.history || [])] }
+    : { ...base };
+
+  // Legacy default.json'i birlestir (isim eslesiyorsa ya da isimsizse): eski kurulumlarda
+  // hafiza + bot personasi default.json'da kalmis olabiliyordu; <user>.json ile split-brain
+  // olusuyordu. Birlestirince recall calisir ve ilk kayitta konsolide olur.
+  if (uname !== 'default') {
+    const def = readJson(path.join(MEMORY_DIR, 'default.json'));
+    if (def && (!def.name || String(def.name).toLowerCase() === uname)) {
+      // Jenerik "Asistan" placeholder'ini gercek persona (orn. Hinata) ile ez
+      const isGeneric = (b) => !b || /^asistan$/i.test(String(b));
+      if (isGeneric(merged.botName) && def.botName && !isGeneric(def.botName)) merged.botName = def.botName;
+      if ((!merged.name || merged.name === 'Kullanıcı') && def.name) merged.name = def.name;
+      const factVal = (f) => ((f && (f.value != null ? f.value : f)) || '').toString().trim();
+      const seen = new Set(merged.facts.map(f => factVal(f).toLowerCase()));
+      for (const f of (def.facts || [])) {
+        const v = factVal(f);
+        if (v && !seen.has(v.toLowerCase())) { seen.add(v.toLowerCase()); merged.facts.push(f); }
+      }
+    }
+  }
+
+  if (!merged.botName) merged.botName = 'Asistan';
+  return merged;
 }
 
 function saveMemory(username, memory) {

package/src/tools/agentic-runner.js

@@ -0,0 +1,281 @@
+/**
+ * agentic-runner — "agentic-text" modeller (MiniMax M2.x gibi) icin bounded tool döngüsü.
+ *
+ * Neden: MiniMax M2.5 tool call'larini OpenAI tarzi `message.tool_calls` JSON'u yerine
+ * dogrudan metin icinde native XML olarak uretir:
+ *   <minimax:tool_call><invoke name="write_file"><parameter name="path">...</parameter>
+ *   <parameter name="content">...</parameter></invoke></minimax:tool_call>
+ * Ayrica skill'leri <skill>ad</skill> ile yuklemek ister. Eski passthrough bunlari
+ * hic islemedigi icin (JSON.parse patliyor, bos catch yutuyor) dosya asla yazilmiyordu.
+ *
+ * Bu modul o XML'i parse eder, gercek araclari (write_file/read_file/edit_file/skill_view)
+ * calistirir, sonuclari modele geri besler ve is bitene kadar (ya da MAX adima kadar) doner.
+ *
+ * Guvenlik: sadece allowlist'teki araclar calisir. bash/shell gibi keyfi komut calistirma
+ * bu modda KAPALIDIR (onay katmanini atlamamak icin).
+ */
+const path = require('path');
+const os = require('os');
+
+// Agentic dongude izin verilen araclar. bash BURADA ama guvenli: bash.js kendi
+// icinde approvals politikasini uyguluyor (isSafeCommand → direkt; tehlikeli → red;
+// digerleri → allowlist/full moda gore). Yani keyfi/yikici komut calismaz.
+// Diger ~85 arac (discord, telegram, cron, browser...) bilerek DISARIDA.
+const DEFAULT_ALLOWED = ['write_file', 'read_file', 'edit_file', 'skill_view', 'bash'];
+
+const TOOL_ALIASES = {
+  write_file: 'write_file', create_file: 'write_file', writefile: 'write_file', write: 'write_file', create: 'write_file', save_file: 'write_file', new_file: 'write_file',
+  read_file: 'read_file', readfile: 'read_file', view_file: 'read_file', open_file: 'read_file', cat: 'read_file',
+  edit_file: 'edit_file', editfile: 'edit_file', str_replace: 'edit_file', str_replace_editor: 'edit_file', replace_in_file: 'edit_file',
+  skill_view: 'skill_view', skillview: 'skill_view', load_skill: 'skill_view', view_skill: 'skill_view', skill: 'skill_view',
+  bash: 'bash', run_command: 'bash', shell: 'bash', shell_command: 'bash', exec: 'bash', run_terminal: 'bash', terminal: 'bash', run: 'bash', command: 'bash',
+};
+
+function expandHome(p) {
+  if (!p || typeof p !== 'string') return p;
+  if (p.startsWith('~')) return path.join(os.homedir(), p.slice(1));
+  return p;
+}
+
+// Ajanin urettigi komutlar icin ekstra koruma. bash.js kendi politikasini uygular
+// ama varsayilan 'full' mod yikici komutlari (rm -rf gibi) bile gecirir — bu insan
+// icin bilincli olabilir, ama MODELIN urettigi komut icin degil. Bu yuzden agentic
+// yolda yikici komutlari politikadan BAGIMSIZ olarak engelliyoruz.
+function defaultIsDangerous(cmd) {
+  try { return require('../utils/approvals').isDangerousCommand(cmd); } catch { return false; }
+}
+
+/**
+ * Model metninden agentic tool cagrilarini cikar.
+ * Destekler: <invoke name><parameter name> (opsiyonel <minimax:tool_call> sarmali),
+ * <skill>ad</skill> kisayolu, ve yan yana gelen native OpenAI tool_calls.
+ */
+function parseAgenticCalls(content, nativeToolCalls) {
+  const calls = [];
+  content = content || '';
+
+  for (const tc of nativeToolCalls || []) {
+    const fn = tc.function || {};
+    if (!fn.name) continue;
+    let args = {};
+    try { args = typeof fn.arguments === 'string' ? JSON.parse(fn.arguments || '{}') : (fn.arguments || {}); } catch {}
+    calls.push({ tool: fn.name, args });
+  }
+
+  const invokeRe = /<invoke\s+name=["']([^"']+)["']\s*>([\s\S]*?)<\/invoke>/g;
+  let m;
+  while ((m = invokeRe.exec(content)) !== null) {
+    const tool = m[1].trim();
+    const body = m[2];
+    const args = {};
+    const paramRe = /<parameter\s+name=["']([^"']+)["']\s*>([\s\S]*?)<\/parameter>/g;
+    let pm;
+    while ((pm = paramRe.exec(body)) !== null) {
+      args[pm[1].trim()] = pm[2];
+    }
+    calls.push({ tool, args });
+  }
+
+  const skillRe = /<skill>\s*([^<>\n]+?)\s*<\/skill>/g;
+  while ((m = skillRe.exec(content)) !== null) {
+    const name = m[1].trim();
+    if (!calls.some(c => /skill/i.test(c.tool || '') && c.args && c.args.name === name)) {
+      calls.push({ tool: 'skill_view', args: { name } });
+    }
+  }
+
+  return calls;
+}
+
+/** Final yanittan protokol jetonlarini temizle (kullaniciya gosterim icin). */
+function stripProtocolTokens(s) {
+  return (s || '')
+    .replace(/<minimax:tool_call>[\s\S]*?<\/minimax:tool_call>/g, '')
+    .replace(/<invoke[\s\S]*?<\/invoke>/g, '')
+    .replace(/<skill>[\s\S]*?<\/skill>/g, '')
+    .replace(/<available_skills>[\s\S]*?<\/available_skills>/g, '')
+    .replace(/<\/?(minimax:tool_call|available_skills|available_skins)>/g, '')
+    .trim();
+}
+
+/**
+ * Streaming ekran filtresi: model canli akarken duz metni goster, ama tool-call/skill
+ * protokol bloklarini (<minimax:tool_call>, <invoke>, <skill>, <available_skills>)
+ * kullaniciya HAM gosterme. Bir protokol jetonu gorunce o tur icin gostermeyi keser
+ * (icerik yine tam biriktirilir; parse sonra yapilir). Kismi tag chunk sinirinda
+ * bolunebilir — sonda olasi kismi-tag kuyrugunu tutar.
+ *
+ *   const f = makeStreamFilter(t => process.stdout.write(t), () => process.stdout.write(' 🔧'));
+ *   f.push(deltaChunk); ... ; f.end();
+ */
+function makeStreamFilter(onText, onTool) {
+  const MARKERS = ['<minimax:tool_call', '<invoke', '<skill>', '<available_skills'];
+  let buf = '';
+  let suppressed = false;
+  return {
+    push(chunk) {
+      if (suppressed) return;
+      buf += (chunk || '');
+      let idx = -1;
+      for (const mk of MARKERS) { const i = buf.indexOf(mk); if (i !== -1 && (idx === -1 || i < idx)) idx = i; }
+      if (idx !== -1) {
+        if (idx > 0 && onText) onText(buf.slice(0, idx));
+        buf = '';
+        suppressed = true;
+        if (onTool) onTool();
+        return;
+      }
+      const lastLt = buf.lastIndexOf('<');
+      if (lastLt === -1) { if (buf && onText) onText(buf); buf = ''; return; }
+      if (lastLt > 0 && onText) onText(buf.slice(0, lastLt));
+      buf = buf.slice(lastLt);
+      // buf artik '<' ile basliyor; bir marker'a buyuyebilecekse tut, degilse yaz (orn. literal <div>)
+      if (!MARKERS.some(mk => mk.startsWith(buf))) { if (onText) onText(buf); buf = ''; }
+    },
+    end() { if (!suppressed && buf && onText) onText(buf); buf = ''; return suppressed; },
+  };
+}
+
+function sanitizeArgs(args) {
+  const a = { ...args };
+  if (typeof a.content === 'string' && a.content.length > 160) a.content = `[${a.content.length} chars]`;
+  if (typeof a.new_string === 'string' && a.new_string.length > 160) a.new_string = `[${a.new_string.length} chars]`;
+  return a;
+}
+
+/**
+ * Tek bir parse edilmis cagriyi calistir.
+ * Donus: { records: [...], feedback: '...' }
+ */
+async function executeCall(call, opts = {}) {
+  const toolsDir = opts.toolsDir || __dirname;
+  const loadTool = opts.loadTool || ((n) => require(path.join(toolsDir, n + '.js')));
+  const allowed = opts.allowed || new Set(DEFAULT_ALLOWED);
+  const rawTool = (call.tool || '').trim();
+  const norm = TOOL_ALIASES[rawTool.toLowerCase()] || rawTool;
+  const records = [];
+  const feedbacks = [];
+
+  // "files" JSON dizisi (bulk-file-operations veya files parametresi) → coklu write_file
+  let files = call.args && call.args.files;
+  if (typeof files === 'string') { try { files = JSON.parse(files); } catch { files = null; } }
+  if (Array.isArray(files) && (/bulk/i.test(rawTool) || /file/i.test(rawTool) || norm === 'write_file')) {
+    let wf;
+    try { wf = loadTool('write_file'); } catch { wf = null; }
+    for (const f of files) {
+      if (!wf || !f || !f.path) { records.push({ tool: 'write_file', status: 'error', error: 'gecersiz dosya girisi' }); feedbacks.push('write_file HATA: gecersiz giris'); continue; }
+      try {
+        const res = await wf.execute({ path: expandHome(f.path), content: f.content != null ? String(f.content) : '' });
+        const ok = res && res.success !== false;
+        records.push({ tool: 'write_file', status: ok ? 'done' : 'error', args: { path: f.path }, result: res, error: ok ? undefined : (res && res.error) });
+        feedbacks.push(ok ? `write_file OK: ${res.path || f.path} (${res.size != null ? res.size : '?'} bytes)` : `write_file HATA: ${res && res.error}`);
+      } catch (e) {
+        records.push({ tool: 'write_file', status: 'error', args: { path: f.path }, error: e.message });
+        feedbacks.push(`write_file HATA: ${e.message}`);
+      }
+    }
+    return { records, feedback: feedbacks.join('\n') };
+  }
+
+  if (!allowed.has(norm)) {
+    records.push({ tool: rawTool, status: 'error', error: 'Bu modda kullanilamayan arac: ' + rawTool });
+    return { records, feedback: `${rawTool}: bu arac bu modda kullanilamaz (izin verilenler: ${[...allowed].join(', ')})` };
+  }
+
+  const args = { ...(call.args || {}) };
+  for (const k of ['path', 'name', 'command', 'old_string', 'new_string']) {
+    if (typeof args[k] === 'string') args[k] = args[k].trim();
+  }
+  if (args.path) args.path = expandHome(args.path);
+
+  // Ajan modu guvenlik guard'i: yikici/tehlikeli kabuk komutlarini calistirmadan engelle
+  if (norm === 'bash') {
+    const cmd = (args.command || args.cmd || '').toString();
+    if (!cmd.trim()) {
+      records.push({ tool: 'bash', status: 'error', error: 'Bos komut' });
+      return { records, feedback: 'bash HATA: bos komut' };
+    }
+    const isDangerous = opts.isDangerous || defaultIsDangerous;
+    if (isDangerous(cmd)) {
+      records.push({ tool: 'bash', status: 'error', args: { command: cmd }, error: 'Yikici/tehlikeli komut ajan modunda engellendi' });
+      return { records, feedback: `bash: "${cmd.slice(0, 80)}" yikici/tehlikeli goruldugu icin ajan tarafindan CALISTIRILMADI. Gerekirse kullanici komutu kendisi calistirabilir.` };
+    }
+  }
+
+  let mod;
+  try { mod = loadTool(norm); } catch {
+    records.push({ tool: rawTool, status: 'error', error: 'Bilinmeyen arac: ' + rawTool });
+    return { records, feedback: `${rawTool} HATA: bilinmeyen arac` };
+  }
+  const fn = mod.execute || (mod.default && mod.default.execute);
+  if (typeof fn !== 'function') {
+    records.push({ tool: norm, status: 'error', error: 'execute yok' });
+    return { records, feedback: `${norm} HATA: execute fonksiyonu yok` };
+  }
+  try {
+    const res = await fn(args);
+    let feedback, status;
+    if (typeof res === 'string') {
+      status = 'done';
+      feedback = `${norm} sonucu:\n` + res.slice(0, 1500);
+    } else {
+      const ok = res && res.success !== false;
+      status = ok ? 'done' : 'error';
+      feedback = ok
+        ? `${norm} OK` + (res.path ? `: ${res.path} (${res.size != null ? res.size : '?'} bytes)` : (res.output ? ': ' + String(res.output).slice(0, 300) : ''))
+        : `${norm} HATA: ${res && res.error}`;
+    }
+    records.push({ tool: norm, status, args: sanitizeArgs(args), result: res });
+    return { records, feedback };
+  } catch (e) {
+    records.push({ tool: norm, status: 'error', args: sanitizeArgs(args), error: e.message });
+    return { records, feedback: `${norm} HATA: ${e.message}` };
+  }
+}
+
+/**
+ * Ana agentic dongu.
+ * callModel(messages) => Promise<{ content, toolCalls }>
+ * Donus: { records, reply, iterations }
+ */
+async function runAgentic({ callModel, systemPrompt, historyMessages, task, toolsDir, loadTool, allowed, maxIterations = 15 }) {
+  const messages = [{ role: 'system', content: systemPrompt }];
+  for (const mm of historyMessages || []) messages.push({ role: mm.role, content: mm.content || '' });
+  messages.push({ role: 'user', content: task });
+
+  const allowedSet = allowed ? new Set(allowed) : new Set(DEFAULT_ALLOWED);
+  const allRecords = [];
+  let finalReply = '';
+  let iterations = 0;
+
+  for (let i = 0; i < maxIterations; i++) {
+    iterations++;
+    const { content, toolCalls } = await callModel(messages);
+    const calls = parseAgenticCalls(content, toolCalls);
+
+    if (calls.length === 0) {
+      finalReply = stripProtocolTokens(content);
+      break;
+    }
+
+    messages.push({ role: 'assistant', content: content || '' });
+    const feedbacks = [];
+    for (const call of calls) {
+      const { records, feedback } = await executeCall(call, { toolsDir, loadTool, allowed: allowedSet });
+      allRecords.push(...records);
+      feedbacks.push(feedback);
+    }
+    messages.push({
+      role: 'user',
+      content: '<tool_results>\n' + feedbacks.join('\n') + '\n</tool_results>\nGorev tamamlandiysa ARAC CAGIRMADAN tek cumlelik ozet yaz. Devam gerekiyorsa sonraki araci cagir.',
+    });
+
+    if (i === maxIterations - 1) {
+      finalReply = stripProtocolTokens(content) || 'Islem maksimum adima ulasti.';
+    }
+  }
+
+  return { records: allRecords, reply: finalReply, iterations };
+}
+
+module.exports = { parseAgenticCalls, stripProtocolTokens, executeCall, runAgentic, expandHome, makeStreamFilter, TOOL_ALIASES, DEFAULT_ALLOWED };

package/src/tools/workflow.js

@@ -24,23 +24,58 @@ function allToolNames() {
 
 function loadUserMemory(username) {
   try {
-    const file = path.join(os.homedir(), '.natureco', 'memory', `${(username || 'default').toLowerCase()}.json`);
-    if (fs.existsSync(file)) {
-      const mem = JSON.parse(fs.readFileSync(file, 'utf8'));
-      const facts = (mem.facts || []).map(f => f.value || f).filter(Boolean);
-      let name = mem.name || '';
-      // Extract name from facts if not saved as memory.name
-      if (!name) {
-        for (const f of facts) {
-          const match = f.toLowerCase().match(/(?:kullanici\s*adi?|kullanıcı\s*adı?|isim|name)\s*:?\s*(.+)/);
-          if (match && match[1].trim().length > 2) { name = match[1].trim(); break; }
-        }
+    const dir = path.join(os.homedir(), '.natureco', 'memory');
+    const uname = (username || 'default').toLowerCase();
+    // Kullanici-ozel dosya (`<user>.json`) + legacy `default.json`'i birlestir.
+    // Eski kurulumlarda hafiza default.json'a yazilmis olabilir; okuyucu sadece
+    // <user>.json'a bakinca eski kayitlar (ve bot personasi) hic yuklenmiyordu.
+    // default.json'i yalnizca ismi aktif kullaniciyla eslesiyorsa (ya da isimsizse)
+    // katariz — coklu kullanicida baska birinin hafizasini sizdirmamak icin.
+    const files = [];
+    const userFile = path.join(dir, `${uname}.json`);
+    if (fs.existsSync(userFile)) files.push(userFile);
+    if (uname !== 'default') {
+      const defFile = path.join(dir, 'default.json');
+      if (fs.existsSync(defFile)) {
+        try {
+          const dm = JSON.parse(fs.readFileSync(defFile, 'utf8'));
+          const dn = (dm.name || '').toLowerCase();
+          if (!dn || dn === uname) files.push(defFile);
+        } catch {}
+      }
+    }
+    if (files.length === 0) return '';
+
+    const seen = new Set();
+    const facts = [];
+    let name = '', botName = '';
+    for (const file of files) {
+      let mem;
+      try { mem = JSON.parse(fs.readFileSync(file, 'utf8')); } catch { continue; }
+      if (!name && mem.name) name = mem.name;
+      // Jenerik "Asistan" placeholder yerine gercek persona adini tercih et
+      if ((!botName || /^asistan$/i.test(botName)) && mem.botName && !/^asistan$/i.test(mem.botName)) botName = mem.botName;
+      for (const f of (mem.facts || [])) {
+        const v = (f && (f.value != null ? f.value : f));
+        if (!v || typeof v !== 'string') continue;
+        const key = v.trim().toLowerCase();
+        if (!key || seen.has(key)) continue;
+        seen.add(key);
+        facts.push(v.trim());
       }
-      const parts = [];
-      if (name) parts.push(`Kullanici adi: ${name}`);
-      if (facts.length > 0) parts.push(`Bilinenler: ${facts.slice(0, 10).join('; ')}`);
-      return parts.join('\n');
     }
+    // isim memory.name'de yoksa fact'lerden cikar
+    if (!name) {
+      for (const f of facts) {
+        const match = f.toLowerCase().match(/(?:kullanici\s*adi?|kullanıcı\s*adı?|isim|name)\s*:?\s*(.+)/);
+        if (match && match[1].trim().length > 2) { name = match[1].trim(); break; }
+      }
+    }
+    const parts = [];
+    if (name) parts.push(`Kullanici adi: ${name}`);
+    if (botName) parts.push(`Bot adi: ${botName}`);
+    if (facts.length > 0) parts.push(`Bilinenler: ${facts.slice(0, 15).join('; ')}`);
+    return parts.join('\n');
   } catch {}
   return '';
 }
@@ -126,89 +161,69 @@ async function workflow(params) {
   if (action === 'run') {
     if (!task) return { success: false, error: 'task gerekli' };
 
-    // Non-tool-calling modellerde once simple/complex kontrolu yap
+    // Non-tool-calling / agentic-text modeller (MiniMax M2.x): model tool call'larini
+    // native XML olarak (<invoke> / <minimax:tool_call>) ve skill yuklemeyi <skill> ile
+    // uretir. Bounded agentic dongu ile parse edip gercek araclari calistir.
     if (!supportsToolCalls()) {
+      const { runAgentic } = require('./agentic-runner');
       const memCtx = memoryContext();
-      // Phase 0: Check if simple chat or complex task
-      const simpleCheckPrompt = {
-        role: 'system',
-        content: 'Gorevin basit bir selamlasma/sohbet mi yoksa arac gerektiren bir islem mi oldugunu belirle. Sadece "simple" veya "complex" yaz, kesinlikle baska bir sey yazma.\n\nSimple: selamlasma, nasilsin, bugun ne yaptin, havadan sudan, genel bilgi sorusu, ben kimim, adim ne, kullanici bilgisi sorgulama, hatirlatma talebi\nComplex: dosya islemleri, kod yazma, arastirma, karsilastirma, duzenleme, otomasyon'
-      };
-      let isComplex = true;
-      try {
-        const checkBody = { model, stream: false, messages: [simpleCheckPrompt, { role: 'user', content: task }], temperature: 0, max_tokens: 20 };
-        const checkResult = await apiCall(providerUrl, providerApiKey, checkBody);
-        const raw = (checkResult.choices?.[0]?.message?.content || '').trim().toLowerCase().replace(/[^a-z]/g, '');
-        isComplex = raw !== 'simple';
-      } catch {}
-
-      if (!isComplex) {
-        // Simple chat — passthrough
-        const sysMsg = 'Sen yardimci bir asistansin. Kisa ve oz yanit ver. Konusma gecmisi varsa onceki mesajlari dikkate al.' + (memCtx ? '\n\nKullanici bilgisi:\n' + memCtx : '') + '\n\n' + skillsIndexBlock;
-        const chatBody = { model, stream: false, messages: chatMessages(sysMsg, task), temperature: 0.7, max_tokens: 1000 };
-        try {
-          const chatResult = await apiCall(providerUrl, providerApiKey, chatBody);
-          const reply = chatResult.choices?.[0]?.message?.content || '';
-          return { success: true, workflowId: 'passthrough', name: 'Direct Chat', status: 'completed', totalSteps: 0, completedSteps: 0, results: [], passthrough: true, reply };
-        } catch (e) {
-          return { success: false, error: 'Sohbet yaniti alinamadi: ' + e.message };
-        }
+      const desktop = path.join(os.homedir(), 'Desktop');
+      const sysMsg = [
+        'Sen NatureCo adli, arac kullanabilen bir yapay zeka ajanisin. Kullanicinin istegini SADECE anlatarak degil, ARACLARI cagirarak fiilen gerceklestir.',
+        memCtx ? '\nKullanici bilgisi:\n' + memCtx : '',
+        '\n\nOrtam:\n- Isletim sistemi: ' + process.platform + '\n- Kullanici home: ' + os.homedir() + '\n- Masaustu: ' + desktop + '\n- Calisma dizini: ' + process.cwd(),
+        '\n\nArac cagirmak icin TAM olarak su formati kullan:\n<minimax:tool_call>\n<invoke name="ARAC_ADI">\n<parameter name="PARAM">DEGER</parameter>\n</invoke>\n</minimax:tool_call>',
+        '\n\nKullanabilecegin araclar:',
+        '- write_file: dosya olustur/uzerine yaz. parametreler: path (TAM yol), content (dosyanin TAM icerigi). Kod/oyun/site isteniyorsa TUM icerigi content icine yaz, kisaltma.',
+        '- read_file: dosya oku. parametre: path',
+        '- edit_file: dosyada metin degistir. parametreler: path, old_string, new_string',
+        '- bash: kabuk komutu calistir (npm, git, node, python, test, ls, mkdir...). parametre: command. Guvenli komutlar dogrudan calisir; yikici/tehlikeli komutlar guvenlik politikasiyla engellenir.',
+        '- skill_view: gorevle ilgili bir skill yukle. parametre: name',
+        '\nKurallar:',
+        '- Kod yazdiktan sonra gerektiginde bash ile calistir/test et (orn. "node dosya.js", "npm test"); hata cikarsa duzelt.',
+        '- Birden fazla dosya gerekiyorsa her biri icin AYRI write_file cagir.',
+        '- Kullanici "masaustu"/"desktop" dediyse ve tam yol vermediyse dosyayi buraya yaz: ' + desktop,
+        '- Goreceli yol yerine TAM yol kullan.',
+        '- Arac sonuclari <tool_results> icinde geri gelir; gorev bitince ARAC CAGIRMADAN tek cumlelik ozet yaz.',
+        '- Basit sohbet/selamlasma ise arac cagirma, dogrudan kisa yanit ver.',
+        skillsIndexBlock ? '\n\n' + skillsIndexBlock : '',
+      ].filter(Boolean).join('\n');
+
+      const historyMessages = [];
+      if (conversationHistory && Array.isArray(conversationHistory)) {
+        for (const hm of conversationHistory) { if (hm._internal) continue; historyMessages.push({ role: hm.role, content: hm.content || '' }); }
       }
 
-      // Complex task for non-tool-calling model: ask LLM for structured file ops
-      const execSysMsg = 'Gorevi tamamlamak icin hangi dosyalarin olusturulacagini JSON olarak belirt. SADECE JSON yaz.\n\n' +
-        'Kullanici bilgisi:\n' + (memCtx || '') +
-        '\n\nMasaustu yolu: ' + require('path').join(require('os').homedir(), 'Desktop') +
-        '\n\nKullanici home: ' + require('os').homedir() +
-        '\n\nJSON format:\n{"files": [{"path": "/tam/dosya/yolu/dosya.html", "content": "dosya icerigi buraya"}]}\n\nHer dosya icin path ve content zorunlu. path TAM yol olmali (~ veya goreceli degil). Birden fazla dosya olusturulabilir.' +
-        '\n\n' + skillsIndexBlock;
-      const execBody = { model, stream: false, messages: chatMessages(execSysMsg, task), temperature: 0.3, max_tokens: 8000 };
-      try {
-        const execResult = await apiCall(providerUrl, providerApiKey, execBody);
-        const reply = execResult.choices?.[0]?.message?.content || '';
-
-        // Try to extract JSON with file operations
-        const jsonStart = reply.indexOf('{');
-        const jsonEnd = reply.lastIndexOf('}');
-        let stepResults = [];
-        let fileWriteSuccess = false;
-
-        if (jsonStart !== -1 && jsonEnd > jsonStart) {
-          try {
-            const plan = JSON.parse(reply.slice(jsonStart, jsonEnd + 1));
-            if (plan.files && Array.isArray(plan.files)) {
-              // Execute file writes locally
-              for (const f of plan.files) {
-                try {
-                  const wfPath = f.path ? require('path').resolve(f.path.replace(/^~/, require('os').homedir())) : '';
-                  if (!wfPath) continue;
-                  require('fs').mkdirSync(require('path').dirname(wfPath), { recursive: true });
-                  require('fs').writeFileSync(wfPath, f.content || '', 'utf-8');
-                  const stats = require('fs').statSync(wfPath);
-                  stepResults.push({ step: 1, tool: 'write_file', status: 'done', args: { path: wfPath }, result: { success: true, path: wfPath, size: stats.size } });
-                  fileWriteSuccess = true;
-                } catch (wfErr) {
-                  stepResults.push({ step: 1, tool: 'write_file', status: 'error', error: wfErr.message });
-                }
-              }
-            }
-          } catch {}
-        }
+      async function callModel(msgs) {
+        const body = { model, stream: false, messages: msgs, temperature: 0.3, max_tokens: 16000 };
+        const r = await apiCall(providerUrl, providerApiKey, body);
+        const msg = r.choices?.[0]?.message || {};
+        return { content: msg.content || '', toolCalls: msg.tool_calls || [] };
+      }
 
-        if (fileWriteSuccess) {
-          const lines = stepResults.map(r => { const p = r.result?.path || ''; const s = r.result?.size || 0; const name = require('path').basename(p); return `  ✓ ${name} oluşturuldu (${s} bytes)`; }).join('\n');
-          const reply = `Dosya(lar) başarıyla oluşturuldu:\n${lines}`;
-          return {
-            success: true, workflowId: 'file_write_' + Date.now().toString(36),
-            name: 'File Operations', status: 'completed',
-            totalSteps: stepResults.length, completedSteps: stepResults.length,
-            results: stepResults,
-            passthrough: true, reply,
-          };
+      try {
+        const { records, reply } = await runAgentic({
+          callModel, systemPrompt: sysMsg, historyMessages, task,
+          toolsDir: __dirname, maxIterations: 15,
+        });
+        const fileWrites = records.filter(r => r.tool === 'write_file' && r.status === 'done');
+        let finalReply = reply || '';
+        if (fileWrites.length > 0) {
+          const lines = fileWrites.map(r => `  ✓ ${path.basename((r.result && r.result.path) || (r.args && r.args.path) || '')} olusturuldu (${(r.result && r.result.size != null) ? r.result.size : '?'} bytes)`).join('\n');
+          finalReply = (finalReply ? finalReply + '\n\n' : '') + 'Dosya(lar):\n' + lines;
         }
-
-        // If no structured file ops detected, return LLM reply as passthrough
-        return { success: true, workflowId: 'passthrough', name: 'Direct Generation', status: 'completed', totalSteps: 0, completedSteps: 0, results: [{ step: 0, tool: 'chat', status: 'done', result: { reply } }], passthrough: true, reply };
+        const done = records.filter(r => r.status === 'done').length;
+        return {
+          success: true,
+          workflowId: (records.length ? 'agentic_' : 'passthrough_') + Date.now().toString(36),
+          name: records.length ? 'Agentic Run' : 'Direct Chat',
+          status: 'completed',
+          totalSteps: records.length,
+          completedSteps: done,
+          results: records.map((r, i) => ({ step: i + 1, ...r })),
+          passthrough: true,
+          reply: finalReply || 'Tamamlandi.',
+        };
       } catch (e) {
         return { success: false, error: 'Yanit alinamadi: ' + e.message };
       }