atris 3.74.12 → 3.74.14

package/commands/member.js

@@ -785,6 +785,7 @@ const MEMBER_RUN_START_BOOLEAN_FLAGS = [
   '--json',
   '--no-verify',
   '--referee',
+  '--referee-if-check-edited',
   '--no-referee',
   '--worktree',
   '--shared-checkout',
@@ -1064,9 +1065,21 @@ function startMemberRunMission(name, missionText, args = []) {
 }
 
 // An ignited run asks a second engine to review the work by default, so every
-// run ends with a verdict. --no-referee skips it; an explicit --referee is kept.
-function memberRunWantsReferee(runArgs, ignite) {
-  return Boolean(ignite) && !hasFlag(runArgs, '--referee') && !hasFlag(runArgs, '--no-referee');
+// run ends with a verdict. A real test command is already that verdict: the
+// second engine only reran the same commands and cost about a minute a run
+// (member lab 2026-10-24), so it stays for runs whose check is not a test
+// runner (whitespace, syntax, or file-exists checks). --no-referee skips it; an explicit --referee is kept.
+function memberRunHasRealCheck(verifier) {
+  const command = String(verifier || '').trim();
+  // A plain test runner only: chaining (|| true, ; , &&, pipes, subshells) or a
+  // pass-with-no-tests switch can make any run "pass", so those keep the review.
+  if (/\|\||&&|[;|`\r\n]|\$\(|pass-?with-?no-?tests|--no-tests|--exit-zero/i.test(command)) return false;
+  return /^((npm|pnpm|yarn)\s+(run\s+)?test\b|node\s+--test\b|npx\s+(jest|vitest|mocha)\b|pytest\b|python3?\s+-m\s+pytest\b|go\s+test\b|cargo\s+test\b)/i.test(command);
+}
+
+function memberRunWantsReferee(runArgs, ignite, verifier = '') {
+  return Boolean(ignite) && !hasFlag(runArgs, '--referee') && !hasFlag(runArgs, '--no-referee')
+    && !memberRunHasRealCheck(verifier);
 }
 
 function memberRunCli(args, cwd, { live = false, missionId = '' } = {}) {
@@ -1393,7 +1406,10 @@ function memberRunWith(name, args, { quiet = false, closeTaskIds = [] } = {}) {
     ['--mission', '--mission-id', '--minutes', '--hours', '--industry', '--domain', '--value', '--outcome', '--truth', '--proof', '--base', '--yes-lock', '--yes-lock-parent'],
     ['--worktree', '--shared-checkout', '--no-worktree', '--choose-work', '--auto', '--ignite', '--wait', '--sync']);
   if (ignite && !hasFlag(runArgs, '--complete-on-pass')) runArgs.push('--complete-on-pass');
-  if (memberRunWantsReferee(runArgs, ignite)) runArgs.push('--referee');
+  if (memberRunWantsReferee(runArgs, ignite, mission.verifier)) runArgs.push('--referee');
+  // Skipped because a real test is the check: review anyway if the worker
+  // edits what that test command runs.
+  else if (ignite && memberRunHasRealCheck(mission.verifier) && !hasFlag(runArgs, '--no-referee')) runArgs.push('--referee-if-check-edited');
   const budgetSeconds = memberRunBudgetSeconds(args);
   if (!readFlag(runArgs, '--max-ticks', '')) {
     runArgs.push('--max-ticks', budgetSeconds ? String(Math.max(4, Math.ceil(budgetSeconds / 300))) : '1');

package/commands/mission.js

@@ -788,6 +788,7 @@ const MISSION_RUN_BOOLEAN_FLAGS = [
   '--no-claude',
   '--no-verify',
   '--referee',
+  '--referee-if-check-edited',
   '--no-referee',
   '--complete-on-pass',
   '--no-drain',
@@ -6950,6 +6951,39 @@ function missionProtectedTags(mission, root = process.cwd()) {
   return tags;
 }
 
+// True when the tick changed what its check command runs: package.json (which
+// defines npm test) or a file the command names. A passing test the worker
+// rewrote is not evidence on its own.
+function tickTouchedCheckDefinition(verifier, before, root = process.cwd()) {
+  const run = (args) => spawnSync('git', args, { cwd: root, encoding: 'utf8' });
+  const head = String(before?.head || '').trim();
+  const changed = [
+    // No starting commit to compare against: every tracked file counts.
+    ...String(run(head ? ['diff', '--name-only', head] : ['ls-files']).stdout || '').split('\n'),
+    ...String(run(['diff', '--name-only', 'HEAD']).stdout || '').split('\n'),
+    ...String(run(['ls-files', '--others', '--exclude-standard']).stdout || '').split('\n'),
+  ].map((file) => file.trim()).filter(Boolean);
+  // npm test runs whatever package.json says, so its paths and folders count too.
+  let checkText = String(verifier || '');
+  if (/^(npm|pnpm|yarn)\s/i.test(checkText.trim())) {
+    try { checkText += ` ${JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'))?.scripts?.test || ''}`; } catch {}
+  }
+  // Runners that find tests by name (node --test, jest, pytest, go test) never
+  // list them, so any changed file shaped like a test counts as well.
+  const testShaped = /(^|\/)(tests?|__tests__|specs?|checks?)\/|\.(test|spec)\.[cm]?[jt]sx?$|_test\.(go|py)$|(^|\/)test_[^/]*\.py$|(^|\/)conftest\.py$/i;
+  return changed.some((file) => path.basename(file) === 'package.json'
+    || testShaped.test(file)
+    || checkText.includes(file)
+    || (path.dirname(file) !== '.' && checkText.includes(`${path.dirname(file)}/`)));
+}
+
+// The worker's `learned:` line from its receipt, so the lesson reaches the
+// member log (and the next worker's preloaded memory) without a hand edit.
+function receiptLearnedLine(text) {
+  const match = String(text || '').match(/^[\s*-]*learned:\s*(.+)$/im);
+  return match ? match[1].trim().slice(0, 240) : undefined;
+}
+
 function inspectMissionTickProtectedDiff(mission, before, root = process.cwd()) {
   const after = gitWorktreeSnapshot(root);
   if (before?.reason === 'not-git-worktree' && after?.reason === 'not-git-worktree') {
@@ -9153,6 +9187,31 @@ function readBoundedContextFile(filePath, maxChars = 1600) {
   }
 }
 
+// Code members never call the account-wide tool servers (mail, calendar,
+// docs), yet loading them cost about 5s per worker start in the member lab.
+// They keep the project's own .mcp.json; ATRIS_MEMBER_KEEP_MCP=1 keeps all.
+const CODE_MEMBERS = new Set(['executor', 'builder', 'codex-executor', 'auto-improver', 'navigator', 'validator', 'architect']);
+
+function claudeRunnerMcpArgs(mission, cwd = process.cwd(), env = process.env) {
+  if (env.ATRIS_MEMBER_KEEP_MCP === '1') return [];
+  if (!CODE_MEMBERS.has(String(mission?.owner || '').trim().toLowerCase())) return [];
+  const args = ['--strict-mcp-config'];
+  const projectConfig = path.join(cwd, '.mcp.json');
+  if (fs.existsSync(projectConfig)) args.push('--mcp-config', projectConfig);
+  // Servers added for this folder with Claude's local scope live in
+  // ~/.claude.json under the folder's path; keep those too.
+  try {
+    const home = env.HOME || os.homedir();
+    const projects = JSON.parse(fs.readFileSync(path.join(home, '.claude.json'), 'utf8'))?.projects || {};
+    // A side checkout's servers are usually registered under the main checkout.
+    const common = spawnSync('git', ['rev-parse', '--git-common-dir'], { cwd, encoding: 'utf8' });
+    const mainRoot = common.status === 0 ? path.dirname(path.resolve(cwd, String(common.stdout || '').trim())) : '';
+    const local = { ...(mainRoot ? projects[mainRoot]?.mcpServers : null), ...projects[path.resolve(cwd)]?.mcpServers };
+    if (Object.keys(local).length) args.push('--mcp-config', JSON.stringify({ mcpServers: local }));
+  } catch {}
+  return args;
+}
+
 function buildPreloadedMemberContextLines(mission, root = process.cwd()) {
   const owner = String(mission?.owner || '').trim();
   const baseRoot = mission?.worktree_root || mission?.worktree?.path || root;
@@ -9282,7 +9341,7 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = [], cwd =
     ``,
     `## Your task`,
     `Do ONE increment of work toward the stop condition. ONE. No more.`,
-    `- ${memberIdentityLine(mission.owner)} Read atris/team/${mission.owner}/MEMBER.md (and SOUL.md if present) before acting, work in that identity, inside its scope and stop rules. After your work, append what you did and what you learned to atris/team/${mission.owner}/logs/<today's date>.md.`,
+    `- ${memberIdentityLine(mission.owner)} Your member files are preloaded above; open atris/team/${mission.owner}/MEMBER.md only if that copy is marked truncated. Work in that identity, inside its scope and stop rules. Atris writes your member log from your receipt, so end the receipt with one \`learned: <one line>\` line instead of editing the log.`,
     `- FIRST: inspect current mission/task state before acting. Read the relevant files, run \`atris mission status ${mission.id}\`, \`git status\`, or \`atris task list\` as needed so you know what's already done.`,
     `- Pick the smallest concrete action that moves the mission forward.`,
     `- Before acting, state your single next move in one sentence.`,
@@ -9290,7 +9349,7 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = [], cwd =
     `- The tick is not done until the verify step passes. If a frozen verifier exists, the harness runs it, but that does not replace the real-surface proof below. If no frozen verifier exists, finish by actually running the surface you changed on this computer and paste the real command output into your receipt.`,
     `- After that one verify step, STOP. Never start a second slice in one tick.`,
     `- Write the tick summary in operator language: what changed and what it buys or costs in plain words, with no flags, task ids, or code identifiers.`,
-    `- Propose the next needle-mover: include a \`next_push: <one concrete feature or optimization to build next>\` line in your receipt and member log so the team compounds exponentially.`,
+    `- Propose the next needle-mover: include a \`next_push: <one concrete feature or optimization to build next>\` line in your receipt so the team compounds exponentially.`,
     ``,
     `## No claimable work? Work the backstop ladder`,
     `If the mission and task state offer no claimable work, inspect these rungs in order. Pick the FIRST rung with real fuel and do ONE bounded slice:`,
@@ -9686,6 +9745,7 @@ function spawnGenericRunnerTick(mission, opts) {
         result: finalText,
         summary: usefulClaudeReceiptSummary(finalText || errStr, ok ? 'no-text' : 'error'),
         receipt_text: cappedClaudeReceiptText(finalText || errStr),
+        learned: receiptLearnedLine(finalText),
         duration_total_ms: Date.now() - startedAt,
         num_turns: null,
         stop_reason: null,
@@ -9775,6 +9835,7 @@ function spawnClaudeTick(mission, opts) {
     ];
     if (model) args.push('--model', model);
     if (mission.roster_effort) args.push('--effort', mission.roster_effort);
+    args.push(...claudeRunnerMcpArgs(mission, cwd));
     if (sessionMode === 'set') args.push('--session-id', sessionId);
     else if (sessionMode === 'resume') args.push('--resume', sessionId);
 
@@ -9881,6 +9942,7 @@ function spawnClaudeTick(mission, opts) {
         result: finalText,
         summary: usefulClaudeReceiptSummary(finalText, ok ? 'no-text' : 'error'),
         receipt_text: cappedClaudeReceiptText(finalText),
+        learned: receiptLearnedLine(finalText),
         api_equivalent_estimate: costEstimate,
         duration_api_ms: durationApiMs,
         duration_total_ms: Date.now() - startedAt,
@@ -10124,6 +10186,7 @@ async function parseAndValidateMissionRunPhase(args) {
   const skipClaude = hasFlag(args, '--no-claude');
   const verifyEach = !hasFlag(args, '--no-verify');
   const refereeEach = hasFlag(args, '--referee') && !hasFlag(args, '--no-referee');
+  const refereeIfCheckEdited = hasFlag(args, '--referee-if-check-edited') && !hasFlag(args, '--no-referee');
   const refereeEngine = readFlag(args, '--referee-engine', '');
   const completeOnPass = hasFlag(args, '--complete-on-pass');
   const skipDrain = hasFlag(args, '--no-drain');
@@ -10161,6 +10224,7 @@ async function parseAndValidateMissionRunPhase(args) {
     skipClaude,
     verifyEach,
     refereeEach,
+    refereeIfCheckEdited,
     refereeEngine,
     completeOnPass,
     skipDrain,
@@ -10995,6 +11059,7 @@ async function executeMissionRunTicksPhase(context) {
         verifier: verifierResult ? (verifierResult.passed ? 'passed' : 'failed') : 'not_run',
         summary: tickSummaryText ? tickSummaryText.slice(0, 240) : undefined,
         next_push: result.next_push ? String(result.next_push).slice(0, 180) : undefined,
+        learned: result?.claude?.learned || receiptLearnedLine(result?.claude?.result || result?.claude?.receipt_text),
         feedback: verifierResult && !verifierResult.passed ? String(mission.last_check_feedback || '').slice(0, 240) : undefined,
         receipt: receiptPath,
       }, cwd);
@@ -11192,6 +11257,7 @@ async function verifyMissionRunTickPhase(context) {
       && (
         !currentTick.frozen.verifier
         || context.refereeEach
+        || (context.refereeIfCheckEdited && tickTouchedCheckDefinition(currentTick.frozen.verifier, currentTick.tickWorktreeBefore, cwd))
         || (!currentTick.storedVerifier && !process.env.NODE_TEST_CONTEXT)
       );
     if (shouldRunReferee) {
@@ -12860,6 +12926,9 @@ function missionCommand(args) {
 }
 
 module.exports = {
+  receiptLearnedLine,
+  tickTouchedCheckDefinition,
+  claudeRunnerMcpArgs,
   crystallizeMemberSkillLesson,
   listSiblingWorkspaceMissionHints,
   missionProtectedLaneHold,

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/lib/zen-apply.js

@@ -31,6 +31,7 @@ const {
   sideCopyLines,
   scheduledCopies,
   runningCopies,
+  shortPlace,
   untrackedFiles,
   ABANDONED_DAYS,
   abandonedDaysFromEnv,
@@ -81,6 +82,13 @@ function identityEnv(root) {
   return env;
 }
 
+// Where zen put your copy of a clashing note, said from the repo root so the
+// line fits the pane, or from home when it sits outside the repo.
+function savedPlace(root, file) {
+  const rel = path.relative(root, file);
+  return rel && !rel.startsWith('..') && !path.isAbsolute(rel) ? rel : shortPlace(file);
+}
+
 function archiveStashes(root, tag) {
   const shas = (gitOut(['stash', 'list', '--format=%H'], root) || '').split('\n').filter(Boolean);
   if (!shas.length) return null;
@@ -444,7 +452,7 @@ function moveKeepingNotes(root, args, target, tag, from = 'HEAD') {
     for (const p of clashed) {
       const mine = path.join(dir, 'mine', p);
       if (isJournal(p) && joinJournal(path.join(root, p), mine)) notes.push(`joined your ${p} onto the new one`);
-      else if (!(fromCommit && lineRefsOnly(root, fromCommit, p, mine))) notes.push(`kept the new ${p}; your copy is in ${mine}`);
+      else if (!(fromCommit && lineRefsOnly(root, fromCommit, p, mine))) notes.push(`kept the new ${p}; your copy is in ${savedPlace(root, mine)}`);
     }
     for (const p of missed) {
       const mine = path.join(dir, 'mine', p);
@@ -452,9 +460,9 @@ function moveKeepingNotes(root, args, target, tag, from = 'HEAD') {
       if (to && fromCommit && followMove(root, fromCommit, p, to, mine)) {
         notes.push(`${p} moved to ${to}, and your edits went with it`);
       } else if (to) {
-        notes.push(`${p} moved to ${to} and your edits clash there; your copy is in ${fs.existsSync(mine) ? mine : patchFile}`);
+        notes.push(`${p} moved to ${to} and your edits clash there; your copy is in ${savedPlace(root, fs.existsSync(mine) ? mine : patchFile)}`);
       } else {
-        notes.push(`${p} no longer fits the new changes; your copy is in ${fs.existsSync(mine) ? mine : patchFile}`);
+        notes.push(`${p} no longer fits the new changes; your copy is in ${savedPlace(root, fs.existsSync(mine) ? mine : patchFile)}`);
       }
     }
   }
@@ -464,7 +472,7 @@ function moveKeepingNotes(root, args, target, tag, from = 'HEAD') {
       // A copy that matches the incoming file loses nothing, so say nothing.
       if (sameBytes(saved, path.join(root, p))) fs.rmSync(saved, { force: true });
       else if (isJournal(p) && joinJournal(path.join(root, p), saved)) notes.push(`joined your ${p} onto the new one`);
-      else notes.push(`kept the new ${p}; your copy is in ${saved}`);
+      else notes.push(`kept the new ${p}; your copy is in ${savedPlace(root, saved)}`);
     } else {
       fs.mkdirSync(path.dirname(path.join(root, p)), { recursive: true });
       fs.copyFileSync(saved, path.join(root, p));

package/lib/zen.js

@@ -646,4 +646,5 @@ module.exports = {
   readTeamState,
   scheduledCopies,
   runningCopies,
+  shortPlace,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.74.12",
+  "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",