@bongos/core 1.19.550 → 1.19.552

package/docs/api/openapi.json

@@ -15213,6 +15213,65 @@
         ]
       }
     },
+    "/tasks/{id}/merge": {
+      "post": {
+        "operationId": "post_tasks_id_merge",
+        "tags": [
+          "tasks"
+        ],
+        "summary": "POST /tasks/:id/merge",
+        "description": "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.\n\n**Rank:** `metic+archon` — Metic or Archon rank (review/triage powers).\n\n**Permissions:** `task.merge` (all required).",
+        "x-rank": "metic+archon",
+        "x-source": "modules/lifecycle/routes/tasks.js",
+        "x-permissions": [
+          "task.merge"
+        ],
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "Path parameter `id`."
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/PostTasksIdMergeRequest"
+              }
+            }
+          },
+          "x-validated": true
+        },
+        "responses": {
+          "200": {
+            "description": "Success."
+          },
+          "400": {
+            "$ref": "#/components/responses/ValidationFailed"
+          },
+          "401": {
+            "$ref": "#/components/responses/Unauthorized"
+          },
+          "403": {
+            "$ref": "#/components/responses/Forbidden"
+          },
+          "404": {
+            "$ref": "#/components/responses/NotFound"
+          }
+        },
+        "security": [
+          {
+            "builderSession": []
+          }
+        ]
+      }
+    },
     "/tasks/{id}/override-request": {
       "post": {
         "operationId": "post_tasks_id_override_request",
@@ -21790,6 +21849,22 @@
         },
         "additionalProperties": false
       },
+      "PostTasksIdMergeRequest": {
+        "type": "object",
+        "properties": {
+          "into_task_id": {
+            "type": "integer",
+            "minimum": 1
+          },
+          "reason": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "into_task_id"
+        ],
+        "additionalProperties": false
+      },
       "PostTasksIdOverrideRequestRequest": {
         "type": "object",
         "properties": {
@@ -22384,8 +22459,8 @@
       "description": "A required dependency/feature is not configured or is temporarily down."
     }
   },
-  "x-endpoint-count": 355,
-  "x-schema-count": 390,
+  "x-endpoint-count": 356,
+  "x-schema-count": 391,
   "x-undocumented-bodies": 9,
   "x-response-schemas": 265,
   "x-generated-by": "scripts/gds/gen-api-docs.js"

package/docs/api-reference.md

@@ -2,7 +2,7 @@
 
 # Bongos API reference
 
-> **Generated from the live route files** — the route file is authoritative. 355 endpoints across 58 route files.
+> **Generated from the live route files** — the route file is authoritative. 356 endpoints across 58 route files.
 > Machine-readable spec: [`docs/api/openapi.json`](api/openapi.json) (OpenAPI 3.1). Rendered docs site: **`/docs`** (e.g. `cloudbongos.com/docs`).
 
 Base path: `/api/bongos`. Ranks (enforced server-side, [ADR 0016](adr/<redacted>.md)): `public` < `any-builder` < `metic+archon` < `archon`.
@@ -581,7 +581,7 @@ Base path: `/api/bongos`. Ranks (enforced server-side, [ADR 0016](adr/<redacted>
 |---|---|---|---|---|
 | GET | `/api/bongos/task-visuals/:name` | `public` | — | the WIDEST path this route can take, declared honestly. |
 
-## `tasks` (31)
+## `tasks` (32)
 
 | Method | Path | Rank | Body | Description |
 |---|---|---|---|---|
@@ -601,6 +601,7 @@ Base path: `/api/bongos`. Ranks (enforced server-side, [ADR 0016](adr/<redacted>
 | PUT | `/api/bongos/tasks/:id/dependencies` | `metic+archon` | `depends_on_task_ids` | PUT /tasks/:id/dependencies — replace the full dep set. |
 | DELETE | `/api/bongos/tasks/:id/dependencies/:depId` | `metic+archon` | — | DELETE /tasks/:id/dependencies/:depId — removes the edge. |
 | POST | `/api/bongos/tasks/:id/grade` | `any-builder` | `subagent_output`, `signals`, `committed_files`, `diff_hash` | GDS-V3 task V3.R18 (task 209). |
+| POST | `/api/bongos/tasks/:id/merge` | `metic+archon` | `into_task_id`, `reason` | POST /tasks/:id/merge — mark a duplicate task merged into its canonical one (task 1001478 — the /bug-triage counterpart to idea_inbox's m… |
 | POST | `/api/bongos/tasks/:id/override-request` | `any-builder` | `rationale` | POST /tasks/:id/override-request — V3.R74 (task 293). |
 | POST | `/api/bongos/tasks/:id/promote` | `metic+archon` | — | backlog→ready promotion; scope mutation; ADR 0090 (was archon). |
 | POST | `/api/bongos/tasks/:id/publish-branch` | `any-builder` | `branch`, `head_sha`, `bundle_b64`, `value_summary` |  |

package/docs/file-map.md

@@ -375,6 +375,7 @@ tests/
 .claude/skills/
 ├── blocker-review/SKILL.md        ← /blocker-review — daily review of open GDS blockers (resolve / escalate / note); Metic+
 ├── blocker-solve/SKILL.md         ← /blocker-solve N — drive ONE blocker to done: do the doable parts, hand back owner-only steps, verify, auto-resolve (auto-promotes waiters); Metic+
+├── bug-triage/SKILL.md            ← /bug-triage — daily walk through open kind=bug tasks (batch-cluster near-dups, merge / won't-fix); the idea-triage counterpart built on the new tasks.merge primitive (task 1001478); Metic+
 ├── builder-backup/SKILL.md        ← /builder-backup — check DB backup status or trigger a fresh local dump before risky changes (migrations, destructive SQL); no SSH required
 ├── builder-box/SKILL.md           ← /builder-box — show the builder their own dev box (state, IP/host, cost, SSH keys) and help them (re)connect
 ├── builder-claim/SKILL.md         ← /builder-claim N — atomic claim; prints the claim-time context pack + discipline playbook routing

package/docs/module-api-changelog.md

@@ -1549,5 +1549,9 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.548 with no explicit bump. run 33906859934. (task 1002620)
   1.19.550 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.549 with no explicit bump. run 33907331050. (task 1002620)
+  1.19.551 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.550 with no explicit bump. run 33917261720. (task 1002620)
+  1.19.552 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.551 with no explicit bump. run 34043771286. (task 1002620)
 ---------------------------------------------------------------------------
 ```

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-goals.js

@@ -14,6 +14,7 @@ const api = require('../../src/module-api');
 const { pool } = api;
 const doneWhen = require('./done-when.js');
 const { deriveRequiredRank, highestRank } = require('./db-rank-authz.js');
+const { nonTerminalSql } = require('./task-status');
 
 // -------------------------------------------------------------------------
 // Goals (ADR 0086 §2 / BV1.R56 — task 1510)
@@ -328,7 +329,7 @@ async function listCriteriaForGoal(goalId, deps = {}) {
               -- task 1002651 (migration 017's family): abandoned is a terminal
               -- state (deliberately cut), not pending work — it must not hold a
               -- criterion's "met — pending review" flip hostage forever.
-              count(*) FILTER (WHERE t.status NOT IN ('shipped', 'abandoned'))::int AS unshipped_tasks
+              count(*) FILTER (WHERE ${nonTerminalSql()})::int AS unshipped_tasks
          FROM task_criteria tc
          JOIN tasks t ON t.id = tc.task_id
         WHERE tc.criterion_id IN (SELECT id FROM crit)

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/done-when.js

@@ -24,6 +24,7 @@
 //   POST /api/gds/done-when/:criterionId/unsatisfy      — auth
 
 const { pool } = require('../../src/module-api');
+const { nonTerminalSql } = require('./task-status');
 
 // isPendingReview — the ONE derivation of the "met — pending review" auto-flag
 // (ADR 0086 §6 / BV1.R63): a criterion with >=1 linked task, every one shipped,
@@ -134,7 +135,7 @@ async function listPendingReviewCriteria({ versionId = null } = {}, deps = {}) {
          JOIN tasks t          ON t.id = tc.task_id
         WHERE c.satisfied = false
         GROUP BY c.id
-       HAVING count(*) FILTER (WHERE t.status NOT IN ('shipped', 'abandoned')) = 0
+       HAVING count(*) FILTER (WHERE ${nonTerminalSql()}) = 0
      ),
      goal_unsat AS (
        SELECT goal_id, count(*)::int AS unsatisfied
@@ -426,7 +427,7 @@ async function autoSatisfyShippedCriteria(exec, { taskId = null } = {}) {
           AND ($1::bigint IS NULL OR c.id IN (
                 SELECT criterion_id FROM task_criteria WHERE task_id = $1::bigint))
         GROUP BY c.id
-       HAVING count(*) FILTER (WHERE t.status NOT IN ('shipped', 'abandoned')) = 0
+       HAVING count(*) FILTER (WHERE ${nonTerminalSql()}) = 0
           AND count(*) FILTER (WHERE t.status = 'shipped') >= 1
      )
      UPDATE done_when_criteria c

package/modules/lifecycle/goal-rollup.js

@@ -32,10 +32,12 @@
 const api = require('../../src/module-api');
 const { pool } = api;
 
-// The status vocabularies, kept beside the SQL that uses them so a reader can
-// check them against goals-lib.js in one glance.
-const DONE_STATUSES = ['shipped', 'confirmed', 'completed'];
-const CUT_STATUSES = ['abandoned', 'dropped'];
+// The status vocabularies live in task-status.js (task 1003588) so this module
+// has ONE spelling of each. These two are the PRESENTATIONAL buckets — they
+// mirror goals-lib.js `readinessOf`, and they are NOT the terminal set: `done`
+// here includes the mid-ship states on purpose, which is right for a progress
+// ring and wrong for any question about whether a goal may close.
+const { DONE_STATUSES, CUT_STATUSES } = require('./task-status');
 
 // goalRollups — one row per goal that has at least one task in `versionId`.
 // Returns [{ goal_id, done, active, ready, blocked, backlog, cut, total,

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/modules/lifecycle/task-status.js

@@ -0,0 +1,72 @@
+'use strict';
+
+// modules/lifecycle/task-status.js — the task-status vocabulary, declared once
+// (task 1003588, goal 1000086, criterion sv-goal-outlives-nothing).
+//
+// WHY THIS FILE EXISTS. "Finished" had two spellings inside one module.
+// `goal-rollup.js` counted shipped|confirmed|completed as done; `done-when.js`
+// counted only shipped and treated abandoned as accounted-for; `db-goals.js`,
+// `version-close.js` and the `sequence` CLI each re-typed the SQL literal
+// `NOT IN ('shipped', 'abandoned')` by hand. Two definitions of finished in one
+// module is precisely what lets a goal read closed on one surface and open on
+// another — the failure goal 1000086 exists to make impossible. So the
+// vocabulary is declared here, once, and every consumer reads it.
+//
+// THE TWO SETS ARE NOT THE SAME QUESTION, and conflating them is the bug in the
+// other direction:
+//
+//   TERMINAL_STATUSES — the LEDGER truth. A task is finished with the project
+//     when it shipped or was deliberately abandoned. Nothing else is terminal:
+//     `completed` and `confirmed` are mid-ship states that can still fail a
+//     grade or strand, so work sitting in them is unfinished work and must hold
+//     its goal open. This is the set the closure invariants read.
+//
+//   DONE_STATUSES / CUT_STATUSES — a PRESENTATIONAL bucketing for the goals
+//     board, mirroring the client's `goals-lib.js readinessOf` verbatim (a
+//     divergence shows a person different numbers per surface, which
+//     tests/goal_sort_staleness.mjs pins). "Done" there means "no longer in the
+//     queue", which deliberately includes the mid-ship states. It is a progress
+//     ring, not a ledger, and must never be used to decide whether a goal may
+//     close.
+//
+// NO DEPENDENCIES, deliberately. This file requires nothing — not even
+// `module-api` — so a CLI (`scripts/gds/sequence.js`) can read the vocabulary
+// without dragging the server's `db.js` and its connection pool into a process
+// that only needs a Set of two strings.
+
+// TERMINAL_STATUSES — the only spelling of "this task is finished with the
+// project". shipped = delivered; abandoned = deliberately cut (task 1002651,
+// migration 017's family). Everything else holds work open.
+const TERMINAL_STATUSES = ['shipped', 'abandoned'];
+
+// TERMINAL_STATUS_SET — the same set for JS membership tests.
+const TERMINAL_STATUS_SET = new Set(TERMINAL_STATUSES);
+
+// isTerminalStatus — true when a task in this status is finished with the
+// project and can no longer hold a criterion, a goal, or a version open.
+function isTerminalStatus(status) {
+  return TERMINAL_STATUS_SET.has(status);
+}
+
+// nonTerminalSql — the SQL predicate for "this task is still unfinished",
+// rendered from TERMINAL_STATUSES so the literal exists in exactly one place.
+// `column` is the status expression in the caller's query (`t.status` under a
+// join, bare `status` in a single-table read). Output is the byte-identical
+// `<column> NOT IN ('shipped', 'abandoned')` every call site used to hardcode.
+function nonTerminalSql(column = 't.status') {
+  return `${column} NOT IN (${TERMINAL_STATUSES.map((s) => `'${s}'`).join(', ')})`;
+}
+
+// DONE_STATUSES / CUT_STATUSES — the goals-board buckets. Presentational only;
+// see the header. Mirrors goals-lib.js `readinessOf`.
+const DONE_STATUSES = ['shipped', 'confirmed', 'completed'];
+const CUT_STATUSES = ['abandoned', 'dropped'];
+
+module.exports = {
+  TERMINAL_STATUSES,
+  TERMINAL_STATUS_SET,
+  isTerminalStatus,
+  nonTerminalSql,
+  DONE_STATUSES,
+  CUT_STATUSES,
+};