atris 3.74.7 → 3.74.9

package/lib/gm-bet.js

@@ -3,9 +3,9 @@
 // gm bet: one new, specific business move nobody wrote down yet, with a
 // prediction, a check date, and exact steps. The owner taps "think" on the
 // phone page; this module reads real local sources (each read is a progress
-// event with one real fact), asks a smart model for one bet as strict JSON,
-// checks it with plain rules, and keeps every bet in a ledger. "do it" turns
-// the bet into a real atris mission.
+// event with one real fact), asks three writers at once for one bet each,
+// checks each with plain rules and a skeptic as it lands, and keeps every bet
+// in a ledger. "do it" turns the bet into a real atris mission.
 //
 // Everything that touches the outside world is passed in (the model command,
 // the mission runner, the clock, the file paths), so tests stub it.
@@ -712,10 +712,10 @@ function npmName(pkg) {
   return encodeURIComponent(pkg).replace('%40', '@');
 }
 
-function defaultFetchJson(url, { timeoutMs = 10000 } = {}) {
+function defaultFetchJson(url, { timeoutMs = 10000, signal = null } = {}) {
   const https = require('https');
   return new Promise((resolve, reject) => {
-    const req = https.get(url, { headers: { 'user-agent': 'atris-gm-bet' } }, (res) => {
+    const req = https.get(url, { headers: { 'user-agent': 'atris-gm-bet' }, ...(signal ? { signal } : {}) }, (res) => {
       if (res.statusCode !== 200) {
         res.resume();
         reject(new Error(`status ${res.statusCode}`));
@@ -849,6 +849,65 @@ function statusSentence(row) {
   return `${row.status}: ${on}, ${row.time}`;
 }
 
+// The ovr cell from one member's entry in gm-season memberRatings: the
+// rating, "new" with 1 or 2 finished, two dots with none finished.
+function ovrCell(rated) {
+  if (!rated || !rated.finished) return NO_RATING;
+  return rated.ovr == null ? 'new' : String(rated.ovr);
+}
+
+// The engine pick the runner makes for a member, with the roster read once.
+function teamEngineResolver(workspaceRoot) {
+  const reg = require('./engine-registry');
+  const { resolveEngineForMember } = require('./member-engine');
+  let rosterState = null;
+  try { rosterState = reg.readRosterState(workspaceRoot); } catch { rosterState = null; }
+  return name => resolveEngineForMember(name, workspaceRoot, { quiet: true, ...(rosterState ? { rosterState } : {}) });
+}
+
+// role, ovr, engine, and parked for each name: the team page's cells, and
+// the same cells the board and the standup draw in a terminal, so every
+// team view says the same thing. ratings is gm-season memberRatings over one
+// loaded season; resolve gives a member's engine pick. A name with no card
+// and no roster line is not on the team, so no engine shows for it.
+function teamCells(workspaceRoot, names = [], { ratings = new Map(), resolve = null } = {}) {
+  const { memberTypeOf } = require('./member-type');
+  const pick = resolve || teamEngineResolver(workspaceRoot);
+  const out = new Map();
+  for (const name of names) {
+    const key = String(name || '');
+    if (!key || /[\\/]/.test(key) || key === '.' || key === '..') {
+      out.set(key, { role: NO_RATING, ovr: ovrCell(ratings.get(key)), engine: NO_RATING, parked: false });
+      continue;
+    }
+    const card = memberCardFacts(workspaceRoot, key);
+    const kind = memberTypeOf({ type: card.type });
+    let engine = kind.type === 'human' ? 'person' : NO_RATING;
+    if (kind.runnable) {
+      let picked = null;
+      try { picked = pick(key); } catch { picked = null; }
+      engine = picked && picked.found === false ? NO_RATING : engineWords(picked);
+    }
+    out.set(key, { role: memberRoleWords(key, card), ovr: ovrCell(ratings.get(key)), engine, parked: card.parked });
+  }
+  return out;
+}
+
+// The team table as a divided box for a terminal, in the team page's
+// columns: one line per { member, status } with that member's cells from
+// teamCells. A long role or status wraps to fit the width (the exact model
+// never splits); null when even that does not fit.
+function teamBox(rows, cells, { width } = {}) {
+  const { renderBorderedTable } = require('./text-table');
+  const wraps = new Set(['role', 'status']);
+  const columns = require('./gm-card').TEAM_COLUMNS.map(header => ({ header, wrap: wraps.has(header) }));
+  const blank = { role: NO_RATING, ovr: NO_RATING, engine: NO_RATING };
+  return renderBorderedTable(columns, (rows || []).map((row) => {
+    const c = (cells && cells.get(row.member)) || blank;
+    return [row.member, c.role, c.ovr, c.engine, row.status];
+  }), { width });
+}
+
 // A verify command that always passes proves nothing. Binary checks only:
 // every piece of it is one of these, or it swallows failure with || true.
 const TRIVIAL_VERIFY = [
@@ -1104,13 +1163,46 @@ function bundleMetrics(bundle) {
 // a real fact (or says it was left out). A missing source is omitted, never
 // invented. Past bets that are due are scored first, so the ledger the model
 // reads already has their results.
-async function readBundle(workspaceRoot, { deps = {}, emit = () => {}, ledgerFile, today = dayKey(Date.now()) } = {}) {
+// The value of p, or late() once the deadline passes or the signal stops it
+// first; p then goes on alone with its errors dropped. With no deadline it is
+// just p. The timer is cleared on every way out, and unref'd as a backstop,
+// so it never holds the process open.
+function byDeadline(p, deadline, late, signal = null) {
+  const work = Promise.resolve(p);
+  if (!deadline) return work;
+  let timer;
+  let onStop = null;
+  const cut = new Promise((resolve) => {
+    const give = () => { clearTimeout(timer); work.catch(() => {}); resolve(late()); };
+    timer = setTimeout(give, Math.max(0, deadline - Date.now()));
+    if (timer.unref) timer.unref();
+    if (signal) {
+      if (signal.aborted) give();
+      else { onStop = give; signal.addEventListener('abort', onStop, { once: true }); }
+    }
+  });
+  return Promise.race([work, cut]).finally(() => {
+    clearTimeout(timer);
+    if (onStop) signal.removeEventListener('abort', onStop);
+  });
+}
+
+// deadline (ms since 1970, optional): the sources are read by then. Scoring
+// past bets and each npm read that is still going at the deadline are left
+// out (scoring finishes on its own), so a slow network never eats the time
+// the writers need.
+// signal (optional): a stop ends the waits at once, and the npm reads with them.
+async function readBundle(workspaceRoot, { deps = {}, emit = () => {}, ledgerFile, today = dayKey(Date.now()), deadline = null, signal = null } = {}) {
   const ledger = ledgerFile || ledgerPath();
+  const LATE = Symbol('late');
   try {
-    await (deps.scoreBets || scoreBets)(workspaceRoot, { ledgerFile: ledger, today, deps, emit });
+    const scored = await byDeadline((deps.scoreBets || scoreBets)(workspaceRoot, { ledgerFile: ledger, today, deps, emit }), deadline, () => LATE, signal);
+    if (scored === LATE) emit({ kind: 'skip', key: 'score', line: 'scoring past bets took too long, so it finishes on its own' });
   } catch {
     // scoring is a side job; a failure never blocks the next bet
   }
+  // an npm read gets what is left before the deadline, at most its usual 10 seconds
+  const fetchOpts = () => (deadline ? { timeoutMs: Math.max(1, Math.min(10000, deadline - Date.now())), ...(signal ? { signal } : {}) } : undefined);
   const bundle = { workspace: workspaceRoot, today, sources: {}, facts: [] };
   const add = (key, fact, data) => {
     bundle.sources[key] = { fact, ...data };
@@ -1164,7 +1256,9 @@ async function readBundle(workspaceRoot, { deps = {}, emit = () => {}, ledgerFil
   if (pkg) {
     try {
       // a year of days: last week, the week before, and the last 8 full weeks
-      installBody = await fetchJson(`https://api.npmjs.org/downloads/range/last-year/${npmName(pkg)}`);
+      const url = `https://api.npmjs.org/downloads/range/last-year/${npmName(pkg)}`;
+      installBody = await byDeadline(fetchOpts() ? fetchJson(url, fetchOpts()) : fetchJson(url), deadline, () => LATE, signal);
+      if (installBody === LATE) throw new Error('npm took too long');
       installs = installWeeks(installBody);
     } catch {
       installs = null;
@@ -1189,7 +1283,8 @@ async function readBundle(workspaceRoot, { deps = {}, emit = () => {}, ledgerFil
   let version = null;
   if (pkg) {
     try {
-      const latest = await fetchJson(`https://registry.npmjs.org/${npmName(pkg)}/latest`);
+      const url = `https://registry.npmjs.org/${npmName(pkg)}/latest`;
+      const latest = await byDeadline(fetchOpts() ? fetchJson(url, fetchOpts()) : fetchJson(url), deadline, () => null, signal);
       version = latest && typeof latest.version === 'string' && /^\d+\.\d+\.\d+/.test(latest.version) ? latest.version : null;
     } catch {
       version = null;
@@ -1340,7 +1435,7 @@ function metricChoices(bundle) {
   });
 }
 
-function buildPrompt(bundle, { today, previousTitle = null, reason = null, previousAnswer = null, blocker = null, avoidTitles = [], reworkOf = null, ownerNote = null } = {}) {
+function buildPrompt(bundle, { today, previousTitle = null, reason = null, previousAnswer = null, blocker = null, avoidTitles = [], reworkOf = null, ownerNote = null, angle = null, concern = 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.',
@@ -1375,6 +1470,10 @@ function buildPrompt(bundle, { today, previousTitle = null, reason = null, previ
   // 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}`);
+  // the owner asked to sharpen an idea a second look worried about
+  if (previousTitle && concern) lines.push(`A second look at that idea worried: ${clip(String(concern).replace(/[.\s]+$/, ''), 240)}. The new idea must answer that worry.`);
+  // each writer in the swarm leans a different way, so the drafts differ
+  if (angle) lines.push('', angle);
   // 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.`);
@@ -1400,6 +1499,24 @@ function claudeArgs(prompt, model = MODEL) {
   return ['-p', prompt, '--model', model, '--output-format', 'stream-json', '--verbose', '--include-partial-messages', '--tools', '', '--no-session-persistence', '--strict-mcp-config'];
 }
 
+// The writer and the skeptic think briefly: on the real prompt, low effort
+// answered in 17 to 19 seconds against 21 at the default, and its answers
+// passed the plain-rule checks.
+const IDEA_EFFORT = 'low';
+function writerCommand() {
+  return { bin: 'claude', args: p => [...claudeArgs(p, MODEL), '--effort', IDEA_EFFORT] };
+}
+
+// The writer and the skeptic get every fact in the prompt, so they run in an
+// empty folder of their own: started in the workspace, the model also loads
+// that project's agent instructions and memory, about 11,000 tokens nobody
+// asked for, and its first word came 10 seconds later (measured).
+function quietDir() {
+  const dir = path.join(require('os').tmpdir(), 'atris-gm-ideas');
+  try { fs.mkdirSync(dir, { recursive: true }); } catch { /* the model can still start in a missing folder's parent */ }
+  return dir;
+}
+
 // 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.
@@ -1407,17 +1524,38 @@ function claudeArgs(prompt, model = MODEL) {
 // stops; otherwise a stopped server leaves them running on their own.
 const LIVE_WRITERS = new Map();
 
+// SIGTERM now, then SIGKILL for the same groups after the grace, so a child
+// that ignores SIGTERM does not outlive the server either.
 function stopWriters() {
   let n = 0;
-  for (const [pid, kill] of LIVE_WRITERS) {
+  const groups = [...LIVE_WRITERS];
+  for (const [pid, kill] of groups) {
     try { kill(-pid, 'SIGTERM'); n += 1; } catch { /* already gone */ }
   }
   LIVE_WRITERS.clear();
+  if (groups.length) {
+    const t = setTimeout(() => {
+      for (const [pid, kill] of groups) {
+        try { kill(-pid, 'SIGKILL'); } catch { /* already gone */ }
+      }
+    }, STOP_GRACE_MS);
+    if (t.unref) t.unref();
+  }
   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) } = {}) {
+// A signal (an AbortSignal) stops the call early: the whole process group
+// gets SIGTERM, then SIGKILL if it is still there after STOP_GRACE_MS, and
+// the call resolves once the process is gone, so nothing it started is left.
+const STOP_GRACE_MS = 1500;
+const STOPPED_REASON = 'stopped: another idea was picked first';
+
+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), signal = null } = {}) {
   return new Promise((resolve) => {
+    if (signal && signal.aborted) {
+      resolve({ ok: false, reason: STOPPED_REASON, stopped: true });
+      return;
+    }
     const args = typeof command.args === 'function' ? command.args(prompt) : [...(command.args || []), prompt];
     let child;
     try {
@@ -1434,15 +1572,36 @@ function runModel(prompt, { command = { bin: 'claude', args: claudeArgs }, cwd,
     let result = null;
     let thinking = 0;
     let timedOut = false;
+    let stopped = false;
+    let hardKill = null;
     let done = false;
-    const timer = setTimeout(() => {
-      timedOut = true;
+    const killGroup = (sig) => {
       try {
-        kill(-child.pid, 'SIGKILL');
+        kill(-child.pid, sig);
       } catch {
-        try { child.kill('SIGKILL'); } catch { /* already gone */ }
+        try { child.kill(sig); } catch { /* already gone */ }
       }
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killGroup('SIGKILL');
     }, timeoutMs);
+    // The SIGKILL for the group always fires after the grace, even when the
+    // model itself has exited by then: a child it started with its own
+    // stdio can ignore SIGTERM and outlive it, so the group is tracked (and
+    // the timer kept alive) until that kill has gone out.
+    const onAbort = () => {
+      if (done || stopped) return;
+      stopped = true;
+      killGroup('SIGTERM');
+      hardKill = setTimeout(() => {
+        killGroup('SIGKILL');
+        if (LIVE_WRITERS.get(child.pid) === kill) LIVE_WRITERS.delete(child.pid);
+      }, STOP_GRACE_MS);
+      // it fires while the process lives, and never holds it open on its own
+      if (hardKill.unref) hardKill.unref();
+    };
+    if (signal) signal.addEventListener('abort', onAbort, { once: true });
     const line = (raw) => {
       if (!raw.trim()) return;
       let ev;
@@ -1476,12 +1635,16 @@ function runModel(prompt, { command = { bin: 'claude', args: claudeArgs }, cwd,
       if (done) return;
       done = true;
       clearTimeout(timer);
-      LIVE_WRITERS.delete(child.pid);
+      if (signal) signal.removeEventListener('abort', onAbort);
+      // a stopped call keeps its SIGKILL and its place in LIVE_WRITERS until
+      // the grace is over; every other call is finished with its group
+      if (!stopped) LIVE_WRITERS.delete(child.pid);
       resolve(out);
     };
     child.on('error', err => finish({ ok: false, reason: `could not start the model: ${err.message}` }));
     child.on('close', (code) => {
       if (buf) line(buf);
+      if (stopped) return finish({ ok: false, reason: STOPPED_REASON, stopped: true });
       if (timedOut) return finish({ ok: false, reason: `the model took longer than ${Math.round(timeoutMs / 1000)} seconds and was stopped`, timed_out: true });
       if (result && result.is_error) return finish({ ok: false, reason: `the model said: ${clip(result.result || result.subtype, 160)}` });
       const answer = result && typeof result.result === 'string' ? result.result : text;
@@ -1781,13 +1944,9 @@ function cleanBet(bet, today, bundle) {
 
 // ---- one generation ----------------------------------------------------------------------
 
-// Reads the sources, asks the model, checks the answer with plain rules, then
-// asks a skeptic model whether it makes sense; either can turn it down, and
-// there is one retry with the reasons. Resolves { ok, bet, bundle } or
-// { ok: false, reason }.
 // Every model attempt, writer and skeptic (the kind field), is kept (raw
-// answer, parse result, reasons, timing), so
-// a failed live run can be read back afterwards.
+// answer, parse result, reasons, timing), so a failed live run can be read
+// back afterwards. generateBet (the swarm, below) writes them.
 function attemptsPath(stateDir = defaultStateDir()) {
   return path.join(stateDir, 'gm-bet-attempts.jsonl');
 }
@@ -1811,21 +1970,30 @@ function wordCount(text) {
 // Whether the move actually moves its number, what has to be true first, and
 // whether a sharp founder would laugh at it is judgment, so a separate model
 // call owns it. It gets the bet and the same facts, never the writer's prompt.
+//
+// The bar is the inner scorecard: the team is judged only on what it controls
+// and can check. A pass needs every team step to be work the team can do and
+// see done, and the move to push the number the right way this week. It does
+// not have to reach the goal: one idea cannot add a whole week's target, and
+// the old bar (from the baseline to the goal) turned down all of the last 82
+// drafts it judged, so every tap waited and then got nothing.
 function buildSkepticPrompt(bet, bundle, { today } = {}) {
   return [
     'You are a skeptical cofounder. Someone else proposed the bet below for this week. Your job is to catch it if it does not make sense, before the team spends a week on it.',
     '',
     'Answer with strict JSON only, no prose and no code fence, in this shape:',
-    '{"verdict": "pass", "missing_first": "...", "moves_metric": true, "reason": "..."}',
+    '{"verdict": "pass", "doable": true, "moves_metric": true, "missing_first": "...", "reason": "...", "concern": "..."}',
     '',
-    'Check these against the facts below:',
-    '- 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.',
+    'The team is judged only on what it controls and can check. Judge it that way, against the facts below:',
+    '- doable: is every team step work the team can do on its own this week, and check once it is done (a page that exists, a post drafted, a demo recorded, a test that passes)? steps for "you" wait for the owner\'s yes and are fine. a team step that only happens if strangers act is not doable.',
+    '- moves_metric: if every step is done, would it plausibly push the target number the right way this week (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)? it does not have to reach target.goal; the goal is the hope, not the bar, so never fail it only because the goal is ambitious. 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".',
+    'verdict is "pass" when doable and moves_metric are both 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.',
+    `concern: when it fails, the worry in one plain everyday line under 120 characters for the owner, who reads it on the card; never these words: ${OWNER_BANNED_WORDS.join(', ')}. "" when it passes.`,
     '',
     `Today is ${today}.`,
     '',
@@ -1850,17 +2018,21 @@ function parseVerdict(text) {
       moves_metric: v.moves_metric,
       missing_first: typeof v.missing_first === 'string' ? clip(v.missing_first, 240) : '',
       reason: clip(v.reason, 400),
+      // doable and concern are newer; an answer without them still counts
+      ...(typeof v.doable === 'boolean' ? { doable: v.doable } : {}),
+      ...(typeof v.concern === 'string' && v.concern.trim() ? { concern: clip(v.concern.trim(), 200) } : {}),
     },
   };
 }
 
 function skepticCommand() {
-  return { bin: 'claude', args: p => claudeArgs(p, SKEPTIC_MODEL) };
+  return { bin: 'claude', args: p => [...claudeArgs(p, SKEPTIC_MODEL), '--effort', IDEA_EFFORT] };
 }
 
-// A pass needs both: the verdict and the skeptic's own yes on moving the number.
+// A pass needs the verdict and the skeptic's own yes on moving the number,
+// and never a no on whether the team can do and check every step.
 function skepticPassed(v) {
-  return v.verdict === 'pass' && v.moves_metric === true;
+  return v.verdict === 'pass' && v.moves_metric === true && v.doable !== false;
 }
 
 // What the skeptic said must be true first, or null when it said nothing is.
@@ -1872,7 +2044,8 @@ function blockerOf(v) {
 function skepticReason(v) {
   const missing = blockerOf(v) ? ` missing first: ${v.missing_first.replace(/[.\s]+$/, '')}.` : '';
   const moves = v.moves_metric ? '' : ' it would not move the target number.';
-  return `a skeptic turned it down: ${v.reason.replace(/[.\s]+$/, '')}.${moves}${missing} if the missing piece is something we can do, add it as a step (a release, or anything public, is a step for "you")`;
+  const doable = v.doable === false ? ' a team step is not work the team can do and check on its own.' : '';
+  return `a skeptic turned it down: ${v.reason.replace(/[.\s]+$/, '')}.${moves}${doable}${missing} if the missing piece is something we can do, add it as a step (a release, or anything public, is a step for "you")`;
 }
 
 // A free repair turn for an answer that broke only length or sentence limits:
@@ -1904,124 +2077,319 @@ 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: avoidIn = [], reworkOf = null, ownerNote = null, emit = () => {}, onBundle = () => {}, deps = {}, ledgerFile, attemptsFile, allowTeamMetrics = false } = {}) {
+// ---- the swarm: several writers at once -----------------------------------------------
+
+// Three writers start at once, each leaning a different way, and every draft
+// is checked the moment it lands: the plain rules in code, then the skeptic,
+// while the other writers keep going. The first draft that passes both is the
+// idea, and every call still running is stopped. Nothing waits past the
+// budget: when it runs out, the best draft so far is the idea, with the
+// skeptic's worry in one plain line. Measured on the real prompt, one writer
+// took 17 to 27 seconds and one skeptic 9 to 20, and one writer after another
+// with its skeptic took over two minutes across three tries.
+const SWARM_WRITERS = 3;
+const SWARM_BUDGET_MS = 30000;
+// reading the facts gets the first quarter of it; anything slower is left out
+const SOURCES_SHARE = 0.25;
+// a call that cannot finish inside the budget is not started: a writer needs
+// about 40% of it, a skeptic about 13% (the shares of a 30 second budget)
+const WRITE_MIN_LEFT_MS = 12000;
+const JUDGE_MIN_LEFT_MS = 4000;
+const COUNT_WORDS = ['no', 'one', 'two', 'three', 'four', 'five', 'six'];
+// each writer leans a different way; any project has these three doors
+const WRITER_ANGLES = [
+  { key: 'reach', text: 'Lean toward reach: put something real in front of new people who would want it and do not know it exists yet.' },
+  { key: 'first_hour', text: 'Lean toward the people already here: make their first hour better, so more of them stay, come back, or tell someone.' },
+  { key: 'proof', text: 'Lean toward proof: one small thing people can see, try, or copy this week that shows what this does.' },
+];
+
+// What the waiting card says while the drafts are written, in the owner's
+// words: each event that carries say is one line the page can show.
+const SWARM_SAY = {
+  drafting: n => (n === 1 ? 'drafting an idea' : `drafting ${COUNT_WORDS[n] || n} ideas at once`),
+  checking: k => `the ${ORDINALS[k - 1] || 'next'} draft is in. checking it`,
+  redraft: 'one draft missed a rule. redrafting it',
+  shorten: 'one draft ran long. shortening it',
+  heldUp: 'found one that holds up',
+  notHeld: 'that one did not hold up. still working',
+  outOfTime: 'out of time. bringing the best one so far',
+  nothing: 'nothing usable came back this time',
+};
+
+// The best draft when none passed: one the skeptic only had small doubts
+// about first, then one it had no time to look at, then the rest, oldest
+// first within each.
+function draftRank(c) {
+  if (!c.verdict) return 1;
+  const v = c.verdict;
+  if (v.moves_metric === true && v.doable !== false && !blockerOf(v)) return 0;
+  return 2 + (v.moves_metric === true ? 0 : 2) + (v.doable === false ? 1 : 0) + (blockerOf(v) ? 1 : 0);
+}
+
+// The skeptic's worry as one line the owner reads on the card: its own
+// concern, else the first sentence of its reason, when that is plain words
+// with none of our own; otherwise a plain line that says what kind of worry.
+const CONCERN_MAX = 140;
+function ownerConcern(c) {
+  if (!c.verdict) return c.unjudged && !/no time left/.test(c.unjudged) ? 'not double-checked: the second look did not finish.' : 'not double-checked yet: it came in as time ran out.';
+  const v = c.verdict;
+  const first = String(v.reason || '').split(/(?<=[.!?])\s+/)[0];
+  const said = String(v.concern || first || '').replace(/\s+/g, ' ').trim().replace(/[.\s]+$/, '');
+  const plain = said && said.length <= CONCERN_MAX - 12 && !ownerWord(said) && !/\u2014/.test(said) && !STEP_CODE.some(re => re.test(said));
+  if (plain) return `one worry: ${said.charAt(0).toLowerCase()}${said.slice(1)}.`;
+  if (v.moves_metric !== true) return 'one worry: it may not move your number much this week.';
+  if (v.doable === false) return 'one worry: one step depends on people outside the team.';
+  if (blockerOf(v)) return 'one worry: something has to be in place before it can work.';
+  return 'one worry: it may not be the best use of this week.';
+}
+
+// Reads the sources, then runs the swarm. Resolves { ok: true, bet, bundle,
+// checked: true } for a draft both checks passed; { ok: true, bet (with
+// concern), checked: false } for the best draft when none passed in the
+// budget; { ok: false, reason } only when no draft met the plain rules at
+// all; { ok: false, stopped: true } when the signal stopped it first.
+// writers: how many at once (tests pass 1 to walk one writer's retries).
+// Every model attempt, writer and skeptic (the kind field), with its lane, is
+// kept in the attempts log, the stopped ones too.
+async function generateBet({ workspaceRoot, today, previousTitle = null, avoidTitles: avoidIn = [], reworkOf = null, ownerNote = null, concern = null, emit = () => {}, onBundle = () => {}, deps = {}, ledgerFile, attemptsFile, allowTeamMetrics = false, writers = deps.writers || SWARM_WRITERS, budgetMs = deps.budgetMs || SWARM_BUDGET_MS, signal = null } = {}) {
+  // the budget runs on the real clock, the one the stop timer uses
+  const deadline = Date.now() + budgetMs;
+  const left = () => deadline - Date.now();
+  const writeMin = Math.min(WRITE_MIN_LEFT_MS, budgetMs * (WRITE_MIN_LEFT_MS / SWARM_BUDGET_MS));
+  const judgeMin = Math.min(JUDGE_MIN_LEFT_MS, budgetMs * (JUDGE_MIN_LEFT_MS / SWARM_BUDGET_MS));
   // 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;
+  const run = deps.runModel || ((prompt, opts) => runModel(prompt, { ...opts, command: writerCommand() }));
   // 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
   const judge = deps.runSkeptic || deps.runModel || ((prompt, opts) => runModel(prompt, { ...opts, command: skepticCommand() }));
   const clock = deps.now || Date.now;
-  // How each try is asked. first: a fresh bet. patch: fix the last answer
-  // against the reasons (code rejects, or a skeptic fail that names no
-  // blocker). blocker: the skeptic named what must be true first, so the
-  // next bet is clearing that blocker, a new move with its own target.
-  // trim: inside a try, a free turn that only shortens fields over a limit.
-  let strategy = 'first';
-  let reason = null;
-  let previousAnswer = null;
-  let blocker = null;
-  const blocked = [];
+  const cwd = deps.runModel ? workspaceRoot : quietDir();
+  const n = Math.max(1, Math.floor(Number(writers)) || 1);
   const MODEL_LINES = { first: 'asking the model for one bet', patch: 'asking again with the reasons', blocker: 'asking again: clearing the blocker is the new bet', trim: 'asking for the same bet, shorter' };
 
-  // one model call and its code check, saved to the attempts log
-  async function ask(prompt, attempt, how, avoid) {
-    let lastSaid = 0;
-    const started = clock();
-    const answer = await run(prompt, {
-      cwd: workspaceRoot,
-      onProgress: ({ text = '' }) => {
-        const at = clock();
-        if (at - lastSaid < 1200) return;
-        lastSaid = at;
-        const words = wordCount(text);
-        emit({ kind: 'thinking', line: words ? `thinking... ${commas(words)} words written` : 'thinking...', n: words });
-      },
-    });
-    const base = { at: new Date(clock()).toISOString(), workspace: workspaceRoot, today, attempt, strategy: how, ...(how === 'blocker' ? { blocker: blocker.missing_first } : {}), previous_title: previousTitle, avoid_titles: avoid.length, ms: clock() - started };
-    if (!answer.ok) {
-      saveAttempt(attemptsFile, { ...base, kind: 'writer', model_ok: false, raw: null, parse: null, passed: false, reasons: [answer.reason] });
-      return { failed: answer.reason, base };
+  // the swarm's shared state, set up before anything is read so the budget
+  // and a stop cover the reading too: the drafts that met the rules, why each
+  // lane ended, and the calls still running, so one stop ends them all
+  const drafts = [];
+  const ends = [];
+  const live = new Set();
+  let turnedDown = 0;
+  let checking = 0;
+  let winner = null;
+  let over = null;
+  let release;
+  const ended = new Promise((resolve) => { release = resolve; });
+  const stop = (why) => {
+    if (over) return;
+    over = why;
+    for (const ac of live) ac.abort();
+    live.clear();
+    release();
+  };
+  if (signal && signal.aborted) stop('stopped');
+  const onSignal = () => stop('stopped');
+  if (signal && !over) signal.addEventListener('abort', onSignal, { once: true });
+  const timer = setTimeout(() => stop('budget'), Math.max(0, left()));
+  // the reading's waits end with the swarm, on every way out
+  const readStop = new AbortController();
+  const finish = (out) => {
+    clearTimeout(timer);
+    readStop.abort();
+    if (signal) signal.removeEventListener('abort', onSignal);
+    return out;
+  };
+
+  // the facts, read in the first share of the budget: whatever is still
+  // slow by then is left out, so the writers keep the time they need
+  const reading = readBundle(workspaceRoot, { deps, emit, ledgerFile, today, deadline: Date.now() + budgetMs * SOURCES_SHARE, signal: readStop.signal });
+  reading.catch(() => {});
+  let bundle;
+  try {
+    bundle = await Promise.race([reading, ended.then(() => null)]);
+  } catch (err) {
+    finish();
+    throw err;
+  }
+  if (over === 'stopped') return finish({ ok: false, stopped: true, reason: 'stopped before an idea was picked' });
+  if (!bundle) return finish({ ok: false, reason: `the facts took longer than ${Math.round(budgetMs / 1000)} seconds to read` });
+  // the desk builds its question cards from these facts while the model works
+  try { onBundle(bundle); } catch { /* the desk's copy is a convenience */ }
+
+  // one model call the swarm can stop; none starts once the budget is spent,
+  // even when the stop timer has not had its turn yet
+  async function call(fn, prompt, opts) {
+    if (over || left() <= 0) return { ok: false, reason: 'the time for this idea ran out', stopped: true };
+    const ac = new AbortController();
+    live.add(ac);
+    try {
+      return await fn(prompt, { ...opts, signal: ac.signal });
+    } catch (err) {
+      return { ok: false, reason: String((err && err.message) || err) };
+    } finally {
+      live.delete(ac);
     }
-    const parsed = parseBet(answer.text);
-    const check = parsed.error ? { ok: false, reasons: [parsed.error], formatOnly: false } : validateBet(parsed.bet, { bundle, today, previousTitle, avoidTitles: avoid, allowTeamMetrics });
-    return { parsed, check, base, raw: answer.text };
-  }
-  const save = (r, extra = {}) => saveAttempt(attemptsFile, { ...r.base, kind: 'writer', model_ok: true, raw: String(r.raw).slice(0, 20000), parse: r.parsed.error || 'ok', passed: r.check.ok, reasons: r.check.reasons, ...extra });
-
-  for (let attempt = 1; attempt <= WRITER_ATTEMPTS; attempt += 1) {
-    emit({ kind: 'model', line: MODEL_LINES[strategy] });
-    // 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, 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);
-
-    // only length or sentence limits broken: one free trim turn, same try
-    if (!r.check.ok && r.check.formatOnly) {
-      emit({ kind: 'model', line: MODEL_LINES.trim });
-      const original = r.parsed.bet;
-      const trimmed = await ask(buildTrimPrompt(JSON.stringify(original), r.check.reasons), attempt, 'trim', avoid);
-      if (trimmed.failed) return { ok: false, reason: trimmed.failed, bundle };
-      if (!trimmed.parsed.error && trimChangedMore(original, trimmed.parsed.bet)) {
-        trimmed.check = { ok: false, reasons: ['the trim changed more than the fields over a limit'], formatOnly: false };
+  }
+
+  async function lane(index) {
+    const laneNo = index + 1;
+    const angle = n > 1 ? WRITER_ANGLES[index % WRITER_ANGLES.length] : null;
+    // How each try is asked. first: a fresh bet. patch: fix the last answer
+    // against the reasons (code rejects, or a skeptic fail that names no
+    // blocker). blocker: the skeptic named what must be true first, so the
+    // next bet is clearing that blocker, a new move with its own target.
+    // trim: inside a try, a free turn that only shortens fields over a limit.
+    let strategy = 'first';
+    let reason = null;
+    let previousAnswer = null;
+    let blocker = null;
+    const blocked = [];
+    const tag = { lane: laneNo, ...(angle ? { angle: angle.key } : {}) };
+
+    // one writer call and its code check, saved to the attempts log
+    async function ask(prompt, attempt, how, avoid) {
+      let lastSaid = 0;
+      const started = clock();
+      const answer = await call(run, prompt, {
+        cwd,
+        onProgress: ({ text = '' }) => {
+          if (over) return;
+          const at = clock();
+          if (at - lastSaid < 1200) return;
+          lastSaid = at;
+          const w = wordCount(text);
+          emit({ kind: 'thinking', line: w ? `thinking... ${commas(w)} words written` : 'thinking...', n: w, lane: laneNo });
+        },
+      });
+      const base = { at: new Date(clock()).toISOString(), workspace: workspaceRoot, today, attempt, strategy: how, ...tag, ...(how === 'blocker' ? { blocker: blocker.missing_first } : {}), previous_title: previousTitle, avoid_titles: avoid.length, ms: clock() - started };
+      if (!answer.ok) {
+        saveAttempt(attemptsFile, { ...base, kind: 'writer', model_ok: false, ...(answer.stopped ? { stopped: true } : {}), raw: null, parse: null, passed: false, reasons: [answer.reason] });
+        return { failed: answer.reason, stopped: Boolean(answer.stopped), base };
       }
-      save(trimmed);
-      r = trimmed;
+      const parsed = parseBet(answer.text);
+      const check = parsed.error ? { ok: false, reasons: [parsed.error], formatOnly: false } : validateBet(parsed.bet, { bundle, today, previousTitle, avoidTitles: avoid, allowTeamMetrics });
+      return { parsed, check, base, raw: answer.text };
     }
+    const save = r => saveAttempt(attemptsFile, { ...r.base, kind: 'writer', model_ok: true, raw: String(r.raw).slice(0, 20000), parse: r.parsed.error || 'ok', passed: r.check.ok, reasons: r.check.reasons });
+
+    for (let attempt = 1; attempt <= WRITER_ATTEMPTS; attempt += 1) {
+      if (over) return;
+      // a writer that cannot finish inside the budget is never started, the first one included
+      if (left() < writeMin) { ends.push({ lane: laneNo, out_of_time: true, reason }); return; }
+      emit({ kind: 'model', line: MODEL_LINES[strategy], ...tag });
+      // a blocked idea is not shown again as a patch
+      const avoid = [...avoidTitles, ...blocked];
+      const angleText = angle ? angle.text : null;
+      const prompt = strategy === 'blocker'
+        ? buildPrompt(bundle, { today, previousTitle, blocker, avoidTitles: avoid, reworkOf, ownerNote, angle: angleText, concern })
+        : buildPrompt(bundle, { today, previousTitle, reason, previousAnswer, avoidTitles: avoid, reworkOf, ownerNote, angle: angleText, concern });
+      let r = await ask(prompt, attempt, strategy, avoid);
+      if (over) return;
+      if (r.failed) { ends.push({ lane: laneNo, model_failed: true, reason: r.failed }); return; }
+      save(r);
+
+      // only length or sentence limits broken: one free trim turn, same try
+      if (!r.check.ok && r.check.formatOnly) {
+        emit({ kind: 'model', line: MODEL_LINES.trim, ...tag, say: SWARM_SAY.shorten });
+        const original = r.parsed.bet;
+        const trimmed = await ask(buildTrimPrompt(JSON.stringify(original), r.check.reasons), attempt, 'trim', avoid);
+        if (over) return;
+        if (trimmed.failed) { ends.push({ lane: laneNo, model_failed: true, reason: trimmed.failed }); return; }
+        if (!trimmed.parsed.error && trimChangedMore(original, trimmed.parsed.bet)) {
+          trimmed.check = { ok: false, reasons: ['the trim changed more than the fields over a limit'], formatOnly: false };
+        }
+        save(trimmed);
+        r = trimmed;
+      }
 
-    previousAnswer = r.parsed.error ? null : JSON.stringify(r.parsed.bet);
-    if (!r.check.ok) {
-      strategy = 'patch';
-      reason = r.check.reasons.slice(0, 4).join('; ');
-      emit({ kind: 'reject', line: `${ORDINALS[attempt - 1]} answer turned down: ${reason}` });
-      continue;
-    }
+      previousAnswer = r.parsed.error ? null : JSON.stringify(r.parsed.bet);
+      if (!r.check.ok) {
+        strategy = 'patch';
+        reason = r.check.reasons.slice(0, 4).join('; ');
+        turnedDown += 1;
+        const again = attempt < WRITER_ATTEMPTS && left() >= writeMin;
+        emit({ kind: 'reject', line: `${ORDINALS[attempt - 1]} answer turned down: ${reason}`, ...tag, ...(again ? { say: SWARM_SAY.redraft } : {}) });
+        continue;
+      }
 
-    // the code checks passed; now a second model judges whether it makes sense
-    const bet = cleanBet(r.parsed.bet, today, bundle);
-    emit({ kind: 'skeptic', line: 'a second model is checking that it makes sense' });
-    const judgedAt = clock();
-    const said = await judge(buildSkepticPrompt(bet, bundle, { today }), { cwd: workspaceRoot, onProgress: () => {} });
-    const skepticBase = { ...r.base, kind: 'skeptic', at: new Date(clock()).toISOString(), ms: clock() - judgedAt, title: bet.title };
-    if (!said.ok) {
-      saveAttempt(attemptsFile, { ...skepticBase, model_ok: false, raw: null, parse: null, passed: false, reasons: [said.reason] });
-      return { ok: false, reason: `the skeptic could not check the bet: ${said.reason}`, bundle };
-    }
-    const judged = parseVerdict(said.text);
-    const passed = !judged.error && skepticPassed(judged.verdict);
-    saveAttempt(attemptsFile, {
-      ...skepticBase,
-      model_ok: true,
-      raw: String(said.text).slice(0, 20000),
-      parse: judged.error || 'ok',
-      verdict: judged.verdict || null,
-      passed,
-      reasons: judged.error ? [judged.error] : (passed ? [] : [judged.verdict.reason]),
-    });
-    if (judged.error) return { ok: false, reason: `the skeptic could not check the bet: ${judged.error}`, bundle };
-    if (passed) {
-      emit({ kind: 'check', line: 'checked the bet: every rule passed and the skeptic agreed' });
-      return { ok: true, bet: { ...bet, skeptic: judged.verdict }, bundle, attempts: attempt };
-    }
-    reason = skepticReason(judged.verdict);
-    const missing = blockerOf(judged.verdict);
-    if (missing) {
-      strategy = 'blocker';
-      blocker = { title: bet.title, missing_first: missing };
-      blocked.push(bet.title);
-    } else {
-      strategy = 'patch';
+      // the code checks passed; now a second model judges whether it makes sense
+      const bet = cleanBet(r.parsed.bet, today, bundle);
+      const draft = { bet, lane: laneNo, attempt, verdict: null, order: drafts.length };
+      drafts.push(draft);
+      if (left() < judgeMin) { draft.unjudged = 'no time left to check it'; ends.push({ lane: laneNo, out_of_time: true, reason }); return; }
+      checking += 1;
+      emit({ kind: 'skeptic', line: 'a second model is checking that it makes sense', ...tag, say: SWARM_SAY.checking(checking) });
+      const judgedAt = clock();
+      const said = await call(judge, buildSkepticPrompt(bet, bundle, { today }), { cwd, onProgress: () => {} });
+      const skepticBase = { ...r.base, kind: 'skeptic', at: new Date(clock()).toISOString(), ms: clock() - judgedAt, title: bet.title };
+      if (!said.ok) {
+        saveAttempt(attemptsFile, { ...skepticBase, model_ok: false, ...(said.stopped ? { stopped: true } : {}), raw: null, parse: null, passed: false, reasons: [said.reason] });
+        if (over) return;
+        draft.unjudged = `the skeptic could not check the bet: ${said.reason}`;
+        ends.push({ lane: laneNo, reason: draft.unjudged });
+        return;
+      }
+      const judged = parseVerdict(said.text);
+      const passed = !judged.error && skepticPassed(judged.verdict);
+      saveAttempt(attemptsFile, {
+        ...skepticBase,
+        model_ok: true,
+        raw: String(said.text).slice(0, 20000),
+        parse: judged.error || 'ok',
+        verdict: judged.verdict || null,
+        passed,
+        reasons: judged.error ? [judged.error] : (passed ? [] : [judged.verdict.reason]),
+      });
+      if (over) return;
+      if (judged.error) {
+        draft.unjudged = `the skeptic could not check the bet: ${judged.error}`;
+        ends.push({ lane: laneNo, reason: draft.unjudged });
+        return;
+      }
+      draft.verdict = judged.verdict;
+      if (passed) {
+        winner = draft;
+        emit({ kind: 'check', line: 'checked the bet: every rule passed and the skeptic agreed', ...tag, say: SWARM_SAY.heldUp });
+        stop('pass');
+        return;
+      }
+      reason = skepticReason(judged.verdict);
+      turnedDown += 1;
+      const missing = blockerOf(judged.verdict);
+      if (missing) {
+        strategy = 'blocker';
+        blocker = { title: bet.title, missing_first: missing };
+        blocked.push(bet.title);
+      } else {
+        strategy = 'patch';
+      }
+      emit({ kind: 'reject', line: `${ORDINALS[attempt - 1]} answer turned down: ${reason}`, ...tag, say: SWARM_SAY.notHeld });
     }
-    emit({ kind: 'reject', line: `${ORDINALS[attempt - 1]} answer turned down: ${reason}` });
+    ends.push({ lane: laneNo, reason });
   }
-  return { ok: false, reason: `the model's answer was turned down ${WRITER_ATTEMPTS} times (${reason})`, bundle };
+
+  emit({ kind: 'swarm', line: `${plural(n, 'writer')} at once`, n, say: SWARM_SAY.drafting(n) });
+  const lanes = Array.from({ length: n }, (_, i) => lane(i).catch((err) => { ends.push({ lane: i + 1, reason: String((err && err.message) || err) }); }));
+  Promise.all(lanes).then(() => stop('done'));
+  await ended;
+  finish();
+
+  if (over === 'stopped') return { ok: false, stopped: true, reason: 'stopped before an idea was picked', bundle };
+  if (winner) return { ok: true, bet: { ...winner.bet, skeptic: winner.verdict }, bundle, attempts: winner.attempt, lane: winner.lane, checked: true };
+  // none passed: the best draft is still a card the owner can act on
+  const best = [...drafts].sort((a, b) => draftRank(a) - draftRank(b) || a.order - b.order)[0];
+  if (best) {
+    const why = best.verdict ? skepticReason(best.verdict) : best.unjudged;
+    emit({ kind: 'fallback', line: `no draft passed every check${over === 'budget' ? ' in time' : ''}; showing the best one: ${why}`, say: SWARM_SAY.outOfTime });
+    return { ok: true, bet: { ...best.bet, skeptic: best.verdict || null, concern: ownerConcern(best) }, bundle, attempts: best.attempt, lane: best.lane, checked: false, reason: why };
+  }
+  emit({ kind: 'none', line: 'no draft met the plain rules', say: SWARM_SAY.nothing });
+  const failedAll = ends.length > 0 && ends.every(e => e.model_failed);
+  const last = [...ends].reverse().find(e => e.reason);
+  if (failedAll) return { ok: false, reason: ends[0].reason, bundle };
+  if (ends.length > 0 && ends.every(e => e.out_of_time) && !turnedDown) return { ok: false, reason: `no time was left to draft inside ${Math.round(budgetMs / 1000)} seconds once the facts were read`, bundle };
+  if (over === 'budget') return { ok: false, reason: `nothing usable came back in ${Math.round(budgetMs / 1000)} seconds${last ? ` (${last.reason})` : ''}`, bundle };
+  return { ok: false, reason: `the model's answer was turned down ${plural(turnedDown, 'time')} (${last ? last.reason : 'no answer met the rules'})`, bundle };
 }
 
 // ---- do it: the mission -------------------------------------------------------------------
@@ -2456,7 +2824,8 @@ function queuedProblem(bet, team) {
 
 // ideas kept ready ahead; one is written again the moment one is shown
 const QUEUE_TARGET = 3;
-// one generation at a time; the cap of 3 calls in flight per session is never reached
+// one drafting at a time (each runs up to three model calls at once, the
+// swarm); the cap of 3 draftings in flight per session is never reached
 const MAX_IN_FLIGHT = 1;
 const SESSION_IN_FLIGHT_CAP = 3;
 const STALE_MS = 6 * 60 * 60 * 1000;
@@ -2562,7 +2931,7 @@ function createBetDesk(deps) {
   // queued bets live in the ledger, so a restart or a reload wastes nothing
   for (const row of readLedger(deps.ledgerFile, deps.workspaceRoot)) {
     if (row.status !== 'queued' || !row.bet) continue;
-    state.queue.push({ id: row.id, bet: row.bet, created_at: Date.parse(row.created_at) || 0 });
+    state.queue.push({ id: row.id, bet: row.bet, created_at: Date.parse(row.created_at) || 0, ...(row.state_key ? { state_key: row.state_key } : {}), ...(row.rework_of ? { rework_of: row.rework_of } : {}) });
   }
 
   // the team, read once: a queued bet whose members are not on it is not shown
@@ -2573,12 +2942,52 @@ function createBetDesk(deps) {
     team = null;
   }
 
-  // Old bets go: older than 6 hours, or made under rules that have changed
-  // since. Each is marked stale with why, and the queue refills behind them.
+  // What a prepared idea was written from on the owner's side: his answers
+  // to the question cards and his own number. An idea written before either
+  // changed would not know what he just said, so it is never shown.
+  function ownerStateKey() {
+    const focus = Object.values(readFocus(focusFile, deps.workspaceRoot)).map(a => [String(a.key), String(a.label)]).sort((a, b) => a[0].localeCompare(b[0]));
+    const board = readScoreboard(scoreboardFile, deps.workspaceRoot);
+    const last = board && board.reports.length ? board.reports[board.reports.length - 1].value : null;
+    return crypto.createHash('sha256').update(JSON.stringify({ focus, board: board ? [board.name, board.up, board.source, last] : null })).digest('hex').slice(0, 12);
+  }
+
+  // Titles the owner already saw or turned down: shown, passed, skipped, or started.
+  const SEEN = new Set(['proposed', 'passed', 'skipped', 'doing']);
+  function seenTitles() {
+    return readLedger(deps.ledgerFile, deps.workspaceRoot).filter(r => r.bet && r.bet.title && (SEEN.has(r.status) || r.shown_at)).map(r => ({ id: r.id, title: r.bet.title }));
+  }
+
+  // The number an idea starts from, as it was when it was written, against
+  // the newest facts read: when it moved, the idea's numbers are old.
+  function startMoved(bet) {
+    const t = bet && bet.target;
+    const m = t && state.bundle ? bundleMetrics(state.bundle)[t.metric] : null;
+    if (!m || !Number.isFinite(m.baseline) || !Number.isFinite(t.baseline) || m.baseline === t.baseline) return null;
+    return `the number it starts from moved: ${commas(t.baseline)} then, ${commas(m.baseline)} now`;
+  }
+
+  // Why a prepared idea can no longer be shown, or null while it is fresh:
+  // older than 6 hours, made under rules that changed since, written before
+  // the owner's newest answer or number, too close to one he already saw or
+  // turned down, or its starting number moved.
+  function staleWhy(item, seen) {
+    if (now() - item.created_at > STALE_MS) return 'older than 6 hours';
+    const rule = queuedProblem(item.bet, team);
+    if (rule) return rule;
+    if (item.state_key && item.state_key !== ownerStateKey()) return 'written before the owner\'s newest answer';
+    // a rework of the idea the owner wrote a note on may stay close to it
+    const close = seen.find(s => s.id !== item.id && s.title !== item.rework_of && nearDuplicate(item.bet.title, s.title));
+    if (close) return `too close to one already shown: ${clip(close.title, 80)}`;
+    return startMoved(item.bet);
+  }
+
+  // Old bets go. Each is marked stale with why, and the queue refills behind them.
   function dropStale() {
     const keep = [];
+    const seen = state.queue.length ? seenTitles() : [];
     for (const item of state.queue) {
-      const why = now() - item.created_at > STALE_MS ? 'older than 6 hours' : queuedProblem(item.bet, team);
+      const why = staleWhy(item, seen);
       if (why) {
         record(item.id, { status: 'stale', stale_reason: why });
         log({ card: 'bet', choice: 'stale', command: null, ran: 'in process', exit_code: 0, bet_id: item.id, why });
@@ -2990,12 +3399,118 @@ function createBetDesk(deps) {
   // page brings the idea in once it is written
   const WAIT_CARD = { what: 'writing your next idea.' };
   function showWait() {
-    state.current = { kind: 'wait', id: `wait:${now()}` };
+    // already the calm line: it stays, with its id and the notes typed on it
+    if (state.status === 'ready' && state.current && state.current.kind === 'wait') return;
+    state.current = { kind: 'wait', id: `wait:${now()}`, shown_at: now(), lines: [] };
     state.status = 'ready';
     state.mission = null;
     state.error = null;
     log({ card: 'bet', choice: 'show', command: null, ran: 'in process', exit_code: 0, kind: 'wait' });
   }
+  const onWait = () => state.status === 'ready' && Boolean(state.current) && state.current.kind === 'wait';
+
+  // Words typed on the calm line are a note for the idea being written: no
+  // read, no new card. The next drafting starts with them (one under way
+  // that nobody asked for is stopped for it), and the calm line waits for
+  // that idea; one written without them is kept for later. It waits only
+  // while that idea is still being written, and at most NOTE_HOLD_MS, a
+  // drafting's own budget. Past that the ready idea comes in on its own
+  // with NOTE_FOLDING as its line, and the idea written with the note is
+  // the next card after it (state.noteComing), never swapped in under him.
+  const NOTE_HOLD_MS = SWARM_BUDGET_MS;
+  const WAIT_NOTE_ACK = 'got it, i\'ll fold that in.';
+  const NOTE_FOLDING = 'your note is still being folded in. that version comes next.';
+  // the newest notes that fit in one note's room, oldest first
+  function joinNotes(notes) {
+    let out = '';
+    for (let i = notes.length - 1; i >= 0; i -= 1) {
+      const more = out ? `${notes[i]}; ${out}` : notes[i];
+      if (more.length > SAY_MAX) break;
+      out = more;
+    }
+    return out || notes[notes.length - 1].slice(0, SAY_MAX);
+  }
+  function noteOnWait(cur, said) {
+    if (!cur.notes && state.pendingSharper && state.pendingSharper.ownerNote) cur.notes = [state.pendingSharper.ownerNote];
+    cur.notes = [...(cur.notes || []), said].slice(-3);
+    cur.note = joinNotes(cur.notes);
+    cur.noteAt = now();
+    state.pendingSharper = { ...(state.pendingSharper || {}), ownerNote: cur.note };
+    log({ card: 'bet', choice: 'wait_note', command: null, ran: 'in process', exit_code: 0, kind: 'wait', chars: said.length });
+    pump();
+    return { ok: true, noted: true, ack: WAIT_NOTE_ACK };
+  }
+  // the idea written with the newest note: the calm line's own, or one still coming after an idea shown without it
+  const notedAt = (cur) => {
+    const note = cur && cur.kind === 'wait' && cur.note ? cur.note : state.noteComing;
+    return note ? state.queue.findIndex(i => i.owner_note === note) : -1;
+  };
+  function waitHolds() {
+    const cur = state.current;
+    if (!onWait() || !cur.note || notedAt(cur) >= 0) return false;
+    return (state.inFlight > 0 || Boolean(state.pendingSharper)) && now() - cur.noteAt < NOTE_HOLD_MS;
+  }
+  // a note already on its way: waiting to start, being written, or ready
+  const noteUnderWay = note => Boolean((state.pendingSharper && state.pendingSharper.ownerNote === note)
+    || (state.gen && !state.gen.stopping && state.gen.asks && state.gen.asks.ownerNote === note)
+    || state.queue.some(i => i.owner_note === note));
+  // the notes typed on the calm line, and the answer to them
+  function waitThread(cur) {
+    const thread = (cur.notes || []).map(text => ({ who: 'owner', text }));
+    if (thread.length) thread.push({ who: 'orb', text: WAIT_NOTE_ACK });
+    return thread;
+  }
+
+  // How the waiting card shows it is alive: the plain lines of the drafting
+  // it waits on (the one running when it showed, or the one that took over
+  // when that was stopped), newest last, and when that drafting began.
+  const WAIT_LINES = 6;
+  function waitProgress(cur) {
+    const was = cur.waitsOn;
+    if (state.gen && (!was || (was.stopping && was !== state.gen))) {
+      // the line that says why it started over stays on the card
+      if (was && was.stopSay) cur.lines = [...(cur.lines || []), { at: was.stopped_at, line: was.stopSay }];
+      cur.waitsOn = state.gen;
+    }
+    const g = cur.waitsOn || null;
+    const said = g ? g.events.filter(e => e.say).map(e => ({ at: e.at, line: e.say })) : [];
+    if (g && g.stopping && g.stopSay) said.push({ at: g.stopped_at, line: g.stopSay });
+    const lines = [...(cur.lines || []), ...said].sort((a, b) => a.at - b.at).slice(-WAIT_LINES);
+    const startedAt = g ? g.started_at : (cur.shown_at || now());
+    return { progress: lines, started_at: startedAt, waited_ms: Math.max(0, now() - startedAt) };
+  }
+
+  // The wait ended with no draft that met the plain rules (the model is down,
+  // or every draft broke a rule): a card the owner can act on, never an error.
+  const MISSED_CARD = { what: 'no idea came together this time.' };
+  // It remembers the wait it ended (after, and the id that wait was served
+  // under), so words the owner was typing there still count.
+  function showMissed() {
+    const was = state.current && state.current.kind === 'wait' ? state.current : null;
+    const servedWait = was && state.served && state.served.kind === 'wait' ? state.served.id : null;
+    state.current = { kind: 'missed', id: `missed:${now()}`, ...(was ? { after: was.id, afterServed: servedWait, ...(was.note ? { note: was.note, notes: was.notes } : {}) } : {}) };
+    state.status = 'ready';
+    state.mission = null;
+    state.error = null;
+    log({ card: 'bet', choice: 'show', command: null, ran: 'in process', exit_code: 0, kind: 'missed' });
+  }
+
+  // The owner asked for something (a sharper idea, words on a card): a
+  // background top-up still drafting is stopped, so his ask starts now
+  // instead of after it.
+  function makeRoomFor() {
+    if (state.gen && !state.gen.asked && !state.gen.stopping) state.gen.stop('the owner asked for something', 'starting a new one for what you asked');
+  }
+
+  // Which ready idea goes next: one the owner asked for first, then a
+  // checked one; one a second look worried about waits behind them.
+  function nextIndex() {
+    if (!state.queue.length) return -1;
+    if (state.queue[0].asked) return 0;
+    const i = state.queue.findIndex(item => !item.bet.concern);
+    return i >= 0 ? i : 0;
+  }
+  const checkedReady = () => state.queue.filter(item => !item.bet.concern);
 
   function showQuestion(item) {
     if (!LOCAL_QUESTIONS.has(item.question.key)) appendLedger(questionsFile, { id: item.question.key, workspace: deps.workspaceRoot, status: 'shown', shown_at: iso() });
@@ -3009,7 +3524,7 @@ function createBetDesk(deps) {
   // a re-tap on a job card moves on: a yes waits for a later session, a done is seen.
   // later: not now on a yes, which also sends it to the back of the job deck
   function passJob(item, { later = false } = {}) {
-    if (item.kind === 'wait') return;
+    if (item.kind === 'wait' || item.kind === 'missed') return;
     if (item.kind === 'report') { state.passedQuestions.add(item.id); return; }
     if (item.kind === 'choice') {
       for (const i of item.items) record(i.id, { status: 'passed', note: 'not picked' });
@@ -3044,18 +3559,31 @@ function createBetDesk(deps) {
     state.retry = setTimer(() => { state.retry = null; pump(); }, BACKOFF_MS);
   }
 
-  function startGeneration({ sharperOf = null, reworkOf = null, ownerNote = null } = {}) {
+  function startGeneration({ sharperOf = null, reworkOf = null, ownerNote = null, concern = 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);
     state.run += 1;
-    const gen = { run: state.run, events: [], sharperOf };
+    // what the idea is written from on the owner's side, read before it starts
+    const key = ownerStateKey();
+    const stopper = new AbortController();
+    const asks = { sharperOf, reworkOf, ownerNote, concern };
+    const gen = { run: state.run, events: [], sharperOf, started_at: now(), key, asked: Boolean(sharperOf || ownerNote), asks, stopping: false };
+    // stops every model call this drafting has running; its answer is dropped.
+    // say: the plain line the waiting card shows for it
+    gen.stop = (why, say = null) => {
+      if (gen.stopping) return;
+      gen.stopping = why || true;
+      gen.stopSay = say;
+      gen.stopped_at = now();
+      stopper.abort();
+    };
     state.gen = gen;
     const emit = (ev) => { gen.events.push({ i: gen.events.length, at: now(), ...ev }); };
     // 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(), ...(ownerNote ? { reworkOf, ownerNote } : {}), emit, onBundle: (b) => { state.bundle = b; } }));
+      started = Promise.resolve(generate({ workspaceRoot: deps.workspaceRoot, today: dayKey(now()), previousTitle: sharperOf, avoidTitles: avoidTitles(), ...(ownerNote ? { reworkOf, ownerNote } : {}), ...(concern ? { concern } : {}), signal: stopper.signal, emit, onBundle: (b) => { state.bundle = b; } }));
     } catch (err) {
       started = Promise.reject(err);
     }
@@ -3065,18 +3593,39 @@ function createBetDesk(deps) {
         state.inFlight -= 1;
         if (state.gen === gen) state.gen = null;
         if (out.bundle) state.bundle = out.bundle;
+        // stopped on purpose: not a failure, and an ask it carried is asked again
+        if (gen.stopping || out.stopped) {
+          log({ card: 'bet', choice: 'generate', command: null, ran: 'in process', exit_code: 0, stopped: clip(String(gen.stopping === true ? 'stopped' : gen.stopping || 'stopped'), 120) });
+          if (gen.asked && !state.pendingSharper) state.pendingSharper = asks;
+          return pump();
+        }
         if (!out.ok) {
-          // a failure stays in the log; the owner never waits on it or sees it
+          // a failure stays in the log; the owner never sees the reason
           log({ card: 'bet', choice: 'generate', command: null, ran: 'in process', exit_code: 1, error: clip(out.reason, 200) });
           emit({ kind: 'failed', line: out.reason });
           state.failures += 1;
           if (state.failures >= MAX_BACKGROUND_FAILURES) backOff();
+          // the owner is waiting on the calm line: the wait ends in a card he can act on
+          if (onWait()) showMissed();
+          return pump();
+        }
+        const item = { id: newId(), bet: out.bet, created_at: now(), state_key: key, ...(gen.asked ? { asked: true } : {}), ...(ownerNote && reworkOf ? { rework_of: reworkOf } : {}), ...(ownerNote ? { owner_note: ownerNote } : {}) };
+        // stale the moment it lands (too close to one just shown): counted as
+        // a failure, so a writer that keeps landing there rests instead of looping
+        const staleNow = staleWhy(item, seenTitles());
+        if (staleNow) {
+          log({ card: 'bet', choice: 'generate', command: null, ran: 'in process', exit_code: 1, error: clip(`stale on arrival: ${staleNow}`, 200) });
+          state.failures += 1;
+          if (state.failures >= MAX_BACKGROUND_FAILURES) {
+            backOff();
+            // resting now, so nothing is drafting for a wait on screen
+            if (onWait()) showMissed();
+          }
           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, ...(ownerNote ? { rework_of: reworkOf, owner_note: ownerNote } : {}) });
-        log({ card: 'bet', choice: 'generate', command: null, ran: 'in process', exit_code: 0, bet_id: item.id });
+        record(item.id, { created_at: iso(), status: 'queued', bet: out.bet, state_key: key, checked: out.checked !== false && !out.bet.concern, 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, checked: out.checked !== false && !out.bet.concern, ms: now() - gen.started_at });
         emit({ kind: 'done', line: 'bet ready' });
         // the sharper or reworked idea the owner asked for is the next shown
         if (sharperOf || ownerNote) state.queue.unshift(item);
@@ -3095,6 +3644,10 @@ function createBetDesk(deps) {
     pumpQuestions();
     pumpSuggestions();
     dropStale();
+    // the owner answered or picked a number since this drafting began: what
+    // it writes would not know that, so it stops and a fresh one starts
+    if (state.gen && !state.gen.stopping && state.gen.key !== ownerStateKey()) state.gen.stop('the owner answered something new', 'starting over with your newest answer');
+    if (state.pendingSharper) makeRoomFor();
     if (state.inFlight >= MAX_IN_FLIGHT) return state.gen && state.gen.done;
     if (state.pendingSharper) {
       const asked = state.pendingSharper;
@@ -3125,6 +3678,10 @@ function createBetDesk(deps) {
   function next({ sharper = false, later = false } = {}) {
     if (state.status === 'starting') return { ok: true, busy: true, ...view() };
     const onScreen = state.status === 'ready' && state.current ? state.current : null;
+    // try again after a wait that ended with a note on it: the note goes into the next
+    // drafting, or the calm line joins the one already writing it, never a second
+    const carried = onScreen && onScreen.kind === 'missed' && onScreen.note ? onScreen : null;
+    if (carried && !state.pendingSharper && !noteUnderWay(carried.note)) state.pendingSharper = { ownerNote: carried.note };
     // passed, skipped, or answered: the card after a yes is never another yes
     const afterYes = Boolean(state.current && state.current.kind === 'yes');
     if (onScreen && onScreen.kind && onScreen.kind !== 'bet') {
@@ -3132,7 +3689,9 @@ function createBetDesk(deps) {
     } 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 };
+      // sharpening one a second look worried about: the new draft must answer the worry
+      const worry = onScreen.bet.concern && onScreen.bet.skeptic && onScreen.bet.skeptic.reason;
+      if (sharper) state.pendingSharper = { sharperOf: onScreen.bet.title, ...(worry ? { concern: worry } : {}) };
     } else {
       log({ card: 'bet', choice: 'think', command: null, ran: 'in process', exit_code: 0 });
     }
@@ -3140,15 +3699,28 @@ function createBetDesk(deps) {
     if (now() - state.jobs.at > 5000) pollJobs();
     const job = nextJobCard({ afterYes });
     const ask = job ? null : askCard();
+    const checked = checkedReady();
+    const noted = notedAt(onScreen);
+    // the calm line's note is not in yet and its wait is over: the ready idea comes on its own, saying so
+    const folding = noted < 0 && onScreen && onScreen.kind === 'wait' && onScreen.note ? onScreen.note : null;
     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());
+    // the idea written with the note comes in on its own
+    else if (noted >= 0) { show(state.queue.splice(noted, 1)[0]); state.noteComing = null; }
+    else if (folding && state.queue.length) { show(state.queue.splice(nextIndex(), 1)[0]); state.current.folding = true; state.noteComing = folding; }
+    // two or more checked ideas ready: one card to pick from; one a second look worried about is never in it
+    else if (deps.choices !== false && checked.length >= 2) {
+      const items = checked.slice(0, CHOICE_MAX);
+      state.queue = state.queue.filter(item => !items.includes(item));
+      showChoice(items);
+    } else if (state.queue.length) show(state.queue.splice(nextIndex(), 1)[0]);
     else {
       const question = nextQuestion();
       if (question) showQuestion(question);
       else {
         showWait();
+        // after try again the calm line carries the note: it shows it and waits for the idea written with it
+        if (carried && state.current.kind === 'wait' && !state.current.note) Object.assign(state.current, { notes: carried.notes || [carried.note], note: carried.note, noteAt: now() });
         // the card says an idea is being written, so one is, even mid backoff
         if (!state.gen) { state.failures = 0; state.backoffUntil = 0; }
       }
@@ -3447,7 +4019,7 @@ function createBetDesk(deps) {
       id: cur ? cur.id : null,
       kind,
       bet: kind === 'bet' ? cur.bet : null,
-      job: kind === 'yes' || kind === 'done' ? publicJob(cur) : (kind === 'wait' ? { ...WAIT_CARD } : null),
+      job: kind === 'yes' || kind === 'done' ? publicJob(cur) : (kind === 'wait' ? { ...WAIT_CARD } : (kind === 'missed' ? { ...MISSED_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?`,
@@ -3501,6 +4073,7 @@ function createBetDesk(deps) {
   // 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' && v.bet.concern) return { kind: 'idea', title: v.bet.title, detail: [v.bet.why_now, v.bet.expect, v.bet.concern].join(' '), buttons: ['go with it', 'sharpen it', 'something else'] };
     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: ['save', 'not now'] };
@@ -3537,18 +4110,24 @@ function createBetDesk(deps) {
     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;
+    let cur = state.status === 'ready' ? state.current : null;
     if (!cur) return { ok: false, reason: 'gone', message: 'there is no card on screen' };
     // words said on a card the page no longer shows act on nothing
     if (card !== undefined && card !== cur.id) return { ok: false, reason: 'gone', message: 'that card changed, so nothing was done. tap the orb for the new one' };
-    const kind = cur.kind || 'bet';
+    // on the calm line there is nothing to answer: the words are a note for the idea being written, read by no model
+    if (cur.kind === 'wait') return noteOnWait(cur, said);
+    let 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
+      // the card moved on while it was read (a tap, do it): drop the reply.
+      // Not when a wait ended on its own (nothing came back): his words are
+      // said on the try-again card that took its place, never dropped
+      const replaced = kind === 'wait' && state.status === 'ready' && state.current && state.current.kind === 'missed' && state.current.after === cur.id;
+      if (replaced) { cur = state.current; kind = 'missed'; }
       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;
@@ -3732,33 +4311,7 @@ function createBetDesk(deps) {
       const loaded = (deps.loadSeason || (root => season.loadSeason(root, { now: now(), lastSeen: null })))(deps.workspaceRoot);
       if (loaded && !loaded.error) ratings = season.memberRatings(loaded.outcomes || []);
     } catch { ratings = new Map(); }
-    let resolve = deps.resolveEngine;
-    if (!resolve) {
-      const reg = require('./engine-registry');
-      const { resolveEngineForMember } = require('./member-engine');
-      let rosterState = null;
-      try { rosterState = reg.readRosterState(deps.workspaceRoot); } catch { rosterState = null; }
-      resolve = name => resolveEngineForMember(name, deps.workspaceRoot, { quiet: true, ...(rosterState ? { rosterState } : {}) });
-    }
-    const facts = new Map();
-    const { memberTypeOf } = require('./member-type');
-    for (const m of team || []) {
-      const card = memberCardFacts(deps.workspaceRoot, m.name);
-      const kind = memberTypeOf({ type: card.type });
-      let engine = kind.type === 'human' ? 'person' : NO_RATING;
-      if (kind.runnable) {
-        let picked = null;
-        try { picked = resolve(m.name); } catch { picked = null; }
-        engine = engineWords(picked);
-      }
-      const rated = ratings.get(m.name);
-      facts.set(m.name, {
-        role: memberRoleWords(m.name, card),
-        ovr: !rated || !rated.finished ? NO_RATING : rated.ovr == null ? 'new' : String(rated.ovr),
-        engine,
-        parked: card.parked,
-      });
-    }
+    const facts = teamCells(deps.workspaceRoot, (team || []).map(m => m.name), { ratings, resolve: deps.resolveEngine || null });
     rosterCache = { at: now(), facts };
     return facts;
   }
@@ -3981,11 +4534,13 @@ function createBetDesk(deps) {
     }
     if (state.status !== 'ready') return null;
     const v = view();
-    if (kind === 'bet') return gmCard.idea({ id: cur.id, title: cur.bet.title, body: betBody(cur.bet) });
+    // an idea no draft beat in time carries the second look's worry, in one plain line
+    if (kind === 'bet') return gmCard.idea({ id: cur.id, title: cur.bet.title, body: betBody(cur.bet), ...(cur.bet.concern ? { concern: cur.folding ? `${cur.bet.concern} ${NOTE_FOLDING}` : cur.bet.concern } : {}), ...(cur.folding ? { line: NOTE_FOLDING } : {}) });
     if (kind === 'question') return gmCard.question({ id: cur.id, title: v.question.ask, body: v.question.line, choices: v.question.choices });
     if (kind === 'report') return gmCard.report({ id: cur.id, title: v.report.what, body: v.report.why });
     if (kind === 'choice') return gmCard.choice({ id: cur.id, items: v.choice.options });
-    if (kind === 'wait') return gmCard.wait({ id: cur.id });
+    if (kind === 'wait') return gmCard.wait({ id: cur.id, ...waitProgress(cur), thread: waitThread(cur) });
+    if (kind === 'missed') return gmCard.missed({ id: cur.id });
     if (kind === 'yes') {
       const j = cur.job;
       return gmCard.yes({ id: cur.id, title: v.job.what, body: v.job.why, job: jobFacts(j.owner), request: { job: j.mission_id, key: j.key, hash: j.lock_hash || null } });
@@ -4058,7 +4613,8 @@ function createBetDesk(deps) {
       ...extra,
       card: gmCard.wire(card),
       status: v.status,
-      queue: v.queue,
+      // ideas ready behind the card: none yet while the calm line waits for the one with its note
+      queue: waitHolds() ? 0 : v.queue,
       team_working: v.team_working,
       needs_you: v.needs_you,
     };
@@ -4092,7 +4648,12 @@ function createBetDesk(deps) {
   async function sayOnMain(text, more = {}) {
     const under = underCard();
     const out = await say({ text, ...more });
-    const back = replied(out, under.id, text);
+    // a note on the calm line: the same card stays, now with the note on it
+    if (out.noted) return done200({ ack: out.ack });
+    // a wait that ended on its own while the words were read: the reply sits on the card that took its place
+    const stays = out.stay || out.reason === 'needs_confirm';
+    const base = stays && under && under.kind === 'wait' && state.current && state.current.kind === 'missed' ? (underCard() || under) : under;
+    const back = replied(out, base.id, text);
     if (back) return back;
     if (!out.ok) return refuse(out.reason || 'gone', out.message || 'that did not send. try again');
     state.reply = null;
@@ -4125,11 +4686,25 @@ function createBetDesk(deps) {
   // from the footer. confirm: the second tap on an option that asks for one.
   async function act(body = {}) {
     const cardId = body.card_id == null || body.card_id === '' ? null : String(body.card_id);
-    const shown = state.served;
-    const stale = Boolean(cardId && (!shown || cardId !== shown.id));
+    let shown = state.served;
+    // the calm line's words change while the idea is written, under the same
+    // card: an id it was served under before still names it
+    const base = id => String(id).split('#')[0];
+    const same = Boolean(shown && cardId && (cardId === shown.id || (shown.kind === 'wait' && base(cardId) === base(shown.id))));
+    let stale = Boolean(cardId && !same);
+    // words typed on a wait that ended on its own (nothing came back) still
+    // count: they are said on the try-again card that took its place
+    const cur = state.status === 'ready' ? state.current : null;
+    if (stale && cur && cur.kind === 'missed' && cur.afterServed && base(cur.afterServed) === base(cardId) && typeof body.text === 'string' && body.text.trim() && body.option_id == null && !state.layer) {
+      state.reply = null;
+      shown = serve();
+      stale = false;
+    }
     // the big orb: the next card; a page that names an older card gets the one on screen, and nothing is passed
     if (body.orb === true) {
       if (stale && shown) return done200();
+      // the calm line waits for the idea written with its note
+      if (shown && shown.kind === 'wait' && waitHolds()) return done200();
       state.layer = null;
       state.reply = null;
       const out = next({ sharper: false });
@@ -4311,5 +4886,10 @@ module.exports = {
   stopWriters,
   scoreBets,
   skepticCommand,
+  buildSkepticPrompt,
+  writerCommand,
+  WRITER_ANGLES,
   validateBet,
+  teamBox,
+  teamCells,
 };