atris 3.0.0 → 3.1.0

package/commands/business.js

@@ -1,7 +1,9 @@
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
+const { syncBusinessCanonical } = require('./sync');
 
 function getBusinessConfigPath() {
   const home = require('os').homedir();
@@ -20,6 +22,86 @@ function saveBusinesses(data) {
   fs.writeFileSync(getBusinessConfigPath(), JSON.stringify(data, null, 2));
 }
 
+function parseCreateBusinessFlags(flags, cwd = process.cwd()) {
+  const options = {
+    description: '',
+    template: null,
+    ownerEmail: '',
+    noLocal: false,
+    workspace: false,
+    here: false,
+    root: null,
+    cwd,
+  };
+
+  for (let i = 0; i < flags.length; i++) {
+    const flag = flags[i];
+    const next = flags[i + 1];
+
+    if ((flag === '--description' || flag === '-d') && next) {
+      options.description = next;
+      i++;
+    } else if ((flag === '--template' || flag === '-t') && next) {
+      options.template = next;
+      i++;
+    } else if (flag === '--owner-email' && next) {
+      options.ownerEmail = next;
+      i++;
+    } else if ((flag === '--root' || flag === '--workspace-root') && next) {
+      options.root = path.resolve(cwd, next);
+      options.workspace = true;
+      i++;
+    } else if (flag === '--here') {
+      options.here = true;
+      options.workspace = true;
+    } else if (flag === '--workspace' || flag === '--local-workspace') {
+      options.workspace = true;
+    } else if (flag === '--no-local') {
+      options.noLocal = true;
+    }
+  }
+
+  return options;
+}
+
+function resolveWorkspaceRoot(slug, options = {}) {
+  if (options.noLocal) return null;
+  if (options.here) return options.cwd || process.cwd();
+  if (options.root) return path.join(options.root, slug);
+  return path.join(os.homedir(), 'arena', 'atris-business', slug);
+}
+
+function createCanonicalBusinessWorkspace(targetRoot, bizMeta, options = {}) {
+  if (!targetRoot) {
+    throw new Error('No target directory provided for business workspace.');
+  }
+
+  if (options.here !== true && fs.existsSync(targetRoot) && !fs.statSync(targetRoot).isDirectory()) {
+    throw new Error(`Target path is not a directory: ${targetRoot}`);
+  }
+
+  fs.mkdirSync(targetRoot, { recursive: true });
+
+  const atrisMetaDir = path.join(targetRoot, '.atris');
+  const businessJsonPath = path.join(atrisMetaDir, 'business.json');
+  if (fs.existsSync(businessJsonPath)) {
+    throw new Error(`Target already contains .atris/business.json: ${targetRoot}`);
+  }
+
+  fs.mkdirSync(atrisMetaDir, { recursive: true });
+  fs.writeFileSync(businessJsonPath, JSON.stringify({
+    business_id: bizMeta.business_id,
+    workspace_id: bizMeta.workspace_id,
+    name: bizMeta.name,
+    slug: bizMeta.slug,
+    owner_email: bizMeta.owner_email || '',
+    created_at: new Date().toISOString(),
+  }, null, 2));
+
+  syncBusinessCanonical(targetRoot, bizMeta, { force: false, dryRun: false });
+  return { targetRoot, businessJsonPath };
+}
+
 function detectBusinessSlug(explicitSlug) {
   if (explicitSlug) return explicitSlug;
   const bizFile = path.join(process.cwd(), '.atris', 'business.json');
@@ -519,9 +601,9 @@ async function businessAudit() {
   console.log('');
 }
 
-async function createBusiness(name, ...flags) {
+async function createBusinessInternal(name, flags = [], mode = 'auto') {
   if (!name) {
-    console.error('Usage: atris business create <name> [--description "..."]');
+    console.error('Usage: atris business create <name> [--description "..."] [--workspace] [--here|--root <dir>]');
     process.exit(1);
   }
 
@@ -531,14 +613,8 @@ async function createBusiness(name, ...flags) {
     process.exit(1);
   }
 
-  // Parse flags
-  let description = '';
-  for (let i = 0; i < flags.length; i++) {
-    if ((flags[i] === '--description' || flags[i] === '-d') && flags[i + 1]) {
-      description = flags[i + 1];
-      i++;
-    }
-  }
+  const options = parseCreateBusinessFlags(flags);
+  const description = options.description;
 
   console.log(`Creating business: ${name}...`);
 
@@ -567,8 +643,15 @@ async function createBusiness(name, ...flags) {
   };
   saveBusinesses(businesses);
 
-  // Scaffold local directory if in an atris project
-  const atrisDir = findAtrisDir();
+  const shouldCreateCanonicalWorkspace = !options.noLocal && (
+    mode === 'canonical' ||
+    options.workspace ||
+    options.here ||
+    Boolean(options.root)
+  );
+
+  // Scaffold legacy local directory if in an atris project
+  const atrisDir = !shouldCreateCanonicalWorkspace ? findAtrisDir() : null;
   if (atrisDir) {
     const bizDir = path.join(atrisDir, 'business', biz.slug);
     if (!fs.existsSync(bizDir)) {
@@ -584,16 +667,21 @@ async function createBusiness(name, ...flags) {
       ].join(''));
       console.log(`  Local scaffold: ${bizDir}/`);
     }
-  }
-
-  // Apply template if specified
-  let template = null;
-  for (let i = 0; i < flags.length; i++) {
-    if ((flags[i] === '--template' || flags[i] === '-t') && flags[i + 1]) {
-      template = flags[i + 1];
-      i++;
-    }
-  }
+  } else if (shouldCreateCanonicalWorkspace) {
+    const workspaceRoot = resolveWorkspaceRoot(biz.slug, options);
+    const scaffold = createCanonicalBusinessWorkspace(workspaceRoot, {
+      business_id: biz.id,
+      workspace_id: biz.workspace_id,
+      name: biz.name,
+      slug: biz.slug,
+      owner_email: options.ownerEmail,
+    }, { here: options.here });
+    console.log(`  Local workspace: ${scaffold.targetRoot}/`);
+  } else if (!options.noLocal) {
+    console.log('  Tip: run `atris business init "<name>"` or add `--workspace` for a local canonical workspace.');
+  }
+
+  const template = options.template;
 
   if (template) {
     const templates = {
@@ -620,9 +708,22 @@ async function createBusiness(name, ...flags) {
   console.log(`  Slug:      ${biz.slug}`);
   console.log(`  Agent:     ${biz.agent_id || '(none)'}`);
   console.log(`  Dashboard: https://atris.ai/dashboard/gm/${biz.id}`);
+  if (shouldCreateCanonicalWorkspace) {
+    const workspaceRoot = resolveWorkspaceRoot(biz.slug, options);
+    console.log(`  Next:      cd ${workspaceRoot}`);
+    console.log('             atris align --fix');
+  }
   console.log('');
 }
 
+async function createBusiness(name, ...flags) {
+  return createBusinessInternal(name, flags, 'auto');
+}
+
+async function initBusinessWorkspace(name, ...flags) {
+  return createBusinessInternal(name, flags, 'canonical');
+}
+
 
 async function businessStatus(slug) {
   const creds = loadCredentials();
@@ -1046,18 +1147,18 @@ async function quickstart() {
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   1. Create:
-     atris business create "My Company" --template saas
+     atris business init "My Company" --template saas
 
-  2. Connect integrations:
-     atris business connect slack --business my-company
-     atris business connect github --business my-company
-
-  3. Deploy:
-     atris business deploy my-company
+  2. Open the local workspace:
+     cd ~/arena/atris-business/my-company
 
-  That's it. Your agents are live.
+  3. Push local state to cloud:
+     atris align --fix
 
   Optional:
+     atris business connect slack --business my-company
+     atris business connect github --business my-company
+
      atris business notify digest --business my-company
      (get 1 email/day instead of every notification)
 
@@ -1076,6 +1177,10 @@ async function businessCommand(subcommand, ...args) {
     case 'new':
       await createBusiness(args[0], ...args.slice(1));
       break;
+    case 'init':
+    case 'workspace':
+      await initBusinessWorkspace(args[0], ...args.slice(1));
+      break;
     case 'list':
     case 'ls': {
       const opts = {};
@@ -1130,7 +1235,9 @@ async function businessCommand(subcommand, ...args) {
       console.log('');
       console.log('  quickstart           ← Start here! 3-command guide');
       console.log('');
-      console.log('  create <name>        Create a new business (cloud + local)');
+      console.log('  init <name>          Create a canonical business workspace (cloud + local)');
+      console.log('  workspace <name>     Alias for init');
+      console.log('  create <name>        Create the cloud business; add --workspace for local canonical scaffold');
       console.log('  add <slug>           Register an existing cloud business');
       console.log('  list                 Show registered businesses');
       console.log('  team [slug]          Show members, roles, and admin access');
@@ -1144,4 +1251,14 @@ async function businessCommand(subcommand, ...args) {
   }
 }
 
-module.exports = { businessCommand, businessHealth, businessAudit, businessTeam, loadBusinesses, saveBusinesses, getBusinessConfigPath };
+module.exports = {
+  businessCommand,
+  businessHealth,
+  businessAudit,
+  businessTeam,
+  loadBusinesses,
+  saveBusinesses,
+  getBusinessConfigPath,
+  createCanonicalBusinessWorkspace,
+  initBusinessWorkspace,
+};

package/commands/sync.js

@@ -31,7 +31,9 @@ function _substituteParams(content, params) {
   return content
     .replace(/\{\{name\}\}/g, params.name || params.slug || 'this business')
     .replace(/\{\{slug\}\}/g, params.slug || 'business')
-    .replace(/\{\{owner_email\}\}/g, params.owner_email || '');
+    .replace(/\{\{owner_email\}\}/g, params.owner_email || '')
+    .replace(/\{\{business_id\}\}/g, params.business_id || '')
+    .replace(/\{\{workspace_id\}\}/g, params.workspace_id || '');
 }
 
 /**
@@ -41,14 +43,16 @@ function _substituteParams(content, params) {
  * Default: NEVER overwrites existing files (preserves customizations).
  * --force: overwrites existing canonical files (bumps to latest).
  */
-function syncBusinessCanonical(targetRoot, bizMeta) {
+function syncBusinessCanonical(targetRoot, bizMeta, options = {}) {
   const params = {
     slug: bizMeta.slug || 'business',
     name: bizMeta.name || bizMeta.slug || 'this business',
     owner_email: bizMeta.owner_email || '',
+    business_id: bizMeta.business_id || '',
+    workspace_id: bizMeta.workspace_id || '',
   };
-  const force = process.argv.includes('--force');
-  const dryRun = process.argv.includes('--dry-run');
+  const force = options.force != null ? options.force : process.argv.includes('--force');
+  const dryRun = options.dryRun != null ? options.dryRun : process.argv.includes('--dry-run');
   const targetAtrisDir = path.join(targetRoot, 'atris');
 
   if (!fs.existsSync(BUSINESS_TEMPLATE_DIR)) {
@@ -567,4 +571,4 @@ function syncSkills({ silent = false } = {}) {
   return updated;
 }
 
-module.exports = { syncAtris, syncSkills };
+module.exports = { syncAtris, syncSkills, syncBusinessCanonical };

package/lib/scorecard.js

@@ -0,0 +1,287 @@
+const fs = require('fs');
+const path = require('path');
+const { parseTodo } = require('./todo');
+
+function parsePickedAt(value) {
+  if (!value) return null;
+  const match = String(value).trim().match(/^(\d{4}-\d{2}-\d{2})(?:\s+(\d{2}:\d{2}))?/);
+  if (!match) return null;
+
+  const [, datePart, timePart = '00:00'] = match;
+  const parsed = new Date(`${datePart}T${timePart}:00`);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+
+function parseTickDate(dateStr, timeLabel) {
+  const match = String(timeLabel || '').trim().toLowerCase().match(/^(\d{1,2}):(\d{2})(?:\s*(am|pm))?$/);
+  if (!match) return null;
+
+  let hours = parseInt(match[1], 10);
+  const minutes = parseInt(match[2], 10);
+  const meridiem = match[3] || null;
+
+  if (meridiem === 'pm' && hours !== 12) hours += 12;
+  if (meridiem === 'am' && hours === 12) hours = 0;
+
+  const parsed = new Date(`${dateStr}T00:00:00`);
+  parsed.setHours(hours, minutes, 0, 0);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+
+function listLogFiles(atrisDir, startDate, endDate = new Date()) {
+  const logsDir = path.join(atrisDir, 'logs');
+  if (!fs.existsSync(logsDir)) return [];
+
+  const startKey = startDate.toISOString().slice(0, 10);
+  const endKey = endDate.toISOString().slice(0, 10);
+  const files = [];
+
+  for (const year of fs.readdirSync(logsDir)) {
+    const yearDir = path.join(logsDir, year);
+    let stat;
+    try {
+      stat = fs.statSync(yearDir);
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory()) continue;
+
+    for (const entry of fs.readdirSync(yearDir)) {
+      if (!entry.endsWith('.md')) continue;
+      const dateKey = entry.replace(/\.md$/, '');
+      if (dateKey < startKey || dateKey > endKey) continue;
+      files.push({ dateKey, file: path.join(yearDir, entry) });
+    }
+  }
+
+  files.sort((a, b) => a.dateKey.localeCompare(b.dateKey));
+  return files;
+}
+
+function readNotesSection(content) {
+  const match = String(content || '').match(/## Notes\n([\s\S]*?)(?=\n##\s|$)/);
+  return match ? match[1] : '';
+}
+
+function collectRewardStats(atrisDir, pickedAt) {
+  const startAt = parsePickedAt(pickedAt);
+  if (!startAt) {
+    return { totalReward: 0, totalTicks: 0, haltedTicks: 0 };
+  }
+
+  let totalReward = 0;
+  let totalTicks = 0;
+  let haltedTicks = 0;
+
+  for (const { dateKey, file } of listLogFiles(atrisDir, startAt)) {
+    const notes = readNotesSection(fs.readFileSync(file, 'utf8'));
+    if (!notes) continue;
+
+    const lines = notes.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      const headerMatch = lines[i].match(/^- (\d{1,2}:\d{2}(?:\s*[ap]m)?)$/i);
+      if (!headerMatch) continue;
+
+      const tickAt = parseTickDate(dateKey, headerMatch[1]);
+      if (!tickAt || tickAt < startAt) continue;
+
+      let reward = null;
+      let halted = false;
+      let j = i + 1;
+      for (; j < lines.length; j++) {
+        const current = lines[j];
+        if (j > i + 1 && /^- (\d{1,2}:\d{2}(?:\s*[ap]m)?)$/i.test(current)) break;
+        if (current && !current.startsWith('  ')) break;
+
+        const trimmed = current.trim();
+        if (!trimmed) continue;
+        if (/^Reward:\s*-?\d+$/i.test(trimmed)) {
+          reward = parseInt(trimmed.replace(/^Reward:\s*/i, ''), 10);
+        }
+        if (/review flagged issues|verify failed|hit an error|stopped for a manual check/i.test(trimmed)) {
+          halted = true;
+        }
+      }
+
+      if (reward !== null) {
+        totalReward += reward;
+        totalTicks += 1;
+        if (halted) haltedTicks += 1;
+      }
+
+      i = j - 1;
+    }
+  }
+
+  return { totalReward, totalTicks, haltedTicks };
+}
+
+function countLessonsGenerated(atrisDir, pickedAt) {
+  const startAt = parsePickedAt(pickedAt);
+  if (!startAt) return 0;
+
+  const lessonsPath = path.join(atrisDir, 'lessons.md');
+  if (!fs.existsSync(lessonsPath)) return 0;
+
+  const startDateKey = startAt.toISOString().slice(0, 10);
+  return fs.readFileSync(lessonsPath, 'utf8')
+    .split('\n')
+    .reduce((count, line) => {
+      const match = line.match(/^- \*\*\[(\d{4}-\d{2}-\d{2})\]/);
+      return match && match[1] >= startDateKey ? count + 1 : count;
+    }, 0);
+}
+
+function buildScorecardData(atrisDir, { slug, pickedAt } = {}) {
+  if (!slug) {
+    throw new Error('Scorecard: slug is required');
+  }
+
+  const todoPath = path.join(atrisDir, 'TODO.md');
+  const todo = parseTodo(todoPath);
+  const startAt = parsePickedAt(pickedAt) || new Date();
+  const rewardStats = collectRewardStats(atrisDir, pickedAt);
+  const completedEndgame = todo.completed.filter(t => t.tag === 'endgame').length;
+  const activeEndgame = todo.backlog.filter(t => t.tag === 'endgame').length
+    + todo.inProgress.filter(t => t.tag === 'endgame').length;
+
+  return {
+    slug,
+    startDate: startAt.toISOString().slice(0, 10),
+    endDate: new Date().toISOString().slice(0, 10),
+    tasksShipped: completedEndgame,
+    tasksAttempted: completedEndgame + activeEndgame,
+    wallClockHours: Math.max(0, (Date.now() - startAt.getTime()) / (1000 * 60 * 60)),
+    haltRatio: rewardStats.totalTicks > 0 ? rewardStats.haltedTicks / rewardStats.totalTicks : 0,
+    totalReward: rewardStats.totalReward,
+    lessonsGenerated: countLessonsGenerated(atrisDir, pickedAt),
+  };
+}
+
+/**
+ * Write a scorecard when an endgame closes.
+ *
+ * @param {string} atrisDir - Path to atris/ directory
+ * @param {object} data - Scorecard data
+ *   - slug: endgame slug (e.g., "loop-self-seeds-horizons")
+ *   - startDate: ISO date when endgame started
+ *   - endDate: ISO date when endgame ended (default: today)
+ *   - tasksShipped: number of tasks completed
+ *   - tasksAttempted: number of tasks started
+ *   - wallClockHours: total hours (float)
+ *   - haltRatio: fraction of ticks that halted (e.g., 0.1)
+ *   - totalReward: sum of per-tick reward scores
+ *   - lessonsGenerated: number of lessons appended to lessons.md
+ */
+function writeScorecard(atrisDir, data) {
+  const {
+    slug,
+    startDate,
+    endDate = new Date().toISOString().split('T')[0],
+    tasksShipped = 0,
+    tasksAttempted = 0,
+    wallClockHours = 0,
+    haltRatio = 0,
+    totalReward = 0,
+    lessonsGenerated = 0,
+  } = data;
+
+  // Validate required fields
+  if (!slug) {
+    throw new Error('Scorecard: slug is required');
+  }
+
+  const scorecardsPath = path.join(atrisDir, 'scorecards.md');
+
+  // Ensure scorecards.md exists
+  if (!fs.existsSync(scorecardsPath)) {
+    const template = `# scorecards.md — Endgame Results\n\n> Append-only. One line per closed endgame. Records outcome metrics from the horizon.\n\n---\n\n`;
+    fs.writeFileSync(scorecardsPath, template, 'utf8');
+  }
+
+  // Format: - **[date] slug** — shipped: X/Y — wall-clock: Nh — halt: Z% — reward: total — lessons: N
+  const haltPercent = Math.round(haltRatio * 100);
+  const wallClockStr = wallClockHours < 1 ? `${Math.round(wallClockHours * 60)}m` : `${wallClockHours.toFixed(1)}h`;
+  const line = `- **[${endDate}] ${slug}** — shipped: ${tasksShipped}/${tasksAttempted} — wall-clock: ${wallClockStr} — halt: ${haltPercent}% — reward: ${totalReward} — lessons: ${lessonsGenerated}\n`;
+
+  // Append to file
+  fs.appendFileSync(scorecardsPath, line, 'utf8');
+}
+
+/**
+ * Detect if the current endgame in TODO.md is complete (all endgame tasks in Completed).
+ * Returns { complete: boolean, endgameSlug: string | null }
+ */
+function detectEndgameCompletion(atrisDir) {
+  const todoPath = path.join(atrisDir, 'TODO.md');
+  if (!fs.existsSync(todoPath)) {
+    return { complete: false, endgameSlug: null };
+  }
+
+  const todo = parseTodo(todoPath);
+
+  // Find the current endgame section
+  const endgameSectionMatch = fs.readFileSync(todoPath, 'utf8')
+    .match(/## Endgame\n\n\*\*Slug:\*\*\s*(\S+)/);
+
+  if (!endgameSectionMatch) {
+    return { complete: false, endgameSlug: null };
+  }
+
+  const slug = endgameSectionMatch[1];
+
+  // Check if there are any endgame-tagged tasks in backlog or in-progress
+  const hasActiveEndgame = todo.backlog.some(t => t.tag === 'endgame')
+    || todo.inProgress.some(t => t.tag === 'endgame');
+
+  return {
+    complete: !hasActiveEndgame,
+    endgameSlug: slug,
+  };
+}
+
+/**
+ * Parse scorecards.md and return array of scorecard objects.
+ */
+function readScorecards(atrisDir) {
+  const scorecardsPath = path.join(atrisDir, 'scorecards.md');
+  if (!fs.existsSync(scorecardsPath)) return [];
+
+  const content = fs.readFileSync(scorecardsPath, 'utf8');
+  const scorecards = [];
+
+  for (const line of content.split('\n')) {
+    const match = line.match(/^- \*\*\[(.+?)\]\s+(.+?)\*\*\s*—\s*shipped:\s*(\d+)\/(\d+)\s*—\s*wall-clock:\s*(.+?)\s*—\s*halt:\s*(\d+)%\s*—\s*reward:\s*(\d+)\s*—\s*lessons:\s*(\d+)$/);
+    if (!match) continue;
+
+    const [, endDate, slug, shipped, attempted, wallClockStr, haltPercent, reward, lessons] = match;
+
+    // Parse wall-clock back to hours
+    let wallClockHours = 0;
+    if (wallClockStr.endsWith('h')) {
+      wallClockHours = parseFloat(wallClockStr);
+    } else if (wallClockStr.endsWith('m')) {
+      wallClockHours = parseInt(wallClockStr) / 60;
+    }
+
+    scorecards.push({
+      endDate,
+      slug,
+      tasksShipped: parseInt(shipped),
+      tasksAttempted: parseInt(attempted),
+      wallClockHours,
+      haltRatio: parseInt(haltPercent) / 100,
+      totalReward: parseInt(reward),
+      lessonsGenerated: parseInt(lessons),
+    });
+  }
+
+  return scorecards;
+}
+
+module.exports = {
+  buildScorecardData,
+  writeScorecard,
+  readScorecards,
+  detectEndgameCompletion,
+};

package/lib/todo.js

@@ -33,8 +33,8 @@ function parseSection(content, sectionName) {
     const line = rawLine.trimEnd();
 
     // New task line: - **T1:** Description or - **T1a:** Description [tag] [tag]
-    // Accepts task IDs like T1, W3b, M12c — single uppercase letter, digits, optional trailing lowercase letter.
-    const taskMatch = line.match(/^- \*\*([A-Z]\d+[a-z]?):\*\*\s*(.+)$/);
+    // Accepts task IDs like T1, W3b, M12c, R1, T#1 — letter(s), optional symbols, digits, optional trailing letter.
+    const taskMatch = line.match(/^- \*\*([A-Za-z][A-Za-z0-9#]*\d[a-z]?):\*\*\s*(.+)$/);
     if (taskMatch) {
       if (current) tasks.push(current);
       // Capture ALL bracketed tags in the line, not just the last one. Endgame is priority.
@@ -47,6 +47,7 @@ function parseSection(content, sectionName) {
         tags: allTags,
         claimed: null,
         stage: null,
+        verify: null,
       };
       continue;
     }
@@ -60,6 +61,7 @@ function parseSection(content, sectionName) {
         tag: null,
         claimed: null,
         stage: null,
+        verify: null,
       });
       continue;
     }
@@ -73,6 +75,7 @@ function parseSection(content, sectionName) {
         tag: null,
         claimed: null,
         stage: null,
+        verify: null,
       });
       continue;
     }
@@ -92,6 +95,13 @@ function parseSection(content, sectionName) {
       current.stage = stageMatch[1].trim();
       continue;
     }
+
+    // Verify line
+    const verifyMatch = line.match(/\*\*Verify:\*\*\s*(.+)$/) || line.match(/Verify:\s*(.+)$/);
+    if (verifyMatch) {
+      current.verify = verifyMatch[1].trim();
+      continue;
+    }
   }
 
   if (current) tasks.push(current);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "atris",
-  "version": "3.0.0",
-  "description": "Atris — the autonomous coding loop. Works with Claude Code, Cursor, Windsurf, Codex. Endgame-driven autopilot, plain-language output, self-improving substrate. Type one command in any folder, walk away, come back to shipped commits.",
+  "version": "3.1.0",
+  "description": "Atris — an operating system for intelligence. Integrates with any agent.",
   "main": "bin/atris.js",
   "bin": {
     "atris": "bin/atris.js"