@bongos/core 1.19.228 → 1.19.230

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.228",
-  "core_contract": "1.19.228",
-  "source_commit": "f14babca30bfba954ddd62b510ebc1ed4749d9fa",
+  "core_version": "1.19.230",
+  "core_contract": "1.19.230",
+  "source_commit": "d0c1085d2633cda96d73c28cdccd40f29771b832",
   "source_ref": "HEAD",
-  "built_at": "2026-08-18T05:08:08.027Z",
+  "built_at": "2026-08-18T11:23:52.179Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 311,
     "agent_docs_stubbed": 21,
-    "functional_verbatim": 1309,
+    "functional_verbatim": 1313,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 1641,
-  "tree_sha256": "2a30117336498006b3241dc75e5157ce5fdc462327dbdf3618e469ad9defb158",
+  "file_count": 1645,
+  "tree_sha256": "6054b1bf932dda1ffc30ce0208aef3e91b62da91beb916a454d51ec6deaf95b0",
   "files": [
     {
       "path": ".claude/skills/blocker-review/SKILL.md",
@@ -347,12 +347,12 @@
     {
       "path": "clients/bongos-client/README.md",
       "mode": "0000644",
-      "sha256": "f963a7ac5bccdc2811ea13f288ec9ff706b4c090ff0df185e9d3111d62194a5e"
+      "sha256": "ad3ebff5e165c917f14840844032150cacfb40335e29df7f23d51dbb0d475d21"
     },
     {
       "path": "clients/bongos-client/bongos-client.global.js",
       "mode": "0000644",
-      "sha256": "8b5bf5d1a077d73a402cbd3ddb215b021d764b9a0167185b072dcf41c802bc67"
+      "sha256": "e474bac9faa5da4da5098b736fd694a9a7ee327d7b952d08a4c366e70e253d84"
     },
     {
       "path": "clients/bongos-client/examples/hello-world.mjs",
@@ -362,17 +362,17 @@
     {
       "path": "clients/bongos-client/index.cjs",
       "mode": "0000644",
-      "sha256": "6bfe5877a0ee3bea5f6162298792a67bd40741786a3add959e237052255929c2"
+      "sha256": "b0bd3bbad51ea1b68f7fd36165d77fce12939cde82b37cd2266a00c103002f4b"
     },
     {
       "path": "clients/bongos-client/index.d.ts",
       "mode": "0000644",
-      "sha256": "68708a1f6a8c4a01dcc62306ee1d09a40f961698bbb0605454a2749514738da2"
+      "sha256": "7b1983354a89000e6d630d69c896515bac844a2e23a9b8c0da66e6c9b1f386d6"
     },
     {
       "path": "clients/bongos-client/index.mjs",
       "mode": "0000644",
-      "sha256": "8b8a1df89fcd53cae49b2f398ac335dc35fbfd3632a9d6c6e1fa49b8e8f4244b"
+      "sha256": "d61a7546173a2212e72c6cbee2ec67b193c3ef506d17ddbfe84e3786fb17cbab"
     },
     {
       "path": "clients/bongos-client/package.json",
@@ -1372,12 +1372,12 @@
     {
       "path": "docs/api-reference.md",
       "mode": "0000644",
-      "sha256": "981ce74f7c526b079ec880c5343d91f28bfba16c5446b19726d11669679ffdb7"
+      "sha256": "0f5532248c4c9554c20a6fc11bc60e696fadf996e1d6f7d049553b02614d5a2a"
     },
     {
       "path": "docs/api/openapi.json",
       "mode": "0000644",
-      "sha256": "af44a3a2e2b866f4d7effd64b910047aeda53d894e17b9e7fdbf7f33ad0b8502"
+      "sha256": "a983685efd08503f73301bf509dda382191aba27321116e064562c8d895ecc73"
     },
     {
       "path": "docs/architecture.md",
@@ -2687,7 +2687,7 @@
     {
       "path": "modules/dev-box/app/src/vendor/bongos-client.cjs",
       "mode": "0000644",
-      "sha256": "6bfe5877a0ee3bea5f6162298792a67bd40741786a3add959e237052255929c2"
+      "sha256": "b0bd3bbad51ea1b68f7fd36165d77fce12939cde82b37cd2266a00c103002f4b"
     },
     {
       "path": "modules/dev-box/app/test/unit.mjs",
@@ -2902,7 +2902,7 @@
     {
       "path": "modules/government/board.js",
       "mode": "0000644",
-      "sha256": "6a2b7ebfcbba1442f45efe6df40131b03455fa0fff9ecce51e87696a72c5b117"
+      "sha256": "5db387128d2f7a1ebc15fefaf1e97aabeda9196df34c91bdeb4a12e9301087f0"
     },
     {
       "path": "modules/government/catalog.js",
@@ -2917,7 +2917,7 @@
     {
       "path": "modules/government/db.js",
       "mode": "0000644",
-      "sha256": "e20e5a4aa8a79441e5860ceda2f19e41cbdb8fd85c0eda5d00f572eee5701f20"
+      "sha256": "e4ff648d5a9d83048214ff111768e5a2ae5e254f4b0a2f8f2fc966ce04138e21"
     },
     {
       "path": "modules/government/migrations/governance_001_tables.sql",
@@ -2979,10 +2979,20 @@
       "mode": "0000644",
       "sha256": "dc570f8871b578a8af965ffbc91fc4e195f2e7fce7d7886166f0025ac2b47bce"
     },
+    {
+      "path": "modules/government/migrations/government_006_returned_items_index.sql",
+      "mode": "0000644",
+      "sha256": "b2c06a954e93487f7df85eb7333c65284e364499fb96c31aad30a263c36b8f73"
+    },
     {
       "path": "modules/government/module.json",
       "mode": "0000644",
-      "sha256": "6ee190f95f9a5c7bbe6d4d4b193dff5116fe3c317ffcffc68512a40da7b1084c"
+      "sha256": "7baa08a671982532d9961164ffdb37b56bdf11bc8ba133739d3af07b54b0eaa8"
+    },
+    {
+      "path": "modules/government/pollers/board-expiry.js",
+      "mode": "0000644",
+      "sha256": "0e524bee731d9a6120cb98a23f419a2803f9bb19118f5e5aa46befd8e253e9ca"
     },
     {
       "path": "modules/government/protected-surfaces.js",
@@ -3007,7 +3017,7 @@
     {
       "path": "modules/government/routes/government.js",
       "mode": "0000644",
-      "sha256": "63ab50af4bc8d36db246eacfc9041c18cf0af89279f8ffe8e89f67978773401b"
+      "sha256": "34ff36c8ab99797a51b44cceacea2be00d73a5d2a1750d71d815a7c9111b1a3a"
     },
     {
       "path": "modules/government/routes/rank-sync.js",
@@ -3547,7 +3557,7 @@
     {
       "path": "modules/ideas/routes/inbox.js",
       "mode": "0000644",
-      "sha256": "9e9288725b66b696bdc565e693c82f046bd78665ae070e3f571ff987f82a7b7b"
+      "sha256": "f19fa968ad6fd08b65931039ecf3b8d4b31b1aabef56b42f62cd1a4fbd06328e"
     },
     {
       "path": "modules/ideas/templates.js",
@@ -4302,12 +4312,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "41bf0bb43e6a556ddf9598e5208bc478dd9bfc5d92f46ff64b6af6ef3ecac0eb"
+      "sha256": "ed784184ada68e6661376d541de1491914ae688e18213b306a6315366b571c7d"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "1b62282a15730fccfbe7ae8b3a2cb2321c4b1f9947bba37928150613db0e6d7d"
+      "sha256": "eb8fe0fd9cd657bba4b693eba9c949bc1bec7b64b0690a63f95e510afdf5693c"
     },
     {
       "path": "public-docs/index.html",
@@ -5922,7 +5932,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "985014c8a83781918e242757e48bf93cbc1df612b1eb4560177aeba85b30b0f7"
+      "sha256": "a15862c3769ab8efd7c3e87f535df17f692fe31d24476a5cef22be8d890e7a16"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -6849,6 +6859,11 @@
       "mode": "0000644",
       "sha256": "4408ec434f36b70a589b0592814733d3f88d48aa9aff38c08c9a2eb6c6c9f7b3"
     },
+    {
+      "path": "tests/government_board_expiry.mjs",
+      "mode": "0000644",
+      "sha256": "1bf22bc4ae339459e28a9f4e7975aac9e9d84eacd3f901d30371b44574f714c1"
+    },
     {
       "path": "tests/government_board_membership.mjs",
       "mode": "0000644",
@@ -6942,7 +6957,7 @@
     {
       "path": "tests/government_seed.mjs",
       "mode": "0000644",
-      "sha256": "8240fef8ed5b7e9a4c16e17e8dd5ffa522a99e320d41229f58f2214e00bcf160"
+      "sha256": "94e10e6d635ee8a4b16b33559bdfa30b7112bcc4a1fcfa59c30ee3648278f6a4"
     },
     {
       "path": "tests/government_session_scope.mjs",
@@ -7104,6 +7119,11 @@
       "mode": "0000644",
       "sha256": "729c511f9bb3d4a9b7fb76c7b3843e1900c8d4c9cfa30fe08e482d1e41113839"
     },
+    {
+      "path": "tests/idea_resubmit.mjs",
+      "mode": "0000644",
+      "sha256": "51e1286235cbde1b56188f29b0e2bd12ac73a9637dbf1c16b325f10147256f27"
+    },
     {
       "path": "tests/idea_task_lineage.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`)
-- 281 operations across 46 resource groups
+- 282 operations across 46 resource groups
 
 ## Install
 

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

@@ -383,6 +383,8 @@ function createClient(opts = {}) {
       patchInboxId: (args) => request("PATCH", "/inbox/{id}", { hasBody: true }, args),
       // POST /inbox/{id}/ratify — rank: metic+archon — POST /inbox/:id/ratify
       postInboxIdRatify: (args) => request("POST", "/inbox/{id}/ratify", { hasBody: true }, args),
+      // POST /inbox/{id}/resubmit — rank: any-builder — POST /inbox/:id/resubmit
+      postInboxIdResubmit: (args) => request("POST", "/inbox/{id}/resubmit", { hasBody: true }, args),
     },
     "instance": {
       // GET /instance — rank: public — GET /instance

package/clients/bongos-client/index.cjs

@@ -382,6 +382,8 @@ function createClient(opts = {}) {
       patchInboxId: (args) => request("PATCH", "/inbox/{id}", { hasBody: true }, args),
       // POST /inbox/{id}/ratify — rank: metic+archon — POST /inbox/:id/ratify
       postInboxIdRatify: (args) => request("POST", "/inbox/{id}/ratify", { hasBody: true }, args),
+      // POST /inbox/{id}/resubmit — rank: any-builder — POST /inbox/:id/resubmit
+      postInboxIdResubmit: (args) => request("POST", "/inbox/{id}/resubmit", { hasBody: true }, args),
     },
     "instance": {
       // GET /instance — rank: public — GET /instance

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

@@ -237,6 +237,7 @@ export interface PostGovernmentRanksRankKeyResetResponse { ok: boolean; rank_key
 export interface PostGovernmentRanksRequest { rank_key: string; label: string; description?: string }
 export interface PostGovernmentRanksResponse { rank: unknown }
 export interface PostInboxIdRatifyRequest { notes_md?: string }
+export interface PostInboxIdResubmitRequest { field_values: Record<string, unknown>; template_key?: string }
 export interface PostInboxRequest { title: string; body_md?: string; kind?: string; suggested_version?: string; suggested_priority?: number; grade?: string; template_key?: string; field_values?: Record<string, unknown> }
 export interface PostLearningsRequest { title: string; body_md: string; tags?: string[]; related_files?: string[]; source?: string; source_ref?: string; task_id?: number }
 export interface PostLearningsResponse { skipped?: boolean; reason?: unknown; learning?: unknown }
@@ -634,6 +635,8 @@ export interface BongosClient {
     patchInboxId(args?: RequestArgs & { body?: PatchInboxIdRequest }): Promise<PatchInboxIdResponse>;
     /** POST /inbox/{id}/ratify — rank: metic+archon */
     postInboxIdRatify(args?: RequestArgs & { body?: PostInboxIdRatifyRequest }): Promise<ApiResponse>;
+    /** POST /inbox/{id}/resubmit — rank: any-builder */
+    postInboxIdResubmit(args: RequestArgs & { body: PostInboxIdResubmitRequest }): Promise<ApiResponse>;
   };
   "instance": {
     /** GET /instance — rank: public */

package/clients/bongos-client/index.mjs

@@ -379,6 +379,8 @@ export function createClient(opts = {}) {
       patchInboxId: (args) => request("PATCH", "/inbox/{id}", { hasBody: true }, args),
       // POST /inbox/{id}/ratify — rank: metic+archon — POST /inbox/:id/ratify
       postInboxIdRatify: (args) => request("POST", "/inbox/{id}/ratify", { hasBody: true }, args),
+      // POST /inbox/{id}/resubmit — rank: any-builder — POST /inbox/:id/resubmit
+      postInboxIdResubmit: (args) => request("POST", "/inbox/{id}/resubmit", { hasBody: true }, args),
     },
     "instance": {
       // GET /instance — rank: public — GET /instance

package/docs/api/openapi.json

@@ -6030,6 +6030,62 @@
         ]
       }
     },
+    "/inbox/{id}/resubmit": {
+      "post": {
+        "operationId": "post_inbox_id_resubmit",
+        "tags": [
+          "inbox"
+        ],
+        "summary": "POST /inbox/:id/resubmit",
+        "description": "RESUBMIT a Full Idea after a rejection (R13 of goal 1000069, criterion C2: an idea never dies and never stalls). AUTHOR-ONLY, enforced in-handler against captured_by: the rejection went back to the originator, and only they can answer it — the same ownership posture as marking a spark (R144). Unbounded by design (the grade gate bounds spam), and every past rejection stays visible: the closed board items and their objection votes are permanent rows, and this writes a NEW grade + opens a NEW window rather than editing history. THE FEEDBACK LOOP, both rejection sources, one shape: • a board return → the objection (reason + flagged section) off the most recent returned item, via the government port; • a sub-bar grade → the weakest-section flag, recomputed from the OLD field_values (derived, never stored — R09). The response says whether the FLAGGED SECTION actually changed, computed per-field exactly because completeness.js scores per-field: a resubmission that reworked everything EXCEPT what was objected to is told so plainly.\n\n**Rank:** `any-builder` — Any authenticated builder (row-level ownership enforced in-handler).",
+        "x-rank": "any-builder",
+        "x-source": "modules/ideas/routes/inbox.js",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "Path parameter `id`."
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/PostInboxIdResubmitRequest"
+              }
+            }
+          },
+          "x-validated": true
+        },
+        "responses": {
+          "200": {
+            "description": "Success."
+          },
+          "400": {
+            "$ref": "#/components/responses/ValidationFailed"
+          },
+          "401": {
+            "$ref": "#/components/responses/Unauthorized"
+          },
+          "403": {
+            "$ref": "#/components/responses/Forbidden"
+          },
+          "404": {
+            "$ref": "#/components/responses/NotFound"
+          }
+        },
+        "security": [
+          {
+            "builderSession": []
+          }
+        ]
+      }
+    },
     "/instance": {
       "get": {
         "operationId": "get_instance",
@@ -16102,6 +16158,22 @@
         },
         "additionalProperties": false
       },
+      "PostInboxIdResubmitRequest": {
+        "type": "object",
+        "properties": {
+          "field_values": {
+            "type": "object"
+          },
+          "template_key": {
+            "type": "string",
+            "maxLength": 64
+          }
+        },
+        "required": [
+          "field_values"
+        ],
+        "additionalProperties": false
+      },
       "PostInboxRequest": {
         "type": "object",
         "properties": {
@@ -17809,8 +17881,8 @@
       "description": "A required dependency/feature is not configured or is temporarily down."
     }
   },
-  "x-endpoint-count": 281,
-  "x-schema-count": 318,
+  "x-endpoint-count": 282,
+  "x-schema-count": 319,
   "x-undocumented-bodies": 8,
   "x-response-schemas": 214,
   "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. 281 endpoints across 46 route files.
+> **Generated from the live route files** — the route file is authoritative. 282 endpoints across 46 route files.
 > Machine-readable spec: [`docs/api/openapi.json`](api/openapi.json) (OpenAPI 3.1). Rendered docs site: **`/docs`** (e.g. `cloudbongos.com/docs`).
 
 Base path: `/api/bongos`. Ranks (enforced server-side, [ADR 0016](adr/<redacted>.md)): `public` < `any-builder` < `metic+archon` < `archon`.
@@ -243,7 +243,7 @@ Base path: `/api/bongos`. Ranks (enforced server-side, [ADR 0016](adr/<redacted>
 |---|---|---|---|---|
 | GET | `/api/bongos/healthz` | `public` | — | liveness probe; status.example.com hits this anonymously. |
 
-## `inbox` (5)
+## `inbox` (6)
 
 | Method | Path | Rank | Body | Description |
 |---|---|---|---|---|
@@ -252,6 +252,7 @@ Base path: `/api/bongos`. Ranks (enforced server-side, [ADR 0016](adr/<redacted>
 | GET | `/api/bongos/inbox/:id` | `any-builder` | — | single idea read for the "#NNN" deep-link resolver (task 1047). |
 | PATCH | `/api/bongos/inbox/:id` | `metic+archon` | `status`, `kind`, `promoted_to_task_id`, `reviewed_at`, `merged_into_idea_id`, `triage_note` | Metic+ (task 360 / ADR 0018): idea triage (promote/discard/merge) shapes the backlog. |
 | POST | `/api/bongos/inbox/:id/ratify` | `metic+archon` | `notes_md` | V3.R31 (task 252) — Archon ratifies a criterion-proposal idea, atomically: - INSERT done_when_criteria row on the target version - UPDATE… |
+| POST | `/api/bongos/inbox/:id/resubmit` | `any-builder` | `field_values`, `template_key` | RESUBMIT a Full Idea after a rejection (R13 of goal 1000069, criterion C2: an idea never dies and never stalls). |
 
 ## `instance` (1)
 

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

@@ -382,6 +382,8 @@ function createClient(opts = {}) {
       patchInboxId: (args) => request("PATCH", "/inbox/{id}", { hasBody: true }, args),
       // POST /inbox/{id}/ratify — rank: metic+archon — POST /inbox/:id/ratify
       postInboxIdRatify: (args) => request("POST", "/inbox/{id}/ratify", { hasBody: true }, args),
+      // POST /inbox/{id}/resubmit — rank: any-builder — POST /inbox/:id/resubmit
+      postInboxIdResubmit: (args) => request("POST", "/inbox/{id}/resubmit", { hasBody: true }, args),
     },
     "instance": {
       // GET /instance — rank: public — GET /instance

package/modules/government/board.js

@@ -351,6 +351,28 @@ async function maybeCloseAfterVote(itemId) {
   return closeItem(item, { cause: 'vote' });
 }
 
+// ── R13's read: the feedback a returned idea carries back to its author ─────
+//
+// One reasoned objection is what returns an idea (§3), so the feedback IS that
+// vote's reason + flagged section, straight off the most recent returned item.
+// Null when this idea has never been returned by the board — the caller (the
+// ideas resubmit path) falls back to the sub-bar weakest-section flag, which is
+// derivable from the stored field_values at any time (R09). Shape mirrors the
+// vote payload so the return flow renders ONE thing for both rejection sources.
+async function latestRejectionForIdea(ideaId) {
+  const id = Number(ideaId);
+  if (!Number.isFinite(id) || id <= 0) return null;
+  const row = await db.getLatestReturnedItemWithObjection('full_idea', id);
+  if (!row) return null;
+  return Object.freeze({
+    source: 'board',
+    item_id: row.item_id,
+    section_key: row.section_key || null,
+    reason_md: row.reason_md || null,
+    closed_at: row.closed_at,
+  });
+}
+
 module.exports = {
   FULL_IDEA_PASS_BAR,
   ideaPassesBar,
@@ -366,4 +388,5 @@ module.exports = {
   passPayload,
   closeItem,
   maybeCloseAfterVote,
+  latestRejectionForIdea,
 };

package/modules/government/db.js

@@ -437,6 +437,44 @@ async function getIdeaCompleteness(ideaId) {
   return rows[0] ? rows[0].completeness_score : null;
 }
 
+// R13's read: the most recent RETURNED item for a subject, carrying its
+// objection (the single 'no' vote — one reasoned objection is what returns an
+// idea, ADR 0175 §3). LEFT JOIN because a returned-by-expiry item could in
+// principle carry no objection row; the caller falls back to the sub-bar flag.
+async function getLatestReturnedItemWithObjection(subjectType, subjectId) {
+  // Ordering is doubly deterministic: the LATEST returned item, then that
+  // item's FIRST objection (v.cast_at, id as the tiebreak). Under consent
+  // several members can object before the sitting ends; the first objection is
+  // the one that decided the outcome, so it is the feedback the author answers.
+  // Indexed by government_006's returned-items index — this runs on every
+  // resubmit, and the items table only grows.
+  const { rows } = await pool.query(
+    `SELECT i.id AS item_id, i.closed_at, v.reason_md, v.section_key, v.voter_id
+       FROM government_board_items i
+       LEFT JOIN government_board_votes v ON v.item_id = i.id AND v.direction = 'no'
+      WHERE i.subject_type = $1 AND i.subject_id = $2 AND i.outcome = 'returned'
+      ORDER BY i.closed_at DESC, v.cast_at ASC, v.id ASC
+      LIMIT 1`,
+    [subjectType, subjectId],
+  );
+  return rows[0] || null;
+}
+
+// The expiry sweep's read (R11): every OPEN item whose deadline has passed, on
+// the database clock, oldest deadline first. Served by the partial index
+// government_board_items_open_by_deadline (government_003 built it for exactly
+// this). NULL closes_at — the no-clock configuration — never appears here.
+async function getExpiredOpenBoardItems(limit = 100) {
+  const { rows } = await pool.query(
+    `SELECT * FROM government_board_items
+      WHERE closed_at IS NULL AND closes_at IS NOT NULL AND closes_at < now()
+      ORDER BY closes_at
+      LIMIT $1`,
+    [limit],
+  );
+  return rows;
+}
+
 // Author-ratification karma (+3, board.js AUTHOR_RATIFY_KARMA_DELTA) — fired by
 // the R10 close on a passed item. IDEMPOTENT: the reason key is unique per item
 // and the INSERT is one atomic WHERE-NOT-EXISTS statement (the economy
@@ -491,4 +529,6 @@ module.exports = {
   getVotesForItem,
   closeBoardItem,
   getIdeaCompleteness,
+  getExpiredOpenBoardItems,
+  getLatestReturnedItemWithObjection,
 };

package/modules/government/migrations/government_006_returned_items_index.sql

@@ -0,0 +1,21 @@
+-- government_006_returned_items_index.sql — index the returned-item lookup
+-- (task 1003026 / R13 of goal 1000069; a grader efficiency finding, and right).
+--
+-- getLatestReturnedItemWithObjection runs on EVERY resubmit: "the most recent
+-- RETURNED item for this subject". government_board_items only grows — one row
+-- per window, resubmission is unbounded by design — and the table's two
+-- existing partial indexes both cover OPEN items (closed_at IS NULL), so this
+-- closed-row lookup would otherwise scan historical volume that scales with
+-- every sitting the project has ever held.
+--
+-- Partial on outcome='returned' (the only outcome the read asks for), keyed to
+-- match the query's WHERE + ORDER BY exactly. Additive, idempotent, no rows
+-- touched — safe on any database state.
+
+BEGIN;
+
+CREATE INDEX IF NOT EXISTS government_board_items_returned_by_subject
+  ON government_board_items (subject_type, subject_id, closed_at DESC)
+  WHERE outcome = 'returned';
+
+COMMIT;

package/modules/government/module.json

@@ -12,6 +12,9 @@
     "routes": [
       "government",
       "rank-sync"
+    ],
+    "pollers": [
+      "board-expiry"
     ]
   },
   "provides": [

package/modules/government/pollers/board-expiry.js

@@ -0,0 +1,101 @@
+'use strict';
+
+// modules/government/pollers/board-expiry.js — the window expiry sweep
+// (BV1.R11 of goal 1000069, ADR 0175 §2).
+//
+// A window closes ON TIME with nobody touching it. The clock is the sitting
+// model's deadlock exit — absent members drop out of the denominator and the
+// deadline ends the sitting — so this poller is what makes the timed half of
+// the constitution real. It calls the SAME closeItem the post-vote path calls
+// (R10), so a clock-close and a turnout-close can never mean different things,
+// and the single-winner UPDATE makes racing one of them against a landing vote
+// safe: exactly one outcome is written.
+//
+// THE SWEEP SHAPE follows the publish reconciler (the in-tree precedent the
+// spec names): a bounded per-sweep read, PER-ITEM failure isolation (one item
+// that cannot close must not stall the item behind it), and a per-item
+// DISPOSITION LINE so a stuck window is visible in the journal rather than
+// silent. Unlike the reconciler it stays QUIET on an empty sweep — a
+// minute-cadence poller logging every tick would bury the journal (the
+// reconciler's own warn-once lesson).
+//
+// CADENCE: windows are minutes-granular (the recommended sitting is 90
+// minutes), so a one-minute sweep bounds lateness at ~1 minute — tight enough
+// that "closes on time" is honest, cheap enough that the query (one indexed
+// read; government_board_items_open_by_deadline exists for exactly this, per
+// government_003's own comment) is negligible. Concurrent windows are normal
+// (owner decision 10): the sweep closes every due item, oldest deadline first.
+
+const board = require('../board');
+const db = require('../db');
+
+const INTERVAL_MS = Number(process.env.BOARD_EXPIRY_SWEEP_MS) || 60_000;
+// A first sweep shortly after boot, so windows that expired while the process
+// was down (a deploy restart mid-sitting) close promptly rather than one full
+// interval late.
+const FIRST_SWEEP_DELAY_MS = Number(process.env.BOARD_EXPIRY_FIRST_MS) || 15_000;
+// Runaway guard, not an expected bound — a project rarely has more than a
+// handful of open windows (the board's subjects are rare by construction).
+const SWEEP_LIMIT = 100;
+
+let intervalTimer = null;
+let firstTimer = null;
+
+// One sweep. Injectable deps keep it DB-free testable: listFn yields the due
+// items, closeFn closes one, log receives the disposition lines.
+async function runSweep({ listFn = db.getExpiredOpenBoardItems, closeFn = board.closeItem, log = console.log, error = console.error } = {}) {
+  let due;
+  try {
+    due = await listFn(SWEEP_LIMIT);
+  } catch (e) {
+    error(`[board-expiry] sweep read failed: ${e && e.message}`);
+    return { closed: 0, failed: 0, due: 0 };
+  }
+  if (!due || !due.length) return { closed: 0, failed: 0, due: 0 }; // quiet on empty
+  let closed = 0;
+  let failed = 0;
+  for (const item of due) {
+    try {
+      const out = await closeFn(item, { cause: 'expiry' });
+      if (out && out.closed) {
+        closed += 1;
+        log(`[board-expiry] item ${item.id} (${item.subject_type} ${item.subject_id}) expired → ${out.outcome}`);
+      } else {
+        // A racer (a landing vote's close) beat the sweep — the item is closed,
+        // just not by us. That is the single-winner design working; say so.
+        log(`[board-expiry] item ${item.id} already closed by a racer — nothing to do`);
+      }
+    } catch (e) {
+      failed += 1;
+      // Per-item isolation: name the item and keep sweeping. A close that
+      // throws here (e.g. the in-tx credit failing) has ROLLED BACK, so the
+      // item is still open and the next sweep retries it — the pass-event
+      // contract's "retried, never silently unpaid".
+      error(`[board-expiry] item ${item.id} failed to close (still open; next sweep retries): ${e && e.message}`);
+    }
+  }
+  return { closed, failed, due: due.length };
+}
+
+function start(deps = {}) {
+  if (process.env.BOARD_EXPIRY_DISABLED === '1') {
+    console.log('[board-expiry] disabled (BOARD_EXPIRY_DISABLED=1)');
+    return;
+  }
+  if (intervalTimer) return; // already started
+  const tick = () => {
+    runSweep(deps).catch((e) => console.error(`[board-expiry] sweep crashed: ${e && e.message}`));
+  };
+  firstTimer = setTimeout(tick, FIRST_SWEEP_DELAY_MS);
+  if (firstTimer.unref) firstTimer.unref();
+  intervalTimer = setInterval(tick, INTERVAL_MS);
+  if (intervalTimer.unref) intervalTimer.unref(); // never hold the process open on a restart
+  console.log(`[board-expiry] started (every ${Math.round(INTERVAL_MS / 1000)}s; first sweep in ${Math.round(FIRST_SWEEP_DELAY_MS / 1000)}s)`);
+}
+
+function stop() {
+  if (firstTimer) { clearTimeout(firstTimer); firstTimer = null; }
+  if (intervalTimer) { clearInterval(intervalTimer); intervalTimer = null; }
+}
+
+module.exports = { start, stop, runSweep, INTERVAL_MS, SWEEP_LIMIT };

package/modules/government/routes/government.js

@@ -91,6 +91,10 @@ const governmentPort = {
   // bar gate lives INSIDE board.js (a sub-bar idea never reaches the board, and
   // no caller is trusted to pre-filter). Returns, never throws into capture.
   openBoardWindowForIdea: board.openWindowForFullIdea,
+  // R13: the feedback a board-returned idea carries back to its author — the
+  // resubmit path in modules/ideas resolves this to show what was objected to
+  // and to check whether the flagged section actually changed.
+  latestRejectionForIdea: board.latestRejectionForIdea,
 };
 
 function registerSeams() {

package/modules/ideas/routes/inbox.js

@@ -254,6 +254,118 @@ module.exports = function buildInboxRouter() {
     }
   });
 
+  // rank: any-builder — RESUBMIT a Full Idea after a rejection (R13 of goal
+  // 1000069, criterion C2: an idea never dies and never stalls). AUTHOR-ONLY,
+  // enforced in-handler against captured_by: the rejection went back to the
+  // originator, and only they can answer it — the same ownership posture as
+  // marking a spark (R144). Unbounded by design (the grade gate bounds spam),
+  // and every past rejection stays visible: the closed board items and their
+  // objection votes are permanent rows, and this writes a NEW grade + opens a
+  // NEW window rather than editing history.
+  //
+  // THE FEEDBACK LOOP, both rejection sources, one shape:
+  //   • a board return → the objection (reason + flagged section) off the most
+  //     recent returned item, via the government port;
+  //   • a sub-bar grade → the weakest-section flag, recomputed from the OLD
+  //     field_values (derived, never stored — R09).
+  // The response says whether the FLAGGED SECTION actually changed, computed
+  // per-field exactly because completeness.js scores per-field: a resubmission
+  // that reworked everything EXCEPT what was objected to is told so plainly.
+  router.post('/inbox/:id/resubmit', api.requireBuilder, async (req, res) => {
+    const id = parseId(req, res, { code: 'bad_id', positiveInt: true });
+    if (id === null) return;
+    if (validateOrRespond(req, res, {
+      field_values: { required: true, type: 'object' },
+      template_key: { type: 'string', maxLength: 64 },
+    })) return;
+    try {
+      const idea = await inbox.getIdea(id);
+      if (!idea) return res.fail('idea_not_found', 404);
+      if (String(idea.captured_by) !== String(req.builder.id)) {
+        return res.fail('not_your_idea', 403, { reason: 'a rejection returns to its ORIGINATOR; only they can resubmit' });
+      }
+      if (idea.grade !== 'full') {
+        return res.fail('not_a_full_idea', 409, { grade: idea.grade, reason: 'resubmission is the Full Idea loop; a quick idea has no grade to answer' });
+      }
+      const templateKey = req.body.template_key ?? idea.template_key ?? undefined;
+      let v;
+      try {
+        v = validateFieldValues(req.body.field_values, templateKey ? { templateKey } : undefined);
+      } catch (validationErr) {
+        console.error('[gds] POST /inbox/:id/resubmit validation threw:', validationErr);
+        return res.fail('invalid_field_values', 400, { errors: [{ field: null, reason: 'unvalidatable' }] });
+      }
+      if (!v.ok) return res.fail('invalid_field_values', 400, { errors: v.errors, template_key: templateKey ?? null });
+
+      // What was flagged, before the old values are overwritten. Board return
+      // first (the human objection outranks the mechanical flag); sub-bar flag
+      // as the fallback; null when this idea was never rejected at all (a
+      // resubmit is then just a revision — still legal, still rescored).
+      const government = api.resolveOptional && api.resolveOptional('government');
+      let rejection = null;
+      if (government && government.latestRejectionForIdea) {
+        try { rejection = await government.latestRejectionForIdea(id); }
+        catch (e) { console.error('[gds] resubmit: rejection lookup failed (continuing without):', e); }
+      }
+      if (!rejection || !rejection.section_key) {
+        const flag = weakestSectionPayload(idea.field_values, templateKey ? { templateKey } : undefined);
+        if (flag) rejection = { source: 'grade', ...flag };
+      }
+      const flaggedKey = rejection && rejection.section_key ? rejection.section_key : null;
+      const oldFlagged = flaggedKey && idea.field_values ? String(idea.field_values[flaggedKey] ?? '').trim() : null;
+      const newFlagged = flaggedKey ? String(req.body.field_values[flaggedKey] ?? '').trim() : null;
+      const flaggedSectionChanged = flaggedKey ? oldFlagged !== newFlagged : null;
+
+      // The whole-row grade write (setIdeaGrade's documented semantics — a
+      // partial merge would inherit stale fields, the exact bug its contract
+      // names), then the SAME post-grade chain capture runs: the idempotent
+      // stream-2 credit (an idea that first passes on resubmission earns it
+      // now; an already-paid one books nothing), and the R07 window hook — the
+      // prior item is CLOSED, so the partial unique index admits a NEW window.
+      const row = await inbox.setIdeaGrade(id, {
+        grade: 'full',
+        ...(templateKey ? { templateKey } : {}),
+        fieldValues: req.body.field_values,
+        completenessScore: completenessScore(req.body.field_values, templateKey ? { templateKey } : undefined),
+      });
+      const out = { ...idea, grade: row.grade, template_key: row.template_key, field_values: row.field_values, completeness_score: row.completeness_score };
+
+      try {
+        const reward = api.resolveOptional && api.resolveOptional('reward');
+        if (reward && reward.awardIdeaFullPassCredit) {
+          const r = await reward.awardIdeaFullPassCredit(api.pool, { ideaId: id, authorId: req.builder.id, completenessScore: row.completeness_score });
+          if (r && r.credited > 0) out.ideator_credit = r.credited;
+        }
+      } catch (creditErr) {
+        console.error('[gds] resubmit: pass-credit failed (regrade intact, credit skipped):', creditErr);
+      }
+
+      let board_window;
+      try {
+        if (government && government.openBoardWindowForIdea) {
+          const w = await government.openBoardWindowForIdea({ ideaId: id, completenessScore: row.completeness_score });
+          if (w && w.opened && w.item) board_window = { item_id: w.item.id, closes_at: w.item.closes_at };
+          else if (w && w.reason === 'below_bar') {
+            const flag = weakestSectionPayload(req.body.field_values, templateKey ? { templateKey } : undefined);
+            if (flag) out.rejection = flag; // still short — the NEW weakest section, fresh feedback
+          }
+        }
+      } catch (boardErr) {
+        console.error('[gds] resubmit: board-window open failed (regrade intact, window skipped):', boardErr);
+      }
+
+      res.json({
+        idea: out,
+        resubmitted: true,
+        ...(flaggedKey ? { flagged_section: flaggedKey, flagged_section_changed: flaggedSectionChanged, rejection_source: rejection.source || 'board' } : {}),
+        ...(board_window ? { board_window } : {}),
+      });
+    } catch (err) {
+      console.error('[gds] POST /inbox/:id/resubmit', err);
+      res.fail('resubmit_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
   // Metic+ (#360 / ADR 0018): idea triage (promote/discard/merge) shapes the
   // backlog. Criterion C2 assigns triage to Metic, so this widened from
   // archon-only to metic+archon when the three-rank model went live. Any

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.228",
+  "version": "1.19.230",
   "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/src/module-api.js

@@ -883,8 +883,12 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         landed since 1.19.226 with no explicit bump. run 32101041951. (task 1002620)
 //   1.19.228 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
 //         landed since 1.19.227 with no explicit bump. run 32101659669. (task 1002620)
+//   1.19.229 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.228 with no explicit bump. run 32130159805. (task 1002620)
+//   1.19.230 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.229 with no explicit bump. run 32131450528. (task 1002620)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.228'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.230'; // CI auto-patch carrier (ADR 0161); see changelog above
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/government_board_expiry.mjs

@@ -0,0 +1,109 @@
+// tests/government_board_expiry.mjs — the window expiry poller (BV1.R11 of
+// goal 1000069, ADR 0175 §2): a window closes on time with nobody touching it.
+//
+// DB-free: runSweep takes injectable deps (the reconciler's testable shape).
+// What must hold:
+//   1. EVERY due item is closed through the SAME closeItem R10 built, with
+//      cause 'expiry' — a clock-close and a turnout-close are one path.
+//   2. PER-ITEM ISOLATION — an item that fails to close (rolled back, still
+//      open, retried next sweep) must not stall the items behind it.
+//   3. DISPOSITIONS ARE VISIBLE — a closed item and a racer-beaten item each
+//      log a line; an EMPTY sweep logs nothing (a minute-cadence poller must
+//      not bury the journal).
+//   4. The timers never hold the process open, and stop() is clean.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const GOV = path.join(ROOT, 'modules', 'government');
+const poller = require(path.join(GOV, 'pollers', 'board-expiry.js'));
+
+const item = (id, over = {}) => ({ id: String(id), subject_type: 'full_idea', subject_id: String(id * 10), closed_at: null, ...over });
+
+test('every due item closes via closeItem with cause expiry — concurrent windows are normal', async () => {
+  const closed = [];
+  const lines = [];
+  const out = await poller.runSweep({
+    listFn: async (limit) => { assert.equal(limit, poller.SWEEP_LIMIT); return [item(1), item(2), item(3)]; },
+    closeFn: async (it, opts) => { closed.push([it.id, opts.cause]); return { closed: true, outcome: 'passed' }; },
+    log: (l) => lines.push(l),
+    error: () => { throw new Error('no errors expected'); },
+  });
+  assert.deepEqual(closed, [['1', 'expiry'], ['2', 'expiry'], ['3', 'expiry']]);
+  assert.deepEqual(out, { closed: 3, failed: 0, due: 3 });
+  assert.equal(lines.length, 3, 'one disposition line per closed item');
+  assert.ok(lines[0].includes('expired → passed'));
+});
+
+test('one failing item does not stall the sweep — named, counted, retried next time', async () => {
+  const closed = [];
+  const errors = [];
+  const out = await poller.runSweep({
+    listFn: async () => [item(1), item(2), item(3)],
+    closeFn: async (it) => {
+      if (it.id === '2') throw new Error('credit write refused — close rolled back');
+      closed.push(it.id);
+      return { closed: true, outcome: 'returned' };
+    },
+    log: () => {},
+    error: (l) => errors.push(l),
+  });
+  assert.deepEqual(closed, ['1', '3'], 'the items behind the failure still closed');
+  assert.deepEqual(out, { closed: 2, failed: 1, due: 3 });
+  assert.equal(errors.length, 1);
+  assert.ok(errors[0].includes('item 2') && errors[0].includes('next sweep retries'),
+    'the stuck window is visible, and the retry story is stated');
+});
+
+test('a racer-beaten item is a disposition, not an error — the single-winner design working', async () => {
+  const lines = [];
+  const out = await poller.runSweep({
+    listFn: async () => [item(7)],
+    closeFn: async () => ({ closed: false, reason: 'already_closed' }),
+    log: (l) => lines.push(l),
+    error: () => { throw new Error('not an error'); },
+  });
+  assert.deepEqual(out, { closed: 0, failed: 0, due: 1 });
+  assert.ok(lines[0].includes('already closed by a racer'));
+});
+
+test('an empty sweep is SILENT, and a failed read is one error line, not a crash', async () => {
+  const lines = [];
+  const errors = [];
+  assert.deepEqual(await poller.runSweep({ listFn: async () => [], log: (l) => lines.push(l), error: (l) => errors.push(l) }),
+    { closed: 0, failed: 0, due: 0 });
+  assert.equal(lines.length, 0, 'a minute-cadence poller must not bury the journal');
+  assert.deepEqual(await poller.runSweep({ listFn: async () => { throw new Error('db down'); }, log: () => {}, error: (l) => errors.push(l) }),
+    { closed: 0, failed: 0, due: 0 });
+  assert.equal(errors.length, 1);
+});
+
+test('the sweep read is indexed, deadline-ordered, and never sees a no-clock item (SQL pins)', () => {
+  const src = fs.readFileSync(path.join(GOV, 'db.js'), 'utf8');
+  const block = src.slice(src.indexOf('async function getExpiredOpenBoardItems'), src.indexOf('// Author-ratification karma'));
+  assert.match(block, /closed_at IS NULL AND closes_at IS NOT NULL AND closes_at < now\(\)/,
+    'open + due, on the DATABASE clock; NULL closes_at (no clock) never expires');
+  assert.match(block, /ORDER BY closes_at/, 'oldest deadline first');
+  const migration = fs.readFileSync(path.join(GOV, 'migrations', 'government_003_board_tables.sql'), 'utf8');
+  assert.ok(migration.includes('government_board_items_open_by_deadline'),
+    'the partial index government_003 built for this sweep exists');
+});
+
+test('the manifest declares the poller, and start/stop are idempotent + unref-safe', () => {
+  const manifest = JSON.parse(fs.readFileSync(path.join(GOV, 'module.json'), 'utf8'));
+  assert.ok(manifest.contributes.pollers.includes('board-expiry'),
+    'the loader starts it only when declared (startModulePollers contract)');
+  // Behavioural start/stop with the sweep stubbed inert: no timer may survive stop().
+  poller.start({ listFn: async () => [], log: () => {}, error: () => {} });
+  poller.start(); // second start is a no-op (already started)
+  poller.stop();
+  poller.stop(); // second stop is a no-op
+  // The timers are unref'd in start(); nothing to await — reaching here without
+  // the test runner hanging IS the assertion.
+  assert.ok(true);
+});

package/tests/government_seed.mjs

@@ -38,6 +38,7 @@ const NON_GRANT_MIGRATIONS = new Set([
   'government_002_rename_permission_keys.sql',     // ADR 0174 key rename (task 1003006)
   'government_003_board_tables.sql',               // ADR 0175 Board Room schema (task 1003016)
   'government_005_seeded_rank_descriptions.sql',   // ADR 0174 seeded-description text fix (task 1003083)
+  'government_006_returned_items_index.sql',      // R13 returned-item lookup index (task 1003026)
 ]);
 
 // Permission keys RENAMED after the grant migrations that first granted them.

package/tests/idea_resubmit.mjs

@@ -0,0 +1,163 @@
+// tests/idea_resubmit.mjs — return-to-originator, and resubmission (BV1.R13 of
+// goal 1000069, criterion C2: a rejected idea never dies and never stalls).
+//
+// DB-free the idea_full_capture way: pool.query patched on the doorway, the
+// REAL route handler driven through a stub req/res, a stub `government`
+// provider registered on the seam registry (hasProvider-guarded, so this
+// process's stub wins and the real module never loads a DB).
+//
+// What must hold:
+//   1. AUTHOR-ONLY — the rejection went to the originator; anyone else is 403.
+//   2. THE FLAGGED SECTION IS CHECKED per-field: a resubmission that reworked
+//      everything EXCEPT what was objected to is told flagged_section_changed
+//      false; one that answered it is told true.
+//   3. The board objection OUTRANKS the mechanical sub-bar flag; the flag is
+//      the fallback when the board never returned it.
+//   4. A passing resubmission re-opens a window (the prior item is closed, so
+//      R07's partial unique index admits a new one); a still-sub-bar one comes
+//      back with FRESH feedback on the new weakest section.
+//   5. A quick idea cannot resubmit (409) — this is the Full Idea loop.
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const api = require('../src/module-api.js');
+
+// ---- the government port stub (registered BEFORE the routes load) ----------
+let rejectionAnswer = null;      // what latestRejectionForIdea returns
+let windowAnswer = { opened: true, item: { id: '31', closes_at: null } };
+const portCalls = [];
+if (!api.hasProvider('government')) {
+  api.registerProvider('government', {
+    latestRejectionForIdea: async (id) => { portCalls.push(['rejection', id]); return rejectionAnswer; },
+    openBoardWindowForIdea: async (args) => { portCalls.push(['open', args]); return windowAnswer; },
+  });
+}
+
+// ---- the pool stub ----------------------------------------------------------
+let queries = [];
+let storedIdea = null; // what GET-by-id returns
+api.pool.query = async (sql, params = []) => {
+  queries.push({ sql, params });
+  if (/FROM idea_inbox i/i.test(sql) && /WHERE i\.id = \$1/i.test(sql)) {
+    return { rows: storedIdea ? [storedIdea] : [] };
+  }
+  if (/INSERT INTO ideas_grades/i.test(sql)) {
+    return { rows: [{ idea_id: params[0], grade: params[1], template_key: params[2], field_values: JSON.parse(params[3]), completeness_score: params[4] }] };
+  }
+  return { rows: [] };
+};
+
+const { BASE_TEMPLATE } = require('../modules/ideas/templates.js');
+const routesFactory = require('../modules/ideas/routes/inbox.js');
+const router = routesFactory({});
+const layer = router.stack.find((l) => l.route && l.route.path === '/inbox/:id/resubmit' && l.route.methods.post);
+assert.ok(layer, 'the resubmit route is declared');
+const handlers = layer.route.stack.map((s) => s.handle);
+const resubmit = handlers[handlers.length - 1];
+
+function call(bodyIn, { builderId = '9', id = '77' } = {}) {
+  return new Promise((resolve) => {
+    const req = { body: bodyIn, params: { id }, builder: { id: builderId, rank: 'metic' }, query: {} };
+    const res = {
+      statusCode: 200,
+      status(c) { this.statusCode = c; return this; },
+      json(payload) { resolve({ status: this.statusCode, payload }); },
+      fail(code, status, extra) {
+        const s = typeof status === 'number' ? status : (status && status.status) || 500;
+        resolve({ status: s, payload: { error: code, ...(extra || {}) } });
+      },
+    };
+    resubmit(req, res);
+  });
+}
+
+const FULL = Object.fromEntries(
+  BASE_TEMPLATE.fields.map((f) => [f.key, `A substantive answer for ${f.key}, long enough to clear the floor.`]),
+);
+const fullIdea = (over = {}) => ({
+  id: '77', title: 'T', status: 'open', captured_by: '9',
+  grade: 'full', template_key: 'base-v1', field_values: { ...FULL, fit: 'thin' }, completeness_score: 55,
+  ...over,
+});
+
+let passed = 0, failed = 0;
+async function test(name, fn) {
+  queries = []; portCalls.length = 0;
+  rejectionAnswer = null; windowAnswer = { opened: true, item: { id: '31', closes_at: null } };
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+await test('author-only: anyone else is 403, and nothing is written', async () => {
+  storedIdea = fullIdea();
+  const r = await call({ field_values: FULL }, { builderId: '4' });
+  assert.equal(r.status, 403);
+  assert.equal(r.payload.error, 'not_your_idea');
+  assert.ok(!queries.some((q) => /INSERT INTO ideas_grades/i.test(q.sql)), 'no grade write');
+});
+
+await test('a quick idea cannot resubmit — the Full Idea loop only', async () => {
+  storedIdea = fullIdea({ grade: 'quick', template_key: null, field_values: null });
+  const r = await call({ field_values: FULL });
+  assert.equal(r.status, 409);
+  assert.equal(r.payload.error, 'not_a_full_idea');
+});
+
+await test('a board objection outranks the mechanical flag, and an ANSWERED section reads changed:true', async () => {
+  storedIdea = fullIdea();
+  rejectionAnswer = { source: 'board', item_id: '30', section_key: 'purpose', reason_md: 'purpose is vague', closed_at: 'T' };
+  const revised = { ...FULL, purpose: 'A completely reworked purpose that answers the objection head-on.' };
+  const r = await call({ field_values: revised });
+  assert.equal(r.status, 200);
+  assert.equal(r.payload.flagged_section, 'purpose', 'the human objection wins over the weakest-section flag');
+  assert.equal(r.payload.flagged_section_changed, true);
+  assert.equal(r.payload.rejection_source, 'board');
+  assert.deepEqual(r.payload.board_window, { item_id: '31', closes_at: null }, 'a new window opened');
+});
+
+await test('reworking everything EXCEPT the flagged section reads changed:false', async () => {
+  storedIdea = fullIdea();
+  rejectionAnswer = { source: 'board', item_id: '30', section_key: 'purpose', reason_md: 'r', closed_at: 'T' };
+  const revised = Object.fromEntries(Object.entries(FULL).map(([k, v]) => [k, k === 'purpose' ? v : `${v} — now even better.`]));
+  storedIdea = fullIdea({ field_values: FULL });
+  const r = await call({ field_values: revised });
+  assert.equal(r.payload.flagged_section_changed, false, 'told plainly: the objected-to section did not move');
+});
+
+await test('with no board return, the sub-bar weakest-section flag is the fallback', async () => {
+  storedIdea = fullIdea(); // old fit is 'thin' — the mechanical weakest
+  rejectionAnswer = null;
+  const revised = { ...FULL, fit: 'A fit section with real substance now, comfortably past the floor.' };
+  const r = await call({ field_values: revised });
+  assert.equal(r.payload.flagged_section, 'fit');
+  assert.equal(r.payload.rejection_source, 'grade');
+  assert.equal(r.payload.flagged_section_changed, true);
+});
+
+await test('a still-sub-bar resubmission gets FRESH feedback and no window', async () => {
+  storedIdea = fullIdea();
+  windowAnswer = { opened: false, reason: 'below_bar' };
+  const stillThin = { ...FULL, big_picture: 'x' }; // new weakest is big_picture
+  const r = await call({ field_values: stillThin });
+  assert.equal(r.status, 200);
+  assert.equal(r.payload.board_window, undefined);
+  assert.equal(r.payload.idea.rejection.section_key, 'big_picture', 'the NEW weakest section, not the old flag');
+});
+
+await test('an invalid field set is a 400 naming the field, before any write', async () => {
+  storedIdea = fullIdea();
+  const r = await call({ field_values: { ...FULL, purpose: 42 } });
+  assert.equal(r.status, 400);
+  assert.equal(r.payload.error, 'invalid_field_values');
+  assert.ok(!queries.some((q) => /INSERT INTO ideas_grades/i.test(q.sql)));
+});
+
+await test('a missing idea is 404', async () => {
+  storedIdea = null;
+  const r = await call({ field_values: FULL });
+  assert.equal(r.status, 404);
+});
+
+console.log(`\nidea_resubmit: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);