atris 2.6.2 → 3.0.0

package/commands/soul.js

@@ -0,0 +1,381 @@
+/**
+ * Atris Soul — The persona as a living artifact
+ *
+ * Every atris project has a soul: persona + policies + learnings + context.
+ * This command lets you see it, evolve it, fork it.
+ *
+ *   atris soul              — Show your project's soul state
+ *   atris soul snapshot      — Export full soul to JSON
+ *   atris soul distill       — Compress learnings into persona
+ *   atris soul fork <target> — Copy soul to another project
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function findAtrisDir() {
+  let dir = process.cwd();
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, 'atris'))) return path.join(dir, 'atris');
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+function readFile(filePath) {
+  try { return fs.readFileSync(filePath, 'utf8'); } catch { return null; }
+}
+
+function readJson(filePath) {
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { return null; }
+}
+
+function countFiles(dir) {
+  try { return fs.readdirSync(dir, { recursive: true }).filter(f => !f.startsWith('.')).length; } catch { return 0; }
+}
+
+// ── Soul snapshot ──────────────────────────────────────
+
+function snapshotSoul(atrisDir) {
+  const soul = {
+    timestamp: new Date().toISOString(),
+    project: path.basename(path.dirname(atrisDir)),
+    identity: {},
+    knowledge: {},
+    learned: {},
+    stats: {},
+  };
+
+  // Identity
+  const persona = readFile(path.join(atrisDir, 'PERSONA.md'));
+  if (persona) soul.identity['PERSONA.md'] = persona;
+
+  const map = readFile(path.join(atrisDir, 'MAP.md'));
+  if (map) soul.identity['MAP.md'] = map;
+
+  // Team members
+  const teamDir = path.join(atrisDir, 'team');
+  if (fs.existsSync(teamDir)) {
+    const members = fs.readdirSync(teamDir).filter(f => {
+      const memberPath = path.join(teamDir, f, 'MEMBER.md');
+      return fs.existsSync(memberPath);
+    });
+    soul.identity.team = members;
+  }
+
+  // Knowledge — features
+  const featuresDir = path.join(atrisDir, 'features');
+  if (fs.existsSync(featuresDir)) {
+    const features = fs.readdirSync(featuresDir).filter(f => {
+      return !f.startsWith('_') && fs.existsSync(path.join(featuresDir, f, 'idea.md'));
+    });
+    soul.knowledge.features = features;
+    soul.knowledge.feature_count = features.length;
+  }
+
+  // Knowledge — research
+  const researchDir = path.join(atrisDir, 'research');
+  if (fs.existsSync(researchDir)) {
+    soul.knowledge.research_files = countFiles(researchDir);
+  }
+
+  // Knowledge — refs
+  const refsDir = path.join(atrisDir, 'refs');
+  if (fs.existsSync(refsDir)) {
+    soul.knowledge.refs = fs.readdirSync(refsDir).filter(f => f.endsWith('.md'));
+  }
+
+  // Learned — policies
+  const policiesDir = path.join(atrisDir, 'policies');
+  if (fs.existsSync(policiesDir)) {
+    soul.learned.policies = fs.readdirSync(policiesDir).filter(f => f.endsWith('.md'));
+  }
+
+  // Learned — logs (journal depth)
+  const logsDir = path.join(atrisDir, 'logs');
+  if (fs.existsSync(logsDir)) {
+    soul.learned.journal_entries = countFiles(logsDir);
+  }
+
+  // Learned — lessons
+  const lessons = readFile(path.join(atrisDir, 'lessons.md'));
+  if (lessons) {
+    const lessonCount = (lessons.match(/^-/gm) || []).length;
+    soul.learned.lessons = lessonCount;
+  }
+
+  // Stats
+  const todo = readFile(path.join(atrisDir, 'TODO.md'));
+  if (todo) {
+    const tasks = (todo.match(/^- /gm) || []).length;
+    soul.stats.open_tasks = tasks;
+  }
+
+  soul.stats.identity_files = Object.keys(soul.identity).length;
+  soul.stats.knowledge_items = (soul.knowledge.feature_count || 0) + (soul.knowledge.research_files || 0);
+  soul.stats.learned_items = (soul.learned.journal_entries || 0) + (soul.learned.lessons || 0);
+
+  return soul;
+}
+
+// ── Display ────────────────────────────────────────────
+
+function displaySoul(soul) {
+  const W = 50;
+  const line = '─'.repeat(W);
+
+  console.log(`\n  ┌${line}┐`);
+  console.log(`  │ ${'◉ SOUL — ' + soul.project}${' '.repeat(Math.max(0, W - 10 - soul.project.length))}│`);
+  console.log(`  ├${line}┤`);
+
+  // Identity
+  console.log(`  │ ${'IDENTITY'.padEnd(W - 1)}│`);
+  if (soul.identity['PERSONA.md']) {
+    const preview = soul.identity['PERSONA.md'].split('\n').find(l => l.trim() && !l.startsWith('#')) || '';
+    console.log(`  │   persona: ${preview.slice(0, W - 15).padEnd(W - 14)}│`);
+  }
+  if (soul.identity.team) {
+    console.log(`  │   team: ${soul.identity.team.length} members${' '.repeat(Math.max(0, W - 20 - String(soul.identity.team.length).length))}│`);
+  }
+
+  // Knowledge
+  console.log(`  │ ${'KNOWLEDGE'.padEnd(W - 1)}│`);
+  if (soul.knowledge.feature_count) {
+    console.log(`  │   features: ${soul.knowledge.feature_count}${' '.repeat(Math.max(0, W - 16 - String(soul.knowledge.feature_count).length))}│`);
+  }
+  if (soul.knowledge.research_files) {
+    console.log(`  │   research: ${soul.knowledge.research_files} files${' '.repeat(Math.max(0, W - 22 - String(soul.knowledge.research_files).length))}│`);
+  }
+
+  // Learned
+  console.log(`  │ ${'LEARNED'.padEnd(W - 1)}│`);
+  if (soul.learned.journal_entries) {
+    console.log(`  │   journal: ${soul.learned.journal_entries} entries${' '.repeat(Math.max(0, W - 23 - String(soul.learned.journal_entries).length))}│`);
+  }
+  if (soul.learned.lessons) {
+    console.log(`  │   lessons: ${soul.learned.lessons}${' '.repeat(Math.max(0, W - 15 - String(soul.learned.lessons).length))}│`);
+  }
+  if (soul.learned.policies) {
+    console.log(`  │   policies: ${soul.learned.policies.length}${' '.repeat(Math.max(0, W - 16 - String(soul.learned.policies.length).length))}│`);
+  }
+
+  console.log(`  └${line}┘\n`);
+}
+
+// ── Fork ───────────────────────────────────────────────
+
+function forkSoul(sourceDir, targetDir) {
+  const toCopy = [
+    'PERSONA.md',
+    'policies',
+    'refs',
+  ];
+
+  let copied = 0;
+  for (const item of toCopy) {
+    const src = path.join(sourceDir, item);
+    const dst = path.join(targetDir, item);
+    if (!fs.existsSync(src)) continue;
+
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      fs.mkdirSync(dst, { recursive: true });
+      for (const f of fs.readdirSync(src)) {
+        fs.copyFileSync(path.join(src, f), path.join(dst, f));
+        copied++;
+      }
+    } else {
+      fs.copyFileSync(src, dst);
+      copied++;
+    }
+  }
+
+  // Write genealogy
+  const genealogy = {
+    forked_from: path.basename(path.dirname(sourceDir)),
+    forked_at: new Date().toISOString(),
+    files_copied: copied,
+  };
+  fs.writeFileSync(path.join(targetDir, 'genealogy.json'), JSON.stringify(genealogy, null, 2));
+
+  return { copied, genealogy };
+}
+
+// ── Distill ────────────────────────────────────────────
+
+function distillSoul(atrisDir) {
+  const personaPath = path.join(atrisDir, 'PERSONA.md');
+  const lessonsPath = path.join(atrisDir, 'lessons.md');
+  const policiesDir = path.join(atrisDir, 'policies');
+
+  // Gather learnings
+  const lessons = readFile(lessonsPath);
+  const persona = readFile(personaPath);
+
+  let policyRules = [];
+  if (fs.existsSync(policiesDir)) {
+    for (const f of fs.readdirSync(policiesDir).filter(f => f.endsWith('.md'))) {
+      const content = readFile(path.join(policiesDir, f));
+      if (content) {
+        // Extract bullet points as rules
+        const bullets = content.match(/^[-*]\s+.+$/gm) || [];
+        policyRules.push(...bullets.map(b => b.replace(/^[-*]\s+/, '').trim()));
+      }
+    }
+  }
+
+  // Extract lesson patterns
+  let lessonItems = [];
+  if (lessons) {
+    lessonItems = (lessons.match(/^[-*]\s+.+$/gm) || []).map(l => l.replace(/^[-*]\s+/, '').trim());
+  }
+
+  // Count journal entries for depth stat
+  const logsDir = path.join(atrisDir, 'logs');
+  let journalCount = 0;
+  if (fs.existsSync(logsDir)) {
+    journalCount = countFiles(logsDir);
+  }
+
+  // Build distilled section
+  const distilled = [];
+  if (lessonItems.length > 0) {
+    distilled.push('## Learned (distilled from lessons.md)');
+    distilled.push('');
+    // Deduplicate and take top 10 by recency (last in list = most recent)
+    const unique = [...new Set(lessonItems)].slice(-10);
+    for (const item of unique) {
+      distilled.push(`- ${item}`);
+    }
+    distilled.push('');
+  }
+
+  if (policyRules.length > 0) {
+    distilled.push('## Policies (distilled from policies/)');
+    distilled.push('');
+    const unique = [...new Set(policyRules)].slice(0, 10);
+    for (const rule of unique) {
+      distilled.push(`- ${rule}`);
+    }
+    distilled.push('');
+  }
+
+  if (distilled.length === 0) {
+    return { status: 'nothing', reason: 'No lessons or policies to distill' };
+  }
+
+  // Archive current persona
+  if (persona) {
+    const archiveDir = path.join(atrisDir, 'persona-history');
+    if (!fs.existsSync(archiveDir)) fs.mkdirSync(archiveDir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    fs.writeFileSync(path.join(archiveDir, `${ts}.md`), persona);
+  }
+
+  // Append distilled section to persona
+  const separator = '\n\n---\n\n';
+  const distilledBlock = `<!-- Distilled ${new Date().toISOString().slice(0, 10)} | ${journalCount} journal entries, ${lessonItems.length} lessons, ${policyRules.length} policy rules -->\n\n` + distilled.join('\n');
+
+  if (persona) {
+    // Check if already has a distilled section, replace it
+    if (persona.includes('<!-- Distilled')) {
+      const updated = persona.replace(/<!-- Distilled[\s\S]*$/, distilledBlock);
+      fs.writeFileSync(personaPath, updated);
+    } else {
+      fs.appendFileSync(personaPath, separator + distilledBlock);
+    }
+  } else {
+    fs.writeFileSync(personaPath, `# Persona\n\n${distilledBlock}`);
+  }
+
+  return {
+    status: 'distilled',
+    lessons: lessonItems.length,
+    policies: policyRules.length,
+    archived: !!persona,
+  };
+}
+
+// ── Main ───────────────────────────────────────────────
+
+async function soul(args = []) {
+  const subcommand = (args[0] || 'status').toLowerCase();
+  const atrisDir = findAtrisDir();
+
+  if (!atrisDir) {
+    console.error('✗ No atris/ folder found. Run "atris init" first.');
+    process.exit(1);
+  }
+
+  if (subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+    console.log('');
+    console.log('  atris soul — see what your project has learned');
+    console.log('');
+    console.log('  soul              show identity, knowledge, learnings');
+    console.log('  soul snapshot     export full soul to JSON (auto-gitignored)');
+    console.log('  soul distill      compress lessons + policies into PERSONA.md');
+    console.log('  soul fork <path>  copy persona + policies to another project');
+    console.log('');
+    return;
+  }
+
+  switch (subcommand) {
+    case 'status':
+    case 'st': {
+      const s = snapshotSoul(atrisDir);
+      displaySoul(s);
+      break;
+    }
+    case 'snapshot':
+    case 'export': {
+      const s = snapshotSoul(atrisDir);
+      const outPath = path.join(atrisDir, 'soul-snapshot.json');
+      fs.writeFileSync(outPath, JSON.stringify(s, null, 2));
+      // Auto-add to .gitignore so it never gets committed
+      const gitignorePath = path.join(path.dirname(atrisDir), '.gitignore');
+      try {
+        const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf8') : '';
+        if (!existing.includes('soul-snapshot.json')) {
+          fs.appendFileSync(gitignorePath, '\n# Atris soul — private, never commit\natris/soul-snapshot.json\n');
+        }
+      } catch {}
+      console.log(`✓ Soul snapshot saved to ${outPath}`);
+      console.log(`  (auto-added to .gitignore — this stays private)`);
+      break;
+    }
+    case 'fork': {
+      const target = args[1];
+      if (!target) {
+        console.error('Usage: atris soul fork <target-project-path>');
+        return;
+      }
+      const targetAtris = path.join(target, 'atris');
+      if (!fs.existsSync(targetAtris)) {
+        console.error(`✗ Target ${targetAtris} not found. Run "atris init" in that project first.`);
+        return;
+      }
+      const result = forkSoul(atrisDir, targetAtris);
+      console.log(`✓ Soul forked: ${result.copied} files copied`);
+      console.log(`  From: ${path.basename(path.dirname(atrisDir))}`);
+      console.log(`  To:   ${path.basename(target)}`);
+      break;
+    }
+    case 'distill':
+    case 'compress': {
+      const result = distillSoul(atrisDir);
+      if (result.status === 'nothing') {
+        console.log(`✗ ${result.reason}`);
+      } else {
+        console.log(`✓ Soul distilled`);
+        console.log(`  ${result.lessons} lessons + ${result.policies} policy rules → PERSONA.md`);
+        if (result.archived) console.log(`  Previous persona archived to persona-history/`);
+      }
+      break;
+    }
+    default:
+      const s = snapshotSoul(atrisDir);
+      displaySoul(s);
+  }
+}
+
+module.exports = { soul, snapshotSoul };

package/commands/status.js

@@ -12,7 +12,71 @@ const pad = (str, w = W) => {
   return len >= w ? str : str + ' '.repeat(w - len);
 };
 
-function statusAtris(isQuick = false, jsonMode = false) {
+function wrapText(text, width = 74) {
+  const normalized = String(text || '').replace(/\s+/g, ' ').trim();
+  if (!normalized) return [''];
+
+  const words = normalized.split(' ');
+  const lines = [];
+  let current = '';
+
+  for (const word of words) {
+    if (!current) {
+      current = word;
+      continue;
+    }
+    if ((current + ' ' + word).length <= width) {
+      current += ' ' + word;
+    } else {
+      lines.push(current);
+      current = word;
+    }
+  }
+
+  if (current) lines.push(current);
+  return lines;
+}
+
+function compactWrappedText(text, width = 74, maxLines = 2) {
+  const lines = wrapText(text, width);
+  if (lines.length <= maxLines) return lines;
+
+  const kept = lines.slice(0, maxLines);
+  const head = kept.slice(0, -1);
+  let tail = kept[kept.length - 1].replace(/[ .,;:!?-]+$/, '');
+  if (tail.length >= width) {
+    tail = tail.slice(0, width - 1).replace(/[ .,;:!?-]+$/, '');
+  }
+  return [...head, `${tail}…`];
+}
+
+function printHumanSection(title, body) {
+  console.log(`  ${title}`);
+  const sourceLines = Array.isArray(body) ? body : String(body || '').split('\n');
+  for (const sourceLine of sourceLines) {
+    if (!sourceLine) {
+      console.log('  ');
+      continue;
+    }
+    for (const line of wrapText(sourceLine)) {
+      console.log(`  ${line}`);
+    }
+  }
+  console.log('');
+}
+
+function readEndgameMeta(todoFile) {
+  if (!fs.existsSync(todoFile)) return { slug: null, horizon: null };
+  const todoContent = fs.readFileSync(todoFile, 'utf8');
+  const endgameMatch = todoContent.match(/##\s+Endgame\s*\n([\s\S]*?)(?=\n##|$)/);
+  if (!endgameMatch) return { slug: null, horizon: null };
+
+  const slug = endgameMatch[1].match(/\*\*Slug:\*\*\s*(.+)/)?.[1]?.trim() || null;
+  const horizon = endgameMatch[1].match(/\*\*Horizon:\*\*\s*(.+)/)?.[1]?.trim() || null;
+  return { slug, horizon };
+}
+
+function statusAtris(isQuick = false, jsonMode = false, verbose = false) {
   const targetDir = path.join(process.cwd(), 'atris');
 
   if (!fs.existsSync(targetDir)) {
@@ -114,6 +178,60 @@ function statusAtris(isQuick = false, jsonMode = false) {
     return;
   }
 
+  if (!verbose) {
+    const endgame = readEndgameMeta(todoFile);
+    const where = [];
+    if (endgame.slug) {
+      where.push(`The active horizon is ${endgame.slug}.`);
+      if (endgame.horizon) {
+        where.push(...compactWrappedText(endgame.horizon, 74, 2));
+      }
+    } else {
+      where.push('No active endgame is set.');
+    }
+    where.push(`There are ${todo.inProgress.length} tasks in progress, ${todo.backlog.length} queued, and ${todo.completed.length} completed items still sitting in TODO.`);
+
+    const queueParts = [];
+    if (todo.inProgress[0]) {
+      queueParts.push(...compactWrappedText(`In progress: ${todo.inProgress[0].title}.`, 74, 2));
+    } else {
+      queueParts.push('In progress: none.');
+    }
+    if (todo.backlog[0]) {
+      queueParts.push(...compactWrappedText(`Next backlog item: ${todo.backlog[0].title}.`, 74, 2));
+    } else {
+      queueParts.push('Next backlog item: none.');
+    }
+    queueParts.push(inboxItems.length > 0
+      ? `Inbox has ${inboxItems.length} item${inboxItems.length === 1 ? '' : 's'}.`
+      : 'Inbox is empty.');
+
+    const blockingParts = [];
+    if (todo.completed.length > 0) {
+      blockingParts.push(`Main drag: ${todo.completed.length} completed item${todo.completed.length === 1 ? '' : 's'} should be cleared from TODO.`);
+    } else {
+      blockingParts.push('No cleanup debt is visible in TODO.');
+    }
+    if (todo.inProgress.length === 0 && todo.backlog.length === 0 && inboxItems.length === 0) {
+      blockingParts.push('No active blocker is visible right now.');
+    } else if (teamActivity.length === 0) {
+      blockingParts.push('No team activity is logged yet today.');
+    } else {
+      blockingParts.push(`Team activity has ${teamActivity.length} recent signal${teamActivity.length === 1 ? '' : 's'}.`);
+    }
+    blockingParts.push(
+      todo.completed.length > 0
+        ? 'Decision: let it run unless you want cleanup debt handled first.'
+        : 'Decision: let it run.'
+    );
+
+    console.log('');
+    printHumanSection('Where we are:', where);
+    printHumanSection('What is queued:', queueParts);
+    printHumanSection('What is blocking:', blockingParts);
+    return;
+  }
+
   // ─── FULL VISUAL STATUS ────────────────────────────────────
   const o = (s) => console.log(s);
 

package/commands/sync.js

@@ -1,8 +1,142 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { ensureWikiScaffold } = require('../lib/wiki');
+
+const BUSINESS_TEMPLATE_DIR = path.join(__dirname, '..', 'templates', 'business-canonical');
+
+/**
+ * Walk a directory and return relative file paths.
+ */
+function _walkTemplateDir(dir, base = dir) {
+  const out = [];
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
+  catch { return out; }
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) {
+      out.push(..._walkTemplateDir(full, base));
+    } else if (e.isFile()) {
+      out.push(path.relative(base, full));
+    }
+  }
+  return out;
+}
+
+/**
+ * Substitute {{name}}, {{slug}}, {{owner_email}} in template content.
+ */
+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 || '');
+}
+
+/**
+ * Sync canonical business template files into a business workspace.
+ * Used when .atris/business.json is present (business mode).
+ *
+ * Default: NEVER overwrites existing files (preserves customizations).
+ * --force: overwrites existing canonical files (bumps to latest).
+ */
+function syncBusinessCanonical(targetRoot, bizMeta) {
+  const params = {
+    slug: bizMeta.slug || 'business',
+    name: bizMeta.name || bizMeta.slug || 'this business',
+    owner_email: bizMeta.owner_email || '',
+  };
+  const force = process.argv.includes('--force');
+  const dryRun = process.argv.includes('--dry-run');
+  const targetAtrisDir = path.join(targetRoot, 'atris');
+
+  if (!fs.existsSync(BUSINESS_TEMPLATE_DIR)) {
+    console.error(`✗ Canonical template directory not found: ${BUSINESS_TEMPLATE_DIR}`);
+    console.error('  Your atris-cli installation may be incomplete.');
+    process.exit(1);
+  }
+
+  console.log('');
+  console.log(`Updating ${params.name} (${params.slug}) from canonical templates...`);
+  console.log(`  Target: ${targetAtrisDir}/`);
+  console.log(`  Source: ${BUSINESS_TEMPLATE_DIR}`);
+  console.log('');
+
+  const templateFiles = _walkTemplateDir(BUSINESS_TEMPLATE_DIR).sort();
+  let added = 0, updated = 0, skipped = 0, preserved = 0;
+  const addedList = [], updatedList = [], preservedList = [];
+
+  for (const relPath of templateFiles) {
+    const templatePath = path.join(BUSINESS_TEMPLATE_DIR, relPath);
+    const targetPath = path.join(targetAtrisDir, relPath);
+    let templateContent;
+    try { templateContent = fs.readFileSync(templatePath, 'utf-8'); } catch { continue; }
+    const finalContent = _substituteParams(templateContent, params);
+
+    if (!fs.existsSync(targetPath)) {
+      addedList.push(relPath); added++;
+      if (!dryRun) {
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        fs.writeFileSync(targetPath, finalContent);
+      }
+    } else {
+      const existing = fs.readFileSync(targetPath, 'utf-8');
+      if (existing === finalContent) {
+        skipped++;
+      } else if (force) {
+        updatedList.push(relPath); updated++;
+        if (!dryRun) fs.writeFileSync(targetPath, finalContent);
+      } else {
+        preservedList.push(relPath); preserved++;
+      }
+    }
+  }
+
+  console.log(`  Added:     ${added}`);
+  console.log(`  Updated:   ${updated} ${force ? '' : '(--force to enable)'}`);
+  console.log(`  Preserved: ${preserved} (existing customizations kept)`);
+  console.log(`  Skipped:   ${skipped} (already match template)`);
+  console.log('');
+
+  if (addedList.length > 0) {
+    console.log('  New files:');
+    addedList.slice(0, 15).forEach(p => console.log(`    + atris/${p}`));
+    if (addedList.length > 15) console.log(`    ... +${addedList.length - 15} more`);
+    console.log('');
+  }
+  if (updatedList.length > 0) {
+    console.log(`  ${force ? 'Updated' : 'Differ from template (preserved)'}:`);
+    updatedList.slice(0, 15).forEach(p => console.log(`    ↑ atris/${p}`));
+    if (updatedList.length > 15) console.log(`    ... +${updatedList.length - 15} more`);
+    console.log('');
+  }
+
+  if (dryRun) {
+    console.log('  (--dry-run, no changes made)');
+  } else if (added === 0 && updated === 0) {
+    ensureWikiScaffold(targetRoot);
+    console.log('  ✓ Already up to date');
+  } else {
+    ensureWikiScaffold(targetRoot);
+    console.log(`  ✓ Local workspace updated. Run \`atris align ${params.slug} --fix\` to push to EC2.`);
+  }
+}
 
 function syncAtris() {
+  // Business mode detection: if .atris/business.json exists, use canonical templates
+  const bizFile = path.join(process.cwd(), '.atris', 'business.json');
+  if (fs.existsSync(bizFile)) {
+    try {
+      const bizMeta = JSON.parse(fs.readFileSync(bizFile, 'utf8'));
+      return syncBusinessCanonical(process.cwd(), bizMeta);
+    } catch (e) {
+      console.error(`✗ Failed to read .atris/business.json: ${e.message}`);
+      process.exit(1);
+    }
+  }
+
+  // Legacy/dev mode: sync from atris-cli's own atris/ folder
   const targetDir = path.join(process.cwd(), 'atris');
   const teamDir = path.join(targetDir, 'team');
   const legacyAgentTeamDir = path.join(targetDir, 'agent_team');
@@ -297,8 +431,10 @@ After displaying the boot output, respond to the user naturally.
   }
 
   if (updated === 0) {
+    ensureWikiScaffold(process.cwd());
     console.log('✓ Already up to date');
   } else {
+    ensureWikiScaffold(process.cwd());
     console.log(`\n✓ Updated ${updated} file(s), ${skipped} unchanged`);
     console.log('\nRun your AI agent again to use the latest specs and agent templates.');
   }
@@ -378,7 +514,17 @@ function syncSkills({ silent = false } = {}) {
     }
   }
 
-  // --- 2. Project-level (only if inside an atris project) ---
+  // --- 2. Project-level (only if inside an atris project AND not a business workspace) ---
+  // BUSINESS GATE: don't sync framework skills into business workspaces.
+  // Per the canonical-layout decision, framework skills (autopilot, wiki, loop, etc.) live
+  // at the system level on EC2, NOT inside per-business workspaces. Customer workspaces
+  // contain ONLY business-specific custom skills in atris/skills/.
+  const businessJson = path.join(process.cwd(), '.atris', 'business.json');
+  if (fs.existsSync(businessJson)) {
+    // We're inside a business workspace — skip project-level skill sync.
+    return updated;
+  }
+
   const targetDir = path.join(process.cwd(), 'atris');
   if (fs.existsSync(targetDir)) {
     const userSkillsDir = path.join(targetDir, 'skills');