@bongos/core 1.19.494 → 1.19.496

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.494",
-  "core_contract": "1.19.494",
-  "source_commit": "3899dae02a9a5c15e0d7f624510c3a342f1bd256",
+  "core_version": "1.19.496",
+  "core_contract": "1.19.496",
+  "source_commit": "8c795e90254fbc29139c278e0fd6d890b2c32035",
   "source_ref": "HEAD",
-  "built_at": "2026-09-02T23:55:30.581Z",
+  "built_at": "2026-09-03T14:22:08.467Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
-    "docs_redacted": 424,
+    "docs_redacted": 425,
     "agent_docs_stubbed": 24,
-    "functional_verbatim": 1937,
+    "functional_verbatim": 1938,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 2385,
-  "tree_sha256": "76335ba0fadf649f7bd21717cae44a485ff2070a4e53410db92d38354e662913",
+  "file_count": 2387,
+  "tree_sha256": "a6e4b7c3e281c43562758626b607ca7c0fa66491a11f41433d821d9a4e94d839",
   "files": [
     {
       "path": ".claude/skills/blocker-review/SKILL.md",
@@ -77,7 +77,7 @@
     {
       "path": ".claude/skills/builder-redteam/SKILL.md",
       "mode": "0000644",
-      "sha256": "8a4f589c161847dcdb7a2ca5258544cd7322154b165b85cb6ff0cc8bb1b03792"
+      "sha256": "2843dadae1ad9d0f9bb52813aa39504b108aa49b9bf903a9ba93214744933046"
     },
     {
       "path": ".claude/skills/builder-release/SKILL.md",
@@ -1674,10 +1674,15 @@
       "mode": "0000644",
       "sha256": "69db7f69b30eb87a8b8e921ea664344faf7b953c7a85ce9d788282a0e181dbd1"
     },
+    {
+      "path": "docs/adr/0234-idea-routing-capture-time-promotion-landing-matrix-homeless-inbox.md",
+      "mode": "0000644",
+      "sha256": "de04b3e3a03f66dd92003dc256c1839a4c8bcc213fb26103b60baf940046502e"
+    },
     {
       "path": "docs/adr/README.md",
       "mode": "0000644",
-      "sha256": "8c8285dcd86e937c0f09b18839fe9628ae845cd4f4f9d332d723cf216e88deac"
+      "sha256": "f86a0fd77bda20522e0907c607b3ef9724f092194760563c92254855b681404d"
     },
     {
       "path": "docs/api-reference.md",
@@ -2562,7 +2567,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "f861f82c27495f73e7117109ce43d137d6bc3da9628d63905bdc679ab4b71ffc"
+      "sha256": "f7ca8307d5cae80f0602080d5d3fc9944cc15d9fc5d2fdf43f45d89626edd039"
     },
     {
       "path": "docs/modules-contract.md",
@@ -5307,7 +5312,7 @@
     {
       "path": "modules/lifecycle/goal-advisory.js",
       "mode": "0000644",
-      "sha256": "9f1a2543b4e575f024fd5dd561c47fd804907a1f8db10ace5b552bdccfe5365e"
+      "sha256": "494c93f4cc64eb8dbc23039fa50a27b8242ba09b5afa0843ca985c807e312b6c"
     },
     {
       "path": "modules/lifecycle/goal-authz.js",
@@ -7207,12 +7212,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "501ef2c960aec4a20d26d149fabb74417deb4f46d5da85d110d6dad0f861ff22"
+      "sha256": "cb12024e16aedcd701269af77cc73012013873d07e37301c24ae10e3c1f2d28b"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "70d72840d1b8edcf74d56407f9446ecc10ffec95d18a2d2921d1b616747ecf4e"
+      "sha256": "ccfb94ab67d5acffc5c910496496a9cfbe44343ff52b90098857338dda375bae"
     },
     {
       "path": "public-docs/index.html",
@@ -8877,7 +8882,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "36694adf0d4cc5c15b9193853b2089a2b533573d7ea2f68cb5f88ac16cf50629"
+      "sha256": "2b403360f3b811aecd3de800ebb5cb87dbc5df36e045754184dd3924abc187f9"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -9912,7 +9917,7 @@
     {
       "path": "tests/goal_advisory.mjs",
       "mode": "0000644",
-      "sha256": "1b1c403574132def4c4beb98595987e90b720a851f29e42f643f1f00f285da5c"
+      "sha256": "1a7498e0a1927485db9a9e99b19012dc7df91825b11077b283a95b23971fe86e"
     },
     {
       "path": "tests/goal_category.mjs",
@@ -11229,6 +11234,11 @@
       "mode": "0000644",
       "sha256": "cad269f556293e0caa234561f5764f90998a5d133b1e0147a5bbf22403c55e3a"
     },
+    {
+      "path": "tests/redteam_followup_kind.mjs",
+      "mode": "0000644",
+      "sha256": "01c34b417bd36ba9676d53c025d6457ffcc949edaac55f1bbe5a3234b23d2801"
+    },
     {
       "path": "tests/redteam_patrol.mjs",
       "mode": "0000644",

package/.claude/skills/builder-redteam/SKILL.md

@@ -28,7 +28,7 @@ The reporter does NOT need Archon attention to file. The Archon comes to the que
 3. Walks the user through five questions (see below).
 4. POSTs to `/api/gds/security/reports`.
 5. Echoes the report id back + a note that the auto-repro subagent will attempt reproduction within the hour.
-6. (Optional) Offers to file an `idea_inbox` entry with `kind='security-finding'` pointing back at the report id, so the fix can be triaged into a normal task on the next `/idea-triage` pass.
+6. (Optional) Offers to file an `idea_inbox` entry with `kind='bug'` pointing back at the report id, so the fix can be triaged into a normal task on the next `/idea-triage` pass.
 
 ## The five questions
 
@@ -92,7 +92,7 @@ node scripts/gds/api.js POST /api/gds/inbox --body-file <path-to-idea.json>
 where `idea.json` is:
 
 ```json
-{ "title": "Fix: <TITLE>", "body_md": "Originates from vulnerability_report #<REPORT_ID> (severity=<SEVERITY>). Target: <TARGET>.\n\n<DESCRIPTION>", "kind": "security-finding" }
+{ "title": "Fix: <TITLE>", "body_md": "Originates from vulnerability_report #<REPORT_ID> (severity=<SEVERITY>). Target: <TARGET>.\n\n<DESCRIPTION>", "kind": "bug" }
 ```
 
 This is optional because some findings are "the system is fine, my mental model was wrong" — the report itself is the durable signal; an idea entry is only useful when there's actual remediation work to schedule.

package/docs/adr/0234-idea-routing-capture-time-promotion-landing-matrix-homeless-inbox.md

@@ -0,0 +1,183 @@
+# 0234 — Idea routing: capture-time promotion, the landing matrix, and the homeless-only inbox
+
+- **Status:** Accepted
+- **Date:** 2026-09-03
+- **Tasks:** [#1003064](https://cloudbongos.com/builders#/task/1003064) (R14 of goal 1000071, "Idea routing") — records the mechanism R01/R02/R05/R07 built and the identity R13 gave the inbox
+- **Spec:** [`docs/specs/<redacted>.md`](../specs/<redacted>.md) — "Design decisions & assumptions" + "Interview decisions"
+- **Related:** ADR 0084 (auto-derived per-task rank floor), ADR 0086 (goal-scoped work hierarchy), ADR 0016 (trust boundary, server-enforced), ADR 0172 (ideator credit lane, the lineage this feeds)
+
+## Context
+
+Idea 1000771 named the failure this goal exists to close: Discord `#bugs` created tasks **directly**
+(`createTask`, no `idea_inbox` row) against a **hardcoded, already-shipped** version id. Every bug
+reported through that channel landed in a version catch-all nobody would ever reopen, and — the worse
+half — no `captured_by`, no `ideas_task_lineage` row, so the ideator-credit lane (goal 1000067) had
+nothing to ever pay against. The reporter vanished from the record the moment their report became work.
+
+Meanwhile the *other* 49 open `idea_inbox` rows sat waiting for a human triage pass that, on
+promotion, dropped the resulting task into "`<version> — general`" — because nothing in the capture
+path had ever named a goal. Work that plainly had a home (a bug in a live feature, a feature request
+against an open goal) got no closer to that home than a homeless idea did.
+
+This ADR records what shipped to fix both: five tasks (R01–R03, R05, R07) plus the promote-path change
+(R13), all now `shipped`.
+
+## Decision
+
+### 1. Routing is capture-time promotion, inside `captureIdea` — never a second door
+
+`inbox.captureIdea` (`modules/ideas/inbox.js:225`, task 1003065 / R01) is documented in its own header
+as **"THE ONE CAPTURE CHOKEPOINT"** — every filing vector (hall, `capture.js`, the Discord `#ideas`
+inbound via the `ideas.capture` port, agents, seeds) already funnels through it, so routing was added
+as one optional argument (`goalId`) rather than a sibling `captureAndRoute` function. The module's own
+comment names the reason explicitly: *"A `captureAndRoute` sibling would have been the same code with
+an invitation to bypass it."* That is the direct, structural answer to the Discord `#bugs` lesson — a
+second creation path is exactly the shape idea 1000771 was.
+
+When the landing matrix (below) says **don't route**, `captureIdea` runs the pre-routing INSERT
+unchanged — `idea_inbox` status `'open'`, no task. This is the default path and is what every
+goal-unaware caller still gets (routing is strictly additive).
+
+When the matrix says **route**, `routeIdeaToGoal` (`modules/ideas/inbox.js:303`) runs **one
+transaction**: the idea row (`status='promoted'`, `reviewed_at` stamped — routing's whole claim is
+that this row never needed a triage pass), the task via the `lifecycle.createTask` kernel port, and an
+`ideas_task_lineage` row with `origin='route'`. The order is forced by foreign keys (idea → task →
+lineage), and the module's own comment states the stakes: *"THE TRANSACTION IS THE POINT, not an
+optimisation... A route that committed the task but lost the lineage row would manufacture exactly
+that bug, at scale, on the path whose whole promise is that attribution survives (criterion C3)."* If
+any step fails, the whole thing rolls back and the filer's report is never silently lost mid-flight.
+
+`captureIdea` treats `filerRank`/`grade` as **read-only inputs to the decision** — it performs no
+authority check itself; that is R05's job (below), a deliberately separate, load-bearing gate.
+
+### 2. The landing matrix, as shipped (`modules/ideas/routing.js`, task 1003065 / R01 + task 1003066 / R05)
+
+`decideLanding()` is a pure, DB-free function — no clock, no rank lookup — so every cell is pinned by
+`tests/idea_routing.mjs` without touching Postgres. Its posture is explicitly **fail-closed**: every
+uncertainty resolves toward "don't route" or "route to backlog", never toward `'ready'`.
+
+| Filed thing | Filer rank | Landing (as shipped) |
+|---|---|---|
+| No goal named | any | `idea_inbox`, `status='open'` — the default path (reason: `no_goal`) |
+| `grade='full'` (Full Idea) | any | Never routes — the Board Room's subject (reason: `full_idea_never_routes`) |
+| `kind` ∈ {`criterion-proposal`, `decision`} | any | Never routes — judgment work (reason: `judgment_kind`) |
+| `kind='bug'` with a goal | Metic or Archon | Task in the goal, `status='ready'` (reason: `bug_trusted_filer`) |
+| `kind='bug'` with a goal | sub-Metic / unknown | Task in the goal, `status='backlog'` (reason: `bug_awaiting_nod`) |
+| Anything else with a goal (feature, cleanup, refactor, infra, or an unrecognised kind) | any | Task in the goal, `status='backlog'` (reason: `soft_landing`) |
+
+This matches the spec's table (`docs/specs/<redacted>.md` "Landing matrix") exactly for the
+hard-land/soft-land split. Priority on a routed task defaults to the idea's own `suggested_priority`,
+clamped to 1–5, else `3` (`routedPriority`) — precisely the "decided without interview" line the spec
+records.
+
+`decideLanding` only decides the **status**; it grants nothing. `authorizeRoutedLanding`
+(`modules/ideas/routing.js:169`, task 1003066 / R05) is the **binding** gate `routeIdeaToGoal` calls
+before it writes anything, and it closes a hole the matrix alone left open: a routed task declares no
+`touches[]`, so the ordinary ADR 0084/0085 rank-floor derivation would land it at `xenos` even when the
+goal's `scope_modules` reach protected territory (the permission/ship-grade/deploy/migration core).
+Two rules, ordered and fail-closed (the `authorizeGoalTaskCreate` precedent):
+
+- **Touches declared** (a programmatic filer that knows its own blast radius) → `goalScopeCheck.check`
+  runs verbatim, refusals and all — the same wall `POST /goals/:id/tasks` applies to an authored task.
+- **Touches absent** (every human filing — demanding touches[] as the price of reporting a bug is
+  exactly the triage tax this goal removes) → protection moves to the **claim side**: a goal whose
+  scope reaches protected territory raises the task's `requires_rank` floor to `metic`
+  (`PROTECTED_SCOPE_FLOOR`), and — the part R05 tightened after its first cut — a **sub-Metic filer is
+  refused outright** (`ROUTE_NOT_AUTHORIZED` / `protected_scope`, HTTP 403) rather than merely having
+  the floor stamped on afterward. The refusal costs the filer nothing they had before: omit `goal_id`
+  and the report files to the inbox exactly as it always did.
+
+**Membership is deliberately not required to route into a goal**, and the module's comment names this
+as the one place the routed path diverges from the authored one on purpose: `authorizeGoalTaskCreate`
+refuses a non-member (`not_a_member`) because *authoring* inside someone's workspace is a member's
+privilege, but *reporting* is not — criterion C5's promise ("the filer never has to know the goal map")
+and C1's ("a bug filed anywhere lands in its home") both require that a non-member can still route a
+report in. The safety membership would have carried moves instead to the rank floor (claim side) and
+the matrix (ready side), and is pinned by a test rather than left to erode quietly.
+
+### 3. The schema: one advisory hint column, one widened CHECK (task 1003060 / R02)
+
+`migrations/<redacted>.sql` adds `idea_inbox.suggested_goal_id` (nullable FK
+`ON DELETE SET NULL`) — **not** where a routed idea's goal lives (that is `tasks.goal_id`, set by
+construction), but the leftover hint for rows that did **not** convert: soft-landed/homeless ideas, a
+Discord classifier's guess, Full Ideas and criterion-proposals. The migration's own comment is explicit
+that the column is "load-bearing for NOTHING — no rank check, no scope wall, and no payout may read
+it." It lives in **core** migrations, not a module migration, because `idea_inbox` is a core table and
+`fitness.js`'s `checkModuleMigrationsAdditive` forbids a module `ALTER TABLE` against it.
+
+`modules/ideas/migrations/<redacted>.sql` widens `ideas_task_lineage`'s CHECK to
+admit a third `origin`: `'route'`, alongside the pre-existing `'promote'` (a human triaged it) and
+`'develop'` (a spark became a Full Idea). The distinction is deliberate — "how much triage routing
+actually saved" (criterion C6) is only answerable if capture-time conversions are tagged differently
+from later human promotions in the ledger.
+
+### 4. The suggester answers "which goal" *before* anything is created (task 1003062 / R07)
+
+`modules/lifecycle/goal-suggest.js` lifts the candidate logic `buildGoalAdvisory` already had (goal
+1000071's "Reuse, do not rebuild" table) into a **pure, creation-free read**: `suggestGoals(goals,
+draft, opts)` ranks open goals against a draft title/body by weighted token overlap (title terms
+weight 2, body terms weight 1 — the `criterion-suggest.js` precedent), returning `[]` rather than five
+arbitrary goals when nothing scores (the `includeZero` default). `GET /goals/suggestions` exposes it to
+a human picker (the hall filing surface, the CLI prompt); `suggestGoalForCapture({ title, body })`
+collapses the same ranking to a **single confident answer or null**, for a vector with nobody to choose
+— currently Discord `#bugs` (below). It ranks across **every** version still open to work
+(`versionAcceptsNewWork`, task 1003061 / R03), not one, because an earlier "decline if more than one
+version is open" design would have returned null on every report this instance (which runs two
+building versions concurrently) ever files.
+
+### 5. The inbox's new identity: homeless-only (task 1003071 / R13)
+
+`scripts/gds/triage.js`'s `resolveGoalDefault(idea, versionId)` gives the promote path a goal by a
+strict precedence — `idea.suggested_goal_id` (a human or filing surface already named this goal; a
+heuristic must not overrule it) **before** the R07 suggester (only when there is no stored hint) — and
+`createTask({ ..., goalId })` finally sends `goal_id` on `POST /tasks`, a field the route has accepted
+since task 1763 with no client ever sending it. `.claude/skills/idea-triage/SKILL.md` states the
+contract plainly: *"the inbox holds only HOMELESS work — bugs and goal-bound captures now route to a
+task at filing time and never reach the inbox."* Triage shrinks to the judgment calls a routing rule
+cannot make for itself: Full Ideas (Board Room material), `criterion-proposal`/`decision` rows, and
+anything nobody could suggest a home for.
+
+## Divergence from the spec, recorded rather than silently reconciled
+
+The spec's interview decision 2 says: *"Discord-filed bugs soft-land with a suggested goal. The report
+files as an idea with a classifier-suggested goal attached and surfaces in the pending queue for a
+one-click route. Nothing lands unvetted."* **That is not what R11 shipped.** `modules/discord/discord-bugs.js`
+(task 1003067 / R11, retiring the hardcoded-`GDS-V3` path idea 1000771 named) instead resolves a
+suggested goal via `suggestGoalForCapture` and hands it straight into `captureIdea` as `goalId` — so a
+**linked Metic+ builder's Discord bug hard-lands `'ready'` immediately**, through the *same* landing
+matrix every other filing vector uses, rather than always parking at `'backlog'` pending a one-click
+nod. The file's own header explains the choice: a local copy of the rank split would only ever drift
+from the one definition in `modules/ideas/routing.js` (`tests/filing_abuse_matrix.mjs` exists precisely
+to prevent that divergence), and "same outcomes as before" (the pre-routing #bugs behaviour already
+hard-landed a trusted linked builder's report). An **unlinked** Discord author still gets no goal and
+no rank, so the matrix cannot route their report into work at all — it lands as a homeless idea, same
+as `#ideas` has always given that person, which is the actual "nothing lands unvetted" guarantee that
+survived.
+
+The companion interview decision — **"Discord `#ideas` files with HINTS only (`suggested_goal_id`),
+never routes"** — is recorded here as the design intent, but **is not yet built**: R12 (task 1003068,
+"Discord `#ideas` carries routing hints") is still `status='ready'`, not shipped. Today,
+`modules/discord/discord-inbound.js`'s `#ideas` capture carries no goal hint at all; every `#ideas`
+filing lands exactly as it did before this goal, an ordinary homeless `idea_inbox` row. When R12 ships,
+its hint must land as `suggested_goal_id` only (never `goal_id`) — consistent with every other
+"classifier guess, not a route" vector this ADR documents — or it would silently convert `#ideas` into
+a second bypass of the kind idea 1000771 already named once.
+
+## Consequences
+
+- **Attribution survives routing by construction, not by discipline.** `tests/idea_routing.mjs` pins
+  the matrix; `tests/filing_abuse_matrix.mjs` (task 1003073 / R06) pins that a Xenos mass-filing bugs
+  never lands anything claimable, never lands in protected scope, and never escalates via filing;
+  task 1003072 / R04 is the proof that a routed bug's lineage + `captured_by` survive end-to-end to a
+  shipped task.
+- **A caller lying about `filerRank` moves a bug from `'backlog'` to `'ready'` and nothing else** — the
+  matrix's own header states this as the reason R06's abuse matrix tests the *route* (server-derived
+  rank), not `captureIdea` (which trusts whatever rank it is handed, by design, because the route is
+  the only legitimate caller).
+- **The inbox count is now a real signal.** With bugs and goal-bound features routed away at filing
+  time, `idea_inbox`'s open count should trend toward "things that genuinely have no home yet" —
+  measured by task 1003074 / R15's before/after sweep of the ~50 rows open when the spec was written
+  (not yet shipped at the time of this ADR).
+- **R08–R10, R12, R15 remain open** (hall filing surface, CLI `--goal`, hall reassignment affordance,
+  Discord `#ideas` hints, the reclassification-sweep proof). This ADR documents the mechanism and the
+  matrix those tasks build against; it does not claim the whole spec is delivered.

package/docs/adr/README.md

@@ -321,5 +321,6 @@ This keeps the decision history honest and traceable.
 | 0232 | [**Rot is derived, not swept; and `water` is the only new verb** ([task 1003279](https://cloudbongos.com/builders#/task/1003279) · goal 1000072, criterion `legibility-sort-and-staleness`). The inbox half [ADR 0226](<redacted>.md) split out and left open. Owner decision (2026-08-25): a goal or task past the timer raises a **needs-attention line** — not an automatic status change (it mutates real work with no human in the loop, and a wrong timer then silently freezes it) and not a nightly digest (a notification is not an action, and one you scroll past is indistinguishable from the silent decay it was meant to fix). The build note asked for an idempotent poller; the decision is that **there is no poller and no items table** — a line is a `SELECT` comparing the thing's rot clock to the timer, so "exactly one item per stale thing, not one per sweep" is true by arithmetic rather than by deduplication code that must be written correctly and then stay correct, and clearing falls out for free (an edit moves `updated_at`, a decision moves `status`, watering moves the mark). A stored item would have been a cache of a query whose inputs it could not observe. **The exclusions are the load-bearing part**: rot is work nobody picked up (`backlog`/`ready`, and `open` goals), and `active` is deliberately excluded because the claim-silence timer already reports it in hours — listing it here in days would put one rot in two inboxes under two numbers, the 6h-vs-24h split one tier up; `blocked`, `completed`/`confirmed` and the terminal states are excluded for the same reason, each naming the surface that owns it. The clock is **not a new definition of touched** — it is `task-lib.js`'s published `max(updated_at, shipped_at)` (task 1003278) plus a water mark, pinned by a test asserting the domain expression appears verbatim in migration `core_231`'s index expressions, because drift there is silent. The timer is a **second** timer and defends itself as a different question (days vs hours, DB vs env, asks a human vs releases a claim), stored in a new unseeded generic `project_settings` table — no row means "never configured", which is what lets a settings page tell that apart from "set to the default" — with ADR 0226's precedence and its reporting-degrades fail posture, and an unreachable DB explicitly not treated as a bad value. Three of the four verbs (**prioritise/prune/kill**) reuse `promote`/`demote`/`abandon`/`archive`, the task-1003066 precedent, so they add no permission; only `water` is new, gated on ownership OR `builder.roster.read` inside the handler (a creator holding no atom must still get through). Verbs are **served with each row** rather than hardcoded, since a goal legitimately gets two where a task gets four. Rejected: an items table, a sweep, a digest, auto-demotion, and a fourth verb on goals that would render a dead button.](<redacted>.md) | GDS / legibility + hall |
 
 | 0233 | [**A copy proposal is a task carrying a patch, and the applier is the only writer** ([task 1003114](https://cloudbongos.com/builders#/task/1003114) · goal 1000074, criterion `artist-edits-land-as-tasks`). Goal 1000074 asks for two things that pull against each other in its own text: the artist must change copy WITHOUT an engineer, and there must be NO LIVE CMS because every copy change is a claimed, graded, shipped task. R02 shipped the half that needs no reconciliation (the flag) and [ADR 0178](<redacted>.md) §3 pinned the absence of any column that could hold replacement text, naming this task as the one that would have to keep it true. Decisions: (1) the shape is **borrowed from the design half, not invented** — ADR 0081 already has a tool authoring and an `adapter.export()` landing the output as a committed diff under a claim inside a path guard, so the artist is the tool, the copy desk is where they author, and the proposal is the export. (2) A proposal is a **TASK carrying a fenced `copy-proposal` patch**, never a row: the ledger is where a proposal belongs anyway, nothing renders a task description as product copy, a reviewer can read the change without running anything, and `copy-desk` gains NO migration (the obvious-but-wrong R03 is a `copy_desk_proposals` table, which is the forbidden column with extra steps). The module gains `consumes: ["lifecycle"]` and calls `createTask` through the port — it can put a request INTO the ledger and nothing can pull copy OUT of it. (3) `scripts/gds/copy-apply.js` **re-derives the position** rather than trusting the patch, which required teaching R01s extractor to record a source SPAN and deliberately dropping it from the committed registry: an offset goes stale the moment anything above it changes, while the id is designed to survive exactly that movement, so the span is recomputed at the moment of the edit by the same code that decided the string was copy. (4) The **placeholder arithmetic** is what makes a patch mechanical rather than a note for an engineer — the applier puts the sources own `${expr}` back, k-th hole to k-th expression, so an artist may MOVE a value within a sentence but never add or drop one, checked at proposal time and again against the real source. (5) Every ambiguity is a **named refusal** (`target_gone`, `ambiguous_target`, `no_exact_span`, `placeholder_mismatch`, `path_outside_surface` — the design adapters path guard, derived from R01s own SURFACES), because a wrong edit is worse than no edit; after writing, the applier regenerates the registry and checks that what it wrote is what the inventory now reads. (6) Proposing is **open to every rank** (an artist is a craft, not a rank) and lands at `backlog`, so a proposal is a request that passes ordinary triage. Rejected: a proposals table, a column beside the flag, trusting the patchs line number, an escape-aware index map to buy spans for nine strings, auto-closing the flag a proposal answers.](<redacted>.md) | copy-desk / the artist loop |
+| 0234 | [**Idea routing: capture-time promotion, the landing matrix, and the homeless-only inbox** ([task 1003064](https://cloudbongos.com/builders#/task/1003064) · goal 1000071, "Idea routing"). Idea 1000771 named the failure: Discord `#bugs` created tasks DIRECTLY against a hardcoded, already-shipped version — no `captured_by`, no lineage, so the ideator-credit lane had nothing to pay against — while every other open idea sat waiting for a human triage pass that dropped its promotion into a version catch-all, because nothing in capture ever named a goal. Records what R01/R02/R05/R07/R13 shipped. `captureIdea` (`modules/ideas/inbox.js`) stays the ONE capture chokepoint — routing is one optional `goalId` argument, never a second creation door — and when the matrix routes, `routeIdeaToGoal` writes the idea row, the task (via the `lifecycle.createTask` port) and an `ideas_task_lineage` row (`origin='route'`) in ONE transaction, so a route can never mint attribution-free work the way `#bugs` did. `modules/ideas/routing.js`'s `decideLanding` is PURE and fail-closed: a bug from a Metic+ filer hard-lands `ready`, a sub-Metic bug or any other kind with a goal soft-lands `backlog`, a Full Idea or `criterion-proposal`/`decision` never routes, no goal named stays the pre-routing inbox path. `authorizeRoutedLanding` is the BINDING gate underneath the matrix's decision — a goal reaching protected scope raises the task's rank floor to Metic and REFUSES a sub-Metic filer outright, while membership is deliberately NOT required (reporting isn't authoring). `core_222`'s `suggested_goal_id` is an advisory hint only — the real home is `tasks.goal_id`, set by construction — and `/idea-triage` (`scripts/gds/triage.js`) now sends `goal_id` on promotion, so the inbox is homeless-only. Divergence recorded: R11 (Discord `#bugs`) hard-lands a linked Metic+ builder's bug immediately through the SAME shared matrix rather than the spec's "always soft-land, pending queue" design, because a local copy of the rank split would only drift from the one definition; and R12 (Discord `#ideas` hints) is NOT YET SHIPPED, so `#ideas` carries no goal hint today despite the interview decision that it should, hint-only, never route.](<redacted>.md) | ideas / lifecycle |
 
 > ⚠️ **Numbering collisions are now machine-enforced, not narrated.** Twenty numbers are shared by two ADRs each — assigned in parallel sessions before anything checked. The files keep their filenames (renumbering would break every existing citation, and a number once assigned is never reused), and this table disambiguates each pair as `NNNN-a` / `NNNN-b`. The authoritative list is `LEGACY_DUPLICATE_ADRS` in [`scripts/gds/adr-namespace.js`](../../scripts/gds/adr-namespace.js), frozen by exact filename: a **new** collision — or a third file joining a legacy number, or a rename of either half — hard-fails the `unit` CI gate, as does an index row that points at no file or an ADR with no row. The list may only shrink. This paragraph used to narrate the collisions one by one and had fallen eight behind reality; see [ADR 0195](<redacted>.md) for why the check exists and why the pairs are grandfathered rather than renumbered.

package/docs/module-api-changelog.md

@@ -1425,5 +1425,9 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.492 with no explicit bump. run 33694576680. (task 1002620)
   1.19.494 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.493 with no explicit bump. run 33697218855. (task 1002620)
+  1.19.495 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.494 with no explicit bump. run 33766103175. (task 1002620)
+  1.19.496 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.495 with no explicit bump. run 33766363834. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/modules/lifecycle/goal-advisory.js

@@ -40,8 +40,14 @@ function generalGoalTitle(versionId) {
 // authorization gate. This is advice appended to a request that ALREADY SUCCEEDED;
 // a wrong guess here nags a builder about a task that is fine, which is worse than
 // staying quiet. A missing versionId or an unreadable goal title yields null.
-function adviseGoal({ versionId, goalId, goalTitle } = {}) {
+//
+// kind='bug' is a THIRD silent case (task 1003214, idea 1000828 — the owner
+// directive against manufacturing small goals): a fix sitting in the catch-all,
+// or with no goal at all, is already where it belongs, so both reasons above
+// collapse to null for a bug. The nudge is for homeless FEATURE work only.
+function adviseGoal({ versionId, goalId, goalTitle, kind } = {}) {
   if (goalId == null) {
+    if (kind === 'bug') return null;
     return {
       reason: 'no_goal',
       message: 'This task has no goal to live in — no scope wall, no done-when criteria gating it, '
@@ -53,6 +59,7 @@ function adviseGoal({ versionId, goalId, goalTitle } = {}) {
   }
   if (versionId == null || typeof goalTitle !== 'string') return null;
   if (goalTitle !== generalGoalTitle(versionId)) return null;
+  if (kind === 'bug') return null;
   return {
     reason: 'catch_all',
     message: `This task landed in "${goalTitle}", the version's catch-all bucket rather than a real goal — `
@@ -93,6 +100,7 @@ async function buildGoalAdvisory({ db, versionId, task }) {
       versionId,
       goalId: task.goal_id,
       goalTitle: homeGoal && homeGoal.title,
+      kind: task.kind,
     });
     if (!verdict) return null;
     // LIMIT 6, not 6-in-JS: Postgres truncates instead of shipping every open goal

package/package-lock.json

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

package/package.json

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

@@ -45,7 +45,7 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.494'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.496'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/goal_advisory.mjs

@@ -55,10 +55,30 @@ await test('catch_all — landing in "<version> — general" is a bucket, not a
   assert.equal(a.goal_id, 3, 'names the catch-all so a caller can PATCH away from it');
 });
 
+// task 1003214 (idea 1000828): a bug in the catch-all is where it belongs, so the
+// advisory goes silent (reuses the same null the module already uses for "no
+// advice needed").
+await test("kind='bug' in the catch-all is quiet — a fix is where it belongs", () => {
+  assert.equal(adviseGoal({ versionId: V, goalId: 3, goalTitle: generalGoalTitle(V), kind: 'bug' }), null);
+});
+
+await test("kind='feature' in the catch-all still gets the nudge — quiet is bug-only", () => {
+  const a = adviseGoal({ versionId: V, goalId: 3, goalTitle: generalGoalTitle(V), kind: 'feature' });
+  assert.equal(a.reason, 'catch_all');
+});
+
+await test("kind='bug' with no goal at all is quiet too — a fix needs no home to be filed correctly", () => {
+  assert.equal(adviseGoal({ versionId: V, goalId: null, kind: 'bug' }), null);
+});
+
 await test('a REAL goal is silent — null, not an empty object', () => {
   assert.equal(adviseGoal({ versionId: V, goalId: 1000025, goalTitle: 'Builder experience — hall, dev box, and skills' }), null);
 });
 
+await test("kind='bug' under a real goal is silent too — already silent, kind changes nothing", () => {
+  assert.equal(adviseGoal({ versionId: V, goalId: 1000025, goalTitle: 'Builder experience — hall, dev box, and skills', kind: 'bug' }), null);
+});
+
 // The bug this guards: a near-miss title must not be mistaken for the catch-all.
 // db.generalGoalIdForVersion resolves the SAME string, so if these two ever disagree
 // a task would be filed into a goal the advisory then calls orphaned (or vice versa).
@@ -164,6 +184,14 @@ await test('buildGoalAdvisory: the catch-all is detected and named', async () =>
   assert.equal(a.goal_id, 3);
 });
 
+// task 1003214: the full POST /tasks path (buildGoalAdvisory reads task.kind
+// off the already-committed row) for a bug landed in the catch-all — silent.
+await test("buildGoalAdvisory: kind='bug' in the catch-all yields null end to end", async () => {
+  const db = stubDb({ goal: { id: 3, title: generalGoalTitle(V) }, goals: [] });
+  const a = await buildGoalAdvisory({ db, versionId: V, task: { id: 7, goal_id: 3, kind: 'bug' } });
+  assert.equal(a, null);
+});
+
 // The invariant a future refactor will quietly break. Both DB calls are covered:
 // getGoal is only reached when goal_id is set, listGoals only on the unhappy path.
 await test('NON-BLOCKING: buildGoalAdvisory returns null when getGoal throws', async () => {

package/tests/redteam_followup_kind.mjs

@@ -0,0 +1,44 @@
+// tests/redteam_followup_kind.mjs — task 1003452.
+//
+// /builder-redteam's optional follow-up idea_inbox POST filed kind:'security-finding',
+// which is not in idea_inbox's CHECK constraint (migrations/042_criterion_proposal_workflow.sql
+// mirrored at modules/ideas/inbox.js VALID_KINDS) — the POST 400s every time, and because
+// the primary vulnerability_reports write already succeeded, the failure is silent (the
+// report lands, the fix idea never files). Fixed by filing kind:'bug' instead — a red-team
+// finding is a bug in the platform's own walls.
+//
+// Static: reads the skill's own committed idea.json shape (CRLF-normalised) and asserts the
+// kind it files is a real member of the enum, imported (not duplicated) from the module that
+// owns it — so a future enum change or a re-broken skill both fail this test honestly.
+//
+// Run:  node --test --test-reporter=tap tests/redteam_followup_kind.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { VALID_KINDS } from '../modules/ideas/inbox.js';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const SKILL_MD = path.join(ROOT, '.claude', 'skills', 'builder-redteam', 'SKILL.md');
+
+function readNormalized(p) {
+  return fs.readFileSync(p, 'utf8').replace(/\r\n/g, '\n');
+}
+
+test('the follow-up idea.json files a kind that is a real member of VALID_KINDS', () => {
+  const md = readNormalized(SKILL_MD);
+  const m = md.match(/"kind":\s*"([^"]+)"/);
+  assert.ok(m, 'SKILL.md must show the literal idea.json shape with a "kind" field');
+  const filedKind = m[1];
+  assert.ok(
+    VALID_KINDS.includes(filedKind),
+    `SKILL.md files kind:'${filedKind}', which is not in VALID_KINDS (${VALID_KINDS.join(', ')})`
+  );
+});
+
+test('SKILL.md does not still describe the dead kind=\'security-finding\' value anywhere', () => {
+  const md = readNormalized(SKILL_MD);
+  assert.doesNotMatch(md, /security-finding/, 'the invalid kind must not linger in prose either');
+});