atris 3.35.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/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/gm.js

@@ -629,12 +629,35 @@ function render(state) {
   for (const command of state.next_commands) console.log(`- ${command}`);
 }
 
+// `gm <name>` is how people greet a team member in chat ("gm maze"). When the
+// positional names a real member (and not the manager persona), the same phrase
+// works in the terminal: wake that member instead of entering manager mode.
+function wakeableMember(args) {
+  const name = slugify(positional(args)[0]);
+  if (!name || name === 'game-manager' || flag(args, '--manager')) return null;
+  const memberDir = path.join(process.cwd(), 'atris', 'team', name);
+  if (!fs.existsSync(path.join(memberDir, 'MEMBER.md'))) return null;
+  return name;
+}
+
 async function gmCommand(...args) {
   if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
     showHelp();
     return;
   }
 
+  const member = wakeableMember(args);
+  if (member) {
+    const { isMemberAwake } = require('../lib/member-switches');
+    if (!isMemberAwake(member)) {
+      console.log(`${member} is asleep`);
+      return;
+    }
+    const { memberCommand } = require('./member');
+    const passthrough = args.filter(arg => arg !== member);
+    return memberCommand('wake', member, ...passthrough);
+  }
+
   const state = gmState(args);
   if (hasFlag(args, '--json')) {
     console.log(JSON.stringify(state, null, 2));

package/commands/goal.js

@@ -0,0 +1,247 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const SCOREBOARD_FILE = path.join('.atris', 'state', 'scoreboard.json');
+const TASK_PROJECTION_FILE = path.join('.atris', 'state', 'tasks.projection.json');
+
+function normalizeText(value) {
+  return String(value || '')
+    .replace(/[\u2013\u2014]/g, '-')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+function scoreboardPath(root = process.cwd()) {
+  return path.join(root, SCOREBOARD_FILE);
+}
+
+function emptyScoreboard() {
+  return { goal: null, metrics: [], updated_at: null };
+}
+
+function readScoreboard(root = process.cwd()) {
+  const file = scoreboardPath(root);
+  if (!fs.existsSync(file)) return emptyScoreboard();
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return {
+      goal: normalizeText(parsed?.goal) || null,
+      metrics: Array.isArray(parsed?.metrics)
+        ? parsed.metrics
+          .map((metric) => ({
+            name: normalizeText(metric?.name),
+            value: normalizeText(metric?.value),
+          }))
+          .filter((metric) => metric.name && metric.value)
+        : [],
+      updated_at: parsed?.updated_at || null,
+    };
+  } catch {
+    return emptyScoreboard();
+  }
+}
+
+function writeScoreboard(scoreboard, root = process.cwd()) {
+  const file = scoreboardPath(root);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const next = {
+    goal: normalizeText(scoreboard.goal),
+    metrics: Array.isArray(scoreboard.metrics) ? scoreboard.metrics : [],
+    updated_at: new Date().toISOString(),
+  };
+  const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(temp, `${JSON.stringify(next)}\n`, 'utf8');
+  fs.renameSync(temp, file);
+  return next;
+}
+
+function timestampMs(value) {
+  if (value === null || value === undefined || value === '') return null;
+  const numeric = Number(value);
+  if (Number.isFinite(numeric)) return numeric;
+  const parsed = new Date(value).getTime();
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function localDateKey(value) {
+  const ms = timestampMs(value);
+  if (ms === null) return null;
+  const date = new Date(ms);
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+function taskDoneTime(task) {
+  if (task?.done_at) return task.done_at;
+  const events = Array.isArray(task?.events) ? task.events : [];
+  const done = [...events].reverse().find((event) => ['completed', 'done', 'accepted'].includes(
+    normalizeText(event?.event_type),
+  ));
+  return done?.created_at || null;
+}
+
+function readTaskMovement(root = process.cwd(), now = new Date()) {
+  const file = path.join(root, TASK_PROJECTION_FILE);
+  if (!fs.existsSync(file)) return { available: false, landed: 0, review: 0 };
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!Array.isArray(parsed?.tasks)) return { available: false, landed: 0, review: 0 };
+    const today = localDateKey(now);
+    return {
+      available: true,
+      landed: parsed.tasks.filter((task) => (
+        normalizeText(task?.status) === 'done'
+        && localDateKey(taskDoneTime(task)) === today
+      )).length,
+      review: parsed.tasks.filter((task) => normalizeText(task?.status) === 'review').length,
+    };
+  } catch {
+    return { available: false, landed: 0, review: 0 };
+  }
+}
+
+function readMissionMovement(root = process.cwd(), now = new Date()) {
+  const file = path.join(root, '.atris', 'state', 'missions.jsonl');
+  if (!fs.existsSync(file)) return { available: false, completed: 0 };
+  try {
+    const { listMissions } = require('./mission');
+    const today = localDateKey(now);
+    const completed = listMissions(root).filter((mission) => (
+      ['complete', 'completed'].includes(normalizeText(mission?.status))
+      && localDateKey(mission?.completed_at || mission?.updated_at) === today
+    )).length;
+    return { available: true, completed };
+  } catch {
+    return { available: false, completed: 0 };
+  }
+}
+
+function plural(count, singular) {
+  return `${count} ${singular}${count === 1 ? '' : 's'}`;
+}
+
+function todayText(tasks, missions) {
+  const parts = [];
+  if (tasks.available) {
+    parts.push(`${plural(tasks.landed, 'task')} landed`);
+    parts.push(`${tasks.review} waiting for your ok`);
+  }
+  if (missions.available) parts.push(`${plural(missions.completed, 'mission')} completed`);
+  return parts.length ? parts.join(', ') : 'no movement recorded today';
+}
+
+function buildGoalView(root = process.cwd(), now = new Date()) {
+  const scoreboard = readScoreboard(root);
+  const tasks = readTaskMovement(root, now);
+  const missions = readMissionMovement(root, now);
+  const today = todayText(tasks, missions);
+  const next = tasks.review > 0
+    ? 'atris task reviews'
+    : scoreboard.goal
+      ? 'atris task day'
+      : 'atris goal set "<sentence>"';
+  return {
+    goal: scoreboard.goal,
+    metrics: scoreboard.metrics,
+    today,
+    next,
+  };
+}
+
+function row(label, value) {
+  return `  ${label.padEnd(10)}${value}`;
+}
+
+function renderGoalView(view) {
+  const goal = view.goal || 'goal not set. set it: atris goal set "<sentence>"';
+  const lines = [row('goal', goal)];
+  if (view.metrics.length > 0) {
+    lines.push(row('distance', view.metrics.map((metric) => `${metric.name}: ${metric.value}`).join(' | ')));
+  }
+  lines.push(row('today', view.today));
+  lines.push(row('next', view.next));
+  return lines.join('\n');
+}
+
+function printHelp() {
+  console.log('usage: atris goal [--json]');
+  console.log('       atris goal set "<sentence>"');
+  console.log('       atris goal metric <name> <value>');
+  console.log('       atris goal metric <name> --rm');
+}
+
+function run(args = [], context = {}) {
+  const root = context.cwd || process.cwd();
+  const now = context.now || new Date();
+  const command = args[0];
+
+  try {
+    if (args.includes('--help') || args.includes('-h') || command === 'help') {
+      printHelp();
+      return 0;
+    }
+
+    if (command === 'set') {
+      const goal = normalizeText(args.slice(1).join(' '));
+      if (!goal) {
+        console.error('error: goal sentence is required');
+        return 2;
+      }
+      const scoreboard = readScoreboard(root);
+      writeScoreboard({ ...scoreboard, goal }, root);
+      console.log('goal set.');
+      return 0;
+    }
+
+    if (command === 'metric') {
+      const name = normalizeText(args[1]);
+      if (!name) {
+        console.error('error: metric name is required');
+        return 2;
+      }
+      const scoreboard = readScoreboard(root);
+      const metrics = scoreboard.metrics.filter((metric) => metric.name !== name);
+      if (args.includes('--rm')) {
+        writeScoreboard({ ...scoreboard, metrics }, root);
+        console.log(`metric ${name} removed.`);
+        return 0;
+      }
+      const value = normalizeText(args.slice(2).join(' '));
+      if (!value) {
+        console.error('error: metric value is required');
+        return 2;
+      }
+      metrics.push({ name, value });
+      writeScoreboard({ ...scoreboard, metrics }, root);
+      console.log(`metric ${name} set.`);
+      return 0;
+    }
+
+    if (command && command !== '--json') {
+      console.error(`error: unknown goal command: ${normalizeText(command)}`);
+      return 2;
+    }
+
+    const view = buildGoalView(root, now);
+    console.log(args.includes('--json') ? JSON.stringify(view, null, 2) : renderGoalView(view));
+    return 0;
+  } catch (error) {
+    console.error(`error: ${normalizeText(error?.message || error)}`);
+    return 2;
+  }
+}
+
+module.exports = {
+  SCOREBOARD_FILE,
+  buildGoalView,
+  readScoreboard,
+  renderGoalView,
+  run,
+  scoreboardPath,
+  writeScoreboard,
+};