atris 3.74.3 → 3.74.5

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,8 @@ 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
+    answeredYes: new Set(),
     // reviews running now, by bet id
     reviews: new Map(),
     // failed jobs being sent back to the team now, by bet id
@@ -2593,7 +2701,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]));
@@ -3157,16 +3265,31 @@ 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.
+  async function answerYes({ 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;
+      }
+    }
+    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 +3297,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 +3308,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,8 +3317,9 @@ 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` };
   }
@@ -3204,7 +3330,7 @@ function createBetDesk(deps) {
     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 +3395,7 @@ 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,
       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 +3569,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 +3587,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 +3629,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 +3647,176 @@ 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 {
+      return { ok: true, ...require('./roster-swap').memberEngineChoices(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 {
+      out = require('./roster-swap').swapFromCard(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 own = (state.jobs.yes || []).find(j => j.mission_id === mission.id && !said.has(j.key));
+    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));
+    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;
+      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, ...publicJob({ kind: 'yes', job: yes }) };
+      return { card, yes };
+    });
+  }
+
+  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 +3871,11 @@ function createBetDesk(deps) {
     }
   }
 
-  return { warm, next, pick, say, talk, report, teamTable, steer, skip, doIt, nice, answerYes, answer, pollJobs, settle, yesCards, recordYes, view, state };
+  return { warm, next, pick, say, talk, report, teamTable, jobDeck, engineCard, swapEngine, steer, skip, doIt, nice, answerYes, answer, pollJobs, settle, yesCards, recordYes, view, state };
 }
 
 module.exports = {
+  plainAsk,
   BACKOFF_MS,
   FALLBACK_QUESTION,
   readScoreboard,