beast-agent 0.15.0

package/tests/python.test.js

@@ -0,0 +1,75 @@
+'use strict';
+
+/* #18 python_run altyapısı testleri — ağ çağrısı YOK */
+
+const test = require('node:test');
+const assert = require('node:assert');
+const tools = require('../src/agent/tools');
+
+test('python_run tanımı TOOLS içinde', () => {
+  const def = tools.definitions.find((d) => d.function.name === 'python_run');
+  assert.ok(def, 'python_run var');
+  const props = def.function.parameters.properties;
+  for (const k of ['code', 'script', 'args', 'timeout_ms']) assert.ok(props[k], k);
+});
+
+test('code/script yoksa net hata döner (interpreter araması bile gerekmez)', async () => {
+  const out = await tools.exec('python_run', {}, { cwd: process.cwd(), allowDownload: false });
+  const r = JSON.parse(out);
+  assert.strictEqual(r.ok, false);
+  assert.ok(/code ya da script/.test(r.error), r.error);
+});
+
+test('olmayan script: interpreter bakılmadan bulunamadı + klasör ipucu döner', async () => {
+  const out = await tools.exec(
+    'python_run',
+    { script: 'kesinlikle-yok-abc123.py' },
+    { cwd: process.cwd(), allowDownload: false }
+  );
+  const r = JSON.parse(out);
+  assert.strictEqual(r.ok, false);
+  assert.match(String(r.error || ''), /bulunamadı/);
+  assert.match(String(r.hint || ''), /scripts/, 'klasör ipucu verildi');
+});
+
+test('scripts klasörü çözümlenir ve oluşturulur', () => {
+  const dir = tools.pythonScriptsDir();
+  assert.ok(typeof dir === 'string' && dir.length > 0);
+});
+
+test('paketlenmiş python scriptleri mevcut ve tohumlanır', () => {
+  for (const name of ['websearch.py', 'news.py']) {
+    assert.ok(require('fs').existsSync(tools.bundledScriptPath(name)), 'paket içi: ' + name);
+    const dest = tools.seedScript(name);
+    assert.ok(require('fs').existsSync(dest), 'tohumlandı: ' + dest);
+  }
+});
+
+/* canlı: python hızlı arama yolu (ağ varsa gerçek sonuç, yoksa JS fallback) */
+test('webSearchFast: python yolu ya da fallback sonuç döner', async function () {
+  const r = await tools.webSearchFast('electron builder portable windows', { maxResults: 5 });
+  assert.strictEqual(r.ok, true);
+  if (!r.results.length) return this.skip('motorlar bu turda sonuç döndürmedi (ağ/rate-limit) — kablaj doğru');
+  assert.ok(r.results[0].title && r.results[0].url);
+}, { timeout: 40000 });
+
+/* canlı python varsa (BEAST_PYTHON / sistem / önceden kurulmuş gömülü):
+   gerçek bir hesap çalıştırılır — ağ kurulumu yapılmaz */
+test('canlı interpreter ile inline code çalışır (kuruluysa)', async () => {
+  let py = null;
+  try { py = await tools.findSystemPython(); } catch {}
+  if (!py) {
+    try { fsAccess(tools.embeddedPythonExe()); } catch { return test.skip('interpreter yok — atlandı'); }
+  }
+  const out = await tools.exec(
+    'python_run',
+    { code: 'print(21*2)' },
+    { cwd: process.cwd(), allowDownload: false }
+  );
+  const r = JSON.parse(out);
+  if (r.ok) assert.ok(/42/.test(r.output), 'çıktı: ' + r.output);
+}, { timeout: 30000 });
+
+function fsAccess(p) {
+  require('fs').accessSync(p);
+}

package/tests/scenarios.json

@@ -0,0 +1,81 @@
+{
+  "note": "Beast eval senaryoları (#4). Her senaryo offline doğrulanabilir olmalı: ya modül fonksiyonu çağrılır ya da prompt/sistem davranışı regex ile kontrol edilir. LLM çağıran uçtan uca testler burada DEĞİL — maliyet ve kararsızlık nedeniyle.",
+  "scenarios": [
+    {
+      "id": "cron-invalid-rejected",
+      "desc": "Bozuk cron ifadesi kabul edilmez",
+      "module": "cron",
+      "call": { "fn": "parseCron", "args": ["61 * * * *"] },
+      "expectNull": true
+    },
+    {
+      "id": "reminder-daily-schedule",
+      "desc": "Tekrarlı hatırlatma daily preset doğru cron üretir",
+      "module": "cron",
+      "call": { "fn": "reminderSchedule", "args": ["2026-08-27T09:00", "daily"] },
+      "expectEquals": { "schedule": "0 9 * * *" }
+    },
+    {
+      "id": "watcher-edge-trigger",
+      "desc": "İzleyici kenar tetiklemeli: koşul doğruyken tek atış",
+      "module": "watchers",
+      "manual": true,
+      "coveredBy": "watchers.test.js"
+    },
+    {
+      "id": "wa-multi-message-merge",
+      "desc": "Ard arda WA mesajları tek pakette birleşir",
+      "module": "main",
+      "manual": true,
+      "coveredBy": "manuel (wa.log queue→flush→perm zinciri)"
+    },
+    {
+      "id": "session-code-format",
+      "desc": "Oturum kodu 6 haneli, karıştırılan harfler yok",
+      "module": "engine",
+      "coveredBy": "sessioncode.test.js"
+    },
+    {
+      "id": "reflection-json-parse",
+      "desc": "Yansıma JSON'u fence'li/gömülü olsa da ayrışır",
+      "module": "engine",
+      "coveredBy": "v11.test.js"
+    },
+    {
+      "id": "kb-search-citation",
+      "desc": "kb_search sonucu citation taşır",
+      "module": "kb",
+      "check": "citation"
+    },
+    {
+      "id": "memory-hygiene-dedup",
+      "desc": "Duplike hafıza kayıtları tekilleşir",
+      "module": "memory",
+      "coveredBy": "eval.test.js"
+    },
+    {
+      "id": "system-prompt-has-local-time",
+      "desc": "Sistem promptu yerel tarih/saat bildirir",
+      "module": "engine",
+      "regex": "Yerel saat:"
+    },
+    {
+      "id": "system-prompt-rules-injected",
+      "desc": "Kalıcı kurallar sistem promptuna girer",
+      "module": "engine",
+      "check": "rules"
+    },
+    {
+      "id": "usage-cost-math",
+      "desc": "Maliyet hesabı (1M token fiyatıyla) doğru",
+      "module": "usage",
+      "coveredBy": "usage.test.js"
+    },
+    {
+      "id": "bus-price-filter",
+      "desc": "Fiyat olayı eşiğiyle filtrelenir",
+      "module": "bus",
+      "coveredBy": "bus.test.js"
+    }
+  ]
+}

package/tests/sessioncode.test.js

@@ -0,0 +1,50 @@
+'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');
+
+function mkEng() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'beast-code-'));
+  return new Engine({}, { sessionsDir: dir });
+}
+
+test('oturum kodu: benzersiz, formatta, meta\u2019dan geri yüklenir', () => {
+  const eng = mkEng();
+  const a = eng.createSession();
+  const b = eng.createSession();
+  assert.match(a.code, /^[23456789ABCDEFGHJKMNPQRSTUVWXYZ]{6}$/);
+  assert.notEqual(a.code, b.code);
+
+  // cache temizlenmiş gibi: yeni engine aynı dosyadan code okumalı
+  const eng2 = new Engine({}, { sessionsDir: eng.sessionsDir });
+  const view = eng2.listSessions().find((s) => s.id === a.id);
+  assert.equal(view.code, a.code);
+});
+
+test('findByCode: kod ile oturumu bulur, hızlı indeks kullanır', async () => {
+  const eng = mkEng();
+  const v = eng.createSession();
+  // gerçek bir mesaj yaz → dosya oluşsun
+  eng.send(v.id, { text: 'merhaba' });
+  await new Promise((r) => setTimeout(r, 30));
+  const hit = eng.findByCode(v.code);
+  assert.ok(hit);
+  assert.equal(hit.id, v.id);
+  assert.equal(eng.findByCode('ZZZZZZ'), null);
+  assert.equal(eng.findByCode(v.code.toLowerCase()).id, v.id);
+  fs.rmSync(eng.sessionsDir, { recursive: true, force: true });
+});
+
+test('ORTAM: yerel tarih/saat/dilim prompta girer', () => {
+  const eng = mkEng();
+  const sys = eng.buildSystem('test');
+  assert.match(sys, /Yerel tarih:/);
+  assert.match(sys, /Yerel saat:/);
+  assert.match(sys, /UTC varsayma/);
+  fs.rmSync(eng.sessionsDir, { recursive: true, force: true });
+});

package/tests/setup.js

@@ -0,0 +1,9 @@
+'use strict';
+
+/* Ortak test kurulumu: tüm modüller izole BEAST_DATA altına yazsın. */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'beast-test-'));
+process.env.BEAST_DATA = path.join(tmp, 'data');

package/tests/tokens.test.js

@@ -0,0 +1,42 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const { estTokens, estMsgTokens } = require('../src/agent/tokens');
+
+test('estTokens boş metin 0', () => {
+  assert.equal(estTokens(''), 0);
+  assert.equal(estTokens(null), 0);
+});
+
+test('estTokens uzunlukla monoton artar', () => {
+  const a = estTokens('hello world');
+  const b = estTokens('hello world and more words here');
+  assert.ok(a > 0 && b > a);
+});
+
+test('geniş karakterler (CJK/emoji) daha pahalı', () => {
+  const ascii = estTokens('aaaa');
+  const wide = estTokens('\u4e00\u4e01\u4e02\u4e03'); // 4 CJK karakter
+  assert.ok(wide > ascii);
+});
+
+test('Türkçe karakterler ASCII\u0027den hafif pahalı', () => {
+  assert.ok(estTokens('ğğğğ') >= estTokens('aaaa'));
+});
+
+test('estMsgTokens mesaj zarfı ekler', () => {
+  const m = { role: 'user', content: 'selam' };
+  assert.ok(estMsgTokens(m) > estTokens('selam'));
+});
+
+test('tool_calls içeren mesaj daha ağır', () => {
+  const base = { role: 'assistant', content: 'x' };
+  const withTools = {
+    role: 'assistant',
+    content: 'x',
+    tool_calls: [{ id: '1', type: 'function', function: { name: 'run_command', arguments: '{"command":"dir"}' } }],
+  };
+  assert.ok(estMsgTokens(withTools) > estMsgTokens(base));
+});

package/tests/tools.test.js

@@ -0,0 +1,84 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const tools = require('../src/agent/tools');
+
+/* ---------- SSRF guard ---------- */
+
+test('public URL kabul edilir', () => {
+  const u = tools.assertPublicHttpUrl('https://example.com/x?y=1');
+  assert.ok(u.startsWith('https://example.com'));
+});
+
+test('localhost ve özel ağlar engellenir', () => {
+  const bad = [
+    'http://localhost/a',
+    'http://127.0.0.1/',
+    'http://10.0.0.5/',
+    'http://192.168.1.1/',
+    'http://172.16.0.1/',
+    'http://172.31.255.255/',
+    'http://169.254.169.254/meta',
+    'http://pc.local/',
+    'file:///C:/Windows',
+    'ftp://example.com',
+    'http://[::1]/',
+    'http://user:pass@example.com/',
+  ];
+  for (const u of bad) assert.throws(() => tools.assertPublicHttpUrl(u));
+});
+
+test('geçersiz URL atar', () => {
+  assert.throws(() => tools.assertPublicHttpUrl('not a url'));
+});
+
+/* ---------- DDG parser ---------- */
+
+test('parseDdgResults sonuçları ayrıştırır', () => {
+  const html = `
+  <div class="result results_links">
+    <a rel="nofollow" class="result__a" href="//duckduckgo.com/l/?uddg=https%3A%2F%2Fexample.com%2Fa&amp;rut=abc">Örnek <b>Başlık</b></a>
+    <a class="result__snippet" href="#">Açıklama &amp; özet</a>
+  </div>
+  <div class="result">
+    <a class="result__a" href="https://direct.com/b">Direkt</a>
+    <a class="result__snippet">snpt</a>
+  </div>`;
+  const out = tools.parseDdgResults(html);
+  assert.equal(out.length, 2);
+  assert.equal(out[0].url, 'https://example.com/a');
+  assert.equal(out[0].title, 'Örnek Başlık');
+  assert.ok(out[0].snippet.includes('özet'));
+  assert.equal(out[1].url, 'https://direct.com/b');
+});
+
+test('parseDdgResults boş HTML\u0027de boş döner', () => {
+  assert.deepEqual(tools.parseDdgResults('<html></html>'), []);
+});
+
+/* ---------- htmlToText ---------- */
+
+test('htmlToText script/style temizler', () => {
+  const t = tools.htmlToText('<head><style>p{color:red}</style><script>evil()</script></head><body><p>Merhaba</p> dünya</body>');
+  assert.ok(t.includes('Merhaba'));
+  assert.ok(!t.includes('evil'));
+  assert.ok(!t.includes('color:red'));
+});
+
+/* ---------- dosya araçları ---------- */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+test('exec write/read/list turu', async () => {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'beast-tools-'));
+  const w = JSON.parse(await tools.exec('write_file', { path: 'alt/dosya.txt', content: 'içerik' }, { cwd }));
+  assert.ok(w.ok);
+  const r = JSON.parse(await tools.exec('read_file', { path: 'alt/dosya.txt' }, { cwd }));
+  assert.equal(r.content, 'içerik');
+  const l = JSON.parse(await tools.exec('list_dir', {}, { cwd }));
+  assert.ok(l.entries.split('\n')[0].includes('alt'));
+});

package/tests/usage.test.js

@@ -0,0 +1,44 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const usageMod = require('../src/agent/usage');
+
+test('usage: kayıt + bugün/ay raporu + maliyet hesabı', () => {
+  usageMod.reset();
+
+  /* maliyetsiz çağrı */
+  usageMod.record({ providerId: 'p1', model: 'm1', promptTokens: 1000, completionTokens: 500 });
+  /* fiyatlı çağrı: $2/M giriş, $8/M çıkış → (2000*2 + 1000*8)/1e6 = $0.012 */
+  usageMod.record({
+    providerId: 'p1',
+    model: 'm2',
+    promptTokens: 2000,
+    completionTokens: 1000,
+    costIn: 2,
+    costOut: 8,
+  });
+  /* sıfır/eksik token — sayılmaz */
+  usageMod.record({});
+  usageMod.record({ providerId: 'pX', model: 'mY' });
+
+  const rep = usageMod.report();
+  assert.equal(rep.today.total.calls, 2);
+  assert.equal(rep.today.total.pin, 3000);
+  assert.equal(rep.today.total.pout, 1500);
+  assert.ok(Math.abs(rep.today.total.cost - 0.012) < 1e-9);
+
+  const byModel = Object.fromEntries(rep.today.models.map((m) => [m.model, m]));
+  assert.equal(byModel['p1::m1'].calls, 1);
+  assert.equal(byModel['p1::m1'].cost, 0);
+  assert.equal(byModel['p1::m2'].calls, 1);
+
+  /* ay raporu aynı günü kapsar */
+  assert.equal(rep.month.total.calls, 2);
+
+  /* reset gerçekten temizler */
+  usageMod.reset();
+  const rep2 = usageMod.report();
+  assert.equal(rep2.today.total.calls, 0);
+});

package/tests/v11.test.js

@@ -0,0 +1,76 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const Engine = require('../src/agent/engine');
+
+/* parseReflectionJson: düz / fence'li / gömülü JSON + bozuk girdi */
+test('reflection JSON ayrıştırıcı', () => {
+  const good = Engine.parseReflectionJson(
+    '{"create": true, "name": "rapor-al", "description": "d", "body": "# Rapor\\n- adım"}'
+  );
+  assert.equal(good.create, true);
+  assert.equal(good.name, 'rapor-al');
+
+  const fenced = Engine.parseReflectionJson(
+    'İşte öneri:\n```json\n{"create": false}\n```\nbitti'
+  );
+  assert.equal(fenced.create, false);
+
+  const embedded = Engine.parseReflectionJson(
+    'önce metin {"create": true, "name": "x", "description": "y", "body": "z"} sonra metin'
+  );
+  assert.equal(embedded.name, 'x');
+
+  assert.equal(Engine.parseReflectionJson('JSON yok burada'), null);
+  assert.equal(Engine.parseReflectionJson('{bozuk'), null);
+});
+
+/* skills taslak yaşam döngüsü */
+test('skills draft: add → list → accept → scan\u2019de görünür', () => {
+  const skills = require('../src/agent/skills');
+  const r = skills.addDraft({
+    name: 'Test Yetenek',
+    description: 'deneme taslağı',
+    body: '# Test Yetenek\n- adım bir',
+  });
+  assert.ok(r.ok);
+
+  const drafts = skills.listDrafts();
+  const d = drafts.find((x) => x.id === 'test-yetenek');
+  assert.ok(d, 'taslak listede olmalı');
+
+  // scan taslağı GÖRMEMELİ
+  assert.ok(!skills.scan().some((s) => s.name === 'Test Yetenek'));
+
+  // kabul → kurulur, taslak silinir
+  const acc = skills.acceptDraft('test-yetenek');
+  assert.ok(acc.ok);
+  assert.ok(skills.scan().some((s) => s.name === 'Test Yetenek'));
+  assert.ok(!skills.listDrafts().some((x) => x.id === 'test-yelenek' || x.id === 'test-yetenek'));
+
+  // temizlik
+  const folder = require('path').join(skills.dir(), 'test-yetenek');
+  require('fs').rmSync(folder, { recursive: true, force: true });
+});
+
+/* kural hattı (#3) */
+test('rules: ekle/liste/çıkar + skill\u2019e madde', () => {
+  const memory = require('../src/agent/memory');
+  const before = memory.listRules();
+  const r = memory.addRule('Terminal çıktısını asla kısaltma');
+  assert.ok(r.ok);
+  const after = memory.listRules();
+  assert.equal(after.length, before.length + 1);
+  assert.ok(after.some((x) => x.includes('Terminal çıktısını')));
+
+  // dup
+  const dup = memory.addRule('Terminal çıktısını asla kısaltma');
+  assert.ok(dup.duplicate);
+
+  // kaldır
+  const rm = memory.removeRule('Terminal çıktısını asla kısaltma');
+  assert.ok(rm.ok);
+  assert.ok(!memory.listRules().some((x) => x.includes('Terminal çıktısını')));
+});

package/tests/watchers.test.js

@@ -0,0 +1,206 @@
+'use strict';
+
+require('./setup');
+const test = require('node:test');
+const assert = require('node:assert');
+const watchers = require('../src/agent/watchers');
+
+const T0 = new Date('2026-08-26T12:00:00Z').getTime();
+
+test('normalize: web izleyicisi minimal alanlarla kurulur', () => {
+  const r = watchers.normalize({ name: 'BTC', kind: 'web', url: 'https://api.x.com/p', value: 100000 });
+  assert.ok(!r.error);
+  assert.equal(r.watcher.kind, 'web');
+  assert.equal(r.watcher.op, 'lte'); // varsayılan
+  assert.equal(r.watcher.everyMin, 15);
+  assert.equal(r.watcher.enabled, true);
+  assert.equal(r.watcher.armed, true);
+});
+
+test('normalize: battery için url gerekmez, web için zorunlu', () => {
+  const b = watchers.normalize({ name: 'Pil', kind: 'battery', value: 20 });
+  assert.ok(!b.error);
+  const w = watchers.normalize({ name: 'X', kind: 'web', value: 1 });
+  assert.ok(w.error);
+});
+
+test('normalize: geçersiz kind / regex / eksik eşik reddedilir', () => {
+  assert.ok(watchers.normalize({ name: 'x', kind: 'uzay' }).error);
+  assert.ok(watchers.normalize({ name: 'x', kind: 'web', url: 'https://a.b', re: '[' }).error);
+  assert.ok(watchers.normalize({ name: 'x', kind: 'web', url: 'https://a.b', op: 'lt' }).error); // value yok
+  assert.ok(watchers.normalize({ kind: 'battery', value: 1 }).error); // isim yok
+  assert.ok(watchers.normalize({ name: 'x', kind: 'web', url: 'ftp://a.b' }).error);
+});
+
+test('normalize: changed opsiyonu value olmadan çalışır, aralık kelepçelenir', () => {
+  const r = watchers.normalize({ name: 'sayfa', kind: 'web', url: 'https://a.b', op: 'changed', everyMin: 1, cooldownMin: 99999 });
+  assert.ok(!r.error);
+  assert.equal(r.watcher.everyMin, 1); // #22: 1 dakika artık geçerli
+  assert.equal(r.watcher.cooldownMin, 10080);
+  /* saniye aralığı: everySec esas alınır, everyMin uyumluluk için türetilir */
+  const s = watchers.normalize({ name: 'sn', kind: 'web', url: 'https://a.b', op: 'changed', everySec: 30 });
+  assert.ok(!s.error);
+  assert.equal(s.watcher.everySec, 30);
+  assert.equal(s.watcher.everyMin, 1);
+  const s2 = watchers.normalize({ name: 'sn2', kind: 'web', url: 'https://a.b', op: 'changed', everySec: 3 });
+  assert.equal(s2.watcher.everySec, 10); // min 10 sn
+});
+
+test('compare: sayısal zorlama ve değişmez karşılaştırma', () => {
+  assert.ok(watchers.compare('lte', '19.9', 20));
+  assert.ok(watchers.compare('gt', 30, 29));
+  assert.ok(watchers.compare('eq', 100, '100'));
+  assert.ok(watchers.compare('neq', 5, 6));
+  assert.ok(!watchers.compare('lt', 'abc', 10)); // sayıya dönmez
+  assert.ok(watchers.compare('changed', 'yeni', 'eski'));
+  assert.ok(!watchers.compare('changed', 'aynı', 'aynı'));
+});
+
+test('applyCheck: kenar tetiklemeli — bir kez ateşlenir, normale dönünce yeniden kurulur', () => {
+  const w = { op: 'lte', value: 20, armed: true, lastTriggeredAt: null };
+  const a = watchers.applyCheck(w, 18, T0);
+  assert.ok(a.triggered);
+  assert.equal(a.patch.armed, false);
+  // koşul hâlâ doğru ama armed=false → tekrar ateşlemez
+  const b = watchers.applyCheck({ ...w, ...a.patch }, 19, T0 + 1);
+  assert.ok(!b.triggered);
+  // normale döndü → armed=true
+  const c = watchers.applyCheck({ ...w, ...a.patch }, 55, T0 + 2);
+  assert.ok(!c.triggered);
+  assert.equal(c.patch.armed, true);
+  // tekrar eşik altına indi → yine ateşler
+  const d = watchers.applyCheck({ ...w, ...c.patch }, 10, T0 + 3);
+  assert.ok(d.triggered);
+});
+
+test('isDue: hiç kontrol edilmemişse vakti geldi, yeni kontrol edildiyse gelmedi', () => {
+  const fresh = { enabled: true, everyMin: 15, lastCheckAt: null };
+  assert.ok(watchers.isDue(fresh, T0));
+  const recent = { enabled: true, everyMin: 15, lastCheckAt: new Date(T0 - 5 * 60000).toISOString() };
+  assert.ok(!watchers.isDue(recent, T0));
+  const old = { enabled: true, everyMin: 15, lastCheckAt: new Date(T0 - 16 * 60000).toISOString() };
+  assert.ok(watchers.isDue(old, T0));
+  assert.ok(!watchers.isDue({ ...fresh, enabled: false }, T0));
+  /* #22 saniye aralığı */
+  const sn = { enabled: true, everySec: 30, lastCheckAt: new Date(T0 - 20000).toISOString() };
+  assert.ok(!watchers.isDue(sn, T0));
+  assert.ok(watchers.isDue({ ...sn, lastCheckAt: new Date(T0 - 31000).toISOString() }, T0));
+});
+
+test('cooldownActive: süre dolmadan aktif', () => {
+  const w = { cooldownMin: 60, lastTriggeredAt: new Date(T0 - 30 * 60000).toISOString() };
+  assert.ok(watchers.cooldownActive(w, T0));
+  const expired = { cooldownMin: 60, lastTriggeredAt: new Date(T0 - 61 * 60000).toISOString() };
+  assert.ok(!watchers.cooldownActive(expired, T0));
+  assert.ok(!watchers.cooldownActive({ cooldownMin: 60, lastTriggeredAt: null }, T0));
+});
+
+/* ---------- arka plan tick ---------- */
+
+const { extractValue } = watchers;
+
+test('extractValue: JSON path ve regex yolu', () => {
+  const w1 = { path: 'data.0.price.usd' };
+  assert.equal(extractValue('{"data":[{"price":{"usd":2377.5}}]}', w1), 2377.5);
+  assert.equal(extractValue('{"data":[]}', { path: 'data.0.price' }), null);
+
+  const w2 = { re: '<span id="p">([\\d.]+)</span>' };
+  assert.equal(extractValue('x<span id="p">99.9</span>y', w2), '99.9');
+
+  assert.throws(() => extractValue('{"a":1}', { kind: 'web' }), /path/);
+});
+
+test('tickOnce: kenar tetikleme + hata disiplini + changed semantiği', async () => {
+  // depoyu temizle
+  for (const w of watchers.list()) watchers.remove(w.id);
+
+  let fakeValue = 100;
+  let throws = false;
+
+  const r = watchers.add({
+    name: 'fiyat alarımı',
+    kind: 'web',
+    url: 'https://api.example.com/x',
+    path: 'price',
+    op: 'lte',
+    value: 90,
+    everyMin: 15,
+    cooldownMin: 0, // akışı gerçek zamanla bağımsız kılmak için kapalı
+  });
+  assert.ok(r.ok);
+
+  const deps = {
+    check: async () => {
+      if (throws) throw new Error('ağ koptu');
+      return fakeValue;
+    },
+  };
+  const rewDue = () =>
+    watchers.patch(r.watcher.id, { lastCheckAt: new Date(Date.now() - 16 * 60000).toISOString() });
+
+  // 1) eşik üstü → tetik yok
+  assert.equal((await watchers.tickOnce(deps)).length, 0);
+  assert.equal(watchers.list()[0].lastValue, 100);
+
+  // 2) henüz due değil (az önce kontrol edildi)
+  assert.equal((await watchers.tickOnce(deps)).length, 0);
+
+  // 3) eşiğe iner → bir kez tetik
+  fakeValue = 85;
+  rewDue();
+  const hit = await watchers.tickOnce(deps);
+  assert.equal(hit.length, 1);
+  assert.equal(hit[0].value, 85);
+
+  // 4) armed=false — koşul doğruyken tekrar tetiklemez
+  rewDue();
+  assert.equal((await watchers.tickOnce(deps)).length, 0);
+
+  // 5) normale döner (re-arm) ama hata modunda lastError yazılır
+  fakeValue = 120;
+  throws = true;
+  rewDue();
+  assert.equal((await watchers.tickOnce(deps)).length, 0);
+  assert.match(watchers.list()[0].lastError, /ağ koptu/);
+
+  // 6) hata düzelir → lastError temizlenir
+  throws = false;
+  rewDue();
+  assert.equal((await watchers.tickOnce(deps)).length, 0);
+  assert.equal(watchers.list()[0].lastError, '');
+
+  /* --- changed: sayfa değişikliği izleme --- */
+  const r2 = watchers.add({
+    name: 'sayfa değişimi',
+    kind: 'web',
+    url: 'https://a.b/c',
+    op: 'changed',
+    everyMin: 2,
+    cooldownMin: 0,
+  });
+  assert.ok(r2.ok, JSON.stringify(r2));
+  let html = '';
+  const deps2 = { check: async () => html };
+
+  // kuruluştaki referans boş — ilk kontrolde içerik görünür → tetik
+  html = '<h1>v1</h1>';
+  let evs = await watchers.tickOnce(deps2);
+  assert.equal(evs.length, 1);
+
+  // içerik sabitken tekrar tetiklenmez
+  await watchers.patch(r2.watcher.id, { lastCheckAt: new Date(Date.now() - 5 * 60000).toISOString() });
+  assert.equal((await watchers.tickOnce(deps2)).length, 0);
+
+  // içeriği eski haline getir (referans değerine dön) → re-arm
+  html = '';
+  await watchers.patch(r2.watcher.id, { lastCheckAt: new Date(Date.now() - 5 * 60000).toISOString() });
+  await watchers.tickOnce(deps2);
+
+  // tekrar değişir → yeniden tetik
+  html = '<h1>v2</h1>';
+  await watchers.patch(r2.watcher.id, { lastCheckAt: new Date(Date.now() - 5 * 60000).toISOString() });
+  evs = await watchers.tickOnce(deps2);
+  assert.equal(evs.length, 1);
+
+  for (const id of watchers.list().map((w) => w.id)) watchers.remove(id);
+});