@@ -14734,7 +14734,13 @@ <h3 id="portableTitle"><span data-icon="disc"></span>Portable session</h3>
   ctx.setTransform(1, 0, 0, 1, 0, 0);
   ctx.clearRect(0, 0, tmSearchBuffer.width, tmSearchBuffer.height);
 
-  const q = state.treemap.query.trim().toLowerCase();
+  // A grammar query with no answer for this tree yet dims nothing: over the
+  // saved index's tree while its scan runs (K03 took the older answer down),
+  // the bare-word rule below judged "ext:mov,mkv" against every name, dimmed
+  // the whole map and counted "0 matches" (ninth browser pass M01). The query
+  // waits, the box says so, and its answer draws the highlights.
+  const waiting = state.treemap.queryMode === 'grammar' && !state.treemap.matchedPaths;
+  const q = waiting ? '' : state.treemap.query.trim().toLowerCase();
   state.treemap.matches = 0;
   updateTmStatus();
   if (!q) return;
@@ -14828,7 +14834,9 @@ <h3 id="portableTitle"><span data-icon="disc"></span>Portable session</h3>
 }
 
 function updateTmStatus() {
-  const q = state.treemap.query.trim();
+  // A grammar query with no answer yet counts nothing: the line is the map's
+  // own, not "0 matches" (M01, as renderSearchOverlay draws it).
+  const q = state.treemap.queryMode === 'grammar' && !state.treemap.matchedPaths ? '' : state.treemap.query.trim();
   if (state.treemap.history.active && !q) {
     const when = formatWhen(state.treemap.history.viewingAt); // the one dialect, memoised
     $('tmStatus').textContent = `Viewing ${when} · ${formatBytes(state.treemap.rootSize)} — drag the slider to Live to interact`;
@@ -24489,7 +24497,10 @@ <h3 id="portableTitle"><span data-icon="disc"></span>Portable session</h3>
 function renderCellsStatus() {
   const st = $('tmStatus');
   if (!st || !isCells()) return;
-  if (state.treemap.query.trim() || state.treemap.history.active || tmPreview.on) return;
+  // A grammar query with no answer yet counts nothing, so the line is the
+  // shapes' own (M01, as renderSearchOverlay draws it).
+  const waiting = state.treemap.queryMode === 'grammar' && !state.treemap.matchedPaths;
+  if ((state.treemap.query.trim() && !waiting) || state.treemap.history.active || tmPreview.on) return;
   const cells = state.treemap.cells;
   const leaves = cells.reduce((k, c) => k + (c.leaf ? 1 : 0), 0);
   st.textContent =
 
@@ -2207,7 +2207,13 @@ function renderSearchOverlay() {
   ctx.setTransform(1, 0, 0, 1, 0, 0);
   ctx.clearRect(0, 0, tmSearchBuffer.width, tmSearchBuffer.height);
 
-  const q = state.treemap.query.trim().toLowerCase();
+  // A grammar query with no answer for this tree yet dims nothing: over the
+  // saved index's tree while its scan runs (K03 took the older answer down),
+  // the bare-word rule below judged "ext:mov,mkv" against every name, dimmed
+  // the whole map and counted "0 matches" (ninth browser pass M01). The query
+  // waits, the box says so, and its answer draws the highlights.
+  const waiting = state.treemap.queryMode === 'grammar' && !state.treemap.matchedPaths;
+  const q = waiting ? '' : state.treemap.query.trim().toLowerCase();
   state.treemap.matches = 0;
   updateTmStatus();
   if (!q) return;
@@ -2301,7 +2307,9 @@ function renderSearchOverlay() {
 }
 
 function updateTmStatus() {
-  const q = state.treemap.query.trim();
+  // A grammar query with no answer yet counts nothing: the line is the map's
+  // own, not "0 matches" (M01, as renderSearchOverlay draws it).
+  const q = state.treemap.queryMode === 'grammar' && !state.treemap.matchedPaths ? '' : state.treemap.query.trim();
   if (state.treemap.history.active && !q) {
     const when = formatWhen(state.treemap.history.viewingAt); // the one dialect, memoised
     $('tmStatus').textContent = `Viewing ${when} · ${formatBytes(state.treemap.rootSize)} — drag the slider to Live to interact`;
 
@@ -920,7 +920,10 @@ function repaintCells() {
 function renderCellsStatus() {
   const st = $('tmStatus');
   if (!st || !isCells()) return;
-  if (state.treemap.query.trim() || state.treemap.history.active || tmPreview.on) return;
+  // A grammar query with no answer yet counts nothing, so the line is the
+  // shapes' own (M01, as renderSearchOverlay draws it).
+  const waiting = state.treemap.queryMode === 'grammar' && !state.treemap.matchedPaths;
+  if ((state.treemap.query.trim() && !waiting) || state.treemap.history.active || tmPreview.on) return;
   const cells = state.treemap.cells;
   const leaves = cells.reduce((k, c) => k + (c.leaf ? 1 : 0), 0);
   st.textContent =
 
@@ -3297,11 +3297,14 @@ function runTmStatus(treemap: Record<string, unknown>): string {
  * the answer there — so that sentence must stay exactly as it was.
  */
 test('a grammar query whose matches outrun the map says so in the status line', () => {
-  const partial = runTmStatus({ query: 'size>1gb', queryMode: 'grammar', matches: 1, matchTotal: 2, rootSize: 5 });
+  // An answered grammar query carries the paths it matched beside its total, as tmRunGrammarQuery sets them; one with
+  // none is still waiting for its answer, and counts nothing (ninth browser pass M01).
+  const answered = new Set(['/a/big', '/b/big']);
+  const partial = runTmStatus({ query: 'size>1gb', queryMode: 'grammar', matchedPaths: answered, matches: 1, matchTotal: 2, rootSize: 5 });
   assert.match(partial, /1 of 2 matches for “size>1gb”/,
     'the drawn count is named as a share of what the query actually matched');
 
-  const all = runTmStatus({ query: 'size>1gb', queryMode: 'grammar', matches: 2, matchTotal: 2, rootSize: 5 });
+  const all = runTmStatus({ query: 'size>1gb', queryMode: 'grammar', matchedPaths: answered, matches: 2, matchTotal: 2, rootSize: 5 });
   assert.match(all, /^2 matches for “size>1gb”/,
     'nothing to disclose when the map drew them all — no "2 of 2"');
 
 
@@ -938,6 +938,105 @@ test('the older scan\'s matches go when a rescan paints the saved index\'s tree
   }
 });
 
+/**
+ * The highlight box over a drawn map: the query's bookkeeping, as queryPage lifts it, with the page's own search
+ * overlay, map footer and shapes' footer drawing what each state says — the scrim laid over each rectangle or shape
+ * that did not match, and the line under the map. `cells` draws the map as circles (§6.2) instead of rectangles.
+ */
+function mapUnderQueryPage(state: Record<string, unknown>, answer: (url: string) => unknown, cells = false) {
+  const $ = stubDom();
+  const asks: Ask[] = [];
+  const reasked: string[] = [];
+  const messages: string[] = [];
+  /** What the overlay's last draw dimmed on the search buffer: each rectangle or circle laid under the scrim. */
+  const dimmed: string[] = [];
+  let style = '';
+  let path: string[] = [];
+  const isScrim = (s: string) => /^rgba\(\d+,\d+,\d+,0\.\d+\)$/.test(s);
+  const ctx = {
+    setTransform: noop, strokeRect: noop, stroke: noop, closePath: noop, lineTo: noop, moveTo: noop,
+    // Each draw of the overlay begins by clearing the whole buffer: what it dims is what that draw laid down.
+    clearRect: (x: number, y: number, w: number, h: number) => { if (x === 0 && y === 0 && w === 200 && h === 100) dimmed.length = 0; },
+    beginPath: () => { path = []; },
+    arc: (x: number) => { path.push(`circle at ${x}`); },
+    fillRect: (x: number) => { if (isScrim(style)) dimmed.push(`rect at ${x}`); },
+    fill: () => { if (isScrim(style)) dimmed.push(...path); },
+    set fillStyle(v: string) { style = v; }, get fillStyle() { return style; },
+    strokeStyle: '', lineWidth: 1,
+  };
+  const given: Record<string, unknown> = {
+    state, $, tmQuerySeq: 0, tmQueryAbort: null, tmQueryDeb: 0, tmLastHits: null, AbortController, clearTimeout: noop,
+    api: async (url: string, init: { body: string }) => { asks.push({ url, scanId: scanOf(url, init.body) }); return answer(url); },
+    tmSetQueryMessage: (m: string) => { messages.push(m); }, tmStageable: () => ({ paths: [] }), seedNodes: noop, tmSyncQueryBar: noop,
+    presentView: noop, formatCount: String, tmUndrawnMessage: () => '',
+    fxTmPillBeamsSync: noop, loadSavedViews: noop, refreshDock: noop,
+    // The overlay and the footers over a 200 × 100 map, the search buffer's context recorded.
+    tmSearchBuffer: { width: 200, height: 100 }, tmBuffer: { width: 200, height: 100 }, tmSearchCtx: ctx, window: { devicePixelRatio: 1 },
+    document: { documentElement: { dataset: { theme: 'dark' } } }, cssVar: () => '#0A84FF', tmKidsOf: () => new Map(), altCellPath: noop,
+    isSun: () => false, isCells: () => cells, tmPreview: { on: false }, formatWhen: String,
+    formatBytes: (n: number) => (n >= 1e9 ? `${(n / 1e9).toFixed(1)} GB` : `${(n / 1e3).toFixed(1)} KB`),
+  };
+  const { fns } = page<{ run: (q: string) => Promise<void>; mount: () => void; changed: () => void; paint: () => void }>(
+    ['async function tmRunGrammarQuery(', 'function tmRejudgeQuery(', 'function tmRejudgeQueryWait(', 'function tmNoScanQueryWords(', 'function tmQueryScanChanged(', 'function tmCancelQueries(',
+      'function tmClearHits(', 'function tmSyncStageButton(', 'function treemapMatch(', 'function renderSearchOverlay(', 'function updateTmStatus(', 'function renderCellsStatus('],
+    given, `{ run: tmRunGrammarQuery, mount: () => (${pageView('treemap')}).mount(), changed: tmQueryScanChanged,
+      paint: () => { renderSearchOverlay(); if (isCells()) renderCellsStatus(); } }`);
+  // A paint lays the map out afresh (loadTreemap → drawTreemap, or drawCells), then draws its overlay and footer over it.
+  given.loadTreemap = () => fns.paint();
+  // tmApplyQuery hands a grammar query to tmRunGrammarQuery (the bare-word path is mapColourPop's and indexSearch's).
+  given.tmApplyQuery = (q: string) => { reasked.push(q); void fns.run(q.trim()); };
+  return { fns, $, asks, reasked, messages, dimmed };
+}
+
+test('while a rescan paints the saved index\'s tree under a query in the highlight box, the map is drawn undimmed and its footer is the map\'s own line — never "0 matches": the query waits for the scan, and the box says so — and the scan that lands is asked once and dims the map again (ninth browser pass M01)', async () => {
+  // corpus scanned, `ext:mov,mkv` answered (266 matches), then Scan pressed again: the saved index's tree was painted
+  // while the scan ran, and K03 took the older scan's matches down, leaving the query in the box with no answer. The
+  // overlay then judged "ext:mov,mkv" by the bare-word rule, which matches no name: every rectangle got the scrim, and
+  // the footer read "0 matches for “ext:mov,mkv” · 9.5 GB in this folder", with no "· from the saved index".
+  for (const cells of [false, true]) {
+    const drawn = cells ? 'as circles' : 'as rectangles';
+    const nodes = [{ path: '/r/a.mov' }, { path: '/r/b.txt' }];
+    const a = { path: '/r/a.mov', name: 'a.mov', type: 'file', extension: 'mov', depth: 1 };
+    const b = { path: '/r/b.txt', name: 'b.txt', type: 'file', extension: 'txt', depth: 1 };
+    const state: Record<string, unknown> = { root: TREE, ...STOPPED, scanningPath: null, view: 'treemap',
+      treemap: { rootPath: '/r', query: 'ext:mov,mkv', queryRoot: '/r', queryMode: 'bare', queryScanId: null, matches: 0, matchedPaths: null, matchTotal: null,
+        mode: cells ? 'circles' : 'treemap', history: { active: false }, minSize: 4000, rootSize: 9.5e9, nodes, nodesFor: { scanId: 'scan-old', nodes },
+        pxRects: [{ n: a, x: 0, y: 0, w: 100, h: 100 }, { n: b, x: 100, y: 0, w: 100, h: 100 }],
+        cells: [{ n: { path: '/r' }, kind: 'circle', cx: 100, cy: 50, r: 50 }, { n: a, kind: 'circle', cx: 50, cy: 50, r: 40, leaf: true }, { n: b, kind: 'circle', cx: 150, cy: 50, r: 40, leaf: true }] } };
+    const t = state.treemap as Record<string, unknown>;
+    const c = mapUnderQueryPage(state, () => ({ hits: [{ path: '/r/a.mov', name: 'a.mov', size: 5e9 }], total: 266 }), cells);
+    const footer = () => c.$('tmStatus').textContent;
+    const answered = cells ? ['circle at 100', 'circle at 150'] : ['rect at 100']; // b.txt, and in circles the folder around both
+    // Control: the older scan's tree, the query answered — what it did not match is dimmed, and the footer counts it.
+    await c.fns.run('ext:mov,mkv');
+    assert.deepEqual(c.dimmed, answered, `${drawn}: control: the answer dims what it did not match`);
+    assert.equal(footer(), '1 of 266 matches for “ext:mov,mkv” · 9.5 GB in this folder', `${drawn}: control: the footer counts the answer`);
+    // Scan pressed again: the saved index's tree is painted (TOPIC.scan, null), and shown again as the scan chrome re-enters the view.
+    Object.assign(state, INDEX_RUNNING, { scanningPath: '/r' });
+    t.nodesFor = { scanId: null, nodes };
+    c.fns.changed();
+    c.fns.paint();
+    for (const when of ['painted', 're-entered']) {
+      if (when === 're-entered') c.fns.mount();
+      assert.deepEqual([t.queryMode, t.matchedPaths, t.matchTotal], ['grammar', null, null], `${drawn}, ${when}: control: the query waits, the older answer gone (K03)`);
+      assert.equal(c.messages.at(-1), 'The search runs on a finished scan — it runs once the scan finishes.', `${drawn}, ${when}: control: the box says the search waits for the scan`);
+      assert.deepEqual(c.dimmed, [], `${drawn}, ${when}: nothing is dimmed while the query waits`);
+      assert.equal(t.matches, 0, `${drawn}, ${when}: and nothing is counted as a match`);
+      assert.equal(footer(), cells ? '2 shapes · 2 without children · 9.5 GB total' : '2 items of 4.0 KB or more drawn · 9.5 GB in this folder · from the saved index',
+        `${drawn}, ${when}: the footer is the map's own line, with no match count`);
+    }
+    // The scan lands (finishScan re-enters the view): the query is asked once, of it — nothing was asked of the running
+    // scan — and its answer dims the map again and is counted under it.
+    Object.assign(state, LANDED);
+    t.nodesFor = { scanId: 'scan-new', nodes };
+    c.fns.mount();
+    await turns();
+    assert.deepEqual([c.reasked, c.asks.map((x) => x.scanId), c.dimmed, footer()],
+      [['ext:mov,mkv'], ['scan-old', 'scan-new'], answered, '1 of 266 matches for “ext:mov,mkv” · 9.5 GB in this folder'],
+      `${drawn}: the scan that lands is asked the query, once, and its answer dims the map and is counted again`);
+  }
+});
+
 test('the highlight box\'s query asked of the older scan during a rescan is not installed over the new tree when it answers after the rescan landed — the new scan is asked — and a scan of the same folder landing stops it on the server', async () => {
   const tm = () => ({ rootPath: '/r', query: 'used>1y', queryRoot: '/r', queryMode: 'bare', queryScanId: null, matches: 0, matchedPaths: null });
   let release: (v: unknown) => void = noop;