@bongos/core 1.21.106 → 1.21.108

package/tests/planning_session_skill.mjs

@@ -161,5 +161,45 @@ test('Phase 5 re-probes the session before the first write, and on a 401 re-auth
   assert.match(p5, /idempotent/i, 'and says why a re-run is safe');
 });
 
+// ---- task 1004668: a new task does not wait at backlog, and ready is not claimable ----
+// POST /tasks answers 'backlog', then the reconciler's sweep promotes any task with
+// no unmet dependency within about a minute. Three playbooks said a new task sits at
+// backlog until promoted; one triage told the owner 15 tasks awaited their go and then
+// hit 409 cannot_promote on every one.
+
+const read = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8').replace(/\s+/g, ' ');
+const PLAYBOOKS = ['planning-session', 'idea-triage', 'goal-create', 'owner-review', 'backlog-review']
+  .map((s) => [s, read(`.claude/skills/${s}/SKILL.md`)]);
+
+test('no playbook says a newly created task lands at backlog and waits for a promote', () => {
+  for (const [name, text] of PLAYBOOKS) {
+    assert.ok(!/Every newly-seeded task lands `status='backlog'`/.test(text), `${name}: the seed-lands-at-backlog claim`);
+    assert.ok(!/Every new task lands status='backlog'/.test(text), `${name}: the new-task-lands-at-backlog claim`);
+    assert.ok(!/lands the new task in `backlog`, \*\*not\*\* `active`/.test(text), `${name}: the triage claim`);
+  }
+});
+
+test('the Phase 5 promote step reads the statuses first and names the claim gate as the enforcement', () => {
+  const step = promoteStep();
+  assert.match(step, /Do \*\*not\*\* assume the seed landed at `backlog`/, 'replaces the assumption with a check');
+  assert.match(step, /backlog sweep/, 'names what promotes them');
+  assert.match(step, /`ready` is not "claimable"/, 'says ready is not claimable');
+  assert.match(step, /DEPS_NOT_SHIPPED/, 'names the claim-time dependency gate');
+});
+
+test('idea-triage and goal-create say to re-read the status and promote only what is still at backlog', () => {
+  const triage = PLAYBOOKS.find(([n]) => n === 'idea-triage')[1];
+  assert.match(triage, /auto-promoted to `ready` within about a minute/);
+  assert.match(triage, /Re-read its status after creating/);
+  assert.match(triage, /409 cannot_promote/);
+  const goal = PLAYBOOKS.find(([n]) => n === 'goal-create')[1];
+  assert.match(goal, /promote only a non-spike still at 'backlog'/);
+});
+
+test('the seeding contract names the pre-seed baseline for a populated goal', () => {
+  assert.ok(NORM.includes('baselineSeedCriteria'), 'names the baseline helper');
+  assert.match(NORM, /BEFORE the first write/);
+});
+
 console.log(`\nplanning_session_skill: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);

package/tests/seed_verify_criteria.mjs

@@ -15,11 +15,13 @@
 
 import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
 
 const require = createRequire(import.meta.url);
 const {
   diffCriterionLinks,
   expectedCriterionCounts,
+  baselineSeedCriteria,
   verifySeedCriteriaLinks,
 } = require('../scripts/gds/seed-verify-criteria.js');
 
@@ -145,5 +147,133 @@ await testAsync('a failed/malformed GET is treated as a verification failure, no
   assert.ok(logs.some((l) => l.includes('VERIFY FAILED')));
 });
 
+// --- task 1004668: seeding into a goal that already carries linked work -----
+//
+// Goal 1000095 held six criteria with live links (1, 9, 4, 3, 6, 10) before a
+// seed touched it. The old diff unioned those into the check with an expected
+// count of zero, so a CORRECT seed exited 1 six times over.
+
+const POPULATED = [
+  { criterion_id: 'old-1', linked_tasks: 1 }, { criterion_id: 'old-2', linked_tasks: 9 },
+  { criterion_id: 'old-3', linked_tasks: 4 }, { criterion_id: 'old-4', linked_tasks: 3 },
+  { criterion_id: 'old-5', linked_tasks: 6 }, { criterion_id: 'old-6', linked_tasks: 10 },
+];
+
+test('THE INCIDENT: without a baseline, criteria the seed does not cite are not assumed to be zero', () => {
+  const rows = [...POPULATED, { criterion_id: 'ours', linked_tasks: 2 }];
+  assert.deepEqual(diffCriterionLinks({ ours: 2 }, rows), []);
+});
+
+test('without a baseline the plan\'s own criteria are still checked', () => {
+  const rows = [...POPULATED, { criterion_id: 'ours', linked_tasks: 0 }];
+  assert.deepEqual(diffCriterionLinks({ ours: 2 }, rows), [{ criterion_id: 'ours', expected: 2, actual: 0 }]);
+});
+
+test('with a baseline, an untouched criterion at its pre-seed count passes', () => {
+  const baseline = { 'old-1': 1, 'old-2': 9, 'old-3': 4, 'old-4': 3, 'old-5': 6, 'old-6': 10, ours: 0 };
+  const rows = [...POPULATED, { criterion_id: 'ours', linked_tasks: 2 }];
+  assert.deepEqual(diffCriterionLinks({ ours: 2 }, rows, { baseline }), []);
+});
+
+test('with a baseline, a stray link onto a criterion the seed never cites is caught', () => {
+  // The RETRO2 mislink lands tasks on the WRONG criterion. With a baseline that
+  // excess is visible even though the wrong criterion is not in the plan.
+  const baseline = { 'old-1': 1, ours: 0 };
+  const rows = [{ criterion_id: 'old-1', linked_tasks: 3 }, { criterion_id: 'ours', linked_tasks: 0 }];
+  assert.deepEqual(diffCriterionLinks({ ours: 2 }, rows, { baseline }), [
+    { criterion_id: 'old-1', expected: 1, actual: 3 },
+    { criterion_id: 'ours', expected: 2, actual: 0 },
+  ]);
+});
+
+test('with a baseline, a planned criterion that already had links expects baseline + plan', () => {
+  const rows = [{ criterion_id: 'shared', linked_tasks: 7 }];
+  assert.deepEqual(diffCriterionLinks({ shared: 2 }, rows, { baseline: { shared: 5 } }), []);
+  assert.deepEqual(diffCriterionLinks({ shared: 2 }, rows, { baseline: { shared: 4 } }),
+    [{ criterion_id: 'shared', expected: 6, actual: 7 }]);
+});
+
+test('a criterion created after the baseline starts at zero, so a link on it is caught', () => {
+  const rows = [{ criterion_id: 'brand-new', linked_tasks: 1 }];
+  assert.deepEqual(diffCriterionLinks({}, rows, { baseline: {} }),
+    [{ criterion_id: 'brand-new', expected: 0, actual: 1 }]);
+});
+
+const goalWith = (criteria) => async () => ({ ok: true, status: 200, json: { criteria } });
+
+// A RESUMED seed (grade finding on task 1004668). The first run created task A
+// (linked to `ours`) and died; the re-run baselines AFTER that, replays A
+// (`idempotent: true`) and creates B. The plan must count only B — tallying the
+// replay too expects A's link twice and fails a correct resume.
+function tallyCreated(responses) {
+  // The reference seed's tally rule, exactly: skip a replayed create.
+  return expectedCriterionCounts(responses.filter((r) => !r.idempotent).map((r) => r.crit));
+}
+
+test('a resumed seed tallies only what THIS run created, and verifies OK', () => {
+  const baseline = { ours: 1 }; // A's link, from the first run
+  const responses = [{ crit: ['ours'], idempotent: true }, { crit: ['ours'] }];
+  const rows = [{ criterion_id: 'ours', linked_tasks: 2 }];
+  assert.deepEqual(diffCriterionLinks(tallyCreated(responses), rows, { baseline }), []);
+  // The bug the finding names: counting the replay expects 3.
+  const naive = expectedCriterionCounts(responses.map((r) => r.crit));
+  assert.deepEqual(diffCriterionLinks(naive, rows, { baseline }), [{ criterion_id: 'ours', expected: 3, actual: 2 }]);
+});
+
+test('a fully re-run seed (every create a replay) plans nothing and verifies OK', () => {
+  const responses = [{ crit: ['ours'], idempotent: true }, { crit: ['ours'], idempotent: true }];
+  assert.deepEqual(diffCriterionLinks(tallyCreated(responses), [{ criterion_id: 'ours', linked_tasks: 2 }], { baseline: { ours: 2 } }), []);
+});
+
+test('the baselined reference seed skips replays when it tallies', () => {
+  const src = readFileSync(new URL('../scripts/gds/seed-bv2-ideator-surface-tasks.js', import.meta.url), 'utf8');
+  assert.match(src, /baselineSeedCriteria\(/, 'it takes a baseline');
+  assert.match(src, /if \(!r\.json\.idempotent\) criterionIdListsPerTask\.push\(t\.crit\);/, 'and tallies only created tasks');
+});
+
+await testAsync('baselineSeedCriteria snapshots the goal before any write', async () => {
+  const logs = [];
+  const baseline = await baselineSeedCriteria({
+    goalId: 1000095, fetchGoal: goalWith(POPULATED), log: (l) => logs.push(l), exit: () => { throw new Error('should not exit'); },
+  });
+  assert.deepEqual(baseline, { 'old-1': 1, 'old-2': 9, 'old-3': 4, 'old-4': 3, 'old-5': 6, 'old-6': 10 });
+  assert.ok(logs.some((l) => l.includes('6 already carrying linked tasks')));
+});
+
+await testAsync('baselineSeedCriteria refuses to seed blind when the goal cannot be read', async () => {
+  let exitCode = null; const logs = [];
+  await baselineSeedCriteria({
+    goalId: 1000095, fetchGoal: async () => ({ ok: false, status: 401, json: null }),
+    log: (l) => logs.push(l), exit: (c) => { exitCode = c; },
+  });
+  assert.equal(exitCode, 1);
+  assert.ok(logs.some((l) => l.includes('Refusing to seed blind')));
+});
+
+await testAsync('a correct seed into a populated goal verifies OK end to end, baseline passed through', async () => {
+  const logs = []; let exitCalled = false;
+  const baseline = await baselineSeedCriteria({ goalId: 1000095, fetchGoal: goalWith(POPULATED), log: () => {} });
+  await verifySeedCriteriaLinks({
+    goalId: 1000095,
+    expectedCounts: expectedCriterionCounts([['ours'], ['ours']]),
+    baseline,
+    fetchGoal: goalWith([...POPULATED, { criterion_id: 'ours', linked_tasks: 2 }]),
+    log: (l) => logs.push(l),
+    exit: () => { exitCalled = true; },
+  });
+  assert.equal(exitCalled, false, logs.join('\n'));
+  assert.ok(logs.some((l) => l.includes('VERIFY OK') && l.includes('pre-seed count')));
+});
+
+await testAsync('without a baseline the OK line says what it did not check', async () => {
+  const logs = [];
+  await verifySeedCriteriaLinks({
+    goalId: 1000095, expectedCounts: { ours: 2 },
+    fetchGoal: goalWith([...POPULATED, { criterion_id: 'ours', linked_tasks: 2 }]),
+    log: (l) => logs.push(l), exit: () => { throw new Error('should not exit'); },
+  });
+  assert.ok(logs.some((l) => /were not checked/.test(l) && l.includes('baselineSeedCriteria')));
+});
+
 console.log(`\nseed_verify_criteria: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);