atris 3.72.5 → 3.73.0

package/lib/gm-bet.js

@@ -65,6 +65,7 @@ const METRIC_SOURCES = ['npm', 'install', 'download', 'git', 'master', 'landed',
 // purpose: filler jobs inflate one, and closing jobs empties the other.
 const METRICS = {
   installs: { what: 'npm installs in the 7 days that end on the check date', now: 'installs last week', up: true },
+  scoreboard: { what: "the owner's own number for this project, as he reports it on the phone; read from his first report on or after the check date", now: 'the last reported value', up: true },
   queue_landed: { what: 'jobs waiting on review today with real work behind them (a commit on a branch or on master that touches their own check) that land, accepted or merged, by the check date; placeholders do not count, and closing, dropping, or parking one counts zero', now: 'jobs landed from today\'s review queue', up: true },
 };
 
@@ -127,6 +128,345 @@ function readLedger(file, workspaceRoot) {
   return [...byId.values()].sort((a, b) => String(a.created_at).localeCompare(String(b.created_at)));
 }
 
+// ---- the owner's scoreboard: the one number that says this project is going well ----
+
+// Beside the ledger, one row per change: a pick (its name, which way is good,
+// and how it is read) or a report of its value. The newest pick wins; its
+// reports are the ones after it.
+function scoreboardPath(stateDir = defaultStateDir()) {
+  return path.join(stateDir, 'gm-scoreboard.jsonl');
+}
+
+function readScoreboard(file, workspaceRoot) {
+  let text = '';
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    return null;
+  }
+  let board = null;
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    let row;
+    try { row = JSON.parse(line); } catch { continue; }
+    if (!row || row.workspace !== workspaceRoot) continue;
+    if (row.kind === 'pick' && row.name) board = { name: row.name, up: row.up !== false, source: row.source === 'installs' ? 'installs' : 'reported', at: row.at, reports: [] };
+    else if (row.kind === 'report' && board && Number.isFinite(row.value)) board.reports.push({ value: row.value, at: row.at });
+  }
+  return board;
+}
+
+// the best of the last 8 reports, once there are 3: the bar a goal must clear
+const SCOREBOARD_REPORTS = 8;
+const SCOREBOARD_MIN_REPORTS = 3;
+
+// ---- the owner's focus: answers to the question cards ----------------------------
+
+// Lives beside the ledger, one row per answer; the newest answer per question wins.
+function focusPath(stateDir = defaultStateDir()) {
+  return path.join(stateDir, 'gm-focus.jsonl');
+}
+
+function readFocus(file, workspaceRoot) {
+  const out = {};
+  let text = '';
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    return out;
+  }
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const row = JSON.parse(line);
+      if (row && row.key && row.workspace === workspaceRoot) out[row.key] = row;
+    } catch {
+      // a torn line is skipped
+    }
+  }
+  return out;
+}
+
+// An answer newer than this is still fresh, so its question is not asked again.
+const FOCUS_FRESH_MS = 7 * 24 * 60 * 60 * 1000;
+
+// Our own words, which the owner never reads: on a card, a button, the
+// footer, a question, or in what the writer model says. A binary tell, so a
+// word list is the right tool.
+const OWNER_BANNED_WORDS = ['bet', 'bets', 'check date', 'started so far', 'the team takes on', 'mission', 'queue', 'landed', 'review', 'reviewed', 'receipt', 'skeptic', 'verify', 'target number'];
+const OWNER_BANNED = /\b(bets?|check dates?|started so far|the team takes on|missions?|queues?|landed|review(?:ed|s)?|receipts?|skeptics?|verify|target numbers?)\b/i;
+
+// When no idea is ready the desk asks the owner a question about his
+// project. The questions are written ahead, in the background, from that
+// project's own files and every earlier answer, like an interview. Until one
+// is written, this one works for any project.
+const FALLBACK_QUESTION = {
+  key: 'focus',
+  ask: 'what matters most for this project this month?',
+  choices: [
+    { id: 'using', label: 'more people using it' },
+    { id: 'money', label: 'making money from it' },
+    { id: 'better', label: 'making it better' },
+  ],
+};
+// questions kept written ahead, so a tap never waits on one
+const QUESTIONS_READY = 2;
+const QUESTION_ASK_MAX = 90;
+const QUESTION_FACT_MAX = 160;
+const QUESTION_CHOICE_MAX = 50;
+
+function questionsPath(stateDir = defaultStateDir()) {
+  return path.join(stateDir, 'gm-questions.jsonl');
+}
+
+// installs said the way the owner would say them, when this project has npm numbers
+function installsLine(bundle) {
+  const inst = bundle && bundle.sources && bundle.sources.installs;
+  const d = inst && inst.data;
+  if (!d || d.week_before == null) return null;
+  if (d.last_week === d.week_before) return `installs held at ${commas(d.last_week)} last week.`;
+  return d.last_week < d.week_before
+    ? `installs dropped to ${commas(d.last_week)} last week, down from ${commas(d.week_before)}.`
+    : `installs rose to ${commas(d.last_week)} last week, up from ${commas(d.week_before)}.`;
+}
+
+// What this project is, in its own words: the readme, the goals, the
+// persona, and the top of the map and the wiki. Read-only; a missing file is
+// left out.
+const CONTEXT_FILES = [['README.md', 60], ['atris/goals.md', 40], ['atris/PERSONA.md', 30], ['atris/MAP.md', 30], ['atris/wiki/index.md', 30]];
+function readProjectContext(workspaceRoot) {
+  const parts = [];
+  for (const [rel, lines] of CONTEXT_FILES) {
+    let text;
+    try {
+      text = fs.readFileSync(path.join(workspaceRoot, rel), 'utf8');
+    } catch {
+      continue;
+    }
+    const body = text.split(/\r?\n/).slice(0, lines).join('\n').trim();
+    if (body) parts.push(`## ${rel}\n${body}`);
+  }
+  return parts.join('\n\n');
+}
+
+// A fact line is drawn from the project's files: it has a number from them,
+// or four words in a row copied from them.
+function citesText(fact, source) {
+  const nums = t => (String(t).match(/\d[\d,]*(?:\.\d+)?/g) || []).map(n => n.replace(/,/g, ''));
+  const have = new Set(nums(source));
+  if (nums(fact).some(n => have.has(n))) return true;
+  const src = ` ${words(source).join(' ')} `;
+  const w = words(fact);
+  for (let i = 0; i + 4 <= w.length; i += 1) {
+    const gram = w.slice(i, i + 4);
+    if (gram.every(x => STOP_WORDS.has(x))) continue;
+    if (src.includes(` ${gram.join(' ')} `)) return true;
+  }
+  return false;
+}
+
+// a question about our own pipeline, not his product
+const PROCESS_TALK = /\b(ideas?|the team)\b/i;
+
+// The code checks on a written question. Our own words and lengths can be
+// fixed by one rewrite; anything else drops the question.
+function validateQuestion(q, { source = '', avoid = [] } = {}) {
+  const reasons = [];
+  const format = new Set();
+  const fmt = (r) => { reasons.push(r); format.add(r); };
+  if (!q || typeof q !== 'object' || Array.isArray(q)) return { ok: false, reasons: ['the answer was not one JSON object'], formatOnly: false };
+  const ask = typeof q.ask === 'string' ? q.ask.trim() : '';
+  const fact = typeof q.fact === 'string' ? q.fact.trim() : '';
+  const choices = Array.isArray(q.choices) ? q.choices.map(c => (typeof c === 'string' ? c.trim() : '')) : null;
+  if (!ask || !ask.endsWith('?')) reasons.push('ask must be one question ending with "?"');
+  else if (ask.length > QUESTION_ASK_MAX) fmt(`ask is ${ask.length} characters, over ${QUESTION_ASK_MAX}`);
+  if (ask && avoid.some(a => nearDuplicate(ask, a))) reasons.push('the ask was already asked');
+  // the fact is optional: a question with no fitting fact stands on its own
+  if (!fact) { /* no fact */ } else if (fact.length > QUESTION_FACT_MAX) fmt(`fact is ${fact.length} characters, over ${QUESTION_FACT_MAX}`);
+  else if (!citesText(fact, source)) reasons.push("the fact is not in this project's files");
+  if (!choices || choices.length < 2 || choices.length > 3 || choices.some(c => !c)) reasons.push('choices must be 2 or 3 short answers');
+  else {
+    choices.forEach((c, i) => { if (c.length > QUESTION_CHOICE_MAX) fmt(`choice ${i + 1} is ${c.length} characters, over ${QUESTION_CHOICE_MAX}`); });
+    if (new Set(choices.map(c => c.toLowerCase())).size !== choices.length) reasons.push('the choices must differ');
+  }
+  for (const [k, text] of [['ask', ask], ['fact', fact]]) {
+    if (PROCESS_TALK.test(text)) fmt(`${k} talks about our ideas or the team; ask about the product and its people`);
+  }
+  const said = [['ask', ask], ['fact', fact], ...(choices || []).map((c, i) => [`choice ${i + 1}`, c])];
+  for (const [k, text] of said) {
+    const word = ownerWord(text);
+    if (word) fmt(`${k} uses "${word}", a word the owner never reads; say it plainly`);
+  }
+  return { ok: reasons.length === 0, reasons, formatOnly: reasons.length > 0 && reasons.every(r => format.has(r)) };
+}
+
+function buildQuestionPrompt(bundle, context, { answers = [], avoid = [] } = {}) {
+  return [
+    'You are interviewing the owner of this project to learn what matters to him. Below is what this project\'s own files say.',
+    'Write exactly ONE question for the owner about the product or the business of this project: its people, money, what is working, what annoys him, or what he wants this month. Never ask about how the team works, its tools, or its process.',
+    'It is an interview: build on his earlier answers, go one step deeper, and never repeat a question already asked.',
+    '',
+    'Answer with strict JSON only, no prose and no code fence, in this shape:',
+    '{"ask": "...", "fact": "...", "choices": ["...", "...", "..."]}',
+    '',
+    'Rules:',
+    `- ask: one short plain question, under ${QUESTION_ASK_MAX} characters, ending with "?".`,
+    `- fact: the plain reason this question matters now, one sentence he would say himself, drawn from the files below, with a number or at least four words in a row copied from them, under ${QUESTION_FACT_MAX} characters. it must lead straight to the question. if nothing in the files gives a reason for this question, set fact to "".`,
+    `- choices: 2 or 3 short concrete answers he can tap, each under ${QUESTION_CHOICE_MAX} characters.`,
+    `- never use these words: ${OWNER_BANNED_WORDS.join(', ')}.`,
+    '- a section marked stale is old: prefer the fresh ones, and never present a stale line as what is happening now.',
+    '- ask about the product and the people who use it or pay for it, for example "who do you most want using this?". never mention ideas, the team, or what happens to his answer.',
+    '- plain lowercase-friendly words, no hype, no em dashes.',
+    '',
+    '## his answers so far',
+    ...(answers.length ? answers.map(a => `- ${a.ask} ${a.label}`) : ['- none yet']),
+    '',
+    '## questions already asked (never repeat one)',
+    ...(avoid.length ? avoid.map(a => `- ${a}`) : ['- none yet']),
+    '',
+    '## this project\'s files',
+    context || '(no readme or goals found)',
+    '',
+    bundleText(bundle),
+  ].join('\n');
+}
+
+function buildQuestionRewrite(previous, reasons) {
+  return [
+    'Your last question broke only these limits:',
+    ...reasons.map(r => `- ${r}`),
+    '',
+    'Fix only those: shorten what is long, and swap each word named for a plain one. Keep the same question, fact, and choices otherwise.',
+    'Answer with the whole JSON object again, strict JSON only, no prose and no code fence.',
+    '',
+    'Your last question:',
+    clip(previous, 2000),
+  ].join('\n');
+}
+
+// ---- reading free text: is it a question back, an answer, an instruction? ----
+
+const SAY_READ_MS = 15000;
+const SAY_KINDS = new Set(['question', 'answer', 'instruction', 'unclear']);
+const SAY_FALLBACK = 'say that another way, or tap a button.';
+// the last turns of a card's conversation the reader sees
+const THREAD_TURNS = 6;
+
+// the roster's model for quick reads (its search job), on the subscription
+function readerModel(workspaceRoot) {
+  try {
+    const team = require('./engine-registry').resolveJobTeam('search', workspaceRoot);
+    const lead = team && team.lead;
+    if (lead && (lead.id === 'claude' || lead.bin === 'claude') && lead.roster_model) return lead.roster_model;
+  } catch {
+    // no roster here
+  }
+  return 'haiku';
+}
+
+// One quick call: what kind of message the owner typed on the card on
+// screen, and what to say back. The card, the conversation on it so far, and
+// a short view of the project go in.
+async function readSaid({ text, card, thread = [], hint = null, workspaceRoot, bundle = null, deps = {} } = {}) {
+  const context = clip((deps.readContext || readProjectContext)(workspaceRoot), 1500);
+  const goal = bundle && bundle.sources && bundle.sources.goal;
+  const prompt = [
+    'You read one short message the owner typed on a card in the app that runs his project, and say what kind it is.',
+    'Answer with strict JSON only, no prose and no code fence, in this shape:',
+    '{"kind": "question" | "answer" | "instruction" | "unclear", "reply": "..."}',
+    '- question: he asks something back, like "what do you mean?" or "why?". reply: one or two plain sentences that say why the card asks this and give a concrete example from this project. read the conversation so far, so a follow-up builds on it.',
+    '- answer: his words answer the card. reply: "".',
+    '- instruction: he wants something done, or has a new idea. reply: one plain sentence saying what will happen next.',
+    '- unclear: you cannot tell. reply: one short question back.',
+    '- a message that ends with "?" or asks why, what, or how is a question back, never an answer.',
+    '- you may add "suggestions": 0 to 3 short replies he could tap next, each under 40 characters.',
+    `- plain lowercase-friendly words, no em dashes, and never these words: ${OWNER_BANNED_WORDS.join(', ')}.`,
+    '',
+    `## the card on screen (${card.kind})`,
+    card.title || '',
+    card.detail || '',
+    card.buttons && card.buttons.length ? `buttons: ${card.buttons.join(' / ')}` : '',
+    '',
+    '## the conversation on this card so far',
+    ...(thread.length ? thread.map(t => `- ${t.who === 'owner' ? 'owner' : 'you'}: ${t.text}`) : ['- none yet']),
+    '',
+    `## his message: "${clip(text, 280)}"`,
+    hint ? `note: ${hint}` : '',
+    '',
+    '## this project',
+    goal && goal.horizon ? `goal: ${goal.horizon.text}` : '',
+    context || '(no readme or goals found)',
+  ].filter(l => l !== '').join('\n');
+  const model = (deps.readerModel || readerModel)(workspaceRoot);
+  const said = await (deps.runModel || runModel)(prompt, { cwd: workspaceRoot, timeoutMs: SAY_READ_MS, command: { bin: 'claude', args: p => claudeArgs(p, model) }, onProgress: () => {} });
+  if (!said.ok) return { ok: false, reason: said.reason };
+  const parsed = parseBet(said.text);
+  const v = parsed.bet;
+  if (!v || !SAY_KINDS.has(v.kind) || typeof v.reply !== 'string') return { ok: false, reason: 'the read was not the shape asked for' };
+  const suggestions = Array.isArray(v.suggestions) ? v.suggestions.filter(x => typeof x === 'string' && x.trim()).map(x => x.trim()) : [];
+  return { ok: true, kind: v.kind, reply: clip(v.reply, 280), ...(suggestions.length ? { suggestions } : {}) };
+}
+
+// Two or three numbers that would tell the owner this project is going well,
+// suggested from its own files. Each is a short plain name and which way is good.
+async function generateScoreboardChoices({ workspaceRoot, bundle = null, deps = {}, ledgerFile, today = dayKey(Date.now()) } = {}) {
+  const b = bundle || await readBundle(workspaceRoot, { deps, ledgerFile, today });
+  const context = (deps.readContext || readProjectContext)(workspaceRoot);
+  const prompt = [
+    'You help the owner of this project pick the one number that tells him it is going well. Below is what its own files say.',
+    'Suggest 2 or 3 such numbers for THIS project, the kind he would check each week. For example: a web app, "people who used it this week"; a research lab, "experiments that worked"; a fund, "returns this month"; a journal, "days you wrote".',
+    'Answer with strict JSON only, no prose and no code fence: {"choices": [{"name": "...", "up": true}]}',
+    '- name: a short plain phrase under 40 characters. up: true when higher is better, false when lower is better.',
+    `- never use these words: ${OWNER_BANNED_WORDS.join(', ')}.`,
+    '',
+    "## this project's files",
+    context || '(no readme or goals found)',
+    '',
+    bundleText(b),
+  ].join('\n');
+  const said = await (deps.runModel || runModel)(prompt, { cwd: workspaceRoot, onProgress: () => {} });
+  if (!said.ok) return { ok: false, reason: said.reason };
+  const parsed = parseBet(said.text);
+  const list = parsed.bet && Array.isArray(parsed.bet.choices) ? parsed.bet.choices : [];
+  const choices = list
+    .filter(c => c && typeof c.name === 'string' && c.name.trim() && c.name.trim().length <= 40 && !ownerWord(c.name) && !PROCESS_TALK.test(c.name))
+    .slice(0, 3)
+    .map(c => ({ name: c.name.trim(), up: c.up !== false }));
+  return choices.length >= 2 ? { ok: true, choices } : { ok: false, reason: 'fewer than two usable numbers' };
+}
+
+// One question for the owner, written from this project's files and his
+// earlier answers. A question with our own words gets one rewrite; one that
+// still fails any check is dropped.
+async function generateQuestion({ workspaceRoot, answers = [], avoid = [], bundle = null, deps = {}, ledgerFile, today = dayKey(Date.now()) } = {}) {
+  const b = bundle || await readBundle(workspaceRoot, { deps, ledgerFile, today });
+  const context = (deps.readContext || readProjectContext)(workspaceRoot);
+  const source = `${context}\n${bundleText(b)}`;
+  const run = deps.runModel || runModel;
+  const ask = async (prompt) => {
+    const said = await run(prompt, { cwd: workspaceRoot, onProgress: () => {} });
+    if (!said.ok) return { failed: said.reason };
+    const parsed = parseBet(said.text);
+    return { parsed, check: parsed.error ? { ok: false, reasons: [parsed.error], formatOnly: false } : validateQuestion(parsed.bet, { source, avoid }) };
+  };
+  let r = await ask(buildQuestionPrompt(b, context, { answers, avoid }));
+  if (r.failed) return { ok: false, reason: r.failed };
+  if (!r.check.ok && r.check.formatOnly) {
+    r = await ask(buildQuestionRewrite(JSON.stringify(r.parsed.bet), r.check.reasons));
+    if (r.failed) return { ok: false, reason: r.failed };
+  }
+  if (!r.check.ok) return { ok: false, reason: `the question was dropped: ${r.check.reasons.slice(0, 3).join('; ')}` };
+  const q = r.parsed.bet;
+  const fact = typeof q.fact === 'string' && q.fact.trim() ? q.fact.trim() : null;
+  return { ok: true, question: { ask: q.ask.trim(), fact, choices: q.choices.map(c => c.trim()) } };
+}
+
+// The first of our own words in a line the owner reads, or null.
+function ownerWord(text) {
+  const m = OWNER_BANNED.exec(String(text || ''));
+  return m ? m[0].toLowerCase() : null;
+}
+
 function ledgerLine(bets) {
   if (!bets.length) return 'past bets: none yet';
   const count = s => bets.filter(b => b.status === s).length;
@@ -150,6 +490,92 @@ function readNow(workspaceRoot) {
   return { fact, text: lines.join('\n') };
 }
 
+// ---- what the project is about now: its goal, open missions, and journal ----------
+
+// a source older than this is labeled stale, and the writers prefer fresher ones
+const STALE_DAYS = 14;
+const MISSIONS_SHOWN = 8;
+const JOURNAL_LINES = 20;
+const JOURNAL_CHARS = 1500;
+
+// whole days from an ISO date (or "YYYY-MM-DD ...") to today, or null
+function ageDays(when, today) {
+  const day = /(\d{4}-\d{2}-\d{2})/.exec(String(when || ''));
+  if (!day) return null;
+  return Math.round((Date.parse(`${today}T00:00:00Z`) - Date.parse(`${day[1]}T00:00:00Z`)) / 86400000);
+}
+
+function staleNote(age) {
+  return age != null && age > STALE_DAYS ? `stale: ${age} days old` : null;
+}
+
+// The goal: the endgame horizon in atris/TODO.md (what the boot shows as the
+// goal) and the sentence set with atris goal, each with the day it was set.
+function readGoal(workspaceRoot) {
+  const out = {};
+  try {
+    const todo = fs.readFileSync(path.join(workspaceRoot, 'atris', 'TODO.md'), 'utf8');
+    const section = (/##\s+Endgame\s*\n([\s\S]*?)(?=\n##|$)/.exec(todo) || [])[1] || '';
+    const horizon = (/\*\*Horizon:\*\*\s*(.+)/.exec(section) || [])[1];
+    const picked = (/\*\*Picked:\*\*\s*(.+)/.exec(section) || [])[1];
+    if (horizon && horizon.trim()) out.horizon = { text: clip(horizon, 240), at: picked ? picked.trim().slice(0, 10) : null };
+  } catch {
+    // no TODO.md here
+  }
+  try {
+    const board = JSON.parse(fs.readFileSync(path.join(workspaceRoot, '.atris', 'state', 'scoreboard.json'), 'utf8'));
+    if (board && typeof board.goal === 'string' && board.goal.trim()) out.goal = { text: clip(board.goal, 240), at: board.updated_at ? String(board.updated_at).slice(0, 10) : null };
+  } catch {
+    // no goal set
+  }
+  return out.horizon || out.goal ? out : null;
+}
+
+// a mission's objective as a plain title: its first sentence
+function missionTitle(objective) {
+  return clip(String(objective || '').split(/\.\s/)[0].replace(/[.\s]+$/, ''), 100);
+}
+
+// Open missions, freshest first, as plain titles with who owns each.
+function openMissions(missions, today) {
+  const list = missions instanceof Map ? [...missions.values()] : Object.values(missions || {});
+  return list
+    .filter(m => m && OPEN_MISSION.has(String(m.status || '')) && m.objective)
+    .map((m) => {
+      const moved = [m.last_tick_at, m.updated_at, m.created_at].filter(Boolean).sort().pop();
+      return { title: missionTitle(m.objective), owner: m.owner || null, moved, age: ageDays(moved, today), running: m.status === 'running' };
+    })
+    // a run that says running but has not moved in a day is dead, not open work
+    .filter(m => !(m.running && m.age != null && m.age >= 1))
+    .sort((a, b) => String(b.moved).localeCompare(String(a.moved)))
+    .slice(0, MISSIONS_SHOWN);
+}
+
+// The newest day in atris/logs, its last lines, bounded.
+function readJournal(workspaceRoot) {
+  const dir = path.join(workspaceRoot, 'atris', 'logs');
+  let newest = null;
+  try {
+    for (const year of fs.readdirSync(dir)) {
+      if (!/^\d{4}$/.test(year)) continue;
+      for (const f of fs.readdirSync(path.join(dir, year))) {
+        if (/^\d{4}-\d{2}-\d{2}\.md$/.test(f) && (!newest || f > newest.name)) newest = { name: f, file: path.join(dir, year, f) };
+      }
+    }
+  } catch {
+    return null;
+  }
+  if (!newest) return null;
+  let text;
+  try {
+    text = fs.readFileSync(newest.file, 'utf8');
+  } catch {
+    return null;
+  }
+  const lines = text.split(/\r?\n/).filter(l => l.trim()).slice(-JOURNAL_LINES);
+  return lines.length ? { day: newest.name.slice(0, 10), text: lines.join('\n').slice(-JOURNAL_CHARS) } : null;
+}
+
 // The weekly target and the season record, read the same way the board reads them.
 function defaultSeasonFacts(workspaceRoot) {
   const season = require('./gm-season');
@@ -488,7 +914,12 @@ function dayEndMs(day) {
 // task db. Resolves { value } or { error, transient }; transient means try
 // again later (npm has not counted the days yet, or the db is busy), not
 // transient means never.
-async function defaultReadMetric(metric, { workspaceRoot, start, end, target = {}, deps = {} }) {
+async function defaultReadMetric(metric, { workspaceRoot, start, end, target = {}, deps = {}, ledgerFile = null }) {
+  if (metric === 'scoreboard') {
+    const board = readScoreboard(scoreboardPath(path.dirname(ledgerFile || ledgerPath())), workspaceRoot);
+    const hit = board && board.reports.find(r => String(r.at).slice(0, 10) >= end);
+    return hit ? { value: hit.value } : { error: 'the owner has not reported the number for this date yet', transient: true };
+  }
   if (metric === 'installs') {
     const pkg = deps.packageName !== undefined ? deps.packageName : packageName(workspaceRoot);
     if (!pkg) return { error: 'no published package here to read installs from', transient: false };
@@ -511,8 +942,9 @@ async function defaultReadMetric(metric, { workspaceRoot, start, end, target = {
 }
 
 // Won when the number reached the goal.
-function wonBet(metric, actual, goal) {
-  return METRICS[metric].up ? actual >= goal : actual <= goal;
+function wonBet(metric, actual, goal, target = {}) {
+  const up = metric === 'scoreboard' ? target.up !== false : METRICS[metric].up;
+  return up ? actual >= goal : actual <= goal;
 }
 
 // Scores every bet the team is doing once its check date is over: reads its
@@ -536,7 +968,7 @@ async function scoreBets(workspaceRoot, { ledgerFile = ledgerPath(), today = day
       out = { error: metric && !METRICS[metric] ? `there is no way to read "${metric}"` : 'the bet has no target number to read', transient: false };
     } else {
       try {
-        out = await read(metric, { workspaceRoot, start, end, target: t, deps });
+        out = await read(metric, { workspaceRoot, start, end, target: t, deps, ledgerFile });
       } catch (err) {
         out = { error: String((err && err.message) || err), transient: true };
       }
@@ -546,8 +978,8 @@ async function scoreBets(workspaceRoot, { ledgerFile = ledgerPath(), today = day
       if (out && out.transient && late <= SCORE_GRACE_DAYS) continue;
       Object.assign(row, { status: 'unreadable', why });
     } else {
-      const window = metric === 'installs' ? `${start} to ${end}` : `landed by the end of ${end}, of ${plural(t.job_ids.length, 'job')} waiting at the start`;
-      Object.assign(row, { status: wonBet(metric, out.value, t.goal) ? 'won' : 'lost', actual: out.value, window });
+      const window = metric === 'installs' ? `${start} to ${end}` : (metric === 'scoreboard' ? `reported on or after ${end}` : `landed by the end of ${end}, of ${plural(t.job_ids.length, 'job')} waiting at the start`);
+      Object.assign(row, { status: wonBet(metric, out.value, t.goal, t) ? 'won' : 'lost', actual: out.value, window });
     }
     appendLedger(ledgerFile, row);
     scored.push({ ...row, title: b.bet.title });
@@ -563,7 +995,9 @@ async function scoreBets(workspaceRoot, { ledgerFile = ledgerPath(), today = day
 function bundleMetrics(bundle) {
   const s = (bundle && bundle.sources) || {};
   const out = {};
-  if (s.installs) {
+  if (s.scoreboard) {
+    out.scoreboard = { baseline: s.scoreboard.baseline, best: s.scoreboard.best, reports: s.scoreboard.reports, up: s.scoreboard.up, name: s.scoreboard.name };
+  } else if (s.installs) {
     const best = s.installs.best || null;
     out.installs = { baseline: s.installs.data.last_week, best: best ? best.best : null, weeks: best ? best.weeks : 0 };
   }
@@ -587,7 +1021,7 @@ async function readBundle(workspaceRoot, { deps = {}, emit = () => {}, ledgerFil
   } catch {
     // scoring is a side job; a failure never blocks the next bet
   }
-  const bundle = { workspace: workspaceRoot, sources: {}, facts: [] };
+  const bundle = { workspace: workspaceRoot, today, sources: {}, facts: [] };
   const add = (key, fact, data) => {
     bundle.sources[key] = { fact, ...data };
     bundle.facts.push(fact);
@@ -596,8 +1030,11 @@ async function readBundle(workspaceRoot, { deps = {}, emit = () => {}, ledgerFil
   const skip = (key, why) => emit({ kind: 'skip', key, line: why });
 
   const now = (deps.readNow || readNow)(workspaceRoot);
-  if (now) add('now', now.fact, { text: now.text });
-  else skip('now', 'no atris/now.md, left out');
+  if (now) {
+    const age = ageDays(/last updated:\s*(.+)$/im.exec(now.text || '') ? /last updated:\s*(.+)$/im.exec(now.text)[1] : null, today);
+    const stale = staleNote(age);
+    add('now', stale ? `${now.fact}, ${age} days ago, stale` : now.fact, { text: now.text, ...(stale ? { stale: age } : {}) });
+  } else skip('now', 'no atris/now.md, left out');
 
   let season = null;
   try {
@@ -707,6 +1144,42 @@ async function readBundle(workspaceRoot, { deps = {}, emit = () => {}, ledgerFil
     ...(b.why ? { why: b.why } : {}),
   }));
   add('ledger', ledgerLine(bets), { bets: shown });
+
+  // what the project is about now: kept out of the facts list and the event
+  // stream, read only when the files are there
+  const goal = (deps.readGoal || readGoal)(workspaceRoot);
+  if (goal) bundle.sources.goal = goal;
+  let missionMap = null;
+  try {
+    missionMap = (deps.readMissions || defaultReadMissions)(workspaceRoot);
+  } catch {
+    missionMap = null;
+  }
+  const open = missionMap ? openMissions(missionMap, today) : [];
+  if (open.length) bundle.sources.missions = { list: open };
+  const journal = (deps.readJournal || readJournal)(workspaceRoot);
+  if (journal) bundle.sources.journal = { ...journal, age: ageDays(journal.day, today) };
+
+  // the owner's own number: a reported one is the target, with the last
+  // report as the baseline; an installs one keeps the npm numbers
+  const board = readScoreboard(scoreboardPath(path.dirname(ledger)), workspaceRoot);
+  if (board && board.source === 'reported' && board.reports.length) {
+    const last = board.reports[board.reports.length - 1];
+    const recent = board.reports.slice(-SCOREBOARD_REPORTS).map(r => r.value);
+    const best = recent.length >= SCOREBOARD_MIN_REPORTS ? (board.up ? Math.max(...recent) : Math.min(...recent)) : null;
+    add('scoreboard', `${board.name}: last reported ${commas(last.value)} on ${String(last.at).slice(0, 10)}`, { name: board.name, up: board.up, baseline: last.value, best, reports: recent.length });
+  } else if (board) {
+    bundle.sources.scoreboard_pick = { name: board.name, up: board.up, source: board.source };
+  }
+
+  // what the owner said to aim at, from the question cards; kept out of the
+  // facts list, so a why_now still has to quote a real number
+  const focus = Object.values(readFocus(focusPath(path.dirname(ledger)), workspaceRoot))
+    .sort((a, b) => String(a.at).localeCompare(String(b.at)));
+  if (focus.length) {
+    bundle.sources.focus = { answers: focus.map(a => ({ key: a.key, ask: a.ask, label: a.label, at: a.at })) };
+    emit({ kind: 'source', key: 'focus', line: `the owner said: ${focus.map(a => a.label).join(', ')}` });
+  }
   return bundle;
 }
 
@@ -719,13 +1192,34 @@ function pastBetLine(b) {
 function bundleText(bundle) {
   const s = bundle.sources;
   const parts = ['## facts', ...bundle.facts.map(f => `- ${f}`)];
-  if (s.now) parts.push('', '## atris/now.md', s.now.text);
+  const aged = (at, verb) => {
+    const note = staleNote(ageDays(at, bundle.today));
+    return at ? ` (${verb} ${at}${note ? `, ${note}` : ''})` : '';
+  };
+  if (s.goal) {
+    parts.push('', '## the goal');
+    if (s.goal.horizon) parts.push(`- horizon: ${s.goal.horizon.text}${aged(s.goal.horizon.at, 'picked')}`);
+    if (s.goal.goal) parts.push(`- goal: ${s.goal.goal.text}${aged(s.goal.goal.at, 'set')}`);
+  }
+  if (s.now) parts.push('', `## atris/now.md${s.now.stale ? ` (stale: ${s.now.stale} days old, prefer the fresher sections)` : ''}`, s.now.text);
+  if (s.missions) parts.push('', '## open missions', ...s.missions.list.map((m) => {
+    const note = staleNote(m.age);
+    const tail = [m.owner, note].filter(Boolean).join(', ');
+    return `- ${m.title}${tail ? ` (${tail})` : ''}`;
+  }));
+  if (s.journal) parts.push('', `## latest journal, ${s.journal.day}${staleNote(s.journal.age) ? ` (${staleNote(s.journal.age)})` : ''}`, s.journal.text);
   if (s.landed && s.landed.subjects.length) parts.push('', '## changes merged on master in the last 7 days', ...s.landed.subjects.map(x => `- ${x}`));
   if (s.installs) parts.push('', `## npm installs for ${s.installs.package}`, `last week: ${s.installs.data.last_week}`, `week before: ${s.installs.data.week_before == null ? 'unknown' : s.installs.data.week_before}`, `through: ${s.installs.data.through}`);
   if (s.release) parts.push('', '## release', `published on npm: ${s.release.version}`, `changes on master not in it: ${s.release.unpublished == null ? 'unknown' : s.release.unpublished}`);
-  if (s.team) parts.push('', '## the team (a team step names one of these as its member)', ...s.team.members.map(m => `- ${m.name}: ${m.role}`));
+  // what each member is on now: their freshest open mission
+  const onNow = new Map();
+  for (const m of (s.missions ? s.missions.list : [])) if (m.owner && !staleNote(m.age) && !onNow.has(m.owner)) onNow.set(m.owner, m.title);
+  if (s.team) parts.push('', '## the team (a team step names one of these as its member)', ...s.team.members.map(m => (onNow.has(m.name) ? `- ${m.name}: ${m.role.replace(/[.\s]+$/, '')}. now on: ${onNow.get(m.name)}` : `- ${m.name}: ${m.role}`)));
   if (s.briefs) for (const b of s.briefs.briefs) parts.push('', `## research brief: ${b.name}`, b.text);
   if (s.ledger && s.ledger.bets.length) parts.push('', '## past bets', ...s.ledger.bets.map(pastBetLine));
+  if (s.scoreboard) parts.push('', "## the owner's scoreboard", `- ${s.scoreboard.name} (${s.scoreboard.up ? 'higher' : 'lower'} is better); last reported ${commas(s.scoreboard.baseline)}`);
+  else if (s.scoreboard_pick) parts.push('', "## the owner's scoreboard", `- ${s.scoreboard_pick.name} (${s.scoreboard_pick.up ? 'higher' : 'lower'} is better), read from ${s.scoreboard_pick.source === 'installs' ? 'npm installs' : 'his reports'}`);
+  if (s.focus) parts.push('', '## what the owner asked for', ...s.focus.answers.map(a => `- ${a.ask} ${a.label} (said ${String(a.at).slice(0, 10)})`));
   return parts.join('\n');
 }
 
@@ -733,6 +1227,12 @@ function bundleText(bundle) {
 
 // The bar a goal has to clear, in words, for the prompt and the reject reason.
 function goalBar(metric, m) {
+  if (metric === 'scoreboard') {
+    const dir = m.up ? 'above' : 'below';
+    return m.best == null
+      ? `with fewer than ${SCOREBOARD_MIN_REPORTS} reports any honest goal ${dir} the baseline ${commas(m.baseline)} passes`
+      : `the best of the last ${m.reports} reports was ${commas(m.best)}, so the goal must be ${dir} ${commas(m.best)}`;
+  }
   if (metric === 'installs') {
     return m.best == null ? 'the goal must be above the baseline' : `the best week in the last ${bestSpan(m.weeks)} was ${commas(m.best)}, so the goal must be above ${commas(m.best)}`;
   }
@@ -745,11 +1245,12 @@ const TEAM_ONLY_METRICS = new Set(['queue_landed']);
 function metricChoices(bundle) {
   const m = bundleMetrics(bundle);
   return Object.keys(m).filter(k => !TEAM_ONLY_METRICS.has(k)).map((k) => {
+    if (k === 'scoreboard') return `"scoreboard" (${m[k].name}, the owner's own number; baseline ${m[k].baseline}; ${goalBar(k, m[k])})`;
     return `"${k}" (${METRICS[k].what}; baseline ${m[k].baseline}; ${goalBar(k, m[k])})`;
   });
 }
 
-function buildPrompt(bundle, { today, previousTitle = null, reason = null, previousAnswer = null, blocker = null, avoidTitles = [] } = {}) {
+function buildPrompt(bundle, { today, previousTitle = null, reason = null, previousAnswer = null, blocker = null, avoidTitles = [], reworkOf = null, ownerNote = null } = {}) {
   const choices = metricChoices(bundle);
   const lines = [
     'You are the strategist for a small software business. Below is everything we can read about it right now.',
@@ -775,11 +1276,18 @@ function buildPrompt(bundle, { today, previousTitle = null, reason = null, previ
     '- check what has to be true first. if the move shows people something that is merged but not published yet (see the release fact), the release is one step for "you" inside the move, never the move itself.',
     '- past bets marked won or lost are real results, read from the same numbers. lean toward moves like the winners and away from the losers, and when you do, say so in why_now.',
     '- write in plain lowercase-friendly words, no hype, no em dashes.',
+    '- a section marked stale is old: prefer the fresh ones, and never present a stale line as what is happening now.',
+    '- never propose a trade, buying or selling stocks, shares, crypto, or any security, or moving money between accounts.',
   ];
+  lines.push(`- title, why_now, and expect are read by the owner, so they never use these words: ${OWNER_BANNED_WORDS.join(', ')}. say "idea" or a plain verb instead of bet, and say what changes for people, not how we work.`);
+  if (bundle.sources && bundle.sources.focus) lines.push('- the bet must serve what the owner asked for (the last section below). when answers pull different ways, the newest wins.');
   // a skeptic named what blocks the last idea: the blocker is the next bet,
   // not one more step on the old idea
   if (blocker) lines.push('', `The last idea ("${clip(blocker.title, 120)}") is blocked by: ${blocker.missing_first.replace(/[.\s]+$/, '')}. Don't patch that idea. Make clearing this blocker the bet, as big as this team can do in the window, with its own target. The blocker stops being a step and becomes the whole move. If the blocker is team plumbing (a release, a merge, a review, a fix to the build or a count), it is never the bet: keep a business move and put the plumbing in as one step.`);
   if (previousTitle) lines.push('', `Make it sharper, more specific, and different from: ${previousTitle}`);
+  // what the owner typed on a card
+  if (ownerNote && reworkOf) lines.push('', `The owner read the idea "${clip(reworkOf, 160)}" and said: "${clip(ownerNote, 280)}". Rework it so it fits what they said; it may keep the same deliverable.`);
+  else if (ownerNote) lines.push('', `The owner said: "${clip(ownerNote, 280)}". The next idea must fit that.`);
   const avoid = avoidTitles.filter(t => t && t !== previousTitle);
   if (avoid.length) lines.push('', 'It must be a different move from every one of these bets already shown or waiting:', ...avoid.map(t => `- ${t}`));
   if (previousAnswer) lines.push('', 'Your last answer was:', clip(previousAnswer, 4000));
@@ -805,6 +1313,19 @@ function claudeArgs(prompt, model = MODEL) {
 // Runs the model in its own process group. On timeout the whole group is
 // killed, so nothing it started keeps running. Streams real progress (tokens
 // thought, characters written) through onProgress.
+// Writers running now, by process group, so the server can end them when it
+// stops; otherwise a stopped server leaves them running on their own.
+const LIVE_WRITERS = new Map();
+
+function stopWriters() {
+  let n = 0;
+  for (const [pid, kill] of LIVE_WRITERS) {
+    try { kill(-pid, 'SIGTERM'); n += 1; } catch { /* already gone */ }
+  }
+  LIVE_WRITERS.clear();
+  return n;
+}
+
 function runModel(prompt, { command = { bin: 'claude', args: claudeArgs }, cwd, timeoutMs = MODEL_TIMEOUT_MS, env = process.env, onProgress = () => {}, spawnFn = require('child_process').spawn, kill = process.kill.bind(process) } = {}) {
   return new Promise((resolve) => {
     const args = typeof command.args === 'function' ? command.args(prompt) : [...(command.args || []), prompt];
@@ -815,6 +1336,7 @@ function runModel(prompt, { command = { bin: 'claude', args: claudeArgs }, cwd,
       resolve({ ok: false, reason: `could not start the model: ${err.message}` });
       return;
     }
+    if (child && child.pid) LIVE_WRITERS.set(child.pid, kill);
     let buf = '';
     let size = 0;
     let stderr = '';
@@ -864,6 +1386,7 @@ function runModel(prompt, { command = { bin: 'claude', args: claudeArgs }, cwd,
       if (done) return;
       done = true;
       clearTimeout(timer);
+      LIVE_WRITERS.delete(child.pid);
       resolve(out);
     };
     child.on('error', err => finish({ ok: false, reason: `could not start the model: ${err.message}` }));
@@ -998,6 +1521,11 @@ function targetProblems(target, bundle, { allowTeamMetrics = false } = {}) {
   } else if (metric === 'installs') {
     if (known.best !== null && !(target.goal > known.best)) out.push(`target goal ${commas(target.goal)} does not beat our best installs week of the last ${bestSpan(known.weeks)}, ${commas(known.best)}; the goal must be above ${commas(known.best)}`);
     else if (known.best === null && !(target.goal > real)) out.push(`target goal ${commas(target.goal)} must be above the baseline ${commas(real)}`);
+  } else if (metric === 'scoreboard') {
+    const better = (a, b) => (known.up ? a > b : a < b);
+    const dir = known.up ? 'above' : 'below';
+    if (known.best != null && !better(target.goal, known.best)) out.push(`target goal ${commas(target.goal)} does not beat the best of the last ${known.reports} reports, ${commas(known.best)}; the goal must be ${dir} ${commas(known.best)}`);
+    else if (known.best == null && !better(target.goal, real)) out.push(`target goal ${commas(target.goal)} must be ${dir} the baseline ${commas(real)}`);
   } else if (metric === 'queue_landed') {
     if (known.real === 0) out.push(known.waiting === 0 ? 'nothing is waiting on review, so there is no queue to land; pick another metric' : `none of the ${commas(known.waiting)} waiting jobs has real work behind it, so none can land; pick another metric`);
     else if (target.goal < known.least) out.push(`target goal ${commas(target.goal)} does not land half the waiting jobs with real work: ${commas(known.real)} have real work, so the goal must be at least ${commas(known.least)}`);
@@ -1006,6 +1534,9 @@ function targetProblems(target, bundle, { allowTeamMetrics = false } = {}) {
   return out;
 }
 
+// a trade, buying or selling a security, or moving money: never an idea
+const TRADE = /\b(buy|sell|short|trade|trading)\b[^.]{0,40}\b(stocks?|shares|securit(?:y|ies)|options|crypto|bitcoin|tokens|bonds?|etfs?|index fund|positions?)\b|\b(wire|transfer|move|send)\b[^.]{0,30}\b(money|funds|cash)\b[^.]{0,30}\b(account|brokerage|bank|wallet)\b/i;
+
 function validateBet(bet, { bundle, today, previousTitle = null, avoidTitles = [], allowTeamMetrics = false } = {}) {
   const reasons = [];
   // format-only reasons: a field too long or with too many sentences. Only
@@ -1017,6 +1548,12 @@ function validateBet(bet, { bundle, today, previousTitle = null, avoidTitles = [
   for (const k of ['title', 'why_now', 'expect', 'metric_source', 'cost']) {
     if (!str(k)) reasons.push(`${k} is missing`);
   }
+  for (const k of ['title', 'why_now', 'expect']) {
+    const word = ownerWord(str(k));
+    if (word) fmt(`${k} uses "${word}", a word the owner never reads; say it plainly`);
+  }
+  const allText = [str('title'), str('why_now'), str('expect'), ...(Array.isArray(bet.steps) ? bet.steps.map(st => `${st && st.text} ${st && st.detail}`) : [])].join(' . ');
+  if (TRADE.test(allText)) reasons.push('it proposes a trade or moving money; ideas never do that');
   if (str('title')) {
     const p = titleProblem(str('title'));
     if (p && (p === 'the title is longer than 140 characters' || p === 'the title is more than one sentence')) fmt(p);
@@ -1082,6 +1619,7 @@ function addDays(today, n) {
 
 // "goal 2,400, best week in 2 months 2,319" or "goal 3 of the 6 jobs with work landed"
 function goalLine(target, known) {
+  if (target.metric === 'scoreboard') return `goal ${commas(target.goal)}, last reported ${commas(target.baseline)}`;
   if (target.metric === 'queue_landed') return `goal ${commas(target.goal)} of the ${commas(target.job_ids.length)} jobs with work landed`;
   if (known && known.best !== null) return `goal ${commas(target.goal)}, best week in ${bestSpan(known.weeks)} ${commas(known.best)}`;
   return `goal ${commas(target.goal)}, ${commas(target.baseline)} last week`;
@@ -1091,6 +1629,8 @@ function cleanBet(bet, today, bundle) {
   const target = { metric: bet.target.metric, baseline: bet.target.baseline, goal: bet.target.goal };
   // the jobs waiting right now, kept with the bet: only these can count
   if (target.metric === 'queue_landed') target.job_ids = [...bundleMetrics(bundle).queue_landed.ids];
+  // the owner's number keeps its name and which way is good, for scoring later
+  if (target.metric === 'scoreboard') Object.assign(target, { name: bundleMetrics(bundle).scoreboard.name, up: bundleMetrics(bundle).scoreboard.up });
   return {
     title: bet.title.trim(),
     why_now: bet.why_now.trim(),
@@ -1150,6 +1690,7 @@ function buildSkepticPrompt(bet, bundle, { today } = {}) {
     '- moves_metric: if every step is done, would it actually move the target number (target.metric: installs are read over the 7 days that end on the check date; queue_landed counts only the waiting jobs with real work when the bet was made (target.job_ids; placeholders with no check are left out) that land, accepted or merged, by the check date, and a closed, dropped, or parked job counts zero) from the baseline to the goal? a post does not move installs if the thing it shows is not installable yet, and work nobody outside sees does not move installs at all.',
     '- missing_first: what must be true first and is not, and is not already a step: an unpublished feature (see the release fact), a page or command that does not exist, no audience that would see it. write "nothing" when nothing is missing.',
     '- would a sharp founder reading this find it obviously wrong, padded, or a waste of the week?',
+    '- does it propose a trade, buying or selling stocks, shares, crypto, or any security, or moving money between accounts: fail it.',
     '- is the deliverable internal plumbing (a release, a review queue, merging or unsticking jobs, test speed, fixing a count or a dashboard)? that is the team\'s job and never an owner bet, so fail it. plumbing as one step inside a business move is fine.',
     'verdict is "pass" only when moves_metric is true, nothing is missing that the steps do not cover, it is not obviously wrong, and it is not plumbing. otherwise "fail".',
     'reason: one or two plain sentences under 240 characters. if the missing piece is something the team or the owner could do, name the step to add.',
@@ -1206,11 +1747,14 @@ function skepticReason(v) {
 // the reasons and the last answer go back, and only those fields may change.
 // The text is never shortened in code.
 function buildTrimPrompt(previousAnswer, reasons) {
+  const worded = reasons.some(r => r.includes('a word the owner never reads'));
   return [
-    'Your last answer below broke only these length or sentence limits:',
+    worded ? 'Your last answer below broke only these wording or length limits:' : 'Your last answer below broke only these length or sentence limits:',
     ...reasons.map(r => `- ${r}`),
     '',
-    'Shorten only those fields so they fit. Change nothing else: the same idea, the same target, the same check_in_days, the same steps in the same order with the same who and public. Keep the plain words, no em dashes.',
+    worded
+      ? 'Fix only those fields: shorten the long ones, and swap each word named for a plain one. Change nothing else: the same idea, the same target, the same check_in_days, the same steps in the same order with the same who and public. Keep the plain words, no em dashes.'
+      : 'Shorten only those fields so they fit. Change nothing else: the same idea, the same target, the same check_in_days, the same steps in the same order with the same who and public. Keep the plain words, no em dashes.',
     'Answer with the whole JSON object again, strict JSON only, no prose and no code fence.',
     '',
     'Your last answer:',
@@ -1228,8 +1772,12 @@ function trimChangedMore(before, after) {
   return a.length !== b.length || a.some((s, i) => !b[i] || s.who !== b[i].who || s.public !== b[i].public);
 }
 
-async function generateBet({ workspaceRoot, today, previousTitle = null, avoidTitles = [], emit = () => {}, deps = {}, ledgerFile, attemptsFile, allowTeamMetrics = false } = {}) {
+async function generateBet({ workspaceRoot, today, previousTitle = null, avoidTitles: avoidIn = [], reworkOf = null, ownerNote = null, emit = () => {}, onBundle = () => {}, deps = {}, ledgerFile, attemptsFile, allowTeamMetrics = false } = {}) {
+  // a rework may stay close to the idea it reworks
+  const avoidTitles = reworkOf ? avoidIn.filter(t => t !== reworkOf) : avoidIn;
   const bundle = await readBundle(workspaceRoot, { deps, emit, ledgerFile, today });
+  // the desk builds its question cards from these facts while the model works
+  try { onBundle(bundle); } catch { /* the desk's copy is a convenience */ }
   const run = deps.runModel || runModel;
   // tests pass runSkeptic; a stubbed runModel without one is also used for the
   // skeptic, so a test can never reach the real model by accident
@@ -1277,8 +1825,8 @@ async function generateBet({ workspaceRoot, today, previousTitle = null, avoidTi
     // a blocked idea is not shown again as a patch
     const avoid = [...avoidTitles, ...blocked];
     const prompt = strategy === 'blocker'
-      ? buildPrompt(bundle, { today, previousTitle, blocker, avoidTitles: avoid })
-      : buildPrompt(bundle, { today, previousTitle, reason, previousAnswer, avoidTitles: avoid });
+      ? buildPrompt(bundle, { today, previousTitle, blocker, avoidTitles: avoid, reworkOf, ownerNote })
+      : buildPrompt(bundle, { today, previousTitle, reason, previousAnswer, avoidTitles: avoid, reworkOf, ownerNote });
     let r = await ask(prompt, attempt, strategy, avoid);
     if (r.failed) return { ok: false, reason: r.failed, bundle };
     save(r);
@@ -1406,6 +1954,38 @@ function missionObjective(bet, { owner = null, betId = null } = {}) {
   ].filter(Boolean).join(' ');
 }
 
+// How long a job may run: the hours its idea says it costs, plus a quarter
+// for slack, from 1 hour to a day, at 12 rounds of work an hour. An idea
+// that names no hours gets the deep tier's 3. Passed as --max-wall and
+// --max-ticks, so a long job is never cut off at the one-hour tier, with
+// --stop-when-done, so the hours are a ceiling and a job done early stops.
+const JOB_SLACK = 1.25;
+const JOB_MIN_HOURS = 1;
+const JOB_MAX_HOURS = 24;
+const JOB_DEFAULT_HOURS = 3;
+const TICKS_PER_HOUR = 12;
+
+// a number as written: 5, 2.5, .5, or 1,000, never a tail of a longer one
+const NUM = '(?<![\\d.,])((?:\\d{1,3}(?:,\\d{3})+|\\d+)(?:\\.\\d+)?|\\.\\d+)';
+const numberOf = text => Number(String(text).replace(/,/g, ''));
+
+function costHours(cost) {
+  const t = String(cost || '').toLowerCase();
+  const range = new RegExp(`${NUM}\\s*(?:-|to)\\s*${NUM}\\s*(?:hours?|hrs?)\\b`).exec(t);
+  if (range) return numberOf(range[2]);
+  const hours = new RegExp(`${NUM}\\s*(?:hours?|hrs?)\\b`).exec(t);
+  if (hours) return numberOf(hours[1]);
+  const minutes = new RegExp(`${NUM}\\s*(?:minutes?|mins?)\\b`).exec(t);
+  if (minutes) return numberOf(minutes[1]) / 60;
+  return null;
+}
+
+function jobTime(bet) {
+  const hours = costHours(bet && bet.cost);
+  const wall = hours ? Math.min(JOB_MAX_HOURS, Math.max(JOB_MIN_HOURS, hours * JOB_SLACK)) : JOB_DEFAULT_HOURS;
+  return { seconds: Math.round(wall * 3600), ticks: Math.ceil(wall * TICKS_PER_HOUR) };
+}
+
 const MISSION_VERIFY = 'git diff --check';
 const MISSION_STOP = 'every team step is done with proof, and every your-yes step was asked, not done';
 
@@ -1414,11 +1994,15 @@ const MISSION_STOP = 'every team step is done with proof, and every your-yes ste
 function missionStartArgs(bet, { owner, lane }, betId = null) {
   // the owner steps are sealed into the mission record at start
   const seal = require('./yes-lock').sealFor(bet.steps);
-  return ['mission', 'start', missionObjective(bet, { owner, betId }), '--owner', owner, '--runner', 'claude', '--lane', lane, '--verify', bet.verify || MISSION_VERIFY, '--stop', MISSION_STOP, '--budget', 'long', ...(seal.length ? ['--yes-lock', JSON.stringify(seal)] : []), '--json'];
+  const time = jobTime(bet);
+  return ['mission', 'start', missionObjective(bet, { owner, betId }), '--owner', owner, '--runner', 'claude', '--lane', lane, '--verify', bet.verify || MISSION_VERIFY, '--stop', MISSION_STOP, '--max-wall', String(time.seconds), '--max-ticks', String(time.ticks), '--stop-when-done', ...(seal.length ? ['--yes-lock', JSON.stringify(seal)] : []), '--json'];
 }
 
-function missionRunArgs(missionId) {
-  return ['mission', 'run', missionId, '--detach', '--json'];
+// the run gets the same time as the start, so the detached driver never
+// falls back to the one-hour default
+function missionRunArgs(missionId, bet) {
+  const time = jobTime(bet);
+  return ['mission', 'run', missionId, '--max-wall', String(time.seconds), '--max-ticks', String(time.ticks), '--stop-when-done', '--detach', '--json'];
 }
 
 function yesPingArgs(missionId, step) {
@@ -1452,6 +2036,8 @@ function makeCliRunner({ cliPath, cwd, env = process.env, timeoutMs = 60000 }) {
 
 const JOB_POLL_MS = 25000;
 const OPEN_MISSION = new Set(['planning', 'running', 'ready', 'paused', 'blocked']);
+// an open mission that has not moved in this long is not working
+const STALL_MS = 2 * 60 * 60 * 1000;
 
 // Every mission in this workspace, read-only, through the same reader the
 // mission command uses (it only reads .atris/state/missions.jsonl).
@@ -1470,6 +2056,39 @@ function defaultReadReceipt(mission, workspaceRoot) {
   }
 }
 
+// "14 hours", "3 days": how long a stalled job has been still
+function agoWords(ms) {
+  const h = Math.max(1, Math.round(ms / 3600000));
+  return h < 48 ? `${h} hours` : `${Math.round(h / 24)} days`;
+}
+
+// "oct 21": a day the way the owner says it
+const MONTH_NAMES = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
+function monthDay(at) {
+  const d = new Date(at);
+  return `${MONTH_NAMES[d.getMonth()]} ${d.getDate()}`;
+}
+
+// "10 minutes", "2 hours", "3 days": a plain span of time
+function spanWords(ms) {
+  const m = Math.max(0, Math.round(ms / 60000));
+  if (m < 1) return 'less than a minute';
+  if (m < 60) return `${m} ${m === 1 ? 'minute' : 'minutes'}`;
+  const h = Math.round(m / 60);
+  if (h < 48) return `${h} ${h === 1 ? 'hour' : 'hours'}`;
+  return `${Math.round(h / 24)} days`;
+}
+
+// "about 4 hours left", "about 20 minutes left"
+function leftWords(ms) {
+  const hours = ms / 3600000;
+  if (hours >= 1) { const h = Math.round(hours); return `about ${h} ${h === 1 ? 'hour' : 'hours'} left`; }
+  return `about ${Math.max(5, Math.round(ms / 300000) * 5)} minutes left`;
+}
+
+// a job whose run hit its wall or its last round, as the mission records it
+const OUT_OF_TIME = /wall-exceeded|max-ticks-reached/;
+
 function ageLabel(ms) {
   const m = Math.max(0, Math.floor(ms / 60000));
   if (m < 1) return 'just started';
@@ -1480,9 +2099,10 @@ function ageLabel(ms) {
 }
 
 // One started bet and its mission, as the deck sees it:
-//   working  the mission is open and asks nothing of the owner
+//   working  the mission is open, asks nothing of the owner, and moved in the last 2 hours
 //   yes      the mission has open asks for the owner (one card per ask)
-//   done     the mission finished (complete) or halted (stopped)
+//   done     the mission finished (complete) or halted (stopped), or it is
+//            open but has not moved in over 2 hours (stalled, a halt)
 //   gone     no such mission here (it is not counted as working)
 // done carries what changed, the proof, and the check, only as the receipt
 // says them; with no receipt it says so.
@@ -1495,6 +2115,9 @@ function jobState(row, mission, receipt, nowMs) {
     .map((ask, index) => ({ index, text: String(typeof ask === 'string' ? ask : (ask && ask.text) || '').trim(), answered: Boolean(ask && typeof ask === 'object' && ask.answered_at) }))
     .filter(a => a.text && !a.answered);
   const status = String(mission.status || '');
+  const outOfTime = OUT_OF_TIME.test([mission.last_tick_reason, mission.pause_reason, mission.stop_reason].join(' '));
+  // a round that left a receipt made progress
+  const progress = Boolean(mission.receipt_path);
   if (status === 'complete' || status === 'stopped') {
     const result = receipt && receipt.result && typeof receipt.result === 'object' ? receipt.result : null;
     const landing = result && result.landing && typeof result.landing === 'object' ? result.landing : null;
@@ -1512,13 +2135,43 @@ function jobState(row, mission, receipt, nowMs) {
       changed,
       proof: receipt ? (mission.receipt_path || null) : null,
       checked,
-      // a check that failed, or a halt nothing proved, goes back to the team on request
+      // a check that failed, or a halt nothing proved, goes back to the team on its own
       failed: checked === 'failed' || (stopped && checked !== 'passed'),
+      out_of_time: stopped && outOfTime,
+      progress,
     };
   }
   const base = { bet_id: row.id, mission_id: mission.id, title, owner, since, running_for: since ? ageLabel(nowMs - since) : null, status };
   if (asks.length) return { ...base, kind: 'yes', asks };
-  return { ...base, kind: OPEN_MISSION.has(status) ? 'working' : 'gone' };
+  if (!OPEN_MISSION.has(status)) return { ...base, kind: 'gone' };
+  // paused because its time or its rounds ran out: it goes on now, no two-hour wait
+  if (status === 'paused' && OUT_OF_TIME.test(String(mission.pause_reason || ''))) {
+    return { kind: 'done', bet_id: row.id, mission_id: mission.id, title, owner, halted: true, stop_reason: 'it ran out of time', changed: null, proof: mission.receipt_path || null, checked: 'none', failed: true, out_of_time: true, progress };
+  }
+  // the newest of its last tick and its last update is when it last moved
+  const moved = Math.max(...[mission.last_tick_at, mission.updated_at, mission.created_at].map(t => Date.parse(t || '') || 0));
+  if (moved && nowMs - moved > STALL_MS) {
+    return {
+      kind: 'done',
+      bet_id: row.id,
+      mission_id: mission.id,
+      title,
+      owner,
+      halted: true,
+      stalled: true,
+      stop_reason: `stopped moving ${agoWords(nowMs - moved)} ago, nothing finished`,
+      changed: null,
+      // the last tick's receipt, when there is one; a stalled job never reached its final check
+      proof: mission.receipt_path || null,
+      checked: 'none',
+      failed: true,
+      out_of_time: outOfTime,
+      progress,
+    };
+  }
+  const wall = Number(mission.max_wall_seconds) || Number(mission.budget_contract && mission.budget_contract.requested_seconds) || 0;
+  const leftMs = wall && since ? since + wall * 1000 - nowMs : 0;
+  return { ...base, kind: 'working', ...(leftMs > 0 ? { left: leftWords(leftMs) } : {}) };
 }
 
 // Who reviews finished work: the lead of the roster's review job (atris
@@ -1575,18 +2228,37 @@ function currentMember(betId, owner, handoffs) {
   return hits.length ? hits[hits.length - 1].to : owner;
 }
 
-// Plain lines for a done card: what changed, the proof, the check.
-function doneLines(job) {
-  const lines = [];
-  if (job.halted) lines.push(job.stop_reason ? `it stopped: ${job.stop_reason}` : 'it stopped before it finished');
-  lines.push(job.changed || 'it left no receipt, so there is nothing to show for what changed');
-  const r = job.review;
-  return {
-    lines: lines.slice(0, 2),
-    proof: job.proof ? `the receipt is at ${job.proof}` : 'no receipt was saved, so there is no proof yet',
-    check: job.checked === 'passed' ? 'it passed its check' : (job.checked === 'failed' ? 'it did not pass its check' : 'no check ran'),
-    review: !r ? 'not reviewed' : (r.verdict === 'pass' ? `${r.engine} reviewed it: pass. ${r.reason}` : (r.verdict === 'fail' ? `${r.engine} reviewed it: fail. ${r.reason}` : `the review by ${r.engine || 'the reviewer'} could not run: ${r.reason}`)),
-  };
+// a line that ends like a sentence
+function sentence(text) {
+  const t = String(text || '').trim();
+  return t && !/[.!?]$/.test(t) ? `${t}.` : t;
+}
+
+// One short line of why for a choice: the idea's expected result, without
+// "if it works", ending at the first comma after about 40 characters, so it
+// is a whole clause and never cut mid word.
+function choiceWhy(expect) {
+  const first = String(expect || '').trim().split(/\.\s/)[0].replace(/^if it works,\s*/i, '').replace(/[.\s]+$/, '');
+  const cut = first.indexOf(', ', 40);
+  return sentence(cut > 0 ? first.slice(0, cut) : clip(first, 110));
+}
+
+// A business move, not plumbing: its target is a number we can read and
+// not one that only measures the team.
+function isBusinessMove(bet) {
+  const metric = bet && bet.target && bet.target.metric;
+  return Boolean(metric && METRICS[metric] && !TEAM_ONLY_METRICS.has(metric));
+}
+
+// What went wrong on the last run, in words for the team's next mission.
+function failWhy(row) {
+  if (row.mission_out_of_time) return 'ran out of time before its check passed; pick up where it left off';
+  if (row.mission_stalled) return row.mission_stop_reason || 'stopped moving, nothing finished';
+  if (row.mission_halted) return `halted: ${row.mission_stop_reason || 'it stopped before it finished'}`;
+  const r = row.review;
+  if (r && r.verdict === 'fail') return `did not pass: ${String(r.reason || '').replace(/[.\s]+$/, '')}`;
+  if (r && r.verdict === 'could not run') return `could not be looked over: ${String(r.reason || '').replace(/[.\s]+$/, '')}`;
+  return 'did not pass its check';
 }
 
 // Why a bet made under older rules can no longer be shown, or null. Only the
@@ -1600,6 +2272,10 @@ function queuedProblem(bet, team) {
   if (TEAM_ONLY_METRICS.has(metric)) return `its target ${metric} measures team plumbing, not a business move`;
   const vp = verifyProblem(bet.verify);
   if (vp) return vp;
+  for (const k of ['title', 'why_now', 'expect']) {
+    const word = ownerWord(bet[k]);
+    if (word) return `its ${k} uses "${word}", a word the owner never reads`;
+  }
   if (team) {
     const names = new Set(team.map(m => m.name));
     const i = bet.steps.findIndex(st => st && st.who === 'team' && !(typeof st.member === 'string' && names.has(st.member)));
@@ -1617,8 +2293,10 @@ const MAX_IN_FLIGHT = 1;
 const SESSION_IN_FLIGHT_CAP = 3;
 const STALE_MS = 6 * 60 * 60 * 1000;
 const RECENT_TITLES = 20;
-// two failed background generations in a row stop the prefetch until the next tap
+// two failed background generations in a row pause the prefetch, and a timer
+// tries again after 10 minutes
 const MAX_BACKGROUND_FAILURES = 2;
+const BACKOFF_MS = 10 * 60 * 1000;
 
 // deps:
 //   workspaceRoot, ledgerFile, attemptsFile   where
@@ -1627,10 +2305,39 @@ const MAX_BACKGROUND_FAILURES = 2;
 //   log(row)                                  receipt row for gm-phone-actions.jsonl
 //   now()                                     clock
 //   readMissions(root), readReceipt(m, root)  mission state, read-only (tests stub)
-//   pollMs                                    how often to read job status (off when unset)
+//   pollMs                                    how often to read job status and top up the queue (off when unset)
+//   warmOnCreate                              start filling the queue at once (default on)
+//   setTimer(fn, ms)                          the backoff timer (tests stub; unref'd by default)
+//   readBundle()                              -> Promise<bundle>, the facts for question cards when no generation reads them
+//   choices                                   2 or more ideas ready show as one card to pick from (default on)
+//   driverAlive(mission)                      is a process really running this mission (tests stub)
+//   scoreboard                                ask for the owner's number and its weekly value (gm phone turns it on)
+//   suggestScoreboard(opts)                   -> { ok, choices }, the numbers to offer (tests stub)
+//   readSaid(opts)                            -> { ok, kind, reply, suggestions }, what the owner typed (tests stub)
+//   sayTimeoutMs                              how long a read may take before the plain fallback (15 s)
 function createBetDesk(deps) {
   const now = deps.now || Date.now;
-  const generate = deps.generate || (opts => generateBet({ ...opts, deps: deps.generatorDeps || {}, ledgerFile: deps.ledgerFile, attemptsFile: deps.attemptsFile }));
+  const setTimer = deps.setTimer || ((fn, ms) => { const t = setTimeout(fn, ms); if (t.unref) t.unref(); return t; });
+  // is a process really running this mission: its driver's pid is alive
+  const driverAlive = deps.driverAlive || ((m) => {
+    try { return require(path.join(__dirname, '..', 'commands', 'mission.js')).missionDriverHealth(m, deps.workspaceRoot).alive === true; } catch { return false; }
+  });
+  const focusFile = focusPath(path.dirname(deps.ledgerFile));
+  const questionsFile = questionsPath(path.dirname(deps.ledgerFile));
+  const scoreboardFile = scoreboardPath(path.dirname(deps.ledgerFile));
+  // a desk with a stubbed idea writer never reaches the real reader either
+  const readFn = deps.readSaid || (deps.generate
+    ? (async () => ({ ok: false, reason: 'no reader here' }))
+    : (opts => readSaid({ ...opts, workspaceRoot: deps.workspaceRoot, bundle: state.bundle, deps: deps.generatorDeps || {} })));
+  const suggestNumbers = deps.suggestScoreboard || (deps.generate
+    ? (() => new Promise(() => {}))
+    : (opts => generateScoreboardChoices({ ...opts, deps: deps.generatorDeps || {}, ledgerFile: deps.ledgerFile, today: dayKey(now()) })));
+  // a desk with a stubbed idea writer never reaches the real question model
+  const writeQuestion = deps.generateQuestion || (deps.generate
+    ? (() => new Promise(() => {}))
+    : (opts => generateQuestion({ ...opts, deps: deps.generatorDeps || {}, ledgerFile: deps.ledgerFile, today: dayKey(now()) })));
+  // the real writer starts on the next turn, so its first reads never hold up a tap
+  const generate = deps.generate || (opts => new Promise(resolve => setImmediate(resolve)).then(() => generateBet({ ...opts, deps: deps.generatorDeps || {}, ledgerFile: deps.ledgerFile, attemptsFile: deps.attemptsFile })));
   const log = deps.log || (() => {});
   const state = {
     status: 'idle',
@@ -1639,13 +2346,28 @@ function createBetDesk(deps) {
     inFlight: 0,
     maxInFlight: 0,
     gen: null,
-    waiting: null,
+    // a sharper idea asked for, made in the background like any other
     pendingSharper: null,
     topping: false,
     failures: 0,
+    backoffUntil: 0,
+    retry: null,
+    // the last bundle a generation read, for the question cards
+    bundle: deps.bundle || null,
+    // questions passed over this session, so a re-tap asks the next one
+    passedQuestions: new Set(),
+    // the question writer: one at a time, resting after failures like the idea writer
+    qInFlight: null,
+    // the numbers the model suggests for the scoreboard question
+    suggestions: null,
+    // the conversation on the card or member talk on screen: { id, turns }
+    thread: { id: null, turns: [] },
+    sInFlight: null,
+    qFailures: 0,
+    qBackoffUntil: 0,
+    qRetry: null,
     run: 0,
     error: null,
-    lastFailed: null,
     mission: null,
     started: [],
     // the started bets' missions as of the last read: working ones, and open
@@ -1655,6 +2377,8 @@ function createBetDesk(deps) {
     seenYes: new Set(),
     // reviews running now, by bet id
     reviews: new Map(),
+    // failed jobs being sent back to the team now, by bet id
+    retrying: new Map(),
   };
 
   const iso = () => new Date(now()).toISOString();
@@ -1758,21 +2482,34 @@ function createBetDesk(deps) {
       const finished = mission && (mission.status === 'complete' || mission.status === 'stopped');
       const receipt = finished ? (deps.readReceipt || defaultReadReceipt)(mission, deps.workspaceRoot) : null;
       const job = jobState(row, mission, receipt, now());
+      // its process is alive (a laptop that slept makes the times look old): working, never resent
+      if (job.kind === 'done' && (job.failed || job.halted) && driverAlive(mission)) {
+        working.push({ kind: 'working', bet_id: row.id, mission_id: mission.id, title: job.title, owner: currentMember(row.id, job.owner, handoffs()) });
+        continue;
+      }
+      // still because the guard holds a step for the owner's yes: that is a yes card, not a halt
+      const held = job.stalled ? require('./yes-lock').askedYesLocks(lockDir, mission.id) : [];
+      if (held.length) {
+        for (const lock of held) yes.push({ ...job, kind: 'yes', ask: lock.text, command: lock.held_command || null, lock_step: lock.step, ask_index: null, key: `${mission.id}:step-${lock.step}` });
+        continue;
+      }
       // finished with nothing failed: the roster's reviewer looks before it counts as done
       if (job.kind === 'done' && !job.failed && !job.halted) {
-        const engine = reviewerName();
-        startReview(row, job, engine);
-        working.push({ ...job, kind: 'working', owner: `${engine || 'the reviewer'} (reviewing)`, running_for: null });
+        startReview(row, job, reviewerName());
+        working.push({ ...job, kind: 'working', owner: currentMember(row.id, job.owner, handoffs()) });
         continue;
       }
       if (job.kind === 'done') {
         record(row.id, {
           mission_result: job.failed ? 'failed' : 'done',
-          mission_status: mission.status,
+          mission_status: job.stalled ? 'stalled' : mission.status,
           mission_checked: job.checked,
           mission_changed: job.changed,
           mission_proof: job.proof,
           mission_halted: job.halted,
+          mission_stalled: Boolean(job.stalled),
+          mission_out_of_time: Boolean(job.out_of_time),
+          mission_progress: Boolean(job.progress),
           mission_stop_reason: job.stop_reason,
           finished_seen_at: iso(),
         });
@@ -1787,12 +2524,53 @@ function createBetDesk(deps) {
         for (const ask of job.asks) yes.push({ ...job, ask_index: ask.index, ask: ask.text, key: `${job.mission_id}:${ask.index}` });
       }
     }
-    state.jobs = { working, yes, at: now() };
+    const expectOf = new Map(readLedger(deps.ledgerFile, deps.workspaceRoot).map(r => [r.id, r.bet && r.bet.expect]));
+    state.jobs = { working, yes: yes.map(y => ({ ...y, expect: expectOf.get(y.bet_id) || null })), at: now() };
+    retryFailed();
     return state.jobs;
   }
 
+  // A job that halted, stalled, or did not pass is never a card: it goes back
+  // to the team once on its own, and the second time it is closed quietly
+  // with why. A bet made under older rules (plumbing) is closed at once.
+  function retryFailed() {
+    let missionMap;
+    const missionOf = (id) => {
+      if (missionMap === undefined) {
+        try { missionMap = (deps.readMissions || defaultReadMissions)(deps.workspaceRoot); } catch { missionMap = null; }
+      }
+      return missionMap instanceof Map ? missionMap.get(id) : (missionMap || {})[id];
+    };
+    for (const row of readLedger(deps.ledgerFile, deps.workspaceRoot)) {
+      if (row.mission_result !== 'failed' || row.done_seen_at || state.retrying.has(row.id)) continue;
+      // its process turned out to be alive: it is working, so put it back and never resend it
+      const live = row.mission_id ? missionOf(row.mission_id) : null;
+      if (live && driverAlive(live)) {
+        record(row.id, { mission_result: null, mission_halted: null, mission_stalled: null, mission_out_of_time: null, mission_progress: null, mission_stop_reason: null });
+        log({ card: 'bet', choice: 'still_running', command: null, ran: 'in process', exit_code: 0, bet_id: row.id, mission_id: row.mission_id });
+        continue;
+      }
+      const why = failWhy(row);
+      const problem = row.bet ? queuedProblem(row.bet, team) : 'it is not a whole bet';
+      if (problem) { close(row, problem); continue; }
+      // up to two more rounds while each one makes progress; one with none closes
+      const rounds = Number(row.auto_sent_back) || 0;
+      if (rounds >= 2) { close(row, `${why}, after two more rounds`); continue; }
+      if (rounds === 1 && !row.mission_progress) { close(row, `${why}, after one try again`); continue; }
+      const run = sendBackJob(row, why)
+        .catch(err => close(row, `it could not go back to the team: ${clip(String((err && err.message) || err), 120)}`))
+        .finally(() => state.retrying.delete(row.id));
+      state.retrying.set(row.id, run);
+    }
+  }
+
+  function close(row, reason) {
+    record(row.id, { mission_result: 'closed', closed_reason: reason, closed_at: iso(), done_seen_at: iso() });
+    log({ card: 'bet', choice: 'close', command: null, ran: 'in process', exit_code: 0, bet_id: row.id, mission_id: row.mission_id, why: reason });
+  }
+
   // One review per finished job at a time. A pass makes it done; a fail makes
-  // it failed (send back is offered); a review that cannot run is tried again
+  // it failed (it goes back to the team on its own); a review that cannot run is tried again
   // on the next read, and after REVIEW_TRIES it counts as failed with why.
   function startReview(row, job, engine) {
     if (state.reviews.has(row.id)) return;
@@ -1811,29 +2589,20 @@ function createBetDesk(deps) {
       const v = res.code === 0 ? reviewVerdict(res.stdout) : null;
       if (!v) return gaveUp(res.code === 0 ? 'the reviewer gave no pass or fail' : `the review exited with code ${res.code}`);
       return finish({ mission_result: v.verdict === 'pass' ? 'done' : 'failed', review: { engine, ...v }, review_tries: tries });
-    }).catch(err => gaveUp(String((err && err.message) || err))).finally(() => state.reviews.delete(row.id));
+    }).catch(err => gaveUp(String((err && err.message) || err))).finally(() => {
+      state.reviews.delete(row.id);
+      // a fail goes back to the team now, not on the next read
+      retryFailed();
+    });
     state.reviews.set(row.id, run);
   }
 
-  // Finished jobs not yet seen, from the ledger, so they survive a restart.
+  // Finished business moves not yet seen, from the ledger, so they survive a
+  // restart. Plumbing and failed work never become a card.
   function doneJobs() {
     return readLedger(deps.ledgerFile, deps.workspaceRoot)
-      .filter(row => (row.mission_result === 'done' || row.mission_result === 'failed') && !row.done_seen_at)
-      .map(row => ({
-        kind: 'done',
-        bet_id: row.id,
-        mission_id: row.mission_id,
-        title: (row.bet && row.bet.title) || row.id,
-        owner: row.owner || 'the team',
-        halted: Boolean(row.mission_halted),
-        stop_reason: row.mission_stop_reason || null,
-        changed: row.mission_changed || null,
-        proof: row.mission_proof || null,
-        checked: row.mission_checked || 'none',
-        failed: row.mission_result === 'failed',
-        review: row.review || null,
-        bet: row.bet,
-      }));
+      .filter(row => row.mission_result === 'done' && !row.done_seen_at && isBusinessMove(row.bet))
+      .map(row => ({ kind: 'done', bet_id: row.id, mission_id: row.mission_id, title: row.bet.title, owner: row.owner || 'the team', bet: row.bet }));
   }
 
   // The next card that is not a bet: a yes the owner owes comes first, then
@@ -1854,20 +2623,231 @@ function createBetDesk(deps) {
     log({ card: 'bet', choice: 'show', command: null, ran: 'in process', exit_code: 0, kind: item.kind, bet_id: item.job.bet_id });
   }
 
+  // ---- the scoreboard: the owner's own number ----
+
+  const SCOREBOARD_ASK = 'what number tells you this is going well?';
+  // questions kept here, not in the questions file
+  const LOCAL_QUESTIONS = new Set([FALLBACK_QUESTION.key, 'scoreboard']);
+  const LOWER_IS_BETTER = /\b(fewer|less|lower|reduce|down|churn|bugs?|costs?|spend|refunds?|complaints?)\b/i;
+  const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+
+  function fallbackNumbers() {
+    const list = [];
+    if (state.bundle && state.bundle.sources && state.bundle.sources.installs) list.push({ name: 'installs each week', up: true });
+    list.push({ name: 'people who used it this week', up: true }, { name: 'money that came in this month', up: true });
+    return list.slice(0, 3);
+  }
+
+  // the model's suggestions, written once in the background while none is saved
+  function pumpSuggestions() {
+    if (!deps.scoreboard || state.suggestions || state.sInFlight || readScoreboard(scoreboardFile, deps.workspaceRoot)) return;
+    state.sInFlight = Promise.resolve()
+      .then(() => suggestNumbers({ workspaceRoot: deps.workspaceRoot, bundle: state.bundle }))
+      .catch(err => ({ ok: false, reason: String((err && err.message) || err) }))
+      .then((out) => {
+        if (out && out.ok && Array.isArray(out.choices)) state.suggestions = out.choices;
+        else log({ card: 'bet', choice: 'scoreboard', command: null, ran: 'in process', exit_code: 1, error: clip((out && out.reason) || 'no numbers', 160) });
+      });
+  }
+
+  // The card the owner owes before any idea: which number to watch, while
+  // none is saved; then, for a number nobody can read on its own, its value
+  // once a week, and whenever an idea is waiting on it to be scored.
+  function askCard() {
+    if (!deps.scoreboard) return null;
+    const board = readScoreboard(scoreboardFile, deps.workspaceRoot);
+    if (!board) {
+      if (state.passedQuestions.has('scoreboard')) return null;
+      const list = (state.suggestions || fallbackNumbers()).slice(0, 3);
+      return {
+        kind: 'question',
+        id: 'question:scoreboard',
+        question: { key: 'scoreboard', ask: SCOREBOARD_ASK, line: null, choices: [...list.map((c, i) => ({ id: `s${i + 1}`, label: c.name })), { id: 'other', label: 'something else', other: true }], numbers: list },
+      };
+    }
+    if (board.source !== 'reported' || state.passedQuestions.has('report')) return null;
+    const last = board.reports[board.reports.length - 1] || null;
+    const weekly = !last || now() - (Date.parse(last.at) || 0) >= WEEK_MS;
+    const today = dayKey(now());
+    const waiting = readLedger(deps.ledgerFile, deps.workspaceRoot).some(r => r.status === 'doing' && r.bet && r.bet.target && r.bet.target.metric === 'scoreboard'
+      && String(r.bet.check_date || '') < today && !board.reports.some(x => String(x.at).slice(0, 10) >= r.bet.check_date));
+    if (!weekly && !waiting) return null;
+    return { kind: 'report', id: `report:${today}`, board, last };
+  }
+
+  function showAsk(item) {
+    if (item.kind === 'question') { showQuestion(item); return; }
+    state.current = item;
+    state.status = 'ready';
+    state.mission = null;
+    state.error = null;
+    log({ card: 'bet', choice: 'show', command: null, ran: 'in process', exit_code: 0, kind: 'report' });
+  }
+
+  // the number for the card on screen, saved beside the ledger
+  function report({ value } = {}) {
+    const item = onJob('report');
+    if (!item) return { ok: false, reason: 'gone', message: 'there is no number asked for on screen' };
+    const raw = String(value == null ? '' : value).replace(/,/g, '').trim();
+    const v = Number(raw);
+    if (!raw || !Number.isFinite(v)) return { ok: false, reason: 'bad_number', message: 'that is not a number' };
+    appendLedger(scoreboardFile, { workspace: deps.workspaceRoot, kind: 'report', value: v, at: iso() });
+    log({ card: 'bet', choice: 'report', command: null, ran: 'in process', exit_code: 0 });
+    state.status = 'cleared';
+    return { ok: true, ack: `saved: ${commas(v)}.` };
+  }
+
+  // The questions written ahead, oldest first, not yet shown.
+  function readyQuestions() {
+    return readLedger(questionsFile, deps.workspaceRoot).filter(r => r.status === 'ready' && r.question);
+  }
+
+  const answerCount = () => Object.keys(readFocus(focusFile, deps.workspaceRoot)).length;
+
+  // Every answer so far, oldest first, for both writers.
+  function answersSoFar() {
+    return Object.values(readFocus(focusFile, deps.workspaceRoot))
+      .sort((a, b) => String(a.at).localeCompare(String(b.at)))
+      .slice(-12)
+      .map(a => ({ ask: a.ask, label: a.label }));
+  }
+
+  // Keeps QUESTIONS_READY questions written ahead, one writer at a time.
+  // After MAX_BACKGROUND_FAILURES in a row it rests for BACKOFF_MS.
+  function pumpQuestions() {
+    if (state.qInFlight) return state.qInFlight;
+    if (readyQuestions().length >= QUESTIONS_READY) return null;
+    if (state.qFailures >= MAX_BACKGROUND_FAILURES) {
+      if (now() < state.qBackoffUntil) return null;
+      state.qFailures = 0;
+    }
+    const avoid = readLedger(questionsFile, deps.workspaceRoot).slice(-20).map(r => r.question && r.question.ask).filter(Boolean);
+    const opts = { workspaceRoot: deps.workspaceRoot, answers: answersSoFar(), avoid, bundle: state.bundle };
+    const seen = answerCount();
+    const run = Promise.resolve()
+      .then(() => writeQuestion(opts))
+      .catch(err => ({ ok: false, reason: String((err && err.message) || err) }))
+      .then((out) => {
+        state.qInFlight = null;
+        // written before the newest answer while another is ready: write it again, knowing the answer
+        if (out && out.ok && seen < answerCount() && readyQuestions().length >= 1) {
+          log({ card: 'bet', choice: 'question', command: null, ran: 'in process', exit_code: 0, stale: 'written before the newest answer' });
+          return pumpQuestions();
+        }
+        if (out && out.ok) {
+          state.qFailures = 0;
+          const id = `q-${dayKey(now())}-${crypto.randomBytes(4).toString('hex')}`;
+          appendLedger(questionsFile, { id, workspace: deps.workspaceRoot, created_at: iso(), status: 'ready', answers_seen: seen, question: out.question });
+          log({ card: 'bet', choice: 'question', command: null, ran: 'in process', exit_code: 0, question: id });
+        } else {
+          state.qFailures += 1;
+          log({ card: 'bet', choice: 'question', command: null, ran: 'in process', exit_code: 1, error: clip((out && out.reason) || 'no question', 200) });
+          if (state.qFailures >= MAX_BACKGROUND_FAILURES) {
+            state.qBackoffUntil = now() + BACKOFF_MS;
+            if (!state.qRetry) state.qRetry = setTimer(() => { state.qRetry = null; pumpQuestions(); }, BACKOFF_MS);
+            return null;
+          }
+        }
+        return pumpQuestions();
+      });
+    state.qInFlight = run;
+    return run;
+  }
+
+  // A question when no idea is ready: the next one written ahead from this
+  // project, else the one generic question if it was not answered this week;
+  // null when there is none to ask.
+  function nextQuestion() {
+    const row = readyQuestions().find(r => !state.passedQuestions.has(r.id));
+    if (row) {
+      const q = row.question;
+      return { kind: 'question', id: `question:${row.id}`, question: { key: row.id, ask: q.ask, line: q.fact, choices: q.choices.map((label, i) => ({ id: `a${i + 1}`, label })) } };
+    }
+    const F = FALLBACK_QUESTION;
+    const said = readFocus(focusFile, deps.workspaceRoot)[F.key];
+    if (state.passedQuestions.has(F.key) || (said && now() - (Date.parse(said.at) || 0) < FOCUS_FRESH_MS)) return null;
+    return { kind: 'question', id: `question:${F.key}`, question: { key: F.key, ask: F.ask, line: installsLine(state.bundle), choices: F.choices.map(c => ({ ...c })) } };
+  }
+
+  // Two or three ideas ready: one card to pick from. Each is shown, so each
+  // is recorded as proposed; the ones not picked are passed.
+  const CHOICE_MAX = 3;
+  function showChoice(items) {
+    state.current = { kind: 'choice', id: `choice:${items.map(i => i.id).join(',')}`, items };
+    state.status = 'ready';
+    state.mission = null;
+    state.error = null;
+    for (const item of items) record(item.id, { status: 'proposed', shown_at: iso() });
+    log({ card: 'bet', choice: 'show', command: null, ran: 'in process', exit_code: 0, kind: 'choice', bet_ids: items.map(i => i.id) });
+  }
+
+  // one tap on a choice: that idea's full card, with do it as before
+  function pick({ id } = {}) {
+    const cur = onJob('choice');
+    const item = cur && cur.items.find(i => i.id === id);
+    if (!item) return { ok: false, reason: 'gone', message: 'there is nothing to pick on screen' };
+    for (const other of cur.items) if (other !== item) record(other.id, { status: 'passed', note: 'not picked' });
+    log({ card: 'bet', choice: 'pick', command: null, ran: 'in process', exit_code: 0, bet_id: item.id });
+    state.current = item;
+    state.status = 'ready';
+    return { ok: true, ...view() };
+  }
+
+  // nothing ready and nothing left to ask: one plain card, shown at once
+  const WAIT_CARD = { what: 'the next idea is being written.', why: 'tap the orb again in a minute to see it.' };
+  function showWait() {
+    state.current = { kind: 'wait', id: `wait:${now()}` };
+    state.status = 'ready';
+    state.mission = null;
+    state.error = null;
+    log({ card: 'bet', choice: 'show', command: null, ran: 'in process', exit_code: 0, kind: 'wait' });
+  }
+
+  function showQuestion(item) {
+    if (!LOCAL_QUESTIONS.has(item.question.key)) appendLedger(questionsFile, { id: item.question.key, workspace: deps.workspaceRoot, status: 'shown', shown_at: iso() });
+    state.current = item;
+    state.status = 'ready';
+    state.mission = null;
+    state.error = null;
+    log({ card: 'bet', choice: 'show', command: null, ran: 'in process', exit_code: 0, kind: 'question', question: item.question.key });
+  }
+
   // a re-tap on a job card moves on: a yes waits for a later session, a done is seen
   function passJob(item) {
+    if (item.kind === 'wait') return;
+    if (item.kind === 'report') { state.passedQuestions.add('report'); return; }
+    if (item.kind === 'choice') {
+      for (const i of item.items) record(i.id, { status: 'passed', note: 'not picked' });
+      log({ card: 'bet', choice: 'pass', command: null, ran: 'in process', exit_code: 0, kind: 'choice' });
+      return;
+    }
+    if (item.kind === 'question') {
+      state.passedQuestions.add(item.question.key);
+      if (!LOCAL_QUESTIONS.has(item.question.key)) appendLedger(questionsFile, { id: item.question.key, workspace: deps.workspaceRoot, status: 'passed' });
+      log({ card: 'bet', choice: 'pass', command: null, ran: 'in process', exit_code: 0, kind: 'question', question: item.question.key });
+      return;
+    }
     if (item.kind === 'yes') state.seenYes.add(item.job.key);
     if (item.kind === 'done') record(item.job.bet_id, { done_seen_at: iso() });
     log({ card: 'bet', choice: 'pass', command: null, ran: 'in process', exit_code: 0, kind: item.kind, bet_id: item.job.bet_id });
   }
 
   pollJobs();
+  // the same read also tops up the queue, so it stays full with no page open
   if (deps.pollMs) {
-    const timer = setInterval(pollJobs, deps.pollMs);
+    const timer = setInterval(() => { pollJobs(); pump(); }, deps.pollMs);
     if (timer.unref) timer.unref();
   }
 
-  function startGeneration({ sharperOf = null } = {}) {
+  // after MAX_BACKGROUND_FAILURES in a row the prefetch rests, and one timer
+  // tries again; a tap in the meantime still gets a card at once
+  function backOff() {
+    state.backoffUntil = now() + BACKOFF_MS;
+    if (state.retry) return;
+    state.retry = setTimer(() => { state.retry = null; pump(); }, BACKOFF_MS);
+  }
+
+  function startGeneration({ sharperOf = null, reworkOf = null, ownerNote = null } = {}) {
     if (state.inFlight >= MAX_IN_FLIGHT || state.inFlight >= SESSION_IN_FLIGHT_CAP) return null;
     state.inFlight += 1;
     state.maxInFlight = Math.max(state.maxInFlight, state.inFlight);
@@ -1878,7 +2858,7 @@ function createBetDesk(deps) {
     // started now, not on a later tick, so the in-flight count is exact
     let started;
     try {
-      started = Promise.resolve(generate({ workspaceRoot: deps.workspaceRoot, today: dayKey(now()), previousTitle: sharperOf, avoidTitles: avoidTitles(), emit }));
+      started = Promise.resolve(generate({ workspaceRoot: deps.workspaceRoot, today: dayKey(now()), previousTitle: sharperOf, avoidTitles: avoidTitles(), ...(ownerNote ? { reworkOf, ownerNote } : {}), emit, onBundle: (b) => { state.bundle = b; } }));
     } catch (err) {
       started = Promise.reject(err);
     }
@@ -1887,54 +2867,48 @@ function createBetDesk(deps) {
       .then((out) => {
         state.inFlight -= 1;
         if (state.gen === gen) state.gen = null;
-        const waited = state.waiting === gen;
+        if (out.bundle) state.bundle = out.bundle;
         if (!out.ok) {
+          // a failure stays in the log; the owner never waits on it or sees it
           log({ card: 'bet', choice: 'generate', command: null, ran: 'in process', exit_code: 1, error: clip(out.reason, 200) });
           emit({ kind: 'failed', line: out.reason });
-          if (waited) {
-            state.waiting = null;
-            state.lastFailed = gen.events;
-            state.status = 'failed';
-            state.error = out.reason;
-          } else {
-            state.failures += 1;
-          }
+          state.failures += 1;
+          if (state.failures >= MAX_BACKGROUND_FAILURES) backOff();
           return pump();
         }
         state.failures = 0;
         const item = { id: newId(), bet: out.bet, created_at: now() };
-        record(item.id, { created_at: iso(), status: 'queued', bet: out.bet, previous_title: sharperOf });
+        record(item.id, { created_at: iso(), status: 'queued', bet: out.bet, previous_title: sharperOf, ...(ownerNote ? { rework_of: reworkOf, owner_note: ownerNote } : {}) });
         log({ card: 'bet', choice: 'generate', command: null, ran: 'in process', exit_code: 0, bet_id: item.id });
         emit({ kind: 'done', line: 'bet ready' });
-        if (waited) {
-          state.waiting = null;
-          show(item);
-        } else {
-          state.queue.push(item);
-        }
+        // the sharper or reworked idea the owner asked for is the next shown
+        if (sharperOf || ownerNote) state.queue.unshift(item);
+        else state.queue.push(item);
         return pump();
       });
     return gen;
   }
 
   // Keeps the queue topped up: below 2 it refills to 3, one generation at a
-  // time. A tap that is waiting, or a sharper idea, goes first.
+  // time. A sharper idea the owner asked for goes first.
   function pump() {
+    pumpQuestions();
+    pumpSuggestions();
     dropStale();
     if (state.inFlight >= MAX_IN_FLIGHT) return state.gen && state.gen.done;
-    if (state.pendingSharper && state.status === 'thinking') {
-      const sharperOf = state.pendingSharper;
+    if (state.pendingSharper) {
+      const asked = state.pendingSharper;
       state.pendingSharper = null;
-      state.waiting = startGeneration({ sharperOf });
-      return state.waiting && state.waiting.done;
-    }
-    if (state.status === 'thinking' && !state.waiting) {
-      state.waiting = startGeneration();
-      return state.waiting && state.waiting.done;
+      const gen = startGeneration(asked);
+      return gen && gen.done;
     }
     if (state.queue.length < REFILL_BELOW) state.topping = true;
     if (state.queue.length >= QUEUE_TARGET) state.topping = false;
-    if (!state.topping || state.failures >= MAX_BACKGROUND_FAILURES) return null;
+    if (!state.topping) return null;
+    if (state.failures >= MAX_BACKGROUND_FAILURES) {
+      if (now() < state.backoffUntil) return null;
+      state.failures = 0;
+    }
     const gen = startGeneration();
     return gen && gen.done;
   }
@@ -1945,49 +2919,39 @@ function createBetDesk(deps) {
     return view();
   }
 
-  // A tap on the orb: the bet on screen is passed over, the next one in the
-  // queue shows at once, or the page waits on the generation in flight.
+  // A tap on the orb: the card on screen is passed over, and the next one
+  // shows at once: a yes, a finished job, a queued bet, a question, or a
+  // plain card that says the next idea is being written. A tap never waits.
+  // sharper passes the bet over and asks the background for a sharper one.
   function next({ sharper = false } = {}) {
-    if (state.status === 'thinking' || state.status === 'starting') return { ok: true, busy: true, ...view() };
-    state.failures = 0;
+    if (state.status === 'starting') return { ok: true, busy: true, ...view() };
     const onScreen = state.status === 'ready' && state.current ? state.current : null;
     if (onScreen && onScreen.kind && onScreen.kind !== 'bet') {
       passJob(onScreen);
     } else if (onScreen) {
       record(onScreen.id, { status: 'passed', ...(sharper ? { note: 'asked for a sharper idea' } : {}) });
       log({ card: 'bet', choice: sharper ? 'sharper' : 'pass', command: null, ran: 'in process', exit_code: 0, bet_id: onScreen.id });
+      if (sharper) state.pendingSharper = { sharperOf: onScreen.bet.title };
     } else {
       log({ card: 'bet', choice: 'think', command: null, ran: 'in process', exit_code: 0 });
     }
     dropStale();
-    // a yes or a finished job comes before the next bet, never in the middle of one
-    if (!sharper) {
-      if (now() - state.jobs.at > 5000) pollJobs();
-      const job = nextJobCard();
-      if (job) {
-        showJob(job);
-        pump();
-        return { ok: true, ...view() };
+    if (now() - state.jobs.at > 5000) pollJobs();
+    const job = nextJobCard();
+    const ask = job ? null : askCard();
+    if (job) showJob(job);
+    else if (ask) showAsk(ask);
+    else if (deps.choices !== false && state.queue.length >= 2) showChoice(state.queue.splice(0, CHOICE_MAX));
+    else if (state.queue.length) show(state.queue.shift());
+    else {
+      const question = nextQuestion();
+      if (question) showQuestion(question);
+      else {
+        showWait();
+        // the card says an idea is being written, so one is, even mid backoff
+        if (!state.gen) { state.failures = 0; state.backoffUntil = 0; }
       }
     }
-    if (sharper) {
-      state.pendingSharper = onScreen && onScreen.bet ? onScreen.bet.title : null;
-      state.current = null;
-      state.status = 'thinking';
-      state.waiting = null;
-      pump();
-      return { ok: true, ...view() };
-    }
-    if (state.queue.length) {
-      show(state.queue.shift());
-      pump();
-      return { ok: true, ...view() };
-    }
-    state.current = null;
-    state.status = 'thinking';
-    state.error = null;
-    // the generation already running is the one this tap waits on
-    state.waiting = state.gen || null;
     pump();
     return { ok: true, ...view() };
   }
@@ -1995,7 +2959,7 @@ function createBetDesk(deps) {
   const isBet = () => state.status === 'ready' && state.current && (!state.current.kind || state.current.kind === 'bet');
 
   function skip() {
-    if (!isBet()) return { ok: false, reason: 'gone', message: 'there is no bet to skip' };
+    if (!isBet()) return { ok: false, reason: 'gone', message: 'there is no idea on screen to skip' };
     record(state.current.id, { status: 'skipped' });
     log({ card: 'bet', choice: 'skip', command: null, ran: 'in process', exit_code: 0, bet_id: state.current.id });
     state.status = 'skipped';
@@ -2003,7 +2967,7 @@ function createBetDesk(deps) {
   }
 
   async function doIt() {
-    if (!isBet()) return { ok: false, reason: 'gone', message: 'there is no bet to start' };
+    if (!isBet()) return { ok: false, reason: 'gone', message: 'there is no idea on screen to start' };
     const { id, bet } = state.current;
     const pick = pickOwner(bet, deps.workspaceRoot);
     const startArgs = missionStartArgs(bet, pick, id);
@@ -2016,19 +2980,21 @@ function createBetDesk(deps) {
     if (res.code !== 0 || !missionId) {
       state.status = 'ready';
       const why = clip((res.stderr || res.stdout || '').trim().split('\n').pop(), 160);
-      return { ok: false, reason: 'start_failed', message: `the mission did not start${why ? `: ${why}` : ''}` };
+      log({ card: 'bet', choice: 'do', command: null, ran: 'in process', exit_code: res.code, bet_id: id, error: why || null });
+      return { ok: false, reason: 'start_failed', message: 'it did not get going. try again in a minute.' };
     }
     const owner = (started.mission && started.mission.owner) || pick.owner;
     record(id, { status: 'doing', mission_id: missionId, owner });
     lockYesSteps(missionId, id, bet.steps);
-    const runArgs = missionRunArgs(missionId);
+    const runArgs = missionRunArgs(missionId, bet);
     res = await deps.runCli(runArgs);
     log({ card: 'bet', choice: 'do', command: display(runArgs), exit_code: res.code, bet_id: id, mission_id: missionId });
     const ran = parseJsonOut(res.stdout) || {};
     let line;
-    if (res.code === 0 && ran.action === 'mission_run_detached') line = `${owner} has it. the mission is running now.`;
-    else if (ran.reason === 'human_asks_open') line = `${owner} has it, and is waiting on your yes before it starts.`;
-    else line = `${owner} has the mission, but it did not start running (exit code ${res.code}). run it from the mac: atris mission run ${missionId}`;
+    // what the owner reads; the command and exit code stay in the log
+    if (res.code === 0 && ran.action === 'mission_run_detached') line = `${owner} has it and is starting now.`;
+    else if (ran.reason === 'human_asks_open') line = `${owner} has it, and is waiting on your yes before starting.`;
+    else line = `${owner} has it, but has not started yet. it can be started from the mac.`;
     state.status = 'started';
     state.mission = { id: missionId, owner, line, commands: [display(startArgs), display(runArgs)] };
     state.started.push({ bet_id: id, mission_id: missionId, owner, steps: bet.steps, yes: {} });
@@ -2048,35 +3014,67 @@ function createBetDesk(deps) {
     return { ok: true, ack: 'nice.' };
   }
 
-  // send back: a job that did not pass goes to the team again as a new mission
-  // on the same bet, with what went wrong in the objective
-  async function sendBack() {
-    const item = onJob('done');
-    if (!item || !item.job.failed || !item.job.bet) return { ok: false, reason: 'gone', message: 'there is no failed job on screen' };
-    const { job } = item;
-    const why = doneLines(job);
-    const again = { ...job.bet, why_now: `the last run ended with: ${why.check}${job.halted && job.stop_reason ? `, ${job.stop_reason}` : ''}. try again. ${job.bet.why_now}` };
+  // an answer to the question on screen is saved to the focus file, where
+  // the writer reads it for every bet after this one
+  function answer({ choice, text } = {}) {
+    const item = onJob('question');
+    if (!item) return { ok: false, reason: 'gone', message: 'there is no question on screen' };
+    const picked = item.question.choices.find(c => c.id === choice);
+    if (!picked) return { ok: false, reason: 'bad_choice', message: 'that is not one of the answers' };
+    const q = item.question;
+    if (q.key === 'scoreboard') {
+      let name;
+      let up;
+      if (picked.other) {
+        name = String(text || '').trim();
+        if (!name) return { ok: false, reason: 'empty', message: 'say the number in a few words' };
+        if (name.length > 60) return { ok: false, reason: 'too_long', message: 'keep it under 60 characters' };
+        up = !LOWER_IS_BETTER.test(name);
+      } else {
+        const pick = q.numbers[Number(picked.id.slice(1)) - 1];
+        name = pick.name;
+        up = pick.up !== false;
+      }
+      // installs on a workspace with npm numbers are read on their own
+      const source = /\b(installs?|downloads?)\b/i.test(name) && state.bundle && state.bundle.sources && state.bundle.sources.installs ? 'installs' : 'reported';
+      appendLedger(scoreboardFile, { workspace: deps.workspaceRoot, kind: 'pick', name, up, source, at: iso() });
+      log({ card: 'bet', choice: 'scoreboard', command: null, ran: 'in process', exit_code: 0, source });
+      state.status = 'cleared';
+      return { ok: true, ack: `got it: ${name}.` };
+    }
+    appendLedger(focusFile, { workspace: deps.workspaceRoot, key: q.key, answer: picked.id, label: picked.label, ask: q.ask, at: iso() });
+    if (q.key !== FALLBACK_QUESTION.key) appendLedger(questionsFile, { id: q.key, workspace: deps.workspaceRoot, status: 'answered' });
+    log({ card: 'bet', choice: 'answer', command: null, ran: 'in process', exit_code: 0, question: q.key, answer: picked.id });
+    state.status = 'cleared';
+    // the next questions are written knowing this answer: any written before
+    // it are retired, except the oldest, so the next tap is still instant
+    const count = answerCount();
+    readyQuestions().slice(1).filter(r => (Number(r.answers_seen) || 0) < count).forEach((r) => {
+      appendLedger(questionsFile, { id: r.id, workspace: deps.workspaceRoot, status: 'stale' });
+    });
+    pumpQuestions();
+    return { ok: true, ack: `got it: ${picked.label}.` };
+  }
+
+  // Send back: a job that did not pass goes to the team again as a new
+  // mission on the same bet, with what went wrong in the objective.
+  async function sendBackJob(row, why) {
+    const again = { ...row.bet, why_now: `the last run ${why}. try again. ${row.bet.why_now}` };
     const pick = pickOwner(again, deps.workspaceRoot);
     const display = args => require('./gm-phone').displayCommand(args);
-    state.status = 'starting';
-    const startArgs = missionStartArgs(again, pick, job.bet_id);
+    const startArgs = missionStartArgs(again, pick, row.id);
     let res = await deps.runCli(startArgs);
-    log({ card: 'bet', choice: 'send_back', command: display(startArgs), exit_code: res.code, bet_id: job.bet_id });
+    log({ card: 'bet', choice: 'send_back', command: display(startArgs), exit_code: res.code, bet_id: row.id });
     const started = parseJsonOut(res.stdout);
     const missionId = started && (started.mission ? started.mission.id : started.mission_id);
-    if (res.code !== 0 || !missionId) {
-      state.status = 'ready';
-      return { ok: false, reason: 'start_failed', message: 'it did not go back to the team; try again from the mac' };
-    }
+    if (res.code !== 0 || !missionId) return close(row, `it could not go back to the team (exit code ${res.code})`);
     const owner = (started.mission && started.mission.owner) || pick.owner;
-    record(job.bet_id, { mission_id: missionId, owner, mission_result: null, done_seen_at: iso(), sent_back_at: iso() });
-    lockYesSteps(missionId, job.bet_id, again.steps);
-    const runArgs = missionRunArgs(missionId);
+    record(row.id, { mission_id: missionId, owner, mission_result: null, mission_halted: null, mission_stalled: null, mission_out_of_time: null, mission_progress: null, mission_stop_reason: null, review_tries: 0, done_seen_at: null, sent_back_at: iso(), auto_sent_back: (Number(row.auto_sent_back) || 0) + 1 });
+    lockYesSteps(missionId, row.id, again.steps);
+    const runArgs = missionRunArgs(missionId, again);
     res = await deps.runCli(runArgs);
-    log({ card: 'bet', choice: 'send_back', command: display(runArgs), exit_code: res.code, bet_id: job.bet_id, mission_id: missionId });
-    state.status = 'cleared';
-    pollJobs();
-    return { ok: true, ack: `sent back. ${owner} has it again.` };
+    log({ card: 'bet', choice: 'send_back', command: display(runArgs), exit_code: res.code, bet_id: row.id, mission_id: missionId });
+    return null;
   }
 
   // yes: answers the mission's open ask through atris decide, matched by
@@ -2115,10 +3113,14 @@ function createBetDesk(deps) {
     return { ok: true, ack: `${job.owner}: got your yes` };
   }
 
+  // Two sentences for the owner: what is going on, and why it matters to
+  // the business. Nothing about how the work was checked.
   function publicJob(item) {
     const j = item.job;
-    if (item.kind === 'yes') return { title: j.title, owner: j.owner, ask: j.ask, ...(j.command ? { command: j.command } : {}) };
-    return { title: j.title, owner: j.owner, failed: j.failed, halted: j.halted, ...doneLines(j) };
+    const expect = item.kind === 'yes' ? j.expect : j.bet && j.bet.expect;
+    const why = expect ? ` ${sentence(expect)}` : '';
+    if (item.kind === 'yes') return { what: j.ask, why: `${j.owner} is waiting on your yes for this.${why}` };
+    return { what: j.title, why: `this is done.${why}` };
   }
 
   // Decision cards for the steps that need the owner's yes, for every bet
@@ -2161,7 +3163,8 @@ function createBetDesk(deps) {
   }
 
   function view() {
-    const events = state.waiting ? state.waiting.events : (state.status === 'failed' && state.lastFailed ? state.lastFailed : []);
+    // the writer's progress stays in the log; the page never reads it
+    const events = [];
     const cur = state.current;
     const kind = cur ? (cur.kind || 'bet') : null;
     return {
@@ -2169,8 +3172,19 @@ function createBetDesk(deps) {
       id: cur ? cur.id : null,
       kind,
       bet: kind === 'bet' ? cur.bet : null,
-      job: kind && kind !== 'bet' ? publicJob(cur) : null,
-      working: state.jobs.working.map(j => ({ title: j.title, owner: j.owner, running_for: j.running_for })),
+      job: kind === 'yes' || kind === 'done' ? publicJob(cur) : (kind === 'wait' ? { ...WAIT_CARD } : null),
+      question: kind === 'question' ? { ask: cur.question.ask, line: cur.question.line, choices: cur.question.choices } : null,
+      report: kind === 'report' ? {
+        what: `${cur.board.name}: what is it this week?`,
+        why: cur.last ? `last time it was ${commas(cur.last.value)}, on ${monthDay(cur.last.at)}.` : 'one number a week shows if this is going well.',
+      } : null,
+      // each option: its title, and one plain line of why, the result it expects
+      choice: kind === 'choice' ? { options: cur.items.map(i => ({ id: i.id, title: i.bet.title, why: choiceWhy(i.bet.expect) })) } : null,
+      working: state.jobs.working.map(j => ({ title: j.title, owner: j.owner, ...(j.left ? { left: j.left } : {}) })),
+      // the conversation on this card so far
+      thread: cur && state.thread.id === cur.id ? state.thread.turns.slice() : [],
+      // the footer count: only members really working
+      team_working: teamTable().rows.filter(r => r.status === 'working').length,
       events: events.map(e => ({ i: e.i, kind: e.kind, line: e.line, ...(e.key ? { key: e.key } : {}), ...(e.n != null ? { n: e.n } : {}) })),
       error: state.error,
       queue: state.queue.length,
@@ -2178,14 +3192,280 @@ function createBetDesk(deps) {
     };
   }
 
-  // resolves when every review running now has finished (tests and shutdown)
-  const settle = () => Promise.all([...state.reviews.values()]);
+  // ---- free text: each card is one turn in a conversation ----
+
+  function threadFor(id) {
+    if (state.thread.id !== id) state.thread = { id, turns: [] };
+    return state.thread;
+  }
+  const endThread = () => { state.thread = { id: null, turns: [] }; };
+  function addTurns(t, ...turns) {
+    t.turns = [...t.turns, ...turns].slice(-THREAD_TURNS);
+  }
+  const plainReply = text => (text && !ownerWord(text) ? text : null);
+  const plainSuggestions = list => (Array.isArray(list) ? list : [])
+    .filter(x => typeof x === 'string' && x.trim() && x.length <= 40 && !ownerWord(x) && !PROCESS_TALK.test(x))
+    .slice(0, 3);
+
+  // a read, within its time; a slow or failed one is a failed read
+  function readWithin(opts) {
+    let timer;
+    const slow = new Promise((resolve) => {
+      timer = setTimeout(() => resolve({ ok: false, reason: 'the read took too long' }), deps.sayTimeoutMs || SAY_READ_MS);
+      if (timer.unref) timer.unref();
+    });
+    return Promise.race([Promise.resolve().then(() => readFn(opts)).catch(err => ({ ok: false, reason: String((err && err.message) || err) })), slow])
+      .finally(() => clearTimeout(timer));
+  }
+
+  // the card as the reader sees it
+  function cardForReader(v) {
+    if (v.kind === 'question') return { kind: 'question', title: v.question.ask, detail: v.question.line, buttons: v.question.choices.map(c => c.label) };
+    if (v.kind === 'bet') return { kind: 'idea', title: v.bet.title, detail: [v.bet.why_now, v.bet.expect].join(' '), buttons: ['do it', 'sharper idea', 'not now'] };
+    if (v.kind === 'choice') return { kind: 'choice', title: 'which one next?', detail: v.choice.options.map(o => o.title).join(' / '), buttons: [] };
+    if (v.kind === 'report') return { kind: 'number', title: v.report.what, detail: v.report.why, buttons: [] };
+    return { kind: v.kind, title: v.job ? v.job.what : '', detail: v.job ? v.job.why : '', buttons: [] };
+  }
+
+  // Read first. A question back or an unclear message is answered on the
+  // same card and saves nothing; an answer or an instruction is acted on.
+  // A failed or slow read falls back to the plain line and saves nothing.
+  const QUESTION_HINT = 'his message ends with a question mark: it is a question back, not an answer';
+  async function readTurn(t, text, card) {
+    const thread = t.turns.slice(-THREAD_TURNS);
+    let read = await readWithin({ text, card, thread });
+    // words that end in a question mark are never saved as an answer: ask once
+    // more with that said, and if it still reads as an answer, fall back
+    if (read && read.ok && read.kind === 'answer' && /\?\s*$/.test(text)) {
+      read = await readWithin({ text, card, thread, hint: QUESTION_HINT });
+      if (read && read.ok && read.kind === 'answer') read = { ok: false, reason: 'a question read as an answer' };
+    }
+    if (read && read.ok && (read.kind === 'answer' || read.kind === 'instruction')) return { act: read };
+    const kind = read && read.ok ? read.kind : 'unclear';
+    const reply = (read && read.ok && plainReply(read.reply)) || SAY_FALLBACK;
+    const suggestions = read && read.ok && reply !== SAY_FALLBACK ? plainSuggestions(read.suggestions) : [];
+    addTurns(t, { who: 'owner', text }, { who: 'orb', text: reply });
+    return { stay: { ok: true, stay: true, kind: reply === SAY_FALLBACK ? 'unclear' : kind, reply, ...(suggestions.length ? { suggestions } : {}), thread: t.turns.slice() } };
+  }
+
+  // On a question it is the answer; on an idea, a note the writer reworks it
+  // with (the rework is the next idea); on a choice or the plain card, the
+  // next idea fits it; on a yes or a finished job, a word to that member.
+  async function say({ text, confirm = false, note = false } = {}) {
+    const said = String(text || '').trim();
+    if (!said) return { ok: false, reason: 'empty', message: 'say something first' };
+    if (said.length > SAY_MAX) return { ok: false, reason: 'too_long', message: `keep it under ${SAY_MAX} characters` };
+    const cur = state.status === 'ready' ? state.current : null;
+    if (!cur) return { ok: false, reason: 'gone', message: 'there is no card on screen' };
+    const kind = cur.kind || 'bet';
+    log({ card: 'bet', choice: 'say', command: null, ran: 'in process', exit_code: 0, kind, chars: said.length });
+    const t = threadFor(cur.id);
+    let read = { kind: 'instruction', reply: '' };
+    // a second tap or a note acts on what was already read
+    if (!confirm && !note) {
+      const turn = await readTurn(t, said, cardForReader(view()));
+      // the card moved on while it was read (a tap, do it): drop the reply
+      if (state.current !== cur || state.status !== 'ready') return { ok: false, reason: 'gone', message: 'that card changed, so nothing was done' };
+      if (turn.stay) return turn.stay;
+      read = turn.act;
+    }
+    if (kind === 'question') {
+      const q = cur.question;
+      if (read.kind === 'answer') {
+        if (q.key === 'scoreboard') {
+          const out = answer({ choice: 'other', text: said });
+          if (out.ok) endThread();
+          return out;
+        }
+        appendLedger(focusFile, { workspace: deps.workspaceRoot, key: q.key, answer: 'own', label: said, ask: q.ask, at: iso() });
+        if (!LOCAL_QUESTIONS.has(q.key)) appendLedger(questionsFile, { id: q.key, workspace: deps.workspaceRoot, status: 'answered' });
+        state.status = 'cleared';
+        endThread();
+        pumpQuestions();
+        return { ok: true, ack: `got it: ${said.replace(/[.\s]+$/, '')}.` };
+      }
+      // an instruction on a question: a note for the next idea
+      state.pendingSharper = { ownerNote: said };
+      state.status = 'cleared';
+      endThread();
+      pump();
+      return { ok: true, ack: plainReply(read.reply) || 'got it. the next idea will fit that.' };
+    }
+    if (kind === 'yes' || kind === 'done') {
+      const out = await steer({ member: cur.job.owner, text: said, confirm, note });
+      if (out.ok) endThread();
+      return out;
+    }
+    if (kind === 'bet') {
+      record(cur.id, { status: 'passed', note: 'reworked with your note', owner_note: said });
+      state.pendingSharper = { reworkOf: cur.bet.title, ownerNote: said };
+      state.status = 'cleared';
+      endThread();
+      pump();
+      return { ok: true, ack: plainReply(read.reply) || 'got it. reworking that idea with your note.' };
+    }
+    if (kind === 'choice') passJob(cur);
+    state.pendingSharper = { ownerNote: said };
+    state.status = 'cleared';
+    endThread();
+    pump();
+    return { ok: true, ack: plainReply(read.reply) || 'got it. the next idea will fit that.' };
+  }
+
+  // The talk card with one member: the same conversation. A question back is
+  // answered from what the table knows; an instruction steers them.
+  async function talk({ member, text, confirm = false, note = false } = {}) {
+    const name = String(member || '');
+    if (!(team || []).some(m => m.name === name)) return { ok: false, reason: 'gone', message: 'there is no such member on the team' };
+    const said = String(text || '').trim();
+    if (!said) return { ok: false, reason: 'empty', message: 'say something first' };
+    if (said.length > SAY_MAX) return { ok: false, reason: 'too_long', message: `keep it under ${SAY_MAX} characters` };
+    const t = threadFor(`member:${name}`);
+    if (!confirm && !note) {
+      const row = teamTable().rows.find(r => r.member === name);
+      const turn = await readTurn(t, said, { kind: 'member', title: name, detail: row ? `${row.status}: ${row.on}. ${row.time}.` : 'no work in the last day', buttons: [] });
+      if (turn.stay) return turn.stay;
+    }
+    const out = await steer({ member: name, text: said, confirm, note });
+    if (out.ok) endThread();
+    return out;
+  }
+
+  // ---- the team table: who is on what, from real state ----
+
+  // A member is working only when a process is really running its mission,
+  // or the mission moved in the last few minutes. A handoff that no process
+  // picked up is waiting to start. Members with nothing in the last day are
+  // left out.
+  const RECENT_MS = 24 * 60 * 60 * 1000;
+  const MOVING_MS = 5 * 60 * 1000;
+  const STATUS_ORDER = ['waiting for your yes', 'working', 'waiting to start', 'stopped', 'done', 'idle'];
+  let teamCache = null;
+  function teamTable() {
+    if (teamCache && now() - teamCache.at < 10000) return teamCache.table;
+    const names = new Set((team || []).map(m => m.name));
+    let missions;
+    try { missions = (deps.readMissions || defaultReadMissions)(deps.workspaceRoot); } catch { missions = null; }
+    const list = missions instanceof Map ? [...missions.values()] : Object.values(missions || {});
+    const ideaTitle = new Map(readLedger(deps.ledgerFile, deps.workspaceRoot).filter(r => r.mission_id && r.bet).map(r => [r.mission_id, r.bet.title]));
+    const best = new Map();
+    const put = (member, row, at) => {
+      if (!names.has(member)) return;
+      const rank = STATUS_ORDER.indexOf(row.status);
+      const cur = best.get(member);
+      if (!cur || rank < cur.rank || (rank === cur.rank && at > cur.at)) best.set(member, { row: { member, ...row }, rank, at });
+    };
+    for (const m of list) {
+      if (!m || !m.owner) continue;
+      const moved = Math.max(...[m.last_tick_at, m.updated_at, m.created_at].map(t => Date.parse(t || '') || 0));
+      const age = now() - moved;
+      if (!moved || age > RECENT_MS) continue;
+      const created = Date.parse(m.created_at || '') || moved;
+      const on = ideaTitle.get(m.id) || missionTitle(m.objective);
+      const status = String(m.status || '');
+      if (status === 'complete') { put(m.owner, { on, status: 'done', time: `finished ${spanWords(age)} ago` }, moved); continue; }
+      if (status === 'stopped') { put(m.owner, { on, status: 'stopped', time: `stopped ${spanWords(age)} ago` }, moved); continue; }
+      if (!OPEN_MISSION.has(status)) continue;
+      const asks = (Array.isArray(m.human_asks) ? m.human_asks : []).some(a => a && !(typeof a === 'object' && a.answered_at))
+        || require('./yes-lock').askedYesLocks(lockDir, m.id).length > 0;
+      if (asks) { put(m.owner, { on, status: 'waiting for your yes', time: `waiting ${spanWords(age)}` }, moved); continue; }
+      if (driverAlive(m) || age <= MOVING_MS) {
+        const wall = Number(m.max_wall_seconds) || Number(m.budget_contract && m.budget_contract.requested_seconds) || 0;
+        const left = wall ? created + wall * 1000 - now() : 0;
+        put(m.owner, { on, status: 'working', time: left > 0 ? leftWords(left) : `at it for ${spanWords(now() - created)}` }, moved);
+        continue;
+      }
+      if (!m.last_tick_at) { put(m.owner, { on, status: 'waiting to start', time: `waiting ${spanWords(now() - created)}` }, moved); continue; }
+      put(m.owner, { on, status: 'stopped', time: `stopped ${spanWords(age)} ago` }, moved);
+    }
+    for (const hnd of (deps.readHandoffs || defaultReadHandoffs)(deps.workspaceRoot)) {
+      const at = Date.parse((hnd && (hnd.closed_at || hnd.created_at)) || '') || 0;
+      if (!hnd || !hnd.to || !at || now() - at > RECENT_MS) continue;
+      const on = clip(String(hnd.summary || '').replace(/^\[[^\]]*\]\s*/, ''), 100);
+      if (hnd.status === 'open') put(hnd.to, { on, status: 'waiting to start', time: `waiting ${spanWords(now() - at)}` }, at);
+      else put(hnd.to, { on, status: 'idle', time: `free for ${spanWords(now() - at)}` }, at);
+    }
+    const rows = [...best.values()]
+      .sort((a, b) => a.rank - b.rank || a.row.member.localeCompare(b.row.member))
+      .map(x => x.row);
+    const table = { rows };
+    teamCache = { at: now(), table };
+    return table;
+  }
+
+  // A word to a member from its talk card or a card on screen. The phone
+  // never calls a steer that can start anyone: it uses --no-ignite, which
+  // only reaches a live run and otherwise starts nothing, and then the page
+  // offers a second tap or a note. A confirmed start runs in the background
+  // (--detach) and reports started or not from that. The owner's words go
+  // after --, behind "the owner says:", so they are never read as options.
+  const SAY_MAX = 280;
+  function steeringNote(name, said) {
+    const file = path.join(deps.workspaceRoot, '.atris', 'state', 'steering.jsonl');
+    appendLedger(file, { schema: 'atris.steering.v1', id: `steer-${crypto.randomBytes(4).toString('hex')}`, kind: 'preference', status: 'active', scope: { member: name }, raw: said, memory: [said], created_at: iso(), source: 'gm-phone' });
+  }
+
+  async function steer({ member, text, confirm = false, note = false } = {}) {
+    const name = String(member || '');
+    if (!(team || []).some(m => m.name === name)) return { ok: false, reason: 'gone', message: 'there is no such member on the team' };
+    const said = String(text || '').trim();
+    if (!said) return { ok: false, reason: 'empty', message: 'say something first' };
+    if (said.length > SAY_MAX) return { ok: false, reason: 'too_long', message: `keep it under ${SAY_MAX} characters` };
+    if (note) {
+      steeringNote(name, said);
+      log({ card: 'bet', choice: 'steer_note', command: null, ran: 'in process', exit_code: 0, member: name, chars: said.length });
+      return { ok: true, ack: `saved for ${name}'s next run.` };
+    }
+    const words = `the owner says: ${said}`;
+    const args = ['member', 'steer', name, confirm === true ? '--detach' : '--no-ignite', '--json', '--', words];
+    const res = await deps.runCli(args);
+    const out = parseJsonOut(res.stdout) || {};
+    log({ card: 'bet', choice: confirm === true ? 'steer_start' : 'steer', command: `atris member steer ${name} ${args[3]} --json -- "<${said.length} characters>"`, exit_code: res.code, member: name, chars: said.length, action: out.action || null });
+    teamCache = null;
+    if (res.code === 0 && out.action === 'member_steered') return { ok: true, ack: `sent to ${name}.` };
+    if (confirm === true) {
+      if (res.code === 0 && out.action === 'member_run_detached') return { ok: true, ack: `${name} is starting on it.` };
+      // refused before it began: say why, in its plain words
+      if (out.action === 'member_run_not_started' && out.reason) return { ok: false, reason: 'not_started', message: `${name} did not start: ${String(out.reason).replace(/[.\s]+$/, '')}.` };
+      return { ok: false, reason: 'not_started', message: `${name} did not start. try again in a minute.` };
+    }
+    if (out.action === 'member_not_running' || res.code === 3) return { ok: false, reason: 'needs_confirm', message: `tap again to start ${name} on this` };
+    return { ok: false, reason: 'steer_failed', message: 'it did not reach them. try again in a minute.' };
+  }
+
+  // resolves when every review and send back running now has finished (tests and shutdown)
+  async function settle() {
+    while (state.reviews.size || state.retrying.size) await Promise.all([...state.reviews.values(), ...state.retrying.values()]);
+  }
+
+  // the queue starts filling now, not when the page first opens; with the
+  // queue already full, the facts for a question card are read on their own
+  if (deps.warmOnCreate !== false) {
+    pump();
+    if (!state.inFlight && deps.readBundle) {
+      Promise.resolve().then(() => deps.readBundle()).then((b) => { if (b && !state.bundle) state.bundle = b; }).catch(() => {});
+    }
+  }
 
-  return { warm, next, skip, doIt, nice, sendBack, answerYes, pollJobs, settle, yesCards, recordYes, view, state };
+  return { warm, next, pick, say, talk, report, teamTable, steer, skip, doIt, nice, answerYes, answer, pollJobs, settle, yesCards, recordYes, view, state };
 }
 
 module.exports = {
+  BACKOFF_MS,
+  FALLBACK_QUESTION,
+  readScoreboard,
+  readSaid,
+  scoreboardPath,
+  choiceWhy,
   JOB_POLL_MS,
+  OWNER_BANNED,
+  jobTime,
+  generateQuestion,
+  readProjectContext,
+  validateQuestion,
+  STALL_MS,
+  focusPath,
+  readFocus,
   queuedProblem,
   MODEL_TIMEOUT_MS,
   STALE_MS,
@@ -2213,6 +3493,7 @@ module.exports = {
   readLedger,
   releaseFact,
   runModel,
+  stopWriters,
   scoreBets,
   skepticCommand,
   validateBet,