@bongos/core 1.21.175 → 1.21.176

package/scripts/bongos/seed-bv2-ideator-surface-tasks.js

@@ -0,0 +1,390 @@
+// Seed the tasks for the ideator surface on goal 1000095 (BONGOS-V2, Working area 6).
+// Source of truth: docs/specs/bongos-v2-ideator-surface.md (status: final).
+// Visual direction: docs/design/ideator-surface-direction.md. Decisions: idea 1001072.
+// Planning session 2026-09-19, meta task 1004076.
+//
+// Idempotent on (source, source_ref). Re-running resolves to the existing rows.
+// criterion_ids are SLUGS, never positional "Cn" — goal 1000095 is one of several
+// goals on this version, so a positional ref resolves against the wrong scope and
+// POST /tasks now refuses it outright (learning 1000188, task 1003108).
+//
+// Ends by diffing the criterion links it planned against what the goal actually
+// carries, and exits non-zero on any mismatch (the seeding contract's self-check).
+//
+// Run: node scripts/bongos/seed-bv2-ideator-surface-tasks.js
+const os = require('os');
+const { baselineSeedCriteria, expectedCriterionCounts, verifySeedCriteriaLinks } = require('./seed-verify-criteria');
+const sess = require(os.homedir() + '/.config/cloudbongos/gds-session.json');
+const BASE = sess.api_base.replace(/\/$/, '');
+const TOKEN = sess.token;
+const VER = 'BONGOS-V2';
+const GOAL = 1000095;
+const SRC = 'planning-session';
+const REF_PREFIX = 'bv2-ideator-surface';
+const H = { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' };
+
+const CRIT = {
+  lost: 'ideator-nothing-is-lost',
+  fork: 'ideator-tag-survives-the-fork',
+  sky: 'ideator-sky-tells-the-truth',
+  full: 'ideator-full-idea-shapes-the-space',
+};
+
+const SPEC = 'Spec: `docs/specs/bongos-v2-ideator-surface.md` (final). Design of record: idea 1001072 + `docs/design/ideator-surface-direction.md`.';
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function api(method, path, body, _tries = 0) {
+  await sleep(400); // base throttle to stay under the per-IP rate limit
+  const res = await fetch(`${BASE}/api/bongos${path}`, {
+    method, headers: H, body: body ? JSON.stringify(body) : undefined,
+  });
+  const text = await res.text();
+  let json; try { json = JSON.parse(text); } catch { json = { _raw: text.slice(0, 300) }; }
+  if (res.status === 429 && _tries < 8) {
+    const wait = ((json.error && json.error.details && json.error.details.retry_after_seconds) || 30) + 1;
+    console.log(`  …rate-limited, waiting ${wait}s`);
+    await sleep(wait * 1000);
+    return api(method, path, body, _tries + 1);
+  }
+  return { status: res.status, ok: res.ok, json };
+}
+
+// TOPOLOGICAL ORDER. The BV2.R## prefix is assigned from this array's index, so
+// for any task A depending on B, B sits earlier and carries the lower number.
+// Nothing else on BONGOS-V2 uses a rank prefix; these 27 carry one so the batch
+// reads in its planned order inside each priority bucket.
+const TASKS = [
+  // ---- T1: the two spikes. Neither auto-promotes (kind='spike', ADR 0015).
+  {
+    ref: 'R07', kind: 'spike', discipline: 'engineer', priority: 5, crit: [CRIT.fork],
+    title: 'Spike: how provenance is recorded without widening the task hierarchy',
+    desc: `Output an ADR naming the edge shape, where it is written, and who writes it when work is split or rewritten.
+
+**The constraint that makes this a spike.** \`modules/lifecycle/hierarchy.js\` caps task parentage at ONE level (a parent may not itself have a parent; a task with children may not become a child) and refuses cross-version trees. Both are deliberate — ship rollup and claim safety lean on them. A descent of the shape idea → task → rewrite → split → removal is four levels and crosses a version boundary, so it cannot ride on that relation, and **widening it is explicitly out of scope** (spec decision 8).
+
+Provenance is a different relation from work decomposition. The expected home is \`ideas_task_lineage\`, which is already many-ideas-to-one-task and carries none of those invariants — but confirm that before assuming it.
+
+**Also settle:** who writes the edge. Parentage today is a manual explicit act, so an edge that depends on someone remembering will have holes. ${SPEC}`,
+  },
+  {
+    ref: 'R14', kind: 'spike', discipline: 'engineer', priority: 5, crit: [CRIT.sky],
+    title: 'Spike: what counts as removed, and who says so',
+    desc: `Output an ADR settling the removal signal: its source, and whether it is derived or declared.
+
+**Nothing records this today.** \`shipped\` is terminal (\`modules/lifecycle/rot.js\` says so in as many words), there is no reverted status, and \`tasks.merged_into_task_id\` is CHECK-constrained to abandoned rows so it can only ever describe work that was cut before it landed. This signal is what lets brightness fall at all.
+
+**The owner's decision (spec decision 13) is the shape, not the detail:** the system PROPOSES and a person CONFIRMS. \`modules/lifecycle/cascade.js\` already implements ship-generates-work and ships with an EMPTY rule set, so the mechanism exists and only the rule is new. A derived-only signal dims the sky for refactors, renames and file moves; a declared-only one rots because nobody remembers.
+
+Nearest existing signal to build the derivation on: \`modules/economy/credits.js\` \`netNegativeBonusAmount\`, which already reads \`lines_removed > lines_added\` from a ship's own diff — the only place the system counts deletion. ${SPEC}`,
+  },
+
+  // ---- Zero-dep surfaces and settings.
+  {
+    ref: 'R01', kind: 'feature', discipline: 'ui', priority: 4, crit: [CRIT.lost],
+    title: 'The receipt persists',
+    desc: `A filing's outcome is stated and survives the next keystroke; the last several outcomes stay reachable on the surface that filed them.
+
+**This is the bug that started the session.** The hall already prints "Filed as task N under <goal>" on a routed capture (\`modules/hall-ui/public/ideas.js\`, the \`#fq-result\` line) — and then clears it the moment the composer is touched again. The signal exists; its half-life is about four seconds.
+
+Done-when: a person files a thought, keeps working, and can still see what became of it without navigating anywhere. ${SPEC}`,
+  },
+  {
+    ref: 'R02', kind: 'feature', discipline: 'ui', priority: 4, crit: [CRIT.lost],
+    title: 'Gravity is visible before release',
+    desc: `The goal that will catch a thought is shown while composing, and letting it float is an explicit choice rather than an empty dropdown.
+
+**No new routing.** \`modules/ideas/routing.js\` \`decideLanding\` already decides this at capture time, and \`GET /goals/suggestions\` already feeds the composer's goal select. This task makes the decision legible at the moment it is made — the invisible dropdown is the direct cause of the confusion this whole scope came from (spec decision 2).
+
+Done-when: before releasing a thought, a person can see which goal will catch it, change it, or deliberately let it float. ${SPEC}`,
+  },
+  {
+    ref: 'R05', kind: 'feature', discipline: 'engineer', priority: 3, crit: [CRIT.lost],
+    title: 'The per-instance dials: the ignite floor and the decay rate',
+    desc: `Both configured rather than constant, sharing one home. Defaults preserve today's behaviour and halving respectively.
+
+**Two dials, one surface** (spec decisions 3 and 16). The ignite floor — who may convert a quick idea directly into claimable work — is today the \`METIC_PLUS\` constant in \`modules/ideas/routing.js\`. The decay rate — how fast an ideator's share falls per hop of the descent — is new in R11. The owner's ruling is that both belong to the project, not to the platform: a project of one wants every thought claimable, a project of fifty wants a nod.
+
+They are scoped together deliberately so a second dial does not grow its own separate home. Do not widen either default as a side effect. ${SPEC}`,
+  },
+  {
+    ref: 'R20', kind: 'feature', discipline: 'engineer', priority: 4, crit: [CRIT.full],
+    title: 'The new five questions as a versioned template',
+    desc: `\`base-v2\` ships beside \`base-v1\`; ideas already filed keep scoring against the questions they were actually asked.
+
+**The owner's question set, in order:** what made you have the idea; scope as best as you can here; what should an engineer or artist know prior to building; how is this long term justified in the project; what does a successful implementation of the idea look like.
+
+**This is cheaper than it looks.** \`modules/ideas/templates.js\` already registers templates by key and every idea stores its \`template_key\`, so this is a second entry in the registry, NOT a migration. Renaming a label is free; only renaming a key would be a data migration, and this does not need to.
+
+One field survives outright (what made you have the idea ≈ \`why_had\`) and one roughly (the long-term justification ≈ \`fit\`). Three are new and one is dropped. ${SPEC}`,
+  },
+
+  // ---- The provenance spine.
+  {
+    ref: 'R08', kind: 'feature', discipline: 'engineer', priority: 5, crit: [CRIT.fork], deps: ['R07'],
+    title: 'Provenance edges on the idea lineage ledger',
+    desc: `task→task descent edges recorded, to arbitrary depth and across version boundaries. The task hierarchy's one-level cap and its cross-version refusal are untouched.
+
+Build to whatever R07's ADR settled. The write side that exists today is \`modules/ideas/inbox.js\` \`linkIdeaTask\`, an upsert on \`(task_id, idea_id)\`; \`ideas_task_lineage\` has been many-ideas-to-one-task since \`ideas_006\`.
+
+**The property that matters:** the tag must survive a rewrite, a split and a merge. If it only survives one hop the result is a link, not a story — and, after R11, someone does not get paid. ${SPEC}`,
+  },
+  {
+    ref: 'R04', kind: 'refactor', discipline: 'ui', priority: 3, crit: [CRIT.lost], deps: ['R01'],
+    title: 'Fold the Full Idea form and the spark queue into the new surface',
+    desc: `Developing a thought is a step taken AFTER a one-line filing, never a gate before it. No dead links from \`/idea/:id\`, the command palette, or the nav.
+
+**What the ideas page actually is today:** three stacked sections — the spark queue ("waiting to be developed"), the quick composer, and the five-field Full Idea composer with its live completeness meter. All three need a home. The Board Room does NOT — it is reached from the left nav and is not behind this page.
+
+**The risk this task carries** (spec decision 18): a spark's whole value is that it costs nothing to have. Folding a five-question form onto the same surface is the most likely way to slow the one-line path. R06a exists to catch that; do not treat it as someone else's problem. ${SPEC}`,
+  },
+  {
+    ref: 'R11', kind: 'feature', discipline: 'engineer', priority: 5, crit: [CRIT.fork], deps: ['R08'],
+    title: 'The ideator payout follows the descent, decayed by depth',
+    desc: `A descendant's ship pays the origin at the decayed rate. Idempotent. Existing first-hop behaviour preserved exactly.
+
+**The seam exists.** \`modules/economy/credits.js\` \`awardIdeaTaskShipCredit\` already resolves a shipped task back to its source idea and splits the payout — but only via the EARLIEST lineage link, one hop. A task split off later, or a child of a child, pays nobody.
+
+**Decay** (spec decision 16): full share at the direct task, halving at each hop, so an infinite descent is worth at most twice the direct task. The rate is a dial (R05), not a constant.
+
+**The boundary that stops farming** (spec decision 7): descendant WORK pays the origin; a separate idea that merely cites the origin does not. The descent displays more than the payout counts. ${SPEC}`,
+  },
+  {
+    ref: 'R09', kind: 'feature', discipline: 'engineer', priority: 4, crit: [CRIT.fork], deps: ['R08'],
+    title: 'The descent reads to arbitrary depth and across versions',
+    desc: `One query, not per-hop round trips.
+
+**Three findings inherited from abandoned task 1004054**, whose predecessor was built, graded and lost. They are free design requirements, not someone else's mess:
+
+1. **Test at the RENDERED layer, not just the data layer.** The prior attempt tested only the server-side trail builder, which is exactly why finding 2 went uncaught.
+2. **A merged idea's triage note lives on the MERGED row, not the target row.** The prior attempt read it from the target, so the headline scenario was the broken one.
+3. **Collapse the hops into one query or a CTE.** The prior attempt ran 4–6 serial round trips per read.
+
+Today's reader is \`modules/ideas/inbox.js\` \`listIdeaTrailForBuilder\`, which returns \`lineage_tasks[]\` — one hop only. ${SPEC}`,
+  },
+  {
+    ref: 'R15', kind: 'feature', discipline: 'engineer', priority: 4, crit: [CRIT.sky], deps: ['R14'],
+    title: 'The cascade rule that proposes a removal',
+    desc: `A ship that deletes an earlier shipped task's work files a QUESTION, not a verdict. \`shipped\` stays terminal and no credit is ever clawed back.
+
+Build to R14's ADR. \`modules/lifecycle/cascade.js\` already implements ship-generates-work and declares an EMPTY rule set — this is the first rule, so expect the mechanism to be sound and unexercised.
+
+**Do not make this a verdict.** The owner chose propose-then-confirm precisely because refactors, renames and file moves all look like deletions to a diff. A rule that marks work removed on its own evidence will dim the sky for reasons that are not real. ${SPEC}`,
+  },
+  {
+    ref: 'R21', kind: 'feature', discipline: 'engineer', priority: 3, crit: [CRIT.full], deps: ['R20'],
+    title: 'Substance floors for the new Full Idea fields',
+    desc: `Floors chosen deliberately for each new field, because the completeness score feeds credits.
+
+\`modules/ideas/completeness.js\` scores against the per-field \`substanceMin\` declared in the template; \`base-v1\` used a flat 40 characters for all five. The new fields are not interchangeable — "scope as best as you can here" and "what made you have the idea" do not deserve the same floor.
+
+**The never-invent-a-field rule gets stronger here, not weaker** (the Ideator pack). The new set is deliberately resistant to ghost-writing: nobody but the filer can answer what made them have the idea. A floor that pushes an agent to pad a thin answer destroys exactly that property. A short answer scores short — that is the scorer working. ${SPEC}`,
+  },
+  {
+    ref: 'R22', kind: 'feature', discipline: 'engineer', priority: 4, crit: [CRIT.full], deps: ['R20'],
+    title: 'A Full Idea carries a recommendation: goal or criterion',
+    desc: `The recommendation is carried from filing through to the board item and shown to voters.
+
+**The ideator does not decide** (spec decision 9). They recommend; the board decides. The reasoning the owner accepted is that scope is the thing you learn last — the person who had the thought writes it, the people reading it judge how big it turned out to be.
+
+The board item payload is \`boardWindowPayload\` in \`modules/ideas/routes/inbox.js\`; the section labels the Board Room renders are a hand-mirror of the template's field keys (\`modules/hall-ui/public/board-room.js\`, test-pinned) — so a template change and a board change move together. **The Board Room's own flow is unchanged.** ${SPEC}`,
+  },
+  {
+    ref: 'R12', kind: 'feature', discipline: 'engineer', priority: 4, crit: [CRIT.fork], deps: ['R11'],
+    title: 'Size is the sum of those payouts',
+    desc: `Computable from the ledger for any idea. Compressed for drawing, with the true figure available.
+
+**Size is credits, not karma** (spec decision 5). \`karma_log\` carries no task key and no idea key — \`migrations/040_builder_karma.sql\` states that this is deliberate — so "the karma a thought caused" is not a quantity that can be computed. Credits are already idea-attributed at ship, so they can.
+
+Size never falls. That is what makes it independent of brightness, and what lets a thought whose work was torn out still render large. Sums are long-tailed, so compress for drawing and show the real number in the panel. ${SPEC}`,
+  },
+  {
+    ref: 'R10', kind: 'feature', discipline: 'ui', priority: 4, crit: [CRIT.fork], deps: ['R09'],
+    title: 'The descent surface on the idea detail page',
+    desc: `One thought at the top, everything it caused falling away below — including the branches that went out.
+
+\`/idea/:id\` (\`modules/hall-ui/public/idea.js\`) is the canonical per-idea record and stays; this is its new section. It already renders a one-line "became task N" outcome, which this replaces with the full story.
+
+Done-when: a person can trace a thing shipped months later back to the line that caused it, through rewrites, splits and merges. See \`docs/design/mocks/ideator-surface/Descent.dc.html\` for the agreed shape — it is a shape, not a pixel contract. ${SPEC}`,
+  },
+  {
+    ref: 'R15a', kind: 'feature', discipline: 'engineer', priority: 4, crit: [CRIT.sky], deps: ['R15'],
+    title: 'Confirming or dismissing a removal proposal',
+    desc: `On the existing awaiting-nod surface, at the same floor as the nod (Metic+, \`task.promote\`). No new permission and no new page.
+
+An unanswered proposal **rots on the normal clock** (spec decision 14) rather than accumulating — \`modules/lifecycle/rot.js\` and the \`GET /inbox/rotting\` feed already exist and this rides them.
+
+The surface is \`modules/hall-ui/public/goal-inbox.js\`, which already renders the awaiting-nod queue and the rot feed side by side. Confirming is what makes brightness fall; dismissing is what stops a refactor from dimming the sky. ${SPEC}`,
+  },
+  {
+    ref: 'R23', kind: 'feature', discipline: 'engineer', priority: 3, crit: [CRIT.full], deps: ['R22'],
+    title: 'Ratify a Full Idea into a goal',
+    desc: `The goal half beside the existing criterion half. One transaction. The five answers land on the goal.
+
+**The criterion half already exists** and is the model to follow: \`modules/ideas/inbox.js\` \`ratifyCriterionProposal\` writes \`done_when_criteria\` + the idea status + karma + the audit row in a single transaction, and \`POST /inbox/:id/ratify\` fronts it.
+
+**Nothing today turns a filed thought into a goal** — goals come from a separate planning act — so this is the genuinely new path of the four in this criterion. \`POST /goals\` validates \`scope_modules\` against the live roster and escalates to Archon for a protected scope; a ratification path has to respect both. ${SPEC}`,
+  },
+  {
+    ref: 'R12a', kind: 'feature', discipline: 'engineer', priority: 4, crit: [CRIT.fork], deps: ['R12'],
+    title: 'Backfill lineage for existing ideas, without backfilling money',
+    desc: `Pre-existing ideas carry a size computed from the descent they actually have. No credits are paid retroactively.
+
+**And the consequence is surfaced, not hidden** (spec decision 17). For those ideas size is NOT a sum of payouts actually made, so it needs a historical marker or the number quietly lies about what it means. The owner chose this deliberately: it makes the sky meaningful on day one without spending credits again on work already paid for once.
+
+Done-when: every idea filed before this shipped has a size, and anywhere that size is shown makes clear which kind of number it is. ${SPEC}`,
+  },
+  {
+    ref: 'R03', kind: 'feature', discipline: 'ui', priority: 3, crit: [CRIT.lost], deps: ['R12'],
+    title: 'The room',
+    desc: `A plain overview of one's own thinking: what was filed, what it became, its size, and whether it still burns.
+
+**This is the page a person opens daily**, and it does the real work — the sky is ambient, the room is useful. It is deliberately unglamorous: rows, a size, a state.
+
+**It is the author's own view. The profile keeps a compact public trail** (spec decision 19) — the two are not the same surface. \`modules/hall-ui/public/profile.js\` already renders an idea trail from \`GET /inbox/by-builder/:id\`; that stays as what someone else sees on you.
+
+See \`docs/design/mocks/ideator-surface/Room.dc.html\` for the agreed shape. ${SPEC}`,
+  },
+  {
+    ref: 'R16', kind: 'feature', discipline: 'engineer', priority: 4, crit: [CRIT.sky], deps: ['R15a', 'R12'],
+    title: 'Brightness — the live share of a descent',
+    desc: `Computable per idea, and it falls when a removal is confirmed.
+
+**Graded, not binary** (spec decision 20): a thought whose descent is five things with three still alive is partly lit, and goes out only when nothing survives. That is what makes a star visibly dim as the project removes pieces of what it caused.
+
+**Brightness never claws back credits.** The ledger is not rewritten when the project changes its mind — only the picture changes. Size, which R12 owns, does not move. ${SPEC}`,
+  },
+  {
+    ref: 'R06', kind: 'verify', discipline: 'engineer', priority: 3, crit: [CRIT.lost], deps: ['R01', 'R03'],
+    title: 'Proof: a thought filed from the hall is traceable an hour later without asking anyone',
+    desc: `**The live demonstration that \`ideator-nothing-is-lost\` is met.**
+
+A person files a thought, leaves, comes back later, and finds what became of it unaided — no asking, no database, no one else's help. If they filed it aimed, they can see which goal caught it; if they let it float, they can see that nothing has claimed it yet.
+
+This is the exact scenario that failed on 2026-09-19 and produced this whole scope: a thought was filed, it silently became a task under a goal, and the person who filed it could not find it five minutes later. The proof is that this can no longer happen. ${SPEC}`,
+  },
+  {
+    ref: 'R06a', kind: 'verify', discipline: 'engineer', priority: 3, crit: [CRIT.lost], deps: ['R04'],
+    title: 'Proof: the one-line path did not get slower',
+    desc: `**The guard on spec decision 18**, which is the decision in this scope carrying the most risk.
+
+Filing a spark takes the same gestures and the same time it does today, with the Full Idea form present on the same surface. Measure it against today's path, not against an impression.
+
+A spark's whole value is that it costs nothing to have. If the fast path picks up an extra step, a scroll, or a decision, this scope will have built something beautiful that people stop using — and they will go back to firing one-liners into Discord. A green build is not the evidence here; a timed comparison is. ${SPEC}`,
+  },
+  {
+    ref: 'R13', kind: 'verify', discipline: 'engineer', priority: 3, crit: [CRIT.fork], deps: ['R10', 'R12'],
+    title: 'Proof: a task split twice pays its origin at the decayed rate and appears in the descent',
+    desc: `**The live demonstration that \`ideator-tag-survives-the-fork\` is met.**
+
+A real thought becomes a real task; that task is split; one of its children is split again; each ships. The origin is paid at the decayed rate at every hop, and the whole chain reads as one descent.
+
+This is the criterion everything else stands on. If the tag dies at the first fork, the descent is a link, the size is wrong, and the sky is decoration over a number that does not mean anything. Demonstrate it on real work, not a fixture. ${SPEC}`,
+  },
+  {
+    ref: 'R17', kind: 'feature', discipline: 'engineer', priority: 4, crit: [CRIT.sky], deps: ['R16'],
+    title: 'The five states resolve from ledger facts',
+    desc: `star / protostar / satellite / remnant / cold body — each DERIVED, none a UI guess.
+
+- **star** — caused work that is still alive
+- **protostar** — filed, not yet ignited. Include the well-vs-open-space distinction: caught by a goal and awaiting a nod is a different state from claimed by nothing, and position is what carries it (spec decision, direction doc)
+- **satellite** — folded into another thought; its value counts there
+- **remnant** — it burned, then the project removed it; it keeps its size
+- **cold body** — declined at triage; it never ignited, so it has no size at all
+
+Done-when: every state is computed from the ledger, and no surface has to infer one. ${SPEC}`,
+  },
+  {
+    ref: 'R24', kind: 'verify', discipline: 'engineer', priority: 3, crit: [CRIT.full], deps: ['R23'],
+    title: 'Proof: a Full Idea ratified as a goal produces a goal carrying its five answers',
+    desc: `**The live demonstration that \`ideator-full-idea-shapes-the-space\` is met.**
+
+A Full Idea is written through the new five questions, carries a recommendation, goes to the Board Room unchanged, is ratified as a GOAL, and the resulting goal carries those five answers natively — scope from "scope as best as you can here", done-when from "what does a successful implementation look like".
+
+Run it end to end through the real Board Room. The point of this criterion is that an ideator's best work becomes the structure other people's thinking lands in; a goal that arrives without its answers has not demonstrated that. ${SPEC}`,
+  },
+  {
+    ref: 'R18', kind: 'feature', discipline: 'ui', priority: 3, crit: [CRIT.sky], deps: ['R17', 'R03'],
+    title: 'The sky',
+    desc: `The ambient view over the five states: size compressed, brightness live, goals as gravity wells and their criteria as the rings inside them.
+
+**It arrives last on purpose.** By this point it draws numbers and states the rest of the work has already produced, which is what keeps it cheap. A galaxy is not trivial, and this scope only earns it because nothing else depends on it.
+
+**It is never the only path to anything it shows** (spec decision 11). Every fact in the sky is reachable from the room or the descent.
+
+See \`docs/design/mocks/ideator-surface/Sky.dc.html\`, and \`docs/design/ideator-surface-direction.md\` for why the project's own design system — a black void and one accent that lights only what is live — already supplies this. ${SPEC}`,
+  },
+  {
+    ref: 'R19', kind: 'verify', discipline: 'engineer', priority: 3, crit: [CRIT.sky], deps: ['R18'],
+    title: 'Proof: a large dead thought renders large and dead',
+    desc: `**The live demonstration that \`ideator-sky-tells-the-truth\` is met**, and the single scenario this criterion exists for.
+
+A thought that caused substantial work which the project has since removed shows at **full size and zero brightness**, and is distinguishable at a glance from a thought that never caused anything at all.
+
+That distinction is the whole reason size and brightness are two channels instead of one number. If those two render alike, the criterion is not met however green the build is. ${SPEC}`,
+  },
+];
+
+async function main() {
+  const ids = {};
+  const criterionIdListsPerTask = [];
+
+  // BASELINE, before anything is written. Goal 1000095 already held six criteria
+  // with live task links before this seed existed; verifying against the pre-seed
+  // snapshot plus the plan keeps those from reading as false mismatches while still
+  // catching any drift (task 1004668 moved this into seed-verify-criteria.js).
+  const baseline = await baselineSeedCriteria({ goalId: GOAL, fetchGoal: (gid) => api('GET', `/goals/${gid}`) });
+
+  console.log(`Seeding ${TASKS.length} tasks into goal ${GOAL} (${VER})…\n`);
+
+  for (let i = 0; i < TASKS.length; i++) {
+    const t = TASKS[i];
+    const rank = String(i + 1).padStart(2, '0');
+    const title = `BV2.R${rank} — ${t.title}`;
+    const r = await api('POST', '/tasks', {
+      version_id: VER,
+      goal_id: GOAL,
+      title,
+      description: t.desc,
+      kind: t.kind,
+      discipline: t.discipline,
+      priority: t.priority,
+      criterion_ids: t.crit,
+      source: SRC,
+      source_ref: `${REF_PREFIX}-${t.ref}`,
+    });
+    if (!r.ok) {
+      console.log(`  ${t.ref} FAILED (${r.status}): ${JSON.stringify(r.json).slice(0, 300)}`);
+      continue;
+    }
+    ids[t.ref] = r.json.task.id;
+    // Count only links THIS run created. A re-run replays an existing task
+    // (`idempotent: true`) whose links the baseline already holds; counting it
+    // again would expect them twice (task 1004668).
+    if (!r.json.idempotent) criterionIdListsPerTask.push(t.crit);
+    console.log(`  ${t.ref} → ${r.json.task.id}  ${title.slice(0, 74)}`);
+  }
+
+  console.log('\nWiring dependencies…');
+  for (const t of TASKS) {
+    if (!t.deps || !t.deps.length) continue;
+    const id = ids[t.ref];
+    if (!id) { console.log(`  ${t.ref}: skipped, task was not created`); continue; }
+    const depIds = t.deps.map((d) => ids[d]).filter(Boolean);
+    if (depIds.length !== t.deps.length) {
+      console.log(`  ${t.ref}: WARNING — ${t.deps.length - depIds.length} dep(s) unresolved`);
+    }
+    if (!depIds.length) continue;
+    const r = await api('POST', `/tasks/${id}/dependencies`, { depends_on_task_ids: depIds });
+    console.log(`  ${t.ref} depends on ${t.deps.join(', ')} → ${r.ok ? 'OK' : `FAILED ${r.status} ${JSON.stringify(r.json).slice(0, 180)}`}`);
+  }
+
+  console.log('');
+  await verifySeedCriteriaLinks({
+    goalId: GOAL,
+    expectedCounts: expectedCriterionCounts(criterionIdListsPerTask),
+    baseline,
+    fetchGoal: (gid) => api('GET', `/goals/${gid}`),
+  });
+}
+
+main().catch((e) => { console.error(e); process.exit(1); });