beast-agent 0.15.0

package/tests/approval.test.js

@@ -0,0 +1,56 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const Engine = require('../src/agent/engine');
+
+function mkEngine(approvals) {
+  const path = require('path');
+  const os = require('os');
+  return new Engine(
+    {},
+    {
+      sessionsDir: path.join(os.tmpdir(), 'beast-appr-test-' + Date.now()),
+      approvals,
+    }
+  );
+}
+
+test('onay kapısı: onay gelmezse riskli araç çalışmaz, onay gelirse çalışır', async () => {
+  let asked = null;
+  const eng = mkEngine({
+    request: async (q) => {
+      asked = q;
+      return false; // reddet
+    },
+  });
+
+  // GATE: run_command dıştan görünür şekilde kapıda durmalı
+  assert.ok(Engine.RISKY_TOOLS.has('run_command'));
+  assert.ok(Engine.RISKY_TOOLS.has('write_file'));
+  assert.ok(Engine.RISKY_TOOLS.has('email_send'));
+  assert.ok(!Engine.RISKY_TOOLS.has('web_search')); // güvenli araç kapıya takılmaz
+
+  const out = await eng._execTool('run_command', { command: 'echo hi' }, null, 's1');
+  const obj = JSON.parse(out);
+  assert.equal(obj.ok, false);
+  assert.match(obj.error, /ONAYLAMADI/);
+  assert.equal(asked.tool, 'run_command');
+  assert.equal(asked.sessionId, 's1');
+
+  // izin verilirse araç gerçekten çalışır (echo)
+  const eng2 = mkEngine({ request: async () => true });
+  const out2 = await eng2._execTool('run_command', { command: 'echo ok' }, null, 's2');
+  const obj2 = JSON.parse(out2);
+  if (obj2.ok === false && /yok/.test(String(obj2.error))) {
+    assert.ok(true); // ortamda shell yoksa kayıtlı davranış
+  } else {
+    assert.ok(JSON.stringify(obj2).includes('ok'));
+  }
+
+  // kapı hiç verilmediyse eski davranış — doğrudan çalışır
+  const eng3 = mkEngine(null);
+  const out3 = await eng3._execTool('run_command', { command: 'echo three' }, null, 's3');
+  assert.ok(out3.length > 0);
+});

package/tests/bg-jobs.test.js

@@ -0,0 +1,315 @@
+'use strict';
+
+/* #14 paralel ajanlar + CEO modu testleri (ağ çağrısı yok) */
+
+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');
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function tmpEngine() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'beast-bg-'));
+  const events = [];
+  const eng = new Engine({}, {
+    sessionsDir: dir,
+    emit: (ev) => events.push(ev),
+  });
+  return { eng, events, dir };
+}
+
+test('CEO modu varsayılan açık; setCeoMode çalışır', () => {
+  const { eng } = tmpEngine();
+  assert.strictEqual(eng.ceoMode, true);
+  eng.setCeoMode(false);
+  assert.strictEqual(eng.ceoMode, false);
+  eng.setCeoMode(true);
+  assert.strictEqual(eng.ceoMode, true);
+});
+
+test('CEO yasaklı araç seti uygulayıcıları kapsar, yönetici araçlarını değil', () => {
+  const E = Engine;
+  for (const t of ['run_command', 'write_file', 'read_file', 'web_search', 'browser_click', 'computer_act', 'delegate_task']) {
+    assert.ok(E.CEO_EXEC_TOOLS.has(t), t);
+  }
+  for (const t of ['memory_write', 'run_background', 'tasks_list', 'task_status', 'set_reminder']) {
+    assert.ok(!E.CEO_EXEC_TOOLS.has(t), t);
+  }
+  /* arka plan ajanı yönetim araçlarını görmemeli — sonsuz alt dal zinciri olmasın */
+  assert.ok(E.BG_HIDDEN_TOOLS.has('run_background'));
+});
+
+test('buildSystem CEO modunda CEO bloğu içerir; kapalıyken içermez', () => {
+  const { eng } = tmpEngine();
+  const onSys = eng.buildSystem('merhaba');
+  assert.ok(onSys.includes('# CEO MODU'), 'ceo bloğu');
+  assert.ok(onSys.includes('PARALEL ajana devret'));
+  eng.setCeoMode(false);
+  const offSys = eng.buildSystem('merhaba');
+  assert.ok(!offSys.includes('# CEO MODU'));
+  assert.ok(offSys.includes('delegate_task ile devret'));
+});
+
+test('runBackground kayıt açar ve iş hata durumunda error olarak kapanır', async () => {
+  const { eng, events } = tmpEngine();
+  const r = eng.runBackground('oturum-1', 'klasördeki pdfleri listele', 'PDF Taraması');
+  assert.ok(r.ok);
+  assert.ok(r.backgroundId);
+
+  let jobs = eng.listBgJobs();
+  assert.strictEqual(jobs.length, 1);
+  assert.strictEqual(jobs[0].status, 'running');
+  assert.strictEqual(jobs[0].title, 'PDF Taraması');
+  assert.ok(jobs[0].task.includes('pdf'));
+  assert.strictEqual(jobs[0].parentId, 'oturum-1');
+
+  await sleep(200); // send tetiklenir → model yok → _run error yakalar
+
+  jobs = eng.listBgJobs();
+  assert.strictEqual(jobs[0].status, 'error');
+  assert.ok(/Model yapılandırılmadı/.test(jobs[0].error || ''), 'hata metni yakalandı: ' + jobs[0].error);
+  assert.ok(events.some((e) => e.type === 'agents' && Array.isArray(e.jobs)));
+});
+
+test('_execTool tasks_list + task_status + task_cancel yanıt verir', async () => {
+  const { eng } = tmpEngine();
+  eng.runBackground('p2', 'araştırma görevi', 'Araştırma');
+  await sleep(150); // iş biter (error)
+
+  const lst = JSON.parse(await eng._execTool('tasks_list', {}, {}));
+  assert.ok(lst.ok && lst.jobs.length >= 1);
+  const id = lst.jobs[0].id;
+
+  const det = JSON.parse(await eng._execTool('task_status', { id }, {}));
+  assert.ok(det.ok);
+  assert.strictEqual(det.job.id, id);
+  assert.ok(Array.isArray(det.messages));
+
+  /* çalışan ajan olmadığından cancel false döner */
+  const c = JSON.parse(await eng._execTool('task_cancel', { id }, {}));
+  assert.strictEqual(c.ok, false);
+});
+
+test('bgDetail kod ile de bulunur; mesaj özeti GÖREV/AJAN etiketlidir', async () => {
+  const { eng } = tmpEngine();
+  const r = eng.runBackground('p3', 'görev metni', 'Kodlu İş');
+  await sleep(150);
+  const job = eng.listBgJobs()[0];
+  const byId = eng.bgDetail(job.id);
+  assert.ok(byId.ok);
+  const byCode = eng.bgDetail(job.code);
+  assert.ok(byCode.ok && byCode.job.id === job.id);
+  const missing = eng.bgDetail('XXXXXX99');
+  assert.strictEqual(missing.ok, false);
+});
+
+/* ---------- superyorizyon (#15) ---------- */
+
+const MIN = 60000;
+
+function fakeJob(over) {
+  return {
+    status: 'running',
+    startedAt: new Date(Date.now() - 10 * MIN).toISOString(),
+    lastActivityAt: new Date(Date.now() - 10 * MIN).toISOString(),
+    lastNudgeAt: null,
+    ...over,
+  };
+}
+
+test('superviseReason: takılan stuck, çalışan uzun iş once wrapup (wrapAt sonrası long), yeni uyarılan null', () => {
+  assert.strictEqual(Engine.superviseReason(fakeJob(), Date.now()), 'stuck');
+
+  assert.strictEqual(
+    Engine.superviseReason(fakeJob({ lastActivityAt: new Date(Date.now() - 30 * 1000).toISOString() }), Date.now()),
+    'wrapup'
+  ); // aktivite sürüyor ama 10 dk koştu — önce zarif bitirme uyarısı
+
+  assert.strictEqual(
+    Engine.superviseReason(fakeJob({ wrapAt: new Date().toISOString(), lastActivityAt: new Date(Date.now() - 30 * 1000).toISOString() }), Date.now()),
+    'long'
+  ); // wrap-up uyarısı verildi, hâlâ bitmedi → CEO ara kontrolü
+
+  assert.strictEqual(
+    Engine.superviseReason(fakeJob({ startedAt: new Date(Date.now() - 1 * MIN).toISOString() }), Date.now()),
+    null
+  ); // henüz çok yeni
+
+  assert.strictEqual(
+    Engine.superviseReason(fakeJob({ lastNudgeAt: new Date(Date.now() - 1 * MIN).toISOString() }), Date.now()),
+    null
+  ); // az önce uyarıldı — cooldown
+
+  assert.strictEqual(Engine.superviseReason(fakeJob({ status: 'done' }), Date.now()), null);
+});
+
+test('emit sarmalayıcı ajan olayında lastActivityAt günceller', () => {
+  const { eng } = tmpEngine();
+  eng.runBackground('pX', 'izleme', 'İz İş');
+  const job = eng.listBgJobs()[0];
+  /* zaman damgasını yapay eskilt — ms çözünürlüğü eşitliğe düşmesin */
+  eng._bgJobs.get(job.id).lastActivityAt = new Date(Date.now() - 5 * MIN).toISOString();
+  const eski = eng._bgJobs.get(job.id).lastActivityAt;
+  eng.emit({ type: 'tool-start', sessionId: job.id, name: 'run_command', args: {} });
+  const sonra = eng._bgJobs.get(job.id).lastActivityAt;
+  assert.ok(new Date(sonra) > new Date(eski), 'aktivite tazelendi');
+  /* yabancı oturum etkilenmez */
+  eng.emit({ type: 'token', sessionId: 'baskasi', delta: 'x' });
+  assert.ok(true);
+});
+
+test('_supervise önce ajana ÖZ-KURTARMA verir, haklar bitince CEO\'ya uyarır', async () => {
+  const { eng } = tmpEngine();
+  const r = eng.runBackground('parentOk', 'uzun araştırma', 'Uzun İş');
+  const job = eng._bgJobs.get(r.backgroundId);
+  job.startedAt = new Date(Date.now() - 10 * MIN).toISOString();
+  job.lastActivityAt = job.startedAt;
+  eng._supervise();
+
+  /* 1. aşama: kurtarma emri ajanın KENDİ oturumuna düşer — CEO meşgul edilmez */
+  const bgS = eng._load(r.backgroundId);
+  assert.ok(bgS.messages.some((m) => String(m.content || '').includes('[ÖZ-KURTARMA 1/')), 'ajana öz-kurtarma düştü');
+  assert.strictEqual(job.checks, 1);
+  assert.strictEqual(job.fixes, 1);
+  const s0 = eng._load('parentOk');
+  assert.ok(!s0.messages.some((m) => String(m.content || '').includes('[SUPERYORIZON]')), 'CEO daha devreye girmedi');
+
+  /* cooldown: ikinci çağrı hemen tekrar müdahale etmez */
+  eng._supervise();
+  assert.strictEqual(job.checks, 1);
+
+  /* 2. aşama: öz-kurtarma hakları bitmiş + iş hâlâ koşuyor (wrap-up zaten
+     verildi, aktif) → CEO uyarısı ('long') */
+  job.status = 'running';
+  job.endedAt = null;
+  job.fixes = 2;
+  job.wrapAt = new Date().toISOString();
+  job.lastActivityAt = new Date(Date.now() - 30 * 1000).toISOString();
+  job.lastNudgeAt = new Date(Date.now() - 5 * MIN).toISOString();
+  eng._supervise();
+  await sleep(250);
+
+  const s = eng._load('parentOk');
+  const got = s.messages.some((m) => String(m.content || '').includes('[SUPERYORIZON] "Uzun İş"'));
+  assert.ok(got, 'üst oturuma uyarı düştü');
+  assert.strictEqual(job.checks, 2);
+});
+
+/* ---------- #17 kalıcı ajan geçmişi ---------- */
+
+test('ajan geçmişi restart sonrası durur; sol listede GİZLİ, kayıt diske yazar; elle silinir', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'beast-persist-'));
+  const eng1 = new Engine({}, { sessionsDir: dir, emit: () => {} });
+  const r = eng1.runBackground('p1', 'masaüstündeki dosyaları listele', 'Tarama İş');
+
+  /* ajan oturumu sol sohbet listesine karışmaz */
+  assert.ok(!eng1.listSessions().some((s) => s.id === r.backgroundId), 'sol liste ajan sohbetini göstermez');
+
+  /* uygulama yeniden başlaması: yeni motor örneği aynı dizinden */
+  const eng2 = new Engine({}, { sessionsDir: dir, emit: () => {} });
+  const jobs = eng2.listBgJobs();
+  assert.strictEqual(jobs.length, 1);
+  assert.strictEqual(jobs[0].status, 'aborted', 'running → aborted migrasyonu');
+  assert.ok(String(jobs[0].error || '').includes('kapatıldı'));
+
+  /* hâlâ sol listede yok */
+  assert.ok(!eng2.listSessions().some((s) => s.id === r.backgroundId), 'restart sonrası da gizli');
+
+  /* elle silme: oturum dosyası + iş kaydı birlikte gider, hayalet yazılmaz */
+  eng2.deleteSession(r.backgroundId);
+  assert.strictEqual(eng2.listBgJobs().length, 0);
+  assert.ok(!fs.existsSync(path.join(dir, r.backgroundId + '.jsonl')));
+  const raw = JSON.parse(fs.readFileSync(path.join(dir, 'bg-jobs.json'), 'utf8'));
+  assert.ok(!raw.jobs.some((j) => j.id === r.backgroundId), 'silinen iş diske geri yazılmaz');
+
+  /* gerçek uygulamada tek motor olur; burada eski örneği de uyumlaştır */
+  eng1._bgJobs.delete(r.backgroundId);
+
+  /* eski motorun geç tetiklenen send'i kaydı diriltmesin */
+  return new Promise((resolve) => setTimeout(resolve, 300)).then(() => {
+    const raw2 = JSON.parse(fs.readFileSync(path.join(dir, 'bg-jobs.json'), 'utf8'));
+    assert.ok(!raw2.jobs.some((j) => j.id === r.backgroundId), 'geç gelen _bgEmit hayır demedi');
+  });
+});
+
+/* ---------- #18 fan-out + #5 eşzamanlılık kuyruğu ---------- */
+
+test('fan-out: adımlar aynı grupta açılır, hepsi bitince TEK birleşik rapor düşer', async () => {
+  const { eng } = tmpEngine();
+  const r = eng.runBackgroundMany(
+    'pg',
+    [
+      { title: 'TR', task: 'tr haberlerini topla' },
+      { title: 'DÜNYA', task: 'dünya haberlerini topla' },
+      { title: 'EKONOMİ', task: 'ekonomi haberlerini topla' },
+    ],
+    'Haber Taraması'
+  );
+  assert.ok(r.ok, 'fan-out başladı');
+  assert.strictEqual(r.ids.length, 3);
+  const groups = new Set([...eng._bgJobs.values()].map((j) => j.groupId));
+  assert.strictEqual(groups.size, 1);
+  for (const id of r.ids) await eng.reportBackgroundDone(id);
+
+  const s = eng._load('pg');
+  const got = s.messages.some((m) => String(m.content || '').includes('[ARKA PLAN GRUP BİTTİ: 3/3]'));
+  assert.ok(got, 'birleşik rapor düştü');
+});
+
+test('#5 eşzamanlılık limiti: fazlası kuyrukta bekler, slot boşalınca FIFO başlar', async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'beast-q-'));
+  const eng = new Engine({}, { sessionsDir: dir, emit: () => {}, bgLimit: 2 });
+  /* model yok → gerçek _run hata ile derhal bitmesin: gönderimi izlemeye al */
+  const sent = [];
+  eng.send = (sid, payload) => { sent.push(String(sid)); return true; };
+  const ids = [];
+  for (let i = 0; i < 4; i++) {
+    const r = eng.runBackground('pq', 'iş ' + i, 'İ' + i);
+    ids.push(r.backgroundId);
+  }
+  await sleep(120); // admit zamanlayıcıları
+  let st = [...eng._bgJobs.values()].map((j) => j.status).sort();
+  assert.deepEqual(st, ['queued', 'queued', 'running', 'running']);
+  assert.strictEqual(sent.length, 2);
+
+  /* slot açılır → sıradaki queued iş running olur ve gönderilir */
+  eng._bgFinish(ids[0], 'aborted');
+  await sleep(30);
+  const queued = [...eng._bgJobs.values()].filter((j) => j.status === 'queued').length;
+  const running = [...eng._bgJobs.values()].filter((j) => j.status === 'running').length;
+  assert.strictEqual(queued, 1);
+  assert.strictEqual(running, 2);
+  assert.strictEqual(sent.length, 3);
+});
+
+/* ---------- /stop anahtarı ---------- */test('stopAll: koşan turları keser, paralel ajanı aborted işaretler', async () => {
+  const { eng } = tmpEngine();
+  const r = eng.runBackground('pS', 'koşan iş', 'Koşu');
+  const id = r.backgroundId;
+
+  /* sahte koşan tur: ctrls'e AbortController koy */
+  const c1 = new AbortController();
+  const c2 = new AbortController();
+  eng.ctrls.set(id, c1);          // paralel ajan
+  eng.ctrls.set('main-sid', c2);  // masaüstü oturumu
+  /* bekleyen rapor kuyruğu da dolu olsun */
+  eng._pendingReports = [{ parentId: 'pS', text: 'eski rapor' }];
+
+  const n = eng.stopAll();
+
+  assert.strictEqual(n, 2);
+  assert.ok(c1.signal.aborted && c2.signal.aborted);
+  assert.strictEqual(eng._bgJobs.get(id).status, 'aborted');
+  assert.ok(eng._bgJobs.get(id).endedAt);
+  assert.strictEqual(eng._pendingReports.length, 0);
+  /* events'te agents yayını var */
+  assert.ok(eng.listBgJobs()[0].status === 'aborted');
+
+  /* ikinci çağrı idempotent: gerçek akışta _run finally ctrl'i siler */
+  eng.ctrls.delete(id);
+  eng.ctrls.delete('main-sid');
+  assert.strictEqual(eng.stopAll(), 0);
+});

package/tests/bus.test.js

@@ -0,0 +1,46 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+
+/* bus saf parçaları: decide/compareOp/emitEvent (hooks.notify stub'lı) */
+const bus = require('../src/agent/bus');
+
+test('bus: sayısal filtre op\u2019ları', () => {
+  assert.ok(bus.compareOp('lt', 2500, 2600));
+  assert.ok(bus.compareOp('gte', 2600, 2600));
+  assert.ok(!bus.compareOp('gt', 2599, 2600));
+});
+
+test('bus: decide — filtre + cooldown mantığı', () => {
+  const sub = { type: 'price:tick', op: 'lte', value: 2600, cooldownMin: 10, lastNotifiedAt: 0 };
+  const now = Date.now();
+  // koşul dışı
+  assert.equal(bus.decide(sub, { type: 'price:tick', value: 2700 }, now).hit, false);
+  // yanlış tip
+  assert.equal(bus.decide(sub, { type: 'mail:new' }, now).hit, false);
+  // koşul içi ilk kez → tetik
+  const d1 = bus.decide(sub, { type: 'price:tick', value: 2550 }, now);
+  assert.ok(d1.hit && !d1.cooled);
+  // hemen ardından → cooldown'a takılır ama hit'tir
+  sub.lastNotifiedAt = now;
+  const d2 = bus.decide(sub, { type: 'price:tick', value: 2500 }, now + 60000);
+  assert.ok(d2.hit && d2.cooled);
+});
+
+test('bus: addSub doğrulama + emitEvent dağıtımı', () => {
+  assert.equal(bus.addSub({ type: 'yok', sessionId: 's1' }).ok, false);
+  assert.equal(bus.addSub({ type: 'price:tick', sessionId: 's1' }).ok, true); // filtresiz genel abonelik
+
+  let notified = 0;
+  // notify hook'u start ile gelir; emitEvent hooks.notify'i kullanır
+  const before = bus.listSubs().length;
+  assert.ok(before >= 1);
+  // fiyat tick yolla — cooldown zaten 10dk varsayılan; ikinci çağrı cooled olmalı
+  const fired1 = bus.emitEvent('price:tick', { symbol: 'PAXGUSDT', price: 100 }, Date.now());
+  const fired2 = bus.emitEvent('price:tick', { symbol: 'PAXGUSDT', price: 101 }, Date.now() + 1000);
+  assert.ok(fired1 >= fired2); // en az ilk seferde tetiklenmiş olmalı
+  // temizle
+  for (const s of bus.listSubs()) bus.removeSub(s.id);
+});

package/tests/computeruse-context.test.js

@@ -0,0 +1,69 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+const Engine = require('../src/agent/engine');
+
+/* computeruse: modül surface + koordinat/girdi kırpma (network'süz) */
+test('#4 computer use: op doğrulama ve sınırlar', async () => {
+  const cu = require('../src/agent/computeruse');
+  const r1 = await cu.act('yokboyleop', {});
+  assert.equal(r1.ok, false);
+  const r2 = await cu.act('type', { text: '' });
+  assert.equal(r2.ok, false);
+  const r3 = await cu.act('key', { combo: '' });
+  assert.equal(r3.ok, false);
+  const r4 = await cu.act('scroll', { dy: 0 });
+  assert.equal(r4.ok, false);
+  /* bilinmeyen op dışındaki gerçek aksiyonlar PowerShell ister; çağrılmaz */
+});
+
+/* #6 bağlam sıkıştırma: notlar öze dönüşünce eski mesajlar diskten de düşer */
+test('#6 compaction: _compactToNotes dosyayı metaya+notlara+son pencereye indirger', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'beast-cx-'));
+  const eng = new Engine({}, { sessionsDir: dir });
+  const s = eng.createSession();
+  /* createSession bir meta satırı yazdı; cache'i atla — ham dosyaya mesaj ekleyip
+     YENİ engine ile yüklüyoruz (cache trick yok) */
+  const file = path.join(dir, s.id + '.jsonl');
+  const lines = [JSON.stringify({ t: 'meta', id: s.id, code: 'ABC234', createdAt: new Date().toISOString() })];
+  for (let i = 0; i < 20; i++) {
+    lines.push(JSON.stringify({ t: 'msg', role: i % 2 ? 'assistant' : 'user', content: 'mesaj-' + i }));
+  }
+  fs.writeFileSync(file, lines.join('\n') + '\n');
+
+  const eng2 = new Engine({}, { sessionsDir: dir }); // taze cache — dosyadan okur
+  const sess = eng2._load(s.id);
+  assert.equal(sess.messages.length, 20);
+  sess.notes = 'eski önemli noktalar:\n- karar A\n- karar B';
+  sess.code = sess.code || 'ABC234';
+  eng2._compactToNotes(sess, 14);
+
+  // dosyayı yeniden oku
+  const raw = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+  const metas = raw.filter((r) => r.t === 'meta');
+  const notesRows = raw.filter((r) => r.t === 'notes');
+  const msgRows = raw.filter((r) => r.t === 'msg');
+  const compacted = raw.filter((r) => r.t === 'compacted');
+  assert.equal(metas.length, 1);
+  assert.ok(metas[0].code, 'kod korunmalı');
+  assert.equal(notesRows.length, 1);
+  assert.match(notesRows[0].text, /karar A/);
+  assert.equal(notesRows[0].at, 0); // notesAt sıfırlandı
+  assert.ok(msgRows.length <= 6, `korunan pencere ≤6=KEEP_RECENT*2 (gerçek ${msgRows.length})`);
+  assert.ok(msgRows.every((m) => Number(m.content.split('-')[1]) >= 14), 'yalnız cut sonrası kaldı');
+  assert.equal(compacted.length, 1);
+
+  // yeniden yükleme tutarlı
+  const reloaded = new Engine({}, { sessionsDir: dir });
+  const again = reloaded._load(s.id);
+  assert.equal(again.code, 'ABC234');
+  assert.ok(again.messages.length <= 12);
+  assert.match(String(again.notes || ''), /karar A/);
+
+  fs.rmSync(dir, { recursive: true, force: true });
+});

package/tests/cron.test.js

@@ -0,0 +1,95 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const cron = require('../src/cron');
+
+test('geçersiz cron ifadeleri reddedilir', () => {
+  assert.equal(cron.parseCron('* * * *'), null);
+  assert.equal(cron.parseCron('61 * * * *'), null);
+  assert.equal(cron.parseCron('* 25 * * *'), null);
+  assert.equal(cron.parseCron('a b c d e'), null);
+});
+
+test('geçerli cron ifadeleri ayrışır', () => {
+  assert.ok(cron.parseCron('* * * * *'));
+  assert.ok(cron.parseCron('*/15 * * * *'));
+  assert.ok(cron.parseCron('0 9 * * 1-5'));
+  assert.ok(cron.parseCron('30 21 1,15 * *'));
+});
+
+/* Sabit tarih: 2026-08-25 Salı 10:00 */
+function at(min, h, day, mon) {
+  return new Date(2026, mon - 1, day, h, min, 0);
+}
+
+test('nextRunFrom sıradaki uyarın anını bulur', () => {
+  // Her saat başı: 10:00'dan sonraki = 11:00
+  const n = new Date(cron.nextRunFrom('0 * * * *', at(0, 10, 25, 8)));
+  assert.equal(n.getHours(), 11);
+  assert.equal(n.getMinutes(), 0);
+
+  // Günlük 09:00: salı 10:00'dan sonra → çarşamba 09:00
+  const d = new Date(cron.nextRunFrom('0 9 * * *', at(0, 10, 25, 8)));
+  assert.equal(d.getDate(), 26);
+  assert.equal(d.getHours(), 9);
+
+  // Hafta içi (Pzt-Cum): salıdan sonraki aynı gün 21:00
+  const w = new Date(cron.nextRunFrom('0 21 * * 1-5', at(30, 20, 25, 8)));
+  assert.equal(w.getDay(), 2); // salı
+  assert.equal(w.getHours(), 21);
+});
+
+test('add: bozuk schedule reddedilir, düzgün olan nextRun alır', () => {
+  const bad = cron.add({ name: 'x', schedule: 'yok', prompt: 'p' });
+  assert.equal(bad.ok, false);
+  const good = cron.add({ name: 'deneme', schedule: '*/5 * * * *', prompt: 'saati söyle' });
+  assert.equal(good.ok, true);
+  assert.ok(good.job.nextRunAt > Date.now());
+  assert.equal(cron.list().some((j) => j.id === good.job.id), true);
+});
+
+test('toggle + remove çalışır', () => {
+  const r = cron.add({ name: 't2', schedule: '0 12 * * *', prompt: 'p' });
+  const id = r.job.id;
+  const t = cron.toggle(id);
+  assert.equal(t.job.enabled, false);
+  assert.equal(t.job.nextRunAt, null);
+  assert.equal(cron.remove(id).ok, true);
+});
+
+/* ---------- reminderSchedule: tekrarlı hatırlatma ---------- */
+
+test('reminderSchedule: presetler when\u0027den saat üretir', () => {
+  // 2026-08-26 Çarşamba 09:00
+  const w = '2026-08-26T09:00';
+
+  const daily = cron.reminderSchedule(w, 'daily');
+  assert.equal(daily.ok, true);
+  assert.equal(daily.schedule, '0 9 * * *');
+
+  const weekdays = cron.reminderSchedule(w, 'weekdays');
+  assert.equal(weekdays.schedule, '0 9 * * 1-5');
+
+  const weekly = cron.reminderSchedule(w, 'weekly');
+  assert.equal(weekly.schedule, '0 9 * * 3'); // çarşamba
+
+  const monthly = cron.reminderSchedule(w, 'monthly');
+  assert.equal(monthly.schedule, '0 9 26 * *');
+
+  // dakika korunmalı
+  const dm = cron.reminderSchedule('2026-08-26T09:30', 'daily');
+  assert.equal(dm.schedule, '30 9 * * *');
+});
+
+test('reminderSchedule: doğrudan cron kabul, bozuk ve bilinmeyen reddedilir', () => {
+  const raw = cron.reminderSchedule(null, '*/30 * * * *');
+  assert.equal(raw.ok, true);
+  assert.equal(raw.schedule, '*/30 * * * *');
+
+  assert.equal(cron.reminderSchedule('2026-08-26T09:00', '').ok, false);
+  assert.equal(cron.reminderSchedule('2026-08-26T09:00', 'hergun').ok, false);
+  assert.equal(cron.reminderSchedule('zaman değil', 'daily').ok, false);
+  assert.equal(cron.reminderSchedule(null, '61 * * * *').ok, false);
+});