beast-agent 0.15.0

package/tests/engine.test.js

@@ -0,0 +1,140 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { Engine, sanitizeTodoItems } = require('../src/agent/engine');
+
+function makeEngine(extra = {}) {
+  const sessionsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'beast-sess-'));
+  const workspace = fs.mkdtempSync(path.join(os.tmpdir(), 'beast-ws-'));
+  return new Engine(
+    {},
+    { sessionsDir, workspace, customProviders: [], emit: () => {}, ...extra }
+  );
+}
+
+/* ---------- sanitizeTodoItems ---------- */
+
+test('todo: boş/geçersiz girdiler elenir', () => {
+  const out = sanitizeTodoItems([
+    { title: 'Planla', status: 'active' },
+    { title: '' },
+    null,
+    'Sadece string başlık',
+    { title: 'Planla', status: 'done' }, // duplicate title
+    { title: 'Bitir', status: 'saçma' },
+  ]);
+  assert.deepEqual(out, [
+    { title: 'Planla', status: 'active' },
+    { title: 'Sadece string başlık', status: 'pending' },
+    { title: 'Bitir', status: 'pending' },
+  ]);
+});
+
+test('todo: 20 ile sınırlı', () => {
+  const items = Array.from({ length: 50 }, (_, i) => ({ title: 'görev ' + i }));
+  assert.equal(sanitizeTodoItems(items).length, 20);
+});
+
+/* ---------- payload builder ---------- */
+
+test('tool_call/tool mesajları birlikte tutulur', () => {
+  const eng = makeEngine();
+  const msgs = [
+    { role: 'user', content: 'merhaba' },
+    { role: 'assistant', content: '', tool_calls: [{ id: '1', type: 'function', function: { name: 'list_dir', arguments: '{}' } }] },
+    { role: 'tool', tool_call_id: '1', name: 'list_dir', content: '{"ok":true}' },
+    { role: 'assistant', content: 'sonuç şu' },
+    { role: 'user', content: 'tekrar' },
+  ];
+  const payload = eng._buildPayload('sys', msgs);
+  assert.equal(payload[0].role, 'system');
+  const idxAssistant = payload.findIndex((m) => m.role === 'assistant');
+  assert.ok(idxAssistant >= 0);
+  assert.equal(payload[idxAssistant + 1].role, 'tool');
+});
+
+test('token bütçesine uyar: eski mesajlar düşer, son mesaj kalır', () => {
+  const eng = makeEngine({ historyTokenBudget: 120 });
+  const big = 'kelime '.repeat(400); // ~700 token
+  const msgs = [];
+  for (let i = 0; i < 10; i++) msgs.push({ role: 'user', content: big + ' #' + i });
+  const payload = eng._buildPayload('sys', msgs);
+  // system + en az son kullanıcı mesajı
+  assert.equal(payload[0].role, 'system');
+  const last = payload[payload.length - 1];
+  assert.ok(last.role === 'user' && last.content.includes('#9'));
+  assert.ok(eng._payloadTokens(payload.slice(1)) <= 120 + estSlack(last));
+  function estSlack(m) {
+    return Math.ceil((m.content || '').length / 4) * 3; // tek mesaj taşabilir
+  }
+});
+
+test('browser_open/browser_read kancaları çağrılır', async () => {
+  const calls = [];
+  const eng = makeEngine({
+    browser: {
+      openUrl: async (u) => { calls.push(['open', u]); return { ok: true, url: u, title: 'T' }; },
+      readText: async () => { calls.push(['read']); return { ok: true, content: 'sayfa metni' }; },
+    },
+  });
+  const r1 = JSON.parse(await eng._execTool('browser_open', { url: 'https://example.com' }, null, 's1'));
+  const r2 = JSON.parse(await eng._execTool('browser_read', {}, null, 's1'));
+  assert.ok(r1.ok && r1.title === 'T');
+  assert.ok(r2.ok && r2.content.includes('metni'));
+  assert.deepEqual(calls, [['open', 'https://example.com'], ['read']]);
+});
+
+test('browser kancası yoksa zarif hata döner', async () => {
+  const eng = makeEngine();
+  const r = JSON.parse(await eng._execTool('browser_open', { url: 'https://x.com' }, null, 's1'));
+  assert.equal(r.ok, false);
+  assert.match(r.error, /tarayıcı/);
+});
+
+test('eski görseller metne indirilir, son mesajın görseli korunur', () => {
+  const eng = makeEngine();
+  const img = (u) => [{ type: 'text', text: 'bak' }, { type: 'image_url', image_url: { url: u } }];
+  const msgs = [
+    { role: 'user', content: img('data:image/png;base64,AAAA') },
+    { role: 'assistant', content: 'ok' },
+    { role: 'user', content: img('data:image/png;base64,BBBB') },
+  ];
+  const payload = eng._buildPayload('sys', msgs);
+  const firstUser = payload.find((m) => m.role === 'user');
+  assert.equal(typeof firstUser.content, 'string');
+  assert.ok(firstUser.content.includes('bağlam dışı'));
+  const lastUser = payload[payload.length - 1];
+  assert.ok(Array.isArray(lastUser.content));
+});
+
+/* ---------- oturum notlar� (ge�ici haf�za) ---------- */
+
+test('oturum notlar�: dosyadan y�klenir, mesaj listesine kar��maz', () => {
+  const eng = makeEngine();
+  const id = eng.createSession().id;
+  for (let i = 0; i < 5; i++) {
+    fs.appendFileSync(eng._file(id), JSON.stringify({ t: 'msg', role: 'user', content: 'mesaj ' + i }) + '\n');
+  }
+  fs.appendFileSync(eng._file(id), JSON.stringify({ t: 'notes', text: 'hedef: v7 �al�smas�', at: 3 }) + '\n');
+  eng.cache.delete(id); // diskten taze y�kle
+  const s = eng._load(id);
+  assert.equal(s.notes, 'hedef: v7 �al�smas�');
+  assert.equal(s.notesAt, 3);
+  assert.equal(s.messages.length, 5);
+});
+
+test('oturum notlar� varken payload s�k�la��r', () => {
+  const eng = makeEngine({ historyTokenBudget: 100000 });
+  const msgs = [];
+  for (let i = 0; i < 30; i++) msgs.push({ role: 'user', content: 'kisa mesaj #' + i });
+  const withoutNotes = eng._buildPayload('sys', msgs, null);
+  const withNotes = eng._buildPayload('sys', msgs, '�zet: test');
+  assert.ok(withNotes.length < withoutNotes.length);
+  assert.equal(withNotes[withNotes.length - 1].content, 'kisa mesaj #29'); // son mesaj hep kal�r
+});

package/tests/eval.test.js

@@ -0,0 +1,91 @@
+'use strict';
+
+/* #4 Eval düzeni: scenarios.json'daki senaryoları koşar.
+   Yeni modül eklerken buraya senaryo düşür — regresyon kalkanı olur. */
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const path = require('path');
+const fs = require('fs');
+
+const SCEN = JSON.parse(fs.readFileSync(path.join(__dirname, 'scenarios.json'), 'utf8'));
+const cron = require('../src/cron');
+const Engine = require('../src/agent/engine');
+const memory = require('../src/agent/memory');
+const kb = require('../src/agent/kb');
+const bus = require('../src/agent/bus');
+const usageMod = require('../src/agent/usage');
+
+function scenario(id) {
+  return SCEN.scenarios.find((s) => s.id === id);
+}
+
+test('eval: cron-invalid-rejected', () => {
+  const s = scenario('cron-invalid-rejected');
+  assert.equal(cron[s.call.fn](...s.call.args), null);
+});
+
+test('eval: reminder-daily-schedule', () => {
+  const s = scenario('reminder-daily-schedule');
+  const r = cron[s.call.fn](...s.call.args);
+  assert.equal(r.schedule, s.expectEquals.schedule);
+});
+
+test('eval: kb-search-citation', () => {
+  const s = scenario('kb-search-citation');
+  kb.add('FxPro GOLD seansları', 'GOLD sembolünde seans 01:00-23:00 arası açıktır', { source: 'test' });
+  const rows = kb.search('gold seans');
+  assert.ok(rows.length >= 1);
+  for (const r of rows) {
+    assert.ok(r.citation && r.citation.includes('['), 'citation formatı');
+    assert.ok(r.title && r.snippet !== undefined);
+  }
+});
+
+test('eval: memory-hygiene-dedup', () => {
+  const s = scenario('memory-hygiene-dedup');
+  assert.equal(s.module, 'memory');
+  memory.append('Kullanıcının adı Batuhan');
+  memory.append('kullanıcının adı batuhan'); // dup (fold edilmiş)
+  const r = memory.hygiene({ maxAgeDays: 0 }); // yalnız dedup, yaş silmesi yok
+  assert.ok(r.ok);
+  const kept = memory.entries().filter((l) => /batuhan/i.test(l));
+  assert.ok(kept.length <= 1, 'duplike tekilleşmeli');
+  // temizlik
+  for (const l of memory.entries()) if (/batuhan/i.test(l)) memory.removeRule('__none__'); // no-op koruması
+});
+
+test('eval: system-prompt-has-local-time', () => {
+  const os = require('os');
+  const eng = new Engine({}, { sessionsDir: fs.mkdtempSync(path.join(os.tmpdir(), 'beast-eval-')) });
+  const sys = eng.buildSystem('x');
+  assert.match(sys, new RegExp(scenario('system-prompt-has-local-time').regex));
+});
+
+test('eval: system-prompt-rules-injected', () => {
+  const os = require('os');
+  const eng = new Engine({}, { sessionsDir: fs.mkdtempSync(path.join(os.tmpdir(), 'beast-eval2-')) });
+  memory.addRule('Eval test kuralı ABCXYZ');
+  const sys = eng.buildSystem('x');
+  assert.match(sys, /KURALLAR/);
+  assert.match(sys, /Eval test kuralı ABCXYZ/);
+  memory.removeRule('Eval test kuralı ABCXYZ');
+});
+
+test('eval: usage-cost-math kısa doğrulama', () => {
+  usageMod.reset();
+  usageMod.record({ providerId: 'e', model: 'm', promptTokens: 1000000, completionTokens: 0, costIn: 1, costOut: 0 });
+  assert.ok(Math.abs(usageMod.report().today.total.cost - 1) < 1e-6);
+});
+
+test('eval: bus-price-filter', () => {
+  for (const s of bus.listSubs()) bus.removeSub(s.id);
+  const r = bus.addSub({ type: 'price:tick', sessionId: 'evalsestest', op: 'gte', value: 100, cooldownMin: 0 });
+  assert.ok(r.ok);
+  const fired = bus.emitEvent('price:tick', { value: 150 }, Date.now());
+  assert.equal(fired, 1); // sadece bu abonelik
+  const notFired = bus.emitEvent('price:tick', { value: 50 }, Date.now());
+  assert.equal(notFired, 0);
+  for (const s of bus.listSubs()) bus.removeSub(s.id);
+});

package/tests/fallout.test.js

@@ -0,0 +1,188 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { Engine } = require('../src/agent/engine');
+
+function tmpDir(prefix) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+/* pA::m1 tek sağlayıcı + çökme kayıt dosyası olan motor */
+function makeFalloutEngine({ fallout, emitEvents } = {}) {
+  const sessionsDir = tmpDir('beast-fall-sess-');
+  const workspace = tmpDir('beast-fall-ws-');
+  const crashFile = path.join(tmpDir('beast-fall-crash-'), 'fallout-crash.json');
+  const chainEntry = {
+    providerId: 'pA',
+    providerName: 'ProvA',
+    model: 'm1',
+    url: 'https://a.test/v1/chat/completions',
+    key: 'keyA',
+  };
+  const cfg = { chain: [chainEntry], defaultSelection: { ...chainEntry } };
+  const events = [];
+  const eng = new Engine(cfg, {
+    sessionsDir,
+    workspace,
+    crashFile,
+    modelOverride: 'pA::m1',
+    fallout,
+    emit: (ev) => events.push(ev),
+  });
+  if (emitEvents) emitEvents(events);
+  return { eng, crashFile, events };
+}
+
+test('fallout: bozuk slotlar elenir, en fazla 10 kalır', () => {
+  const eng = makeFalloutEngine().eng;
+  const norm = eng._normalizeFallout({
+    enabled: true,
+    slots: [
+      null,
+      { providerId: '', model: 'x', key: 'k' },
+      { providerId: 'p', model: '', key: 'k' },
+      { providerId: 'p', model: 'm', key: '' },
+      { providerId: 'pA', providerName: 'ProvA', model: 'm1', key: 'k1' },
+      ...Array.from({ length: 12 }, (_, i) => ({
+        providerId: 'p' + i,
+        providerName: 'P' + i,
+        model: 'm',
+        key: 'k',
+      })),
+    ],
+  });
+  assert.equal(norm.enabled, true);
+  assert.equal(norm.chain.length, 10); // 1 geçerli + 11 aday ama sınır 10
+  assert.deepEqual(norm.chain[0], { providerId: 'pA', providerName: 'ProvA', model: 'm1', key: 'k1' });
+});
+
+test('fallout: kapalıyken zincir boş döner', () => {
+  const { eng } = makeFalloutEngine({
+    fallout: { enabled: false, slots: [{ providerId: 'pA', model: 'm1', key: 'other' }] },
+  });
+  assert.deepEqual(eng._falloutSelections(eng.sel), []);
+});
+
+test('fallout: aynı provider+model farklı key ile listelenir, birebir aynı olan atlanır', () => {
+  const { eng } = makeFalloutEngine({
+    fallout: {
+      enabled: true,
+      slots: [
+        { providerId: 'pA', providerName: 'ProvA', model: 'm1', key: 'keyA' }, // aktif ile aynı -> atla
+        { providerId: 'pA', providerName: 'ProvA', model: 'm1', key: 'keyA2' }, // farklı key -> kalsın
+        { providerId: 'yok', model: 'm9', key: 'k' }, // kayıtlı değil -> atla
+      ],
+    },
+  });
+  const sels = eng._falloutSelections(eng.sel);
+  assert.equal(sels.length, 1);
+  assert.equal(sels[0].url, 'https://a.test/v1/chat/completions'); // URL zincirden gelir
+  assert.equal(sels[0].key, 'keyA2');
+});
+
+test('fallout: çökme kaydı yazılır ve silinir', () => {
+  const { eng, crashFile } = makeFalloutEngine({});
+  eng._saveCrash('sess1', new Error('patladı'), 'provider');
+  assert.ok(fs.existsSync(crashFile));
+  const st = JSON.parse(fs.readFileSync(crashFile, 'utf8'));
+  assert.equal(st.sessionId, 'sess1');
+  assert.match(st.error, /patladı/);
+  assert.equal(st.phase, 'provider');
+  eng._clearCrash();
+  assert.ok(!fs.existsSync(crashFile));
+});
+
+function sseResponse(sseText) {
+  const enc = new TextEncoder();
+  const stream = new ReadableStream({
+    start(c) {
+      c.enqueue(enc.encode(sseText));
+      c.close();
+    },
+  });
+  return new Response(stream, { status: 200, headers: { 'Content-Type': 'text/event-stream' } });
+}
+
+const SSE_OK =
+  'data: {"choices":[{"delta":{"content":"merhaba"}}]}\n\n' +
+  'data: {"choices":[{"delta":{},"finish_reason":"stop"}]}\n\n' +
+  'data: [DONE]\n\n';
+
+test('fallout: ilk sağlayıcı 401 çöker → zincirdeki sıradaki key ile devam eder', async () => {
+  const { eng, crashFile, events } = makeFalloutEngine({
+    fallout: {
+      enabled: true,
+      slots: [{ providerId: 'pA', providerName: 'ProvA', model: 'm1', key: 'keyYedek' }],
+    },
+  });
+
+  const calls = [];
+  const realFetch = globalThis.fetch;
+  globalThis.fetch = async (url, opts = {}) => {
+    calls.push({ url: String(url), auth: opts.headers && opts.headers.Authorization });
+    if (calls.length === 1) {
+      return new Response(JSON.stringify({ error: { message: 'bad key' } }), {
+        status: 401,
+        statusText: 'Unauthorized',
+      });
+    }
+    return sseResponse(SSE_OK);
+  };
+  try {
+    const res = await eng._streamWithFallbacks(
+      { id: 's1', messages: [{ role: 'user', content: 'selam' }] },
+      [{ role: 'user', content: 'selam' }],
+      [],
+      null,
+      () => {},
+      eng.sel,
+      false
+    );
+    assert.equal(res.content, 'merhaba');
+  } finally {
+    globalThis.fetch = realFetch;
+  }
+
+  assert.equal(calls.length, 2);
+  assert.match(calls[0].auth, /keyA$/);
+  assert.match(calls[1].auth, /keyYedek$/);
+  // durumu kaydet adımı çalıştı
+  assert.ok(fs.existsSync(crashFile), 'çökme kaydı yazılmalı');
+  // durum mesajı Fallout geçişini haber verdi
+  const st = events.find((e) => e.type === 'status' && /FALLOUT/.test(e.status));
+  assert.ok(st, 'FALLOUT durum mesajı beklenirdi');
+});
+
+test('fallout: kapalıysa tek denemede hatayı fırlatır', async () => {
+  const { eng } = makeFalloutEngine({ fallout: { enabled: false, slots: [] } });
+  const realFetch = globalThis.fetch;
+  let n = 0;
+  globalThis.fetch = async () => {
+    n++;
+    return new Response('{}', { status: 401, statusText: 'Unauthorized' });
+  };
+  try {
+    await assert.rejects(
+      () =>
+        eng._streamWithFallbacks(
+          { id: 's1', messages: [] },
+          [{ role: 'user', content: 'x' }],
+          [],
+          null,
+          () => {},
+          eng.sel,
+          false
+        ),
+      /HTTP 401/
+    );
+  } finally {
+    globalThis.fetch = realFetch;
+  }
+  assert.equal(n, 1);
+});

package/tests/llm.test.js

@@ -0,0 +1,56 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const { withRetries, friendlyError } = require('../src/agent/llm');
+
+test('withRetries: 503 sonrası başarılı isteği tekrarlar', async () => {
+  let calls = 0;
+  const r = await withRetries(
+    async () => {
+      calls++;
+      if (calls < 3) {
+        const e = new Error('HTTP 503');
+        e.status = 503;
+        throw e;
+      }
+      return 'ok';
+    },
+    { onRetry: () => {} }
+  );
+  assert.equal(r, 'ok');
+  assert.equal(calls, 3);
+});
+
+test('withRetries: 400 gibi kalıcı hata beklemeksizin fırlatır', async () => {
+  let calls = 0;
+  await assert.rejects(
+    () =>
+      withRetries(async () => {
+        calls++;
+        const e = new Error('HTTP 400');
+        e.status = 400;
+        throw e;
+      }),
+    /400/
+  );
+  assert.equal(calls, 1);
+});
+
+test('withRetries: ağ hatası (status yok) tekrarlanır', async () => {
+  let calls = 0;
+  const r = await withRetries(async () => {
+    calls++;
+    if (calls === 1) throw new Error('fetch failed');
+    return 'ok';
+  });
+  assert.equal(r, 'ok');
+  assert.equal(calls, 2);
+});
+
+test('friendlyError ipuçları içerir', () => {
+  const m = friendlyError(503, 'Service Unavailable', '{"error":"x"}');
+  assert.match(m, /kullanılamıyor/);
+  assert.match(m, /model seçici/);
+});

package/tests/memory.test.js

@@ -0,0 +1,33 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const memory = require('../src/agent/memory');
+
+test('append + entries turu', () => {
+  memory.append('Kullanıcı FxPro MT5 kullanıyor');
+  memory.append('Beast hızlı olmalı, gereksiz sormaz');
+  const list = memory.entries();
+  assert.ok(list.length >= 2);
+  assert.ok(list.some((l) => l.includes('FxPro')));
+});
+
+test('search ilgili kaydı bulur (Türkçe büyük/küçük + diakritik duyarsız)', () => {
+  memory.append('Kullanıcının favori editörü VS Code');
+  const hits = memory.search('favori editör nedir?');
+  assert.ok(hits.length >= 1);
+  assert.ok(hits[0].text.toLowerCase().includes('editör') || hits[0].text.toLowerCase().includes('edıtor'));
+});
+
+test('relevantFor alakasız sorguda bile son kayıtları döndürür', () => {
+  const out = memory.relevantFor('zzz bilinmeyen kelime xyzq');
+  assert.ok(out.length > 0);
+  assert.ok(out.startsWith('- '));
+});
+
+test('relevantFor charCap\u0027e uyar', () => {
+  for (let i = 0; i < 30; i++) memory.append('uzun kayıt numara ' + i + ' ' + 'x'.repeat(200));
+  const out = memory.relevantFor('kayıt');
+  assert.ok(out.length <= 2600);
+});

package/tests/memoryloop.test.js

@@ -0,0 +1,26 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const memory = require('../src/agent/memory');
+
+test('#v13 memory döngüsü: append dedup + cap hygiene', () => {
+  // temiz başlangıç
+  const f = require('path').join(memory.memDir(), 'MEMORY.md');
+  require('fs').rmSync(f, { force: true });
+
+  const r1 = memory.append('Kullanıcının projeleri: Beast Agent, GOLD trading');
+  assert.ok(r1.ok);
+  // aynı bilgi farklı ifadeyle — dup yakalanmalı (fold+normalize)
+  const r2 = memory.append('kullanıcının PROJELERİ: beast agent, gold trading!');
+  assert.ok(r2.ok);
+  assert.equal(r2.duplicate, true);
+
+  const list = memory.entries().filter((l) => /beast agent/i.test(l));
+  assert.equal(list.length, 1, 'dup tekilleşmeli');
+
+  // hygiene çalışıyor mu
+  const h = memory.hygiene({ maxAgeDays: 0 });
+  assert.ok(h.ok);
+});

package/tests/notegen.test.js

@@ -0,0 +1,63 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+/* chatOnce'ı stub'la: engine yüklenmeden önce llm modülünü patch'le
+   (engine destructure anında referansı alır) */
+const llm = require('../src/agent/llm');
+let stubResponse = 'Not: kullanıcı Beast Agent geliştiriyor. Karar: not sistemi çalışmalı.';
+let stubCalls = 0;
+llm.chatOnce = async () => {
+  stubCalls++;
+  return { content: stubResponse };
+};
+
+const { Engine } = require('../src/agent/engine');
+
+function makeEngine(extra = {}) {
+  const sessionsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'beast-sess-'));
+  const workspace = fs.mkdtempSync(path.join(os.tmpdir(), 'beast-ws-'));
+  const eng = new Engine({}, { sessionsDir, workspace, customProviders: [], emit: () => {}, ...extra });
+  eng.sel = { provider: 'test', providerName: 'Test', model: 'test-model', sel: 'test::test-model' };
+  return eng;
+}
+
+test('oturum notları: 14+ mesajda not üretilir ve listNotes görünür', async () => {
+  const eng = makeEngine();
+  const s = eng.createSession();
+  const full = eng._load(s.id);
+  for (let i = 0; i < 20; i++) {
+    full.messages.push({ role: 'user', content: 'mesaj ' + i });
+    full.messages.push({ role: 'assistant', content: 'cevap ' + i });
+  }
+  const r = await eng._updateSessionNotes(full, undefined);
+  assert.equal(r.ok, true, 'not üretimi başarılı olmalı, hata: ' + (r && r.reason));
+  assert.equal(stubCalls, 1);
+  assert.ok(full.notes && full.notes.length, 'notes yazıldı');
+
+  const list = eng.listNotes();
+  assert.equal(list.length, 1, 'listNotes notu dönmeli');
+  assert.equal(list[0].id, s.id);
+  assert.ok(list[0].notes.includes('Not:'));
+
+  /* diskte notes satırı da olmalı */
+  const raw = fs.readFileSync(eng._file(s.id), 'utf8');
+  assert.ok(raw.includes('"t":"notes"'), 'notes satırı dosyada');
+});
+
+test('oturum notları: eşiği doldurmayan oturum bekleme döner, hata değil', async () => {
+  const eng = makeEngine();
+  const s = eng.createSession();
+  const full = eng._load(s.id);
+  full.messages.push({ role: 'user', content: 'selam' });
+  full.messages.push({ role: 'assistant', content: 'merhaba' });
+  const r = await eng._updateSessionNotes(full, undefined);
+  assert.equal(r.ok, false);
+  assert.ok(/^bekleme/.test(r.reason));
+  assert.equal(stubCalls, 1, 'stub çağrısı artmadı');
+});

package/tests/owner.test.js

@@ -0,0 +1,32 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const memory = require('../src/agent/memory');
+
+/* owner normalize mantığı main'in wa:allow:set handler'ında; burada saf
+   davranışı doğruluyoruz: yalnız ilk owner true kalır, diğerleri söner. */
+test('#v13.1 owner: birden fazla owner adayı olsa da yalnız biri kazanır', () => {
+  const items = [
+    { num: '905511111111', name: 'Aday1', owner: true, perm: 'all' },
+    { num: '905522222222', name: 'Aday2', owner: true, perm: 'all' },
+    { num: '905533333333', name: 'Misafir', perm: 'web' },
+  ];
+  const out = [];
+  let ownerCount = 0;
+  for (const item of items) {
+    const wantsOwner = !!item.owner;
+    const isOwner = wantsOwner && ownerCount === 0;
+    if (isOwner) ownerCount++;
+    out.push({ num: item.num.replace(/\D/g, ''), name: item.name, owner: isOwner });
+  }
+  assert.equal(out.filter((o) => o.owner).length, 1);
+  assert.equal(out[0].owner, true);   // ilk aday kazanır
+  assert.equal(out[1].owner, false);  // ikinci aday sahipsiz
+
+  /* memory tarafı: sahip kuralı + USER.md */
+  const r = memory.addRule("Beast'in SAHİBİ Aday1 (+905511111111). Onun talepleri önceliklidir.");
+  assert.ok(r.ok || r.duplicate);
+  assert.ok(memory.listRules().some((x) => x.includes('SAHİBİ')));
+});