rterm-backend 3.1.0 → 3.1.2

package/plugins/netdata-rterm/netdata-rterm.extreme.spec.ts

@@ -0,0 +1,252 @@
+import {
+  parseNetdataAlert, mapSeverity, buildFingerprint, toTriggerEvent, correlateWithRterm, register,
+} from './index.mjs'
+
+const cases: Array<{ name: string; run: () => void | Promise<void> }> = []
+function test(n: string, r: () => void | Promise<void>) { cases.push({ name: n, run: r }) }
+
+// ---- parseNetdataAlert ----
+test('parse: alert notification with all fields', () => {
+  const payload = {
+    message: 'CPU usage is 95%', alert: 'cpu_usage', info: 'CPU utilization too high',
+    chart: 'system.cpu', context: 'system.cpu', space: 'prod-cluster', family: 'cpu',
+    class: 'Error', severity: 'critical', date: '2026-07-22T10:00:00Z', duration: '5m',
+    additional_active_critical_alerts: 2, additional_active_warning_alerts: 1,
+    alert_url: 'https://app.netdata.cloud/alert/123',
+  }
+  const p = parseNetdataAlert(payload)
+  if (!p || p.kind !== 'alert') throw new Error('should parse alert')
+  if (p.alert !== 'cpu_usage') throw new Error('alert name')
+  if (p.severity !== 'critical') throw new Error('severity')
+  if (p.chart !== 'system.cpu') throw new Error('chart')
+  if (p.additionalCritical !== 2) throw new Error('additional critical')
+  if (p.host !== 'prod-cluster') throw new Error('host from space')
+  if (p.alertUrl !== 'https://app.netdata.cloud/alert/123') throw new Error('alert url')
+})
+
+test('parse: warning severity', () => {
+  const p = parseNetdataAlert({ alert: 'disk_space', severity: 'warning', message: 'Disk 80% full', space: 'web-01' })
+  if (!p || p.severity !== 'warning') throw new Error('should be warning')
+})
+
+test('parse: clear severity (alert resolved)', () => {
+  const p = parseNetdataAlert({ alert: 'cpu_usage', severity: 'clear', message: 'CPU back to normal', space: 'web-01' })
+  if (!p || p.severity !== 'clear') throw new Error('should be clear')
+})
+
+test('parse: reachability notification (node down)', () => {
+  const p = parseNetdataAlert({ message: 'Node unreachable', node: 'web-02', space: 'prod', status: 'down', date: '2026-07-22T10:00:00Z', duration: '2m' })
+  if (!p || p.kind !== 'reachability') throw new Error('should parse reachability')
+  if (p.status !== 'down') throw new Error('status')
+  if (p.host !== 'web-02') throw new Error('host from node')
+})
+
+test('parse: reachability notification (node up)', () => {
+  const p = parseNetdataAlert({ node: 'web-02', status: 'up', date: '2026-07-22T10:05:00Z' })
+  if (!p || p.status !== 'up') throw new Error('should be up')
+})
+
+test('parse: null for invalid payload', () => {
+  if (parseNetdataAlert(null) !== null) throw new Error('null payload')
+  if (parseNetdataAlert({}) !== null) throw new Error('empty object')
+  if (parseNetdataAlert('not an object') !== null) throw new Error('string')
+  if (parseNetdataAlert({ foo: 'bar' }) !== null) throw new Error('missing required fields')
+})
+
+// ---- mapSeverity ----
+test('mapSeverity: critical -> critical', () => {
+  if (mapSeverity('critical') !== 'critical') throw new Error('critical')
+})
+test('mapSeverity: warning -> warning', () => {
+  if (mapSeverity('warning') !== 'warning') throw new Error('warning')
+})
+test('mapSeverity: clear -> info', () => {
+  if (mapSeverity('clear') !== 'info') throw new Error('clear should map to info')
+})
+test('mapSeverity: unknown -> info', () => {
+  if (mapSeverity('unknown') !== 'info') throw new Error('unknown')
+})
+
+// ---- buildFingerprint ----
+test('buildFingerprint: alert fingerprint', () => {
+  const p = parseNetdataAlert({ alert: 'cpu_usage', severity: 'critical', space: 'web-01' })
+  const fp = buildFingerprint(p)
+  if (fp !== 'netdata:web-01:cpu_usage:critical') throw new Error(`got ${fp}`)
+})
+test('buildFingerprint: reachability fingerprint', () => {
+  const p = parseNetdataAlert({ node: 'web-02', status: 'down' })
+  const fp = buildFingerprint(p)
+  if (fp !== 'netdata:reachability:web-02:down') throw new Error(`got ${fp}`)
+})
+test('buildFingerprint: empty for null', () => {
+  if (buildFingerprint(null) !== '') throw new Error('should be empty')
+})
+
+// ---- toTriggerEvent ----
+test('toTriggerEvent: alert -> trigger event with correct severity', () => {
+  const p = parseNetdataAlert({ alert: 'disk_full', severity: 'critical', space: 'db-01', message: 'Disk 95%', date: '2026-07-22T10:00:00Z' })
+  const evt = toTriggerEvent(p)
+  if (!evt) throw new Error('should produce event')
+  if (evt.source !== 'netdata') throw new Error('source')
+  if (evt.severity !== 'critical') throw new Error('severity')
+  if (!evt.title.includes('disk_full')) throw new Error('title')
+  if (!evt.title.includes('db-01')) throw new Error('title host')
+  if (evt.labels.host !== 'db-01') throw new Error('labels host')
+  if (evt.labels.alert !== 'disk_full') throw new Error('labels alert')
+})
+
+test('toTriggerEvent: reachability down -> critical', () => {
+  const p = parseNetdataAlert({ node: 'web-03', status: 'down', date: '2026-07-22T10:00:00Z' })
+  const evt = toTriggerEvent(p)
+  if (!evt || evt.severity !== 'critical') throw new Error('down should be critical')
+  if (!evt.title.includes('DOWN')) throw new Error('title')
+})
+
+test('toTriggerEvent: reachability up -> info', () => {
+  const p = parseNetdataAlert({ node: 'web-03', status: 'up', date: '2026-07-22T10:00:00Z' })
+  const evt = toTriggerEvent(p)
+  if (!evt || evt.severity !== 'info') throw new Error('up should be info')
+})
+
+test('toTriggerEvent: null parsed -> null event', () => {
+  if (toTriggerEvent(null) !== null) throw new Error('should be null')
+})
+
+// ---- correlateWithRterm ----
+test('correlate: with metrics + incidents', () => {
+  const p = parseNetdataAlert({ alert: 'cpu_usage', severity: 'critical', space: 'web-01', additional_active_critical_alerts: 3 })
+  const mockMetrics = { snapshot: (host: string) => ({ host, cpuUsagePercent: 95, memoryUsagePercent: 70 }) }
+  const mockIncidents = { list: () => [
+    { title: 'web-01 disk full', affected: ['web-01'], status: 'open' },
+    { title: 'web-02 network issue', affected: ['web-02'], status: 'open' },
+    { title: 'web-01 resolved issue', affected: ['web-01'], status: 'resolved' },
+  ] }
+  const result = correlateWithRterm(p, mockMetrics as any, mockIncidents as any)
+  if (!result.recentMetrics || result.recentMetrics.cpuUsagePercent !== 95) throw new Error('metrics')
+  if (result.openIncidents.length !== 1) throw new Error(`expected 1 open incident, got ${result.openIncidents.length}`)
+  if (!result.correlation.includes('cpu_usage')) throw new Error('correlation should mention alert')
+  if (!result.correlation.includes('disk full')) throw new Error('correlation should mention incident')
+  if (!result.correlation.includes('3 additional critical')) throw new Error('correlation should mention additional alerts')
+})
+
+test('correlate: no prior context', () => {
+  const p = parseNetdataAlert({ alert: 'mem_usage', severity: 'warning', space: 'new-host' })
+  const result = correlateWithRterm(p, null, null)
+  if (result.recentMetrics !== null) throw new Error('no metrics')
+  if (result.openIncidents.length !== 0) throw new Error('no incidents')
+  if (!result.correlation.includes('No prior RTerm context')) throw new Error('should say no context')
+})
+
+test('correlate: null parsed -> empty', () => {
+  const result = correlateWithRterm(null, null, null)
+  if (result.recentMetrics !== null || result.openIncidents.length !== 0) throw new Error('should be empty')
+})
+
+// ---- register (plugin lifecycle) ----
+test('register: registers 2 tools, 2 triggers, 1 panel', () => {
+  const tools: any[] = [], triggers: any[] = [], panels: any[] = [], logs: string[] = []
+  register({
+    registerTool: (t) => tools.push(t),
+    registerTrigger: (t) => triggers.push(t),
+    registerPanel: (p) => panels.push(p),
+    exec: async () => '',
+    readLedger: () => ({}),
+    log: (line: string) => logs.push(line),
+  } as any)
+  if (tools.length !== 2) throw new Error(`expected 2 tools, got ${tools.length}`)
+  if (triggers.length !== 2) throw new Error(`expected 2 triggers, got ${triggers.length}`)
+  if (panels.length !== 1) throw new Error(`expected 1 panel, got ${panels.length}`)
+  if (!tools.some((t) => t.name === 'netdata_alert_summary')) throw new Error('missing alert_summary tool')
+  if (!tools.some((t) => t.name === 'netdata_correlate')) throw new Error('missing correlate tool')
+  if (!triggers.some((t) => t.name === 'netdata_critical_alert')) throw new Error('missing critical trigger')
+  if (!triggers.some((t) => t.name === 'netdata_warning_alert')) throw new Error('missing warning trigger')
+  if (!panels.some((p) => p.name === 'netdata-alert-feed')) throw new Error('missing alert feed panel')
+  if (!logs.some((l) => l.includes('registered'))) throw new Error('should log registration')
+})
+
+test('register: critical trigger matches critical events only', () => {
+  const triggers: any[] = []
+  register({
+    registerTool: () => {}, registerTrigger: (t) => triggers.push(t), registerPanel: () => {},
+    exec: async () => '', readLedger: () => ({}), log: () => {},
+  } as any)
+  const critTrigger = triggers.find((t) => t.name === 'netdata_critical_alert')
+  if (!critTrigger) throw new Error('missing critical trigger')
+  if (!critTrigger.match({ source: 'netdata', severity: 'critical' })) throw new Error('should match critical')
+  if (critTrigger.match({ source: 'netdata', severity: 'warning' })) throw new Error('should NOT match warning')
+  if (critTrigger.match({ source: 'other', severity: 'critical' })) throw new Error('should NOT match non-netdata')
+  if (critTrigger.match({})) throw new Error('should NOT match empty')
+})
+
+test('register: warning trigger matches warning events only', () => {
+  const triggers: any[] = []
+  register({
+    registerTool: () => {}, registerTrigger: (t) => triggers.push(t), registerPanel: () => {},
+    exec: async () => '', readLedger: () => ({}), log: () => {},
+  } as any)
+  const warnTrigger = triggers.find((t) => t.name === 'netdata_warning_alert')
+  if (!warnTrigger) throw new Error('missing warning trigger')
+  if (!warnTrigger.match({ source: 'netdata', severity: 'warning' })) throw new Error('should match warning')
+  if (warnTrigger.match({ source: 'netdata', severity: 'critical' })) throw new Error('should NOT match critical')
+})
+
+test('register: panel renders alert rows', () => {
+  const panels: any[] = []
+  register({
+    registerTool: () => {}, registerTrigger: () => {}, registerPanel: (p) => panels.push(p),
+    exec: async () => '', readLedger: () => ({}), log: () => {},
+  } as any)
+  const panel = panels[0]
+  const html = panel.render([
+    { host: 'web-01', alert: 'cpu_high', severity: 'critical', date: '2026-07-22' },
+    { host: 'web-02', alert: 'disk_full', severity: 'warning', date: '2026-07-22' },
+  ])
+  if (!html.includes('cpu_high') || !html.includes('disk_full')) throw new Error('should contain alert names')
+  if (!html.includes('<table>')) throw new Error('should render table')
+})
+
+test('register: panel renders empty feed', () => {
+  const panels: any[] = []
+  register({
+    registerTool: () => {}, registerTrigger: () => {}, registerPanel: (p) => panels.push(p),
+    exec: async () => '', readLedger: () => ({}), log: () => {},
+  } as any)
+  const html = panels[0].render(null)
+  if (!html.includes('Netdata Alerts')) throw new Error('should have title even when empty')
+})
+
+test('register: netdata_correlate tool handles invalid payload', async () => {
+  const tools: any[] = []
+  register({
+    registerTool: (t) => tools.push(t), registerTrigger: () => {}, registerPanel: () => {},
+    exec: async () => '', readLedger: () => ({}), log: () => {},
+  } as any)
+  const correlateTool = tools.find((t) => t.name === 'netdata_correlate')
+  const result = await correlateTool.handler({ alert: { foo: 'bar' } })
+  if (!result.error) throw new Error('should return error for invalid payload')
+})
+
+test('register: netdata_correlate tool correlates valid payload', async () => {
+  const tools: any[] = []
+  register({
+    registerTool: (t) => tools.push(t), registerTrigger: () => {}, registerPanel: () => {},
+    exec: async () => '', readLedger: () => null, log: () => {},
+  } as any)
+  const correlateTool = tools.find((t) => t.name === 'netdata_correlate')
+  const result = await correlateTool.handler({
+    alert: { alert: 'cpu_usage', severity: 'critical', space: 'web-01', message: 'CPU 95%' },
+  })
+  if (!result.parsed) throw new Error('should return parsed alert')
+  if (result.parsed.alert !== 'cpu_usage') throw new Error('alert name')
+})
+
+async function main() {
+  let pass = 0, fail = 0
+  for (const c of cases) {
+    try { await c.run(); pass++; console.log(`PASS ${c.name}`) }
+    catch (e: any) { fail++; console.log(`FAIL ${c.name}: ${e?.message ?? e}`) }
+  }
+  console.log(`\n${pass}/${cases.length} passed, ${fail} failed`)
+  if (fail > 0) process.exit(1)
+}
+void main()

package/plugins/web-intel/web-intel.extreme.spec.ts

@@ -0,0 +1,263 @@
+/**
+ * web-intel.extreme.spec.ts — exhaustive offline tests for the web-intel plugin:
+ * the dependency-free wigolo REST client (URL building, auth header, error
+ * mapping, every endpoint), the sidecar lifecycle (lean-by-default spawn plan,
+ * start/stop/status), and the plugin glue (config resolution, tool wiring,
+ * unreachable-daemon resilience, result normalization, trigger match). No
+ * network — fetch is mocked; spawn is injected/mocked.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { WigoloClient, WigoloApiError, buildHeaders, joinUrl, DEFAULT_BASE_URL } from './wigoloClient.mjs'
+import { WigoloSidecar, buildServePlan, buildInitPlan } from './sidecar.mjs'
+import {
+  register,
+  resolveConfig,
+  buildClient,
+  toResultRows,
+  toPageSummary,
+  toResearchBrief,
+  toWatchRows,
+  isPageChangedEvent,
+} from './index.mjs'
+
+// ─── mock fetch ─────────────────────────────────────────────────────────────
+function mockFetch(respond) {
+  const calls = []
+  const fn = async (url, init) => {
+    calls.push({ url, init })
+    const r = typeof respond === 'function' ? respond(url, init, calls.length) : respond
+    return { ok: r.ok !== false && (r.status ?? 200) < 400, status: r.status ?? 200, text: async () => r.text ?? (r.json !== undefined ? JSON.stringify(r.json) : '') }
+  }
+  fn.calls = calls
+  return fn
+}
+
+// ─── wigoloClient ───────────────────────────────────────────────────────────
+
+test('joinUrl joins base + path with a single slash', () => {
+  assert.equal(joinUrl('http://x:3333/', '/health'), 'http://x:3333/health')
+  assert.equal(joinUrl('http://x:3333', 'health'), 'http://x:3333/health')
+  assert.equal(joinUrl('', '/v1/search'), `${DEFAULT_BASE_URL}/v1/search`)
+})
+
+test('buildHeaders adds bearer token only when set', () => {
+  assert.equal(buildHeaders().authorization, undefined)
+  assert.equal(buildHeaders('tok').authorization, 'Bearer tok')
+})
+
+test('client.health() GETs /health without auth and maps ok/error', async () => {
+  const up = mockFetch({ json: { status: 'ok', searxng: 'not_configured' } })
+  const c = new WigoloClient({ fetchImpl: up })
+  const h = await c.health()
+  assert.equal(h.ok, true)
+  assert.equal(up.calls[0].url, `${DEFAULT_BASE_URL}/health`)
+
+  const down = mockFetch(() => { throw new Error('ECONNREFUSED') })
+  const h2 = await new WigoloClient({ fetchImpl: down }).health()
+  assert.equal(h2.ok, false)
+  assert.match(h2.error, /ECONNREFUSED/)
+})
+
+test('client.search() POSTs query (+ array) to /v1/search with token header', async () => {
+  const f = mockFetch({ json: { results: [] } })
+  const c = new WigoloClient({ token: 'tok', fetchImpl: f })
+  await c.search(['a', 'b'], { time_range: 'week', max_results: 5 })
+  assert.equal(f.calls[0].url, `${DEFAULT_BASE_URL}/v1/search`)
+  assert.equal(f.calls[0].init.method, 'POST')
+  assert.equal(f.calls[0].init.headers.authorization, 'Bearer tok')
+  const body = JSON.parse(f.calls[0].init.body)
+  assert.deepEqual(body.query, ['a', 'b'])
+  assert.equal(body.time_range, 'week')
+  assert.equal(body.max_results, 5)
+})
+
+test('client maps non-2xx to WigoloApiError with status', async () => {
+  const f = mockFetch({ status: 500, text: 'boom' })
+  const c = new WigoloClient({ fetchImpl: f })
+  await assert.rejects(() => c.fetch('https://x'), (e) => {
+    assert.ok(e instanceof WigoloApiError)
+    assert.equal(e.status, 500)
+    return true
+  })
+})
+
+test('client.watch() sends action + url for create/list/remove', async () => {
+  const f = mockFetch({ json: { id: 'w1' } })
+  const c = new WigoloClient({ fetchImpl: f })
+  await c.watch('create', { url: 'https://x', interval: '1h' })
+  assert.equal(JSON.parse(f.calls[0].init.body).action, 'create')
+  await c.watch('list')
+  assert.equal(JSON.parse(f.calls[1].init.body).action, 'list')
+  await c.watch('remove', { id: 'w1' })
+  assert.equal(JSON.parse(f.calls[2].init.body).action, 'remove')
+})
+
+// ─── sidecar ────────────────────────────────────────────────────────────────
+
+test('buildServePlan is lean by default (WIGOLO_NO_WARMUP=1, no token)', () => {
+  const p = buildServePlan({})
+  assert.equal(p.command, 'npx')
+  assert.deepEqual(p.args.slice(0, 3), ['-y', 'wigolo', 'serve'])
+  assert.equal(p.env.WIGOLO_NO_WARMUP, '1')
+  assert.equal(p.env.WIGOLO_API_TOKEN, undefined)
+})
+
+test('buildServePlan honors port/host/token and warmup=true omits the no-warmup flag', () => {
+  const p = buildServePlan({ port: 3477, host: '0.0.0.0', token: 't', warmup: true })
+  assert.ok(p.args.includes('3477'))
+  assert.equal(p.env.WIGOLO_NO_WARMUP, undefined)
+  assert.equal(p.env.WIGOLO_API_TOKEN, 't')
+})
+
+test('sidecar.start() spawns detached + unref and is idempotent', async () => {
+  const spawned = []
+  const spawnImpl = (cmd, args, opts) => { spawned.push({ cmd, args, opts }); return { unref() {}, kill() {} } }
+  const sc = new WigoloSidecar({ spawnImpl, log: () => {} })
+  await sc.start()
+  await sc.start() // idempotent — no second spawn
+  assert.equal(spawned.length, 1)
+  assert.equal(spawned[0].opts.detached, true)
+  assert.equal(sc.isRunning(), true)
+  assert.equal(sc.status().warmup, 'lean (no warmup)')
+})
+
+test('sidecar.stop() kills the process', async () => {
+  let killed = false
+  const spawnImpl = () => ({ unref() {}, kill() { killed = true } })
+  const sc = new WigoloSidecar({ spawnImpl, log: () => {} })
+  await sc.start()
+  await sc.stop()
+  assert.equal(killed, true)
+  assert.equal(sc.isRunning(), false)
+})
+
+// ─── plugin glue ────────────────────────────────────────────────────────────
+
+function makeCtx(fetchImpl, settings = {}, spawnProcess) {
+  const tools = new Map()
+  const triggers = []
+  const panels = []
+  const logs = []
+  const ctx = {
+    settings: { webIntel: settings },
+    fetchImpl,
+    registerTool: (t) => tools.set(t.name, t),
+    registerTrigger: (t) => triggers.push(t),
+    registerPanel: (p) => panels.push(p),
+    log: (l) => logs.push(l),
+    ...(spawnProcess ? { spawnProcess } : {}),
+  }
+  return { tools, triggers, panels, logs, ctx }
+}
+
+test('resolveConfig reads the webIntel block with lean defaults', () => {
+  const c = resolveConfig({ settings: { webIntel: { restUrl: ' http://x:3477/ ', warmupOnInit: true, autoStart: false } } })
+  assert.equal(c.restUrl, 'http://x:3477', 'restUrl trimmed of whitespace + trailing slash')
+  assert.equal(c.warmupOnInit, true)
+  assert.equal(c.autoStart, false)
+  const d = resolveConfig({ settings: {} })
+  assert.equal(d.enabled, true)
+  assert.equal(d.autoStart, true)
+  assert.equal(d.warmupOnInit, false)
+})
+
+test('register wires 9 tools, 1 trigger, 1 panel', () => {
+  const { tools, triggers, panels, ctx } = makeCtx(mockFetch({ json: {} }))
+  register(ctx)
+  assert.equal(tools.size, 9)
+  for (const n of ['webintel_health', 'web_search', 'web_fetch', 'web_crawl', 'web_research', 'web_find_similar', 'web_watch_add', 'web_watch_list', 'web_watch_remove']) assert.ok(tools.has(n), `missing ${n}`)
+  assert.equal(triggers.length, 1)
+  assert.equal(panels.length, 1)
+})
+
+test('web_search returns normalized ranked results', async () => {
+  const f = mockFetch((url) => url.endsWith('/health')
+    ? { json: { status: 'ok' } }
+    : { json: { results: [{ title: 'A', url: 'https://a', excerpt: 'x'.repeat(300), citation_id: 'src-1', evidence_score: { final: 0.9 } }], freshness_signal: { published: '2026-07-01' } } })
+  const { tools, ctx } = makeCtx(f)
+  register(ctx)
+  const r = await tools.get('web_search').handler({ query: 'cisco bgp error' })
+  assert.equal(r.results.length, 1)
+  assert.equal(r.results[0].citation, 'src-1')
+  assert.equal(r.results[0].score, 0.9)
+  assert.ok(r.results[0].excerpt.length <= 240)
+  assert.equal(r.freshness.published, '2026-07-01')
+})
+
+test('web_research returns the evidence brief (synthesis left to RTerm agent)', async () => {
+  const f = mockFetch((url) => url.endsWith('/health')
+    ? { json: { status: 'ok' } }
+    : { json: { question: 'q', evidence: [{ title: 'S', url: 'https://s', snippet: 'ev' }], citations: [{ id: 'src-1', url: 'https://s' }] } })
+  const { tools, ctx } = makeCtx(f)
+  register(ctx)
+  const r = await tools.get('web_research').handler({ question: 'is rijndael128-cbc safe' })
+  assert.equal(r.evidence.length, 1)
+  assert.equal(r.citations.length, 1)
+  assert.match(r.note, /RTerm agent/)
+})
+
+test('web_fetch surfaces a blocked page honestly', async () => {
+  const f = mockFetch((url) => url.endsWith('/health')
+    ? { json: { status: 'ok' } }
+    : { json: { url: 'https://x', blocked_by_challenge: true, markdown: '' } })
+  const { tools, ctx } = makeCtx(f)
+  register(ctx)
+  const r = await tools.get('web_fetch').handler({ url: 'https://x' })
+  assert.equal(r.blocked, true)
+})
+
+test('every web_* tool returns error+hint when daemon is down and no spawn (no throw)', async () => {
+  const down = mockFetch(() => { throw new Error('ECONNREFUSED') })
+  const { tools, ctx } = makeCtx(down, { autoStart: true }) // no spawnProcess → can't start
+  register(ctx)
+  const r = await tools.get('web_search').handler({ query: 'x' })
+  assert.ok(r.error)
+  assert.match(r.hint, /wigolo daemon/)
+})
+
+test('web_search auto-starts the daemon via spawnProcess then serves', async () => {
+  let healthy = false
+  const spawned = []
+  const f = mockFetch((url) => url.endsWith('/health')
+    ? (healthy ? { json: { status: 'ok' } } : (() => { throw new Error('down') })())
+    : { json: { results: [] } })
+  const spawnProcess = (cmd, args, opts) => { spawned.push(true); healthy = true; return { unref() {}, kill() {} } }
+  const { tools, ctx } = makeCtx(f, { autoStart: true }, spawnProcess)
+  register(ctx)
+  const r = await tools.get('web_search').handler({ query: 'x' })
+  assert.equal(spawned.length, 1)
+  assert.ok(Array.isArray(r.results))
+})
+
+test('webintel_page_changed trigger matches only webintel change events', () => {
+  const { triggers, ctx } = makeCtx(mockFetch({ json: {} }))
+  register(ctx)
+  const m = triggers[0].match
+  assert.equal(m({ source: 'webintel', changed: true }), true)
+  assert.equal(m({ source: 'webintel', kind: 'page_changed' }), true)
+  assert.equal(m({ source: 'agentspan', changed: true }), false)
+  assert.equal(m({ source: 'webintel', changed: false }), false)
+})
+
+// ─── normalization helpers ─────────────────────────────────────────────────
+
+test('toResultRows normalizes + truncates excerpts', () => {
+  const rows = toResultRows({ results: [{ url: 'https://a', description: 'y'.repeat(400) }] })
+  assert.equal(rows.length, 1)
+  assert.ok(rows[0].excerpt.length <= 240)
+  assert.equal(toResultRows({}).length, 0)
+})
+
+test('toResearchBrief handles empty payload', () => {
+  assert.deepEqual(toResearchBrief(null).evidence, [])
+  assert.equal(toResearchBrief({ evidence: [] }).evidence.length, 0)
+})
+
+test('toWatchRows normalizes watch entries', () => {
+  const rows = toWatchRows({ watches: [{ id: 'w1', url: 'https://x', changed: true, last_checked: '2026-07-28' }] })
+  assert.equal(rows.length, 1)
+  assert.equal(rows[0].changed, true)
+})
+
+console.log('web-intel: all cases passed')