cyborg-hunter 0.5.0 → 0.7.2

package/src/cli/renderers/triage-md.js

@@ -11,15 +11,21 @@ export async function renderTriage(triage, config) {
     '',
     `_${triage.length} participants analyzed_`,
     '',
-    '| Rank | Participant | Score | Hard | Reason |',
-    '|------|-------------|-------|------|--------|',
+    '**Tier** is the library\'s two-tier screening verdict: `HARD` = a hard signal',
+    '(paste/drop/copy) crossed its count threshold; `soft` = library soft score ≥',
+    'its threshold; `clean` = neither. **Score** is the CLI\'s separate ranking',
+    'heuristic (5×paste + 5×copy + 3×sidebar + 1×tab-away) — it orders rows',
+    '*within* a tier and is not the library soft score.',
+    '',
+    '| Rank | Participant | Tier | Score | Reason |',
+    '|------|-------------|------|-------|--------|',
   ];
 
   triage.forEach((t, i) => {
-    const hard = t.hardTriggered ? '**YES**' : 'no';
+    const tier = t.hardTriggered ? '**HARD**' : t.softFlagged ? 'soft' : 'clean';
     // Escape pipe characters in reason text to avoid breaking the table
     const reason = t.reason.replace(/\|/g, '\\|');
-    lines.push(`| ${i + 1} | ${t.participantId} | ${t.score} | ${hard} | ${reason} |`);
+    lines.push(`| ${i + 1} | ${t.participantId} | ${tier} | ${t.score} | ${reason} |`);
   });
 
   lines.push('');

package/src/cli/renderers/typing-profile-core.js

@@ -0,0 +1,211 @@
+// src/cli/renderers/typing-profile-core.js
+//
+// Pure drawing core for per-participant typing-speed bar-chart images — no
+// Node APIs, so a browser demo can bundle it directly (0.7.2-style
+// extraction from cli/renderers/typing-profile.js, which is now a thin fs
+// wrapper around this module: it acquires node-canvas, calls
+// drawTypingProfile per participant, and writes the returned canvas to a
+// PNG). Mirrors the session-timeline-core.js / trajectories-core.js split.
+//
+// drawTypingProfile(p, config, createCanvas) draws one participant's typing
+// speed bar chart — one bar per trial's chars/sec, with a horizontal
+// threshold line and bars above threshold colored red — and returns the
+// drawn canvas (or null if there's nothing to draw: no trials, or no trial
+// has either a typed speed or a paste event). createCanvas is injected so
+// this module never imports the `canvas` package directly — a browser
+// caller can pass a document-canvas-backed factory instead.
+
+const BAR_WIDTH = 30;
+const BAR_GAP = 8;
+const CHART_HEIGHT = 200;
+const TOP_PAD = 50;
+const BOTTOM_PAD = 50;
+const LEFT_PAD = 60;
+
+// ── Per-participant renderer ─────────────────────────────────────────────
+// Returns the drawn canvas, or null if there's no data to draw (caller
+// decides what "no data" means — the fs wrapper skips the PNG write).
+export function drawTypingProfile(p, config, createCanvas) {
+  const trials = p.trials;
+  if (trials.length === 0) return null;
+
+  // Per-participant threshold line: prefer the typing-speed cutoff the library
+  // actually screened this participant with (saved in session.config.thresholds)
+  // so the red "fast typing" line matches summary.csv's count; fall back to the
+  // CLI/default. A strict participant (8 cps) otherwise shows a 10 cps line.
+  const threshold =
+    p.session?.config?.thresholds?.typingSpeedCps ?? config.typingSpeedThreshold_cps ?? 10;
+
+  // Per-trial state. We distinguish three cases:
+  //   "typed"       — charsPerSec is a real number, draw a normal bar
+  //   "paste-only"  — charsPerSec is null but there's a paste event; draw a
+  //                   grey hatched marker so the absence is legible. Single
+  //                   paste fires one input event → editTimestamps.length < 2
+  //                   → computeTypingSpeed returns null. Without this, a
+  //                   pasted response looks identical to a very slow one.
+  //   "no-data"     — neither, leave blank
+  const kinds = trials.map(t => {
+    if (typeof t.charsPerSec === 'number') return 'typed';
+    if ((t.pasteEvents || []).length > 0) return 'paste-only';
+    return 'no-data';
+  });
+  const speeds = trials.map(t => (typeof t.charsPerSec === 'number' ? t.charsPerSec : 0));
+  if (kinds.every(k => k === 'no-data')) return null;
+
+  const canvasW = LEFT_PAD + trials.length * (BAR_WIDTH + BAR_GAP) + 20;
+  const canvasH = TOP_PAD + CHART_HEIGHT + BOTTOM_PAD;
+  const canvas = createCanvas(canvasW, canvasH);
+  const ctx = canvas.getContext('2d');
+
+  // Background
+  ctx.fillStyle = '#ffffff';
+  ctx.fillRect(0, 0, canvasW, canvasH);
+
+  // Title
+  ctx.fillStyle = '#333';
+  ctx.font = 'bold 14px sans-serif';
+  ctx.fillText(`Typing Speed Profile — ${p.participantId}`, LEFT_PAD, 20);
+  ctx.font = '10px sans-serif';
+  ctx.fillStyle = '#666';
+  ctx.fillText(`Threshold: ${threshold} chars/sec`, LEFT_PAD, 35);
+
+  // Legend — three states documented in the `kinds` comment above.
+  const legendY = 35;
+  const legendX0 = LEFT_PAD + 180;
+  ctx.fillStyle = '#2196F3';
+  ctx.fillRect(legendX0, legendY - 8, 12, 10);
+  ctx.fillStyle = '#666';
+  ctx.fillText('typed', legendX0 + 16, legendY);
+  ctx.fillStyle = '#f44336';
+  ctx.fillRect(legendX0 + 60, legendY - 8, 12, 10);
+  ctx.fillStyle = '#666';
+  ctx.fillText('> threshold', legendX0 + 76, legendY);
+  // Hatched swatch for paste-only
+  drawHatchedRect(ctx, legendX0 + 150, legendY - 8, 12, 10);
+  ctx.fillStyle = '#666';
+  ctx.fillText('paste (P)', legendX0 + 166, legendY);
+
+  // Y-axis scaling
+  const maxSpeed = Math.max(...speeds, threshold * 1.5);
+  const yScale = CHART_HEIGHT / maxSpeed;
+
+  // Y-axis labels
+  ctx.fillStyle = '#666';
+  ctx.font = '9px sans-serif';
+  const yTicks = 5;
+  for (let t = 0; t <= yTicks; t++) {
+    const val = (maxSpeed / yTicks) * t;
+    const y = TOP_PAD + CHART_HEIGHT - val * yScale;
+    ctx.fillText(`${val.toFixed(1)}`, 5, y + 3);
+    // Grid line
+    ctx.strokeStyle = '#eee';
+    ctx.lineWidth = 0.5;
+    ctx.beginPath();
+    ctx.moveTo(LEFT_PAD, y);
+    ctx.lineTo(canvasW - 10, y);
+    ctx.stroke();
+  }
+
+  // Threshold line
+  const threshY = TOP_PAD + CHART_HEIGHT - threshold * yScale;
+  ctx.strokeStyle = '#ff0000';
+  ctx.lineWidth = 1.5;
+  ctx.setLineDash([5, 3]);
+  ctx.beginPath();
+  ctx.moveTo(LEFT_PAD, threshY);
+  ctx.lineTo(canvasW - 10, threshY);
+  ctx.stroke();
+  ctx.setLineDash([]);
+
+  // Bars
+  const PASTE_BAR_H = CHART_HEIGHT * 0.2; // Paste-only marker height: fixed 20% of chart.
+  for (let i = 0; i < trials.length; i++) {
+    const kind = kinds[i];
+    const speed = speeds[i];
+    const x = LEFT_PAD + i * (BAR_WIDTH + BAR_GAP);
+
+    if (kind === 'paste-only') {
+      // Fixed-height hatched grey bar + "P" marker. The height is arbitrary
+      // — the point is visible presence, not magnitude (we have no CPS to
+      // show). Sits at the bottom like a normal bar.
+      const y = TOP_PAD + CHART_HEIGHT - PASTE_BAR_H;
+      drawHatchedRect(ctx, x, y, BAR_WIDTH, PASTE_BAR_H);
+      ctx.strokeStyle = '#888';
+      ctx.lineWidth = 0.5;
+      ctx.strokeRect(x, y, BAR_WIDTH, PASTE_BAR_H);
+      // "P" marker above the bar
+      ctx.fillStyle = '#555';
+      ctx.font = 'bold 11px sans-serif';
+      ctx.fillText('P', x + BAR_WIDTH / 2 - 3, y - 3);
+    } else if (kind === 'typed') {
+      const barH = speed * yScale;
+      const y = TOP_PAD + CHART_HEIGHT - barH;
+      ctx.fillStyle = speed > threshold ? '#f44336' : '#2196F3';
+      ctx.fillRect(x, y, BAR_WIDTH, barH);
+      ctx.strokeStyle = '#333';
+      ctx.lineWidth = 0.5;
+      ctx.strokeRect(x, y, BAR_WIDTH, barH);
+      if (speed > 0) {
+        ctx.fillStyle = '#fff';
+        ctx.font = 'bold 9px sans-serif';
+        ctx.fillText(speed.toFixed(1), x + 3, y + 12);
+      }
+      // Mixed: typed AND pasted in the same trial. The bar shows the typing
+      // rate (legitimate signal); the "P" glyph above it flags that *some*
+      // of the response came in via paste. Distinct from pure paste-only
+      // (which is a hatched bar, no colored fill).
+      if ((trials[i].pasteEvents || []).length > 0) {
+        ctx.fillStyle = '#555';
+        ctx.font = 'bold 11px sans-serif';
+        ctx.fillText('P', x + BAR_WIDTH / 2 - 3, y - 3);
+      }
+    }
+    // 'no-data' → render nothing (blank column)
+
+    // Trial label (always drawn, even for blank columns)
+    const trialId = trials[i].trialId || trials[i].ruleId || `T${i + 1}`;
+    ctx.fillStyle = '#333';
+    ctx.font = '8px sans-serif';
+    ctx.save();
+    ctx.translate(x + BAR_WIDTH / 2, TOP_PAD + CHART_HEIGHT + 10);
+    ctx.rotate(Math.PI / 4);
+    ctx.fillText(trialId.substring(0, 12), 0, 0);
+    ctx.restore();
+  }
+
+  // Baseline
+  ctx.strokeStyle = '#333';
+  ctx.lineWidth = 1;
+  ctx.beginPath();
+  ctx.moveTo(LEFT_PAD, TOP_PAD + CHART_HEIGHT);
+  ctx.lineTo(canvasW - 10, TOP_PAD + CHART_HEIGHT);
+  ctx.stroke();
+
+  return canvas;
+}
+
+// Cross-hatched fill for paste-only markers. Uses a light grey background
+// with diagonal strokes so the bar reads as "distinct category, not zero".
+function drawHatchedRect(ctx, x, y, w, h) {
+  ctx.save();
+  ctx.fillStyle = '#e8e8e8';
+  ctx.fillRect(x, y, w, h);
+  ctx.beginPath();
+  ctx.rect(x, y, w, h);
+  ctx.clip();
+  ctx.strokeStyle = '#888';
+  ctx.lineWidth = 0.8;
+  const step = 5;
+  for (let d = -h; d < w + h; d += step) {
+    ctx.beginPath();
+    ctx.moveTo(x + d, y);
+    ctx.lineTo(x + d + h, y + h);
+    ctx.stroke();
+  }
+  ctx.restore();
+}
+
+// Used by the fs wrapper to build the per-participant PNG filename.
+export function sanitize(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, '_').substring(0, 40);
+}

package/src/cli/renderers/typing-profile.js

@@ -1,171 +1,26 @@
 // src/cli/renderers/typing-profile.js
-// Renders per-participant typing speed bar chart using node-canvas.
-// Each bar = one trial's chars/sec. A horizontal threshold line shows
-// the configured CPS threshold. Bars above threshold are colored red.
-
+// Thin fs wrapper around the pure drawing core (typing-profile-core.js).
+// The core takes an injected createCanvas and returns the drawn canvas (or
+// null when there's nothing to draw); this wrapper owns node-canvas
+// acquisition and PNG serialization so the core can also run in a browser
+// context (demo plot adapter) with document canvases.
 import { writeFileSync } from 'fs';
 import { join } from 'path';
-
-const BAR_WIDTH = 30;
-const BAR_GAP = 8;
-const CHART_HEIGHT = 200;
-const TOP_PAD = 50;
-const BOTTOM_PAD = 50;
-const LEFT_PAD = 60;
-
+import { drawTypingProfile, sanitize } from './typing-profile-core.js';
+// Load-bearing re-export: drawTypingProfile serves this wrapper's own loop
+// below and the future browser demo plot adapter — mirrors
+// session-timeline.js / trajectories.js. (renderTypingProfiles remains the
+// only symbol external consumers import from this file — see
+// tests/cli/renderers.test.js and src/cli/report.js.)
+export { drawTypingProfile };
+
+// ── Public API ───────────────────────────────────────────────────────────
 export async function renderTypingProfiles(participants, config) {
   const { createCanvas } = await import('canvas');
-  const threshold = config.typingSpeedThreshold_cps || 10;
 
   for (const p of participants) {
-    const trials = p.trials;
-    if (trials.length === 0) continue;
-
-    // Per-trial state. We distinguish three cases:
-    //   "typed"       — charsPerSec is a real number, draw a normal bar
-    //   "paste-only"  — charsPerSec is null but there's a paste event; draw a
-    //                   grey hatched marker so the absence is legible. Single
-    //                   paste fires one input event → editTimestamps.length < 2
-    //                   → computeTypingSpeed returns null. Without this, a
-    //                   pasted response looks identical to a very slow one.
-    //   "no-data"     — neither, leave blank
-    const kinds = trials.map(t => {
-      if (typeof t.charsPerSec === 'number') return 'typed';
-      if ((t.pasteEvents || []).length > 0) return 'paste-only';
-      return 'no-data';
-    });
-    const speeds = trials.map(t => (typeof t.charsPerSec === 'number' ? t.charsPerSec : 0));
-    if (kinds.every(k => k === 'no-data')) continue;
-
-    const canvasW = LEFT_PAD + trials.length * (BAR_WIDTH + BAR_GAP) + 20;
-    const canvasH = TOP_PAD + CHART_HEIGHT + BOTTOM_PAD;
-    const canvas = createCanvas(canvasW, canvasH);
-    const ctx = canvas.getContext('2d');
-
-    // Background
-    ctx.fillStyle = '#ffffff';
-    ctx.fillRect(0, 0, canvasW, canvasH);
-
-    // Title
-    ctx.fillStyle = '#333';
-    ctx.font = 'bold 14px sans-serif';
-    ctx.fillText(`Typing Speed Profile — ${p.participantId}`, LEFT_PAD, 20);
-    ctx.font = '10px sans-serif';
-    ctx.fillStyle = '#666';
-    ctx.fillText(`Threshold: ${threshold} chars/sec`, LEFT_PAD, 35);
-
-    // Legend — three states documented in the `kinds` comment above.
-    const legendY = 35;
-    const legendX0 = LEFT_PAD + 180;
-    ctx.fillStyle = '#2196F3';
-    ctx.fillRect(legendX0, legendY - 8, 12, 10);
-    ctx.fillStyle = '#666';
-    ctx.fillText('typed', legendX0 + 16, legendY);
-    ctx.fillStyle = '#f44336';
-    ctx.fillRect(legendX0 + 60, legendY - 8, 12, 10);
-    ctx.fillStyle = '#666';
-    ctx.fillText('> threshold', legendX0 + 76, legendY);
-    // Hatched swatch for paste-only
-    drawHatchedRect(ctx, legendX0 + 150, legendY - 8, 12, 10);
-    ctx.fillStyle = '#666';
-    ctx.fillText('paste (P)', legendX0 + 166, legendY);
-
-    // Y-axis scaling
-    const maxSpeed = Math.max(...speeds, threshold * 1.5);
-    const yScale = CHART_HEIGHT / maxSpeed;
-
-    // Y-axis labels
-    ctx.fillStyle = '#666';
-    ctx.font = '9px sans-serif';
-    const yTicks = 5;
-    for (let t = 0; t <= yTicks; t++) {
-      const val = (maxSpeed / yTicks) * t;
-      const y = TOP_PAD + CHART_HEIGHT - val * yScale;
-      ctx.fillText(`${val.toFixed(1)}`, 5, y + 3);
-      // Grid line
-      ctx.strokeStyle = '#eee';
-      ctx.lineWidth = 0.5;
-      ctx.beginPath();
-      ctx.moveTo(LEFT_PAD, y);
-      ctx.lineTo(canvasW - 10, y);
-      ctx.stroke();
-    }
-
-    // Threshold line
-    const threshY = TOP_PAD + CHART_HEIGHT - threshold * yScale;
-    ctx.strokeStyle = '#ff0000';
-    ctx.lineWidth = 1.5;
-    ctx.setLineDash([5, 3]);
-    ctx.beginPath();
-    ctx.moveTo(LEFT_PAD, threshY);
-    ctx.lineTo(canvasW - 10, threshY);
-    ctx.stroke();
-    ctx.setLineDash([]);
-
-    // Bars
-    const PASTE_BAR_H = CHART_HEIGHT * 0.2; // Paste-only marker height: fixed 20% of chart.
-    for (let i = 0; i < trials.length; i++) {
-      const kind = kinds[i];
-      const speed = speeds[i];
-      const x = LEFT_PAD + i * (BAR_WIDTH + BAR_GAP);
-
-      if (kind === 'paste-only') {
-        // Fixed-height hatched grey bar + "P" marker. The height is arbitrary
-        // — the point is visible presence, not magnitude (we have no CPS to
-        // show). Sits at the bottom like a normal bar.
-        const y = TOP_PAD + CHART_HEIGHT - PASTE_BAR_H;
-        drawHatchedRect(ctx, x, y, BAR_WIDTH, PASTE_BAR_H);
-        ctx.strokeStyle = '#888';
-        ctx.lineWidth = 0.5;
-        ctx.strokeRect(x, y, BAR_WIDTH, PASTE_BAR_H);
-        // "P" marker above the bar
-        ctx.fillStyle = '#555';
-        ctx.font = 'bold 11px sans-serif';
-        ctx.fillText('P', x + BAR_WIDTH / 2 - 3, y - 3);
-      } else if (kind === 'typed') {
-        const barH = speed * yScale;
-        const y = TOP_PAD + CHART_HEIGHT - barH;
-        ctx.fillStyle = speed > threshold ? '#f44336' : '#2196F3';
-        ctx.fillRect(x, y, BAR_WIDTH, barH);
-        ctx.strokeStyle = '#333';
-        ctx.lineWidth = 0.5;
-        ctx.strokeRect(x, y, BAR_WIDTH, barH);
-        if (speed > 0) {
-          ctx.fillStyle = '#fff';
-          ctx.font = 'bold 9px sans-serif';
-          ctx.fillText(speed.toFixed(1), x + 3, y + 12);
-        }
-        // Mixed: typed AND pasted in the same trial. The bar shows the typing
-        // rate (legitimate signal); the "P" glyph above it flags that *some*
-        // of the response came in via paste. Distinct from pure paste-only
-        // (which is a hatched bar, no colored fill).
-        if ((trials[i].pasteEvents || []).length > 0) {
-          ctx.fillStyle = '#555';
-          ctx.font = 'bold 11px sans-serif';
-          ctx.fillText('P', x + BAR_WIDTH / 2 - 3, y - 3);
-        }
-      }
-      // 'no-data' → render nothing (blank column)
-
-      // Trial label (always drawn, even for blank columns)
-      const trialId = trials[i].trialId || trials[i].ruleId || `T${i + 1}`;
-      ctx.fillStyle = '#333';
-      ctx.font = '8px sans-serif';
-      ctx.save();
-      ctx.translate(x + BAR_WIDTH / 2, TOP_PAD + CHART_HEIGHT + 10);
-      ctx.rotate(Math.PI / 4);
-      ctx.fillText(trialId.substring(0, 12), 0, 0);
-      ctx.restore();
-    }
-
-    // Baseline
-    ctx.strokeStyle = '#333';
-    ctx.lineWidth = 1;
-    ctx.beginPath();
-    ctx.moveTo(LEFT_PAD, TOP_PAD + CHART_HEIGHT);
-    ctx.lineTo(canvasW - 10, TOP_PAD + CHART_HEIGHT);
-    ctx.stroke();
-
+    const canvas = drawTypingProfile(p, config, createCanvas);
+    if (!canvas) continue;
     const buf = canvas.toBuffer('image/png');
     const filename = `typing_profile_${sanitize(p.participantId)}.png`;
     writeFileSync(join(config.outputDir, 'images', filename), buf);
@@ -173,28 +28,3 @@ export async function renderTypingProfiles(participants, config) {
 
   console.log(`  typing profiles — rendered`);
 }
-
-function sanitize(name) {
-  return name.replace(/[^a-zA-Z0-9_-]/g, '_').substring(0, 40);
-}
-
-// Cross-hatched fill for paste-only markers. Uses a light grey background
-// with diagonal strokes so the bar reads as "distinct category, not zero".
-function drawHatchedRect(ctx, x, y, w, h) {
-  ctx.save();
-  ctx.fillStyle = '#e8e8e8';
-  ctx.fillRect(x, y, w, h);
-  ctx.beginPath();
-  ctx.rect(x, y, w, h);
-  ctx.clip();
-  ctx.strokeStyle = '#888';
-  ctx.lineWidth = 0.8;
-  const step = 5;
-  for (let d = -h; d < w + h; d += step) {
-    ctx.beginPath();
-    ctx.moveTo(x + d, y);
-    ctx.lineTo(x + d + h, y + h);
-    ctx.stroke();
-  }
-  ctx.restore();
-}

package/src/cli/report.js

@@ -12,6 +12,7 @@ import { ingest } from './ingest.js';
 import { computeSummary } from './analyzers/summary.js';
 import { detectEdgeExits } from './analyzers/edge-exit.js';
 import { rankTriage } from './analyzers/triage.js';
+import { applyPhaseScope, describePhaseScope, findUnmatchedPhaseScopePhases } from './analyzers/phase-scope.js';
 import { VERSION } from '../shared/constants.js';
 
 export async function run(args) {
@@ -44,19 +45,43 @@ export async function run(args) {
     process.exit(1);
   }
 
-  // 3. Analyze — compute summaries, detect edge exits, rank by triage priority
-  const summaries = computeSummary(participants, config);
-  const edgeExits = detectEdgeExits(participants, config);
+  // 3. Analyze — compute summaries, detect edge exits, rank by triage priority.
+  // config.phaseScope (0.6.1) filters which trials feed the analyzers so
+  // scores can honor pre-registered phase scoping; renderers below still get
+  // the FULL participants, so the visual evidence is never hidden.
+  const scoredParticipants = applyPhaseScope(participants, config.phaseScope);
+  if (scoredParticipants !== participants) {
+    console.log(`\nPhase scope active (${describePhaseScope(config.phaseScope)}):`);
+    console.log(`  scores count per-trial signals inside the scope only; ambient session`);
+    console.log(`  signals (sidebar, shortcuts, viewport shifts, zoom) stay session-wide.`);
+    // A configured phase name that matches no trial is almost always a typo. For
+    // an `include`, it silently filters every trial and reports the cohort clean.
+    const unmatched = findUnmatchedPhaseScopePhases(participants, config.phaseScope);
+    if (unmatched.length > 0) {
+      console.warn(`[cyborg-hunter] phaseScope names match NO trial in the data: ` +
+        `${unmatched.join(', ')} — likely a typo; scored trials may be wrongly emptied.`);
+    }
+  }
+  const summaries = computeSummary(scoredParticipants, config);
+  const edgeExits = detectEdgeExits(scoredParticipants, config);
   const triage = rankTriage(summaries, edgeExits, config);
 
   const flaggedHard = triage.filter(t => t.hardTriggered).length;
   const flaggedSoft = triage.filter(t => !t.hardTriggered && t.softFlagged).length;
   const clean = triage.length - flaggedHard - flaggedSoft;
 
+  // Two DIFFERENT numbers live in this report and used to share the word
+  // "flagged": the tier counts below come from the LIBRARY's two-tier
+  // screening (hard count thresholds / soft score vs its threshold), while
+  // triage.md is ORDERED by the CLI's separate composite triage score
+  // (5×paste + 5×copy + 3×sidebar + 1×tab-away) within each tier. Label both
+  // explicitly so the console summary can't be read as "top N of triage.md".
   console.log(`\nAnalyzing...`);
-  console.log(`  Participants flagged (hard signals): ${flaggedHard}`);
-  console.log(`  Participants flagged (soft score): ${flaggedSoft}`);
-  console.log(`  Participants clean: ${clean}`);
+  console.log(`  Hard-flagged (hard signal crossed its count threshold): ${flaggedHard}`);
+  console.log(`  Soft-flagged (library soft score >= its threshold):     ${flaggedSoft}`);
+  console.log(`  Clean:                                                  ${clean}`);
+  console.log(`  Triage.md orders tier-first (hard > soft > clean), then by the CLI`);
+  console.log(`  triage score (5xpaste + 5xcopy + 3xsidebar + 1xtab-away) within a tier.`);
 
   // 4. Render outputs
   console.log(`\nRendering...`);
@@ -92,19 +117,28 @@ export async function run(args) {
 
     if (canvas) {
       const { renderTrajectories } = await import('./renderers/trajectories.js');
-      const { renderTabTimelines } = await import('./renderers/tab-timeline.js');
+      const { renderSessionTimelines } = await import('./renderers/session-timeline.js');
       const { renderTypingProfiles } = await import('./renderers/typing-profile.js');
 
       // Create images/ subdirectory for visual outputs
       mkdirSync(join(config.outputDir, 'images'), { recursive: true });
 
       await renderTrajectories(participants, triage, config);
-      await renderTabTimelines(participants, config);
+      await renderSessionTimelines(participants, config);
       await renderTypingProfiles(participants, config);
       visualsRendered = true;
     }
   }
 
+  // Replay assets — per-participant JSONP models under replay/, lazy-loaded
+  // by the HTML report. Size is printed because dom-tier models dominate
+  // the report's disk footprint.
+  const { renderReplayAssets } = await import('./renderers/replay-assets.js');
+  const replayAssets = renderReplayAssets(participants, config.outputDir);
+  if (replayAssets.count > 0) {
+    console.log(`  replay/ — ${replayAssets.count} session replays (${(replayAssets.totalBytes / 1024 / 1024).toFixed(1)} MB)`);
+  }
+
   // HTML index page — references images/ folder (not base64-embedded)
   const { renderHtmlIndex } = await import('./renderers/html-index.js');
   await renderHtmlIndex(summaries, triage, participants, config, visualsRendered);