@bongos/core 1.19.497 → 1.19.499

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/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.497",
+  "version": "1.19.499",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/src/module-api.js

@@ -45,7 +45,7 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.497'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.499'; // 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/idea_spark_hall.mjs

@@ -48,7 +48,19 @@ const QUEUE = [
   { id: '78', title: 'A shared changelog', status: 'open', grade: 'spark', captured_at: '2026-07-30T00:00:00Z', filed_by_login: null },
 ];
 
-function boot({ search = '', sparks = QUEUE, count = null, idea = SPARK, ideaOk = true, store = {} } = {}) {
+// task 1003069 (R08, goal 1000071) — the quick filing form's fixtures: one
+// building version and two open goals, so the suggester + full-list halves of
+// the picker both have something real to render against.
+const VERSIONS = [{ id: 'BV1', status: 'building' }];
+const GOALS = [
+  { id: '77', title: 'Goal Seventy Seven', version_id: 'BV1' },
+  { id: '88', title: 'Another goal', version_id: 'BV1' },
+];
+
+function boot({
+  search = '', sparks = QUEUE, count = null, idea = SPARK, ideaOk = true, store = {},
+  versions = VERSIONS, goals = GOALS, suggestions = [],
+} = {}) {
   const els = new Map();
   const makeEl = () => ({
     dataset: {}, style: {}, textContent: '', value: '', hidden: false, disabled: false,
@@ -77,9 +89,36 @@ function boot({ search = '', sparks = QUEUE, count = null, idea = SPARK, ideaOk
       getInboxSparks: async () => { calls.push(['sparks', null]); return { status: 200, ok: true, data: { sparks, count: count == null ? sparks.length : count } }; },
       getInboxId: async (a) => { calls.push(['idea', a]); return { status: ideaOk ? 200 : 404, ok: ideaOk, data: ideaOk ? { idea } : null }; },
       postInboxScore: async (a) => { calls.push(['score', a]); return { status: 200, ok: true, data: { score: 60, fields: TEMPLATE.fields.map((f) => ({ key: f.key, substance: 24, floor: 40, ratio: 0.6 })) } }; },
-      postInbox: async (a) => { calls.push(['capture', a]); return { status: 201, ok: true, data: { idea: { id: '900', grade: 'full', completeness_score: 80 } } }; },
+      // task 1003069 (R08) — a quick capture that named a goal comes back
+      // ROUTED (the shape captureIdea/routeIdeaToGoal actually returns:
+      // idea.routing + a top-level routed_task); one with no goal_id is a
+      // quick capture that stayed homeless; anything else is the existing
+      // Full Idea fixture the earlier tests in this file already assert on.
+      postInbox: async (a) => {
+        calls.push(['capture', a]);
+        if (a.body && a.body.goal_id != null) {
+          return { status: 201, ok: true, data: {
+            idea: { id: '910', routing: { routed: true, goal_id: a.body.goal_id, status: 'ready' } },
+            routed_task: { id: '5555', goal_id: a.body.goal_id },
+          } };
+        }
+        if (a.body && a.body.kind && !('grade' in a.body)) {
+          return { status: 201, ok: true, data: { idea: { id: '911', routing: { routed: false, reason: 'no_goal' } } } };
+        }
+        return { status: 201, ok: true, data: { idea: { id: '900', grade: 'full', completeness_score: 80 } } };
+      },
       postInboxIdDevelop: async (a) => { calls.push(['develop', a]); return { status: 200, ok: true, data: { idea: { ...idea, grade: 'full', completeness_score: 80, ideator_credit: 5 } } }; },
     },
+    // task 1003069 (R08) — the quick-filing goal picker's reads: the building
+    // versions (to scope the suggester) and the open goal list (the picker's
+    // browse-all half). Overridable per test via boot({ versions, goals, suggestions }).
+    versions: {
+      getVersions: async () => { calls.push(['versions', null]); return { status: 200, ok: true, data: { versions } }; },
+    },
+    goals: {
+      getGoals: async () => { calls.push(['goals', null]); return { status: 200, ok: true, data: { goals } }; },
+      getGoalsSuggestions: async (a) => { calls.push(['suggest', a]); return { status: 200, ok: true, data: { suggestions } }; },
+    },
   };
 
   const toasts = [];
@@ -111,6 +150,7 @@ function boot({ search = '', sparks = QUEUE, count = null, idea = SPARK, ideaOk
     queueHtml: () => el('fi-queue').innerHTML,
     fill: () => { for (const f of TEMPLATE.fields) el(`fi-f-${f.key}`).value = `an answer for ${f.key} long enough to count`; },
     submit: () => el('fi-form')._handlers.submit({ preventDefault() {} }),
+    submitQuick: () => el('fq-form')._handlers.submit({ preventDefault() {} }),
   };
 }
 
@@ -196,6 +236,10 @@ await test('filing in develop mode calls the DEVELOP route with no title and no
   assert.ok(call[1].body.field_values, 'it carries the five answers');
   assert.ok(!('title' in call[1].body), 'and no title');
   assert.ok(!('grade' in call[1].body), 'and no grade');
+  // task 1003069 (R08) — routing is a QUICK-mode-only affordance; developing a
+  // spark always produces a Full Idea (routing.js NEVER_ROUTE_GRADE), so this
+  // path must never carry a goal_id even if one happened to be in view.
+  assert.ok(!('goal_id' in call[1].body), 'and no goal_id — develop mode never routes');
   assert.ok(!r.calls.some((c) => c[0] === 'capture'), 'and never files a second idea');
 });
 
@@ -259,5 +303,95 @@ await test('the plain composer is unaffected — develop mode is never entered',
   assert.equal(call[1].body.title, 'a new idea');
 });
 
+// --- quick filing: kind + goal picker (task 1003069 / R08, goal 1000071) ---
+//
+// A second, independent capture path on this same page: title + kind +
+// optional body + a goal picker fed by the R07 suggester. It exists beside the
+// Full Idea form rather than inside it — a routed capture must never carry
+// grade='full' (routing.js NEVER_ROUTE_GRADE) — so quick and full cannot share
+// one submit, and it is offered only outside develop mode (developing a spark
+// always produces a Full Idea from someone else's thought, never a fresh
+// lightweight report).
+
+await test('the quick-filing section is offered in plain mode and hidden while developing a spark', async () => {
+  const plain = boot();
+  await settle(); await settle();
+  assert.equal(plain.el('fq-compose-scroll').hidden, false);
+
+  const developing = boot({ search: '?develop=77' });
+  await settle(); await settle(); await settle();
+  assert.equal(developing.el('fq-compose-scroll').hidden, true);
+});
+
+await test('typing a title debounces a call to the goal suggester, scoped to the building version and the kind control', async () => {
+  const r = boot({ suggestions: [{ id: '77', title: 'Goal Seventy Seven', score: 4, matched_terms: ['goal'] }] });
+  await settle(); await settle();
+  r.el('fq-title').value = 'a goal seventy seven problem';
+  r.el('fq-title')._handlers.input();
+  await new Promise((res) => setTimeout(res, 400));
+  const call = r.calls.find((c) => c[0] === 'suggest');
+  assert.ok(call, 'the suggester was called');
+  assert.equal(call[1].query.version, 'BV1');
+  assert.equal(call[1].query.title, 'a goal seventy seven problem');
+  assert.equal(call[1].query.kind, 'bug', 'the kind control feeds the suggester too');
+  const html = r.el('fq-goal').innerHTML;
+  assert.match(html, /No goal \(homeless\)/);
+  assert.match(html, /Suggested/);
+  assert.match(html, /Goal Seventy Seven/);
+  assert.match(html, /Another goal/, 'the full open-goal list is still offered below the suggestion');
+});
+
+await test('an empty title refuses locally, without hitting the network', async () => {
+  const r = boot();
+  await settle(); await settle();
+  await r.submitQuick();
+  await settle();
+  assert.ok(!r.calls.some((c) => c[0] === 'capture'), 'no request was made');
+  assert.match(r.el('fq-err').textContent, /title is required/);
+});
+
+await test('submitting with no goal picked sends no goal_id — an unrouted response says it went to the inbox', async () => {
+  const r = boot();
+  await settle(); await settle();
+  r.el('fq-title').value = 'a quiet feature idea';
+  await r.submitQuick();
+  await settle();
+  const call = r.calls.find((c) => c[0] === 'capture');
+  assert.ok(call, 'POST /inbox was called');
+  assert.equal(call[1].body.kind, 'bug', 'bug is the default kind');
+  assert.ok(!('goal_id' in call[1].body), 'homeless sends no goal_id at all');
+  assert.ok(!('grade' in call[1].body), 'a quick capture carries no grade either');
+  assert.equal(r.el('fq-result').textContent, 'Filed to the inbox.');
+});
+
+await test('submitting with a goal picked sends goal_id as a NUMBER, and a routed response renders the task link', async () => {
+  const r = boot();
+  await settle(); await settle();
+  r.el('fq-title').value = 'the widget is broken';
+  r.el('fq-kind').value = 'bug';
+  r.el('fq-goal').value = '77';
+  r.el('fq-goal')._handlers.change();
+  await r.submitQuick();
+  await settle();
+  const call = r.calls.find((c) => c[0] === 'capture');
+  assert.ok(call);
+  assert.equal(call[1].body.goal_id, 77, 'sent as a number — the option carries a string value');
+  const html = r.el('fq-result').innerHTML;
+  assert.match(html, /task 5555/);
+  assert.match(html, /href="\/task\/5555"/);
+  assert.match(html, /Goal Seventy Seven/, 'names the goal the task landed in');
+});
+
+await test('the kind control travels with the filing', async () => {
+  const r = boot();
+  await settle(); await settle();
+  r.el('fq-title').value = 'clean up the queue module';
+  r.el('fq-kind').value = 'refactor';
+  await r.submitQuick();
+  await settle();
+  const call = r.calls.find((c) => c[0] === 'capture');
+  assert.equal(call[1].body.kind, 'refactor');
+});
+
 console.log(`\nidea_spark_hall: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);

package/tests/planning_session_skill.mjs

@@ -53,5 +53,43 @@ test('step 5 (run the seed script) points at the self-check rather than treating
   assert.ok(step5.slice(0, 400).includes('verifySeedCriteriaLinks'), 'step 5 references the self-check by name');
 });
 
+// --- task 1003075: the mechanics-map subagent becomes a named step ---------
+
+test('a named "Map the mechanism" step exists between Phase 1 and Phase 2, in order', () => {
+  const phase1 = SKILL.indexOf('### Phase 1 —');
+  const mapStep = SKILL.indexOf('### Phase 1.5 — Map the mechanism');
+  const phase2 = SKILL.indexOf('### Phase 2 —');
+  assert.ok(phase1 !== -1 && mapStep !== -1 && phase2 !== -1, 'all three headings must exist');
+  assert.ok(phase1 < mapStep && mapStep < phase2, 'Phase 1.5 must sit between Phase 1 and Phase 2');
+});
+
+test('the mechanics-map step names its input, its output artifact, and where the output is consumed', () => {
+  const start = NORM.indexOf('Phase 1.5 — Map the mechanism');
+  const end = NORM.indexOf('Phase 2 — Criteria', start);
+  const section = NORM.slice(start, end === -1 ? undefined : end);
+  assert.ok(section.length > 0, 'the Phase 1.5 section must be non-empty');
+  assert.ok(/\bInput\b/.test(section), 'names its input');
+  assert.ok(section.includes('mechanics map'), 'names its output artifact (the mechanics map)');
+  assert.ok(/\bConsumed by\b/.test(section), 'names where the output is consumed');
+  assert.ok(section.includes('Phase 2') && section.includes('Phase 3'), 'names the specific later steps that consume it');
+});
+
+test('the mechanics-map step names the subagent mechanism and the retro precedent that motivated it', () => {
+  const start = NORM.indexOf('Phase 1.5 — Map the mechanism');
+  const end = NORM.indexOf('Phase 2 — Criteria', start);
+  const section = NORM.slice(start, end === -1 ? undefined : end);
+  assert.ok(section.includes('subagent'), 'names a subagent as the mechanism');
+  assert.ok(section.includes('goal 1000071'), 'cites the idea-routing session as the precedent');
+  assert.ok(section.includes('task 1003075'));
+});
+
+test('the step is scoped to process-change sessions, not every planning session', () => {
+  const start = NORM.indexOf('Phase 1.5 — Map the mechanism');
+  const end = NORM.indexOf('Phase 2 — Criteria', start);
+  const section = NORM.slice(start, end === -1 ? undefined : end);
+  assert.ok(/process-change/i.test(section));
+  assert.ok(/skip/i.test(section), 'says explicitly when to skip it');
+});
+
 console.log(`\nplanning_session_skill: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);