scripts-orchestrator 2.15.1 → 3.5.0

package/lib/process-manager.js

@@ -46,6 +46,7 @@ export class ProcessManager {
     startedByScript,
     process_tracking,
     kill_command,
+    prefix = 'npm run',
   }) {
     this.logger.verbose(`Adding background process: ${command} (${url})`);
     this.backgroundProcessesDetails.push({
@@ -54,6 +55,7 @@ export class ProcessManager {
       startedByScript,
       process_tracking,
       kill_command,
+      prefix,
     });
   }
 
@@ -93,7 +95,13 @@ export class ProcessManager {
     env = null,
     reportTime = false,
     reportMemory = false,
+    prefix = 'npm run',
   }) {
+    // Resolve how the command is invoked. A non-empty prefix (e.g. 'npm run') is
+    // prepended to the command name; an empty/false prefix runs the command verbatim
+    // as a regular shell command. `displayCmd` is what we surface in logs.
+    const commandPrefix = prefix ? String(prefix).trim() : '';
+    const displayCmd = commandPrefix ? `${commandPrefix} ${cmd}` : cmd;
     const baseDir = this.logFolder
       ? path.resolve(this.logFolder)
       : process.cwd();
@@ -131,12 +139,12 @@ export class ProcessManager {
       const startTime = Date.now();
       let timeOutputPath = null;
       // Build command with environment variables if provided
-      let fullCommand = `npm run ${cmd}`;
+      let fullCommand = displayCmd;
       if (env && Object.keys(env).length > 0) {
         const envStr = Object.entries(env)
           .map(([key, value]) => `${key}=${value}`)
           .join(' ');
-        fullCommand = `${envStr} npm run ${cmd}`;
+        fullCommand = `${envStr} ${displayCmd}`;
       }
       const useTimeWrapper =
         reportMemory && !background && (process.platform === 'linux' || process.platform === 'darwin');
@@ -286,6 +294,7 @@ export class ProcessManager {
                   url: healthCheck?.url,
                   startedByScript: true,
                   kill_command,
+                  prefix: commandPrefix,
                 });
 
                 this.logger.verbose(`Unreferencing process ${processGroupId}`);
@@ -293,7 +302,7 @@ export class ProcessManager {
 
                 this.logger.stopTask(cmd);
                 this.logger.verbose(
-                  `Background process started: npm run ${cmd} (PGID: ${processGroupId})`,
+                  `Background process started: ${displayCmd} (PGID: ${processGroupId})`,
                 );
                 return {
                   success: true,
@@ -304,7 +313,7 @@ export class ProcessManager {
               } catch (error) {
                 if (attempt === maxAttempts) {
                   this.logger.error(
-                    `Failed to start background process: npm run ${cmd}`,
+                    `Failed to start background process: ${displayCmd}`,
                   );
                   this.logger.verbose(
                     `Final verification attempt failed: ${error.message}`,
@@ -382,7 +391,7 @@ export class ProcessManager {
 
             if (code !== 0) {
               this.logger.error(
-                `Failed: npm run ${cmd} ❌${durationStr} (exit code: ${code})`,
+                `Failed: ${displayCmd} ❌${durationStr} (exit code: ${code})`,
               );
               this.logger.verbose(`Process output: ${output}`);
               resolve({
@@ -392,7 +401,7 @@ export class ProcessManager {
                 memoryKb,
               });
             } else {
-              this.logger.success(`Completed: npm run ${cmd} ✅${durationStr}`);
+              this.logger.success(`Completed: ${displayCmd} ✅${durationStr}`);
               resolve({
                 success: true,
                 output,
@@ -507,13 +516,14 @@ export class ProcessManager {
     );
 
     const killPromises = commandProcesses.map(
-      async ({ command, pgid, url, startedByScript, kill_command }) => {
+      async ({ command, pgid, url, startedByScript, kill_command, prefix }) => {
         await this.cleanupProcess({
           command,
           pgid,
           url,
           startedByScript,
           kill_command,
+          prefix,
         });
       },
     );
@@ -529,7 +539,7 @@ export class ProcessManager {
     );
   }
 
-  async cleanupProcess({ command, pgid, url, startedByScript, kill_command }) {
+  async cleanupProcess({ command, pgid, url, startedByScript, kill_command, prefix = 'npm run' }) {
     if (!startedByScript) {
       this.logger.verbose(
         `- Skipping cleanup for ${command} (${url}) as it was not started by this script`,
@@ -544,13 +554,15 @@ export class ProcessManager {
     // Try custom kill command first if specified
     if (kill_command) {
       try {
+        const killDisplay = prefix ? `${String(prefix).trim()} ${kill_command}` : kill_command;
         this.logger.verbose(
-          `- Using custom kill command: npm run ${kill_command}`,
+          `- Using custom kill command: ${killDisplay}`,
         );
         const result = await this.runCommand({
           cmd: kill_command,
           logFile: null,
           background: false,
+          prefix,
         });
         if (result.success) {
           this.logger.verbose(

package/lib/process-manager.test.js

@@ -1,4 +1,6 @@
 import path from 'path';
+import fs from 'fs';
+import os from 'os';
 import { ProcessManager } from './process-manager.js';
 
 describe('ProcessManager.getLogPath', () => {
@@ -20,3 +22,59 @@ describe('ProcessManager.getLogPath', () => {
     expect(result).toBe(path.resolve(override));
   });
 });
+
+describe('ProcessManager.runCommand prefix handling', () => {
+  let tmpDir;
+  let prevCwd;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'so-prefix-'));
+    prevCwd = process.cwd();
+    process.chdir(tmpDir);
+  });
+
+  afterEach(() => {
+    process.chdir(prevCwd);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('runs a regular bash command verbatim when prefix is disabled', async () => {
+    const pm = new ProcessManager();
+    pm.setLogFolder(tmpDir);
+    const marker = 'orchestrator-raw-bash-ok';
+    const result = await pm.runCommand({
+      cmd: `echo ${marker}`,
+      background: false,
+      prefix: '',
+    });
+    expect(result.success).toBe(true);
+    const logPath = pm.getLogPath(`echo ${marker}`);
+    expect(fs.readFileSync(logPath, 'utf8')).toContain(marker);
+  });
+
+  test('honors a custom prefix by invoking it (failure surfaces a non-zero exit)', async () => {
+    const pm = new ProcessManager();
+    pm.setLogFolder(tmpDir);
+    // With prefix 'npm run' and no package.json script, the command must fail —
+    // proving the prefix is actually prepended rather than the command run raw.
+    const result = await pm.runCommand({
+      cmd: 'definitely-not-a-script',
+      background: false,
+      prefix: 'npm run',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('supports multi-token shell commands (pipes, &&) when run raw', async () => {
+    const pm = new ProcessManager();
+    pm.setLogFolder(tmpDir);
+    const result = await pm.runCommand({
+      cmd: 'printf "a\\nb\\nc\\n" | grep b',
+      background: false,
+      prefix: '',
+    });
+    expect(result.success).toBe(true);
+    const logPath = pm.getLogPath('printf');
+    expect(fs.readFileSync(logPath, 'utf8').trim()).toBe('b');
+  });
+});

package/lib/report-html.js

@@ -27,6 +27,45 @@ export function formatMs(ms) {
   return `${s}s`;
 }
 
+// Compact memory formatting (input in KB): MB up to ~1 GB, then GB.
+export function formatMem(kb) {
+  if (kb == null) return '—';
+  const mb = kb / 1024;
+  if (mb < 1024) return `${mb.toFixed(mb < 10 ? 1 : 0)} MB`;
+  return `${(mb / 1024).toFixed(1)} GB`;
+}
+
+// Default heat thresholds (fraction of the heaviest command in the run).
+export const DEFAULT_HEAT_THRESHOLDS = { mid: 0.33, high: 0.66 };
+
+// Normalize caller-supplied thresholds, clamping to (0,1) and ensuring mid < high.
+// Falls back to a default for any missing/invalid value.
+export function normalizeHeatThresholds(t) {
+  const def = DEFAULT_HEAT_THRESHOLDS;
+  const clamp = (v, fallback) => (Number.isFinite(v) && v > 0 && v < 1 ? v : fallback);
+  let mid = clamp(t?.mid, def.mid);
+  let high = clamp(t?.high, def.high);
+  if (mid >= high) { mid = def.mid; high = def.high; }
+  return { mid, high };
+}
+
+// Classify a value relative to the maximum in the run (low / mid / high), so heavy or
+// slow commands can be flagged green→amber→red. Thresholds (fractions of the run's max)
+// are configurable; defaults are used otherwise. Returns null when no value was recorded.
+export function heatLevel(value, max, thresholds = DEFAULT_HEAT_THRESHOLDS) {
+  if (value == null || !(max > 0)) return null;
+  const frac = value / max;
+  if (frac >= thresholds.high) return 'high';
+  if (frac >= thresholds.mid) return 'mid';
+  return 'low';
+}
+
+// Classify a command's memory use relative to the heaviest in the run, so the
+// Gantt can flag which bars are too memory-hungry to run alongside others.
+export function memoryHeat(memoryKb, maxMemory, thresholds = DEFAULT_HEAT_THRESHOLDS) {
+  return heatLevel(memoryKb, maxMemory, thresholds);
+}
+
 // Keys that are folded into the synthetic Status column or the Gantt rather than shown raw.
 const HANDLED_KEYS = new Set(['success', 'startedAt', 'skipReason']);
 
@@ -83,6 +122,24 @@ function barCellWrap(text, percent, kind) {
   return `<div class="cellbar"><span>${text}</span><div class="bar ${kind}" style="width:${percent.toFixed(1)}%"></div></div>`;
 }
 
+// Duration cell: green→amber→red heat scale relative to the slowest command in the run,
+// applied to both the bar and the value text, so the slowest commands stand out at a glance.
+function durCellWrap(durationMs, maxDuration, thresholds) {
+  const heat = heatLevel(durationMs, maxDuration, thresholds);
+  const heatCls = heat ? ` dur-${heat}` : '';
+  const percent = pct(durationMs, maxDuration);
+  return `<div class="cellbar"><span class="durval${heatCls}">${formatMs(durationMs)}</span><div class="bar dur${heatCls}" style="width:${percent.toFixed(1)}%"></div></div>`;
+}
+
+// Memory cell: same green→amber→red heat scale as the Gantt, applied to both the
+// bar and the value text, so the table and the Gantt read identically.
+function memCellWrap(memoryKb, maxMemory, thresholds) {
+  const heat = memoryHeat(memoryKb, maxMemory, thresholds);
+  const heatCls = heat ? ` mem-${heat}` : '';
+  const percent = pct(memoryKb, maxMemory);
+  return `<div class="cellbar"><span class="memval${heatCls}">${formatMem(memoryKb)}</span><div class="bar mem${heatCls}" style="width:${percent.toFixed(1)}%"></div></div>`;
+}
+
 // Render a single command cell for a given column key.
 function renderCell(key, c, ctx) {
   const v = c[key];
@@ -92,9 +149,9 @@ function renderCell(key, c, ctx) {
   case 'phase':
     return v != null ? escapeHtml(v) : '—';
   case 'durationMs':
-    return v != null ? barCellWrap(formatMs(v), pct(v, ctx.maxDuration), 'dur') : '—';
+    return v != null ? durCellWrap(v, ctx.maxDuration, ctx.durationHeatThresholds) : '—';
   case 'memoryKb':
-    return v != null ? barCellWrap(`${(v / 1024).toFixed(1)} MB`, pct(v, ctx.maxMemory), 'mem') : '—';
+    return v != null ? memCellWrap(v, ctx.maxMemory, ctx.heatThresholds) : '—';
   case 'logFile':
     return v
       ? `<a class="logref" href="file://${escapeHtml(path.resolve(process.cwd(), v))}" title="${escapeHtml(v)}"><code>${escapeHtml(v)}</code></a>`
@@ -130,7 +187,7 @@ function renderPhasesTable(phases, ctx) {
 }
 
 // Critical-path Gantt for one command list (uses observed startedAt + durationMs).
-function renderGantt(commands, overallDurationMs, hasPhases) {
+function renderGantt(commands, overallDurationMs, hasPhases, ctx = {}) {
   const timed = (commands || [])
     .filter((c) => c.startedAt && c.durationMs != null)
     .map((c) => ({ ...c, _start: Date.parse(c.startedAt) }))
@@ -160,15 +217,29 @@ function renderGantt(commands, overallDurationMs, hasPhases) {
   }
   const criticalTotal = timed.filter((c) => criticalKeys.has(c.command)).reduce((sum, c) => sum + c.durationMs, 0);
 
+  const anyMemory = timed.some((c) => c.memoryKb != null);
+
   const ganttRow = (c) => {
     const offsetPct = ((c._start - runStart) / spanMs) * 100;
     const widthPct = Math.max((c.durationMs / spanMs) * 100, 0.5);
     const crit = criticalKeys.has(c.command);
     const cls = c.success === false ? 'failed' : crit ? 'crit' : '';
-    return `<div class="gantt-row"><div class="gantt-label" title="${escapeHtml(c.command)}${c.phase ? ` — ${escapeHtml(c.phase)}` : ''}">${crit ? '★ ' : ''}${escapeHtml(c.command)}</div><div class="gantt-track"><div class="gantt-bar ${cls}" style="left:${offsetPct.toFixed(2)}%;width:${widthPct.toFixed(2)}%" title="${escapeHtml(c.command)} — ${formatMs(c.durationMs)}"><span class="gantt-dur">${formatMs(c.durationMs)}</span></div></div></div>`;
+    const heat = memoryHeat(c.memoryKb, ctx.maxMemory, ctx.heatThresholds);
+    const heatCls = heat ? ` mem-${heat}` : '';
+    const memTitle = c.memoryKb != null ? ` · ${formatMem(c.memoryKb)}` : '';
+    const memChip = anyMemory
+      ? `<div class="gantt-mem${heat ? ` mem-${heat}` : ''}">${c.memoryKb != null ? formatMem(c.memoryKb) : '—'}</div>`
+      : '';
+    return `<div class="gantt-row"><div class="gantt-label" title="${escapeHtml(c.command)}${c.phase ? ` — ${escapeHtml(c.phase)}` : ''}">${crit ? '★ ' : ''}${escapeHtml(c.command)}</div>${memChip}<div class="gantt-track"><div class="gantt-bar ${cls}${heatCls}" style="left:${offsetPct.toFixed(2)}%;width:${widthPct.toFixed(2)}%" title="${escapeHtml(c.command)} — ${formatMs(c.durationMs)}${memTitle}"><span class="gantt-dur">${formatMs(c.durationMs)}</span></div></div></div>`;
   };
 
-  return `<section><h3>Actual Critical Path</h3><p class="muted">★ marks each phase's bottleneck — the chain that drives wall-clock time. Critical path ≈ <strong>${formatMs(criticalTotal)}</strong>${overallDurationMs != null ? ` of ${formatMs(overallDurationMs)} total` : ''}.</p><div class="gantt">${timed.map(ganttRow).join('')}</div></section>`;
+  const t = ctx.heatThresholds || DEFAULT_HEAT_THRESHOLDS;
+  const memLegend = anyMemory
+    ? ' Bar outline + memory column show peak RSS (green→red, relative to the heaviest command:' +
+      ` amber ≥ ${Math.round(t.mid * 100)}%, red ≥ ${Math.round(t.high * 100)}%) so you can spot which` +
+      ' parallel commands are too memory-hungry to overlap.'
+    : '';
+  return `<section><h3>Actual Critical Path</h3><p class="muted">★ marks each phase's bottleneck — the chain that drives wall-clock time. Critical path ≈ <strong>${formatMs(criticalTotal)}</strong>${overallDurationMs != null ? ` of ${formatMs(overallDurationMs)} total` : ''}.${memLegend}</p><div class="gantt">${timed.map(ganttRow).join('')}</div></section>`;
 }
 
 function renderMeta(meta) {
@@ -188,7 +259,7 @@ function renderSection(section, columns, ctx) {
   const inner =
     renderMeta(section.meta) +
     renderPhasesTable(section.phases, ctx) +
-    renderGantt(section.commands, section.overallDurationMs, hasPhases) +
+    renderGantt(section.commands, section.overallDurationMs, hasPhases, ctx) +
     renderCommandsTable(section.commands, columns, ctx) +
     (section.sections || []).map((s) => renderSection(s, columns, ctx)).join('');
   return `<details class="section" open><summary><span class="badge ${st.kind}">${escapeHtml(st.label)}</span> <span class="section-title">${escapeHtml(section.title || 'Section')}</span><span class="section-dur">${dur}</span></summary><div class="section-body">${inner}</div></details>`;
@@ -224,6 +295,20 @@ tr.running { background: rgba(59,130,246,0.08); }
 .cellbar span { font-size: 0.85em; }
 .bar { height: 6px; background: #3b82f6; border-radius: 4px; min-width: 2px; margin-top: 2px; }
 .bar.mem { background: #8b5cf6; }
+/* Duration heat: same green→amber→red scale, relative to the slowest command. */
+.bar.dur.dur-low { background: #22c55e; }
+.bar.dur.dur-mid { background: #f59e0b; }
+.bar.dur.dur-high { background: #ef4444; }
+.durval.dur-low { color: #22c55e; }
+.durval.dur-mid { color: #f59e0b; }
+.durval.dur-high { color: #ef4444; font-weight: 600; }
+/* Memory heat: same green→amber→red scale as the Gantt's bar outline. */
+.bar.mem.mem-low { background: #22c55e; }
+.bar.mem.mem-mid { background: #f59e0b; }
+.bar.mem.mem-high { background: #ef4444; }
+.memval.mem-low { color: #22c55e; }
+.memval.mem-mid { color: #f59e0b; }
+.memval.mem-high { color: #ef4444; font-weight: 600; }
 code { font-size: 0.9em; background: #333; padding: 0.1rem 0.3rem; border-radius: 4px; }
 a.logref { color: #60a5fa; text-decoration: none; }
 a.logref:hover { text-decoration: underline; }
@@ -235,6 +320,14 @@ a.logref:hover { text-decoration: underline; }
 .gantt-bar { position: absolute; top: 0; height: 16px; background: #3b82f6; border-radius: 4px; min-width: 2px; display: flex; align-items: center; overflow: hidden; }
 .gantt-bar.crit { background: #f59e0b; }
 .gantt-bar.failed { background: #ef4444; }
+/* Memory heat: an inset ring on the bar (doesn't change layout or overlap neighbours). */
+.gantt-bar.mem-low { box-shadow: inset 0 0 0 2px #22c55e; }
+.gantt-bar.mem-mid { box-shadow: inset 0 0 0 2px #f59e0b; }
+.gantt-bar.mem-high { box-shadow: inset 0 0 0 2px #ef4444; }
+.gantt-mem { width: 64px; flex: 0 0 64px; text-align: right; font-family: ui-monospace, monospace; font-size: 0.7rem; color: #888; }
+.gantt-mem.mem-low { color: #22c55e; }
+.gantt-mem.mem-mid { color: #f59e0b; }
+.gantt-mem.mem-high { color: #ef4444; font-weight: 600; }
 .gantt-dur { font-size: 0.65rem; color: #0f0f0f; padding: 0 4px; white-space: nowrap; }
 details.section { background: #232323; border-radius: 8px; margin-bottom: 0.6rem; padding: 0.25rem 0.75rem; }
 details.section > summary { cursor: pointer; padding: 0.5rem 0; display: flex; align-items: center; gap: 0.6rem; }
@@ -263,6 +356,9 @@ export function renderReportHtml(payload) {
   const ctx = {
     maxDuration: Math.max(0, ...allCommands.map((c) => c.durationMs || 0)),
     maxMemory: Math.max(0, ...allCommands.map((c) => c.memoryKb || 0)),
+    // Heat thresholds travel in the payload so re-rendering a saved JSON (--render) honours them.
+    heatThresholds: normalizeHeatThresholds(payload.memoryHeat),
+    durationHeatThresholds: normalizeHeatThresholds(payload.durationHeat),
   };
 
   const top = statusOf({ success });
@@ -270,7 +366,7 @@ export function renderReportHtml(payload) {
 
   const topBlocks =
     renderPhasesTable(payload.phases, ctx) +
-    renderGantt(topCommands, overallDurationMs, hasTopPhases) +
+    renderGantt(topCommands, overallDurationMs, hasTopPhases, ctx) +
     (topCommands.length > 0
       ? `<section><h3>Commands</h3>${renderCommandsTable(topCommands, columns, ctx)}</section>`
       : '');

package/lib/report-html.test.js

@@ -85,4 +85,124 @@ describe('renderReportHtml', () => {
     expect(html).toContain('badge warn');
     expect(html).toContain('NX CACHE');
   });
+
+  test('Memory table cell uses the same green→red heat scale as the Gantt', () => {
+    const html = renderReportHtml({
+      success: true,
+      timestamp: 't',
+      overallDurationMs: 10000,
+      commands: [
+        { command: 'light', success: true, durationMs: 2000, memoryKb: 100 * 1024 },
+        { command: 'heavy', success: true, durationMs: 3000, memoryKb: 2048 * 1024 },
+      ],
+    });
+    // heaviest cell heat-coloured red; lightest green — both bar and value text
+    expect(html).toContain('bar mem mem-high');
+    expect(html).toContain('bar mem mem-low');
+    expect(html).toContain('memval mem-high');
+    expect(html).toContain('memval mem-low');
+  });
+
+  test('memoryHeat thresholds are configurable via payload.memoryHeat', () => {
+    // With a low high-threshold (0.4), a command at 50% of peak should read as high.
+    const payload = {
+      success: true,
+      timestamp: 't',
+      overallDurationMs: 10000,
+      memoryHeat: { mid: 0.2, high: 0.4 },
+      commands: [
+        { command: 'mid', success: true, startedAt: '2026-06-17T00:00:00.000Z', durationMs: 1000, memoryKb: 500 * 1024 }, // 50% of peak
+        { command: 'peak', success: true, startedAt: '2026-06-17T00:00:01.000Z', durationMs: 1000, memoryKb: 1000 * 1024 },
+      ],
+    };
+    const html = renderReportHtml(payload);
+    // 50% ≥ configured high (40%) → high; default thresholds (66%) would have made it 'mid'.
+    expect(html).toContain('bar mem mem-high');
+    expect(html).not.toContain('bar mem mem-mid');
+    // legend reflects the configured thresholds
+    expect(html).toContain('amber ≥ 20%, red ≥ 40%');
+  });
+
+  test('invalid memoryHeat thresholds fall back to defaults', () => {
+    const html = renderReportHtml({
+      success: true,
+      timestamp: 't',
+      overallDurationMs: 10000,
+      memoryHeat: { mid: 0.9, high: 0.1 }, // mid >= high → invalid, use defaults
+      commands: [
+        { command: 'a', success: true, startedAt: '2026-06-17T00:00:00.000Z', durationMs: 1000, memoryKb: 500 * 1024 },
+        { command: 'b', success: true, startedAt: '2026-06-17T00:00:01.000Z', durationMs: 1000, memoryKb: 1000 * 1024 },
+      ],
+    });
+    // default thresholds restored: 50% of peak → mid (≥33%, <66%)
+    expect(html).toContain('amber ≥ 33%, red ≥ 66%');
+    expect(html).toContain('bar mem mem-mid');
+  });
+
+  test('Duration table cell uses a green→red heat scale relative to the slowest command', () => {
+    const html = renderReportHtml({
+      success: true,
+      timestamp: 't',
+      overallDurationMs: 10000,
+      commands: [
+        { command: 'quick', success: true, durationMs: 500, memoryKb: 100 * 1024 },
+        { command: 'slow', success: true, durationMs: 9000, memoryKb: 200 * 1024 },
+      ],
+    });
+    // slowest cell heat-coloured red; quickest green — both bar and value text
+    expect(html).toContain('bar dur dur-high');
+    expect(html).toContain('bar dur dur-low');
+    expect(html).toContain('durval dur-high');
+    expect(html).toContain('durval dur-low');
+  });
+
+  test('durationHeat thresholds are configurable via payload.durationHeat', () => {
+    // With a low high-threshold (0.4), a command at 50% of the slowest should read as high.
+    const html = renderReportHtml({
+      success: true,
+      timestamp: 't',
+      overallDurationMs: 10000,
+      durationHeat: { mid: 0.2, high: 0.4 },
+      commands: [
+        { command: 'mid', success: true, durationMs: 500, memoryKb: 100 * 1024 }, // 50% of slowest
+        { command: 'slow', success: true, durationMs: 1000, memoryKb: 100 * 1024 },
+      ],
+    });
+    // 50% ≥ configured high (40%) → high; default thresholds (66%) would have made it 'mid'.
+    expect(html).toContain('bar dur dur-high');
+    expect(html).not.toContain('bar dur dur-mid');
+  });
+
+  test('Gantt flags memory-heavy commands with a heat ring and memory chip', () => {
+    const html = renderReportHtml({
+      success: true,
+      timestamp: 't',
+      overallDurationMs: 10000,
+      commands: [
+        { command: 'light', success: true, startedAt: '2026-06-17T00:00:00.000Z', durationMs: 2000, memoryKb: 100 * 1024 },
+        { command: 'heavy', success: true, startedAt: '2026-06-17T00:00:01.000Z', durationMs: 3000, memoryKb: 2048 * 1024 },
+      ],
+    });
+    // heaviest command gets the high-heat ring + bold chip; lightest gets low
+    expect(html).toContain('mem-high');
+    expect(html).toContain('mem-low');
+    // memory value surfaced on the Gantt row itself (no table lookup needed)
+    expect(html).toContain('class="gantt-mem');
+    expect(html).toContain('2.0 GB');
+  });
+
+  test('Gantt omits the memory chip entirely when no command reports memory', () => {
+    const html = renderReportHtml({
+      success: true,
+      timestamp: 't',
+      overallDurationMs: 10000,
+      commands: [
+        { command: 'a', success: true, startedAt: '2026-06-17T00:00:00.000Z', durationMs: 2000 },
+      ],
+    });
+    // no rendered chip element and no heat ring on the bar
+    expect(html).not.toContain('class="gantt-mem');
+    expect(html).not.toContain('gantt-bar  mem-');
+    expect(html).not.toContain('gantt-bar crit mem-');
+  });
 });