@bongos/core 1.19.806 → 1.19.808

package/tests/hall_record_world.mjs

@@ -274,8 +274,15 @@ const MD_SRC = read('md-reader.js');
 // (default) echoes the task back at 200 with goal_id applied from the request
 // body (so a reload's GET reflects the move); { status, data } refuses it with
 // that shape instead, for the refusal-surfacing tests.
-function renderTask(task, { lastClaim = null, viewer = null, goal = null, goalsList = null, patch = null, status = 200, search = '', referrer = '', withReader = true, grade, sessionLogs, claims } = {}) {
+// task 1002858 — `write` refuses the shaping routes the way `patch` refuses the
+// goal move: { status, data }, applied to POST /dependencies, DELETE
+// /dependencies/:id and POST /abandon. `writes` records method + path + body for
+// all of them, because what these tests are actually about is the REQUEST the
+// page issues — `requests` carries paths only and is left alone so the older
+// assertions on it keep meaning what they meant.
+function renderTask(task, { lastClaim = null, viewer = null, goal = null, goalsList = null, patch = null, write = null, status = 200, search = '', referrer = '', withReader = true, grade, sessionLogs, claims } = {}) {
   const requests = [];
+  const writes = [];
   const toasts = [];
   const els = new Map();
   const makeEl = () => ({
@@ -302,6 +309,15 @@ function renderTask(task, { lastClaim = null, viewer = null, goal = null, goalsL
   const client = {
     request: async (method, p, opts) => {
       requests.push(p);
+      if (method !== 'GET') writes.push({ method, path: p, body: (opts && opts.body) || null });
+      // task 1002858 — the shaping routes. Checked before the generic /tasks/\d+
+      // read below, which ignores method and would otherwise swallow them.
+      if (/\/tasks\/\d+\/dependencies/.test(p) || /\/tasks\/\d+\/abandon$/.test(p)) {
+        if (write && write.status && write.status !== 200) {
+          return { status: write.status, ok: false, data: write.data || null };
+        }
+        return { status: 200, ok: true, data: { ok: true } };
+      }
       // PATCH must be checked before the generic /tasks/\d+ read below — both
       // match the same path shape, and the read branch ignores method.
       if (method === 'PATCH' && /\/tasks\/\d+$/.test(p)) {
@@ -356,6 +372,7 @@ function renderTask(task, { lastClaim = null, viewer = null, goal = null, goalsL
     sub: () => documentObj.getElementById('task-sub').textContent,
     el: (id) => documentObj.getElementById(id),
     requests,
+    writes,
     toasts,
   };
 }
@@ -821,6 +838,171 @@ test('a successful move-to-goal PATCH re-renders the goal line against the new g
     'the goal line reflects the new goal after the PATCH triggers a reload');
 });
 
+// ---- 11b. the task-SHAPING verbs (task 1002858) -----------------------------
+//
+// priority, dependency add/remove and abandon all had routes and no hall control,
+// so a goal lead shaping their goal's work dropped to the CLI to retire a
+// duplicate, re-rank a task or fix a dependency chain. Same posture as every
+// other write on this page (ADR 0016): the server owns the gate, this only
+// decides what to draw and prints the refusal it gets back.
+//
+// WHAT THESE TESTS ARE FOR is the REQUEST each control issues — the method, the
+// path and the body — because a control that renders correctly and sends the
+// wrong thing looks identical from the markup. That is the defect class the
+// invite button in task 1002886 carried for months.
+
+test('the shaping controls render for Metic/Archon and not for Xenos/Thetes', async () => {
+  // BASE_TASK is shipped, and a shipped task deliberately loses the retire
+  // control (see the guard test below) — so this one asks about a LIVE task.
+  const OPEN_TASK = { ...BASE_TASK, status: 'ready' };
+  for (const rank of ['metic', 'archon']) {
+    const r = renderTask(OPEN_TASK, { viewer: { rank } });
+    await r.boot(); await settle();
+    assert.match(r.html(), /id="priority-select"/, `${rank} sees the priority control`);
+    assert.match(r.html(), /id="dep-add-input"/, `${rank} sees the add-dependency control`);
+    assert.match(r.html(), /id="abandon-open-btn"/, `${rank} sees the retire control`);
+  }
+  for (const rank of ['xenos', 'thetes']) {
+    const r = renderTask(OPEN_TASK, { viewer: { rank } });
+    await r.boot(); await settle();
+    for (const id of ['priority-select', 'dep-add-input', 'abandon-open-btn']) {
+      assert.doesNotMatch(r.html(), new RegExp(`id="${id}"`), `${rank} must not see ${id}`);
+    }
+  }
+});
+
+test('setting a priority PATCHes the priority field, and unset is sent as null', async () => {
+  const r = renderTask({ ...BASE_TASK, priority: 5 }, { viewer: { rank: 'metic' } });
+  await r.boot(); await settle();
+  r.el('priority-select').value = '2';
+  await r.el('priority-btn')._handlers.click();
+  await settle();
+  const patchCall = r.writes.find((w) => w.method === 'PATCH');
+  assert.ok(patchCall, 'a PATCH was issued');
+  assert.equal(patchCall.body.priority, 2);
+
+  // '' is the UNSET option and must travel as null: "no priority" is a real state
+  // the optimizer sorts last (NULLS LAST), not a synonym for P5. Sending nothing
+  // would 400 as no_supported_fields.
+  const r2 = renderTask({ ...BASE_TASK, priority: 3 }, { viewer: { rank: 'metic' } });
+  await r2.boot(); await settle();
+  r2.el('priority-select').value = '';
+  await r2.el('priority-btn')._handlers.click();
+  await settle();
+  const clear = r2.writes.find((w) => w.method === 'PATCH');
+  assert.ok(clear && Object.prototype.hasOwnProperty.call(clear.body, 'priority'), 'priority is present');
+  assert.equal(clear.body.priority, null, 'and it is null, not "" and not 5');
+});
+
+test('re-setting the priority it already has sends nothing', async () => {
+  const r = renderTask({ ...BASE_TASK, priority: 3 }, { viewer: { rank: 'metic' } });
+  await r.boot(); await settle();
+  r.el('priority-select').value = '3';
+  await r.el('priority-btn')._handlers.click();
+  await settle();
+  assert.equal(r.writes.filter((w) => w.method === 'PATCH').length, 0, 'no write for a no-op');
+  assert.match(r.toasts.join(' '), /already P3/);
+});
+
+test('adding a dependency POSTs the id, and refuses a self-dependency before the network', async () => {
+  const r = renderTask(BASE_TASK, { viewer: { rank: 'metic' } });
+  await r.boot(); await settle();
+  r.el('dep-add-input').value = '4242';
+  await r.el('dep-add-btn')._handlers.click();
+  await settle();
+  const post = r.writes.find((w) => w.method === 'POST' && /\/dependencies$/.test(w.path));
+  assert.ok(post, 'a POST to /dependencies was issued');
+  assert.equal(post.body.depends_on_task_id, 4242);
+
+  const r2 = renderTask(BASE_TASK, { viewer: { rank: 'metic' } });
+  await r2.boot(); await settle();
+  r2.el('dep-add-input').value = String(BASE_TASK.id);
+  await r2.el('dep-add-btn')._handlers.click();
+  await settle();
+  assert.equal(r2.writes.length, 0, 'a self-dependency is caught before the request');
+  assert.match(r2.toasts.join(' '), /cannot wait for itself/i);
+});
+
+test('the × cuts an edge with DELETE, and only ever from "Blocked by"', async () => {
+  // The asymmetry is the point. DELETE /tasks/:id/dependencies/:depId removes the
+  // edge where THIS task waits on another — its own business. The "Blocks" list is
+  // the same edges from the far end: a × there would edit a DIFFERENT task's
+  // dependency set from a page not showing it.
+  const task = {
+    ...BASE_TASK,
+    dependencies: [{ id: 900, title: 'upstream', status: 'ready' }],
+    dependents: [{ id: 901, title: 'downstream', status: 'ready' }],
+  };
+  const r = renderTask(task, { viewer: { rank: 'metic' } });
+  await r.boot(); await settle();
+  const html = r.html();
+  assert.match(html, /data-cut-dep="900"/, 'the blocked-by edge is cuttable');
+  assert.doesNotMatch(html, /data-cut-dep="901"/, 'the blocks edge is NOT cuttable from here');
+
+  const xenos = renderTask(task, { viewer: { rank: 'xenos' } });
+  await xenos.boot(); await settle();
+  assert.doesNotMatch(xenos.html(), /data-cut-dep=/, 'and it is Metic+ only');
+});
+
+test('retire requires a reason, then POSTs it to /abandon', async () => {
+  const r = renderTask({ ...BASE_TASK, status: 'ready' }, { viewer: { rank: 'metic' } });
+  await r.boot(); await settle();
+  await r.el('abandon-open-btn')._handlers.click();
+  await settle();
+  assert.match(r.html(), /id="abandon-reason"/, 'the disclosure opens onto a reason field');
+
+  // A REASON IS REQUIRED though the server accepts an empty one: the value of the
+  // audit_log row is the sentence in it.
+  r.el('abandon-reason').value = '   ';
+  await r.el('abandon-btn')._handlers.click();
+  await settle();
+  assert.equal(r.writes.length, 0, 'a blank reason never reaches the server');
+  assert.match(r.toasts.join(' '), /Say why/i);
+
+  r.el('abandon-reason').value = 'superseded by the consolidated task';
+  await r.el('abandon-btn')._handlers.click();
+  await settle();
+  const post = r.writes.find((w) => /\/abandon$/.test(w.path));
+  assert.ok(post, 'a POST to /abandon was issued');
+  assert.equal(post.method, 'POST');
+  assert.equal(post.body.reason, 'superseded by the consolidated task');
+  assert.match(r.toasts.join(' '), /Promote restores it/i,
+    'and the toast names the way back, so a misclick is visibly recoverable');
+});
+
+test('retire is replaced by a sentence where the server would only refuse it', async () => {
+  // Both of these are 409s the server raises anyway AND are knowable from this
+  // record. Offering a button that cannot work teaches the reader the page guesses.
+  const shipped = renderTask({ ...BASE_TASK, status: 'shipped' }, { viewer: { rank: 'metic' } });
+  await shipped.boot(); await settle();
+  assert.doesNotMatch(shipped.html(), /id="abandon-open-btn"/, 'no retire control on shipped');
+  assert.match(shipped.html(), /immutable history/i, 'it says why instead');
+
+  const held = renderTask({ ...BASE_TASK, status: 'active' }, {
+    viewer: { rank: 'metic' },
+    lastClaim: { github_login: 'someone', claimed_at: '2026-09-01T00:00:00Z', released_at: null },
+  });
+  await held.boot(); await settle();
+  assert.doesNotMatch(held.html(), /id="abandon-open-btn"/, 'no retire control while a claim is live');
+  assert.match(held.html(), /released/i, 'it names the step that unblocks it');
+});
+
+test("a shaping refusal surfaces the server's own sentence, verbatim", async () => {
+  const serverMsg = 'release the active claim before abandoning';
+  const r = renderTask({ ...BASE_TASK, status: 'ready' }, {
+    viewer: { rank: 'metic' },
+    write: { status: 409, data: { error: { code: 'task_has_active_claim', message: serverMsg } } },
+  });
+  await r.boot(); await settle();
+  await r.el('abandon-open-btn')._handlers.click();
+  await settle();
+  r.el('abandon-reason').value = 'no longer relevant';
+  await r.el('abandon-btn')._handlers.click();
+  await settle();
+  assert.ok(r.toasts.some((m) => m.includes(serverMsg)),
+    `the server's sentence is printed as-is — got ${JSON.stringify(r.toasts)}`);
+});
+
 test("a move-to-goal refusal (403) surfaces the server's own sentence, verbatim", async () => {
   const task = { ...BASE_TASK, goal_id: 1000071 };
   const goalsList = [{ id: 1000071, title: 'Old goal', status: 'open' }, { id: 555, title: 'New goal', status: 'open' }];

package/tests/routine_schedule.mjs

@@ -50,13 +50,73 @@ test('cronCadence refuses what its vocabulary cannot describe, rather than guess
   // Unclassifiable must mean "never matches a declared cadence" — the safe
   // direction. A clever cron that silently counted as `weekly` would reopen
   // exactly the drift this check exists to catch.
-  for (const expr of ['*/5 * * * *', '0 6 * * 1-5', '0 6 * * 1,4', '0 0 1 1 *', '17 6 * *', '', 'nonsense']) {
+  for (const expr of ['0 6 * * 1-5', '0 6 * * 1,4', '0 0 1 1 *', '17 6 * *', '', 'nonsense']) {
     assert.equal(rs.cronCadence(expr), null, `${expr} should not classify`);
   }
   // A day-of-month AND day-of-week together is an OR in cron — neither period.
   assert.equal(rs.cronCadence('17 6 3 * 1'), null);
 });
 
+test('cronCadence classifies a uniform sub-hourly step (task 1003674)', () => {
+  // The vocabulary used to stop at `hourly`, so a routine meant to fire every
+  // 15 minutes had no way to declare it: the cron that realizes it read as
+  // unclassifiable and hard-failed, leaving "declare nothing, stay dormant" as
+  // the only green option — the state this check exists to refuse.
+  assert.equal(rs.cronCadence('*/15 * * * *'), '15min');
+  assert.equal(rs.cronCadence('*/5 * * * *'), '5min');
+  assert.equal(rs.cronCadence('*/30 * * * *'), '30min');
+  assert.equal(rs.cronCadence('0/15 * * * *'), '15min', 'the 0/N spelling is the same schedule');
+});
+
+test('cronCadence refuses a step that is not a true period (task 1003674)', () => {
+  // A cron step restarts every hour, so only a divisor of 60 is uniform:
+  // */7 fires at :00…:56 then waits 4. Calling that "7min" would be the same
+  // silent drift between declared and realized period the check is here for.
+  for (const expr of ['*/7 * * * *', '*/8 * * * *', '*/45 * * * *', '*/60 * * * *', '*/0 * * * *']) {
+    assert.equal(rs.cronCadence(expr), null, `${expr} is not a uniform period`);
+  }
+  // A step narrowed to one hour or one weekday is not the sub-hourly period it
+  // resembles — it only fires inside that window.
+  assert.equal(rs.cronCadence('*/15 6 * * *'), null);
+  assert.equal(rs.cronCadence('*/15 * * * 1'), null);
+});
+
+test('isCadence accepts the named periods and the divisor-of-60 Nmin form (task 1003674)', () => {
+  for (const ok of ['hourly', 'daily', 'weekly', 'monthly', '15min', '5min', '30min', '1min']) {
+    assert.equal(rs.isCadence(ok), true, `${ok} should be declarable`);
+  }
+  for (const no of ['7min', '60min', '90min', 'min', '0min', 'fortnightly', '', null, undefined]) {
+    assert.equal(rs.isCadence(no), false, `${no} should not be declarable`);
+  }
+});
+
+test('a routine declaring a sub-hourly cadence matches a step cron that fires it (task 1003674)', () => {
+  // End-to-end through evaluate(): declaring 15min is only green when a
+  // committed scheduler actually fires it at 15 minutes.
+  const wf = (cron) => [{
+    file: 'sweep.yml',
+    text: `on:\n  schedule:\n    - cron: '${cron}'\njobs:\n  go:\n    steps:\n      - run: node scripts/gds/run-routine.js sweepy\n`,
+  }];
+  const declared = routines([{ name: 'sweepy', cadence: '15min', steps: [] }]);
+  assert.deepEqual(rs.evaluate(declared, wf('*/15 * * * *')).violations, []);
+
+  // Wrong period, and the check names both sides rather than shrugging.
+  const drifted = rs.evaluate(declared, wf('17 6 * * *')).violations;
+  assert.equal(drifted.length, 1);
+  assert.match(drifted[0], /declares cadence: 15min/);
+  assert.match(drifted[0], /-> daily|→ daily/);
+
+  // A non-divisor step cannot satisfy it either — it classifies as nothing.
+  assert.match(rs.evaluate(declared, wf('*/7 * * * *')).violations[0], /unclassifiable/);
+});
+
+test('an undeclarable cadence is refused by name (task 1003674)', () => {
+  const v = rs.evaluate(routines([{ name: 'sweepy', cadence: '7min', steps: [] }]), []).violations;
+  assert.equal(v.length, 1);
+  assert.match(v[0], /unknown cadence "7min"/);
+  assert.match(v[0], /N divides 60/);
+});
+
 test('workflowCrons reads every cron a workflow declares, quoted or bare, ignoring trailing comments', () => {
   const y = ["  schedule:", "    - cron: '17 6 * * 1'", '    - cron: "0 3 * * *"', '    - cron: 5 * * * *  # bare + comment'].join('\n');
   assert.deepEqual(rs.workflowCrons(y), ['17 6 * * 1', '0 3 * * *', '5 * * * *']);