@bongos/core 1.19.496 → 1.19.498

package/docs/file-map.md

@@ -185,7 +185,7 @@
 │       ├── box.js               ← (#598/ADR 0031) per-builder dev box lifecycle CLI: provision·park·wake·deprovision·sweep-idle·sweep-dormant·status (dry-run default, --apply to act; rank-gated)
 │       ├── smoke-box.sh         ← (#598) hermetic box-lifecycle smoke (no DB/DO/network): runs tests/boxes.mjs + tests/cf_tunnel.mjs (#771 named tunnel) + route-rank + module-load
 │       ├── recall.js            ← `/recall` CLI: two-call progressive-disclosure search (summary → `--expand <id>`) over Bongos retrieval layer (ADR 0060); `node scripts/gds/recall.js <query>`
-│       ├── capture.js           ← file an idea_inbox row from the CLI (the ideas.capture kernel port); backs the "capture a tangent" flow across skills. Task 1002927 / R151 taught it the GRADES: `--full --fields-file f.json` files a Full Idea, `--spark` is capture-then-mark (two requests — the route refuses a pre-marked capture), and after a plain quick capture it OFFERS to develop further. That offer is TTY-gated (`--no-prompt` too): capture.js is run by agents with no terminal and reads its body from stdin, so an unguarded prompt would hang every non-interactive caller
+│       ├── capture.js           ← file an idea_inbox row from the CLI (the ideas.capture kernel port); backs the "capture a tangent" flow across skills. Task 1002927 / R151 taught it the GRADES: `--full --fields-file f.json` files a Full Idea, `--spark` is capture-then-mark (two requests — the route refuses a pre-marked capture), and after a plain quick capture it OFFERS to develop further. That offer is TTY-gated (`--no-prompt` too): capture.js is run by agents with no terminal and reads its body from stdin, so an unguarded prompt would hang every non-interactive caller. Task 1003070 / R09 (goal 1000071) taught it capture-time ROUTING: `--goal N` sends goal_id, `--goal none` opts out explicitly, and with neither it defaults to the caller's active claim's goal, else prints a one-line R07 suggester hint
 │       ├── spark.js            ← (tasks 1002920 / R144 + 1002921 / R145 + 1002922 / R146) the whole spark handoff from the terminal: mark one of your OWN quick ideas as a Big Idea Spark (`--undo` withdraws it), `--list` is the SPARK QUEUE, `--template` prints the five Full Idea fields, `--develop <id> --fields-file <json>` is the PICKUP (any builder; author + developer both recorded). Author-only server-side for the mark (it is the consent); its own command because sparking acts on an EXISTING idea, which is why capture.js refuses grade='spark'
 │       ├── stale-worktrees.js   ← (task 1003365) the per-claim worktrees whose branch already landed on origin/main or is gone — pure git facts, no API; `--line` is the SessionStart probe, `/worktree-clean` walks the list through worktree.js remove
 │       ├── worktree-claim-guard.js ← (task 1002579) the PURE decision behind worktree-per-claim, enforced at claim time: claiming in the MAIN CHECKOUT is refused (escape hatch `--here` → loud warning), a linked worktree passes, an unclassifiable tree fails open. Stops the ship-time "the main checkout is on <branch>, not main" strand at its cause

package/docs/module-api-changelog.md

@@ -1429,5 +1429,9 @@ is load-bearing: the script throws rather than guess if it is missing, and
         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)
+  1.19.497 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.496 with no explicit bump. run 33767382661. (task 1002620)
+  1.19.498 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.497 with no explicit bump. run 33768753719. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/modules/discord/discord-inbound.js

@@ -20,6 +20,25 @@
 //
 // Requires (go-live): the Message Content PRIVILEGED intent (to read message
 // text) + DISCORD_IDEAS_CHANNEL_ID. Inert until both are set.
+//
+// ROUTING HINTS, NEVER ROUTING (task 1003068, BV1.R12; goal 1000071 criterion
+// C5, deliberately not C1/C3). Unlike #bugs (discord-bugs.js, R11), this vector
+// never routes: a Discord author is outside the trust boundary (ADR 0016,
+// ADR 0032), so their message may SUGGEST a goal but must never BIND one. The
+// suggester (modules/lifecycle/goal-suggest.js, resolved through the same
+// `lifecycle` port #bugs already consumes) supplies a candidate goal; its id
+// rides onto the row as the advisory `suggested_goal_id` hint (core_222) and its
+// `version_id` as `suggested_version` — both read-only guesses for /idea-triage
+// (R13), never `goalId`, which is what would make captureIdea actually route.
+//
+// suggested_version DEFAULTS even without a goal match: when the classifier
+// finds no confident goal, `suggested_version` falls back to whichever open
+// version most recently started `status='building'` — the version a filer is
+// overwhelmingly likely to mean when they post right now, absent any other
+// signal. A matched goal's OWN version always wins over the default (the two
+// travel together elsewhere in this goal — a routed capture binds to the
+// goal's version, never a caller-supplied one), so the fallback only fires
+// when there is truly nothing more specific to say.
 
 // captureIdea is no longer a doorway export (retired at BV1.R78 / ADR 0093 §5).
 // We resolve the `ideas.capture` kernel PORT the ideas module registers — the
@@ -31,6 +50,7 @@ const auth = require('./auth');
 const attachments = require('./bug-attachments');
 const { createMessageAggregator } = require('./discord-message-buffer');
 const { LIMITS } = api;
+const log = api.logger('discord');
 
 // Auto-pairing window for #ideas (task #979) — same default as #bugs. Env
 // DISCORD_IDEAS_PAIR_WINDOW_MS overrides.
@@ -68,10 +88,37 @@ const realDeps = {
   // Lazy: resolve the `ideas.capture` port at CALL time, so the ideas module's
   // registration (at its route-factory mount) need not precede this module's load.
   captureIdea: (...a) => api.resolve('ideas.capture')(...a),
+  // resolveOptional, not resolve: a vanilla instance without the lifecycle
+  // module has no goals to suggest, and that is a reason to skip the hint —
+  // never a reason to lose the idea (the discord-bugs.js precedent).
+  suggestGoalForCapture: async (...a) => {
+    const lifecycle = api.resolveOptional && api.resolveOptional('lifecycle');
+    if (!lifecycle || !lifecycle.suggestGoalForCapture) return null;
+    return lifecycle.suggestGoalForCapture(...a);
+  },
+  // Same resolveOptional posture — a vanilla instance without lifecycle has no
+  // versions to default to, which is a reason to skip the default, never the idea.
+  listVersions: async () => {
+    const lifecycle = api.resolveOptional && api.resolveOptional('lifecycle');
+    if (!lifecycle || !lifecycle.listVersions) return [];
+    return lifecycle.listVersions();
+  },
   insertAuditLog: db.insertAuditLog,
   persistImages: attachments.persistImages,
 };
 
+// mostRecentBuildingVersionId — PURE: the id of whichever `status='building'`
+// version most recently started, or null. The suggested_version fallback for a
+// filing whose classifier found no confident goal (see header). `started_at` is
+// a timestamp string/Date; String() comparison is wrong for it, so this compares
+// parsed dates explicitly rather than relying on default sort.
+function mostRecentBuildingVersionId(versions) {
+  const building = (Array.isArray(versions) ? versions : []).filter((v) => v && v.status === 'building');
+  if (building.length === 0) return null;
+  building.sort((a, b) => new Date(b.started_at) - new Date(a.started_at));
+  return building[0].id;
+}
+
 // File one inbound message as an idea. NEVER throws (the caller is a gateway
 // event handler). Returns a small status object for logging/tests.
 async function recordInboundIdea({ discordUserId, content, imageUrls = [], messageId }, deps = realDeps) {
@@ -114,12 +161,34 @@ async function recordInboundIdea({ discordUserId, content, imageUrls = [], messa
     }
     bodyMd = bodyMd.slice(0, LIMITS.DESCRIPTION);
 
+    // HINTS ONLY (see header). Neither lookup throws into the filing — a
+    // suggester/version-list outage must not cost the idea, only the hints.
+    let hint = null;
+    try {
+      hint = await deps.suggestGoalForCapture({ title: derived.title, body: derived.bodyMd });
+    } catch (e) {
+      log.warn({ err: e && e.message }, 'idea goal suggestion failed — filing without a goal hint');
+    }
+    let suggestedVersion = hint ? hint.version_id : null;
+    if (!suggestedVersion) {
+      try {
+        suggestedVersion = mostRecentBuildingVersionId(await deps.listVersions());
+      } catch (e) {
+        log.warn({ err: e && e.message }, 'default-version lookup failed — filing without a version hint');
+      }
+    }
+
     const idea = await deps.captureIdea({
       title: derived.title,
       bodyMd,
       capturedBy: builder ? builder.id : null,
       // kind left null → inbox.captureIdea auto-classifies. We never pass
       // 'criterion-proposal' (the rank-gated kind) from this path.
+      // suggestedGoalId/suggestedVersion are ADVISORY-ONLY columns — this call
+      // deliberately never names the routing parameter (see header + F12 in
+      // tests/filing_abuse_matrix.mjs, which greps this exact call for it).
+      suggestedGoalId: hint ? hint.id : null,
+      suggestedVersion,
     });
 
     await auditDiscordBot(deps, {
@@ -144,4 +213,7 @@ function createIdeaAggregator({ onFlush, windowMs = pairWindowMs(), timers = glo
   return createMessageAggregator({ onFlush, windowMs, timers });
 }
 
-module.exports = { deriveIdea, recordInboundIdea, createIdeaAggregator, pairWindowMs, realDeps };
+module.exports = {
+  deriveIdea, recordInboundIdea, createIdeaAggregator, pairWindowMs, realDeps,
+  mostRecentBuildingVersionId,
+};

package/modules/hall-ui/public/ideas.css

@@ -74,6 +74,11 @@
 .fi-err { margin: var(--sp-sm) 0 0; max-width: var(--measure); font-size: 14px; line-height: 1.5; color: var(--danger); }
 .fi-err[data-visible="0"] { display: none; }
 
+/* The quick-filing form's outcome line (task 1003069 / R08) — a routed capture
+   names the task it landed in, so its link takes the world's 24px row recipe. */
+.fi-result { margin: var(--sp-sm) 0 0; max-width: var(--measure); font-size: 14px; line-height: 1.5; color: var(--ink-soft); }
+.fi-result a { display: inline-block; min-height: 24px; padding: 3px 0; line-height: 18px; box-sizing: border-box; color: inherit; }
+
 .fi-actions { display: flex; flex-wrap: wrap; gap: 10px 12px; align-items: center; margin-top: var(--sp-md); }
 .fi-draft { font-size: 12.5px; color: var(--ink-faint); }
 

package/modules/hall-ui/public/ideas.html

@@ -47,6 +47,60 @@
           <div id="fi-queue"><p class="fi-note">Loading…</p></div>
         </section>
 
+        <!-- Quick filing (task 1003069 / R08, goal 1000071 "Idea routing") —
+             the hall's first bug/idea report, separate from the Full Idea
+             composer below: title + kind + optional body + a goal picker fed
+             by the R07 suggester. A routed capture must never carry
+             grade='full' (routing.js NEVER_ROUTE_GRADE), so this cannot share
+             a submit with the form below it. Hidden while developing a spark
+             (?develop=<id>) — that surface always turns someone else's
+             existing thought into a Full Idea, never a fresh quick report. -->
+        <section class="scroll" id="fq-compose-scroll" aria-labelledby="fq-compose-h">
+          <h2 id="fq-compose-h" class="scroll__h">File a bug or idea</h2>
+          <p class="scroll__lede">
+            A quick report — title, what's going on, and where it belongs. Pick a goal
+            and it lands there as a task the moment you file; leave it on "no goal" and
+            it waits in the inbox for triage.
+          </p>
+
+          <form id="fq-form" novalidate>
+            <label class="fi-label" for="fq-title">Title</label>
+            <input type="text" id="fq-title" class="fi-input" maxlength="200" autocomplete="off"
+                   placeholder="what's wrong, or what you'd like to see">
+
+            <label class="fi-label" for="fq-kind">Kind</label>
+            <select id="fq-kind" class="fi-input">
+              <option value="bug" selected>Bug</option>
+              <option value="feature">Feature</option>
+              <option value="infra">Infra</option>
+              <option value="refactor">Refactor</option>
+              <option value="spike">Spike</option>
+              <option value="learning-capture">Learning capture</option>
+              <option value="cleanup">Cleanup</option>
+              <option value="decision">Decision</option>
+              <option value="blocker-resolution">Blocker resolution</option>
+              <option value="unclassified">Unclassified</option>
+            </select>
+
+            <label class="fi-label" for="fq-body">Details <span class="fi-hint">(optional)</span></label>
+            <textarea id="fq-body" class="fi-text" rows="4"
+                      placeholder="repro steps, context, anything that helps…"></textarea>
+
+            <label class="fi-label" for="fq-goal">
+              Goal
+              <span class="fi-hint">Suggested as you type; leave it on "no goal" and it waits for triage.</span>
+            </label>
+            <select id="fq-goal" class="fi-input"></select>
+
+            <p class="fi-err" id="fq-err" role="alert"></p>
+            <p class="fi-result" id="fq-result" role="status" aria-live="polite"></p>
+
+            <div class="fi-actions">
+              <button type="submit" class="btn" id="fq-submit">File it</button>
+            </div>
+          </form>
+        </section>
+
         <!-- The composer. The idea detail view lives on its own page (R153). -->
         <section class="scroll" id="fi-compose-scroll" aria-labelledby="fi-compose-h">
           <h2 id="fi-compose-h" class="scroll__h">Write a Full Idea</h2>
@@ -121,6 +175,9 @@
 <script src="/builders/shell.js?v=2026-07-02-shell1"></script>
 <script src="/builders/palette.js" defer></script>
 <script src="/builders/dom-utils.js?v=2026-06-23-contrib"></script>
+<!-- task 1003069 (R08) — the quick-filing form's routed result links a task
+     through window.OTBTaskDetail.href(); guarded if this ever loads without it. -->
+<script src="/builders/task-detail.js?v=2026-07-03-taskdetail2" defer></script>
 <script src="/builders/ideas.js?v=2026-08-22-r154"></script>
 </body>
 </html>

package/modules/hall-ui/public/ideas.js

@@ -75,6 +75,20 @@
   let draftTimer = null;
   let filing = false;
 
+  // QUICK FILING (task 1003069 / R08, goal 1000071 "Idea routing"). A second,
+  // independent capture path on this page: title + kind + optional body + a
+  // goal picker fed by the R07 suggester (GET /goals/suggestions). It lives
+  // beside the Full Idea form above rather than inside it — a routed capture
+  // must never carry grade='full' (routing.js NEVER_ROUTE_GRADE), so the two
+  // cannot share one submit. Quick-mode only: hidden while developing a spark.
+  const QUICK_SUGGEST_DEBOUNCE_MS = 300;
+  let buildingVersionIds = [];   // fetched once — the suggester is scoped per version
+  let allOpenGoals = [];         // the picker's "browse everything" half
+  let allGoalsById = new Map();  // for naming the goal a routed capture landed in
+  let goalTouchedByUser = false; // once the builder picks, stop clobbering it with fresh suggestions
+  let quickSuggestTimer = null;
+  let quickFiling = false;
+
   // ---------------------------------------------------------------------------
   // draft persistence
   // ---------------------------------------------------------------------------
@@ -347,6 +361,155 @@
     toast('Draft discarded.');
   }
 
+  // ---------------------------------------------------------------------------
+  // quick filing — kind + goal picker (task 1003069 / R08)
+  // ---------------------------------------------------------------------------
+
+  const fqTitleEl = () => $('#fq-title');
+  const fqKindEl = () => $('#fq-kind');
+  const fqBodyEl = () => $('#fq-body');
+  const fqGoalEl = () => $('#fq-goal');
+
+  // The picker's options: "no goal" first (the default — a filer never has to
+  // know the goal map, C5), then whatever the suggester found, then every open
+  // goal it didn't. Suggested ids are excluded from the second list rather than
+  // shown twice.
+  function renderGoalOptions(suggested) {
+    const sel = fqGoalEl();
+    const suggestedIds = new Set((suggested || []).map((g) => String(g.id)));
+    const rest = allOpenGoals.filter((g) => !suggestedIds.has(String(g.id)));
+    const optionHtml = (g, why) => `<option value="${escapeHtml(String(g.id))}">${escapeHtml(g.title || `goal ${g.id}`)}${why ? ` — matched: ${escapeHtml(why)}` : ''}</option>`;
+    let html = `<option value="" selected>No goal (homeless)</option>`;
+    if (suggested && suggested.length) {
+      html += `<optgroup label="Suggested">${suggested.map((g) => optionHtml(g, (g.matched_terms || []).join(', '))).join('')}</optgroup>`;
+    }
+    html += `<optgroup label="All open goals">${rest.map((g) => optionHtml(g)).join('')}</optgroup>`;
+    sel.innerHTML = html;
+  }
+
+  // The suggester is ranked per version (GET /goals/suggestions requires one),
+  // so a filer whose instance has more than one version building gets both
+  // consulted and merged by score. An outage — or no building version at all —
+  // degrades to "no suggestions"; the homeless option and the full goal list
+  // are still there either way (goal-suggest.js's own fail-open contract).
+  async function refreshGoalSuggestions() {
+    if (goalTouchedByUser) return; // never yank a manual pick out from under someone
+    const title = fqTitleEl().value.trim();
+    if (!title || !buildingVersionIds.length) { renderGoalOptions([]); return; }
+    const kind = fqKindEl().value;
+    try {
+      const results = await Promise.all(buildingVersionIds.map((versionId) => api.goals.getGoalsSuggestions({
+        query: { version: versionId, title, kind, limit: 5 },
+      })));
+      const byId = new Map();
+      for (const r of results) {
+        if (!r.ok || !r.data || !Array.isArray(r.data.suggestions)) continue;
+        for (const g of r.data.suggestions) {
+          const prev = byId.get(String(g.id));
+          if (!prev || g.score > prev.score) byId.set(String(g.id), g);
+        }
+      }
+      const merged = Array.from(byId.values()).sort((a, b) => b.score - a.score).slice(0, 5);
+      renderGoalOptions(merged);
+    } catch (_) {
+      renderGoalOptions([]);
+    }
+  }
+
+  function onQuickTitleEdit() {
+    clearTimeout(quickSuggestTimer);
+    quickSuggestTimer = setTimeout(refreshGoalSuggestions, QUICK_SUGGEST_DEBOUNCE_MS);
+  }
+
+  function showQuickErr(msg) {
+    $('#fq-err').textContent = msg || '';
+  }
+
+  // The server names why a routed capture was refused (task 1003066's landing
+  // gate) or names the refusal code when it doesn't — read it, never re-derive
+  // the landing matrix here (routing.js stays the one place that decides).
+  function explainQuickFiling(status, data) {
+    const err = data && data.error;
+    const code = err && (typeof err === 'object' ? err.code : err);
+    const details = (err && typeof err === 'object' && err.details) || {};
+    if (details.reason) return `Not filed — ${details.reason}`;
+    if (code) return `Not filed — ${code}.`;
+    if (status === 401 || status === 403) return 'Not filed — your session may have expired. Reload and try again.';
+    return `Not filed (${status}). Nothing was saved — try again.`;
+  }
+
+  async function fileQuick(ev) {
+    ev.preventDefault();
+    if (quickFiling) return;
+    const title = fqTitleEl().value.trim();
+    showQuickErr('');
+    $('#fq-result').innerHTML = '';
+    if (!title) { showQuickErr('Not filed — a title is required.'); return; }
+    quickFiling = true;
+    $('#fq-submit').disabled = true;
+
+    const goalId = fqGoalEl().value;
+    const body = { title, body_md: fqBodyEl().value, kind: fqKindEl().value };
+    if (goalId) body.goal_id = Number(goalId);
+
+    const r = await api.inbox.postInbox({ body });
+    quickFiling = false;
+    $('#fq-submit').disabled = false;
+
+    if (!r.ok) {
+      showQuickErr(explainQuickFiling(r.status, r.data));
+      return;
+    }
+
+    // The routing verdict travels on idea.routing; a routed capture also
+    // carries the task it became at the top level (routed_task) — see
+    // routes/inbox.js. Not routed (no goal picked, or the matrix declined
+    // one) is exactly today's inbox behaviour.
+    const routedTask = r.data && r.data.routed_task;
+    const routing = r.data && r.data.idea && r.data.idea.routing;
+    if (routedTask && routedTask.id && routing && routing.routed) {
+      const href = window.OTBTaskDetail && typeof window.OTBTaskDetail.href === 'function'
+        ? window.OTBTaskDetail.href(routedTask.id)
+        : `/task/${encodeURIComponent(routedTask.id)}`;
+      const goal = allGoalsById.get(String(routing.goal_id));
+      const goalName = goal ? goal.title : `goal ${routing.goal_id}`;
+      $('#fq-result').innerHTML = `Filed as <a href="${href}">task ${escapeHtml(String(routedTask.id))}</a> under ${escapeHtml(goalName)}.`;
+    } else {
+      $('#fq-result').textContent = 'Filed to the inbox.';
+    }
+
+    fqTitleEl().value = '';
+    fqBodyEl().value = '';
+    fqKindEl().value = 'bug';
+    goalTouchedByUser = false;
+    renderGoalOptions([]);
+  }
+
+  async function bootQuickComposer() {
+    fqKindEl().value = 'bug';
+    renderGoalOptions([]);
+    fqTitleEl().addEventListener('input', onQuickTitleEdit);
+    fqKindEl().addEventListener('change', onQuickTitleEdit);
+    fqGoalEl().addEventListener('change', () => { goalTouchedByUser = true; });
+    $('#fq-form').addEventListener('submit', fileQuick);
+
+    try {
+      const [versionsRes, goalsRes] = await Promise.all([
+        api.versions.getVersions({}),
+        api.goals.getGoals({ query: { status: 'open' } }),
+      ]);
+      buildingVersionIds = (versionsRes.ok && versionsRes.data && Array.isArray(versionsRes.data.versions))
+        ? versionsRes.data.versions.filter((v) => v.status === 'building').map((v) => v.id)
+        : [];
+      allOpenGoals = (goalsRes.ok && goalsRes.data && Array.isArray(goalsRes.data.goals)) ? goalsRes.data.goals : [];
+      allGoalsById = new Map(allOpenGoals.map((g) => [String(g.id), g]));
+      renderGoalOptions([]);
+    } catch (_) {
+      // The picker degrades to "homeless only" — filing itself never depends
+      // on this read succeeding.
+    }
+  }
+
   // ---------------------------------------------------------------------------
   // boot
   // ---------------------------------------------------------------------------
@@ -433,6 +596,16 @@
     // A surface that does not depend on the failure must not be hostage to it.
     loadQueue();
 
+    // Quick filing (R08) is a THIRD independent surface on this page, offered
+    // only outside develop mode — developing a spark always produces a Full
+    // Idea, never a fresh quick report (see the section's own header comment).
+    if (DEVELOP_ID) {
+      const scroll = $('#fq-compose-scroll');
+      if (scroll) scroll.hidden = true;
+    } else {
+      bootQuickComposer();
+    }
+
     const r = await api.inbox.getInboxTemplate({});
     if (!r.ok || !r.data || !r.data.template) {
       $('#fi-sub').textContent = 'Could not load the idea template. Reload, or file from the terminal with capture.js.';

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

@@ -66,6 +66,24 @@
     return data;
   }
 
+  // task 1003063 (R10): mutating call for the move-to-goal affordance. Same
+  // posture as postJSON — resolves to the parsed 2xx body, throws an Error
+  // carrying { status, data } on a non-2xx so the caller can read the server's
+  // own refusal sentence (ADR 0016 enforces; this only surfaces it).
+  async function patchJSON(path, body) {
+    const res = await api.request('PATCH', path, { body: body || {} });
+    if (res.status === 401) { toAuth(); throw new Error('redirecting to auth'); }
+    let data = null;
+    try { data = res.data; } catch (_) { /* empty / non-JSON body */ }
+    if (!res.ok) {
+      const err = new Error(`${path} → ${res.status}`);
+      err.status = res.status;
+      err.data = data || {};
+      throw err;
+    }
+    return data;
+  }
+
   // Map the server's typed lifecycle-error to a builder-readable line. Codes are
   // exactly those POST /tasks/:id/ship + /confirm can return. The server is the
   // authority (ADR 0016); the UI only surfaces the refusal.
@@ -430,11 +448,17 @@
   }
 
   function renderTask(t, lastClaim, viewer, goal, extras) {
-    const { grade = null, sessionLogs = null, claims = null } = extras || {};
+    const { grade = null, sessionLogs = null, claims = null, goalsList = null } = extras || {};
     document.title = `#${t.id} — ${t.title || 'Task'} — ${document.title.split(' — ').pop()}`;
     const sub = $('#task-sub');
     if (sub) sub.textContent = `Task ${t.id}`;
 
+    // Metic+ is the floor for both the lifecycle supervisor controls below and
+    // the move-to-goal affordance (task 1003063 / R10) — hoisted so the two
+    // gates read the same rank once, rather than risking drift between copies.
+    const rank = (viewer && viewer.rank) ? String(viewer.rank).toLowerCase() : '';
+    const isSupervisor = rank === 'metic' || rank === 'archon';
+
     const parts = [];
     parts.push(`<p class="rec-kind">Task ${statusPill(t.status)}</p>`);
     parts.push(`<h1 class="rec-title" id="task-h"><span class="rec-title__id">${escapeHtml(String(t.id))}</span>${escapeHtml(t.title || 'Untitled task')}</h1>`);
@@ -473,6 +497,28 @@
       parts.push(`<p class="rec-goal">Goal <a href="/goals#/goal/${encodeURIComponent(t.goal_id)}">${escapeHtml(String(t.goal_id))}${goalName}</a>${catChip}</p>`);
     }
 
+    // task 1003063 (R10): the reassignment affordance — so a wrong routing pick
+    // is one PATCH away, never a re-file. Metic+ only (the server's own floor on
+    // PATCH /tasks/:id, ADR 0090); goalsList is fetched by load() scoped to this
+    // task's own version, because the server refuses a cross-version move
+    // (goal_version_mismatch, 409) and there is no point offering one.
+    if (isSupervisor && t.version_id) {
+      const openGoals = (Array.isArray(goalsList) ? goalsList : []).filter((g) => g.status !== 'archived');
+      const goalOpts = openGoals.length
+        ? openGoals.map((g) => `<option value="${escapeHtml(String(g.id))}"${String(g.id) === String(t.goal_id) ? ' selected' : ''}>${escapeHtml(String(g.id))} — ${escapeHtml(g.title || '')}</option>`).join('')
+        : '<option value="">No open goals in this version</option>';
+      parts.push(`
+        <div class="td-form" id="move-goal-form">
+          <label class="td-field td-field--wide"><span>Move to goal</span>
+            <select id="move-goal-select">${goalOpts}</select>
+          </label>
+          <div class="td-actions">
+            <button type="button" class="td-btn" id="move-goal-btn">Move</button>
+          </div>
+        </div>
+      `);
+    }
+
     const creditVal = window.OTBBranding?.taskCreditValue?.(t) ?? t.credits_reward;
     parts.push(figureBand([
       [window.OTBBranding?.taskCreditLabel?.(t) ?? curLabel(), creditVal],
@@ -550,8 +596,6 @@
     // toast. `confirmed → shipped` is the any-builder-supervisor / own-claim ship;
     // `completed → confirmed` is the Archon-only grader-bypass confirm (others see
     // a read-only note — the grader/Archon still has to act).
-    const rank = (viewer && viewer.rank) ? String(viewer.rank).toLowerCase() : '';
-    const isSupervisor = rank === 'metic' || rank === 'archon';
     const ownsLastClaim = !!(viewer && lastClaim && lastClaim.github_login &&
       lastClaim.github_login === viewer.github_login);
     let lifecycle = '';
@@ -610,6 +654,33 @@
         runLifecycle(confirmBtn, `${API}/tasks/${encodeURIComponent(t.id)}/confirm`, body, `#${t.id} confirmed.`);
       });
     }
+
+    // task 1003063 (R10): PATCH goal_id, then a full reload so the goal line, the
+    // picker's preselected option and everything else on the record re-render
+    // against the server's own state — no local patchwork of the DOM.
+    const moveGoalBtn = $('#move-goal-btn');
+    if (moveGoalBtn) {
+      moveGoalBtn.addEventListener('click', async () => {
+        const sel = $('#move-goal-select');
+        const goalId = sel ? Number(sel.value) : NaN;
+        if (!Number.isInteger(goalId) || goalId <= 0) { toast('Choose a goal first.'); return; }
+        const orig = moveGoalBtn.textContent;
+        moveGoalBtn.disabled = true;
+        moveGoalBtn.textContent = '…';
+        try {
+          await patchJSON(`${API}/tasks/${encodeURIComponent(t.id)}`, { goal_id: goalId });
+          toast(`#${t.id} moved to goal ${goalId}.`);
+          await load();
+        } catch (err) {
+          if (err && err.message === 'redirecting to auth') return;
+          // The server's own sentence, verbatim (a rank_forbidden 403 or a
+          // goal_version_mismatch 409 both say exactly what went wrong).
+          toast(errMessage(err && err.data) || `Could not move that task (${(err && err.status) || '?'}). Try again.`);
+          moveGoalBtn.disabled = false;
+          moveGoalBtn.textContent = orig;
+        }
+      });
+    }
   }
 
   // The two honest failures. Both keep the <h1> — the empty and error renders are
@@ -664,6 +735,18 @@
           goal = (g && g.goal) ? g.goal : null;
         } catch (_) { /* cosmetic — the goal link still resolves without it */ }
       }
+      // task 1003063 (R10): the move-to-goal picker's options, fetched only for
+      // the rank that can act on it and scoped to this task's own version (the
+      // server refuses a cross-version move). Best-effort: a failed read just
+      // means an empty picker, never a blocked page.
+      let goalsList = null;
+      const viewerRank = (viewer && viewer.rank) ? String(viewer.rank).toLowerCase() : '';
+      if ((viewerRank === 'metic' || viewerRank === 'archon') && d.task.version_id) {
+        try {
+          const gl = await getJSON(`${API}/goals?version=${encodeURIComponent(d.task.version_id)}`, { softAuth: true });
+          goalsList = Array.isArray(gl && gl.goals) ? gl.goals : [];
+        } catch (_) { /* cosmetic — the picker just has nothing to offer */ }
+      }
       // The repo bases a description's relative paths resolve onto (the primer's
       // and drachmae's pattern). Best-effort: without them a path passes through.
       try {
@@ -675,6 +758,7 @@
         grade: d.grade || null,
         sessionLogs: Array.isArray(d.session_logs) ? d.session_logs : null,
         claims: Array.isArray(d.claims) ? d.claims : null,
+        goalsList,
       });
     } catch (err) {
       if (err && err.code === AUTH_NEEDED) { toAuth(); return; }

package/modules/ideas/inbox.js

@@ -240,6 +240,13 @@ async function captureIdea({
   // (a hall filing surface, a Discord classifier) can, and when it does the
   // goal's scope wall is applied to it verbatim. See ./routing.js.
   touches = null,
+  // task 1003068 (BV1.R12): a HINT-ONLY goal guess — NEVER fed to decideLanding,
+  // only recorded as the advisory suggested_goal_id column. `goalId` is a
+  // caller's routing DECISION; this is a machine guess with no such authority
+  // (the Discord #ideas classifier has no human behind it to have decided
+  // anything). Ignored when `goalId` is already set, so every existing caller
+  // is untouched.
+  suggestedGoalId = null,
 }, deps = {}) {
   if (!title || typeof title !== 'string') {
     throw { code: 'TITLE_REQUIRED' };
@@ -277,7 +284,7 @@ async function captureIdea({
              $7)
      RETURNING ${IDEA_COLS}`,
     [title, bodyMd, resolvedKind, suggestedVersion, suggestedPriority, capturedBy,
-      goalId ?? null]
+      goalId ?? suggestedGoalId ?? null]
   );
   // A brand-new idea has no ideas_grades row, so it is quick by definition —
   // no join needed to know that. Grading it (R143's Full Idea capture) is a

package/package-lock.json

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

package/package.json

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