beast-agent 0.15.0

package/src/agent/engine.js

@@ -0,0 +1,3118 @@
+'use strict';
+
+/* Beast engine: sessions, frugal context, streaming tool loop.
+   v2: token-bazlı bağlam bütçesi (kullanım kalibrasyonlu), paralel tool
+   çağrıları, retrieval'lı memory, web araçları, alt-agent ve todo listesi. */
+
+const fs = require('fs');
+const path = require('path');
+const { chatStream } = require('./llm');
+const { chatCompletionsUrl } = require('./config');
+const tools = require('./tools');
+const memory = require('./memory');
+const skills = require('./skills');
+const { estTokens, estMsgTokens } = require('./tokens');
+
+const MAX_TURNS = 25;
+const SUB_MAX_TURNS = 8;
+const HISTORY_TOKEN_BUDGET = 18000;
+const TOOL_OUT_KEEP = 1200;
+const USER_MAX = 8000;
+
+/* Oturum notları (geçici hafıza): eski mesajlar bütçeden düşülmeden önce
+   önemli noktalar çıkarılır, sistem promptuna küçük blok olarak girer. */
+const NOTES_TRIGGER = 14; // #24 son nottan bu yana bu kadar mesaj birikince not güncelle
+const NOTES_KEEP_RECENT = 6; // son N mesaj her zaman birebir tutulur
+const NOTES_MAX_UNITS = 12; // notlar varken birebir tutulan azami birim sayısı
+
+/* Superyorizyon (#15): CEO paralel ajanları kendi başına bırakmaz.
+   Supervisor döngüsü periyodik denetler: takılan/çok uzun süren işte
+   ana oturuma [SUPERYORIZON] uyarısı düşer, CEO müdahale eder. */
+const SUP_CHECK_MS = 60000; // denetim aralığı
+const SUP_STUCK_START_MIN = 3; // en az bu kadar süredir koşuyor ve...
+const SUP_IDLE_MIN = 2; // ...bu kadar süredir hiç aktivite yoksa TAKILDI
+const SUP_LONG_MIN = 6; // bu kadar süredir koşuyorsa ara kontrol nödü
+const SUP_NUDGE_COOLDOWN_MIN = 4; // aynı iş için iki uyarı arası min süre
+const BG_FIX_MAX = 2; // paralel ajanın otomatik öz-kurtarma hakkı (bitince CEO devreye girer)
+/* Zarif bitirme: iş BU sürede bitmezse ajan artık yeni araştırma yapmaz,
+   elindekiyle SON RAPORU yazar ve düzgün biter — "görev bitmeden patlama" yok */
+const BG_WRAP_MIN = 4;
+/* #5 hız: eşzamanlı arka plan LLM turu sınırı — rate-limit yemeden maksimum paralellik */
+const BG_MAX_CONCURRENT_DEFAULT = 4;
+/* #17 kalıcı başarısızlıkta owner'a anlık uyarı */
+const OWNER_FAIL_EMAIL = 'info@algokod.com';
+/* bu bayrak çalışma zamanında /notify on|off ile değiştirilir (main köprüsü) */
+
+/* Düşünme (reasoning) seviyeleri — sağlayıcıların GERÇEK değerleri.
+   OpenAI (reasoning.effort) ve OpenRouter (reasoning_effort) 2026 itibarıyla:
+   none · minimal · low · medium · high · xhigh · max.
+   0 (Kapalı) parametre göndermez; 1-5 API'ye reasoning_effort olarak gider.
+   Model desteklemiyorsa llm.js tek seferlik parametresiz retry yapar. */
+const THINK_LEVELS = [
+  { v: 0, label: 'Kapalı', effort: null },
+  { v: 1, label: 'Low', effort: 'low' },
+  { v: 2, label: 'Medium', effort: 'medium' },
+  { v: 3, label: 'High', effort: 'high' },
+  { v: 4, label: 'X-High', effort: 'xhigh' },
+  { v: 5, label: 'Max', effort: 'max' },
+];
+
+/* Çıktı biçimi kuralı: # ve * karakteri yasak (tüm ajanlar için ortak metin) */
+const FORMAT_RULES =
+  'ÇIKTI BİÇİMİ (ZORUNLU):\n' +
+  '- Yanıtlarında asla # karakteri kullanma (markdown başlık yok).\n' +
+  '- Asla * karakteri kullanma (kalın/italik yıldız yok); madde işaretleri için - kullan.\n' +
+  '- Renkli sembol/ikon kullanma (renkli kalp, daire vb. yok); normal sarı emoji kullanabilirsin.\n' +
+  '- Kod bloklarında dil gereği # veya * gerekiyorsa kod içinde serbest.';
+
+/* Kişi bazlı granül izin seviyeleri: hangi araçlara erişilebilir */
+const PERM_TOOL_SETS = {
+  all: null, // tüm araçlar (filtre yok)
+  web: new Set([
+    'web_search', 'http_fetch',
+    'browser_open', 'browser_read', 'browser_snapshot', 'browser_screenshot',
+    'browser_click', 'browser_type', 'browser_press', 'browser_scroll', 'browser_select',
+    'ocr_read',
+  ]),
+  read: new Set([
+    'web_search', 'http_fetch',
+    'browser_open', 'browser_read', 'browser_snapshot',
+    'list_dir', 'read_file',
+  ]),
+  chat: new Set([]), // sadece sohbet
+};
+const PERM_LEVELS = ['all', 'web', 'read', 'chat'];
+
+/* CEO modu: ana (konuşma) oturumunun KULLANAMAYACAĞI uygulayıcı araçlar.
+   Bunların hepsi run_background ile paralel ajana devredilir — CEO sadece
+   konuşur, planlar, emir verir ve takip eder. */
+const CEO_EXEC_TOOLS = new Set([
+  'run_command', 'read_file', 'write_file', 'list_dir',
+  'python_run',
+  'web_search', 'http_fetch',
+  'browser_open', 'browser_read', 'browser_screenshot', 'browser_snapshot',
+  'browser_click', 'browser_type', 'browser_press', 'browser_scroll', 'browser_select',
+  'computer_look', 'computer_act',
+  'ocr_read',
+  'delegate_task', // senkron bekler — CEO hep asenkron run_background kullanır
+]);
+
+/* Arka plan oturumunun görmemesi gerekenler: alt ajan daha fazla alt dal
+   açmasın ve kendini iptal edemesin — işi bitirip rapor yazsın. */
+const BG_HIDDEN_TOOLS = new Set(['run_background', 'tasks_list', 'task_status', 'task_cancel']);
+
+function uid() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+}
+function nowIso() {
+  return new Date().toISOString();
+}
+function clamp(n, lo, hi) {
+  return Math.max(lo, Math.min(hi, n));
+}
+
+/* İnsan-okur 6 haneli oturum kodu — karıştırılan harfler (0,O,1,I,L) yok */
+const CODE_ALPHABET = '23456789ABCDEFGHJKMNPQRSTUVWXYZ';
+function sessionCode() {
+  let s = '';
+  for (let i = 0; i < 6; i++) {
+    s += CODE_ALPHABET[Math.floor(Math.random() * CODE_ALPHABET.length)];
+  }
+  return s;
+}
+
+/* Yansıma cevabından JSON çıkarımı: düz JSON, ```json fence'li veya
+   metin arasına gömülü olabilir. Bozuk girişte null döner. */
+function parseReflectionJson(text) {
+  const t = String(text || '').replace(/```(?:json)?/gi, '');
+  const start = t.indexOf('{');
+  if (start < 0) return null;
+  /* son } itibarıyla dene, patlarsa kademeli kırp */
+  for (let end = t.lastIndexOf('}'); end > start; end = t.lastIndexOf('}', end - 1)) {
+    try {
+      const obj = JSON.parse(t.slice(start, end + 1));
+      if (obj && typeof obj === 'object' && typeof obj.create === 'boolean') return obj;
+    } catch {}
+  }
+  return null;
+}
+
+/* ---------- todo yardımcıları ---------- */
+
+function sanitizeTodoItems(items) {
+  if (!Array.isArray(items)) return [];
+  const out = [];
+  const seen = new Set();
+  for (const it of items.slice(0, 20)) {
+    const rawTitle = typeof it === 'string' ? it : it && it.title;
+    const title = String(rawTitle ?? '').replace(/\s+/g, ' ').trim().slice(0, 120);
+    if (!title || seen.has(title)) continue;
+    seen.add(title);
+    const status = ['pending', 'active', 'done'].includes(it && it.status) ? it.status : 'pending';
+    out.push({ title, status });
+  }
+  return out;
+}
+
+function customChain(list) {
+  const out = [];
+  for (const p of Array.isArray(list) ? list : []) {
+    if (!p || !p.baseUrl || !p.key) continue;
+    for (const m of p.models || []) {
+      out.push({
+        providerId: 'custom:' + p.id,
+        providerName: p.name || 'Custom',
+        model: m,
+        url: chatCompletionsUrl(p.baseUrl),
+        key: p.key,
+        costIn: Number(p.priceIn ?? p.price_in) || null,
+        costOut: Number(p.priceOut ?? p.price_out) || null,
+      });
+    }
+  }
+  return out;
+}
+
+class Engine {
+  constructor(cfg, opts) {
+    this.cfg = cfg || {};
+    /* emit sarmalayıcı: paralel ajan olaylarını superyorizyon için izle */
+    const userEmit = opts.emit || (() => {});
+    this.emit = (ev) => {
+      try { this._bgTrack(ev); } catch {}
+      userEmit(ev);
+    };
+    this.sessionsDir = opts.sessionsDir;
+    fs.mkdirSync(this.sessionsDir, { recursive: true });
+    this.workspace = opts.workspace || process.env.USERPROFILE || '.';
+    this.cfg.baseChain = (this.cfg.chain || []).slice();
+    this.cfg.chain = [...this.cfg.baseChain, ...customChain(opts.customProviders)];
+    this.sel = this._resolve(opts.modelOverride) || this.cfg.defaultSelection || null;
+    this.roleModels = opts.roleModels || {}; // { vision?, terminal?, coding?, subagent? } // providerId::model string
+    this.lockdown = !!opts.lockdown; // varsayılan kısıt (oturum bazlı override edilmezse)
+    this.sessionPerm = new Map(); // sessionId -> 'web'|'read'|'chat' (kişi bazlı izin)
+    this.deletedModels = new Set(opts.deletedModels || []); // kullanıcı tarafından listeden silinenler
+    this.fallout = this._normalizeFallout(opts.fallout); // FALLOUT: yedek provider/model/key zinciri
+    this.limits = this._normalizeLimits(opts.limits); // provider bazlı max input limiti + bağlam sıkıştırma
+    this.crashFile = opts.crashFile || null; // çökme durumu buraya yazılır (kurtarma için)
+    this._customProviders = opts.customProviders || [];
+    this.cache = new Map();
+    this.ctrls = new Map();
+    this.todos = new Map(); // sessionId -> [{title,status}]
+    this.tokRatio = 1; // gerçek prompt_tokens ile kalibre edilir
+    this._codeIndex = new Map(); // kısa oturum kodu -> session id
+    /* yansıma: oturumda 5+ yeni araç çağrısında skill taslağı denenir */
+    this.reflection = { enabled: opts.reflection !== false, minTools: 5 };
+    this.historyTokenBudget = Number(opts.historyTokenBudget) || HISTORY_TOKEN_BUDGET;
+    this.browser = opts.browser || null; // dahili tarayıcı kancaları
+    this.fileSend = opts.fileSend || null; // #26 dosya gönderim köprüsü (chat/WA)
+    this.notifyOwnerFail = opts.notifyOwnerFail !== false; // #25 hata mail bildirimi (runtime /notify)
+    this.reminders = opts.reminders || null; // hatırlatıcı kancası (main enjekte eder)
+    this.watchers = opts.watchers || null; // arka plan izleyici köprüsü (main enjekte eder)
+    /* onay kapısı: riskli araç öncesi dış onay beklenir ({request} async) */
+    this.approvals = opts.approvals || null;
+    /* "bir daha sorma" onaylanan araçlar — bu setteki riskli araçlar sorulmaz */
+    this.alwaysAllowTools = new Set(Array.isArray(opts.alwaysAllowTools) ? opts.alwaysAllowTools : []);
+    /* olay merkezi köprüsü (#4): event_subscribe/list/unsubscribe */
+    this.bus = opts.bus || null;
+    /* computer use köprüsü (#4 v11): { look(), act(op,args) } — main enjekte eder */
+    this.computer = opts.computer || null;
+    /* dahili OCR köprüsü: { ocr({image, lang}) } — görsel desteklemeyen modeller için */
+    this.ocr = opts.ocr || null;
+    this.email = opts.email || null; // e-posta kancaları {list, read, send}
+    /* CEO modu: konuşan ana ajan iş YAPMAZ — paralel ajana devreder (varsayılan açık) */
+    this.ceoMode = opts.ceoMode !== false;
+    /* Düşünme (reasoning) seviyesi: 0=Kapalı .. 5=Max (/think veya üst bardan seçilir) */
+    this.thinkLevel = Math.min(5, Math.max(0, Math.round(Number(opts.thinkLevel) || 0)));
+    /* paralel arka plan ajanları kaydı: bgSessionId -> job */
+    this._bgJobs = new Map();
+    this._kickTimers = new Map(); // sid -> bekleyen öz-kurtarma gönderim zamanlayıcısı
+    /* #5 eşzamanlılık kuyruğu + #18 fan-out grupları */
+    this._bgLimit = Math.max(1, Number(opts.bgLimit || process.env.BEAST_BG_LIMIT) || BG_MAX_CONCURRENT_DEFAULT);
+    this._bgPendingStart = new Map(); // sid -> ilk görev metni (slot açılınca gönderilir)
+    this._bgGroups = new Map(); // groupId -> {parentId,total,results,dead}
+    /* #17 kalıcı ajan geçmişi: restart sonrası işler + sohbetler kaybolmasın */
+    this._bgJobsFile = path.join(this.sessionsDir, 'bg-jobs.json');
+    this._loadBgJobsPersisted();
+    /* superyorizyon döngüsü: takılan/uzun süren ajanı CEO'ya bildirir */
+    this._supTimer = setInterval(() => {
+      try { this._supervise(); } catch {}
+    }, SUP_CHECK_MS);
+    if (this._supTimer.unref) this._supTimer.unref();
+    skills.seedIfEmpty();
+  }
+
+  /* Zinciri yeniden kur: base + custom, silinenleri ayıkla */
+  _rebuildChain() {
+    const full = [...(this.cfg.baseChain || []), ...customChain(this._customProviders)];
+    const key = (c) => c.providerId + '::' + c.model;
+    this.cfg.chain = full.filter((c) => !this.deletedModels.has(key(c)));
+    // aktif model silindiyse varsayılana dön
+    if (this.sel) {
+      const k = this.sel.providerId + '::' + this.sel.model;
+      const stillThere = full.some((c) => key(c) === k) && !this.deletedModels.has(k);
+      if (!stillThere) {
+        const defKey = this.cfg.defaultSelection
+          ? this.cfg.defaultSelection.providerId + '::' + this.cfg.defaultSelection.model
+          : null;
+        this.sel =
+          defKey && !this.deletedModels.has(defKey)
+            ? this.cfg.defaultSelection
+            : this.cfg.chain[0] || null;
+      }
+    }
+  }
+
+  setCustomProviders(list) {
+    this._customProviders = list || [];
+    this._rebuildChain();
+  }
+
+  setDeletedModels(list) {
+    this.deletedModels = new Set(Array.isArray(list) ? list : []);
+    this._rebuildChain();
+  }
+
+  setLockdown(v) {
+    this.lockdown = !!v;
+  }
+
+  /* Kişi bazlı granül izin — WhatsApp oturumları için. 'all' kaydı siler. */
+  setSessionPerm(sessionId, perm) {
+    const id = String(sessionId || '');
+    if (!id) return;
+    const p = PERM_LEVELS.includes(perm) ? perm : null;
+    if (p && p !== 'all') this.sessionPerm.set(id, p);
+    else this.sessionPerm.delete(id);
+  }
+
+  sessionPermFor(sessionId) {
+    const p = this.sessionPerm.get(String(sessionId || ''));
+    if (p) return p;
+    return this.lockdown ? 'chat' : 'all';
+  }
+
+  setRoleModels(map) {
+    this.roleModels = map || {};
+  }
+
+  setCeoMode(v) {
+    this.ceoMode = !!v;
+  }
+
+  /* ---------- FALLOUT: çökme sonrası otomatik kurtarma zinciri ---------- */
+
+  _normalizeFallout(f) {
+    const out = { enabled: !!(f && f.enabled), chain: [] };
+    const slots = Array.isArray(f && f.slots) ? f.slots : [];
+    const valid = [];
+    for (const s of slots) {
+      if (!s || typeof s !== 'object') continue;
+      const providerId = String(s.providerId || '').trim();
+      const model = String(s.model || '').trim();
+      const key = String(s.key || '').trim();
+      if (!providerId || !model || !key) continue;
+      valid.push({
+        providerId,
+        providerName: String(s.providerName || providerId),
+        model,
+        key,
+      });
+    }
+    out.chain = valid.slice(0, 10);
+    return out;
+  }
+
+  setFallout(cfg) {
+    this.fallout = this._normalizeFallout(cfg);
+  }
+
+  /* ---------- provider bazlı girdi limiti + bağlam sıkıştırma ---------- */
+
+  _normalizeLimits(l) {
+    const out = { enabled: false, compress: true, default: 0, perProvider: {} };
+    if (!l || typeof l !== 'object') return out;
+    out.enabled = !!l.enabled;
+    out.compress = l.compress !== false;
+    out.default = Math.max(0, Math.round(Number(l.default) || 0));
+    const per = l.perProvider && typeof l.perProvider === 'object' ? l.perProvider : {};
+    for (const [k, v] of Object.entries(per)) {
+      const n = Math.max(0, Math.round(Number(v) || 0));
+      if (n > 0 && k) out.perProvider[String(k)] = n;
+    }
+    return out;
+  }
+
+  setLimits(l) {
+    this.limits = this._normalizeLimits(l);
+  }
+
+  /* Seçili provider için girdi token limiti (0 = limitsiz) */
+  _inputLimitFor(sel) {
+    if (!this.limits || !this.limits.enabled || !sel) return 0;
+    const per = this.limits.perProvider[sel.providerName];
+    return per || this.limits.default || 0;
+  }
+
+  /* Payload limiti aşıyorsa sıkıştır: system korunur, sondan geriye sığanlar
+     alınır, kopuk tool zinciri hizalanır, araya kısa sıkıştırma notu girer.
+     withNote=false ise sessiz kırpım yapılır. */
+  _compressPayload(payload, maxTokens, withNote) {
+    if (!Array.isArray(payload) || payload.length < 2) return payload;
+    const sys = payload[0];
+    const rest = payload.slice(1);
+    const sysCost = Math.ceil(estMsgTokens(sys) * this.tokRatio);
+    const budget = maxTokens - sysCost - 48;
+    if (budget <= 0) return [sys, rest[rest.length - 1]].filter(Boolean);
+    const picked = [];
+    let used = 0;
+    for (let i = rest.length - 1; i >= 0; i--) {
+      const cost = Math.ceil(estMsgTokens(rest[i]) * this.tokRatio);
+      if (used + cost > budget) {
+        if (picked.length) break; // sığmayan eski mesajlar atılır
+        continue; // en yeni mesaj bile sığmıyorsa onu da at (aşağıda min. 1 tutulur)
+      }
+      picked.unshift(rest[i]);
+      used += cost;
+    }
+    if (!picked.length) picked.push(rest[rest.length - 1]);
+    /* kopuk tool yanıtıyla başlama — assistant/tool_calls grubu bozulmasın */
+    while (picked.length && picked[0].role === 'tool') picked.shift();
+    if (!picked.length) picked.push(rest[rest.length - 1]);
+    if (picked.length >= rest.length) return payload; // zaten sığıyordu
+    if (withNote) {
+      const dropped = rest.length - picked.length;
+      picked.unshift({
+        role: 'system',
+        content: `[bağlam sıkıştırıldı: önceki ${dropped} mesaj, ${maxTokens} token girdi limiti nedeniyle çıkarıldı]`,
+      });
+    }
+    return [sys, ...picked];
+  }
+
+  /* Fallout kayıtlarını mevcut zincirdeki URL'lerle eşleştir.
+     Aynı provider+model farklı key ile birden fazla kez gelebilir. */
+  _falloutSelections(exclude) {
+    if (!this.fallout.enabled) return [];
+    const chain = this.cfg.chain || [];
+    const exKey = exclude ? exclude.providerId + '::' + exclude.model + '::' + exclude.key : null;
+    const out = [];
+    for (const e of this.fallout.chain) {
+      const base =
+        chain.find((c) => c.providerId === e.providerId && c.model === e.model) ||
+        chain.find((c) => c.providerId === e.providerId);
+      if (!base) continue; // provider artık kayıtlı değil, atla
+      const sel = {
+        providerId: base.providerId,
+        providerName: base.providerName,
+        model: e.model,
+        url: base.url,
+        key: e.key,
+      };
+      const k = sel.providerId + '::' + sel.model + '::' + sel.key;
+      if (k === exKey) continue; // aktif seçimle birebir aynıysa anlamsız
+      out.push(sel);
+    }
+    return out;
+  }
+
+  /* Çökme durumunu diske yaz — hata yakala → durumu kaydet adımı */
+  _saveCrash(sessionId, err, phase) {
+    if (!this.crashFile) return;
+    try {
+      fs.writeFileSync(
+        this.crashFile,
+        JSON.stringify(
+          {
+            sessionId,
+            at: nowIso(),
+            phase: phase || 'chat',
+            error: String((err && err.message) || err).slice(0, 500),
+            model: this.sel ? this.sel.providerId + '::' + this.sel.model : null,
+          },
+          null,
+          2
+        )
+      );
+    } catch {}
+  }
+
+  _clearCrash() {
+    if (!this.crashFile) return;
+    try { fs.unlinkSync(this.crashFile); } catch {}
+  }
+
+  /* Bir tur için denenecek seçim listesi: [aktif, ...fallout zinciri] */
+  _chatCandidates(sel, wasVision) {
+    const list = [];
+    const seen = new Set();
+    const push = (s) => {
+      if (!s || !s.url) return;
+      const k = s.providerId + '::' + s.model + '::' + s.key;
+      if (!seen.has(k)) { seen.add(k); list.push(s); }
+    };
+    push(sel);
+    if (wasVision) push(this.sel || this.modelFor(null)); // resimsiz modele geri düş
+    for (const f of this._falloutSelections(sel)) push(f);
+    return list;
+  }
+
+  /* Adayları sırayla dene. Hata olursa durumu kaydet, zincirdeki sonrakine geç. */
+  async _streamWithFallbacks(session, payload, activeTools, signal, onDelta, sel, wasVision) {
+    const cands = this._chatCandidates(sel, wasVision);
+    let lastErr = null;
+    for (let i = 0; i < cands.length; i++) {
+      const c = cands[i];
+      try {
+        /* provider bazlı girdi limiti: payload aşıyorsa sıkıştırılıp öyle gönderilir */
+        let msgs = payload;
+        const lim = this._inputLimitFor(c);
+        if (lim > 0) {
+          const est = Math.ceil(payload.reduce((a, m) => a + estMsgTokens(m), 0) * this.tokRatio);
+          if (est > lim) {
+            const before = msgs.length;
+            msgs = this._compressPayload(payload, lim, this.limits.compress);
+            if (i === 0) {
+              emitSafe(this, session.id, {
+                type: 'status',
+                status: `bağlam sıkıştırıldı: ~${est} token → limit ${lim} (${c.providerName}, ${before}→${msgs.length} mesaj)`,
+              });
+            }
+          }
+        }
+        const res = await chatStream(
+          c,
+          { messages: msgs, tools: activeTools, reasoningEffort: this._thinkEffort() },
+          {
+            signal,
+            onDelta,
+            onRetry: (attempt) =>
+              emitSafe(this, session.id, {
+                type: 'status',
+                status: `sağlayıcı yanıtsız — tekrar deniyor (${attempt}/${3})`,
+              }),
+          }
+        );
+        if (i > 0) {
+          emitSafe(this, session.id, {
+            type: 'status',
+            status: `\u2622 FALLOUT devrede: ${c.providerName} · ${c.model} (#${i + 1})`,
+          });
+        }
+        /* maliyet sayacı için hangi adayın cevapladığı taşınır */
+        res.meta = {
+          providerId: c.providerId,
+          providerName: c.providerName,
+          model: c.model,
+          costIn: Number(c.costIn) || null,
+          costOut: Number(c.costOut) || null,
+        };
+        return res;
+      } catch (e) {
+        if (e && (e.name === 'AbortError' || (signal && signal.aborted))) throw e;
+        lastErr = e;
+        const msgStr = String((e && e.message) || '');
+        const imgIssue =
+          wasVision &&
+          ([400, 404, 422].includes(e.status) ||
+            /\bno endpoints\b/i.test(msgStr) ||
+            /\bimage input\b/i.test(msgStr));
+        const next = cands[i + 1];
+        if (!next) break; // zincir bitti — hatayı yukarı fırlat
+        if (imgIssue) {
+          emitSafe(this, session.id, {
+            type: 'status',
+            status: `vision rolünde uyuldu (${c.providerName} · ${c.model}) — resimsiz modeller devre dışı, sıradakiyle devam`,
+          });
+          continue;
+        }
+        if (!this.fallout.enabled) break;
+        // FALLOUT: hata yakalandı → durumu kaydet → sıradaki adaya geç
+        this._saveCrash(session.id, e, 'provider');
+        emitSafe(this, session.id, {
+          type: 'status',
+          status: `\u2622 FALLOUT: ${c.providerName} · ${c.model} çöktü (${e.status || 'ağ'}) → ${next.providerName} · ${next.model} geçiliyor`,
+        });
+      }
+    }
+    throw lastErr;
+  }
+
+  /* ---------- model selection ---------- */
+
+  _resolve(input) {
+    if (!input) return null;
+    const chain = this.cfg.chain || [];
+    if (typeof input === 'string') {
+      const [p, m] = input.split('::');
+      return chain.find((c) => c.providerId === p && c.model === m) || null;
+    }
+    if (input.providerId && input.model) {
+      return chain.find((c) => c.providerId === input.providerId && c.model === input.model) || null;
+    }
+    return null;
+  }
+
+  _resolveRole(input) {
+    if (!input) return null;
+    const chain = this.cfg.chain || [];
+    if (typeof input === 'string') {
+      const [p, m] = input.split('::');
+      return chain.find((c) => c.providerId === p && c.model === m) || null;
+    }
+    if (input.providerId && input.model) {
+      return chain.find((c) => c.providerId === input.providerId && c.model === input.model) || null;
+    }
+    return null;
+  }
+
+  _lastUserHasImage(session) {
+    const m = session.messages[session.messages.length - 1];
+    if (!m || m.role !== 'user') return false;
+    if (!Array.isArray(m.content)) return false;
+    return m.content.some((p) => p && p.type === 'image_url');
+  }
+
+  modelFor(role) {
+    const map = this.roleModels || {};
+    const sel = map[role];
+    if (!sel) return this.sel;
+    return this._resolveRole(sel) || this.sel;
+  }
+
+  setModelOverride(sel) {
+    this.sel = this._resolve(sel) || this.cfg.defaultSelection || null;
+  }
+
+  /* Model refresh: config.yaml'dan gelen taban zinciri tazeler; aktif seçim
+     hâlâ mevcutsa korunur, değilse varsayılana döner. */
+  refreshBaseChain(cfg) {
+    const c = cfg || {};
+    this.cfg.baseChain = (c.chain || []).slice();
+    if (c.defaultSelection) this.cfg.defaultSelection = c.defaultSelection;
+    this._rebuildChain();
+    const cur = this.sel ? this.sel.providerId + '::' + this.sel.model : null;
+    this.sel = (cur && this._resolve(cur)) || this.cfg.defaultSelection || this.sel || null;
+  }
+
+  setWorkspace(dir) {
+    this.workspace = dir;
+  }
+
+  setThinkLevel(v) {
+    this.thinkLevel = Math.min(5, Math.max(0, Math.round(Number(v) || 0)));
+    return this.thinkLevel;
+  }
+
+  _thinkEffort() {
+    const lv = THINK_LEVELS[this.thinkLevel] || THINK_LEVELS[0];
+    return lv.effort || null;
+  }
+
+  _thinkLabel() {
+    const lv = THINK_LEVELS[this.thinkLevel] || THINK_LEVELS[0];
+    return lv.label;
+  }
+
+  publicState() {
+    return {
+      workspace: this.workspace,
+      workspaceName: path.basename(this.workspace) || this.workspace,
+      hasModel: !!this.sel,
+      activeModel: this.sel
+        ? { sel: this.sel.providerId + '::' + this.sel.model, providerName: this.sel.providerName, model: this.sel.model }
+        : null,
+      models: (this.cfg.chain || []).map((c) => ({
+        sel: c.providerId + '::' + c.model,
+        providerName: c.providerName,
+        model: c.model,
+      })),
+      roleModels: this.roleModels || {},
+      deletedModels: [...this.deletedModels],
+      busy: [...this.ctrls.keys()],
+      thinkLevel: this.thinkLevel,
+    };
+  }
+
+  /* #23 Fallout: providerId -> çözülmüş API key (chain zaten .env/custom'dan
+     anahtarları çözmüş durumda — tek doğruluk kaynağı budur) */
+  providerKeyMap() {
+    const map = {};
+    for (const c of this.cfg.chain || []) {
+      if (c && c.providerId && c.key && !map[c.providerId]) map[c.providerId] = c.key;
+    }
+    return map;
+  }
+
+  /* ---------- sessions ---------- */
+
+  _file(id) {
+    if (!/^[A-Za-z0-9]+$/.test(id)) throw new Error('bad session id');
+    return path.join(this.sessionsDir, id + '.jsonl');
+  }
+
+  _append(session, msg) {
+    fs.appendFileSync(this._file(session.id), JSON.stringify({ t: 'msg', ...msg }) + '\n');
+    session.updatedAt = nowIso();
+    if (session.code) this._codeIndex.set(session.code, session.id);
+  }
+
+  _load(id) {
+    if (this.cache.has(id)) return this.cache.get(id);
+    const file = this._file(id);
+    const session = { id, messages: [], createdAt: nowIso(), updatedAt: nowIso() };
+    try {
+      const lines = fs.readFileSync(file, 'utf8').split('\n');
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const rec = JSON.parse(line);
+          if (rec.t === 'meta') {
+            session.createdAt = rec.createdAt || session.createdAt;
+            session.code = rec.code || session.code;
+          } else if (rec.t === 'meta2') {
+            /* #17 paralel ajan oturumu: temiz başlık + işaret */
+            session.bgTitle = String(rec.title || '');
+            session.bgOf = String(rec.bgOf || '');
+          } else if (rec.t === 'todo') {
+            session.todos = sanitizeTodoItems(rec.items);
+          } else if (rec.t === 'notes') {
+            session.notes = String(rec.text || '');
+            session.notesAt = Number(rec.at) || 0;
+          } else if (rec.t === 'msg') {
+            delete rec.t;
+            session.messages.push(rec);
+          }
+        } catch {}
+      }
+    } catch {}
+    if (!session.code) session.code = sessionCode();
+    this._codeIndex.set(session.code, id);
+    if (session.todos && session.todos.length) this.todos.set(id, session.todos);
+    this.cache.set(id, session);
+    return session;
+  }
+
+  /* Kısa okunabilir oturum kodu → benzersiz çakışmasız üretim */
+  _newCode() {
+    for (;;) {
+      const c = sessionCode();
+      if (!this._codeIndex.has(c)) return c;
+    }
+  }
+
+  findByCode(code) {
+    const k = String(code || '').trim().toUpperCase();
+    if (!k) return null;
+    let id = this._codeIndex.get(k) || null;
+    if (id && this.cache.has(id)) return this._view(this.cache.get(id));
+    /* hızlı yol bulamadıysa dosyaları tara */
+    for (const v of this.listSessions()) {
+      if (v.code === k) return v;
+    }
+    return null;
+  }
+
+  _appendNotes(session) {
+    fs.appendFileSync(
+      this._file(session.id),
+      JSON.stringify({ t: 'notes', text: session.notes || '', at: session.notesAt || 0 }) + '\n'
+    );
+  }
+
+  /* Oturum dosyası birikince sıkıştırır: meta + son mesajlar + en güncel
+     not + todos kalır, eski satırlar düşer. Atomik yazım. */
+  _maybeCompact(id) {
+    try {
+      const file = this._file(String(id));
+      const st = fs.statSync(file);
+      if (st.size < 512 * 1024) return; // 512 KB altında dokunma
+      const s = this._load(String(id));
+      const lines = fs.readFileSync(file, 'utf8').split('\n').filter((l) => l.trim());
+      const keepFrom = Math.max(0, s.messages.length - NOTES_KEEP_RECENT * 3);
+      const lastNotesLine =
+        [...lines].reverse().find((l) => {
+          try { return JSON.parse(l).t === 'notes'; } catch { return false; }
+        }) || '';
+      const out = [];
+      for (const l of lines) {
+        let r;
+        try { r = JSON.parse(l); } catch { continue; }
+        if (r.t === 'meta') out.push(JSON.stringify({ t: 'meta', id: s.id, code: s.code, createdAt: s.createdAt }));
+        else if (r.t === 'todo') out.push(l);
+      }
+      if (lastNotesLine) out.push(lastNotesLine);
+      /* korunan pencere: son N mesaj */
+      const msgLines = lines.filter((l) => {
+        try { return JSON.parse(l).t === 'msg'; } catch { return false; }
+      });
+      out.push(...msgLines.slice(keepFrom));
+      out.push(JSON.stringify({ t: 'compacted', at: nowIso(), droppedBefore: keepFrom }));
+      const tmp = file + '.tmp';
+      fs.writeFileSync(tmp, out.join('\n') + '\n');
+      fs.renameSync(tmp, file);
+    } catch {}
+  }
+
+  /* Not tutan oturumları listele (ayarlar ekranı için) — oturum koduyla eşli */
+  listNotes() {
+    const out = [];
+    for (const v of this.listSessions()) {
+      const s = this._load(v.id);
+      if (s && s.notes && String(s.notes).trim()) {
+        out.push({ id: s.id, code: s.code || '', title: v.title, updatedAt: v.updatedAt, count: v.count, notes: String(s.notes) });
+      }
+    }
+    return out;
+  }
+
+  /* Bir oturumun notlarını sil — dosyadaki notes satırları temizlenir */
+  clearNotes(id) {
+    const sid = String(id || '');
+    let s;
+    try { s = this._load(sid); } catch { return false; }
+    if (!s || !s.notes) return false;
+    delete s.notes;
+    delete s.notesAt;
+    try {
+      const file = this._file(sid);
+      const lines = fs.readFileSync(file, 'utf8').split('\n').filter((l) => l.trim());
+      const kept = lines.filter((l) => {
+        try { return JSON.parse(l).t !== 'notes'; } catch { return true; }
+      });
+      fs.writeFileSync(file, kept.join('\n') + '\n');
+    } catch {}
+    return true;
+  }
+
+  _view(s) {
+    const firstUser = s.messages.find((m) => m.role === 'user');
+    const isBg = !!s.bgTitle;
+    const job = isBg ? this._bgJobs.get(String(s.id)) : null;
+    return {
+      id: s.id,
+      code: s.code || '',
+      title: (isBg ? s.bgTitle : (firstUser ? String(firstUser.content).slice(0, 48) : '')) || 'Yeni Sohbet',
+      createdAt: s.createdAt,
+      updatedAt: s.updatedAt,
+      count: s.messages.length,
+      isBg,
+      bgStatus: isBg ? (job ? job.status : null) : null,
+    };
+  }
+
+  /* #17 paralel ajan oturumları sol sohbet listesine KARIŞMAZ;
+     geçmişleri sağdaki Paralel Ajanlar panelinde izlenir */
+  listSessions() {
+    let files = [];
+    try {
+      files = fs.readdirSync(this.sessionsDir).filter((f) => f.endsWith('.jsonl'));
+    } catch {}
+    const out = [];
+    for (const f of files) {
+      const id = f.replace(/\.jsonl$/, '');
+      const v = this._view(this._load(id));
+      if (v.isBg) continue;
+      out.push(v);
+    }
+    out.sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)));
+    return out.slice(0, 100);
+  }
+
+  createSession() {
+    const id = uid();
+    const code = this._newCode();
+    const session = { id, code, messages: [], createdAt: nowIso(), updatedAt: nowIso() };
+    fs.writeFileSync(
+      this._file(id),
+      JSON.stringify({ t: 'meta', id, code, createdAt: session.createdAt }) + '\n'
+    );
+    this._codeIndex.set(code, id);
+    this.cache.set(id, session);
+    return this._view(session);
+  }
+
+  /* #25 /clear: oturumun mesaj geçmişini temizler; kod/meta/todolar korunur.
+     Notlar da sıfırlanır — taze başlangıç. */
+  clearMessages(id) {
+    const sid = String(id || '');
+    let s;
+    try { s = this._load(sid); } catch { return false; }
+    if (!s) return false;
+    try {
+      const file = this._file(sid);
+      const lines = fs.readFileSync(file, 'utf8').split('\n').filter((l) => l.trim());
+      const kept = lines.filter((l) => {
+        try {
+          const r = JSON.parse(l);
+          return r.t === 'meta' || r.t === 'meta2' || r.t === 'todo';
+        } catch { return false; }
+      });
+      const tmp = file + '.tmp';
+      fs.writeFileSync(tmp, kept.join('\n') + '\n');
+      fs.renameSync(tmp, file);
+    } catch {}
+    s.messages = [];
+    delete s.notes;
+    delete s.notesAt;
+    this.todos.set(sid, []);
+    this.emit({ type: 'sessions' });
+    return true;
+  }
+
+  /* "Nerede kaldım?" (#5): en son aktif oturumun özeti + yarım kalan todolar.
+     Saf toplama — gönderim/otomatik-devam main'e aittir. */  lastWhereWasI() {
+    let latest = null;
+    for (const v of this.listSessions()) {
+      if (!latest || String(v.updatedAt) > String(latest.updatedAt)) latest = v;
+    }
+    if (!latest) return null;
+    const s = this._load(latest.id);
+    const todos = s.todos || this.todos.get(s.id) || [];
+    /* son kullanıcı mesajı + son asistan cevabı */
+    let lastUser = '';
+    let lastAssistant = '';
+    for (let i = s.messages.length - 1; i >= 0; i--) {
+      const m = s.messages[i];
+      if (!lastUser && m.role === 'user') {
+        lastUser = typeof m.content === 'string' ? m.content : '(görsel/ek)';
+      }
+      if (!lastAssistant && m.role === 'assistant' && m.content && !m.tool_calls) {
+        lastAssistant = typeof m.content === 'string' ? m.content : '';
+      }
+      if (lastUser && lastAssistant) break;
+    }
+    const when = s.updatedAt ? new Date(s.updatedAt).toLocaleString('tr-TR', { day: '2-digit', month: '2-digit', hour: '2-digit', minute: '2-digit' }) : '?';
+    return {
+      sessionId: s.id,
+      code: s.code || '',
+      title: latest.title,
+      updatedAt: when,
+      msgCount: s.messages.length,
+      lastUser: String(lastUser).slice(0, 160),
+      lastAssistant: String(lastAssistant).replace(/\s+/g, ' ').slice(0, 200),
+      pendingTodos: todos.filter((t) => t.status !== 'done').slice(0, 8),
+      doneCount: todos.filter((t) => t.status === 'done').length,
+    };
+  }
+
+  openSession(id) {
+    const s = this._load(String(id));
+    return { ...this._view(s), messages: s.messages, todos: s.todos || this.todos.get(s.id) || [] };
+  }
+
+  deleteSession(id) {
+    try {
+      const c = this.ctrls.get(id);
+      if (c) {
+        c.abort();
+        this.ctrls.delete(id);
+      }
+      /* #17 silinecek ajanın bekleyen öz-kurtarma zamanlayıcısını iptal et —
+         yoksa send() oturum dosyasını yeniden yaratıp işi diriltir */
+      if (this._bgJobs.has(String(id))) {
+        const j = this._bgJobs.get(String(id));
+        j.revive = false;
+        j.status = 'aborted';
+        this._clearKicks(id);
+      }
+      fs.unlinkSync(this._file(String(id)));
+    } catch {}
+    try { fs.rmSync(this._file(String(id)) + '.tmp', { force: true }); } catch {}
+    const cached = this.cache.get(String(id));
+    if (cached && cached.code) this._codeIndex.delete(cached.code);
+    this.cache.delete(String(id));
+    this.todos.delete(String(id));
+    this.sessionPerm.delete(String(id));
+    this._errCount && this._errCount.delete(String(id));
+    /* paralel ajan oturumuysa iş kaydını da düşür — hayalet kayıt kalmasın */
+    if (this._bgJobs.has(String(id))) {
+      this._bgJobs.delete(String(id));
+      this._saveBgJobs();
+      this._bgEmit();
+    }
+    this.emit({ type: 'sessions' });
+    return true;
+  }
+
+  /* ---------- prompt assembly (the frugal part) ---------- */
+
+  buildSystem(queryText) {
+    const mem = memory.loadAll();
+    const relevantMemory = memory.relevantFor(String(queryText || ''), {});
+    const rules = memory.listRules();
+    const sk = skills.scan().map((s) => `- ${s.name}: ${s.description} [${s.path}]`);
+    const parts = [mem.soul, FORMAT_RULES];
+    if (mem.user) parts.push('# USER\n' + mem.user);
+    if (rules.length) parts.push('# KURALLAR (kullanıcının kalıcı talimatları — daima uy)\n' + rules.map((r) => '- ' + r).join('\n'));
+    if (relevantMemory) parts.push('# İLGİLİ HAFIZA\n' + relevantMemory);
+    /* #v13.2 tanışma modu: hafıza tamamen boşsa ajan sahibini tanımaya çalışır;
+       ilk bilgiler geldikçe soru sormayı bırakır (yazmaya devam eder) */
+    const sparse = !mem.soul.includes('SAHİBİ') && memory.entries().length < 1 && !mem.user;
+    if (sparse) {
+      parts.push(
+        '# TANIŞMA MODU (hafıza henüz boş)\n' +
+          'Bu kullanıcıyı henüz tanımıyorsun. Sohbette doğal bir anda KISA sorarak ' +
+          'adını/hitap şeklini öğren ve öğrendiğin an HEMEN memory_write ile kaydet. ' +
+          'İlk kayıt düştükten sonra soru sormayı bırak; sonraki bilgiler sohbet akışında kendiliğinden not edilir.'
+      );
+    }
+    if (sk.length) {
+      parts.push(
+        '# SKILLS\nKullanmadan önce ilgili SKILL.md dosyasını read_file ile oku.\n' + sk.join('\n')
+      );
+    }
+    const nowD = new Date();
+    const localDate = nowD.toLocaleDateString('tr-TR');
+    const localTime = nowD.toLocaleTimeString('tr-TR', { hour: '2-digit', minute: '2-digit' });
+    let tz = '';
+    try {
+      tz = Intl.DateTimeFormat().resolvedOptions().timeZone || '';
+    } catch {}
+    parts.push(
+      `# ORTAM\nWindows + PowerShell. Çalışma klasörü: ${this.workspace}\n` +
+        `Yerel tarih: ${localDate} (${['Pazar','Pazartesi','Salı','Çarşamba','Perşembe','Cuma','Cumartesi'][nowD.getDay()]})\n` +
+        `Yerel saat: ${localTime}${tz ? ` (saat dilimi: ${tz})` : ''}\n` +
+        'Tarih/saat gerektiren her işte bu YEREL zamanı esas al; UTC varsayma, kendin dönüşüm yapma. Bu satırlar her mesajda güncellenir.\n' +
+        'Kısa ve net cevap ver. Konuşmaya özgü geçici detayları hafızaya yazma — oturum kayıtları zaten saklar. Sadece kalıcı/genel bilgileri memory_write ile kaydet.'
+    );
+    parts.push(
+      '# ARAÇ KURALLARI\n' +
+        [
+          'Basit soruları araç kullanmadan doğrudan cevapla — hız önceliklidir.',
+          'Kullanıcı bir tarihte/saatte hatırlatılmasını isterse set_reminder kullan; when değerini ORTAMdaki bugüne göre hesapla (yerel saat). "Her sabah/gün/hafta" gibi tekrarlı isteklerde repeat alanını da ver (daily/weekly/monthly/weekdays veya cron).',
+                    'Kullanıcı kalıcı bir arka plan takibi isterse (fiyat eşiği, pil seviyesi, sayfa değişikliği) watcher_add ile izleyici kur; kurduktan sonra watcher_list ile doğrula ve kullanıcıya koşulu + kontrol sıklığını kısaca bildir.',
+          'Anlık olay takipleri için (yeni mail, fiyat eşiği, dosya değişimi, webhook) event_subscribe kullan — cron/polling gerekmez; listeyi event_list ile göster, vazgeçirirse event_unsubscribe.',
+        'Kullanıcı "artık hep böyle yap / bunu unutma" tarzı kalıcı talimat verirse kural olarak kaydet: sohbette /rule <metin> kullanmasını söyle VEYA kullanıcı isterse event_subscribe ile olaya bağlan (mail/fiyat/dosya/webhook).',
+          'Kullanıcının mesajında 2+ ayrı iş/hedef varsa (örn "X yap ve sonra Y\u2019i kontrol et") KODLAMAYA/İŞE BAŞLAMADAN önce todo_write ile plan çıkar ve sırayla yürüt; her adımı tamamlarken güncelle.',
+          this.ceoMode
+            ? 'Bağımsız alt-işleri run_background ile PARALEL ajana devret; işi KENDİN YÜRÜTME — emri ver, takip et, raporla.'
+            : 'Bağımsız alt-işleri delegate_task ile devret; kendi başına halledebileceğin işleri devretme.',
+          'Güncel/dış bilgi gerekiyorsa web_search kullan (Python çoklu-motor paralel — hızlı, anahtarsız); bir sayfayı okumak için http_fetch kullan.',
+          'ARAMA-DİSİPLİN: bir bilgiyi 2-3 denemede bulamazsan TAKILMA — farklı bir açıya/sorguya geç, yine yoksa bulabildiğin kısmi bilgiyle cevap ver ve neyi bulamadığını açıkça söyle. Kapalı/gizli içerik (private profil, login arkası veri) peşinde KOŞMA — bulunamayacağı belliyse hemen vazgeç.',
+          'Beast\u2019in DAHİLİ TARAYICISI VARDIR: ekranın sağındaki panelde açılır ve kullanıcı da görebilir. Etkileşimli/görüntülü siteler için onu kullan: browser_open ile aç, önce browser_snapshot al; ref numaralarıyla browser_click/browser_type/browser_select ile hareket et, browser_read ile metin oku. Sadece görsel yerleşim/grafik gerekiyorsa browser_screenshot çek.' +
+            ' Görselleri GÖREMEMİYORSAN (metin-model) görüntüdeki metni okumak için ocr_read kullan: source:"browser" ile tarayıcı sayfasını, "screen" ile masaüstünü OCR\u2019la okursun (captcha/canvas/görsel metin dahil).' +
+            (this.ceoMode ? ' (CEO: bu araçları KENDİN ÇAĞIRMA — içinde tarayıcı geçen işi run_background ile paralel ajana devret.)' : ''),
+          'Tarayıcı eylemlerinin yanıtındaki recent günlüğü ve navigated bilgisini takip et; sayfa değişmişse yeni snapshot al.',
+          'CONUŞMA ODAĞI SENDE KALSIN: kullanıcı seninle konuşurken iş çıkmışsa — uzun da olsa UFACIK da (tek komutluk dizin listesi, tek dosya okuma, tek arama…) — run_background ile PARALEL ajana devret; ana sohbet hiçbir işi beklemez; bittiğinde özet otomatik düşer.',
+          'Python işleri için python_run kullan: küçük betikler inline code ile; tekrarlayan işler %APPDATA%\\beast\\scripts klasöründeki dosyalarla (ör. news.py = RSS haber toplayıcı: args ["--limit","8","--json"]). Python kurulu olmasa bile ilk çağrıda taşınabilir gömülü runtime otomatik iner.',
+          'PYTHON DURUMU: makinede sistem Python\'u görünmese bile ŞAŞIRMA ve "python yok" DEME — python_run aracı kendi taşınabilir runtime\'ını (%APPDATA%\\beast\\py\\python.exe) otomatik indirir/kullanır ve bu klasör run_command PATH\'inde önceliklidir; yani run_command içinde de `python` çalışır. Ham Google/Bing scrape yerine önce web_search aracını kullan (zaten Python çoklu-motor + Exa destekli), script gerektiğinde python_run yaz.',
+          'Eski bir hafıza kaydına ihtiyacın olursa memory_search ile ara; kalıcı bilgi/birikim için kb_search kullan, yeni bilgi öğrenirsen kb_add ile kaynak belirt.',
+          'Bir oturumda 3+ kez memory_write yaptıysan iş bitince memory_hygiene çağır (duplike/eskime temizliği).',
+        ].join('\n')
+    );
+    if (this.ceoMode) {
+      parts.push(
+        '# CEO MODU (yönetici rolü)\n' +
+          [
+            'Sen yürütücü DEĞİL yöneticisin (CEO): sohbet etmek, anlamak, planlamak, karar vermek ve EMİR VERMEK senin işin; uygulamak değil.',
+            'Konuşma harici HER somut işi KENDİN YAPMA — UFUĞU YOK: komut çalıştırma, dosya okuma/yazma, web araştırması, tarayıcıda gezinme, ekran kontrolü, analiz. "Masaüstünde hangi dosyalar var?" gibi tek adımlık minik görevler bile run_background ile PARALEL ajana devredilir; sen asla çalıştırmazsın.',
+            'Devrettikten sonra o konuda elinden geleni yapmışsın gibi DAVRANMA; sonuç gelene kadar beklemedigini bil ve kullanıcıyı yanlış bilgilendirme. Ara durumlarda task_status ile bak.',
+            'SUPERYORIZON GÖREVİN: devrettiğin her işi SAHİPLEN — ajanı kendi başına BIRAKMA. tasks_list/task_status ile düzenli kontrol et; bitti raporu geldiğinde sonucu DOĞRULA (görevle eşleşiyor mu? eksik var mı?), eksik/yanlışsa tamamlama veya düzeltme görevi için yeni run_background aç.',
+            'Sistem sana [SUPERYORIZON] uyarısı düşürürse (takılma / uzun süre) bu bir emirdir: hemen task_status ile dökümü oku, gerekirse task_cancel + düzeltilmiş yeni run_background, ve kullanıcıya tek cümleyle durumu bildir. Uyarıyı asla cevapsız bırak.',
+            'Görev tanımı kendi başına YETERLİ olsun: tüm bağlam, dosya/URL yolları, kısıtlar ve beklenen çıktı görev metnine yazılır — paralel ajan senin bağlamını göremez.',
+            'Birden fazla bağımsız iş varsa hepsini aynı anda ayrı run_background çağrılarıyla devret (paralel çalışsınlar).',
+            'HIZ FAN-OUT: aynı işin farklı adımlarını run_background_many ile TEK SEFERDE paralel aç (örnek: haber taraması → TR / Dünya / Ekonomi ayrı ajan; araştırma+veri çekme+analiz ayrı ajan). Hepsi bitince sana TEK birleşik rapor düşer — hız dramatik artar. Bağımsız 2+ adım görürsen bunu tercih et.',
+            'Takip araçları: tasks_list (genel tablo), task_status (tek ajanın canlı dökümü), task_cancel (iptal). Kullanıcı ilerleme sorarsa buradan raporla.',
+            'Bilgi sorularını, sohbeti, planlamayı, hafıza/hatırlatıcı/izleyici kurulumunu YİNE SEN yaparsın — bunlar "iş" değildir.',
+          ].join('\n')
+      );
+    }
+    return parts.filter(Boolean).join('\n\n');
+  }
+
+  _payloadTokens(payload) {
+    let t = 0;
+    for (const m of payload) t += estMsgTokens(m);
+    return Math.ceil(t * this.tokRatio);
+  }
+
+  _contentLen(m) {
+    if (typeof m.content === 'string') return m.content.length;
+    if (Array.isArray(m.content)) {
+      return m.content.reduce(
+        (a, p) => a + (p.type === 'text' ? String(p.text || '').length : (String(p.image_url && p.image_url.url || '').length * 0.25)),
+        0
+      );
+    }
+    return 0;
+  }
+
+  _buildPayload(system, messages, notes) {
+    const units = [];
+    let i = 0;
+    while (i < messages.length) {
+      const m = messages[i];
+      if (m.role === 'assistant' && m.tool_calls && m.tool_calls.length) {
+        const grp = [m];
+        i++;
+        while (i < messages.length && messages[i].role === 'tool') grp.push(messages[i++]);
+        units.push(grp);
+      } else {
+        units.push([m]);
+        i++;
+      }
+    }
+    const budget = this.historyTokenBudget;
+    const maxUnits = notes ? NOTES_MAX_UNITS : units.length; // notlar varken pencereyi sıkılaştır
+    const picked = [];
+    let used = 0;
+    for (let u = units.length - 1; u >= 0; u--) {
+      if (picked.length >= maxUnits) break;
+      const cost = units[u].reduce(
+        (a, m) =>
+          a +
+          clamp(Math.ceil(estMsgTokens(m) * this.tokRatio), 1, this.historyTokenBudget),
+        0
+      );
+      if (picked.length && used + cost > budget) break;
+      picked.unshift(units[u]);
+      used += cost;
+    }
+    // Eski kullanıcı mesajlarındaki görselleri metne indir (token tasarrufu)
+    const flat = picked.flat().map((m, idx, arr) => {
+      if (
+        m.role === 'user' &&
+        Array.isArray(m.content) &&
+        idx < arr.length - 2
+      ) {
+        const txt = m.content.filter((p) => p.type === 'text').map((p) => p.text).join('\n');
+        return { ...m, content: txt + '\n[resimler bağlam dışı bırakıldı]' };
+      }
+      return m;
+    });
+    for (let k = 0; k < flat.length; k++) {
+      const m = flat[k];
+      if (m.role === 'tool' && String(m.content || '').length > TOOL_OUT_KEEP * 2) {
+        flat[k] = { ...m, content: String(m.content).slice(0, TOOL_OUT_KEEP) + '\n…[kırpıldı]' };
+      }
+    }
+    return [{ role: 'system', content: system }, ...flat];
+  }
+
+  _lastUserText(session) {
+    for (let i = session.messages.length - 1; i >= 0; i--) {
+      const m = session.messages[i];
+      if (m.role !== 'user') continue;
+      if (typeof m.content === 'string') return m.content;
+      return m.content.map((p) => (p.type === 'text' ? p.text : '')).join('\n');
+    }
+    return '';
+  }
+
+  /* ---------- oturum notları ---------- */
+
+  _plainText(m) {
+    if (typeof m.content === 'string') return m.content;
+    if (Array.isArray(m.content)) {
+      return m.content.filter((p) => p.type === 'text').map((p) => p.text || '').join(' ');
+    }
+    return '';
+  }
+
+  _renderTranscript(msgs) {
+    const lines = [];
+    for (const m of msgs) {
+      if (m.role === 'user') lines.push('[Kullanıcı] ' + this._plainText(m).slice(0, 1500));
+      else if (m.role === 'assistant' && String(m.content || '').trim()) lines.push('[Asistan] ' + this._plainText(m).slice(0, 1200));
+      else if (m.role === 'assistant' && m.tool_calls && m.tool_calls.length) {
+        lines.push('[Araç çağrısı] ' + m.tool_calls.map((t) => t.function && t.function.name).filter(Boolean).join(', '));
+      } else if (m.role === 'tool') lines.push('[Araç sonucu] ' + String(m.content || '').slice(0, 400));
+    }
+    return lines.filter(Boolean).join('\n');
+  }
+
+  /* Not üretimi sonrası: notlara dönüştürülen [0..cut) aralığı diskten düşer;
+     meta+notes+todos+son NOTES_KEEP_RECENT*2 mesaj kalır. notesAt=0 sıfırlanır.
+     Atomik — başarısız olursa mevcut dosya sağlam kalır. */
+  _compactToNotes(session, cut) {
+    try {
+      const file = this._file(session.id);
+      /* korunan pencere cut'tan sonra başlar — özetlenen bölgeyle ÇAKIŞMAZ */
+      const keepFrom = cut;
+      const out = [];
+      out.push(JSON.stringify({ t: 'meta', id: session.id, code: session.code, createdAt: session.createdAt }));
+      for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+        if (!line.trim()) continue;
+        let r;
+        try { r = JSON.parse(line); } catch { continue; }
+        if (r.t === 'todo') out.push(line); // en güncel todo satırı kalır (append-only, sonuncusu kazanır)
+      }
+      out.push(JSON.stringify({ t: 'notes', text: session.notes || '', at: 0 }));
+      /* korunan pencere */
+      let seen = 0;
+      const msgLines = [];
+      for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+        if (!line.trim()) continue;
+        let r;
+        try { r = JSON.parse(line); } catch { continue; }
+        if (r.t !== 'msg') continue;
+        if (seen++ >= keepFrom) msgLines.push(line);
+      }
+      out.push(...msgLines);
+      out.push(JSON.stringify({ t: 'compacted', at: nowIso(), droppedBefore: keepFrom, noteBased: true }));
+      const tmp = file + '.tmp';
+      fs.writeFileSync(tmp, out.join('\n') + '\n');
+      fs.renameSync(tmp, file);
+    } catch {}
+  }
+
+  /* Cevap verildikten sonra çağrılır: son not update'ten bu yana NOTES_EVERY
+     (14) mesaj biriktiginde özet çıkarıp oturum notlarını günceller.
+     Notlar oturum dosyasına (code ile eşli) yazılır ve _chatTurn'da aynı
+     oturuma enjekte edilir. */
+  async _updateSessionNotes(session, signal) {
+    try {
+      if (!this.sel) return { ok: false, reason: 'model yok' };
+      const msgs = session.messages;
+      const mark = clamp(Number(session.notesAt) || 0, 0, msgs.length);
+      /* #24 KESİN tetik: son nottan bu yana >= NOTES_EVERY mesaj biriktiyse */
+      const pending = msgs.length - mark;
+      if (pending < NOTES_TRIGGER) return { ok: false, reason: `bekleme: ${pending}/${NOTES_TRIGGER}` };
+      const cut = Math.max(mark, msgs.length - NOTES_KEEP_RECENT);
+      if (cut <= mark) return { ok: false, reason: 'aralık boş' };
+      const transcript = this._renderTranscript(slice);
+      if (!transcript.trim()) {
+        session.notesAt = cut;
+        return { ok: false, reason: 'özetlenecek metin yok' };
+      }
+      const prev = session.notes ? `Önceki notlar (koru ve birleştir):\n${session.notes}\n\n` : '';
+      const prompt =
+        `OTURUM KODU: ${session.code || '?'} — üretilen not bu oturuma aittir.\n` +
+        `${prev}Aşağıdaki sohbet parçasının ÖNEMLİ noktalarını çıkar. Şunları yakala:\n` +
+        `- kullanıcının hedefleri ve net talepleri\n` +
+        `- alınan kararlar, önemli bilgi parçaları (isim, sayı, dosya/klasör yolu, hata ve çözümü)\n` +
+        `- tamamlanan işler ve sonuçları\n` +
+        `Madde madde yaz, en fazla 120 kelime, başlık/selamlama yok. Alakasız ayrıntıyı at.\n\n` +
+        `# SOHBET PARÇASI\n${transcript}`;
+      const res = await chatOnce(
+        this.sel,
+        { messages: [{ role: 'user', content: prompt }], temperature: 0.2 },
+        { signal }
+      );
+      const txt = String(res.content || '').trim();
+      if (!txt) return { ok: false, reason: 'model boş döndü' };
+      session.notes = txt.slice(0, 4000);
+      session.notesAt = cut;
+      try { this._appendNotes(session); } catch {}
+      /* #6 bağlam sıkıştırma: öze dönüşen eski mesajlar bellekten VE diskten
+         düşer (compacted işaretiyle); notlar + son pencere her zaman kalır.
+         Böylece notesAt=0'dan yeniden başlar, uzun sohbette şişme olmaz. */
+      this._compactToNotes(session, cut);
+      /* bellek kopyasını da eşele: özetlenen bölge [0..cut) atılır */
+      session.messages = session.messages.slice(cut);
+      session.notesAt = 0;
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, reason: String((e && e.message) || e).slice(0, 120) }; // not üretimi asla sohbeti bozmasın
+    }
+  }
+
+  /* ---------- agent loop ---------- */
+
+  send(sessionId, payload) {
+    const s = this._load(String(sessionId));
+    if (!s || this.ctrls.has(s.id)) return false;
+
+    let msg;
+    if (typeof payload === 'string') {
+      msg = { role: 'user', content: payload.slice(0, USER_MAX) };
+    } else {
+      const text = String((payload && payload.text) || '').slice(0, USER_MAX);
+      const atts = Array.isArray(payload && payload.attachments) ? payload.attachments : [];
+      const imgs = atts.filter((a) => a.type === 'image' && a.dataUrl).slice(0, 4);
+      const files = atts.filter((a) => a.type === 'file');
+      let extra = '';
+      for (const f of files) {
+        extra += `\n\n[Ek dosya: ${f.name}]\n${String(f.content || '').slice(0, 20000)}`;
+      }
+      if (imgs.length) {
+        const parts = [{ type: 'text', text: (text + extra).trim() }];
+        for (const im of imgs) parts.push({ type: 'image_url', image_url: { url: im.dataUrl } });
+        msg = { role: 'user', content: parts };
+      } else {
+        msg = { role: 'user', content: ((text + extra).trim() || '(ek)').slice(0, USER_MAX + extra.length) };
+      }
+    }
+
+    if (!String(typeof msg.content === 'string' ? msg.content : msg.content[0].text || '').trim()) return false;
+    /* #12 kişilik kalibrasyonu: kullanıcı cümlelerini örnek havuzuna düşür */
+    try { memory.addStyleSample(this._plainText(msg)); } catch {}
+    s.messages.push(msg);
+    try {
+      this._append(s, msg);
+    } catch {}
+    this.emit({ type: 'message', sessionId: s.id, message: msg });
+    this.emit({ type: 'sessions' });
+    this._run(s).catch(() => {});
+    return true;
+  }
+
+  /* #14 paralel ajanlar: ANA oturumu hiç bloklamayan arka plan çalıştırıcı.
+     Ayrı gizli oturum açar, işi orada koşturur; bitince özet bildirim
+     istenen sohbete düşer. Birden fazla iş aynı anda paralel koşabilir —
+     her biri _bgJobs kaydına düşer ve UI'da canlı izlenir. */
+  runBackground(parentSessionId, task, title, opts = {}) {
+    const t = String(task || '').trim();
+    if (!t) return { ok: false, error: 'görev boş' };
+    const parent = String(parentSessionId || '');
+    /* createSession() view döndürür (messages yok) — tam oturumu cache'ten al.
+       Aksi halde send() s.messages.push'da sessizce patlardı ve iş koşmazdı. */
+    const bg = this._load(this.createSession().id);
+    bg.messages = bg.messages || [];
+    bg.bgJob = true; // arka plan oturumu: auto-memory/kalibrasyon kapalı
+    this.cache.set(bg.id, bg);
+    const ttl = String(title || t).replace(/\s+/g, ' ').trim().slice(0, 80) || 'arka plan görevi';
+    /* #17 cache'teki nesneye de işaret koy — listSessions temiz başlık göstersin */
+    bg.bgTitle = ttl;
+    bg.bgOf = parent;
+    try {
+      // arka plan oturumunu sakla — listSessions'a karışmasın diye isimlendirme:
+      fs.appendFileSync(
+        this._file(bg.id),
+        JSON.stringify({ t: 'meta2', bgOf: parent, title: ttl, at: new Date().toISOString() }) + '\n'
+      );
+    } catch {}
+    this._bgJobs.set(bg.id, {
+      id: bg.id,
+      code: bg.code,
+      title: ttl,
+      task: t.slice(0, 500),
+      parentId: parent,
+      groupId: opts.groupId || null,
+      status: 'running', // queued | running | done | error | aborted
+      slot: false, // #5 gerçekten bir eşzamanlı LLM slotu işgal ediyor mu (admit'te true)
+      startedAt: nowIso(),
+      lastActivityAt: nowIso(), // superyorizyon: son hareket zamanı
+      lastNudgeAt: null, // son [SUPERYORIZON] uyarısı
+      checks: 0,
+      fixes: 0, // öz-kurtarma denemeleri (BG_FIX_MAX'a kadar; bitince CEO)
+      endedAt: null,
+      error: null,
+    });
+    this._bgMeta = this._bgMeta || new Map();
+    this._bgMeta.set(bg.id, { parentId: parent, title: ttl });
+    this._bgEmit();
+    setTimeout(() => this._bgAdmit(bg.id, t), 60);
+    return { ok: true, backgroundId: bg.id, code: bg.code };
+  }
+
+  /* ---------- #5 eşzamanlılık kuyruğu ----------
+     Slot doluysa iş 'queued' görünür; bir iş bitince FIFO sıradaki başlar. */
+
+  _runningBgCount() {
+    let n = 0;
+    for (const j of this._bgJobs.values()) if (j.status === 'running' && j.slot) n++;
+    return n;
+  }
+
+  _bgAdmit(sid, fullTask) {
+    try {
+      const j = this._bgJobs.get(String(sid));
+      if (!j || j.status !== 'running' || j.slot) return;
+      if (this._runningBgCount() >= this._bgLimit) {
+        j.status = 'queued';
+        this._bgPendingStart.set(String(sid), fullTask || j.task);
+        this._bgEmit();
+        return;
+      }
+      j.slot = true;
+      this.send(sid, {
+        text:
+          `[ARKA PLAN GÖREV] Aşağıdaki işi baştan sona bitir. Ara sonuçları not et; ` +
+          `en sonda SADECE 3-5 satırlık net bir sonuç raporu yaz.\n\n${fullTask}`,
+      });
+    } catch {}
+  }
+
+  _bgResumeQueue() {
+    while (this._runningBgCount() < this._bgLimit) {
+      let next = null;
+      for (const j of this._bgJobs.values()) {
+        if (j.status !== 'queued') continue;
+        if (!next || String(j.startedAt).localeCompare(String(next.startedAt)) < 0) next = j;
+      }
+      if (!next) break;
+      next.status = 'running';
+      next.slot = true;
+      const text = this._bgPendingStart.get(String(next.id)) || next.task;
+      this._bgPendingStart.delete(String(next.id));
+      this._bgEmit();
+      try {
+        this.send(next.id, {
+          text:
+            `[ARKA PLAN GÖREV] Aşağıdaki işi baştan sona bitir. Ara sonuçları not et; ` +
+            `en sonda SADECE 3-5 satırlık net bir sonuç raporu yaz.\n\n${text}`,
+        });
+      } catch {}
+    }
+  }
+
+  /* #18 aynı işin farklı adımları için paralel fan-out.
+     Her adım AYRI ajan koşar; hepsi bitince TEK birleşik rapor düşer —
+     örnek: haber toplama → TR / Dünya / Ekonomi üç ajan paralel. */
+  runBackgroundMany(parentSessionId, tasks, groupTitle) {
+    const list = Array.isArray(tasks) ? tasks : [];
+    if (!list.length) return { ok: false, error: 'tasks boş' };
+    const parent = String(parentSessionId || '');
+    const groupId = uid();
+    this._bgGroups.set(groupId, { parentId: parent, total: list.length, results: [], dead: false });
+    const ids = [];
+    let n = 0;
+    for (const item of list) {
+      const task = String((item && item.task) || item || '').trim();
+      if (!task) continue;
+      const r = this.runBackground(parent, task, (item && item.title) || `${groupTitle || 'grup'} #${++n}`, { groupId });
+      if (r.ok) ids.push(r.backgroundId);
+    }
+    if (!ids.length) {
+      this._bgGroups.delete(groupId);
+      return { ok: false, error: 'geçerli görev yok' };
+    }
+    const g = this._bgGroups.get(groupId);
+    g.total = ids.length;
+    return { ok: true, groupId, ids, total: ids.length };
+  }
+
+  /* #17 kalıcı arka plan hatası → owner'a tek seferlik uyarı maili (fire-and-forget) */
+  _notifyOwnerTaskFailed(job, msg) {
+    if (this.notifyOwnerFail === false) return;
+    if (!this.email || typeof this.email.send !== 'function') return;
+    if (job._mailed) return;
+    job._mailed = true;
+    Promise.resolve(
+      this.email.send({
+        to: OWNER_FAIL_EMAIL,
+        subject: `[Beast] Paralel ajan başarısız: ${job.title}`,
+        body:
+          `Görev: ${job.title}\nKod: ${job.code || '?'}\nDurum: öz-kurtarma hakları tükendi\n\n` +
+          `Hata:\n${String(msg || 'bilinmeyen hata').slice(0, 800)}\n\n` +
+          `Sohbet geçmişi sağ paneldeki Paralel Ajanlar bölümünde.`,
+      })
+    ).catch(() => {});
+  }
+
+  /* grup üyesi kapandığında sonuç yazılır; sonuncuysa birleşik rapor basılır */
+  _bgGroupRecord(title, status, summary) {
+    for (const [gid, g] of this._bgGroups) {
+      if (g.dead) continue;
+      g.results.push({ title, status, summary: String(summary || '').slice(0, 900) });
+      if (g.results.length >= g.total) {
+        this._bgGroups.delete(gid);
+        const okN = g.results.filter((r) => r.status === 'done').length;
+        const body = g.results
+          .map((r) => (r.status === 'done' ? `\u2713 ${r.title}\n${r.summary}` : `\u2718 ${r.title} (${r.status})\n${r.summary || ''}`))
+          .join('\n\n')
+          .slice(0, 4000);
+        const text =
+          `[ARKA PLAN GRUP BİTTİ: ${okN}/${g.total}]\n${body}\n\n` +
+          `(Supervizyon: parçaları görevle karşılaştır — eksik varsa tamamlama görevi aç.)`;
+        emitSafe(this, g.parentId, { type: 'status', status: 'paralel grup tamamlandı' });
+        if (!this.isBusy(g.parentId)) {
+          this.send(g.parentId, { text });
+        } else {
+          this._pendingReports = this._pendingReports || [];
+          this._pendingReports.push({ parentId: g.parentId, text });
+        }
+        return true;
+      }
+      return true; // henüz bekleyen üye var — bireysel rapor bastırılır
+    }
+    return false; // grup bulunamadı → eski bireysel akış
+  }
+
+  /* ---------- paralel ajan kaydı (UI + CEO takip araçları) ---------- */
+
+  /* #17 iş kayıtlarını diske yaz — uygulama kapansa da geçmiş dursun.
+     Oturum dosyası silinmiş işler (elle silinmiş) geri yazılmaz. */
+  _saveBgJobs() {
+    try {
+      const jobs = [];
+      for (const j of this.listBgJobs().slice(0, 200)) {
+        try { fs.accessSync(this._file(j.id)); } catch { continue; }
+        const c = { ...j };
+        delete c._persisted;
+        jobs.push(c);
+      }
+      fs.writeFileSync(this._bgJobsFile, JSON.stringify({ v: 1, jobs }) + '\n');
+    } catch {}
+  }
+
+  _loadBgJobsPersisted() {
+    let migrated = false;
+    try {
+      if (!fs.existsSync(this._bgJobsFile)) return;
+      const data = JSON.parse(fs.readFileSync(this._bgJobsFile, 'utf8'));
+      for (const j of Array.isArray(data.jobs) ? data.jobs : []) {
+        if (!j || !j.id) continue;
+        /* eski süreçte koşuyor/kuyrukta idi → kimse koşturmuyor: kesildi say */
+        if (j.status === 'running' || j.status === 'queued') {
+          j.status = 'aborted';
+          j.endedAt = new Date().toISOString();
+          j.error = String(j.error || '') || 'uygulama kapatıldı';
+          migrated = true;
+        }
+        j._persisted = true;
+        this._bgJobs.set(String(j.id), j);
+      }
+    } catch {}
+    if (migrated) this._saveBgJobs();
+  }
+
+  _bgEmit() {
+    this._saveBgJobs();
+    try { this.emit({ type: 'agents', jobs: this.listBgJobs() }); } catch {}
+  }
+
+  listBgJobs() {
+    return [...this._bgJobs.values()].sort((a, b) =>
+      String(b.startedAt).localeCompare(String(a.startedAt))
+    );
+  }
+
+  /* Tek ajanın detayı: durum + mesaj dökümünün kısa kuyruğu */
+  bgDetail(idOrCode) {
+    const key = String(idOrCode || '').trim();
+    let job = this._bgJobs.get(key);
+    if (!job) job = this.listBgJobs().find((j) => j.code === key.toUpperCase()) || null;
+    if (!job) return { ok: false, error: 'ajan bulunamadı: ' + key };
+    const s = this._load(job.id);
+    const brief = (m) => {
+      const who = m.role === 'user' ? 'GÖREV' : m.role === 'assistant' ? 'AJAN' : m.role === 'tool' ? 'ARAÇ' : m.role;
+      const body = typeof m.content === 'string'
+        ? m.content
+        : Array.isArray(m.content)
+          ? m.content.map((p) => (p.type === 'text' ? p.text : '[görsel]')).join(' ')
+          : '';
+      return `${who}: ${String(body || '').replace(/\s+/g, ' ').trim().slice(0, 300)}`;
+    };
+    const tail = [];
+    for (const m of s.messages) {
+      if (m.tool_calls && m.tool_calls.length) {
+        tail.push(`ARAÇ ÇAĞRISI: ${m.tool_calls.map((t) => (t.function && t.function.name) || '?').join(', ')}`);
+        continue;
+      }
+      const line = brief(m);
+      if (line.trim()) tail.push(line);
+    }
+    return { ok: true, job, messages: tail.slice(-30) };
+  }
+
+  /* İş bitişi kaydı: status=done|error|aborted. Hata olursa üst sohbete haber gider. */
+  _bgFinish(sid, status, errorMsg) {
+    const job = this._bgJobs.get(String(sid));
+    if (!job || job.status !== 'running') return;
+    job.status = status;
+    job.revive = false;
+    job.endedAt = nowIso();
+    if (errorMsg) job.error = String(errorMsg).slice(0, 400);
+    this._bgEmit();
+    this._bgResumeQueue(); // #5 slot boşaldı — sıradaki iş başlar
+    /* grup üyeliği geçersizse bireysel akışa dön */
+    let grouped = false;
+    if (job.groupId) {
+      const g = this._bgGroups.get(job.groupId);
+      if (!g || g.dead) job.groupId = null;
+      else grouped = true;
+    }
+    if (status === 'error') {
+      const msg = String(errorMsg || '');
+      const cfgIssue = /Model yapılandır|config/i.test(msg);
+      /* #16 hatadan sonra otomatik toparlama: aynı oturumda devam hakkı varsa
+         CEO'ya hata bildirmeden önce kendini düzeltmeyi dene */
+      if (!cfgIssue && (job.fixes || 0) < BG_FIX_MAX) {
+        job.fixes = (job.fixes || 0) + 1;
+        const quick = /tur limiti/i.test(msg);
+        const text = quick
+          ? `[ÖZ-DÜZELTME] Tur limiti doldu — araç çağrısı YAPMA, elindeki bulgularla 3-5 satırlık final raporunu yaz ve bitir.`
+          : `[HATA SONRASI ÖZ-DÜZELTME ${job.fixes}/${BG_FIX_MAX}] Görev sırasında hata oluştu:\n${msg.slice(0, 220)}\n\nKALDIĞIN YERDEN DEVAM ET: hatayı telafi et (farklı yöntem/araç/parametre); tam yol yoksa elindekiyle EN İYİ KISMİ SONUCU raporla ve bitir.`;
+        this._bgKick(job, text);
+        return;
+      }
+      /* #17 öz-kurtarma hakları tükendi → owner'a anlık altyapı uyarısı */
+      this._notifyOwnerTaskFailed(job, msg);
+      if (grouped) {
+        /* #18 hatalı üye de gruba yazılır — birleşik raporda görünecek */
+        this._bgGroupRecord(job.title, 'error', 'HATA: ' + msg.slice(0, 300));
+        return;
+      }
+      const text =
+        `[ARKA PLAN HATA: ${job.title}]\n${msg || 'bilinmeyen hata'}\n` +
+        `(tasks_list / task_status ile detaya bakabilirsin.)`;
+      this._pendingReports = this._pendingReports || [];
+      this._pendingReports.push({ parentId: job.parentId, text });
+      this.flushPendingReports(job.parentId);
+    } else if (status === 'aborted' && grouped) {
+      /* iptal edilen üye gruptan düşmüş sayılır */
+      this._bgGroupRecord(job.title, 'aborted', '');
+    }
+  }
+
+  /* ---------- superyorizyon: CEO ajanları SAHİPLENİR (#15) ---------- */
+
+  /* Ajan olaylarında son aktivite zamanını güncelle (emit sarmalayıcıdan çağrılır) */
+  _bgTrack(ev) {
+    if (!ev || !ev.sessionId || !this._bgJobs) return;
+    const job = this._bgJobs.get(String(ev.sessionId));
+    if (!job || job.status !== 'running') return;
+    if (!['status', 'message', 'token', 'tool-start', 'tool-end'].includes(ev.type)) return;
+    if (ev.type === 'status' && ev.status === 'idle') return;
+    job.lastActivityAt = nowIso();
+  }
+
+  /* Saf sınıflandırma (test edilebilir): null | 'stuck' | 'wrapup' | 'long' */
+  static superviseReason(job, nowMs) {
+    if (!job || job.status !== 'running') return null;
+    const started = Date.parse(job.startedAt || '') || nowMs;
+    const lastAct = Date.parse(job.lastActivityAt || '') || started;
+    const runMin = (nowMs - started) / 60000;
+    const idleMin = (nowMs - lastAct) / 60000;
+    const nudgedMin = job.lastNudgeAt
+      ? (nowMs - (Date.parse(job.lastNudgeAt) || 0)) / 60000
+      : Infinity;
+    if (nudgedMin < SUP_NUDGE_COOLDOWN_MIN) return null; // yeni uyardık — boğmayalım
+    if (runMin >= SUP_STUCK_START_MIN && idleMin >= SUP_IDLE_MIN) return 'stuck';
+    if (!job.wrapAt && runMin >= BG_WRAP_MIN) return 'wrapup';
+    if (runMin >= SUP_LONG_MIN) return 'long';
+    return null;
+  }
+
+  /* Periyodik denetim: uygun iş varsa önce ajanın KENDİNİ düzeltmesine izin ver,
+     haklar biterse ana oturuma (CEO) müdahale emri düşür */
+  _supervise() {
+    const now = Date.now();
+    for (const job of this._bgJobs.values()) {
+      const reason = Engine.superviseReason(job, now);
+      if (!reason) continue;
+      /* #16 öz-kurtarma: takılan ajan CEO'yu meşgul etmeden kendini toparlar */
+      if (reason === 'stuck' && (job.fixes || 0) < BG_FIX_MAX) {
+        this._bgSelfHeal(job, now);
+        continue;
+      }
+      /* zarif bitirme: süre dolunca yeni araştırma yasak → SON RAPORU yazsın */
+      if (reason === 'wrapup') {
+        this._bgWrapUp(job, now);
+        continue;
+      }
+      job.lastNudgeAt = nowIso();
+      job.checks = (job.checks || 0) + 1;
+      const det = this.bgDetail(job.id);
+      const tail = det.ok && det.messages.length ? det.messages.slice(-5).join('\n') : '(henüz çıktı yok)';
+      const runMin = Math.max(0, Math.round((now - Date.parse(job.startedAt)) / 60000));
+      const idleMin = Math.max(0, Math.round((now - (Date.parse(job.lastActivityAt) || now)) / 60000));
+      const text =
+        reason === 'stuck'
+          ? `[SUPERYORIZON] "${job.title}" paralel ajanı ${runMin} dk'dır koşuyor ama son ${idleMin} dk'dır HİÇ hareket yok — büyük olasılıkla TAKILDI.\nSon çıktı:\n${tail}\n\nYAPILACAKLAR: task_status id=${job.id} ile dökümü oku → sorun netse task_cancel id=${job.id} ve düzeltilmiş görevle YENİ run_background aç → kullanıcıya TEK cümleyle durumu bildir. Bu uyarıyı ASLA görmezden gelme.`
+          : `[SUPERYORIZON] "${job.title}" paralel ajanı ${runMin} dk'dır koşuyor (aktivite sürüyor).\nSon çıktı:\n${tail}\n\nARA KONTROL yap: hedefe gidiyor mu? Sapma varsa müdahale et (iptal + yeniden görevlendir); yolundaysa beklemeye devam — kullanıcıya gereksiz gürültü çıkarma.`;
+      if (!this.isBusy(job.parentId)) {
+        this.send(job.parentId, { text });
+      } else {
+        this._pendingReports = this._pendingReports || [];
+        this._pendingReports.push({ parentId: job.parentId, text });
+      }
+    }
+  }
+
+  /* #16 takılan paralel ajanın KENDİ kendini düzeltmesi: asılı tur kesilir,
+     aynı oturuma öz-kurtarma emri düşer — CEO sadece haklar bitince devreye girer */
+  _bgSelfHeal(job, now) {
+    job.lastNudgeAt = nowIso();
+    job.checks = (job.checks || 0) + 1;
+    job.fixes = (job.fixes || 0) + 1;
+    const fixNo = job.fixes;
+    const det = this.bgDetail(job.id);
+    const tail = det.ok && det.messages.length ? det.messages.slice(-3).join('\n') : '(henüz çıktı yok)';
+    const idleMin = Math.max(1, Math.round((now - (Date.parse(job.lastActivityAt) || now)) / 60000));
+    const text =
+      `[ÖZ-KURTARMA ${fixNo}/${BG_FIX_MAX}] "${job.title}" görevinde son ~${idleMin} dk'dır hiç hareket yok — muhtemelen TAKILDIN.\nSon çıktı:\n${tail}\n\n` +
+      `ŞİMDİ KENDİNİ DÜZELT (bunu tartışma, doğrudan uygula):\n` +
+      `1) Takılan aracı/adımı bırak, FARKLI bir yöntemle devam et (farklı komut, daha kısa yol, farklı kaynak).\n` +
+      `2) Gerekirse görevi küçült: en kritik sonucu üretecek kısma odaklan.\n` +
+      `3) Her yolla çıkılmıyorsa engeli TEK cümlede açıkla ve şu ana kadarki EN İYİ KISMİ SONUCU rapor olarak yazıp bitir.`;
+    this._bgKick(job, text);
+  }
+
+  /* Zarif bitirme: süre dolunca ajanı kesip SON RAPORU yazmasını iste.
+     Uzatma yok, öldürme yok — mevcut bulgularla düzgün kapanış. */
+  _bgWrapUp(job, now) {
+    job.wrapAt = nowIso();
+    job.lastNudgeAt = nowIso();
+    job.checks = (job.checks || 0) + 1;
+    const runMin = Math.max(1, Math.round((now - Date.parse(job.startedAt)) / 60000));
+    const det = this.bgDetail(job.id);
+    const tail = det.ok && det.messages.length ? det.messages.slice(-3).join('\n') : '';
+    const text =
+      `[SÜRE UYARISI] "${job.title}" görevi ${runMin} dk'dır sürüyor — süre doldu.\n` +
+      `YENİ arama/fetch/sayfa açma YAPMA. Şu ana kadar bulduklarınla SON RAPORU şimdi yaz:\n` +
+      `- 3-5 madde: net sonuç + yapılamayanlar açıkça "bulunamadı" diye.\n` +
+      `Raporu yazınca görev tamamlanır — fazladan tur harcama.` +
+      (tail ? `\n\nSon çıktın:\n${tail}` : '');
+    this._bgKick(job, text);
+  }
+
+  /* Arka plan oturumuna müdahale: asılı turu kes (ctrl.abort), sonra
+      kurtarma mesajını bas. abort → eski _run sonlanır → send yeni tur açar.
+      revive bayrağı: /stop veya silme sonrası bekleyen müdahaleler patlamasın. */
+  _bgKick(job, text) {
+    const sid = String(job.id);
+    job.revive = true;
+    const ctrl = this.ctrls.get(sid);
+    if (ctrl) {
+      try { ctrl.abort(); } catch {}
+      if (!this._kickTimers) this._kickTimers = new Map();
+      clearTimeout(this._kickTimers.get(sid));
+      this._kickTimers.set(sid, setTimeout(() => {
+        this._kickTimers.delete(sid);
+        this._bgKickSend(sid, text);
+      }, 1200));
+    } else {
+      this._bgKickSend(sid, text);
+    }
+  }
+
+  _clearKicks(sid) {
+    if (this._kickTimers && this._kickTimers.has(String(sid))) {
+      clearTimeout(this._kickTimers.get(String(sid)));
+      this._kickTimers.delete(String(sid));
+    }
+  }
+
+  _bgKickSend(sid, text) {
+    try {
+      const j = this._bgJobs.get(String(sid));
+      /* silinmiş/durdurulmuş işe geri dönüş yok — hayalet dosya yaratma */
+      if (!j || j.revive !== true) return;
+      j.revive = false;
+      if (!this._load(sid)) return;
+      if (j.status !== 'running') { j.status = 'running'; j.endedAt = null; }
+      this.send(sid, { text });
+      this._bgEmit();
+    } catch {}
+  }
+
+  /* Eski motor örneğini kapat (reloadBackend) — supervisor zamanlayıcısı durur */
+  dispose() {
+    if (this._supTimer) {
+      clearInterval(this._supTimer);
+      this._supTimer = null;
+    }
+  }
+
+  /* Arka plan oturumu 'done' olduğunda ana sohbete özet basar (main çağırır) */
+  async reportBackgroundDone(bgSessionId) {
+    try {
+      const meta = this._bgMeta && this._bgMeta.get(String(bgSessionId));
+      if (!meta) return false;
+      /* Öz-kurtarma/wrap-up kick'i bekliyorsa bu bir ABORT turudur — gerçek
+         bitiş DEĞİL; erken "ARKA PLAN BİTTİ (sonuca ulaşmadan)" ilanı basma */
+      const pendingKick = this._bgJobs.get(String(bgSessionId));
+      if (pendingKick && pendingKick.revive === true) return false;
+      /* #18 grup üyesiyse bireysel rapor yok — birleşik rapor için sonucu yaz */
+      const jobRec = this._bgJobs.get(String(bgSessionId));
+      const inGroup = !!(jobRec && jobRec.groupId);
+      this._bgFinish(bgSessionId, 'done');
+      const s = this._load(String(bgSessionId));
+      let lastA = '';
+      for (let i = s.messages.length - 1; i >= 0; i--) {
+        const m = s.messages[i];
+        if (m.role === 'assistant' && m.content && !m.tool_calls) {
+          lastA = typeof m.content === 'string' ? m.content : '';
+          break;
+        }
+      }
+      const summary = lastA.slice(0, 900) || '(arka plan görevi sonuca ulaşmadan bitti)';
+      if (inGroup) {
+        this._bgGroupRecord(meta.title, 'done', summary);
+        this._bgMeta.delete(String(bgSessionId));
+        return true;
+      }
+      emitSafe(this, meta.parentId, { type: 'status', status: 'arka plan görevi tamamlandı' });
+      const text =
+        `[ARKA PLAN BİTTİ: ${meta.title}]\n${summary}\n` +
+        `(Supervizyon: raporu görevle karşılaştır — EKSİK/YANLIŞ varsa hemen tamamlama görevi aç; "arka plan raporunu göster" dersen tam dökümü incelersin.)`;
+      if (!this.isBusy(meta.parentId)) {
+        this.send(meta.parentId, { text });
+      } else {
+        // ana oturum meşgulse sessizce bekle: kullanıcı mesajıyla birlikte akar
+        this._pendingReports = this._pendingReports || [];
+        this._pendingReports.push({ parentId: meta.parentId, text });
+      }
+      this._bgMeta.delete(String(bgSessionId));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /* Ana oturum işini bitirince bekleyen arka plan raporlarını boşalt */
+  flushPendingReports(sessionId) {
+    if (!this._pendingReports || !this._pendingReports.length) return;
+    const rest = [];
+    for (const r of this._pendingReports) {
+      if (r.parentId === sessionId && !this.isBusy(sessionId)) {
+        try { this.send(sessionId, { text: r.text }); } catch {}
+      } else rest.push(r);
+    }
+    this._pendingReports = rest;
+  }
+
+  /* #21 arka plan ajanı İNCE sistem promptu: dev CEO/hafıza/skill blokları yok
+     → her turda çok daha az prompt tokeni = hızlı ön-bellek + düşük maliyet */
+  buildBgSystem(session) {
+    const job = (session && this._bgJobs.get(String(session.id))) || {};
+    return (
+      `Sen odaklı bir ARKA PLAN ajanısın. Tek görevini baştan sona bitir.\n` +
+      (job.task ? `GÖREV: ${job.task}\n` : '') +
+      `Ortam: Windows + PowerShell; çalışma klasörü: ${this.workspace}\n` +
+      `HIZ KURALLARI:\n` +
+      `- Döngülü işleri (çok URL/dosya/sayfa, tekrarlı parse-hesap) TEK python_run betiğinde topluca bitir.\n` +
+      `- Web için web_search (çoklu-motor) kullan; etkileşimli sayfada dahili tarayıcı: browser_open → browser_snapshot → browser_click/type/read. Görseli göremiyorsan metni ocr_read ile oku (source:"browser").\n` +
+      `- Bağımsız araç çağrılarını aynı turda PARALEL ver.\n` +
+      `- ARAŞTIRMA SINIRI: 3-5 kaynak yeter; süre hedefi ~3 dakika. 2-3 denemede bulunamayan bilgiyi BIRAK — bulabildiğin kısmi sonucu raporla ve neyi bulamadığını yaz. Kapalı/gizli içerik peşinde koşma.\n` +
+      FORMAT_RULES + '\n' +
+      `SON ÇIKTI: 3-5 satırlık net sonuç raporu, madde madde. Soru sorma, sohbet etme.`
+    );
+  }
+
+  /* uzun bg işlerinde geçmiş şişer → payload büyür, hız düşer. Son N mesaj kalsın
+     (+ asıl görev mesajı); kopuk tool çifti sınırı hizalanır */
+  static BG_KEEP_MSGS = 24;
+  _bgTrim(session) {
+    const max = Engine.BG_KEEP_MSGS;
+    const msgs = session.messages;
+    if (!session.bgJob || msgs.length <= max) return;
+    const keep = msgs.slice(-max);
+    while (keep.length && keep[0].role === 'tool') keep.shift();
+    const firstUser = msgs.find((m) => m.role === 'user');
+    if (firstUser && !keep.includes(firstUser)) keep.unshift(firstUser);
+    session.messages = keep;
+  }
+
+  async _chatTurn(session, signal, onDelta, toolsList = TOOLS) {
+    const promptText = this._lastUserText(session);
+    let system = session.bgJob ? this.buildBgSystem(session) : this.buildSystem(promptText);
+    // Granül izin: oturumun yetki seviyesine göre araç seti daraltılır
+    const perm = this.sessionPermFor(session.id);
+    const allowedSet = PERM_TOOL_SETS[perm] || null;
+    let activeTools = allowedSet ? toolsList.filter((t) => allowedSet.has(t.function.name)) : toolsList;
+    if (session.bgJob) {
+      /* arka plan ajanı: yönetim araçlarını görmez — işini bitirsin */
+      activeTools = activeTools.filter((t) => !BG_HIDDEN_TOOLS.has(t.function.name));
+    } else if (this.ceoMode) {
+      /* CEO: uygulayıcı araçlar kapalı — her şey paralel ajana devredilir */
+      activeTools = activeTools.filter((t) => !CEO_EXEC_TOOLS.has(t.function.name));
+    }
+    if (perm === 'chat') {
+      system +=
+        '\n\n# KISITLI MOD\nTüm araçların (komut, dosya, web, tarayıcı, hafıza) kapalı. Sadece yazarak cevap ver. ' +
+        'Bilgisayarla ilgili bir işlem istenirse bu modda yapamayacağını kibarca söyle.';
+    } else if (perm === 'web') {
+      system +=
+        '\n\n# SINIRLI YETKİ (web)\nSadece web ve tarayıcı araçlarına erişimin var; dosya okuma/yazma ve komut çalıştırma YOK. ' +
+        'Böyle bir istek gelirse yetkin olmadığını söyle.';
+    } else if (perm === 'read') {
+      system +=
+        '\n\n# SINIRLI YETKİ (salt-okunur)\nBilgisayarı SADECE OKUYABİLİRSİN (klasör listeleme, dosya okuma) + web/tarayıcı. ' +
+        'Dosya yazma, silme ve komut çalıştırma YOK; istenirse yapamayacağını söyle.';
+    }
+    if (session.notes) {
+      system +=
+        `\n\n# OTURUM NOTLARI (oturum ${session.code || '?'} — bu oturumun önceki konuşma özeti; birebir geçmişi buradan hatırla)\n` +
+        session.notes;
+    }
+    const payload = this._buildPayload(system, session.messages, session.notes);
+    // Vision model sadece mesajda görsel varsa devreye girer; terminal ise prompt'un
+    // shell/command işi olduğunda. Aksi halde ana model kullanılır.
+    let role = this._lastUserHasImage(session) ? 'vision' : null;
+    if (!role && /^(?:bash|sh|powershell|cmd|run_command|powershell script|terminal)\b/i.test(String(promptText || '').trim())) {
+      role = 'terminal';
+    }
+    let sel = this.modelFor(role);
+    if (role && this.roleModels[role]) {
+      emitSafe(this, session.id, { type: 'status', status: `rol: ${role} → ${sel.providerName} · ${sel.model}` });
+    }
+    // FALLOUT destekli çağrı: hata olursa zincirdeki sıradaki sağlayıcıya geç
+    const res = await this._streamWithFallbacks(
+      session,
+      payload,
+      activeTools,
+      signal,
+      onDelta,
+      sel,
+      role === 'vision'
+    );
+    // Gerçek kullanım ile tahmini bütçeyi kalibre et
+    const actual = res.usage && res.usage.prompt_tokens;
+    if (actual > 0) {
+      const predicted = this._payloadTokens(payload);
+      if (predicted > 50) {
+        const r = clamp(actual / predicted, 0.4, 3);
+        this.tokRatio = clamp(this.tokRatio * 0.7 + r * 0.3, 0.4, 3);
+      }
+    }
+    return res;
+  }
+
+  async _run(session) {
+    const ctrl = new AbortController();
+    this.ctrls.set(session.id, ctrl);
+    const sid = session.id;
+    const emit = (ev) => this.emit({ ...ev, sessionId: sid });
+    try {
+      if (!this.sel) throw new Error('Model yapılandırılmadı — %APPDATA%\\beast\\config.yaml ve .env kontrol et');
+
+      for (let turn = 0; turn < MAX_TURNS; turn++) {
+        this._bgTrim(session); // #21 bg geçmişini olabildiğince ince tut
+        emit({ type: 'status', status: 'thinking' });
+        const res = await this._chatTurn(session, ctrl.signal, (delta) =>
+          emit({ type: 'token', delta })
+        );
+
+        const assistant = { role: 'assistant', content: res.content || '' };
+        if (res.toolCalls && res.toolCalls.length) assistant.tool_calls = res.toolCalls;
+        session.messages.push(assistant);
+        try {
+          this._append(session, assistant);
+        } catch {}
+        emit({ type: 'message', message: assistant });
+
+        if (!res.toolCalls || !res.toolCalls.length) {
+          // cevap tamam — pencereden düşecek kısmın oturum notlarını güncelle
+          /* #21 bg ajanı: görev sonu ekstra LLM çağrıları YOK — hızlı kapansın */
+          if (!session.bgJob) {
+            const r = await this._updateSessionNotes(session, ctrl.signal);
+            if (r && r.ok) {
+              emitSafe(this, sid, { type: 'status', status: `oturum notları güncellendi (${session.code || ''})` });
+            } else if (r && r.reason && !/^bekleme/.test(r.reason)) {
+              emitSafe(this, sid, { type: 'status', status: `oturum notu YAZILAMADI: ${r.reason}` });
+            }
+          }
+          /* otomatik memory döngüsü: kalıcı değerli bilgiyi MEMORY.md'ye düşür */
+          if (!ctrl.signal.aborted && !session.bgJob) {
+            try {
+              await this._autoMemory(session, ctrl.signal);
+            } catch {}
+          }
+          /* deneyimden skill doğurma (#2): 5+ yeni araç çağrısı biriktiyse yansıt */
+          if (this.reflection.enabled && !ctrl.signal.aborted && !session.bgJob) {
+            try {
+              const made = await this._maybeReflectSkill(session);
+              if (made) emitSafe(this, sid, { type: 'status', status: `skill taslağı doğdu: ${made}` });
+            } catch {}
+          }
+          this._clearCrash(); // temiz bitiş — çökme kaydını sil
+          this._maybeCompact(sid); // oturum dosyası şiştiyse sıkıştır
+          emit({ type: 'done', usage: res.usage || null, meta: res.meta || null });
+          this._bgFinish(sid, 'done');
+          this.flushPendingReports(sid); // bekleyen arka plan raporları
+          /* #12: yeterli örnek birikmişse üslup kalibrasyonu (sessiz) */
+          try {
+            const cal = memory.calibratePersona();
+            if (cal.ok && cal.traits && cal.traits.length) {
+              emitSafe(this, sid, { type: 'status', status: 'kişilik kalibre edildi' });
+            }
+          } catch {}
+          return;
+        }
+
+        // Paralel yürütme — bağımsız çağrılar beklemesin
+        session.toolsSinceReflect = (session.toolsSinceReflect || 0) + res.toolCalls.length;
+        await Promise.all(
+          res.toolCalls.map(async (tc) => {
+            const name = tc.function && tc.function.name;
+            let args = {};
+            try {
+              args = JSON.parse((tc.function && tc.function.arguments) || '{}');
+            } catch {}
+            emit({ type: 'tool-start', callId: tc.id, name, args });
+            emit({ type: 'status', status: name });
+            let out = await this._execTool(name, args, ctrl.signal, sid);
+            // Ekran görüntüsü gibi araçlar görseli sonraki tura enjekte eder
+            let injectedImage = null;
+            try {
+              const obj = JSON.parse(out);
+              if (obj && obj.__injectImage) {
+                injectedImage = String(obj.__injectImage);
+                delete obj.__injectImage;
+                out = JSON.stringify(obj);
+              }
+            } catch {}
+            const toolMsg = { role: 'tool', tool_call_id: tc.id, name, content: out.slice(0, TOOL_OUT_KEEP * 6) };
+            session.messages.push(toolMsg);
+            try {
+              this._append(session, toolMsg);
+            } catch {}
+            emit({ type: 'tool-end', callId: tc.id, ok: !/"error"/.test(out.slice(0, 200)), result: out.slice(0, 4000) });
+            if (injectedImage) {
+              const imgMsg = {
+                role: 'user',
+                content: [
+                  { type: 'text', text: '[tarayıcı ekran görüntüsü — bu kareyi analiz et ve devam et]' },
+                  { type: 'image_url', image_url: { url: injectedImage } },
+                ],
+              };
+              session.messages.push(imgMsg);
+              try { this._append(session, imgMsg); } catch {}
+              emit({ type: 'message', message: imgMsg });
+            }
+          })
+        );
+      }
+      emit({ type: 'done', usage: null });
+      this._bgFinish(sid, 'error', 'tur limiti doldu (MAX_TURNS)');
+    } catch (e) {
+      const aborted = e && (e.name === 'AbortError' || ctrl.signal.aborted);
+      if (aborted) {
+        this._clearCrash(); // kullanıcı durdurdu — kurtarma yok
+        emit({ type: 'done', aborted: true });
+        this._bgFinish(sid, 'aborted');
+      } else {
+        // FALLOUT: tüm zincir tükendi — durumu kaydet, açılışta kaldığı yerden devam edilir
+        this._saveCrash(sid, e, 'chain-exhausted');
+        emit({ type: 'error', error: String((e && e.message) || e) });
+        this._bgFinish(sid, 'error', e.message);
+        /* #11 self-heal: aynı oturumda 2. hatada log okuyup teşhis başlat */
+        this._maybeSelfHeal(sid, e);
+      }
+    } finally {
+      this.ctrls.delete(sid);
+      emit({ type: 'status', status: 'idle' });
+    }
+  }
+
+  /* ---------- yansıma: deneyimden skill taslağı (#2) ---------- */
+
+  /* #11 kendini tamir: aynı oturumda 2. hatada son log satırlarını okuyup
+     teşhis görevini AYNI oturuma düşürür; agent kendi hatasını analiz eder. */
+  _maybeSelfHeal(sid, err) {
+    try {
+      const key = String(sid);
+      this._errCount = this._errCount || new Map();
+      const n = (this._errCount.get(key) || 0) + 1;
+      this._errCount.set(key, n);
+      if (n < 2) return;
+
+      /* tekrar döngüsüne girmesin: sayaç sıfırla, teşhis tek sefer */
+      this._errCount.set(key, 0);
+
+      let tail = '';
+      try {
+        const logfile = path.join(this.sessionsDir, '..', 'wa.log');
+        tail = fs.readFileSync(logfile, 'utf8').split('\n').slice(-30).join('\n');
+      } catch {}
+      if (!tail.trim()) {
+        // app log yoksa oturum kaydının son satırlarıyla idare et
+        try {
+          const raw = fs.readFileSync(this._file(sid), 'utf8').split('\n').filter(Boolean);
+          tail = raw.slice(-10).join('\n');
+        } catch {}
+      }
+
+      const msg =
+        `[SELF-HEAL] Bu oturumda art arda 2 hata oluştu. Son hata: ` +
+        `${String((err && err.message) || err).slice(0, 200)}\n` +
+        `Son günlük satırları:\n${tail.slice(-2500)}\n\n` +
+        `Günlüğü incele: sorunun kök nedenini TEK cümleyle teşhis et ve kullanıcıya ` +
+        `sadece teşhis + önerilen çözümü bildir. Yeni iş başlatma.`;
+
+      setTimeout(() => {
+        try {
+          if (!this.isBusy(sid)) {
+            emitSafe(this, sid, { type: 'status', status: 'self-heal: teşhis yapılıyor' });
+            this.send(sid, { text: msg });
+          }
+        } catch {}
+      }, 1200);
+    } catch {}
+  }
+
+  /* Oturumda son yansımadan bu yana kaç araç çağrısı biriktiğini sayar.
+     Mesajları yeniden taramak yerine imza tutarız: session.toolsSinceReflect */
+  /* ---------- otomatik memory döngüsü ----------
+     Sohbetten kalıcı değerli bilgiyi (isim, tercih, proje, alışkanlık)
+     yakalayıp MEMORY.md'ye düşürür. Şişmeyi engelleme: her turda DEĞİL,
+     NOTES_TRIGGER mesajda bir; kısa tutulmuş madde; hygiene dedup'ı. */
+  async _autoMemory(session, signal) {
+    try {
+      if (!this.sel) return;
+      const msgs = session.messages;
+      if (msgs.length < 4) return;
+      /* son taramadan beri yeterli yeni içerik var mı */
+      const since = Number(session.memScanAt ?? -6);
+      if (msgs.length - since < 4) return;
+      session.memScanAt = msgs.length;
+
+      const slice = msgs.slice(Math.max(0, msgs.length - 10));
+      const transcript = this._renderTranscript(slice);
+      if (transcript.trim().length < 200) return;
+
+      const existing = memory.entries().slice(-30).join('\n');
+      const prompt =
+        'Aşağıdaki konuşma parçasından UZUN VADELİ hatırlanmaya değer bilgileri çıkar ' +
+        '(kullanıcının kalıcı tercihleri, projeleri/işleri, isimler, rutinleri).\n' +
+        'KURALLAR:\n' +
+        '- Sadece haftalar sonra bile işe yarayacak şeyler; geçici detay asla\n' +
+        '- En fazla 3 madde, her biri max 120 karakter, "kullanıcı ..." diye başla\n' +
+        '- Değerli bilgi yoksa boş dizi\n' +
+        `ZATEN KAYITLI olanlar (tekrar ekleme):\n${existing || '(boş)'}\n\n` +
+        '# SOHBET\n' + transcript.slice(0, 4000) +
+        '\n\nSADECE JSON dön: {"memories": ["...", "..."]} veya {"memories": []}';
+
+      const res = await chatOnce(
+        this.sel,
+        { messages: [{ role: 'user', content: prompt }], temperature: 0.1 },
+        { signal }
+      );
+      let parsed = null;
+      try { parsed = JSON.parse(String(res.content || '').replace(/```(?:json)?|```/g, '').trim()); } catch {}
+      const mems = parsed && Array.isArray(parsed.memories) ? parsed.memories : [];
+      for (const m of mems.slice(0, 3)) {
+        const t = String(m || '').trim().slice(0, 200);
+        if (!t) continue;
+        const r = memory.append(t);
+        if (r.ok && !r.duplicate) emitSafe(this, session.id, { type: 'status', status: 'hafıza güncellendi' });
+      }
+      /* şişme kontrolü: kayıt sayısı cap'a yaklaşınca hijyen koş */
+      if (memory.entries().length > 320) {
+        try { memory.hygiene({}); } catch {}
+      }
+    } catch {}
+  }
+
+  async _maybeReflectSkill(session) {
+    const since = (session.toolsSinceReflect || 0);
+    if (since < this.reflection.minTools) return null;
+    if (!this.sel) return null;
+    /* derin döngülerde tekrar tetiklenmesin: hemen sıfırla */
+    session.toolsSinceReflect = 0;
+
+    const transcript = this._renderTranscript(
+      session.messages.filter((m) => m.role !== 'tool').slice(-40)
+    );
+    if (transcript.length < 400) return null; // çok kısa deneyim değmez
+
+    const prompt =
+      'Aşağıdaki agent oturumunda TEKRARLANABİLİR, yeniden kullanılabilir bir prosedür/bilgi ' +
+      'birikti mi? Kullanıcıya özel geçici detaylar sayılmaz. Karar: evet ise SKILL.md taslağı üret.\n\n' +
+      'SADECE şu JSON formatında cevap ver, başka metin yok:\n' +
+      '{"create": true|false, "name": "kisa-kebab-ad", "description": "tek cümle ne işe yarar", ' +
+      '"body": "# Başlık\\n\\nmaddeler halinde adım adım prosedür"}\n\n' +
+      '# OTURUM ÖZETİ\n' + transcript.slice(0, 6000);
+
+    const res = await chatOnce(
+      this.sel,
+      { messages: [{ role: 'user', content: prompt }], temperature: 0.2 },
+      {}
+    );
+    const draft = parseReflectionJson(res.content || '');
+    if (!draft || !draft.create || !draft.name || !draft.body) return null;
+    const skills = require('./skills');
+    const r = skills.addDraft({
+      name: String(draft.name),
+      description: String(draft.description || ''),
+      body: String(draft.body),
+    });
+    return r.ok ? skills.slugify(draft.name) : null;
+  }
+
+  /* ---------- alt-agent ---------- */
+
+  async _subagent(task, context, parentSignal, sessionId) {
+    const ctrl = new AbortController();
+    const onAbort = () => ctrl.abort();
+    if (parentSignal) {
+      if (parentSignal.aborted) throw new Error('iptal edildi');
+      parentSignal.addEventListener('abort', onAbort, { once: true });
+    }
+    const subTools = TOOLS.filter(
+      (t) =>
+        t.function.name !== 'delegate_task' &&
+        t.function.name !== 'set_reminder' &&
+        !t.function.name.startsWith('email_')
+    );
+    const role = 'subagent';
+    const sel = this.modelFor(role) || this.sel;
+    if (this.roleModels[role]) {
+      emitSafe(this, sessionId, { type: 'status', status: `rol: ${role} → ${sel.providerName} · ${sel.model}` });
+    }
+    const system =
+      `Sen odaklı bir alt-agentsın. Ana ajansın verdiği TEK görevi bitir ve sadece nihai sonucu döndür.\n` +
+      `Windows + PowerShell, çalışma klasörü: ${this.workspace}\n` +
+      `HIZ KURALI: döngü gerektiren işleri (çok sayfa okuma, çok URL çekme, tekrarlı hesap/parse) TEK python_run betiğinde topluca yap — her adım için ayrı araç turu harcama; 10 fetch = 1 betik = çok daha hızlı görev.\n` +
+      `ARAŞTIRMA SINIRI: 3-5 kaynak yeter; 2-3 denemede bulamazsan kısmi sonucu getir, takılma.\n` +
+      `Kısa çalış, gereksiz soru sorma, sonucu madde madde raporla.\n` +
+      FORMAT_RULES;
+    const user = context ? `${task}\n\n# BAĞLAM\n${context}` : task;
+    const msgs = [
+      { role: 'system', content: system },
+      { role: 'user', content: user },
+    ];
+    try {
+      for (let turn = 0; turn < SUB_MAX_TURNS; turn++) {
+        const res = await chatStream(
+          sel,
+          { messages: [{ role: 'system', content: system }, ...msgs.slice(1)], tools: subTools, reasoningEffort: this._thinkEffort() },
+          { signal: ctrl.signal }
+        );
+        const assistant = { role: 'assistant', content: res.content || '' };
+        if (res.toolCalls && res.toolCalls.length) assistant.tool_calls = res.toolCalls;
+        msgs.push(assistant);
+        if (!res.toolCalls || !res.toolCalls.length) return res.content || '(alt-agent boş döndü)';
+        for (const tc of res.toolCalls) {
+          let args = {};
+          try {
+            args = JSON.parse((tc.function && tc.function.arguments) || '{}');
+          } catch {}
+          const out = await this._subExecTool(tc.function.name, args, ctrl.signal);
+          msgs.push({ role: 'tool', tool_call_id: tc.id, name: tc.function.name, content: out });
+        }
+      }
+      const last = [...msgs].reverse().find((m) => m.role === 'assistant' && m.content);
+      return (last && last.content) || '(tur limiti doldu)';
+    } finally {
+      if (parentSignal) parentSignal.removeEventListener('abort', onAbort);
+    }
+  }
+
+  /* Dahili OCR aracı: görüntüden metin çıkarır (görsel desteklemeyen modeller için).
+     Kaynak: 'browser' (dahili tarayıcı görüntüsü, varsayılan) | 'screen' (masaüstü) | dosya yolu. */
+  async _ocrRead(args, signal) {
+    if (!this.ocr) return { ok: false, error: 'OCR kullanılamıyor' };
+    const src = String((args && args.source) || 'browser');
+    let image = null;
+    let via = 'file';
+    try {
+      if (src === 'browser') {
+        via = 'browser';
+        if (!this.browser || typeof this.browser.screenshot !== 'function') {
+          return { ok: false, error: 'dahili tarayıcı kullanılamıyor' };
+        }
+        const shot = await this.browser.screenshot(signal);
+        if (!shot || !shot.ok) return { ok: false, error: (shot && shot.error) || 'görüntü alınamadı' };
+        image = shot.__injectImage || shot.image || null;
+      } else if (src === 'screen') {
+        via = 'screen';
+        if (!this.computer || typeof this.computer.look !== 'function') {
+          return { ok: false, error: 'ekran erişimi yok' };
+        }
+        const shot = await this.computer.look();
+        image = typeof shot === 'string' ? shot : (shot && (shot.image || shot.dataUrl)) || null;
+      } else {
+        const abs = path.isAbsolute(src) ? src : path.join(this.workspace, src);
+        if (!fs.existsSync(abs)) return { ok: false, error: 'görsel bulunamadı: ' + src };
+        image = abs;
+      }
+    } catch (e) {
+      return { ok: false, error: String((e && e.message) || e) };
+    }
+    const r = await this.ocr({ image, lang: String((args && args.lang) || 'tur+eng') });
+    return { ...r, via };
+  }
+
+  async _subExecTool(name, args, signal) {
+    try {
+      if (name === 'memory_write') return JSON.stringify(memory.append(args.text));
+      if (name === 'memory_search') {
+        return JSON.stringify({
+          ok: true,
+          query: String(args.query || ''),
+          results: memory.search(String(args.query || ''), clamp(Number(args.limit) || 5, 1, 15)),
+        });
+      }
+      if (name === 'ocr_read') return JSON.stringify(await this._ocrRead(args || {}, signal));
+      if (!(name === 'run_command' || name === 'read_file' || name === 'write_file' || name === 'list_dir' ||
+            name === 'web_search' || name === 'http_fetch' || name === 'python_run')) {
+        return JSON.stringify({ ok: false, error: `unknown tool ${name}` });
+      }
+      return await tools.exec(name, args, { cwd: this.workspace, signal });
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: String((e && e.message) || e) });
+    }
+  }
+
+  /* ---------- tool dispatch ---------- */
+
+  /* Onay gerektiren araçlar — tepkiyle onay kapısına takılır */
+  static RISKY_TOOLS = new Set(['run_command', 'write_file', 'python_run', 'email_send', 'watcher_add']);
+
+  async _execTool(name, args, signal, sessionId) {
+    try {
+      /* onay kapısı: riskli araçta dış onay bekle; reddedilirse araç çalışmaz.
+         "always" onaylı araçlar doğrudan geçer. */
+      if (
+        Engine.RISKY_TOOLS.has(name) &&
+        !this.alwaysAllowTools.has(name) &&
+        this.approvals && typeof this.approvals.request === 'function'
+      ) {
+        emitSafe(this, sessionId, { type: 'status', status: `onay bekleniyor: ${name}` });
+        let ok = false;
+        try {
+          ok = !!(await this.approvals.request({ sessionId, tool: name, args: args || {} }));
+        } catch {}
+        if (!ok) {
+          return JSON.stringify({
+            ok: false,
+            error:
+              'kullanıcı bu işlemi ONAYLAMADI (iptal edildi veya zaman aşımı). İşlemi yeniden deneme; kullanıcıya sormadan alternatif öner.',
+          });
+        }
+      }
+      if (name === 'memory_write') {
+        return JSON.stringify(memory.append(args.text));
+      }
+      if (name === 'memory_search') {
+        return JSON.stringify({
+          ok: true,
+          query: String(args.query || ''),
+          results: memory.search(String(args.query || ''), clamp(Number(args.limit) || 5, 1, 15)),
+        });
+      }
+      if (name === 'todo_write') {
+        const items = sanitizeTodoItems(args.items);
+        this.todos.set(sessionId, items);
+        try {
+          fs.appendFileSync(
+            this._file(sessionId),
+            JSON.stringify({ t: 'todo', items }) + '\n'
+          );
+        } catch {}
+        this.emit({ type: 'todos', sessionId, todos: items });
+        const done = items.filter((t) => t.status === 'done').length;
+        return JSON.stringify({ ok: true, total: items.length, done, note: 'kullanıcıya gösterildi; her adımda güncelle' });
+      }
+      if (name === 'delegate_task') {
+        const task = String(args.task || '').trim();
+        if (!task) return JSON.stringify({ ok: false, error: 'task gerekli' });
+        emitSafe(this, sessionId, { type: 'status', status: 'delegate_task' });
+        const result = await this._subagent(task, String(args.context || ''), signal, sessionId);
+        return JSON.stringify({ ok: true, task, result: String(result).slice(0, 12000) });
+      }
+      if (name === 'send_file') {
+        if (typeof this.fileSend !== 'function') {
+          return JSON.stringify({ ok: false, error: 'dosya gönderim köprüsü yok' });
+        }
+        const p = String((args && args.path) || '').trim();
+        if (!p) return JSON.stringify({ ok: false, error: 'path gerekli' });
+        const r = await this.fileSend(sessionId, p, String((args && args.caption) || ''));
+        return JSON.stringify(r);
+      }
+      if (name === 'run_background') {
+        const r = this.runBackground(sessionId, args.task, args.title);
+        return JSON.stringify({
+          ...r,
+          note: 'paralel ajan başladı — ana sohbet açık; bittiğinde özet otomatik gelir',
+        });
+      }
+      if (name === 'run_background_many') {
+        const rawList = Array.isArray(args.tasks) ? args.tasks : [];
+        const tasks = rawList
+          .map((t) => ({ title: String((t && t.title) || ''), task: String((t && t.task) || t || '') }))
+          .filter((t) => t.task.trim());
+        const r = tasks.length
+          ? this.runBackgroundMany(sessionId, tasks, String(args.title || ''))
+          : { ok: false, error: 'tasks boş' };
+        return JSON.stringify({
+          ...r,
+          note: 'fan-out başladı — eşzamanlılık kuyruğuna girer; hepsi bitince TEK birleşik rapor gelir',
+        });
+      }
+      if (name === 'tasks_list') {
+        const jobs = this.listBgJobs();
+        return JSON.stringify({ ok: true, jobs });
+      }
+      if (name === 'task_status') {
+        return JSON.stringify(this.bgDetail(String(args.id || args.code || '')));
+      }
+      if (name === 'task_cancel') {
+        const id = String(args.id || '');
+        const ok = this.interrupt(id);
+        return JSON.stringify(ok ? { ok: true, id } : { ok: false, error: 'çalışan ajan yok: ' + id });
+      }
+      if (name === 'set_reminder') {
+        if (!this.reminders || typeof this.reminders.add !== 'function') {
+          return JSON.stringify({ ok: false, error: 'hatırlatıcı kullanılamıyor' });
+        }
+        const r = await this.reminders.add({
+          when: args.when,
+          message: args.message,
+          repeat: args.repeat,
+          sessionId,
+        });
+        return JSON.stringify(r);
+      }
+      if (name === 'watcher_add' || name === 'watcher_list' || name === 'watcher_remove') {
+        if (!this.watchers) {
+          return JSON.stringify({ ok: false, error: 'izleyici servisi kullanılamıyor' });
+        }
+        if (name === 'watcher_list') {
+          const rows = this.watchers.list().map((w) => ({
+            id: w.id,
+            name: w.name,
+            kind: w.kind,
+            url: w.url || undefined,
+            op: w.op,
+            value: w.value,
+            everyMin: w.everyMin,
+            enabled: w.enabled,
+            lastValue: w.lastValue,
+            lastError: w.lastError || undefined,
+          }));
+          return JSON.stringify({ ok: true, watchers: rows });
+        }
+        if (name === 'watcher_add') {
+          return JSON.stringify(this.watchers.add({ ...(args || {}), sessionId }));
+        }
+        return JSON.stringify(this.watchers.remove(String((args && args.id) || '')));
+      }
+      if (name === 'kb_add' || name === 'kb_search') {
+        const kb = require('./kb');
+        if (name === 'kb_add') {
+          return JSON.stringify(
+            kb.add(String(args.title || ''), String(args.text || ''), {
+              source: args.source || `oturum:${sessionId}`,
+              tags: args.tags,
+            })
+          );
+        }
+        const rows = kb.search(String(args.query || ''), clamp(Number(args.limit) || 5, 1, 10));
+        return JSON.stringify({
+          ok: true,
+          query: String(args.query || ''),
+          results: rows,
+          note: rows.length ? 'kaynakları (citation) cevabında aynen belirt' : 'eşleşme yok',
+        });
+      }
+      if (name === 'memory_hygiene') {
+        const r = memory.hygiene({ maxAgeDays: Number(args.maxAgeDays) || undefined });
+        return JSON.stringify(r);
+      }
+      if (name === 'event_subscribe' || name === 'event_list' || name === 'event_unsubscribe') {
+        if (!this.bus) {
+          return JSON.stringify({ ok: false, error: 'olay merkezi kapalı — Ayarlar > Entegrasyonlar' });
+        }
+        if (name === 'event_list') {
+          const rows = this.bus.listSubs().filter((s) => s.sessionId === sessionId);
+          return JSON.stringify({ ok: true, subscriptions: rows });
+        }
+        if (name === 'event_subscribe') {
+          const r = this.bus.addSub({
+            type: args && args.type,
+            sessionId,
+            op: args && args.op,
+            value: args && args.value,
+            cooldownMin: args && args.cooldownMin,
+          });
+          if (r.ok) {
+            emitSafe(this, sessionId, { type: 'status', status: `olay aboneliği: ${args.type}` });
+          }
+          return JSON.stringify(r);
+        }
+        return JSON.stringify(this.bus.removeSub(String((args && args.id) || '')));
+      }
+      if (name === 'email_list' || name === 'email_read' || name === 'email_send') {
+        if (!this.email || typeof this.email[name === 'email_list' ? 'list' : name === 'email_read' ? 'read' : 'send'] !== 'function') {
+          return JSON.stringify({ ok: false, error: 'e-posta kullanılamıyor — Entegrasyonlar\u0027da ayarla' });
+        }
+        if (name === 'email_list') return JSON.stringify(await this.email.list(args || {}));
+        if (name === 'email_read') return JSON.stringify(await this.email.read(args || {}));
+        return JSON.stringify(await this.email.send(args || {}));
+      }
+      if (name === 'computer_look') {
+        if (!this.computer || typeof this.computer.look !== 'function') {
+          return JSON.stringify({ ok: false, error: 'ekran erişimi yok' });
+        }
+        emitSafe(this, sessionId, { type: 'status', status: 'ekrana bakıyor' });
+        const shot = await this.computer.look();
+        if (!shot) return JSON.stringify({ ok: false, error: 'ekran görüntüsü alınamadı' });
+        /* görsel sonraki tura vision mesajı olarak enjekte edilir */
+        return JSON.stringify({
+          ok: true,
+          note: 'ekran görüntüsü alındı — görsel aşağıda; koordinatlar 1280x720 tabanlı',
+          __injectImage: shot,
+        });
+      }
+      if (name === 'computer_act') {
+        if (!this.computer || typeof this.computer.act !== 'function') {
+          return JSON.stringify({ ok: false, error: 'fare/klavye erişimi yok' });
+        }
+        const op = String(args.op || '');
+        /* type ve key güvenlik: RISKY davranır ama onay kapısı kapalı; hız sınırı module içinde */
+        emitSafe(this, sessionId, { type: 'status', status: `bilgisayar: ${op}` });
+        const r = await this.computer.act(op, args || {});
+        return JSON.stringify(r);
+      }
+      if (name === 'web_search') {
+        /* SIRA: 0) TinyFish (anahtar girildiyse ZİRVEDE)
+                 1) dahili tarayıcı (gerçek Chromium ile DİREK GOOGLE — bot koruması yok)
+                 2) python çoklu-motor (ddgs / DDG+Bing+Mojeek)
+                 3) Exa (anahtar girildiyse, son çare) */        const q = String((args && args.query) || '');
+        let r = null;
+        try { r = await tools.tinyfishSearch(q, Number((args && args.max_results) || 8), signal); } catch {}
+        if (!r || !r.ok || !(r.results || []).length) {
+          if (this.browser && typeof this.browser.search === 'function') {
+            try { r = await this.browser.search(q, signal); } catch {}
+          }
+        }
+        if (!r || !r.ok || !(r.results || []).length) {
+          try {
+            r = JSON.parse(await tools.exec('web_search', args, { cwd: this.workspace, signal }));
+          } catch {}
+        }
+        return JSON.stringify(r || { ok: false, error: 'web arama başarısız — tüm motorlar boş döndü' });
+      }
+      if (name === 'ocr_read') {
+        return JSON.stringify(await this._ocrRead(args || {}, signal));
+      }
+      if (name === 'browser_open') {
+        if (!this.browser || typeof this.browser.openUrl !== 'function') {
+          return JSON.stringify({ ok: false, error: 'dahili tarayıcı kullanılamıyor' });
+        }
+        const r = await this.browser.openUrl(String(args.url || ''), signal);
+        return JSON.stringify(r);
+      }
+      if (name === 'browser_read') {
+        if (!this.browser || typeof this.browser.readText !== 'function') {
+          return JSON.stringify({ ok: false, error: 'dahili tarayıcı kullanılamıyor' });
+        }
+        const r = await this.browser.readText(signal);
+        return JSON.stringify(r);
+      }
+      if (name === 'browser_screenshot') {
+        if (!this.browser || typeof this.browser.screenshot !== 'function') {
+          return JSON.stringify({ ok: false, error: 'dahili tarayıcı kullanılamıyor' });
+        }
+        const r = await this.browser.screenshot(signal);
+        return JSON.stringify(r);
+      }
+      if (name === 'browser_snapshot') {
+        if (!this.browser || typeof this.browser.snapshot !== 'function') {
+          return JSON.stringify({ ok: false, error: 'dahili tarayıcı kullanılamıyor' });
+        }
+        const r = await this.browser.snapshot(signal);
+        return JSON.stringify(r);
+      }
+      if (name === 'browser_click' || name === 'browser_type' || name === 'browser_press' || name === 'browser_scroll' || name === 'browser_select') {
+        if (!this.browser || typeof this.browser.act !== 'function') {
+          return JSON.stringify({ ok: false, error: 'dahili tarayıcı kullanılamıyor' });
+        }
+        const r = await this.browser.act(name.slice(8), args, signal);
+        return JSON.stringify(r);
+      }
+      if (!(name === 'run_command' || name === 'read_file' || name === 'write_file' || name === 'list_dir' ||
+            name === 'web_search' || name === 'http_fetch' || name === 'python_run')) {
+        return JSON.stringify({ ok: false, error: `unknown tool ${name}` });
+      }
+      return await tools.exec(name, args, { cwd: this.workspace, signal });
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: String((e && e.message) || e) });
+    }
+  }
+
+  interrupt(sessionId) {
+    const c = this.ctrls.get(String(sessionId));
+    if (!c) return false;
+    c.abort();
+    return true;
+  }
+
+  /* /stop anahtarı: koşan HER ŞEYİ kes — tüm oturum turları (masaüstü + WA +
+     paralel ajanlar) ve bekleyen rapor kuyruğu. Cron/izleyici/olay merkezi
+     main katmanında BAĞIMSIZ yaşar — /stop onlara dokunmaz. */
+  stopAll() {
+    let aborted = 0;
+    /* fan-out gruplarını kapat — yarım grup artık birleşik rapor beklemesin */
+    if (this._bgGroups) {
+      for (const g of this._bgGroups.values()) g.dead = true;
+    }
+    if (this._bgPendingStart) this._bgPendingStart.clear();
+    for (const [sid, c] of this.ctrls) {
+      try { c.abort(); aborted++; } catch {}
+      /* abort sonrası _run finally bloğu temizler; paralel ajan kaydını biz işaretleyelim */
+      if (this._bgJobs.has(sid)) {
+        const job = this._bgJobs.get(sid);
+        if (job.status === 'running' || job.status === 'queued') {
+          job.status = 'aborted';
+          job.endedAt = nowIso();
+        }
+        job.revive = false; // bekleyen öz-kurtarma gönderimini de öldür
+        this._clearKicks(sid);
+      }
+    }
+    /* kuyrukta bekleyenleri de kes */
+    for (const j of this._bgJobs.values()) {
+      if (j.status === 'queued') {
+        j.status = 'aborted';
+        j.endedAt = nowIso();
+        aborted++;
+      }
+    }
+    if (this._pendingReports && this._pendingReports.length) {
+      this._pendingReports = [];
+    }
+    this._bgEmit();
+    return aborted;
+  }
+
+  isBusy(sessionId) {
+    return this.ctrls.has(String(sessionId));
+  }
+}
+
+function emitSafe(engine, sessionId, ev) {
+  engine.emit({ ...ev, sessionId });
+}
+
+const TOOLS = [
+  ...tools.definitions,
+  {
+    type: 'function',
+    function: {
+      name: 'memory_write',
+      description:
+        'Append one permanent fact/preference/correction to long-term memory. Use for important user info worth remembering in future chats.',
+      parameters: {
+        type: 'object',
+        properties: {
+          text: { type: 'string', description: 'One concise line to remember forever' },
+        },
+        required: ['text'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'memory_search',
+      description:
+        'Search long-term memory by keywords. Use when you suspect an old stored fact/preference is relevant but was not included in context.',
+      parameters: {
+        type: 'object',
+        properties: {
+          query: { type: 'string' },
+          limit: { type: 'number', description: 'default 5' },
+        },
+        required: ['query'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'todo_write',
+      description:
+        'Replace the visible task checklist for this chat. Use ONLY for multi-step work (3+ steps); do not use for simple questions. Keep titles short; update statuses as you progress; clear the list when done.',
+      parameters: {
+        type: 'object',
+        properties: {
+          items: {
+            type: 'array',
+            maxItems: 20,
+            items: {
+              type: 'object',
+              properties: {
+                title: { type: 'string' },
+                status: { type: 'string', enum: ['pending', 'active', 'done'] },
+              },
+              required: ['title'],
+            },
+          },
+        },
+        required: ['items'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'delegate_task',
+      description:
+        'Spawn a fresh sub-agent that independently works on ONE self-contained sub-task (with the same tools except delegation) and returns only its final answer. Use for heavy/isolated research or multi-file jobs you want kept off the main context.',
+      parameters: {
+        type: 'object',
+        properties: {
+          task: { type: 'string', description: 'Clear, self-contained instructions for the sub-agent' },
+          context: { type: 'string', description: 'Optional data/notes the sub-agent needs' },
+        },
+        required: ['task'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'set_reminder',
+      description:
+        'Schedule a reminder for the user. Without repeat: one-time at the given date+time (compute exact local datetime from ORTAM). With repeat: recurring task — time-of-day comes from `when` and it fires forever at that cadence ("her sabah 09:00" => when=<next 09:00>, repeat=daily). Delivered back to this chat.',
+      parameters: {
+        type: 'object',
+        properties: {
+          when: {
+            type: 'string',
+            description:
+              'Local datetime, format YYYY-MM-DDTHH:mm (24h), e.g. 2026-08-27T09:00. For recurring reminders this fixes the hour/minute (and weekday/day-of-month).',
+          },
+          message: { type: 'string', description: 'What to remind, short and clear' },
+          repeat: {
+            type: 'string',
+            description:
+              "Omit for one-time. Recurring presets: 'daily' | 'weekdays' | 'weekly' | 'monthly'; or a raw 5-field cron expression like '0 9 * * *' or '*/30 * * * *'.",
+          },
+        },
+        required: ['when', 'message'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'watcher_add',
+      description:
+        'Create a background watcher that periodically checks something and notifies THIS chat when a condition becomes true (edge-triggered: fires once per crossing; cooldown limits repeats). Use for price alarms ("X altına düşerse haber ver"), battery levels, page change detection.',
+      parameters: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', description: 'Short label, e.g. "GOLD 2300 alarmı"' },
+          kind: { type: 'string', enum: ['web', 'battery'], description: 'web: fetch URL and extract value; battery: local battery percent' },
+          url: { type: 'string', description: 'http(s) URL to poll (kind=web, required)' },
+          path: {
+            type: 'string',
+            description:
+              "If response is JSON: dot-path to watched value, e.g. 'price.usd' or 'data.0.close' (recommended over re)",
+          },
+          re: { type: 'string', description: 'If response is HTML/text: regex; first capture group becomes the value' },
+          op: {
+            type: 'string',
+            enum: ['lt', 'lte', 'gt', 'gte', 'eq', 'neq', 'changed'],
+            description: "Comparison vs value. Use 'changed' with no value for page-change alerts.",
+          },
+          value: { type: 'number', description: 'Threshold for numeric ops (not needed for changed)' },
+          everyMin: { type: 'number', description: 'Check interval in minutes (default 15, min 1, max 1440)' },
+          everySec: { type: 'number', description: 'Check interval in SECONDS (10-8640) — overrides everyMin for fast watchers (e.g. 30 = every 30s)' },
+          cooldownMin: { type: 'number', description: 'Min minutes between notifications (default 60)' },
+        },
+        required: ['name', 'kind'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'watcher_list',
+      description: 'List configured background watchers with their last values and errors.',
+      parameters: { type: 'object', properties: {} },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'watcher_remove',
+      description: 'Delete a background watcher by its id (from watcher_list).',
+      parameters: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'kb_add',
+      description:
+        'Store a durable piece of knowledge (learned fact, procedure, domain insight) into the knowledge base for future sessions. Do NOT store transient chat details. Always set source (where this came from).',
+      parameters: {
+        type: 'object',
+        properties: {
+          title: { type: 'string', description: 'Short title, e.g. "FxPro GOLD seans saatleri"' },
+          text: { type: 'string', description: 'The knowledge itself, self-contained, max ~2000 chars.' },
+          source: { type: 'string', description: 'Origin: url, file path, or conversation.' },
+          tags: { type: 'array', items: { type: 'string' }, description: 'Up to 8 short tags.' },
+        },
+        required: ['title', 'text'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'kb_search',
+      description:
+        'Search the knowledge base with TF-IDF ranking. Results come with citations — quote them verbatim when you use a result.',
+      parameters: {
+        type: 'object',
+        properties: {
+          query: { type: 'string' },
+          limit: { type: 'number', description: 'default 5, max 10' },
+        },
+        required: ['query'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'memory_hygiene',
+      description:
+        'Run memory cleanup: dedupe near-identical MEMORY.md entries and drop very old ones. Run it when the user asks to clean memory, or after many memory_write calls in one session.',
+      parameters: {
+        type: 'object',
+        properties: {
+          maxAgeDays: { type: 'number', description: 'Age cutoff in days (default 120).' },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'event_subscribe',
+      description:
+        'Subscribe this chat to a live event source (no polling/cron needed). Types: mail:new (incoming email), price:tick (price feed with optional op/value filter e.g. alert when gold-pegged PAXG drops below 2600), fs:changed (workspace file changes), webhook (custom POST events), wa:presence. Notifies THIS chat when the event fires; cooldownMin limits repeats.',
+      parameters: {
+        type: 'object',
+        properties: {
+          type: {
+            type: 'string',
+            enum: ['mail:new', 'price:tick', 'fs:changed', 'webhook', 'wa:presence'],
+            description: 'Event source to subscribe to.',
+          },
+          op: { type: 'string', enum: ['lt', 'lte', 'gt', 'gte', 'eq'], description: 'Optional numeric filter on event value (mainly price:tick).' },
+          value: { type: 'number', description: 'Threshold for the numeric filter.' },
+          cooldownMin: { type: 'number', description: 'Minimum minutes between notifications (default 10).' },
+        },
+        required: ['type'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'event_list',
+      description: 'List this chat\u2019s active event subscriptions.',
+      parameters: { type: 'object', properties: {} },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'event_unsubscribe',
+      description: 'Cancel an event subscription by its id (from event_list).',
+      parameters: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_background',
+      description:
+        'Spawn a PARALLEL background agent for a self-contained subtask (e.g. "read this terminal output", "research X", "monitor and summarize"). The main chat is NOT blocked; multiple agents can run at once; when each finishes, its summary report is delivered to this chat automatically. In CEO mode EVERY concrete task goes through here — you never execute work yourself. Keep research SHALLOW: 3-5 sources, ~3 minutes target; if info cannot be found after 2-3 attempts, finish with partial findings and clearly state what was not found — never get stuck.',
+      parameters: {
+        type: 'object',
+        properties: {
+          task: { type: 'string', description: 'Self-contained task description with ALL needed context (paths, URLs, constraints, expected output) — the agent cannot see your context.' },
+          title: { type: 'string', description: 'Short label shown in the agents tab and notification.' },
+        },
+        required: ['task'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'tasks_list',
+      description:
+        'List parallel background agents with status (queued/running/done/error/aborted), titles and timings. Use to report overall progress.',
+      parameters: { type: 'object', properties: {} },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_background_many',
+      description:
+        "Fan-out: spawn MULTIPLE parallel background agents at once for different steps of the SAME job (e.g. news collection → TR / World / Economy agents in parallel; or research A + scrape B + analyze C). They run concurrently; when ALL finish you get ONE merged report instead of N separate pings. Each task must be self-contained. Use this over repeated run_background when steps are independent.",
+      parameters: {
+        type: 'object',
+        properties: {
+          title: { type: 'string', description: 'Group label (e.g. "Haber Taraması")' },
+          tasks: {
+            type: 'array',
+            description: '2-6 independent sub-tasks',
+            items: {
+              type: 'object',
+              properties: {
+                title: { type: 'string', description: 'Short label of this step' },
+                task: { type: 'string', description: 'Self-contained instruction with all context' },
+              },
+              required: ['task'],
+            },
+          },
+        },
+        required: ['tasks'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'task_status',
+      description:
+        'Get one background agent\u2019s live detail by id/code: current status plus a tail of its working transcript. Use when the user asks what an agent found or whether it finished.',
+      parameters: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', description: 'job id or session code from tasks_list' },
+        },
+        required: ['id'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'send_file',
+      description:
+        "Deliver a local file to the user in THIS chat (desktop shows a file card; if this session is a WhatsApp chat the file is sent there as image/document). Use when the user asks for a produced report/PDF/image/export, e.g. 'raporu bana gönder', 'grafik dosyasını at'. path = absolute or workspace-relative.",
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path (absolute or relative to workspace)' },
+          caption: { type: 'string', description: 'Optional short caption' },
+        },
+        required: ['path'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'task_cancel',
+      description: 'Cancel a running background agent by id (from tasks_list).',
+      parameters: {
+        type: 'object',
+        properties: {
+          id: { type: 'string' },
+        },
+        required: ['id'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'computer_look',
+      description:
+        'Take a screenshot of the user\u2019s screen and receive it as an image. Use before computer_act to see the GUI; coordinates are on a 1280x720 basis.',
+      parameters: { type: 'object', properties: {} },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'computer_act',
+      description:
+        'Control mouse/keyboard on the user\u2019s Windows desktop (GUI automation). Ops: click{x,y}, dblclick{x,y}, rightclick{x,y}, move{x,y}, type{text}, key{combo e.g. "ctrl+s","enter","alt+tab"}, scroll{x,y,dy}. Look first with computer_look, act step by step, look again after acting.',
+      parameters: {
+        type: 'object',
+        properties: {
+          op: {
+            type: 'string',
+            enum: ['click', 'dblclick', 'rightclick', 'move', 'type', 'key', 'scroll'],
+          },
+          x: { type: 'number' },
+          y: { type: 'number' },
+          text: { type: 'string', description: 'for op=type (max 2000 chars)' },
+          combo: { type: 'string', description: 'for op=key: "enter", "ctrl+s", "alt+tab", "win"' },
+          dy: { type: 'number', description: 'for op=scroll: positive = down (-10..10)' },
+        },
+        required: ['op'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'email_list',
+      description:
+        'List recent emails from the configured inbox (newest first). Use when the user asks about incoming mail / inbox summary. Returns uid, from, subject, date.',
+      parameters: {
+        type: 'object',
+        properties: {
+          limit: { type: 'number', description: 'default 10, max 30' },
+          unread: { type: 'boolean', description: 'only unseen mails' },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'email_read',
+      description: 'Read one email\u0027s full body text by its uid (from email_list).',
+      parameters: {
+        type: 'object',
+        properties: {
+          uid: { type: 'number' },
+        },
+        required: ['uid'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'email_send',
+      description: 'Send an email from the configured account.',
+      parameters: {
+        type: 'object',
+        properties: {
+          to: { type: 'string', description: 'recipient address' },
+          subject: { type: 'string' },
+          body: { type: 'string', description: 'plain text body' },
+        },
+        required: ['to', 'subject', 'body'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'browser_open',
+      description:
+        'Open a URL in the built-in visible browser panel (JS-rendered pages work). Use for pages that need JavaScript or when showing the user a page is useful; prefer http_fetch for plain reading.',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string' },
+        },
+        required: ['url'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'browser_read',
+      description:
+        'Read the visible text of the page currently open in the built-in browser panel.',
+      parameters: { type: 'object', properties: {}, required: [] },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'browser_screenshot',
+      description:
+        'Take a screenshot of the built-in browser panel; the image is shown to you on the next step. Use to visually inspect layouts/charts/captchas-ish pages before acting.',
+      parameters: { type: 'object', properties: {}, required: [] },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'browser_snapshot',
+      description:
+        'List all interactive elements of the built-in browser page as numbered refs: [3] <button> "Gönder". ALWAYS start with this; then act using ref numbers. Much more reliable than CSS selectors.',
+      parameters: { type: 'object', properties: {}, required: [] },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'ocr_read',
+      description:
+        'Built-in OCR (Tesseract) — extract TEXT from an image. Essential for text-only models that cannot see images: instead of browser_screenshot, call this with source="browser" to READ the current built-in browser page (captchas, canvas text, images). source: "browser" (default, current browser page) | "screen" (full desktop) | image file path. lang default "tur+eng". Returns {text}.',
+      parameters: {
+        type: 'object',
+        properties: {
+          source: { type: 'string', description: '"browser" (default) | "screen" | image file path' },
+          lang: { type: 'string', description: 'OCR language, default "tur+eng"' },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'browser_click',
+      description:
+        'Click an element in the built-in browser. Prefer ref from browser_snapshot (e.g. {"ref":3}); CSS selector or text=X also accepted.',
+      parameters: {
+        type: 'object',
+        properties: {
+          ref: { type: 'number', description: 'element number from browser_snapshot' },
+          selector: { type: 'string', description: 'CSS selector or text=X alternative' },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'browser_type',
+      description:
+        'Type text into an input/textarea/contenteditable in the built-in browser (prefer ref). Set submit=true to press Enter afterwards.',
+      parameters: {
+        type: 'object',
+        properties: {
+          ref: { type: 'number' },
+          selector: { type: 'string' },
+          text: { type: 'string' },
+          submit: { type: 'boolean' },
+        },
+        required: ['text'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'browser_press',
+      description:
+        'Press a key (Enter, Tab, Escape, ArrowDown…) on the focused element in the built-in browser; optionally focus a ref first.',
+      parameters: {
+        type: 'object',
+        properties: {
+          key: { type: 'string' },
+          ref: { type: 'number', description: 'optional element to focus first' },
+        },
+        required: ['key'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'browser_scroll',
+      description: 'Scroll the built-in browser page. direction: up | down.',
+      parameters: {
+        type: 'object',
+        properties: {
+          direction: { type: 'string', enum: ['up', 'down'] },
+          amount: { type: 'number', description: 'pixels, default ~0.9x viewport' },
+        },
+        required: ['direction'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'browser_select',
+      description:
+        'Pick an <option> of a dropdown (<select>) in the built-in browser by value/text (prefer ref).',
+      parameters: {
+        type: 'object',
+        properties: {
+          ref: { type: 'number' },
+          selector: { type: 'string' },
+          value: { type: 'string' },
+        },
+        required: ['value'],
+      },
+    },
+  },
+];
+
+module.exports = Engine;
+module.exports.Engine = Engine;
+module.exports.sanitizeTodoItems = sanitizeTodoItems;
+module.exports.parseReflectionJson = parseReflectionJson;
+module.exports.CEO_EXEC_TOOLS = CEO_EXEC_TOOLS;
+module.exports.BG_HIDDEN_TOOLS = BG_HIDDEN_TOOLS;