@bongos/core 1.19.288 → 1.19.290

package/docs/copy-registry.json

@@ -3,9 +3,9 @@
   "generator": "scripts/gds/copy-inventory.js",
   "goal": 1000074,
   "counts": {
-    "strings": 1337,
-    "unique_ids": 1186,
-    "certain": 1337,
+    "strings": 1339,
+    "unique_ids": 1188,
+    "certain": 1339,
     "heuristic": 0,
     "duplicate_ids": 121
   },
@@ -13,7 +13,7 @@
     "builders-hall": {
       "at": "modules/hall-ui/public",
       "files": 61,
-      "strings": 1053
+      "strings": 1055
     },
     "status-dashboard": {
       "at": "modules/status-ui/public",
@@ -3481,7 +3481,7 @@
       "surface": "builders-hall",
       "text": "Create task",
       "file": "modules/hall-ui/public/task-detail.js",
-      "line": 300,
+      "line": 354,
       "origin": "js-markup",
       "confidence": "certain"
     },
@@ -3823,7 +3823,7 @@
       "surface": "builders-hall",
       "text": "Estimate (min)",
       "file": "modules/hall-ui/public/task-detail.js",
-      "line": 295,
+      "line": 349,
       "origin": "js-markup",
       "confidence": "certain"
     },
@@ -4030,7 +4030,7 @@
       "surface": "builders-hall",
       "text": "Fold this idea into #",
       "file": "modules/hall-ui/public/task-detail.js",
-      "line": 369,
+      "line": 444,
       "origin": "js-markup",
       "confidence": "certain"
     },
@@ -4957,7 +4957,7 @@
       "surface": "builders-hall",
       "text": "Loading versions…",
       "file": "modules/hall-ui/public/task-detail.js",
-      "line": 258,
+      "line": 307,
       "origin": "js-markup",
       "confidence": "certain"
     },
@@ -5623,7 +5623,7 @@
       "surface": "builders-hall",
       "text": "Note (optional)",
       "file": "modules/hall-ui/public/task-detail.js",
-      "line": 372,
+      "line": 447,
       "origin": "js-markup",
       "confidence": "certain"
     },
@@ -6325,7 +6325,7 @@
       "surface": "builders-hall",
       "text": "Reason (optional)",
       "file": "modules/hall-ui/public/task-detail.js",
-      "line": 423,
+      "line": 498,
       "origin": "js-markup",
       "confidence": "certain"
     },
@@ -9313,7 +9313,7 @@
       "surface": "builders-hall",
       "text": "idea number",
       "file": "modules/hall-ui/public/task-detail.js",
-      "line": 370,
+      "line": 445,
       "origin": "js-markup",
       "confidence": "certain"
     },
@@ -9425,6 +9425,15 @@
       "origin": "js-markup",
       "confidence": "certain"
     },
+    {
+      "id": "2ce7738b1eb0",
+      "surface": "builders-hall",
+      "text": "loading goals…",
+      "file": "modules/hall-ui/public/task-detail.js",
+      "line": 371,
+      "origin": "js-markup",
+      "confidence": "certain"
+    },
     {
       "id": "8c22f0ee5edb",
       "surface": "builders-hall",
@@ -10024,7 +10033,7 @@
       "surface": "builders-hall",
       "text": "why these are the same",
       "file": "modules/hall-ui/public/task-detail.js",
-      "line": 373,
+      "line": 448,
       "origin": "js-markup",
       "confidence": "certain"
     },
@@ -10033,7 +10042,7 @@
       "surface": "builders-hall",
       "text": "why this isn’t worth doing",
       "file": "modules/hall-ui/public/task-detail.js",
-      "line": 424,
+      "line": 499,
       "origin": "js-markup",
       "confidence": "certain"
     },
@@ -10478,6 +10487,15 @@
       "origin": "js-markup",
       "confidence": "certain"
     },
+    {
+      "id": "9ac518dfa95e",
+      "surface": "builders-hall",
+      "text": "— none (the version's general bucket) —",
+      "file": "modules/hall-ui/public/task-detail.js",
+      "line": 302,
+      "origin": "js-markup",
+      "confidence": "certain"
+    },
     {
       "id": "da9962dc1729",
       "surface": "builders-hall",
@@ -10645,7 +10663,7 @@
       "surface": "builders-hall",
       "text": "→ no idea #",
       "file": "modules/hall-ui/public/task-detail.js",
-      "line": 391,
+      "line": 466,
       "origin": "js-text-assign",
       "confidence": "certain"
     },

package/modules/hall-ui/public/task-detail.js

@@ -254,6 +254,55 @@
         + '</div>';
     }
 
+    // task 1003071 (R13) — the goal picker's options, same precedence as the CLI
+    // triage path: the STORED hint (idea.suggested_goal_id, written by
+    // inbox.captureIdea precisely so triage inherits the guess) wins; the R07
+    // suggester only fills in when there is no hint. Returns option HTML.
+    async function goalOptionsFor(versionId) {
+      // Number() so a junk stored value cannot reach the DOM as value="NaN" and
+      // then be POSTed as a goal id.
+      var raw = Number(idea.suggested_goal_id);
+      var hint = Number.isFinite(raw) && raw > 0 ? raw : null;
+      var suggestions = [];
+      // The suggester is a convenience, so an outage degrades to "no suggestions"
+      // and must not stop a triage verdict — the hint and the opt-out below are
+      // both still reachable without it.
+      try {
+        var q = '?version=' + encodeURIComponent(versionId)
+          + '&title=' + encodeURIComponent(idea.title || '')
+          + '&body=' + encodeURIComponent(String(idea.body_md || '').slice(0, 2000))
+          + '&limit=5';
+        // softAuth: a cosmetic suggestion list must not navigate the builder away
+        // from a half-filled promote form. The submit re-auths if the session died.
+        var res = await getJSON(API + '/goals/suggestions' + q, { softAuth: true });
+        suggestions = (res && res.suggestions) || [];
+      } catch (_) { suggestions = []; }
+      var opts = [];
+      var seen = {};
+      if (hint != null) {
+        seen[hint] = true;
+        opts.push('<option value="' + hint + '" selected>goal ' + hint + ' — carried from the filing</option>');
+      }
+      suggestions.forEach(function (g, i) {
+        if (seen[g.id]) return;
+        seen[g.id] = true;
+        var why = (g.matched_terms || []).join(', ');
+        // The score + matched terms are shown on purpose: token overlap can match
+        // an incidental word, so the operator judges the suggestion rather than
+        // trusting it (task 1003062's stated limit).
+        opts.push('<option value="' + esc(String(g.id)) + '"' + (hint == null && i === 0 ? ' selected' : '') + '>'
+          + esc(String(g.id)) + ' — ' + esc(g.title || '') + (why ? ' (matched: ' + esc(why) + ')' : '') + '</option>');
+      });
+      // Always offer the opt-out, and make it the fallback when nothing was found.
+      // Sending no goal_id does not create a goal-less task — db.createTask files
+      // it under the version's catch-all "general" goal — so the label names where
+      // it actually lands. That bucket carries no done-when criteria, which is why
+      // it should be a choice rather than the silent default it used to be.
+      opts.push('<option value=""' + (opts.length === 0 ? ' selected' : '')
+        + '>— none (the version\'s general bucket) —</option>');
+      return opts.join('');
+    }
+
     async function renderPromote() {
       box.innerHTML = '<p class="deeplink-card__note">Loading versions…</p>';
       // Both dead ends offer the way back through the same delegated [data-go]
@@ -283,6 +332,10 @@
       // CHECKed 1-5, so clamp rather than let an out-of-range value match no
       // option and leave the browser silently defaulting to P1.
       var pri = Math.min(5, Math.max(1, Number(idea.suggested_priority) || 3));
+      // Fetched for the PREFERRED version; the change listener below re-fetches,
+      // because goals belong to a version and showing another version's goals
+      // would offer a home the server would reject.
+      var goalOptions = await goalOptionsFor(preferred);
       var priOptions = [1, 2, 3, 4, 5].map(function (p) {
         return '<option value="' + p + '"' + (p === pri ? ' selected' : '') + '>P' + p + '</option>';
       }).join('');
@@ -291,6 +344,7 @@
         + '<label class="td-field td-field--wide"><span>Title</span>'
         + '<input type="text" name="title" maxlength="' + TITLE_MAX + '" required value="' + esc(idea.title || '') + '"></label>'
         + '<label class="td-field td-field--wide"><span>Version</span><select name="version">' + options + '</select></label>'
+        + '<label class="td-field td-field--wide"><span>Goal</span><select name="goal" data-goal-select>' + goalOptions + '</select></label>'
         + '<label class="td-field"><span>Priority</span><select name="priority">' + priOptions + '</select></label>'
         + '<label class="td-field"><span>Estimate (min)</span>'
         + '<input type="number" name="est" min="0" max="100000" step="5" placeholder="—"></label>'
@@ -304,6 +358,23 @@
         ev.preventDefault();
         submitPromote(ev.target);
       });
+      // Re-fetch the goal list when the version changes (task 1003071). Two quick
+      // changes race — the fetches can resolve out of order — so only the newest
+      // request is allowed to write, and only it re-enables the control.
+      var vsel = box.querySelector('select[name="version"]');
+      var gsel = box.querySelector('[data-goal-select]');
+      if (vsel && gsel) {
+        var goalFetch = 0;
+        vsel.addEventListener('change', async function () {
+          var mine = ++goalFetch;
+          gsel.disabled = true;
+          gsel.innerHTML = '<option value="">loading goals…</option>';
+          var html = await goalOptionsFor(vsel.value);
+          if (mine !== goalFetch) return;
+          gsel.innerHTML = html;
+          gsel.disabled = false;
+        });
+      }
     }
 
     async function submitPromote(form) {
@@ -325,6 +396,10 @@
         source: 'idea_inbox',
         source_ref: 'idea:' + idea.id,
       };
+      // task 1003071 (R13): the whole point — a triaged promotion NAMES its goal.
+      // Empty means the operator chose the version's general bucket, which the
+      // server applies itself when goal_id is absent.
+      if (form.goal && form.goal.value !== '') payload.goal_id = Number(form.goal.value);
       if (form.est.value !== '') payload.est_minutes = Number(form.est.value);
       if (form.credits.value !== '') payload.credits_reward = Number(form.credits.value);
       // 'criterion-proposal' is an idea-only kind; everything else is shared with

package/modules/lifecycle/goal-suggest.js

@@ -0,0 +1,171 @@
+'use strict';
+
+// modules/lifecycle/goal-suggest.js — "which goal should this work live in?",
+// answered BEFORE anything is created (task 1003062 / R07 of goal 1000071).
+//
+// THE GAP. `buildGoalAdvisory` (goal-advisory.js) already answers this — but only
+// AFTER a task exists, as a hint attached to the 201. Every consumer R07 feeds
+// needs it BEFORE: the hall filing surface offering a goal picker (R08), the CLI
+// asking at capture time (R09), and the Discord suggestion (R11) all have a draft
+// title and no row yet. So the candidate logic is lifted into a pure read that
+// creates nothing.
+//
+// WHY THIS RANKS, rather than returning "the first five open goals". Unranked
+// candidates are useless here: BONGOS-V1 carries dozens of open goals, so an
+// arbitrary five is noise dressed as a suggestion. Ranking is what makes it a
+// suggester. It reuses `tokenize` from criterion-suggest.js — a sibling, already
+// covering the weighting idea (title terms 2, body terms 1) and already tested —
+// so there is one notion of "these two texts are about the same thing" in the
+// module, not two.
+//
+// WHAT A GOAL IS MATCHED ON: its title and its scope_modules. Deliberately NOT
+// its description — a goal description is where a whole planning spec lives (goal
+// 1000062 carries an entire decision record in its), so it shares tokens with
+// almost any draft and would flatten every score toward the same number. Modules
+// are included because they are a strong, cheap signal: a draft about the hall
+// really does belong with a goal scoped to `hall-ui`.
+
+const { tokenize } = require('./criterion-suggest.js');
+const { candidateGoals } = 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');
+
+// Matches suggestCriteria's default so the two suggesters feel the same.
+const SUGGEST_LIMIT = 5;
+
+// Rank open goals against a DRAFT capture. Pure — no DB, no writes; the caller
+// supplies the goal rows.
+//
+//   goals   — open goal rows { id, title, scope_modules }
+//   draft   — { title, body } (body optional: a capture's prose, weighted lower)
+//   opts    — { versionId, limit, includeZero }
+//
+// Returns [{ id, title, scope_modules, score, matched_terms }] best-first, ties
+// broken by ascending id so output is stable for a picker.
+//
+// `includeZero` defaults FALSE, following suggestCriteria: a draft that matches
+// nothing returns [] — "no confident suggestion" — rather than five arbitrary
+// goals. The route reports the open-goal count alongside so a caller can still
+// offer "browse all" without this function pretending to a confidence it lacks.
+function suggestGoals(goals, draft = {}, opts = {}) {
+  const { title = '', body = '' } = draft;
+  const { versionId = null, limit = SUGGEST_LIMIT, includeZero = false } = opts;
+
+  // Weighted term map: body terms at 1, title terms override to 2 (a term in
+  // both IS a title term — the stronger signal wins). suggestCriteria's rule.
+  const weights = new Map();
+  for (const t of tokenize(body)) weights.set(t, 1);
+  for (const t of tokenize(title)) weights.set(t, 2);
+
+  // candidateGoals drops the "<version> — general" catch-all and normalises the
+  // row shape. Reused rather than re-filtered so "which goals may be suggested"
+  // has one definition — the catch-all is never a suggestion, it is the fallback
+  // when there is no home, which is a different question (R03 owns that).
+  const ranked = candidateGoals(goals, versionId).map((g) => {
+    const goalTerms = new Set([
+      ...tokenize(g.title),
+      // A module key like `hall-ui` tokenizes to ['hall','ui']; 'ui' is dropped
+      // by the >=3-char filter, which is fine — 'hall' is the signal.
+      ...tokenize((g.scope_modules || []).join(' ')),
+    ]);
+    let score = 0;
+    const matched = [];
+    for (const [term, w] of weights) {
+      if (goalTerms.has(term)) { score += w; matched.push(term); }
+    }
+    return { ...g, score, matched_terms: matched.sort() };
+  }).sort((a, b) => (b.score - a.score) || (Number(a.id) - Number(b.id)));
+
+  const kept = includeZero ? ranked : ranked.filter((r) => r.score > 0);
+  return kept.slice(0, Math.max(0, limit));
+}
+
+
+// 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
+// requires nothing but its siblings.
+//
+// Creates NOTHING — that is the point of R07. A caller with a draft title gets
+// candidates and decides; POST /inbox (R01) is what actually routes.
+//
+// VISIBILITY, stated rather than silently decided: this returns open goals
+// without filtering on `visibility`, which MATCHES the existing GET /goals — that
+// route already lists private goals' titles to any signed-in builder
+// (db.listGoals has no visibility predicate). So this neither widens nor narrows
+// the status quo. It is worth knowing that the status quo is wider than the
+// private-goal leak rule the CLAIM refusal follows (goal-authz
+// goalMembershipClaimRefusal withholds a private goal's title); reconciling the
+// two is a real decision about the goal board as a whole, not something a
+// suggester should settle on its own.
+function goalSuggestHandler({ db, LIMITS }) {
+  return async function getGoalSuggestions(req, res) {
+    const versionId = String(req.query.version || '').trim();
+    if (!versionId) return res.fail('version_required', 400, { message: 'Pass ?version=<version_id> — suggestions are scoped to one version.' });
+    const title = String(req.query.title || '').slice(0, (LIMITS && LIMITS.TITLE) || 200);
+    const body = String(req.query.body || '').slice(0, 4000);
+    if (!title && !body) {
+      return res.fail('draft_text_required', 400, { message: 'Pass ?title= (and optionally ?body=) — there is nothing to rank against otherwise.' });
+    }
+    const rawLimit = Number(req.query.limit);
+    const limit = Number.isFinite(rawLimit) ? Math.min(Math.max(1, Math.trunc(rawLimit)), 20) : SUGGEST_LIMIT;
+    // Wrapped like criteriaSuggestHandler below: without it a db error escapes to
+    // Express's default handler, which can put internal detail on a JSON API
+    // response. The sibling in this same file already did this; not matching it
+    // was an oversight, not a decision.
+    try {
+      const open = await db.listGoals({ versionId, status: 'open' });
+      const suggestions = suggestGoals(open, { title, body }, { versionId, limit });
+      return res.json({
+        version_id: versionId,
+        // `kind` is echoed, NOT ranked on. Kind decides how a capture LANDS (the
+        // R05 landing matrix: a bug hard-lands, a feature soft-lands); it does not
+        // indicate WHICH goal the work belongs to. Saying so here stops a caller
+        // reading the echo as a ranking input.
+        kind: req.query.kind ? String(req.query.kind).slice(0, 64) : null,
+        suggestions,
+        // So a caller can offer "browse all" honestly when nothing scored: an empty
+        // `suggestions` means "no confident match", never "this version has no goals".
+        open_goal_count: (open || []).length,
+        created: null,
+      });
+    } catch (err) {
+      proseErr(err);
+      return res.fail('suggest_failed', { status: 500, message: 'internal error' });
+    }
+  };
+}
+
+// criteriaSuggestHandler — GET /goals/:id/suggest-criteria (task 2165), moved
+// here in task 1003062. Same reason as its sibling above: routes/goals.js is over
+// the fitness oversize threshold and the ratchet is shrink-only, so adding the
+// goal suggester there had to be PAID FOR — and paying with a cohesion
+// improvement beats shaving comments. It belongs beside the other suggester
+// anyway: both answer "what should this draft attach to", one at goal level and
+// one at criterion level. Behaviour byte-identical; only the registration line
+// stays in the route file so route-rank-check still classifies it.
+function criteriaSuggestHandler({ db, suggestCriteria, parseId }) {
+  return async function getSuggestCriteria(req, res) {
+    const id = parseId(req, res, { code: 'bad_goal_id' });
+    if (id === null) return;
+    try {
+      const goal = await db.getGoal(id);
+      if (!goal) return res.fail('goal_not_found', 404);
+      const criteria = await db.listCriteriaForGoal(id);
+      const limit = Math.min(10, Math.max(1, Number(req.query.limit) || 3));
+      const suggestions = suggestCriteria(
+        criteria,
+        { title: req.query.title, description: req.query.description },
+        { limit }
+      );
+      return res.json({ goal_id: goal.id, suggestions });
+    } catch (err) {
+      // Same seam as its sibling above — one error-handling pattern per file.
+      api.logger('lifecycle').error({ err: err && err.message }, 'GET /goals/:id/suggest-criteria failed');
+      return res.fail('fetch_failed', { status: 500, message: 'internal error' });
+    }
+  };
+}
+
+module.exports = { suggestGoals, goalSuggestHandler, criteriaSuggestHandler, SUGGEST_LIMIT };

package/modules/lifecycle/routes/goals.js

@@ -26,6 +26,7 @@ const api = require('../../../src/module-api');
 const auth = api;
 const db = require('../db');
 const hierarchy = require('../hierarchy');
+const goalSuggest = require('../goal-suggest.js'); // task 1003062 — pre-creation goal suggester
 const goalEdits = require('../goal-edits.js'); // task 1003102 — goal self-edit handlers
 const { suggestCriteria } = require('../criterion-suggest');
 const { classifyTaskKind, VALID_KINDS, VALID_DISCIPLINES, TASK_FIELD_BOUNDS } = require('../task-classifier');
@@ -535,6 +536,13 @@ module.exports = function buildGoalsRouter() {
     }
   });
 
+  // GET /goals/suggestions — "which goal should this draft live in?", answered
+  // before anything is created (task 1003062 / R07). Handler + the ranking and
+  // visibility rationale: ../goal-suggest.js. Mounted BEFORE GET /goals/:id so
+  // 'suggestions' is never captured as an id.
+  // rank: any-builder — a read of open goal titles, same surface as GET /goals.
+  router.get('/goals/suggestions', auth.requireBuilder, goalSuggest.goalSuggestHandler({ db, LIMITS }));
+
   // GET /goals/inbox — the caller's private-goals inbox (task 1952 / ADR 0112):
   // { invitations: invites addressed to me (accept/decline); joinRequests: pending
   // join-requests on goals I own or manage (approve/deny); myPendingRequests: my own
@@ -578,25 +586,7 @@ module.exports = function buildGoalsRouter() {
   // task, so a create flow can SUGGEST which done-when criterion to link (the
   // author confirms/overrides — nothing is auto-linked). Read-only + advisory;
   // rank: any-builder (same as GET /goals/:id).
-  router.get('/goals/:id/suggest-criteria', auth.requireBuilder, async (req, res) => {
-    const id = parseId(req, res, { code: 'bad_goal_id' });
-    if (id === null) return;
-    try {
-      const goal = await db.getGoal(id);
-      if (!goal) return res.fail('goal_not_found', 404);
-      const criteria = await db.listCriteriaForGoal(id);
-      const limit = Math.min(10, Math.max(1, Number(req.query.limit) || 3));
-      const suggestions = suggestCriteria(
-        criteria,
-        { title: req.query.title, description: req.query.description },
-        { limit }
-      );
-      return res.json({ goal_id: goal.id, suggestions });
-    } catch (err) {
-      console.error('[gds] GET /goals/:id/suggest-criteria', err);
-      return res.fail('fetch_failed', { status: 500, message: 'internal error' });
-    }
-  });
+  router.get('/goals/:id/suggest-criteria', auth.requireBuilder, goalSuggest.criteriaSuggestHandler({ db, suggestCriteria, parseId }));
 
   // POST /goals/:id/join — join an open goal.
   // rank: any-builder — open join for a NORMAL goal. A PROTECTED-scope goal is

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.288",
+  "version": "1.19.290",
   "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/scripts/gds/triage.js

@@ -151,11 +151,80 @@ async function patchIdea(id, patch) {
   return r.data?.idea;
 }
 
-async function createTask({ versionId, title, description, priority, sourceRef }) {
-  // NOTE: POST /api/gds/tasks doesn't currently accept 'kind' — tasks default
-  // to 'unclassified' and the server-side classifier (B1) runs separately.
-  // The idea's auto-classified kind is therefore informational only at this
-  // step; the task description preserves the body for re-classification.
+// resolveGoalDefault — what goal should a triaged promotion land in? (task
+// 1003071 / R13.)
+//
+// PRECEDENCE IS DELIBERATE:
+//   1. `idea.suggested_goal_id` — the STORED hint. inbox.captureIdea writes it
+//      even when the matrix declined to route, precisely so "/idea-triage
+//      inherits the guess instead of re-deriving it" (core_222, its own comment).
+//      A human or a filing surface already named this goal; a heuristic must not
+//      overrule that.
+//   2. the R07 suggester (GET /goals/suggestions) — only when there is no hint.
+//      Best-scoring candidate, and its score/matched_terms are shown so the
+//      operator can see WHY before accepting.
+// Returns { goalId, label, source } — goalId null when neither yields anything.
+// The caller prints `source` as provenance, because "the suggester guessed this"
+// and "the filing already named this" deserve different trust. Never throws: a
+// suggester outage degrades to "no default", it does not block a triage verdict.
+//
+// `client` is injectable so the precedence can be driven end-to-end in a test
+// rather than pattern-matched in the source. (Task 1003102 shipped a handler
+// whose collaborators were not injectable; its tests read the source, passed,
+// and the route 500'd on every call. Not repeating that.)
+async function resolveGoalDefault(idea, versionId, { client = cliClient } = {}) {
+  // Guarded: a junk stored value must not become goalId NaN and then a goal_id
+  // the server rejects with 400 on every retry.
+  const hint = Number(idea.suggested_goal_id);
+  if (Number.isInteger(hint) && hint > 0) {
+    return { goalId: hint, label: `goal ${hint}`, source: 'hint' };
+  }
+  try {
+    const api = await client();
+    // The GENERATED typed method (regenerated when R07 landed), not the generic
+    // request() escape hatch — so a path or param rename reds the client build.
+    const r = await api.goals.getGoalsSuggestions({
+      query: { version: versionId, title: idea.title || '', body: (idea.body_md || '').slice(0, 2000), limit: 3 },
+    });
+    const top = r.ok && r.data && Array.isArray(r.data.suggestions) ? r.data.suggestions[0] : null;
+    if (!top) return { goalId: null, label: null, source: 'none' };
+    const why = (top.matched_terms || []).join('/');
+    return { goalId: Number(top.id), label: `${top.id} ${trim(top.title, 44)} (score ${top.score}${why ? ' · ' + why : ''})`, source: 'suggester' };
+  } catch (_) {
+    return { goalId: null, label: null, source: 'unavailable' };
+  }
+}
+
+// What the operator's answer to the goal prompt means. Blank ACCEPTS the shown
+// default — declining has to be said ('-' or 'none'), because silently dropping a
+// real default on a bare Enter is how work ends up in the general bucket by
+// accident. Declining is legal: the server then applies the catch-all itself.
+function applyGoalAnswer(defaultGoalId, rawAnswer) {
+  const answer = String(rawAnswer == null ? '' : rawAnswer).trim();
+  if (answer === '') return { goalId: defaultGoalId, warn: null };
+  if (answer === '-' || answer.toLowerCase() === 'none') return { goalId: null, warn: null };
+  const parsed = Number(answer);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    return { goalId: null, warn: "not a goal id — falling back to the version's general bucket" };
+  }
+  return { goalId: parsed, warn: null };
+}
+
+async function createTask({ versionId, title, description, priority, sourceRef, goalId = null }) {
+  // (The old note here said POST /api/gds/tasks does not accept 'kind'. That is
+  // no longer true — routes/tasks.js takes it, and the hall promote path already
+  // sends it. Left un-sent from THIS path deliberately: changing what kind a
+  // triaged promotion lands with is a behaviour change task R13 was not asked to
+  // make, and the server classifier still runs. Corrected rather than deleted so
+  // the next reader does not re-derive it.)
+  //
+  // task 1003071 (R13): goal_id is the point of this task. Omitting it does NOT
+  // leave the task goal-less — db.createTask (modules/lifecycle/db.js) defaults a
+  // goal-less create into the version's catch-all "<version> — general" goal. That
+  // bucket is the actual defect: it carries no done-when criteria, so since ADR
+  // 0183 made criteria close themselves off LINKED tasks, work parked there can
+  // never advance anything, and it does not read as real goal work on the board.
+  // Naming the goal here is what stops a triaged promotion falling into it.
   const body = {
     version_id: versionId,
     title,
@@ -165,6 +234,7 @@ async function createTask({ versionId, title, description, priority, sourceRef }
     source: 'idea_inbox',
     source_ref: sourceRef ?? null,
   };
+  if (goalId != null) body.goal_id = Number(goalId);
   const api = await cliClient();
   const r = await api.tasks.postTasks({ body });
   if (!r.ok) {
@@ -296,7 +366,7 @@ async function main() {
         }
 
         if (ans === 'p' || ans === 'promote') {
-          // Promote: ask for version + priority (defaulted from idea).
+          // Promote: version, priority, title, goal — each defaulted from the idea.
           const defaultVersion = idea.suggested_version || 'PMS-V2';
           const versionAns = (await prompt(rl, `  version [${defaultVersion}]: `)).trim();
           const versionId = versionAns || defaultVersion;
@@ -308,6 +378,23 @@ async function main() {
           const titleAns = (await prompt(rl, `  title [${trim(idea.title, 60)}]: `)).trim();
           const title = titleAns || idea.title;
 
+          // task 1003071 (R13): a triaged promotion NAMES its goal. The default
+          // comes from the stored hint, else the R07 suggester; '-' opts out
+          // explicitly, which falls through to the version's catch-all "general"
+          // bucket — now a choice someone typed rather than the silent default.
+          // The EFFECTIVE title, not idea.title: the suggester matches on title
+          // terms, and the operator may just have retitled this.
+          const gd = await resolveGoalDefault({ ...idea, title }, versionId);
+          if (gd.source === 'suggester') console.log(`  suggested goal: ${gd.label}`);
+          if (gd.source === 'unavailable') console.log('  (goal suggester unreachable — enter a goal id, or "-" to accept the general bucket)');
+          const goalPrompt = gd.goalId != null
+            ? `  goal [${gd.goalId}] ("-" for the version's general bucket): `
+            : '  goal (blank/"-" for the version\'s general bucket): ';
+          const goalAns = (await prompt(rl, goalPrompt)).trim();
+          const picked = applyGoalAnswer(gd.goalId, goalAns);
+          if (picked.warn) console.log(`  ! ${picked.warn}`);
+          const goalId = picked.goalId;
+
           try {
             const task = await createTask({
               versionId,
@@ -315,6 +402,7 @@ async function main() {
               description: idea.body_md || '',
               priority: Number.isFinite(priority) ? priority : null,
               sourceRef: `idea:${idea.id}`,
+              goalId,
             });
             await patchIdea(idea.id, {
               status: 'promoted',
@@ -323,7 +411,7 @@ async function main() {
             });
             summary.promoted++;
             promotedIds.push({ ideaId: idea.id, taskId: task.id });
-            console.log(`  ✓ promoted #${idea.id} → task #${task.id} (${versionId}, P${priority})`);
+            console.log(`  ✓ promoted #${idea.id} → task #${task.id} (${versionId}, P${priority}${goalId != null ? `, goal ${goalId}` : ', → general bucket'})`);
           } catch (err) {
             console.error(`  ! ${err.message}`);
           }
@@ -360,6 +448,9 @@ if (require.main === module) {
 }
 
 module.exports = {
+  resolveGoalDefault,
+  applyGoalAnswer,
+  createTask,
   resolveDevelopmentPath,
   parseDevelopment,
   loadDevelopment,