atris 3.58.7 → 3.58.8

package/commands/study.js

@@ -15,6 +15,7 @@ const fs = require('fs');
 const path = require('path');
 const http = require('http');
 const { spawn, spawnSync } = require('child_process');
+const { resolveBackendRoot } = require('../utils/backend-root');
 
 const FEED_URL = 'http://localhost:8777';
 const FEED_STATS_URL = `${FEED_URL}/api/stats`;
@@ -91,15 +92,19 @@ function parseArgs(argv = []) {
 }
 
 function resolveStudyRoot(cwd = process.cwd()) {
-  const candidates = [
-    process.env.ATRIS_STUDY_ROOT,
-    process.env.ATRIS_BACKEND_ROOT,
-    path.join(path.resolve(cwd), 'atris', 'study'),
-  ].filter(Boolean);
-  for (const root of candidates) {
-    const resolved = path.resolve(String(root));
-    if (fs.existsSync(resolved)) return resolved;
-  }
+  if (process.env.ATRIS_STUDY_ROOT) {
+    const explicit = path.resolve(process.env.ATRIS_STUDY_ROOT);
+    if (fs.existsSync(explicit) && fs.statSync(explicit).isDirectory()) return explicit;
+  }
+  // Same order as before: an explicitly set backend root wins over the local folder.
+  if (process.env.ATRIS_BACKEND_ROOT) {
+    const envBackend = path.resolve(process.env.ATRIS_BACKEND_ROOT);
+    if (fs.existsSync(envBackend)) return envBackend;
+  }
+  const local = path.join(path.resolve(cwd), 'atris', 'study');
+  if (fs.existsSync(local) && fs.statSync(local).isDirectory()) return local;
+  const backend = resolveBackendRoot(cwd);
+  if (backend) return backend;
   return null;
 }
 
@@ -697,6 +702,7 @@ async function run(argv = []) {
 
 module.exports = {
   run,
+  resolveStudyRoot,
   parseArgs,
   showHelp,
   wrapText,

package/commands/sync.js

@@ -615,7 +615,7 @@ Detect: Project has \`atris/\` folder with MAP.md, TODO.md, PERSONA.md
 Commands: plan → do → review
 
 Key behaviors:
-- Read PERSONA.md (3-4 sentences, ASCII visuals)
+- Read PERSONA.md (MAP.md first, plain words, lead with the outcome)
 - Check MAP.md for file:line refs
 - Use \`atris task\` for claims, proof, ready, and accept
 - Give every task a plain first layer: what changes, why it matters, and what

package/commands/task.js

@@ -634,6 +634,12 @@ function goldenPathMissionXpTask(task) {
     && /\b(?:golden[- ]path|zero[- ]knowledge|zero[- ]papercuts?|fresh[- ](?:laptop|environment|install|home)|self[- ]landed)\b/i.test(text);
 }
 
+// A receipt that cannot be read drops out of review evidence; name it under
+// ATRIS_DEBUG so the gap is findable, matching lib/todo.js.
+function debugUnreadableReceipt(rel, err) {
+  if (process.env.ATRIS_DEBUG) console.error(`[task] receipt unreadable, skipped: ${rel}: ${err && err.message}`);
+}
+
 function receiptTextForProof(proof, root = process.cwd()) {
   const chunks = [];
   const pattern = new RegExp(RECEIPT_PATH_PATTERN.source, 'g');
@@ -652,7 +658,9 @@ function receiptTextForProof(proof, root = process.cwd()) {
         last_landing: parsed.last_landing || null,
         summary: parsed.summary || null,
       }).slice(0, 12000));
-    } catch {}
+    } catch (err) {
+      debugUnreadableReceipt(rel, err);
+    }
   }
   return chunks.join(' ');
 }
@@ -672,7 +680,10 @@ function missionReceiptResultForProof(task, proof, root = process.cwd()) {
     try {
       const parsed = JSON.parse(fs.readFileSync(path.resolve(root, rel), 'utf8'));
       landing = parsed?.result?.landing || parsed?.landing || parsed?.last_landing || null;
-    } catch { continue; }
+    } catch (err) {
+      debugUnreadableReceipt(rel, err);
+      continue;
+    }
     const changed = String(landing?.changed || landing?.happened || '').replace(/\s+/g, ' ').trim();
     if (!changed) continue;
     if (/\brecorded tick \d+\.?$/i.test(changed) || /^recorded a proof heartbeat\b/i.test(changed)) continue;

package/commands/workflow.js

@@ -21,6 +21,10 @@ const { loadContext } = require('../lib/state-detection');
 const { buildToolResultBody } = require('../lib/tool-result-encode');
 const { commitReviewLearning } = require('./learn');
 
+function reviewLearningLine(timestamp, answer) {
+  return `- ${timestamp} - ${String(answer).trim().replace(/\s*\u2014\s*/g, ', ')}`;
+}
+
 function appendReviewLearningToJournal(journalContent, learning) {
   const text = String(journalContent || '').replace(/\r\n/g, '\n');
   const note = String(learning || '');
@@ -1782,7 +1786,7 @@ async function reviewAtris() {
         if (fs.existsSync(logFile)) {
           let journalContent = fs.readFileSync(logFile, 'utf8');
           const timestamp = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: false });
-          const learning = `- ${timestamp} \u2014 ${answer.trim()}`;
+          const learning = reviewLearningLine(timestamp, answer);
 
           journalContent = appendReviewLearningToJournal(journalContent, learning);
 
@@ -1898,6 +1902,7 @@ module.exports = {
   doAtris,
   reviewAtris,
   appendReviewLearningToJournal,
+  reviewLearningLine,
   renderReviewMinute,
   executorAgentPrompt,
   executorDispatchForTask,

package/lib/codex-flight.js

@@ -1,10 +1,12 @@
 'use strict';
 
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const { spawn, spawnSync } = require('child_process');
 
-const CODEX_COMPANION = '/Users/keshavrao/.claude/plugins/cache/openai-codex/codex/1.0.4/scripts/codex-companion.mjs';
+// Worktree flights need full file access to edit and ship the requested repo.
+const FLIGHT_SANDBOX = 'danger-full-access';
 const CONTRACT = "CRITICAL: complete the entire job in this single run; never end your reply on a plan. Do NOT run any atris boot/brain/state commands; the only atris commands allowed are 'atris worktree guard' and 'atris worktree ship'.";
 const COAUTHOR = 'Co-authored-by: Atris <299057014+atris-builder[bot]@users.noreply.github.com>';
 
@@ -96,12 +98,30 @@ function parseTaskId(stdout) {
   return asMatch ? asMatch[1] : '';
 }
 
-function spawnCodex(worktreePath, prompt) {
+function resolveCodexCompanion() {
+  if (process.env.ATRIS_CODEX_COMPANION) {
+    const override = path.resolve(process.env.ATRIS_CODEX_COMPANION);
+    return fs.existsSync(override) && fs.statSync(override).isFile() ? override : null;
+  }
+  const cache = path.join(os.homedir(), '.claude', 'plugins', 'cache', 'openai-codex', 'codex');
+  if (!fs.existsSync(cache)) return null;
+  const versions = fs.readdirSync(cache, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+  for (const version of versions) {
+    const script = path.join(cache, version, 'scripts', 'codex-companion.mjs');
+    if (fs.existsSync(script) && fs.statSync(script).isFile()) return script;
+  }
+  return null;
+}
+
+function spawnCodex(worktreePath, prompt, companion) {
   return new Promise((resolve, reject) => {
-    const argv = [CODEX_COMPANION, 'task', '--background', '--write', prompt];
+    const argv = [companion, 'task', '--background', '--write', prompt];
     const child = spawn('node', argv, {
       cwd: worktreePath,
-      env: { ...process.env, CODEX_COMPANION_SANDBOX: 'danger-full-access' },
+      env: { ...process.env, CODEX_COMPANION_SANDBOX: FLIGHT_SANDBOX },
       stdio: ['ignore', 'pipe', 'pipe'],
     });
     let stdout = '';
@@ -143,12 +163,15 @@ async function dispatchCodexFlight({ repoPath, slug, brief, verifyCmd, dryRun =
     return { dryRun: true, prompt };
   }
 
+  const companion = resolveCodexCompanion();
+  if (!companion) throw new Error('codex companion not found. set ATRIS_CODEX_COMPANION to its script path.');
   runWorktreeAdd(repo.repoPath, branch, worktreePath);
-  const task = await spawnCodex(worktreePath, prompt);
+  const task = await spawnCodex(worktreePath, prompt, companion);
   return { taskId: task.taskId, worktreePath, branch };
 }
 
 module.exports = {
   dispatchCodexFlight,
   buildPrompt,
+  resolveCodexCompanion,
 };

package/lib/fleet.js

@@ -33,6 +33,8 @@ const {
 const { listWorktrees, defaultMainlineBase } = require('../commands/worktree');
 const { isConductorStatusLine } = require('./conductor-artifacts');
 const { matchLessons } = require('./lesson-preflight');
+const { sleepSync } = require('./sleep-sync');
+const { ownerIdentity } = require('../utils/owner-identity');
 const { matchTaste } = require('./taste-lessons');
 const { buildVerifiedScoutPack, appendVerifiedScoutPack } = require('./dispatch-scout');
 const {
@@ -286,7 +288,7 @@ function terminateTrackedSandbox(stateFile, leaseFile) {
     for (const pid of tracked.pids) {
       try { process.kill(pid, signal); } catch {}
     }
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+    sleepSync(100);
   }
 }
 
@@ -1381,6 +1383,7 @@ function reviewOnlyEngineEnvironment(worktreePath, options = {}) {
     throw error;
   }
   const environment = {
+    ATRIS_OWNER_NAMES: [...new Set(ownerIdentity().names)].join(','),
     PATH: `${guardDir}${path.delimiter}${process.env.PATH || ''}`,
     GIT_CONFIG_COUNT: '2',
     GIT_CONFIG_KEY_0: 'remote.origin.pushurl',

package/lib/improve-vitals-html.js

@@ -10,6 +10,7 @@
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const { isOwner } = require('../utils/owner-identity');
 
 const HTML_RELATIVE_PATH = path.join('.atris', 'state', 'improve-vitals.html');
 
@@ -51,8 +52,8 @@ function openLoops(cwd, now) {
   try {
     const close = require('../commands/close');
     const flags = close.openFlags(cwd, { now });
-    const mine = flags.filter((f) => /^(you|me|operator|human|keshav)$/.test(f.owner));
-    const theirs = flags.filter((f) => !/^(you|me|operator|human|keshav)$/.test(f.owner));
+    const mine = flags.filter((f) => isOwner(f.owner));
+    const theirs = flags.filter((f) => !isOwner(f.owner));
     return { mine, theirs };
   } catch {
     return { mine: [], theirs: [] };

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,183 @@
+'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' }) };
+  });
+  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 };
+}
+
+module.exports = { checkMapRefs, fixMapRefs };

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: [] };