atris 3.34.0 → 3.36.0

package/commands/experiments.js

@@ -17,6 +17,7 @@ const {
   summarizeReview,
   writeArtifact,
 } = require('../lib/endstate');
+const daily = require('../lib/experiments/daily');
 
 const SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const ROOT_FILES = ['README.md', 'validate.py', 'benchmark_validate.py', 'benchmark_runtime.py'];
@@ -520,8 +521,31 @@ function experimentsReplay(target = 'endstate') {
   experimentsCompare('endstate');
 }
 
+function experimentsDaily(...args) {
+  ensureAtrisWorkspace();
+  const code = daily.runDaily(process.cwd(), args);
+  if (code) process.exit(code);
+}
+
+function experimentsQueue(subcommand, ...args) {
+  ensureAtrisWorkspace();
+  const root = process.cwd();
+  let code = 1;
+  if (subcommand === 'add') code = daily.queueAdd(root, args);
+  else if (subcommand === 'list') code = daily.queueList(root, args);
+  else {
+    console.error('Usage: atris experiments queue <add|list> ...');
+    code = 1;
+  }
+  if (code) process.exit(code);
+}
+
 function experimentsCommand(subcommand, ...args) {
   switch (subcommand) {
+    case 'daily':
+      return experimentsDaily(...args);
+    case 'queue':
+      return experimentsQueue(args[0], ...args.slice(1));
     case 'init':
     case 'new':
       return experimentsInit(args[0]);
@@ -546,6 +570,8 @@ function experimentsCommand(subcommand, ...args) {
       console.log('  compare endstate     Compare the latest baseline and stack receipts');
       console.log('  replay endstate      Validate, dry-run, and compare the public benchmark flow');
       console.log('  benchmark [mode]     Run validate/runtime/all benchmark harness');
+      console.log('  daily [--dry-run] [--force] [--json]');
+      console.log('  queue add|list       Manage the daily experiment queue');
       console.log('');
       console.log('Examples:');
       console.log('  atris experiments init');
@@ -564,4 +590,6 @@ module.exports = {
   ensureExperimentsFramework,
   buildBenchmarkArtifact,
   parseRunOptions,
+  experimentsDaily,
+  experimentsQueue,
 };

package/commands/feed.js

@@ -0,0 +1,202 @@
+'use strict';
+
+// Feed: the business group feed from the terminal — read receipts, post receipts.
+// Auth: existing atris login. Business: nearest .atris/business.json above cwd.
+
+const fs = require('fs');
+const path = require('path');
+const { ensureValidCredentials } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+
+function showHelp() {
+  console.log('');
+  console.log('Usage: atris feed [list] [n] [--author <name>] [--since <7d|24h>] [--full] [--json]');
+  console.log('       atris feed post "<content>"');
+  console.log('');
+  console.log('Description:');
+  console.log('  Read and write the business group feed (the same feed as the web GM dashboard).');
+  console.log('  Posts should be receipts and state changes only: what shipped, what blocked, what changed.');
+  console.log('');
+  console.log('Options:');
+  console.log('  --author <name>   Only posts whose author matches (name, email prefix, or id prefix).');
+  console.log('  --since <window>  Only posts newer than e.g. 7d, 48h.');
+  console.log('  --full            Print full post bodies instead of one line each.');
+  console.log('  --json            Machine-readable output.');
+  console.log('  --help, -h        Show this help.');
+  console.log('');
+}
+
+function findBusiness(startDir) {
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    const file = path.join(dir, '.atris', 'business.json');
+    if (fs.existsSync(file)) {
+      try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (parsed.business_id) return { businessId: parsed.business_id, name: parsed.name || parsed.slug, root: dir };
+      } catch { /* fall through to parent dirs */ }
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+function loadAuthorAliases(workspaceRoot) {
+  const file = path.join(workspaceRoot, '.atris', 'feed_authors.json');
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function parseSince(raw) {
+  const match = /^(\d+)([dh])$/.exec(String(raw || '').trim());
+  if (!match) return null;
+  const amount = parseInt(match[1], 10);
+  const ms = match[2] === 'd' ? amount * 24 * 3600 * 1000 : amount * 3600 * 1000;
+  return Date.now() - ms;
+}
+
+function authorLabel(post, aliases, selfId, selfEmail) {
+  if (post.post_type === 'agent_post') return post.agent_name || post.author_display_name || 'agent';
+  if (post.author_display_name) return post.author_display_name;
+  const id = post.author_id || '';
+  if (aliases[id]) return aliases[id];
+  if (selfId && id === selfId) return (selfEmail || 'me').split('@')[0];
+  return id ? id.slice(0, 8) : '?';
+}
+
+async function fetchPosts(businessId, token, want) {
+  const pageSize = 100;
+  let all = [];
+  for (let offset = 0; all.length < want; offset += pageSize) {
+    const res = await apiRequestJson(
+      `/business/${businessId}/feed?limit=${pageSize}&offset=${offset}`,
+      { token, timeoutMs: 20000 }
+    );
+    const statusCode = res.statusCode || res.status;
+    if (statusCode && statusCode >= 400) {
+      throw new Error(`Feed fetch failed (${statusCode}): ${JSON.stringify(res.data)}`);
+    }
+    const page = Array.isArray(res.data?.posts) ? res.data.posts : Array.isArray(res.data) ? res.data : [];
+    all = all.concat(page);
+    if (page.length < pageSize) break;
+  }
+  return all;
+}
+
+async function feedCommand(args = []) {
+  if (args.includes('--help') || args.includes('-h')) {
+    showHelp();
+    return 0;
+  }
+
+  const business = findBusiness(process.cwd());
+  if (!business) {
+    console.error('✗ No .atris/business.json found above this directory. Run from a bound workspace.');
+    return 1;
+  }
+
+  const auth = await ensureValidCredentials(apiRequestJson);
+  if (auth.error || !auth.credentials?.token) {
+    console.error(`✗ Not logged in (${auth.error || 'no token'}). Run: atris login`);
+    return 1;
+  }
+  const token = auth.credentials.token;
+  const selfId = auth.credentials.user_id || auth.user?.id || null;
+  const selfEmail = auth.credentials.email || auth.user?.email || null;
+
+  const positional = args.filter((a) => !a.startsWith('--'));
+  const sub = positional[0] || 'list';
+
+  if (sub === 'post') {
+    const content = positional.slice(1).join(' ').trim();
+    if (!content) {
+      console.error('✗ Nothing to post. Usage: atris feed post "<content>"');
+      return 1;
+    }
+    const res = await apiRequestJson(`/business/${business.businessId}/feed`, {
+      method: 'POST',
+      token,
+      body: { content: content.slice(0, 10000) },
+      timeoutMs: 20000,
+    });
+    if (!res.data?.id) {
+      console.error(`✗ Post failed: ${JSON.stringify(res.data)}`);
+      return 1;
+    }
+    console.log(`✓ Posted to ${business.name || 'business'} feed (${res.data.id})`);
+    return 0;
+  }
+
+  if (sub !== 'list') {
+    console.error(`✗ Unknown subcommand: ${sub}`);
+    showHelp();
+    return 1;
+  }
+
+  const countArg = parseInt(positional[1], 10);
+  const count = Number.isFinite(countArg) ? Math.max(1, Math.min(300, countArg)) : 15;
+  const authorFlag = args.includes('--author') ? String(args[args.indexOf('--author') + 1] || '').toLowerCase() : null;
+  const sinceFlag = args.includes('--since') ? parseSince(args[args.indexOf('--since') + 1]) : null;
+  if (args.includes('--since') && sinceFlag === null) {
+    console.error('✗ Bad --since window. Use forms like 7d or 48h.');
+    return 1;
+  }
+  const full = args.includes('--full');
+  const json = args.includes('--json');
+
+  const aliases = loadAuthorAliases(business.root);
+  // Over-fetch when filtering so the filtered result can still reach `count`.
+  const fetchWant = authorFlag || sinceFlag ? 300 : count;
+  let posts = await fetchPosts(business.businessId, token, fetchWant);
+
+  if (sinceFlag) posts = posts.filter((p) => Date.parse(p.created_at) >= sinceFlag);
+  if (authorFlag) {
+    posts = posts.filter((p) => {
+      const label = authorLabel(p, aliases, selfId, selfEmail).toLowerCase();
+      return label.includes(authorFlag) || String(p.author_id || '').startsWith(authorFlag);
+    });
+  }
+  posts = posts.slice(0, count);
+
+  if (json) {
+    console.log(JSON.stringify(posts.map((p) => ({
+      id: p.id,
+      author: authorLabel(p, aliases, selfId, selfEmail),
+      type: p.post_type,
+      created_at: p.created_at,
+      content: p.content,
+    })), null, 2));
+    return 0;
+  }
+
+  if (!posts.length) {
+    console.log('No posts matched.');
+    return 0;
+  }
+
+  for (const p of posts) {
+    const when = String(p.created_at || '').slice(0, 16).replace('T', ' ');
+    const who = authorLabel(p, aliases, selfId, selfEmail);
+    if (full) {
+      console.log(`─── ${who} — ${when}`);
+      console.log(String(p.content || '').trim());
+      console.log('');
+    } else {
+      const oneLine = String(p.content || '').replace(/\s+/g, ' ').slice(0, 120);
+      console.log(`[${when}] ${who}: ${oneLine}`);
+    }
+  }
+  return 0;
+}
+
+module.exports = {
+  feedCommand,
+  findBusiness,
+  loadAuthorAliases,
+  parseSince,
+  authorLabel,
+  fetchPosts,
+};

package/commands/feedback.js

@@ -39,10 +39,15 @@ function getAuth() {
   return { token: creds.token, email: creds.email || 'unknown' };
 }
 
+function rejectMissingFeedbackMessage() {
+  console.error('Error: feedback message is required.');
+  printHelp(console.error);
+  process.exit(1);
+}
+
 async function submitFeedback(message, opts = {}) {
-  if (!message) {
-    console.error('Usage: atris feedback "your message here" [--business <slug|id>]');
-    process.exit(1);
+  if (!message || !String(message).trim()) {
+    rejectMissingFeedbackMessage();
   }
 
   const { token } = getAuth();
@@ -65,15 +70,20 @@ async function submitFeedback(message, opts = {}) {
     body,
   });
 
-  if (!result.ok) {
-    console.error(`Error: ${result.error || 'Failed to submit feedback'}`);
+  if (!result.ok || !result.data?.feedback_id) {
+    const parts = [];
+    if (result.error) parts.push(result.error);
+    if (result.data && typeof result.data === 'object') {
+      const serverMsg = result.data.detail || result.data.error || result.data.message;
+      if (serverMsg && serverMsg !== result.error) parts.push(String(serverMsg));
+    }
+    if (result.text && !result.data) parts.push(result.text.trim());
+    if (!parts.length) parts.push('Failed to submit feedback (no feedback_id returned)');
+    console.error(`Error: ${parts.join(' — ')}`);
     process.exit(1);
   }
 
-  console.log('Feedback submitted.');
-  if (result.data?.feedback_id) {
-    console.log(`  ID: ${result.data.feedback_id}`);
-  }
+  console.log(`Feedback submitted. ID: ${result.data.feedback_id}`);
 }
 
 async function fetchFeedbackItems({ token, businessId, limit = 100, status = null } = {}) {
@@ -279,7 +289,7 @@ function directFeedbackMessage(args) {
 }
 
 function rejectUnknownFeedbackCommand(subcommand) {
-  console.error(`Unknown feedback command: ${subcommand || '(empty)'}`);
+  fs.writeSync(2, `Unknown feedback command: ${subcommand || '(empty)'}\n`);
   printHelp(console.error);
   process.exit(1);
 }
@@ -293,9 +303,14 @@ async function feedbackCommand() {
     process.exit(1);
   }
 
+  if (args.length === 0) {
+    await listFeedback();
+    return;
+  }
+
   const subcommand = args[0];
 
-  if (!subcommand || subcommand === 'list') {
+  if (subcommand === 'list') {
     await listFeedback();
     return;
   }
@@ -306,7 +321,10 @@ async function feedbackCommand() {
   }
 
   if (subcommand === 'submit') {
-    const message = args.slice(1).join(' ');
+    const message = args.slice(1).join(' ').trim();
+    if (!message) {
+      rejectMissingFeedbackMessage();
+    }
     await submitFeedback(message, { businessId });
     return;
   }
@@ -328,6 +346,10 @@ async function feedbackCommand() {
     return;
   }
 
+  if (args.length === 1 && !String(args[0]).trim()) {
+    rejectMissingFeedbackMessage();
+  }
+
   const message = directFeedbackMessage(args);
   if (message) {
     await submitFeedback(message, { businessId });

package/commands/fleet-report.js

@@ -0,0 +1,206 @@
+/**
+ * atris fleet-report [business] [--all-alive] [--wake] [--dry-run]
+ *
+ * Deliver the daily report to business AI computers so every computer
+ * that is alive can see it at /workspace/atris/reports/daily-YYYY-MM-DD.md.
+ *
+ * Why push from the fleet side instead of a cron on the box: computers
+ * hold no API token on disk (Iron Dome P4 - /workspace persists, secrets
+ * never touch disk), so the fleet layer fetches the report with the
+ * owner token and writes it over the existing /terminal primitive.
+ *
+ *   atris fleet-report agentgrads --wake     # one computer, wake if asleep
+ *   atris fleet-report --all-alive           # every running computer (cron mode)
+ */
+
+const { loadCredentials } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+async function listBusinesses(token) {
+  const res = await apiRequestJson('/business/', { method: 'GET', token });
+  if (!res.ok) throw new Error(`Could not list businesses: ${res.status || res.error}`);
+  return res.data || [];
+}
+
+async function computerStatus(token, businessId) {
+  const res = await apiRequestJson(`/business/${businessId}/ai-computer/status`, {
+    method: 'GET',
+    token,
+  });
+  return res.ok ? res.data : null;
+}
+
+async function wakeComputer(token, businessId, maxWaitSec = 90) {
+  await apiRequestJson(`/business/${businessId}/ai-computer/wake`, { method: 'POST', token });
+  const start = Date.now();
+  while (Date.now() - start < maxWaitSec * 1000) {
+    await sleep(3000);
+    const status = await computerStatus(token, businessId);
+    if (status && status.status === 'running' && status.endpoint) return true;
+  }
+  return false;
+}
+
+async function fetchDailyReport(token, businessId) {
+  const res = await apiRequestJson(`/business/${businessId}/daily-report`, {
+    method: 'GET',
+    token,
+    timeoutMs: 60000,
+  });
+  if (!res.ok) throw new Error(`daily-report fetch failed: ${res.status || res.error}`);
+  return res.data;
+}
+
+async function writeReportToComputer(token, businessId, workspaceId, report) {
+  const date = report.date || new Date().toISOString().slice(0, 10);
+  const remotePath = `/workspace/atris/reports/daily-${date}.md`;
+  const b64 = Buffer.from(report.markdown || '', 'utf8').toString('base64');
+  const command =
+    `mkdir -p /workspace/atris/reports && ` +
+    `echo '${b64}' | base64 -d > ${remotePath} && ` +
+    `ln -sf ${remotePath} /workspace/atris/reports/latest.md && ` +
+    `echo WROTE:${remotePath}`;
+  if (command.length > 10000) {
+    throw new Error(`report too large for one terminal write (${command.length} chars)`);
+  }
+  const res = await apiRequestJson(`/business/${businessId}/workspaces/${workspaceId}/terminal`, {
+    method: 'POST',
+    token,
+    body: { command, timeout: 30 },
+    timeoutMs: 45000,
+  });
+  if (!res.ok) throw new Error(`terminal write failed: ${res.status || res.error}`);
+  const out = (res.data && (res.data.stdout || res.data.output)) || '';
+  if (!out.includes('WROTE:')) throw new Error(`terminal write not confirmed: ${out.slice(0, 200)}`);
+  return remotePath;
+}
+
+async function deliverToBusiness(token, biz, { wake, dryRun }) {
+  const label = biz.slug || biz.name || biz.id;
+  const status = await computerStatus(token, biz.id);
+  const running = status && status.status === 'running' && status.endpoint;
+
+  if (!running && !wake) {
+    console.log(`  ${label}: computer not alive, skipping`);
+    return { business: label, delivered: false, reason: 'asleep' };
+  }
+  if (!running && wake) {
+    process.stdout.write(`  ${label}: waking... `);
+    const ok = await wakeComputer(token, biz.id);
+    console.log(ok ? 'awake' : 'wake timeout');
+    if (!ok) return { business: label, delivered: false, reason: 'wake-timeout' };
+  }
+
+  const report = await fetchDailyReport(token, biz.id);
+  const board = report.scoreboard || null;
+  const pnl = board
+    ? ` | mrr $${board.revenue_mrr_usd} cost $${(board.compute_cost_usd + (board.ec2_cost_usd || 0)).toFixed(2)}/d profit $${board.profit_daily_usd}/d`
+    : '';
+  if (dryRun) {
+    console.log(`  ${label}: dry-run, report ${String(report.markdown || '').length} chars${pnl}`);
+    return { business: label, delivered: false, reason: 'dry-run', scoreboard: board };
+  }
+  const remotePath = await writeReportToComputer(token, biz.id, biz.workspace_id, report);
+  console.log(`  ${label}: delivered ${remotePath}${pnl}`);
+  return { business: label, delivered: true, path: remotePath, scoreboard: board };
+}
+
+async function leaderboard(token, businesses) {
+  const rows = [];
+  const pool = [...businesses];
+  const workers = Array.from({ length: 5 }, async () => {
+    let biz;
+    while ((biz = pool.shift())) {
+      try {
+        const report = await fetchDailyReport(token, biz.id);
+        const b = report.scoreboard;
+        if (b) rows.push({ slug: biz.slug || biz.name, ...b });
+      } catch {
+        /* business without a readable report stays off the board */
+      }
+    }
+  });
+  await Promise.all(workers);
+
+  rows.sort(
+    (a, b) =>
+      (b.revenue_collected_30d_usd || 0) - (a.revenue_collected_30d_usd || 0) ||
+      (b.profit_daily_usd || 0) - (a.profit_daily_usd || 0) ||
+      (b.revenue_mrr_usd || 0) - (a.revenue_mrr_usd || 0)
+  );
+
+  console.log('Computer leaderboard - collected 30d, then profit/day');
+  const fmt = (n) => `$${(n || 0).toFixed(2)}`;
+  rows.forEach((r, i) => {
+    console.log(
+      `  ${String(i + 1).padStart(2)}. ${r.slug.padEnd(22)} collected ${fmt(
+        r.revenue_collected_30d_usd
+      ).padStart(10)}  mrr ${fmt(r.revenue_mrr_usd).padStart(10)}  profit/d ${fmt(
+        r.profit_daily_usd
+      ).padStart(9)}`
+    );
+  });
+  if (rows.length === 0) console.log('  (no scoreboards yet)');
+}
+
+async function fleetReport() {
+  const args = process.argv.slice(3);
+  const allAlive = args.includes('--all-alive');
+  const wake = args.includes('--wake');
+  const dryRun = args.includes('--dry-run');
+  const board = args.includes('--leaderboard');
+  const slug = args.find((a) => !a.startsWith('--'));
+
+  if (!allAlive && !slug && !board) {
+    console.log('Usage: atris fleet-report <business> [--wake] | --all-alive [--dry-run] | --leaderboard');
+    process.exit(1);
+  }
+
+  const creds = loadCredentials();
+  if (!creds || !creds.token) {
+    console.error('Not logged in. Run: atris login');
+    process.exit(1);
+  }
+  const token = creds.token;
+
+  const businesses = await listBusinesses(token);
+  if (board) {
+    await leaderboard(token, businesses);
+    return;
+  }
+  const targets = allAlive
+    ? businesses
+    : businesses.filter(
+        (b) => b.slug === slug || (b.name || '').toLowerCase() === slug.toLowerCase()
+      );
+  if (targets.length === 0) {
+    console.error(`No business matching "${slug}"`);
+    process.exit(1);
+  }
+
+  console.log(`Fleet daily report - ${targets.length} target(s)`);
+  const results = [];
+  for (const biz of targets) {
+    try {
+      results.push(await deliverToBusiness(token, biz, { wake, dryRun }));
+    } catch (err) {
+      console.log(`  ${biz.slug || biz.name}: FAILED - ${err.message}`);
+      results.push({ business: biz.slug || biz.name, delivered: false, reason: err.message });
+    }
+  }
+  const delivered = results.filter((r) => r.delivered).length;
+  const boards = results.map((r) => r.scoreboard).filter(Boolean);
+  if (boards.length > 0) {
+    const mrr = boards.reduce((s, b) => s + (b.revenue_mrr_usd || 0), 0);
+    const profit = boards.reduce((s, b) => s + (b.profit_daily_usd || 0), 0);
+    console.log(`Fleet: $${mrr} MRR, $${profit.toFixed(2)}/day profit across ${boards.length} scoreboards`);
+  }
+  console.log(`Done: ${delivered}/${targets.length} delivered`);
+  process.exitCode = delivered > 0 || dryRun || results.every((r) => r.reason === 'asleep') ? 0 : 1;
+}
+
+module.exports = { fleetReport };

package/commands/github.js

@@ -0,0 +1,38 @@
+const { createOfficialCliCommand } = require('../lib/official-cli-integration');
+
+const githubCommand = createOfficialCliCommand({
+  name: 'github',
+  binary: 'gh',
+  versionArgs: ['--version'],
+  authArgs: ['auth', 'status'],
+  installHint: 'https://cli.github.com/',
+  loginHint: 'gh auth login',
+  commands: [
+    {
+      usage: 'pr list',
+      match: ['pr', 'list'],
+      forward: ['pr', 'list'],
+      description: 'list pull requests',
+    },
+    {
+      usage: 'pr create',
+      match: ['pr', 'create'],
+      forward: ['pr', 'create'],
+      description: 'create a pull request',
+    },
+    {
+      usage: 'pr checks',
+      match: ['pr', 'checks'],
+      forward: ['pr', 'checks'],
+      description: 'show pull request checks',
+    },
+    {
+      usage: 'pr view',
+      match: ['pr', 'view'],
+      forward: ['pr', 'view'],
+      description: 'show pull request details',
+    },
+  ],
+});
+
+module.exports = { githubCommand };