@bongos/core 1.19.1043 → 1.19.1044

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.1043",
-  "core_contract": "1.19.1043",
-  "source_commit": "a7f87df67be821c4552587a83313fdd13e3a3c17",
+  "core_version": "1.19.1044",
+  "core_contract": "1.19.1044",
+  "source_commit": "34b337286c8c548570070f55a237ae07ff128c22",
   "source_ref": "HEAD",
-  "built_at": "2026-09-26T17:20:34.417Z",
+  "built_at": "2026-09-26T17:54:25.223Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 543,
     "agent_docs_stubbed": 26,
-    "functional_verbatim": 2513,
+    "functional_verbatim": 2515,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 3083,
-  "tree_sha256": "a9b86c4c4e0acc27d6554d3d5ea4240bae592dde6b1edd0a2f070d422194ca1b",
+  "file_count": 3085,
+  "tree_sha256": "9e1fcf88474d43f87fc0192c0deed9eedbb6ba08ac68bcb3d432e3acdc7ee237",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -352,12 +352,12 @@
     {
       "path": "clients/bongos-client/README.md",
       "mode": "0000644",
-      "sha256": "7073eca28ea1e8ebab33e072c688c2b0e6cf82671849c8e7684a576796efc901"
+      "sha256": "1a52f7ad05de6ca7410e4899cfecba6821ead741bc437afcfdf9904baf2cb403"
     },
     {
       "path": "clients/bongos-client/bongos-client.global.js",
       "mode": "0000644",
-      "sha256": "48b9d83d0ee81e63d5a94be73a0cb505fac99fd9f049a45d0f28e15e112602b1"
+      "sha256": "7bbce7057aaad2ee184924e3f5cee7c7a543785c6f54a20bee82997b7825d27f"
     },
     {
       "path": "clients/bongos-client/examples/hello-world.mjs",
@@ -367,17 +367,17 @@
     {
       "path": "clients/bongos-client/index.cjs",
       "mode": "0000644",
-      "sha256": "0cd41f959d6b8b2e7be0f317fc1cfe0ef83d35f48338810d5d0bc73307226c74"
+      "sha256": "685b1eb0d4fac786d931b5cb97523c26cf3ff4f2b5da23dbf3460e16f65cddee"
     },
     {
       "path": "clients/bongos-client/index.d.ts",
       "mode": "0000644",
-      "sha256": "8c14cf27d91d8c9ae4c6e75b94cecc403daad87f37b8a04bc03f76b8bf11c3a4"
+      "sha256": "a5b32997f5d8f8c2415e194a05c208c40efde8a9a0277fa08468cbde35aeebef"
     },
     {
       "path": "clients/bongos-client/index.mjs",
       "mode": "0000644",
-      "sha256": "e380741ea83429e405e684d629044c067ff2e2d308fb8ef2a4a94c3c37c7c120"
+      "sha256": "e6ebb2574a13931d3777d27d45c620dd36e02b0bd9efd1d4b1d5cf7051f60990"
     },
     {
       "path": "clients/bongos-client/package.json",
@@ -2207,12 +2207,12 @@
     {
       "path": "docs/api-reference.md",
       "mode": "0000644",
-      "sha256": "06c5bea02e1e479aac06addd9a9fb71c9da889030cf4687d1bb89ba2d8c68038"
+      "sha256": "2830b600af9e930611ede0897e0da0678e92815288377254c2e29c3bb7f9ac97"
     },
     {
       "path": "docs/api/openapi.json",
       "mode": "0000644",
-      "sha256": "d94e6449c03eac000296fe13ebd81c066333ffc04b7d325e9b30c2ab569fd200"
+      "sha256": "d2512a57a976e3947fef2bbaeb441dd8077ad04d11168524fb64127b34da338e"
     },
     {
       "path": "docs/architecture.md",
@@ -2772,7 +2772,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "21d0dd30bb815e977954716bff215839a0877f32f1e95dcd183635e5a0246964"
+      "sha256": "376bff3138af4e48742c5f3a4a89e4fb2f34d55a1a0ce1cbe26544d807b24317"
     },
     {
       "path": "docs/modules-contract.md",
@@ -3904,6 +3904,11 @@
       "mode": "0000644",
       "sha256": "14924b5db9c9620e17a4cd5baa4c7821aa97db3d11711831faeb45fbfb035213"
     },
+    {
+      "path": "migrations/core_256_blocker_unlink_releases_task.sql",
+      "mode": "0000644",
+      "sha256": "a201e803f55458a1224bee5a48a88d311f663bcca2c5b8939e422f3ec90e4929"
+    },
     {
       "path": "modules/agents/CLAUDE.md",
       "mode": "0000644",
@@ -5697,7 +5702,7 @@
     {
       "path": "modules/ideas/blockers.js",
       "mode": "0000644",
-      "sha256": "e372a43f0aeff5a83075d83d2db2733b1be6e7e28dc4631901772af82914c9a6"
+      "sha256": "8bab6ae99fcc4b72e9d46ee51b8d1034931e22e77cf6537f0f11c63d62c46d7e"
     },
     {
       "path": "modules/ideas/born-of.js",
@@ -5822,7 +5827,7 @@
     {
       "path": "modules/ideas/routes/blockers.js",
       "mode": "0000644",
-      "sha256": "551b485b7d7ed9d6e8f28b0baea7154ffe9e9cee093c296a2097d585923340c7"
+      "sha256": "0746d83375ce1f76c578d17aae21a8afe9ac4c07e081c519489d63028fee9147"
     },
     {
       "path": "modules/ideas/routes/inbox.js",
@@ -8502,12 +8507,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "f422ee23bd52d7f90f4bc43727d8f25dda5369ee018a9ebe8d61c8adb12a0e1f"
+      "sha256": "1e36601af2ae18c0a0ece2e3a1eda00978d5cbe9b29bf89623be84fb3d1aa1c7"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "c696fd88b366bf880bbf8358a1502f26dedb4229aee867a6d73e944897529762"
+      "sha256": "18a7a52341443b1ebdeac607508a0559fa54850c6f44cb9b36be4fc59cb20ed3"
     },
     {
       "path": "public-docs/index.html",
@@ -8527,7 +8532,7 @@
     {
       "path": "release-notes.json",
       "mode": "0000644",
-      "sha256": "f1a8435bcf9e0329846f00f25418d6fa671fb943c34521f4420b85074d15cdf6"
+      "sha256": "4a6d22fce202bfef29ad1e4b2fe68f56207eaea1eb724a3f7c784321c78093de"
     },
     {
       "path": "scripts/bongos-mcp.js",
@@ -10597,7 +10602,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "28057a8787770e36c9992cac05d5bdc4166b1442da16448cac9c335bf3784637"
+      "sha256": "35c167db08eac18ea4cd0f3919855a5e2f3301ced410e556295ba5694af8cd1e"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -11129,6 +11134,11 @@
       "mode": "0000644",
       "sha256": "3a85b9e9bee4258aa64d26ca025d52c605f5f33938d3fdd5a31c393f1ec3f249"
     },
+    {
+      "path": "tests/blocker_unlink.mjs",
+      "mode": "0000644",
+      "sha256": "b1e13e7372d08f573072b47d0a41314fe33e3eb789dbf5ad4ae130efc7cc6419"
+    },
     {
       "path": "tests/blockers_hall.mjs",
       "mode": "0000644",

package/clients/bongos-client/README.md

@@ -5,7 +5,7 @@ A **generated**, zero-dependency typed client for the Bongos API — produced fr
 by hand; it regenerates when the spec changes, so it can never drift from the routes.
 
 - API version: **v1** (served at `/api/bongos/v1`)
-- 442 operations across 68 resource groups
+- 443 operations across 68 resource groups
 
 ## Use it from your project
 

package/clients/bongos-client/bongos-client.global.js

@@ -207,6 +207,8 @@ function createClient(opts = {}) {
       getBlockersId: (args) => request("GET", "/blockers/{id}", { hasBody: false }, args),
       // POST /blockers/{id}/link — rank: metic+archon — POST /blockers/:id/link
       postBlockersIdLink: (args) => request("POST", "/blockers/{id}/link", { hasBody: true }, args),
+      // DELETE /blockers/{id}/link/{taskId} — rank: metic+archon — DELETE /blockers/:id/link/:taskId
+      deleteBlockersIdLinkTaskId: (args) => request("DELETE", "/blockers/{id}/link/{taskId}", { hasBody: false }, args),
       // POST /blockers/{id}/resolve — rank: metic+archon — POST /blockers/:id/resolve
       postBlockersIdResolve: (args) => request("POST", "/blockers/{id}/resolve", { hasBody: true }, args),
     },

package/clients/bongos-client/index.cjs

@@ -206,6 +206,8 @@ function createClient(opts = {}) {
       getBlockersId: (args) => request("GET", "/blockers/{id}", { hasBody: false }, args),
       // POST /blockers/{id}/link — rank: metic+archon — POST /blockers/:id/link
       postBlockersIdLink: (args) => request("POST", "/blockers/{id}/link", { hasBody: true }, args),
+      // DELETE /blockers/{id}/link/{taskId} — rank: metic+archon — DELETE /blockers/:id/link/:taskId
+      deleteBlockersIdLinkTaskId: (args) => request("DELETE", "/blockers/{id}/link/{taskId}", { hasBody: false }, args),
       // POST /blockers/{id}/resolve — rank: metic+archon — POST /blockers/:id/resolve
       postBlockersIdResolve: (args) => request("POST", "/blockers/{id}/resolve", { hasBody: true }, args),
     },

package/clients/bongos-client/index.d.ts

@@ -6,6 +6,7 @@ export declare const DEFAULT_BASE_URL: string;
 // Request-body + shared types, generated from the OpenAPI components.schemas.
 export interface ApiErrorObject { code: string; message: string; details?: unknown }
 export interface DeleteAgentsNameResponse { ok: boolean; deleted: unknown }
+export interface DeleteBlockersIdLinkTaskIdResponse { ok: boolean; unlinked: boolean; released: unknown }
 export interface DeleteBoxSshKeyIdResponse { ok: boolean; deleted: unknown }
 export interface DeleteConnectionsIdResponse { outcome: unknown }
 export interface DeleteDependenciesResponse { ok: boolean }
@@ -622,6 +623,8 @@ export interface BongosClient {
     getBlockersId(args?: RequestArgs): Promise<GetBlockersIdResponse>;
     /** POST /blockers/{id}/link — rank: metic+archon */
     postBlockersIdLink(args: RequestArgs & { body: PostBlockersIdLinkRequest }): Promise<PostBlockersIdLinkResponse>;
+    /** DELETE /blockers/{id}/link/{taskId} — rank: metic+archon */
+    deleteBlockersIdLinkTaskId(args?: RequestArgs): Promise<DeleteBlockersIdLinkTaskIdResponse>;
     /** POST /blockers/{id}/resolve — rank: metic+archon */
     postBlockersIdResolve(args?: RequestArgs & { body?: PostBlockersIdResolveRequest }): Promise<ApiResponse>;
   };

package/clients/bongos-client/index.mjs

@@ -203,6 +203,8 @@ export function createClient(opts = {}) {
       getBlockersId: (args) => request("GET", "/blockers/{id}", { hasBody: false }, args),
       // POST /blockers/{id}/link — rank: metic+archon — POST /blockers/:id/link
       postBlockersIdLink: (args) => request("POST", "/blockers/{id}/link", { hasBody: true }, args),
+      // DELETE /blockers/{id}/link/{taskId} — rank: metic+archon — DELETE /blockers/:id/link/:taskId
+      deleteBlockersIdLinkTaskId: (args) => request("DELETE", "/blockers/{id}/link/{taskId}", { hasBody: false }, args),
       // POST /blockers/{id}/resolve — rank: metic+archon — POST /blockers/:id/resolve
       postBlockersIdResolve: (args) => request("POST", "/blockers/{id}/resolve", { hasBody: true }, args),
     },

package/docs/api/openapi.json

@@ -2456,6 +2456,70 @@
         ]
       }
     },
+    "/blockers/{id}/link/{taskId}": {
+      "delete": {
+        "operationId": "delete_blockers_id_link_taskId",
+        "tags": [
+          "blockers"
+        ],
+        "summary": "DELETE /blockers/:id/link/:taskId",
+        "description": "Unlink a blocker from a task — the inverse of /link (task 1003518). Both ids sit in the PATH, matching DELETE /tasks/:id/dependencies/:depId, the closest existing shape: an edge between two rows, removed by naming both. Post-core_223 a task is released only when its LAST open blocker resolves, so a wrong link is permanent: the only way out was to resolve a blocker that was never real, putting a falsehood in the blocker ledger to clear a bookkeeping artifact. This is the honest way out. Promotion is the TRIGGER's job here exactly as it is on /resolve: core_256 fires AFTER DELETE on task_blockers and re-uses core_223's predicate, so \"nothing open is left against this task\" has one definition, not two. blockers.unlinkBlockerFromTask only deletes and reads back what happened. `released` says whether the task actually moved, never a bare {ok:true} (task 1002559 — a write that reports success without saying what changed is how a dead loop hides). Metic+ (task 360 / ADR 0018) — same blocker-review grant as link and resolve. rank: metic+archon — unlink a blocker from a task; same blocker-review grant as link.\n\n**Rank:** `metic+archon` — Metic or Archon rank (review/triage powers).\n\n**Permissions:** `blocker.review` (all required).",
+        "x-rank": "metic+archon",
+        "x-source": "modules/ideas/routes/blockers.js",
+        "x-permissions": [
+          "blocker.review"
+        ],
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "Path parameter `id`."
+          },
+          {
+            "name": "taskId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "Path parameter `taskId`."
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success.",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DeleteBlockersIdLinkTaskIdResponse"
+                }
+              }
+            }
+          },
+          "400": {
+            "$ref": "#/components/responses/BadRequest"
+          },
+          "401": {
+            "$ref": "#/components/responses/Unauthorized"
+          },
+          "403": {
+            "$ref": "#/components/responses/Forbidden"
+          },
+          "404": {
+            "$ref": "#/components/responses/NotFound"
+          }
+        },
+        "security": [
+          {
+            "builderSession": []
+          }
+        ]
+      }
+    },
     "/blockers/{id}/resolve": {
       "post": {
         "operationId": "post_blockers_id_resolve",
@@ -20477,6 +20541,23 @@
           "deleted"
         ]
       },
+      "DeleteBlockersIdLinkTaskIdResponse": {
+        "type": "object",
+        "properties": {
+          "ok": {
+            "type": "boolean"
+          },
+          "unlinked": {
+            "type": "boolean"
+          },
+          "released": {}
+        },
+        "required": [
+          "ok",
+          "unlinked",
+          "released"
+        ]
+      },
       "DeleteBoxSshKeyIdResponse": {
         "type": "object",
         "properties": {
@@ -28040,9 +28121,9 @@
       "description": "A required dependency/feature is not configured or is temporarily down."
     }
   },
-  "x-endpoint-count": 442,
-  "x-schema-count": 482,
+  "x-endpoint-count": 443,
+  "x-schema-count": 483,
   "x-undocumented-bodies": 9,
-  "x-response-schemas": 330,
+  "x-response-schemas": 331,
   "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. 442 endpoints across 76 route files.
+> **Generated from the live route files** — the route file is authoritative. 443 endpoints across 76 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/0016-trust-boundary-server-enforced-permissions.md)): `public` < `any-builder` < `metic+archon` < `archon`.
@@ -104,7 +104,7 @@ Base path: `/api/bongos`. Ranks (enforced server-side, [ADR 0016](adr/0016-trust
 | GET | `/api/bongos/backup/status` | `metic+archon` | — | any working builder may check or trigger a backup. |
 | POST | `/api/bongos/backup/trigger` | `metic+archon` | — | kicks off a fresh dump; same gate as the status read. |
 
-## `blockers` (5)
+## `blockers` (6)
 
 | Method | Path | Rank | Body | Description |
 |---|---|---|---|---|
@@ -112,6 +112,7 @@ Base path: `/api/bongos`. Ranks (enforced server-side, [ADR 0016](adr/0016-trust
 | POST | `/api/bongos/blockers` | `any-builder` | `title`, `body_md`, `source`, `source_ref` | FILE a blocker (contribution, not resolution). |
 | GET | `/api/bongos/blockers/:id` | `any-builder` | — | single blocker detail read. |
 | POST | `/api/bongos/blockers/:id/link` | `metic+archon` | `task_id` | Link an existing blocker to a task. |
+| DELETE | `/api/bongos/blockers/:id/link/:taskId` | `metic+archon` | — | Unlink a blocker from a task — the inverse of /link (task 1003518). |
 | POST | `/api/bongos/blockers/:id/resolve` | `metic+archon` | `resolution_note` | Resolve. |
 
 ## `box` (20)

package/docs/module-api-changelog.md

@@ -2573,5 +2573,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.1041 with no explicit bump. run 36254852933. (task 1002620)
   1.19.1043 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.1042 with no explicit bump. run 36258640780. (task 1002620)
+  1.19.1044 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.1043 with no explicit bump. run 36260641494. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/migrations/core_256_blocker_unlink_releases_task.sql

@@ -0,0 +1,84 @@
+-- core_256_blocker_unlink_releases_task.sql — unlinking a blocker from a task
+-- must release that task when it was the last thing holding it (task 1003518).
+--
+-- THE GAP. `POST /blockers/:id/link` parks a 'ready' task in 'blocked' so the
+-- resolve trigger (009, tightened by core_223) has something to promote. Nothing
+-- removed a link. Post-core_223 a task is released only when its LAST open
+-- blocker resolves, so a wrong link — wrong task id, a duplicate filed by two
+-- people, a blocker later understood to be irrelevant — was permanent. The only
+-- escape was to resolve a blocker that was never real, putting a falsehood in
+-- the blocker ledger to clear a bookkeeping artifact. core_223's own header
+-- names this: "there is no unlink route to detach one first."
+--
+-- WHY A TRIGGER AND NOT THE ROUTE. tests/blocker_resolve_guard.mjs pins that
+-- modules/ideas/blockers.js never writes `tasks.status = 'ready'` itself: "if it
+-- ever started UPDATE-ing tasks.status, this guard would be bypassable and the
+-- fix would need to live in two places." An unlink that promoted in JS would be
+-- exactly that second place — a hand-copy of the predicate below, free to drift
+-- from it. Putting the release here keeps ONE definition of "this task has
+-- nothing open against it any more", and has a second payoff: the direct
+-- `DELETE FROM task_blockers` that was the only workaround before this task now
+-- does the right thing too, instead of silently leaving the task stranded.
+--
+-- NO `b.id <> …` EXCLUSION, AND THAT IS THE DIFFERENCE FROM core_223. That
+-- migration runs in a BEFORE UPDATE trigger, where the blocker being resolved
+-- still reads 'open' in the table and would count itself as an open blocker —
+-- so without the exclusion nothing would ever promote. This is an AFTER DELETE
+-- trigger: the link row is already gone when the body runs, so the NOT EXISTS
+-- already sees exactly the blockers that remain. Adding the exclusion here would
+-- be cargo-cult; omitting it is deliberate.
+--
+-- Deliberately NOT gating on dependencies, for core_223's reason: the
+-- dep-promotion triggers (163) only ever flip 'backlog' -> 'ready', never
+-- 'blocked' -> 'ready', so a task this left in 'blocked' for unshipped deps
+-- would have no release path at all. The claim path re-checks DEPS_NOT_SHIPPED
+-- as its second line of defence. Blocker-clearing and dep-clearing stay separate.
+--
+-- ONLY 'blocked' IS REWRITTEN. A task that was never parked (link arrived while
+-- it was active/backlog/shipped — see LINK_BLOCKABLE_STATUSES) is left exactly
+-- as it is, so an unlink can never launder a task past the metic+archon promote
+-- gate.
+--
+-- Legacy markdown-anchor links (a task_blockers row with blocker_ref and no
+-- blocker_id) are out of scope, the same scope core_223 and 176 draw: the JOIN
+-- below only sees structured links, so a legacy row neither blocks nor releases.
+--
+-- CASCADE SAFETY. task_blockers.task_id and .blocker_id are both ON DELETE
+-- CASCADE. Nothing in the repo hard-deletes a task (abandon is terminal) or a
+-- blocker (resolve is), so in practice this fires only on a real unlink. If a
+-- blocker ever were deleted outright, releasing the tasks it held is the correct
+-- reading — the thing that was blocking them no longer exists.
+--
+-- Idempotent: CREATE OR REPLACE for the function, DROP IF EXISTS + CREATE for
+-- the trigger (a trigger has no CREATE OR REPLACE before PG 14, and this must
+-- apply cleanly on a re-run).
+
+BEGIN;
+
+CREATE OR REPLACE FUNCTION trg_release_task_on_blocker_unlink()
+RETURNS TRIGGER AS $$
+BEGIN
+  UPDATE tasks
+     SET status = 'ready', updated_at = now()
+   WHERE id = OLD.task_id
+     AND status = 'blocked'
+     -- … and nothing open is left against this task (core_223's predicate,
+     -- minus the self-exclusion an AFTER DELETE trigger does not need).
+     AND NOT EXISTS (
+       SELECT 1
+         FROM task_blockers tb
+         JOIN blockers b ON b.id = tb.blocker_id
+        WHERE tb.task_id = OLD.task_id
+          AND b.status = 'open'
+     );
+  RETURN OLD;
+END;
+$$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS release_task_on_blocker_unlink ON task_blockers;
+CREATE TRIGGER release_task_on_blocker_unlink
+  AFTER DELETE ON task_blockers
+  FOR EACH ROW
+  EXECUTE FUNCTION trg_release_task_on_blocker_unlink();
+
+COMMIT;

package/modules/ideas/blockers.js

@@ -147,6 +147,65 @@ async function linkBlockerToTask({ blockerId, taskId }) {
   }
 }
 
+// Unlink a blocker from a task — the missing inverse of linkBlockerToTask
+// (task 1003518). Linking is one-way and Metic+, so before this a wrong link
+// (wrong task id, a duplicate filed by two people, a blocker later understood
+// to be irrelevant) could only be undone by a direct DELETE on task_blockers.
+//
+// LIKE resolveBlocker, THIS ONLY OBSERVES. The release lives in a DB trigger
+// (core_256), for the reason tests/blocker_resolve_guard.mjs states about the
+// resolve path: a promotion written here would be a second copy of core_223's
+// predicate, free to drift from it. One DELETE, then a read-back of what the
+// trigger did — the same shape resolveBlocker uses for `promoted_tasks`.
+//
+// The three statements share a transaction so `released` cannot be a lie told
+// by a concurrent writer between the delete and the read-back.
+//
+// `poolOverride` is injected by tests only, and is named so it cannot shadow the
+// module-level `pool` this file closes over.
+async function unlinkBlockerFromTask({ blockerId, taskId }, { pool: poolOverride = pool } = {}) {
+  const client = await poolOverride.connect();
+  try {
+    await client.query('BEGIN');
+    // Status BEFORE, so `released` means "this unlink moved it", not merely
+    // "it is ready now" — a task linked while it was never blockable would
+    // otherwise report a release that never happened (the task-1002559 lesson:
+    // a write that reports success without saying what changed hides a dead
+    // loop). FOR UPDATE so the row cannot move under the read-back below.
+    const { rows: before } = await client.query(
+      `SELECT status FROM tasks WHERE id = $1 FOR UPDATE`,
+      [taskId]
+    );
+    const { rows: removed } = await client.query(
+      `DELETE FROM task_blockers
+        WHERE task_id = $1 AND blocker_id = $2
+        RETURNING task_id`,
+      [taskId, blockerId]
+    );
+    // Answer honestly when nothing was there: a missing link is a refusal, not
+    // a silent success a caller would read as "detached".
+    if (removed.length === 0) {
+      await client.query('ROLLBACK');
+      const e = new Error('no such blocker link on that task');
+      e.code = 'LINK_NOT_FOUND';
+      throw e;
+    }
+    const { rows: after } = await client.query(
+      `SELECT status FROM tasks WHERE id = $1`,
+      [taskId]
+    );
+    await client.query('COMMIT');
+    const was = before[0] && before[0].status;
+    const now = after[0] && after[0].status;
+    return { unlinked: true, released: was === 'blocked' && now === 'ready' };
+  } catch (err) {
+    if (err.code !== 'LINK_NOT_FOUND') await client.query('ROLLBACK');
+    throw err;
+  } finally {
+    client.release();
+  }
+}
+
 module.exports = {
   listOpenBlockers,
   countOpenBlockers,
@@ -154,6 +213,7 @@ module.exports = {
   createBlocker,
   resolveBlocker,
   linkBlockerToTask,
+  unlinkBlockerFromTask,
   blocksOnLink,
   LINK_BLOCKABLE_STATUSES,
 };

package/modules/ideas/routes/blockers.js

@@ -145,5 +145,46 @@ module.exports = function buildBlockersRouter() {
     }
   });
 
+  // Unlink a blocker from a task — the inverse of /link (task 1003518). Both ids
+  // sit in the PATH, matching DELETE /tasks/:id/dependencies/:depId, the closest
+  // existing shape: an edge between two rows, removed by naming both.
+  //
+  // Post-core_223 a task is released only when its LAST open blocker resolves,
+  // so a wrong link is permanent: the only way out was to resolve a blocker that
+  // was never real, putting a falsehood in the blocker ledger to clear a
+  // bookkeeping artifact. This is the honest way out.
+  //
+  // Promotion is the TRIGGER's job here exactly as it is on /resolve: core_256
+  // fires AFTER DELETE on task_blockers and re-uses core_223's predicate, so
+  // "nothing open is left against this task" has one definition, not two.
+  // blockers.unlinkBlockerFromTask only deletes and reads back what happened.
+  //
+  // `released` says whether the task actually moved, never a bare {ok:true}
+  // (task 1002559 — a write that reports success without saying what changed is
+  // how a dead loop hides).
+  // Metic+ (#360 / ADR 0018) — same blocker-review grant as link and resolve.
+  // rank: metic+archon — unlink a blocker from a task; same blocker-review grant as link.
+  router.delete('/blockers/:id/link/:taskId', api.requireBuilder, api.requirePermission('blocker.review'), async (req, res) => {
+    // Both ids strict positive integers (`positiveInt`), via the shared parseId
+    // rather than a hand-rolled check: a `7.5` would otherwise pass a bare
+    // isFinite and then simply miss on the DELETE, answering "not linked" for
+    // what is really a malformed id. The sibling link/resolve routes predate
+    // that option; this one has no reason to be looser than it can be.
+    const id = parseId(req, res, { code: 'bad_id', positiveInt: true });
+    if (id === null) return;
+    const taskId = parseId(req, res, { param: 'taskId', code: 'bad_task_id', positiveInt: true });
+    if (taskId === null) return;
+    try {
+      const { released } = await blockers.unlinkBlockerFromTask({ blockerId: id, taskId });
+      res.json({ ok: true, unlinked: true, released });
+    } catch (err) {
+      if (err.code === 'LINK_NOT_FOUND') {
+        return res.fail('link_not_found', { status: 404, message: 'that blocker is not linked to that task' });
+      }
+      console.error('[gds] DELETE /blockers/:id/link/:taskId', err);
+      res.fail('unlink_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
   return router;
 };

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.1043",
+  "version": "1.19.1044",
   "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",

package/release-notes.json

@@ -7559,5 +7559,11 @@
       "id": "1004301",
       "text": "A task's own page now says where its code is — which version carries it, whether it is running on Bongos, whether it is released — and says plainly when a task marked done never actually landed."
     }
+  ],
+  "1.19.1044": [
+    {
+      "id": "1003518",
+      "text": "A blocker that was linked to the wrong task — a duplicate, or a mistake — can now be unlinked, and the task goes back to being claimable if nothing else was holding it. Before this the only way out was to mark the blocker reso"
+    }
   ]
 }

package/src/module-api.js

@@ -71,7 +71,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.1043'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.1044'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/blocker_unlink.mjs

@@ -0,0 +1,251 @@
+// tests/blocker_unlink.mjs
+//
+// Task 1003518 — a blocker can be UNLINKED from a task. Linking is one-way and
+// Metic+, and post-core_223 a task is released only when its LAST open blocker
+// resolves, so a wrong link (wrong task id, a duplicate filed twice, a blocker
+// later understood to be irrelevant) was permanent: the only escape was to
+// resolve a blocker that was never real, putting a falsehood in the ledger.
+//
+// TWO HALVES, mirroring tests/blocker_resolve_guard.mjs:
+//   1. the JS is an OBSERVER — it deletes and reads back, it never promotes;
+//   2. the promotion itself is core_256's trigger, pinned as SQL TEXT so a
+//      later edit cannot quietly drop the guard or "simplify" it into a bug.
+//
+// The JS half is behavioural, not shape assertions. The module-level `pool` is
+// replaced through require.cache BEFORE blockers.js loads, so the default
+// (zero-injection) path is the one under test — the shape a `deps.pool || pool`
+// shadowing bug would break while a harness that always injects stayed green.
+//
+// Run:  node tests/blocker_unlink.mjs
+
+import { strict as assert } from 'node:assert';
+import { readFileSync, readdirSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { createRequire } from 'node:module';
+import { makeRunner, makeSqlAwareClient } from './helpers.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const repoRoot = join(__dirname, '..');
+const read = (...p) => readFileSync(join(repoRoot, ...p), 'utf8');
+const require = createRequire(import.meta.url);
+const { test, summary } = makeRunner();
+
+// -- the fake pool, installed as the module's OWN pool ----------------------
+
+let current = null;   // the pool the stubbed module-api hands out this test
+let releases = 0;     // how many times client.release() was called
+
+const apiPath = require.resolve('../src/module-api.js');
+require.cache[apiPath] = {
+  id: apiPath,
+  filename: apiPath,
+  loaded: true,
+  exports: { pool: { connect: (...a) => current.connect(...a) } },
+};
+
+const blockers = require('../modules/ideas/blockers.js');
+
+// before/after: the task's status either side of the DELETE (the trigger is what
+// changes it in production, so the fake simply reports what it would have done).
+// deleted: rows the DELETE returns (0 = there was no such link).
+// failOn: a substring; the first matching statement throws.
+function scenario({ before = 'blocked', after = 'ready', deleted = 1, failOn = null } = {}) {
+  let seenDelete = false;
+  const pool = makeSqlAwareClient((sql) => {
+    if (failOn && sql.includes(failOn)) throw new Error('boom');
+    if (/^DELETE FROM task_blockers/.test(sql)) {
+      seenDelete = true;
+      return { rows: Array.from({ length: deleted }, () => ({ task_id: 7 })) };
+    }
+    if (/^SELECT status FROM tasks/.test(sql)) {
+      return { rows: [{ status: seenDelete ? after : before }] };
+    }
+    return { rows: [] };
+  });
+  const realRelease = pool._client.release.bind(pool._client);
+  pool._client.release = () => { releases += 1; realRelease(); };
+  current = pool;
+  releases = 0;
+  return pool;
+}
+
+const sqlOf = (pool) => pool.queries.map((q) => String(q.sql).replace(/\s+/g, ' ').trim());
+const unlink = (opts) => blockers.unlinkBlockerFromTask({ blockerId: 93, taskId: 7 }, opts);
+
+// == 1. the JS observes =====================================================
+
+await test('the link row is deleted, keyed on BOTH ids', async () => {
+  const pool = scenario();
+  await unlink();
+  const del = pool.queries.find((q) => /DELETE FROM task_blockers/.test(q.sql));
+  assert.ok(del, 'no DELETE was issued');
+  // Order matters: the SQL is (task_id, blocker_id), so a swap deletes a
+  // different edge — or silently none.
+  assert.deepEqual(del.params, [7, 93]);
+});
+
+await test('the JS never promotes — that is core_256s job', async () => {
+  // The same assertion blocker_resolve_guard.mjs makes about the resolve path,
+  // restated for unlink so the next person to "just fix it here" trips a test.
+  const src = read('modules', 'ideas', 'blockers.js');
+  assert.doesNotMatch(src, /UPDATE\s+tasks[\s\S]{0,200}?status\s*=\s*'ready'/);
+});
+
+await test('the whole unlink is one transaction', async () => {
+  const pool = scenario();
+  await unlink();
+  const s = sqlOf(pool);
+  assert.equal(s[0], 'BEGIN');
+  assert.equal(s[s.length - 1], 'COMMIT');
+});
+
+await test('the before-status is read FOR UPDATE so the read-back cannot be raced', async () => {
+  const pool = scenario();
+  await unlink();
+  const s = sqlOf(pool);
+  const first = s.find((q) => q.startsWith('SELECT status FROM tasks'));
+  assert.match(first, /FOR UPDATE/);
+  // …and it is read BEFORE the delete, or "did this unlink move it?" is unanswerable.
+  assert.ok(s.indexOf(first) < s.findIndex((q) => q.startsWith('DELETE FROM task_blockers')));
+});
+
+await test('released:true when the task went blocked -> ready', async () => {
+  scenario({ before: 'blocked', after: 'ready' });
+  assert.deepEqual(await unlink(), { unlinked: true, released: true });
+});
+
+await test('released:false while another blocker is still open', async () => {
+  // The trigger's NOT EXISTS fails, so the task stays blocked. The unlink still
+  // happened — but saying released:true here is the task-1002559 lie.
+  scenario({ before: 'blocked', after: 'blocked' });
+  assert.deepEqual(await unlink(), { unlinked: true, released: false });
+});
+
+await test('released:false when the task was never blocked in the first place', async () => {
+  // A link can land on a task that LINK_BLOCKABLE_STATUSES never parks (active,
+  // backlog, shipped). Reporting "released" for one of those would claim a
+  // promotion that never happened — and would be exactly what a naive
+  // "is it ready now?" read-back returns.
+  scenario({ before: 'active', after: 'active' });
+  assert.deepEqual(await unlink(), { unlinked: true, released: false });
+});
+
+await test('released:false for a task that was ALREADY ready before the unlink', async () => {
+  // THE DISCRIMINATING CASE. A legacy blocker_ref link, or one that landed while
+  // the task was not blockable, leaves a 'ready' task carrying a link. Removing
+  // it changes nothing — but a naive "is it ready NOW?" read-back reports a
+  // release that never happened. Only comparing against the BEFORE status can
+  // tell the two apart, which is why that status is read at all.
+  scenario({ before: 'ready', after: 'ready' });
+  assert.deepEqual(await unlink(), { unlinked: true, released: false });
+});
+
+await test('a link that is not there refuses with LINK_NOT_FOUND and rolls back', async () => {
+  const pool = scenario({ deleted: 0 });
+  await assert.rejects(() => unlink(), (e) => e.code === 'LINK_NOT_FOUND');
+  const s = sqlOf(pool);
+  assert.ok(s.includes('ROLLBACK'), 'must roll back');
+  assert.ok(!s.includes('COMMIT'), 'must not commit');
+});
+
+await test('an unexpected failure rolls back exactly once', async () => {
+  const pool = scenario({ failOn: 'DELETE FROM task_blockers' });
+  await assert.rejects(() => unlink());
+  const s = sqlOf(pool);
+  assert.equal(s.filter((q) => q === 'ROLLBACK').length, 1);
+  assert.ok(!s.includes('COMMIT'));
+});
+
+await test('the client is returned to the pool on EVERY path', async () => {
+  scenario();
+  await unlink();
+  assert.equal(releases, 1, 'success path');
+
+  scenario({ deleted: 0 });
+  await assert.rejects(() => unlink());
+  assert.equal(releases, 1, 'refusal path');
+
+  scenario({ failOn: 'DELETE FROM task_blockers' });
+  await assert.rejects(() => unlink());
+  assert.equal(releases, 1, 'error path');
+});
+
+await test('an injected pool overrides the module-level one', async () => {
+  scenario({ before: 'active', after: 'active' });   // module-level: would say false
+  let sawDelete = false;
+  const other = makeSqlAwareClient((sql) => {
+    if (/^DELETE FROM task_blockers/.test(sql)) { sawDelete = true; return { rows: [{ task_id: 7 }] }; }
+    if (/^SELECT status FROM tasks/.test(sql)) return { rows: [{ status: sawDelete ? 'ready' : 'blocked' }] };
+    return { rows: [] };
+  });
+  assert.equal((await unlink({ pool: other })).released, true, 'the injected pool must be the one used');
+  assert.equal(current.queries.length, 0, 'the module-level pool saw none');
+});
+
+// == 2. core_256 — the trigger that actually releases =======================
+
+const MIG = 'core_256_blocker_unlink_releases_task.sql';
+const mig = read('migrations', MIG);
+const migN = mig.replace(/\s+/g, ' ');
+// Comments carry the rationale; strip them when asserting on the executable
+// body, so a claim in prose can never stand in for the real SQL.
+const body = mig.replace(/^\s*--.*$/gm, '').replace(/\s+/g, ' ');
+
+await test('256 installs an AFTER DELETE row trigger on task_blockers', () => {
+  assert.match(body, /CREATE OR REPLACE FUNCTION trg_release_task_on_blocker_unlink\(\)/);
+  assert.match(body, /AFTER DELETE ON task_blockers/);
+  assert.match(body, /FOR EACH ROW/);
+});
+
+await test('the release targets ONLY a blocked task', () => {
+  assert.match(body, /UPDATE tasks SET status = 'ready'/);
+  assert.match(body, /WHERE id = OLD\.task_id/);
+  // Without this, an unlink would launder any task straight to 'ready' — past
+  // the metic+archon promote gate.
+  assert.match(body, /AND status = 'blocked'/);
+});
+
+await test("core_223's NOT EXISTS over the task's remaining open blockers is carried", () => {
+  assert.match(body, /AND NOT EXISTS \( SELECT 1 FROM task_blockers tb JOIN blockers b ON b\.id = tb\.blocker_id/);
+  assert.match(body, /WHERE tb\.task_id = OLD\.task_id/);
+  assert.match(body, /AND b\.status = 'open'/);
+});
+
+await test("and deliberately has NO `b.id <> …` exclusion — AFTER DELETE, the row is gone", () => {
+  // core_223 needs that clause because it runs BEFORE UPDATE, where the blocker
+  // being resolved still reads 'open' and would count itself, stalling forever.
+  // Here the link row is already deleted when the body runs, so the NOT EXISTS
+  // sees only what remains. Copying the clause across would be cargo-cult.
+  assert.doesNotMatch(body, /b\.id <>/);
+});
+
+await test('256 does NOT also gate on dependencies — that would strand the task', () => {
+  // The dep-promotion triggers (163) only flip backlog -> ready, so a task held
+  // in 'blocked' for unshipped deps would have no release path at all.
+  assert.doesNotMatch(body, /task_is_fully_unblocked/);
+});
+
+await test('256 is transactional and re-appliable', () => {
+  assert.match(migN, /BEGIN;.*COMMIT;/);
+  // A trigger has no CREATE OR REPLACE before PG 14, so the drop is what makes
+  // a re-run clean rather than a duplicate-object error.
+  assert.match(body, /DROP TRIGGER IF EXISTS release_task_on_blocker_unlink ON task_blockers/);
+  assert.doesNotMatch(body, /DROP FUNCTION/i);
+});
+
+await test('256 is the ONLY definition of the unlink-release function', () => {
+  const defs = readdirSync(join(repoRoot, 'migrations'))
+    .filter((f) => f.endsWith('.sql'))
+    .filter((f) => /FUNCTION trg_release_task_on_blocker_unlink/.test(read('migrations', f)))
+    .sort();
+  // migrate.sh applies in filename order, so a second, lower-numbered
+  // definition landing later would silently reinstate whatever it said.
+  assert.deepEqual(defs, [MIG]);
+});
+
+await test('unlinkBlockerFromTask is exported', () => {
+  assert.equal(typeof blockers.unlinkBlockerFromTask, 'function');
+});
+
+summary();