atris 3.74.13 → 3.74.14

package/lib/gm-bet.js

@@ -372,7 +372,11 @@ const SAY_READ_MS = 15000;
 const SAY_KINDS = new Set(['question', 'answer', 'instruction', 'unclear']);
 // on the weekly number card, what an instruction wants done with the number
 const NUMBER_INTENTS = new Set(['stop', 'change', 'later', 'other']);
+// only for a model that answered and could not make sense of the words
 const SAY_FALLBACK = 'say that another way, or tap a button.';
+// no model answered the words: never put on them
+const SAY_NO_MODEL = 'the orb needs a model signed in on this computer to read that, so nothing was saved.';
+const SAY_NOT_HEARD = 'the model did not answer this time, so nothing was saved. try again in a moment.';
 // the last turns of a card's conversation the reader sees
 const THREAD_TURNS = 6;
 
@@ -391,7 +395,10 @@ function readerModel(workspaceRoot) {
 // One quick call: what kind of message the owner typed on the card on
 // screen, and what to say back. The card, the conversation on it so far, and
 // a short view of the project go in.
-async function readSaid({ text, card, thread = [], hint = null, workspaceRoot, bundle = null, deps = {} } = {}) {
+// A read no model answered says so (no_model, retry from think); a model
+// that answered with a read of no use says answered, so only that one asks
+// the owner to say it another way.
+async function readSaid({ text, card, thread = [], hint = null, workspaceRoot, bundle = null, deps = {}, timeoutMs = SAY_READ_MS } = {}) {
   const context = clip((deps.readContext || readProjectContext)(workspaceRoot), 1500);
   const goal = bundle && bundle.sources && bundle.sources.goal;
   const prompt = [
@@ -424,11 +431,12 @@ async function readSaid({ text, card, thread = [], hint = null, workspaceRoot, b
     context || '(no readme or goals found)',
   ].filter(l => l !== '').join('\n');
   const model = (deps.readerModel || readerModel)(workspaceRoot);
-  const said = await (deps.runModel || runModel)(prompt, { cwd: workspaceRoot, timeoutMs: SAY_READ_MS, command: { bin: 'claude', args: p => claudeArgs(p, model) }, onProgress: () => {} });
-  if (!said.ok) return { ok: false, reason: said.reason };
+  const run = deps.runModel || ((p, o) => think(p, { ...o, root: workspaceRoot }));
+  const said = await run(prompt, { cwd: workspaceRoot, timeoutMs, command: { bin: 'claude', args: p => claudeArgs(p, model) }, onProgress: () => {} });
+  if (!said.ok) return { ok: false, reason: said.reason, ...(said.no_model ? { no_model: said.no_model, retry: Boolean(said.retry) } : {}) };
   const parsed = parseBet(said.text);
   const v = parsed.bet;
-  if (!v || !SAY_KINDS.has(v.kind) || typeof v.reply !== 'string') return { ok: false, reason: 'the read was not the shape asked for' };
+  if (!v || !SAY_KINDS.has(v.kind) || typeof v.reply !== 'string') return { ok: false, reason: 'the read was not the shape asked for', answered: true };
   const suggestions = Array.isArray(v.suggestions) ? v.suggestions.filter(x => typeof x === 'string' && x.trim()).map(x => x.trim()) : [];
   const intent = card.kind === 'number' && NUMBER_INTENTS.has(v.intent) ? v.intent : null;
   return { ok: true, kind: v.kind, reply: clip(v.reply, 280), ...(intent ? { intent } : {}), ...(suggestions.length ? { suggestions } : {}) };
@@ -452,7 +460,8 @@ async function generateScoreboardChoices({ workspaceRoot, bundle = null, deps =
     '',
     bundleText(b),
   ].join('\n');
-  const said = await (deps.runModel || runModel)(prompt, { cwd: workspaceRoot, onProgress: () => {} });
+  const run = deps.runModel || ((p, o) => think(p, { ...o, root: workspaceRoot }));
+  const said = await run(prompt, { cwd: workspaceRoot, onProgress: () => {} });
   if (!said.ok) return { ok: false, reason: said.reason };
   const parsed = parseBet(said.text);
   const list = parsed.bet && Array.isArray(parsed.bet.choices) ? parsed.bet.choices : [];
@@ -470,7 +479,7 @@ async function generateQuestion({ workspaceRoot, answers = [], avoid = [], bundl
   const b = bundle || await readBundle(workspaceRoot, { deps, ledgerFile, today });
   const context = (deps.readContext || readProjectContext)(workspaceRoot);
   const source = `${context}\n${bundleText(b)}`;
-  const run = deps.runModel || runModel;
+  const run = deps.runModel || ((p, o) => think(p, { ...o, root: workspaceRoot }));
   const ask = async (prompt) => {
     const said = await run(prompt, { cwd: workspaceRoot, onProgress: () => {} });
     if (!said.ok) return { failed: said.reason };
@@ -1523,10 +1532,14 @@ function quietDir() {
 // Writers running now, by process group, so the server can end them when it
 // stops; otherwise a stopped server leaves them running on their own.
 const LIVE_WRITERS = new Map();
+// how many times the server stopped its writers: a call under way when it
+// did starts no other model after
+let WRITER_STOPS = 0;
 
 // SIGTERM now, then SIGKILL for the same groups after the grace, so a child
 // that ignores SIGTERM does not outlive the server either.
 function stopWriters() {
+  WRITER_STOPS += 1;
   let n = 0;
   const groups = [...LIVE_WRITERS];
   for (const [pid, kill] of groups) {
@@ -1544,6 +1557,9 @@ function stopWriters() {
   return n;
 }
 
+// A start that failed because the program is not on this computer.
+const notHere = err => (err && err.code === 'ENOENT' ? { missing: true } : {});
+
 // A signal (an AbortSignal) stops the call early: the whole process group
 // gets SIGTERM, then SIGKILL if it is still there after STOP_GRACE_MS, and
 // the call resolves once the process is gone, so nothing it started is left.
@@ -1561,7 +1577,7 @@ function runModel(prompt, { command = { bin: 'claude', args: claudeArgs }, cwd,
     try {
       child = spawnFn(command.bin, args, { cwd, env: modelEnv(env), detached: process.platform !== 'win32', stdio: ['ignore', 'pipe', 'pipe'] });
     } catch (err) {
-      resolve({ ok: false, reason: `could not start the model: ${err.message}` });
+      resolve({ ok: false, reason: `could not start the model: ${err.message}`, ...notHere(err) });
       return;
     }
     if (child && child.pid) LIVE_WRITERS.set(child.pid, kill);
@@ -1571,6 +1587,8 @@ function runModel(prompt, { command = { bin: 'claude', args: claudeArgs }, cwd,
     let text = '';
     let result = null;
     let thinking = 0;
+    // the model began to answer: the api sent its first event back
+    let heard = false;
     let timedOut = false;
     let stopped = false;
     let hardKill = null;
@@ -1610,6 +1628,7 @@ function runModel(prompt, { command = { bin: 'claude', args: claudeArgs }, cwd,
       } catch {
         return;
       }
+      if (ev.type === 'stream_event' || ev.type === 'assistant' || ev.type === 'result') heard = true;
       if (ev.type === 'system' && ev.subtype === 'thinking_tokens' && Number.isFinite(ev.estimated_tokens)) {
         thinking = ev.estimated_tokens;
         onProgress({ thinking, chars: text.length, text });
@@ -1641,11 +1660,12 @@ function runModel(prompt, { command = { bin: 'claude', args: claudeArgs }, cwd,
       if (!stopped) LIVE_WRITERS.delete(child.pid);
       resolve(out);
     };
-    child.on('error', err => finish({ ok: false, reason: `could not start the model: ${err.message}` }));
+    child.on('error', err => finish({ ok: false, reason: `could not start the model: ${err.message}`, ...notHere(err) }));
     child.on('close', (code) => {
       if (buf) line(buf);
-      if (stopped) return finish({ ok: false, reason: STOPPED_REASON, stopped: true });
-      if (timedOut) return finish({ ok: false, reason: `the model took longer than ${Math.round(timeoutMs / 1000)} seconds and was stopped`, timed_out: true });
+      const began = heard ? { heard: true } : {};
+      if (stopped) return finish({ ok: false, reason: STOPPED_REASON, stopped: true, ...began });
+      if (timedOut) return finish({ ok: false, reason: `the model took longer than ${Math.round(timeoutMs / 1000)} seconds and was stopped`, timed_out: true, ...began });
       if (result && result.is_error) return finish({ ok: false, reason: `the model said: ${clip(result.result || result.subtype, 160)}` });
       const answer = result && typeof result.result === 'string' ? result.result : text;
       if (code !== 0 && !answer) return finish({ ok: false, reason: `the model exited with code ${code}${stderr.trim() ? `: ${clip(stderr.trim().split('\n').pop(), 160)}` : ''}` });
@@ -1655,6 +1675,196 @@ function runModel(prompt, { command = { bin: 'claude', args: claudeArgs }, cwd,
   });
 }
 
+// ---- who thinks: claude first, then the next model signed in here ---------------------
+
+// The orb thinks on claude, the way it always has. When claude is not on
+// this computer, fails, or never starts to answer, the next model the
+// engine registry says is here answers instead, in the registry's own
+// fallback order, each on its own default model and launched the way
+// `atris engine ask` launches it (read-only). Hosted engines are left out:
+// they spend the owner's atris tokens, and the orb drafts in the background.
+//
+// What is known lives in memory, one entry per workspace: the registry's
+// list, read the way every router reads it (the first read saves it, later
+// reads take about a millisecond; an unsaved one probes every tool, about
+// half a second on a busy Mac) and kept for ten minutes (THINKER_LIST_MS),
+// and the models that just failed, which sit out for five minutes
+// (THINKER_BENCH_MS). A tap on the card that says no model answered forgets
+// both (forgetThinkers), so a model signed in a moment ago works on the very
+// next tap.
+const THINKER_LIST_MS = 10 * 60 * 1000;
+const THINKER_BENCH_MS = 5 * 60 * 1000;
+// claude that sent nothing back from the api for this long is not answering
+const UNHEARD_MS = 15000;
+const THINKERS = new Map();
+
+function thinkerState(root) {
+  const key = path.resolve(String(root || '.'));
+  if (!THINKERS.has(key)) THINKERS.set(key, { list: null, listAt: 0, bench: new Map(), answered: new Map(), benches: 0, fresh: false });
+  return THINKERS.get(key);
+}
+
+// The next list read looks for every tool itself. The count of benches
+// only grows, so a drafting under way still knows whether one sat out.
+function forgetThinkers(root) {
+  const st = thinkerState(root);
+  st.list = null;
+  st.fresh = true;
+  st.bench.clear();
+  st.answered.clear();
+}
+
+// The models that can think here, in order: the one on the claude program
+// first (it runs the orb's own command), then every other installed,
+// non-hosted engine by the registry's fallback order, one per program.
+function thinkerLineup(root) {
+  const st = thinkerState(root);
+  if (st.list && Date.now() - st.listAt < THINKER_LIST_MS) return st.list;
+  let engines = [];
+  try {
+    const reg = require('./engine-registry');
+    const known = reg.readEngineRegistry(root).engines.filter(e => !reg.engineHosted(e));
+    engines = known.filter(e => e.installed === true);
+    // A saved "not here" can be older than the tool on this computer now (a
+    // saved credit wall is never looked at again, a missing tool for a
+    // minute), so the orb looks for itself: for its own model on every read,
+    // and for every tool after a tap on the card that says no model answered.
+    const bins = new Set(engines.map(e => e.bin));
+    for (const e of known.filter(x => st.fresh || x.id === 'claude')) {
+      if (bins.has(e.bin)) continue;
+      bins.add(e.bin);
+      if (reg.binInstalled(e.bin)) engines.push(e);
+    }
+  } catch {
+    engines = [];
+  }
+  const lead = e => (e.bin === 'claude' ? 0 : 1);
+  engines.sort((a, b) => lead(a) - lead(b) || Number(a.fallback_order) - Number(b.fallback_order) || String(a.id).localeCompare(String(b.id)));
+  const once = new Set();
+  st.list = engines.filter(e => !once.has(e.bin) && once.add(e.bin)).map(e => ({ id: e.id, lead: e.bin === 'claude' }));
+  st.listAt = Date.now();
+  st.fresh = false;
+  return st.list;
+}
+
+function benched(st, id) {
+  const b = st.bench.get(id);
+  if (!b) return false;
+  if (Date.now() < b.until) return true;
+  st.bench.delete(id);
+  return false;
+}
+
+function benchThinker(st, id, reason, missing = false) {
+  st.bench.set(id, { until: Date.now() + THINKER_BENCH_MS, reason: clip(String(reason || ''), 160), missing });
+  st.benches += 1;
+}
+
+// 'ready': a model here can take the next call. 'none': no model is on this
+// computer. 'failed': every one here failed or never answered just now.
+function thinkerVerdict(root) {
+  const st = thinkerState(root);
+  const list = thinkerLineup(root);
+  if (list.some(t => !benched(st, t.id))) return 'ready';
+  return list.every(t => st.bench.get(t.id) && st.bench.get(t.id).missing) ? 'none' : 'failed';
+}
+
+// A fallback model's child joins the writers the server ends when it stops.
+function trackedSpawn(bin, args, opts) {
+  const child = require('child_process').spawn(bin, args, opts);
+  if (child && child.pid) {
+    const kill = process.kill.bind(process);
+    LIVE_WRITERS.set(child.pid, kill);
+    child.once('close', () => { if (LIVE_WRITERS.get(child.pid) === kill) LIVE_WRITERS.delete(child.pid); });
+  }
+  return child;
+}
+
+// One answer from a model other than claude, through the read-only command
+// `atris engine ask` builds for it, in the same shape runModel answers.
+function askThinker(id, prompt, { timeoutMs = MODEL_TIMEOUT_MS, onProgress = () => {}, signal = null } = {}) {
+  const ask = require('./engine-ask');
+  let invocation;
+  try {
+    invocation = ask.buildReadOnlyEngineInvocation(id, prompt, '', { timeoutMs, effort: IDEA_EFFORT });
+  } catch (err) {
+    return Promise.resolve({ ok: false, reason: `could not start the model: ${err.message}` });
+  }
+  let text = '';
+  // any word on stdout: the model began to answer
+  let heard = false;
+  return ask.runAskProcess(invocation, {
+    cwd: invocation.cwd || quietDir(),
+    timeoutMs,
+    signal,
+    env: modelEnv(process.env),
+    spawnProcess: trackedSpawn,
+    onOutputChunk: (chunk, stream) => {
+      if (stream !== 'stdout' || text.length > OUTPUT_MAX) return;
+      heard = true;
+      text += chunk.toString('utf8');
+      onProgress({ thinking: 0, chars: text.length, text });
+    },
+  }).then((r) => {
+    const began = heard ? { heard: true } : {};
+    if (r.cancelled) return { ok: false, reason: STOPPED_REASON, stopped: true, ...began };
+    if (r.timed_out) return { ok: false, reason: `the model took longer than ${Math.round(timeoutMs / 1000)} seconds and was stopped`, timed_out: true, ...began };
+    const tail = String(r.stderr || r.stdout || '').trim().split('\n').pop();
+    if (r.reason === 'spawn_error') return { ok: false, reason: `could not start the model: ${clip(tail, 160)}`, ...(/ENOENT/.test(r.stderr || '') ? { missing: true } : {}) };
+    // a failed exit is never an answer, whatever it printed (a login error on stdout)
+    if (r.exit_code !== 0) return { ok: false, reason: `the model exited with code ${r.exit_code}${tail ? `: ${clip(tail, 160)}` : ''}` };
+    const answer = String(r.stdout || '');
+    if (!answer.trim()) return { ok: false, reason: 'the model gave an empty answer' };
+    return { ok: true, text: answer };
+  });
+}
+
+// One call through the lineup: each model in turn until one answers, each
+// with what is left of timeoutMs. command is the claude command the call
+// wants (its model and effort); the others ride their own defaults. A stop,
+// or the server stopping its writers, ends it at once. A model that fails
+// sits out; so does one that said nothing until its time ran out, or for
+// unheardMs before a stop, unless it answered another call meanwhile. A
+// model that began to answer and is only slow keeps its place, and one
+// that answers is back in at once. With no answer, no_model says why:
+// 'none' when no model is on this computer, else 'failed'; retry says
+// another one here can still take the next call.
+async function think(prompt, { root, command = { bin: 'claude', args: claudeArgs }, cwd, timeoutMs = MODEL_TIMEOUT_MS, onProgress = () => {}, signal = null, unheardMs = UNHEARD_MS } = {}) {
+  const st = thinkerState(root);
+  const deadline = Date.now() + timeoutMs;
+  const stops = WRITER_STOPS;
+  const shutDown = () => ({ ok: false, reason: STOPPED_REASON, stopped: true });
+  let last = null;
+  for (const t of thinkerLineup(root)) {
+    if (WRITER_STOPS !== stops) return shutDown();
+    if (benched(st, t.id)) continue;
+    const left = deadline - Date.now();
+    if (left <= 0) break;
+    const started = Date.now();
+    const out = t.lead
+      ? await runModel(prompt, { command, cwd, timeoutMs: left, onProgress, signal })
+      : await askThinker(t.id, prompt, { timeoutMs: left, onProgress, signal });
+    if (out.ok) {
+      st.answered.set(t.id, Date.now());
+      st.bench.delete(t.id);
+      return { ...out, engine: t.id };
+    }
+    // the server stopped while this one ran: not the model's failure
+    if (WRITER_STOPS !== stops) return shutDown();
+    // heard: claude's api sent an event back, or another model printed a word
+    const silent = !out.heard && !(st.answered.get(t.id) >= started);
+    if (out.stopped) {
+      if (silent && Date.now() - started >= unheardMs) benchThinker(st, t.id, 'it never started to answer');
+      return { ...out, engine: t.id, ...(silent ? { unheard: true } : {}) };
+    }
+    last = out;
+    if (out.timed_out && !silent) break;
+    benchThinker(st, t.id, out.reason, Boolean(out.missing));
+  }
+  const verdict = thinkerVerdict(root);
+  return { ok: false, reason: last ? last.reason : 'no model here can think right now', no_model: verdict === 'none' ? 'none' : 'failed', retry: verdict === 'ready' };
+}
+
 // ---- checking a bet -------------------------------------------------------------------
 
 function parseBet(text) {
@@ -2152,6 +2362,14 @@ function ownerConcern(c) {
 // Every model attempt, writer and skeptic (the kind field), with its lane, is
 // kept in the attempts log, the stopped ones too.
 async function generateBet({ workspaceRoot, today, previousTitle = null, avoidTitles: avoidIn = [], reworkOf = null, ownerNote = null, concern = null, emit = () => {}, onBundle = () => {}, deps = {}, ledgerFile, attemptsFile, allowTeamMetrics = false, writers = deps.writers || SWARM_WRITERS, budgetMs = deps.budgetMs || SWARM_BUDGET_MS, signal = null } = {}) {
+  // the orb's lineup of models thinks, unless a test stubs the model
+  const lineup = !deps.runModel;
+  // no model here can think: said at once, before a fact is read
+  if (lineup) {
+    const verdict = thinkerVerdict(workspaceRoot);
+    if (verdict !== 'ready') return { ok: false, reason: verdict === 'none' ? 'no model is on this computer' : 'every model here failed just now', no_model: verdict, retry: false };
+  }
+  const benchesBefore = lineup ? thinkerState(workspaceRoot).benches : 0;
   // the budget runs on the real clock, the one the stop timer uses
   const deadline = Date.now() + budgetMs;
   const left = () => deadline - Date.now();
@@ -2159,10 +2377,12 @@ async function generateBet({ workspaceRoot, today, previousTitle = null, avoidTi
   const judgeMin = Math.min(JUDGE_MIN_LEFT_MS, budgetMs * (JUDGE_MIN_LEFT_MS / SWARM_BUDGET_MS));
   // a rework may stay close to the idea it reworks
   const avoidTitles = reworkOf ? avoidIn.filter(t => t !== reworkOf) : avoidIn;
-  const run = deps.runModel || ((prompt, opts) => runModel(prompt, { ...opts, command: writerCommand() }));
+  // claude silent for half the budget is not answering this drafting
+  const unheardMs = Math.min(UNHEARD_MS, budgetMs / 2);
+  const run = deps.runModel || ((prompt, opts) => think(prompt, { ...opts, root: workspaceRoot, command: writerCommand(), unheardMs }));
   // tests pass runSkeptic; a stubbed runModel without one is also used for the
   // skeptic, so a test can never reach the real model by accident
-  const judge = deps.runSkeptic || deps.runModel || ((prompt, opts) => runModel(prompt, { ...opts, command: skepticCommand() }));
+  const judge = deps.runSkeptic || deps.runModel || ((prompt, opts) => think(prompt, { ...opts, root: workspaceRoot, command: skepticCommand(), unheardMs }));
   const clock = deps.now || Date.now;
   const cwd = deps.runModel ? workspaceRoot : quietDir();
   const n = Math.max(1, Math.floor(Number(writers)) || 1);
@@ -2176,6 +2396,9 @@ async function generateBet({ workspaceRoot, today, previousTitle = null, avoidTi
   const live = new Set();
   let turnedDown = 0;
   let checking = 0;
+  // writer answers that came back, and writers stopped before the api said a word
+  let answers = 0;
+  let unheard = 0;
   let winner = null;
   let over = null;
   let release;
@@ -2261,7 +2484,9 @@ async function generateBet({ workspaceRoot, today, previousTitle = null, avoidTi
           emit({ kind: 'thinking', line: w ? `thinking... ${commas(w)} words written` : 'thinking...', n: w, lane: laneNo });
         },
       });
-      const base = { at: new Date(clock()).toISOString(), workspace: workspaceRoot, today, attempt, strategy: how, ...tag, ...(how === 'blocker' ? { blocker: blocker.missing_first } : {}), previous_title: previousTitle, avoid_titles: avoid.length, ms: clock() - started };
+      const base = { at: new Date(clock()).toISOString(), workspace: workspaceRoot, today, attempt, strategy: how, ...tag, ...(how === 'blocker' ? { blocker: blocker.missing_first } : {}), previous_title: previousTitle, avoid_titles: avoid.length, ms: clock() - started, ...(answer.engine ? { engine: answer.engine } : {}) };
+      if (answer.ok) answers += 1;
+      else if (answer.unheard) unheard += 1;
       if (!answer.ok) {
         saveAttempt(attemptsFile, { ...base, kind: 'writer', model_ok: false, ...(answer.stopped ? { stopped: true } : {}), raw: null, parse: null, passed: false, reasons: [answer.reason] });
         return { failed: answer.reason, stopped: Boolean(answer.stopped), base };
@@ -2373,6 +2598,13 @@ async function generateBet({ workspaceRoot, today, previousTitle = null, avoidTi
   Promise.all(lanes).then(() => stop('done'));
   await ended;
   finish();
+  // out of time with no answer back: the stopped calls end within the stop's
+  // grace, and only then is it known whether claude ever started to answer
+  if (lineup && over === 'budget' && !answers) {
+    let grace;
+    await Promise.race([Promise.all(lanes), new Promise((resolve) => { grace = setTimeout(resolve, STOP_GRACE_MS + 500); })]);
+    clearTimeout(grace);
+  }
 
   if (over === 'stopped') return { ok: false, stopped: true, reason: 'stopped before an idea was picked', bundle };
   if (winner) return { ok: true, bet: { ...winner.bet, skeptic: winner.verdict }, bundle, attempts: winner.attempt, lane: winner.lane, checked: true };
@@ -2386,7 +2618,19 @@ async function generateBet({ workspaceRoot, today, previousTitle = null, avoidTi
   emit({ kind: 'none', line: 'no draft met the plain rules', say: SWARM_SAY.nothing });
   const failedAll = ends.length > 0 && ends.every(e => e.model_failed);
   const last = [...ends].reverse().find(e => e.reason);
-  if (failedAll) return { ok: false, reason: ends[0].reason, bundle };
+  // No model answered: every writer's call failed, or the time ran out with
+  // claude never starting to answer. That is the model's trouble, never the
+  // owner's: no_model says so, and retry says another model here can take
+  // the next drafting (one sat out during this one, so it is not the same try).
+  const silent = over === 'budget' && !answers && unheard > 0;
+  if (failedAll || silent) {
+    const reason = failedAll ? ends[0].reason : `no model answered in ${Math.round(budgetMs / 1000)} seconds`;
+    if (!lineup && failedAll) return { ok: false, reason, bundle, no_model: 'failed', retry: false };
+    const verdict = lineup ? thinkerVerdict(workspaceRoot) : 'ready';
+    if (verdict !== 'ready') return { ok: false, reason, bundle, no_model: verdict, retry: false };
+    if (lineup && thinkerState(workspaceRoot).benches > benchesBefore) return { ok: false, reason, bundle, no_model: 'failed', retry: true };
+    if (failedAll) return { ok: false, reason, bundle };
+  }
   if (ends.length > 0 && ends.every(e => e.out_of_time) && !turnedDown) return { ok: false, reason: `no time was left to draft inside ${Math.round(budgetMs / 1000)} seconds once the facts were read`, bundle };
   if (over === 'budget') return { ok: false, reason: `nothing usable came back in ${Math.round(budgetMs / 1000)} seconds${last ? ` (${last.reason})` : ''}`, bundle };
   return { ok: false, reason: `the model's answer was turned down ${plural(turnedDown, 'time')} (${last ? last.reason : 'no answer met the rules'})`, bundle };
@@ -2854,6 +3098,7 @@ const BACKOFF_MS = 10 * 60 * 1000;
 //   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)
+//   wakeThinkers()                            forget which models were missing or failing, on a tap on the card that says so
 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; });
@@ -2867,7 +3112,7 @@ function createBetDesk(deps) {
   // a desk with a stubbed idea writer never reaches the real reader either
   const readFn = deps.readSaid || (deps.generate
     ? (async () => ({ ok: false, reason: 'no reader here' }))
-    : (opts => readSaid({ ...opts, workspaceRoot: deps.workspaceRoot, bundle: state.bundle, deps: deps.generatorDeps || {} })));
+    : (opts => readSaid({ ...opts, workspaceRoot: deps.workspaceRoot, bundle: state.bundle, deps: deps.generatorDeps || {}, ...(deps.sayTimeoutMs ? { timeoutMs: deps.sayTimeoutMs } : {}) })));
   const suggestNumbers = deps.suggestScoreboard || (deps.generate
     ? (() => new Promise(() => {}))
     : (opts => generateScoreboardChoices({ ...opts, deps: deps.generatorDeps || {}, ledgerFile: deps.ledgerFile, today: dayKey(now()) })));
@@ -2878,6 +3123,7 @@ function createBetDesk(deps) {
   // the real writer starts on the next turn, so its first reads never hold up a tap
   const generate = deps.generate || (opts => new Promise(resolve => setImmediate(resolve)).then(() => generateBet({ ...opts, deps: deps.generatorDeps || {}, ledgerFile: deps.ledgerFile, attemptsFile: deps.attemptsFile })));
   const log = deps.log || (() => {});
+  const wakeThinkers = deps.wakeThinkers || (() => forgetThinkers(deps.workspaceRoot));
   const state = {
     status: 'idle',
     current: null,
@@ -3408,6 +3654,10 @@ function createBetDesk(deps) {
     log({ card: 'bet', choice: 'show', command: null, ran: 'in process', exit_code: 0, kind: 'wait' });
   }
   const onWait = () => state.status === 'ready' && Boolean(state.current) && state.current.kind === 'wait';
+  // the card on screen says no model answered
+  const onNoModel = () => state.status === 'ready' && Boolean(state.current) && state.current.kind === 'missed' && Boolean(state.current.no_model);
+  // the line the calm line shows when one model did not answer and another takes over
+  const NEXT_MODEL_LINE = 'the model here did not answer, so another one is trying.';
 
   // Words typed on the calm line are a note for the idea being written: no
   // read, no new card. The next drafting starts with them (one under way
@@ -3480,19 +3730,22 @@ function createBetDesk(deps) {
     return { progress: lines, started_at: startedAt, waited_ms: Math.max(0, now() - startedAt) };
   }
 
-  // The wait ended with no draft that met the plain rules (the model is down,
-  // or every draft broke a rule): a card the owner can act on, never an error.
+  // The wait ended with no draft that met the plain rules: a card the owner
+  // can act on, never an error. When no model answered at all (noModel:
+  // 'none', no model on this computer, or 'failed', the one here did not
+  // answer) the card says that instead, and what to do.
   const MISSED_CARD = { what: 'no idea came together this time.' };
+  const NO_MODEL_CARD = { what: 'the orb needs a model signed in on this computer.' };
   // It remembers the wait it ended (after, and the id that wait was served
   // under), so words the owner was typing there still count.
-  function showMissed() {
+  function showMissed(noModel = null) {
     const was = state.current && state.current.kind === 'wait' ? state.current : null;
     const servedWait = was && state.served && state.served.kind === 'wait' ? state.served.id : null;
-    state.current = { kind: 'missed', id: `missed:${now()}`, ...(was ? { after: was.id, afterServed: servedWait, ...(was.note ? { note: was.note, notes: was.notes } : {}) } : {}) };
+    state.current = { kind: 'missed', id: `missed:${now()}`, ...(noModel ? { no_model: noModel } : {}), ...(was ? { after: was.id, afterServed: servedWait, ...(was.note ? { note: was.note, notes: was.notes } : {}) } : {}) };
     state.status = 'ready';
     state.mission = null;
     state.error = null;
-    log({ card: 'bet', choice: 'show', command: null, ran: 'in process', exit_code: 0, kind: 'missed' });
+    log({ card: 'bet', choice: 'show', command: null, ran: 'in process', exit_code: 0, kind: 'missed', ...(noModel ? { no_model: noModel } : {}) });
   }
 
   // The owner asked for something (a sharper idea, words on a card): a
@@ -3601,12 +3854,24 @@ function createBetDesk(deps) {
         }
         if (!out.ok) {
           // a failure stays in the log; the owner never sees the reason
-          log({ card: 'bet', choice: 'generate', command: null, ran: 'in process', exit_code: 1, error: clip(out.reason, 200) });
+          log({ card: 'bet', choice: 'generate', command: null, ran: 'in process', exit_code: 1, error: clip(out.reason, 200), ...(out.no_model ? { no_model: out.no_model } : {}) });
           emit({ kind: 'failed', line: out.reason });
+          // one model did not answer and another one here can: the next
+          // drafting starts on it now, with what this one was asked, and the
+          // calm line says so instead of ending
+          if (out.no_model && out.retry) {
+            if (gen.asked && !state.pendingSharper) state.pendingSharper = asks;
+            if (onWait()) {
+              state.current.lines = [...(state.current.lines || []), { at: now(), line: NEXT_MODEL_LINE }];
+              state.current.waitsOn = null;
+            }
+            return pump();
+          }
           state.failures += 1;
           if (state.failures >= MAX_BACKGROUND_FAILURES) backOff();
-          // the owner is waiting on the calm line: the wait ends in a card he can act on
-          if (onWait()) showMissed();
+          // the owner is waiting on the calm line: the wait ends in a card he
+          // can act on, the one that says no model answered when none did
+          if (onWait()) showMissed(out.no_model || null);
           return pump();
         }
         const item = { id: newId(), bet: out.bet, created_at: now(), state_key: key, ...(gen.asked ? { asked: true } : {}), ...(ownerNote && reworkOf ? { rework_of: reworkOf } : {}), ...(ownerNote ? { owner_note: ownerNote } : {}) };
@@ -3677,6 +3942,8 @@ function createBetDesk(deps) {
   // later: not now on a yes card.
   function next({ sharper = false, later = false } = {}) {
     if (state.status === 'starting') return { ok: true, busy: true, ...view() };
+    // a tap on the card that says no model answered looks again, so one signed in since then is found
+    if (onNoModel()) wakeThinkers();
     const onScreen = state.status === 'ready' && state.current ? state.current : null;
     // try again after a wait that ended with a note on it: the note goes into the next
     // drafting, or the calm line joins the one already writing it, never a second
@@ -4020,7 +4287,7 @@ function createBetDesk(deps) {
       id: cur ? cur.id : null,
       kind,
       bet: kind === 'bet' ? cur.bet : null,
-      job: kind === 'yes' || kind === 'done' ? publicJob(cur) : (kind === 'wait' ? { ...WAIT_CARD } : (kind === 'missed' ? { ...MISSED_CARD } : null)),
+      job: kind === 'yes' || kind === 'done' ? publicJob(cur) : (kind === 'wait' ? { ...WAIT_CARD } : (kind === 'missed' ? { ...(cur.no_model ? NO_MODEL_CARD : MISSED_CARD) } : null)),
       question: kind === 'question' ? { ask: cur.question.ask, line: cur.question.line, choices: cur.question.choices } : null,
       report: kind === 'report' ? {
         what: `${cur.board.name}: what is it this week?`,
@@ -4083,7 +4350,9 @@ function createBetDesk(deps) {
 
   // Read first. A question back or an unclear message is answered on the
   // same card and saves nothing; an answer or an instruction is acted on.
-  // A failed or slow read falls back to the plain line and saves nothing.
+  // A model that answered with a read of no use asks him to say it another
+  // way. A read no model answered (it failed, was slow, or none is here) is
+  // never put on his words: the reply says what happened, and nothing is saved.
   const QUESTION_HINT = 'his message ends with a question mark: it is a question back, not an answer';
   async function readTurn(t, text, card) {
     const thread = t.turns.slice(-THREAD_TURNS);
@@ -4092,16 +4361,23 @@ function createBetDesk(deps) {
     // more with that said, and if it still reads as an answer, fall back
     if (read && read.ok && read.kind === 'answer' && /\?\s*$/.test(text)) {
       read = await readWithin({ text, card, thread, hint: QUESTION_HINT });
-      if (read && read.ok && read.kind === 'answer') read = { ok: false, reason: 'a question read as an answer' };
+      if (read && read.ok && read.kind === 'answer') read = { ok: false, reason: 'a question read as an answer', answered: true };
     }
     if (read && read.ok && (read.kind === 'answer' || read.kind === 'instruction')) return { act: read };
-    const kind = read && read.ok ? read.kind : 'unclear';
-    const reply = (read && read.ok && plainReply(read.reply)) || SAY_FALLBACK;
+    let reply;
+    let kind;
+    if (read && (read.ok || read.answered)) {
+      reply = (read.ok && plainReply(read.reply)) || SAY_FALLBACK;
+      kind = reply === SAY_FALLBACK ? 'unclear' : read.kind;
+    } else {
+      reply = read && read.no_model && !read.retry ? SAY_NO_MODEL : SAY_NOT_HEARD;
+      kind = 'unheard';
+    }
     const suggestions = read && read.ok && reply !== SAY_FALLBACK
       ? plainSuggestions((Array.isArray(read.suggestions) ? read.suggestions : []).map(you).filter(sug => !(card.buttons || []).some(b => sameLabel(b, sug))))
       : [];
     addTurns(t, { who: 'owner', text }, { who: 'orb', text: reply });
-    return { stay: { ok: true, stay: true, kind: reply === SAY_FALLBACK ? 'unclear' : kind, reply, ...(suggestions.length ? { suggestions } : {}), thread: t.turns.slice() } };
+    return { stay: { ok: true, stay: true, kind, reply, ...(suggestions.length ? { suggestions } : {}), thread: t.turns.slice() } };
   }
 
   // On a question it is the answer; on an idea, a note the writer reworks it
@@ -4117,6 +4393,8 @@ function createBetDesk(deps) {
     if (card !== undefined && card !== cur.id) return { ok: false, reason: 'gone', message: 'that card changed, so nothing was done. here is the one on screen now.' };
     // on the calm line there is nothing to answer: the words are a note for the idea being written, read by no model
     if (cur.kind === 'wait') return noteOnWait(cur, said);
+    // words on the card that says no model answered look again first, so one signed in since then reads them
+    if (onNoModel()) wakeThinkers();
     let kind = cur.kind || 'bet';
     log({ card: 'bet', choice: 'say', command: null, ran: 'in process', exit_code: 0, kind, chars: said.length });
     const t = threadFor(cur.id);
@@ -4541,7 +4819,7 @@ function createBetDesk(deps) {
     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, ...waitProgress(cur), thread: waitThread(cur) });
-    if (kind === 'missed') return gmCard.missed({ id: cur.id });
+    if (kind === 'missed') return gmCard.missed({ id: cur.id, noModel: cur.no_model || null });
     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 } });

package/lib/gm-card.js

@@ -166,10 +166,20 @@ function wait({ id, progress = [], started_at = null, waited_ms = null, thread =
   return { id, kind: 'wait', asks: id, title: 'writing your next idea.', body: null, options: [], input: sayInput({ placeholder: 'add a note for this idea' }), watch: true, progress, started_at, waited_ms, thread };
 }
 
-// the wait ended with nothing usable: a way to try again, and the box
-function missed({ id }) {
+// the wait ended with nothing usable: a way to try again, and the box.
+// noModel: no model answered at all, so the card says what it needs
+// instead: 'none' when there is no model on this computer, 'failed' when
+// the one here did not answer
+const NO_MODEL_TITLE = 'the orb needs a model signed in on this computer.';
+const NO_MODEL_BODY = {
+  none: 'there is none here yet. once one is set up, tap try again.',
+  failed: 'the model here did not answer. check that it is signed in, then tap try again.',
+};
+function missed({ id, noModel = null }) {
   return {
-    id, kind: 'missed', asks: id, title: 'no idea came together this time.', body: 'try again, or say what you want one about.',
+    id, kind: 'missed', asks: id,
+    title: noModel ? NO_MODEL_TITLE : 'no idea came together this time.',
+    body: noModel ? NO_MODEL_BODY[noModel] || NO_MODEL_BODY.failed : 'try again, or say what you want one about.',
     options: [answer(id, { id: 'again', label: 'try again', action: 'next', style: 'primary' })],
     input: sayInput(),
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.74.13",
+  "version": "3.74.14",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",