@bongos/core 1.23.21 → 1.24.1

package/tests/fixtures/per-row-loops-legacy.cjs

@@ -0,0 +1,245 @@
+'use strict';
+
+// tests/fixtures/per-row-loops-legacy.cjs — the FOUR one-query-per-row loops as
+// they stood before task 1004929 batched them, kept verbatim (comments trimmed)
+// so tests/batched_writes_parity.mjs and tests/government_routes.mjs can run the
+// old and the new code over the same fake database and compare what each one
+// returns and leaves behind. A frozen reference, not live code: nothing in src/
+// or modules/ may require it.
+
+const { nonTerminalSql, isTerminalStatus } = require('../../modules/lifecycle/task-status');
+const { cancelPendingMembershipRequests } = require('../../modules/lifecycle/goal-close-sweep.js');
+
+// modules/government/routes/government.js — POST /government/rank-sets/apply,
+// the try-block body. `db` is the government db slice, `rankSet` the
+// recommendedRankSet output. Returns { created, skipped } as the reply carried.
+async function legacyApplyRankSet({ db, catalog, rankSet, builderId }) {
+  const set = rankSet;
+  const created = [];
+  const skipped = [];
+  for (const r of set.ranks) {
+    if (await db.getRankByKey(r.rank_key)) { skipped.push({ rank_key: r.rank_key, label: r.label }); continue; }
+    let rank;
+    try {
+      rank = await db.createRank({ rankKey: r.rank_key, label: r.label, description: r.description, createdBy: builderId });
+    } catch (err) {
+      if (err && err.code === '23505') { skipped.push({ rank_key: r.rank_key, label: r.label }); continue; }
+      throw err;
+    }
+    const granted = [];
+    for (const key of r.permissions) {
+      if (!catalog.byKey(key) || !catalog.isGrantableTo(key, rank)) continue;
+      if (await db.grantRankPermission({ rankKey: r.rank_key, permissionKey: key })) granted.push(key);
+    }
+    created.push({ rank_key: r.rank_key, label: r.label, permissions: granted });
+  }
+  return { created, skipped };
+}
+
+// modules/lifecycle/db-goals.js — archiveGoalWithDispositions, the plan loop.
+// Runs on an open client (the caller has already locked the goal). Returns the
+// applied list, or throws what the loop threw.
+async function legacyArchiveLoop(client, { goalId, plan = [], reason }) {
+  const applied = [];
+  for (const step of plan) {
+    const { rows: tRows } = await client.query(
+      `SELECT id, title, status FROM tasks WHERE id = $1 AND goal_id = $2 FOR UPDATE`,
+      [step.taskId, goalId]
+    );
+    if (!tRows[0]) { applied.push({ task_id: String(step.taskId), verb: step.verb, result: 'skipped_not_in_goal' }); continue; }
+    if (isTerminalStatus(tRows[0].status)) {
+      applied.push({ task_id: String(step.taskId), verb: step.verb, result: 'skipped_already_terminal', status: tRows[0].status });
+      continue;
+    }
+
+    const { rows: claimed } = await client.query(
+      `SELECT id FROM claims WHERE task_id = $1 AND released_at IS NULL LIMIT 1`, [step.taskId]
+    );
+    if (claimed[0]) {
+      throw Object.assign(new Error('task has an active claim'), {
+        code: 'TASK_HAS_ACTIVE_CLAIM', taskId: String(step.taskId), taskTitle: tRows[0].title,
+      });
+    }
+
+    if (step.verb === 'abandon') {
+      await client.query(
+        `UPDATE tasks SET status = 'abandoned',
+                          value_summary = COALESCE(NULLIF($2, ''), value_summary),
+                          updated_at = now()
+          WHERE id = $1`,
+        [step.taskId, `Abandoned: ${reason}`]
+      );
+      applied.push({ task_id: String(step.taskId), verb: 'abandon', result: 'abandoned' });
+    } else {
+      const { rows: dest } = await client.query(
+        `SELECT id, status FROM goals WHERE id = $1 FOR SHARE`, [step.toGoalId]
+      );
+      if (!dest[0]) {
+        throw Object.assign(new Error('move target not found'), { code: 'MOVE_TARGET_NOT_FOUND', toGoalId: String(step.toGoalId) });
+      }
+      if (dest[0].status !== 'open') {
+        throw Object.assign(new Error('move target is not open'), {
+          code: 'MOVE_TARGET_NOT_OPEN', toGoalId: String(step.toGoalId), targetStatus: dest[0].status,
+        });
+      }
+      await client.query(`UPDATE tasks SET goal_id = $2, updated_at = now() WHERE id = $1`, [step.taskId, step.toGoalId]);
+      applied.push({ task_id: String(step.taskId), verb: 'move', result: 'moved', to_goal_id: String(step.toGoalId) });
+    }
+  }
+  return applied;
+}
+
+// modules/lifecycle/db-versions.js — closeVersion, the plan loop. Same contract.
+async function legacyCloseLoop(client, { versionId, plan = [], reason, planningVersionId = null }) {
+  const applied = [];
+  for (const step of plan) {
+    const { rows: gRows } = await client.query(
+      `SELECT id, title, status FROM goals WHERE id = $1 AND version_id = $2 FOR UPDATE`,
+      [step.goalId, versionId]
+    );
+    if (!gRows[0]) { applied.push({ goal_id: String(step.goalId), verb: step.verb, result: 'skipped_not_on_version' }); continue; }
+    if (gRows[0].status !== 'open') {
+      applied.push({ goal_id: String(step.goalId), verb: step.verb, result: 'skipped_already_closed', status: gRows[0].status });
+      continue;
+    }
+
+    if (step.verb === 'abandon') {
+      const { rows: killed } = await client.query(
+        `UPDATE tasks SET status = 'abandoned',
+                          value_summary = COALESCE(NULLIF($2, ''), value_summary),
+                          updated_at = now()
+          WHERE goal_id = $1 AND ${nonTerminalSql('status')}
+            AND title NOT LIKE '\\_\\_smoke\\_\\_%' ESCAPE '\\'
+          RETURNING id`,
+        [step.goalId, `Abandoned: ${reason}`]
+      );
+      await client.query(`UPDATE goals SET status = 'archived', updated_at = now() WHERE id = $1`, [step.goalId]);
+      await cancelPendingMembershipRequests(client, step.goalId);
+      applied.push({ goal_id: String(step.goalId), verb: 'abandon', result: 'archived', tasks_abandoned: killed.length });
+    } else {
+      if (!planningVersionId) {
+        throw Object.assign(new Error('roll_forward with no planning version'), {
+          code: 'NO_PLANNING_VERSION', goalId: String(step.goalId),
+        });
+      }
+      const { rows: made } = await client.query(
+        `WITH next_order AS (
+           SELECT COALESCE(MAX(sort_order) + 1, 0) AS n FROM goals WHERE version_id = $2
+         )
+         INSERT INTO goals (version_id, title, subtitle, description, scope_modules,
+                            status, visibility, accepting_requests, created_by, sort_order, category_id, working_area)
+         SELECT $2, g.title, g.subtitle, g.description, g.scope_modules,
+                'open', g.visibility, g.accepting_requests, g.created_by, next_order.n, g.category_id, g.working_area
+           FROM goals g, next_order
+          WHERE g.id = $1
+         RETURNING id`,
+        [step.goalId, planningVersionId]
+      );
+      const successorId = made[0].id;
+
+      await client.query(
+        `INSERT INTO goal_members (goal_id, builder_id, membership_kind)
+         SELECT $2, builder_id, membership_kind FROM goal_members WHERE goal_id = $1
+         ON CONFLICT DO NOTHING`,
+        [step.goalId, successorId]
+      );
+
+      const { rows: moved } = await client.query(
+        `UPDATE tasks SET goal_id = $2, version_id = $3, updated_at = now()
+          WHERE goal_id = $1 AND ${nonTerminalSql('status')}
+            AND title NOT LIKE '\\_\\_smoke\\_\\_%' ESCAPE '\\'
+          RETURNING id`,
+        [step.goalId, successorId, planningVersionId]
+      );
+
+      await client.query(
+        `UPDATE goals SET succeeded_by_goal_id = $2, updated_at = now() WHERE id = $1`,
+        [step.goalId, successorId]
+      );
+      await client.query(`UPDATE goals SET status = 'archived', updated_at = now() WHERE id = $1`, [step.goalId]);
+      await cancelPendingMembershipRequests(client, step.goalId);
+
+      applied.push({
+        goal_id: String(step.goalId), verb: 'roll_forward', result: 'succeeded',
+        successor_goal_id: String(successorId), tasks_moved: moved.length,
+      });
+    }
+  }
+  return applied;
+}
+
+// modules/lifecycle/db-analytics.js — tallyPeerVotes, the whole function, with
+// the transaction primitive passed in (it was api.withTx).
+const PEER_VOTE_KARMA_LAG_DAYS = 7;
+async function legacyTallyPeerVotes(withTx) {
+  return withTx(async (client) => {
+    const { rows: matured } = await client.query(
+      `SELECT pv.id, t.shipped_by AS builder_id, pv.vote
+         FROM peer_votes pv
+         JOIN tasks t ON t.id = pv.target_task_id
+        WHERE pv.tallied_at IS NULL
+          AND pv.recorded_at <= now() - ($1::int * interval '1 day')
+          AND t.shipped_by IS NOT NULL
+        FOR UPDATE OF pv`,
+      [PEER_VOTE_KARMA_LAG_DAYS]
+    );
+    const netByBuilder = new Map();
+    const voteIds = [];
+    for (const r of matured) {
+      voteIds.push(r.id);
+      netByBuilder.set(r.builder_id, (netByBuilder.get(r.builder_id) || 0) + r.vote);
+    }
+    const ideaVoteIds = [];
+    const { rows: [{ has: hasIdeaVotes }] } = await client.query(
+      `SELECT to_regclass('ideas_votes') IS NOT NULL AS has`
+    );
+    if (hasIdeaVotes) {
+      const { rows: maturedIdeas } = await client.query(
+        `SELECT iv.id, i.captured_by AS builder_id, iv.vote
+           FROM ideas_votes iv
+           JOIN idea_inbox i ON i.id = iv.target_idea_id
+          WHERE iv.tallied_at IS NULL
+            AND iv.recorded_at <= now() - ($1::int * interval '1 day')
+            AND i.captured_by IS NOT NULL
+          FOR UPDATE OF iv`,
+        [PEER_VOTE_KARMA_LAG_DAYS]
+      );
+      for (const r of maturedIdeas) {
+        ideaVoteIds.push(r.id);
+        netByBuilder.set(r.builder_id, (netByBuilder.get(r.builder_id) || 0) + r.vote);
+      }
+    }
+    const karmaRows = [];
+    for (const [builderId, net] of netByBuilder) {
+      if (net === 0) continue;
+      await client.query(
+        `INSERT INTO karma_log (builder_id, delta, reason, granted_by)
+         VALUES ($1, $2, 'peer_vote_weekly', NULL)`,
+        [builderId, net]
+      );
+      karmaRows.push({ builder_id: builderId, delta: net });
+    }
+    if (voteIds.length) {
+      await client.query(
+        `UPDATE peer_votes SET tallied_at = now() WHERE id = ANY($1::bigint[])`,
+        [voteIds]
+      );
+    }
+    if (ideaVoteIds.length) {
+      await client.query(
+        `UPDATE ideas_votes SET tallied_at = now() WHERE id = ANY($1::bigint[])`,
+        [ideaVoteIds]
+      );
+    }
+    return {
+      ok: true,
+      votes_tallied: voteIds.length + ideaVoteIds.length,
+      idea_votes_tallied: ideaVoteIds.length,
+      builders_credited: karmaRows.length,
+      karma: karmaRows,
+      lag_days: PEER_VOTE_KARMA_LAG_DAYS,
+    };
+  });
+}
+
+module.exports = { legacyApplyRankSet, legacyArchiveLoop, legacyCloseLoop, legacyTallyPeerVotes };

package/tests/fixtures/seed-tasks/bongos-v1-idea-routing.json

@@ -0,0 +1,256 @@
+{
+  "_comment": "Historical seed, already run: goal 1000071 (BONGOS-V1), from seed-bongos-v1-idea-routing-tasks.js; spec docs/specs/bongos-v1-idea-routing.md. Kept as the equivalence fixture for tests/seed_tasks.mjs (task 1004979).",
+  "version_id": "BONGOS-V1",
+  "goal_id": 1000071,
+  "source": "planning-session",
+  "source_ref_prefix": "bongos-v1-idea-routing",
+  "tasks": [
+    {
+      "ref": "R02",
+      "title": "R02 · Schema: idea_inbox.suggested_goal_id + lineage origin 'route'",
+      "description": "Core migration: nullable suggested_goal_id FK on idea_inbox (routing hint for soft-landed/Discord/homeless ideas). Module migration (ideas_*): extend ideas_task_lineage.origin CHECK with 'route'. See docs/specs/bongos-v1-idea-routing.md.",
+      "kind": "infra",
+      "discipline": "engineer",
+      "priority": 5,
+      "est_minutes": 90,
+      "criterion_ids": [
+        "bug-lands-in-its-goal",
+        "no-route-loses-the-author"
+      ]
+    },
+    {
+      "ref": "R03",
+      "title": "R03 · Catch-all fallback never resolves to a non-building version",
+      "description": "generalGoalIdForVersion (modules/lifecycle/db.js:1343) + the null-goal fallback (:1414): a task create must never land in a shipped/frozen version's catch-all goal (the 1000771 failure shape). Routed creates with no goal go to the inbox instead. Done-when: test proves a create against a shipped version cannot resolve a catch-all.",
+      "kind": "bug",
+      "discipline": "engineer",
+      "priority": 5,
+      "est_minutes": 90,
+      "criterion_ids": [
+        "bug-lands-in-its-goal"
+      ]
+    },
+    {
+      "ref": "R07",
+      "title": "R07 · Capture-time goal suggester (advisory consulted BEFORE creation)",
+      "description": "Expose candidate goals for a draft capture — reuse buildGoalAdvisory's candidate logic (modules/lifecycle/goal-advisory.js:89) as a pre-creation read (e.g. GET /inbox/goal-suggestions?title=&kind=&version=). Feeds the hall picker (R08), CLI (R09), and Discord suggestion (R11). Done-when: candidates returned for a draft title/kind without creating anything.",
+      "kind": "feature",
+      "discipline": "engineer",
+      "priority": 5,
+      "est_minutes": 120,
+      "criterion_ids": [
+        "system-offers-the-home"
+      ]
+    },
+    {
+      "ref": "R10",
+      "title": "R10 · Hall move-a-task-to-goal affordance",
+      "description": "PATCH /tasks/:id {goal_id} (task 1763) exists but has no hall UI. Add move-to-goal on the task overlay (Metic+, task.edit) so a wrong routing pick is one reassignment, never a re-file. Done-when: a Metic+ moves a task between same-version goals from the hall.",
+      "kind": "feature",
+      "discipline": "ui",
+      "priority": 5,
+      "est_minutes": 120,
+      "criterion_ids": [
+        "system-offers-the-home"
+      ]
+    },
+    {
+      "ref": "R14",
+      "title": "R14 · ADR: idea routing — capture-time promotion, the landing matrix, the homeless-only inbox",
+      "description": "Write the ADR recording: routing mechanism is capture-time promotion (never inbox bypass — the Discord #bugs lesson), the landing matrix (bugs hard-land by rank; other kinds soft-land; Full Ideas/criterion-proposals/decisions never auto-route), and the inbox's new identity (holds only work without a home). Source: docs/specs/bongos-v1-idea-routing.md interview decisions.",
+      "kind": "decision",
+      "discipline": "engineer",
+      "priority": 5,
+      "est_minutes": 60,
+      "criterion_ids": [
+        "inbox-holds-only-homeless"
+      ]
+    },
+    {
+      "ref": "R01",
+      "title": "R01 · Capture-time routing core: POST /inbox accepts goal_id and converts in one transaction",
+      "description": "Extend inbox.captureIdea/route: when goal_id present and the landing matrix says route, one transaction writes the idea row (status=promoted, promoted_to_task_id), the task (in the goal, matrix-decided status), and ideas_task_lineage (origin=route). Validations: goal open + belongs to a building version; Full-grade and criterion-proposal/decision kinds never auto-route; goal-less capture behaves exactly as today. Deps R02.",
+      "kind": "feature",
+      "discipline": "engineer",
+      "priority": 5,
+      "est_minutes": 240,
+      "criterion_ids": [
+        "bug-lands-in-its-goal",
+        "no-route-loses-the-author"
+      ],
+      "deps": [
+        "R02"
+      ]
+    },
+    {
+      "ref": "R05",
+      "title": "R05 · Rank-aware landing: matrix enforcement server-side",
+      "description": "Metic+ filer's bug → status=ready; sub-Metic filer / any non-bug kind → backlog (awaiting any Metic+ promote via the existing task.promote, surfaced in the Needs-your-attention slice). Auto-derived requires_rank floors (ADR 0084) and the goal scope wall run on routed tasks exactly as on authored ones. Deps R01.",
+      "kind": "feature",
+      "discipline": "engineer",
+      "priority": 4,
+      "est_minutes": 150,
+      "criterion_ids": [
+        "filing-cannot-outrun-rank"
+      ],
+      "deps": [
+        "R01"
+      ]
+    },
+    {
+      "ref": "R11",
+      "title": "R11 · Discord #bugs retired onto the routing path",
+      "description": "Replace discord-bugs.js's direct createTask bypass (hardcoded GDS-V3 → goal 1000002 catch-all; destroys attribution) with capture-time routing: idea row + classifier-suggested goal (suggested_goal_id), soft-landing into the pending queue for a one-click Metic+ route. Unlinked authors still yield an attributable idea row (captured_by null). Closes inbox idea 1000771. Deps R01.",
+      "kind": "feature",
+      "discipline": "engineer",
+      "priority": 4,
+      "est_minutes": 180,
+      "criterion_ids": [
+        "bug-lands-in-its-goal",
+        "no-route-loses-the-author"
+      ],
+      "deps": [
+        "R01"
+      ]
+    },
+    {
+      "ref": "R12",
+      "title": "R12 · Discord #ideas carries routing hints",
+      "description": "The #ideas inbound (discord-inbound.js) files with no suggested_version at all today. Add: default suggested_version (most-recent building), classifier-suggested suggested_goal_id. Deps R02.",
+      "kind": "feature",
+      "discipline": "engineer",
+      "priority": 4,
+      "est_minutes": 120,
+      "criterion_ids": [
+        "system-offers-the-home"
+      ],
+      "deps": [
+        "R02"
+      ]
+    },
+    {
+      "ref": "R08",
+      "title": "R08 · Hall filing surface: file a bug/idea with a goal picker",
+      "description": "The hall has NO capture surface today (triage only). Add file-a-bug/idea: title, body, kind, goal picker fed by the suggester (R07); submits to POST /inbox with goal_id so goal-bound work routes at filing time. Grade capture untouched. Deps R01,R07.",
+      "kind": "feature",
+      "discipline": "ui",
+      "priority": 4,
+      "est_minutes": 240,
+      "criterion_ids": [
+        "bug-lands-in-its-goal",
+        "system-offers-the-home"
+      ],
+      "deps": [
+        "R01",
+        "R07"
+      ]
+    },
+    {
+      "ref": "R09",
+      "title": "R09 · CLI capture routing: --goal, suggester prompt, active-claim default",
+      "description": "capture.js gains --goal; when the builder holds a claim the suggested goal defaults to the claim's goal (interview decision 4); suggester candidates offered otherwise. Deps R01,R07.",
+      "kind": "feature",
+      "discipline": "engineer",
+      "priority": 4,
+      "est_minutes": 120,
+      "criterion_ids": [
+        "bug-lands-in-its-goal",
+        "system-offers-the-home"
+      ],
+      "deps": [
+        "R01",
+        "R07"
+      ]
+    },
+    {
+      "ref": "R13",
+      "title": "R13 · Promote path passes goal_id; /idea-triage goes homeless-only",
+      "description": "task-detail.js (:320) and triage.js (:160) finally send goal_id (suggester-fed default) so even triaged promotions land in a real goal; the /idea-triage skill doc is updated to the homeless-only contract. Deps R07.",
+      "kind": "feature",
+      "discipline": "engineer",
+      "priority": 4,
+      "est_minutes": 120,
+      "criterion_ids": [
+        "inbox-holds-only-homeless",
+        "triage-shrinks-to-judgment"
+      ],
+      "deps": [
+        "R07"
+      ]
+    },
+    {
+      "ref": "R04",
+      "title": "R04 · PROOF: attribution survives the route end-to-end",
+      "description": "A routed bug's task ships; sourceIdeaForTask returns the filer; ideas_task_lineage (origin=route) + captured_by intact — the trail goal 1000067's ideator credit will pay against (test). Deps R01.",
+      "kind": "verify",
+      "discipline": "engineer",
+      "priority": 3,
+      "est_minutes": 90,
+      "criterion_ids": [
+        "no-route-loses-the-author"
+      ],
+      "deps": [
+        "R01"
+      ]
+    },
+    {
+      "ref": "R06",
+      "title": "R06 · PROOF: abuse matrix — filing cannot escalate",
+      "description": "A Xenos mass-filing bugs never lands claimable work, never reaches protected scope, rate limits hold; a sub-Metic cannot reach ready via any capture vector (test suite). Deps R05.",
+      "kind": "verify",
+      "discipline": "engineer",
+      "priority": 3,
+      "est_minutes": 120,
+      "criterion_ids": [
+        "filing-cannot-outrun-rank"
+      ],
+      "deps": [
+        "R05"
+      ]
+    },
+    {
+      "ref": "R15",
+      "title": "R15 · PROOF: reclassification sweep of the open inbox",
+      "description": "Walk the open idea_inbox (~50 rows at planning time; 14 bugs) under the new rules: every goal-bound bug homed in a real goal; residual inbox is homeless-only; before/after counts recorded in this task's notes as the goal's measured evidence. Deps R01,R05,R13.",
+      "kind": "verify",
+      "discipline": "engineer",
+      "priority": 2,
+      "est_minutes": 120,
+      "criterion_ids": [
+        "inbox-holds-only-homeless",
+        "triage-shrinks-to-judgment"
+      ],
+      "deps": [
+        "R01",
+        "R05",
+        "R13"
+      ]
+    }
+  ],
+  "promote": [
+    "R02",
+    "R03",
+    "R07",
+    "R10",
+    "R14"
+  ],
+  "links": [
+    {
+      "method": "PATCH",
+      "path": "/inbox/1000771",
+      "body": {
+        "status": "promoted",
+        "promoted_to_task_id": {
+          "$task": "R11"
+        }
+      }
+    },
+    {
+      "method": "PATCH",
+      "path": "/tasks/1003059",
+      "body": {
+        "goal_id": 1000071
+      }
+    }
+  ]
+}