atris 3.68.7 → 3.68.9

package/commands/member.js

@@ -10904,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
@@ -11013,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':
@@ -11047,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/sync.js

@@ -83,6 +83,23 @@ function ensureRealDirectory(dir) {
   fs.mkdirSync(dir, { recursive: true });
 }
 
+// A hook script the project already has is never replaced. Projects harden
+// their hooks (nonce checks, queues, proof before pop); a sync must not
+// downgrade them to the shipped copy.
+function isProtectedHook(destPath) {
+  return path.basename(path.dirname(destPath)) === 'hooks' && fs.existsSync(destPath);
+}
+
+// A member retired to team/_archived/<name>-<date>/ must never come back.
+function isArchivedMember(teamDir, name) {
+  const archiveDir = path.join(teamDir, '_archived');
+  try {
+    return fs.readdirSync(archiveDir).some(entry => entry === name || (entry.startsWith(`${name}-`) && /^\d{4}-\d{2}-\d{2}$/.test(entry.slice(name.length + 1))));
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Sync the canonical skill set from atris-cli/atris/skills/* into a
  * workspace's atris/skills/* (plus ensure .claude/skills/ symlinks).
@@ -128,7 +145,9 @@ function syncPackageSkills(targetAtrisDir, opts = {}) {
         } else {
           const srcContent = fs.readFileSync(srcPath, 'utf8');
           const destContent = fs.existsSync(destPath) ? fs.readFileSync(destPath, 'utf8') : '';
-          if (srcContent !== destContent) {
+          if (srcContent !== destContent && isProtectedHook(destPath)) {
+            if (verbose) console.log(`- Kept atris/skills/${skillName}/${relPath} (differs from shipped hook, not replaced)`);
+          } else if (srcContent !== destContent) {
             if (!dryRun) {
               fs.writeFileSync(destPath, srcContent);
               if (entry.endsWith('.sh')) fs.chmodSync(destPath, 0o755);
@@ -348,6 +367,12 @@ function syncWorkspaceTemplate(targetRoot, bizMeta, options = {}) {
     try { templateContent = fs.readFileSync(templatePath, 'utf-8'); } catch { continue; }
     const finalContent = _substituteParams(templateContent, params);
 
+    const memberMatch = targetRelPath.split(path.sep).join('/').match(/^team\/([^/_][^/]*)\//);
+    if (memberMatch && isArchivedMember(path.join(targetAtrisDir, 'team'), memberMatch[1])) {
+      skipped++;
+      continue;
+    }
+
     if (!fs.existsSync(targetPath)) {
       addedList.push(targetRelPath); added++;
       if (!dryRun) {
@@ -358,7 +383,7 @@ function syncWorkspaceTemplate(targetRoot, bizMeta, options = {}) {
       const existing = fs.readFileSync(targetPath, 'utf-8');
       if (existing === finalContent) {
         skipped++;
-      } else if (force) {
+      } else if (force && !memberMatch) {
         updatedList.push(targetRelPath); updated++;
         if (!dryRun) fs.writeFileSync(targetPath, finalContent);
       } else {
@@ -437,6 +462,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 +492,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);
@@ -552,6 +590,17 @@ function syncAtris(options = {}) {
       return;
     }
 
+    // Team members belong to the project. Update never adds a member (init
+    // does that, and a missing member may have been retired to
+    // team/_archived/) and never replaces one the project has changed.
+    if (target.startsWith('team/')) {
+      if (fs.existsSync(targetFile)) {
+        console.log(`- Kept ${target} (newer template exists in the package, yours not replaced)`);
+      }
+      skipped++;
+      return;
+    }
+
     if (!dryRun) {
       fs.mkdirSync(path.dirname(targetFile), { recursive: true });
       fs.copyFileSync(sourceFile, targetFile);
@@ -695,6 +744,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 });
 }
 
 /**
@@ -713,7 +764,9 @@ function syncRecursiveCount(src, dest, label, silent) {
     } else {
       const srcBuf = fs.readFileSync(srcPath);
       const destBuf = fs.existsSync(destPath) ? fs.readFileSync(destPath) : Buffer.alloc(0);
-      if (!srcBuf.equals(destBuf)) {
+      if (!srcBuf.equals(destBuf) && isProtectedHook(destPath)) {
+        if (!silent) console.log(`- Kept ${label}/${entry} (differs from shipped hook, not replaced)`);
+      } else if (!srcBuf.equals(destBuf)) {
         fs.writeFileSync(destPath, srcBuf);
         if (entry.endsWith('.sh')) {
           fs.chmodSync(destPath, 0o755);

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/package.json

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