atris 3.58.6 → 3.58.8

package/lib/design-api.js

@@ -0,0 +1,130 @@
+'use strict';
+
+// Shared client for the Atris design API. Used by `atris design` and the
+// `atris mcp` stdio server so both resolve keys and bill the same way.
+//
+// Key resolution order:
+//   1. ATRIS_API_KEY env var
+//   2. login credentials token (atris login)
+//   3. ~/.atris/design-api-key file (raw key text, saved by hand)
+//
+// Endpoints (see https://api.atris.ai/llms.txt):
+//   POST /design/extractions {"url"}            -> job; poll GET /design/extractions/{id}
+//   POST /design/adherence  {source, reference} -> job; poll GET /design/adherence/{id}
+//   POST /design/search     {"query", "limit"}  -> sync result
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { getApiBaseUrl, httpRequest } = require('../utils/api');
+const { loadCredentials } = require('../utils/auth');
+
+const DESIGN_KEY_FILE = path.join(os.homedir(), '.atris', 'design-api-key');
+
+const POLL_INTERVAL_MS = 3000;
+const POLL_TIMEOUT_MS = 3 * 60 * 1000;
+
+function readKeyFile(file = DESIGN_KEY_FILE) {
+  try {
+    const text = fs.readFileSync(file, 'utf8').trim();
+    return text || null;
+  } catch {
+    return null;
+  }
+}
+
+// Returns the bearer token for design calls, or null when nothing is set up.
+function resolveDesignKey(env = process.env, deps = {}) {
+  const fromEnv = env.ATRIS_API_KEY && env.ATRIS_API_KEY.trim();
+  if (fromEnv) return fromEnv;
+  const load = deps.loadCredentials || loadCredentials;
+  const creds = load();
+  const token = creds && typeof creds.token === 'string' ? creds.token.trim() : '';
+  if (token) return token;
+  return (deps.readKeyFile || readKeyFile)();
+}
+
+// One JSON call against the design API. Returns { ok, status, data, error }.
+async function designRequest(pathname, options = {}) {
+  const key = options.key;
+  const url = `${getApiBaseUrl()}${pathname.startsWith('/') ? pathname : `/${pathname}`}`;
+  const headers = {
+    'Authorization': `Bearer ${key}`,
+    'Accept': 'application/json',
+    ...(options.headers || {}),
+  };
+  let body;
+  if (options.body !== undefined && options.body !== null) {
+    body = JSON.stringify(options.body);
+    headers['Content-Type'] = 'application/json';
+  }
+  const res = await httpRequest(url, {
+    method: options.method || 'GET',
+    headers,
+    body,
+    timeoutMs: options.timeoutMs != null ? options.timeoutMs : 30000,
+  });
+  const text = res.body.toString('utf8');
+  let data = null;
+  try { data = text ? JSON.parse(text) : null; } catch { data = null; }
+  const ok = res.status >= 200 && res.status < 300;
+  const error = !ok
+    ? (data && typeof data === 'object' && (data.detail || data.error || data.message)) || text.slice(0, 200) || `http ${res.status}`
+    : undefined;
+  return { ok, status: res.status, data, error };
+}
+
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+
+// Poll a design job until it finishes. `fetchJob` returns the parsed job
+// object; `onTick` fires once per wait so callers can draw a spinner.
+// Resolves { ok, job, timedOut } and never throws on a bad status.
+async function pollDesignJob(fetchJob, options = {}) {
+  const intervalMs = options.intervalMs != null ? options.intervalMs : POLL_INTERVAL_MS;
+  const timeoutMs = options.timeoutMs != null ? options.timeoutMs : POLL_TIMEOUT_MS;
+  const wait = options.sleep || sleep;
+  const onTick = typeof options.onTick === 'function' ? options.onTick : null;
+  const start = Date.now();
+  let job = await fetchJob();
+  while (job && job.status && !isTerminalStatus(job.status)) {
+    if (Date.now() - start >= timeoutMs) return { ok: false, job, timedOut: true };
+    if (onTick) onTick(Date.now() - start, job);
+    await wait(intervalMs);
+    job = await fetchJob();
+  }
+  const ok = Boolean(job) && job.status === 'completed' && !job.error;
+  return { ok, job, timedOut: false };
+}
+
+function isTerminalStatus(status) {
+  const s = String(status || '').toLowerCase();
+  return s === 'completed' || s === 'failed' || s === 'error' || s === 'succeeded';
+}
+
+// Pull the billing block off any design response. Top-level credits_charged on
+// jobs is the job's price; atris.credits_charged is what this call billed.
+function billingOf(data = {}) {
+  const raw = data && typeof data === 'object' ? data : {};
+  const atris = raw.atris && typeof raw.atris === 'object' ? raw.atris : {};
+  const charged = Number(atris.credits_charged != null ? atris.credits_charged : raw.credits_charged);
+  const balance = Number(atris.balance_remaining_usd);
+  return {
+    credits: Number.isFinite(charged) ? charged : null,
+    balanceUsd: Number.isFinite(balance) ? balance : null,
+  };
+}
+
+function creditLine(data) {
+  const bill = billingOf(data);
+  const charged = bill.credits == null ? '?' : `${bill.credits} credit${bill.credits === 1 ? '' : 's'}`;
+  const left = bill.balanceUsd == null ? '' : ` $${bill.balanceUsd.toFixed(2)} left.`;
+  return `${charged} charged.${left}`;
+}
+
+module.exports = {
+  resolveDesignKey,
+  designRequest,
+  pollDesignJob,
+  billingOf,
+  creditLine,
+};

package/lib/engine-ask.js

@@ -283,7 +283,7 @@ function buildReadOnlyEngineInvocation(engineName, prompt, modelName = '', {
   if (engine === 'opencode') {
     // `run` with a message is headless print mode; the built-in plan agent
     // keeps the ask read-only (verified live 2026-08-21, ~7s per lookup).
-    return { engine, bin: profile.bin, args: ['--agent', 'plan', ...(model ? ['-m', model] : []), request] };
+    return { engine, bin: profile.bin, args: ['run', '--agent', 'plan', ...(model ? ['-m', model] : []), request] };
   }
   throw new Error(`engine ask has no read-only command for ${engine}`);
 }

package/lib/first-minute.js

@@ -168,12 +168,7 @@ function titlesFromTodoSection(root, section) {
     if (!match) return null;
     const body = String(match[1] || '').trim();
     if (!body || /\(empty|\(see /i.test(body)) return [];
-    return body
-      .split('\n')
-      .map((line) => line.trim())
-      .filter((line) => /^-\s+/.test(line) && !/\(empty/i.test(line))
-      .map((line) => line.replace(/^-+\s*/, '').trim())
-      .filter(Boolean);
+    return require('./todo-fallback').parseSection(text, section).map(task => task.title);
   } catch {
     return null;
   }

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/known-commands.js

@@ -1,11 +1,11 @@
 'use strict';
 
-const knownCommands = ['init', 'guide', 'doctor', 'install', 'workspace', 'log', 'logs', 'later', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'revisions', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
+const knownCommands = ['init', 'guide', 'doctor', 'doc-health', 'install', 'workspace', 'log', 'logs', 'later', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'revisions', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'team', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'tree', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube', 'x-search',
                        'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'sync-checkout',
-                       'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'balance', 'usage', 'api-key', 'topup', 'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
-                       'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'playbook', 'feed', 'brief', 'social', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join'];
+                       'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'balance', 'usage', 'api-key', 'topup', 'design', 'mcp', 'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
+                       'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'playbook', 'feed', 'brief', 'social', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join', 'rsi'];
 
 // Damerau-Levenshtein edit distance between two short strings. Counts an
 // adjacent transposition (e.g. "taks" -> "task") as a single edit, since

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/member-context.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MEMBER_PROCESS_PATH = 'atris/team/MEMBER_PROCESS.md';
+const MAX_MEMBER_PROCESS_BYTES = 32 * 1024;
+
+// Read from the executing workspace only. Never fall back to the launcher,
+// an ancestor workspace, or a bundled policy belonging to another owner.
+function memberProcessPrompt(cwd = process.cwd()) {
+  const file = path.join(cwd, MEMBER_PROCESS_PATH);
+  let fd;
+  try {
+    const stat = fs.statSync(file);
+    if (!stat.isFile()) throw new Error('expected a regular file');
+    fd = fs.openSync(file, 'r');
+    const buffer = Buffer.alloc(MAX_MEMBER_PROCESS_BYTES + 1);
+    const count = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    if (count > MAX_MEMBER_PROCESS_BYTES) {
+      throw new Error(`keep the shared process within ${MAX_MEMBER_PROCESS_BYTES} bytes`);
+    }
+    const body = buffer.subarray(0, count).toString('utf8').trim();
+    if (!body) return '';
+    return [
+      '## Shared member process',
+      `Source: ${MEMBER_PROCESS_PATH} in this execution workspace.`,
+      'Apply these defaults alongside the member identity. They do not expand role permissions or override operator direction, task scope, output format, or frozen mission constraints.',
+      '',
+      body,
+      '',
+      'End of shared member process. The current task and its constraints follow.',
+    ].join('\n');
+  } catch (error) {
+    if (error.code === 'ENOENT') return '';
+    throw new Error(`Cannot load ${MEMBER_PROCESS_PATH}: ${error.message}`);
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+  }
+}
+
+module.exports = { memberProcessPrompt, MEMBER_PROCESS_PATH, MAX_MEMBER_PROCESS_BYTES };

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