@velaro/cli 1.4.96 → 1.4.98

package/lib/log-search.test.js

@@ -1,51 +1,86 @@
 // Regression (2026-10-14): velaro-messaging's logs search under-reported text queries (q=[HttpFallback] returned 0-2 rows
 // while 136 existed; q=AsrsNegotiateFailed with no level returned 0 while 4 existed) because each scan only examined the
-// newest N rows of the window and never said so. completeLogSearch must find rows behind an arbitrary pile of newer
-// rows, say COMPLETE only when no slice hit the server cap, and never send q=.
+// newest N rows of the window and never said so. completeLogSearch must find rows behind an arbitrary pile of newer rows,
+// say COMPLETE only when the whole window was covered, honour its request/time budgets, and (older servers) never send q=.
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { completeLogSearch, describeCompleteness, describeRawMeta } from './log-search.js';
+import { completeLogSearch, describeCompleteness, describeRawMeta, escapeRegex, fetchJsonRetry } from './log-search.js';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 
-/** Mock of the messaging search endpoint: newest-first scan capped at `cap` rows BEFORE any filter other than level/site. */
-function mockServer(rows, cap = 5000) {
+/**
+ * Mock of the messaging search endpoint.
+ *  legacy=true : OLD server: newest-first fetch capped at `cap` rows BEFORE any non-OData filter, no truncated/scannedRows,
+ *                includeTotal reports totalCountCapped.
+ *  legacy=false: NEW server (#2510): server-side text filtering while scanning (q as regex when regex=true), scan stops after
+ *                `take` matches or `cap` examined rows, returns truncated/scannedRows and a nextCursor whenever more may exist.
+ */
+function mockServer(rows, { cap = 5000, legacy = false } = {}) {
   const calls = [];
   const fetchJson = async (query) => {
     const p = new URLSearchParams(query);
     calls.push(p);
-    assert.equal(p.get('q'), null, 'the complete read must never send q=');
-    assert.equal(p.get('regex'), null);
     const from = new Date(p.get('from')).getTime();
     const to = new Date(p.get('to')).getTime();
     const lvl = p.get('level');
     const site = p.get('siteId');
-    // newest first, server-side filters first, then the fetch cap (the real bug), then in-window filter
+    const take = Number(p.get('take'));
     let pool = rows.filter((r) => (!lvl || r.level === lvl) && (!site || String(r.siteId) === site));
     pool = pool.filter((r) => new Date(r.timestamp).getTime() >= from && new Date(r.timestamp).getTime() <= to);
     pool.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-    const capped = pool.length >= cap;
-    const fetched = pool.slice(0, cap);
-    const take = Number(p.get('take'));
-    let start = 0;
-    if (p.get('cursor')) start = fetched.findIndex((r) => r.id === p.get('cursor')) + 1;
-    const page = fetched.slice(start, start + take);
-    const more = start + take < fetched.length;
-    const out = { entries: page, nextCursor: more ? page[page.length - 1].id : null };
-    if (p.get('includeTotal') === 'true') { out.totalCount = fetched.length; out.totalCountCapped = capped; }
-    return out;
+
+    if (legacy) {
+      // The only request allowed to carry q is the first (the new-server probe), and then only with regex=true, which forces the exact
+      // path: the AI-search path (the one that under-reports) must never be reachable. Every bisect request after it has no q at all.
+      if (p.get('q') !== null) {
+        assert.equal(calls.length, 1, 'only the probe may carry q=; bisect requests must not');
+        assert.equal(p.get('regex'), 'true', 'a q= sent to an old server must force the exact path with regex=true');
+      }
+      const capped = pool.length >= cap;
+      const fetched = pool.slice(0, cap);
+      let start = 0;
+      if (p.get('cursor')) start = fetched.findIndex((r) => r.id === p.get('cursor')) + 1;
+      const page = fetched.slice(start, start + take);
+      const out = { entries: page, nextCursor: start + take < fetched.length ? page[page.length - 1].id : null };
+      if (p.get('includeTotal') === 'true') { out.totalCount = fetched.length; out.totalCountCapped = capped; }
+      return out;
+    }
+
+    const re = p.get('q') ? new RegExp(p.get('q'), 'i') : null;
+    const lre = p.get('logger') ? new RegExp(p.get('logger'), 'i') : null;
+    let startIdx = 0;
+    if (p.get('cursor')) startIdx = pool.findIndex((r) => r.id === p.get('cursor')) + 1;
+    const matches = [];
+    let examined = 0;
+    let more = false;
+    let capHit = false;
+    let lastId = null;
+    for (let i = startIdx; i < pool.length; i++) {
+      if (examined >= cap) { capHit = true; break; }
+      examined++;
+      lastId = pool[i].id;
+      const r = pool[i];
+      if ((!re || re.test(r.message)) && (!lre || lre.test(r.logger))) {
+        if (matches.length >= take) { more = true; break; }
+        matches.push(r);
+      }
+    }
+    let nextCursor = null;
+    if (more) nextCursor = matches[matches.length - 1].id;
+    else if (capHit) nextCursor = lastId;
+    return { entries: matches, nextCursor, searchPath: 'table-storage', scannedRows: examined, truncated: capHit };
   };
   return { fetchJson, calls };
 }
 
-function makeRows(n, needles) {
+function makeRows(n, needles, level = 'WARN') {
   const base = Date.UTC(2026, 9, 14, 13, 45, 0);
   const rows = [];
   for (let i = 0; i < n; i++) {
-    rows.push({ id: `r${String(i).padStart(7, '0')}`, timestamp: new Date(base - i * 1000).toISOString(), level: 'WARN', siteId: 20519, logger: 'VisitorLoggingService', message: needles.has(i) ? '[AsrsNegotiateFailed] site=20715' : `noise ${i}` });
+    rows.push({ id: `r${String(i).padStart(7, '0')}`, timestamp: new Date(base - i * 1000).toISOString(), level, siteId: 20519, logger: 'VisitorLoggingService', message: needles.has(i) ? '[AsrsNegotiateFailed] site=20715' : `noise ${i}` });
   }
   return rows;
 }
@@ -53,28 +88,58 @@ const W = (rows) => [new Date(rows[rows.length - 1].timestamp), new Date(rows[0]
 
 test('the single raw call misses a needle behind 9,000 newer rows (the live bug shape)', async () => {
   const rows = makeRows(12000, new Set([9000]));
-  const { fetchJson } = mockServer(rows, 5000);
+  const { fetchJson } = mockServer(rows, { legacy: true });
   const [from, to] = W(rows);
   const raw = await fetchJson(new URLSearchParams({ from: from.toISOString(), to: to.toISOString(), take: '500', includeTotal: 'true' }).toString());
   assert.equal(raw.totalCountCapped, true);
   assert.equal(raw.entries.some((e) => e.message.includes('AsrsNegotiate')), false);
 });
 
-test('completeLogSearch finds the needle behind 9,000 newer rows and reports COMPLETE', async () => {
+// ---------------- CURSOR mode (new server) ----------------
+
+test('CURSOR mode: finds a needle behind 9,000 newer rows via server-side text filtering and cursor paging, COMPLETE, few requests', async () => {
   const rows = makeRows(12000, new Set([9000, 11000]));
-  const { fetchJson } = mockServer(rows, 5000);
+  const { fetchJson, calls } = mockServer(rows, { cap: 5000 });
   const [from, to] = W(rows);
-  const r = await completeLogSearch({ fetchJson, from, to, contains: '[AsrsNegotiateFailed]', maxRequests: 200 });
+  const r = await completeLogSearch({ fetchJson, from, to, contains: '[AsrsNegotiateFailed]' });
+  assert.equal(r.mode, 'cursor');
   assert.equal(r.entries.length, 2);
   assert.equal(r.complete, true);
-  assert.ok(r.slices > 1, 'capped slices must have been bisected');
+  assert.ok(r.requests <= 4, `expected a handful of requests, got ${r.requests}`);   // 12,000 rows / 5,000-row scans, not hundreds
+  assert.equal(r.scanned, 12000);                                                    // the REAL server scannedRows, summed
   assert.match(describeCompleteness(r), /COMPLETE/);
   assert.doesNotMatch(describeCompleteness(r), /INCOMPLETE/);
+  // text is sent as an ESCAPED regex with regex=true (forces the exact path), and the AI-search fall-through is disabled
+  assert.equal(calls[0].get('regex'), 'true');
+  assert.equal(calls[0].get('q'), escapeRegex('[AsrsNegotiateFailed]'));
+  assert.equal(calls[0].get('fallthrough'), 'false');
 });
 
-test('a request budget that runs out is INCOMPLETE, never a silent partial', async () => {
-  const rows = makeRows(12000, new Set([9000]));
-  const { fetchJson } = mockServer(rows, 5000);
+test('CURSOR mode: an UNFILTERED default search is a couple of requests, not hundreds (wanted=50 stops after the first page)', async () => {
+  const rows = makeRows(84000, new Set());
+  const { fetchJson } = mockServer(rows, { cap: 60000 });
+  const [from, to] = W(rows);
+  const r = await completeLogSearch({ fetchJson, from, to, wanted: 50 });
+  assert.equal(r.mode, 'cursor');
+  assert.equal(r.requests, 1);
+  assert.equal(r.satisfied, true);
+  assert.ok(r.entries.length >= 50);
+  assert.match(describeCompleteness(r), /more may exist/);
+});
+
+test('CURSOR mode: a genuine 0 follows the cursor to the end and says COMPLETE', async () => {
+  const rows = makeRows(14000, new Set());
+  const { fetchJson } = mockServer(rows, { cap: 5000 });
+  const [from, to] = W(rows);
+  const r = await completeLogSearch({ fetchJson, from, to, contains: 'nope' });
+  assert.equal(r.entries.length, 0);
+  assert.equal(r.complete, true);
+  assert.match(describeCompleteness(r), /0 matches means nothing was logged/);
+});
+
+test('CURSOR mode: the request budget ending mid-cursor is INCOMPLETE, never a silent partial', async () => {
+  const rows = makeRows(20000, new Set([19000]));
+  const { fetchJson } = mockServer(rows, { cap: 5000 });
   const [from, to] = W(rows);
   const r = await completeLogSearch({ fetchJson, from, to, contains: '[AsrsNegotiateFailed]', maxRequests: 2 });
   assert.equal(r.complete, false);
@@ -83,25 +148,73 @@ test('a request budget that runs out is INCOMPLETE, never a silent partial', asy
   assert.match(describeCompleteness(r), /NOT proof of absence/);
 });
 
-test('level and siteId are pushed server side; contains/regex/logger filter client side', async () => {
+test('CURSOR mode: the wall-clock budget ending mid-cursor is INCOMPLETE', async () => {
+  const rows = makeRows(20000, new Set([19000]));
+  const { fetchJson } = mockServer(rows, { cap: 5000 });
+  const slow = async (q) => { await new Promise((r) => setTimeout(r, 30)); return fetchJson(q); };
+  const [from, to] = W(rows);
+  const r = await completeLogSearch({ fetchJson: slow, from, to, contains: '[AsrsNegotiateFailed]', maxSeconds: 0.01 });
+  assert.equal(r.complete, false);
+  assert.equal(r.timeExhausted, true);
+  assert.match(describeCompleteness(r), /time budget exhausted/);
+});
+
+// ---------------- BISECT mode (older server) ----------------
+
+test('BISECT mode (old server): finds the needle behind 9,000 newer rows, never sends q=, reports COMPLETE', async () => {
+  const rows = makeRows(12000, new Set([9000, 11000]));
+  const { fetchJson } = mockServer(rows, { cap: 5000, legacy: true });
+  const [from, to] = W(rows);
+  const r = await completeLogSearch({ fetchJson, from, to, contains: '[AsrsNegotiateFailed]', maxRequests: 200 });
+  assert.equal(r.mode, 'bisect');
+  assert.equal(r.entries.length, 2);
+  assert.equal(r.complete, true);
+  assert.ok(r.slices > 1, 'capped slices must have been bisected');
+});
+
+test('BISECT mode: level and siteId are pushed server side; contains/regex/logger filter client side', async () => {
   const rows = makeRows(300, new Set([10, 20]));
   rows[5].logger = 'Other.Logger';
-  const { fetchJson, calls } = mockServer(rows, 5000);
+  const { fetchJson, calls } = mockServer(rows, { cap: 5000, legacy: true });
   const [from, to] = W(rows);
   const r = await completeLogSearch({ fetchJson, from, to, params: { level: 'warn', siteId: 20519 }, regex: 'Asrs.*Failed', logger: 'visitorlogging' });
   assert.equal(r.entries.length, 2);
-  assert.equal(calls[0].get('level'), 'WARN');
-  assert.equal(calls[0].get('siteId'), '20519');
+  assert.equal(calls.at(-1).get('level'), 'WARN');
+  assert.equal(calls.at(-1).get('siteId'), '20519');
   assert.equal(r.complete, true);
 });
 
-test('a genuine 0 on a complete scan says so (0 means nothing was logged)', async () => {
-  const rows = makeRows(500, new Set());
-  const { fetchJson } = mockServer(rows, 5000);
+test('BISECT mode: a request budget that runs out is INCOMPLETE', async () => {
+  const rows = makeRows(12000, new Set([9000]));
+  const { fetchJson } = mockServer(rows, { cap: 5000, legacy: true });
   const [from, to] = W(rows);
-  const r = await completeLogSearch({ fetchJson, from, to, contains: 'nope' });
-  assert.equal(r.entries.length, 0);
-  assert.match(describeCompleteness(r), /0 matches means nothing was logged/);
+  const r = await completeLogSearch({ fetchJson, from, to, contains: '[AsrsNegotiateFailed]', maxRequests: 2 });
+  assert.equal(r.complete, false);
+  assert.equal(r.budgetExhausted, true);
+});
+
+// ---------------- shared behaviour ----------------
+
+test('results are ordered by instant, not by string: mixed fractional-second digit counts', async () => {
+  const mk = (id, ts) => ({ id, timestamp: ts, level: 'WARN', siteId: 1, logger: 'x', message: 'm' });
+  // as strings "…:10Z" > "…:10.5Z" (because 'Z' > '.') although 10.5 s is LATER than 10 s
+  const rows = [mk('a', '2026-10-14T13:00:10Z'), mk('b', '2026-10-14T13:00:10.5Z'), mk('c', '2026-10-14T13:00:10.25Z')];
+  const fetchJson = async () => ({ entries: rows, nextCursor: null, searchPath: 'table-storage', scannedRows: 3, truncated: false });
+  const r = await completeLogSearch({ fetchJson, from: new Date('2026-10-14T13:00:00Z'), to: new Date('2026-10-14T13:01:00Z') });
+  assert.deepEqual(r.entries.map((e) => e.id), ['b', 'c', 'a']);
+});
+
+test('fetchJsonRetry honours 429 Retry-After, then succeeds; gives up after the retry budget', async () => {
+  const waits = [];
+  const mkRes = (status, retryAfter, body) => ({ status, ok: status >= 200 && status < 300, headers: { get: () => retryAfter }, json: async () => body, text: async () => 'busy' });
+  let n = 0;
+  const ok = await fetchJsonRetry('u', {}, { fetchImpl: async () => (++n < 3 ? mkRes(429, '2', null) : mkRes(200, null, { done: true })), sleepImpl: async (ms) => { waits.push(ms); } });
+  assert.deepEqual(ok, { done: true });
+  assert.deepEqual(waits, [2000, 2000]);
+
+  n = 0;
+  await assert.rejects(() => fetchJsonRetry('u', {}, { retries: 2, fetchImpl: async () => { n++; return mkRes(429, '1', null); }, sleepImpl: async () => {} }), (e) => e.status === 429);
+  assert.equal(n, 3);
 });
 
 test('describeRawMeta surfaces searchPath/scannedRows/truncated and warns on old deploys', () => {
@@ -117,13 +230,145 @@ test('cli/lib/log-search.js and mcp/log-search.js are byte-identical (the npm pa
   assert.equal(a, b, 'copy cli/lib/log-search.js to mcp/log-search.js (or the reverse)');
 });
 
-test('neither the CLI search handler nor the MCP tool sends q= in complete mode', () => {
+test('no staff log check searches the literal TEXT "level:ERROR" or "X OR Y" (they always matched nothing and printed "no errors")', () => {
+  for (const rel of ['commands/logs.js', 'commands/ops.js', '../../mcp/staff-server.js', '../../mcp/server.js']) {
+    const src = fs.readFileSync(path.join(here, rel), 'utf8');
+    assert.ok(!/q=level%3AERROR/.test(src) && !/search\('level:ERROR'\)/.test(src), `${rel}: still searches the text "level:ERROR"`);
+    assert.ok(!/q=WF-AI-ROUTE\+OR\+PERF-SLOW/.test(src) && !/search\('WF-AI-ROUTE OR PERF-SLOW'\)/.test(src), `${rel}: still searches the text "WF-AI-ROUTE OR PERF-SLOW"`);
+  }
+});
+
+test('the complete-mode handlers use completeLogSearch and never set q= themselves', () => {
   const cli = fs.readFileSync(path.join(here, 'commands', 'logs.js'), 'utf8');
   const mcp = fs.readFileSync(path.join(here, '..', '..', 'mcp', 'staff-server.js'), 'utf8');
-  for (const [name, src, marker] of [['cli', cli, 'Default: COMPLETE read'], ['mcp', mcp, 'Default: COMPLETE read']]) {
-    const tail = src.slice(src.indexOf(marker));
-    const handler = tail.slice(0, 1200);
+  for (const [name, src] of [['cli', cli], ['mcp', mcp]]) {
+    const tail = src.slice(src.indexOf('Default: COMPLETE read'));
+    const handler = tail.slice(0, 1400);
     assert.ok(handler.includes('completeLogSearch('), `${name}: complete mode must call completeLogSearch`);
-    assert.ok(!/params\.set\('q'/.test(handler), `${name}: complete mode must not set q=`);
+    assert.ok(!/params\.set\('q'/.test(handler), `${name}: complete mode must not set q= itself`);
   }
 });
+
+test('timeouts: log searches allow the server scan budget (12 s + 6 s AI search), not the 20 s default', () => {
+  for (const rel of ['commands/logs.js', '../../mcp/staff-server.js']) {
+    assert.match(fs.readFileSync(path.join(here, rel), 'utf8'), /AbortSignal\.timeout\(40000\)/, `${rel}: log search timeout must be 40 s`);
+  }
+});
+
+// ---------------- Opus final check (2026-10-14): the cursor protocol must never turn a truncated scan into COMPLETE ----------------
+
+test('CURSOR mode: truncated=true with NO cursor is INCOMPLETE, never COMPLETE (the server deadline fired before any row)', async () => {
+  const fetchJson = async () => ({ entries: [], nextCursor: null, searchPath: 'table-storage', scannedRows: 0, truncated: true });
+  const r = await completeLogSearch({ fetchJson, from: new Date('2026-10-14T13:00:00Z'), to: new Date('2026-10-14T13:45:00Z'), contains: 'x' });
+  assert.equal(r.mode, 'cursor');
+  assert.equal(r.complete, false);
+  assert.match(describeCompleteness(r), /INCOMPLETE/);
+  assert.match(r.unresolved.join(' '), /without a cursor/);
+});
+
+test('CURSOR mode: a LATER page that is truncated without a cursor is INCOMPLETE too (it needs truncated===false on the last page)', async () => {
+  let n = 0;
+  const fetchJson = async () => (++n === 1
+    ? { entries: [{ id: 'a', timestamp: '2026-10-14T13:00:00Z', message: 'm' }], nextCursor: 'c1', scannedRows: 10, truncated: true }
+    : { entries: [], nextCursor: null, scannedRows: 0, truncated: true });
+  const r = await completeLogSearch({ fetchJson, from: new Date('2026-10-14T13:00:00Z'), to: new Date('2026-10-14T13:45:00Z'), contains: 'm' });
+  assert.equal(r.complete, false);
+  assert.equal(r.requests, 2);
+});
+
+test('CURSOR mode: a last page that does not confirm truncated===false is not COMPLETE', async () => {
+  let n = 0;
+  const fetchJson = async () => (++n === 1
+    ? { entries: [], nextCursor: 'c1', scannedRows: 10, truncated: true }
+    : { entries: [], nextCursor: null, scannedRows: 10 });          // truncated missing: unknown, so not proof
+  const r = await completeLogSearch({ fetchJson, from: new Date('2026-10-14T13:00:00Z'), to: new Date('2026-10-14T13:45:00Z'), contains: 'm' });
+  assert.equal(r.complete, false);
+});
+
+test('CURSOR mode: the server handing back the SAME cursor means no progress: INCOMPLETE, and the loop stops', async () => {
+  let n = 0;
+  const fetchJson = async () => { n++; return { entries: [], nextCursor: 'stuck', scannedRows: 0, truncated: true }; };
+  const r = await completeLogSearch({ fetchJson, from: new Date('2026-10-14T13:00:00Z'), to: new Date('2026-10-14T13:45:00Z'), contains: 'm', maxRequests: 50 });
+  assert.equal(r.complete, false);
+  assert.match(r.unresolved.join(' '), /no progress/);
+  assert.ok(n <= 3, `must stop at the first repeated cursor, made ${n} requests`);
+});
+
+test('CURSOR mode: a page chain that ends with truncated===false and no cursor IS complete', async () => {
+  let n = 0;
+  const fetchJson = async () => (++n === 1
+    ? { entries: [], nextCursor: 'c1', scannedRows: 5000, truncated: true }
+    : { entries: [{ id: 'a', timestamp: '2026-10-14T13:00:00Z', message: 'm' }], nextCursor: null, scannedRows: 4000, truncated: false });
+  const r = await completeLogSearch({ fetchJson, from: new Date('2026-10-14T13:00:00Z'), to: new Date('2026-10-14T13:45:00Z'), contains: 'm' });
+  assert.equal(r.complete, true);
+  assert.equal(r.scanned, 9000);
+  assert.equal(r.entries.length, 1);
+});
+
+test('fetchRetry429 retries only 429 and returns the final response after the retry budget', async () => {
+  const { fetchRetry429 } = await import('./log-search.js');
+  let n = 0;
+  const waits = [];
+  const mk = (status) => ({ status, ok: status < 300, headers: { get: () => '1' } });
+  const res = await fetchRetry429('u', {}, { retries: 2, fetchImpl: async () => { n++; return mk(429); }, sleepImpl: async (ms) => { waits.push(ms); } });
+  assert.equal(res.status, 429);
+  assert.equal(n, 3);
+  assert.deepEqual(waits, [1000, 1000]);
+  n = 0;
+  const ok = await fetchRetry429('u', {}, { fetchImpl: async () => { n++; return mk(500); }, sleepImpl: async () => {} });
+  assert.equal(ok.status, 500);
+  assert.equal(n, 1);                                                   // a 500 is not retried
+});
+
+test('bot_full_diagnostic: errors use the server-side level=ERROR filter, patterns are a separate read; neither is the old text regex', () => {
+  for (const rel of ['../../mcp/staff-server.js', '../../mcp/server.js']) {
+    const src = fs.readFileSync(path.join(here, rel), 'utf8');
+    const a = src.indexOf('const velaroLoggerP = safeJson');
+    const body = src.slice(a, a + 2600);
+    assert.ok(body.includes('level=ERROR'), `${rel}: errors must use level=ERROR`);
+    assert.ok(body.includes("WF-AI-ROUTE|PERF-SLOW"), `${rel}: patterns are their own read`);
+    assert.ok(!body.includes("'ERROR|WF-AI-ROUTE|PERF-SLOW'"), `${rel}: still runs the regex ERROR|... over message text`);
+    assert.ok(/errRes[\s\S]*patRes/.test(body), `${rel}: two reads expected`);
+  }
+});
+
+test('both MCP servers retry 429 on their messaging calls (GETs)', () => {
+  for (const rel of ['../../mcp/staff-server.js', '../../mcp/server.js']) {
+    const src = fs.readFileSync(path.join(here, rel), 'utf8');
+    assert.ok(src.includes('fetchRetry429('), `${rel}: messagingApi must retry 429`);
+  }
+});
+
+test('describeRawMeta surfaces the best-effort caveat when exact=false (an AI-search-index answer is a floor, never exact)', () => {
+  const m = describeRawMeta({ entries: [], searchPath: 'ai-search', scannedRows: 400, truncated: false, exact: false });
+  assert.match(m, /exact=false/);
+  assert.match(m, /best-effort search index/);
+  assert.match(m, /floor, not exact/);
+  // an authoritative table answer carries no caveat
+  assert.doesNotMatch(describeRawMeta({ entries: [], searchPath: 'table-storage', scannedRows: 400, truncated: false, exact: true }), /exact=false/);
+  // an older server that does not send exact at all is not accused of being best-effort
+  assert.doesNotMatch(describeRawMeta({ entries: [], searchPath: 'table-storage', scannedRows: 400, truncated: false }), /exact=false/);
+});
+
+test('ops health and the diagnostics run their log searches ONE AT A TIME and retry 429 (the server runs 2 exact scans per instance)', () => {
+  const parallelSearch = /await Promise\.all\(\[\s*(search\(|messagingApi\(|fetch\()/;
+  for (const rel of ['commands/ops.js', 'commands/logs.js', '../../mcp/staff-server.js', '../../mcp/server.js']) {
+    const src = fs.readFileSync(path.join(here, rel), 'utf8');
+    assert.ok(!parallelSearch.test(src), rel + ': log searches must not be fired in parallel');
+  }
+  assert.ok(fs.readFileSync(path.join(here, 'commands', 'ops.js'), 'utf8').includes('fetchRetry429('));
+});
+
+test('fetchRetry429: a 429 with NO Retry-After waits the 5 s default (Number(null) is 0: it must not become an immediate retry)', async () => {
+  const { fetchRetry429 } = await import('./log-search.js');
+  const waits = [];
+  let n = 0;
+  const noHeader = (status) => ({ status, ok: status < 300, headers: { get: () => null } });
+  await fetchRetry429('u', {}, { fetchImpl: async () => (++n < 3 ? noHeader(429) : noHeader(200)), sleepImpl: async (ms) => { waits.push(ms); } });
+  assert.deepEqual(waits, [5000, 5000]);
+  // an explicit Retry-After: 0 is honoured as 0 (retry now), it is not mistaken for "missing"
+  const zero = [];
+  n = 0;
+  await fetchRetry429('u', {}, { fetchImpl: async () => (++n < 2 ? { status: 429, ok: false, headers: { get: () => '0' } } : noHeader(200)), sleepImpl: async (ms) => { zero.push(ms); } });
+  assert.deepEqual(zero, [0]);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velaro/cli",
-  "version": "1.4.96",
+  "version": "1.4.98",
   "description": "Velaro Workspace v20 — command-line interface for managing bots, knowledge base ingestion, MCP API keys, search indexes, and ops health.",
   "type": "module",
   "bin": {