atris 3.58.7 → 3.59.0

package/lib/lesson-contradiction.js

@@ -22,8 +22,8 @@ function detectLessonContradictions(cwd) {
     ? fs.readFileSync(lessonsMdPath, 'utf8')
     : '';
 
-  // Format: - **[YYYY-MM-DD] slug**, pass|fail, prose
-  const lessonRegex = /^-\s+\*\*\[(\d{4}-\d{2}-\d{2})\]\s+([a-z0-9-]+)\*\*\s*\u2014\s*(pass|fail)\s*\u2014\s*(\[resolved\])?\s*(.+)$/m;
+  // Format: - **[YYYY-MM-DD] slug** - pass|fail - prose
+  const lessonRegex = /^-\s+\*\*\[(\d{4}-\d{2}-\d{2})\]\s+([a-z0-9-]+)\*\*\s*[-\u2014]\s*(pass|fail)\s*[-\u2014]\s*(\[resolved\])?\s*(.+)$/m;
   const lines = lessonsMdContent.split('\n');
 
   const lessonsBySlug = new Map(); // slug -> [{ date, outcome, lineNum, resolved }]

package/lib/map-refs.js

@@ -0,0 +1,226 @@
+'use strict';
+
+// Checks the `path:N` line refs in a map document against the code they point at.
+// A ref may carry a symbol: an identifier written right after it (`path:N` `name`,
+// `path:N` (`name`), or a bare camelCase name) or right before it (`name` (`path:N`)).
+// A name elsewhere in the sentence never binds: map sentences often name a helper
+// the ref does not point at, and binding it would move the ref to the wrong place.
+
+const fs = require('fs');
+const path = require('path');
+
+const WINDOW = 3;
+const IDENT = /^[A-Za-z_$][\w$]*$/;
+const REF = /^(?:\.\/)?([^\s:`<>*|]+):(\d+)(?:-(\d+))?((?:,\d+(?:-\d+)?)*)(?:#\S*)?$/;
+
+function escape(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function definitionPatterns(symbol) {
+  const s = escape(symbol);
+  return [
+    new RegExp(`\\bfunction\\s*\\*?\\s*${s}\\s*\\(`),
+    new RegExp(`\\b(?:const|let|var)\\s+${s}\\b`),
+    new RegExp(`\\bclass\\s+${s}\\b`),
+    new RegExp(`\\bdef\\s+${s}\\b`),
+    new RegExp(`^\\s*(?:async\\s+)?(?:static\\s+)?(?:get\\s+|set\\s+)?\\*?${s}\\s*\\([^)]*\\)\\s*\\{`),
+    new RegExp(`^\\s*['"]?${s}['"]?\\s*:(?!:)`),
+    new RegExp(`\\bcase\\s+['"\`]?${s}['"\`]?\\s*:`),
+    new RegExp(`\\bexports\\.${s}\\s*=`),
+  ];
+}
+
+function tokenPattern(symbol, flags = '') {
+  return new RegExp(`(?<![\\w$])${escape(symbol)}(?![\\w$])`, flags);
+}
+
+function isPathLike(file) {
+  return !file.includes('://') && (file.includes('/') || /\.[a-z0-9]+$/i.test(file));
+}
+
+// Find every ref in the map, with its map line, column, and optional symbol.
+// Code fences are scanned too: the map keeps prose notes inside its search block.
+function parseRefs(mapText) {
+  const refs = [];
+  mapText.split(/\r?\n/).forEach((line, index) => {
+    const spans = [...line.matchAll(/`([^`\r\n]+)`/g)].map(match => ({
+      text: match[1], start: match.index, end: match.index + match[0].length,
+    }));
+    spans.forEach((span, i) => {
+      const match = span.text.trim().match(REF);
+      if (!match || !isPathLike(match[1])) return;
+      const ref = {
+        map_line: index + 1, column: span.start, raw: span.text, path: match[1],
+        start: Number(match[2]), end: match[3] ? Number(match[3]) : null,
+        extra: match[4] ? match[4].slice(1).split(',').map(part => part.split('-').map(Number)) : [],
+        symbols: [],
+      };
+      if (!ref.extra.length) ref.symbols = symbolsFor(line, spans, i);
+      ref.symbol = ref.symbols[0] || null;
+      refs.push(ref);
+    });
+  });
+  return refs;
+}
+
+// Symbols bind only when written right next to the ref, so a backticked word
+// later in the sentence never passes for the thing the ref points at.
+function symbolsFor(line, spans, i) {
+  const clean = text => text.trim().replace(/\(\)$/, '');
+  const found = [];
+  const after = spans[i + 1];
+  if (after && /^\s*\(?\s*$/.test(line.slice(spans[i].end, after.start)) && IDENT.test(clean(after.text))) {
+    found.push(clean(after.text));
+  }
+  // An unquoted name counts only when it is shaped like code (camelCase or snake_case).
+  const bare = line.slice(spans[i].end).match(/^ ([A-Za-z_$][\w$]*)(?:\(\))?(?=[\s),;:.]|$)/);
+  if (bare && /[a-z][A-Z]|_/.test(bare[1])) found.push(bare[1]);
+  const before = spans[i - 1];
+  if (before && /^\s*\(\s*$/.test(line.slice(before.end, spans[i].start)) && IDENT.test(clean(before.text))) {
+    found.push(clean(before.text));
+  }
+  return [...new Set(found)];
+}
+
+// Line numbers (1-based) of every line holding the symbol, found in one pass over the text.
+function lineNumbersOf(file, symbol) {
+  const found = [];
+  for (const match of file.text.matchAll(tokenPattern(symbol, 'g'))) {
+    let low = 0;
+    let high = file.starts.length - 1;
+    while (low < high) {
+      const mid = (low + high + 1) >> 1;
+      if (file.starts[mid] <= match.index) low = mid; else high = mid - 1;
+    }
+    if (found[found.length - 1] !== low + 1) found.push(low + 1);
+  }
+  return found;
+}
+
+function classify(ref, file) {
+  const { lines } = file;
+  const last = ref.end || ref.start;
+  const numbers = [ref.start, last, ...ref.extra.flat()];
+  const inBounds = numbers.every(n => n >= 1 && n <= lines.length);
+  if (!ref.symbol) return inBounds ? { status: 'ok' } : { status: 'missing', reason: 'line out of range' };
+  const low = Math.max(1, ref.start - WINDOW);
+  const high = Math.min(lines.length, last + WINDOW);
+  // A range that runs past the end of the file is wrong even when its start is right.
+  if (inBounds) for (const symbol of ref.symbols) {
+    const near = tokenPattern(symbol);
+    for (let n = low; n <= high; n++) if (near.test(lines[n - 1])) return { status: 'ok', symbol };
+  }
+  const uses = lineNumbersOf(file, ref.symbol);
+  const patterns = definitionPatterns(ref.symbol);
+  const defs = uses.filter(n => patterns.some(pattern => pattern.test(lines[n - 1])));
+  const candidates = defs.length ? defs : uses;
+  if (!candidates.length) return { status: 'missing', reason: `${ref.symbol} is not in the file` };
+  if (candidates.length > 1) return { status: 'ambiguous', lines: candidates.slice(0, 5) };
+  const line = candidates[0];
+  // Keep the range width but never write an end past the last line.
+  return { status: 'moved', line, ...(ref.end ? { end_line: Math.min(lines.length, line + ref.end - ref.start) } : {}) };
+}
+
+function checkMapRefs(root, mapText) {
+  const cache = new Map();
+  const linesOf = file => {
+    if (!cache.has(file)) {
+      const full = path.resolve(root, file);
+      let text = null;
+      try {
+        if (fs.statSync(full).isFile()) text = fs.readFileSync(full, 'utf8');
+      } catch (error) {
+        if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') throw error;
+      }
+      if (text === null) cache.set(file, null);
+      else {
+        const raw = text.split('\n');
+        const starts = [0];
+        for (let i = 0; i < raw.length - 1; i++) starts.push(starts[i] + raw[i].length + 1);
+        const lines = raw.map(line => (line.endsWith('\r') ? line.slice(0, -1) : line));
+        cache.set(file, { text, lines, starts });
+      }
+    }
+    return cache.get(file);
+  };
+  const refs = parseRefs(mapText).map(ref => {
+    const file = linesOf(ref.path);
+    return { ...ref, ...(file ? classify(ref, file) : { status: 'missing-file' }) };
+  });
+  return summarize(refs);
+}
+
+function summarize(refs) {
+  const count = status => refs.filter(ref => ref.status === status).length;
+  const summary = {
+    total: refs.length, ok: count('ok'), moved: count('moved'), ambiguous: count('ambiguous'),
+    missing: count('missing'), missing_file: count('missing-file'),
+  };
+  return { ...summary, score: refs.length ? summary.ok / refs.length : 1, refs };
+}
+
+function newRefText(ref) {
+  const lineText = ref.end ? `${ref.line}-${ref.end_line}` : `${ref.line}`;
+  return ref.raw.replace(`:${ref.start}${ref.end ? `-${ref.end}` : ''}`, `:${lineText}`);
+}
+
+// Rewrite only refs whose symbol sits unambiguously on another line.
+function fixMapRefs(root, mapFile = 'atris/MAP.md') {
+  const file = path.resolve(root, mapFile);
+  const text = fs.readFileSync(file, 'utf8');
+  const result = checkMapRefs(root, text);
+  const moved = result.refs.filter(ref => ref.status === 'moved');
+  const lines = text.split('\n');
+  const changes = [];
+  for (const ref of [...moved].sort((a, b) => b.map_line - a.map_line || b.column - a.column)) {
+    const replacement = newRefText(ref);
+    const line = lines[ref.map_line - 1];
+    lines[ref.map_line - 1] = line.slice(0, ref.column + 1) + replacement + line.slice(ref.column + 1 + ref.raw.length);
+    changes.unshift({ map_line: ref.map_line, from: ref.raw, to: replacement, symbol: ref.symbol });
+  }
+  if (changes.length) fs.writeFileSync(file, lines.join('\n'));
+  const left = result.refs.filter(ref => ref.status !== 'ok' && ref.status !== 'moved');
+  return { changes, left };
+}
+
+// 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.
+const MAP_REF_DOCS = ['atris/MAP.md', 'atris/refs/MAP-NOTES.md'];
+
+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;
+    }
+  });
+}
+
+// mapText is the already-read atris/MAP.md, so boot does not read it twice.
+function checkMapDocs(root, mapText) {
+  const refs = existingMapDocs(root).flatMap(doc => {
+    const text = doc === MAP_REF_DOCS[0] && typeof mapText === 'string'
+      ? mapText : fs.readFileSync(path.resolve(root, doc), 'utf8');
+    return checkMapRefs(root, text).refs.map(ref => ({ doc, ...ref }));
+  });
+  return summarize(refs);
+}
+
+function fixMapDocs(root) {
+  const changes = [];
+  const left = [];
+  for (const doc of existingMapDocs(root)) {
+    const result = fixMapRefs(root, doc);
+    changes.push(...result.changes.map(change => ({ doc, ...change })));
+    left.push(...result.left.map(ref => ({ doc, ...ref })));
+  }
+  return { changes, left };
+}
+
+// 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 };

package/lib/member-engine.js

@@ -0,0 +1,253 @@
+'use strict';
+
+// Which engine a team member runs on. Every member in atris/team/*/MEMBER.md
+// gets a job on its own: navigators, researchers, and scouts search;
+// 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.
+
+const fs = require('fs');
+const path = require('path');
+const {
+  ENGINE_JOBS,
+  ENGINE_ROLES,
+  inferJobKind,
+  mainCheckoutRoot,
+  readEngineRegistry,
+  readRosterState,
+  resolveEngineForRoleRanked,
+  rosterChoiceForPick,
+  rosterDecided,
+  ROSTER_LAYERS,
+  rosterJobKey,
+  rosterJobLabel,
+  rosterJobRole,
+  rosterModelLabel,
+  rosterPickFromValue,
+} = require('./engine-registry');
+
+const SEARCH_WORDS = Object.freeze(['navigator', 'researcher', 'research', 'search', 'scout']);
+const REVIEW_WORDS = Object.freeze(['validator', 'reviewer', 'review', 'judge', 'critic', 'verifier']);
+
+function memberCardFile(root, name) {
+  return path.join(root, 'atris', 'team', name, 'MEMBER.md');
+}
+
+// This folder's card, else the main checkout's when this is a git worktree:
+// the same fallback the roster file uses, so a card not yet committed still
+// counts from a worktree. '' when neither has one.
+function findMemberCard(root, name) {
+  const own = memberCardFile(root, name);
+  if (fs.existsSync(own)) return own;
+  const main = mainCheckoutRoot(root);
+  const shared = main ? memberCardFile(main, name) : '';
+  return shared && fs.existsSync(shared) ? shared : '';
+}
+
+// name and role from the MEMBER.md frontmatter; found is false when there is
+// no card for this name.
+function readMemberCard(root, name) {
+  let text = '';
+  try {
+    text = fs.readFileSync(findMemberCard(root, name), 'utf8');
+  } catch {
+    return { name, role: '', found: false };
+  }
+  const block = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+  const field = (key) => {
+    const match = block ? new RegExp(`^${key}:\\s*(.*)$`, 'm').exec(block[1]) : null;
+    return match ? match[1].trim().replace(/^["']|["']$/g, '') : '';
+  };
+  return { name: field('name') || name, role: field('role'), found: true };
+}
+
+function listTeamMembers(root = process.cwd()) {
+  const dir = path.join(root, 'atris', 'team');
+  let names = [];
+  try {
+    names = fs.readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.') && !entry.name.startsWith('_'))
+      .map((entry) => entry.name)
+      .filter((name) => fs.existsSync(memberCardFile(root, name)));
+  } catch {
+    return [];
+  }
+  return names.sort();
+}
+
+function words(text) {
+  return String(text || '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+}
+
+function kindFromWords(list) {
+  if (list.some((word) => SEARCH_WORDS.includes(word))) return 'search';
+  if (list.some((word) => REVIEW_WORDS.includes(word))) return 'review';
+  return '';
+}
+
+// The job a member gets with no team line: its name decides first, then its
+// role title, else build.
+function autoJobForMember(name, role = '') {
+  return kindFromWords(words(name)) || kindFromWords(words(role)) || 'build';
+}
+
+// This session's team line wins, then this project's, then the
+// all-projects one.
+function teamLineFor(state, member) {
+  const key = String(member || '').trim().toLowerCase();
+  const find = (layer) => (layer && Array.isArray(layer.team) ? layer.team.filter((line) => line.member === key)[0] : null);
+  for (const scope of ROSTER_LAYERS) {
+    const line = find(state[scope]);
+    if (line) return { ...line, scope };
+  }
+  return null;
+}
+
+// What a team line value means: a job (built-in name, a job the roster
+// already has, or a name that says its kind) or a direct engine pick for the
+// member's own kind of work. error is a plain sentence for a line that means
+// neither.
+function interpretTeamValue(value, state, memberKind, options = {}) {
+  const text = String(value || '').trim();
+  if (!text) return { error: 'names no job or engine' };
+  const key = rosterJobKey(text);
+  if (key && ENGINE_ROLES.includes(key)) return { type: 'job', key };
+  const saved = (layer) => Boolean(key && layer && layer.picks && layer.picks[key]);
+  if (saved(state.session) || saved(state.project) || saved(state.machine)) return { type: 'job', key };
+  try {
+    return { type: 'pick', pick: rosterPickFromValue(text, ENGINE_JOBS[memberKind], options) };
+  } catch (error) {
+    if (key && inferJobKind(text)) return { type: 'job', key };
+    return { error: error.message };
+  }
+}
+
+function engineText(engine) {
+  if (!engine) return 'no ready engine';
+  return `${engine.id}${engine.roster_model ? ` ${rosterModelLabel(engine.roster_model)}` : ''}`;
+}
+
+// The engine one member runs on, with a plain reason ("researcher does
+// search: claude haiku"). roster_backed is true when a roster line decided
+// (a job pick or a team line); when false the router decided, and callers
+// keep whatever they did before the roster existed.
+function resolveEngineForMember(memberName, root = process.cwd(), options = {}) {
+  const name = String(memberName || '').trim();
+  const card = readMemberCard(root, name);
+  const state = options.rosterState || readRosterState(root, options);
+  const autoKind = autoJobForMember(name, card.role);
+  const line = teamLineFor(state, name);
+  const read = line ? interpretTeamValue(line.value, state, autoKind, options) : null;
+  const override = read && !read.error ? read : null;
+  const yearless = override && override.type === 'pick' && override.pick.until_needs_year;
+  const pickOptions = {
+    ...options,
+    sessionRosterPicks: state.session ? state.session.picks : {},
+    projectRosterPicks: state.project.picks,
+    machineRosterPicks: state.machine.picks,
+  };
+  const base = {
+    member: name,
+    title: card.role || '',
+    found: card.found || Boolean(line),
+    source: override ? 'file' : 'auto',
+    file: override ? line.file : null,
+    line: override ? line.line : null,
+    ...(read && read.error ? { warning: read.error } : {}),
+    ...(yearless ? { until_warning: `has no year in its until date, so it counts as expired; write until ${yearless}` } : {}),
+  };
+
+  if (override && override.type === 'pick') {
+    const role = ENGINE_JOBS[autoKind];
+    const registry = readEngineRegistry(root, { persist: false });
+    const choice = rosterChoiceForPick(override.pick, role, registry, { label: autoKind, source: line.scope, now: options.now });
+    if (choice) {
+      return {
+        ...base,
+        job: autoKind,
+        job_key: role,
+        role,
+        engine: choice.engine,
+        model: choice.engine.roster_model || '',
+        pick_source: 'team',
+        roster_backed: true,
+        reason: `${name} does ${autoKind}: ${engineText(choice.engine)}`,
+      };
+    }
+  }
+
+  const jobKey = override && override.type === 'job' ? override.key : ENGINE_JOBS[autoKind];
+  const role = rosterJobRole(jobKey, root, pickOptions) || ENGINE_JOBS[autoKind];
+  const custom = !ENGINE_ROLES.includes(jobKey);
+  const resolved = resolveEngineForRoleRanked(role, root, { ...pickOptions, ...(custom ? { job: jobKey } : {}) });
+  const job = rosterJobLabel(jobKey);
+  const fromRoster = rosterDecided(resolved.source);
+  return {
+    ...base,
+    job,
+    job_key: jobKey,
+    role,
+    engine: resolved.engine || null,
+    model: resolved.engine && resolved.engine.roster_model ? resolved.engine.roster_model : '',
+    pick_source: resolved.source,
+    roster_backed: fromRoster || Boolean(override),
+    reason: `${name} does ${job}: ${engineText(resolved.engine)}`,
+  };
+}
+
+// The member's engine only when the roster decided it and the member is on
+// the team (a MEMBER.md or a team line). null means keep the old routing.
+// Never throws: a broken roster must not stop a run.
+function memberRosterEngine(memberName, root = process.cwd(), options = {}) {
+  const name = String(memberName || '').trim();
+  if (!name || name.includes('/') || name.includes('\\')) return null;
+  try {
+    const picked = resolveEngineForMember(name, root, options);
+    if (!picked.found && options.requireMember !== false) return null;
+    return picked.roster_backed && picked.engine ? picked : null;
+  } catch {
+    return null;
+  }
+}
+
+// One row per member for `atris engine roster`, plus a warning for every
+// team line that could not be used.
+function teamRosterView(root = process.cwd(), options = {}) {
+  const state = options.rosterState || readRosterState(root, options);
+  const names = new Set(listTeamMembers(root));
+  const warnings = [];
+  for (const layer of [state.session, state.project, state.machine]) {
+    for (const line of (layer && layer.team) || []) {
+      if (findMemberCard(root, line.member)) names.add(line.member);
+      else if (layer.scope === 'project') warnings.push({ file: line.file, line: line.line, text: line.text, message: `there is no team member named ${line.member}, so the line does nothing` });
+    }
+  }
+  const rows = [...names].sort().map((name) => {
+    const picked = resolveEngineForMember(name, root, { ...options, rosterState: state });
+    const line = teamLineFor(state, name);
+    if (picked.warning && line) {
+      warnings.push({ file: line.file, line: line.line, text: line.text, message: `${picked.warning}, so ${name} picks automatically` });
+    }
+    if (picked.until_warning && line) warnings.push({ file: line.file, line: line.line, text: line.text, message: picked.until_warning });
+    return {
+      member: name,
+      job: picked.job,
+      engine: picked.engine ? picked.engine.id : null,
+      model: picked.model || null,
+      effort: picked.engine && picked.engine.roster_effort ? picked.engine.roster_effort : null,
+      max_seconds: picked.engine && picked.engine.roster_max_seconds ? picked.engine.roster_max_seconds : null,
+      source: picked.source,
+      file: picked.file,
+      reason: picked.reason,
+    };
+  });
+  return { rows, warnings };
+}
+
+module.exports = {
+  autoJobForMember,
+  resolveEngineForMember,
+  memberRosterEngine,
+  teamRosterView,
+};

package/lib/mission-room.js

@@ -400,9 +400,9 @@ function defaultThinkingBody() {
     '',
     'Team logs say what happened.',
     '',
-    'This file says how Keshav thinks.',
+    'This file says how the operator thinks.',
     '',
-    '## How Keshav Thinks',
+    '## How the Operator Thinks',
     '',
     '- Starts from messy truth, then wants it clarified into a mission he can approve or reject.',
     '- Values plain English, no jargon, and proof over motion.',
@@ -411,7 +411,7 @@ function defaultThinkingBody() {
     '## Approval Rules',
     '',
     '- Atris can clarify, propose, run bounded proof steps, and write receipts.',
-    '- Keshav keeps taste, judgment, priority, budget, customer calls, and final accept.',
+    '- The operator keeps taste, judgment, priority, budget, customer calls, and final accept.',
     '- Real-world side effects wait for approval unless the mission explicitly grants permission.',
     '',
     '## Proof Standards',
@@ -457,7 +457,7 @@ function writeThinkingMemory(room, options = {}) {
     path: relativePath,
     updated: true,
     latest_signal: signal,
-    purpose: 'how Keshav thinks, decides, approves, rejects, prioritizes, and explains.',
+    purpose: 'how the operator thinks, decides, approves, rejects, prioritizes, and explains.',
   };
 }
 

package/lib/noninteractive.js

@@ -1,5 +1,17 @@
 'use strict';
 
+/**
+ * The one place that reads the two env names. Both mean the same thing; any
+ * value other than empty, 0, or false turns prompts off.
+ */
+const NON_INTERACTIVE_ENV_NAMES = ['ATRIS_NONINTERACTIVE', 'ATRIS_NO_INTERACTIVE'];
+function envForcesNonInteractive(env = process.env) {
+  return NON_INTERACTIVE_ENV_NAMES.some((name) => {
+    const value = String(env[name] || '').trim().toLowerCase();
+    return value !== '' && value !== '0' && value !== 'false';
+  });
+}
+
 /**
  * Shared headless/agent guard. When true, commands must not open a prompt.
  * Covers: ATRIS_NONINTERACTIVE / ATRIS_NO_INTERACTIVE, --yes/-y, --json.
@@ -9,8 +21,7 @@
  */
 function isForcedNonInteractive(args = process.argv.slice(2)) {
   const list = Array.isArray(args) ? args : [];
-  if (process.env.ATRIS_NONINTERACTIVE === '1') return true;
-  if (process.env.ATRIS_NO_INTERACTIVE === '1') return true;
+  if (envForcesNonInteractive()) return true;
   if (list.includes('--yes') || list.includes('-y')) return true;
   if (list.includes('--json')) return true;
   return false;
@@ -48,8 +59,7 @@ function hasYesFlag(args = []) {
 function refuseHeadlessUnless(args, { allowYes = true, allowOnce = false, usage = '' } = {}) {
   const list = Array.isArray(args) ? args : [];
   const headless = Boolean(
-    process.env.ATRIS_NONINTERACTIVE === '1'
-    || process.env.ATRIS_NO_INTERACTIVE === '1'
+    envForcesNonInteractive()
     || !process.stdin.isTTY
     || !process.stdout.isTTY
   );
@@ -77,6 +87,7 @@ function rejectUnsupportedJson(commandName, args = process.argv.slice(2)) {
 }
 
 module.exports = {
+  envForcesNonInteractive,
   isForcedNonInteractive,
   isNonInteractive,
   wantsJson,

package/lib/policy-lessons.js

@@ -366,7 +366,7 @@ function syncLessonsMd(root, mined) {
   const today = (mined.mined_at || new Date().toISOString()).split('T')[0];
   const lines = (mined.lessons || []).map((lesson) => ({
     id: lesson.id,
-    line: `- **[${today}] policy-${lesson.id}** \u2014 ${lesson.status || 'pass'} \u2014 ${lesson.lesson} (mined from ${mined.sources.career_xp_receipts} receipts / ${mined.sources.task_episodes} episodes / ${mined.sources.scorecards} scorecards)`,
+    line: `- **[${today}] policy-${lesson.id}** - ${lesson.status || 'pass'} - ${String(lesson.lesson).replace(/\s*\u2014\s*/g, ', ')} (mined from ${mined.sources.career_xp_receipts} receipts / ${mined.sources.task_episodes} episodes / ${mined.sources.scorecards} scorecards)`,
   }));
   if (!lines.length) return { path: lessonsPath, written: [] };