@bongos/core 1.19.550 → 1.19.551

package/migrations/core_232_task_merge_provenance.sql

@@ -0,0 +1,64 @@
+-- core_232_task_merge_provenance.sql — give a task-triage MERGE verdict
+-- somewhere to record what it decided (task 1001478).
+--
+-- Bugs now land directly as kind=bug tasks with no triage gate (task 1003071),
+-- so near-duplicate bug reports accumulate with nothing to record "this is the
+-- same report as #N". idea_inbox solved the identical problem for ideas in
+-- core_195 (`merged_into_idea_id` + `triage_note`); this is the same shape for
+-- `tasks`, reusing the SAME column names so a reader who knows one surface
+-- already knows the other.
+--
+-- Deliberately NOT a new `tasks.status` value. Adding `'merged'` to the status
+-- CHECK would touch every place that already enumerates task statuses
+-- (VOTABLE_TASK_STATUSES, the claimable feed, dependency satisfaction, the
+-- version-close gate, the diagrams generator's state machine) for a distinction
+-- that is really just "abandoned, and here is which task absorbed it". A merged
+-- task instead reuses the existing terminal `abandoned` status — it already
+-- means "retired, not shippable, dependents on it are stranded by owner ruling"
+-- (modules/lifecycle/CLAUDE.md), which is exactly what a merged-away duplicate
+-- is — and `merged_into_task_id` carries the one thing `abandoned` alone can't:
+-- which task is now the canonical one.
+--
+-- CORE, not modules/lifecycle/migrations/: `tasks` is a CORE table (created
+-- before the module system), and a module migration may only touch its own
+-- <key>_-prefixed objects — fitness.js checkModuleMigrationsAdditive hard-fails
+-- an `ALTER TABLE tasks` from a module (ADR 0083 Decision #5).
+--
+-- Two additive, nullable columns + an index. Forward-safe by construction:
+-- every existing reader SELECTs an explicit column list, so old code on the new
+-- schema neither sees nor needs these (tests/migrations_forward_safe.mjs).
+
+BEGIN;
+
+ALTER TABLE tasks
+  ADD COLUMN IF NOT EXISTS merged_into_task_id bigint REFERENCES tasks(id);
+
+ALTER TABLE tasks
+  ADD COLUMN IF NOT EXISTS triage_note text;
+
+-- A target exists IFF the task is abandoned. Mirrors idea_inbox's
+-- merge_target_needs_merged_status guard (core_195) one status value later:
+-- 'abandoned' is where a normal (non-merge) retirement already lands, so this
+-- CHECK only rules out the shape a merge target with a still-live task behind
+-- it would produce — never a normal abandon, which sets no target at all.
+DO $$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM pg_constraint
+     WHERE conrelid = 'tasks'::regclass
+       AND conname = 'tasks_merge_target_needs_abandoned_status'
+  ) THEN
+    ALTER TABLE tasks
+      ADD CONSTRAINT tasks_merge_target_needs_abandoned_status
+      CHECK (merged_into_task_id IS NULL OR status = 'abandoned');
+  END IF;
+END $$;
+
+CREATE INDEX IF NOT EXISTS tasks_merged_into_task_id_idx
+  ON tasks (merged_into_task_id)
+  WHERE merged_into_task_id IS NOT NULL;
+
+INSERT INTO schema_migrations (version) VALUES ('core_232_task_merge_provenance')
+  ON CONFLICT DO NOTHING;
+
+COMMIT;

package/modules/dev-box/app/src/vendor/bongos-client.cjs

@@ -848,6 +848,8 @@ function createClient(opts = {}) {
       deleteTasksIdDependenciesDepId: (args) => request("DELETE", "/tasks/{id}/dependencies/{depId}", { hasBody: false }, args),
       // POST /tasks/{id}/grade — rank: any-builder — POST /tasks/:id/grade
       postTasksIdGrade: (args) => request("POST", "/tasks/{id}/grade", { hasBody: true }, args),
+      // POST /tasks/{id}/merge — rank: metic+archon — POST /tasks/:id/merge
+      postTasksIdMerge: (args) => request("POST", "/tasks/{id}/merge", { hasBody: true }, args),
       // POST /tasks/{id}/override-request — rank: any-builder — POST /tasks/:id/override-request
       postTasksIdOverrideRequest: (args) => request("POST", "/tasks/{id}/override-request", { hasBody: true }, args),
       // POST /tasks/{id}/promote — rank: metic+archon — POST /tasks/:id/promote

package/modules/government/catalog.js

@@ -137,6 +137,7 @@ const PERMISSIONS = [
   { key: 'task.promote', system: false, floor: 'metic', guards: 'POST /tasks/:id/promote' },
   { key: 'task.demote', system: false, floor: 'metic', guards: 'POST /tasks/:id/demote' },
   { key: 'task.abandon', system: false, floor: 'metic', guards: 'POST /tasks/:id/abandon — scope removal; undo = POST /tasks/:id/promote (ADR 0152, was archon)' },
+  { key: 'task.merge', system: false, floor: 'metic', guards: 'POST /tasks/:id/merge — mark a duplicate task merged into another (task 1001478, the idea.triage merge analogue)' },
   { key: 'task.vote', system: false, floor: 'metic', guards: 'POST /tasks/:id/vote' },
   { key: 'task.dependency.manage', system: false, floor: 'metic', guards: 'POST|PUT|DELETE /tasks/:id/dependencies (same-tier)' },
   { key: 'task.criterion.manage', system: false, floor: 'metic', guards: 'POST|DELETE /tasks/:id/criteria' },

package/modules/government/migrations/government_011_task_merge_metic.sql

@@ -0,0 +1,38 @@
+-- government_011_task_merge_metic.sql — grant the new `task.merge` atom to the
+-- Metic and Archon rank-roles (task 1001478).
+--
+-- A BRAND-NEW key: no rank holds it yet, so BOTH rungs the floor implies are
+-- granted here. RANK_SEED is a cumulative superset — floor `metic` means
+-- {metic, archon} — and the drift guard (tests/government_seed.mjs) compares
+-- the UNION of the run-once seed plus every later grant migration against
+-- that floor-derived seed, per rank. Minting the catalog row WITHOUT this
+-- migration is exactly what that guard catches.
+--
+-- Mirrors government_010_project_settings_manage.sql, NOT a `governance_*`
+-- file — those predate government_001_rename_from_governance, which renamed
+-- `governance_role_permissions` -> `government_rank_permissions` and
+-- `role_key` -> `rank_key` with no compatibility shim.
+--
+-- Additive only: one new permission key granted to two ranks; nothing is
+-- revoked. Idempotent (ON CONFLICT DO NOTHING); forward-safe (INSERT only).
+--
+-- One block PER RANK, in the government_004/009/010 shape: the drift guard
+-- scans for `SELECT '<rank>', unnest(ARRAY[…])` literally, so a combined
+-- `unnest(ARRAY['metic','archon']), 'key'` form parses as zero grants and
+-- reds it.
+
+BEGIN;
+
+INSERT INTO government_rank_permissions (rank_key, permission_key)
+SELECT 'metic', unnest(ARRAY[
+  'task.merge'
+])
+ON CONFLICT (rank_key, permission_key) DO NOTHING;
+
+INSERT INTO government_rank_permissions (rank_key, permission_key)
+SELECT 'archon', unnest(ARRAY[
+  'task.merge'
+])
+ON CONFLICT (rank_key, permission_key) DO NOTHING;
+
+COMMIT;

package/modules/lifecycle/db-ship.js

@@ -963,9 +963,22 @@ async function restoreTask({ taskId }, deps = {}) {
       throw Object.assign(new Error('task is not abandoned'), { code: 'TASK_NOT_ABANDONED' });
     }
 
+    // Clearing merged_into_task_id/triage_note here is not cosmetic — it is
+    // what keeps this UPDATE legal. core_232's CHECK is
+    // `merged_into_task_id IS NULL OR status = 'abandoned'`, and this UPDATE
+    // sets status = 'backlog', so a restore that left a stale target would
+    // 23514 (constraint violation) on exactly the merged tasks this route
+    // exists to un-merge — mergeTask's own header names "retarget by
+    // restoring first" as the intended path, so restore must actually work
+    // on one (task 1001478 grade finding). value_summary is left alone here
+    // beyond the existing 'Abandoned: %' stamp: mergeTask PRESERVES whatever
+    // value_summary a task already had unless a human reason overwrote it, so
+    // there is no mechanical merge-default text to clean up on the way back.
     const { rows: updated } = await client.query(
       `UPDATE tasks
           SET status = 'backlog',
+              merged_into_task_id = NULL,
+              triage_note = NULL,
               value_summary = CASE WHEN value_summary LIKE 'Abandoned: %' THEN NULL ELSE value_summary END,
               updated_at = now()
         WHERE id = $1
@@ -988,7 +1001,141 @@ async function restoreTask({ taskId }, deps = {}) {
   }
 }
 
+// mergeTask (task 1001478) — the idea_inbox merge verdict's twin for `tasks`,
+// so /bug-triage can fold a near-duplicate kind=bug report into its canonical
+// task the same way /idea-triage folds a duplicate idea (modules/ideas/inbox.js
+// updateIdea's MERGE_SELF/MERGE_TARGET_NOT_FOUND/MERGE_TARGET_MERGED guards).
+//
+// A merge is `abandonTask` with a target attached, not a new status: 'merged'
+// would need its own line in every place that already enumerates task statuses
+// (VOTABLE_TASK_STATUSES, the claimable feed, dependency satisfaction, the
+// diagrams state machine) to answer a question 'abandoned' already answers —
+// this task is retired, its dependents are stranded by owner ruling
+// (see this file's CLAUDE.md). `merged_into_task_id` (core_232) carries the one
+// thing bare abandon can't: which task absorbed it.
+//
+// Guards, checked in this order (mirrors abandonTask, then layers the merge
+// checks on top):
+//   - MERGE_SELF            — a task cannot merge into itself.
+//   - TASK_NOT_FOUND         — the task being merged away doesn't exist.
+//   - CANNOT_MERGE_SHIPPED   — shipped work is immutable history (abandonTask's
+//                              CANNOT_ABANDON_SHIPPED, same reasoning).
+//   - already merged, SAME target  → idempotent no-op (alreadyMerged:true).
+//   - already merged, DIFFERENT target → ALREADY_MERGED (no re-merge chains —
+//     retarget by restoring first, the abandon/restore precedent, not a second
+//     merge call silently overwriting provenance).
+//   - TASK_HAS_ACTIVE_CLAIM  — a live claim means a session still owns the
+//                              work; release it first (same as abandonTask).
+//   - MERGE_TARGET_NOT_FOUND — the canonical task doesn't exist.
+//   - MERGE_TARGET_MERGED    — the target is ITSELF merged elsewhere (tests the
+//                              target's own `merged_into_task_id` column, not
+//                              its status — the idea precedent's "no chains"
+//                              check reads the column because a status-based
+//                              check can be raced by an ordinary PATCH).
+//
+// The target's own status is deliberately UNCHECKED beyond that — a duplicate
+// bug report can legitimately point at a task that already shipped (the fix
+// landed before the dup was noticed), mirroring idea merge's target-status
+// silence.
+//
+// #538 test seam: a caller-supplied pool is honored ONLY under NODE_ENV==='test'
+// (matches abandonTask/restoreTask).
+async function mergeTask({ taskId, intoTaskId, reason }, deps = {}) {
+  const activePool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : pool;
+  const client = await activePool.connect();
+  try {
+    await client.query('BEGIN');
+
+    if (String(intoTaskId) === String(taskId)) {
+      throw Object.assign(new Error('a task cannot merge into itself'), { code: 'MERGE_SELF' });
+    }
+
+    const { rows: taskRows } = await client.query(
+      `SELECT id, title, status, merged_into_task_id FROM tasks WHERE id = $1 FOR UPDATE`,
+      [taskId]
+    );
+    if (taskRows.length === 0) {
+      throw Object.assign(new Error('task not found'), { code: 'TASK_NOT_FOUND' });
+    }
+    const task = taskRows[0];
+    if (task.status === 'shipped') {
+      throw Object.assign(new Error('cannot merge a shipped task'), { code: 'CANNOT_MERGE_SHIPPED' });
+    }
+    if (task.merged_into_task_id != null) {
+      if (String(task.merged_into_task_id) === String(intoTaskId)) {
+        await client.query('COMMIT');
+        return {
+          taskId, taskTitle: task.title, taskStatus: 'abandoned',
+          mergedIntoTaskId: Number(task.merged_into_task_id), alreadyMerged: true,
+        };
+      }
+      throw Object.assign(
+        new Error('task is already merged into a different task'),
+        { code: 'ALREADY_MERGED', merged_into: String(task.merged_into_task_id) }
+      );
+    }
+
+    const { rows: activeClaims } = await client.query(
+      `SELECT id FROM claims WHERE task_id = $1 AND released_at IS NULL LIMIT 1`,
+      [taskId]
+    );
+    if (activeClaims.length > 0) {
+      throw Object.assign(new Error('task has an active claim; release it first'), { code: 'TASK_HAS_ACTIVE_CLAIM' });
+    }
+
+    const { rows: targetRows } = await client.query(
+      `SELECT id, merged_into_task_id FROM tasks WHERE id = $1`,
+      [intoTaskId]
+    );
+    if (targetRows.length === 0) {
+      throw Object.assign(new Error('merge target task not found'), { code: 'MERGE_TARGET_NOT_FOUND' });
+    }
+    if (targetRows[0].merged_into_task_id != null) {
+      throw Object.assign(
+        new Error('merge target is itself merged into another task'),
+        { code: 'MERGE_TARGET_MERGED', merged_into: String(targetRows[0].merged_into_task_id) }
+      );
+    }
+
+    // value_summary PRESERVES on an empty reason, exactly like abandonTask's
+    // `COALESCE(NULLIF($2,''), value_summary)` — not a synthesized "Merged
+    // into #N" default. A `completed`/`confirmed` bug task can already carry
+    // a real value_summary (its own shipped-value sentence), and merging it
+    // with no explicit reason must not clobber that; `merged_into_task_id`
+    // is the queryable source of truth for where it went (grade finding,
+    // task 1001478 round 2).
+    const noteText = typeof reason === 'string' ? reason.trim().slice(0, 2000) : '';
+    const { rows: updated } = await client.query(
+      `UPDATE tasks
+          SET status = 'abandoned',
+              merged_into_task_id = $2,
+              triage_note = NULLIF($3, ''),
+              value_summary = COALESCE(NULLIF($3, ''), value_summary),
+              updated_at = now()
+        WHERE id = $1
+        RETURNING id, title, status`,
+      [taskId, intoTaskId, noteText]
+    );
+
+    await client.query('COMMIT');
+    return {
+      taskId,
+      taskTitle: updated[0].title,
+      taskStatus: 'abandoned',
+      previousStatus: task.status,
+      mergedIntoTaskId: Number(intoTaskId),
+      alreadyMerged: false,
+    };
+  } catch (err) {
+    await client.query('ROLLBACK').catch(() => {});
+    throw err;
+  } finally {
+    client.release();
+  }
+}
+
 module.exports = {
+  mergeTask,
   abandonTask,
   confirmTask,
   flagTaskNeedsRebase,

package/modules/lifecycle/db.js

@@ -173,6 +173,7 @@ const {
   getBuildersRoster,
   getClaimPublishedSha,
   listConfirmedTasksForReconcile,
+  mergeTask,
   needsRebaseTasksForBuilder,
   releaseClaimOnBehalf,
   resolveClaim,
@@ -320,6 +321,7 @@ module.exports = {
   confirmTask,
   abandonTask,
   restoreTask, // ADR 0152 — the abandoned→backlog undo that pairs with the Metic+ abandon grant
+  mergeTask, // task 1001478 — the idea_inbox merge verdict's twin for tasks (/bug-triage)
   applyGrade,
   shipTask,
   normalizeShipAssurance, SHIP_ASSURANCE_KINDS, // ADR 0184 — re-exported from ./ship-assurance

package/modules/lifecycle/routes/tasks.js

@@ -664,6 +664,48 @@ module.exports = function buildTasksRouter() {
     }
   });
 
+  // POST /tasks/:id/merge — mark a duplicate task merged into its canonical one
+  // (task 1001478 — the /bug-triage counterpart to idea_inbox's merge verdict).
+  // Implemented as `abandonTask` plus a target (db.mergeTask, db-ship.js) rather
+  // than a new `tasks.status` value — see that function's header for why. Refuses
+  // a self-merge, a shipped task, a task with an active claim, a target that
+  // doesn't exist, and a target that is itself merged elsewhere (no chains);
+  // idempotent when re-merging into the SAME target already recorded.
+  // rank: metic+archon — same floor as task.abandon, which this reuses under the
+  // hood; a Metic who may retire a task may also say which task it duplicates.
+  router.post('/tasks/:id/merge', auth.requireBuilder, auth.requirePermission('task.merge'), async (req, res) => {
+    if (validateOrRespond(req, res, {
+      into_task_id: { required: true, type: 'integer', min: 1 },
+      reason: { type: 'string' },  // free-text triage note (sliced to 2000 below)
+    })) return;
+    const id = parseId(req, res, { code: 'bad_task_id', positiveInt: true });
+    if (id === null) return;
+    const intoTaskId = req.body.into_task_id;
+    const reason = typeof req.body?.reason === 'string' ? req.body.reason.slice(0, 2000) : '';
+    try {
+      const result = await db.mergeTask({ taskId: id, intoTaskId, reason });
+      res.json({ ok: true, ...result });
+    } catch (err) {
+      if (err.code === 'MERGE_SELF') return res.fail('merge_self', { status: 400, message: 'a task cannot merge into itself' });
+      if (err.code === 'TASK_NOT_FOUND') return res.fail('task_not_found', 404);
+      if (err.code === 'CANNOT_MERGE_SHIPPED') {
+        return res.fail('cannot_merge_shipped', { status: 409, message: 'shipped tasks are immutable history' });
+      }
+      if (err.code === 'ALREADY_MERGED') {
+        return res.fail('already_merged', { status: 409, message: `already merged into #${err.merged_into}`, merged_into: err.merged_into });
+      }
+      if (err.code === 'TASK_HAS_ACTIVE_CLAIM') {
+        return res.fail('task_has_active_claim', { status: 409, message: 'release the active claim before merging' });
+      }
+      if (err.code === 'MERGE_TARGET_NOT_FOUND') return res.fail('merge_target_not_found', 404);
+      if (err.code === 'MERGE_TARGET_MERGED') {
+        return res.fail('merge_target_merged', { status: 409, message: `merge target is itself merged into #${err.merged_into}`, merged_into: err.merged_into });
+      }
+      log.error('[gds] POST /tasks/:id/merge', err);
+      res.fail('merge_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
   // ==== peer votes (V3.R25 #245) — criterion C2 karma signal sourcing =======
   // These three sit BEFORE the generic /tasks/:id-shaped routes that take a
   // numeric id, but Express keys on the literal path so /tasks/peer-votes/feed

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.550",
+  "version": "1.19.551",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.550",
+      "version": "1.19.551",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.550",
+  "version": "1.19.551",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",