atris 3.30.1 → 3.30.3

package/bin/atris.js

@@ -369,6 +369,7 @@ function showHelp() {
   console.log('  activate   - Load Atris context');
   console.log('  radar      - Show live agents joined with tasks, missions, and worktrees');
   console.log('  ctop       - Show a process-first live agent CPU/memory view');
+  console.log('  launchpad  - Show the next action from local brain, task, mission, and proof state');
   console.log('  status     - See local work and completions (`atris status <business>` for remote)');
   console.log('  recap      - What your AI team did, in plain English (--share for paste-ready)');
   console.log('  xp         - Show Career XP and contribution graph');
@@ -820,7 +821,7 @@ if (command === '2' && ['fast', 'pro'].includes(String(firstCommandArg || '').to
 }
 
 // Check if this is a known command or natural language input
-const knownCommands = ['init', 'log', 'now', 'radar', 'ctop', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
+const knownCommands = ['init', 'log', 'now', 'radar', 'ctop', 'launchpad', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'verify', 'search', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'plugin', 'experiments', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube',
                        'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'probe', 'worktree', 'aeo', 'slop', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'xp', 'play', 'gm', 'x', 'recap', 'signup', 'clarity', 'moves',
@@ -1702,6 +1703,9 @@ if (command === 'init') {
       console.error(`\u2717 Run failed: ${error.message || error}`);
       process.exit(1);
     });
+} else if (command === 'launchpad') {
+  const code = require('../commands/launchpad').launchpadCommand(process.argv.slice(3));
+  process.exit(code);
 } else if (command === 'autopilot') {
   const args = process.argv.slice(3);
   if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {

package/commands/agent-spawn.js

@@ -350,9 +350,9 @@ function writeDogfoodReceipt(root, receipt) {
 }
 
 function showDogfoodHelp(output = console.log) {
-  output('Usage: atris agent dogfood [devin|droid|--engine all] [--model glm-5.2] [--live] [--json]');
+  output('Internal usage: atris agent dogfood [devin|droid|--engine all] [--model glm-5.2] [--live] [--json]');
   output('');
-  output('Cheaply verifies external coding CLIs without a model call by default.');
+  output('Internal support smoke for external coding CLIs; hidden from public agent help.');
   output('Add --live to run one exact sentinel prompt through Devin/Droid.');
 }
 

package/commands/brain.js

@@ -13,6 +13,9 @@ const GENERATED_LOAD_ORDER_FILES = [
   'atris/brain/STATUS.md',
   'atris/brain/self_improvement_ledger.md',
 ];
+const OPTIONAL_STATE_LOAD_ORDER_FILES = [
+  '.atris/state/chat_scan.latest.json',
+];
 const OPTIONAL_LOAD_ORDER_FILES = [
   'atris/wiki/concepts/agent-activation-contract.md',
   'atris/skills/atris/SKILL.md',
@@ -1128,10 +1131,68 @@ function taskEpisodeScorecard(root, episode, workspace, ts = new Date().toISOStr
     lesson: episode.lesson || '',
     proof: episode.proof || '',
     next_task_suggestion: episode.next_task_suggestion || null,
+    review_landing: episode.review_landing || null,
+    landing_quality: episode.landing_quality || null,
+    human_feedback: episode.human_feedback || null,
+    approval_status: episode.human_feedback && episode.human_feedback.approval_status || episode.rl && episode.rl.approval_status || null,
+    rl_label: episode.rl && episode.rl.label || null,
     episode_created_at: episode.created_at || episode.ts || null,
   };
 }
 
+function landingQualityFromReviewLanding(landing) {
+  const normalized = {
+    happened: landing && landing.happened || null,
+    checked: landing && landing.checked || null,
+    tested: landing && landing.tested || null,
+    decision: landing && landing.decision || null,
+  };
+  const present = Object.entries(normalized)
+    .filter(([, value]) => Boolean(value))
+    .map(([key]) => key);
+  const missing = Object.keys(normalized).filter(key => !normalized[key]);
+  return {
+    present,
+    missing,
+    completeness: present.length / Object.keys(normalized).length,
+    has_decision: Boolean(normalized.decision),
+  };
+}
+
+function taskProjectionByEpisodeId(root) {
+  const tasks = readTaskProjectionTasks(root) || [];
+  const byId = new Map();
+  for (const task of tasks) {
+    for (const key of [task.id, task.display_id, task.legacy_ref, task.ref].filter(Boolean)) {
+      byId.set(String(key), task);
+    }
+  }
+  return byId;
+}
+
+function enrichTaskEpisodeFromProjection(episode, taskById) {
+  if (episode.review_landing) return episode;
+  const task = taskById.get(String(episode.task_id || ''));
+  const landing = task?.review?.landing || null;
+  if (!landing) return episode;
+  const approvalStatus = task?.review?.approval_status || episode.human_feedback?.approval_status || episode.rl?.approval_status || null;
+  return {
+    ...episode,
+    review_landing: landing,
+    landing_quality: episode.landing_quality || landingQualityFromReviewLanding(landing),
+    human_feedback: episode.human_feedback || {
+      approval_status: approvalStatus,
+      human_revision_count: Number(task?.review?.human_revision_count || 0),
+      human_revision_note: task?.review?.human_revision_note || null,
+    },
+    rl: episode.rl ? {
+      ...episode.rl,
+      landing_completeness: episode.rl.landing_completeness ?? landingQualityFromReviewLanding(landing).completeness,
+      approval_status: episode.rl.approval_status || approvalStatus,
+    } : episode.rl,
+  };
+}
+
 function latestTaskEpisodes(taskEpisodes) {
   const byTask = new Map();
   for (const episode of taskEpisodes) {
@@ -1154,19 +1215,31 @@ function recordTaskEpisodeScorecards(options) {
     {};
   const taskEpisodes = stateDirs.flatMap(item => readJsonlRows(path.join(item, 'task_episodes.jsonl')))
     .filter(row => row && row.schema === 'atris.task_episode.v1');
-  const scoreableEpisodes = latestTaskEpisodes(taskEpisodes);
+  const taskById = taskProjectionByEpisodeId(stateRoot);
+  if (stateRoot !== root) {
+    for (const [key, task] of taskProjectionByEpisodeId(root)) taskById.set(key, task);
+  }
+  const scoreableEpisodes = latestTaskEpisodes(taskEpisodes)
+    .map(episode => enrichTaskEpisodeFromProjection(episode, taskById));
   const existing = stateDirs.flatMap(item => readJsonlRows(path.join(item, 'scorecards.jsonl')));
-  const seenEpisodeIds = new Set(existing
-    .map(row => row.source_episode_id)
-    .filter(Boolean));
+  const existingByEpisodeId = new Map();
+  for (const row of existing) {
+    if (!row.source_episode_id) continue;
+    const rows = existingByEpisodeId.get(row.source_episode_id) || [];
+    rows.push(row);
+    existingByEpisodeId.set(row.source_episode_id, rows);
+  }
 
   const written = [];
   for (const episode of scoreableEpisodes) {
     const episodeId = episode.episode_id;
-    if (seenEpisodeIds.has(episodeId)) continue;
     const scorecard = taskEpisodeScorecard(root, episode, workspace);
+    const existingRows = existingByEpisodeId.get(episodeId) || [];
+    const existingHasLanding = existingRows.some(row => row.review_landing);
+    if (existingRows.length && (!scorecard.review_landing || existingHasLanding)) continue;
     appendJsonl(scorecardsPath, scorecard);
-    seenEpisodeIds.add(episodeId);
+    existingRows.push(scorecard);
+    existingByEpisodeId.set(episodeId, existingRows);
     written.push(scorecard);
   }
 
@@ -1212,9 +1285,21 @@ function verifyApproval(root, approvalId) {
 
 function brainLoadOrderFiles(state) {
   const root = state.root;
+  const lookupRoots = [root, ...(state.stateRoots || []), state.stateRoot]
+    .filter(Boolean)
+    .map(item => path.resolve(item));
+  const seen = new Set();
+  const uniqueRoots = lookupRoots.filter(item => {
+    if (seen.has(item)) return false;
+    seen.add(item);
+    return true;
+  });
+  const loadOrderFileExists = rel => uniqueRoots.some(base => fs.existsSync(path.join(base, rel)));
+  const existingState = OPTIONAL_STATE_LOAD_ORDER_FILES
+    .filter(loadOrderFileExists);
   const existing = OPTIONAL_LOAD_ORDER_FILES
     .filter(rel => fs.existsSync(path.join(root, rel)));
-  return [...GENERATED_LOAD_ORDER_FILES, ...existing];
+  return [...GENERATED_LOAD_ORDER_FILES, ...existingState, ...existing];
 }
 
 function renderNumberedLoadOrder(state) {

package/commands/brainstorm.js

@@ -321,29 +321,43 @@ async function brainstormAtris() {
       const nextSteps = nextStepsRaw
         ? nextStepsRaw.split(';').map((item) => item.trim()).filter(Boolean)
         : [];
-      recordBrainstormSession(
-        logFile,
-        sourceLabel,
-        topicSummary,
-        userStory,
-        [],
-        [],
-        constraints,
-        '',
-        feelingsVibe || '',
-        nextSteps,
-        sessionSummary
-      );
-      if (selectedInboxItem) {
-        const archive = await askYesNo('Archive this Inbox idea now? (y/n): ');
-        if (archive) {
-          let latestContent = fs.readFileSync(logFile, 'utf8');
-          latestContent = removeInboxItemFromContent(latestContent, selectedInboxItem.id);
-          fs.writeFileSync(logFile, latestContent);
-          console.log(`✓ Archived I${selectedInboxItem.id} from Inbox.`);
+      try {
+        recordBrainstormSession(
+          logFile,
+          sourceLabel,
+          topicSummary,
+          userStory,
+          [],
+          [],
+          constraints,
+          '',
+          feelingsVibe || '',
+          nextSteps,
+          sessionSummary
+        );
+        if (selectedInboxItem) {
+          const archive = await askYesNo('Archive this Inbox idea now? (y/n): ');
+          if (archive) {
+            try {
+              let latestContent = fs.readFileSync(logFile, 'utf8');
+              latestContent = removeInboxItemFromContent(latestContent, selectedInboxItem.id);
+              if (typeof latestContent !== 'string') {
+                throw new Error('Archive operation produced invalid journal content.');
+              }
+              writeJournalFile(logFile, latestContent);
+              console.log(`✓ Archived I${selectedInboxItem.id} from Inbox.`);
+            } catch (error) {
+              console.log(`Could not archive I${selectedInboxItem.id}: ${error.message}`);
+            }
+          }
+        }
+        console.log('✓ Brainstorm session logged.');
+      } catch (error) {
+        if (error && error.__brainstormAbort) {
+          throw error;
         }
+        console.log(`Could not log brainstorm session: ${error.message}`);
       }
-      console.log('✓ Brainstorm session logged.');
     } else {
       console.log('Skipped journaling. Prompt is ready for your agent.');
     }
@@ -365,6 +379,32 @@ function removeInboxItemFromContent(content, id) {
   return replaceInboxSection(content, items);
 }
 
+function writeJournalFile(logFile, content) {
+  if (typeof logFile !== 'string' || logFile.trim() === '') {
+    throw new Error('Journal log file path is required.');
+  }
+  if (typeof content !== 'string') {
+    throw new Error('Journal content must be a string.');
+  }
+  const logDir = path.dirname(logFile);
+  const tempFile = path.join(logDir, `.${path.basename(logFile)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`);
+  let tempFileWritten = false;
+  try {
+    fs.mkdirSync(logDir, { recursive: true });
+    fs.writeFileSync(tempFile, content, { encoding: 'utf8', flag: 'wx' });
+    tempFileWritten = true;
+    fs.renameSync(tempFile, logFile);
+  } catch (error) {
+    if (tempFileWritten || !error || error.code !== 'EEXIST') {
+      try {
+        fs.unlinkSync(tempFile);
+      } catch {}
+    }
+    const message = error && error.message ? error.message : String(error);
+    throw new Error(`Could not write journal file: ${message}`);
+  }
+}
+
 function insertIntoNotesSection(content, block) {
   const regex = /(## Notes\n)([\s\S]*?)(\n---|\n##|$)/;
   const match = content.match(regex);
@@ -437,7 +477,7 @@ function recordBrainstormSession(
 
   const block = lines.join('\n');
   content = insertIntoNotesSection(content, block);
-  fs.writeFileSync(logFile, content);
+  writeJournalFile(logFile, content);
 }
 
 

package/commands/business-sync.js

@@ -1,7 +1,8 @@
 const { spawn } = require('child_process');
 const fs = require('fs');
 const path = require('path');
-const { loadManifest } = require('../lib/manifest');
+const { loadManifest, saveManifest } = require('../lib/manifest');
+const { removeBaseContents, writeBaseContents } = require('../lib/company-brain-sync');
 
 const WATCH_IGNORED_DIRS = new Set([
   '.git', '.atris', '.claude', '.cursor', '.next', '.cache',
@@ -29,6 +30,7 @@ function parseBusinessSyncArgs(args = []) {
   const resolveIdx = positional.indexOf('resolve');
   const resolveFlag = parseFlagValue(args, '--resolve', null);
   const resolve = resolveFlag || (resolveIdx !== -1 ? positional[resolveIdx + 1] : null);
+  const resolvePath = parseFlagValue(args, '--path', parseFlagValue(args, '--file', null));
   const commandWords = new Set(['status', 'doctor', 'review', 'resolve', 'local', 'cloud', 'both', 'merge']);
   const slug = positional.find((arg) => !commandWords.has(arg)) || null;
   const dryRun = args.includes('--dry-run');
@@ -39,7 +41,7 @@ function parseBusinessSyncArgs(args = []) {
   const debounceSec = Number.parseInt(parseFlagValue(args, '--debounce', '5'), 10);
   const help = args.includes('--help') || args.includes('-h') || positional[0] === 'help';
 
-  return { slug, dryRun, timeout, allowDelete, watch, intervalSec, debounceSec, status, review, resolve, help };
+  return { slug, dryRun, timeout, allowDelete, watch, intervalSec, debounceSec, status, review, resolve, resolvePath, help };
 }
 
 function readBusinessSlug(cwd = process.cwd()) {
@@ -332,7 +334,7 @@ function renderLocalSyncStatus(status) {
 
 function renderBusinessSyncHelp() {
   return [
-    'Usage: atris sync [business] [--dry-run] [--watch] [--status] [--review] [--resolve local|cloud|both|merge] [--timeout 120]',
+    'Usage: atris sync [business] [--dry-run] [--watch] [--status] [--review] [--resolve local|cloud|both|merge] [--path <file>] [--timeout 120]',
     '',
     'Safe loop:',
     '  Pull -> Review -> Publish',
@@ -341,7 +343,7 @@ function renderBusinessSyncHelp() {
     '  atris sync --status       Show local sync health',
     '  atris sync --dry-run      Preview pull and publish plans without writing cloud',
     '  atris sync --review       Read the latest conflict packet',
-    '  atris sync --resolve cloud|local|merge',
+    '  atris sync --resolve cloud|local|merge [--path <file>]',
     '  atris sync --watch        Keep the workspace live with the same safety gates',
     '',
     'Publish safety:',
@@ -398,6 +400,7 @@ function collectConflictResolutionEntries(cwd = process.cwd()) {
         const targetRel = path.relative(dir, full).replace(/\\/g, '/').replace(/\.local$/, '');
         entries.push({
           targetRel,
+          packetDir: dir,
           basePath: full.replace(/\.local$/, '.base'),
           localPath,
           remotePath,
@@ -426,6 +429,73 @@ function cleanupResolvedConflictSidecars(cwd, targetRel, { keepCloud = false } =
   }
 }
 
+function cleanupConflictPacketArtifacts(entry) {
+  for (const artifactPath of [entry.basePath, entry.localPath, entry.remotePath]) {
+    fs.rmSync(artifactPath, { force: true });
+  }
+}
+
+function conflictPacketHasEntries(packetDir) {
+  let hasEntries = false;
+
+  function walk(current) {
+    if (hasEntries) return;
+    let items;
+    try {
+      items = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const item of items) {
+      const full = path.join(current, item.name);
+      if (item.isDirectory()) walk(full);
+      else if (item.isFile() && item.name.endsWith('.local')) {
+        hasEntries = true;
+        return;
+      }
+      if (hasEntries) return;
+    }
+  }
+
+  walk(packetDir);
+  return hasEntries;
+}
+
+function finalizeResolvedConflictPacket(cwd, packetDir) {
+  const pendingPath = path.join(packetDir, 'manifest.json');
+  const pending = readJsonFile(pendingPath);
+  if (!pending || !pending.manifest || !pending.manifest.files) return null;
+
+  const slug = pending.slug || readBusinessSlug(cwd);
+  if (!slug) return null;
+
+  const manifest = {
+    ...pending.manifest,
+    workspace_root: pending.manifest.workspace_root || cwd,
+  };
+  saveManifest(slug, manifest);
+  if (pending.baseContents && typeof pending.baseContents === 'object') {
+    writeBaseContents(cwd, pending.baseContents);
+  }
+  if (Array.isArray(pending.deletedRemote)) {
+    removeBaseContents(cwd, pending.deletedRemote);
+  }
+  return slug;
+}
+
+function cleanupEmptyConflictPackets(cwd, entries) {
+  const finalized = [];
+  const packetDirs = Array.from(new Set(entries.map((entry) => entry.packetDir).filter(Boolean)));
+  for (const packetDir of packetDirs) {
+    if (!conflictPacketHasEntries(packetDir)) {
+      const slug = finalizeResolvedConflictPacket(cwd, packetDir);
+      if (slug) finalized.push(slug);
+      fs.rmSync(packetDir, { recursive: true, force: true });
+    }
+  }
+  return finalized;
+}
+
 function changedRange(baseLines, changedLines) {
   let start = 0;
   while (start < baseLines.length && start < changedLines.length && baseLines[start] === changedLines[start]) {
@@ -562,16 +632,24 @@ function safeMarkdownMerge(baseContent, localContent, remoteContent) {
   return { ok: true, content: merged, mode: 'markdown' };
 }
 
-function resolveLatestConflict(cwd = process.cwd(), strategy = 'local') {
+function normalizeResolvePath(value) {
+  return String(value || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+/, '');
+}
+
+function resolveLatestConflict(cwd = process.cwd(), strategy = 'local', target = null) {
   if (!['local', 'cloud', 'both', 'merge'].includes(strategy)) {
     throw new Error('Use `atris sync --resolve local`, `atris sync --resolve cloud`, `atris sync --resolve both`, or `atris sync --resolve merge`.');
   }
 
-  const entries = collectConflictResolutionEntries(cwd);
+  const wantedTarget = normalizeResolvePath(target);
+  const entries = collectConflictResolutionEntries(cwd)
+    .filter((entry) => !wantedTarget || normalizeResolvePath(entry.targetRel) === wantedTarget);
   if (entries.length === 0) {
     return {
       resolved: [],
-      message: 'No sync conflicts need resolution.\n',
+      message: wantedTarget
+        ? `No sync conflicts need resolution for ${wantedTarget}.\n`
+        : 'No sync conflicts need resolution.\n',
     };
   }
 
@@ -591,6 +669,7 @@ function resolveLatestConflict(cwd = process.cwd(), strategy = 'local') {
         fs.copyFileSync(entry.remotePath, remoteCopyPath);
       }
       cleanupResolvedConflictSidecars(cwd, entry.targetRel, { keepCloud: true });
+      cleanupConflictPacketArtifacts(entry);
       resolved.push(entry.targetRel);
       continue;
     }
@@ -612,6 +691,7 @@ function resolveLatestConflict(cwd = process.cwd(), strategy = 'local') {
       fs.mkdirSync(path.dirname(targetPath), { recursive: true });
       fs.writeFileSync(targetPath, merged.content, 'utf8');
       cleanupResolvedConflictSidecars(cwd, entry.targetRel);
+      cleanupConflictPacketArtifacts(entry);
       resolved.push(entry.targetRel);
       continue;
     }
@@ -621,15 +701,19 @@ function resolveLatestConflict(cwd = process.cwd(), strategy = 'local') {
     fs.mkdirSync(path.dirname(targetPath), { recursive: true });
     fs.copyFileSync(sourcePath, targetPath);
     cleanupResolvedConflictSidecars(cwd, entry.targetRel);
+    cleanupConflictPacketArtifacts(entry);
     resolved.push(entry.targetRel);
   }
 
+  const finalizedManifests = cleanupEmptyConflictPackets(cwd, entries);
+
   return {
     resolved,
     unresolved,
     message: [
       `Resolved ${resolved.length} conflict${resolved.length === 1 ? '' : 's'} using ${strategy === 'both' ? 'both versions' : `${strategy === 'merge' ? 'safe merge' : `${strategy === 'local' ? 'local' : 'cloud'} version`}`}.`,
       ...resolved.map((rel) => `  - ${rel}`),
+      ...(finalizedManifests.length ? ['', `Updated sync manifest for ${finalizedManifests.join(', ')}.`] : []),
       ...(unresolved.length ? ['', 'Still needs review:', ...unresolved.map((rel) => `  - ${rel}`)] : []),
       '',
       'Next: run `atris sync --dry-run` before publishing.',
@@ -717,7 +801,7 @@ async function businessSync(args = process.argv.slice(3), cwd = process.cwd()) {
   }
 
   if (options.resolve) {
-    process.stdout.write(resolveLatestConflict(cwd, options.resolve).message);
+    process.stdout.write(resolveLatestConflict(cwd, options.resolve, options.resolvePath).message);
     return;
   }
 

package/commands/business.js

@@ -867,7 +867,6 @@ function renderBusinessMissingAction(missing) {
 }
 
 function renderBusinessCreatedNextSteps(bizMeta = {}, workspaceRoot = '.') {
-  const slug = bizMeta.slug || slugifyName(bizMeta.name) || 'business';
   const lines = [
     '  Atris:     seeded local computer + operator + validator',
     '',
@@ -887,7 +886,8 @@ function renderBusinessCreatedNextSteps(bizMeta = {}, workspaceRoot = '.') {
     '    atris business share --write',
     '',
     '  Sync when ready:',
-    `    atris align ${slug} --fix`,
+    '    atris sync --dry-run',
+    '    atris sync',
   ];
   return lines.join('\n');
 }
@@ -926,6 +926,7 @@ function renderBusinessShareHandoff(state, options = {}) {
       '```bash',
       `atris pull ${bizMeta.slug}`,
       `cd ${bizMeta.slug}`,
+      'atris sync --dry-run',
       'atris business start',
       '```',
     ] : [
@@ -959,13 +960,13 @@ function renderBusinessShareHandoff(state, options = {}) {
     '',
     '```bash',
     'atris business onboard --website <url> --contact "Name" --note "what changed"',
-    'atris pull --dry-run',
+    state.remoteReady ? 'atris sync --dry-run' : '# local-only: no cloud sync is available yet',
     'atris task next',
     ...renderBusinessMissionBootstrapLines(bizMeta),
     'atris do',
     'atris business record atris/reports/<recap>.md --outcome mixed --metric "operator speed"',
     'atris business share --write',
-    'atris align --fix',
+    state.remoteReady ? 'atris sync' : '# local-only: share the folder directly',
     '```',
     '',
     '## Proof State',
@@ -984,6 +985,8 @@ function renderBusinessShareHandoff(state, options = {}) {
     'Useful commands:',
     '',
     '```bash',
+    state.remoteReady ? 'atris sync --status' : '# local-only: no cloud sync status yet',
+    state.remoteReady ? 'atris sync --watch' : '# local-only: no cloud watcher yet',
     'atris radar',
     'atris task next',
     ...renderBusinessMissionBootstrapLines(bizMeta),
@@ -1027,7 +1030,7 @@ function renderBusinessStartCard(state, options = {}) {
     `- ${state.onePager || 'missing operator one-pager'}`,
     '',
     'Run:',
-    state.remoteReady ? '  atris pull --dry-run' : '  # local-only: no cloud pull is available yet',
+    state.remoteReady ? '  atris sync --dry-run' : '  # local-only: no cloud sync is available yet',
     '  atris',
     '  atris business start',
     '  atris radar',
@@ -1037,7 +1040,8 @@ function renderBusinessStartCard(state, options = {}) {
     '  atris do',
     '  atris business record atris/reports/<recap>.md --outcome mixed --metric "operator speed"',
     '  atris business share --write',
-    '  atris align --fix',
+    state.remoteReady ? '  atris sync' : '  # local-only: share the folder directly',
+    state.remoteReady ? '  atris sync --watch' : '  # local-only: no cloud watcher yet',
     '',
     'Proof:',
     `- team lanes: ${state.teamMembers}`,
@@ -2833,12 +2837,14 @@ async function quickstart() {
      atris business share --write
 
   9. Push local state to cloud:
-     atris align --fix
+     atris sync --dry-run
+     atris sync
 
   Repeat:
      atris radar -> atris task next -> atris do -> record -> share
 
   Optional:
+     atris sync --watch
      atris business connect slack --business my-company
      atris business connect github --business my-company
 

package/commands/chat-scan.js

@@ -0,0 +1,102 @@
+const fs = require('fs');
+const path = require('path');
+const { scanChatLogs, writeLatestScan } = require('../lib/chat-log-scan');
+
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+
+function readFlag(args, name, fallback) {
+  const i = args.indexOf(name);
+  if (i === -1 || i === args.length - 1) return fallback;
+  return args[i + 1];
+}
+
+function printReport(report) {
+  console.log('');
+  console.log('┌ Chat scan ─────────────────────────────────────────────────┐');
+  console.log(`│ sessions ${String(report.summary.sessions).padEnd(3)} │ ax ${String(report.summary.ax_sessions).padEnd(3)} │ cursor ${String(report.summary.cursor_sessions).padEnd(3)} │ findings ${String(report.summary.findings).padEnd(3)} │`);
+  console.log('└────────────────────────────────────────────────────────────┘');
+  console.log('');
+  console.log(`Window: last ${report.window_hours}h`);
+  console.log(`Ax logs: ${report.sources.ax_dirs.join(', ') || '(none)'}`);
+  console.log(`Cursor: ${report.sources.cursor_roots.join(', ') || '(none)'}`);
+  console.log('');
+
+  if (!report.sessions.length) {
+    console.log('No recent chat logs found.');
+    console.log('  ax --pro --chat writes atris/runs/ax-play-*.log');
+    console.log('  Cursor writes ~/.cursor/projects/<slug>/agent-transcripts/*.jsonl');
+    return;
+  }
+
+  console.log('Recent sessions:');
+  for (const session of report.sessions.slice(0, 8)) {
+    const label = session.source === 'ax' ? `ax/${session.mode || '?'}` : 'cursor';
+    const when = session.started_at || path.basename(session.path);
+    const last = session.last_user || session.last_assistant || '(no text captured)';
+    console.log(`- [${label}] ${when}`);
+    console.log(`  last: ${last}`);
+    if (session.interrupted) console.log('  signal: interrupted');
+    if (session.log_findings?.length) console.log(`  errors: ${session.log_findings[0]}`);
+  }
+
+  if (report.findings.length) {
+    console.log('');
+    console.log('Problems detected:');
+    for (const finding of report.findings.slice(0, 8)) {
+      console.log(`- [${finding.severity}] ${finding.title}`);
+      if (finding.evidence) console.log(`  ${finding.evidence}`);
+    }
+    console.log('');
+    console.log(`Next: ${report.next_command}`);
+  } else {
+    console.log('');
+    console.log('No problem patterns detected in recent chat logs.');
+  }
+}
+
+function chatScanCommand(argv = []) {
+  const args = argv.filter((a) => a !== '--');
+  if (hasFlag(args, '--help') || hasFlag(args, '-h') || args[0] === 'help') {
+    console.log(`Usage: atris chat scan [--json] [--hours <n>] [--limit <n>] [--no-write]
+
+Read recent ax chat logs and Cursor agent transcripts; surface friction/errors.
+
+Options:
+  --hours <n>   Lookback window (default 720 = 30 days)
+  --limit <n>   Max sessions per source (default 12)
+  --no-write    Skip writing .atris/state/chat_scan.latest.json
+  --json        Machine-readable output`);
+    return { ok: true };
+  }
+
+  const root = process.cwd();
+  if (!fs.existsSync(path.join(root, 'atris'))) {
+    console.error('✗ atris/ folder not found. Run from an Atris workspace.');
+    process.exit(1);
+  }
+
+  const report = scanChatLogs({
+    cwd: root,
+    hours: readFlag(args, '--hours', 720),
+    limit: readFlag(args, '--limit', 12),
+  });
+
+  let latestPath = null;
+  if (!hasFlag(args, '--no-write')) {
+    latestPath = writeLatestScan(root, report);
+    report.latest_path = latestPath;
+  }
+
+  if (hasFlag(args, '--json')) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return report;
+  }
+
+  printReport(report);
+  if (latestPath) console.log(`\nWrote ${path.relative(root, latestPath)}`);
+  return report;
+}
+
+module.exports = { chatScanCommand };