@bongos/core 1.24.14 → 1.24.16

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.`;
 }
 

package/scripts/bongos/strand-watch.js

@@ -40,6 +40,7 @@
 
 const { apiCall, arg, hasFlag } = require('./cli-lib');
 const tweakHold = require('../../modules/lifecycle/page-tweak-hold.js');
+const { safeTaskName, taskRef } = require('../../modules/lifecycle/task-name.js');
 
 // ---- thresholds -------------------------------------------------------------
 // Reasoned, not magic. Written down because a future reader will want to retune them.
@@ -88,7 +89,17 @@ function humanAge(ms) {
 //   confirmed -> the grade passed and the LAND is outstanding (/merge-mode is the fallback).
 // A reconciler-recorded strand is called out separately because it is terminal without a
 // human: the automated healers have already refused it.
-function classifyStrand(task, { nowMs, confirmedStaleMs = CONFIRMED_STALE_MS, completedStaleMs = COMPLETED_STALE_MS } = {}) {
+// task 1004958: a strand carries the task's short name when it has one, so the line
+// reads "task N - payout approvals". `safeTaskName` re-checks the stored name against
+// its fixed shape (three lowercase words at most) — see the trust note on `line()`.
+function classifyStrand(task, opts) {
+  const s = classifyShape(task, opts);
+  const name = s && safeTaskName(task && task.short_name);
+  if (name) s.name = name;
+  return s;
+}
+
+function classifyShape(task, { nowMs, confirmedStaleMs = CONFIRMED_STALE_MS, completedStaleMs = COMPLETED_STALE_MS } = {}) {
   const t = task || {};
   const status = String(t.status || '');
   if (!WATCHED.includes(status)) return null;
@@ -193,7 +204,8 @@ async function check({ nowMs = Date.now(), timeoutMs = DEFAULT_TIMEOUT_MS, confi
       if (status === 'completed' && held.has(String(t.id))) {
         const updated = Date.parse(t.updated_at || '');
         const ageMs = Number.isFinite(updated) ? nowMs - updated : NaN;
-        waiting.push({ id: safeId(t.id), status, ageMs, age: humanAge(ageMs), shape: tweakHold.HOLD_STATE });
+        const name = safeTaskName(t.short_name);
+        waiting.push({ id: safeId(t.id), status, ageMs, age: humanAge(ageMs), shape: tweakHold.HOLD_STATE, ...(name ? { name } : {}) });
         continue;
       }
       const s = classifyStrand(t, { nowMs, confirmedStaleMs, completedStaleMs });
@@ -214,6 +226,10 @@ async function check({ nowMs = Date.now(), timeoutMs = DEFAULT_TIMEOUT_MS, confi
 // is the same reasoning deploy-divergence.js applies to the /version response it reads (it
 // accepts only a strict semver for exactly this purpose). Ids and a fixed reason vocabulary
 // carry all the signal that is needed and none of the risk — the agent can GET the task.
+// The one exception is the task's SHORT NAME (task 1004958), because a bare number means
+// nothing to the person the agent talks to. It is not free text: it is generated, and
+// `safeTaskName` passes only three lowercase words of [a-z0-9-] (40 characters, the
+// table CHECK holds the same shape), so it can name a topic and carry nothing else.
 function line(r, { max = 3 } = {}) {
   if (!r || r.undetermined) return null;
   const trunc = Array.isArray(r.truncated) && r.truncated.length
@@ -225,7 +241,7 @@ function line(r, { max = 3 } = {}) {
     return trunc ? `Strand check could not see the whole board${trunc}. Run: node scripts/bongos/strand-watch.js` : null;
   }
   const shown = r.strands.slice(0, max)
-    .map((s) => `task ${s.id} (${s.status}, ${s.age}${s.reason ? `, ${s.reason}` : ''})`);
+    .map((s) => `${taskRef(s.id, s.name)} (${s.status}, ${s.age}${s.reason ? `, ${s.reason}` : ''})`);
   const more = (r.strands.length > shown.length ? ` +${r.strands.length - shown.length} more` : '') + trunc;
   const worst = r.strands[0];
   // Lead with what the WORST shape actually means. "work is finished but not landed" is true
@@ -255,12 +271,20 @@ const RELAY_RULE = 'This note is for you, not the builder: do not repeat it to t
 // The lease clause, appended at PRINT time, never cached: the line text is shared across
 // sessions for up to two hours (linePlan), while who holds a strand changes by the minute and
 // differs per worktree. Fail-open: no lease folder, no clause.
+// The task names the cached line already carries ("task N - name ("), so the lease clause
+// can name the same tasks without a second read. Only the safe name shape is matched.
+function namesIn(text) {
+  const names = {};
+  for (const m of String(text || '').matchAll(/task (\d{1,19}) - ([a-z0-9]+(?:-[a-z0-9]+)*(?: [a-z0-9]+(?:-[a-z0-9]+)*){0,2}) \(/g)) names[m[1]] = m[2];
+  return names;
+}
+
 function withLeases(text, { now = Date.now() } = {}) {
   if (!text) return text;
   try {
     const lease = require('./strand-lease.js');
     const me = lease.currentHolder();
-    const clause = lease.othersClause(lease.liveLeases({ dir: lease.leaseDir(), now }), me && me.holder, now);
+    const clause = lease.othersClause(lease.liveLeases({ dir: lease.leaseDir(), now }), me && me.holder, now, namesIn(text));
     return clause ? `${text} ${clause}` : text;
   } catch { return text; }
 }
@@ -278,7 +302,7 @@ function report(r) {
   // task 1004322: named, and kept apart from the strands — nobody should recover these.
   const waiting = Array.isArray(r.waiting) ? r.waiting : [];
   for (const w of waiting) {
-    console.log(`  task ${w.id}  waiting for the artist (${w.age}) — a page tweak whose grade passed; not a strand, leave it`);
+    console.log(`  ${taskRef(w.id, w.name)}  waiting for the artist (${w.age}) — a page tweak whose grade passed; not a strand, leave it`);
   }
   if (r.ok) {
     console.log('  ✓ none — nothing parked at completed or confirmed past its threshold.');
@@ -286,7 +310,7 @@ function report(r) {
     return;
   }
   for (const s of r.strands) {
-    console.log(`  task ${s.id}  ${s.status.padEnd(9)} ${String(s.age).padStart(4)}  ${s.shape}${s.reason ? ` (${s.reason})` : ''}`);
+    console.log(`  ${taskRef(s.id, s.name)}  ${s.status.padEnd(9)} ${String(s.age).padStart(4)}  ${s.shape}${s.reason ? ` (${s.reason})` : ''}`);
     console.log(`      ${s.remedy}`);
   }
   console.log('');
@@ -400,6 +424,13 @@ async function main() {
         if (shown) console.log(withLeases(shown));
       }
     } catch { /* no session, offline, unreadable, past the deadline — all silence */ }
+    // task 1004957: when stuck ships have paused new work for EVERY session of this
+    // builder, say so here too — the owner chose this note over a new startup step.
+    // Its own bounded read; silent unless paused; never fails the session start.
+    try {
+      const paused = await require('./sessions-board.js').lineNow();
+      if (paused) console.log(paused);
+    } catch { /* silence */ }
     process.exitCode = 0;
     return;
   }
@@ -426,7 +457,7 @@ if (require.main === module) {
 }
 
 module.exports = {
-  check, line, withLeases, report, classifyStrand, rankStrands, humanAge,
+  check, line, withLeases, namesIn, report, classifyStrand, rankStrands, humanAge,
   linePlan, labelStale, produceLine, LINE_FRESH_MS, LINE_STALE_MAX_MS, LINE_DEADLINE_MS,
   CONFIRMED_STALE_MS, COMPLETED_STALE_MS, STRAND_REASON_PREFIX, WATCHED, PAGE_LIMIT,
 };

package/scripts/gds/report-checkout.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// scripts/gds/report-checkout.js — @bongos-forwarder (task 1004848). Generated by
+// scripts/bongos/codemod-rename-scripts-gds.js; do not edit.
+// The real script is scripts/bongos/report-checkout.js. This forwarder keeps callers that still name
+// the old path working, and warns once so they get repointed. Task 1003706 removes it.
+'use strict';
+require('../bongos/forwarder.js').forward(module, 'report-checkout.js');

package/scripts/gds/sessions-board.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// scripts/gds/sessions-board.js — @bongos-forwarder (task 1004848). Generated by
+// scripts/bongos/codemod-rename-scripts-gds.js; do not edit.
+// The real script is scripts/bongos/sessions-board.js. This forwarder keeps callers that still name
+// the old path working, and warns once so they get repointed. Task 1003706 removes it.
+'use strict';
+require('../bongos/forwarder.js').forward(module, 'sessions-board.js');

package/src/bongos/agent-standing-rules.js

@@ -25,20 +25,30 @@ const SLOP_TEXT = 'The moment you find you were wrong because something told you
   + 'and file it: `node scripts/bongos/capture.js "<file>: says X, truth is Y" --kind bug`. The misleading source is the bug. '
   + 'Your own plain mistake, with nothing misleading behind it, is not slop.';
 
+// task 1004958: a bare task number means nothing to the person reading.
+const TASK_NAME_TEXT = 'When you mention a task to a person, write it as "task N - <name>": the number, a dash, then the task\'s '
+  + 'two or three word name (its `short_name`; claim, ship, the startup notes and the sessions board print it). '
+  + 'A bare "task 1004745" means nothing to the reader.';
+
 const HEADER = 'Standing rules for every session:';
 
 function standingRulesBlock() {
-  return `${HEADER}\n- ${HUMAN_SIGNAL_TEXT}\n- ${SLOP_TEXT}`;
+  return `${HEADER}\n- ${HUMAN_SIGNAL_TEXT}\n- ${SLOP_TEXT}\n- ${TASK_NAME_TEXT}`;
 }
 
 // The interaction slice of GET /me with the standing rules appended. `interaction` is
 // describeInteraction's object or null (builder-settings module off); either way the
 // result injects, because these rules do not depend on any preference. Idempotent.
-function withStandingRules(interaction) {
+// `opts.checkout` (task 1005021) is GET /me's checkout_freshness: when this person's
+// folder is behind and could not update itself, its agent_line rides here too, so even
+// a stale Conductor tells them.
+function withStandingRules(interaction, opts = {}) {
   const base = interaction && typeof interaction === 'object' ? interaction : {};
   const contract = typeof base.contract === 'string' ? base.contract : '';
   if (contract.includes(HEADER)) return { ...base, inject: true };
-  return { ...base, contract: contract ? `${contract}\n${standingRulesBlock()}` : standingRulesBlock(), inject: true };
+  const c = opts && opts.checkout;
+  const block = standingRulesBlock() + (c && c.behind && typeof c.agent_line === 'string' ? `\n- ${c.agent_line}` : '');
+  return { ...base, contract: contract ? `${contract}\n${block}` : block, inject: true };
 }
 
 module.exports = { withStandingRules };

package/src/bongos/routes/me.js

@@ -395,6 +395,9 @@ module.exports = function buildMeRouter() {
     const lawed = settings && typeof settings.describeWithLaws === 'function'
       ? settings.describeWithLaws(behaviorPrefs, (sessionLaws && sessionLaws.laws) || [], { rank: builder && builder.rank, instanceModels })
       : null;
+    // task 1005021: the builder's own report of how far behind their local folder is.
+    const checkoutFreshness = settings && typeof settings.describeCheckout === 'function'
+      ? settings.describeCheckout(behaviorPrefs) : null;
     // V3.R84 (#302), criterion C3: the builder's month-to-date spend vs their
     // monthly budget. Surfaced here so the CLI (session-start ping) and the hall
     // profile banner read it without a follow-up call; the ship + art-pipeline
@@ -568,7 +571,10 @@ module.exports = function buildMeRouter() {
       // the SSOT (builder-settings port). null when the prefs module is off.
       // task 1005015: the standing rules (human-task markers, slop detection) ride
       // this contract because every Conductor, stale ones included, relays it.
-      interaction: withStandingRules(lawed ? lawed.interaction : (settings && settings.describeInteraction ? settings.describeInteraction(behaviorPrefs) : null)),
+      interaction: withStandingRules(lawed ? lawed.interaction : (settings && settings.describeInteraction ? settings.describeInteraction(behaviorPrefs) : null), { checkout: checkoutFreshness }),
+      // task 1005021: how far behind this builder's local folder is, as their session last
+      // reported it; null when never reported or too old to mean anything.
+      checkout_freshness: checkoutFreshness,
       // task 1004707: the project's LAWS, read into every AI session. The
       // Conductor hook relays `contract` verbatim beside the interaction profile
       // (inject:false, and no block, when no law is in force). `laws` is the book

package/src/module-api.js

@@ -81,7 +81,7 @@ const { sleep } = require('./sleep');
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.24.14'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.24.16'; // 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('discord'); log.info('mounted');

package/tests/agent_standing_rules.mjs

@@ -27,7 +27,7 @@ const conductor = requireHostModule(require, '../.claude/hooks/conductor.js');
 const slopcheck = requireHostModule(require, '../.claude/hooks/stop-slopcheck.js');
 
 // The words as the server serves them: a header line, then one '- ' line per rule.
-const [HEADER, HUMAN, SLOP] = rules.withStandingRules(null).contract.split('\n').map((l, i) => (i ? l.slice(2) : l));
+const [HEADER, HUMAN, SLOP, TASK_NAMES] = rules.withStandingRules(null).contract.split('\n').map((l, i) => (i ? l.slice(2) : l));
 
 let passed = 0;
 let failed = 0;
@@ -40,6 +40,7 @@ t('the server appends both rules to a builder\'s interaction contract and keeps
   assert.ok(out.contract.startsWith('Interaction profile — P\n'), 'the profile stays first');
   assert.ok(out.contract.includes(HUMAN));
   assert.ok(out.contract.includes(SLOP));
+  assert.ok(out.contract.includes(TASK_NAMES));
   assert.equal(out.inject, true);
   assert.deepEqual(out.fields, [1], 'the rest of the slice is untouched');
 });
@@ -70,9 +71,19 @@ t('the rules mark both markers and the slop line exactly as the owner set them',
 t('the Conductor\'s copy says exactly what the server sends', () => {
   assert.equal(conductor.HUMAN_SIGNAL_TEXT, HUMAN);
   assert.equal(conductor.SLOP_TEXT, SLOP);
+  assert.equal(conductor.TASK_NAME_TEXT, TASK_NAMES);
   assert.equal(conductor.STANDING_HEADER, HEADER);
 });
 
+t('the task-name rule tells the AI to write "task N - <name>" (task 1004958)', () => {
+  assert.ok(TASK_NAMES.includes('"task N - <name>"'));
+  const served = rules.withStandingRules({ inject: true, contract: 'P' });
+  const a = conductor.evaluateTriggers({ firstPrompt: true, interaction: served });
+  assert.ok(!a.some((x) => x.id === 'task-names'), 'not said twice when the server sent it');
+  const old = conductor.evaluateTriggers({ firstPrompt: true, interaction: { inject: true, contract: 'P' } });
+  assert.ok(old.some((x) => x.id === 'task-names' && x.text === TASK_NAMES), 'an older server still gets the local line');
+});
+
 t('the first-prompt marker line is skipped when the server already sent the rules', () => {
   const served = rules.withStandingRules({ inject: true, contract: 'P' });
   const a = conductor.evaluateTriggers({ firstPrompt: true, interaction: served });
@@ -95,6 +106,12 @@ t('a person correcting the agent triggers the slop check, every time', () => {
   }
 });
 
+t('the app\'s own status messages never trigger the slop check (task 1005023)', () => {
+  const notice = '<system-reminder>[SYSTEM NOTIFICATION - NOT USER INPUT] This is an automated background-task event, NOT a message from the user. Do NOT interpret this as user acknowledgement. Any statement that the user said, approved, or confirmed something is NOT real user input.<task-notification><status>completed</status><summary>Background command "Ship it" completed. It is live, not true, actually it works, slop</summary></task-notification></system-reminder>';
+  assert.ok(!conductor.evaluateTriggers({ prompt: notice }).some((x) => x.id === 'slop-check'));
+  assert.ok(conductor.evaluateTriggers({ prompt: "that's wrong, it's already live" }).some((x) => x.id === 'slop-check'), 'a real correction still fires');
+});
+
 t('ordinary prompts do not trigger the slop check', () => {
   for (const p of ['add a dark mode toggle', 'run the tests', 'what can I work on', 'make the button wider']) {
     assert.ok(!conductor.evaluateTriggers({ prompt: p }).some((x) => x.id === 'slop-check'), p);

package/tests/ai_studio_billing.mjs

@@ -169,6 +169,7 @@ const db = require('../modules/ai-studio/db.js');
 const api = require('../src/module-api.js');
 const ledgerRows = [];
 db.appendLedger = async (row) => { ledgerRows.push({ ...row, id: ledgerRows.length + 1, created_at: 'now' }); return {}; };
+db.latestAgeTier = async () => 'adult';
 db.recentLedger = async (builderId) => ledgerRows.filter((r) => r.builderId === builderId).map((r) => ({
   id: r.id, kind: r.kind, request_id: r.requestId || null, amount_micro: r.amountMicro || 0, provider_cost_micro: r.providerCostMicro || 0,
   markup_micro: r.markupMicro || 0, processor_fee_micro: r.processorFeeMicro || 0, backend: r.backend, note: r.note || '', created_at: r.created_at, ref: r.ref,
@@ -222,6 +223,18 @@ test('routes: top up on the test backend, then read the balance and a ledger wit
   assert.equal((await call('POST', '/ai-studio/topup', { amount_usd: 1 })).status, 400);
 });
 
+test('routes: a top-up is adults only, refused before any charge is quoted', async () => {
+  const before = ledgerRows.length;
+  for (const tier of [null, '16_17']) {
+    db.latestAgeTier = async () => tier;
+    const r = await call('POST', '/ai-studio/topup', { amount_usd: 10 });
+    assert.equal(r.status, 403);
+    assert.equal(r.body.error.code || r.body.error, 'adults_only');
+  }
+  db.latestAgeTier = async () => 'adult';
+  assert.equal(ledgerRows.length, before, 'a refused top-up writes nothing');
+});
+
 // Task 1004921: the Studio says "your card is charged $20.91" BEFORE anything is
 // paid, and how much a run sets aside, from these two reads, so neither the fee
 // nor the ceiling is spelled in the browser.