wowbagger 0.5.0-beta.0 → 0.5.0

package/src/report-impact.js

@@ -0,0 +1,106 @@
+import { projectReadiness } from './ready.js';
+
+// Report-only dependency impact. The core readiness projection stays the
+// authority: ready-if-done is the baseline-to-counterfactual diff of
+// `projectReadiness` on a copied ledger where only the candidate is done.
+// Downstream reach mirrors the recommendation leverage traversal over the
+// retained open graph. Pure: no Node or DOM access, input never mutated.
+export function buildReportImpact(allItems, retainedOpenIds, asOf) {
+  const retained = new Set(retainedOpenIds);
+  const byId = new Map(allItems.map((item) => [item.data.id, item]));
+  const baseline = projectReadiness(allItems, asOf);
+
+  const dependents = new Map();
+  const children = new Map();
+  for (const id of retained) {
+    dependents.set(id, []);
+    children.set(id, []);
+  }
+  for (const item of allItems) {
+    const id = item.data.id;
+    if (Array.isArray(item.data.depends_on)) {
+      for (const dependencyId of item.data.depends_on) {
+        if (dependents.has(dependencyId) && retained.has(id)) {
+          dependents.get(dependencyId).push(id);
+        }
+      }
+    }
+    const parentId = item.data.parent;
+    if (parentId && children.has(parentId) && retained.has(id)) {
+      children.get(parentId).push(id);
+    }
+  }
+
+  const downstreamCache = new Map();
+  function downstream(id, onStack) {
+    const cached = downstreamCache.get(id);
+    if (cached !== undefined) {
+      return cached;
+    }
+    if (onStack.has(id)) {
+      return new Set();
+    }
+    onStack.add(id);
+    const collected = new Set();
+    for (const dependentId of dependents.get(id) ?? []) {
+      collected.add(dependentId);
+      for (const transitiveId of downstream(dependentId, onStack)) {
+        collected.add(transitiveId);
+      }
+    }
+    onStack.delete(id);
+    downstreamCache.set(id, collected);
+    return collected;
+  }
+
+  // Reverse dependency/ancestor reach from a candidate bounds the diff scan.
+  function affectedIds(candidateId) {
+    const seen = new Set([candidateId]);
+    const queue = [candidateId];
+    while (queue.length > 0) {
+      const current = queue.pop();
+      for (const next of dependents.get(current) ?? []) {
+        if (!seen.has(next)) {
+          seen.add(next);
+          queue.push(next);
+        }
+      }
+      for (const next of children.get(current) ?? []) {
+        if (!seen.has(next)) {
+          seen.add(next);
+          queue.push(next);
+        }
+      }
+    }
+    seen.delete(candidateId);
+    return seen;
+  }
+
+  function readinessIfDone(candidateId) {
+    const candidate = byId.get(candidateId);
+    if (!candidate) {
+      return baseline;
+    }
+    const copied = allItems.map((item) => (item === candidate
+      ? { ...item, data: { ...item.data, status: 'done' } }
+      : item));
+    return projectReadiness(copied, asOf);
+  }
+
+  const impact = {};
+  for (const id of [...retained].sort(compareText)) {
+    const downstreamIds = [...downstream(id, new Set())].filter((other) => other !== id).sort(compareText);
+    const after = readinessIfDone(id);
+    const readyIfDoneIds = [...affectedIds(id)]
+      .filter((other) => retained.has(other)
+        && baseline.get(other)?.state !== 'ready'
+        && after.get(other)?.state === 'ready')
+      .sort(compareText);
+    impact[id] = { downstreamIds, readyIfDoneIds };
+  }
+  return impact;
+}
+
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}

package/src/report-selection.js

@@ -0,0 +1,97 @@
+import { reportFieldValues } from './report-view.js';
+
+const SEARCH_INDEX = new WeakMap();
+const FACET_INDEX = new WeakMap();
+
+function searchableText(item) {
+  if (!SEARCH_INDEX.has(item)) {
+    SEARCH_INDEX.set(item, [
+      item.number, item.id, item.title,
+      ...Object.values(item.fields).flatMap(reportFieldValues),
+    ].filter((value) => value !== null && value !== undefined).join(' ').toLowerCase());
+  }
+  return SEARCH_INDEX.get(item);
+}
+
+function dimensionValues(item, dimension) {
+  if (!FACET_INDEX.has(item)) FACET_INDEX.set(item, new Map());
+  const index = FACET_INDEX.get(item);
+  if (!index.has(dimension)) {
+    const value = dimension === 'readiness' ? item.readiness.state
+      : dimension.startsWith('field:') ? item.fields[dimension.slice(6)] : item[dimension];
+    index.set(dimension, reportFieldValues(value));
+  }
+  return index.get(dimension);
+}
+
+export function selectReportItems(items, scope) {
+  const tokens = scope.search.trim().toLowerCase().split(/\s+/).filter(Boolean);
+  const facets = Object.entries(scope.facets);
+  return items.filter((item) => tokens.every((token) => searchableText(item).includes(token))
+    && facets.every(([dimension, selected]) => {
+      const values = dimensionValues(item, dimension);
+      return selected.length === 0 || selected.some((entry) => entry.kind === 'missing'
+        ? values.length === 0 : values.includes(entry.value));
+    }));
+}
+
+export function countReportFacets(items, scope, dimensions) {
+  return dimensions.map((dimension) => {
+    const facets = { ...scope.facets };
+    delete facets[dimension];
+    const options = new Map();
+    for (const item of selectReportItems(items, { search: scope.search, facets })) {
+      const values = dimensionValues(item, dimension);
+      const selections = values.length === 0 ? [{ kind: 'missing' }]
+        : [...new Set(values)].map((value) => ({ kind: 'value', value }));
+      for (const selection of selections) {
+        const key = JSON.stringify(selection);
+        const option = options.get(key);
+        if (option) option.count += 1;
+        else options.set(key, { selection, count: 1 });
+      }
+    }
+    return { dimension, options: [...options.entries()]
+      .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+      .map(([, option]) => option) };
+  });
+}
+
+const TERMINAL_STATUSES = new Set(['done', 'killed', 'archived', 'deferred']);
+
+export function selectListItems(items, state, workNextIds) {
+  const scoped = selectReportItems(items, state.scope);
+  if (state.drilldown !== null) {
+    const ids = new Set(state.drilldown.itemIds);
+    return scoped.filter((item) => ids.has(item.id));
+  }
+  const open = scoped.filter((item) => !TERMINAL_STATUSES.has(item.status));
+  let selected;
+  if (state.quickView === 'work-next') {
+    const byId = new Map(open.map((item) => [item.id, item]));
+    selected = workNextIds.filter((id) => byId.has(id)).map((id) => byId.get(id));
+  } else {
+    selected = open.filter((item) => {
+      switch (state.quickView) {
+        case 'in-progress': return item.status === 'in-progress';
+        case 'blocked': return item.readiness.state === 'blocked';
+        case 'triage': return item.status === 'triage';
+        case 'all-open': return true;
+        default: throw new Error(`Unknown report quick view: ${state.quickView}`);
+      }
+    });
+  }
+  return state.showHistory
+    ? [...selected, ...scoped.filter((item) => TERMINAL_STATUSES.has(item.status))]
+    : selected;
+}
+
+export function reportSelectionBrowserSource() {
+  return [
+    'const SEARCH_INDEX = new WeakMap();',
+    'const FACET_INDEX = new WeakMap();',
+    `const TERMINAL_STATUSES = new Set(${JSON.stringify([...TERMINAL_STATUSES])});`,
+    ...[reportFieldValues, searchableText, dimensionValues, selectReportItems,
+      countReportFacets, selectListItems].map((fn) => fn.toString().replace(/^export\s+/, '')),
+  ].join('\n');
+}

package/src/report-sequencing.js

@@ -98,7 +98,7 @@ export function computeEpicEnablement(allItems) {
   return epicById;
 }
 
-// Transitive unblocking leverage over the depends_on DAG. For each open item,
+// Transitive downstream reach over the depends_on DAG. For each open item,
 // the set of other open items whose dependency chain passes through it. The
 // ledger is cycle-checked before a report renders, so the reverse graph is a
 // DAG; the on-stack guard only keeps a hand-built model from looping.
@@ -170,7 +170,7 @@ export function collectUnknownClasses(openItems) {
 // The recommended order. Every factor is a separate, visible comparison step,
 // never a single opaque score: an entry's position is always explained by the
 // first step on which it beat the entry below it. Dominance runs expedite
-// class, fixed-date proximity, unblocking leverage, epic enablement, priority,
+// class, fixed-date proximity, downstream reach, epic enablement, priority,
 // age, then size, with the immutable ID as the determinism backstop.
 export function rankWorkNext(readyItems) {
   return [...readyItems]
@@ -239,7 +239,7 @@ function describeReasons(item) {
     reasons.push({ code: 'due', label: `due ${sequencing.due.date} (${duePhrase(sequencing.due.daysUntil)})` });
   }
   if (sequencing.leverage.count > 0) {
-    reasons.push({ code: 'leverage', label: `unblocks ${plural(sequencing.leverage.count, 'item')}${namedNumbers(sequencing.leverage.numbers)}` });
+    reasons.push({ code: 'leverage', label: `downstream reach: ${plural(sequencing.leverage.count, 'item')}${namedNumbers(sequencing.leverage.numbers)}` });
   }
   if (sequencing.epic !== null) {
     reasons.push({ code: 'epic', label: `advances ${epicPhrase(sequencing.epic)}` });
@@ -264,7 +264,7 @@ function plural(count, noun) {
   return `${count} ${noun}${count === 1 ? '' : 's'}`;
 }
 
-// Name at most four unblocked items so the reason stays one readable line.
+// Name at most four downstream items so the reason stays one readable line.
 function namedNumbers(numbers) {
   if (numbers.length === 0) {
     return '';

package/src/report-svg.js

@@ -10,7 +10,7 @@
 const CHART_WIDTH = 720;
 // The mean the evidence layer computes; named here only so the tooltip can say
 // how long a window it covers.
-const ROLLING_WEEKS = 4;
+const CHART_ROLLING_WEEKS = 4;
 const PLOT_LEFT = 34;
 const PLOT_RIGHT = 10;
 
@@ -64,7 +64,7 @@ export function agingHeatmapChart(matrix) {
     const top = HEAT_HEADER + rowIndex * HEAT_ROW;
     const cells = row.counts.map((count, columnIndex) => {
       const opacity = count === 0 ? 0 : coordinate(HEAT_FLOOR + HEAT_RANGE * (count / peak));
-      return `<g><title>${escapeText(matrix.statuses[columnIndex])}, ${escapeText(row.label)}: ${plural(count, 'open item')}</title>`
+      return `<g data-chart="aging" data-bucket="${escapeText(row.label)}" data-status="${escapeText(matrix.statuses[columnIndex])}"><title>${escapeText(matrix.statuses[columnIndex])}, ${escapeText(row.label)}: ${plural(count, 'open item')}</title>`
         + `<rect class="heat" x="${HEAT_LABEL_WIDTH + columnIndex * HEAT_CELL_WIDTH + 2}" y="${top + 2}" width="${HEAT_CELL_WIDTH - 4}" height="${HEAT_ROW - 4}" fill-opacity="${opacity}"></rect>`
         + `<text class="chart-value" x="${columnCentre(columnIndex)}" y="${top + 18}" text-anchor="middle">${count}</text>`
         + '</g>';
@@ -81,11 +81,12 @@ const THROUGHPUT_HEIGHT = 160;
 const THROUGHPUT_TOP = 14;
 const THROUGHPUT_BOTTOM = 34;
 
-// Completions per week with a four-week mean over them. Weekly throughput is
+// Closures per week with a four-week mean over them. Weekly throughput is
 // noisy enough that the bars alone invite a story about last week; the mean is
-// the line that tells whether the ledger is actually speeding up.
+// the line that tells whether the ledger is actually speeding up. The mean is
+// a closure rate: it counts every departure, not delivered work alone.
 export function throughputChart(weeks) {
-  const total = weeks.reduce((sum, week) => sum + week.completions, 0);
+  const total = weeks.reduce((sum, week) => sum + week.closures, 0);
   if (weeks.length === 0 || total === 0) {
     return '';
   }
@@ -94,7 +95,7 @@ export function throughputChart(weeks) {
   const plotHeight = THROUGHPUT_HEIGHT - THROUGHPUT_TOP - THROUGHPUT_BOTTOM;
   const baseline = THROUGHPUT_TOP + plotHeight;
   // The mean can never exceed the tallest week, so the bars set the scale.
-  const peak = Math.max(...weeks.map((week) => week.completions));
+  const peak = Math.max(...weeks.map((week) => week.closures));
   const slot = plotWidth / weeks.length;
   const barWidth = slot * 0.6;
   const centre = (index) => PLOT_LEFT + slot * (index + 0.5);
@@ -103,12 +104,13 @@ export function throughputChart(weeks) {
   const bars = weeks.map((week, index) => {
     const mean = week.rolling === null
       ? 'no four-week mean yet'
-      : `${week.rolling} a week over the last ${ROLLING_WEEKS}`;
+      : `${week.rolling} a week over the last ${CHART_ROLLING_WEEKS}`;
+    const scope = week.partial === true ? ', partial week' : '';
     const label = (weeks.length - 1 - index) % 2 === 0
       ? `<text class="chart-tick" x="${coordinate(centre(index))}" y="${baseline + 15}" text-anchor="middle">${escapeText(week.weekStart.slice(5))}</text>`
       : '';
-    return `<g><title>Week of ${escapeText(week.weekStart)}: ${plural(week.completions, 'completion')}, ${mean}</title>`
-      + `<rect class="bar-completion" x="${coordinate(centre(index) - barWidth / 2)}" y="${atCount(week.completions)}" width="${coordinate(barWidth)}" height="${coordinate((week.completions / peak) * plotHeight)}"></rect>`
+    return `<g><title>Week of ${escapeText(week.weekStart)}: ${plural(week.closures, 'closure')} (${week.done ?? 0} done)${scope}, ${mean}</title>`
+      + `<rect class="bar-closure" x="${coordinate(centre(index) - barWidth / 2)}" y="${atCount(week.closures)}" width="${coordinate(barWidth)}" height="${coordinate((week.closures / peak) * plotHeight)}"></rect>`
       + `</g>${label}`;
   }).join('');
 
@@ -123,7 +125,7 @@ export function throughputChart(weeks) {
     ? ''
     : `<polyline class="rolling" points="${meanPoints.join(' ')}"></polyline>`;
 
-  return `<svg class="chart" data-testid="chart-throughput" viewBox="0 0 ${CHART_WIDTH} ${THROUGHPUT_HEIGHT}" role="img" aria-label="Completions per week with a four-week mean. ${plural(total, 'completion')} over ${plural(weeks.length, 'week')}.">`
+  return `<svg class="chart" data-testid="chart-throughput" viewBox="0 0 ${CHART_WIDTH} ${THROUGHPUT_HEIGHT}" role="img" aria-label="Closures per week with a four-week mean. ${plural(total, 'closure')} over ${plural(weeks.length, 'week')}.">`
     + `<line class="chart-grid" x1="${PLOT_LEFT}" y1="${THROUGHPUT_TOP}" x2="${CHART_WIDTH - PLOT_RIGHT}" y2="${THROUGHPUT_TOP}"></line>`
     + `<line class="chart-axis" x1="${PLOT_LEFT}" y1="${baseline}" x2="${CHART_WIDTH - PLOT_RIGHT}" y2="${baseline}"></line>`
     + `<text class="chart-tick" x="${PLOT_LEFT - 6}" y="${THROUGHPUT_TOP + 4}" text-anchor="end">${peak}</text>`
@@ -186,10 +188,10 @@ export function cumulativeFlowChart(points) {
 const SCATTER_HEIGHT = 180;
 const SCATTER_TOP = 12;
 const SCATTER_BOTTOM = 34;
-const MILLISECONDS_PER_DAY = 86400000;
+const CHART_MILLISECONDS_PER_DAY = 86400000;
 
 function dayNumber(date) {
-  return Date.parse(`${date}T00:00:00Z`) / MILLISECONDS_PER_DAY;
+  return Date.parse(`${date}T00:00:00Z`) / CHART_MILLISECONDS_PER_DAY;
 }
 
 // Every finished item as one dot: how long it took against when it finished.
@@ -216,7 +218,7 @@ export function cycleTimeChart(cycleTime) {
 
   const dots = cycleTime.samples.map((sample, index) => {
     const handle = sample.number === null ? 'An item' : `#${sample.number}`;
-    return `<g><title>${escapeText(handle)} completed ${escapeText(sample.completedOn)} after ${plural(sample.days, 'day')}</title>`
+    return `<g data-chart="cycle" data-number="${sample.number === null ? '' : sample.number}" data-completed="${escapeText(sample.completedOn)}" data-days="${sample.days}"><title>${escapeText(handle)} completed ${escapeText(sample.completedOn)} after ${plural(sample.days, 'day')}</title>`
       + `<circle class="sample" cx="${atDay(days[index])}" cy="${atDuration(sample.days)}" r="3.5"></circle></g>`;
   }).join('');
 
@@ -300,11 +302,11 @@ const FLOW_HEIGHT = 200;
 const FLOW_TOP = 14;
 const FLOW_BOTTOM = 34;
 
-// Arrivals against completions, one grouped pair per week. The gap between the
+// Arrivals against closures, one grouped pair per week. The gap between the
 // pairs is the backlog growing or shrinking, which is the only thing this
 // chart exists to make visible.
 export function weeklyFlowChart(weeks) {
-  const total = weeks.reduce((sum, week) => sum + week.arrivals + week.completions, 0);
+  const total = weeks.reduce((sum, week) => sum + week.arrivals + week.closures, 0);
   if (weeks.length === 0 || total === 0) {
     return '';
   }
@@ -314,29 +316,81 @@ export function weeklyFlowChart(weeks) {
   const baseline = FLOW_TOP + plotHeight;
   // A zero total returned above, so some week is positive and the peak can
   // never be zero. A single week divides just as cleanly as twelve.
-  const peak = Math.max(...weeks.map((week) => Math.max(week.arrivals, week.completions)));
+  const peak = Math.max(...weeks.map((week) => Math.max(week.arrivals, week.closures)));
   const slot = plotWidth / weeks.length;
   const barWidth = slot * 0.32;
 
   const groups = weeks.map((week, index) => {
     const centre = PLOT_LEFT + slot * (index + 0.5);
     const arrivalHeight = (week.arrivals / peak) * plotHeight;
-    const completionHeight = (week.completions / peak) * plotHeight;
+    const closureHeight = (week.closures / peak) * plotHeight;
     // Tick every other week, counted back from the newest: the most recent
     // week is the one a reader looks for first, so it always carries a date.
     const label = (weeks.length - 1 - index) % 2 === 0
       ? `<text class="chart-tick" x="${coordinate(centre)}" y="${baseline + 15}" text-anchor="middle">${escapeText(week.weekStart.slice(5))}</text>`
       : '';
-    return `<g><title>Week of ${escapeText(week.weekStart)}: ${plural(week.arrivals, 'arrival')}, ${plural(week.completions, 'completion')}</title>`
+    const scope = week.partial === true ? ', partial week' : '';
+    return `<g data-chart="weekly" data-week="${escapeText(week.weekStart)}" data-kind="arrivals"><title>Week of ${escapeText(week.weekStart)}: ${plural(week.arrivals, 'arrival')}, ${plural(week.closures, 'closure')}${scope}</title>`
       + `<rect class="bar-arrival" x="${coordinate(centre - barWidth - 1)}" y="${coordinate(baseline - arrivalHeight)}" width="${coordinate(barWidth)}" height="${coordinate(arrivalHeight)}"></rect>`
-      + `<rect class="bar-completion" x="${coordinate(centre + 1)}" y="${coordinate(baseline - completionHeight)}" width="${coordinate(barWidth)}" height="${coordinate(completionHeight)}"></rect>`
+      + `</g><g data-chart="weekly" data-week="${escapeText(week.weekStart)}" data-kind="closures"><title>Week of ${escapeText(week.weekStart)}: ${plural(week.arrivals, 'arrival')}, ${plural(week.closures, 'closure')}${scope}</title>`
+      + `<rect class="bar-closure" x="${coordinate(centre + 1)}" y="${coordinate(baseline - closureHeight)}" width="${coordinate(barWidth)}" height="${coordinate(closureHeight)}"></rect>`
       + `</g>${label}`;
   }).join('');
 
-  return `<svg class="chart" data-testid="chart-weekly-flow" viewBox="0 0 ${CHART_WIDTH} ${FLOW_HEIGHT}" role="img" aria-label="Arrivals against completions per week. Peak ${peak} items in a week.">`
+  return `<svg class="chart" data-testid="chart-weekly-flow" viewBox="0 0 ${CHART_WIDTH} ${FLOW_HEIGHT}" role="img" aria-label="Arrivals against closures per week. Peak ${peak} items in a week.">`
     + `<line class="chart-grid" x1="${PLOT_LEFT}" y1="${FLOW_TOP}" x2="${CHART_WIDTH - PLOT_RIGHT}" y2="${FLOW_TOP}"></line>`
     + `<line class="chart-axis" x1="${PLOT_LEFT}" y1="${baseline}" x2="${CHART_WIDTH - PLOT_RIGHT}" y2="${baseline}"></line>`
     + `<text class="chart-tick" x="${PLOT_LEFT - 6}" y="${FLOW_TOP + 4}" text-anchor="end">${peak}</text>`
     + `<text class="chart-tick" x="${PLOT_LEFT - 6}" y="${baseline + 4}" text-anchor="end">0</text>`
     + `${groups}</svg>`;
 }
+
+// The charts the browser re-renders, serialized from the same functions Node
+// executes above. Tested for runtime parity against the direct functions in a
+// VM: the browser never carries a second formula.
+function browserChartSource(fn) {
+  return fn.toString().replace(/^export\s+/, '');
+}
+
+export function reportSvgBrowserSource() {
+  return [
+    `const CHART_WIDTH = ${CHART_WIDTH};`,
+    `const CHART_ROLLING_WEEKS = ${CHART_ROLLING_WEEKS};`,
+    `const PLOT_LEFT = ${PLOT_LEFT};`,
+    `const PLOT_RIGHT = ${PLOT_RIGHT};`,
+    `const HEAT_LABEL_WIDTH = ${HEAT_LABEL_WIDTH};`,
+    `const HEAT_CELL_WIDTH = ${HEAT_CELL_WIDTH};`,
+    `const HEAT_ROW = ${HEAT_ROW};`,
+    `const HEAT_HEADER = ${HEAT_HEADER};`,
+    `const HEAT_FLOOR = ${HEAT_FLOOR};`,
+    `const HEAT_RANGE = ${HEAT_RANGE};`,
+    `const THROUGHPUT_HEIGHT = ${THROUGHPUT_HEIGHT};`,
+    `const THROUGHPUT_TOP = ${THROUGHPUT_TOP};`,
+    `const THROUGHPUT_BOTTOM = ${THROUGHPUT_BOTTOM};`,
+    `const FLOW_AREA_HEIGHT = ${FLOW_AREA_HEIGHT};`,
+    `const FLOW_AREA_TOP = ${FLOW_AREA_TOP};`,
+    `const FLOW_AREA_BOTTOM = ${FLOW_AREA_BOTTOM};`,
+    `const FLOW_BANDS = ${JSON.stringify(FLOW_BANDS)};`,
+    `const SCATTER_HEIGHT = ${SCATTER_HEIGHT};`,
+    `const SCATTER_TOP = ${SCATTER_TOP};`,
+    `const SCATTER_BOTTOM = ${SCATTER_BOTTOM};`,
+    `const CHART_MILLISECONDS_PER_DAY = ${CHART_MILLISECONDS_PER_DAY};`,
+    `const FORECAST_HEIGHT = ${FORECAST_HEIGHT};`,
+    `const FORECAST_TOP = ${FORECAST_TOP};`,
+    `const FORECAST_BOTTOM = ${FORECAST_BOTTOM};`,
+    `const FORECAST_MARKS = ${JSON.stringify(FORECAST_MARKS)};`,
+    `const FLOW_HEIGHT = ${FLOW_HEIGHT};`,
+    `const FLOW_TOP = ${FLOW_TOP};`,
+    `const FLOW_BOTTOM = ${FLOW_BOTTOM};`,
+    browserChartSource(escapeText),
+    browserChartSource(coordinate),
+    browserChartSource(plural),
+    browserChartSource(agingHeatmapChart),
+    browserChartSource(throughputChart),
+    browserChartSource(cumulativeFlowChart),
+    browserChartSource(dayNumber),
+    browserChartSource(cycleTimeChart),
+    browserChartSource(forecastChart),
+    browserChartSource(weeklyFlowChart),
+  ].join('\n');
+}

package/src/report-view.js

@@ -64,6 +64,18 @@ export function normalizeReportViews(value, fieldMappings) {
 // configured `"1"` are different selections. An item missing the mapped field
 // matches no selected value for that field. Values inside one group are
 // alternatives; every present group must match.
+
+// One accessor for every consumer of a projected field value: absent values
+// carry no candidates, the tags array carries each member, and a scalar
+// carries itself. Named matching below and later selection code share it so
+// one item with two tags answers either tag filter.
+export function reportFieldValues(value) {
+  if (value === undefined || value === null) {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+}
+
 export function matchesReportView(item, filters) {
   if (filters.readiness !== undefined && !filters.readiness.includes(item.readiness.state)) {
     return false;
@@ -76,8 +88,9 @@ export function matchesReportView(item, filters) {
   }
   if (filters.fields !== undefined) {
     for (const [name, values] of Object.entries(filters.fields)) {
+      const carried = reportFieldValues(item.fields[name]);
       if (!Object.prototype.hasOwnProperty.call(item.fields, name)
-        || !values.some((candidate) => isSameScalar(candidate, item.fields[name]))) {
+        || !values.some((candidate) => carried.some((entry) => isSameScalar(candidate, entry)))) {
         return false;
       }
     }

package/src/report.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { projectReadiness } from './ready.js';
 import { buildAttention } from './report-attention.js';
 import { buildEvidence } from './report-evidence.js';
+import { buildReportImpact } from './report-impact.js';
 import {
   classifyItem,
   collectUnknownClasses,
@@ -38,6 +39,7 @@ const FIELD_KEYS = new Set([
   'severity',
   'confidence',
   'security',
+  'tags',
   'priority_base',
   'priority_component',
   'priority_impact',
@@ -108,11 +110,13 @@ export function resolvePointer(value, pointer) {
 export function buildReportModel(items, config, asOf) {
   const view = config.view ?? null;
   const readinessById = projectReadiness(items, asOf);
-  const allProjected = items.map((item) => projectItem(item, config.fields, readinessById.get(item.data.id)));
+  const projections = items.map((item) => projectItem(item, config.fields, readinessById.get(item.data.id)));
+  const allProjected = projections.map((projection) => projection.item);
   const projected = view === null
     ? allProjected
     : allProjected.filter((item) => matchesReportView(item, view.filters));
   const retainedIds = new Set(projected.map((item) => item.id));
+  const fieldCoverage = buildFieldCoverage(projections, config.fields, retainedIds);
   const reportItems = projected
     .filter((item) => item.terminalDate === null)
     .sort(compareProjectedItems);
@@ -145,9 +149,11 @@ export function buildReportModel(items, config, asOf) {
     items: reportItems,
     terminalItems,
     workNext,
+    impactById: buildReportImpact(items, new Set(reportItems.map((item) => item.id)), asOf),
     unknownClasses: collectUnknownClasses(reportItems),
     evidence,
     attention: buildAttention(reportItems, terminalItems, evidence.cycleTime, asOf),
+    fieldCoverage,
     stats: {
       total: projected.length,
       open: reportItems.length,
@@ -181,33 +187,104 @@ export function buildReportModel(items, config, asOf) {
 function projectItem(item, fieldMappings, readiness) {
   const { data } = item;
   const fields = {};
+  const invalidFields = [];
   for (const [slot, pointer] of Object.entries(fieldMappings)) {
-    const value = resolvePointer(data, pointer);
-    if (value !== null && ['string', 'number', 'boolean'].includes(typeof value)) {
-      fields[slot] = value;
+    const outcome = projectFieldValue(slot, resolvePointer(data, pointer));
+    if (outcome.state === 'present') {
+      fields[slot] = outcome.value;
+    } else if (outcome.state === 'invalid') {
+      invalidFields.push(slot);
     }
   }
 
-
   return {
-    id: data.id,
-    number: data.number ?? null,
-    title: data.title,
-    kind: data.kind,
-    status: data.status,
-    created: data.created,
-    updated: data.updated,
-    terminalDate: terminalDate(data),
-    priority: data.priority ?? null,
-    parent: data.parent ?? null,
-    dependsOn: data.depends_on ?? [],
-    related: data.related ?? [],
-    decisions: data.decisions ?? [],
-    body: item.body,
-    readiness,
-    fields,
+    item: {
+      id: data.id,
+      number: data.number ?? null,
+      title: data.title,
+      kind: data.kind,
+      status: data.status,
+      created: data.created,
+      updated: data.updated,
+      terminalDate: terminalDate(data),
+      priority: data.priority ?? null,
+      parent: data.parent ?? null,
+      dependsOn: data.depends_on ?? [],
+      related: data.related ?? [],
+      decisions: data.decisions ?? [],
+      body: item.body,
+      readiness,
+      fields,
+    },
+    invalidFields,
   };
 }
+
+// A resolved mapping is present, missing, or invalid, never guessed: absent
+// pointers and nulls are missing, a rejected value is invalid and stays out
+// of `fields` so it can never become a valid classification.
+function projectFieldValue(slot, value) {
+  if (value === undefined || value === null) {
+    return { state: 'missing', value: undefined };
+  }
+  if (slot === 'tags') {
+    const normalized = normalizeTags(value);
+    if (normalized === null) {
+      return { state: 'invalid', value: undefined };
+    }
+    return normalized.length === 0
+      ? { state: 'missing', value: undefined }
+      : { state: 'present', value: normalized };
+  }
+  return ['string', 'number', 'boolean'].includes(typeof value)
+    ? { state: 'present', value }
+    : { state: 'invalid', value: undefined };
+}
+
+// Tags are the one multi-value slot. A scalar source reads as a one-tag set;
+// an array must hold only nonempty strings and is taken whole, never
+// partially. Exact duplicates collapse and values sort deterministically. No
+// comma splitting, lowercasing, or object coercion.
+function normalizeTags(value) {
+  const source = typeof value === 'string' ? [value] : value;
+  if (!Array.isArray(source)) {
+    return null;
+  }
+  if (source.length === 0) {
+    return [];
+  }
+  if (!source.every((entry) => typeof entry === 'string' && entry.trim().length > 0)) {
+    return null;
+  }
+  return [...new Set(source)].sort();
+}
+
+// Coverage counts the retained named-report population, open and terminal, in
+// field-name order. Every configured field appears with `mapped: true`; area
+// and tags appear with `mapped: false` when not configured, with every
+// retained item missing. Counts never print rejected raw values.
+function buildFieldCoverage(projections, fieldMappings, retainedIds) {
+  const names = [...new Set([...Object.keys(fieldMappings), 'area', 'tags'])].sort();
+  return names.map((name) => {
+    const mapped = Object.prototype.hasOwnProperty.call(fieldMappings, name);
+    let present = 0;
+    let missing = 0;
+    let invalid = 0;
+    for (const projection of projections) {
+      if (!retainedIds.has(projection.item.id)) {
+        continue;
+      }
+      if (Object.prototype.hasOwnProperty.call(projection.item.fields, name)) {
+        present += 1;
+      } else if (projection.invalidFields.includes(name)) {
+        invalid += 1;
+      } else {
+        missing += 1;
+      }
+    }
+    return { name, mapped, present, missing, invalid };
+  });
+}
 export function buildSwarmBatches(items, eligibleComplexities) {
   const pool = items.filter((item) => item.readiness.state === 'ready'
     && isNonEmptyString(item.fields.area)