@bongos/core 1.18.3 → 1.18.19

package/scripts/gds/smoke-gds.js

@@ -3,17 +3,127 @@
 // Works on Windows (Git Bash / PowerShell / cmd), macOS, and Linux.
 //
 // Usage:
-//   node scripts/gds/smoke-gds.js                        # against production
+//   node scripts/gds/smoke-gds.js                        # against THIS instance
 //   GDS_API_BASE=http://localhost:3000 node scripts/gds/smoke-gds.js
 //
-// Exit 0 = all checks passed. Exit 1 = one or more failures.
+// Exit 0 = all checks passed (or the local-target skip). Exit 1 = one or more
+// failures, or no resolvable target (see resolveSmokeTarget).
 
 const https = require('https');
 const http = require('http');
 const net = require('net');
 const { URL } = require('url');
+const ic = require('../../src/instance-config');
+const { loadSessionSync } = require('./cli-lib');
 
-const BASE = process.env.GDS_API_BASE || process.env.PMS_API_BASE || 'https://amazonprimea.com';
+function safeBranding() {
+  try { return require('../../src/branding').branding(); } catch (_) { return {}; }
+}
+
+// readSessionApiBase — the signed-in session's persisted api_base (the instance
+// this CLI is actually pointed at), or null when not signed in / unreadable. The
+// session's OWN value only — deliberately NOT cli-lib's readSessionToken().apiBase,
+// which already folds in the env override + branding default; resolveSmokeTarget
+// orders that precedence itself so it stays pure over its injected inputs. Twin of
+// ship.js's readSessionApiBase.
+function readSessionApiBase() {
+  try {
+    const s = loadSessionSync();
+    return (s && typeof s.api_base === 'string' && s.api_base.trim()) ? s.api_base.trim() : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+const normalizeBase = (s) => (typeof s === 'string' && s.trim() ? s.trim().replace(/\/+$/, '') : null);
+
+// Which <PREFIX>_API_BASE supplied the override — the same prefix list, in the
+// same order, that ic.resolveEnv() itself walks. A lookup of the winning NAME,
+// not a second copy of the precedence.
+function matchedApiBaseVar(env) {
+  for (const p of [ic.envPrefix(), ...ic.LEGACY_ENV_PREFIXES]) {
+    const k = `${p}_API_BASE`;
+    if (env[k] !== undefined && env[k] !== '') return k;
+  }
+  return null;
+}
+
+// resolveSmokeTarget — WHICH instance these checks are run against. Precedence
+// mirrors ship.js's resolveInstanceBase(): <PREFIX>_API_BASE env (incl. legacy
+// GDS_/OTB_/PMS_) → the signed-in session's api_base → branding publicOrigin →
+// null.
+//
+// There is deliberately NO hardcoded host. This file baked in
+// `https://amazonprimea.com` as its fallback, so a builder signed into any OTHER
+// instance who shipped without an env override ran the ship's verification smoke
+// against the founder's box — which PASSED, because that box is healthy. The ship
+// then reported "smoke=clean" on the strength of testing a system it never
+// touched (task 1002418; the smoke sibling of resolveInstanceBase's task 1002232).
+//
+// FAILS CLOSED: a null base is an error, not a fallback. Verifying nothing and
+// saying so beats verifying the wrong instance and calling it a pass.
+//
+// Pure over its injected inputs (env / sessionApiBase / branding) so the
+// precedence is unit-tested without fs/env/network; the defaults read the real
+// session file + brand pack.
+function resolveSmokeTarget({
+  env = process.env,
+  sessionApiBase = readSessionApiBase(),
+  branding = safeBranding(),
+} = {}) {
+  const envBase = normalizeBase(ic.resolveEnv('API_BASE', { env }));
+  const session = normalizeBase(sessionApiBase);
+  const brandOrigin = normalizeBase(branding && branding.domains && branding.domains.publicOrigin);
+
+  const base = envBase || session || brandOrigin || null;
+  let source = null;
+  if (envBase) source = 'env';
+  else if (session) source = 'session';
+  else if (brandOrigin) source = 'branding';
+
+  const same = (a, b) => String(a).toLowerCase() === String(b).toLowerCase();
+  return {
+    base,
+    source,
+    envVar: envBase ? matchedApiBaseVar(env) : null,
+    sessionApiBase: session,
+    mismatch: Boolean(base && session && !same(base, session)),
+  };
+}
+
+const SOURCE_LABELS = {
+  session: 'signed-in session api_base',
+  branding: 'branding domains.publicOrigin',
+};
+
+// The env leg names the variable that actually matched, so "clear the override"
+// is actionable — a builder with a stale OTB_API_BASE shouldn't have to guess
+// which of four names to unset (and shouldn't be shown a literal "<PREFIX>").
+const sourceLabel = ({ source, envVar }) =>
+  (source === 'env' ? `${envVar || 'API_BASE'} env override` : SOURCE_LABELS[source] || source);
+
+// formatTargetReport — the lines main() prints BEFORE any check runs, so every run
+// states what it is about to verify. A target that disagrees with the signed-in
+// session gets a loud banner: silence about the mismatch is what made the old
+// hardcoded fallback dangerous. Returns lines so the warning is unit-testable.
+function formatTargetReport({ base, source, envVar, sessionApiBase, mismatch }) {
+  const label = sourceLabel({ source, envVar });
+  const lines = [`=== GDS smoke target: ${base}  (source: ${label}) ===`];
+  if (!mismatch) return lines;
+  const bar = '!'.repeat(72);
+  lines.push(
+    bar,
+    '!! WARNING: the smoke target is NOT the instance you are signed into.',
+    `!!   smoke target : ${base}  (${label})`,
+    `!!   your session : ${sessionApiBase}`,
+    '!! These checks verify the smoke target ONLY. A ship that reports',
+    '!! "smoke=clean" off this run is making a claim about the target above,',
+    `!! not about your own instance. Unset ${envVar || 'the API_BASE env override'} to verify`,
+    '!! the instance you are signed into.',
+    bar,
+  );
+  return lines;
+}
 
 // Laptop-ergonomics preflight (#958 / V4.R20). The smoke checks need a running
 // GDS server. When BASE points at a LOCAL listener that isn't up, every check
@@ -40,7 +150,10 @@ function probeListener(host, port, timeoutMs = 1500) {
   });
 }
 
-const CHECKS = [
+// Built per-run from the resolved base (was a module-level const off a hardcoded
+// BASE): resolution now happens inside main(), so requiring this module for its
+// helpers stays side-effect-free.
+const buildChecks = (BASE) => [
   // Public read-only surface
   ['GET /api/gds/healthz',              `${BASE}/api/gds/healthz`,             200],
   ['GET /api/gds/versions',             `${BASE}/api/gds/versions`,            200],
@@ -100,7 +213,26 @@ function checkUrl(label, url, expectStatus, method = 'GET') {
 }
 
 async function main() {
-  const parsed = new URL(BASE);
+  const target = resolveSmokeTarget();
+  if (!target.base) {
+    console.log('=== GDS smoke FAILED: no target ===');
+    console.log('Could not resolve which instance to verify: no <PREFIX>_API_BASE env var,');
+    console.log('no signed-in session (node scripts/gds/setup.js), and no readable branding');
+    console.log('domains.publicOrigin. Refusing to guess a host — a smoke run against the');
+    console.log('wrong instance passes and certifies nothing (task 1002418).');
+    process.exit(1);
+  }
+  const BASE = target.base;
+  for (const line of formatTargetReport(target)) console.log(line);
+
+  let parsed;
+  try {
+    parsed = new URL(BASE);
+  } catch (_) {
+    console.log(`=== GDS smoke FAILED: unusable target ===`);
+    console.log(`"${BASE}" is not an absolute URL — it needs a scheme (https://host).`);
+    process.exit(1);
+  }
   const host = parsed.hostname;
   const port = Number(parsed.port) || (parsed.protocol === 'https:' ? 443 : 80);
 
@@ -112,8 +244,7 @@ async function main() {
     process.exit(0);
   }
 
-  console.log(`=== GDS smoke against ${BASE} ===`);
-  const results = await Promise.all(CHECKS.map(([label, url, status, method]) => checkUrl(label, url, status, method)));
+  const results = await Promise.all(buildChecks(BASE).map(([label, url, status, method]) => checkUrl(label, url, status, method)));
   const passed = results.filter(Boolean).length;
   const failed = results.length - passed;
   console.log(`=== ${passed} passed, ${failed} failed ===`);
@@ -122,4 +253,4 @@ async function main() {
 
 if (require.main === module) main();
 
-module.exports = { isLocalTarget, probeListener };
+module.exports = { isLocalTarget, probeListener, resolveSmokeTarget, formatTargetReport, buildChecks };

package/scripts/gds/start.js

@@ -52,8 +52,9 @@
 //
 // Returns JSON if --json is passed (for the slash command to parse cleanly).
 
-const { cliClient, requireSession, fmtUsd, printOnboardingNudge, printCostWarning, printNeedsNudge } = require('./cli-lib');
+const { cliClient, requireSession, fmtUsd, printOnboardingNudge, printCostWarning, printNeedsNudge, hallBase, API_BASE, rewardPolicy, costPlusOnlyNote } = require('./cli-lib');
 const { contextPack, formatContextPackCompact } = require('./context-pack');
+const { depsFinding } = require('./preflight');
 
 // task 1284: the card shows only the top N claimable rows. The table is the bulk
 // of the widget HTML the model relays verbatim, so fewer rows = fewer tokens +
@@ -200,15 +201,22 @@ function whatItIs(t) {
 // The claimable table — # / Version / Type / Reward / Est. / What it is.
 // Ids are emitted as hall links (renders as a clean #N) — a bare "#NNN" in a
 // relayed chat message autolinks to GitHub and 404s (CLAUDE.md ref rule).
-const HALL_TASK = 'https://amazonprimea.com/builders#/task/';
-function claimableTable(rows) {
+const HALL_TASK = `${hallBase()}#/task/`;
+function claimableTable(rows, rewardFromServer) {
+  // On a cost-plus-only instance the Reward column is an advertised estimate that
+  // is never paid — say so in the header so the column can't read as a promise,
+  // and footnote what IS paid below the table (task 1002469).
+  const perTask = rewardPolicy(rewardFromServer).perTaskCredit;
+  const rewardHead = perTask ? 'Reward' : 'Reward (est.)';
   const out = [
-    '| # | Version | Type | Reward | Est. | What it is |',
+    `| # | Version | Type | ${rewardHead} | Est. | What it is |`,
     '|---|---|---|---|---|---|',
   ];
   for (const t of rows) {
     out.push(`| [#${t.id}](${HALL_TASK}${t.id}) | ${cell(t.version_id || '?')} | ${cell(disciplineLabel(t) || '—')} | ${t.credits_reward ?? 0}c | ${estimateShort(t)} | ${cell(whatItIs(t))} |`);
   }
+  const cpNote = costPlusOnlyNote(rewardFromServer);
+  if (cpNote) out.push('', `_${cpNote}_`);
   return out.join('\n');
 }
 
@@ -228,6 +236,49 @@ function miniBar(pct) {
   return `<span class="bs-bar"><span class="bs-barfill" style="width:${pct}%;"></span></span>`;
 }
 
+// ---------- owed-rebase warning (ADR 0120 part 5) ----------
+// The builder's un-landed confirmed tasks the publish-reconciler flagged
+// needs_rebase (part 2). They GATE new claims (part 3: claimTask refuses with
+// REBASE_REQUIRED) and their per-task reward now lands only on ship (part 1),
+// so this is the single most urgent thing to show at session start — rendered
+// prominently, before the claimable table, in both the markdown card and the
+// widget. /me carries them as `needs_rebase_tasks` (each { id, title, … }).
+// Refs use the `task N` form, NEVER a bare "#N" (a bare #N in relayed chat
+// autolinks to GitHub issues and 404s — the CLAUDE.md linkify rule).
+
+// Normalize the /me list into a small render model, or null when nothing is
+// owed. Shared by the markdown + widget renderers and unit-tested directly
+// (no live server needed).
+function rebaseWarningModel(needsRebaseTasks) {
+  const owed = Array.isArray(needsRebaseTasks)
+    ? needsRebaseTasks.filter((t) => t && t.id != null)
+    : [];
+  if (owed.length === 0) return null;
+  const n = owed.length;
+  return {
+    count: n,
+    refs: owed.map((t) => `task ${t.id}`).join(', '),
+    noun: n === 1 ? 'task' : 'tasks',
+    pronoun: n === 1 ? 'it' : 'them',
+  };
+}
+
+// The markdown warning line (prominent, before the claimable table), or null
+// when nothing is owed.
+function rebaseWarningMarkdown(needsRebaseTasks) {
+  const w = rebaseWarningModel(needsRebaseTasks);
+  if (!w) return null;
+  return `⚠️ **Rebase owed — your queue is GATED.** ${w.count} ${w.noun} can't land and block new claims until you rebase + re-ship (or \`/builder-release\`) ${w.pronoun}: ${w.refs}.`;
+}
+
+// The widget warning block (Tabler alert icon, danger-tinted), or '' when none.
+function rebaseWarningWidget(needsRebaseTasks) {
+  const w = rebaseWarningModel(needsRebaseTasks);
+  if (!w) return '';
+  return `<div class="bs-warn"><i class="ti ti-alert-triangle" aria-hidden="true"></i>`
+    + `<span><strong>Rebase owed — your queue is GATED.</strong> ${w.count} ${w.noun} can't land and block new claims until you rebase + re-ship (or /builder-release) ${w.pronoun}: ${hesc(w.refs)}.</span></div>`;
+}
+
 // Run console.log-based helpers (printCostWarning/printOnboardingNudge) without
 // polluting stdout (which must be pure HTML in --widget mode); return the lines.
 function captureLog(fn) {
@@ -272,6 +323,8 @@ const WIDGET_STYLE = `<style>
 .bs-dot{color:var(--color-text-tertiary);}
 .bs-bar{display:inline-block;width:34px;height:5px;border-radius:3px;background:var(--color-border-tertiary);overflow:hidden;vertical-align:middle;}
 .bs-barfill{display:block;height:100%;background:#1D9E75;}
+.bs-warn{display:flex;gap:8px;align-items:flex-start;font-size:13px;margin-top:8px;padding:8px 10px;border-radius:var(--border-radius-md);background:var(--color-background-danger);color:var(--color-text-danger);}
+.bs-warn i{font-size:15px;flex:none;margin-top:1px;}
 .bs-line{font-size:13px;color:var(--color-text-secondary);margin-top:8px;}
 .bs-line i{font-size:14px;vertical-align:-2px;margin-right:4px;}
 .bs-holditem{margin-top:4px;padding-left:18px;}
@@ -291,8 +344,11 @@ const WIDGET_STYLE = `<style>
 .bs-foot{font-size:13px;color:var(--color-text-tertiary);margin-top:12px;}
 </style>`;
 
-function renderWidget({ builder, claims, claimable, total, streak, recommendations, header, routingByPreference, preferred, filters, readyToClose }) {
+function renderWidget({ builder, claims, claimable, total, streak, recommendations, header, routingByPreference, preferred, filters, readyToClose, needsRebaseTasks }) {
   const b = builder || {};
+  // ADR 0120 part 5: the owed-rebase gate warning, rendered at the top of the
+  // card (before status/holdings) since it blocks new claims. '' when none owed.
+  const rebaseRow = rebaseWarningWidget(needsRebaseTasks);
   // Streak badge — warm amber, the one bold pop of colour + the motivational
   // stat. Shown only on an active (>0) streak; tooltip carries the record.
   // (Singular element — left inline; the savings live in the repeated grid.)
@@ -318,7 +374,7 @@ function renderWidget({ builder, claims, claimable, total, streak, recommendatio
 
   // holdings — each held task gets quick actions off it (ship / release /
   // open). Parallel sessions under one builder are normal, so this informs.
-  const hallUrl = (id) => `https://amazonprimea.com/builders#/task/${encodeURIComponent(id)}`;
+  const hallUrl = (id) => `${hallBase()}#/task/${encodeURIComponent(id)}`;
   const dot = '<span class="bs-dot"> · </span>';
   const act = (label, msg) => `<a href="#" onclick="event.preventDefault();sendPrompt('${jsq(msg)}')" class="bs-link">${label} ↗</a>`;
   const actionsFor = (c) => `${act('Ship', 'Ship task ' + c.task_id)}${dot}${act('Release', 'Release task ' + c.task_id)}${dot}<a href="${hesc(hallUrl(c.task_id))}" class="bs-link">Open ↗</a>`;
@@ -395,6 +451,7 @@ function renderWidget({ builder, claims, claimable, total, streak, recommendatio
     <span class="bs-brand"><span class="bs-title"><i class="ti ti-player-play" aria-hidden="true"></i>builder-start</span>${streakBadge}</span>
     <span class="bs-meta">${hesc(b.github_login)} · ${hesc(rank)} · ${hesc(credits)} credits · ${hesc(disc)}</span>
   </div>
+  ${rebaseRow}
   ${statusRow}
   ${holdings}
   ${closeBanner}
@@ -439,7 +496,49 @@ function rankCrossDisciplineRecommendations(claimable, preferredDisciplines, lim
   return outside.slice(0, Math.max(0, limit));
 }
 
-(async () => {
+// ---------- environment guard (task 1002403 / goal 1000052) ----------
+// /builder-start is often the FIRST command run in a freshly-cloned instance —
+// before the local server has ever been brought up. When the API can't be
+// reached, guide the builder to the one-command bring-up instead of dying with a
+// raw fetch stack trace (the old failure). The generated client REJECTS on a
+// network error even under throwOnError:false (see clients/bongos-client), so the
+// Promise.all in main() throws into the guard below. Wrong-instance (exit 3) and
+// no-session (exit 2) are handled upstream in cliClient()/apiCall, and the
+// builder-start skill routes those + the pre-install "bongos not found" case.
+function isConnectionError(err) {
+  if (!err) return false;
+  const codes = ['ECONNREFUSED', 'ENOTFOUND', 'ECONNRESET', 'EAI_AGAIN', 'ETIMEDOUT', 'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_SOCKET'];
+  const code = err.code || (err.cause && err.cause.code) || '';
+  if (codes.includes(code)) return true;
+  const msg = `${err.message || ''} ${(err.cause && err.cause.message) || ''}`;
+  return /fetch failed|ECONNREFUSED|ENOTFOUND|EAI_AGAIN|network|socket hang up/i.test(msg);
+}
+
+// The guided "instance isn't running" card. Markdown (never leads with `<`), so
+// the builder-start skill relays it verbatim even in --widget mode. Tailors the
+// first step to whether deps are installed — a fresh clone needs `npm install`
+// before the `bongos` CLI (which ships inside @bongos/core) even exists.
+function instanceNotRunningCard({ origin, depsMissing } = {}) {
+  const out = [];
+  out.push(`**builder-start — this instance isn't reachable yet**`);
+  out.push('');
+  out.push(`I couldn't reach the Cloud Bongos instance${origin ? ` at \`${origin}\`` : ''}. On a freshly-cloned project that almost always just means it hasn't been brought up yet. To start it locally:`);
+  out.push('');
+  let n = 1;
+  if (depsMissing) {
+    out.push(`${n++}. \`npm install\` — installs the toolchain first (the \`bongos\` CLI ships inside \`@bongos/core\`, so nothing else runs until this does).`);
+  }
+  out.push(`${n++}. \`bongos dev\` — one command: starts Postgres, builds the tables, runs the server, and signs you in.`);
+  out.push(`${n++}. Re-run \`/builder-start\`.`);
+  out.push('');
+  out.push(`Meant to work on a *different* instance that's already running? Sign in to it with \`bongos login <url>\` first.`);
+  return out.join('\n');
+}
+function emitInstanceNotRunningCard(opts) {
+  console.log(instanceNotRunningCard(opts));
+}
+
+async function main() {
   await requireSession();
   const args = process.argv.slice(2);
   const json = args.includes('--json');
@@ -479,16 +578,32 @@ function rankCrossDisciplineRecommendations(claimable, preferredDisciplines, lim
   // endpoint fails, that widget degrades to "N/A" rather than killing
   // /builder-start.
   const api = await cliClient();
-  const [me, r, closeRes, progressRes, costRes, recentRes, inboxRes, blockersRes] = await Promise.all([
-    api.me.getMe(),
-    api.tasks.getTasksClaimable({ query: claimableQuery }),
-    api.versions.getVersionsCloseSuggestions(),
-    api.public.getPublicProgress(),
-    api.public.getPublicCostSummary(),
-    api.public.getPublicRecentShipped(),
-    api.inbox.getInbox({ query: { status: 'open' } }),
-    api.blockers.getBlockers(),
-  ]);
+  let me, r, closeRes, progressRes, costRes, recentRes, inboxRes, blockersRes;
+  try {
+    [me, r, closeRes, progressRes, costRes, recentRes, inboxRes, blockersRes] = await Promise.all([
+      api.me.getMe(),
+      api.tasks.getTasksClaimable({ query: claimableQuery }),
+      api.versions.getVersionsCloseSuggestions(),
+      api.public.getPublicProgress(),
+      api.public.getPublicCostSummary(),
+      api.public.getPublicRecentShipped(),
+      api.inbox.getInbox({ query: { status: 'open' } }),
+      api.blockers.getBlockers(),
+    ]);
+  } catch (err) {
+    // A fresh-clone instance that was never brought up refuses the connection.
+    // Human modes get a guided bring-up card + clean exit; machine modes (--json,
+    // --hook) keep the throw so the autonomous runner still sees the failure.
+    if (isConnectionError(err) && !json && !hookMode) {
+      let depsMissing = false;
+      try { depsMissing = depsFinding({ repoRoot: process.cwd() }).level !== 'ok'; } catch (_) { /* best-effort */ }
+      let origin = '';
+      try { origin = new URL(API_BASE).origin; } catch (_) { origin = API_BASE || ''; }
+      emitInstanceNotRunningCard({ origin, depsMissing });
+      process.exit(0);
+    }
+    throw err;
+  }
   // #766: the primer-read gate on the claimable endpoint was removed, so a
   // newcomer no longer gets a 403 stage_required here. A generic stage_required
   // (any future onboarding gate) still renders cleanly rather than crashing.
@@ -548,6 +663,13 @@ function rankCrossDisciplineRecommendations(claimable, preferredDisciplines, lim
     ? blockersRes.data.blockers.filter((b) => b.status === 'open' || !b.status).length
     : null;
 
+  // ADR 0120 part 5: the confirmed tasks this builder owes a rebase on (they
+  // GATE new claims; the reward lands only on ship). Shared by every card form;
+  // already present verbatim in --json via me.data.needs_rebase_tasks below.
+  const needsRebaseTasks = me.ok && Array.isArray(me.data?.needs_rebase_tasks)
+    ? me.data.needs_rebase_tasks
+    : [];
+
   if (json) {
     console.log(JSON.stringify(
       {
@@ -602,6 +724,7 @@ function rankCrossDisciplineRecommendations(claimable, preferredDisciplines, lim
       preferred,
       filters: { version, discipline, fit },
       readyToClose,
+      needsRebaseTasks,
     }) + '\n');
     return;
   }
@@ -638,6 +761,15 @@ function rankCrossDisciplineRecommendations(claimable, preferredDisciplines, lim
     }
   }
 
+  // ADR 0120 part 5: the owed-rebase gate warning — rendered directly under the
+  // identity line and before the claimable table, since it BLOCKS new claims
+  // until the builder lands (rebase + re-ship) or releases the flagged tasks.
+  const rebaseLine = rebaseWarningMarkdown(needsRebaseTasks);
+  if (rebaseLine) {
+    console.log('');
+    console.log(rebaseLine);
+  }
+
   // ambient status: one quiet line by default; the full widgets + context pack
   // under --full.
   if (full) {
@@ -708,7 +840,7 @@ function rankCrossDisciplineRecommendations(claimable, preferredDisciplines, lim
   console.log('');
   if (claimable.length) {
     const cardRows = claimable.slice(0, CARD_ROWS);
-    console.log(claimableTable(cardRows));
+    console.log(claimableTable(cardRows, me.ok ? me.data?.reward : null));
     const moreN = filtered.length - cardRows.length;
     if (moreN > 0) {
       console.log('');
@@ -761,6 +893,7 @@ function rankCrossDisciplineRecommendations(claimable, preferredDisciplines, lim
         preferred,
         filters: { version, discipline, fit },
         readyToClose,
+        needsRebaseTasks,
       })
       : null;
     const markdown = captureLog(emitMarkdownCard).join('\n');
@@ -776,7 +909,23 @@ function rankCrossDisciplineRecommendations(claimable, preferredDisciplines, lim
   // body to stdout.
   emitCardDirective('markdown');
   emitMarkdownCard();
-})().catch((err) => {
-  console.error('fatal:', err);
-  process.exit(1);
-});
+}
+
+// Only auto-run when invoked directly (`node start.js …`); a `require()` (the
+// unit test) imports the pure render helpers without executing the fetch flow —
+// the claim.js precedent. The owed-rebase warning helpers (ADR 0120 part 5) are
+// exported so they can be unit-tested without a live server.
+if (require.main === module) {
+  main().catch((err) => {
+    console.error('fatal:', err);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  rebaseWarningModel,
+  rebaseWarningMarkdown,
+  rebaseWarningWidget,
+  isConnectionError,
+  instanceNotRunningCard,
+};

package/scripts/gds/status.js

@@ -59,7 +59,7 @@ async function fetchProgress(version) {
   let res;
   try {
     res = await fetch(`${API_BASE}/api/gds/versions/${encodeURIComponent(version)}/progress`, {
-      headers: { 'User-Agent': 'amazonprimea-status-cli/1.0' },
+      headers: { 'User-Agent': require('../../src/branding').userAgent() },
     });
   } catch (err) {
     console.error(`status: could not reach ${API_BASE} (${err.message})`);

package/scripts/gds/triage.js

@@ -22,13 +22,10 @@
 // Prompts per idea:
 //   [p]romote        → create a backlog task, mark idea 'promoted',
 //                      reviewed_at=now, promoted_to_task_id=<new>
-//   [m]erge with #N  → mark idea 'merged' with promoted_to_task_id=N
-//                      (N is the canonical idea or task to keep). Note:
-//                      the current PATCH /tasks/:id only supports
-//                      parent_task_id, so we can't append the body to the
-//                      target task's description via API — we just link
-//                      via promoted_to_task_id. The body remains in the
-//                      merged idea row for history.
+//   [m]erge with #N  → mark idea 'merged' with merged_into_idea_id=N
+//                      (N is the canonical IDEA to keep). The body remains
+//                      on the merged idea row for history — there is no
+//                      description-append vector, so nothing is copied to N.
 //   [d]iscard        → mark idea 'discarded', reviewed_at=now
 //   [s]kip           → no patch; idea surfaces again next triage
 //   [q]uit           → exit early, print partial summary
@@ -269,7 +266,7 @@ async function main() {
           const inline = ans.replace(/^m(\s|#)*/, '').trim();
           if (inline) target = Number(inline.replace(/^#/, ''));
           if (!Number.isFinite(target) || target <= 0) {
-            const a = (await prompt(rl, '  merge into id (task or idea #): ')).trim().replace(/^#/, '');
+            const a = (await prompt(rl, '  merge into idea #: ')).trim().replace(/^#/, '');
             target = Number(a);
           }
           if (!Number.isFinite(target) || target <= 0) {
@@ -278,9 +275,13 @@ async function main() {
             continue;
           }
           try {
+            // task 1002447 / migration core_195: the merge target belongs in
+            // merged_into_idea_id. This used to write promoted_to_task_id — a
+            // column that is REFERENCES tasks(id), so an idea id there either
+            // tripped the FK or silently named an unrelated task.
             await patchIdea(idea.id, {
               status: 'merged',
-              promoted_to_task_id: target,
+              merged_into_idea_id: target,
               reviewed_at: new Date().toISOString(),
             });
             summary.merged++;