@bongos/core 1.19.813 → 1.19.815

package/tests/government_ownership_scope.mjs

@@ -100,18 +100,24 @@ test('A2: every ".own"-suffixed key DECLARES scope own — the namespace never o
 });
 
 test('A3: the modelled families are the ones the ownership sweep names', () => {
+  // `task` joined the modelled families in task 1002443 (ADR 0297) — the first
+  // family added because a ROUTE needed it rather than to complete the model.
   assert.deepEqual(Object.keys(RESOURCE_FAMILIES).sort(),
-    ['box', 'builder_prefs', 'claim', 'credential', 'goal', 'memory']);
+    ['box', 'builder_prefs', 'claim', 'credential', 'goal', 'memory', 'task']);
   assert.deepEqual([...ownershipScopedKeys()].sort(),
-    ['box.manage.own', 'credential.manage.own', 'goal.manage.own', 'me.wandering.set', 'memory.manage.own', 'task.act.own']);
-  // The cross-owner side is NOT derivable from spelling: box's is `box.fleet.manage`.
+    ['box.manage.own', 'credential.manage.own', 'goal.manage.own', 'me.wandering.set', 'memory.manage.own', 'task.abandon.own', 'task.act.own']);
+  // The cross-owner side is NOT derivable from spelling: box's is `box.fleet.manage`,
+  // and `task.abandon` carries no suffix at all — it predates the axis and was given
+  // scope/resource/verb in place rather than renamed, because it is seeded in live
+  // rank rows (governance_002) and a key rename is a migration, not a declaration.
   assert.deepEqual([...crossOwnerKeys()].sort(),
-    ['box.fleet.manage', 'claim.release.any', 'memory.read.any']);
+    ['box.fleet.manage', 'claim.release.any', 'memory.read.any', 'task.abandon']);
   // The escalation path is DECLARED per key, never derived from the resource
-  // family (task 1003195). box is the one REAL pair in the catalog today:
-  // `box.fleet.manage` is the same `manage` verb over every owner's box, so it
-  // genuinely subsumes managing your own.
+  // family (task 1003195). TWO real pairs now: `box.fleet.manage` is the same
+  // `manage` verb over every owner's box, and `task.abandon` the same `act` verb
+  // over every creator's task, so each genuinely subsumes doing it to your own.
   assert.deepEqual(crossOwnerKeysFor('box.manage.own'), ['box.fleet.manage']);
+  assert.deepEqual(crossOwnerKeysFor('task.abandon.own'), ['task.abandon']);
   // claim and memory each HAVE an `any` key in their family and still declare no
   // counterpart — the distinction the family-derived version could not make.
   // `claim.release.any` carries one third of `act` (release, not cost or notes);

package/tests/idea_cascade.mjs

@@ -0,0 +1,211 @@
+// tests/idea_cascade.mjs — the SECOND cross-role cascade: an ideator lands a Full
+// Idea, an engineer gets a scoping task (task 1003856, part 1's residue).
+//
+// The first cascade (artist-review-on-ship, task 1003549) is covered by
+// modules/lifecycle/tests/cascade.mjs. This file covers what the second one added:
+// a trigger that is not a ship. The mechanism was ship-only, and an idea reaching
+// grade 'full' emitted nothing at all — so the rule could not be a table entry.
+//
+// The runner guarantees are the same four the ship runner's header names, and the
+// one that matters most here is the first: an ideator grading their own idea must
+// never be able to fail on a follow-up task's account.
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const C = require(path.join(ROOT, 'modules', 'lifecycle', 'cascade.js'));
+
+const idea = (over = {}) => ({
+  id: '1001030',
+  title: 'Price swaps from mechanism',
+  grade: 'full',
+  status: 'open',
+  completeness_score: 4,
+  captured_by: '1000025',
+  suggested_goal_id: '1000095',
+  suggested_version: 'BONGOS-V2',
+  ...over,
+});
+
+const deps = (over = {}) => {
+  const created = [];
+  return {
+    created,
+    findTaskBySourceRef: async () => null,
+    createTask: async (spec) => { created.push(spec); return { id: '9001' }; },
+    ...over,
+  };
+};
+
+// ---------- the rule ----------
+test('the declaration is well-formed — a malformed rule is a wiring bug, not a silent skip', () => {
+  assert.deepEqual(C.validateCascades(C.IDEA_CASCADES), []);
+});
+
+test('a Full Idea matches, and files for the ENGINEER', () => {
+  const { matched, errors } = C.cascadesFor(idea(), C.IDEA_CASCADES, {}, C.TRIGGERS.idea);
+  assert.deepEqual(errors, []);
+  assert.equal(matched.length, 1);
+  assert.equal(matched[0].rule.discipline, 'engineer');
+  assert.match(matched[0].spec.title, /Scope the Full Idea: Price swaps from mechanism/);
+});
+
+test('a spark or quick idea does NOT match — Full is the hand-off point', () => {
+  for (const grade of ['quick', 'spark', undefined]) {
+    const { matched } = C.cascadesFor(idea({ grade }), C.IDEA_CASCADES, {}, C.TRIGGERS.idea);
+    assert.equal(matched.length, 0, `grade=${grade} should not file a scoping task`);
+  }
+});
+
+test('a CLOSED idea does not file — triage got there first', () => {
+  for (const status of ['discarded', 'merged', 'promoted']) {
+    const { matched } = C.cascadesFor(idea({ status }), C.IDEA_CASCADES, {}, C.TRIGGERS.idea);
+    assert.equal(matched.length, 0, `status=${status} should not file`);
+  }
+});
+
+test('a cascade-sourced idea cannot file another cascade — the anti-recursion guard', () => {
+  const { matched } = C.cascadesFor(idea({ source: C.CASCADE_SOURCE }), C.IDEA_CASCADES, {}, C.TRIGGERS.idea);
+  assert.equal(matched.length, 0);
+});
+
+// ---------- the generated task ----------
+test('the task inherits the version but NEVER the advisory goal hint', () => {
+  // idea_inbox.suggested_goal_id documents itself as "Strictly advisory: no rank
+  // check, no scope wall, and no payout may read it... The BINDING home for
+  // 'which goal' is tasks.goal_id". A generated task's goal IS binding, so
+  // inheriting it from the hint would be exactly the read that column forbids.
+  // A version is a label and carries no such rule.
+  const { matched } = C.cascadesFor(idea(), C.IDEA_CASCADES, {}, C.TRIGGERS.idea);
+  const spec = matched[0].spec;
+  assert.equal(spec.versionId, 'BONGOS-V2');
+  assert.equal(spec.goalId, null, 'an advisory hint must not place a task');
+  assert.equal(spec.allowCatchAll, true, 'so it lands in the catch-all and gets triaged like any other homeless work');
+});
+
+test('the hint is surfaced for a human rather than silently dropped', () => {
+  // Not acting on it is the rule; losing it would be a different mistake.
+  const body = C.fullIdeaScopingBody(idea());
+  assert.match(body, /routing hint/);
+  assert.match(body, /goal 1000095/);
+  assert.match(body, /advisory/);
+});
+
+test('an idea with no hint says nothing about goals at all', () => {
+  const body = C.fullIdeaScopingBody(idea({ suggested_goal_id: null }));
+  assert.doesNotMatch(body, /routing hint/);
+});
+
+test('a goal-less idea still opts into the catch-all rather than vanishing', () => {
+  // The exact regression task 1003598 closed for ships: under the goal guard a
+  // null goalId THROWS, and the throw is caught per-rule — so the task would
+  // disappear with only a console line.
+  const { matched } = C.cascadesFor(idea({ suggested_goal_id: null }), C.IDEA_CASCADES, {}, C.TRIGGERS.idea);
+  assert.equal(matched[0].spec.allowCatchAll, true);
+});
+
+test('the preamble says what actually happened — an idea was graded, not a task shipped', () => {
+  const { matched } = C.cascadesFor(idea(), C.IDEA_CASCADES, {}, C.TRIGGERS.idea);
+  const d = matched[0].spec.description;
+  assert.match(d, /idea 1001030 was graded Full/);
+  assert.doesNotMatch(d, /shipped/, 'the ship preamble would be a lie on this trigger');
+});
+
+test('the body tells the engineer what is already settled and what is being asked', () => {
+  const body = C.fullIdeaScopingBody(idea());
+  assert.match(body, /reached \*\*Full\*\*/);
+  assert.match(body, /completeness 4/);
+  assert.match(body, /What would building it actually touch/);
+  // A scoping that concludes "don't build it" is a real answer; say so.
+  assert.match(body, /why it should not be built/);
+});
+
+test('the source_ref pins one rule to one idea, so a re-grade cannot double-file', () => {
+  const { matched } = C.cascadesFor(idea(), C.IDEA_CASCADES, {}, C.TRIGGERS.idea);
+  assert.equal(matched[0].spec.sourceRef, C.cascadeSourceRef('engineer-scoping-on-full-idea', '1001030'));
+  assert.equal(matched[0].spec.source, C.CASCADE_SOURCE);
+});
+
+// ---------- the runner ----------
+test('the runner files the task from the event payload alone', async () => {
+  const d = deps();
+  const report = await C.runCascadesForIdea(idea(), d);
+  assert.deepEqual(report.errors, []);
+  assert.equal(report.created.length, 1);
+  assert.equal(d.created.length, 1);
+  assert.equal(d.created[0].discipline, 'engineer');
+});
+
+test('an already-filed cascade is SKIPPED, not filed twice', async () => {
+  const d = deps({ findTaskBySourceRef: async () => ({ id: '8001' }) });
+  const report = await C.runCascadesForIdea(idea(), d);
+  assert.equal(report.created.length, 0);
+  assert.deepEqual(report.skipped.map((s) => s.reason), ['already filed']);
+  assert.equal(d.created.length, 0);
+});
+
+test('a payload with no id is reported, never thrown', async () => {
+  const report = await C.runCascadesForIdea({}, deps());
+  assert.equal(report.created.length, 0);
+  assert.match(report.errors.join(' '), /carried no idea id/);
+});
+
+test('createTask throwing costs that rule its task and NOTHING else', async () => {
+  // Property 1: the ideator's grade is already written. A follow-up task failing
+  // must never surface as a failure of the thing that triggered it.
+  const d = deps({ createTask: async () => { throw new Error('db down'); } });
+  const report = await C.runCascadesForIdea(idea(), d);
+  assert.equal(report.created.length, 0);
+  assert.match(report.errors.join(' '), /db down/);
+});
+
+test('the runner never rejects, whatever the deps do', async () => {
+  const report = await C.runCascadesForIdea(idea(), { findTaskBySourceRef: async () => { throw new Error('boom'); }, createTask: async () => ({ id: '1' }) });
+  assert.ok(Array.isArray(report.errors) && report.errors.length > 0);
+});
+
+test('an injected reader that finds nothing is an error, not a silent fall-back', async () => {
+  const report = await C.runCascadesForIdea(idea(), deps({ getIdea: async () => null }));
+  assert.match(report.errors.join(' '), /not readable after grading/);
+  assert.equal(report.created.length, 0);
+});
+
+// ---------- the wiring, which fails silently when it breaks ----------
+const src = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8');
+
+test('the event is in the catalog AND something dispatches it', () => {
+  // The catalog's own comment: widening it is deliberate and must land together
+  // with a real dispatcher. Both halves asserted, because either alone is dead.
+  assert.match(src('modules/agents/lib/validate.js'), /'idea\.graded\.full'/);
+  assert.match(src('modules/ideas/inbox.js'), /api\.emit\('idea\.graded\.full'/);
+});
+
+test('the emit carries the whole idea, not just an id', () => {
+  // The listener lives in lifecycle, which owns no idea table and has no read
+  // port for one — so a bare {id} payload would leave the rules nothing to match.
+  const inbox = src('modules/ideas/inbox.js');
+  assert.match(inbox, /const idea = await getIdea\(ideaId\)/);
+  assert.match(inbox, /\.\.\.\(idea \|\| \{\}\)/);
+});
+
+test('lifecycle subscribes to the idea trigger and tears it down again', () => {
+  const lc = src('modules/lifecycle/routes/lifecycle.js');
+  assert.match(lc, /api\.on\('idea\.graded\.full'/);
+  assert.match(lc, /if \(_ideaCascadeListenerOff\) _ideaCascadeListenerOff\(\)/);
+  // It must NOT reach into the ideas module's table to do it.
+  assert.doesNotMatch(lc, /getIdeaForCascade/, 'lifecycle must not query another module\'s rows');
+});
+
+test('the emit only fires on a REAL transition', () => {
+  // The UPDATE carries `AND grade = 'spark'`, so a no-op re-grade returns null.
+  // The emit is inside `if (graded)`, so it cannot repeat for one idea.
+  const inbox = src('modules/ideas/inbox.js');
+  const at = inbox.indexOf("api.emit('idea.graded.full'");
+  assert.ok(at > 0);
+  assert.match(inbox.slice(0, at).split('\n').slice(-25).join('\n'), /if \(graded\) \{/);
+});

package/tests/task_goal_required.mjs

@@ -134,11 +134,23 @@ test('cascade opts in ONLY when inheritance actually failed', () => {
   // general. A blanket `true` here would quietly re-open the hole for every
   // follow-up task the system files.
   const body = src('modules/lifecycle/cascade.js');
-  assert.match(body, /allowCatchAll: task\.goal_id == null,/);
+  // Pinned on the RULE, not on one spelling of it: task 1003856 added an
+  // idea-triggered cascade whose subject carries its goal as `suggested_goal_id`,
+  // so the condition legitimately grew a term. What must stay true is that the
+  // hatch is conditional and covers every source the spec can inherit from.
+  const hatch = (body.match(/allowCatchAll:.*$/m) || [''])[0];
+  assert.match(hatch, /task\.goal_id == null/, 'the hatch still turns on a missing inherited goal');
   assert.equal(/allowCatchAll: true/.test(body), false,
     'an unconditional hatch here would cover every cascade, not just the legacy ones');
-  assert.match(body, /goalId: task\.goal_id != null \? Number\(task\.goal_id\) : null,/,
-    'inheritance stays the primary path');
+
+  // Every field the spec inherits a goal FROM must also be a field the hatch
+  // checks, or a subject shape could arrive with a real goal and still opt into
+  // the catch-all — the hole this test exists to keep shut.
+  const goalLine = (body.match(/^\s*goalId:[\s\S]*?,$/m) || [''])[0];
+  assert.match(goalLine, /task\.goal_id != null \? Number\(task\.goal_id\)/, 'inheritance stays the primary path');
+  for (const field of (goalLine.match(/task\.[a-z_]*goal[a-z_]*/g) || [])) {
+    assert.ok(hatch.includes(field), `${field} is inherited as a goal but is not checked by the catch-all hatch`);
+  }
 });
 
 test('a goal-less parent does not silently lose its cascade task', async () => {