atris 3.14.0 → 3.15.0

package/README.md

@@ -157,6 +157,7 @@ atris business record atris/reports/2026-04-12-operator-recap.md --outcome mixed
 - `atris task` keeps a local SQLite task plane for agents while `atris/TODO.md` remains the readable project board
 - `atris experiments` runs small test packs in `atris/experiments/`
 - `atris pull` and `atris push` sync cloud workspaces and journals
+- `atris live` keeps a business brain fresh by checking/fixing the workspace, pushing local state, pulling cloud state, and pushing again after local changes go quiet
 
 ## Verifiable Feedback Loop
 

package/bin/atris.js

@@ -270,6 +270,7 @@ function showHelp() {
   console.log('Sync:');
   console.log('  pull       - Pull journals + member data from cloud');
   console.log('  push       - Push workspace files to cloud');
+  console.log('  live       - Keep a business brain fresh (doctor, pull, watch, push)');
   console.log('  clean-workspace <slug> - Analyze & remove junk files from a workspace (alias: cw)');
   console.log('');
   console.log('GitHub for Context:');
@@ -444,8 +445,8 @@ const { planAtris: planCmd, doAtris: doCmd, reviewAtris: reviewCmd } = require('
 // Check if this is a known command or natural language input
 const knownCommands = ['init', 'log', 'status', 'analytics', 'visualize', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'chat', 'console', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
-                       'clean', 'verify', 'search', 'skill', 'member', 'app', 'learn', 'plugin', 'experiments', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'align', 'terminal', 'computer', 'diff', 'business', 'sync',
-                       'ingest', 'query', 'lint', 'loop', 'task',
+                       'clean', 'verify', 'search', 'skill', 'member', 'app', 'learn', 'plugin', 'experiments', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync',
+                       'ingest', 'query', 'lint', 'loop', 'task', 'aeo',
                        'gmail', 'calendar', 'twitter', 'slack', 'integrations', 'setup', 'clean-workspace', 'cw',
                        'fork', 'browse', 'publish', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet'];
 
@@ -796,6 +797,11 @@ if (command === 'init') {
   Promise.resolve(require('../commands/task').run(process.argv.slice(3)))
     .then(() => process.exit(0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'aeo') {
+  // AEO: AI Engine Optimization — credit-metered citation drafting against the customer workspace.
+  Promise.resolve(require('../commands/aeo').run(process.argv.slice(3)))
+    .then(() => process.exit(0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'agent') {
   agentAtris().then(() => process.exit(0)).catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'log') {
@@ -1104,6 +1110,10 @@ if (command === 'init') {
   require('../commands/push').pushAtris()
     .then(() => process.exit(0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'live') {
+  require('../commands/live').liveCommand()
+    .then(() => process.exit(0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'align') {
   require('../commands/align').alignAtris()
     .then(() => process.exit(0))

package/commands/aeo.js

@@ -0,0 +1,197 @@
+/**
+ * atris aeo — AI Engine Optimization commands
+ *
+ *   atris aeo init                          # create entity-graph skeleton in workspace
+ *   atris aeo draft "<topic>" [opts]        # generate citation-optimized article (credit-metered)
+ *
+ * Hits the backend endpoints registered under:
+ *   POST /api/business/{id}/workspaces/{ws}/aeo/init
+ *   POST /api/business/{id}/workspaces/{ws}/aeo/draft
+ *
+ * Business resolution mirrors `atris terminal`: explicit --workspace slug,
+ * else cwd .atris/business.json. The endpoint itself takes care of running
+ * Claude Sonnet 4.6 with the 10 AEO rules and writing to /workspace/atris/aeo/drafts/.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { loadCredentials } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+const { loadBusinesses, saveBusinesses } = require('./business');
+
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+
+async function ensureAwake(token, businessId, maxWaitSec = 90) {
+  const status = await apiRequestJson(`/business/${businessId}/ai-computer/status`, { method: 'GET', token });
+  if (status.ok && status.data && status.data.status === 'running' && status.data.endpoint) return true;
+  process.stdout.write('  Waking EC2 computer... ');
+  await apiRequestJson(`/business/${businessId}/ai-computer/wake`, { method: 'POST', token });
+  const start = Date.now();
+  while (Date.now() - start < maxWaitSec * 1000) {
+    await sleep(3000);
+    const s = await apiRequestJson(`/business/${businessId}/ai-computer/status`, { method: 'GET', token });
+    if (s.ok && s.data && s.data.status === 'running' && s.data.endpoint) {
+      console.log(`awake (${Math.floor((Date.now() - start) / 1000)}s)`);
+      return true;
+    }
+  }
+  console.log('timeout');
+  return false;
+}
+
+async function resolveBusiness(token, slug) {
+  const businesses = loadBusinesses();
+  const list = await apiRequestJson('/business/', { method: 'GET', token });
+  if (list.ok) {
+    const match = (list.data || []).find(
+      (b) => b.slug === slug || b.name.toLowerCase() === slug.toLowerCase()
+    );
+    if (!match) return null;
+    businesses[slug] = {
+      business_id: match.id,
+      workspace_id: match.workspace_id,
+      name: match.name,
+      slug: match.slug,
+      added_at: new Date().toISOString(),
+    };
+    saveBusinesses(businesses);
+    return { businessId: match.id, workspaceId: match.workspace_id, businessName: match.name };
+  }
+  if (businesses[slug]) {
+    return {
+      businessId: businesses[slug].business_id,
+      workspaceId: businesses[slug].workspace_id,
+      businessName: businesses[slug].name || slug,
+    };
+  }
+  return null;
+}
+
+function pickSlug(args) {
+  const wsIdx = args.findIndex((a) => a === '--workspace' || a === '-w');
+  if (wsIdx !== -1 && args[wsIdx + 1]) {
+    const slug = args[wsIdx + 1];
+    args.splice(wsIdx, 2);
+    return slug;
+  }
+  const bizFile = path.join(process.cwd(), '.atris', 'business.json');
+  if (fs.existsSync(bizFile)) {
+    try { return JSON.parse(fs.readFileSync(bizFile, 'utf8')).slug; } catch { /* ignore */ }
+  }
+  return null;
+}
+
+function printHelp() {
+  console.log('Usage:');
+  console.log('  atris aeo init [--workspace <slug>]');
+  console.log('  atris aeo draft "<topic>" [--workspace <slug>] [--queries q1,q2] [--slug X] [--url URL]');
+  console.log('');
+  console.log('Examples:');
+  console.log('  atris aeo init');
+  console.log('  atris aeo draft "what is pallet" --queries "what is pallet,best freight platform"');
+  console.log('  atris aeo draft "how does atris work" --workspace doordash --slug atris-overview');
+}
+
+async function aeoInit(args) {
+  const slug = pickSlug(args);
+  if (!slug) {
+    console.error('Cannot determine business. Pass --workspace <slug> or run from a workspace.');
+    process.exit(1);
+  }
+  const creds = loadCredentials();
+  if (!creds || !creds.token) { console.error('Not logged in. Run: atris login'); process.exit(1); }
+
+  const biz = await resolveBusiness(creds.token, slug);
+  if (!biz) { console.error(`Business "${slug}" not found.`); process.exit(1); }
+  if (!biz.workspaceId) { console.error(`Business "${slug}" has no workspace.`); process.exit(1); }
+
+  const awake = await ensureAwake(creds.token, biz.businessId);
+  if (!awake) { console.error('  EC2 computer did not become ready in time.'); process.exit(1); }
+
+  const result = await apiRequestJson(
+    `/business/${biz.businessId}/workspaces/${biz.workspaceId}/aeo/init`,
+    { method: 'POST', token: creds.token, body: {}, timeoutMs: 60000 }
+  );
+  if (!result.ok) {
+    console.error(`✗ aeo init failed: ${result.errorMessage || result.error || result.status}`);
+    process.exit(1);
+  }
+  const data = result.data || {};
+  const created = data.created || [];
+  const skipped = data.skipped || [];
+  console.log(`✓ AEO entity graph @ ${data.dir}`);
+  if (created.length) console.log(`  created: ${created.map((p) => p.split('/').pop()).join(', ')}`);
+  if (skipped.length) console.log(`  existed: ${skipped.map((p) => p.split('/').pop()).join(', ')}`);
+}
+
+async function aeoDraft(args) {
+  // Pull --slug, --url, --queries, --workspace; remainder is the topic.
+  const opts = {};
+  for (const k of ['slug', 'url', 'queries']) {
+    const i = args.findIndex((a) => a === `--${k}`);
+    if (i !== -1 && args[i + 1]) {
+      opts[k] = args[i + 1];
+      args.splice(i, 2);
+    }
+  }
+  const slug = pickSlug(args);
+  const topic = args.join(' ').trim();
+  if (!topic) {
+    console.error('Missing topic. Usage: atris aeo draft "<topic>"');
+    process.exit(1);
+  }
+  if (!slug) {
+    console.error('Cannot determine business. Pass --workspace <slug> or run from a workspace.');
+    process.exit(1);
+  }
+  const creds = loadCredentials();
+  if (!creds || !creds.token) { console.error('Not logged in. Run: atris login'); process.exit(1); }
+
+  const biz = await resolveBusiness(creds.token, slug);
+  if (!biz) { console.error(`Business "${slug}" not found.`); process.exit(1); }
+  if (!biz.workspaceId) { console.error(`Business "${slug}" has no workspace.`); process.exit(1); }
+
+  const awake = await ensureAwake(creds.token, biz.businessId);
+  if (!awake) { console.error('  EC2 computer did not become ready in time.'); process.exit(1); }
+
+  const body = { topic };
+  if (opts.slug) body.slug = opts.slug;
+  if (opts.url) body.target_url = opts.url;
+  if (opts.queries) body.target_queries = opts.queries.split(',').map((s) => s.trim()).filter(Boolean);
+
+  process.stdout.write(`Drafting "${topic}" for ${biz.businessName}... `);
+  const t0 = Date.now();
+  const result = await apiRequestJson(
+    `/business/${biz.businessId}/workspaces/${biz.workspaceId}/aeo/draft`,
+    { method: 'POST', token: creds.token, body, timeoutMs: 180000 }
+  );
+  const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+  if (!result.ok) {
+    console.log('failed');
+    console.error(`✗ aeo draft failed (${result.status}): ${result.errorMessage || result.error}`);
+    process.exit(1);
+  }
+  const data = result.data || {};
+  console.log(`done (${elapsed}s)`);
+  console.log('');
+  console.log(`  path:           ${data.path}`);
+  console.log(`  self-score:     ${data.self_score ?? '?'}/10`);
+  console.log(`  credits:        ${data.credits_charged ?? '?'}`);
+  console.log(`  tokens:         in=${data.tokens?.input ?? '?'} out=${data.tokens?.output ?? '?'}`);
+  console.log(`  entity graph:   entities=${data.entity_graph?.has_entities ? 'y' : 'n'} defs=${data.entity_graph?.has_definitions ? 'y' : 'n'} stats=${data.entity_graph?.has_stats ? 'y' : 'n'}`);
+  if (data.overlay_active) console.log(`  overlay:        active (${data.overlay_lines} lines)`);
+  if (data.hint) console.log(`  hint:           ${data.hint}`);
+}
+
+async function run(args = []) {
+  const sub = args[0];
+  if (!sub || sub === 'help' || sub === '--help' || sub === '-h') return printHelp();
+  const rest = args.slice(1);
+  if (sub === 'init') return aeoInit(rest);
+  if (sub === 'draft') return aeoDraft(rest);
+  console.error(`Unknown aeo subcommand: ${sub}`);
+  printHelp();
+  process.exit(1);
+}
+
+module.exports = { run };

package/commands/live.js

@@ -0,0 +1,289 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const DEFAULT_INTERVAL_SEC = 120;
+const DEFAULT_DEBOUNCE_SEC = 30;
+const DEFAULT_TIMEOUT_SEC = 600;
+
+const IGNORED_DIRS = new Set(['.git', 'node_modules', 'dist', 'build', 'release', '.next', '__pycache__']);
+const IGNORED_FILES = new Set(['.DS_Store']);
+
+function parseNumberFlag(args, name, fallback) {
+  const eq = args.find((arg) => arg.startsWith(`--${name}=`));
+  if (eq) {
+    const value = Number(eq.slice(name.length + 3));
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+  }
+  const idx = args.indexOf(`--${name}`);
+  if (idx !== -1 && args[idx + 1]) {
+    const value = Number(args[idx + 1]);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+  }
+  return fallback;
+}
+
+function parseStringFlag(args, name) {
+  const eq = args.find((arg) => arg.startsWith(`--${name}=`));
+  if (eq) return eq.slice(name.length + 3);
+  const idx = args.indexOf(`--${name}`);
+  if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith('-')) return args[idx + 1];
+  return null;
+}
+
+function firstPositionalArg(args) {
+  const flagsWithValues = new Set(['--interval', '--debounce', '--timeout', '--only', '--root']);
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (flagsWithValues.has(arg)) {
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('-')) continue;
+    return arg;
+  }
+  return null;
+}
+
+function readBusinessSlugFromCwd(cwd) {
+  const file = path.join(cwd, '.atris', 'business.json');
+  if (!fs.existsSync(file)) return null;
+  try {
+    const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return data.slug || data.canonical_slug || data.name || null;
+  } catch {
+    return null;
+  }
+}
+
+function parseLiveOptions(args, cwd = process.cwd()) {
+  const first = firstPositionalArg(args);
+  return {
+    slug: first || readBusinessSlugFromCwd(cwd),
+    once: args.includes('--once'),
+    dryRun: args.includes('--dry-run'),
+    noDoctor: args.includes('--no-doctor'),
+    noPush: args.includes('--no-push'),
+    intervalSec: parseNumberFlag(args, 'interval', DEFAULT_INTERVAL_SEC),
+    debounceSec: parseNumberFlag(args, 'debounce', DEFAULT_DEBOUNCE_SEC),
+    timeoutSec: parseNumberFlag(args, 'timeout', DEFAULT_TIMEOUT_SEC),
+    only: parseStringFlag(args, 'only'),
+    root: parseStringFlag(args, 'root') || path.dirname(cwd),
+    cwd,
+  };
+}
+
+function printLiveHelp() {
+  console.log('Usage: atris live [business] [options]');
+  console.log('');
+  console.log('Keeps a business brain fresh: doctor, pull, watch local changes, push after quiet, and periodically pull.');
+  console.log('');
+  console.log('Examples:');
+  console.log('  atris live atris-labs');
+  console.log('  atris live --once');
+  console.log('  atris live atris-labs --dry-run');
+  console.log('  atris live atris-labs --interval=120 --debounce=30');
+  console.log('');
+  console.log('Options:');
+  console.log('  --once             Run one freshness cycle and exit');
+  console.log('  --dry-run          Print the plan without running pull/push');
+  console.log('  --interval <sec>   Seconds between cloud pulls (default: 120)');
+  console.log('  --debounce <sec>   Quiet seconds before pushing local changes (default: 30)');
+  console.log('  --timeout <sec>    Pull timeout passed through to atris pull (default: 600)');
+  console.log('  --only <prefix>    Limit pull/push to a path prefix');
+  console.log('  --no-doctor        Skip business doctor --fix');
+  console.log('  --no-push          Pull/watch only; never push');
+}
+
+function shouldIgnore(relativePath) {
+  if (!relativePath) return true;
+  const parts = relativePath.split(path.sep);
+  if (parts.some((part) => IGNORED_DIRS.has(part))) return true;
+  if (IGNORED_FILES.has(path.basename(relativePath))) return true;
+  if (relativePath.startsWith(path.join('.atris', 'state'))) return true;
+  return false;
+}
+
+function collectSnapshot(root) {
+  const snapshot = new Map();
+
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      const rel = path.relative(root, full);
+      if (shouldIgnore(rel)) continue;
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile()) {
+        try {
+          const stat = fs.statSync(full);
+          snapshot.set(rel, `${stat.size}:${Math.floor(stat.mtimeMs)}`);
+        } catch {
+          // Files can disappear while the operator is saving.
+        }
+      }
+    }
+  }
+
+  walk(root);
+  return snapshot;
+}
+
+function snapshotsDiffer(a, b) {
+  if (a.size !== b.size) return true;
+  for (const [key, value] of a.entries()) {
+    if (b.get(key) !== value) return true;
+  }
+  return false;
+}
+
+function commandLine(argv) {
+  return ['atris', ...argv].join(' ');
+}
+
+function runCli(argv, options) {
+  if (options.dryRun) {
+    console.log(`  dry-run: ${commandLine(argv)}`);
+    return Promise.resolve({ status: 0 });
+  }
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(__dirname, '..', 'bin', 'atris.js'), ...argv], {
+      cwd: options.cwd,
+      stdio: 'inherit',
+      env: { ...process.env, ATRIS_SKIP_UPDATE_CHECK: '1' },
+    });
+    child.on('error', reject);
+    child.on('exit', (status) => {
+      if (status === 0) resolve({ status });
+      else reject(new Error(`${commandLine(argv)} exited ${status}`));
+    });
+  });
+}
+
+function buildPullArgs(options) {
+  const args = ['pull', options.slug, '--timeout', String(options.timeoutSec)];
+  if (options.only) args.push('--only', options.only);
+  return args;
+}
+
+function buildPushArgs(options) {
+  const args = ['push', options.slug, '--from', options.cwd];
+  if (options.only) args.push('--only', options.only);
+  return args;
+}
+
+async function runFreshnessCycle(options, reason) {
+  console.log('');
+  console.log(`atris live: ${reason}`);
+  if (!options.noDoctor) {
+    await runCli(['business', 'doctor', '--fix', '--root', options.root], options);
+  }
+  if (!options.noPush) {
+    await runCli(buildPushArgs(options), options);
+  }
+  await runCli(buildPullArgs(options), options);
+}
+
+async function liveCommand(args = process.argv.slice(3)) {
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    printLiveHelp();
+    return;
+  }
+
+  const options = parseLiveOptions(args);
+  if (!options.slug) {
+    console.error('Usage: atris live [business]');
+    console.error('Run inside a business workspace or pass a business slug.');
+    process.exit(1);
+  }
+
+  console.log('');
+  console.log(`Atris Live: ${options.slug}`);
+  console.log(`  workspace: ${options.cwd}`);
+  console.log(`  interval: ${options.intervalSec}s`);
+  console.log(`  debounce: ${options.debounceSec}s`);
+  console.log(`  push: ${options.noPush ? 'off' : 'on'}`);
+  if (options.only) console.log(`  only: ${options.only}`);
+
+  if (options.dryRun) {
+    await runFreshnessCycle(options, 'planned startup cycle');
+    if (!options.once) console.log(`  dry-run: would watch ${options.cwd} and sync every ${options.intervalSec}s`);
+    return;
+  }
+
+  await runFreshnessCycle(options, 'startup freshness cycle');
+  if (options.once) return;
+
+  console.log('');
+  console.log('Brain fresh. Watching for local changes. Press Ctrl+C to stop.');
+
+  let lastSnapshot = collectSnapshot(options.cwd);
+  let pendingPush = false;
+  let quietTicks = 0;
+  let running = false;
+
+  async function guarded(label, fn) {
+    if (running) return;
+    running = true;
+    try {
+      await fn();
+      lastSnapshot = collectSnapshot(options.cwd);
+      pendingPush = false;
+      quietTicks = 0;
+    } catch (err) {
+      console.error(`\natris live paused after ${label}: ${err.message || err}`);
+      console.error('Fix the issue, then restart `atris live`.');
+      process.exit(1);
+    } finally {
+      running = false;
+    }
+  }
+
+  setInterval(() => {
+    if (running) return;
+    const current = collectSnapshot(options.cwd);
+    if (snapshotsDiffer(lastSnapshot, current)) {
+      pendingPush = true;
+      quietTicks = 0;
+      lastSnapshot = current;
+      process.stdout.write('\rLocal brain changed. Waiting for quiet before push... ');
+      return;
+    }
+    if (pendingPush) {
+      quietTicks += 1;
+      if (quietTicks >= options.debounceSec) {
+        void guarded('push', async () => {
+          console.log('\nLocal brain quiet. Pushing fresh state...');
+          if (!options.noPush) await runCli(buildPushArgs(options), options);
+        });
+      }
+    }
+  }, 1000);
+
+  setInterval(() => {
+    if (pendingPush) {
+      process.stdout.write('\rLocal changes pending; skipping cloud pull until local brain is pushed... ');
+      return;
+    }
+    void guarded('periodic pull', async () => {
+      console.log('\nChecking cloud for fresher brain...');
+      await runCli(buildPullArgs(options), options);
+    });
+  }, options.intervalSec * 1000);
+}
+
+module.exports = {
+  collectSnapshot,
+  liveCommand,
+  parseLiveOptions,
+  shouldIgnore,
+  snapshotsDiffer,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.14.0",
+  "version": "3.15.0",
   "description": "Atris — an operating system for intelligence. Integrates with any agent.",
   "main": "bin/atris.js",
   "bin": {