atris 3.74.4 → 3.74.6

package/lib/gm-bet.js

@@ -787,6 +787,68 @@ function readTeam(workspaceRoot) {
   return team.length ? team : null;
 }
 
+// ---- the team page's cells --------------------------------------------------------
+
+// what a cell shows when there is nothing true to put in it
+const NO_RATING = '\u00b7\u00b7';
+
+// role, description, type, and parked from one member's MEMBER.md
+// frontmatter. A card with neither role nor description gives a "role:"
+// line in its body, else its first plain paragraph.
+function memberCardFacts(workspaceRoot, name) {
+  let text = '';
+  try { text = fs.readFileSync(path.join(workspaceRoot, 'atris', 'team', name, 'MEMBER.md'), 'utf8'); } catch { text = ''; }
+  const block = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+  const head = block ? block[1] : '';
+  const field = k => ((new RegExp(`^${k}:\\s*(.+)$`, 'm').exec(head) || [])[1] || '').trim().replace(/^["']|["']$/g, '');
+  let role = field('role');
+  const description = field('description');
+  if (!role && !description) {
+    const body = block ? text.slice(block[0].length) : text;
+    const line = /^role:\s*(.+)$/im.exec(body);
+    const para = body.split(/\r?\n\s*\r?\n/).map(x => x.trim()).find(x => x && !/^[#>|`-]/.test(x));
+    role = line ? line[1].trim() : (para || '');
+  }
+  return { role, description, type: field('type'), parked: require('./member-park').isParkedText(text) };
+}
+
+// A role in a few words: up to its first full stop or colon, title-case
+// words lowercased (a name like CEO or YouTube keeps its letters), at most
+// six words.
+function roleWords(text) {
+  const first = String(text || '').split(/[.;:!?](?:\s|$)/)[0].replace(/\s+[-\u2013]\s+/g, ', ').trim();
+  const words = first.split(/\s+/).filter(Boolean).map(w => (/^\(?[A-Z][a-z'\u2019]*[,)]?$/.test(w) ? w.toLowerCase() : w));
+  if (!words.length) return NO_RATING;
+  return words.length > 6 ? `${words.slice(0, 6).join(' ').replace(/[,\s]+$/, '')}\u2026` : words.join(' ');
+}
+
+// The role cell for one card: its role, unless that only says the member's
+// own name ("builder" for builder), then its description.
+function memberRoleWords(name, card) {
+  const plain = w => String(w || '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+  const role = roleWords(card.role || card.description);
+  if (card.description && plain(role) === plain(name)) return roleWords(card.description);
+  return role;
+}
+
+// The tool and its exact model, the tool id then the roster's own label for
+// the model, from a member's resolved pick. Only a pinned model counts: a
+// tool alone is not a model.
+function engineWords(picked) {
+  const id = picked && picked.engine && picked.engine.id;
+  const model = picked && picked.model;
+  if (!id || !model) return NO_RATING;
+  const label = String(require('./engine-registry').rosterModelLabel(model) || model).trim();
+  return label.toLowerCase().startsWith(`${String(id).toLowerCase()} `) ? label : `${id} ${label}`;
+}
+
+// One plain sentence: the status, what it is on, and for how long.
+function statusSentence(row) {
+  if (!row || !row.on) return row && row.time ? `${row.status}, ${row.time}` : `${(row && row.status) || 'idle'}: no work in the last day`;
+  const on = /^[A-Z][a-z]/.test(row.on) ? row.on[0].toLowerCase() + row.on.slice(1) : row.on;
+  return `${row.status}: ${on}, ${row.time}`;
+}
+
 // 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 = [
@@ -1507,6 +1569,48 @@ function stepProblem(text) {
   return null;
 }
 
+// What a yes is for, as the owner reads it. A plain ask stays as written. A
+// held command, a handed-off job's own or one between backticks in an ask,
+// is said in words that keep its verb and its target: create or delete,
+// which release, which pull request, which branch, which repo. One that
+// cannot be said exactly says where it goes and shows what it names, and
+// never gets a friendlier verb.
+const ASK_TOOLS = { gh: 'GitHub', git: 'the git remote', npm: 'npm', pnpm: 'npm', yarn: 'npm', npx: 'npm', atris: 'Atris', curl: 'a web service', vercel: 'Vercel' };
+
+function plainAsk(text) {
+  const t = String(text || '').replace(/\s+/g, ' ').trim();
+  const tick = /`([^`]+)`/.exec(t);
+  const handed = /^(.{3,80}?\bwants to) (\S+)(.*)$/.exec(t);
+  let lead = null;
+  let cmd = '';
+  if (tick) cmd = tick[1].trim();
+  else if (handed && ASK_TOOLS[handed[2]]) { lead = handed[1]; cmd = `${handed[2]}${handed[3]}`.trim(); }
+  const words = cmd.split(' ').filter(Boolean);
+  if (!words.length || !ASK_TOOLS[words[0]]) return t;
+  // the guard keeps the first 120 characters: a cut command is never said in words
+  const exact = cmd.length < 120 ? require('./yes-lock').describeCommand(words) : null;
+  const what = exact || `run a command that changes ${ASK_TOOLS[words[0]]}: "${words.slice(1).join(' ')}"`;
+  return lead ? `${lead} ${what}` : `ok to ${what}?`;
+}
+
+// A job's work as plain words: code spans and flags are dropped, a path or
+// a file name reads "a file", and a command left bare goes. When too little
+// is left to read, it is the member's job.
+function plainWork(text, member) {
+  const t = String(text || '');
+  if (!STEP_CODE.some(re => re.test(t))) return t;
+  const kept = t.replace(/`[^`]*`/g, ' ')
+    .split(/\s+/)
+    .filter(w => w && !/^--?[a-z]/i.test(w))
+    .map(w => (/\/|\.(js|ts|tsx|sh|md|json|py|yml|yaml|txt|html|css|jsonl)\b/i.test(w) ? 'a file' : w))
+    .join(' ')
+    .replace(/\b(npm|npx|git|node|gh|atris)\s+[a-z-]+\b/gi, ' ')
+    .replace(/\s+([,.;:])/g, '$1')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return kept.split(' ').length >= 3 && !STEP_CODE.some(re => re.test(kept)) ? kept : `a job for ${member}`;
+}
+
 function sentenceCount(text) {
   return String(text || '').split(/[.!?]+(?:\s+|$)/).filter(x => x.trim()).length;
 }
@@ -2379,6 +2483,8 @@ const BACKOFF_MS = 10 * 60 * 1000;
 //   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)
+//   loadSeason(root)                          -> season, the board's 30 days of plays for each ovr (tests stub)
+//   resolveEngine(name)                       -> { engine, model }, the member's roster pick (tests stub)
 function createBetDesk(deps) {
   const now = deps.now || Date.now;
   const setTimer = deps.setTimer || ((fn, ms) => { const t = setTimeout(fn, ms); if (t.unref) t.unref(); return t; });
@@ -2438,6 +2544,11 @@ function createBetDesk(deps) {
     jobs: { working: [], yes: [], at: 0 },
     // yes cards passed over this session, so a re-tap moves on
     seenYes: new Set(),
+    // yeses said this session, by key, and nos; a yes only passed over is still owed
+    answeredYes: new Set(),
+    // yeses skipped with not now, in the order skipped: they wait at the back
+    skippedYes: new Map(),
+    skips: 0,
     // reviews running now, by bet id
     reviews: new Map(),
     // failed jobs being sent back to the team now, by bet id
@@ -2593,7 +2704,7 @@ function createBetDesk(deps) {
     // own; the yes always goes to the run that was held
     for (const card of require('./yes-lock').handoffYesCards(lockDir)) {
       const parent = [...working, ...yes].find(j => j.mission_id && j.mission_id === card.parent_mission_id) || null;
-      const where = parent ? { bet_id: parent.bet_id, title: parent.title, owner: parent.owner } : { bet_id: null, title: 'a handed-off job', owner: 'the handed-off job' };
+      const where = parent ? { bet_id: parent.bet_id, title: parent.title, owner: parent.owner } : { bet_id: null, title: 'a handed-off job', owner: card.who && card.who !== 'a handed-off job' ? card.who : 'the handed-off job' };
       yes.push({ kind: 'yes', ...where, mission_id: card.mission_id, ask: card.ask, command: card.command, lock_step: card.step, lock_hash: card.hash || null, ask_index: null, key: `${card.mission_id}:step-${card.step}:${card.hash || ''}` });
     }
     const expectOf = new Map(readLedger(deps.ledgerFile, deps.workspaceRoot).map(r => [r.id, r.bet && r.bet.expect]));
@@ -2677,10 +2788,19 @@ function createBetDesk(deps) {
       .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 yeses still owed, one per key: not answered yes or no this session.
+  function owedYes() {
+    const keys = new Set();
+    return state.jobs.yes.filter(j => !state.answeredYes.has(j.key) && !keys.has(j.key) && keys.add(j.key));
+  }
+
   // The next card that is not a bet: a yes the owner owes comes first, then
   // a finished job. Nothing pops on its own; these only come on the next tap.
-  function nextJobCard() {
-    const ask = state.jobs.yes.find(j => !state.seenYes.has(j.key));
+  // Yes cards never take over the screen: right after a yes, the next card is
+  // a normal one, and only a yes not seen yet comes up on its own. The rest
+  // wait behind the small need-you line, in the job deck.
+  function nextJobCard({ afterYes = false } = {}) {
+    const ask = afterYes ? null : owedYes().find(j => !state.seenYes.has(j.key));
     if (ask) return { kind: 'yes', id: `yes:${ask.key}`, job: ask };
     const done = doneJobs()[0];
     if (done) return { kind: 'done', id: `done:${done.bet_id}`, job: done };
@@ -2886,8 +3006,9 @@ function createBetDesk(deps) {
     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) {
+  // 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 === 'report') { state.passedQuestions.add(item.id); return; }
     if (item.kind === 'choice') {
@@ -2901,9 +3022,11 @@ function createBetDesk(deps) {
       log({ card: 'bet', choice: 'pass', command: null, ran: 'in process', exit_code: 0, kind: 'question', question: item.question.key });
       return;
     }
+    const skipped = later && item.kind === 'yes';
     if (item.kind === 'yes') state.seenYes.add(item.job.key);
+    if (skipped) { state.skips += 1; state.skippedYes.set(item.job.key, state.skips); }
     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 });
+    log({ card: 'bet', choice: skipped ? 'later' : 'pass', command: null, ran: 'in process', exit_code: 0, kind: item.kind, bet_id: item.job.bet_id });
   }
 
   pollJobs();
@@ -2998,11 +3121,14 @@ function createBetDesk(deps) {
   // 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 } = {}) {
+  // later: not now on a yes card.
+  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;
+    // 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') {
-      passJob(onScreen);
+      passJob(onScreen, { later });
     } 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 });
@@ -3012,7 +3138,7 @@ function createBetDesk(deps) {
     }
     dropStale();
     if (now() - state.jobs.at > 5000) pollJobs();
-    const job = nextJobCard();
+    const job = nextJobCard({ afterYes });
     const ask = job ? null : askCard();
     if (job) showJob(job);
     else if (ask) showAsk(ask);
@@ -3157,16 +3283,39 @@ function createBetDesk(deps) {
 
   // yes: answers the mission's open ask through atris decide, matched by
   // mission and ask, never by its place in a list
-  async function answerYes() {
-    const item = onJob('yes');
-    if (!item) return { ok: false, reason: 'gone', message: 'there is no question on screen' };
+  // A yes from the job deck names its key, and answers that job's yes
+  // wherever it is; the card on the main screen clears only when it is the
+  // same yes.
+  // The yes or no a key names: the main screen's yes card when it is the
+  // same request, else that job's card in the job deck. Without a key, the
+  // yes on the main screen.
+  function findYes({ key, job: jobId } = {}) {
+    const shown = onJob('yes');
+    let item = shown;
+    if (key) {
+      // a deck yes is bound to its job and its command: both must match
+      const bound = y => y && y.key === key && y.mission_id === jobId;
+      item = jobId && shown && bound(shown.job) ? shown : null;
+      if (!item && jobId) {
+        const found = deckCards().map(x => x.yes).find(bound);
+        item = found ? { kind: 'yes', job: found } : null;
+      }
+    }
+    return { shown, item };
+  }
+
+  async function answerYes({ key, job: jobId } = {}) {
+    const { shown, item } = findYes({ key, job: jobId });
+    if (!item) return { ok: false, reason: 'gone', message: key ? 'that question was already answered' : 'there is no question on screen' };
     const { job } = item;
+    const clear = () => { if (shown && shown.job.key === job.key) state.status = 'cleared'; };
     if (job.lock_step) {
       // the yes releases only the command on this card (its hash), once
       const approved = require('./yes-lock').approveYesLock(lockDir, job.mission_id, job.lock_step, null, iso(), { hash: job.lock_hash || null });
       if (job.lock_hash && !approved) {
         state.seenYes.add(job.key);
-        state.status = 'cleared';
+      state.answeredYes.add(job.key);
+        clear();
         pollJobs();
         return { ok: true, ack: 'that request was already answered.' };
       }
@@ -3174,8 +3323,9 @@ function createBetDesk(deps) {
       const res = await deps.runCli(args);
       log({ card: 'bet', choice: 'yes', command: require('./gm-phone').displayCommand(args), exit_code: res.code, bet_id: job.bet_id, mission_id: job.mission_id, step: job.lock_step });
       state.seenYes.add(job.key);
+      state.answeredYes.add(job.key);
       if (job.bet_id) record(job.bet_id, { yes_answered: { mission_id: job.mission_id, step: job.lock_step, at: iso() } });
-      state.status = 'cleared';
+      clear();
       pollJobs();
       return { ok: true, ack: `${job.owner}: got your yes` };
     }
@@ -3184,7 +3334,8 @@ function createBetDesk(deps) {
     const match = open.find(d => d && d.mission_id === job.mission_id && d.ask_index === job.ask_index);
     if (!match) {
       state.seenYes.add(job.key);
-      state.status = 'cleared';
+      state.answeredYes.add(job.key);
+      clear();
       return { ok: true, ack: 'that question was already answered.' };
     }
     const args = ['decide', String(match.number), 'yes', '--json'];
@@ -3192,19 +3343,58 @@ function createBetDesk(deps) {
     log({ card: 'bet', choice: 'yes', command: require('./gm-phone').displayCommand(args), exit_code: res.code, bet_id: job.bet_id, mission_id: job.mission_id });
     if (res.code !== 0) return { ok: false, reason: 'answer_failed', message: 'your yes did not go through; try again' };
     state.seenYes.add(job.key);
-    record(job.bet_id, { yes_answered: { mission_id: job.mission_id, ask_index: job.ask_index, at: iso() } });
-    state.status = 'cleared';
+      state.answeredYes.add(job.key);
+    if (job.bet_id) record(job.bet_id, { yes_answered: { mission_id: job.mission_id, ask_index: job.ask_index, at: iso() } });
+    clear();
     pollJobs();
     return { ok: true, ack: `${job.owner}: got your yes` };
   }
 
+  // no: the one request on the card is told no, and the job goes on without
+  // it. A held command is denied for good (asking again only hears the no)
+  // and the job is pinged; a plain ask is answered no through atris decide,
+  // matched by mission and ask, the way a yes is.
+  async function answerNo({ key, job: jobId } = {}) {
+    const { shown, item } = findYes({ key, job: jobId });
+    if (!item) return { ok: false, reason: 'gone', message: key ? 'that question was already answered' : 'there is no question on screen' };
+    const { job } = item;
+    const display = args => require('./gm-phone').displayCommand(args);
+    const told = `told ${job.owner} no. it goes on without it.`;
+    const done = (ack) => {
+      state.seenYes.add(job.key);
+      state.answeredYes.add(job.key);
+      if (shown && shown.job.key === job.key) state.status = 'cleared';
+      pollJobs();
+      return { ok: true, ack };
+    };
+    if (job.lock_step) {
+      const denied = require('./yes-lock').denyYesLock(lockDir, job.mission_id, job.lock_step, { hash: job.lock_hash || null, at: iso() });
+      if (!denied) return done('that request was already answered.');
+      const args = ['mission', 'ping', job.mission_id, `the owner said no to step ${job.lock_step}: ${job.ask}. do not run it; leave that step undone and go on with the rest.`, '--from', 'gm-phone'];
+      const res = await deps.runCli(args);
+      log({ card: 'bet', choice: 'no', command: display(args), exit_code: res.code, bet_id: job.bet_id, mission_id: job.mission_id, step: job.lock_step });
+      if (job.bet_id) record(job.bet_id, { no_answered: { mission_id: job.mission_id, step: job.lock_step, at: iso() } });
+      return done(told);
+    }
+    const listed = await deps.runCli(['decide', '--json']);
+    const open = (parseJsonOut(listed.stdout) || {}).decisions || [];
+    const match = open.find(d => d && d.mission_id === job.mission_id && d.ask_index === job.ask_index);
+    if (!match) return done('that question was already answered.');
+    const args = ['decide', String(match.number), 'no', '--json'];
+    const res = await deps.runCli(args);
+    log({ card: 'bet', choice: 'no', command: display(args), exit_code: res.code, bet_id: job.bet_id, mission_id: job.mission_id });
+    if (res.code !== 0) return { ok: false, reason: 'answer_failed', message: 'your no did not go through; try again' };
+    if (job.bet_id) record(job.bet_id, { no_answered: { mission_id: job.mission_id, ask_index: job.ask_index, at: iso() } });
+    return done(told);
+  }
+
   // 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;
     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}` };
+    if (item.kind === 'yes') return { what: plainAsk(j.ask), why: `${j.owner} is waiting on your yes for this.${why}` };
     return { what: j.title, why: `this is done.${why}` };
   }
 
@@ -3269,7 +3459,9 @@ function createBetDesk(deps) {
       // 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,
+      team_working: statusTable().rows.filter(r => r.status === 'working').length,
+      // the yeses still owed past the one on screen: the small need-you line
+      needs_you: owedYes().filter(j => !(kind === 'yes' && cur.job && cur.job.key === j.key)).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,
@@ -3443,7 +3635,7 @@ function createBetDesk(deps) {
     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 row = statusTable().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;
     }
@@ -3461,8 +3653,33 @@ function createBetDesk(deps) {
   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'];
+  // One mission's row: what it is on, its status, and for how long, with
+  // when it last moved; null when it has not moved in the last day or is
+  // not a job.
+  function missionRow(m, ideaTitle) {
+    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) return null;
+    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') return { moved, row: { on, status: 'done', time: `finished ${spanWords(age)} ago` } };
+    if (status === 'stopped') return { moved, row: { on, status: 'stopped', time: `stopped ${spanWords(age)} ago` } };
+    if (!OPEN_MISSION.has(status)) return null;
+    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) return { moved, row: { on, status: 'waiting for your yes', time: `waiting ${spanWords(age)}` } };
+    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;
+      return { moved, row: { on, status: 'working', time: left > 0 ? leftWords(left) : `at it for ${spanWords(now() - created)}` } };
+    }
+    if (!m.last_tick_at) return { moved, row: { on, status: 'waiting to start', time: `waiting ${spanWords(now() - created)}` } };
+    return { moved, row: { on, status: 'stopped', time: `stopped ${spanWords(age)} ago` } };
+  }
+
   let teamCache = null;
-  function teamTable() {
+  function statusTable() {
     if (teamCache && now() - teamCache.at < 10000) return teamCache.table;
     const names = new Set((team || []).map(m => m.name));
     let missions;
@@ -3478,26 +3695,8 @@ function createBetDesk(deps) {
     };
     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);
+      const r = missionRow(m, ideaTitle);
+      if (r) put(m.owner, r.row, r.moved);
     }
     for (const hnd of (deps.readHandoffs || defaultReadHandoffs)(deps.workspaceRoot)) {
       const at = Date.parse((hnd && (hnd.closed_at || hnd.created_at)) || '') || 0;
@@ -3514,6 +3713,185 @@ function createBetDesk(deps) {
     return table;
   }
 
+  // The team page: every member on the team, one row each. role is a few
+  // words from its MEMBER.md. ovr is the board's own rating (atris gm
+  // --board): 60 to 99 from the share of finished jobs that landed in the
+  // last 30 days, "new" with 1 or 2 finished, and two dots with none
+  // finished in that window (a first claim alone is not a rating) or no
+  // task list to read. engine is the tool and the exact model the roster
+  // gives the member (atris engine roster), two dots when no model is
+  // pinned; a person on the team (type: human) never runs on one, so it
+  // says person. A parked member is left out unless it has work on.
+  const ROSTER_MS = 60 * 1000;
+  let rosterCache = null;
+  function rosterFacts() {
+    if (rosterCache && now() - rosterCache.at < ROSTER_MS) return rosterCache.facts;
+    const season = require('./gm-season');
+    let ratings = new Map();
+    try {
+      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,
+      });
+    }
+    rosterCache = { at: now(), facts };
+    return facts;
+  }
+
+  function teamTable() {
+    const facts = rosterFacts();
+    const byName = new Map(statusTable().rows.map(r => [r.member, r]));
+    const rows = [];
+    for (const m of team || []) {
+      const f = facts.get(m.name) || { role: NO_RATING, ovr: NO_RATING, engine: NO_RATING, parked: false };
+      const st = byName.get(m.name) || { member: m.name, on: '', status: 'idle', time: '' };
+      if (f.parked && !byName.has(m.name)) continue;
+      rows.push({ member: m.name, role: f.role, ovr: f.ovr, engine: f.engine, status: st.status, sentence: statusSentence(st), on: st.on, time: st.time });
+    }
+    rows.sort((a, b) => STATUS_ORDER.indexOf(a.status) - STATUS_ORDER.indexOf(b.status) || a.member.localeCompare(b.member));
+    return { rows };
+  }
+
+  // The engine card: what a member runs on now and every model this machine
+  // offers that can do its work, read from local files only. A tap swaps
+  // through the same code as atris engine roster set (lib/roster-swap.js);
+  // the owner's tap is the approval, so there is no yes card. scope member
+  // gives only this member the model, scope job swaps the lead of its job.
+  function onTeam(name) { return (team || []).some(m => m.name === name); }
+  const NOT_ON_TEAM = { ok: false, reason: 'gone', message: 'there is no such member on the team' };
+  function engineCard({ member } = {}) {
+    const name = String(member || '');
+    if (!onTeam(name)) return NOT_ON_TEAM;
+    try {
+      const read = deps.engineChoices || ((root, who, o) => require('./roster-swap').memberEngineChoices(root, who, o));
+      return { ok: true, ...read(deps.workspaceRoot, name, { now: new Date(now()) }) };
+    } catch (err) {
+      return { ok: false, reason: 'unreadable', message: String((err && err.message) || err) };
+    }
+  }
+
+  function swapEngine({ member, engine, model, scope } = {}) {
+    const name = String(member || '');
+    if (!onTeam(name)) return NOT_ON_TEAM;
+    const where = scope === 'job' ? 'job' : 'member';
+    let out;
+    try {
+      const swapFn = deps.swapFromCard || ((...a) => require('./roster-swap').swapFromCard(...a));
+      out = swapFn(deps.workspaceRoot, name, String(engine || ''), String(model || ''), where, { now: new Date(now()) });
+    } catch (err) {
+      const message = String((err && err.message) || err);
+      log({ card: 'bet', choice: 'engine_swap', command: null, ran: 'in process', exit_code: 2, member: name, scope: where, reason: message.slice(0, 200) });
+      return { ok: false, reason: 'refused', message };
+    }
+    rosterCache = null;
+    log({ card: 'bet', choice: 'engine_swap', command: out.command, ran: 'in process', exit_code: 0, member: name, scope: where, changed: out.changed });
+    return { ok: true, ack: out.line, rows: teamTable().rows };
+  }
+
+  // ---- the job deck: one card per running job, the ones waiting on the
+  // owner's yes first. Each card is one divided row: done, work, member,
+  // role, ovr, engine, and status. role, ovr, and engine are the team
+  // table's own cells, so the deck and the table always agree. A card that
+  // needs the owner carries its yes card's two lines and the key the page
+  // sends back with the yes. Every word on it is plain: no command, flag,
+  // or path.
+  const DECK_COLUMNS = ['done', 'work', 'member', 'role', 'ovr', 'engine', 'status'];
+  const DECK_STATUS = new Set(['waiting for your yes', 'working', 'waiting to start']);
+
+  // The yes a running job waits on: the desk's own yes card for it when it
+  // has one, else a step its guard holds, else its first open ask. The keys
+  // are the desk's own, so a yes said on one is said on the other. A yes only
+  // passed over on the main screen is still owed, so it stays on its card.
+  function yesFor(mission) {
+    const said = state.answeredYes;
+    const owed = (state.jobs.yes || []).filter(j => j.mission_id === mission.id && !said.has(j.key));
+    const own = owed.find(j => !state.skippedYes.has(j.key)) || owed[0];
+    if (own) return own;
+    const owner = mission.owner || 'the team';
+    for (const lock of require('./yes-lock').askedYesLocks(lockDir, mission.id)) {
+      const key = `${mission.id}:step-${lock.step}:${lock.hash || ''}`;
+      if (!said.has(key)) return { kind: 'yes', bet_id: null, mission_id: mission.id, owner, ask: lock.text, command: lock.held_command || null, lock_step: lock.step, lock_hash: lock.hash || null, ask_index: null, key };
+    }
+    const job = jobState({ id: null }, mission, null, now());
+    const ask = job.kind === 'yes' ? job.asks.find(x => !said.has(`${mission.id}:${x.index}`)) : null;
+    return ask ? { kind: 'yes', bet_id: null, mission_id: mission.id, owner, ask: ask.text, ask_index: ask.index, key: `${mission.id}:${ask.index}` } : null;
+  }
+
+  // One card per job, never per member: a member with two jobs has two
+  // cards, each with its own table and its own yes. A handoff no run has
+  // picked up yet is a job waiting to start.
+  function deckCards() {
+    let missions;
+    try { missions = (deps.readMissions || defaultReadMissions)(deps.workspaceRoot); } catch { missions = null; }
+    const names = new Set((team || []).map(m => m.name));
+    const facts = new Map(teamTable().rows.map(r => [r.member, r]));
+    const titles = new Map(readLedger(deps.ledgerFile, deps.workspaceRoot).filter(r => r.mission_id && r.bet).map(r => [r.mission_id, r.bet.title]));
+    const jobs = [];
+    for (const m of missions instanceof Map ? missions.values() : Object.values(missions || {})) {
+      if (!m || !m.id || !names.has(m.owner) || !OPEN_MISSION.has(String(m.status || ''))) continue;
+      const r = missionRow(m, titles);
+      if (r && DECK_STATUS.has(r.row.status)) jobs.push({ id: m.id, mission: m, member: m.owner, row: r.row, moved: r.moved });
+    }
+    for (const hnd of (deps.readHandoffs || defaultReadHandoffs)(deps.workspaceRoot)) {
+      const at = Date.parse((hnd && hnd.created_at) || '') || 0;
+      if (!hnd || hnd.status !== 'open' || !names.has(hnd.to) || !at || now() - at > RECENT_MS) continue;
+      const on = clip(String(hnd.summary || '').replace(/^\[[^\]]*\]\s*/, ''), 100);
+      jobs.push({ id: `handoff:${hnd.id || at}`, mission: null, member: hnd.to, row: { on, status: 'waiting to start', time: `waiting ${spanWords(now() - at)}` }, moved: at });
+    }
+    jobs.sort((x, y) => STATUS_ORDER.indexOf(x.row.status) - STATUS_ORDER.indexOf(y.row.status) || y.moved - x.moved || x.member.localeCompare(y.member));
+    // a yes skipped with not now waits at the back of the ones that need the owner
+    const skipRank = x => (x.yes && state.skippedYes.get(x.yes.key)) || 0;
+    const needsFirst = x => (x.card.label === 'needs you' ? 0 : 1);
+    return jobs.map((j) => {
+      const needs = j.row.status === 'waiting for your yes';
+      const yes = needs && j.mission ? yesFor(j.mission) : null;
+      const f = facts.get(j.member) || { role: NO_RATING, ovr: NO_RATING, engine: NO_RATING };
+      // a job whose yes was said here is back with its member, not waiting on the owner
+      const label = needs ? (yes ? 'needs you' : 'you answered') : j.row.status;
+      const card = {
+        job_id: j.id,
+        mission_id: j.mission ? j.mission.id : null,
+        member: j.member,
+        label,
+        time: j.row.time,
+        rows: [{ done: 'not yet', work: plainWork(j.row.on, j.member), member: j.member, role: f.role, ovr: f.ovr, engine: f.engine, status: label }],
+      };
+      if (yes) card.yes = { key: yes.key, ...(yes.lock_hash ? { hash: yes.lock_hash } : {}), ...publicJob({ kind: 'yes', job: yes }) };
+      return { card, yes };
+    }).map((x, i) => ({ x, i }))
+      .sort((a, b) => needsFirst(a.x) - needsFirst(b.x) || (needsFirst(a.x) ? 0 : skipRank(a.x) - skipRank(b.x)) || a.i - b.i)
+      .map(p => p.x);
+  }
+
+  function jobDeck() {
+    return { columns: DECK_COLUMNS, cards: deckCards().map(x => x.card) };
+  }
+
   // 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
@@ -3568,10 +3946,324 @@ function createBetDesk(deps) {
     }
   }
 
-  return { warm, next, pick, say, talk, report, teamTable, steer, skip, doIt, nice, answerYes, answer, pollJobs, settle, yesCards, recordYes, view, state };
+  // ---- the one card on screen (lib/gm-card.js) ----
+  //
+  // The page draws exactly the card served here and nothing else. Over the
+  // main card (the idea, question, yes, and the rest) can sit one layer: the
+  // team, a member's talk card, the job deck, or a swap card. A reply to
+  // words said on a card is its own card over that card. Every action names
+  // the card it acts on and one option on it; anything else is refused.
+  const gmCard = require('./gm-card');
+  // layer: null | { kind: team|member|deck|swap, id, ... }; reply: null | { base, id, text, suggestions, confirm, thread }
+  state.layer = null;
+  state.reply = null;
+  state.served = null;
+  state.serial = 0;
+  // ids made here carry this desk's own tag, so a page left open across a
+  // restart never names a card this desk made
+  const deskTag = crypto.randomBytes(3).toString('hex');
+  const freshId = kind => `${kind}~${deskTag}${(state.serial += 1)}`;
+  const betBody = b => [b.why_now, b.expect].map(sentence).join(' ');
+
+  // the member's facts for a card about their job
+  function jobFacts(name) {
+    if (!onTeam(name)) return null;
+    const f = rosterFacts().get(name) || {};
+    return { member: name, role: f.role || NO_RATING, ovr: f.ovr || NO_RATING, engine: f.engine || NO_RATING };
+  }
+
+  function mainCard() {
+    const cur = state.current;
+    if (!cur) return null;
+    const kind = cur.kind || 'bet';
+    if (kind === 'bet' && (state.status === 'starting' || state.status === 'started')) {
+      return gmCard.started({ id: `${cur.id}:started`, title: cur.bet.title, body: betBody(cur.bet), line: state.status === 'starting' ? 'starting now' : (state.mission && state.mission.line) });
+    }
+    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) });
+    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 === '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 } });
+    }
+    if (kind === 'done') return gmCard.done({ id: cur.id, title: v.job.what, body: v.job.why, job: jobFacts(cur.job.owner) });
+    return null;
+  }
+
+  function layerCard() {
+    const l = state.layer;
+    if (!l) return null;
+    if (l.kind === 'team') {
+      const rows = teamTable().rows;
+      return gmCard.team({ id: l.id, rows, line: l.line || null, deck: rows.some(r => DECK_STATUS.has(r.status)) });
+    }
+    if (l.kind === 'member') {
+      const row = teamTable().rows.find(r => r.member === l.name);
+      return gmCard.member({ id: l.id, name: l.name, sentence: row ? sentence(row.sentence) : 'nothing in the last day.', job: jobFacts(l.name), line: l.line || null });
+    }
+    if (l.kind === 'deck') {
+      const cards = deckCards().map(x => x.card);
+      if (!cards.length) return null;
+      const at = Math.min(l.at || 0, cards.length - 1);
+      const c = { ...cards[at], said: (l.said && l.said[cards[at].job_id]) || null };
+      const r = c.rows[0];
+      // the deck card is about the job: its row without the rating and the model, which live on the team table
+      const columns = DECK_COLUMNS.filter(k => k !== 'ovr' && k !== 'engine');
+      return gmCard.deck({ id: l.id, at, total: cards.length, card: c, columns, job: { member: c.member, role: r.role, ovr: r.ovr, engine: r.engine } });
+    }
+    if (l.kind === 'swap') {
+      if (!l.choices) {
+        const out = engineCard({ member: l.name });
+        if (!out.ok) return gmCard.member({ id: l.id, name: l.name, sentence: out.message || 'could not read the models on this machine.', job: jobFacts(l.name) });
+        l.choices = out;
+      }
+      return gmCard.swap({ id: l.id, name: l.name, choices: l.choices, scope: l.scope, all: l.all, line: l.line || null });
+    }
+    return null;
+  }
+
+  // the card under a reply: the layer when one is open, else the main card
+  function underCard() {
+    return layerCard() || mainCard();
+  }
+
+  function currentCard() {
+    const under = underCard();
+    if (!under) return null;
+    const r = state.reply;
+    if (r && r.base === under.id) {
+      return gmCard.reply({ id: r.id, base: under, text: r.text, thread: r.thread, suggestions: r.suggestions, confirm: r.confirm });
+    }
+    if (r) state.reply = null;
+    return under;
+  }
+
+  function serve() {
+    const card = currentCard();
+    // served under a stamped id: options that change come with a new id, so a tap on the old one does nothing
+    state.served = card ? gmCard.stamp(gmCard.enforce(card, problems => log({ card: 'bet', choice: 'card_problem', command: null, ran: 'in process', exit_code: 1, kind: card.kind, problems: problems.slice(0, 5) }))) : null;
+    return state.served;
+  }
+
+  // what every answer carries: the card on screen and the small lines around it
+  function envelope(extra = {}) {
+    const card = serve();
+    const v = view();
+    return {
+      ok: true,
+      ...extra,
+      card: gmCard.wire(card),
+      status: v.status,
+      queue: v.queue,
+      team_working: v.team_working,
+      needs_you: v.needs_you,
+    };
+  }
+
+  function refuse(reason, message, status = 409) {
+    return { status, body: { ...envelope(), ok: false, reason, message } };
+  }
+  const done200 = extra => ({ status: 200, body: envelope(extra) });
+
+  // the page opened, or looked again: the card on screen now. A read starts
+  // no work: the queue fills when the desk is made, on its timer, and on an act.
+  function card() {
+    return envelope();
+  }
+
+  // a word that came back as a reply: the reply is the next card
+  function replied(out, baseId, text) {
+    if (out.stay) {
+      state.reply = { base: baseId, id: freshId(`${baseId}~r`), text: out.reply, suggestions: out.suggestions || [], confirm: null, thread: (out.thread || []).slice(0, -1) };
+      return done200();
+    }
+    if (out.reason === 'needs_confirm') {
+      state.reply = { base: baseId, id: freshId(`${baseId}~r`), text: out.message, suggestions: [], confirm: { text }, thread: [] };
+      return done200();
+    }
+    return null;
+  }
+
+  // words said on the main card, a reply on it, or its something else
+  async function sayOnMain(text, more = {}) {
+    const under = underCard();
+    const out = await say({ text, ...more });
+    const back = replied(out, under.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;
+    next();
+    return done200({ ack: out.ack });
+  }
+
+  // words to the member on a talk card or a deck card
+  async function talkOnLayer(text, more = {}) {
+    const l = state.layer;
+    const under = underCard();
+    const name = l.kind === 'deck' ? under.member : l.name;
+    const out = await talk({ member: name, text, ...more });
+    const back = replied(out, under.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;
+    if (l.kind === 'deck') { l.said = { ...(l.said || {}), [under.deck_job]: out.ack }; l.id = freshId('deck'); } else { l.line = out.ack; l.id = freshId('member'); }
+    return done200();
+  }
+
+  function open(kind, extra = {}) {
+    state.reply = null;
+    state.layer = { kind, id: freshId(kind), ...extra };
+    if (kind === 'deck' && !layerCard()) state.layer = { kind: 'team', id: freshId('team') };
+  }
+
+  // One action from the page: { card_id, option_id } or { card_id, text } for
+  // the card's box, or { orb: true } for the next card, or { open: team|deck }
+  // 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));
+    // 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();
+      state.layer = null;
+      state.reply = null;
+      const out = next({ sharper: false });
+      return done200(out.busy ? { busy: true } : {});
+    }
+    if (body.open === 'team' || body.open === 'deck') {
+      if (stale) return refuse('gone', 'that card changed. here is the one on screen now');
+      open(body.open);
+      return done200();
+    }
+    // an option or words always name the card they were for
+    if (!shown || !cardId || stale) return refuse('gone', 'that card changed, so nothing was done. here is the one on screen now');
+    const optionId = body.option_id == null ? null : String(body.option_id);
+    const opt = optionId ? shown.options.find(o => o.id === optionId) : null;
+    if (optionId && !opt) return refuse('bad_option', 'that is not on this card');
+    if (!opt && !shown.input) return refuse('bad_option', 'this card has no box to type in');
+    const typed = String(body.text == null ? '' : body.text).trim();
+    if ((!opt || opt.type) && !typed) return refuse('empty', 'say something first');
+    if (opt && opt.confirm && body.confirm !== true) return { status: 409, body: { ...envelope(), ok: false, reason: 'needs_confirm', message: opt.confirm } };
+    const action = opt ? opt.action : shown.input.action;
+    const b = (opt && opt.binds) || {};
+    const onLayer = Boolean(state.layer);
+    log({ card: 'bet', choice: 'act', command: null, ran: 'in process', exit_code: 0, kind: shown.kind, action, option: optionId });
+    switch (action) {
+      case 'do': {
+        const out = await doIt();
+        if (!out.ok) return refuse(out.reason, out.message);
+        next();
+        return done200({ ack: out.ack });
+      }
+      case 'sharper': next({ sharper: true }); return done200();
+      case 'skip': {
+        const out = skip();
+        if (!out.ok) return refuse(out.reason, out.message);
+        state.reply = null;
+        return done200({ ack: out.ack, home: true });
+      }
+      case 'next': next(); return done200();
+      case 'later': {
+        if (onLayer && state.layer.kind === 'deck') {
+          state.seenYes.add(b.key);
+          state.skips += 1;
+          state.skippedYes.set(b.key, state.skips);
+          state.layer.id = freshId('deck');
+          return done200();
+        }
+        state.reply = null;
+        next({ later: true });
+        return done200();
+      }
+      case 'yes':
+      case 'no': {
+        const out = await (action === 'yes' ? answerYes : answerNo)({ key: b.key, job: b.job });
+        if (!out.ok) return refuse(out.reason, out.message);
+        state.reply = null;
+        if (onLayer && state.layer.kind === 'deck') {
+          state.layer.said = { ...(state.layer.said || {}), [shown.deck_job]: out.ack };
+          state.layer.id = freshId('deck');
+          return done200();
+        }
+        next();
+        return done200({ ack: out.ack });
+      }
+      case 'nice': {
+        const out = nice();
+        if (!out.ok) return refuse(out.reason, out.message);
+        next();
+        return done200({ ack: out.ack });
+      }
+      case 'answer': {
+        const out = answer({ choice: b.choice });
+        if (!out.ok) return refuse(out.reason, out.message);
+        state.reply = null;
+        next();
+        return done200();
+      }
+      case 'pick': {
+        const out = pick({ id: b.bet });
+        if (!out.ok) return refuse(out.reason, out.message);
+        return done200();
+      }
+      case 'report': {
+        const raw = typed.replace(/,/g, '');
+        if (/^-?\d+(\.\d+)?$/.test(raw)) {
+          const out = report({ value: raw });
+          if (!out.ok) return refuse(out.reason, out.message);
+          state.reply = null;
+          next();
+          return done200({ ack: out.ack });
+        }
+        return sayOnMain(typed);
+      }
+      case 'say': return onLayer ? talkOnLayer(typed || b.text) : sayOnMain(typed || b.text);
+      case 'talk': return talkOnLayer(typed);
+      case 'start':
+      case 'note': {
+        const more = action === 'start' ? { confirm: true } : { note: true };
+        return onLayer ? talkOnLayer(b.text, more) : sayOnMain(b.text, more);
+      }
+      case 'back': {
+        if (state.reply) { state.reply = null; return done200(); }
+        const l = state.layer;
+        // a talk card, a swap card, and the job deck go back to the whole team; the team goes back to the card under it
+        if (l && l.kind !== 'team') open('team');
+        else state.layer = null;
+        return done200();
+      }
+      case 'member': open('member', { name: b.member }); return done200();
+      case 'swap': open('swap', { name: b.member, scope: 'member', all: false }); return done200();
+      case 'deck': open('deck', { at: 0 }); return done200();
+      case 'flip': {
+        const n = deckCards().length;
+        if (n) state.layer.at = (((state.layer.at || 0) + (Number(b.step) || 1)) % n + n) % n;
+        state.layer.id = freshId('deck');
+        return done200();
+      }
+      case 'scope': state.layer.scope = b.scope === 'job' ? 'job' : 'member'; state.layer.id = freshId('swap'); return done200();
+      // more models: the same card, with every model on it
+      case 'more': state.layer.all = true; return done200();
+      case 'swap_to': {
+        const out = swapEngine({ member: state.layer.name, engine: b.engine, model: b.model, scope: b.scope });
+        if (!out.ok) return refuse(out.reason, out.message);
+        open('team', { line: out.ack });
+        return done200({ ack: out.ack });
+      }
+      default: return refuse('bad_option', 'that does nothing here');
+    }
+  }
+
+  return { warm, next, pick, say, talk, report, teamTable, jobDeck, engineCard, swapEngine, steer, skip, doIt, nice, answerYes, answerNo, answer, pollJobs, settle, yesCards, recordYes, view, card, act, state };
 }
 
 module.exports = {
+  plainAsk,
   BACKOFF_MS,
   FALLBACK_QUESTION,
   readScoreboard,