atris 3.80.0 → 3.82.1

package/lib/json-file.js

@@ -34,4 +34,25 @@ function writeJson(filePath, value, { indent = 2 } = {}) {
   return filePath;
 }
 
-module.exports = { readJson, writeJson };
+/**
+ * Write text to a file by way of a temp file in the same folder and a rename, so a
+ * reader never sees half a file and two writers never interleave: the last rename wins
+ * whole. Creates parent dirs. The temp file is removed if the write fails.
+ * @param {string} filePath
+ * @param {string} text
+ * @returns {string} the path written
+ */
+function writeFileAtomic(filePath, text) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmp = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`);
+  try {
+    fs.writeFileSync(tmp, text, 'utf8');
+    fs.renameSync(tmp, filePath);
+  } catch (err) {
+    try { fs.rmSync(tmp, { force: true }); } catch { /* nothing left to clean */ }
+    throw err;
+  }
+  return filePath;
+}
+
+module.exports = { readJson, writeJson, writeFileAtomic };

package/lib/loop-doctor.js

@@ -127,6 +127,20 @@ function walk(value, visit, trail = []) {
   });
 }
 
+function tickSignalIdentity(receipt, value) {
+  if (!value || typeof value !== 'object') return null;
+  const missionId = String((receipt && receipt.mission_id) || value.mission_id || '').trim();
+  const briefId = String((value.claude && value.claude.brief_id) || value.brief_id || '').trim();
+  if (briefId) return `brief:${missionId}:${briefId}`;
+  const hasTickIndex = value.tick_index != null && value.tick_index !== '';
+  const startedAt = typeof value.started_at === 'string' ? value.started_at.trim() : '';
+  const finishedAt = typeof value.finished_at === 'string' ? value.finished_at.trim() : '';
+  if (hasTickIndex && (startedAt || finishedAt)) {
+    return `tick:${missionId}:${value.tick_index}:${startedAt}:${finishedAt}`;
+  }
+  return null;
+}
+
 function receiptFailureSignals(entry) {
   const signals = [];
   walk(entry.receipt, (value, trail) => {
@@ -137,7 +151,7 @@ function receiptFailureSignals(entry) {
     // node carries none.
     const signalTs = objectTimestamp(value) || entry.ts;
     if (typeof value.pause_reason === 'string' && value.pause_reason.trim()) {
-      signals.push({ type: 'pause_reason', value: value.pause_reason.trim(), trail, ts: signalTs });
+      signals.push({ type: 'pause_reason', value: value.pause_reason.trim(), trail, ts: signalTs, signalId: null });
     }
     const status = String(value.status || '').toLowerCase();
     const tickContext = trail.some((part) => part === 'tick' || part === 'ticks');
@@ -148,7 +162,15 @@ function receiptFailureSignals(entry) {
     if (!errored) return;
     const detail = value.error || value.error_message || value.reason || value.message || status;
     const text = typeof detail === 'string' ? detail.trim() : JSON.stringify(detail);
-    if (text) signals.push({ type: 'tick_error', value: text, trail, ts: signalTs });
+    if (text) {
+      signals.push({
+        type: 'tick_error',
+        value: text,
+        trail,
+        ts: signalTs,
+        signalId: tickSignalIdentity(entry.receipt, value),
+      });
+    }
   });
   const unique = new Map();
   for (const signal of signals) unique.set(`${signal.type}\0${signal.value}`, signal);
@@ -157,10 +179,16 @@ function receiptFailureSignals(entry) {
 
 function repeatedFailureFindings(receipts, nowIso, freshnessMs) {
   const groups = new Map();
+  const seenSignalIds = new Map();
   for (const entry of receipts) {
     for (const signal of receiptFailureSignals(entry)) {
       const key = `${signal.type}\0${signal.value}`;
       if (!groups.has(key)) groups.set(key, []);
+      if (signal.signalId) {
+        const dedupKey = `${key}\0${signal.signalId}`;
+        if (seenSignalIds.has(dedupKey)) continue;
+        seenSignalIds.set(dedupKey, true);
+      }
       groups.get(key).push({ ts: signal.ts || entry.ts, receipt: path.basename(entry.file), trail: signal.trail });
     }
   }
@@ -267,10 +295,16 @@ function isOpenMission(mission) {
   return mission && !TERMINAL_MISSION_STATUSES.has(String(mission.status || 'planning').toLowerCase());
 }
 
+function isLoopDoctorRepairMission(mission) {
+  const objective = String(mission && mission.objective || '').trim();
+  return /^\[loop-doctor:[^\]]+\]/i.test(objective);
+}
+
 function isDueCapableMission(mission) {
   const cadence = String(mission && mission.cadence || 'manual').trim().toLowerCase();
   const runner = String(mission && mission.runner || 'manual').trim().toLowerCase();
   return isOpenMission(mission)
+    && !isLoopDoctorRepairMission(mission)
     && cadence !== 'manual'
     && cadence !== ''
     && mission.always_on === true

package/lib/map-refs.js

@@ -194,16 +194,32 @@ function fixMapRefs(root, mapFile = 'atris/MAP.md') {
 }
 
 // The short routing map loads at boot; exact line refs live in the notes file.
-// Both are checked and fixed, so moving a ref out of the boot map never hides it.
+// A workspace may split the notes into one file per area under atris/refs/map/,
+// with MAP-NOTES.md left as their index. Every one is checked and fixed, so
+// moving a ref out of the boot map or into an area note never hides it.
 const MAP_REF_DOCS = ['atris/MAP.md', 'atris/refs/MAP-NOTES.md'];
+const MAP_NOTES_DIR = 'atris/refs/map';
+
+function isFile(file) {
+  try { return fs.statSync(file).isFile(); } catch (error) {
+    if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return false;
+    throw error;
+  }
+}
+
+function areaNoteDocs(root) {
+  let names;
+  try { names = fs.readdirSync(path.resolve(root, MAP_NOTES_DIR)); } catch (error) {
+    if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return [];
+    throw error;
+  }
+  return names.filter(name => name.endsWith('.md')).sort()
+    .map(name => `${MAP_NOTES_DIR}/${name}`)
+    .filter(doc => isFile(path.resolve(root, doc)));
+}
 
 function existingMapDocs(root) {
-  return MAP_REF_DOCS.filter(doc => {
-    try { return fs.statSync(path.resolve(root, doc)).isFile(); } catch (error) {
-      if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return false;
-      throw error;
-    }
-  });
+  return [...MAP_REF_DOCS.filter(doc => isFile(path.resolve(root, doc))), ...areaNoteDocs(root)];
 }
 
 // Boot scores the docs every session, and checking every ref means reading
@@ -284,9 +300,53 @@ function fixMapDocs(root) {
   return { changes, left };
 }
 
+// Lines from the deep map notes that share words with a query, for prompts that
+// cannot open files themselves. With area notes, the index only describes them,
+// so the notes are read instead. Notes are ranked by how many query words they
+// match, and the budget fills from the best note first, its best lines first.
+function mapNotesExcerpt(root, query, maxChars) {
+  const words = [...new Set(String(query || '').toLowerCase().split(/[^a-z0-9]+/).filter(w => w.length >= 4))];
+  if (!words.length || !(maxChars > 0)) return '';
+  // The notes file is read too while it still holds real notes, so a project
+  // that has moved only some of them into area notes keeps the rest.
+  const notes = existingMapDocs(root).filter(doc => doc !== MAP_REF_DOCS[0])
+    .filter(doc => doc !== MAP_REF_DOCS[1] || !areaNoteDocs(root).length || holdsRealNotes(fs.readFileSync(path.resolve(root, doc), 'utf8')));
+  const ranked = notes.map((doc, order) => {
+    const lines = fs.readFileSync(path.resolve(root, doc), 'utf8').split(/\r?\n/)
+      .map((line, index) => ({ line, index, hits: words.filter(w => line.toLowerCase().includes(w)).length }))
+      .filter(row => row.hits > 0)
+      .sort((a, b) => b.hits - a.hits || a.index - b.index);
+    const matched = new Set(words.filter(w => lines.some(row => row.line.toLowerCase().includes(w))));
+    return { doc, order, lines, matched: matched.size, total: lines.reduce((sum, row) => sum + row.hits, 0) };
+  }).filter(note => note.lines.length)
+    .sort((a, b) => b.matched - a.matched || b.total - a.total || a.order - b.order);
+  const out = [];
+  let used = 0;
+  for (const note of ranked) {
+    for (const row of note.lines) {
+      // Lines are joined by one newline, so only lines after the first pay for it.
+      const room = maxChars - used - (out.length ? 1 : 0);
+      if (room <= 0) return out.join('\n');
+      if (row.line.length > room) {
+        out.push(row.line.slice(0, room));
+        return out.join('\n');
+      }
+      out.push(row.line);
+      used += row.line.length + (out.length > 1 ? 1 : 0);
+    }
+  }
+  return out.join('\n');
+}
+
+// An index line links into atris/refs/map/; a real note names code or a search.
+function holdsRealNotes(text) {
+  return text.split(/\r?\n/).some(line => !line.includes('](map/')
+    && (/`[\w./-]+\.(?:js|mjs|cjs|ts|py|sh|json)(?::\d+(?:-\d+)?)?`/.test(line) || /^\s*rg "/.test(line)));
+}
+
 // Repo-relative path of the notes file when this workspace has one, else null.
 function mapNotesPath(root) {
   return existingMapDocs(root).includes(MAP_REF_DOCS[1]) ? MAP_REF_DOCS[1] : null;
 }
 
-module.exports = { MAP_REF_DOCS, existingMapDocs, mapNotesPath, checkMapRefs, checkMapDocs, fixMapRefs, fixMapDocs };
+module.exports = { MAP_REF_DOCS, MAP_NOTES_DIR, existingMapDocs, mapNotesPath, mapNotesExcerpt, checkMapRefs, checkMapDocs, fixMapRefs, fixMapDocs };

package/lib/member-engine.js

@@ -5,7 +5,7 @@
 // validators, reviewers, judges, critics, and verifiers review; everyone else
 // builds. A line under "## team" in ROSTER.md overrides that, either with a
 // job ("researcher: search", "fixer: small build") or with engine or model
-// words ("judge: opus 5.5"). The job's pick then comes from the roster.
+// words ("judge: opus"). The job's pick then comes from the roster.
 
 const fs = require('fs');
 const { memberRefusalReason } = require('./member-type');

package/lib/member-map-fold.js

@@ -4,7 +4,9 @@
 // atris/refs/map-notes.d/ instead of editing atris/refs/MAP-NOTES.md, so two
 // changes never clash on the shared map. Once an hour the autoland tick folds
 // those files into MAP-NOTES.md on the main branch and removes them, in one
-// commit built without touching any checkout. A push that loses a race with
+// commit built without touching any checkout. When the notes are split into
+// area notes under atris/refs/map/, a drop whose heading an area note already
+// has folds into that note; any other drop folds into the member notes file. A push that loses a race with
 // another landing is dropped; the next hour tries again from the new main.
 
 const fs = require('fs');
@@ -12,8 +14,12 @@ const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
+const { MAP_NOTES_DIR } = require('./map-refs');
+
 const NOTES_FILE = 'atris/refs/MAP-NOTES.md';
 const DROP_DIR = 'atris/refs/map-notes.d';
+const MEMBER_NOTES_FILE = `${MAP_NOTES_DIR}/member-notes.md`;
+const MEMBER_NOTES_HEAD = '# Member notes\n\nMap notes that member changes added and no area has claimed yet. Move each one into the area note that owns its code. Back to [MAP-NOTES.md](../MAP-NOTES.md).\n';
 const FOLD_EVERY_MS = 60 * 60 * 1000;
 
 function git(args, cwd, extraEnv = {}) {
@@ -71,6 +77,34 @@ function foldNotesText(notes, drops) {
   return { text: lines.length ? `${lines.join('\n')}\n` : '', added };
 }
 
+// Which notes file each drop folds into. Without area notes every drop goes to
+// MAP-NOTES.md as before.
+function foldTargets(root, baseSha, drops) {
+  const read = (file) => {
+    const blob = git(['cat-file', 'blob', `${baseSha}:${file}`], root);
+    return blob.ok ? blob.stdout : null;
+  };
+  const listed = git(['ls-tree', '--name-only', baseSha, '--', `${MAP_NOTES_DIR}/`], root).stdout
+    .split('\n').filter((f) => f.endsWith('.md')).sort();
+  const targets = new Map();
+  const put = (file, text, drop) => {
+    if (!targets.has(file)) targets.set(file, { text, drops: [] });
+    targets.get(file).drops.push(drop);
+  };
+  if (!listed.length) {
+    for (const drop of drops) put(NOTES_FILE, read(NOTES_FILE) || '', drop);
+    return targets;
+  }
+  const notes = listed.map((file) => ({ file, text: read(file) || '' }));
+  for (const drop of drops) {
+    const first = trimEnd(drop.text).split('\n').find((l) => l.trim()) || '';
+    const owner = isHeading(first) && notes.find((note) => note.text.split('\n').some((l) => l.trim() === first.trim()));
+    if (owner) put(owner.file, owner.text, drop);
+    else put(MEMBER_NOTES_FILE, read(MEMBER_NOTES_FILE) || MEMBER_NOTES_HEAD, drop);
+  }
+  return targets;
+}
+
 function mainBranch(root, remote) {
   const head = git(['symbolic-ref', '--short', `refs/remotes/${remote}/HEAD`], root).stdout.trim();
   return head.startsWith(`${remote}/`) ? head.slice(remote.length + 1) : 'master';
@@ -96,19 +130,23 @@ function foldMapNotesOnMain(root, { base = '', remote = 'origin', push = true }
     if (!blob.ok) return { folded: 0, reason: 'drop_unreadable', detail: file };
     drops.push({ file, text: blob.stdout });
   }
-  const current = git(['cat-file', 'blob', `${baseSha}:${NOTES_FILE}`], root);
-  const { text, added } = foldNotesText(current.ok ? current.stdout : '', drops);
-
+  const targets = foldTargets(root, baseSha, drops);
+  let added = 0;
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-map-fold-'));
   try {
     const index = { GIT_INDEX_FILE: path.join(tmp, 'index') };
-    const notesPath = path.join(tmp, 'notes');
-    fs.writeFileSync(notesPath, text);
-    const blob = git(['hash-object', '-w', notesPath], root).stdout.trim();
-    const built = git(['read-tree', baseSha], root, index).ok
-      && /^[0-9a-f]{40,64}$/.test(blob)
-      && git(['update-index', '--add', '--cacheinfo', `100644,${blob},${NOTES_FILE}`], root, index).ok
-      && git(['update-index', '--force-remove', '--', ...files], root, index).ok;
+    let built = git(['read-tree', baseSha], root, index).ok;
+    for (const [target, { text: currentText, drops: targetDrops }] of targets) {
+      if (!built) break;
+      const folded = foldNotesText(currentText, targetDrops);
+      added += folded.added;
+      const notesPath = path.join(tmp, 'notes');
+      fs.writeFileSync(notesPath, folded.text);
+      const blob = git(['hash-object', '-w', notesPath], root).stdout.trim();
+      built = /^[0-9a-f]{40,64}$/.test(blob)
+        && git(['update-index', '--add', '--cacheinfo', `100644,${blob},${target}`], root, index).ok;
+    }
+    built = built && git(['update-index', '--force-remove', '--', ...files], root, index).ok;
     const tree = built ? git(['write-tree'], root, index).stdout.trim() : '';
     const message = `Fold ${files.length} map ${files.length === 1 ? 'note' : 'notes'} from member changes into the shared map`;
     const commit = tree ? git(['commit-tree', tree, '-p', baseSha, '-m', message], root).stdout.trim() : '';

package/lib/member-map-inbox.js

@@ -13,7 +13,8 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 
 const INBOX_DIR = 'atris/refs/map-inbox';
-const SHARED_MAP = /(?:^|\/)MAP(?:-NOTES)?\.md$/;
+// The area notes that MAP-NOTES.md may index are shared map files too.
+const SHARED_MAP = /(?:^|\/)MAP(?:-NOTES)?\.md$|^atris\/refs\/map\/[^/]+\.md$/;
 
 function run(args, cwd, extraEnv = {}, { raw = false } = {}) {
   const env = { ...process.env, ...extraEnv, GIT_NO_REPLACE_OBJECTS: '1' };

package/lib/mission-core.js

@@ -38,7 +38,7 @@ const {
   shortRecordLabel,
   shortRecordRef,
 } = require('./short-name');
-const { readJson, writeJson } = require('./json-file');
+const { readJson, writeJson, writeFileAtomic } = require('./json-file');
 
 const VALID_STATUSES = new Set(['planning', 'running', 'ready', 'paused', 'blocked', 'stopped', 'complete']);
 const TERMINAL_STATUSES = new Set(['stopped', 'complete']);
@@ -827,10 +827,17 @@ function loadTaskDb(asJson = false) {
   }
 }
 
+// The projection has one writer and one shape: `atris task`'s writeDefaultProjection, which
+// enriches the rows and writes through a temp file and a rename. Writing the bare rows here
+// left readers a different shape depending on which command ran last. The fallback (only if
+// the task command cannot load) still writes atomically.
 function writeMissionTaskProjection(taskDb, db, workspaceRoot) {
+  let writer = null;
+  try { writer = require('../commands/task').writeDefaultProjection; } catch { writer = null; }
+  if (typeof writer === 'function') return writer(taskDb, db, { root: workspaceRoot });
   const projection = taskDb.taskProjection(db, { workspaceRoot, limit: 500 });
   const outPath = path.join(workspaceRoot, '.atris', 'state', 'tasks.projection.json');
-  writeJson(outPath, projection);
+  writeFileAtomic(outPath, JSON.stringify(projection, null, 2) + '\n');
   return { projection, outPath };
 }
 

package/lib/recall-exam.js

@@ -0,0 +1,171 @@
+'use strict';
+
+// Recall exam: how fast can an agent find the right note by following links?
+//
+// The reader starts with the boot files, then keeps opening the linked
+// markdown file whose link text and line best match the question, the way an
+// agent scans an index and follows the line that says when to open it. It never
+// greps the whole tree. A question is found when an opened file contains the
+// question's needle, an exact answer phrase. Needles survive a file move, so the
+// same exam scores a layout before and after notes are split or merged.
+
+const fs = require('fs');
+const path = require('path');
+
+const STOP_WORDS = new Set(('the and for are was were where what which who how does did can could should would this that these those '
+  + 'with from into about find have has had there here when why our you your its it is be do to of in on at or an a i im me my we us '
+  + 'if not no any all one get got make need needs want am will just then than so but by as up out over use using used new before after '
+  + 'first next way thing things something someone mid work working about while also only very much more most some same each every').split(' '));
+const DEFAULT_MAX_OPENS = 6;
+// A real file reader stops after this many lines unless asked for more.
+const READ_LINE_CAP = 2000;
+
+function stem(word) {
+  return word.replace(/(?:ing|ed|es|s)$/u, '') || word;
+}
+
+function keywords(text) {
+  return [...new Set((String(text).toLowerCase().match(/[\p{L}\p{N}]+/gu) || [])
+    .filter(word => word.length >= 3 && !STOP_WORDS.has(word)).map(stem))];
+}
+
+function normalize(text) {
+  return String(text).toLowerCase().replace(/\s+/g, ' ');
+}
+
+function readCapped(file) {
+  let text;
+  try { text = fs.readFileSync(file, 'utf8'); } catch { return null; }
+  const lines = text.split('\n');
+  return lines.length > READ_LINE_CAP ? lines.slice(0, READ_LINE_CAP).join('\n') : text;
+}
+
+// Every markdown file a line points at, with the words an agent sees beside it.
+function linksIn(text, fromFile, root) {
+  const links = [];
+  const fromDir = path.dirname(fromFile);
+  let heading = '';
+  for (const line of text.split('\n')) {
+    const head = line.match(/^#{1,6}\s+(.*)/);
+    if (head) heading = head[1];
+    const targets = [];
+    for (const match of line.matchAll(/\[([^\]]*)\]\(([^)\s]+)\)/g)) targets.push({ label: match[1], target: match[2] });
+    for (const match of line.matchAll(/\[\[([^\]|#]+)(?:[|#][^\]]*)?\]\]/g)) targets.push({ label: '', target: match[1] });
+    for (const match of line.matchAll(/`([^`\s]+\.md)(?:#[^`]*)?`/g)) targets.push({ label: '', target: match[1] });
+    for (const { label, target } of targets) {
+      const clean = target.replace(/#.*$/, '').replace(/:\d+(?:-\d+)?$/, '');
+      if (!/\.md$/i.test(clean) || clean.includes('://')) continue;
+      const candidates = [path.resolve(fromDir, clean), path.resolve(root, clean)];
+      const resolved = candidates.find(file => file.startsWith(root + path.sep) && fs.existsSync(file));
+      if (!resolved) continue;
+      links.push({ file: resolved, context: `${label} ${line} ${heading} ${path.basename(clean, '.md')}` });
+    }
+  }
+  return links;
+}
+
+function scoreContext(context, words) {
+  const have = new Set(keywords(context));
+  return words.filter(word => have.has(word)).length;
+}
+
+function examineQuestion(root, question, { bootFiles, maxOpens = DEFAULT_MAX_OPENS }) {
+  const words = keywords(question.q);
+  const needle = normalize(question.needle);
+  const opened = [];
+  let charsRead = 0;
+  let foundIn = null;
+  const seen = new Set();
+  const frontier = new Map();
+  // The file whose link led to each opened file, so the path to the answer is known.
+  const via = new Map();
+  const absorb = (file, text) => {
+    seen.add(file);
+    for (const link of linksIn(text, file, root)) {
+      if (seen.has(link.file)) continue;
+      const score = scoreContext(link.context, words);
+      const prior = frontier.get(link.file);
+      if (!prior || score > prior.score) frontier.set(link.file, { score, order: prior ? prior.order : frontier.size, from: file });
+    }
+    if (!foundIn && normalize(text).includes(needle)) foundIn = path.relative(root, file);
+  };
+  for (const rel of bootFiles) {
+    const file = path.resolve(root, rel);
+    const text = readCapped(file);
+    if (text === null) continue;
+    absorb(file, text);
+  }
+  while (!foundIn && opened.length < maxOpens) {
+    let best = null;
+    for (const [file, entry] of frontier) {
+      if (seen.has(file) || entry.score === 0) continue;
+      if (!best || entry.score > best.score || (entry.score === best.score && entry.order < best.order)) best = { file, ...entry };
+    }
+    if (!best) break;
+    frontier.delete(best.file);
+    via.set(best.file, best.from);
+    const text = readCapped(best.file) || '';
+    opened.push(path.relative(root, best.file));
+    charsRead += text.length;
+    absorb(best.file, text);
+  }
+  // An index opened on the way to the answer was needed; every other open was not.
+  const needed = new Set();
+  for (let at = foundIn && path.resolve(root, foundIn); at && via.has(at); at = via.get(at)) needed.add(path.relative(root, at));
+  return {
+    id: question.id, area: question.area || null, found: Boolean(foundIn), found_in: foundIn,
+    files_opened: opened.length, opened, tokens_opened: Math.round(charsRead / 4),
+    wrong_opens: opened.filter(rel => !needed.has(rel)).length,
+  };
+}
+
+function readQuestions(file) {
+  const questions = [];
+  const invalid = [];
+  const text = fs.readFileSync(file, 'utf8');
+  text.split(/\r?\n/).forEach((line, index) => {
+    if (!line.trim()) return;
+    let row;
+    try { row = JSON.parse(line); } catch { row = null; }
+    if (!row || typeof row.q !== 'string' || typeof row.needle !== 'string' || !row.needle.trim()) invalid.push(index + 1);
+    else questions.push(row);
+  });
+  return { questions, invalid };
+}
+
+function median(values) {
+  if (!values.length) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+
+function runRecallExam(root, questionsFile, { bootFiles, maxOpens = DEFAULT_MAX_OPENS } = {}) {
+  const { questions, invalid } = readQuestions(questionsFile);
+  const bootChars = bootFiles.reduce((sum, rel) => sum + (readCapped(path.resolve(root, rel)) || '').length, 0);
+  const results = questions.map(question => examineQuestion(root, question, { bootFiles, maxOpens }));
+  const found = results.filter(result => result.found);
+  const opens = results.map(result => result.files_opened);
+  const tokens = results.map(result => result.tokens_opened);
+  const wrong = results.map(result => result.wrong_opens);
+  const byArea = {};
+  for (const result of results) {
+    const area = result.area || 'none';
+    byArea[area] = byArea[area] || { total: 0, found: 0 };
+    byArea[area].total++;
+    if (result.found) byArea[area].found++;
+  }
+  return {
+    questions: results.length, invalid_lines: invalid, max_opens: maxOpens,
+    boot_tokens: Math.round(bootChars / 4),
+    found: found.length, found_share: results.length ? found.length / results.length : null,
+    files_opened: { total: opens.reduce((a, b) => a + b, 0), median: median(opens), mean: results.length ? opens.reduce((a, b) => a + b, 0) / results.length : null },
+    wrong_opens: { total: wrong.reduce((a, b) => a + b, 0), median: median(wrong), mean: results.length ? wrong.reduce((a, b) => a + b, 0) / results.length : null },
+    tokens_opened: { total: tokens.reduce((a, b) => a + b, 0), median: median(tokens), mean: results.length ? Math.round(tokens.reduce((a, b) => a + b, 0) / results.length) : null },
+    tokens_opened_when_found: { median: median(found.map(result => result.tokens_opened)) },
+    by_area: byArea,
+    results,
+  };
+}
+
+module.exports = { runRecallExam, keywords };

package/lib/roster-markdown.js

@@ -8,10 +8,10 @@
 //
 // Two shapes read side by side. The sectioned shape, which assign writes:
 //   ## build
-//   - claude code, model: opus 5.5
+//   - claude code, model: opus
 //   - codex, effort: medium
 // and the older one-line shape, still read as before:
-//   build: claude opus 5.5, backup codex
+//   build: claude opus, backup codex
 
 const OLD_ROSTER_NOTE = '> edit any time. each line is job: engine and model, an optional effort (low, medium, high, xhigh, max), then optional "backup <engine and model>", "max 20 min", and "until 2026-10-24" (the year is required).';
 const ROSTER_NOTE = '> edit any time. each "## job" lists its workers in order, one per line: "- tool, model: name", then optional "effort: medium", "max: 20 min", "prep: search" (that job reads the task first and hands this worker a short brief), and "until 2026-10-24" (the year is required). the first ready worker leads and the rest back it up.';

package/lib/runner-command.js

@@ -95,7 +95,7 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
   }),
   haiku: Object.freeze({
     bin: 'claude',
-    model: 'claude-haiku-5-5',
+    model: DEFAULT_CLAUDE_RUNNER_MODEL,
     commandTemplate: '',
     effortFlag: '--effort',
     efforts: CLAUDE_EFFORTS,
@@ -109,8 +109,8 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
     model: '',
     commandTemplate: '{bin} -p {pinnedModelFlag} -- {prompt}',
   }),
-  // No hard pin: a pinned grok-4.6 went stale when the grok CLI moved its
-  // own default to grok-4.7-build-fast, so an unpinned run rides the CLI.
+  // No hard pin: a pinned grok version went stale when the grok CLI moved its
+  // own default to a newer build, so an unpinned run rides the CLI.
   // Grok runs only xAI models, so a claude model name never reaches it.
   grok: Object.freeze({
     bin: 'grok',
@@ -123,7 +123,7 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
   agy: Object.freeze({
     bin: 'agy',
     // No hard pin: the agy CLI keeps its own session model, so an unpinned
-    // run rides that and a roster line names gemini 3.8 flash (the 2026-09-04
+    // run rides that and a roster line names its own gemini model (the 2026-09-04
     // bake-off pick) when it wants it. --add-dir or agy edits its own scratch
     // folder; the headless note or gemini stops to ask "may I edit?" and
     // exits 0 having changed nothing.
@@ -319,7 +319,7 @@ function runnerModelFor(engineId, model) {
   // Required here, not at the top: engine-registry requires this file.
   const { isClaudeFamilyModel } = require('./engine-registry');
   const name = String(engineId || '').trim().toLowerCase();
-  // A display name like "opus 5.5" only becomes an id for the claude cli (or
+  // A spaced display name only becomes an id for the claude cli (or
   // an unnamed engine). Any other engine's model name is handed over as is.
   const canonical = RUNNER_PROFILE_ALIASES[name] || name;
   const claudeCli = !canonical || canonical === 'claude' || canonical === 'fable' || canonical === 'haiku';