mixdog 0.9.172 → 0.9.173

package/scripts/office/build-pptx-icons.mjs

@@ -135,7 +135,6 @@ export const ICON_NAMES = [
   'circle-dollar-sign',
   'dollar-sign',
   'euro',
-  'landmark',
   // technology and product
   'cpu',
   'microchip',

package/scripts/perf/transcript-runtime-probe.mjs

@@ -40,8 +40,20 @@ const timed = async (name, action, repetitions = 5) => {
   return { name, medianMs: +median(samples).toFixed(3), samplesMs: samples.map((n) => +n.toFixed(3)) };
 };
 const results = [];
-results.push(await timed('token-floors-before', () => messages.forEach((m) => legacyTokenFloors(m.content))));
-results.push(await timed('token-floors-after', () => messages.forEach((m) => currentFloors(m.content))));
+results.push(
+  await timed('token-floors-before', () => {
+    messages.forEach((m) => {
+      legacyTokenFloors(m.content);
+    });
+  })
+);
+results.push(
+  await timed('token-floors-after', () => {
+    messages.forEach((m) => {
+      currentFloors(m.content);
+    });
+  })
+);
 results.push(await timed('full-token-meter-after', () => estimateMessagesTokens(messages)));
 results.push(await timed('context-summary-cold-after', () => summarizeContextMessages(structuredClone(messages))));
 summarizeContextMessages(messages);
@@ -57,14 +69,18 @@ for (const [name, action] of [
   [
     'shared-loop-before',
     () => {
-      messages.forEach((m) => legacyTokenFloors(m.content));
+      messages.forEach((m) => {
+        legacyTokenFloors(m.content);
+      });
       oldReader();
     },
   ],
   [
     'shared-loop-after',
     () => {
-      messages.forEach((m) => currentFloors(m.content));
+      messages.forEach((m) => {
+        currentFloors(m.content);
+      });
       currentReader(target, true);
     },
   ],

package/scripts/pg-memory-diet.mjs

@@ -5,6 +5,7 @@ import { join, resolve } from 'node:path';
 import { spawn } from 'node:child_process';
 import { createServer } from 'node:net';
 import { createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
 import pg from 'pg';
 import { searchRelevantHybrid } from '../src/runtime/memory/lib/memory-recall-store.mjs';
 
@@ -250,10 +251,7 @@ async function prepare(dataDir, runtimeDir, sourcePort) {
   }
 }
 
-if (
-  process.argv[1] &&
-  resolve(process.argv[1]) === resolve(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1'))
-) {
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
   if (process.argv[2] !== 'prepare' || !process.argv[3] || !process.argv[4]) {
     throw new Error('Usage: node scripts/pg-memory-diet.mjs prepare <data-dir> <runtime-dir> <source-port>');
   }

package/scripts/routing-corpus.mjs

@@ -292,13 +292,11 @@ function toolSequence(sorted, iters) {
     if (it != null) iters.add(it);
     const tool = field(r, 'tool_name') || '?';
     const rawArgs = field(r, 'tool_args');
-    const summaryArgs = rawArgs;
     sequence.push({
       it: it ?? null,
       tool,
       args: argsSummary(tool, rawArgs),
       rawArgs,
-      inspectArgs: summaryArgs,
       argsHash: field(r, 'tool_args_hash'),
       resultKind: field(r, 'result_kind'),
       resultLines: Number(field(r, 'result_lines_est') || 0),

package/scripts/session-diag.mjs

@@ -149,11 +149,6 @@ function inferProviderFromModel(model) {
   return null;
 }
 
-function sessionInclusive(provider) {
-  if (provider) return isInclusiveProvider(provider);
-  return true;
-}
-
 function usageDenom(row, provider) {
   const prompt = numberField(row, 'prompt_tokens');
   const input = numberField(row, 'input_tokens');
@@ -265,7 +260,6 @@ function deriveSessionMeta(rows) {
     model = usage ? field(usage, 'model') : null;
   }
   if (!provider) provider = inferProviderFromModel(model);
-  const inclusive = sessionInclusive(provider);
   const tsList = sorted.map((r) => Number(r.ts || 0)).filter((n) => n > 0);
   const minTs = tsList.length ? Math.min(...tsList) : 0;
   const maxTs = tsList.length ? Math.max(...tsList) : 0;
@@ -292,7 +286,6 @@ function deriveSessionMeta(rows) {
     agent,
     provider,
     model,
-    inclusive,
     minTs,
     maxTs,
     turns,

package/scripts/session-sweep.mjs

@@ -22,8 +22,7 @@
  *
  * This tool NEVER deletes. It only prints a report.
  */
-import { existsSync, readdirSync, statSync } from 'node:fs';
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { getPluginData } from '../src/runtime/agent/orchestrator/config.mjs';
 import { summaryIndexPath, listStoredSessionSummaries } from '../src/runtime/agent/orchestrator/session/store.mjs';
@@ -153,27 +152,9 @@ function fmtTs(ms) {
   }
 }
 
-function main() {
-  const { maxAgeDays, minClosedAgeDays, now } = parseArgs(process.argv.slice(2));
-  const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
-  const minClosedAgeMs = minClosedAgeDays * 24 * 60 * 60 * 1000;
-
-  const dir = join(getPluginData(), 'sessions');
-  if (!existsSync(dir)) {
-    process.stdout.write(`[session-sweep] no sessions dir at ${dir}\n`);
-    return;
-  }
-
-  // Authoritative lifecycle rows (read-only). rebuildIfMissing:false so this
-  // report never triggers a summary-index write.
-  const rows = listStoredSessionSummaries({ rebuildIfMissing: false });
-  const rowById = new Map();
-  for (const r of rows) if (r?.id) rowById.set(r.id, r);
-
-  // Disk scan for sizes + mtime fallback. `.hb` sidecar bytes are attributed
-  // to their session so reclaimable bytes reflect the full on-disk footprint.
-  const files = readdirSync(dir);
-  const jsonFiles = files.filter((f) => f.endsWith('.json'));
+// `.hb` sidecar bytes are attributed to their session so reclaimable bytes
+// reflect the full on-disk footprint of a session.
+function collectHbSidecarSizes(dir, files) {
   const hbSizeById = new Map();
   for (const f of files) {
     if (!f.endsWith('.hb')) continue;
@@ -184,7 +165,42 @@ function main() {
       /* ignore */
     }
   }
+  return hbSizeById;
+}
 
+// Authoritative per-file lifecycle via cheap top-level scan; the summary
+// index is stale here (most on-disk files are unindexed), so the file
+// itself — not the index — decides closed/age. Fall back to the index
+// row, then to file mtime, only when the scan can't resolve a field.
+function classifySessionFile({ full, mtimeMs, row, now, maxAgeMs, minClosedAgeMs }) {
+  let scan = null;
+  try {
+    scan = scanTopLevelScalars(readFileSync(full, 'utf-8'));
+  } catch {
+    scan = null;
+  }
+  const closedScan = scan && (scan.closed === true || scan.status === 'closed');
+  const closedRow = row && (row.closed === true || row.status === 'closed');
+  const closed = scan ? !!closedScan : !!closedRow;
+  let updatedAt = scan && Number(scan.updatedAt) > 0 ? Number(scan.updatedAt) : 0;
+  if (!updatedAt && row && Number(row.updatedAt) > 0) updatedAt = Number(row.updatedAt);
+  if (!updatedAt) updatedAt = mtimeMs;
+  const ageMs = now - updatedAt;
+  // Min-closed-age gate: a closed session only qualifies once its close
+  // timestamp (closedAt when present, else updatedAt — markSessionClosed
+  // sets updatedAt=Date.now() at tombstone time) is older than the gate.
+  // Recently-closed sessions may still be resumed, so keep them.
+  const closedAt = scan && Number(scan.closedAt) > 0 ? Number(scan.closedAt) : updatedAt;
+  const closedAge = now - closedAt;
+  const closedQualifies =
+    closed && (minClosedAgeMs <= 0 || (Number.isFinite(closedAt) && closedAt > 0 && closedAge > minClosedAgeMs));
+  const ageOnly = !closed && maxAgeMs > 0 && Number.isFinite(updatedAt) && updatedAt > 0 && ageMs > maxAgeMs;
+  return { scanned: !!scan, closed, updatedAt, closedQualifies, ageOnly };
+}
+
+// Disk scan for sizes + mtime fallback, then the retention verdict per file
+// rolled into the totals the report prints.
+function collectRetention({ dir, jsonFiles, hbSizeById, rowById, now, maxAgeMs, minClosedAgeMs }) {
   let totalFiles = 0;
   let totalBytes = 0;
   const candidates = []; // { id, reason, updatedAt, bytes, inIndex }
@@ -217,44 +233,19 @@ function main() {
     totalBytes += bytes;
 
     const row = rowById.get(id) || null;
-    // Authoritative per-file lifecycle via cheap top-level scan; the summary
-    // index is stale here (most on-disk files are unindexed), so the file
-    // itself — not the index — decides closed/age. Fall back to the index
-    // row, then to file mtime, only when the scan can't resolve a field.
-    let scan = null;
-    try {
-      scan = scanTopLevelScalars(readFileSync(full, 'utf-8'));
-    } catch {
-      scan = null;
-    }
-    if (!scan) scanFailFiles += 1;
-    const closedScan = scan && (scan.closed === true || scan.status === 'closed');
-    const closedRow = row && (row.closed === true || row.status === 'closed');
-    const closed = scan ? !!closedScan : !!closedRow;
-    let updatedAt = scan && Number(scan.updatedAt) > 0 ? Number(scan.updatedAt) : 0;
-    if (!updatedAt && row && Number(row.updatedAt) > 0) updatedAt = Number(row.updatedAt);
-    if (!updatedAt) updatedAt = mtimeMs;
-    const ageMs = now - updatedAt;
-    // Min-closed-age gate: a closed session only qualifies once its close
-    // timestamp (closedAt when present, else updatedAt — markSessionClosed
-    // sets updatedAt=Date.now() at tombstone time) is older than the gate.
-    // Recently-closed sessions may still be resumed, so keep them.
-    const closedAt = scan && Number(scan.closedAt) > 0 ? Number(scan.closedAt) : updatedAt;
-    const closedAge = now - closedAt;
-    const closedQualifies =
-      closed && (minClosedAgeMs <= 0 || (Number.isFinite(closedAt) && closedAt > 0 && closedAge > minClosedAgeMs));
-    const ageOnly = !closed && maxAgeMs > 0 && Number.isFinite(updatedAt) && updatedAt > 0 && ageMs > maxAgeMs;
+    const verdict = classifySessionFile({ full, mtimeMs, row, now, maxAgeMs, minClosedAgeMs });
+    if (!verdict.scanned) scanFailFiles += 1;
 
-    if (closed && !closedQualifies) {
+    if (verdict.closed && !verdict.closedQualifies) {
       closedButFreshCount += 1;
       closedButFreshBytes += bytes;
     }
-    if (!closedQualifies && !ageOnly) continue; // keep
+    if (!verdict.closedQualifies && !verdict.ageOnly) continue; // keep
 
-    const reason = closedQualifies ? 'closed' : 'age';
-    candidates.push({ id, reason, updatedAt, bytes, inIndex: !!row });
+    const reason = verdict.closedQualifies ? 'closed' : 'age';
+    candidates.push({ id, reason, updatedAt: verdict.updatedAt, bytes, inIndex: !!row });
     reclaimBytes += bytes;
-    if (closedQualifies) {
+    if (verdict.closedQualifies) {
       closedCount += 1;
       closedBytes += bytes;
     } else {
@@ -264,6 +255,37 @@ function main() {
   }
 
   candidates.sort((a, b) => (a.updatedAt || 0) - (b.updatedAt || 0));
+  return {
+    totalFiles,
+    totalBytes,
+    candidates,
+    closedCount,
+    ageOnlyCount,
+    closedBytes,
+    ageOnlyBytes,
+    reclaimBytes,
+    scanFailFiles,
+    closedButFreshCount,
+    closedButFreshBytes,
+    fileIds,
+  };
+}
+
+function renderReport({ dir, rows, now, maxAgeDays, minClosedAgeDays, retention }) {
+  const {
+    totalFiles,
+    totalBytes,
+    candidates,
+    closedCount,
+    ageOnlyCount,
+    closedBytes,
+    ageOnlyBytes,
+    reclaimBytes,
+    scanFailFiles,
+    closedButFreshCount,
+    closedButFreshBytes,
+    fileIds,
+  } = retention;
   const oldest = candidates[0] || null;
   const newest = candidates[candidates.length - 1] || null;
   const dropRows = candidates.filter((c) => c.inIndex).length;
@@ -304,7 +326,31 @@ function main() {
   L.push(`index rows after    : ${rebuiltIndexRows}  (= surviving files; rebuild reindexes all remaining)`);
   L.push('');
   L.push('DRY-RUN ONLY — this tool performed no unlink and no disk writes.');
-  process.stdout.write(`${L.join('\n')}\n`);
+  return `${L.join('\n')}\n`;
+}
+
+function main() {
+  const { maxAgeDays, minClosedAgeDays, now } = parseArgs(process.argv.slice(2));
+  const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+  const minClosedAgeMs = minClosedAgeDays * 24 * 60 * 60 * 1000;
+
+  const dir = join(getPluginData(), 'sessions');
+  if (!existsSync(dir)) {
+    process.stdout.write(`[session-sweep] no sessions dir at ${dir}\n`);
+    return;
+  }
+
+  // Authoritative lifecycle rows (read-only). rebuildIfMissing:false so this
+  // report never triggers a summary-index write.
+  const rows = listStoredSessionSummaries({ rebuildIfMissing: false });
+  const rowById = new Map();
+  for (const r of rows) if (r?.id) rowById.set(r.id, r);
+
+  const files = readdirSync(dir);
+  const jsonFiles = files.filter((f) => f.endsWith('.json'));
+  const hbSizeById = collectHbSidecarSizes(dir, files);
+  const retention = collectRetention({ dir, jsonFiles, hbSizeById, rowById, now, maxAgeMs, minClosedAgeMs });
+  process.stdout.write(renderReport({ dir, rows, now, maxAgeDays, minClosedAgeDays, retention }));
 }
 
 main();

package/scripts/test.mjs

@@ -2,33 +2,77 @@
 // Discovery-based test entry (docs/testing.md). A test file joins the suite
 // by existing; its lane comes from its name, never from a hand-kept list:
 //
-//   *.test.mjs        fast   the default lane; every push, every local run
-//   *.slow.test.mjs   slow   files over ~10s; their own CI job
-//   *.live.test.mjs   live   need a built artifact or a live system
+//   *.test.mjs           fast     the default lane; every push, every local run
+//   *.slow.test.mjs      slow     files over ~10s; their own CI job
+//   *.live.test.mjs      live     need a built artifact or a live system
+//   *.electron.test.mjs  electron need a real Electron or window-capture
+//                                 surface, so two runs of them cannot overlap
 //
-// Usage: node scripts/test.mjs [--lane fast|slow|live|all] [--list]
-//                              [--import <spec>]... [--test-*]... [filter...]
-//   filter   substring of a file path; only matching files run.
-//   --import forwarded to node (desktop passes its test-env and tsx loaders).
-//   --test-* forwarded to node --test (e.g. --test-name-pattern, --test-only).
+// The electron lane rides the default lane (a plain run still covers it) and
+// `--exclude-lane electron` is the explicit opt-out that lets a second run
+// proceed concurrently; `--lane electron` runs those files alone.
 //
-// Runs from the package that invokes it: `src/` and `scripts/` under cwd are
-// the roots, so the root package and apps/desktop share this one entry.
+// Usage — see USAGE below (`node scripts/test.mjs --help`).
+//
+// Runs from the package that invokes it: `src/`, `scripts/`, `lib/`, `deploy/`
+// and the package root itself are searched under cwd, so the root package,
+// apps/desktop and apps/relay share this one entry. A root a package does not
+// have simply yields nothing.
 import { glob } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { runNodeTests } from './lib/run-node-tests.mjs';
 
-const ROOTS = ['src', 'scripts'];
+const FILE_LANES = ['fast', 'slow', 'live', 'electron'];
+const LANES = [...FILE_LANES, 'all'];
+
+export const USAGE = `Usage: node scripts/test.mjs [--lane ${LANES.join('|')}] [--exclude-lane <lane>]...
+                             [--rerun-failed <n>] [--list] [--coverage]
+                             [--import <spec>]... [--test-*]... [filter...]
+  filter          substring of a file path; only matching files run.
+  --lane          fast (default) also covers the electron lane, so a plain run
+                  keeps testing it; --lane electron runs those files alone.
+  --exclude-lane  drop one lane from the selection, repeatable. Electron and
+                  window-capture tests cannot run twice at once, so a second
+                  concurrent run uses --exclude-lane electron.
+  --rerun-failed <n>  re-run the failed files up to n times (default 0 = off).
+                  A test that passes on a re-run is reported as flaky and,
+                  because the flag was passed, does NOT fail the run; a test
+                  that fails every re-run still exits 1. Without the flag every
+                  failure fails the run, as before.
+  --import        forwarded to node (desktop passes its test-env and tsx loaders).
+  --test-*        forwarded to node --test (e.g. --test-name-pattern, --test-only).
+  --coverage      collect V8 coverage (NODE_V8_COVERAGE, no dependency) and fold
+                  it into .runtime/coverage/coverage.json, which answers "did the
+                  suite execute this function?" — see scripts/coverage-query.mjs.
+                  Selection, lanes, reporting and exit codes are untouched.
+  --list          print the selected files with their lane, run nothing.
+
+Every run ends with a "[failure-summary]" block, printed after all other
+output, naming each failed and flaky test by file and test name; every line of
+it carries that tag, so it survives line filtering.`;
+
+const ROOTS = ['.', 'src', 'scripts', 'lib', 'deploy'];
 const PATTERNS = ['**/*.test.mjs', '**/*-test.mjs'];
+// The package root is searched shallowly: a recursive pattern there would pull
+// every workspace package into the invoking package's suite.
+const ROOT_PATTERNS = ['*.test.mjs', '*-test.mjs'];
 const EXCLUDED_DIRS = new Set(['node_modules', '.runtime', 'out', 'dist', 'target']);
 
 export function laneOf(file) {
   if (/\.live\.test\.mjs$/.test(file)) return 'live';
   if (/\.slow\.test\.mjs$/.test(file)) return 'slow';
+  if (/\.electron\.test\.mjs$/.test(file)) return 'electron';
   return 'fast';
 }
 
+function rerunCount(value) {
+  if (!/^\d+$/.test(String(value))) {
+    throw new Error(`--rerun-failed requires a non-negative integer (got "${value}")`);
+  }
+  return Number(value);
+}
+
 export function parseArgs(argv) {
   const options = { lane: 'fast', list: false, nodeArgs: [], filters: [] };
   for (let index = 0; index < argv.length; index++) {
@@ -36,12 +80,30 @@ export function parseArgs(argv) {
     if (arg === '--lane') options.lane = argv[++index];
     else if (arg.startsWith('--lane=')) options.lane = arg.slice('--lane='.length);
     else if (arg === '--list') options.list = true;
-    else if (arg === '--import') options.nodeArgs.push(arg, argv[++index]);
-    else if (arg.startsWith('--import=') || arg.startsWith('--test-')) options.nodeArgs.push(arg);
+    // Opt-in only: an absent flag leaves the parsed options exactly as they
+    // were, so nothing downstream can branch on coverage, lane exclusion or
+    // re-runs by accident.
+    else if (arg === '--coverage') options.coverage = true;
+    else if (arg === '--help' || arg === '-h') options.help = true;
+    else if (arg === '--exclude-lane') options.excludeLanes = [...(options.excludeLanes ?? []), argv[++index]];
+    else if (arg.startsWith('--exclude-lane='))
+      options.excludeLanes = [...(options.excludeLanes ?? []), arg.slice('--exclude-lane='.length)];
+    else if (arg === '--rerun-failed') options.rerunFailed = rerunCount(argv[++index]);
+    else if (arg.startsWith('--rerun-failed=')) options.rerunFailed = rerunCount(arg.slice('--rerun-failed='.length));
+    else if (arg === '--import') {
+      const spec = argv[++index];
+      if (spec === undefined) throw new Error('--import requires a value');
+      options.nodeArgs.push(arg, spec);
+    } else if (arg.startsWith('--import=') || arg.startsWith('--test-')) options.nodeArgs.push(arg);
     else options.filters.push(arg.replaceAll('\\', '/'));
   }
-  if (!['fast', 'slow', 'live', 'all'].includes(options.lane)) {
-    throw new Error(`unknown lane "${options.lane}" (fast|slow|live|all)`);
+  if (!LANES.includes(options.lane)) {
+    throw new Error(`unknown lane "${options.lane}" (${LANES.join('|')})`);
+  }
+  for (const lane of options.excludeLanes ?? []) {
+    if (!FILE_LANES.includes(lane)) {
+      throw new Error(`unknown excluded lane "${lane}" (${FILE_LANES.join('|')})`);
+    }
   }
   return options;
 }
@@ -49,29 +111,39 @@ export function parseArgs(argv) {
 export async function discoverTestFiles(cwd = process.cwd()) {
   const files = new Set();
   for (const root of ROOTS) {
-    for await (const entry of glob(
-      PATTERNS.map((pattern) => `${root}/${pattern}`),
-      {
-        cwd,
-        exclude: (path) =>
-          String(path)
-            .split(/[\\/]/)
-            .some((segment) => EXCLUDED_DIRS.has(segment)),
-      }
-    ))
+    for await (const entry of glob(root === '.' ? ROOT_PATTERNS : PATTERNS.map((pattern) => `${root}/${pattern}`), {
+      cwd,
+      exclude: (path) =>
+        String(path)
+          .split(/[\\/]/)
+          .some((segment) => EXCLUDED_DIRS.has(segment)),
+    }))
       files.add(entry.replaceAll('\\', '/'));
   }
   return [...files].sort();
 }
 
-export function selectTestFiles(files, { lane, filters }) {
+// The electron lane rides the default lane so a plain `npm test` keeps
+// covering an Electron/window-capture surface that no other lane owns;
+// `--exclude-lane electron` is the explicit way to drop it.
+export function laneSelected(lane, fileLane) {
+  if (lane === 'all' || lane === fileLane) return true;
+  return lane === 'fast' && fileLane === 'electron';
+}
+
+export function selectTestFiles(files, { lane, filters, excludeLanes = [] }) {
+  const excluded = new Set(excludeLanes);
   return files
-    .filter((file) => lane === 'all' || laneOf(file) === lane)
+    .filter((file) => laneSelected(lane, laneOf(file)) && !excluded.has(laneOf(file)))
     .filter((file) => filters.length === 0 || filters.some((filter) => file.includes(filter)));
 }
 
 async function main() {
   const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    console.log(USAGE);
+    return;
+  }
   const files = selectTestFiles(await discoverTestFiles(), options);
   if (options.list) {
     for (const file of files) console.log(`${laneOf(file).padEnd(5)} ${file}`);
@@ -82,16 +154,20 @@ async function main() {
     process.exitCode = 1;
     return;
   }
-  await runNodeTests([
-    ...options.nodeArgs,
-    // node:test `mock.module` (module-boundary stubs such as the pinned fetch
-    // in the browser-document live suite) is still flag-gated on 22/24.
-    '--experimental-test-module-mocks',
-    '--test',
-    // A suite that leaves a handle open (a session runtime closed without
-    // waiting for its children) must not hang the whole run.
-    '--test-force-exit',
-  ], files);
+  await runNodeTests(
+    [
+      ...options.nodeArgs,
+      // node:test `mock.module` (module-boundary stubs such as the pinned fetch
+      // in the browser-document live suite) is still flag-gated on 22/24.
+      '--experimental-test-module-mocks',
+      '--test',
+      // A suite that leaves a handle open (a session runtime closed without
+      // waiting for its children) must not hang the whole run.
+      '--test-force-exit',
+    ],
+    files,
+    { coverage: options.coverage === true, rerunFailed: options.rerunFailed ?? 0 }
+  );
 }
 
 const invoked = process.argv[1] ? resolve(process.argv[1]) : '';

package/scripts/tui-frame-harness.mjs

@@ -280,7 +280,7 @@ function makeDriver({ rows, cols, isWindows }) {
 // (NON-fullscreen branch) → log-update relative cursorUp walk → one-row-low
 // dip under Windows Terminal. A steady frame (shortByOne=false) fills the
 // viewport, stays on the absolute cursorTo path, and is stable.
-function frame({ rows, cols, palette, shortByOne, heightRows }) {
+function frame({ rows, cols: _cols, palette, shortByOne, heightRows }) {
   // [FAITHFUL] App.jsx pins the bottom cluster with the outer full-height
   // column (height=resizeState.rows) + flexShrink={0} on the bottom bar. So the
   // Yoga root height is `rows` when accounting is correct. When a reclaimed row