@bongos/core 1.19.534 → 1.19.535

package/modules/hall-ui/public/style.css

@@ -2039,8 +2039,10 @@ main [id] { scroll-margin-top: calc(var(--topbar-h) + 16px); }
      reduced-motion kill switch (§the kill switch, at the end of this sheet)
      already zeroes this with !important — do NOT add a second @media block
      here, which is what `tests/hall_tokens.mjs` forbids and why the rule
-     cannot rot in two places. */
-  transition: width 200ms ease;
+     cannot rot in two places. `margin-left` rides along because a SPAN bar
+     (barSeriesHtml's per-row `start`) moves as well as grows, and a bar that
+     slides while its neighbour eases reads as two different animations. */
+  transition: width 200ms ease, margin-left 200ms ease;
 }
 .kit-bars__row:hover .kit-bars__fill { opacity: .8; }
 .kit-bars__val { text-align: right; color: var(--ink-faint); }

package/modules/hall-ui/public/watch.html

@@ -111,6 +111,10 @@
             <h2 id="ledger-h" class="scroll__h">Repo health</h2>
             <p class="scroll__lede">The shape and health of the codebase.</p>
             <div id="ledger-stats" class="ov-figs"><span class="kit-skel"></span></div>
+            <!-- The trend the request has always carried and the page dropped
+                 on the floor (task 1003447) — the same shape as the sessions
+                 fix above it. -->
+            <div id="ledger-trend"></div>
             <div id="ledger-loc"></div>
             <div id="ledger-files"></div>
           </section>

package/modules/hall-ui/public/watch.js

@@ -942,6 +942,120 @@
       .replace(/\b\w/g, (c) => c.toUpperCase());
   }
 
+  // The four series the snapshot table keeps, in the order a reader wants them:
+  // how big the codebase is, then the three kinds of rot it accumulates.
+  //
+  // `zeroBased` is the axis decision, made per metric because the metrics are
+  // not alike. A count of dead exports belongs on a zero floor: zero is a real,
+  // reachable state and the distance from it IS the reading. `total_loc` never
+  // goes near zero — on a zero floor a month of real movement is a flat band
+  // across the top of the box, which is a picture of nothing. That one fits its
+  // floor to the data, and `trendFigure` puts the range in the foot so the
+  // magnified wiggle is never silent about what it is.
+  const TREND_METRICS = [
+    {
+      key: 'total_loc', title: 'Total lines', fmt: fmtCompact, zeroBased: false,
+      foot: 'Every tracked line of the codebase, snapshot by snapshot.',
+    },
+    {
+      key: 'dead_exports', title: 'Dead exports', fmt: fmtInt, zeroBased: true,
+      foot: 'Exported symbols nothing imports — the knip scan, run daily.',
+    },
+    {
+      key: 'stale_branches', title: 'Stale branches', fmt: fmtInt, zeroBased: true,
+      foot: 'Branches with no movement inside the staleness window.',
+    },
+    {
+      key: 'confirmed_unshipped', title: 'Confirmed, unshipped', fmt: fmtInt, zeroBased: true,
+      foot: 'Work verified but not yet landed — the strand backlog.',
+    },
+  ];
+
+  // One repo-health metric as a figure: the step plot, the value it ends on, and
+  // the table twin that keeps it out of picture-only territory.
+  //
+  // A STEP line, not a polyline, and that is the honest shape here: a snapshot's
+  // value is what the repo measured that morning and it holds until the next run
+  // measures again. The scan does not run every single day, so a straight line
+  // between two samples a week apart would draw movement nobody recorded.
+  //
+  // No readout is wired, so the plot passes `interactive: false` and takes
+  // neither a focus stop nor a crosshair — the /drachmae contract. The reading
+  // is the aria-label, the labelled endpoint and the twin.
+  function trendFigure({ key, title, fmt, foot: footText, zeroBased }, trend) {
+    const kit = window.OTBKit;
+    // Only rows that actually carry this metric. An older snapshot predates a
+    // column and sends null; counting that as 0 would draw a cliff to the floor
+    // that never happened.
+    //
+    // NOT `Number(v)` — that is the trap, and the trap is silent: Number(null),
+    // Number(undefined ?? '') and Number('') are 0, 0 and 0, every one of them
+    // finite, so a plain isFinite filter keeps a missing reading as a real zero.
+    // The page's own `num()` coerces the same way for the same reason. Mapping
+    // an absent value to NaN is what makes the filter below mean "carried".
+    const carried = (v) => (v === null || v === undefined || v === '' ? NaN : Number(v));
+    const points = trend
+      .map((r) => ({ x: Date.parse(r.snapshot_date), value: carried(r[key]) }))
+      .filter((p) => Number.isFinite(p.x) && Number.isFinite(p.value));
+    // One sample is a reading, not a trend, and it draws a single dot on an
+    // axis with nothing to compare it to.
+    if (points.length < 2) return '';
+
+    const last = points[points.length - 1];
+    // The axis window is the kit's arithmetic, not this page's.
+    const { lo, hi, yMin, yMax } = kit.plotWindow(points.map((p) => p.value), { zeroBased });
+
+    const series = kit.timeStepSeriesHtml(points, {
+      x0: points[0].x, x1: last.x, yMin, yMax,
+    });
+    const { endX, endY } = series.geometry;
+    const day = (t) => new Date(t).toISOString().slice(0, 10);
+    // At most ~21 rows however wide the window is (?days goes to 90), and the
+    // last row is always present so the twin ends where the plot's label does.
+    const step = Math.max(1, Math.ceil(points.length / 20));
+    const twinRows = points.filter((p, i) => i % step === 0 || i === points.length - 1);
+    const range = `${fmt(lo)} – ${fmt(hi)} across ${fmtInt(points.length)} snapshots.`;
+    // A fitted floor multiplies how big every move looks, so the figure says so
+    // in words rather than letting the picture imply a collapse to nothing.
+    const axisNote = zeroBased ? '' : ` The axis starts at ${fmt(Math.round(yMin))}, not zero.`;
+
+    return `<figure class="pchart" id="ledger-trend-${escapeHtml(key)}">
+      <figcaption class="pchart__title">${escapeHtml(title)}</figcaption>
+      ${kit.plotSvgHtml({
+    series: series.body,
+    interactive: false,
+    ariaLabel: `${title}: ${fmt(last.value)} on ${day(last.x)}, ranging ${fmt(lo)} to ${fmt(hi)} over the window.`,
+    label: kit.plotValueLabelHtml(endX, endY - 8, fmt(last.value), 'end'),
+    leftTick: day(points[0].x),
+    rightTick: day(last.x),
+  })}
+      <details class="pchart__twin">
+        <summary>Read it as a table</summary>
+        <table class="ledger pchart__table"><thead><tr><th>Snapshot</th><th>${escapeHtml(title)}</th></tr></thead><tbody>
+        ${twinRows.map((p) => `<tr><td>${escapeHtml(day(p.x))}</td><td>${escapeHtml(fmt(p.value))}</td></tr>`).join('')}
+        </tbody></table>
+      </details>
+      <p class="pchart__foot">${escapeHtml(`${footText} ${range}${axisNote}`)}</p>
+    </figure>`;
+  }
+
+  // The trend the route has always sent and renderLedger discarded (task
+  // 1003447). It is requested WITH ?days=30 — the page was paying for the window
+  // and reading one snapshot off it.
+  function renderTrend(data) {
+    const el = $('#ledger-trend');
+    if (!el) return;
+    const trend = Array.isArray(data.trend) ? data.trend : [];
+    const figures = TREND_METRICS.map((m) => trendFigure(m, trend)).filter(Boolean).join('');
+    // Nothing plottable yet (a fresh instance, or one metrics run) renders
+    // nothing at all — the figures above already say what today's numbers are,
+    // and an empty panel under them would be worse than no panel.
+    el.innerHTML = figures
+      ? `<section class="ov-group"><div class="ov-group__head"><span class="ov-group__name">Over the last ${escapeHtml(String(data.window_days || 30))} days</span></div>`
+        + `<div class="pcharts">${figures}</div></section>`
+      : '';
+  }
+
   function renderLedger(data, stats) {
     const locEl = $('#ledger-loc');
     const filesEl = $('#ledger-files');
@@ -962,6 +1076,8 @@
     }
     stats.innerHTML = figs(cards);
 
+    renderTrend(data);
+
     // loc_by_dir as a two-column ledger under its own head.
     const locByDir = latest.loc_by_dir && typeof latest.loc_by_dir === 'object' ? latest.loc_by_dir : {};
     const dirEntries = Object.entries(locByDir).sort((a, b) => num(b[1]) - num(a[1]));

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.534",
+  "version": "1.19.535",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.534",
+      "version": "1.19.535",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.534",
+  "version": "1.19.535",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/scripts/hall-preview/refresh-fixtures.js

@@ -63,6 +63,12 @@ const SNAPSHOTS = [
   ['public/progress', 'public__progress'],
   ['public/recent-shipped', 'public__recent-shipped'],
   ['public/repo-info', 'public__repo-info'],
+  // The roadmap's OTHER read (task 1003447). It was missing, so /roadmap has
+  // always 404'd here and fallen through its `.catch(() => [])` — which meant
+  // no track chip and no shipped date in preview, and (once the deck learned to
+  // draw them) no timeline. `versions` above is the AUTHENTICATED list; this is
+  // the public one the page actually calls, and the two are not interchangeable.
+  ['public/versions', 'public__versions'],
 ];
 
 (async () => {

package/src/module-api.js

@@ -46,7 +46,7 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.534'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.535'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/hall_kit_charts.mjs

@@ -349,6 +349,10 @@ test('the kit is loaded before every page that draws through it', () => {
     ['index.html', 'hall-render.js'],
     ['watch.html', 'watch.js'],
     ['profile.html', 'profile-charts.js'],
+    // task 1003447: the roadmap's own series module reads the kit, and the page
+    // reads that. Both edges of the chain are ordered here.
+    ['roadmap.html', 'roadmap-timeline.js'],
+    ['roadmap.html', 'roadmap.js'],
   ]) {
     // The loaded ORDER, read off the script tags — index.html's prose mentions
     // hall-render.js ~90 lines above where it loads it, so a substring search
@@ -375,3 +379,172 @@ test('the migrated pages run for real against the kit and emit its classes', ()
     /class="kit-bars"/,
   );
 });
+
+// ---- 5. the SPAN bar and the fitted axis (task 1003447) --------------------
+//
+// Two options, both added so the goal's last two charts needed no new drawing
+// code and no new class family: a bar that starts somewhere other than the
+// track's left edge (which is what makes a bar series a TIMELINE), and a plot
+// whose axis sits at something other than zero (which is what makes a step line
+// readable for a LEVEL rather than a running total).
+
+test('a row\'s `start` offsets the bar and leaves its length alone', () => {
+  // The roadmap's shape: version A ran for the first quarter of the axis,
+  // version B for the middle half. Same primitive, same classes.
+  const html = kit.barSeriesHtml([
+    { label: 'A', value: 25 },
+    { label: 'B', value: 50, start: 25 },
+  ], { max: 100 });
+  const fills = [...html.matchAll(/class="kit-bars__fill" style="([^"]+)"/g)].map((m) => m[1]);
+  assert.deepEqual(fills, ['width:25%', 'margin-left:25%;width:50%']);
+  assert.equal((html.match(/class="kit-bars"/g) || []).length, 1, 'still one class family');
+});
+
+test('a bar with no `start` writes no offset at all', () => {
+  // The compatibility contract: every caller that predates the span option gets
+  // byte-identical markup, so `margin-left:0%` never appears in a diff or in a
+  // snapshot of an existing chart.
+  const html = kit.barSeriesHtml([{ label: 'a', value: 3 }, { label: 'b', value: 1, start: 0 }]);
+  assert.doesNotMatch(html, /margin-left/);
+  // A nonsense start is ignored rather than written through into the style.
+  const junk = kit.barSeriesHtml([{ label: 'a', value: 3, start: 'nope' }], { max: 10 });
+  assert.doesNotMatch(junk, /margin-left/);
+  assert.doesNotMatch(junk, /NaN/);
+});
+
+test('a tiny non-zero `start` still offsets, so "first" stays a real claim', () => {
+  // The offset takes the same floor the width does. Without it a span beginning
+  // just after the axis origin rounds to 0% and draws flush left — which on a
+  // timeline reads as "this one started first", a claim about ordering rather
+  // than a rounding artefact.
+  const html = kit.barSeriesHtml([
+    { label: 'first', value: 500 },
+    { label: 'barely later', value: 500, start: 1 },
+  ], { max: 1000 });
+  const fills = [...html.matchAll(/class="kit-bars__fill" style="([^"]+)"/g)].map((m) => m[1]);
+  assert.equal(fills[0], 'width:50%', 'the one at the origin carries no offset');
+  assert.match(fills[1], /^margin-left:1%/, 'and the one after it is visibly after it');
+});
+
+test('a positive value never draws nothing, however small its share', () => {
+  // Rounding alone sends anything under half a percent to `width:0%`, which
+  // reads as "none" — the one thing it is not. Load-bearing for the roadmap: a
+  // version that started and shipped inside one day is a real span.
+  const html = kit.barSeriesHtml([{ label: 'tiny', value: 1 }, { label: 'huge', value: 100000 }]);
+  assert.match(html, /width:1%/, 'the sliver survives');
+  // and zero is still zero: an empty track is the honest picture of nothing.
+  assert.match(kit.barSeriesHtml([{ label: 'a', value: 0 }, { label: 'b', value: 9 }]), /width:0%/);
+});
+
+test('plotWindow puts a reachable-zero series on a zero floor', () => {
+  const w = kit.plotWindow([0, 3, 1, 4]);
+  assert.equal(w.yMin, 0, 'a count sits on zero — the distance from it IS the reading');
+  assert.ok(w.yMax > 4, 'with air above, so the peak does not ride the top edge');
+  assert.equal(w.lo, 0);
+  assert.equal(w.hi, 4);
+});
+
+test('plotWindow fits the floor for a level, which is why the caller must say so', () => {
+  const w = kit.plotWindow([24880, 27195], { zeroBased: false });
+  assert.ok(w.yMin > 24000 && w.yMin < 24880, 'the axis rises to just under the minimum');
+  assert.ok(w.yMax > 27195);
+  // The whole point: on a zero floor this month of change would occupy the top
+  // 9% of the box. Fitted, it occupies the whole of it.
+  const zero = kit.plotWindow([24880, 27195]);
+  assert.ok((w.yMax - w.yMin) < (zero.yMax - zero.yMin) / 5, 'the fitted window is far tighter');
+});
+
+test('plotWindow survives a flat series and an empty one', () => {
+  // A flat series has no range to take a fraction of, and dividing by it is how
+  // a chart renders as an invisible NaN.
+  const flat = kit.plotWindow([5, 5, 5]);
+  assert.ok(flat.yMax > 5, 'flat still gets air, so the line is not welded to the top');
+  const flatFit = kit.plotWindow([5, 5, 5], { zeroBased: false });
+  assert.ok(flatFit.yMin < 5 && flatFit.yMax > 5, 'and a fitted flat line lands mid-box');
+  const zeros = kit.plotWindow([0, 0, 0]);
+  assert.equal(zeros.yMin, 0);
+  assert.ok(zeros.yMax > 0, 'a month of honest zeros still divides by something');
+  assert.deepEqual(kit.plotWindow([]), { lo: 0, hi: 0, yMin: 0, yMax: 1, n: 0 });
+});
+
+test('plotWindow DROPS a non-finite reading rather than counting it as zero', () => {
+  // The trap this exists to close: Number(null) is 0 and finite, so a snapshot
+  // that predates a column would drag `lo` to zero and draw a cliff.
+  const w = kit.plotWindow([100, null, 120, undefined, 110]);
+  assert.equal(w.lo, 100);
+  assert.equal(w.n, 3, 'three readings, not five');
+});
+
+test('yMin lifts the axis, and its default leaves every existing series where it was', () => {
+  const box = { width: 100, height: 100, pad: { l: 0, r: 0, t: 0, b: 0 } };
+  const pts = [{ x: 0, value: 10 }, { x: 10, value: 20 }];
+  // Default (0): 20 of a 20-high window is the top, 10 is halfway.
+  const zero = kit.timeStepGeometry(pts, { x0: 0, x1: 10, yMax: 20, ...box });
+  assert.equal(zero.py(20).toFixed(1), '0.0');
+  assert.equal(zero.py(10).toFixed(1), '50.0');
+  // Fitted to 10..20: the same two points now span the whole box.
+  const fitted = kit.timeStepGeometry(pts, { x0: 0, x1: 10, yMin: 10, yMax: 20, ...box });
+  assert.equal(fitted.py(20).toFixed(1), '0.0');
+  assert.equal(fitted.py(10).toFixed(1), '100.0');
+  // A degenerate window (yMin === yMax) must not divide by zero.
+  const flat = kit.timeStepGeometry(pts, { x0: 0, x1: 10, yMin: 5, yMax: 5, ...box });
+  assert.doesNotMatch(flat.d, /NaN|Infinity/);
+});
+
+test('RUN: the roadmap timeline draws the real versions as spans on one axis', async () => {
+  // The page's own series module, run against the checked-in /public/versions
+  // fixture — the arithmetic a source assertion cannot reach. It is imported
+  // rather than stubbed for the same reason the kit is: a copy of the maths
+  // agreeing with itself proves nothing about what a reader gets.
+  const modPath = path.join(HALL, 'roadmap-timeline.js');
+  const tl = await import(`file://${modPath.replace(/\\/g, '/')}`).then((m) => m.default);
+  // public__versions.json, NOT versions.json — the deck calls /public/versions,
+  // and the authenticated list is a different payload. Reading the wrong one
+  // here is precisely the trap this task's own CLAUDE.md note warns about.
+  const fixture = JSON.parse(fs.readFileSync(
+    path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', 'public__versions.json'), 'utf8'));
+  const all = fixture.versions.map((v) => ({ id: v.id, start: v.started_at, ship: v.shipped_at }));
+  const now = Date.parse('2026-09-03T12:00:00Z');
+
+  const rows = tl.timelineRows(all, now);
+  assert.equal(rows.length, all.length, 'every fixture version has a start date');
+  const starts = rows.map((r) => r.from);
+  assert.deepEqual(starts, [...starts].sort((a, b) => a - b), 'oldest first');
+  assert.ok(rows.some((r) => r.open), 'the in-flight version runs to today');
+  assert.ok(rows.every((r) => r.to >= r.from), 'no span runs backwards');
+
+  const card = tl.timelineCardHtml(all, now, kit);
+  assert.equal(card.count, rows.length);
+  assert.doesNotMatch(card.html, /NaN|Infinity|undefined/);
+  assert.match(card.html, /class="kit-bars"/, 'drawn by the kit, not by hand');
+  const offsets = [...card.html.matchAll(/margin-left:(\d+)%/g)].map((m) => Number(m[1]));
+  assert.ok(offsets.length >= 2, 'later versions start further along the axis');
+  assert.deepEqual(offsets, [...offsets].sort((a, b) => a - b), 'and their offsets grow with their start dates');
+  // PMS-V1 started and shipped inside ONE day of a four-month axis: the span
+  // that rounds to nothing without the 1% floor. It is also the earliest
+  // version, so it correctly carries no offset — assert the floor, not a
+  // margin-left the axis origin has no reason to write.
+  const pms = card.html.match(/PMS-V1<\/span><span class="kit-bars__track"[^>]*><span class="kit-bars__fill" style="([^"]+)"/);
+  assert.ok(pms, 'PMS-V1 has a bar');
+  assert.match(pms[1], /width:[1-9]/, 'a one-day span still draws, rather than rounding to nothing');
+  assert.doesNotMatch(pms[1], /margin-left/, 'and the earliest version sits at the axis origin');
+});
+
+test('RUN: the timeline refuses to draw rather than drawing an empty axis', async () => {
+  const modPath = path.join(HALL, 'roadmap-timeline.js');
+  const tl = await import(`file://${modPath.replace(/\\/g, '/')}`).then((m) => m.default);
+  const now = Date.parse('2026-09-03T12:00:00Z');
+  assert.equal(tl.timelineCardHtml([], now, kit), null, 'nothing at all');
+  assert.equal(tl.timelineCardHtml([{ id: 'A', start: '2026-01-01' }], now, kit), null,
+    'one version is not a timeline');
+  // A version with no start date is left OUT and counted in the foot, never
+  // drawn at the axis origin — which would read as "began with the project".
+  const card = tl.timelineCardHtml([
+    { id: 'A', start: '2026-01-01', ship: '2026-02-01' },
+    { id: 'B', start: '2026-03-01', ship: null },
+    { id: 'C', start: null, ship: null },
+  ], now, kit);
+  assert.equal(card.count, 2);
+  assert.doesNotMatch(card.html, />C</, 'the unstarted version is not a bar');
+  assert.match(card.html, /1 version with no start date is not shown/, 'the foot says so');
+});

package/tests/hall_oversight_world.mjs

@@ -11,6 +11,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import path from 'node:path';
+import vm from 'node:vm';
 import { fileURLToPath } from 'node:url';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
@@ -116,3 +117,161 @@ test('the vocabulary wall holds: the family is named oversight on the government
     assert.ok(!/governance/i.test(read(f)), `${f} does not say the pre-ADR-0174 word`);
   }
 });
+
+// ---- the repo-health trend (task 1003447, `legibility-series-are-drawn`) ----
+//
+// /public/repo-health has always answered with `latest` PLUS a trend[], and the
+// route's own comment says the trend exists "so the status page can draw LOC /
+// dead-exports / stale-branch lines over time ... oldest->newest so the
+// dashboard can plot left->right". Watch requested it WITH ?days=30 — paying for
+// the whole window — and renderLedger read one snapshot off it. The series
+// arrived over the wire and went on the floor.
+//
+// The AXIS arithmetic is the kit's (plotWindow / timeStepSeriesHtml) and
+// tests/hall_kit_charts.mjs runs it for real. What lives here is Watch's half:
+// that the section composes the kit rather than drawing by hand, and — the part
+// no source assertion can reach — that booting the REAL page against the REAL
+// checked-in fixture puts four finite plots on the panel.
+
+const FIXTURES = path.join(ROOT, 'scripts', 'hall-preview', 'fixtures');
+const repoHealthFixture = () => JSON.parse(fs.readFileSync(path.join(FIXTURES, 'public__repo-health.json'), 'utf8'));
+
+// Boot watch.js in a stub DOM with the real dom-utils and the real kit, answer
+// /me as an archon and /public/repo-health with the fixture, and hand back what
+// landed in #ledger-trend. Every OTHER endpoint answers 500, which is the
+// page's own design (each section loads independently) and keeps this harness
+// to the one panel it is about.
+async function bootWatchLedger(overrides = {}) {
+  const payload = { ...repoHealthFixture(), ...overrides };
+  const els = new Map();
+  const makeEl = () => ({
+    dataset: {}, style: {}, textContent: '', hidden: false, disabled: false, _html: '',
+    classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+    setAttribute() {}, getAttribute() { return null; }, removeAttribute() {},
+    addEventListener() {}, appendChild() {}, insertAdjacentHTML(_, h) { this._html += h; },
+    closest() { return null; },
+    querySelector() { return null; }, querySelectorAll() { return []; },
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+  });
+  const documentObj = {
+    getElementById(id) { if (!els.has(id)) els.set(id, makeEl()); return els.get(id); },
+    querySelector(sel) {
+      const s = String(sel);
+      return s.startsWith('#') ? this.getElementById(s.slice(1)) : makeEl();
+    },
+    querySelectorAll() { return []; },
+    createElement() { return makeEl(); },
+    addEventListener() {},
+  };
+  const client = {
+    request: async (method, urlPath) => {
+      if (urlPath.endsWith('/me')) {
+        return { ok: true, status: 200, data: { builder: { id: '1', rank: 'archon', github_login: 'x' } } };
+      }
+      if (urlPath.includes('/public/repo-health')) return { ok: true, status: 200, data: payload };
+      return { ok: false, status: 500, data: {} };
+    },
+  };
+  const windowObj = {
+    BongosClient: { createClient: () => client },
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    localStorage: { getItem: () => null, setItem() {}, removeItem() {} },
+    location: { hash: '', pathname: '/watch', search: '', assign() {} },
+    addEventListener() {}, matchMedia: () => ({ matches: false, addEventListener() {} }),
+  };
+  const sandbox = {
+    window: windowObj, document: documentObj, location: windowObj.location,
+    localStorage: windowObj.localStorage,
+    // The two browser globals the kit reaches for outside `window`: CSS.escape
+    // (tab selectors) and history.replaceState (the tab's deep link).
+    CSS: { escape: (s) => String(s) },
+    history: { replaceState() {} },
+    console: { ...console, error() {}, warn() {} },
+    setTimeout, clearTimeout, URLSearchParams, Intl,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  for (const f of ['dom-utils.js', 'hall-kit.js', 'watch.js']) {
+    vm.runInContext(read(f), sandbox, { filename: f });
+  }
+  // load() is async: let every section's promise settle before reading the DOM.
+  for (let i = 0; i < 8; i++) await new Promise((r) => setTimeout(r, 0));
+  return { html: documentObj.getElementById('ledger-trend').innerHTML, latest: payload.latest, windowObj };
+}
+
+test('the repo-health trend has a mount, and renderLedger fills it', () => {
+  const js = read('watch.js');
+  assert.match(read('watch.html'), /id="ledger-trend"/, 'the mount exists in the markup');
+  assert.match(js, /renderTrend\(data\);/, 'renderLedger hands the whole payload on, not just latest');
+  assert.match(js, /'\/public\/repo-health\?days=30'/, 'the request still asks for the window');
+  assert.match(js, /data\.window_days/, 'and the heading says which window it drew');
+});
+
+test('every mark in the trend is the kit\'s — no hand-drawn plot on the oversight page', () => {
+  const js = read('watch.js');
+  for (const fn of ['plotWindow', 'timeStepSeriesHtml', 'plotSvgHtml', 'plotValueLabelHtml']) {
+    assert.match(js, new RegExp(`kit\\.${fn}\\(`), `the trend draws through ${fn}`);
+  }
+  // §6b holds this globally; pinned here too because this is the page that
+  // hand-rolled a bar chart once already (task 1003445).
+  assert.doesNotMatch(js, /<(?:path|polyline|rect)\b[^>]*\b(?:d|points)="\$\{/,
+    'no hand-built SVG geometry on Watch');
+  // No readout is wired, so the plot must drop the focus stop AND the crosshair
+  // together — the task 1003446 pairing. Half of it is worse than neither.
+  assert.match(js, /interactive: false/, 'the trend plots are not fake-interactive');
+  assert.match(js, /class="pchart__twin"/, 'and each carries its table twin instead');
+});
+
+test('a fitted axis says so in words, because it magnifies every move', () => {
+  // total_loc is the one metric drawn off a non-zero floor: on a zero floor a
+  // month of real change is a flat band across the top of the box. That choice
+  // makes small movement look large, so the figure states its baseline rather
+  // than letting the picture imply a collapse to nothing.
+  const js = read('watch.js');
+  assert.match(js, /key: 'total_loc',[\s\S]{0,120}zeroBased: false/, 'total_loc fits its floor');
+  for (const k of ['dead_exports', 'stale_branches', 'confirmed_unshipped']) {
+    assert.match(js, new RegExp(`key: '${k}',[\\s\\S]{0,120}zeroBased: true`), `${k} keeps the zero floor`);
+  }
+  assert.match(js, /not zero/, 'and a fitted figure names its baseline in the foot');
+});
+
+test('RUN: the real page against the real fixture puts four finite plots on the panel', async () => {
+  // The half a source assertion cannot see. A NaN in a path `d` renders as an
+  // invisible chart with no error anywhere — a grep never finds that, and a
+  // stub agreeing with a stub never would either.
+  const { html, latest } = await bootWatchLedger();
+  assert.ok(html.length > 0, 'the panel drew something');
+  assert.doesNotMatch(html, /NaN|Infinity|undefined/, 'no broken geometry reaches the DOM');
+  const figures = [...html.matchAll(/id="ledger-trend-([a-z_]+)"/g)].map((m) => m[1]);
+  assert.deepEqual(figures, ['total_loc', 'dead_exports', 'stale_branches', 'confirmed_unshipped'],
+    'all four metrics draw, in the reading order');
+  assert.equal((html.match(/class="kit-plot"/g) || []).length, 4, 'four plots');
+  assert.ok(!/tabindex="0"/.test(html), 'none of them is a focus stop with nothing to do');
+  assert.equal((html.match(/class="kit-plot__hair"/g) || []).length, 0, 'and none carries a crosshair nothing moves');
+  // The plot and the figure band above it derive from ONE payload, so they
+  // cannot disagree: the labelled endpoint is the number the snapshot states.
+  const compact = `${(latest.total_loc / 1e3).toFixed(1)}k`;
+  assert.ok(html.includes(`>${compact}<`), `the line ends on ${compact}, the value the snapshot figure shows`);
+});
+
+test('RUN: a payload with no trend renders nothing rather than an empty panel', async () => {
+  // The honest exit the module doc requires. The figures above already say what
+  // today's numbers are; an empty card under them would be worse than no card.
+  const { html } = await bootWatchLedger({ trend: [] });
+  assert.equal(html.trim(), '', 'no heading, no card, no "no data" box');
+});
+
+test('RUN: one snapshot is a reading, not a trend', async () => {
+  // A single point draws a dot on an axis with nothing to compare it to.
+  const { html } = await bootWatchLedger({ trend: repoHealthFixture().trend.slice(-1) });
+  assert.equal(html.trim(), '');
+});
+
+test('RUN: a metric its snapshots never carried is skipped, not drawn as a cliff', async () => {
+  // An older snapshot predates a column and sends null. Reading that as 0 would
+  // draw a fall to the floor that never happened, so the figure is dropped.
+  const trend = repoHealthFixture().trend.map((r) => ({ ...r, dead_exports: null }));
+  const { html } = await bootWatchLedger({ trend });
+  const figures = [...html.matchAll(/id="ledger-trend-([a-z_]+)"/g)].map((m) => m[1]);
+  assert.deepEqual(figures, ['total_loc', 'stale_branches', 'confirmed_unshipped']);
+});