beast-agent 2.3.3 → 2.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "beast-agent",
     "productName": "Beast Agent",
-    "version": "2.3.3",
+    "version": "2.4.0",
     "description": "Ultra-fast local agent shell for Windows.",
     "author": "algokodcom (AlgoKod)",
     "license": "MIT",

package/src/agent/mem0.js

@@ -101,11 +101,16 @@ function loadPipeline() {
   _pipeLoading = (async () => {
     try {
       const { pipeline, env } = require('@xenova/transformers');
+      const bus = require('./progressbus');
       const modelsDir = process.env.BEAST_MODELS_DIR || path.join(beastRoot(), 'models');
       fs.mkdirSync(modelsDir, { recursive: true });
       env.cacheDir = modelsDir;
       env.allowLocalModels = false;
-      const p = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2', { quantized: true });
+      const p = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2', {
+        quantized: true,
+        progress_callback: bus.fileProgressAggregator('emb'),
+      });
+      bus.emitInstallProgress('emb', { pct: 100 });
       _pipe = async (texts) => {
         const out = [];
         for (const t of texts) {

package/src/agent/perception.js

@@ -0,0 +1,447 @@
+'use strict';
+
+/* Empati Loop — proaktif algı/event alt sistemi (ana sohbet motorundan bağımsız).
+   Boru hattı: SİNYAL → NORMALİZE → DEDUP → UCUZ FİLTRE (LLM) → ÖNCELİK → KUYRUK
+   Bu modül saf mantık + olay deposudur; LLM çağrıları (llmFilter) ve sinyal
+   toplayıcıları (signals) main.js tarafından enjekte edilir.
+   İlke: her sinyal event olmaz, her event büyük modele gitmez, her event
+   kullanıcıya bildirilmez. Depo: %APPDATA%\beast\perception\events.json */
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { beastRoot } = require('./memory');
+
+const DEFAULTS = {
+  enabled: false,
+  intervalMin: 15,        // tarama aralığı (3-1440 dk)
+  cooldownMin: 30,        // aynı konu için sessizlik (0-10080 dk)
+  minNotifyPriority: 60,  // bu kompozit puanın altı yalnız depoya yazılır (0-100)
+  maxNotifyPerCycle: 1,   // döngü başına en fazla bildirim (maliyet freni)
+  notifyTarget: '',       // bildirim hedefi: '' = bağlı entegrasyonlar | whatsapp | telegram | discord
+  filterModel: '',        // ucuz filtre modeli ('provider::model'); boşsa ana model
+  interests: '',          // kullanıcı ilgi alanları (relevance ağırlığı)
+  newsTopics: '',         // Google News RSS sorguları (virgülle)
+  weights: { importance: 0.40, relevance: 0.25, urgency: 0.20, novelty: 0.15 },
+};
+
+const EVENT_CAP = 250;    // depo tavanı — eskiler düşer
+const SEEN_CAP = 800;     // dedup parmakizi havuzu
+const SEEN_TTL = 6 * 3600 * 1000; // aynı olay 6 saat içinde tekrar gelirse yut
+const FILTER_MAX = 12;    // tek filtre çağrısında en fazla olay
+const NEWS_MAX = 12;      // konu başına en fazla haber adayı
+
+/* ---------- config ---------- */
+
+function clampW(v, d) {
+  const n = Number(v);
+  return Number.isFinite(n) && n > 0 && n < 1 ? n : d;
+}
+
+function mergeCfg(raw) {
+  const r = raw || {};
+  const num = (v, min, max, d) => {
+    const n = Math.round(Number(v));
+    return Number.isFinite(n) ? Math.min(max, Math.max(min, n)) : d;
+  };
+  const w = r.weights || {};
+  return {
+    enabled: r.enabled === true,
+    intervalMin: num(r.intervalMin, 3, 1440, DEFAULTS.intervalMin),
+    cooldownMin: num(r.cooldownMin, 0, 10080, DEFAULTS.cooldownMin),
+    minNotifyPriority: num(r.minNotifyPriority, 0, 100, DEFAULTS.minNotifyPriority),
+    maxNotifyPerCycle: num(r.maxNotifyPerCycle, 1, 5, DEFAULTS.maxNotifyPerCycle),
+    notifyTarget: ['whatsapp', 'telegram', 'discord'].includes(String(r.notifyTarget || ''))
+      ? String(r.notifyTarget)
+      : '',
+    filterModel: String(r.filterModel || '').trim(),
+    interests: String(r.interests || '').slice(0, 400),
+    newsTopics: String(r.newsTopics || '').slice(0, 400),
+    weights: {
+      importance: clampW(w.importance, DEFAULTS.weights.importance),
+      relevance: clampW(w.relevance, DEFAULTS.weights.relevance),
+      urgency: clampW(w.urgency, DEFAULTS.weights.urgency),
+      novelty: clampW(w.novelty, DEFAULTS.weights.novelty),
+    },
+  };
+}
+
+/* ---------- depo ---------- */
+
+function stateFile() {
+  return path.join(beastRoot(), 'perception', 'events.json');
+}
+
+function loadState() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(stateFile(), 'utf8'));
+    return {
+      events: Array.isArray(raw.events) ? raw.events : [],
+      seen: raw.seen && typeof raw.seen === 'object' ? raw.seen : {},
+      cooldowns: raw.cooldowns && typeof raw.cooldowns === 'object' ? raw.cooldowns : {},
+      lastRunAt: raw.lastRunAt || null,
+    };
+  } catch {
+    return { events: [], seen: {}, cooldowns: {}, lastRunAt: null };
+  }
+}
+
+function saveState(st) {
+  try {
+    fs.mkdirSync(path.dirname(stateFile()), { recursive: true });
+    fs.writeFileSync(stateFile(), JSON.stringify(st, null, 2));
+  } catch {}
+}
+
+/* ---------- normalize / dedup ---------- */
+
+function normTitle(t) {
+  const base = String(t || '')
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s]/gu, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return base.split(' ').slice(0, 12).join(' ');
+}
+
+function fingerprint(type, title) {
+  return crypto.createHash('sha1').update(normTitle(type + '|' + title)).digest('hex').slice(0, 14);
+}
+
+/* cooldown anahtarı: konunun ilk 5 kelimesi — varyasyonlar aynı kovaya düşer */
+function topicKey(type, title) {
+  return normTitle(type + ' ' + title).split(' ').slice(0, 5).join(' ');
+}
+
+function uid() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+}
+
+function normalizeRaw(item) {
+  const title = String((item && item.title) || '').replace(/\s+/g, ' ').trim().slice(0, 300);
+  if (!title) return null;
+  const type = String((item && item.type) || 'news').slice(0, 24);
+  return {
+    id: uid(),
+    ts: item.ts || new Date().toISOString(),
+    source: String((item && item.source) || type).slice(0, 40),
+    type,
+    title,
+    detail: String((item && item.detail) || '').slice(0, 300),
+    sources: [(item && item.source) || type],
+    scores: {},
+    priority: 0,
+    reason: '',
+    status: 'new',
+    level: '',
+    text: '',
+    notifiedAt: null,
+  };
+}
+
+/* ---------- haber kaynağı (Google News RSS — anahtar gerektirmez,
+   Reuters/BBC/AP gibi kaynakları zaten tek beslemede harmanlar) ---------- */
+
+async function fetchNews(topics) {
+  const out = [];
+  for (const q of (topics || []).slice(0, 4)) {
+    try {
+      const url = 'https://news.google.com/rss/search?q=' + encodeURIComponent(q) + '&hl=tr&gl=TR&ceid=TR:tr';
+      const res = await fetch(url, { signal: AbortSignal.timeout(12000) });
+      if (!res.ok) continue;
+      const xml = await res.text();
+      const re = /<item>[\s\S]*?<\/item>/g;
+      let m;
+      let count = 0;
+      while ((m = re.exec(xml)) && count < NEWS_MAX) {
+        const t = /<title>(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?<\/title>/.exec(m[0]);
+        const title = t ? String(t[1]).replace(/\s+/g, ' ').trim() : '';
+        if (!title) continue;
+        count++;
+        out.push({ type: 'news', title, detail: 'Google News · ' + q, source: 'news:' + q });
+      }
+    } catch {}
+  }
+  return out;
+}
+
+/* ---------- ucuz deterministik puanlayıcı (LLM yoksa/çökerse fallback) ---------- */
+
+const URGENT_RE = /acil|critical|son dakika|outage|arıza|crash|down|kesinti|kapatıldı|breach|güvenlik|saldırı|risk/i;
+
+function heuristicScores(ev, cfg) {
+  const t = normTitle(ev.title);
+  const URGENT = URGENT_RE.test(t);
+  let importance = ev.type === 'news' ? 40 : 65;
+  if (URGENT) importance += 20;
+  const words = String(cfg.interests || '').toLowerCase().split(/[,\s]+/).filter((w) => w.length > 2);
+  let hits = 0;
+  for (const w of words) if (t.includes(w)) hits++;
+  const relevance = hits ? Math.min(100, 55 + hits * 15) : (ev.type === 'news' ? 30 : 60);
+  const urgency = URGENT ? 75 : (ev.type === 'news' ? 35 : 45);
+  const novelty = ev.type === 'news' ? 80 : 60;
+  return { importance, relevance, urgency, novelty };
+}
+
+function compositePriority(scores, cfg) {
+  const w = cfg.weights;
+  const s = (x) => Math.max(0, Math.min(100, Number(x) || 0));
+  const sum = w.importance + w.relevance + w.urgency + w.novelty || 1;
+  return Math.round(
+    (s(scores.importance) * w.importance +
+      s(scores.relevance) * w.relevance +
+      s(scores.urgency) * w.urgency +
+      s(scores.novelty) * w.novelty) / sum
+  );
+}
+
+/* ---------- LLM filtre promptu / ayrıştırıcı ---------- */
+
+const FILTER_SYSTEM =
+  'Sen bir bilgi filtresisin; sohbet etmezsin. Sana verilen olayları değerlendirip YALNIZCA JSON döndürürsün. ' +
+  'Skorlar 0-100 arası tamsayı. "relevant": kullanıcının ilgi alanlarıyla alakalı mı. ' +
+  '"notify": kullanıcıya bildirmeye gerçekten değer mi (önemsiz/spam/klasik haberlerde false). ' +
+  '"reason": en fazla 60 karakter kısa gerekçe.';
+
+function filterPrompt(events, interests) {
+  const list = events.map((e) => ({
+    id: e.id,
+    type: e.type,
+    title: e.title,
+    detail: e.detail,
+  }));
+  return (
+    'KULLANICI İLGİLERİ: ' + (String(interests || '').trim() || '(belirtilmemiş)') + '\n' +
+    'OLAYLAR:\n' + JSON.stringify(list) + '\n\n' +
+    'Her olay için {"id","relevant","importance","urgency","novelty","notify","reason"} içeren ' +
+    'TEK bir JSON dizisi döndür. Sadece JSON, başka metin yok.'
+  );
+}
+
+function parseFilterJson(text) {
+  try {
+    let s = String(text || '').replace(/```(?:json)?/gi, '');
+    const a = s.indexOf('[');
+    const b = s.lastIndexOf(']');
+    if (a < 0 || b <= a) return [];
+    const arr = JSON.parse(s.slice(a, b + 1));
+    if (!Array.isArray(arr)) return [];
+    const map = new Map();
+    for (const it of arr) {
+      if (it && it.id !== undefined) map.set(String(it.id).toLowerCase(), it);
+    }
+    return map;
+  } catch {
+    return [];
+  }
+}
+
+/* ---------- ana LLM compose promptu / fallback ---------- */
+
+const COMPOSE_SYSTEM =
+  'Beast adlı yerel yardımcı için proaktif bildirim metni yazarsın. Türkçe, samimi "kanka" tonunda, ' +
+  'EN FAZLA 2 kısa cümle: ne olduğunu soyutla, neden önemli olabileceğini söyle, istersen tek kısa soru sor. ' +
+  'Alarm spam\'i yok; başlık/emoji/Markdown ekleme, yalnız düz metin yaz.';
+
+function composePrompt(ev, cfg) {
+  return (
+    'OLAY: ' + ev.title + '\n' +
+    (ev.detail ? 'DETAY: ' + ev.detail + '\n' : '') +
+    'KAYNAK: ' + ev.source + '\n' +
+    'ÖNCELİK: ' + ev.priority + '/100 · ' + (ev.reason || '') + '\n' +
+    'KULLANICI İLGİLERİ: ' + (String((cfg && cfg.interests) || '').trim() || '(belirtilmemiş)') + '\n\n' +
+    'Bu olay için kullanıcıya gönderilecek proaktif kısa mesajı yaz.'
+  );
+}
+
+function composeFallback(ev) {
+  return ev.title + (ev.detail ? ' — ' + ev.detail : '');
+}
+
+/* ---------- döngü ---------- */
+
+/* signals: { self: async()=>[raw], news: async()=>[raw] } — her biri bağımsız;
+   biri çökerse diğerleri çalışmaya devam eder. llmFilter: async(prompt)=>text. */
+async function runCycle({ cfg, signals, llmFilter, now = new Date(), log = () => {} }) {
+  const t0 = Date.now();
+  log('cycle başladı');
+  const st = loadState();
+  const raws = [];
+  const srcStats = {};
+  for (const [name, fn] of Object.entries(signals || {})) {
+    if (typeof fn !== 'function') continue;
+    try {
+      const items = (await fn()) || [];
+      srcStats[name] = items.length;
+      for (const it of items) {
+        const ev = normalizeRaw(it);
+        if (ev) raws.push(ev);
+      }
+    } catch (e) {
+      srcStats[name] = 'hata: ' + String((e && e.message) || e).slice(0, 60);
+    }
+  }
+  log('sinyaller: ' + JSON.stringify(srcStats));
+
+  /* dedup: havuzda taze parmakizi varsa yut; toplu içinde tekrar varsa birleştir */
+  const pending = [];
+  let dups = 0;
+  for (const ev of raws) {
+    const fp = fingerprint(ev.type, ev.title);
+    const seenAt = st.seen[fp];
+    if (seenAt && now.getTime() - seenAt < SEEN_TTL) {
+      dups++;
+      continue;
+    }
+    st.seen[fp] = now.getTime();
+    const same = pending.find((p) => p._fp === fp);
+    if (same) {
+      if (!same.sources.includes(ev.source)) same.sources.push(ev.source);
+      dups++;
+      continue;
+    }
+    ev._fp = fp;
+    pending.push(ev);
+  }
+  /* parmakizi havuzu tavanı — en eskiyi düşür */
+  const seenKeys = Object.keys(st.seen);
+  if (seenKeys.length > SEEN_CAP) {
+    seenKeys.sort((a, b) => st.seen[a] - st.seen[b]);
+    for (const k of seenKeys.slice(0, seenKeys.length - SEEN_CAP)) delete st.seen[k];
+  }
+
+  /* UCUZ FİLTRE: tüm adaylar TEK toplu çağrıda (maliyet freni). Çökerse deterministik. */
+  let graded = null;
+  if (typeof llmFilter === 'function' && pending.length) {
+    try {
+      const out = await llmFilter(filterPrompt(pending.slice(0, FILTER_MAX), cfg.interests));
+      graded = parseFilterJson(out);
+      if (graded.size) log('filtre: LLM ' + graded.size + ' olayı puanladı');
+    } catch {
+      graded = null;
+    }
+  }
+  if (!graded || !graded.size) log('filtre: deterministik puanlama');
+
+  const counts = { ignored: 0, stored: 0, queued: 0, dup: dups, raw: raws.length };
+  const actions = [];
+  for (const ev of pending) {
+    const g = graded && graded.get(String(ev.id).toLowerCase());
+    ev.scores = g
+      ? {
+          importance: Math.max(0, Math.min(100, Math.round(Number(g.importance) || 0))),
+          relevance: Math.max(0, Math.min(100, Math.round(Number(g.relevance) || 0))),
+          urgency: Math.max(0, Math.min(100, Math.round(Number(g.urgency) || 0))),
+          novelty: Math.max(0, Math.min(100, Math.round(Number(g.novelty) || 0))),
+        }
+      : heuristicScores(ev, cfg);
+    ev.priority = compositePriority(ev.scores, cfg);
+    ev.reason = g ? String(g.reason || '').slice(0, 80) : 'deterministik puan';
+    if (g && g.notify === false && ev.priority < cfg.minNotifyPriority) {
+      ev.status = 'ignored';
+      counts.ignored++;
+    } else if (ev.priority < 30) {
+      ev.status = 'ignored';
+      counts.ignored++;
+    } else {
+      const key = topicKey(ev.type, ev.title);
+      const cd = st.cooldowns[key];
+      if (cd && now.getTime() < cd.until && ev.priority < (cd.lastPriority || 0) + 15) {
+        ev.status = 'stored';
+        ev.reason = (ev.reason || '') + ' · sessizlik penceresi';
+        counts.stored++;
+      } else if (ev.priority < cfg.minNotifyPriority) {
+        ev.status = 'stored';
+        counts.stored++;
+      } else {
+        ev.status = 'queued';
+        counts.queued++;
+        actions.push({
+          event: ev,
+          level: ev.priority >= 80 ? 'high' : 'medium',
+        });
+      }
+    }
+    st.events.push(ev);
+  }
+
+  /* kuyruğu önceliğe göre kes — döngü başına en fazla maxNotifyPerCycle bildirim */
+  actions.sort((a, b) => b.event.priority - a.event.priority);
+  const kept = actions.slice(0, cfg.maxNotifyPerCycle);
+  const dropped = actions.slice(cfg.maxNotifyPerCycle);
+  for (const a of dropped) {
+    a.event.status = 'stored';
+    a.event.reason += ' · kuyruk tavanı';
+    counts.stored++;
+  }
+  counts.queued = kept.length;
+
+  /* depo tavanı */
+  if (st.events.length > EVENT_CAP) st.events = st.events.slice(st.events.length - EVENT_CAP);
+
+  st.lastRunAt = now.toISOString();
+  saveState(st);
+  log(
+    'cycle tamam: raw=' + counts.raw + ' dup=' + dups +
+    ' ignored=' + counts.ignored + ' stored=' + counts.stored + ' queued=' + counts.queued +
+    ' (' + (Date.now() - t0) + 'ms)'
+  );
+  return { summary: counts, actions: kept };
+}
+
+function markNotified(id, level, text, cooldownMin) {
+  const st = loadState();
+  const ev = st.events.find((e) => e.id === id);
+  if (ev) {
+    ev.status = 'notified';
+    ev.level = level || 'medium';
+    ev.text = String(text || '').slice(0, 600);
+    ev.notifiedAt = new Date().toISOString();
+    const key = topicKey(ev.type, ev.title);
+    st.cooldowns[key] = {
+      until: Date.now() + Math.max(0, Number(cooldownMin) || 0) * 60000,
+      lastPriority: ev.priority,
+      notifiedAt: ev.notifiedAt,
+    };
+    saveState(st);
+  }
+}
+
+function listEvents(limit) {
+  const st = loadState();
+  const n = Math.max(1, Math.min(200, Number(limit) || 60));
+  return st.events.slice(-n).reverse().map((e) => ({
+    id: e.id,
+    ts: e.ts,
+    source: e.source,
+    type: e.type,
+    title: e.title,
+    detail: e.detail,
+    priority: e.priority,
+    scores: e.scores || {},
+    reason: e.reason,
+    status: e.status,
+    level: e.level,
+    text: e.text,
+  }));
+}
+
+function lastRunAt() {
+  return loadState().lastRunAt;
+}
+
+module.exports = {
+  DEFAULTS,
+  mergeCfg,
+  fetchNews,
+  runCycle,
+  markNotified,
+  listEvents,
+  lastRunAt,
+  FILTER_SYSTEM,
+  COMPOSE_SYSTEM,
+  filterPrompt,
+  composePrompt,
+  composeFallback,
+  fingerprint,
+};

package/src/agent/progressbus.js

@@ -0,0 +1,41 @@
+'use strict';
+
+/* Kurulum progress bus — agent modülleri (whisper / mem0 / tools) yüzde üretir,
+   main abone olup renderer'a 'install-progress' agent:event olarak aktarır.
+   transformers.js progress_callback'i dosya bazlı geldiği için per-dosya
+   loaded/total toplamından genel yüzde hesaplayan aggregator da burada. */
+
+const listeners = new Set();
+
+function onInstallProgress(fn) {
+  if (typeof fn === 'function') listeners.add(fn);
+  return () => listeners.delete(fn);
+}
+
+function emitInstallProgress(id, data) {
+  for (const fn of listeners) {
+    try { fn(id, data); } catch {}
+  }
+}
+
+/* transformers.js benzeri dosya bazlı akışlar için: per-dosya loaded/total'dan
+   genel yüzde üreten progress_callback üretir. */
+function fileProgressAggregator(id) {
+  const files = new Map(); // file -> { loaded, total }
+  return (d) => {
+    try {
+      const key = d && (d.file || d.name);
+      if (!key || typeof d.loaded !== 'number' || typeof d.total !== 'number' || d.total <= 0) return;
+      files.set(String(key), { loaded: d.loaded, total: d.total });
+      let loaded = 0;
+      let total = 0;
+      for (const v of files.values()) {
+        loaded += v.loaded;
+        total += v.total;
+      }
+      if (total > 0) emitInstallProgress(id, { pct: (loaded / total) * 100, loaded, total });
+    } catch {}
+  };
+}
+
+module.exports = { onInstallProgress, emitInstallProgress, fileProgressAggregator };

package/src/agent/tools.js

@@ -695,21 +695,25 @@ async function findSystemPython() {
   return null;
 }
 
-function httpsGetBuffer(url, redirectsLeft = 4, signal) {
+function httpsGetBuffer(url, redirectsLeft = 4, signal, onProgress) {
   return new Promise((resolve, reject) => {
     const req = https.get(url, { headers: { 'User-Agent': 'BeastAgent/1.0 (+python bootstrap)' } }, (res) => {
       if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.headers.location && redirectsLeft > 0) {
         res.resume();
-        return resolve(httpsGetBuffer(new URL(res.headers.location, url).toString(), redirectsLeft - 1, signal));
+        return resolve(httpsGetBuffer(new URL(res.headers.location, url).toString(), redirectsLeft - 1, signal, onProgress));
       }
       if (res.statusCode !== 200) {
         res.resume();
         return reject(new Error(`indirme başarısız: HTTP ${res.statusCode}`));
       }
+      const total = parseInt(res.headers['content-length'] || '0', 10) || 0;
       const chunks = [];
       let size = 0;
       res.on('data', (c) => {
         size += c.length;
+        if (typeof onProgress === 'function') {
+          try { onProgress(size, total); } catch {}
+        }
         if (size > 80 * 1024 * 1024) {
           req.destroy(new Error('dosya çok büyük'));
           return;
@@ -731,7 +735,10 @@ async function installEmbeddedPython(signal) {
   const dest = path.join(beastAppDir(), 'py');
   fs.mkdirSync(dest, { recursive: true });
   const zipPath = path.join(os.tmpdir(), 'beast-py-embed.zip');
-  const buf = await httpsGetBuffer(PYTHON_EMBED_URL, 4, signal);
+  const bus = require('./progressbus');
+  const buf = await httpsGetBuffer(PYTHON_EMBED_URL, 4, signal, (size, total) => {
+    if (total > 0) bus.emitInstallProgress('python', { pct: (size / total) * 100, loaded: size, total });
+  });
   fs.writeFileSync(zipPath, buf);
   const r = await runCommand(
     `Expand-Archive -LiteralPath "${zipPath}" -DestinationPath "${dest}" -Force`,

package/src/agent/whatsapp.js

@@ -36,6 +36,83 @@ function waLogSafe(line) {
 
 const TRACK_CAP = 500;
 
+/* ---------- TTS → WhatsApp sesli not (OGG/Opus) ---------- */
+
+let _ffmpegPath = null;
+function getFfmpegPath() {
+  if (_ffmpegPath !== null) return _ffmpegPath;
+  try { _ffmpegPath = require('ffmpeg-static') || ''; } catch { _ffmpegPath = ''; }
+  return _ffmpegPath;
+}
+
+function runFfmpeg(args, input) {
+  return new Promise((resolve, reject) => {
+    try {
+      const { spawn } = require('child_process');
+      const p = spawn(getFfmpegPath(), args, { windowsHide: true });
+      const out = [];
+      let err = '';
+      p.stdout.on('data', (c) => out.push(c));
+      p.stderr.on('data', (c) => { if (err.length < 400) err += c.toString(); });
+      p.on('error', reject);
+      p.on('close', (code) => {
+        if (code !== 0) return reject(new Error(`ffmpeg ${code}: ${err.slice(0, 200)}`));
+        resolve(Buffer.concat(out));
+      });
+      p.stdin.on('error', () => {});
+      p.stdin.write(input);
+      p.stdin.end();
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+
+/* Herhangi bir ses buffer'ı → OGG/Opus (WhatsApp sesli not formatı). Zaten OggS ise olduğu gibi döner. */
+async function toVoiceOggOpus(buf) {
+  if (buf.length > 4 && buf.subarray(0, 4).toString('latin1') === 'OggS') return buf;
+  const ff = getFfmpegPath();
+  if (!ff) throw new Error('ffmpeg bulunamadı');
+  return runFfmpeg([
+    '-hide_banner', '-loglevel', 'error',
+    '-i', 'pipe:0',
+    '-c:a', 'libopus', '-b:a', '48k', '-ar', '24000', '-ac', '1',
+    '-application', 'voip', '-vbr', 'on',
+    '-f', 'ogg', 'pipe:1',
+  ], buf);
+}
+
+/* Sesli not dalga formu: 64 segmentlik normalize genlik histogramı (Uint8Array) */
+async function audioWaveform(buf) {
+  try {
+    const ff = getFfmpegPath();
+    if (!ff) return undefined;
+    const pcm = await runFfmpeg([
+      '-hide_banner', '-loglevel', 'error',
+      '-i', 'pipe:0', '-f', 's16le', '-ar', '16000', '-ac', '1', 'pipe:1',
+    ], buf);
+    const SEG = 64;
+    const step = Math.max(1, Math.floor(pcm.length / 2 / SEG));
+    const wave = new Uint8Array(SEG);
+    let max = 1;
+    for (let i = 0; i < SEG; i++) {
+      let sum = 0;
+      const start = i * step;
+      for (let j = 0; j < step; j++) {
+        const off = (start + j) * 2;
+        if (off + 1 < pcm.length) sum += Math.abs(pcm.readInt16LE(off));
+      }
+      const v = Math.round(sum / step);
+      wave[i] = v;
+      if (v > max) max = v;
+    }
+    for (let i = 0; i < SEG; i++) wave[i] = Math.min(255, Math.round((wave[i] / max) * 255));
+    return wave;
+  } catch {
+    return undefined;
+  }
+}
+
 /* lastKnownPresence etiketleri */
 const PRESENCE_LABELS = {
   available: 'çevrimiçi',
@@ -470,11 +547,29 @@ class WhatsAppBridge {
     return id ? { id } : true;
   }
 
-  /* Sesli not olarak yanıtla (TTS çıktısı mp3 buffer) */
+  /* Sesli not olarak yanıtla (TTS çıktısı mp3 buffer → WhatsApp sesli not formatı OGG/Opus'a çevrilir;
+     ptt sesli notlar mp3 ile açılmaz, mutlaka audio/ogg; codecs=opus olmalı) */
   async sendAudio(jid, audioBuf) {
     if (!this.sock || !this.connected || !audioBuf) return false;
     try {
-      const ret = await this.sock.sendMessage(jid, { audio: audioBuf, ptt: true, mimetype: 'audio/mpeg' });
+      let voice = audioBuf;
+      let mime = 'audio/mpeg';
+      let ptt = false;
+      let waveform;
+      try {
+        voice = await toVoiceOggOpus(audioBuf);
+        mime = 'audio/ogg; codecs=opus';
+        ptt = true;
+        waveform = await audioWaveform(voice);
+      } catch {
+        /* ffmpeg dönüşümü başarısızsa mp3'ü ptt'siz ses mesajı olarak dene */
+        voice = audioBuf;
+        mime = 'audio/mpeg';
+        ptt = false;
+      }
+      const msg = { audio: voice, ptt, mimetype: mime };
+      if (waveform) msg.waveform = waveform;
+      const ret = await this.sock.sendMessage(jid, msg);
       this._trackOutgoing(jid, '[sesli yanıt]', ret);
       return true;
     } catch (e) {