@bongos/core 1.21.174 → 1.21.176

package/tests/spike_task_map.mjs

@@ -1,422 +0,0 @@
-// tests/spike_task_map.mjs — the task-network-map spike is REPRODUCIBLE
-// (task 1003282, goal 1000072 "Human legibility").
-//
-// docs/research/task-network-map-readability.md quotes exact numbers and draws a
-// verdict from them ("build the goal graph, never the task graph"). A spike whose
-// numbers cannot be reproduced is an opinion with a table attached, so the harness's
-// pure halves are pinned here: the corpus is deterministic, the graph views are what
-// they claim to be, and the two findings the verdict actually rests on come out of the
-// code rather than out of the prose.
-//
-// Deliberately NOT pinned: the exact crossing counts and layout milliseconds. Those are
-// machine- and iteration-dependent, and asserting them would make this file fail on a
-// slower CI box for no reader's benefit. The structural numbers — which is what the
-// verdict argues from — are exact.
-//
-// Run:  node tests/spike_task_map.mjs
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import fs from 'node:fs';
-import os from 'node:os';
-import zlib from 'node:zlib';
-import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
-import { makeRunner } from './helpers.mjs';
-
-const require = createRequire(import.meta.url);
-const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const spike = require(path.join(ROOT, 'scripts/gds/spike-task-map.js'));
-
-const { test, summary } = makeRunner();
-const CORPUS = { nodes: 1357, goals: 40 };
-
-await test('the corpus is deterministic — the same seed gives the same graph', () => {
-  const a = spike.buildSynthetic({ ...CORPUS, density: 0.1 });
-  const b = spike.buildSynthetic({ ...CORPUS, density: 0.1 });
-  assert.deepEqual(a, b, 'a spike that re-rolls its own numbers proves nothing twice');
-});
-
-await test('dependencies point backwards only — the real table cannot hold a cycle', () => {
-  // task_dependencies has a no-self-dep CHECK and the auto-promotion trigger assumes a
-  // DAG, so a corpus with a cycle would be measuring a graph the system cannot contain.
-  const tasks = spike.buildSynthetic({ ...CORPUS, density: 0.4 });
-  for (const t of tasks) for (const d of t.deps) assert.ok(d < t.id, `task ${t.id} depends on ${d}`);
-});
-
-await test('the four views are what the write-up says they are', () => {
-  const tasks = spike.buildSynthetic({ ...CORPUS, density: 0.2 });
-  const v = spike.viewsOf(tasks);
-  assert.equal(v.A.nodes.length, 1357, 'A is every task');
-  assert.equal(v.D.nodes.length, 1357, 'D is every task too — only the edges differ');
-  assert.equal(v.C.nodes.length, 40, 'C is one node per goal');
-  assert.ok(v.B.nodes.length < v.A.nodes.length, 'B drops the unconnected');
-  assert.ok(v.D.edges.length > v.A.edges.length * 50, 'D is denser than A by orders of magnitude');
-  assert.ok(v.D.edges.length > 20000, `D is the dense attempt — got ${v.D.edges.length} edges`);
-  // B is exactly A minus the isolated nodes, and keeps every edge.
-  assert.equal(v.B.edges.length, v.A.edges.length);
-  const cA = spike.components(v.A.nodes, v.A.edges);
-  assert.equal(v.B.nodes.length, v.A.nodes.length - cA.singletons);
-});
-
-await test('FINDING 1: "every task" is majority-isolated at every density swept', () => {
-  // The verdict's load-bearing claim: the failure is confetti, not a hairball, and it
-  // does not go away at the dense end of the plausible range.
-  for (const density of [0.02, 0.05, 0.10, 0.20, 0.40]) {
-    const v = spike.viewsOf(spike.buildSynthetic({ ...CORPUS, density }));
-    const c = spike.components(v.A.nodes, v.A.edges);
-    const isolatedPct = (c.singletons / v.A.nodes.length) * 100;
-    assert.ok(isolatedPct > 50,
-      `p=${density}: only ${isolatedPct.toFixed(1)}% isolated — the confetti finding no longer holds`);
-    assert.ok(c.count > 900,
-      `p=${density}: ${c.count} components — a force layout has nothing to arrange below this`);
-  }
-});
-
-await test('FINDING 1b: a task node can never carry a label at this scale', () => {
-  // 1,357 nodes on a 1280×720 canvas is 26.1px of pitch against the 48px a six-character
-  // label needs. Nothing about the layout changes this; it is division.
-  const ink = spike.inkBudget(1357);
-  assert.ok(ink.fits_as_dot, 'dots do fit — the map is drawable, just not readable');
-  assert.equal(ink.fits_with_label, false);
-  assert.ok(ink.pitch_px < 30, `pitch was ${ink.pitch_px}px`);
-  // …and the goal graph clears it three times over, which is the recommendation.
-  const goals = spike.inkBudget(40);
-  assert.ok(goals.fits_with_label);
-  assert.ok(goals.pitch_px > 3 * ink.pitch_px);
-});
-
-await test('FINDING 2: the dense attempt overplots into roughly the goal graph', () => {
-  // D spends 22,341 edges to draw, illegibly, the picture C draws with ~50. The claim is
-  // about OVERPLOTTING, so it needs the real layout — but only the order of the result
-  // is asserted, not the exact mark count.
-  const v = spike.viewsOf(spike.buildSynthetic({ ...CORPUS, density: 0.1 }));
-  const laid = spike.layout(v.D.nodes, v.D.edges, { iters: 120 });
-  const cells = new Set(laid.pos.map((p) => `${Math.round(p[0] / 7)},${Math.round(p[1] / 7)}`));
-  assert.ok(cells.size < v.D.nodes.length / 3,
-    `D resolved to ${cells.size} marks for ${v.D.nodes.length} nodes — the overplot finding no longer holds`);
-});
-
-await test('the layout is Barnes-Hut, and it converges rather than smearing', () => {
-  // An earlier cut used a neighbour-grid, whose short-range-only repulsion drew a
-  // cross-shaped artifact at 1,357 mostly-disconnected nodes — a property of the
-  // approximation, not the data. Measuring readability on that would have proved
-  // nothing, convincingly. The guard: a disconnected corpus must spread across the
-  // frame in BOTH axes rather than collapsing onto one.
-  const v = spike.viewsOf(spike.buildSynthetic({ ...CORPUS, density: 0.05 }));
-  const laid = spike.layout(v.A.nodes, v.A.edges, { iters: 120 });
-  const xs = laid.pos.map((p) => p[0]);
-  const ys = laid.pos.map((p) => p[1]);
-  const spanX = Math.max(...xs) - Math.min(...xs);
-  const spanY = Math.max(...ys) - Math.min(...ys);
-  assert.ok(spanX > 600 && spanY > 400, `layout collapsed to ${spanX.toFixed(0)}×${spanY.toFixed(0)}`);
-  // and no node is stacked on the frame edge, the signature of a per-iteration clamp
-  const onEdge = laid.pos.filter((p) => p[0] < 7 || p[1] < 7).length;
-  assert.ok(onEdge < 40, `${onEdge} nodes pinned to the frame — the clamp artifact is back`);
-});
-
-await test('components() counts weakly, and singletons are counted', () => {
-  const nodes = [1, 2, 3, 4, 5];
-  const edges = [[1, 2], [2, 3]];
-  const c = spike.components(nodes, edges);
-  assert.equal(c.count, 3, 'one chain of three plus two loners');
-  assert.equal(c.largest, 3);
-  assert.equal(c.singletons, 2);
-});
-
-// ---------------------------------------------------------------------------
-// The rasteriser. These figures are cited as EVIDENCE in ADR 0227, so a stride,
-// CRC or alpha-blend bug would corrupt the evidence SILENTLY rather than fail —
-// the one failure mode a spike cannot afford, because the picture is the claim.
-// ---------------------------------------------------------------------------
-
-await test('crc32 matches the canonical CRC-32 vectors (and zlib, where available)', () => {
-  // The PNG spec's CRC is standard CRC-32/ISO-HDLC. "123456789" -> 0xCBF43926 is
-  // the check value published with the algorithm; an empty input is 0.
-  assert.equal(spike.crc32(Buffer.from('123456789', 'ascii')), 0xcbf43926);
-  assert.equal(spike.crc32(Buffer.alloc(0)), 0);
-  assert.equal(spike.crc32(Buffer.from('The quick brown fox jumps over the lazy dog', 'ascii')), 0x414fa339);
-  // Cross-check against the platform implementation rather than only fixed
-  // vectors, so a table-generation bug cannot hide behind three lucky inputs.
-  if (typeof zlib.crc32 === 'function') {
-    for (const s of ['', 'a', 'IHDR', 'x'.repeat(1000), '\x00\xff\x80']) {
-      const b = Buffer.from(s, 'binary');
-      assert.equal(spike.crc32(b), zlib.crc32(b), `crc32 disagrees with zlib on ${JSON.stringify(s.slice(0, 12))}`);
-    }
-  }
-});
-
-await test('chunk() frames a PNG chunk: big-endian length, ascii type, CRC over type+data', () => {
-  const data = Buffer.from([1, 2, 3, 4, 5]);
-  const c = spike.chunk('IDAT', data);
-  assert.equal(c.length, 4 + 4 + data.length + 4, 'length + type + data + crc');
-  assert.equal(c.readUInt32BE(0), data.length, 'length counts DATA only, not the type');
-  assert.equal(c.subarray(4, 8).toString('ascii'), 'IDAT');
-  assert.deepEqual(c.subarray(8, 8 + data.length), data);
-  // The CRC covers type+data — excluding the length field is the classic slip.
-  assert.equal(c.readUInt32BE(8 + data.length), spike.crc32(Buffer.concat([Buffer.from('IDAT', 'ascii'), data])));
-  // A zero-length chunk (IEND) still carries a valid CRC over the bare type.
-  const iend = spike.chunk('IEND', Buffer.alloc(0));
-  assert.equal(iend.readUInt32BE(0), 0);
-  assert.equal(iend.readUInt32BE(8), spike.crc32(Buffer.from('IEND', 'ascii')));
-});
-
-await test('canvas() px() is stride-correct, clips out of bounds, and blends alpha', () => {
-  const w = 5; const h = 3;
-  const cv = spike.canvas(w, h, [255, 255, 255, 255]);
-  // Stride: a pixel at (x,y) must land at (y*w + x)*4. An off-by-w bug here would
-  // shear every figure diagonally and still look plausible.
-  cv.px(3, 1, [255, 0, 0, 255]);
-  const o = (1 * w + 3) * 4;
-  assert.deepEqual([...cv.buf.subarray(o, o + 4)], [255, 0, 0, 255], 'red pixel is not at the stride-computed offset');
-  // its neighbours are untouched background
-  assert.deepEqual([...cv.buf.subarray(o - 4, o)], [255, 255, 255, 255]);
-  assert.deepEqual([...cv.buf.subarray(o + 4, o + 8)], [255, 255, 255, 255]);
-  // Clipping: every out-of-range write is a no-op, not a wrap onto the next row.
-  const before = Buffer.from(cv.buf);
-  cv.px(-1, 0, [0, 0, 0, 255]);
-  cv.px(w, 0, [0, 0, 0, 255]);
-  cv.px(0, -1, [0, 0, 0, 255]);
-  cv.px(0, h, [0, 0, 0, 255]);
-  cv.px(999, 999, [0, 0, 0, 255]);
-  assert.deepEqual(cv.buf, before, 'an out-of-bounds write mutated the buffer');
-  // Alpha blend: 50% black over white lands mid-grey, and the result stays opaque.
-  const cv2 = spike.canvas(1, 1, [255, 255, 255, 255]);
-  cv2.px(0, 0, [0, 0, 0, 128]);
-  const v = cv2.buf[0];
-  assert.ok(v >= 126 && v <= 129, `50% black over white gave ${v}, expected ~127`);
-  assert.equal(cv2.buf[3], 255, 'the canvas must stay opaque — a transparent PNG is not evidence');
-});
-
-await test('canvas() disc() stays inside its radius and line() reaches both endpoints', () => {
-  const cv = spike.canvas(21, 21, [0, 0, 0, 0]);
-  cv.disc(10, 10, 4, [255, 255, 255, 255]);
-  let painted = 0; let worst = 0;
-  for (let y = 0; y < 21; y++) {
-    for (let x = 0; x < 21; x++) {
-      if (cv.buf[(y * 21 + x) * 4 + 3] === 255) {
-        painted++;
-        worst = Math.max(worst, Math.hypot(x - 10, y - 10));
-      }
-    }
-  }
-  assert.ok(worst <= 4.001, `disc bled to radius ${worst.toFixed(2)}, asked for 4`);
-  // area is ~pi*r^2 on a square lattice; generous bounds, tight enough to catch r/2 or 2r
-  assert.ok(painted > 40 && painted < 60, `disc painted ${painted}px, expected ~49`);
-
-  const ln = spike.canvas(10, 10, [0, 0, 0, 0]);
-  ln.line(1, 1, 8, 6, [9, 9, 9, 255]);
-  assert.equal(ln.buf[(1 * 10 + 1) * 4 + 3], 255, 'line missed its start point');
-  assert.equal(ln.buf[(6 * 10 + 8) * 4 + 3], 255, 'line missed its end point');
-  // a zero-length line is one pixel, not a divide-by-zero hole
-  const dot = spike.canvas(3, 3, [0, 0, 0, 0]);
-  dot.line(1, 1, 1, 1, [9, 9, 9, 255]);
-  assert.equal(dot.buf[(1 * 3 + 1) * 4 + 3], 255, 'a zero-length line drew nothing');
-});
-
-await test('goalColor() is deterministic, in gamut, and honours its alpha', () => {
-  assert.deepEqual(spike.goalColor(7), spike.goalColor(7), 'same goal, different colour');
-  assert.notDeepEqual(spike.goalColor(7), spike.goalColor(8), 'adjacent goals share a hue');
-  assert.equal(spike.goalColor(3, 128)[3], 128, 'alpha argument ignored');
-  for (let g = 0; g < 40; g++) {
-    for (const ch of spike.goalColor(g)) {
-      assert.ok(Number.isInteger(ch) && ch >= 0 && ch <= 255, `goal ${g} produced an out-of-gamut channel ${ch}`);
-    }
-  }
-});
-
-await test('writePng() emits a real PNG whose pixels survive the round trip', () => {
-  // No layout is run here: a hand-built `laid` keeps this a test of the ENCODER,
-  // not a second copy of the physics test above.
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'spike-png-'));
-  const file = path.join(dir, 'probe.png');
-  try {
-    const w = 6; const h = 4;
-    const cv = spike.canvas(w, h, [252, 252, 251, 255]);
-    cv.px(4, 2, [255, 0, 0, 255]);
-    const bytes = spike.writePng(file, w, h, cv.buf);
-    const png = fs.readFileSync(file);
-    assert.equal(png.length, bytes, 'writePng lied about how much it wrote');
-    assert.deepEqual([...png.subarray(0, 8)], [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a], 'not a PNG signature');
-
-    // Walk the chunk list, verifying every CRC — the check that makes the file
-    // openable by anything other than the encoder that produced it.
-    const seen = [];
-    let off = 8; let idat = null;
-    while (off < png.length) {
-      const len = png.readUInt32BE(off);
-      const type = png.subarray(off + 4, off + 8).toString('ascii');
-      const data = png.subarray(off + 8, off + 8 + len);
-      const crc = png.readUInt32BE(off + 8 + len);
-      assert.equal(crc, spike.crc32(png.subarray(off + 4, off + 8 + len)), `bad CRC on ${type}`);
-      if (type === 'IDAT') idat = data;
-      seen.push(type);
-      off += 12 + len;
-    }
-    assert.deepEqual(seen, ['IHDR', 'IDAT', 'IEND'], `unexpected chunk list: ${seen.join(',')}`);
-    assert.equal(off, png.length, 'trailing bytes after IEND');
-
-    const ihdr = png.subarray(16, 16 + 13);
-    assert.equal(ihdr.readUInt32BE(0), w);
-    assert.equal(ihdr.readUInt32BE(4), h);
-    assert.equal(ihdr[8], 8, 'bit depth must be 8');
-    assert.equal(ihdr[9], 6, 'colour type must be 6 (RGBA)');
-
-    // The round trip is the stride guard: inflate, check every scanline carries a
-    // 0 filter byte, and find the red pixel at the offset the stride predicts.
-    const raw = zlib.inflateSync(idat);
-    const stride = w * 4;
-    assert.equal(raw.length, (stride + 1) * h, 'raw size disagrees with width*4+1 per row');
-    for (let y = 0; y < h; y++) {
-      assert.equal(raw[y * (stride + 1)], 0, `scanline ${y} is missing its filter byte`);
-    }
-    const at = 2 * (stride + 1) + 1 + 4 * 4;
-    assert.deepEqual([...raw.subarray(at, at + 4)], [255, 0, 0, 255], 'the red pixel is not where the stride says it is');
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-await test('render() draws a view end to end and writes an openable file', () => {
-  // Again no physics: positions are supplied, so this covers render -> canvas ->
-  // goalColor -> writePng and nothing else.
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'spike-render-'));
-  const file = path.join(dir, 'view.png');
-  try {
-    const view = { nodes: [1, 2, 3], edges: [[1, 2], [2, 3], [3, 99]], groups: [0, 1, 2] };
-    const laid = { idx: new Map([[1, 0], [2, 1], [3, 2]]), pos: [[100, 100], [400, 300], [700, 200]] };
-    const bytes = spike.render(file, view, laid, { radius: 3 });
-    assert.ok(bytes > 0, 'render wrote nothing');
-    const png = fs.readFileSync(file);
-    assert.deepEqual([...png.subarray(0, 8)], [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-    assert.equal(png.readUInt32BE(8 + 4 + 4 + 0) > 0, true, 'IHDR width is zero');
-    // The [3, 99] edge names a node absent from idx: it must be skipped, not crash
-    // and not throw the whole figure away.
-    assert.ok(png.length > 100, 'a dangling edge appears to have aborted the render');
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// the LIVE-corpus path (task 1003477) — ADR 0227 items 3 and 4 are decided by
-// numbers this loader produces, so the loader is pinned harder than the prose.
-// ---------------------------------------------------------------------------
-
-// The dump shape the live API actually answers with: GET /tasks?include=deps returns
-// `blocked_by`, an array of objects — NOT `dependencies`, and not bare ids.
-const REAL_DUMP = {
-  tasks: [
-    { id: 1, goal_id: '100', blocked_by: [] },
-    { id: 2, goal_id: '100', blocked_by: [{ id: 1, status: 'shipped' }] },
-    { id: 3, goal_id: '100', blocked_by: [{ id: 2, status: 'ready' }] },
-    { id: 4, goal_id: '200', blocked_by: [{ id: 3, status: 'ready' }] },   // crosses a goal
-    { id: 5, goal_id: '200', blocked_by: [] },
-    { id: 6, goal_id: null, blocked_by: [] },                              // no goal
-    { id: 7, goal_id: null, blocked_by: [] },                              // no goal
-  ],
-};
-
-function withDump(obj, fn) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'spike-dump-'));
-  const file = path.join(dir, 'corpus.json');
-  try {
-    fs.writeFileSync(file, JSON.stringify(obj));
-    return fn(file);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-}
-
-await test('depIdsOf reads the field the live API actually sends (blocked_by)', () => {
-  // THE REGRESSION THIS EXISTS FOR: the loader only looked for `dependencies`/`deps`,
-  // so a real dump parsed as a corpus with zero edges and every --from number described
-  // an empty graph while looking entirely plausible.
-  assert.deepEqual(spike.depIdsOf({ blocked_by: [{ id: 1 }, { id: 2 }] }), [1, 2]);
-  assert.deepEqual(spike.depIdsOf({ dependencies: [3, 4] }), [3, 4], 'the older spelling still has to work');
-  assert.deepEqual(spike.depIdsOf({ deps: [5] }), [5]);
-  assert.deepEqual(spike.depIdsOf({}), [], 'a task with no dependencies is not an error');
-  assert.deepEqual(spike.depIdsOf({ blocked_by: null }), [], 'a null must not throw');
-  assert.deepEqual(spike.depIdsOf({ blocked_by: [{ title: 'no id' }, { id: 9 }] }), [9],
-    'an unparseable entry is dropped, it does not become NaN');
-  assert.deepEqual(spike.depIdsOf({ blocked_by: [], dependencies: [7] }), [7],
-    'an empty blocked_by must not shadow a populated dependencies — that is the silent zero again');
-});
-
-await test('loadReal turns a real include=deps dump into a graph with edges in it', () => {
-  const tasks = withDump(REAL_DUMP, (f) => spike.loadReal(f));
-  assert.equal(tasks.length, 7);
-  const edges = tasks.reduce((n, t) => n + t.deps.length, 0);
-  assert.equal(edges, 3, 'the real dump shape must not parse as an edgeless corpus');
-  assert.deepEqual(tasks.find((t) => t.id === 4).deps, [3]);
-});
-
-await test('two tasks with no goal do not share a goal — pooling them would hide cross-goal edges', () => {
-  // '__none__' as a single bucket would make every dependency between two ungoaled
-  // tasks read as WITHIN-goal, understating the one number this loader exists for.
-  const tasks = withDump(REAL_DUMP, (f) => spike.loadReal(f));
-  const [a, b] = tasks.filter((t) => t.goalId === null);
-  assert.notEqual(a.goal, b.goal, 'ungoaled tasks were pooled into one goal');
-  const inGoal100 = tasks.filter((t) => t.goalId === '100').map((t) => t.goal);
-  assert.equal(new Set(inGoal100).size, 1, 'tasks sharing a real goal must share a bucket');
-});
-
-await test('census answers the two questions ADR 0227 items 3 and 4 wait on', () => {
-  const c = spike.census(withDump(REAL_DUMP, (f) => spike.loadReal(f)));
-  // Q1 — tasks 2, 3 and 4 each declare one row; 1, 5, 6, 7 declare none.
-  assert.equal(c.with_dependency, 3);
-  assert.equal(c.with_dependency_pct, Number(((3 / 7) * 100).toFixed(2)));
-  // Q2 — of the three edges, only 4->3 crosses a goal boundary.
-  assert.equal(c.edges, 3);
-  assert.equal(c.cross_goal, 1);
-  assert.equal(c.cross_goal_pct, Number(((1 / 3) * 100).toFixed(2)));
-  assert.equal(c.goals, 2, 'the two ungoaled tasks are not goals');
-  assert.equal(c.ungoaled_tasks, 2);
-  assert.equal(c.goal_pairs, 1);
-  assert.equal(c.goals_isolated, 0, 'both real goals carry the one cross-goal edge');
-});
-
-await test('census counts an edge touching an ungoaled task as neither within nor across', () => {
-  // Calling it "within-goal" would invent a shared goal; calling it "cross-goal" would
-  // invent two. It is reported on its own line so the number is never silently absorbed.
-  const dump = { tasks: [
-    { id: 1, goal_id: null, blocked_by: [] },
-    { id: 2, goal_id: '100', blocked_by: [{ id: 1 }] },
-  ] };
-  const c = spike.census(withDump(dump, (f) => spike.loadReal(f)));
-  assert.equal(c.edges, 1);
-  assert.equal(c.cross_goal, 0);
-  assert.equal(c.edges_touching_ungoaled, 1);
-});
-
-await test('census only counts edges whose other end is in the corpus', () => {
-  // A paged dump can name a dependency that fell outside the page. Counting it would
-  // report an edge the drawn graph does not contain.
-  const dump = { tasks: [{ id: 1, goal_id: '100', blocked_by: [{ id: 999 }] }] };
-  const c = spike.census(withDump(dump, (f) => spike.loadReal(f)));
-  assert.equal(c.edges, 0, 'a dangling dependency became a phantom edge');
-  assert.equal(c.with_dependency, 1, 'the task still DECLARES a row — that is Q1, and it is a different question');
-});
-
-await test('census measures the per-goal drill-down, which is the shape item 4 is scoped as', () => {
-  // Goal '100' holds the chain 1<-2<-3, so its drill-down is three tasks. Goal '200'
-  // has no edge with both ends inside it, so it has no drill-down at all.
-  const c = spike.census(withDump(REAL_DUMP, (f) => spike.loadReal(f)));
-  assert.equal(c.per_goal_forests, 1);
-  assert.equal(c.per_goal_largest, 3);
-  assert.equal(c.per_goal_largest_labels, true, 'three nodes on a 1280x720 canvas obviously label');
-});
-
-await test('componentSizes returns sizes largest-first, and components agrees with it', () => {
-  // census() takes its median from this ordering, so a change of order is a change of
-  // verdict. Two islands (1-2-3 and 4-5) plus a loner.
-  const nodes = [1, 2, 3, 4, 5, 6];
-  const edges = [[1, 2], [2, 3], [4, 5]];
-  assert.deepEqual(spike.componentSizes(nodes, edges), [3, 2, 1]);
-  const c = spike.components(nodes, edges);
-  assert.equal(c.count, 3);
-  assert.equal(c.largest, 3);
-  assert.equal(c.singletons, 1);
-});
-
-
-summary();

package/tests/status-probe.mjs

@@ -1,89 +0,0 @@
-// tests/status-probe.mjs
-//
-// Task #565 — external uptime prober. The HTTP probing + git push are exercised
-// live in CI (.github/workflows/status-probe.yml); this file covers the pure
-// logic that decides what the off-box history records and what The Watch will
-// read: argument parsing, the uptime-percentage computation (window filtering +
-// rounding + empty-window), and JSONL history parsing (blank/corrupt-line
-// tolerance + missing-file → []).
-//
-// Run:  node tests/status-probe.mjs
-
-import { strict as assert } from 'node:assert';
-import { writeFile, mkdtemp, rm } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-
-import { uptimePct, readHistory, parseArgs } from '../scripts/status-probe.mjs';
-
-let passed = 0;
-const ok = (name) => { passed++; console.log('  ✓', name); };
-
-// --- parseArgs: defaults, overrides, numeric coercion ---
-{
-  const a = parseArgs([]);
-  assert.equal(a.target, 'https://example.com/healthz');
-  assert.equal(a.attempts, 3);
-  assert.equal(a['timeout-ms'], 15000);
-  ok('parseArgs returns defaults');
-
-  const b = parseArgs(['--target', 'https://x/h', '--attempts', '5', '--timeout-ms', '2000']);
-  assert.equal(b.target, 'https://x/h');
-  assert.equal(b.attempts, 5);                 // coerced to Number
-  assert.equal(b['timeout-ms'], 2000);
-  assert.equal(typeof b.attempts, 'number');
-  ok('parseArgs applies overrides and coerces numerics');
-}
-
-// --- uptimePct: window filtering + rounding + empty window ---
-{
-  const now = 1_000_000_000_000;
-  const rows = [
-    { t: new Date(now - 1000).toISOString(), status: 'up' },
-    { t: new Date(now - 2000).toISOString(), status: 'down' },
-    { t: new Date(now - 3000).toISOString(), status: 'up' },
-    { t: new Date(now - 4000).toISOString(), status: 'up' },
-  ];
-  assert.equal(uptimePct(rows, now - 5000), 75);   // 3 up / 4 total
-  assert.equal(uptimePct(rows, now - 2500), 50);   // window = {up, down}
-  assert.equal(uptimePct(rows, now + 1000), null); // nothing in window
-  assert.equal(uptimePct([], now - 5000), null);   // no data
-  ok('uptimePct filters to window, rounds, and returns null when empty');
-
-  // rounding to 2 d.p.: 2 up / 3 total = 66.67
-  const three = [
-    { t: new Date(now - 1000).toISOString(), status: 'up' },
-    { t: new Date(now - 2000).toISOString(), status: 'up' },
-    { t: new Date(now - 3000).toISOString(), status: 'down' },
-  ];
-  assert.equal(uptimePct(three, now - 5000), 66.67);
-  ok('uptimePct rounds to two decimal places');
-}
-
-// --- readHistory: JSONL parse, blank/corrupt tolerance, missing file ---
-{
-  const dir = await mkdtemp(path.join(os.tmpdir(), 'status-probe-test-'));
-  try {
-    const f = path.join(dir, 'history.jsonl');
-    await writeFile(
-      f,
-      JSON.stringify({ t: '2026-01-01T00:00:00Z', status: 'up' }) + '\n' +
-      '\n' +                                   // blank line — skipped
-      'this is not json\n' +                   // corrupt line — skipped, not fatal
-      JSON.stringify({ t: '2026-01-02T00:00:00Z', status: 'down' }) + '\n'
-    );
-    const rows = await readHistory(f);
-    assert.equal(rows.length, 2);
-    assert.equal(rows[0].status, 'up');
-    assert.equal(rows[1].status, 'down');
-    ok('readHistory parses JSONL and skips blank/corrupt lines');
-
-    const none = await readHistory(path.join(dir, 'does-not-exist.jsonl'));
-    assert.deepEqual(none, []);
-    ok('readHistory returns [] for a missing file');
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-}
-
-console.log(`\nstatus-probe: ${passed} checks passed`);