atris 3.15.13 → 3.15.22

package/commands/gm.js

@@ -0,0 +1,376 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ROLE_PLAYERS_TO_IGNORE = new Set([
+  'game-manager',
+  'navigator',
+  'executor',
+  'validator',
+  'launcher',
+  'researcher',
+  'brainstormer',
+  'ops',
+]);
+
+function showHelp() {
+  console.log('');
+  console.log('Usage: atris gm [--manager <id>] [--player <id>] [--workspace <path>] [--json]');
+  console.log('');
+  console.log('Description:');
+  console.log('  Enter AgentXP General Manager mode for the current Atris workspace.');
+  console.log('  Shows local players, active missions, review queue, and the next command');
+  console.log('  that moves the same AgentXP game loop forward.');
+  console.log('');
+  console.log('Options:');
+  console.log('  --manager <id>    Manager id. Defaults to game-manager when present.');
+  console.log('  --as <id>         Alias for --manager.');
+  console.log('  --player <id>     Preferred player when seeding a first local mission.');
+  console.log('  --workspace <p>   Read missions from another Atris workspace.');
+  console.log('  --no-seed         Do not create a starter player mission.');
+  console.log('  --json            Print machine-readable mode state.');
+  console.log('  --help, -h        Show this help.');
+  console.log('');
+}
+
+function flag(args, name) {
+  const inline = args.find(arg => arg.startsWith(`${name}=`));
+  if (inline) return inline.slice(name.length + 1);
+  const index = args.indexOf(name);
+  if (index >= 0 && args[index + 1] && !args[index + 1].startsWith('--')) {
+    return args[index + 1];
+  }
+  return null;
+}
+
+function hasFlag(args, name) {
+  return args.includes(name) || args.some(arg => arg.startsWith(`${name}=`));
+}
+
+function positional(args) {
+  return args.filter((arg, index) => {
+    if (arg.startsWith('--')) return false;
+    if (index > 0 && args[index - 1].startsWith('--')) return false;
+    return true;
+  });
+}
+
+function slugify(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/@.*$/, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function taskRef(task) {
+  return task.display_id || task.legacy_ref || String(task.id || '').slice(0, 8);
+}
+
+function taskAssignee(task) {
+  const metadata = task && task.metadata && typeof task.metadata === 'object'
+    ? task.metadata
+    : {};
+  return metadata.assigned_to
+    || metadata.owner
+    || metadata.assignee
+    || task.claimed_by
+    || null;
+}
+
+function clip(value, max = 240) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 3)).trim()}...`;
+}
+
+function teamMembers(workspaceRoot) {
+  const teamDir = path.join(workspaceRoot, 'atris', 'team');
+  try {
+    return fs.readdirSync(teamDir, { withFileTypes: true })
+      .filter(entry => entry.isDirectory())
+      .map(entry => slugify(entry.name))
+      .filter(Boolean)
+      .filter(name => !name.startsWith('_') && name !== 'template')
+      .filter(name => fs.existsSync(path.join(teamDir, name, 'MEMBER.md')) || fs.existsSync(path.join(teamDir, name, 'START_HERE.md')));
+  } catch {
+    return [];
+  }
+}
+
+function inferManager(workspaceRoot, args = []) {
+  const explicit = flag(args, '--manager') || flag(args, '--as') || positional(args)[0];
+  if (explicit) return { manager: slugify(explicit), source: 'flag' };
+
+  for (const value of [process.env.ATRIS_GM, process.env.ATRIS_MANAGER, process.env.ATRIS_AGENT_ID]) {
+    const manager = slugify(value);
+    if (manager) return { manager, source: 'env' };
+  }
+
+  if (fs.existsSync(path.join(workspaceRoot, 'atris', 'team', 'game-manager'))) {
+    return { manager: 'game-manager', source: 'team' };
+  }
+
+  return { manager: 'game-manager', source: 'default' };
+}
+
+function activeTasks(tasks) {
+  return (tasks || []).filter(task => !['done', 'failed'].includes(task.status));
+}
+
+function activeAgentXpTasks(tasks) {
+  return activeTasks(tasks).filter((task) => {
+    const metadata = task.metadata || {};
+    const text = `${task.title || ''} ${task.tag || ''} ${metadata.delegate_via || ''}`.toLowerCase();
+    return text.includes('agentxp') || text.includes('agent-xp');
+  });
+}
+
+function playersFromTasks(tasks) {
+  const players = new Set();
+  for (const task of activeTasks(tasks)) {
+    const assignee = slugify(taskAssignee(task));
+    if (assignee && !ROLE_PLAYERS_TO_IGNORE.has(assignee)) players.add(assignee);
+    const claimedBy = slugify(task.claimed_by);
+    if (claimedBy && !ROLE_PLAYERS_TO_IGNORE.has(claimedBy)) players.add(claimedBy);
+  }
+  return Array.from(players).sort();
+}
+
+function playersFromWorkspace(workspaceRoot) {
+  return teamMembers(workspaceRoot)
+    .filter(member => !ROLE_PLAYERS_TO_IGNORE.has(member))
+    .sort();
+}
+
+function starterMissionTitle() {
+  return 'AgentXP Mode first rep: complete one proof-backed customer-motion mission';
+}
+
+function starterMissionPrompt(player) {
+  return [
+    `Player ${player}: enter AgentXP Mode in this local workspace.`,
+    'Pick one concrete customer-motion rep you can finish today.',
+    'Use an agent for the artifact and verifier proof.',
+    'Human accept/revise gates the XP.',
+  ].join(' ');
+}
+
+function pickSeedPlayer(workspaceRoot, tasks, args = []) {
+  const explicit = flag(args, '--player') || flag(args, '--user');
+  if (explicit) return slugify(explicit);
+
+  const fromTasks = playersFromTasks(tasks);
+  if (fromTasks.length === 1) return fromTasks[0];
+
+  const fromWorkspace = playersFromWorkspace(workspaceRoot);
+  if (fromWorkspace.length === 1) return fromWorkspace[0];
+
+  const local = slugify(process.env.ATRIS_PLAYER || process.env.USER || os.userInfo().username);
+  if (local && !ROLE_PLAYERS_TO_IGNORE.has(local)) return local;
+
+  return null;
+}
+
+function ensureStarterMission(taskDb, db, workspaceRoot, tasks, args = []) {
+  if (hasFlag(args, '--no-seed')) return { tasks, seeded: null };
+  if (!fs.existsSync(path.join(workspaceRoot, 'atris'))) return { tasks, seeded: null };
+  if (activeAgentXpTasks(tasks).length) return { tasks, seeded: null };
+
+  const player = pickSeedPlayer(workspaceRoot, tasks, args);
+  if (!player) return { tasks, seeded: null };
+
+  const result = taskDb.addTask(db, {
+    title: starterMissionTitle(),
+    tag: 'agent-xp',
+    workspaceRoot,
+    metadata: {
+      assigned_to: player,
+      delegate_via: 'agentxp_gm',
+      auto_seeded_by: 'atris gm',
+      created_for_day: new Date().toISOString().slice(0, 10),
+    },
+  });
+  taskDb.noteTask(db, {
+    id: result.id,
+    actor: 'game-manager',
+    content: starterMissionPrompt(player),
+  });
+
+  const refreshed = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, {
+    workspaceRoot,
+    limit: 500,
+  }));
+  return {
+    tasks: refreshed,
+    seeded: refreshed.find(task => task.id === result.id) || null,
+  };
+}
+
+function groupPlayers(tasks, workspaceRoot) {
+  const players = new Map();
+  for (const task of activeTasks(tasks)) {
+    const player = slugify(taskAssignee(task)) || 'unassigned';
+    if (!players.has(player)) {
+      players.set(player, {
+        player,
+        source: 'task',
+        open: 0,
+        claimed: 0,
+        review: 0,
+        active: 0,
+      });
+    }
+    const row = players.get(player);
+    row.active += 1;
+    if (task.status === 'open') row.open += 1;
+    if (task.status === 'claimed') row.claimed += 1;
+    if (task.status === 'review') row.review += 1;
+  }
+
+  if (!players.size) {
+    for (const player of playersFromWorkspace(workspaceRoot)) {
+      players.set(player, {
+        player,
+        source: 'team',
+        open: 0,
+        claimed: 0,
+        review: 0,
+        active: 0,
+      });
+    }
+  }
+
+  return Array.from(players.values())
+    .filter(row => !ROLE_PLAYERS_TO_IGNORE.has(row.player))
+    .sort((a, b) => b.active - a.active || a.player.localeCompare(b.player));
+}
+
+function compactTask(task) {
+  if (!task) return null;
+  return {
+    id: task.id,
+    ref: taskRef(task),
+    title: task.title,
+    status: task.status,
+    assigned_to: taskAssignee(task),
+    claimed_by: task.claimed_by || null,
+  };
+}
+
+function nextCommands({ seeded, reviewQueue, missions, players }) {
+  if (reviewQueue.length) {
+    const ref = reviewQueue[0].ref;
+    return [
+      `atris task show ${ref}`,
+      `atris task accept ${ref} --proof "<human review>"`,
+      `atris task revise ${ref} --note "<what must change>"`,
+    ];
+  }
+  if (missions.length) {
+    const mission = missions[0];
+    const player = mission.assigned_to || mission.claimed_by || players[0]?.player || 'player';
+    if (mission.status === 'open') return [`atris task claim ${mission.ref} --as ${player}`];
+    return [`atris play --as ${player}`];
+  }
+  if (seeded) return [`atris play --as ${seeded.assigned_to || 'player'}`];
+  return ['atris gm --player <player>'];
+}
+
+function gmState(args = []) {
+  const taskDb = require('../lib/task-db');
+  const workspaceArg = flag(args, '--workspace') || flag(args, '--root') || process.cwd();
+  const workspaceRoot = taskDb.workspaceRoot(path.resolve(workspaceArg));
+  const db = taskDb.open();
+  let tasks = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, {
+    workspaceRoot,
+    limit: 500,
+  }));
+  const detected = inferManager(workspaceRoot, args);
+  const starter = ensureStarterMission(taskDb, db, workspaceRoot, tasks, args);
+  tasks = starter.tasks;
+
+  const missions = activeAgentXpTasks(tasks).map(compactTask);
+  const reviewQueue = missions.filter(task => task.status === 'review');
+  const players = groupPlayers(tasks, workspaceRoot);
+  const seeded = compactTask(starter.seeded);
+  const commands = nextCommands({ seeded, reviewQueue, missions, players });
+
+  return {
+    schema: 'atris.agentxp_gm_mode.v1',
+    mode: 'AgentXP General Manager',
+    generated_at: new Date().toISOString(),
+    manager: detected.manager,
+    manager_source: detected.source,
+    workspace_root: workspaceRoot,
+    workspace_name: path.basename(workspaceRoot),
+    seeded,
+    counts: {
+      players: players.length,
+      missions: missions.length,
+      review: reviewQueue.length,
+    },
+    players,
+    missions,
+    review_queue: reviewQueue,
+    next_commands: commands,
+    xp_rule: 'GM can route missions and review proof, but AgentXP still lands only after human accept.',
+  };
+}
+
+function render(state) {
+  console.log('');
+  console.log('AgentXP General Manager');
+  console.log(`Manager ${state.manager} | Workspace ${state.workspace_name}`);
+  console.log('');
+
+  if (state.seeded) {
+    console.log(`Starter mission created locally: ${state.seeded.ref} -> ${state.seeded.assigned_to || 'player'}`);
+    console.log('');
+  }
+
+  console.log(`Players ${state.counts.players} | Missions ${state.counts.missions} | Review ${state.counts.review}`);
+  if (state.players.length) {
+    console.log('');
+    console.log('Players:');
+    for (const player of state.players.slice(0, 8)) {
+      console.log(`- ${player.player}: ${player.active} active, ${player.review} review`);
+    }
+  }
+
+  if (state.missions.length) {
+    console.log('');
+    console.log('Missions:');
+    for (const task of state.missions.slice(0, 8)) {
+      console.log(`- ${task.ref} [${task.status}] ${task.assigned_to || 'unassigned'}: ${clip(task.title, 120)}`);
+    }
+  }
+
+  console.log('');
+  console.log('XP rule: no proof, no AgentXP; accept/revise stays human-gated.');
+  console.log('');
+  console.log('Next commands:');
+  for (const command of state.next_commands) console.log(`- ${command}`);
+}
+
+async function gmCommand(...args) {
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    showHelp();
+    return;
+  }
+
+  const state = gmState(args);
+  if (hasFlag(args, '--json')) {
+    console.log(JSON.stringify(state, null, 2));
+    return;
+  }
+  render(state);
+}
+
+module.exports = {
+  gmCommand,
+  gmState,
+};

package/commands/init.js

@@ -233,6 +233,17 @@ ${profile.hasCode ? `**Validation:** Run \`${profile.testCommand}\` to verify ch
 }
 
 function initAtris() {
+  // Print usage on -h / --help / help instead of running init (which scaffolds
+  // many files, including atris/now.md and atris/team/). Asking for help
+  // shouldn't have file-system side effects.
+  const args = process.argv.slice(3);
+  if (args[0] === '-h' || args[0] === '--help' || args[0] === 'help') {
+    console.log('Usage: atris init [--force]');
+    console.log('');
+    console.log('  Scaffold the atris/ workspace in the current directory.');
+    console.log('  Refuses to run inside an existing atris/ folder unless --force is passed.');
+    return;
+  }
   // GUARD: Refuse nested init.
   // Bug: running `atris init` inside an existing `atris/` folder creates
   // `atris/atris/` nesting hell. Cloud doordash had this exact problem.
@@ -595,7 +606,7 @@ tools: []
   // Create agent instruction files for different tools
   const agentInstructions = `# AGENTS.md — Universal Agent Instructions
 
-> Works with: Claude Code, Cursor, Codex, Windsurf, and any AI coding agent.
+> Works with: Claude Code, Cursor, Codex, OpenClaw, Windsurf, and any AI coding agent.
 
 ## FIRST MESSAGE — Boot Sequence
 
@@ -609,14 +620,46 @@ This is the Atris boot sequence. Show the output to the user, then respond natur
 
 ## Core Files
 
+Atris is the source of truth. This file is only an adapter for tools that read
+\`AGENTS.md\`; do not turn it into a parallel brain. Durable policy, workflow,
+task truth, proof, review, and backend/cloud sync all flow through Atris.
+
 | File | Purpose |
 |------|---------|
+| \`atris/atris.md\` | Protocol/backbone for this workspace |
 | \`atris/PERSONA.md\` | Communication style (read first) |
 | \`atris task\` | Current tasks, claims, dialogue, proof |
 | \`.atris/state/tasks.projection.json\` | Readable task projection for UIs/agents |
 | \`atris/TODO.md\` | Rendered/legacy task view only |
 | \`atris/MAP.md\` | Navigation (where is X?) |
 
+## Agent Contract
+
+Every agent should leave four artifacts another agent can trust:
+
+| Artifact | Where |
+|----------|-------|
+| Objective | \`atris task note <id> "Goal / files / done / check"\` |
+| Navigation | \`atris/MAP.md\` when a new route or file location is learned |
+| Change | Small git diff in declared files only |
+| Proof ready | \`atris task ready <id> --proof "<commands or receipt>"\` |
+| Human accept | \`atris task accept <id>\` |
+
+Do not rely on chat context. Put the task, file pointers, and proof on disk.
+Do not write new operating doctrine here first; add it to Atris policy, skills,
+wiki, or \`atris/atris.md\`, then regenerate this adapter if needed.
+
+Native goals and task approval are separate gates:
+
+\`\`\`text
+Agent proof ready -> native goal can complete
+Human accept      -> task Done + AgentXP awarded
+\`\`\`
+
+Always-on agents should move proof-backed work to Review, complete their native
+goal, then continue the mission loop with the next goal. They must not run
+\`atris task accept\` or claim AgentXP unless a human approved the proof.
+
 ## Workflow
 
 \`\`\`
@@ -625,6 +668,20 @@ BUILD → atris do     (execute tasks)
 CHECK → atris review (verify + cleanup)
 \`\`\`
 
+## Mission Autonomy
+
+Use \`atris mission\` when work should survive this chat or run as an autonomous loop.
+
+\`\`\`
+member -> mission start --verify -> status --status active -> one bounded step -> mission tick --verify -> receipt -> complete|run|stop
+\`\`\`
+
+- Start current-agent work: \`atris mission start "<objective>" --owner <member> --runner codex_goal --lane code --verify "<cmd>" --stop "<condition>"\`
+- Start headless Claude work: add \`--runner claude --cadence "15m" --always-on\`, then use \`atris mission run <id> --max-ticks 4 --complete-on-pass\`.
+- Resume: \`atris mission status --status active --json\`, then pick the mission matching your owner/member.
+- Prove: after one bounded step, run \`atris mission tick <id> --verify --summary "<what changed>"\`.
+- Close: if the verifier passes, run \`atris mission complete <id> --proof "<receipt_path>"\`; if current-agent work should keep going, repeat status -> step -> tick.
+
 ## Rules
 
 - [ ] 3-4 sentences max per response
@@ -632,8 +689,12 @@ CHECK → atris review (verify + cleanup)
 - [ ] Check MAP.md before touching code
 - [ ] Run \`atris task list\` or \`atris task next\` before picking work
 - [ ] Claim tasks with \`atris task claim <id> --as <agent>\`
-- [ ] Finish tasks with proof via \`atris task finish <id> --proof "..."\`
+- [ ] Move agent-completed work to Review via \`atris task ready <id> --proof "..."\`
+- [ ] Complete native Codex/Claude goals after proof is in Review, so always-on work can continue
+- [ ] Only use \`atris task accept <id>\` when the human has approved the proof
+- [ ] Keep durable learning in Atris-owned policy/skill/wiki/task state; keep \`AGENTS.md\` as a generated/pointer layer
 - [ ] Treat \`atris/TODO.md\` as a rendered view; do not manually use it as the source of truth
+- [ ] Use \`atris-labs\` for the Atris Labs business computer slug in docs and links
 
 ## Anti-patterns
 
@@ -670,6 +731,22 @@ CHECK → atris review (verify + cleanup)
     console.log('✓ Created AGENTS.md (for Codex)');
   }
 
+  // .devin/config.local.json for Devin for Terminal
+  const devinConfigDir = path.join(process.cwd(), '.devin');
+  const devinConfigFile = path.join(devinConfigDir, 'config.local.json');
+  if (!fs.existsSync(devinConfigFile)) {
+    fs.mkdirSync(devinConfigDir, { recursive: true });
+    const devinConfig = {
+      permissions: {
+        allow: [
+          'Exec(atris)',
+        ],
+      },
+    };
+    fs.writeFileSync(devinConfigFile, `${JSON.stringify(devinConfig, null, 2)}\n`);
+    console.log('✓ Created .devin/config.local.json (for Devin)');
+  }
+
   // .claude/commands/atris.md for Claude Code
   const claudeCommandsDir = path.join(process.cwd(), '.claude', 'commands');
   const claudeCommandFile = path.join(claudeCommandsDir, 'atris.md');
@@ -680,7 +757,7 @@ description: Activate Atris context - loads TODO.md, journal, and persona
 allowed-tools: Read, Bash, Glob, Grep
 ---
 
-Read @AGENTS.md then run \`atris\` command.
+Run \`atris\` and read \`atris/atris.md\`; @AGENTS.md is only a tool adapter.
 
 Follow the workflow: plan → do → review