@bongos/core 1.20.65 → 1.20.66

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.20.65",
-  "core_contract": "1.20.65",
-  "source_commit": "d83ddd9aee9444dee8d60cf40c8dcb9b3d32e296",
+  "core_version": "1.20.66",
+  "core_contract": "1.20.66",
+  "source_commit": "b20b1cd9652722eebc2cc8a17369c7bc29c7284a",
   "source_ref": "HEAD",
-  "built_at": "2026-10-01T11:03:38.854Z",
+  "built_at": "2026-10-01T11:16:57.096Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 572,
     "agent_docs_stubbed": 27,
-    "functional_verbatim": 2790,
+    "functional_verbatim": 2793,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 3390,
-  "tree_sha256": "ede972bceb550b8da7d974492895636275f2f66415178c7632b00d1d85e3dbe0",
+  "file_count": 3393,
+  "tree_sha256": "fe92e9b1d448a099b9733514cd16f02219f90b86e1af2612331edbb45aed7a2a",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -317,12 +317,12 @@
     {
       "path": "clients/bongos-client/README.md",
       "mode": "0000644",
-      "sha256": "87352a8f884ec57b9263ac7596f8c66a5f353b633658304f2b531d31b9cf9b44"
+      "sha256": "3350163ed447189b523028f711e3ef1a400ea375ebe7123f2515add8b6a89de1"
     },
     {
       "path": "clients/bongos-client/bongos-client.global.js",
       "mode": "0000644",
-      "sha256": "0a2e5d5157aeecb5ba74d68533e8267bc733f06eff2a72025c2fefce196c4c4e"
+      "sha256": "a863d3db1a112c490648e0f2b3eaddf3f2e8c9ebe107ec298ea5ff0c663a5e6a"
     },
     {
       "path": "clients/bongos-client/examples/hello-world.mjs",
@@ -332,17 +332,17 @@
     {
       "path": "clients/bongos-client/index.cjs",
       "mode": "0000644",
-      "sha256": "1b62998873e5e55e5ddd827b48b4698e851859c667f2993d2552b79fae4e9009"
+      "sha256": "06bf39230e1c813494dc85130694754d1eb6b3fd55d3e93a684dd238bf6bc22b"
     },
     {
       "path": "clients/bongos-client/index.d.ts",
       "mode": "0000644",
-      "sha256": "425cfa53b1e0bf7d7ff08675e7732312fe14e6b6bf84bb3d627beffbebbd73ad"
+      "sha256": "2345d96c47f3851443f8b1adc5dac4556705e7f63f9875a4c62252bf833f17d4"
     },
     {
       "path": "clients/bongos-client/index.mjs",
       "mode": "0000644",
-      "sha256": "1a73be7803ba716ee5e03cdffdb807d2700d8cd398ce4f22a07a3fe809c3aa76"
+      "sha256": "313cfd428b7fd04a9fec6e56cdc1ddabb69af6ca144d7e09d2384a50d48b53df"
     },
     {
       "path": "clients/bongos-client/package.json",
@@ -2262,12 +2262,12 @@
     {
       "path": "docs/api-reference.md",
       "mode": "0000644",
-      "sha256": "630d2344ea6f8a380f99022dfab1d2c4a79b2c1804259f42f6954cb769536407"
+      "sha256": "0abf904bcf32aef68bd70592d09cb986e4538cae62c2b9b268af8904d8a483fb"
     },
     {
       "path": "docs/api/openapi.json",
       "mode": "0000644",
-      "sha256": "bbfc9546a939b4472a734d121f4db659667ad2e647e005b882a7a7c76589a287"
+      "sha256": "026ea9ba339051ada00869b8363718fae4fcded3be6eae98bcc60a37b9e844dc"
     },
     {
       "path": "docs/architecture.md",
@@ -2802,7 +2802,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "9754d3deec186136216507d8dfc84c40eaf82c4ca40c63f48ad60884527452bf"
+      "sha256": "a6ca9dad8d9c0bd38f081d1852a161731a62e9b34a759f6740c890ee4b3f7170"
     },
     {
       "path": "docs/modules-contract.md",
@@ -4762,7 +4762,7 @@
     {
       "path": "modules/government/catalog.js",
       "mode": "0000644",
-      "sha256": "0559d78f54b4b8a89ac4e6924d6dad4e2693a7e54f943532e83e4ac966868b76"
+      "sha256": "f3d82f60997e944eb7108c36bafa9d9be8469c5980b5460abfdf410ffa601dea"
     },
     {
       "path": "modules/government/charter.js",
@@ -6654,6 +6654,11 @@
       "mode": "0000644",
       "sha256": "593c5a96579f1df60f1fa232f6f31414541372a8a5277126e78b5046bcd990ac"
     },
+    {
+      "path": "modules/lifecycle/goal-move.js",
+      "mode": "0000644",
+      "sha256": "9f176232145d0e173d9a7fd08906186c127749c409469b7af1c02b071c9f3d23"
+    },
     {
       "path": "modules/lifecycle/goal-rollup.js",
       "mode": "0000644",
@@ -6792,7 +6797,7 @@
     {
       "path": "modules/lifecycle/module.json",
       "mode": "0000644",
-      "sha256": "75b5ab14761c7c83b44219a0d4540b064548a38ecb1de20eab540c5cbebf162b"
+      "sha256": "4eaad6ef027c1e2f3baa2d589a963e721d1f4c20201ed003e412953ea570ee8e"
     },
     {
       "path": "modules/lifecycle/page-tweak-approve.js",
@@ -6909,6 +6914,11 @@
       "mode": "0000644",
       "sha256": "474b9fa9e13a731f39ab15de74a75ee4878155eb2236d25b0f12011c1df99583"
     },
+    {
+      "path": "modules/lifecycle/routes/goal-move.js",
+      "mode": "0000644",
+      "sha256": "9b5ed11cf59a69105d861fc6bd01bddc5c7d3d29913b4d1e9d8daf73434ea083"
+    },
     {
       "path": "modules/lifecycle/routes/goal-route-authz.js",
       "mode": "0000644",
@@ -9447,12 +9457,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "9c2fa6e82319388a9b4b7c68acb6aabf12cf447cc9df068c9351540e39e41f6e"
+      "sha256": "3cab8f24d1505f76d3830cba2640a4d75a29b6f77cb288f3e0b73ac72528b829"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "253fd4502f205668e930fb1863b1dbc47f376462139e3a33809d84bb62157110"
+      "sha256": "ae2d9d106c6a31eb87e19ab5d4da9d433a43bfa14d029773a33f8119236145e1"
     },
     {
       "path": "public-docs/index.html",
@@ -9472,7 +9482,7 @@
     {
       "path": "release-notes.json",
       "mode": "0000644",
-      "sha256": "e041a1335bad43a910cce4057eaf312ec70054008fef566a5b07f373fbddd8aa"
+      "sha256": "1f738eb89f28f99d21310d526b289097059ddc1f660339a1282461396e06801c"
     },
     {
       "path": "scripts/bongos-mcp.js",
@@ -10157,7 +10167,7 @@
     {
       "path": "scripts/gds/goal.js",
       "mode": "0000644",
-      "sha256": "6cd8b2e7d23a4a8351f4018d2eec9403bb7eb16391e77fa2583a5f4c612e3046"
+      "sha256": "320841b1e4df014966ea9b6b70645ecb7915b412f94b8fa0d9835dae5b9446c5"
     },
     {
       "path": "scripts/gds/grade-correlation-audit.js",
@@ -11492,7 +11502,7 @@
     {
       "path": "src/bongos/route-rank-check.js",
       "mode": "0000644",
-      "sha256": "3d7c62d9c3925bc1ebafeae7d90ff09fc22a09c75c2ec47382e12bcff8d017ad"
+      "sha256": "c31e753d353b6c8c6b1f4e9af80a31afc995568aea9fd4ad8ab408e093a6f786"
     },
     {
       "path": "src/bongos/routes.js",
@@ -11652,7 +11662,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "b8165107a23910ad35f528a86cd39ddff17a185fe7081f7cb8fb03f0c072a813"
+      "sha256": "91a903030df7c3ff180de1a505f0de4dece1cfcbd9fc7131c22c667a2074c648"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -13349,6 +13359,11 @@
       "mode": "0000644",
       "sha256": "a465047f1e25c6cdeedf75f53337851224b7207c95d5135d1353504b3c660087"
     },
+    {
+      "path": "tests/goal_move.mjs",
+      "mode": "0000644",
+      "sha256": "7a7caded5d4d1f26b9f37a4c2c55636adc6f10ad2633f2b3260d7c4f31ebacd8"
+    },
     {
       "path": "tests/goal_names.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`)
-- 484 operations across 73 resource groups
+- 485 operations across 73 resource groups
 
 ## Use it from your project
 

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

@@ -449,6 +449,8 @@ function createClient(opts = {}) {
       postGoalsIdMembers: (args) => request("POST", "/goals/{id}/members", { hasBody: true }, args),
       // PATCH /goals/{id}/members/{builderId} — rank: any-builder — PATCH /goals/:id/members/:builderId
       patchGoalsIdMembersBuilderId: (args) => request("PATCH", "/goals/{id}/members/{builderId}", { hasBody: true }, args),
+      // POST /goals/{id}/move — rank: archon — POST /goals/:id/move
+      postGoalsIdMove: (args) => request("POST", "/goals/{id}/move", { hasBody: true }, args),
       // POST /goals/{id}/reopen — rank: metic+archon — POST /goals/:id/reopen
       postGoalsIdReopen: (args) => request("POST", "/goals/{id}/reopen", { hasBody: true }, args),
       // GET /goals/{id}/requests — rank: any-builder — GET /goals/:id/requests

package/clients/bongos-client/index.cjs

@@ -448,6 +448,8 @@ function createClient(opts = {}) {
       postGoalsIdMembers: (args) => request("POST", "/goals/{id}/members", { hasBody: true }, args),
       // PATCH /goals/{id}/members/{builderId} — rank: any-builder — PATCH /goals/:id/members/:builderId
       patchGoalsIdMembersBuilderId: (args) => request("PATCH", "/goals/{id}/members/{builderId}", { hasBody: true }, args),
+      // POST /goals/{id}/move — rank: archon — POST /goals/:id/move
+      postGoalsIdMove: (args) => request("POST", "/goals/{id}/move", { hasBody: true }, args),
       // POST /goals/{id}/reopen — rank: metic+archon — POST /goals/:id/reopen
       postGoalsIdReopen: (args) => request("POST", "/goals/{id}/reopen", { hasBody: true }, args),
       // GET /goals/{id}/requests — rank: any-builder — GET /goals/:id/requests

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

@@ -320,6 +320,8 @@ export interface PostGoalsIdJoinResponse { ok: boolean; member: unknown }
 export interface PostGoalsIdLeaveResponse { ok: boolean }
 export interface PostGoalsIdMembersRequest { membership_kind?: string; builder_id?: StringifiableId }
 export interface PostGoalsIdMembersResponse { ok: boolean; member: unknown }
+export interface PostGoalsIdMoveRequest { version_id: string; admit_reason?: string }
+export interface PostGoalsIdMoveResponse { ok: boolean; goal: unknown; from_version_id: unknown; to_version_id: unknown; moved_task_ids: unknown; moved_criterion_ids: unknown; admitted: unknown }
 export interface PostGoalsIdReopenResponse { ok: boolean; goal: unknown }
 export interface PostGoalsIdRequestsReqIdRespondRequest { action: string }
 export interface PostGoalsIdRequestsReqIdRespondResponse { ok: boolean; action: unknown; request: unknown; member?: unknown }
@@ -893,6 +895,8 @@ export interface BongosClient {
     postGoalsIdMembers(args?: RequestArgs & { body?: PostGoalsIdMembersRequest }): Promise<PostGoalsIdMembersResponse>;
     /** PATCH /goals/{id}/members/{builderId} — rank: any-builder */
     patchGoalsIdMembersBuilderId(args: RequestArgs & { body: PatchGoalsIdMembersBuilderIdRequest }): Promise<PatchGoalsIdMembersBuilderIdResponse>;
+    /** POST /goals/{id}/move — rank: archon */
+    postGoalsIdMove(args: RequestArgs & { body: PostGoalsIdMoveRequest }): Promise<PostGoalsIdMoveResponse>;
     /** POST /goals/{id}/reopen — rank: metic+archon */
     postGoalsIdReopen(args?: RequestArgs): Promise<PostGoalsIdReopenResponse>;
     /** GET /goals/{id}/requests — rank: any-builder */

package/clients/bongos-client/index.mjs

@@ -445,6 +445,8 @@ export function createClient(opts = {}) {
       postGoalsIdMembers: (args) => request("POST", "/goals/{id}/members", { hasBody: true }, args),
       // PATCH /goals/{id}/members/{builderId} — rank: any-builder — PATCH /goals/:id/members/:builderId
       patchGoalsIdMembersBuilderId: (args) => request("PATCH", "/goals/{id}/members/{builderId}", { hasBody: true }, args),
+      // POST /goals/{id}/move — rank: archon — POST /goals/:id/move
+      postGoalsIdMove: (args) => request("POST", "/goals/{id}/move", { hasBody: true }, args),
       // POST /goals/{id}/reopen — rank: metic+archon — POST /goals/:id/reopen
       postGoalsIdReopen: (args) => request("POST", "/goals/{id}/reopen", { hasBody: true }, args),
       // GET /goals/{id}/requests — rank: any-builder — GET /goals/:id/requests

package/docs/api/openapi.json

@@ -7470,6 +7470,72 @@
         ]
       }
     },
+    "/goals/{id}/move": {
+      "post": {
+        "operationId": "post_goals_id_move",
+        "tags": [
+          "goals"
+        ],
+        "summary": "POST /goals/:id/move",
+        "description": "(perm:version.create) — re-homes a goal and its tasks across versions.\n\n**Rank:** `archon` — Archon only (rank and identity management + the escalation keys — the trust boundary).\n\n**Permissions:** `version.create` (all required).",
+        "x-rank": "archon",
+        "x-source": "modules/lifecycle/routes/goal-move.js",
+        "x-permissions": [
+          "version.create"
+        ],
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "Path parameter `id`."
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/PostGoalsIdMoveRequest"
+              }
+            }
+          },
+          "x-validated": true
+        },
+        "responses": {
+          "200": {
+            "description": "Success.",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PostGoalsIdMoveResponse"
+                }
+              }
+            }
+          },
+          "400": {
+            "$ref": "#/components/responses/ValidationFailed"
+          },
+          "401": {
+            "$ref": "#/components/responses/Unauthorized"
+          },
+          "403": {
+            "$ref": "#/components/responses/Forbidden"
+          },
+          "404": {
+            "$ref": "#/components/responses/NotFound"
+          }
+        },
+        "security": [
+          {
+            "builderSession": []
+          }
+        ]
+      }
+    },
     "/goals/{id}/reopen": {
       "post": {
         "operationId": "post_goals_id_reopen",
@@ -27248,6 +27314,47 @@
           "member"
         ]
       },
+      "PostGoalsIdMoveRequest": {
+        "type": "object",
+        "properties": {
+          "version_id": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 64
+          },
+          "admit_reason": {
+            "type": "string",
+            "maxLength": 2000
+          }
+        },
+        "required": [
+          "version_id"
+        ],
+        "additionalProperties": false
+      },
+      "PostGoalsIdMoveResponse": {
+        "type": "object",
+        "properties": {
+          "ok": {
+            "type": "boolean"
+          },
+          "goal": {},
+          "from_version_id": {},
+          "to_version_id": {},
+          "moved_task_ids": {},
+          "moved_criterion_ids": {},
+          "admitted": {}
+        },
+        "required": [
+          "ok",
+          "goal",
+          "from_version_id",
+          "to_version_id",
+          "moved_task_ids",
+          "moved_criterion_ids",
+          "admitted"
+        ]
+      },
       "PostGoalsIdReopenResponse": {
         "type": "object",
         "properties": {
@@ -30890,9 +30997,9 @@
       "description": "A required dependency/feature is not configured or is temporarily down."
     }
   },
-  "x-endpoint-count": 484,
-  "x-schema-count": 511,
+  "x-endpoint-count": 485,
+  "x-schema-count": 513,
   "x-undocumented-bodies": 12,
-  "x-response-schemas": 342,
+  "x-response-schemas": 343,
   "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. 484 endpoints across 88 route files.
+> **Generated from the live route files** — the route file is authoritative. 485 endpoints across 89 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`.
@@ -296,7 +296,7 @@ Base path: `/api/bongos`. Ranks (enforced server-side, [ADR 0016](adr/0016-trust
 | POST | `/api/bongos/goal-task-relevance/:id/decide` | `metic+archon` | `decision`, `note` | task.promote — same atom as the read (task.promote's own gate). |
 | GET | `/api/bongos/goal-task-relevance/pending` | `metic+archon` | — | task.promote (metic+archon) — the reused review-queue atom. |
 
-## `goals` (33)
+## `goals` (34)
 
 | Method | Path | Rank | Body | Description |
 |---|---|---|---|---|
@@ -317,6 +317,7 @@ Base path: `/api/bongos`. Ranks (enforced server-side, [ADR 0016](adr/0016-trust
 | POST | `/api/bongos/goals/:id/leave` | `any-builder` | — | POST /goals/:id/leave — leave a goal you're in. |
 | POST | `/api/bongos/goals/:id/members` | `any-builder` | `membership_kind`, `builder_id` | POST /goals/:id/members — the goal's own authority (owner \| manager \| Archon) invites a builder to the goal (task 1762: widened from Arch… |
 | PATCH | `/api/bongos/goals/:id/members/:builderId` | `any-builder` | `membership_kind` | PATCH /goals/:id/members/:builderId — membership management by the goal's own authority (task 1735): the owner, a manager, or an Archon p… |
+| POST | `/api/bongos/goals/:id/move` | `archon` | `version_id`, `admit_reason` | (perm:version.create) — re-homes a goal and its tasks across versions. |
 | POST | `/api/bongos/goals/:id/reopen` | `metic+archon` | — | POST /goals/:id/reopen — bring an archived goal back to open (ADR 0086 §6 / BV1.R64). |
 | GET | `/api/bongos/goals/:id/requests` | `any-builder` | — | GET /goals/:id/requests — the goal's own pending invite/join-request queue (task 1953): every pending row on THIS goal, both kinds — outs… |
 | POST | `/api/bongos/goals/:id/requests` | `any-builder` | `note` | POST /goals/:id/requests — a builder asks to join a (private or protected) goal (task 1952 / ADR 0112). |

package/docs/module-api-changelog.md

@@ -2787,5 +2787,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.20.63 with no explicit bump. run 36851876428. (task 1002620)
   1.20.65 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.20.64 with no explicit bump. run 36852902728. (task 1002620)
+  1.20.66 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.20.65 with no explicit bump. run 36854308972. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/modules/government/catalog.js

@@ -152,7 +152,7 @@ const PERMISSIONS = [
   // granted is not a gate" argument. That argument was heard and was not the deciding
   // one. The revisit trigger is a concrete one — the first time such a rank exists —
   // and tests/government_catalog.mjs pins the flag so the change cannot land silently.
-  { key: 'version.create', system: false, floor: 'archon', guards: 'POST /versions — create a version + its done-when criteria (ADR 0250 §6 returns it to archon; ADR 0157 had lowered it to metic)' },
+  { key: 'version.create', system: false, floor: 'archon', guards: 'POST /versions — create a version + its done-when criteria (ADR 0250 §6 returns it to archon; ADR 0157 had lowered it to metic); POST /goals/:id/move — re-home a goal across versions (task 1004485)' },
   { key: 'task.confirm.grade_bypass', system: true, floor: 'archon', guards: 'POST /tasks/:id/confirm — ratify past a failed grade (env-relaxable, ADR 0041)' },
   { key: 'dependency.cross_tier.manage', system: true, floor: 'archon', guards: 'POST|DELETE /dependencies — cross-tier structural edges (ADR 0086)' },
   { key: 'goal.scope.manage', system: true, floor: 'archon', guards: 'cross-tier goal-scope edges + protected-scope admission (ADR 0086)' },

package/modules/lifecycle/goal-move.js

@@ -0,0 +1,182 @@
+'use strict';
+
+// modules/lifecycle/goal-move.js — move a goal, with everything it holds, to
+// another version (task 1004485).
+//
+// WHY. A goal's version was write-once. PATCH /goals/:id edits prose, never
+// version_id, and PATCH /tasks/:id refuses `goal_version_mismatch` — so the only
+// way to re-home a goal that did not make its version (the 2026-10-01 case:
+// goals 1000122 and 1000123 deferred from BONGOS-V2 to BONGOS-V3) was to recreate
+// it and its tasks under new ids, or a hand-written prod UPDATE.
+//
+// THE GOAL MOVES WHOLE. The goal row, every done-when criterion parented to it,
+// and every task in it — terminal ones included — change version in ONE
+// transaction. Two half-moves are the failure shapes this exists to avoid:
+//   • tasks left behind would sit in a goal of another version, which PATCH
+//     /tasks/:id refuses for exactly that reason (a task joins a goal in its own
+//     version only);
+//   • a task moved by goal_id but not version_id is the carryBugsForward lesson
+//     (db-goals.js, BV1.R18c): `version_progress` joins on tasks.version_id, so a
+//     half-moved task keeps counting against the version it left.
+//
+// WHAT IS REFUSED, and why:
+//   • a maintenance goal — only carryBugsForward moves those, at version close;
+//   • a goal that is not open — achieved/archived goals are history;
+//   • a goal on a SHIPPED version — moving it would rewrite closed scope-truth;
+//   • the same version — a no-op dressed as a write;
+//   • a target that would refuse a new goal — the SAME gate POST /goals uses
+//     (authorizeGoalCreate), so "may this version take this goal" has one answer.
+//     A building target therefore needs the Archon `admit_reason` override, and
+//     the admission is recorded exactly as a create's is;
+//   • a criterion link that crosses the goal's edge (a task inside linked to a
+//     criterion outside, or the reverse) — after the move it would join two
+//     versions, and /status would count it against the wrong one. The caller
+//     unlinks it first; the refusal names every pair.
+// An ACTIVE CLAIM is not a refusal: re-pointing the version takes no work from
+// anyone (the claim references the task, untouched) — carryBugsForward's
+// reasoning, for the same act.
+//
+// Lives in its own file because routes/goals.js sits at the fitness oversize
+// line (1,500) and db-goals.js near it; a move is a cohesive slice, the
+// goal-edits.js precedent.
+
+const api = require('../../src/module-api');
+const { executorFor } = require('./db-executor.js');
+const { authorizeGoalCreate } = require('./routes/goal-route-authz.js');
+const { pool } = api;
+
+// authorizeGoalMove — PURE, FAIL-CLOSED. May this goal move to this version?
+// The route gathers the facts; this decides; the route renders the verdict.
+function authorizeGoalMove({ goal, source, target, admitReason = null }) {
+  if (!goal) {
+    return { ok: false, status: 404, body: { error: 'goal_not_found', message: 'No such goal.' } };
+  }
+  if (goal.is_maintenance) {
+    return { ok: false, status: 409, body: {
+      error: 'maintenance_goal',
+      message: `Goal #${goal.id} is its version's maintenance goal — it moves only with the version close (carry-forward), never by hand.`,
+    } };
+  }
+  if (goal.status !== 'open') {
+    return { ok: false, status: 409, body: {
+      error: 'goal_not_open', goal_status: goal.status,
+      message: `Goal #${goal.id} is '${goal.status}' — only an open goal can move to another version.`,
+    } };
+  }
+  if (source && source.status === 'shipped') {
+    return { ok: false, status: 409, body: {
+      error: 'source_version_shipped',
+      message: `Goal #${goal.id} belongs to '${source.id}', which has shipped — its goals are closed history.`,
+    } };
+  }
+  if (target && String(target.id) === String(goal.version_id)) {
+    return { ok: false, status: 409, body: {
+      error: 'same_version', message: `Goal #${goal.id} is already on '${target.id}'.`,
+    } };
+  }
+  const decision = authorizeGoalCreate({ version: target, override: admitReason !== null });
+  if (!decision.ok) return decision;
+  return { ok: true, overrideApplied: decision.overrideApplied };
+}
+
+// moveGoalToVersion — the write, in ONE transaction. Returns
+// { fromVersionId, toVersionId, taskIds, criterionIds }. Throws a coded error the
+// route translates:
+//   GOAL_NOT_FOUND, GOAL_CHANGED (status/version moved since the route checked),
+//   TARGET_CHANGED (the target's status moved since the route checked),
+//   CRITERION_LINKS_CROSS_GOAL (with .links), CRITERION_ID_COLLISION (a criterion
+//   slug the target version already uses — UNIQUE (version_id, criterion_id)).
+async function moveGoalToVersion({ goalId, fromVersionId, toVersionId, targetStatus, admission = null }, deps = {}) {
+  const client = await executorFor(deps, pool).connect();
+  try {
+    await client.query('BEGIN');
+
+    const { rows: g } = await client.query(
+      `SELECT id, version_id, status FROM goals WHERE id = $1 FOR UPDATE`, [goalId]
+    );
+    if (!g[0]) throw Object.assign(new Error('goal not found'), { code: 'GOAL_NOT_FOUND' });
+    if (String(g[0].version_id) !== String(fromVersionId) || g[0].status !== 'open') {
+      throw Object.assign(new Error('goal changed'), { code: 'GOAL_CHANGED' });
+    }
+    // The target's status was what the gate judged; a close or promotion in
+    // between would let a goal into a version that now refuses it.
+    const { rows: v } = await client.query(
+      `SELECT status FROM versions WHERE id = $1 FOR SHARE`, [toVersionId]
+    );
+    if (!v[0] || v[0].status !== targetStatus) {
+      throw Object.assign(new Error('target changed'), { code: 'TARGET_CHANGED' });
+    }
+
+    // Exactly one side of the link inside this goal = the link crosses its edge.
+    const { rows: links } = await client.query(
+      `SELECT tc.task_id::text AS task_id, tc.criterion_id::text AS criterion_id
+         FROM task_criteria tc
+         JOIN tasks t ON t.id = tc.task_id
+         JOIN done_when_criteria c ON c.id = tc.criterion_id
+        WHERE (t.goal_id IS NOT DISTINCT FROM $1) <> (c.goal_id IS NOT DISTINCT FROM $1)
+          AND (t.goal_id = $1 OR c.goal_id = $1)
+        ORDER BY tc.task_id, tc.criterion_id
+        LIMIT 50`,
+      [goalId]
+    );
+    if (links.length > 0) {
+      throw Object.assign(new Error('criterion links cross the goal'), { code: 'CRITERION_LINKS_CROSS_GOAL', links });
+    }
+
+    // Appended to the end of the target's goal order rather than keeping a
+    // sort_order that meant something only among the old version's goals.
+    await client.query(
+      `UPDATE goals
+          SET version_id = $2,
+              sort_order = (SELECT COALESCE(MAX(sort_order), 0) + 10 FROM goals WHERE version_id = $2),
+              updated_at = now()
+        WHERE id = $1`,
+      [goalId, toVersionId]
+    );
+    let criterionIds;
+    try {
+      const { rows } = await client.query(
+        `UPDATE done_when_criteria SET version_id = $2 WHERE goal_id = $1 RETURNING id::text`,
+        [goalId, toVersionId]
+      );
+      criterionIds = rows.map((r) => r.id);
+    } catch (err) {
+      if (err && err.code === '23505') {
+        throw Object.assign(new Error('criterion id collision'), { code: 'CRITERION_ID_COLLISION' });
+      }
+      throw err;
+    }
+    const { rows: tasks } = await client.query(
+      `UPDATE tasks SET version_id = $2, updated_at = now() WHERE goal_id = $1 RETURNING id::text`,
+      [goalId, toVersionId]
+    );
+    // A building target was opened by the Archon override: recorded like a
+    // create's admission. goal_id is the table's key, so a goal admitted before
+    // carries its LATEST admission — the one that explains where it is now.
+    if (admission) {
+      await client.query(
+        `INSERT INTO lifecycle_goal_version_admissions (goal_id, version_id, admitted_by, reason)
+         VALUES ($1, $2, $3, $4)
+         ON CONFLICT (goal_id) DO UPDATE
+           SET version_id = EXCLUDED.version_id, admitted_by = EXCLUDED.admitted_by,
+               reason = EXCLUDED.reason, created_at = now()`,
+        [goalId, toVersionId, admission.admittedBy, admission.reason]
+      );
+    }
+
+    await client.query('COMMIT');
+    return {
+      fromVersionId: String(fromVersionId),
+      toVersionId: String(toVersionId),
+      taskIds: tasks.map((r) => r.id).sort((a, b) => Number(a) - Number(b)),
+      criterionIds: criterionIds.sort((a, b) => Number(a) - Number(b)),
+    };
+  } catch (err) {
+    await client.query('ROLLBACK').catch(() => {});
+    throw err;
+  } finally {
+    if (typeof client.release === 'function') client.release();
+  }
+}
+
+module.exports = { authorizeGoalMove, moveGoalToVersion };

package/modules/lifecycle/module.json

@@ -16,6 +16,7 @@
       "done-when",
       "criterion-uat",
       "goals",
+      "goal-move",
       "dependencies",
       "gate-approvals",
       "analytics",

package/modules/lifecycle/routes/goal-move.js

@@ -0,0 +1,92 @@
+'use strict';
+
+// modules/lifecycle/routes/goal-move.js — POST /goals/:id/move (task 1004485).
+//
+// Moves an open goal — its criteria and every task in it — to another version.
+// The rules and the write live in ../goal-move.js; this file is the doorway and
+// must never grow a query (the rot.js precedent).
+//
+// GATE: `version.create` (Archon floor). Re-homing a goal changes the scope of
+// TWO versions at once, which is the same authority as authoring a version's
+// scope in the first place — so it reuses that atom rather than minting a new
+// one, and adds no new authority to the system. Pinned in route-rank-check.
+//
+// Body: { version_id, admit_reason? } — `admit_reason` is the Archon override
+// that lets a goal into a version that is already building (the POST /goals R07
+// admission); on a planning target it is accepted and changes nothing.
+//
+// MODULE BOUNDARY: reaches core only through `../../../src/module-api`.
+
+const express = require('express');
+const api = require('../../../src/module-api');
+const db = require('../db');
+const goalMove = require('../goal-move');
+const { validateOrRespond, parseId } = api;
+
+const log = api.logger('lifecycle');
+
+module.exports = function buildGoalMoveRouter() {
+  const router = express.Router();
+
+  // rank: archon (perm:version.create) — re-homes a goal and its tasks across versions.
+  router.post('/goals/:id/move', api.requireBuilder, api.requirePermission('version.create'), async (req, res) => {
+    if (validateOrRespond(req, res, {
+      version_id: { required: true, type: 'string', minLength: 1, maxLength: 64 },
+      admit_reason: { type: 'string', maxLength: 2000 },
+    })) return;
+    const id = parseId(req, res, { code: 'bad_goal_id' });
+    if (id === null) return;
+    const admitReason = (req.body.admit_reason || '').trim() || null;
+    try {
+      const goal = await db.getGoal(id);
+      const [source, target] = goal
+        ? await Promise.all([db.getVersion(goal.version_id), db.getVersion(req.body.version_id)])
+        : [null, null];
+      const decision = goalMove.authorizeGoalMove({ goal, source, target, admitReason });
+      if (!decision.ok) return res.status(decision.status).json(decision.body);
+
+      const moved = await goalMove.moveGoalToVersion({
+        goalId: id,
+        fromVersionId: goal.version_id,
+        toVersionId: target.id,
+        targetStatus: target.status,
+        admission: decision.overrideApplied ? { admittedBy: req.builder.id, reason: admitReason } : null,
+      });
+      const updated = await db.getGoal(id);
+      return res.json({
+        ok: true,
+        goal: updated,
+        from_version_id: moved.fromVersionId,
+        to_version_id: moved.toVersionId,
+        moved_task_ids: moved.taskIds,
+        moved_criterion_ids: moved.criterionIds,
+        admitted: decision.overrideApplied,
+      });
+    } catch (err) {
+      if (err && err.code === 'CRITERION_LINKS_CROSS_GOAL') {
+        return res.fail('criterion_links_cross_goal', {
+          status: 409,
+          message: `Goal #${id} has criterion links that cross its edge — after the move they would join two versions. Unlink them (DELETE /tasks/:id/criteria/:criterionId) or move the task into the goal first. Nothing was changed.`,
+          details: { links: err.links },
+        });
+      }
+      if (err && err.code === 'CRITERION_ID_COLLISION') {
+        return res.fail('criterion_id_collision', {
+          status: 409,
+          message: `A criterion on goal #${id} uses a criterion_id the target version already has. Rename one of them first. Nothing was changed.`,
+        });
+      }
+      if (err && (err.code === 'GOAL_CHANGED' || err.code === 'TARGET_CHANGED')) {
+        return res.fail('changed_during_move', {
+          status: 409,
+          message: 'The goal or the target version changed while the move was running — nothing was changed. Re-read and retry.',
+        });
+      }
+      if (err && err.code === 'GOAL_NOT_FOUND') return res.fail('goal_not_found', 404);
+      log.error(`POST /goals/:id/move: ${err && err.message}`);
+      return res.fail('move_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
+  return router;
+};

package/package-lock.json

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

package/package.json

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

@@ -8519,5 +8519,11 @@
       "id": "1004486",
       "text": "Previewing an older version from the deploy page now works on the real server: the preview could not log in to its copy of the database, so every page in it failed. It also no longer leaves a full copy of the live database lyi"
     }
+  ],
+  "1.20.66": [
+    {
+      "id": "1004485",
+      "text": "Goals can now be moved from one version to another, taking their tasks and done-when criteria with them and keeping every task number. Used first to move the two goals that did not make V2 into V3."
+    }
   ]
 }

package/scripts/gds/goal.js

@@ -4,8 +4,11 @@
 // Usage:
 //   node scripts/gds/goal.js list [--version V] [--status open|achieved|archived|all]
 //   node scripts/gds/goal.js show <id>
+//   node scripts/gds/goal.js move <id> --to <version> [--admit-reason "..."]
 //
-// Read-only. Default list filter is --status open.
+// list/show are read-only; default list filter is --status open. `move` re-homes an
+// open goal — its criteria and every task in it — on another version (Archon;
+// POST /goals/:id/move, task 1004485).
 
 const { cliClient, requireSession, arg } = require('./cli-lib');
 
@@ -16,6 +19,7 @@ const LIST_STATUSES = ['open', 'achieved', 'archived', 'all'];
 function usageExit() {
   console.error('usage: node scripts/gds/goal.js list [--version V] [--status open|achieved|archived|all]');
   console.error('       node scripts/gds/goal.js show <id>');
+  console.error('       node scripts/gds/goal.js move <id> --to <version> [--admit-reason "..."]');
   process.exit(2);
 }
 
@@ -208,6 +212,38 @@ async function printTaskBuckets(api, tasks) {
   }
 }
 
+// parseMoveArgs — the argv after `move`: `<id> --to <version> [--admit-reason "..."]`.
+// Returns { id, body } or null (usage error). Pure, so the CLI's own validation
+// is tested rather than trusted (task 1004485).
+function parseMoveArgs(args) {
+  const id = args[0];
+  if (!/^\d+$/.test(id || '')) return null;
+  const rest = args.slice(1);
+  const to = arg('--to', rest);
+  if (!to || !/^[\w.-]+$/.test(to)) return null;
+  const body = { version_id: to };
+  const reason = arg('--admit-reason', rest);
+  if (reason) body.admit_reason = reason;
+  return { id: Number(id), body };
+}
+
+async function move(api, args) {
+  const parsed = parseMoveArgs(args);
+  if (!parsed) usageExit();
+  const { id, body } = parsed;
+  const r = await api.goals.postGoalsIdMove({ id, body });
+  if (!r.ok) {
+    console.error(`move refused (${r.status}):`, (r.data && (r.data.message || r.data.error)) || JSON.stringify(r.data));
+    if (r.data && r.data.details && r.data.details.links) console.error('  crossing links:', JSON.stringify(r.data.details.links));
+    process.exitCode = 1;
+    return;
+  }
+  const d = r.data;
+  console.log(`Goal #${d.goal.id} "${d.goal.title}" moved ${d.from_version_id} → ${d.to_version_id}${d.admitted ? ' (admitted into a building version)' : ''}.`);
+  console.log(`  tasks moved: ${d.moved_task_ids.length}${d.moved_task_ids.length ? ' (' + d.moved_task_ids.join(', ') + ')' : ''}`);
+  console.log(`  criteria moved: ${d.moved_criterion_ids.length}`);
+}
+
 async function main() {
   await requireSession();
   const args = process.argv.slice(2);
@@ -219,6 +255,8 @@ async function main() {
   } else if (cmd === 'show') {
     if (!/^\d+$/.test(args[1] || '')) usageExit();
     await show(api, Number(args[1]));
+  } else if (cmd === 'move') {
+    await move(api, args.slice(1));
   } else {
     usageExit();
   }
@@ -231,4 +269,4 @@ if (require.main === module) {
   });
 }
 
-module.exports = { rollup, criterionGlyph, criterionState, bucketTasks, liveTasks };
+module.exports = { rollup, criterionGlyph, criterionState, bucketTasks, liveTasks, parseMoveArgs };

package/src/bongos/route-rank-check.js

@@ -346,6 +346,9 @@ const MODULE_EXPECTED_RANKS = {
     // builder archive/resurrect a shared workspace out from under its members.
     'POST /goals/:id/archive': 'metic+archon',
     'POST /goals/:id/reopen': 'metic+archon',
+    // goal re-home across versions (task 1004485) — changes two versions' scope at
+    // once, so it carries the version-authoring atom (Archon floor), not a goal one.
+    'POST /goals/:id/move': 'perm:version.create',
     // The bounded task-authoring KEYSTONE + self-service membership (ADR 0086 §3,
     // BV1.R60/R61). These are DELIBERATELY 'any-builder': the wall is the IN-HANDLER
     // scope/protected/rank-floor gate (authorizeGoalTaskCreate + goal-scope-check),

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.20.65'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.20.66'; // 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('discord'); log.info('mounted');

package/tests/goal_move.mjs

@@ -0,0 +1,285 @@
+// tests/goal_move.mjs — POST /goals/:id/move re-homes a goal, whole, on another
+// version (task 1004485).
+//
+// Three layers, the goal_archive_disposition / goal_archive_route_e2e split in one
+// file: the pure gate's truth table, the writer's transaction shape against a fake
+// pool (every write inside ONE transaction, tasks moved by version_id AND goal,
+// the cross-goal criterion refusal BEFORE any write), and the real router over a
+// real socket with the db layer stubbed at the module boundary.
+//
+// Run:  node --test tests/goal_move.mjs
+
+import assert from 'node:assert/strict';
+import { test, after } from 'node:test';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { makeSqlAwareClient } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const { authorizeGoalMove, moveGoalToVersion } = require('../modules/lifecycle/goal-move.js');
+
+const OPEN_GOAL = { id: '7', version_id: 'V2', status: 'open', is_maintenance: false };
+const V2 = { id: 'V2', status: 'building' };
+const V3 = { id: 'V3', status: 'planning' };
+
+// ---- the pure gate ----------------------------------------------------------
+
+test('an open goal moves to the planning version', () => {
+  const d = authorizeGoalMove({ goal: OPEN_GOAL, source: V2, target: V3 });
+  assert.deepEqual(d, { ok: true, overrideApplied: false });
+});
+
+test('refusals, each by name', () => {
+  const cases = [
+    [{ goal: null, source: null, target: V3 }, 404, 'goal_not_found'],
+    [{ goal: { ...OPEN_GOAL, is_maintenance: true }, source: V2, target: V3 }, 409, 'maintenance_goal'],
+    [{ goal: { ...OPEN_GOAL, status: 'achieved' }, source: V2, target: V3 }, 409, 'goal_not_open'],
+    [{ goal: { ...OPEN_GOAL, status: 'archived' }, source: V2, target: V3 }, 409, 'goal_not_open'],
+    [{ goal: OPEN_GOAL, source: { id: 'V2', status: 'shipped' }, target: V3 }, 409, 'source_version_shipped'],
+    [{ goal: OPEN_GOAL, source: V2, target: V2 }, 409, 'same_version'],
+    [{ goal: OPEN_GOAL, source: V2, target: null }, 404, 'version_not_found'],
+    [{ goal: OPEN_GOAL, source: V2, target: { id: 'V1', status: 'shipped' } }, 409, 'version_closed'],
+    [{ goal: { ...OPEN_GOAL, version_id: 'V3' }, source: V3, target: V2 }, 409, 'version_not_planning'],
+  ];
+  for (const [input, status, error] of cases) {
+    const d = authorizeGoalMove(input);
+    assert.equal(d.ok, false, error);
+    assert.equal(d.status, status, error);
+    assert.equal(d.body.error, error);
+  }
+});
+
+test('a building target opens only with the admit_reason override, and says so', () => {
+  const goal = { ...OPEN_GOAL, version_id: 'V3' };
+  assert.deepEqual(authorizeGoalMove({ goal, source: V3, target: V2, admitReason: 'owner pulled it back' }),
+    { ok: true, overrideApplied: true });
+  // On a planning target the reason changes nothing — so nothing is recorded.
+  assert.deepEqual(authorizeGoalMove({ goal: OPEN_GOAL, source: V2, target: V3, admitReason: 'x' }),
+    { ok: true, overrideApplied: false });
+});
+
+// ---- the writer ---------------------------------------------------------------
+
+const flat = (q) => String(q.sql).replace(/\s+/g, ' ').trim();
+function txPool(handler) {
+  const c = makeSqlAwareClient(handler);
+  return { connect: c.connect, query: (sql, params) => c._client.query(sql, params), queries: c._client.queries };
+}
+function happyPool(over = {}) {
+  return txPool((q) => {
+    for (const [re, rows] of Object.entries(over)) if (new RegExp(re).test(q)) return { rows };
+    if (/FROM goals WHERE id = \$1 FOR UPDATE/.test(q)) return { rows: [{ id: '7', version_id: 'V2', status: 'open' }] };
+    if (/FROM versions WHERE id = \$1 FOR SHARE/.test(q)) return { rows: [{ status: 'planning' }] };
+    if (/FROM task_criteria/.test(q)) return { rows: [] };
+    if (/UPDATE done_when_criteria/.test(q)) return { rows: [{ id: '51' }] };
+    if (/UPDATE tasks/.test(q)) return { rows: [{ id: '12' }, { id: '3' }] };
+    return { rows: [] };
+  });
+}
+const ARGS = { goalId: 7, fromVersionId: 'V2', toVersionId: 'V3', targetStatus: 'planning' };
+
+test('goal, criteria and every task move inside ONE transaction', async () => {
+  const pool = happyPool();
+  const out = await moveGoalToVersion(ARGS, { pool });
+  assert.deepEqual(out, { fromVersionId: 'V2', toVersionId: 'V3', taskIds: ['3', '12'], criterionIds: ['51'] });
+  const sqls = pool.queries.map(flat);
+  const at = (re) => sqls.findIndex((s) => re.test(s));
+  assert.equal(sqls.filter((s) => s === 'BEGIN').length, 1);
+  assert.equal(sqls.filter((s) => s === 'COMMIT').length, 1);
+  for (const re of [/^UPDATE goals SET version_id = \$2/, /^UPDATE done_when_criteria SET version_id = \$2 WHERE goal_id = \$1/, /^UPDATE tasks SET version_id = \$2/]) {
+    const i = at(re);
+    assert.ok(i > at(/^BEGIN$/) && i < at(/^COMMIT$/), `${re} is inside the transaction`);
+  }
+  // Every task in the goal — not only the open ones — or a shipped task would be
+  // left in a goal of another version.
+  const taskWrite = sqls[at(/^UPDATE tasks/)];
+  assert.match(taskWrite, /WHERE goal_id = \$1 RETURNING/);
+  assert.doesNotMatch(taskWrite, /status/);
+  // The goal is locked before anything is read or written.
+  assert.ok(at(/FROM goals WHERE id = \$1 FOR UPDATE/) < at(/^UPDATE/));
+});
+
+test('a criterion link crossing the goal edge refuses BEFORE any write, and names the pair', async () => {
+  const pool = happyPool({ 'FROM task_criteria': [{ task_id: '12', criterion_id: '900' }] });
+  await assert.rejects(moveGoalToVersion(ARGS, { pool }), (e) => {
+    assert.equal(e.code, 'CRITERION_LINKS_CROSS_GOAL');
+    assert.deepEqual(e.links, [{ task_id: '12', criterion_id: '900' }]);
+    return true;
+  });
+  const sqls = pool.queries.map(flat);
+  assert.equal(sqls.filter((s) => /^UPDATE|^INSERT/.test(s)).length, 0, 'nothing written');
+  assert.ok(sqls.includes('ROLLBACK'));
+});
+
+test('the crossing test asks "exactly one side inside the goal"', async () => {
+  const pool = happyPool();
+  await moveGoalToVersion(ARGS, { pool });
+  const q = pool.queries.map(flat).find((s) => /FROM task_criteria/.test(s));
+  assert.match(q, /\(t\.goal_id IS NOT DISTINCT FROM \$1\) <> \(c\.goal_id IS NOT DISTINCT FROM \$1\)/);
+});
+
+test('a goal or target that changed since the route checked rolls back', async () => {
+  for (const [over, code] of [
+    [{ 'FROM goals WHERE id = \\$1 FOR UPDATE': [{ id: '7', version_id: 'V9', status: 'open' }] }, 'GOAL_CHANGED'],
+    [{ 'FROM goals WHERE id = \\$1 FOR UPDATE': [{ id: '7', version_id: 'V2', status: 'archived' }] }, 'GOAL_CHANGED'],
+    [{ 'FROM versions WHERE id = \\$1 FOR SHARE': [{ status: 'building' }] }, 'TARGET_CHANGED'],
+    [{ 'FROM goals WHERE id = \\$1 FOR UPDATE': [] }, 'GOAL_NOT_FOUND'],
+  ]) {
+    const pool = happyPool(over);
+    await assert.rejects(moveGoalToVersion(ARGS, { pool }), (e) => e.code === code);
+    assert.equal(pool.queries.map(flat).filter((s) => /^UPDATE/.test(s)).length, 0, code);
+  }
+});
+
+test('a criterion slug the target already uses becomes CRITERION_ID_COLLISION', async () => {
+  const pool = txPool((q) => {
+    if (/FROM goals WHERE id = \$1 FOR UPDATE/.test(q)) return { rows: [{ id: '7', version_id: 'V2', status: 'open' }] };
+    if (/FROM versions WHERE id = \$1 FOR SHARE/.test(q)) return { rows: [{ status: 'planning' }] };
+    if (/UPDATE done_when_criteria/.test(q)) throw Object.assign(new Error('dup'), { code: '23505' });
+    return { rows: [] };
+  });
+  await assert.rejects(moveGoalToVersion(ARGS, { pool }), (e) => e.code === 'CRITERION_ID_COLLISION');
+});
+
+test('the admission is written only when the override opened a building target', async () => {
+  const plain = happyPool();
+  await moveGoalToVersion(ARGS, { pool: plain });
+  assert.equal(plain.queries.map(flat).filter((s) => /lifecycle_goal_version_admissions/.test(s)).length, 0);
+
+  const admitted = happyPool({ 'FROM versions WHERE id = \\$1 FOR SHARE': [{ status: 'building' }] });
+  await moveGoalToVersion({ ...ARGS, targetStatus: 'building', admission: { admittedBy: '3', reason: 'r' } }, { pool: admitted });
+  const ins = admitted.queries.find((q) => /lifecycle_goal_version_admissions/.test(flat(q)));
+  assert.ok(ins, 'admission recorded');
+  assert.deepEqual(ins.params, [7, 'V3', '3', 'r']);
+});
+
+// ---- the route, over a real socket ---------------------------------------------
+
+const express = require('express');
+const api = require('../src/module-api.js');
+const db = require('../modules/lifecycle/db.js');
+const goalMove = require('../modules/lifecycle/goal-move.js');
+
+let permSeen = null;
+api.requireBuilder = (req, _res, next) => { req.builder = { id: '3', rank: 'archon' }; next(); };
+api.requirePermission = (...p) => { permSeen = p; return (_req, _res, next) => next(); };
+
+const GOALS = { 7: { ...OPEN_GOAL }, 8: { id: '8', version_id: 'V2', status: 'open', is_maintenance: true } };
+const VERSIONS = { V2, V3 };
+let writes = [];
+db.getGoal = async (id) => GOALS[Number(id)] ?? null;
+db.getVersion = async (id) => VERSIONS[id] ?? null;
+goalMove.moveGoalToVersion = async (args) => {
+  writes.push(args);
+  GOALS[args.goalId] = { ...GOALS[args.goalId], version_id: args.toVersionId };
+  return { fromVersionId: args.fromVersionId, toVersionId: args.toVersionId, taskIds: ['3', '12'], criterionIds: [] };
+};
+
+const app = express();
+app.use(express.json());
+app.use((req, res, next) => {
+  res.fail = (code, statusOrOpts, details) => {
+    const o = typeof statusOrOpts === 'number' ? { status: statusOrOpts } : (statusOrOpts || {});
+    return res.status(o.status || 400).json({ error: code, message: o.message, details: o.details ?? details });
+  };
+  next();
+});
+app.use('/api/gds', require('../modules/lifecycle/routes/goal-move.js')());
+const server = app.listen(0);
+await new Promise((r) => server.once('listening', r));
+after(() => server.close());
+const base = `http://127.0.0.1:${server.address().port}/api/gds`;
+const post = async (p, body) => {
+  const r = await fetch(base + p, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body ?? {}) });
+  return { status: r.status, body: await r.json().catch(() => null) };
+};
+
+test('the route is gated on the version-authoring atom', () => {
+  assert.deepEqual(permSeen, ['version.create']);
+  const pins = readFileSync(new URL('../src/bongos/route-rank-check.js', import.meta.url), 'utf8');
+  assert.match(pins, /'POST \/goals\/:id\/move': 'perm:version\.create'/);
+});
+
+test('a move returns the goal on its new version and the tasks that went with it', async () => {
+  writes = [];
+  const r = await post('/goals/7/move', { version_id: 'V3' });
+  assert.equal(r.status, 200, JSON.stringify(r.body));
+  assert.equal(r.body.goal.version_id, 'V3');
+  assert.equal(r.body.from_version_id, 'V2');
+  assert.deepEqual(r.body.moved_task_ids, ['3', '12']);
+  assert.equal(r.body.admitted, false);
+  assert.deepEqual(writes, [{ goalId: 7, fromVersionId: 'V2', toVersionId: 'V3', targetStatus: 'planning', admission: null }]);
+});
+
+test('a refused move writes nothing and renders the gate verbatim', async () => {
+  writes = [];
+  let r = await post('/goals/8/move', { version_id: 'V3' });
+  assert.equal(r.status, 409); assert.equal(r.body.error, 'maintenance_goal');
+  r = await post('/goals/404/move', { version_id: 'V3' });
+  assert.equal(r.status, 404); assert.equal(r.body.error, 'goal_not_found');
+  r = await post('/goals/8/move', {});
+  assert.equal(r.status, 400);
+  r = await post('/goals/8/move', { version_id: 'V3', versionid: 'typo' });
+  assert.equal(r.status, 400, 'an unknown field is rejected, not ignored');
+  assert.equal(writes.length, 0);
+});
+
+test('a crossing criterion link surfaces as 409 with the pairs', async () => {
+  GOALS[9] = { id: '9', version_id: 'V2', status: 'open', is_maintenance: false };
+  const real = goalMove.moveGoalToVersion;
+  goalMove.moveGoalToVersion = async () => { throw Object.assign(new Error('x'), { code: 'CRITERION_LINKS_CROSS_GOAL', links: [{ task_id: '1', criterion_id: '2' }] }); };
+  const r = await post('/goals/9/move', { version_id: 'V3' });
+  goalMove.moveGoalToVersion = real;
+  assert.equal(r.status, 409);
+  assert.equal(r.body.error, 'criterion_links_cross_goal');
+  assert.deepEqual(r.body.details.links, [{ task_id: '1', criterion_id: '2' }]);
+});
+
+// ---- the CLI wrapper ----------------------------------------------------------
+
+test('goal.js move parses a real goal id and version id, and refuses junk', () => {
+  const { parseMoveArgs } = require('../scripts/gds/goal.js');
+  assert.deepEqual(parseMoveArgs(['1000122', '--to', 'BONGOS-V3']), { id: 1000122, body: { version_id: 'BONGOS-V3' } });
+  assert.deepEqual(parseMoveArgs(['7', '--to=V3.1', '--admit-reason', 'owner call']),
+    { id: 7, body: { version_id: 'V3.1', admit_reason: 'owner call' } });
+  for (const bad of [[], ['abc', '--to', 'V3'], ['7'], ['7', '--to'], ['7', '--to', 'V 3'], ['7', '--to', 'V3;rm']]) {
+    assert.equal(parseMoveArgs(bad), null, JSON.stringify(bad));
+  }
+});
+
+// ---- version progress follows the move --------------------------------------
+//
+// The live view counts a version's tasks by tasks.version_id — so the counts move
+// with the goal exactly when the writer re-points every task's version_id, which
+// the transaction test above pins. Both halves are asserted here together: if the
+// view ever counted through goals instead, or the writer stopped touching
+// tasks.version_id, V2's progress would keep counting moved work.
+
+test('version_progress counts by tasks.version_id, and the move rewrites it for every task in the goal', async () => {
+  const { readdirSync } = await import('node:fs');
+  const files = readdirSync(new URL('../migrations/', import.meta.url)).filter((f) => f.endsWith('.sql')).sort();
+  const latest = files.filter((f) => /VIEW version_progress/.test(readFileSync(new URL('../migrations/' + f, import.meta.url), 'utf8'))).pop();
+  assert.ok(latest, 'version_progress view found');
+  const view = readFileSync(new URL('../migrations/' + latest, import.meta.url), 'utf8');
+  assert.match(view, /LEFT JOIN tasks t ON t\.version_id = v\.id/);
+
+  // Before/after against the writer's own statements: a goal holding tasks 3 and
+  // 12 on V2 — after the move both carry V3, so V2 counts 0 of them and V3 counts 2.
+  const tasks = [{ id: '3', goal_id: 7, version_id: 'V2' }, { id: '12', goal_id: 7, version_id: 'V2' }, { id: '99', goal_id: 8, version_id: 'V2' }];
+  const count = (v) => tasks.filter((t) => t.version_id === v).length;
+  assert.equal(count('V2'), 3); assert.equal(count('V3'), 0);
+  const pool = txPool((q, params) => {
+    if (/FROM goals WHERE id = \$1 FOR UPDATE/.test(q)) return { rows: [{ id: '7', version_id: 'V2', status: 'open' }] };
+    if (/FROM versions WHERE id = \$1 FOR SHARE/.test(q)) return { rows: [{ status: 'planning' }] };
+    if (/^UPDATE tasks SET version_id = \$2/.test(q)) {
+      const hit = tasks.filter((t) => t.goal_id === params[0]);
+      for (const t of hit) t.version_id = params[1];
+      return { rows: hit.map((t) => ({ id: t.id })) };
+    }
+    return { rows: [] };
+  });
+  await moveGoalToVersion(ARGS, { pool });
+  assert.equal(count('V2'), 1, 'only the other goal\'s task still counts on V2');
+  assert.equal(count('V3'), 2);
+});