@bongos/core 1.20.77 → 1.20.78

package/tests/profile_activity.mjs

@@ -468,27 +468,35 @@ await test('the other three outcomes each say what happened', async () => {
   assert.ok(/Still open/.test(html), 'AN OPEN IDEA READS AS OPEN — not as nothing');
 });
 
-await test('switching craft re-asks the SERVER — it does not filter a page in the browser', async () => {
-  const p = bootProfile();
+// Task 1004435 (WA6.RP05): one tab per role the person has, each its craft's
+// own record. The engineer tab is the works and goals, WHOLE (no craft filter:
+// most of the corpus is unclassified); the ideator tab is the trail; the artist
+// tab is the approved pages. No tab is "tasks carrying that label" any more.
+await test('each role tab asks the server for that craft\'s OWN record', async () => {
+  const p = bootProfile({ roles: ['ideator', 'engineer', 'artist'] });
   await settle(); await settle(); await settle();
-  const before = p.requests.length;
+  assert.ok(p.requests.some((u) => u.includes('/inbox/by-builder/')), 'the first tab (the ideator) reads the trail');
+  assert.ok(!p.requests.some((u) => u.includes('section=goals')), 'and no goals ledger until the engineer tab opens');
+  let before = p.requests.length;
+  p.switchCraft('engineer');
+  await settle(); await settle();
+  let after = p.requests.slice(before);
+  assert.ok(after.some((u) => u.includes('section=tasks') && !u.includes('role=')), 'the engineer tab reads the whole works ledger');
+  assert.ok(after.some((u) => u.includes('section=goals') && !u.includes('role=')), 'and the whole goals ledger');
+  before = p.requests.length;
   p.switchCraft('artist');
   await settle(); await settle();
-  const after = p.requests.slice(before);
-  assert.ok(after.some((u) => u.includes('section=tasks') && u.includes('role=artist')), 'tasks are re-fetched for the craft');
-  assert.ok(after.some((u) => u.includes('section=goals') && u.includes('role=artist')), 'goals are re-fetched for the craft');
+  after = p.requests.slice(before);
+  assert.ok(after.some((u) => /\/copy-desk\/artists\/95\/pages\?limit=\d+&offset=0/.test(u)), 'the artist tab reads their approved pages, a few at a time');
+  assert.ok(!after.some((u) => u.includes('role=artist')), 'never "tasks labelled artist"');
 });
 
-await test('the idea trail belongs to the ideator view, not to every craft', async () => {
-  const p = bootProfile();
+await test('a role the person does not have gets no tab and no read', async () => {
+  const p = bootProfile({ roles: ['engineer'] });
   await settle(); await settle(); await settle();
-  assert.equal(p.el('activity-ideas-panel').hidden, false, 'the default "all" view is the whole record, trail included');
-  p.switchCraft('engineer');
-  await settle();
-  assert.equal(p.el('activity-ideas-panel').hidden, true, 'an engineer view is engineer work');
-  p.switchCraft('ideator');
-  await settle();
-  assert.equal(p.el('activity-ideas-panel').hidden, false, 'filing an idea IS ideator work');
+  assert.ok(p.requests.some((u) => u.includes('section=tasks')), 'the only tab is the engineer\'s');
+  assert.ok(!p.requests.some((u) => u.includes('/inbox/by-builder/')), 'no trail read for a person with no ideator role');
+  assert.ok(!p.requests.some((u) => u.includes('/copy-desk/artists/')), 'no pages read for a person with no artist role');
 });
 
 await test('the ledgers page server-side — the request carries a window, not the whole record', async () => {

package/tests/profile_role_headline.mjs

@@ -64,11 +64,11 @@ await test('an artist who never shipped a task leads with pages approved and the
 
 await test('an ideator leads with thoughts, size and what is still alive', () => {
   const v = headline(IDEATOR, OPTS);
-  assert.deepEqual(words(v.tally), ['186 credits', '31 thoughts filed', '7 ignited']);
-  assert.deepEqual(words(v.tiles), ['31 thoughts filed', '7 ignited', '3 Full Ideas', '186~ total size', '72% still alive', '3 karma']);
+  assert.deepEqual(words(v.tally), ['186 credits', '14 thoughts filed', '7 ignited']);
+  assert.deepEqual(words(v.tiles), ['14 thoughts filed', '7 ignited', '3 Full Ideas', '186~ total size', '72% still alive', '3 karma']);
   assert.equal(v.tiles[2].f, '1 ratified by the board');
   assert.match(v.tiles[3].title, /Includes 24 credits of historical estimate/, 'the ~ says what it means');
-  assert.equal(v.sub, 'Builder 9 — Contributor · 31 thoughts filed');
+  assert.equal(v.sub, 'Builder 9 — Contributor · 14 thoughts filed');
 });
 
 await test('several crafts each show, main first, in the server\'s order', () => {
@@ -164,7 +164,7 @@ await test('the real page draws the artist\'s tally, chips, tiles and surface ro
 
 await test('the real page draws the ideator\'s and the engineer\'s own headlines', async () => {
   const i = await boot(IDEATOR);
-  assert.match(text(i.head), /186 credits 31 thoughts filed 7 ignited/);
+  assert.match(text(i.head), /186 credits 14 thoughts filed 7 ignited/);
   assert.match(text(i.nums), /186~ total size/);
   assert.match(text(i.nums), /72% still alive/);
   assert.ok(!i.nums.includes('kit-bars'), 'no surface rows for an ideator');

package/tests/profile_role_tabs.mjs

@@ -0,0 +1,163 @@
+// tests/profile_role_tabs.mjs — the profile's Ideator and Artist tabs show the
+// role's own record (task 1004435 / WA6.RP05, goal 1000095, criterion
+// wa6-roles-read-true-in-public).
+//
+// The done-when: "both tabs match the mock for fixtures, and the old
+// task-labelled lists are gone from those tabs". Run for real, end to end:
+//
+//   1. THE ARTIST'S READ. composeArtistPages over the copy desk's own round
+//      fixture, then the new signed-in route over a stubbed lifecycle port:
+//      only that artist's SHIPPED rounds, newest first, each with its first
+//      changed line; a stranger gets a 401, a bad id a 400.
+//   2. THE IDEATOR'S TRAIL. profile-crafts.js over the harness's ideator fixture
+//      (the mock's fourteen thoughts): one mark per thought, each tied to its
+//      row, the sky's five words, size and brightness as separate channels.
+//   3. THE PAGE. The REAL profile.js in a vm with the artist tab open, fed the
+//      route's own output, so a field the route renames cannot leave this green.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { makeRunner, bootProfilePage, settle } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const ROOT = fileURLToPath(new URL('..', import.meta.url));
+
+const F = require('../modules/copy-desk/tests/fixtures/page-tweak.cjs');
+const pageStatus = require('../modules/copy-desk/page-status.js');
+const { test, summary } = makeRunner();
+
+// ---- 1. the artist's read ---------------------------------------------------
+
+await test('an artist\'s approved pages: only theirs, only shipped, newest first, with the first changed line', () => {
+  const alice = pageStatus.composeArtistPages({ builderId: F.ALICE.id, inventory: F.INVENTORY, tasks: F.TASKS });
+  assert.deepEqual(alice.map((p) => p.task_id), ['201', '101'], 'Sep 20 before Sep 1; Bob\'s round and the abandoned one are not hers');
+  assert.equal(alice[0].page_id, 'builders:studio');
+  assert.equal(alice[0].surface_label, 'Builders hall');
+  assert.equal(alice[0].line_count, 1);
+  assert.deepEqual(alice[0].first, { before: 'Welcome', after: 'Welcome home' });
+  assert.equal(alice[0].approved_at, '2026-09-20T10:00:00.000Z');
+  const bob = pageStatus.composeArtistPages({ builderId: F.BOB.id, inventory: F.INVENTORY, tasks: F.TASKS });
+  assert.deepEqual(bob.map((p) => p.task_id), ['102'], 'his active round is not an approved page');
+  assert.equal(bob[0].line_count, 2);
+  assert.deepEqual(bob[0].first, { before: 'Every projekt', after: 'Every project' }, 'the FIRST changed line');
+});
+
+await test('the route: signed in only, a bad id refused, paged, and it asks for THIS artist\'s rounds', async () => {
+  const api = require('../src/module-api.js');
+  const seams = require('../src/module-seams.js');
+  const pageData = require('../modules/copy-desk/page-data.js');
+  const asked = [];
+  seams._reset();
+  seams.registerProvider('lifecycle', { async listPageTweakTasks(opts) { asked.push(opts); return F.TASKS; } });
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'artist-pages-'));
+  fs.mkdirSync(path.join(tmp, 'docs'), { recursive: true });
+  fs.writeFileSync(path.join(tmp, 'docs', 'page-inventory.json'), JSON.stringify(F.INVENTORY));
+  pageData._setRoot(tmp);
+  let signedIn = true;
+  const realRequire = api.requireBuilder;
+  api.requireBuilder = (req, res, next) => (signedIn ? next() : res.status(401).json({ error: 'unauthorized' }));
+  const express = require('express');
+  const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+  const app = express();
+  app.use(attachFail);
+  app.use(require('../modules/copy-desk/routes/copy-desk-artist.js')());
+  const server = await new Promise((r) => { const s = app.listen(0, '127.0.0.1', () => r(s)); });
+  const get = async (p) => { const r = await fetch(`http://127.0.0.1:${server.address().port}${p}`); return { status: r.status, body: await r.json() }; };
+  try {
+    const all = await get(`/copy-desk/artists/${F.ALICE.id}/pages`);
+    assert.equal(all.status, 200);
+    assert.deepEqual(all.body.rows.map((r) => r.task_id), ['201', '101']);
+    assert.equal(all.body.total, 2);
+    assert.deepEqual(asked.at(-1), { artistId: F.ALICE.id }, 'the read is scoped to the artist, never every round');
+    const page2 = await get(`/copy-desk/artists/${F.ALICE.id}/pages?limit=1&offset=1`);
+    assert.deepEqual(page2.body.rows.map((r) => r.task_id), ['101']);
+    assert.equal(page2.body.total, 2, 'the total is the whole set, not the page');
+    assert.equal((await get('/copy-desk/artists/abc/pages')).status, 400);
+    assert.equal((await get('/copy-desk/artists/0/pages')).status, 400);
+    signedIn = false;
+    assert.equal((await get(`/copy-desk/artists/${F.ALICE.id}/pages`)).status, 401, 'owner decision (a): the pages and their words need a sign-in');
+  } finally {
+    api.requireBuilder = realRequire;
+    pageData._setRoot(null);
+    seams._reset();
+    server.closeAllConnections();
+    await new Promise((r) => server.close(r));
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ---- 2. the ideator's trail -------------------------------------------------
+
+function loadCrafts() {
+  const sandbox = { window: {}, console };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  for (const f of ['idea-objects.js', 'profile-crafts.js']) {
+    vm.runInContext(fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public', f), 'utf8'), sandbox, { filename: f });
+  }
+  return sandbox.window.OTBProfileCrafts;
+}
+const crafts = loadCrafts();
+const TRAIL = JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts/hall-preview/fixtures/inbox__by-builder__2002.json'), 'utf8')).ideas;
+
+await test('the trail draws every thought once, each mark tied to its ledger row', () => {
+  const svg = crafts.trailSvgHtml(TRAIL, { width: 900 });
+  const ids = [...svg.matchAll(/data-i="(\d+)"/g)].map((m) => Number(m[1]));
+  assert.deepEqual(ids.sort((a, b) => a - b), TRAIL.map((_, i) => i), 'one mark per thought, none missing, none doubled');
+  assert.match(svg, /role="img"/);
+  assert.match(svg, /aria-label="14 thoughts filed, by the day each was filed\. Each is also a row in the table below\."/);
+  assert.ok(!/<(?:path|polyline|rect)\b/.test(svg), 'circles and lines only: series geometry is the kit\'s (hall_audit §6b)');
+  assert.equal((svg.match(/class="pt-tether"/g) || []).length, 2, 'each folded-in thought is tethered to the one it joined');
+  for (const cls of ['pt-star', 'pt-remnant', 'pt-cold', 'pt-ring']) assert.ok(svg.includes(cls), `the ${cls} mark is drawn`);
+});
+
+await test('size and brightness are separate channels', () => {
+  const big = crafts.trailSvgHtml([TRAIL[0]], { width: 600 });   // 64 cr, all alive
+  const half = crafts.trailSvgHtml([TRAIL[1]], { width: 600 });  // 42 cr, 60% alive
+  const r = (s) => Number(/class="pt-m pt-star"[^>]*r="([\d.]+)"/.exec(s)[1]);
+  const op = (s) => Number(/fill-opacity="([\d.]+)"/.exec(s)[1]);
+  assert.ok(r(big) > r(half), 'more credits, a wider mark');
+  assert.equal(op(big), 1);
+  assert.equal(op(half), 0.72, 'less of its work alive, a dimmer mark (0.3 + 0.7 x 0.6)');
+  const remnant = crafts.trailSvgHtml([TRAIL[4]], { width: 600 });
+  assert.match(remnant, /pt-remnant[^>]*r="(?!3\.2")/, 'a burned-out thought keeps its size');
+});
+
+await test('every row says its state in the sky\'s words, its size and what is still alive', () => {
+  const href = (id) => `/idea/${id}`;
+  const outcome = () => 'OUTCOME';
+  const row = (i) => crafts.thoughtRowHtml(TRAIL[i], i, { outcomeHtml: outcome, ideaHref: href });
+  assert.match(row(0), /burning<\/span>/);
+  assert.match(row(0), />64 cr</);
+  assert.match(row(1), />60%</);
+  assert.match(row(2), /waiting<\/span>[\s\S]*no size/);
+  assert.match(row(4), /burned out[\s\S]*22 cr<span class="pt-est" title="12 of it estimated[^"]*"> ~<\/span>[\s\S]*>0%</, 'the ~ marks the historical estimate');
+  assert.match(row(5), /folded in/);
+  assert.match(row(6), /declined/);
+  assert.match(row(0), /<tr id="pt-row-0" data-i="0" tabindex="0">/, 'a row is focusable, so a mark\'s click can land on it');
+  assert.match(row(0), /OUTCOME/, 'the old trail\'s "what became of it" is folded in, not dropped');
+  const legend = crafts.legendHtml();
+  for (const w of ['burning', 'waiting', 'folded in', 'burned out', 'declined']) assert.ok(legend.includes(w), `the legend names "${w}"`);
+});
+
+// ---- 3. the page --------------------------------------------------------------
+
+await test('the real page\'s artist tab draws the route\'s own rows, before and after', async () => {
+  const rows = pageStatus.composeArtistPages({ builderId: F.ALICE.id, inventory: F.INVENTORY, tasks: F.TASKS });
+  const wire = JSON.parse(JSON.stringify(rows));
+  const p = bootProfilePage({ roles: ['artist'], artistPages: wire });
+  await settle(); await settle(); await settle(); await settle();
+  const html = p.el('activity-pages').innerHTML;
+  assert.match(html, /Studio[\s\S]*Builders hall · approved Sep 20[\s\S]*1 line changed/);
+  assert.match(html, /pg-ba__was">Welcome<[\s\S]*pg-ba__now">Welcome home</);
+  assert.match(html, /Projects[\s\S]*Landing · approved Sep 1/);
+  assert.ok(!p.requests.some((u) => u.includes('role=artist')), 'the old "tasks labelled artist" list is gone');
+});
+
+summary();

package/tests/update_channel.mjs

@@ -15,7 +15,7 @@
 
 import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
-import { mkdtempSync, writeFileSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -338,6 +338,85 @@ t('describeStaleness: silent when healthy, explicit about "the upgrader stopped"
   assert.match(msg, /upgrader has most likely stopped/);
 });
 
+// ---- the follow: every candidate, or released only (task 1004297, ADR 0360) -
+
+t('normalizeFollow: released and candidates are the words; anything else reads as the safer released', () => {
+  assert.equal(uc.DEFAULT_FOLLOW, 'released');
+  assert.deepEqual(uc.VALID_FOLLOWS, ['released', 'candidates']);
+  assert.equal(uc.normalizeFollow('candidates'), 'candidates');
+  assert.equal(uc.normalizeFollow(' Candidates '), 'candidates');
+  for (const v of [undefined, null, '', 'every', 'latest', 'next', 42]) assert.equal(uc.normalizeFollow(v), 'released', String(v));
+});
+
+t('versionsForFollow: candidates takes every version; released stops at the released label', () => {
+  const available = ['1.19.1038', '1.19.1039', '1.19.1040', '1.19.1041'];
+  assert.deepEqual(uc.versionsForFollow({ follow: 'candidates', available, released: '1.19.1039' }), available);
+  assert.deepEqual(uc.versionsForFollow({ follow: 'released', available, released: '1.19.1039' }), ['1.19.1038', '1.19.1039']);
+  assert.deepEqual(uc.versionsForFollow({ available, released: '1.19.1039' }), ['1.19.1038', '1.19.1039'], 'no follow given reads as released');
+});
+
+t('versionsForFollow: a follower of releases takes NOTHING when nobody can say what is released', () => {
+  const available = ['1.19.1040', '1.19.1041'];
+  for (const released of [null, undefined, '', 'not-a-version']) {
+    assert.deepEqual(uc.versionsForFollow({ follow: 'released', available, released }), [], String(released));
+  }
+  assert.deepEqual(uc.versionsForFollow({ follow: 'candidates', available, released: null }), available, 'candidates never needs the label');
+});
+
+t('the follow composes with the channel: released caps which versions exist, the channel caps the jump', () => {
+  const available = ['1.19.1040', '1.19.1041', '1.20.0'];
+  const pick = (follow, released) => uc.resolveChannelTarget({
+    installed: '1.19.1039', channel: 'patch', available: uc.versionsForFollow({ follow, available, released }),
+  });
+  assert.equal(pick('candidates', '1.19.1040'), '1.19.1041', 'Bongos takes the newest candidate its channel allows');
+  assert.equal(pick('released', '1.19.1040'), '1.19.1040', 'every other project stops at the release');
+  assert.equal(pick('released', '1.20.0'), '1.19.1041', 'and the patch channel still refuses the new line');
+  assert.equal(pick('released', null), null, 'an unreadable label moves nobody');
+});
+
+t('readReleaseTags: the released version is the latest label, read fail-soft', () => {
+  const seen = [];
+  const run = (cmd, args, o) => { seen.push([cmd, args, o.timeout]); return { status: 0, stdout: '{"latest":"1.19.1040","next":"1.19.1042"}' }; };
+  assert.deepEqual(uc.readReleaseTags({ run }), { ok: true, released: '1.19.1040', tags: { latest: '1.19.1040', next: '1.19.1042' } });
+  assert.deepEqual(seen[0].slice(0, 2), ['npm', ['view', '@bongos/core', 'dist-tags', '--json']]);
+  assert.ok(seen[0][2] > 0, 'the read carries a timeout');
+
+  const noLatest = uc.readReleaseTags({ run: () => ({ status: 0, stdout: '{"next":"1.19.1042"}' }) });
+  assert.equal(noLatest.ok, false);
+  assert.equal(noLatest.released, null);
+  const pre = uc.readReleaseTags({ run: () => ({ status: 0, stdout: '{"latest":"2.0.0-rc.1"}' }) });
+  assert.equal(pre.ok, false, 'a prerelease is never the release');
+  assert.equal(uc.readReleaseTags({ run: () => ({ status: 1, stderr: 'E404 Not Found' }) }).ok, false);
+  assert.match(uc.readReleaseTags({ run: () => ({ status: 1, stderr: 'E404 Not Found' }) }).error, /E404/);
+  assert.equal(uc.readReleaseTags({ run: () => ({ status: 0, stdout: 'not json' }) }).ok, false);
+  assert.equal(uc.readReleaseTags({ run: () => ({ status: 0, stdout: '["1.0.0"]' }) }).ok, false);
+  assert.equal(uc.readReleaseTags({ run: () => { throw new Error('spawn ENOENT'); } }).ok, false);
+});
+
+t('listAvailableVersions is untouched by the follow: same command, same shape', () => {
+  const seen = [];
+  const r = uc.listAvailableVersions({ run: (c, a) => { seen.push(a); return { status: 0, stdout: '["1.0.0"]' }; } });
+  assert.deepEqual(seen[0], ['view', '@bongos/core', 'versions', '--json']);
+  assert.deepEqual(r, { ok: true, versions: ['1.0.0'] });
+});
+
+t('loadSubscriptions: each entry carries a follow, released unless it says candidates', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'uc-follow-'));
+  mkdirSync(join(dir, 'config'), { recursive: true });
+  writeFileSync(join(dir, 'config', 'update-subscriptions.json'), JSON.stringify({ instances: [
+    { slug: 'cloudbongos', dir: '/srv/cb', follow: 'candidates' },
+    { slug: 'tenant', dir: '/srv/t' },
+    { slug: 'typo', dir: '/srv/x', follow: 'everything' },
+  ] }));
+  const r = uc.loadSubscriptions({ instanceDir: dir });
+  assert.equal(r.defaultFollow, 'released');
+  assert.deepEqual(r.instances.map((i) => [i.slug, i.follow]), [['cloudbongos', 'candidates'], ['tenant', 'released'], ['typo', 'released']]);
+
+  writeFileSync(join(dir, 'config', 'update-subscriptions.json'), JSON.stringify({ defaultFollow: 'candidates', instances: [{ slug: 'a', dir: '/a' }, { slug: 'b', dir: '/b', follow: 'released' }] }));
+  const d = uc.loadSubscriptions({ instanceDir: dir });
+  assert.deepEqual(d.instances.map((i) => i.follow), ['candidates', 'released'], 'a roster-wide default, overridable per entry');
+});
+
 console.log(`\nupdate_channel: ${passed} passed, ${failed} failed`);
 process.exit(failed ? 1 : 0);
 

package/tests/update_subscription_engine.mjs

@@ -766,3 +766,102 @@ test('the post-upgrade net re-probes, rather than reusing the set from before th
   assert.match(beforeSpawn, /const pre = pinState\(inst\.dir, spawnSync, generated\);/,
     'the heal runs before the bump, so it reads the core installed THEN');
 });
+
+// ── the follow (task 1004297, ADR 0360) ─────────────────────────────────────────────
+//
+// followTarget is the sweep's whole decision about WHICH version an instance moves to. It
+// runs the REAL update-channel.js math; only the registry read is stood in for, the way
+// every other case here injects its externals.
+
+const UC = require('../scripts/gds/update-channel.js');
+const PUBLISHED = ['1.19.1039', '1.19.1040', '1.19.1041', '1.20.0'];
+// The real module, with its dist-tags read answering from `tags` (or failing).
+function channelWith(tags) {
+  return {
+    ...UC,
+    readReleaseTags: () => (tags ? UC.readReleaseTags({ run: () => ({ status: 0, stdout: JSON.stringify(tags) }) })
+      : UC.readReleaseTags({ run: () => ({ status: 1, stderr: 'npm ERR! network timeout' }) })),
+  };
+}
+const aim = (inst, channel) => S.followTarget({ inst: entry(inst), installed: '1.19.1039', channel, versions: PUBLISHED, env: {} });
+
+test('follow candidates: the platform takes the newest version its channel allows, whatever is released', () => {
+  assert.deepEqual(aim({ follow: 'candidates' }, channelWith({ latest: '1.19.1039' })), { follow: 'candidates', target: '1.19.1041', held: null });
+});
+
+test('follow released: every other project stops at the released label', () => {
+  assert.deepEqual(aim({ follow: 'released' }, channelWith({ latest: '1.19.1040', next: '1.19.1041' })), { follow: 'released', target: '1.19.1040', held: null });
+  assert.deepEqual(aim({ follow: 'released' }, channelWith({ latest: '1.19.1039' })), { follow: 'released', target: null, held: null }, 'up to date on the release');
+});
+
+test('follow released with an unreadable label is SKIPPED, never upgraded on a guess', () => {
+  const r = aim({ follow: 'released' }, channelWith(null));
+  assert.equal(r.target, undefined);
+  assert.match(r.skip, /could not read which version is released \(npm ERR! network timeout\)/);
+});
+
+test('a core that predates the follow keeps the old reading: every published version', () => {
+  const { readReleaseTags, versionsForFollow, ...oldCore } = UC;
+  assert.equal(aim({}, oldCore).target, '1.19.1041', 'no follow on the entry — the roster came from an older core');
+  assert.equal(aim({ follow: 'released' }, oldCore).target, '1.19.1041', 'no dist-tags reader: before the split every version was a release');
+});
+
+test('the sweep asks followTarget, and says the follow on every line it prints', () => {
+  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'update-sweep.js'), 'utf8');
+  const main = src.slice(src.indexOf('function main('));
+  assert.match(main, /followTarget\(\{ inst, installed, channel, versions: listed\.versions/);
+  assert.doesNotMatch(main, /resolveChannelTarget\(\{ installed, channel: inst\.channel, available: listed\.versions/, 'the unfiltered list never reaches the target');
+  assert.match(main, /follows: \$\{aim\.follow\}/);
+});
+
+// ── a version that failed here is held, not retried every sweep (task 1004297) ──────
+//
+// At a 15-minute cadence an unguarded lane would install a bad version, fail its health
+// check, restart the service and roll back four times an hour until a fix was published.
+
+const NOW = Date.parse('2026-09-26T18:00:00Z');
+const hoursAgo = (h) => new Date(NOW - h * 3600000).toISOString();
+
+test('a held version is skipped and named; a NEWER version is still taken at once', () => {
+  const held = S.heldVersions({ demo: [{ version: '1.19.1041', at: hoursAgo(1), reason: 'exit 1' }] }, 'demo', NOW);
+  const r = S.followTarget({ inst: entry({ follow: 'candidates' }), installed: '1.19.1039', channel: UC, versions: ['1.19.1040', '1.19.1041'], env: {}, held });
+  assert.equal(r.target, '1.19.1040', 'the held version is not retried');
+  assert.deepEqual(r.held, { version: '1.19.1041', at: hoursAgo(1), reason: 'exit 1' });
+
+  const fixed = S.followTarget({ inst: entry({ follow: 'candidates' }), installed: '1.19.1039', channel: UC, versions: ['1.19.1040', '1.19.1041', '1.19.1042'], env: {}, held });
+  assert.equal(fixed.target, '1.19.1042', 'the fix is taken the moment it is published');
+  assert.equal(fixed.held, null, 'and no hold is reported, because none changed the answer');
+});
+
+test('a hold is per instance and expires after a day', () => {
+  const refusals = { demo: [{ version: '1.19.1041', at: hoursAgo(25) }, { version: '1.19.1042', at: hoursAgo(2) }], other: [{ version: '1.19.1043', at: hoursAgo(1) }] };
+  assert.deepEqual([...S.heldVersions(refusals, 'demo', NOW).keys()], ['1.19.1042'], 'a day-old failure is retried');
+  assert.deepEqual([...S.heldVersions(refusals, 'nobody', NOW).keys()], []);
+  assert.equal(S.REFUSAL_HOLD_MS, 24 * 3600000);
+  for (const bad of [null, 'x', { demo: 'x' }, { demo: [null, { version: 7 }, { version: '1.0.0', at: 'not a date' }] }]) {
+    assert.deepEqual([...S.heldVersions(bad, 'demo', NOW).keys()], [], JSON.stringify(bad));
+  }
+});
+
+test('recordRefusal writes outside the instance, keeps only live holds, and never throws', () => {
+  const dir = mkdtempSync(path.join(tmpdir(), 'refusals-'));
+  const file = path.join(dir, 'nested', 'core-update-refused.json');
+  assert.equal(S.recordRefusal({ file, slug: 'demo', version: '1.19.1041', reason: 'exit 1', now: NOW - 30 * 3600000 }), true);
+  assert.equal(S.recordRefusal({ file, slug: 'demo', version: '1.19.1042', reason: 'exit 1', now: NOW }), true);
+  const all = JSON.parse(readFileSync(file, 'utf8'));
+  assert.deepEqual(all.demo.map((r) => r.version), ['1.19.1042'], 'the expired hold was dropped on write');
+  assert.equal(S.recordRefusal({ file, slug: 'demo', version: '1.19.1042', now: NOW + 1000 }), true);
+  assert.equal(JSON.parse(readFileSync(file, 'utf8')).demo.length, 1, 'the same version is one row, re-dated');
+  assert.equal(S.recordRefusal({ file: null, slug: 'demo', version: '1' }), false);
+  assert.equal(S.recordRefusal({ file, slug: 'demo', version: '1', writeFile: () => { throw new Error('EROFS'); } }), false, 'a failed write costs a retry, not the sweep');
+  assert.deepEqual(S.readRefusals(path.join(dir, 'missing.json')), {});
+});
+
+test('the sweep holds a version only when it did not go in', () => {
+  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'update-sweep.js'), 'utf8');
+  const at = src.indexOf('if (res.status !== 0) {');
+  const failBranch = src.slice(at, src.indexOf('failed++; continue;', at));
+  assert.match(failBranch, /if \(readInstalledCoreVersion\(inst\.dir\) !== target\) \{\s*const held = recordRefusal\(/);
+  assert.match(src, /held: heldVersions\(refusals, label, Date\.now\(\)\)/, 'every target is chosen with the holds applied');
+  assert.match(src, /return path\.join\(require\('\.\.\/\.\.\/src\/instance-config\.js'\)\.configHome\(\), REFUSALS_FILE\)/, 'the record lives in the config home, never the instance tree');
+});