atris 3.74.5 → 3.74.6

package/lib/gm-bet.js

@@ -2544,8 +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; a yes only passed over is still owed
+    // 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
@@ -2785,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 };
@@ -2994,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') {
@@ -3009,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();
@@ -3106,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 });
@@ -3120,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);
@@ -3268,7 +3286,10 @@ function createBetDesk(deps) {
   // 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.
-  async function answerYes({ key, job: jobId } = {}) {
+  // 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) {
@@ -3280,6 +3301,11 @@ function createBetDesk(deps) {
         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'; };
@@ -3324,6 +3350,44 @@ function createBetDesk(deps) {
     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) {
@@ -3396,6 +3460,8 @@ function createBetDesk(deps) {
       thread: cur && state.thread.id === cur.id ? state.thread.turns.slice() : [],
       // the footer count: only members really working
       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,
@@ -3722,7 +3788,8 @@ function createBetDesk(deps) {
     const name = String(member || '');
     if (!onTeam(name)) return NOT_ON_TEAM;
     try {
-      return { ok: true, ...require('./roster-swap').memberEngineChoices(deps.workspaceRoot, name, { now: new Date(now()) }) };
+      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) };
     }
@@ -3734,7 +3801,8 @@ function createBetDesk(deps) {
     const where = scope === 'job' ? 'job' : 'member';
     let out;
     try {
-      out = require('./roster-swap').swapFromCard(deps.workspaceRoot, name, String(engine || ''), String(model || ''), where, { now: new Date(now()) });
+      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) });
@@ -3761,7 +3829,8 @@ function createBetDesk(deps) {
   // passed over on the main screen is still owed, so it stays on its card.
   function yesFor(mission) {
     const said = state.answeredYes;
-    const own = (state.jobs.yes || []).find(j => j.mission_id === mission.id && !said.has(j.key));
+    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)) {
@@ -3795,11 +3864,15 @@ function createBetDesk(deps) {
       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 };
-      const label = needs ? 'needs you' : j.row.status;
+      // 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,
@@ -3808,9 +3881,11 @@ function createBetDesk(deps) {
         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, ...publicJob({ kind: 'yes', job: yes }) };
+      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() {
@@ -3871,7 +3946,320 @@ function createBetDesk(deps) {
     }
   }
 
-  return { warm, next, pick, say, talk, report, teamTable, jobDeck, engineCard, swapEngine, 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 = {