@bongos/core 1.19.454 → 1.19.456

package/modules/lifecycle/goal-suggest.js

@@ -26,10 +26,14 @@
 // really does belong with a goal scoped to `hall-ui`.
 
 const { tokenize } = require('./criterion-suggest.js');
-const { candidateGoals } = require('./goal-advisory.js');
+const { versionAcceptsNewWork } = require('./db-tasks.js');
+const { candidateGoals, generalGoalTitle } = require('./goal-advisory.js');
 const api = require('../../src/module-api');
 // Through the published logger seam, not a raw console call (est-advisory.js precedent).
 const proseErr = (err) => api.logger('lifecycle').error({ err: err && err.message }, 'GET /goals/suggestions failed');
+// The capture-time twin has its own message: it is not an HTTP route, and a log
+// line that names the wrong caller is a wrong turn taken during an incident.
+const captureErr = (err) => api.logger('lifecycle').error({ err: err && err.message }, 'suggestGoalForCapture failed — filing without a goal');
 
 // Matches suggestCriteria's default so the two suggesters feel the same.
 const SUGGEST_LIMIT = 5;
@@ -82,6 +86,70 @@ function suggestGoals(goals, draft = {}, opts = {}) {
 }
 
 
+// suggestGoalForCapture — ONE goal for a filing that arrived with no goal named
+// (task 1003067 / BV1.R11). The HTTP suggester above hands a human five options to
+// choose from; a Discord message has nobody to choose, so this collapses the same
+// ranking to a single confident answer or none at all.
+//
+// WHY IT RESOLVES THE VERSION ITSELF. The vector this was built for — Discord
+// #bugs — used to carry a hardcoded version id, and because that id was a SHIPPED
+// version every bug reported through it landed in a tomb nobody reads (idea
+// 1000771, the failure goal 1000071 exists to fix). A filing vector should not be
+// in the business of naming a version at all, so it does not: the GOAL carries the
+// version, and this picks the goal.
+//
+// It therefore ranks across EVERY version still open to work (versionAcceptsNewWork,
+// task 1003061), not one. An earlier cut of this declined whenever more than one
+// version was open — prudent-looking, and a dead feature: this instance runs two
+// building versions concurrently, so it would have returned null for every report
+// ever filed. "Which version" is not a question worth asking when the answer is
+// already attached to the goal that won.
+//
+// Catch-all goals are excluded for every one of those versions. candidateGoals
+// drops the catch-all for ONE version id, which is the wrong shape here, so the
+// filtering happens up front — a "<version> — general" bucket is never a home
+// (that is R03's fallback question, a different one).
+//
+// Returns { id, title, version_id, score } or NULL. Null is the ordinary case and
+// a good one: no goal means the filing lands in the inbox, exactly as every
+// goal-unaware capture always has. Never throws — a suggester that takes down a
+// bug report is worse than one that shrugs.
+async function suggestGoalForCapture({ title = '', body = '' } = {}, deps = {}) {
+  const db = deps.db || require('./db.js');
+  try {
+    if (!String(title || '').trim() && !String(body || '').trim()) return null;
+
+    // Independent reads — issued together rather than in sequence.
+    const [versions, allGoals] = await Promise.all([db.listVersions(), db.listGoals({ status: 'open' })]);
+    const openIds = new Set(
+      (versions || []).filter((v) => versionAcceptsNewWork(v && v.status)).map((v) => String(v.id))
+    );
+    // Nothing is being built ⇒ nowhere for new work to go ⇒ the inbox.
+    if (openIds.size === 0) return null;
+
+    const goals = allGoals || [];
+    const homes = goals.filter((g) => g
+      && openIds.has(String(g.version_id))
+      && g.title !== generalGoalTitle(g.version_id));
+    if (homes.length === 0) return null;
+
+    // versionId is passed null: the catch-alls are already gone, and passing one
+    // version's id here would only re-filter for that version. includeZero stays
+    // false, so a filing that matches nothing gets NO goal rather than the
+    // first one dressed up as a suggestion.
+    const [best] = suggestGoals(homes, { title, body }, { versionId: null, limit: 1 });
+    if (!best) return null;
+
+    // suggestGoals normalises to { id, title, scope_modules, … } and drops
+    // version_id, so read it back off the row that won.
+    const row = homes.find((g) => String(g.id) === String(best.id));
+    return { id: best.id, title: best.title, version_id: row ? row.version_id : null, score: best.score };
+  } catch (err) {
+    captureErr(err);
+    return null;
+  }
+}
+
 // goalSuggestHandler — GET /goals/suggestions. Handler lives here, not inline in
 // routes/goals.js, because that file is over the fitness oversize threshold and
 // the ratchet is shrink-only; collaborators are injected so this module still
@@ -168,4 +236,4 @@ function criteriaSuggestHandler({ db, suggestCriteria, parseId }) {
   };
 }
 
-module.exports = { suggestGoals, goalSuggestHandler, criteriaSuggestHandler, SUGGEST_LIMIT };
+module.exports = { suggestGoals, suggestGoalForCapture, goalSuggestHandler, criteriaSuggestHandler, SUGGEST_LIMIT };

package/modules/lifecycle/lifecycle.js

@@ -18,6 +18,7 @@
 
 const db = require('./db');
 const classifier = require('./task-classifier');
+const goalSuggest = require('./goal-suggest');
 const helpRequests = require('./help-requests');
 const taskRecommendations = require('./task-recommendations');
 const activity = require('./activity');
@@ -35,6 +36,12 @@ module.exports = {
   // (consumer: core cascade-dispatch.js, the dormant System-3 lib).
   get VOTABLE_TASK_STATUSES() { return classifier.VOTABLE_TASK_STATUSES; },
   classifyTaskKind: (...a) => classifier.classifyTaskKind(...a),
+  // suggestGoalForCapture: ONE goal for a filing that named none, or null (task
+  // 1003067). Consumer: the discord #bugs vector, which files through the ideas
+  // routing path and needs a home to offer it. Lives behind the port because
+  // "which goal, on which version" is a lifecycle judgement and discord may not
+  // import lifecycle (the one-way module rule).
+  suggestGoalForCapture: (...a) => goalSuggest.suggestGoalForCapture(...a),
 
   // --- work-tracking READS the staying-core read routes resolve --------------
   // public.js (the status surface): version/ship feed + grade trend.

package/package-lock.json

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

package/package.json

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

@@ -33,7 +33,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.454'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.456'; // 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/discord_bugs.mjs

@@ -3,7 +3,8 @@
 // Unit tests for Discord #bugs → GDS tasks (kind='bug') (Phase 3 F8, ADR 0047).
 // Pure screening/landing + orchestration via injected fakes — no Discord, no DB:
 //   - screenBug: message → { ok, title, bodyMd }; blank/short/text-free rejected.
-//   - decideBugLanding: Metic+ → 'ready'; everyone else linked → 'backlog'.
+//   - the landing: Metic+ → 'ready'; everyone else linked → 'backlog'. Decided by
+//     the ideas landing matrix since task 1003067, not by this module.
 //   - recordInboundBug: files via createTask under the anti-abuse guard —
 //     linked-only (unlinked rejected), rank-aware landing, per-builder
 //     rate-limit, body screen; audits surface='discord_bot'; never throws.
@@ -23,7 +24,9 @@ function t(name, fn) {
 }
 
 const GOOD_ID = '123456789012345678';
-const CFG = { rateLimitPerHour: 5, versionId: 'GDS-V3', credits: 10 };
+// task 1003067: versionId and credits are gone from this vector's config — the
+// goal carries the version and the reward auto-assigns at the create layer.
+const CFG = { rateLimitPerHour: 5 };
 
 console.log('Discord #bugs → GDS tasks (Phase 3 F8):');
 
@@ -51,21 +54,16 @@ await t('screenBug: long first line is capped (≤200, ellipsis)', () => {
   assert.ok(s.title.endsWith('…'));
 });
 
-// ---- decideBugLanding ------------------------------------------------------
-await t('decideBugLanding: Metic+ → ready', () => {
-  assert.equal(bg.decideBugLanding('metic'), 'ready');
-  assert.equal(bg.decideBugLanding('archon'), 'ready');
-  assert.equal(bg.decideBugLanding('ARCHON'), 'ready');
-});
-await t('decideBugLanding: Xenos/Thetes/unknown → backlog', () => {
-  for (const r of ['xenos', 'thetes', 'periokoi', '', null, undefined]) {
-    assert.equal(bg.decideBugLanding(r), 'backlog');
-  }
-});
 
 // ---- recordInboundBug (fakes) ---------------------------------------------
+// The fake capture mirrors the real landing rule rather than hardcoding a status,
+// so a matrix change shows up here as a failure instead of a stale fixture.
+// task 1003067: the fake defers to the REAL landing matrix, so this fixture can
+// never quietly disagree with the rule the server actually applies.
+const { decideLanding } = require('../modules/ideas/routing.js');
+const READY_OR_BACKLOG = (rank) => (rank == null ? null : decideLanding({ goalId: 7, kind: 'bug', filerRank: rank }).status);
 function makeDeps(over = {}) {
-  const calls = { create: [], audit: [], count: [], persist: [] };
+  const calls = { create: [], audit: [], count: [], persist: [], suggest: [] };
   const deps = {
     getBuilderByDiscordUserId: async () => (over.builder === undefined ? null : over.builder),
     countRecentDiscordBugFilings: async (id, since) => {
@@ -73,7 +71,29 @@ function makeDeps(over = {}) {
       if (over.countThrows) throw new Error('count boom');
       return over.recent ?? 0;
     },
-    createTask: async (a) => { calls.create.push(a); if (over.createThrows) throw new Error('db boom'); return { id: over.taskId ?? 555 }; },
+    // task 1003067: the vector files through ideas.capture now. `calls.create`
+    // keeps its name — it is still "what this vector asked to be created" — but
+    // the argument shape is a CAPTURE, and the landing status comes back from the
+    // matrix rather than being posted in.
+    suggestGoalForCapture: async (draft) => {
+      calls.suggest.push(draft);
+      if (over.suggestThrows) throw new Error('suggest boom');
+      return over.goal === undefined ? { id: 7, title: 'A goal', version_id: 'BONGOS-V1', score: 4 } : over.goal;
+    },
+    captureIdea: async (a) => {
+      calls.create.push(a);
+      if (over.createThrows) throw new Error('db boom');
+      // routeIdeaToGoal refuses a landing by THROWING, which rolls the idea row
+      // back with it — the case the goal-dropping retry exists for.
+      if (over.refuseRouted && a.goalId != null) throw { code: 'ROUTE_NOT_AUTHORIZED', gate: 'protected_scope' };
+      const routes = a.goalId != null && READY_OR_BACKLOG(a.filerRank) !== null;
+      return {
+        id: over.ideaId ?? 900,
+        routing: routes
+          ? { routed: true, task_id: over.taskId ?? 555, goal_id: a.goalId, status: READY_OR_BACKLOG(a.filerRank) }
+          : { routed: false, reason: 'no_goal' },
+      };
+    },
     insertAuditLog: async (a) => { calls.audit.push(a); if (over.auditThrows) throw new Error('audit boom'); return { id: 1 }; },
     persistImages: async (urls, opts) => {
       calls.persist.push({ urls, opts });
@@ -90,13 +110,16 @@ await t('recordInboundBug: linked Metic → filed at ready, kind=bug, attributed
   const r = await bg.recordInboundBug({ discordUserId: GOOD_ID, content: 'Boats vanish at the dock', messageId: 'm1' }, deps, CFG);
   assert.equal(r.outcome, 'filed');
   assert.equal(r.taskId, 555);
+  assert.equal(r.ideaId, 900, 'the idea row is the attribution the old path threw away');
   assert.equal(r.status, 'ready');
-  assert.equal(calls.create[0].kind, 'bug');
-  assert.equal(calls.create[0].status, 'ready');
-  assert.equal(calls.create[0].source, 'discord:bugs');
-  assert.equal(calls.create[0].sourceRef, 'discord:m1');
-  assert.equal(calls.create[0].versionId, 'GDS-V3');
-  assert.match(calls.create[0].description, /reported from Discord #bugs by mona/);
+  assert.equal(calls.create[0].kind, 'bug', 'the channel IS the classification');
+  assert.equal(calls.create[0].filerRank, 'metic', 'the LIVE rank is handed to the matrix');
+  assert.equal(calls.create[0].capturedBy, 9, 'and the reporter is attached to the capture');
+  assert.equal(calls.create[0].goalId, 7, 'the suggester found it a home');
+  // task 1003067: no versionId is passed AT ALL. It used to be the hardcoded
+  // 'GDS-V3' — a shipped version, which is idea 1000771. The goal carries it now.
+  assert.equal(calls.create[0].versionId, undefined, 'this vector no longer names a version');
+  assert.match(calls.create[0].bodyMd, /reported from Discord #bugs by mona/);
   assert.equal(calls.audit[0].surface, 'discord_bot');
   assert.equal(calls.audit[0].responseStatus, 201);
   assert.equal(calls.audit[0].builderId, 9);
@@ -106,18 +129,74 @@ await t('recordInboundBug: linked Xenos → filed at backlog (needs confirm)', a
   const { deps, calls } = makeDeps({ builder: { id: 4, github_login: 'newbie', rank: 'xenos' } });
   const r = await bg.recordInboundBug({ discordUserId: GOOD_ID, content: 'Typo on the welcome sign', messageId: 'm2' }, deps, CFG);
   assert.equal(r.outcome, 'filed');
-  assert.equal(r.status, 'backlog');
-  assert.equal(calls.create[0].status, 'backlog');
+  assert.equal(r.status, 'backlog', 'a sub-Metic report waits for a nod, as before');
+  assert.equal(calls.create[0].filerRank, 'xenos');
 });
 
-await t('recordInboundBug: UNLINKED author → ignored, nothing created', async () => {
+await t('recordInboundBug: UNLINKED author → an inbox idea, never a task [changed by 1003067]', async () => {
+  // WAS: dropped entirely ('unlinked'), because this path minted claimable work
+  // and ADR 0047 would not let an unaccountable author near that. It no longer
+  // mints work, so the report is kept — as an idea row with no author and NO
+  // GOAL, which is exactly what #ideas has always done for the same person.
+  // The security property survives structurally: no goal ⇒ the matrix cannot
+  // route ⇒ no task exists to claim.
   const { deps, calls } = makeDeps({ builder: null });
   const r = await bg.recordInboundBug({ discordUserId: GOOD_ID, content: 'something is broken here', messageId: 'm3' }, deps, CFG);
-  assert.equal(r.outcome, 'ignored');
-  assert.equal(r.reason, 'unlinked');
+  assert.equal(r.outcome, 'filed');
+  assert.equal(r.ideaId, 900, 'the report is recorded rather than silently dropped');
+  assert.equal(r.taskId, null, 'and it is NOT work');
+  assert.equal(r.status, null);
+  assert.equal(calls.create[0].capturedBy, null, 'unattributed, and honestly so');
+  assert.equal(calls.create[0].goalId, null, 'no home is offered to an unlinked author');
+  assert.equal(calls.suggest.length, 0, 'we do not even ask for one');
+  assert.match(calls.create[0].bodyMd, /unlinked author/);
+});
+
+await t('recordInboundBug: an unlinked author is NOT rate-limited by builder id (there is none)', async () => {
+  const { deps, calls } = makeDeps({ builder: null, recent: 999 });
+  const r = await bg.recordInboundBug({ discordUserId: GOOD_ID, content: 'another unlinked report', messageId: 'm3b' }, deps, CFG);
+  assert.equal(r.outcome, 'filed', 'the per-builder cap cannot express an author with no builder row');
+  assert.equal(calls.count.length, 0, 'so it is not consulted');
+  assert.equal(r.taskId, null, 'the bound that matters is that none of it becomes work');
+});
+
+await t('recordInboundBug: a suggester failure still files — to the inbox [1003067]', async () => {
+  // A suggester that throws must not lose the bug report. No goal ⇒ inbox row.
+  const { deps, calls } = makeDeps({ builder: { id: 9, github_login: 'mona', rank: 'metic' }, suggestThrows: true });
+  const r = await bg.recordInboundBug({ discordUserId: GOOD_ID, content: 'the suggester is down', messageId: 'm3c' }, deps, CFG);
+  assert.equal(r.outcome, 'error', 'it surfaces as an error rather than pretending to have filed');
   assert.equal(calls.create.length, 0);
 });
 
+await t('recordInboundBug: a REFUSED goal drops the guess and still files the report [1003067]', async () => {
+  // The suggester picks the home; the goal can still refuse it (protected scope, a
+  // scope-wall verdict, an archive mid-flight). Because routing is one transaction
+  // that refusal takes the idea row with it — so a goal WE guessed at would lose a
+  // report the reporter did nothing wrong to file. Drop the guess, keep the report.
+  const { deps, calls } = makeDeps({ builder: { id: 9, github_login: 'mona', rank: 'metic' }, refuseRouted: true });
+  const r = await bg.recordInboundBug({ discordUserId: GOOD_ID, content: 'a bug whose words match a protected goal', messageId: 'm7' }, deps, CFG);
+  assert.equal(r.outcome, 'filed', 'the report survives the refusal');
+  assert.equal(calls.create.length, 2, 'one routed attempt, then one homeless retry');
+  assert.equal(calls.create[0].goalId, 7, 'the first carried the suggested home');
+  assert.equal(calls.create[1].goalId, null, 'the retry drops it');
+  assert.equal(r.taskId, null, 'and it lands in the inbox, where triage will see it');
+});
+
+await t('recordInboundBug: a refusal with NO goal to drop is a real error, not a retry loop', async () => {
+  const { deps, calls } = makeDeps({ builder: { id: 9, github_login: 'mona', rank: 'metic' }, goal: null, refuseRouted: true, createThrows: true });
+  const r = await bg.recordInboundBug({ discordUserId: GOOD_ID, content: 'the database is simply down', messageId: 'm8' }, deps, CFG);
+  assert.equal(r.outcome, 'error', 'nothing to drop ⇒ surface it rather than retrying forever');
+  assert.equal(calls.create.length, 1, 'exactly one attempt');
+});
+
+await t('recordInboundBug: NO confident goal → the report still lands, in the inbox', async () => {
+  const { deps, calls } = makeDeps({ builder: { id: 9, github_login: 'mona', rank: 'metic' }, goal: null });
+  const r = await bg.recordInboundBug({ discordUserId: GOOD_ID, content: 'a bug matching no goal at all', messageId: 'm3d' }, deps, CFG);
+  assert.equal(r.outcome, 'filed');
+  assert.equal(r.taskId, null, 'no home ⇒ no task, which is the homeless-inbox contract (C2)');
+  assert.equal(calls.create[0].goalId, null);
+});
+
 await t('recordInboundBug: over rate-limit → ignored + audited 429, nothing created', async () => {
   const { deps, calls } = makeDeps({ builder: { id: 9, github_login: 'mona', rank: 'metic' }, recent: 5 });
   const r = await bg.recordInboundBug({ discordUserId: GOOD_ID, content: 'yet another bug report', messageId: 'm4' }, deps, CFG);
@@ -170,7 +249,7 @@ await t('recordInboundBug: audit failure does NOT undo the filing', async () =>
   assert.equal(calls.create.length, 1);
 });
 
-await t('recordInboundBug: createTask error → {error}, never throws', async () => {
+await t('recordInboundBug: a capture error → {error}, never throws', async () => {
   const { deps } = makeDeps({ builder: { id: 9, github_login: 'mona', rank: 'metic' }, createThrows: true });
   const r = await bg.recordInboundBug({ discordUserId: GOOD_ID, content: 'valid bug body here', messageId: 'm' }, deps, CFG);
   assert.equal(r.outcome, 'error');
@@ -202,8 +281,8 @@ await t('recordInboundBug: text + images → persists images + embeds durable li
   assert.equal(r.images, 1);
   assert.equal(calls.persist.length, 1);
   assert.deepEqual(calls.persist[0].urls, ['https://cdn.discordapp.com/a.png']);
-  assert.match(calls.create[0].description, /Attachments \(1\)/);
-  assert.match(calls.create[0].description, /!\[attachment 1\]\(\/api\/gds\/bug-attachments\//);
+  assert.match(calls.create[0].bodyMd, /Attachments \(1\)/);
+  assert.match(calls.create[0].bodyMd, /!\[attachment 1\]\(\/api\/gds\/bug-attachments\//);
 });
 
 await t('recordInboundBug: image-only (empty text) → filed with screenshot title', async () => {
@@ -225,7 +304,7 @@ await t('recordInboundBug: image persist failure → still files (without images
   );
   assert.equal(r.outcome, 'filed');
   assert.equal(r.images, 0);
-  assert.doesNotMatch(calls.create[0].description, /Attachments/);
+  assert.doesNotMatch(calls.create[0].bodyMd, /Attachments/);
 });
 
 await t('recordInboundBug: all images refused (stored empty) → filed, no Attachments block', async () => {
@@ -236,7 +315,7 @@ await t('recordInboundBug: all images refused (stored empty) → filed, no Attac
   );
   assert.equal(r.outcome, 'filed');
   assert.equal(r.images, 0);
-  assert.doesNotMatch(calls.create[0].description, /Attachments/);
+  assert.doesNotMatch(calls.create[0].bodyMd, /Attachments/);
 });
 
 // ---- combineParts ----------------------------------------------------------

package/tests/filing_abuse_matrix.mjs

@@ -29,19 +29,21 @@
 //   F10 make the rate-limit COUNT fail, to slip past the cap   → denied (fail-closed)
 //   F11 file through Discord #bugs at all, as a sub-Metic      → 'backlog', never 'ready'
 //   F12 file through Discord #ideas naming a goal              → that vector cannot route
+//   F15 reach #bugs' old direct-createTask bypass              → it no longer exists
+//   F16 file through #bugs as an UNLINKED author               → an inbox row, never work
 //   F13 declare touches[] outside the goal to widen blast area → the real wall refuses
 //   F14 file against a SHIPPED version's goal                  → refused (version not building)
 //   P1  a Metic+ files a bug in an ordinary goal               → 'ready' (the C1 grant)
 //   P2  a Metic+ files into protected scope                    → allowed, floored to metic
 //
 // AND THE ANTI-DRIFT PIN (the point of the file, really). The rows above are true
-// of the four capture vectors that exist TODAY. Nothing stops a fifth being added
+// of the capture vectors that exist TODAY. Nothing stops a fifth being added
 // next month that quietly skips all of it — which is exactly how the 1000771 bug
 // got in. So the last section ENUMERATES the vectors from source and fails when
 // the roster changes, forcing a new vector's author to come here and add its row.
 //
 // PURE: the decision cores only (decideLanding, authorizeRoutedLanding,
-// decideBugLanding, rateLimitPerHour) — no DB, no network. The transaction that
+// rateLimitPerHour) — no DB, no network. The transaction that
 // obeys them is proven in tests/idea_routing.mjs; the end-to-end attribution trail
 // in tests/idea_route_attribution.mjs.
 //
@@ -72,7 +74,7 @@ const read = (rel) => readFileSync(path.join(ROOT, rel), 'utf8');
 const routing = require('../modules/ideas/routing.js');
 const { decideLanding, authorizeRoutedLanding, routedPriority, PROTECTED_SCOPE_FLOOR } = routing;
 const bugs = require('../modules/discord/discord-bugs.js');
-const { decideBugLanding, rateLimitPerHour } = bugs;
+const { rateLimitPerHour } = bugs;
 const { scopeIncludesProtected, isModuleKey } = require('../src/bongos/module-scope-map.js');
 
 const { test, summary } = makeRunner();
@@ -215,11 +217,15 @@ await test('[F10] a rate-limit COUNT failure DENIES — you cannot break the cou
 });
 
 await test('[F11] #bugs lands a sub-Metic at backlog and only Metic+ at ready', () => {
+  // Since R11 this is the SAME rule as F1/P1 — the channel has no landing logic of
+  // its own. Asserted through the matrix, which is now the only place it exists.
   for (const rank of SUB_METIC) {
-    assert.equal(decideBugLanding(rank), 'backlog', `${JSON.stringify(rank)} must not reach ready`);
+    assert.equal(landing({ kind: 'bug', filerRank: rank }).status, 'backlog',
+      `${JSON.stringify(rank)} must not reach ready`);
   }
   for (const rank of TRUSTED) {
-    assert.equal(decideBugLanding(rank), 'ready', `${rank} is the C1 straight-through grant`);
+    assert.equal(landing({ kind: 'bug', filerRank: rank }).status, 'ready',
+      `${rank} is the C1 straight-through grant`);
   }
 });
 
@@ -228,7 +234,7 @@ await test('[F9+F11] the flood, composed: at the cap, EVERY landed row is still
   const landedStatuses = [];
   for (let i = 0; i < cap + 25; i++) {
     if (i >= cap) continue; // the counter refuses past the cap (F9/F10)
-    landedStatuses.push(decideBugLanding('xenos'));
+    landedStatuses.push(landing({ kind: 'bug', filerRank: 'xenos' }).status);
   }
   assert.equal(landedStatuses.length, cap, 'the cap bounds how many rows exist at all');
   assert.ok(landedStatuses.every((s) => s === 'backlog'),
@@ -297,6 +303,42 @@ await test('priority cannot be weaponised: an out-of-band suggestion is clamped,
   assert.equal(routedPriority(1), 1, 'a sane suggestion still rides through');
 });
 
+// =========================================================================
+// F15–F16 — the #bugs bypass is retired (task 1003067 / BV1.R11)
+// =========================================================================
+
+await test('[F15] #bugs mints NO task of its own — the bypass that lost attribution is gone', () => {
+  const src = read('modules/discord/discord-bugs.js');
+  const code = src.split('\n').filter((l) => !l.trim().startsWith('//')).join('\n');
+  assert.ok(!/\bdeps\.createTask\(/.test(code),
+    'the vector must file through ideas.capture, so every report leaves an idea row + lineage');
+  assert.match(code, /deps\.captureIdea\(/, 'and it does');
+});
+
+await test('[F15b] #bugs names NO version — a vector that cannot name one cannot name a dead one', () => {
+  const src = read('modules/discord/discord-bugs.js');
+  const code = src.split('\n').filter((l) => !l.trim().startsWith('//')).join('\n');
+  // This is idea 1000771 in one assertion: the old default was 'GDS-V3', shipped,
+  // so every bug reported here landed in a closed version's catch-all.
+  assert.ok(!/GDS-V3|DEFAULT_BUGS_VERSION_ID|DISCORD_BUGS_VERSION_ID/.test(code),
+    'no version id may be hardcoded or env-configured on this path any more');
+  assert.ok(!/versionId:/.test(code), 'and none is passed into the capture');
+});
+
+await test('[F16] an unlinked #bugs author gets an inbox row and CANNOT reach work', () => {
+  // The report is kept (it used to be dropped), but with no rank and no goal, so
+  // the matrix has nothing to route: structurally incapable of becoming a task.
+  const noRank = decideLanding({ goalId: null, kind: 'bug', filerRank: null });
+  assert.equal(noRank.route, false, 'no goal ⇒ the inbox');
+  // And even if a goal somehow reached it, an unknown filer never hard-lands:
+  const withGoal = decideLanding({ goalId: 5, kind: 'bug', filerRank: null });
+  assert.equal(withGoal.status, 'backlog', 'never claimable on an unknown filer');
+  const src = read('modules/discord/discord-bugs.js');
+  const code = src.split('\n').filter((l) => !l.trim().startsWith('//')).join('\n');
+  assert.match(code, /if \(builder\) \{[\s\S]{0,200}suggestGoalForCapture/,
+    'a goal is only ever sought for a LINKED builder');
+});
+
 // =========================================================================
 // THE ANTI-DRIFT PIN — a fifth vector cannot arrive unaudited
 // =========================================================================
@@ -308,7 +350,7 @@ const KNOWN_FILING_VECTORS = {
   'modules/ideas/inbox.js': 'routeIdeaToGoal — the ONE transaction every routed filing runs (F1–F8, F13, F14)',
   'modules/ideas/routes/inbox.js': 'POST /inbox — the web + CLI door onto it (F3)',
   'modules/discord/discord-inbound.js': 'Discord #ideas — files an idea, never routes (F12)',
-  'modules/discord/discord-bugs.js': 'Discord #bugs — the direct-createTask bypass R11 retires (F9–F11)',
+  'modules/discord/discord-bugs.js': 'Discord #bugs — files through ideas.capture since R11 (F9–F11, F15, F16)',
 };
 
 await test('[pin] every declared vector still reaches a task-minting path', () => {
@@ -336,20 +378,17 @@ await test('[pin] no OTHER module file mints a task from a filing without a row
     `a new filing vector must be added to KNOWN_FILING_VECTORS and given a matrix row: ${unaudited.join(', ')}`);
 });
 
-await test('[pin] the trusted tier is Metic+ in BOTH decision cores — one boundary, not two', () => {
-  // routing.js and discord-bugs.js each spell the tier locally (both are pure and
-  // import-free by design). They must agree, or "Metic+" means two things.
+await test('[pin] there is ONE trusted-tier definition, and #bugs no longer keeps a copy', () => {
+  // This pin used to assert that two spellings of "Metic+" AGREED — routing.js and
+  // discord-bugs.js each carried one. R11 deleted the second, which is the better
+  // outcome: agreement you have to test for is a duplication you could have removed.
   const routingSrc = read('modules/ideas/routing.js');
-  const bugsSrc = read('modules/discord/discord-bugs.js');
-  assert.match(routingSrc, /METIC_PLUS = new Set\(\['metic', 'archon'\]\)/);
-  assert.match(bugsSrc, /READY_RANKS = new Set\(\['metic', 'archon'\]\)/);
-  // And behaviourally, which is what actually matters:
-  for (const rank of [...SUB_METIC, ...TRUSTED]) {
-    const viaRouting = landing({ kind: 'bug', filerRank: rank }).status;
-    const viaBugs = decideBugLanding(rank);
-    assert.equal(viaRouting, viaBugs,
-      `the two vectors must agree on ${JSON.stringify(rank)} (routing=${viaRouting}, bugs=${viaBugs})`);
-  }
+  assert.match(routingSrc, /METIC_PLUS = new Set\(\['metic', 'archon'\]\)/,
+    'the one definition, in the matrix');
+  const bugsCode = read('modules/discord/discord-bugs.js')
+    .split('\n').filter((l) => !l.trim().startsWith('//')).join('\n');
+  assert.ok(!/READY_RANKS/.test(bugsCode), '#bugs must not reintroduce a local rank set');
+  assert.ok(!/decideBugLanding/.test(bugsCode), 'nor a local landing decision');
 });
 
 summary();

package/tests/goal_subtitle.mjs

@@ -184,20 +184,26 @@ test('an unset subtitle is hidden; a set one is shown trimmed', () => {
   assert.equal(els.sub.textContent, 'the grep path');
 });
 
-test('on a LIST the subtitle is a tooltip, never a second visible line', () => {
+test('on a LIST the subtitle is a visible line; on the CARD it stays a tooltip', () => {
   // task 1003206: the row/card painters moved to goals-render.js — the second half
   // of the carve goals-lib.js began — so read the family, not one filename.
   const js = goalsPageSource();
-  // The helper lives in goals-lib.js — the file that exists because
+  // Both helpers live in goals-lib.js — the file that exists because
   // goals-page.js was over the excess-lines ratchet (task 1003135).
   const lib = read('modules', 'hall-ui', 'public', 'goals-lib.js');
   assert.match(lib, /function subtitleAttr/);
-  assert.match(lib, /escapeHtml\(t\)/, 'escaped, since it lands in an attribute');
-  for (const anchor of ['class="gr-title"', 'class="goal-card__title gr-title"']) {
-    const i = js.indexOf(anchor);
-    assert.ok(i > 0, `${anchor} still rendered`);
-    assert.match(js.slice(i, i + 160), /subtitleAttr\(g\)/, `${anchor} carries the tooltip`);
-  }
+  assert.match(lib, /function subtitleLine/);
+  assert.match(lib, /escapeHtml\(t\)/, 'escaped, since it lands in an attribute or a text node');
+  // task 1003307 gave the ROW its line back on the owner's call: 35 of 72 goals
+  // carry a subtitle, and a tooltip does not exist on a touch screen. The CARD
+  // has no room for a line, so it keeps the tooltip (task 1003224's shape).
+  const row = js.indexOf('class="gr-title"');
+  assert.ok(row > 0, 'the row title is still rendered');
+  assert.match(js.slice(row, row + 200), /subtitleLine\(g\)/, 'the row renders the visible line');
+  assert.doesNotMatch(js.slice(row, row + 160), /subtitleAttr\(g\)/, 'the row does not also carry the tooltip');
+  const card = js.indexOf('class="goal-card__title gr-title"');
+  assert.ok(card > 0, 'the card title is still rendered');
+  assert.match(js.slice(card, card + 160), /subtitleAttr\(g\)/, 'the card carries the tooltip');
 });
 
 test('every CSS token the new styles use actually exists', () => {