@bongos/core 1.24.14 → 1.24.15

package/modules/public-landing/public/terms.html

@@ -129,9 +129,19 @@
     <p><b>These numbers describe; they do not govern.</b> Your cross-project record is descriptive analytics and never authority. What you may do inside any project is decided by that project alone, from its own records, at the moment you ask. A large record grants nothing and a hidden one takes nothing away; no project is required to read it, and none may treat it as permission. A rank shown here is that project&rsquo;s own standing for you, as that project reported it &mdash; the platform holds no rank of its own.</p>
     <p><b>What is public.</b> Once you have signed in with your platform account in your browser, here or to a project, and accepted these terms, your profile and that record are public by default: at your handle&rsquo;s page, in the people directory, to project owners looking for people to work with, and to search engines. An account that has never signed in that way stays provisional and is published nowhere.</p>
     <p><b>What you control.</b> From your settings you can hide your statistics, drop out of the recruiting directory, or make your account private. Each takes effect immediately, everywhere, including on a page someone already has open. Hiding removes the platform&rsquo;s combined view; it does not retract the per-project numbers each project publishes itself, so a determined reader could still add them up the hard way.</p>
-    <p><b>Your acceptance is recorded.</b> The platform stores the date you accepted these terms, and which version, on your account. It is written when you sign in with your platform account in your browser, here or to a project, and only once &mdash; signing in again does not change the date you accepted. Signing in from the command line does not record it: you approve that sign-in on GitHub&rsquo;s page, where these terms are not shown, so an account that has only signed in that way stays unpublished until you sign in once in your browser. This is version <b>2026-08-29</b>.</p>
+    <p><b>Your acceptance is recorded.</b> The platform stores the date you accepted these terms, and which version, on your account. It is written when you sign in with your platform account in your browser, here or to a project, and only once &mdash; signing in again does not change the date you accepted. When these terms change, your next sign-in that way records that you accepted the new version. Signing in from the command line does not record it: you approve that sign-in on GitHub&rsquo;s page, where these terms are not shown, so an account that has only signed in that way stays unpublished until you sign in once in your browser. This is version <b>2026-10-30</b>.</p>
     <p><b>Accounts from before these terms.</b> If your account already existed when this version took effect, the platform accepted it on your behalf, rather than waiting for you to sign in, and dated it the day that was done. The record marks that acceptance as grandfathered, so it is never mistaken for one you gave, and your own acceptance replaces it the next time you sign in that way.</p>
     <!--apex-only:end-->
+    <h2>AI features</h2>
+    <p>Some features, such as AI Studio, send what you submit to an AI model run by another company, reached through OpenRouter. To use them:</p>
+    <ul>
+      <li>You must be 18 or over. The AI companies only serve adults, so these features stay off until your account records that you are.</li>
+      <li>You agree to follow the terms and usage policies of the AI company whose model answers your request, and OpenRouter's own terms. Which company that is shows on <a href="https://openrouter.ai/models">openrouter.ai</a>.</li>
+      <li>You may not use what these features produce to train or build a competing AI model, or try to trick a model into breaking its own rules.</li>
+      <li>You are responsible for what you submit and for what you do with the results, including that you have the right to use any image or file you upload.</li>
+    </ul>
+    <p>When you pay with your balance, the price is what the AI company charged plus a small markup, shown before you confirm. When you use your own key, you pay that company directly and its terms apply to you as its customer. AI output can be wrong; check it before you rely on it.</p>
+
     <h2>Fair use</h2>
     <p>Don't use {{productName}} to break the law, to attack this site or other people's projects, to mine, spam or otherwise abuse hosted resources, or to harass other builders. The owner may deactivate a builder or take a project offline for breaking these, and may set further house rules inside the hall.</p>
 
@@ -140,7 +150,7 @@
 
     <h2>Changes</h2>
     <p>These terms ship with the software and change with it. The version served on this page is the one that applies; the repository keeps the history. <a href="{{sourceRepoUrl}}">Read the source.</a></p>
-    <p>Questions go through the <a href="/contact">contact page</a>. What is kept about you is on the <a href="/privacy">privacy page</a>. Revised August 2026.</p>
+    <p>Questions go through the <a href="/contact">contact page</a>. What is kept about you is on the <a href="/privacy">privacy page</a>. Revised October 2026.</p>
   </section>
 </main>
 

package/modules/ui-design/kit/fixtures/me-google.json

@@ -0,0 +1,10 @@
+{
+  "_": "A Google-only builder (task 1004996): the stand-in login ~<handle> a Google-born row carries until GitHub is linked. Aliased as me by the *-google states files, beside me-sign-in-methods-google.",
+  "builder": {
+    "id": "1",
+    "github_login": "~builder",
+    "display_name": "A Builder",
+    "avatar_url": "/__kit/avatar.svg",
+    "rank": "archon"
+  }
+}

package/modules/ui-design/kit/fixtures/me-sign-in-methods-google.json

@@ -0,0 +1,4 @@
+{
+  "_": "A Google-only person (task 1004996): no GitHub way in, so the bar draws the Link GitHub chip. Aliased as me__sign-in-methods by the *-google states files.",
+  "methods": [{ "provider": "google", "email": "octo@example.com" }]
+}

package/modules/ui-design/kit/serve.js

@@ -585,8 +585,14 @@ function myGuilds(res) {
 // The fixture builder is GitHub-born with Google linked, held for the run so a
 // Remove reads back. Each way in carries the route's own unlink_refused, by
 // account-logins.js unlinkRefusal's rule, and DELETE refuses as the route does.
+// A states file may alias `me__sign-in-methods` to a fixture's `methods` (task 1004996: the
+// Link GitHub chip pictures a Google-only person through `me-sign-in-methods-google`).
 let _ways = null;
-function waysHeld() { return _ways || (_ways = [{ provider: 'github', email: null }, { provider: 'google', email: 'octo@example.com' }]); }
+function waysHeld() {
+  if (_ways) return _ways;
+  if (ALIAS['me__sign-in-methods']) return (_ways = heldFixture('me__sign-in-methods').methods.map((m) => ({ provider: m.provider, email: m.email || null })));
+  return (_ways = [{ provider: 'github', email: null }, { provider: 'google', email: 'octo@example.com' }]);
+}
 function wayRefusal(provider, count) { return provider === 'github' ? 'born_with' : count <= 1 ? 'last_way_in' : null; }
 function signInMethods(res) {
   const held = waysHeld();

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.24.14",
+  "version": "1.24.15",
   "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/release-notes.json

@@ -10922,7 +10922,55 @@
       "text": "The weekly Market Watch run now also reads the links members added to a tracked item, treating them safely as outside text and staying within its page-reading limit."
     }
   ],
-  "1.24.14": [
+  "1.24.15": [
+    {
+      "id": "1005027",
+      "text": "The automatic checks that gate releases now agree with the new terms rule, so finished work can reach the live site again."
+    },
+    {
+      "id": "1005026",
+      "text": "Approving a correction to a Market Watch log entry works again, and the release lane that puts finished work on the live site is unblocked."
+    },
+    {
+      "id": "1005025",
+      "text": "AI Studio is now adults only and only uses AI providers that do not keep or train on your prompts; the terms and privacy pages explain the AI features, and everyone re-accepts the updated terms at their next sign-in."
+    },
+    {
+      "id": "1004958",
+      "text": "Every task now has a short two or three word name, and the AI writes \"task 1004745 - payout approvals\" instead of a bare number: in the startup notes, the sessions board, claim and ship messages, stuck-ship notes and blockers."
+    },
+    {
+      "id": "1003182",
+      "text": "The project now has an account record that shows every movement of money and why it happened: who was paid, for which task, and under which payment-processor transfer. Entries can never be edited or deleted, a retried payout c"
+    },
+    {
+      "id": "1005024",
+      "text": "The AI Studio works again with your own Google key even when Google retires a model, and you can now paste a picture or take a photo with your camera."
+    },
+    {
+      "id": "1004996",
+      "text": "People who signed in with Google and have not linked GitHub now see a tiny \"Link GitHub\" chip in the top bar, with the engineer icon so it reads as needed for coding. One click starts linking. It disappears once GitHub is link"
+    },
+    {
+      "id": "1005023",
+      "text": "The slop reminder no longer pops up on the app's own status messages, only when someone actually corrects the AI."
+    },
+    {
+      "id": "1005018",
+      "text": "People using a screen reader on Market Watch now hear the right name for the pop-up they opened (\"stop tracking\" or \"send a new scout\") instead of always \"Propose a change\"."
+    },
+    {
+      "id": "1005021",
+      "text": "Each builder's computer now updates its own project folder at the start of a session, saving any old leftovers first, and tells them plainly when it can't."
+    },
+    {
+      "id": "1004957",
+      "text": "Ask the AI \"what are my sessions doing\" (or type /session-board) and it shows a table of everything you have going at once: each session, its task, whether it is building, waiting to land, back from review or stuck, and what i"
+    },
+    {
+      "id": "1005016",
+      "text": "When the owner approves a member's correction to a Market Watch finding, the finding now actually changes (or is marked wrong), the item page shows a small \"corrected\" note, and who, when and why are kept."
+    },
     {
       "id": "1004906",
       "text": "The payment processor is chosen: Stripe Connect. Each project's money will sit in its own Stripe account, so we never hold anyone's money. J.P. Morgan Payments is recorded as the backup. Nothing is bought or opened yet, and th"

package/scripts/bongos/claim.js

@@ -12,6 +12,7 @@ const path = require('node:path');
 const { cliClient, requireSession, fmtTouches, printOnboardingNudge, rewardPolicy, costPlusOnlyNote, detectWorktreeName, cliExit } = require('./cli-lib');
 const { nextNumbers, padAdr, padMig } = require('./next-number');
 const { CORE_NS } = require('./migration-namespace');
+const { taskRef } = require('../../modules/lifecycle/task-name.js'); // task 1004958
 const { contextPack, formatContextPack, resolveWorktreeRoot } = require('./context-pack');
 const { printClaimRecall } = require('./claim-recall');
 const { decideWorktreeClaim, ESCAPE_FLAG } = require('./worktree-claim-guard');
@@ -238,6 +239,7 @@ function printClaimCard(task, widgetsEnabled = true) {
     const model = shipCard.buildCardModel({
       stage: 'claimed',
       taskId: task.id,
+      shortName: task.short_name,
       title: task.title,
       description: task.description || '',
       estMinutes: task.est_minutes != null ? Number(task.est_minutes) : null,
@@ -391,13 +393,13 @@ function claimFailureGuidance({ code, message, d }, r, taskId, ctx) {
     // so this one leaves it alone instead of piling onto the same /strand-fix.
     const leases = (ctx && ctx.strandLeases) || [];
     for (const t of owed) {
-      lines.push(`  - task ${t.id}${t.title ? `  ${clip(t.title)}` : ''}`);
+      lines.push(`  - ${taskRef(t.id, t.short_name)}${t.title ? `  ${clip(t.title)}` : ''}`);
       if (t.reason) lines.push(`      flagged: ${clip(t.reason)}`);
       const held = leases.find((l) => String(l.task_id) === String(t.id) && !l.mine);
       if (held) lines.push(`      already being fixed by ${held.by} — leave it to that session`);
     }
     if (waiting.length) lines.push('  Waiting, not on you (set aside; they land on their own):');
-    for (const t of waiting) lines.push(`  - task ${t.id}${t.title ? `  ${clip(t.title)}` : ''} — ${clip(t.waits_on || t.reason || 'outside you')}`);
+    for (const t of waiting) lines.push(`  - ${taskRef(t.id, t.short_name)}${t.title ? `  ${clip(t.title)}` : ''} — ${clip(t.waits_on || t.reason || 'outside you')}`);
     lines.push(`  ${clip(d.hint, 600) || 'Clear it with /strand-fix N, or rebase the branch and re-ship — or /builder-release it to give up on one.'}`);
     return { lines, exit: QUEUE_GATED_EXIT };
   }

package/scripts/bongos/land-watch.js

@@ -118,6 +118,7 @@ function buildShippedEnvelope(crumb, task) {
     ...inputs,
     postGradeStatus: 'shipped',
     taskId: crumb.taskId,
+    shortName: inputs.shortName || (task && task.short_name),
     // Prefer a fact from the fresh task row when the breadcrumb didn't carry it.
     title: inputs.title || (task && task.title) || `Task #${crumb.taskId}`,
     valueSummary: inputs.valueSummary || (task && task.value_summary) || '',

package/scripts/bongos/report-checkout.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// scripts/bongos/report-checkout.js — tell the server how far behind this computer's
+// project folder is (task 1005021).
+//
+// WHY. Session start heals a stale main folder when it safely can; when it cannot, nobody
+// would know — the owner's sat 1,000 changes behind for a week. This sends the facts to
+// PATCH /me/checkout-freshness, and GET /me then tells the person and their agent.
+// Spawned detached by .claude/hooks/session-start.js, so it never delays a session.
+// Silent and fail-open: no session, offline, an older server — nothing happens.
+//
+// Usage: node scripts/bongos/report-checkout.js <behind> <branch> <reason>
+
+'use strict';
+
+const { apiCall, readSessionToken, cliExit } = require('./cli-lib');
+
+async function main() {
+  const [behindRaw, branch, reason] = process.argv.slice(2);
+  const behind = Number.parseInt(behindRaw, 10);
+  if (!Number.isInteger(behind) || behind < 0 || !reason) return cliExit(0);
+  if (!readSessionToken()) return cliExit(0);
+  try {
+    await apiCall('PATCH', '/api/bongos/me/checkout-freshness',
+      { behind, branch: branch && branch !== 'HEAD' ? branch : '', reason },
+      { allowUnauthenticated: true });
+  } catch (_) { /* fail-open */ }
+  return cliExit(0);
+}
+
+if (require.main === module) main();

package/scripts/bongos/run-unit-tests.js

@@ -266,6 +266,13 @@ const INTEGRATION = new Set([
   // cannot be edited, deleted or truncated; unknown types and blank amounts are
   // refused; the reads' SQL resolves a task's own set over the project's.
   'pay_terms_db',
+  // task 1004991 (ADR 0385 pay-type gates): the gate table from the real migration —
+  // append-only, no eu_labour row, evidence required — and the verdict SQL.
+  'pay_type_gates_db',
+  // task 1004958: core_289's CHECK and the task-name backfill against real Postgres.
+  'task_name_db',
+  // task 1004958: the blocker read's lateral join that names held tasks, against real Postgres.
+  'blocker_tasks_named_db',
   // task 1004988 (ADR 0385 D2): credit_log from the real migration — Postgres
   // refuses a spend, redemption or transfer row; only a reversal of an existing
   // row may be negative, and core_194's clawback still books.
@@ -274,6 +281,10 @@ const INTEGRATION = new Set([
   // Postgres, the writer's ON CONFLICT turns it into a no-op, and a ledger already
   // holding a duplicate still migrates (a warning, no index, nothing deleted).
   'credit_log_idea_unique_db',
+  // task 1003182: the project-account record from the real migration — Postgres refuses a
+  // causeless or wrongly-directed movement, any UPDATE/DELETE/TRUNCATE, and a second row
+  // for one processor reference.
+  'project_account_db',
   // task 1004408: migration platform_identity_028 deletes the old hub invite's
   // pending rows before a cutoff it reads from the core_upgrades ledger. Only a real
   // engine runs the DO block, the numeric version compare and the one-shot guard.

package/scripts/bongos/sessions-board.js

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+'use strict';
+//
+// scripts/bongos/sessions-board.js — every session a builder has going, and where they
+// are jammed, as a board the AI shows in chat (task 1004957).
+//
+// WHY. A builder running several sessions at once could not see where things were stuck:
+// which session was building, which piece was waiting to land, which had come back from
+// review, which ship was stuck — and the one that matters most, that new work was paused
+// for EVERY session because too many ships were stuck (the REBASE_REQUIRED queue gate).
+// The owner wanted this as a board the AI shows in chat (/session-board), not a hall
+// page, plus a one-line version at session start when something is jammed, so a new
+// session knows not to pile on.
+//
+// WHERE IT READS. Nothing new on the server: GET /me already carries the builder's active
+// claims (one per session, with the worktree it lives in) and the stuck ships that gate
+// them (needs_rebase_tasks); the confirmed and completed task lists say what is waiting to
+// land and what came back from review. Whether the gate is shut is the server's own rule
+// (modules/lifecycle/rebase-gate.js), read here rather than re-derived. Who is fixing a
+// stuck ship is the local strand lease (strand-lease.js, task 1004956).
+//
+// Usage:
+//   node scripts/bongos/sessions-board.js          # the board, as markdown for chat
+//   node scripts/bongos/sessions-board.js --json   # the same, as data
+//   node scripts/bongos/sessions-board.js --line   # ONE line at session start, only when jammed
+//
+// The same line also rides strand-watch.js --line (the stuck-ship startup note) through
+// lineNow(), which is how it reaches a new session: the owner chose that over adding a
+// startup step of its own (2026-10-30).
+//
+// --line is FAIL-OPEN and SILENT when nothing is jammed, and carries ids and fixed words
+// only — never a task title, which is builder-authored text injected into every session
+// (the strand-watch.js trust boundary).
+
+const { apiCall, hasFlag } = require('./cli-lib');
+const { splitRebaseGate } = require('../../modules/lifecycle/rebase-gate.js');
+// task 1004958: every task is written "task N - <name>"; safeTaskName passes only the
+// generated name's fixed shape, so it is safe in the startup line too.
+const { safeTaskName, taskRef } = require('../../modules/lifecycle/task-name.js');
+
+const PAGE_LIMIT = 200;
+const safeId = (v) => (/^\d{1,19}$/.test(String(v)) ? String(v) : null);
+
+// A stuck ship's reason, in words a person reads.
+const REASON_WORDS = Object.freeze({
+  land_not_proven: 'it may have landed, but that could not be proven',
+  pr_not_landed: 'its change is waiting to merge',
+  unresolvable_conflict: 'its change overlaps newer work',
+  branch_modifies_executed_code: 'it changes code the merge helper will not run; a person lands it',
+  red_check: 'a check failed on its change',
+});
+function reasonWords(reason) {
+  const key = String(reason || '').replace(/^strand:/, '').split(':')[0];
+  if (/^waiting:/.test(String(reason || ''))) return `waiting on ${String(reason).slice(8)}`;
+  return REASON_WORDS[key] || 'stuck on its way in';
+}
+
+function ageWords(iso, now) {
+  const t = Date.parse(iso || '');
+  if (!Number.isFinite(t)) return '';
+  const h = (now - t) / 3600000;
+  if (h < 1) return `${Math.max(1, Math.round(h * 60))}m`;
+  if (h < 48) return `${Math.round(h)}h`;
+  return `${Math.round(h / 24)}d`;
+}
+
+const upper = (t) => t.charAt(0).toUpperCase() + t.slice(1);
+
+// boardOf(input) → { sessions, landing, back, stuck, gate, jams }. PURE.
+//   me         GET /me (active_claims, needs_rebase_tasks, builder.id)
+//   confirmed  confirmed tasks (any builder; filtered to this one by shipped_by)
+//   completed  completed tasks (same)
+//   leases     live strand leases [{ task_id, holder, label, taken_at }]
+//   here       this session's worktree { holder, label } or null
+function boardOf({ me, confirmed = [], completed = [], leases = [], here = null, now = Date.now(), truncated = false } = {}) {
+  const meId = me && me.builder && me.builder.id != null ? String(me.builder.id) : null;
+  const claims = (me && Array.isArray(me.active_claims)) ? me.active_claims : [];
+  const owed = (me && Array.isArray(me.needs_rebase_tasks)) ? me.needs_rebase_tasks : [];
+  const mine = (t) => t && meId && String(t.shipped_by || t.claimed_by || '') === meId;
+  const stuckIds = new Set(owed.map((t) => String(t.id)));
+  const leaseFor = (id) => leases.find((l) => String(l.task_id) === String(id)) || null;
+
+  const sessions = claims.map((c) => ({
+    task_id: String(c.task_id),
+    name: safeTaskName(c.short_name),
+    title: c.title || null,
+    session: c.worktree_name || null,
+    here: !!(here && c.worktree_name && c.worktree_name === here.label),
+    stage: 'building',
+    since: ageWords(c.claimed_at, now),
+    waiting_on: c.release_requested_at ? 'someone asked for this task back' : null,
+  }));
+  const landing = confirmed.filter((t) => mine(t) && !stuckIds.has(String(t.id))).map((t) => ({
+    task_id: String(t.id), name: safeTaskName(t.short_name), title: t.title || null, stage: 'waiting to land', since: ageWords(t.updated_at, now),
+  }));
+  const back = completed.filter(mine).map((t) => ({
+    task_id: String(t.id), name: safeTaskName(t.short_name), title: t.title || null, stage: 'back from review', since: ageWords(t.updated_at, now),
+    waiting_on: 'fix what review found and ask again (or an artist approves a held page)',
+  }));
+  const split = splitRebaseGate(owed);
+  const stuck = owed.map((t) => {
+    const lease = leaseFor(t.id);
+    const waits = split.waiting.find((w) => String(w.id) === String(t.id));
+    return {
+      task_id: String(t.id),
+      name: safeTaskName(t.short_name),
+      title: t.title || null,
+      stage: 'stuck',
+      since: ageWords(t.needs_rebase_at, now),
+      why: reasonWords(t.needs_rebase_reason),
+      set_aside: !!waits,
+      fixer: lease ? (here && lease.holder === here.holder ? 'this session' : `session ${String(lease.label || '').replace(/[^\w.-]/g, '') || 'another session'}`) : null,
+    };
+  });
+  const gate = { shut: split.gates, fixable: split.fixable.length };
+
+  const jams = [];
+  if (gate.shut) {
+    jams.push({
+      kind: 'paused',
+      text: `New work is paused for every one of your sessions: ${split.fixable.length} stuck ship${split.fixable.length === 1 ? '' : 's'} must come down first.`,
+      task_ids: split.fixable.map((t) => String(t.id)),
+    });
+  }
+  for (const s of stuck) {
+    if (s.set_aside) continue;
+    jams.push({
+      kind: 'stuck',
+      text: s.fixer ? `${upper(taskRef(s.task_id, s.name))} is stuck (${s.why}); ${s.fixer} is fixing it.` : `${upper(taskRef(s.task_id, s.name))} is stuck (${s.why}); nobody is fixing it yet.`,
+      task_ids: [s.task_id],
+      fixer: s.fixer,
+    });
+  }
+  // A full page of confirmed or completed tasks means older ones of this builder's may
+  // be past it: the board says so rather than passing a capped list off as complete.
+  return { sessions, landing, back, stuck, gate, jams, truncated: !!truncated };
+}
+
+// The board as markdown for chat: jams first, then one table.
+function markdown(b) {
+  const out = [];
+  out.push('**Jams**');
+  if (!b.jams.length) out.push('- Nothing is jammed.');
+  for (const j of b.jams) out.push(`- ${j.text}`);
+  out.push('');
+  const rows = [
+    ...b.sessions.map((s) => [s.session ? `${s.session}${s.here ? ' (this one)' : ''}` : '(no folder recorded)', s, s.waiting_on || '—']),
+    ...b.stuck.map((s) => ['—', s, s.set_aside ? `${s.why} (set aside; it does not pause new work)` : s.fixer ? `${s.why}; ${s.fixer} is fixing it` : `${s.why}; nobody is fixing it`]),
+    ...b.landing.map((s) => ['—', s, 'the merge; nothing for you to do']),
+    ...b.back.map((s) => ['—', s, s.waiting_on]),
+  ];
+  if (!rows.length) {
+    out.push('No sessions are building anything, and nothing of yours is in flight.');
+    return out.join('\n');
+  }
+  // A title is builder-authored: no link, emphasis, code or tag syntax reaches the chat,
+  // and a pipe cannot break the table.
+  const cell = (v) => String(v == null ? '' : v).replace(/[`*_[\]<>#~]/g, '').replace(/\|/g, '\\|').replace(/\s+/g, ' ').trim();
+  out.push('| Session | Task | Stage | Waiting on |');
+  out.push('|---|---|---|---|');
+  for (const [session, s, waits] of rows) {
+    const title = s.title ? ` — ${cell(s.title).slice(0, 70)}` : '';
+    out.push(`| ${cell(session)} | ${taskRef(s.task_id, s.name)}${title} | ${s.stage}${s.since ? ` (${s.since})` : ''} | ${cell(waits)} |`);
+  }
+  if (b.truncated) out.push('', 'More tasks were waiting to land or back from review than one read returns, so some older ones of yours may be missing from this board.');
+  return out.join('\n');
+}
+
+// ONE line for session start, or null. Only the pause is worth interrupting a new session
+// for — single stuck ships are strand-watch's line already. Ids, generated task names
+// (safeTaskName) and fixed words only.
+function line(b) {
+  if (!b || !b.gate.shut) return null;
+  const paused = b.jams.find((j) => j.kind === 'paused');
+  const ids = (paused ? paused.task_ids : []).map(safeId).filter(Boolean);
+  const nameOf = (id) => { const s = b.stuck.find((x) => x.task_id === id); return taskRef(id, s && s.name); };
+  const fixing = b.stuck.filter((s) => s.fixer && ids.includes(s.task_id)).map((s) => `${taskRef(s.task_id, s.name)} by ${s.fixer.replace(/[^\w .-]/g, '')}`);
+  const free = ids.filter((id) => !b.stuck.some((s) => s.task_id === id && s.fixer));
+  return `Sessions board: new work is paused for every session of this builder until ${ids.length} stuck ship${ids.length === 1 ? '' : 's'} (${ids.map(nameOf).join(', ')}) come down. `
+    + (fixing.length ? `Already being fixed: ${fixing.join('; ')}. ` : '')
+    + (free.length ? `Nobody is on ${free.map(nameOf).join(', ')} yet — take one with /strand-fix, or do unclaimed work. ` : 'Do not pile on: carry on with unclaimed work. ')
+    + 'This note is for you, not the builder; show them /session-board only if they ask where things are stuck.';
+}
+
+// Who is fixing which stuck ship on this machine (strand-lease.js), and which session
+// this is. No checkout: nobody is fixing anything that we can see.
+function localLeases() {
+  try {
+    const lease = require('./strand-lease.js');
+    return { here: lease.currentHolder(), leases: lease.liveLeases({ dir: lease.leaseDir() }) };
+  } catch { return { here: null, leases: [] }; }
+}
+
+async function read() {
+  const body = (r) => (r && (r.data || r)) || {};
+  const [me, confirmed, completed] = await Promise.all([
+    apiCall('GET', '/api/bongos/me').then(body),
+    apiCall('GET', `/api/bongos/tasks?status=confirmed&limit=${PAGE_LIMIT}`).then((r) => body(r).tasks || []).catch(() => []),
+    apiCall('GET', `/api/bongos/tasks?status=completed&limit=${PAGE_LIMIT}`).then((r) => body(r).tasks || []).catch(() => []),
+  ]);
+  const { leases, here } = localLeases();
+  const truncated = confirmed.length >= PAGE_LIMIT || completed.length >= PAGE_LIMIT;
+  return { me, confirmed, completed, leases, here, truncated };
+}
+
+// THE STARTUP READ, shared across session starts. The pause needs only the stuck ships
+// on /me, so the line asks for nothing else, and the answer is cached for every session
+// on the machine (probe-cache, the strand-watch line's own cache): four sessions opened
+// together make ONE call, not four times three. Stuck ships are measured in hours, so a
+// few minutes' age is as true as fresh. A failed read throws, so it is never cached.
+const OWED_CACHE_KEY = 'sessions-board-owed';
+const OWED_FRESH_MS = 5 * 60 * 1000;
+async function readOwed() {
+  const { cached } = require('./probe-cache.js');
+  const { value } = await cached(OWED_CACHE_KEY, async () => {
+    const r = await apiCall('GET', '/api/bongos/me');
+    const me = (r && (r.data || r)) || {};
+    if (!me.builder || !Array.isArray(me.needs_rebase_tasks)) throw new Error('unreadable');
+    return { builder: { id: me.builder.id }, needs_rebase_tasks: me.needs_rebase_tasks };
+  }, { ttlMs: OWED_FRESH_MS });
+  const { leases, here } = localLeases();
+  return { me: value, leases, here };
+}
+
+// The startup line, read and bounded: the line, or null on silence, a slow read or any
+// failure. Never throws.
+async function lineNow({ deadlineMs = 4000 } = {}) {
+  try {
+    const deadline = new Promise((_, rej) => setTimeout(() => rej(new Error('deadline')), deadlineMs).unref());
+    return line(boardOf(await Promise.race([readOwed(), deadline])));
+  } catch { return null; }
+}
+
+// The chat board as text. Fail OPEN: the board is read in chat, so a failed read is a
+// sentence there, never a stack trace or a non-zero exit.
+async function boardText({ json = false, readBoard = read } = {}) {
+  let input;
+  try {
+    input = await readBoard();
+  } catch (e) {
+    return json
+      ? JSON.stringify({ available: false, reason: String((e && e.message) || e) }, null, 2)
+      : '**Jams**\n- The board could not be read just now (the server did not answer). Nothing is known to be jammed or clear; try again in a minute.';
+  }
+  const b = boardOf(input);
+  return json ? JSON.stringify(b, null, 2) : markdown(b);
+}
+
+async function main() {
+  if (hasFlag('--line')) {
+    const one = await lineNow();
+    if (one) console.log(one);
+    process.exitCode = 0;
+    return;
+  }
+  console.log(await boardText({ json: hasFlag('--json') }));
+  process.exitCode = 0;
+}
+
+if (require.main === module) {
+  main().catch((e) => { console.error('sessions-board: failed —', e.message || e); process.exitCode = 1; });
+}
+
+module.exports = { boardOf, markdown, boardText, line, lineNow, readOwed, reasonWords, OWED_CACHE_KEY };

package/scripts/bongos/ship-finish.js

@@ -344,6 +344,7 @@ async function printCompletionCard({ taskId, postGradeStatus, card, usage, land
       stage, // task 1004379: 'held' from finishHeld; undefined ⇒ derived from postGradeStatus
       postGradeStatus,
       taskId,
+      shortName: card.shortName,
       title: card.title,
       valueSummary: card.valueSummary,
       notes: card.notes,

package/scripts/bongos/ship-flow.js

@@ -442,6 +442,7 @@ async function shipMain() {
         const model = shipCard.buildCardModel({
           stage: 'review',
           taskId,
+          shortName: ac.short_name,
           title: ac.title,
           valueSummary: summary,
           fileCount: committedFiles.length || null,
@@ -780,6 +781,7 @@ async function shipMain() {
     taskId, summary, advanceToMerge, skipMerge, postGradeStatus, doneLine: 'Done.', dbOnly, held,
     // task 1270: data for the deterministic completion card.
     card: {
+      shortName: ac.short_name,
       title: ac.title,
       valueSummary: summary,
       notes,
@@ -968,7 +970,7 @@ async function regradeMain(opts = {}) {
     await attachVisual();
     await finishShip({
       taskId, summary: summaryArg || task.value_summary || '', held: true, postGradeStatus: 'completed', doneLine: 'Done.',
-      card: { title: task.title, valueSummary: summaryArg || task.value_summary || '', notes: '' },
+      card: { shortName: task.short_name, title: task.title, valueSummary: summaryArg || task.value_summary || '', notes: '' },
     });
     return;
   }
@@ -1088,7 +1090,7 @@ async function regradeMain(opts = {}) {
         taskId, summary, advanceToMerge: confirmedStatus === 'confirmed', skipMerge, dbOnly: true,
         postGradeStatus: confirmedStatus,
         doneLine: 'Done — confirmed with no artifact (grader had nothing to read).',
-        card: { title: task.title, valueSummary: summary, notes: '' },
+        card: { shortName: task.short_name, title: task.title, valueSummary: summary, notes: '' },
       });
       return;
     }
@@ -1190,6 +1192,7 @@ async function regradeMain(opts = {}) {
     doneLine: g.passed ? 'Done — re-grade passed.' : 'Done — re-grade still failing; fix and try again.',
     // task 1270: completion card for the re-grade path too.
     card: {
+      shortName: task.short_name,
       title: task.title,
       valueSummary: summary,
       // Empty by design, not by omission (task 1003702). A re-grade takes no

package/scripts/bongos/strand-lease.js

@@ -35,6 +35,7 @@
 //   node scripts/bongos/strand-lease.js release <task-id>   # drop this worktree's lease
 //   node scripts/bongos/strand-lease.js show [<task-id>]    # who holds what
 
+const { taskRef } = require('../../modules/lifecycle/task-name.js'); // task 1004958
 const fs = require('node:fs');
 const path = require('node:path');
 
@@ -197,11 +198,12 @@ function describe(lease, now = Date.now()) {
 }
 
 // The clause the strand note appends: the strands OTHER sessions hold, so this one leaves
-// them alone. Null when nobody else holds one.
-function othersClause(leases, holder, now = Date.now()) {
+// them alone. Null when nobody else holds one. `names` maps a task id to its short name
+// (task 1004958) — a lease is local and carries none, so the caller hands in what it knows.
+function othersClause(leases, holder, now = Date.now(), names = {}) {
   const others = (leases || []).filter((l) => l.holder !== holder);
   if (!others.length) return null;
-  const list = others.map((l) => `task ${safeId(l.task_id)} by ${describe(l, now)}`).join('; ');
+  const list = others.map((l) => `${taskRef(safeId(l.task_id), names[String(l.task_id)])} by ${describe(l, now)}`).join('; ');
   return `Already being fixed: ${list}. Leave ${others.length === 1 ? 'that one' : 'those'} to that session and carry on with your own work.`;
 }