atris 3.68.6 → 3.68.8

package/bin/atris.js

@@ -630,7 +630,7 @@ function showHelpAll() {
   console.log('  rainmaker  - Relationship manager dashboard (atrisos-backend/scripts/rainmaker.py)');
   console.log('  meet       - onboard a stranger in one sitting and print their /book link');
   console.log('  avail      - Booking availability (/book/{username} weekly windows)');
-  console.log('  scoreboard - Today\'s github contributions vs your best day, streak, repo commits (--watch)');
+  console.log('  scoreboard - Today\'s github contributions vs your best day, streak, repo commits (--watch, --json)');
   console.log('  brain      - Compile MAP/TODO/wiki/state into a loadable agent brain');
   console.log('  lesson     - atris lesson add <slug> <pass|fail> "<text>" (mine/sweep/resolve/revert/ledger; --detector validates the falsifier at write time)');
   console.log('  taste      - Record the operator\'s keep, kill, and more creative verdicts');

package/commands/member.js

@@ -1300,6 +1300,13 @@ function memberRunWith(name, args, { quiet = false } = {}) {
     if (nodeModulesLinked) console.log(`linked node_modules from ${nodeModulesSource}`);
   }
 
+  // An ignited run works for minutes; say where to watch it before it starts.
+  if (ignite && !asJson && !quiet && !hasFlag(args, '--quiet')) {
+    const progressDir = process.env.ATRIS_PROGRESS_DIR || '~/.atris/progress';
+    console.log(`watch: tail -f ${progressDir}/${String(name).replace(/[^A-Za-z0-9._-]/g, '_')}.log`);
+    console.log('board: atris member board --watch');
+  }
+
   const cwd = mission.worktree?.path || process.cwd();
   const verifier = readFlag(args, '--verify', '') || mission.verifier || requestedVerifier;
   if (verifier && verifier !== mission.verifier) {
@@ -9789,6 +9796,17 @@ const IDEA_ARCHETYPE_RULES = [
   },
 ];
 
+// Dispatch defaults to the core team. Other members (experiments, one-off
+// workers) win only when the idea names them or out-scores the core by 2x.
+const CORE_DISPATCH_MEMBERS = new Set([
+  'executor', 'architect', 'auto-improver', 'navigator', 'validator', 'customer-lead', 'researcher',
+]);
+
+function ideaNamesMember(text, slug) {
+  const escaped = slug.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/-/g, '[-\\s]+');
+  return new RegExp(`(^|[^a-z0-9-])${escaped}($|[^a-z0-9-])`, 'i').test(text);
+}
+
 function pickMemberForIdea(ideaText, root = process.cwd(), preferredMember = '') {
   const teamDir = path.join(root, 'atris', 'team');
   const members = findAllMembers(teamDir).filter(isFleetMember);
@@ -9841,6 +9859,13 @@ function pickMemberForIdea(ideaText, root = process.cwd(), preferredMember = '')
     if (slug === 'executor') score += 3;
     if (slug === 'auto-improver') score += 2;
 
+    if (ideaNamesMember(text, slug)) {
+      score += 40;
+      matchedReason = 'named in the idea';
+    } else if (!CORE_DISPATCH_MEMBERS.has(slug)) {
+      score = Math.floor(score / 2);
+    }
+
     if (!matchedReason) {
       matchedReason = record.description
         ? compactSentence(record.description, 90)
@@ -10879,6 +10904,29 @@ async function memberRoom(...args) {
   return room;
 }
 
+// --- EXPORT subcommand ---
+
+function memberExport(...args) {
+  const { exportMembers, summaryLine } = require('../lib/member-export');
+  const dryRun = args.includes('--dry-run');
+  const root = process.cwd();
+  if (!fs.existsSync(path.join(root, 'atris', 'team'))) {
+    console.error('No atris/team folder here, so there are no members to export.');
+    process.exitCode = 1;
+    return null;
+  }
+  const result = exportMembers(root, { dryRun });
+  if (args.includes('--json')) {
+    console.log(JSON.stringify({ dry_run: dryRun, ...result }, null, 2));
+    return result;
+  }
+  for (const file of result.written) console.log(`${dryRun ? 'Would write' : '✓ Wrote'} ${file}`);
+  for (const file of result.removed) console.log(`${dryRun ? 'Would remove' : '✓ Removed'} ${file}`);
+  for (const file of result.kept) console.log(`Left alone ${file} (hand-written, not made by export)`);
+  console.log(summaryLine(result, { dryRun }));
+  return result;
+}
+
 async function memberCommand(subcommand, ...args) {
   // Subcommands that take a member name as args[0] otherwise treat `--help` as
   // a name and error with "Member '--help' not found". `create`/`new` handle
@@ -10988,6 +11036,8 @@ async function memberCommand(subcommand, ...args) {
       return memberObjectiveGeneratorCommand(args[0], ...args.slice(1));
     case 'generalist':
       return memberGeneralistCommand(args[0], ...args.slice(1));
+    case 'export':
+      return memberExport(...args);
     case 'archive':
       return memberArchive(args[0]);
     case 'purge-archived':
@@ -11022,6 +11072,7 @@ async function memberCommand(subcommand, ...args) {
       console.log('  install <slug> [--update]  Install missing files, or refresh template skills');
       console.log('  chat <name> "..."   Send a message to this member\'s desk in Atris Desktop');
       console.log('  list [--json]       Show all team members');
+      console.log('  export [--dry-run]  Write each member as a subagent for Claude Code, Cursor, and Codex');
       console.log('  activate <name>     Symlink member skills, show context and permissions');
       console.log('  upgrade <name>      Convert flat file (name.md) to directory format');
       console.log('  push <name>         Push a local team member to the cloud');

package/commands/scoreboard.js

@@ -48,13 +48,21 @@ function bar(count, target) {
   return `[${'#'.repeat(filled)}${'-'.repeat(BAR_WIDTH - filled)}]`;
 }
 
+// Today's commits on every ref (all local and remote branches, the checkout,
+// tags), so an old branch checked out still sees today's work. Stash is left
+// out. Each commit counts once, keyed by hash.
 function repoCommits(cwd = process.cwd(), now = new Date()) {
   const midnight = new Date(now.getFullYear(), now.getMonth(), now.getDate());
   try {
-    const out = execFileSync('git', ['log', `--since=${midnight.toISOString()}`, '--format=%B%x1e'], {
+    const out = execFileSync('git', ['log', '--exclude=refs/stash', '--all', `--since=${midnight.toISOString()}`, '--format=%H%x1f%B%x1e'], {
       cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
     });
-    const bodies = out.split('\x1e').map((b) => b.trim()).filter(Boolean);
+    const byHash = new Map();
+    for (const rec of out.split('\x1e')) {
+      const [hash, body = ''] = rec.trim().split('\x1f');
+      if (hash) byHash.set(hash, body);
+    }
+    const bodies = [...byHash.values()];
     const members = bodies.filter((b) => b.includes(MEMBER_TRAILER)).length;
     return { total: bodies.length, you: bodies.length - members, members };
   } catch {
@@ -90,14 +98,21 @@ function cheers(prev, next) {
 
 function snapshot() {
   const s = score(fetchDays());
-  return { s, text: render(s, repoCommits()) };
+  const commits = repoCommits();
+  return { s, commits, text: render(s, commits) };
+}
+
+// Same numbers as the board, as one object for scripts.
+function toJson(s, commits, date = localDate()) {
+  return { date, today: s.today, best: s.best, streak: s.streak, repo: commits };
 }
 
 async function scoreboardCommand(args = []) {
   if (args.includes('--help') || args.includes('-h')) {
-    console.log('usage: atris scoreboard [--watch]');
+    console.log('usage: atris scoreboard [--watch | --json]');
     console.log('  today\'s github contributions, your best day this year, your streak, and this repo\'s commits');
     console.log('  --watch   refresh every 60 seconds and cheer at every 50');
+    console.log('  --json    print the same numbers once as one json object');
     return 0;
   }
   let snap;
@@ -107,6 +122,10 @@ async function scoreboardCommand(args = []) {
     console.error('could not read your github contributions. check that gh is installed and logged in (gh auth status).');
     return 1;
   }
+  if (args.includes('--json')) {
+    console.log(JSON.stringify(toJson(snap.s, snap.commits), null, 2));
+    return 0;
+  }
   console.log(snap.text);
   if (!args.includes('--watch')) return 0;
 
@@ -129,4 +148,4 @@ async function scoreboardCommand(args = []) {
   return 0;
 }
 
-module.exports = { scoreboardCommand, score, render, cheers, bar, localDate };
+module.exports = { scoreboardCommand, score, render, toJson, cheers, bar, localDate };

package/commands/sync.js

@@ -437,6 +437,18 @@ function syncBusinessCanonical(targetRoot, bizMeta, options = {}) {
   });
 }
 
+// Team members follow every written update, business or legacy, into Claude
+// Code, Cursor, and Codex as subagents. An export failure never fails the update.
+function exportTeamAfterUpdate(root, { dryRun = false } = {}) {
+  if (dryRun || !fs.existsSync(path.join(root, 'atris', 'team'))) return;
+  try {
+    const { exportMembers, summaryLine } = require('../lib/member-export');
+    console.log(`✓ Team: ${summaryLine(exportMembers(root))}`);
+  } catch (err) {
+    console.log(`Team export skipped: ${err.message || err}`);
+  }
+}
+
 function syncAtris(options = {}) {
   const explicitDryRun = options.dryRun != null ? options.dryRun : process.argv.includes('--dry-run');
   const yes = options.yes != null
@@ -455,6 +467,7 @@ function syncAtris(options = {}) {
         dryRun,
         force,
       });
+      exportTeamAfterUpdate(process.cwd(), { dryRun });
       if (!yes) {
         console.log('\nPlan only. Re-run with --yes to write these files.');
         if (!explicitDryRun && isNonInteractive()) process.exit(2);
@@ -695,6 +708,8 @@ Key behaviors:
     console.log(`\n✓ Updated ${updated} file(s), ${skipped} unchanged`);
     console.log('\nRun your AI agent again to use the latest specs and agent templates.');
   }
+
+  exportTeamAfterUpdate(process.cwd(), { dryRun });
 }
 
 /**

package/lib/member-board.js

@@ -9,6 +9,7 @@ const os = require('os');
 const path = require('path');
 
 const QUIET_AFTER_MS = 2 * 60 * 1000;
+const HIDE_DONE_AFTER_MS = 60 * 60 * 1000;
 const TAIL_BYTES = 256 * 1024;
 const JOB_WIDTH = 50;
 const STEP_WIDTH = 50;
@@ -53,7 +54,13 @@ function ago(ms) {
   return `${Math.floor(s / 86400)}d ago`;
 }
 
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 // The current run is everything from the latest "started:" line on.
+// Steps that only write the member's own log are housekeeping, so the last
+// step column skips them unless nothing else happened.
 function memberRow(name, text, now) {
   const lines = text.split('\n').map(parseLine).filter(Boolean);
   if (!lines.length) return null;
@@ -64,7 +71,10 @@ function memberRow(name, text, now) {
   const run = lines.slice(start);
   const startedLine = run[0].text.startsWith('started:') ? run[0] : null;
   const finished = [...run].reverse().find((l) => l.text.startsWith('finished:'));
-  const step = [...run].reverse().find((l) => !l.text.startsWith('started:') && !l.text.startsWith('finished:'));
+  const ownLog = new RegExp(`atris/team/${escapeRe(name)}/logs\\b`);
+  const steps = run.filter((l) => !l.text.startsWith('started:') && !l.text.startsWith('finished:'));
+  const real = steps.filter((l) => !ownLog.test(l.text));
+  const step = real[real.length - 1] || steps[steps.length - 1];
   const last = run[run.length - 1];
   let state;
   if (finished) state = /^finished:\s*ok\b/.test(finished.text) ? 'done ok' : 'done failed';
@@ -76,10 +86,12 @@ function memberRow(name, text, now) {
     step: step ? cut(step.text, STEP_WIDTH) : '',
     ago: ago(now - last.at),
     at: last.at,
+    // Finished more than an hour ago: off the board unless --all.
+    idle: last.text.startsWith('finished:') && now - last.at >= HIDE_DONE_AFTER_MS,
   };
 }
 
-function readBoard({ dir = progressDir(), now = Date.now() } = {}) {
+function readBoard({ dir = progressDir(), now = Date.now(), all = false } = {}) {
   let files = [];
   try { files = fs.readdirSync(dir).filter((f) => f.endsWith('.log')); } catch {}
   const rows = [];
@@ -89,11 +101,12 @@ function readBoard({ dir = progressDir(), now = Date.now() } = {}) {
     const row = memberRow(f.slice(0, -'.log'.length), text, now);
     if (row) rows.push(row);
   }
-  return rows.sort((a, b) => b.at - a.at);
+  return rows.filter((r) => all || !r.idle).sort((a, b) => b.at - a.at);
 }
 
-function renderBoard(rows, dir = progressDir()) {
-  if (!rows.length) return `no member progress yet in ${dir}`;
+function renderBoard(rows, dir = progressDir(), hidden = 0) {
+  const note = hidden ? `${hidden} finished over an hour ago, hidden. --all shows them` : '';
+  if (!rows.length) return note ? `nobody is working right now. ${note}` : `no member progress yet in ${dir}`;
   const w = (key, min) => Math.max(min, ...rows.map((r) => r[key].length));
   const nameW = w('member', 6);
   const stateW = w('state', 5);
@@ -103,16 +116,137 @@ function renderBoard(rows, dir = progressDir()) {
   const line = (a, b, c, d, e) => `${pad(a, nameW)}  ${pad(b, stateW)}  ${pad(c, agoW)}  ${pad(d, jobW)}  ${e}`.trimEnd();
   const out = [line('member', 'state', 'ago', 'job', 'last step')];
   for (const r of rows) out.push(line(r.member, r.state, r.ago, r.job || '-', r.step || '-'));
+  if (note) out.push('', note);
   return out.join('\n');
 }
 
+// Live stream format for `atris member board --json --follow`, one JSON
+// object per line on stdout, forever:
+//   first line: {"kind":"snapshot","at":"<iso>","dir":"<progress dir>","members":[<same rows as --json>]}
+//   then one line per new progress line, in the order it was read:
+//     {"member":"builder","mission":"m-1","at":"<iso>","kind":"started","text":"<job>"}
+//     {"member":"builder","mission":"m-1","at":"<iso>","kind":"step","text":"<step>"}
+//     {"member":"builder","mission":"m-1","at":"<iso>","kind":"finished","text":"ok","ok":true}
+// "ok" appears only on finished. Lines that are not "<iso> <mission> <text>"
+// are skipped, and a line is only read once its newline has been written.
+// Stops on ctrl-c, or on the next write after the reader closes the pipe;
+// an app that is done should kill the process.
+function progressEvent(member, raw) {
+  const m = /^(\S+) (\S+) (.*)$/.exec(raw);
+  if (!m) return null;
+  const at = Date.parse(m[1]);
+  if (Number.isNaN(at)) return null;
+  const event = { member, mission: m[2], at: new Date(at).toISOString(), kind: 'step', text: m[3] };
+  const tagged = /^(started|finished):\s*(.*)$/.exec(m[3]);
+  if (tagged) {
+    event.kind = tagged[1];
+    event.text = tagged[2];
+    if (tagged[1] === 'finished') event.ok = /^ok\b/.test(tagged[2]);
+  }
+  return event;
+}
+
+// Tails every <member>.log in dir and calls emit(event) for each new full
+// line. Files present at start are read from just after their last newline,
+// so a line half written before the stream started still arrives once done;
+// files that appear later are read from the top. scan() is sync, so watch
+// and poll can both call it without racing.
+function afterLastNewline(file) {
+  let fd;
+  try { fd = fs.openSync(file, 'r'); } catch { return 0; }
+  try {
+    const buf = Buffer.alloc(64 * 1024);
+    for (let end = fs.fstatSync(fd).size; end > 0;) {
+      const start = Math.max(0, end - buf.length);
+      const n = fs.readSync(fd, buf, 0, end - start, start);
+      const i = buf.subarray(0, n).lastIndexOf(0x0a);
+      if (i >= 0) return start + i + 1;
+      end = start;
+    }
+    return 0;
+  } catch { return 0; } finally { fs.closeSync(fd); }
+}
+
+function followBoard({ dir = progressDir(), emit, pollMs = 1000 } = {}) {
+  const offsets = new Map();
+  const sizeOf = (file) => { try { return fs.statSync(file).size; } catch { return null; } };
+  const list = () => { try { return fs.readdirSync(dir).filter((f) => f.endsWith('.log')); } catch { return []; } };
+  for (const f of list()) offsets.set(f, afterLastNewline(path.join(dir, f)));
+
+  function readNew(f) {
+    const file = path.join(dir, f);
+    const size = sizeOf(file);
+    if (size === null) return;
+    let from = offsets.get(f) || 0;
+    if (size < from) from = 0; // truncated or replaced: start over
+    if (size === from) { offsets.set(f, from); return; }
+    let buf;
+    try {
+      const fd = fs.openSync(file, 'r');
+      try {
+        buf = Buffer.alloc(size - from);
+        buf = buf.subarray(0, fs.readSync(fd, buf, 0, buf.length, from));
+      } finally { fs.closeSync(fd); }
+    } catch { return; }
+    // Stop at the last newline; a half-written tail waits for the next scan.
+    const end = buf.lastIndexOf(0x0a);
+    if (end < 0) { offsets.set(f, from); return; }
+    offsets.set(f, from + end + 1);
+    const member = f.slice(0, -'.log'.length);
+    for (const raw of buf.subarray(0, end).toString('utf8').split('\n')) {
+      const event = progressEvent(member, raw.replace(/\r$/, ''));
+      if (event) emit(event);
+    }
+  }
+
+  let watcher = null;
+  let stopped = false;
+  function scan() {
+    if (stopped) return;
+    if (!watcher) {
+      try {
+        watcher = fs.watch(dir, () => scan());
+        watcher.on('error', () => { try { watcher.close(); } catch {} watcher = null; });
+      } catch { watcher = null; }
+    }
+    for (const f of list()) readNew(f);
+  }
+  const timer = setInterval(scan, pollMs);
+  scan();
+  return {
+    scan,
+    stop() {
+      stopped = true;
+      clearInterval(timer);
+      if (watcher) { try { watcher.close(); } catch {} }
+    },
+  };
+}
+
 function memberBoardCommand(...args) {
   const asJson = args.includes('--json');
+  const all = args.includes('--all');
+  if (args.includes('--follow')) {
+    const dir = progressDir();
+    const write = (obj) => process.stdout.write(`${JSON.stringify(obj)}\n`);
+    write({ kind: 'snapshot', at: new Date().toISOString(), dir, members: readBoard({ dir, all }) });
+    const follower = followBoard({ dir, emit: write });
+    // Runs until ctrl-c or the reader closes the pipe.
+    return new Promise((resolve) => {
+      const done = () => { follower.stop(); resolve(); };
+      process.once('SIGINT', done);
+      process.stdout.once('error', done);
+    });
+  }
   if (asJson) {
-    console.log(JSON.stringify({ ok: true, dir: progressDir(), members: readBoard() }, null, 2));
+    console.log(JSON.stringify({ ok: true, dir: progressDir(), members: readBoard({ all }) }, null, 2));
     return;
   }
-  const draw = () => renderBoard(readBoard());
+  const draw = () => {
+    const every = readBoard({ all: true });
+    const rows = all ? every : every.filter((r) => !r.idle);
+    return renderBoard(rows, progressDir(), every.length - rows.length);
+  };
   if (!args.includes('--watch')) {
     console.log(draw());
     return;
@@ -126,4 +260,4 @@ function memberBoardCommand(...args) {
   });
 }
 
-module.exports = { readBoard, renderBoard, memberRow, ago, memberBoardCommand };
+module.exports = { readBoard, renderBoard, memberRow, ago, progressEvent, followBoard, memberBoardCommand };

package/lib/member-export.js

@@ -0,0 +1,240 @@
+'use strict';
+
+// `atris member export`: each active atris/team/<member>/MEMBER.md becomes a
+// native subagent file for the coding tools that read one.
+//
+//   claude  .claude/agents/<name>.md   markdown, YAML frontmatter (name, description, model)
+//   cursor  .cursor/agents/<name>.md   same markdown shape; cursor-agent globs **/.cursor/agents/**/*.md
+//   codex   .codex/agents/<name>.toml  agent role file (name, description, developer_instructions);
+//                                      codex 0.162 discovers roles in .codex/agents
+//
+// Every file carries GENERATED_MARK. Export only overwrites or removes files
+// that carry it, so a hand-written agent with the same name is left alone.
+// Parked members are skipped, and their old generated files are removed.
+
+const fs = require('fs');
+const path = require('path');
+const { isParkedText } = require('./member-park');
+
+const GENERATED_MARK = 'generated by atris member export';
+const TARGETS = ['claude', 'cursor', 'codex'];
+const SKIP_DIRS = new Set(['_template', '_archive', '_archived']);
+
+function frontmatterOf(text) {
+  const match = String(text || '').replace(/^/, '').match(/^---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/);
+  if (!match) return { fields: {}, body: String(text || '') };
+  const fields = {};
+  let listKey = null;
+  for (const line of match[1].split(/\r?\n/)) {
+    const item = line.match(/^\s+-\s+(.+)$/);
+    if (item && listKey) {
+      fields[listKey].push(item[1].trim().replace(/^["']|["']$/g, ''));
+      continue;
+    }
+    const kv = line.match(/^([a-zA-Z_-]+):\s*(.*)$/);
+    if (!kv) continue;
+    const value = kv[2].replace(/\s+#.*$/, '').trim();
+    if (value === '') {
+      fields[kv[1]] = [];
+      listKey = kv[1];
+    } else if (value.startsWith('[') && value.endsWith(']')) {
+      fields[kv[1]] = value.slice(1, -1).split(',').map((s) => s.trim().replace(/^["']|["']$/g, '')).filter(Boolean);
+      listKey = null;
+    } else {
+      fields[kv[1]] = value.replace(/^["']|["']$/g, '');
+      listKey = null;
+    }
+  }
+  return { fields, body: String(text).replace(/^/, '').slice(match[0].length) };
+}
+
+function scalar(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function listOf(value) {
+  return Array.isArray(value) ? value.filter((v) => typeof v === 'string' && v.trim()) : [];
+}
+
+// Skills named in frontmatter plus any skills/<name>/SKILL.md on disk.
+function memberSkills(dir, fields) {
+  const names = new Set(listOf(fields.skills));
+  const skillsDir = path.join(dir, 'skills');
+  try {
+    for (const entry of fs.readdirSync(skillsDir)) {
+      if (fs.existsSync(path.join(skillsDir, entry, 'SKILL.md'))) names.add(entry);
+    }
+  } catch {}
+  return [...names].sort();
+}
+
+function readMembers(root) {
+  const teamDir = path.join(root, 'atris', 'team');
+  let entries = [];
+  try {
+    entries = fs.readdirSync(teamDir).sort();
+  } catch {
+    return { members: [], parked: [] };
+  }
+  const members = [];
+  const parked = [];
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry) || entry.startsWith('.')) continue;
+    const dir = path.join(teamDir, entry);
+    const file = path.join(dir, 'MEMBER.md');
+    let text;
+    try {
+      text = fs.readFileSync(file, 'utf8');
+    } catch {
+      continue;
+    }
+    if (isParkedText(text)) {
+      parked.push(entry);
+      continue;
+    }
+    const { fields, body } = frontmatterOf(text);
+    members.push({
+      slug: entry,
+      role: scalar(fields.role),
+      description: scalar(fields.description),
+      model: scalar(fields.model),
+      skills: memberSkills(dir, fields),
+      body: body.trim(),
+    });
+  }
+  return { members, parked };
+}
+
+// Claude Code wants lowercase letters, digits, and hyphens; codex allows
+// letters, digits, spaces, hyphens, and underscores. One safe form fits both.
+function agentName(slug) {
+  return String(slug).toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '') || 'member';
+}
+
+// Written for the tool's router: what the member does, then when to hand it work.
+function agentDescription(member) {
+  const what = member.description.replace(/\s+/g, ' ').trim();
+  const role = member.role || member.slug;
+  const lead = what ? (/[.!?]$/.test(what) ? what : `${what}.`) : `The ${role} on this project's Atris team.`;
+  return `${lead} Use this agent when a task fits the ${role} role on this project's Atris team.`;
+}
+
+function instructions(member) {
+  const lines = [
+    `You are ${member.slug}, the ${member.role || member.slug} on this project's Atris team.`,
+    `Your full card is atris/team/${member.slug}/MEMBER.md; read it when this summary is not enough.`,
+    '',
+  ];
+  if (member.body) lines.push(member.body, '');
+  if (member.skills.length) {
+    lines.push('## Skills', '');
+    for (const skill of member.skills) {
+      lines.push(`- ${skill}: atris/team/${member.slug}/skills/${skill}/SKILL.md`);
+    }
+    lines.push('');
+  }
+  return lines.join('\n').trimEnd() + '\n';
+}
+
+function markdownAgent(member, { withModel }) {
+  const source = `atris/team/${member.slug}/MEMBER.md`;
+  const front = [
+    '---',
+    `# ${GENERATED_MARK} from ${source}. edit MEMBER.md; this file gets overwritten.`,
+    `name: ${agentName(member.slug)}`,
+    `description: ${JSON.stringify(agentDescription(member))}`,
+  ];
+  if (withModel && member.model) front.push(`model: ${JSON.stringify(member.model)}`);
+  front.push('---', '', '');
+  return front.join('\n') + instructions(member);
+}
+
+// TOML basic strings take the same escapes JSON.stringify emits.
+function codexAgent(member) {
+  const source = `atris/team/${member.slug}/MEMBER.md`;
+  return [
+    `# ${GENERATED_MARK} from ${source}. edit MEMBER.md; this file gets overwritten.`,
+    `name = ${JSON.stringify(agentName(member.slug))}`,
+    `description = ${JSON.stringify(agentDescription(member))}`,
+    `developer_instructions = ${JSON.stringify(instructions(member))}`,
+    '',
+  ].join('\n');
+}
+
+const FORMATS = {
+  claude: { dir: ['.claude', 'agents'], ext: '.md', render: (m) => markdownAgent(m, { withModel: true }) },
+  cursor: { dir: ['.cursor', 'agents'], ext: '.md', render: (m) => markdownAgent(m, { withModel: false }) },
+  codex: { dir: ['.codex', 'agents'], ext: '.toml', render: codexAgent },
+};
+
+function isGenerated(file) {
+  try {
+    return fs.readFileSync(file, 'utf8').slice(0, 400).includes(GENERATED_MARK);
+  } catch {
+    return false;
+  }
+}
+
+function exportMembers(root, { targets = TARGETS, dryRun = false } = {}) {
+  const { members, parked } = readMembers(root);
+  const result = { members: members.map((m) => m.slug), parked, written: [], unchanged: [], removed: [], kept: [] };
+  if (!fs.existsSync(path.join(root, 'atris', 'team'))) return result;
+
+  for (const target of targets) {
+    const format = FORMATS[target];
+    if (!format) continue;
+    const dir = path.join(root, ...format.dir);
+    const wanted = new Set();
+    for (const member of members) {
+      const file = path.join(dir, agentName(member.slug) + format.ext);
+      const rel = path.relative(root, file);
+      wanted.add(file);
+      const next = format.render(member);
+      if (fs.existsSync(file)) {
+        if (!isGenerated(file)) {
+          result.kept.push(rel);
+          continue;
+        }
+        if (fs.readFileSync(file, 'utf8') === next) {
+          result.unchanged.push(rel);
+          continue;
+        }
+      }
+      if (!dryRun) {
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(file, next, 'utf8');
+      }
+      result.written.push(rel);
+    }
+    // A member that was parked or removed leaves no stale generated file behind.
+    let existing = [];
+    try {
+      existing = fs.readdirSync(dir);
+    } catch {}
+    for (const entry of existing) {
+      const file = path.join(dir, entry);
+      if (!entry.endsWith(format.ext) || wanted.has(file) || !isGenerated(file)) continue;
+      if (!dryRun) fs.unlinkSync(file);
+      result.removed.push(path.relative(root, file));
+    }
+  }
+  return result;
+}
+
+function summaryLine(result, { dryRun = false } = {}) {
+  const count = result.members.length;
+  const parts = [`${count} ${count === 1 ? 'member' : 'members'} exported to claude code, cursor, and codex`];
+  if (result.written.length) parts.push(`${result.written.length} ${dryRun ? 'would change' : 'files written'}`);
+  if (result.removed.length) parts.push(`${result.removed.length} old ${dryRun ? 'would be removed' : 'removed'}`);
+  if (!result.written.length && !result.removed.length) parts.push('already up to date');
+  if (result.parked.length) parts.push(`${result.parked.length} parked skipped`);
+  return parts.join(', ');
+}
+
+module.exports = {
+  GENERATED_MARK,
+  agentName,
+  exportMembers,
+  frontmatterOf,
+  summaryLine,
+};

package/lib/member-progress.js

@@ -62,21 +62,33 @@ function hhmm(date = new Date()) {
   return `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
 }
 
+// One progress line stays one short line: a 'started:' objective keeps its
+// first line and at most 80 chars; any other line caps at 100.
+function shortenLine(line) {
+  const first = String(line || '').split('\n')[0];
+  if (first.startsWith('started: ')) {
+    const objective = first.slice('started: '.length);
+    return `started: ${objective.length > 80 ? `${objective.slice(0, 80)}...` : objective}`;
+  }
+  return first.length > 100 ? `${first.slice(0, 100)}...` : first;
+}
+
 function appendProgress(member, line, missionId) {
   // Test runs never write into the real home folder unless they name a dir.
   if (!process.env.ATRIS_PROGRESS_DIR && process.env.NODE_TEST_CONTEXT) return;
   try {
     const dir = progressDir();
     fs.mkdirSync(dir, { recursive: true });
-    const entry = `${new Date().toISOString()} ${missionId || '-'} ${line}\n`;
+    const entry = `${new Date().toISOString()} ${missionId || '-'} ${shortenLine(line)}\n`;
     fs.appendFileSync(path.join(dir, `${safeMember(member)}.log`), entry, 'utf8');
   } catch {}
 }
 
 // Print one step for the operator and keep it in the member's progress log.
 function reportProgress(member, line, missionId) {
-  try { process.stderr.write(`  ${member || 'mission'} ${hhmm()}  ${line}\n`); } catch {}
-  appendProgress(member, line, missionId);
+  const short = shortenLine(line);
+  try { process.stderr.write(`  ${member || 'mission'} ${hhmm()}  ${short}\n`); } catch {}
+  appendProgress(member, short, missionId);
 }
 
-module.exports = { formatToolStep, appendProgress, reportProgress };
+module.exports = { formatToolStep, appendProgress, reportProgress, shortenLine };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.68.6",
+  "version": "3.68.8",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {