atris 3.82.12 → 3.82.15

package/commands/growth.js

@@ -0,0 +1,151 @@
+'use strict';
+
+const { spawn } = require('node:child_process');
+const { apiRequestJson } = require('../utils/api');
+const { loadCredentials } = require('../utils/auth');
+const { NOT_LOGGED_IN, wantsHelp, wantsJson, tokenFrom, oneLine, printResult } = require('../lib/developer-api');
+
+const PAGE_URL = 'https://atris.ai/dashboard/growth';
+const NOT_FOUNDER = 'the growth room is only for the Atris team. sign in with a team account: atris login';
+
+function showGrowthHelp() {
+  console.log('usage: atris growth [--json | --open]');
+  console.log('       atris growth note "what you did" [--day YYYY-MM-DD]');
+  console.log('signups, people, paying, revenue, cli installs and countries, the same numbers as the growth page.');
+  console.log('  --open   open the growth page in your browser');
+  console.log('  --json   print the full numbers once as one json object');
+  console.log('  note     save a dated note that shows on the growth charts');
+}
+
+const count = (value) => Number(value || 0).toLocaleString('en-US');
+
+/** "up 50%" against the week before; empty when there is nothing to compare with. */
+function change(now, before) {
+  const a = Number(now || 0);
+  const b = Number(before || 0);
+  if (!b) return '';
+  const percent = Math.round(((a - b) / b) * 100);
+  if (percent === 0) return ', flat';
+  return `, ${percent > 0 ? 'up' : 'down'} ${Math.abs(percent)}%`;
+}
+
+function shortDay(day) {
+  const date = new Date(`${day}T12:00:00Z`);
+  if (Number.isNaN(date.getTime())) return String(day || '');
+  return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', timeZone: 'UTC' });
+}
+
+/** The growth numbers as a few short lines. */
+function growthText(data = {}) {
+  const totals = data.totals || {};
+  const lines = [
+    `signups   ${count(totals.signups_today)} today, ${count(totals.signups_7d)} last 7 days${change(totals.signups_7d, totals.signups_prev_7d)}, ${count(totals.signups_30d)} last 30`,
+    `people    ${count(totals.people)} total, ${count(totals.paying)} paying`,
+    `revenue   $${count(Math.round(Number(totals.mrr_usd || 0)))} a month`,
+  ];
+  const cli = data.cli_installs;
+  if (cli) lines.push(`installs  ${count(cli.last_7d)} last 7 days${change(cli.last_7d, cli.prev_7d)}`);
+
+  const countries = Array.isArray(data.countries) ? data.countries.slice(0, 5) : [];
+  lines.push(countries.length
+    ? `places    ${countries.map((row) => `${row.country} ${count(row.people)}`).join(', ')}`
+    : 'places    none recorded yet');
+
+  const marks = Array.isArray(data.marks) ? data.marks.slice(0, 5) : [];
+  if (marks.length) {
+    lines.push(`marked    ${marks.map((mark) => (mark.people ? `${mark.label} ${count(mark.people)}` : mark.label)).join(', ')}`);
+  }
+  const notes = Array.isArray(data.notes) ? data.notes.slice(0, 3) : [];
+  notes.forEach((note, index) => {
+    lines.push(`${index === 0 ? 'notes   ' : '        '}  ${shortDay(note.day)}  ${oneLine(note.text)}`);
+  });
+  lines.push(`page      ${PAGE_URL}`);
+  return lines.join('\n');
+}
+
+function openPage(url) {
+  const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+  try {
+    const child = spawn(opener, args, { stdio: 'ignore', detached: true });
+    child.on('error', () => {});
+    child.unref();
+  } catch {
+    // The address is printed either way.
+  }
+}
+
+/** Pull `note "text" [--day YYYY-MM-DD]` apart; null text means the note is missing. */
+function readNote(args) {
+  const rest = args.slice(1).filter((arg) => arg !== '--json');
+  const at = rest.indexOf('--day');
+  let day;
+  if (at !== -1) {
+    day = rest[at + 1];
+    rest.splice(at, 2);
+  }
+  return { text: rest.join(' ').trim(), day };
+}
+
+function failure(result) {
+  const status = Number(result && result.status);
+  if (status === 401 || status === 403) return NOT_FOUNDER;
+  return oneLine(result && result.error);
+}
+
+async function growthCommand(args = [], deps = {}) {
+  if (wantsHelp(args)) {
+    showGrowthHelp();
+    return 0;
+  }
+  const json = wantsJson(args);
+  const io = { log: deps.log || console.log, err: deps.err || console.error };
+  const fail = (error, extra = {}) => {
+    printResult({ json, ok: false, error, payload: { ok: false, error, ...extra } }, io);
+    return 1;
+  };
+
+  if (args.includes('--open')) {
+    (deps.openPage || openPage)(PAGE_URL);
+    printResult({ json, ok: true, text: PAGE_URL, payload: { ok: true, url: PAGE_URL } }, io);
+    return 0;
+  }
+
+  const token = tokenFrom((deps.loadCredentials || loadCredentials)());
+  if (!token) return fail(NOT_LOGGED_IN);
+  const request = deps.apiRequestJson || apiRequestJson;
+
+  try {
+    if (args[0] === 'note') {
+      const { text, day } = readNote(args);
+      if (!text) return fail('say what you did: atris growth note "posted the launch video"');
+      if (text.length > 280) return fail('keep a note under 280 characters');
+      if (day !== undefined && !/^\d{4}-\d{2}-\d{2}$/.test(String(day))) return fail('write the day as YYYY-MM-DD');
+      const result = await request('/admin/growth/notes', {
+        method: 'POST',
+        token,
+        retries: 0, // a retry could save the same note twice
+        body: day ? { text, day } : { text },
+      });
+      if (!result || !result.ok) return fail(failure(result), { status: result && result.status });
+      const saved = result.data || {};
+      printResult({
+        json,
+        ok: true,
+        text: `noted for ${shortDay(saved.day || day)}: ${oneLine(saved.text || text)}`,
+        payload: { ok: true, note: saved },
+      }, io);
+      return 0;
+    }
+
+    const result = await request('/admin/growth/overview?days=28', { method: 'GET', token });
+    if (!result || !result.ok) return fail(failure(result), { status: result && result.status });
+    const data = result.data || {};
+    printResult({ json, ok: true, text: growthText(data), payload: { ok: true, ...data } }, io);
+    return 0;
+  } catch (error) {
+    return fail(oneLine(error && error.message));
+  }
+}
+
+module.exports = { growthCommand, growthText, showGrowthHelp };

package/commands/memory-live.js

@@ -1,6 +1,6 @@
 'use strict';
 
-// atris memory show, search, read, ls, remember, write, rm, usage, log, lesson
+// atris memory show, search, ask, read, ls, remember, write, rm, usage, log, lesson
 // and agents: the person's Atris memory from any terminal, so any agent can
 // read it, search it and save to it. One request per command. The login and
 // network modules load only when a command needs the server.
@@ -13,6 +13,7 @@ const { NOT_LOGGED_IN, oneLine, tokenFrom } = require('../lib/developer-api');
 const MAX_WRITE_BYTES = 1000000;
 const STDIN_WAIT_MS = 5000;
 const REMEMBER_MAX_CHARS = 1000;
+const ASK_MAX_CHARS = 500;
 const REMEMBER_FILES = ['journal', 'now', 'learning'];
 const LEARNING_SECTIONS = ['want', 'understand', 'shaky'];
 
@@ -138,6 +139,20 @@ const COMMANDS = {
     },
   },
 
+  ask: {
+    check(ctx) {
+      const question = ctx.words.join(' ').replace(/\s+/g, ' ').trim();
+      if (!question) throw new UsageError('ask a question, like atris memory ask "where does Sam work?"');
+      if (question.length > ASK_MAX_CHARS) throw new UsageError('keep the question under 500 characters');
+      return { question, folder: ctx.flags['--in'] || '' };
+    },
+    async run(ctx, { question, folder }) {
+      // The server reads for up to 75 seconds; asking twice would count twice.
+      const data = await ctx.call(`/memory/ask?q=${enc(question)}${folder ? `&folder=${enc(folder)}` : ''}`, { timeoutMs: 90000, retries: 0 });
+      return { data, lines: live.askLines(data) };
+    },
+  },
+
   read: {
     check(ctx) {
       const rel = onePath(ctx, 'file to read');

package/commands/push.js

@@ -9,6 +9,17 @@ const { normalizeWikiOnlyPrefix } = require('../lib/wiki');
 const { emitSyncEvent, startTimer } = require('../lib/sync-telemetry');
 const { assertSafeWorkspaceRoot } = require('../lib/workspace-safety');
 
+// The server's own words for a refused request. It used to be dropped, so a
+// refusal for any reason read as "you can only push to your team/ folder".
+function refusalText(result) {
+  if (!result) return '';
+  const raw = result.errorMessage || result.error || (result.data && result.data.detail) || '';
+  if (!raw) return '';
+  if (typeof raw === 'string') return raw === 'Request failed' ? '' : raw;
+  if (typeof raw === 'object' && typeof raw.message === 'string') return raw.message;
+  try { return JSON.stringify(raw); } catch { return String(raw); }
+}
+
 function resolvePushSourceDir({ slug, argv = process.argv, cwd = process.cwd() }) {
   const fromIdx = argv.indexOf('--from');
   if (fromIdx !== -1 && argv[fromIdx + 1]) {
@@ -858,13 +869,15 @@ async function pushAtris() {
               pushed = landedPaths.size;
               break;
             } else {
-              console.error(`\n  Push failed: ${retry.errorMessage || retry.error || retry.status}`);
+              console.error(`\n  Push failed: ${refusalText(retry) || retry.status}`);
+              if (refusalText(result)) console.error(`  The first refusal said: ${refusalText(result)}`);
               await emit('access_denied', { error_detail: `403 retry failed: ${retry.status}` });
               process.exit(1);
             }
           } else {
-            console.error('\n  Access denied: you can only push to your team/ folder.');
-            await emit('access_denied');
+            const reason = refusalText(result);
+            console.error(`\n  Access denied: ${reason || 'the server refused this push and gave no reason.'}`);
+            await emit('access_denied', reason ? { error_detail: reason } : undefined);
             process.exit(1);
           }
         } else if (result.status === 409) {
@@ -1052,6 +1065,7 @@ async function pushAtris() {
 }
 
 module.exports = {
+  refusalText,
   pushAtris,
   buildPushChangePlan,
   buildPushUploadBatches,

package/lib/auto-accept-certified.js

@@ -715,12 +715,12 @@ function runVerifyCommandCached(verify, workspaceRoot, cache = null) {
 // root: one scan covers every task in a sweep.
 const repoHygieneCache = new Map();
 
-function repoHygieneGate(workspaceRoot) {
+function repoHygieneGate(workspaceRoot, skillScope = null) {
   const root = path.resolve(workspaceRoot || process.cwd());
   // Skill receipts are mutable workspace state, so recompute this gate before
   // consulting the repo-wide dead-code cache. A new receipt can unblock a
   // landing, while a later SKILL.md edit must make an older receipt stale.
-  const skillEval = skillEvalGate(root);
+  const skillEval = skillEvalGate(root, skillScope || {});
   if (!skillEval.ok) return skillEval;
   if (repoHygieneCache.has(root)) return repoHygieneCache.get(root);
   let result = { ok: true, skipped: true };
@@ -755,8 +755,17 @@ function repoHygieneGate(workspaceRoot) {
 
 // Shared by both landing lanes so the check cannot ship in one dispatch branch
 // and silently skip the sibling (lesson: parallel-paths-drift).
-function hygieneBlockResult(task, ref) {
-  const hygiene = repoHygieneGate(task.workspace_root || process.cwd());
+// A job answers for the skills it changed. When its exact file list is on
+// record (the same list the taste check just read), only those files count,
+// read where the job's branch is checked out. With no list on record the
+// workspace-wide check stays, so an unevaluated skill is never waved through.
+function jobSkillScope(task, candidateGate) {
+  if (!candidateGate || candidateGate.advisory_only || !Array.isArray(candidateGate.paths)) return null;
+  return { changeRoot: candidateWorkspaceRoot(task), paths: candidateGate.paths };
+}
+
+function hygieneBlockResult(task, ref, candidateGate = null) {
+  const hygiene = repoHygieneGate(task.workspace_root || process.cwd(), jobSkillScope(task, candidateGate));
   if (hygiene.ok) return null;
   return {
     eligible: false,
@@ -1360,7 +1369,7 @@ function evaluateAutoAccept(task, options = {}) {
     if (executeVerify) {
       candidateGate = candidatePolicyGate(task, { verifyCache, executeDetectors: true });
       if (!candidateGate.ok) return { ...candidateGate, ref };
-      const hygieneBlock = hygieneBlockResult(task, ref);
+      const hygieneBlock = hygieneBlockResult(task, ref, candidateGate.gate);
       if (hygieneBlock) return hygieneBlock;
     }
     return {
@@ -1444,7 +1453,7 @@ function evaluateAutoAccept(task, options = {}) {
   if (executeVerify) {
     candidateGate = candidatePolicyGate(task, { verifyCache, executeDetectors: true });
     if (!candidateGate.ok) return { ...candidateGate, ref };
-    const hygieneBlock = hygieneBlockResult(task, ref);
+    const hygieneBlock = hygieneBlockResult(task, ref, candidateGate.gate);
     if (hygieneBlock) return hygieneBlock;
   }
 

package/lib/known-commands.js

@@ -3,7 +3,7 @@
 const knownCommands = ['init', 'guide', 'doctor', 'doc-health', 'install', 'workspace', 'log', 'logs', 'later', 'idea', 'done', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', '99', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'revisions', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'team', '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', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'tree', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube', 'x-search',
-                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'campaign', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'sentinel', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'scoreboard', 'scorecard', 'rating', 'sync-checkout', 'zen',
+                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'campaign', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'sentinel', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'scoreboard', 'growth', 'scorecard', 'rating', 'sync-checkout', 'zen',
                        'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'memory', 'balance', 'usage', 'spend', 'api-key', 'agent-client', 'topup', 'buy', 'transactions', 'hire', 'hires', 'mail', 'design', 'mcp', 'gmail', 'google', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
                        'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'link', 'playbook', 'feed', 'brief', 'social', 'host', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join', 'rsi', 'pay', 'trust'];
 

package/lib/memory-live.js

@@ -9,7 +9,7 @@ const fs = require('fs');
 const path = require('path');
 
 const LIVE_COMMANDS = new Set([
-  'show', 'search', 'read', 'ls', 'remember', 'write', 'rm', 'usage', 'log', 'lesson', 'agents', 'setup',
+  'show', 'search', 'ask', 'read', 'ls', 'remember', 'write', 'rm', 'usage', 'log', 'lesson', 'agents', 'setup',
 ]);
 
 function isLiveCommand(word) {
@@ -19,10 +19,11 @@ function isLiveCommand(word) {
 // One line per command, shown together by `atris memory` and one at a time by
 // `atris memory <command> --help`.
 const COLUMN = 38;
-const row = (form, ...what) => [`  ${form}`.padEnd(COLUMN) + what[0], ...what.slice(1).map((more) => ' '.repeat(COLUMN) + more)].join('\n');
+const row = (form, ...what) => [`  ${form} `.padEnd(COLUMN) + what[0], ...what.slice(1).map((more) => ' '.repeat(COLUMN) + more)].join('\n');
 const USAGE_LINES = {
   show: row('show', 'who they are and what matters now; read it before helping'),
   search: row('search "rent|lease" [--in folder]', 'lines with any of the words, split by |'),
+  ask: row('ask "a question" [--in folder]', 'answered from their memory, with the lines it rests on'),
   read: row('read <path> [--from N] [--lines N]', 'numbered lines of one file; --raw prints it as stored'),
   ls: row('ls [folder]', 'what is in a folder; MAP.md says what is where'),
   remember: row('remember "one short line"', 'a lasting fact or preference about the person, when they',
@@ -43,6 +44,7 @@ const LIVE_HELP = [
   'read',
   USAGE_LINES.show,
   USAGE_LINES.search,
+  USAGE_LINES.ask,
   USAGE_LINES.read,
   USAGE_LINES.ls,
   '',
@@ -62,6 +64,7 @@ const LIVE_HELP = [
 // Flags that take a value, per command. --json, --raw and --help take none.
 const VALUE_FLAGS = {
   search: ['--in'],
+  ask: ['--in'],
   read: ['--from', '--lines'],
   ls: [],
   show: [],
@@ -205,6 +208,26 @@ function searchLines(query, data) {
   return lines;
 }
 
+// The answer first, then each line it rests on, then how sure it is. With no
+// answer (the model was busy) the search hits it started from are shown.
+function askLines(data) {
+  const sources = (data && data.sources) || [];
+  const cite = sources.map((s) => `  ${s.path}:${s.n}: ${s.text}`);
+  if (data && data.answer && data.found) {
+    return [String(data.answer), ...(cite.length ? ['', 'From:', ...cite] : [])];
+  }
+  if (data && data.answer) {
+    const lines = [String(data.answer)];
+    if (cite.length) lines.push('', 'Closest lines:', ...cite);
+    lines.push('', 'Not found for certain. Search it yourself: atris memory search "word|other word"');
+    return lines;
+  }
+  const hits = (data && data.search && data.search.hits) || [];
+  const lines = [String((data && data.note) || 'No answer right now.')];
+  if (hits.length) lines.push('', 'Lines that may hold it:', ...hits.slice(0, 8).map((h) => `  ${h.path}:${h.n}: ${h.text}`));
+  return lines;
+}
+
 function readLines(data) {
   const page = (data && data.lines) || [];
   const total = Number(data && data.total) || 0;
@@ -244,7 +267,7 @@ function rulesBlock(agent) {
     '',
     'This person keeps one memory in Atris that every app and agent shares. Use it.',
     '- Start each task with `atris memory show`: who they are and what matters now.',
-    '- Before you ask them anything they may have said before, search: `atris memory search "word|other word"`.',
+    '- Before you ask them anything they may have said before, search: `atris memory search "word|other word"`, or ask in plain words: `atris memory ask "..."`.',
     '- Open what you find with `atris memory read <path>`. `atris memory ls` shows the folder.',
     '- When they say remember, note, save or don\'t forget, save one short line: `atris memory remember "..."`.',
     '- Save only lasting facts about them, never logs or your own work. Never rewrite their about.md.',
@@ -338,6 +361,7 @@ module.exports = {
   END,
   LIVE_HELP,
   USAGE_LINES,
+  askLines,
   isLiveCommand,
   lsLines,
   mcpLines,

package/lib/skill-eval-gate.js

@@ -187,12 +187,47 @@ function validateSkillEvalReceipt(receipt, skill) {
   return { ok: true, receipt_at_ms: receiptAtMs };
 }
 
-function skillEvalGate(workspaceRoot = process.cwd()) {
+// The learner writes these notes itself after verified runs (see
+// writeAutoLearnedSkill in lib/mission-core.js). No job authors them, so they
+// never count against a job whose own file list is unknown.
+const LEARNER_NOTE_PATTERN = /(^|\/)skills\/auto-learned\/SKILL\.md$/;
+
+function normalizedScopePaths(paths) {
+  if (!Array.isArray(paths)) return null;
+  return paths
+    .map((entry) => String(entry || '').trim().replace(/\\/g, '/').replace(/\/+$/, ''))
+    .filter(Boolean);
+}
+
+// A job answers for the skills it changed, not for every skill file that
+// happens to sit changed in the workspace. Eight learner notes nobody had
+// evaluated held seven finished jobs for five days (2026-11-04 to 11-09)
+// while none of those jobs touched a skill.
+//   scope.paths      the job's exact file list, when it is on record. Only
+//                    skills inside it count, learner notes included.
+//   scope.changeRoot where the job's branch is checked out, when that is not
+//                    the workspace itself.
+// With no file list every changed skill still counts, except learner notes.
+function skillsInScope(root, scope = {}) {
+  const changeRoot = path.resolve(scope.changeRoot || root);
+  const jobPaths = normalizedScopePaths(scope.paths);
+  return changedSkillFiles(changeRoot).filter((skill) => {
+    if (!jobPaths) return !LEARNER_NOTE_PATTERN.test(skill.path);
+    return jobPaths.some((entry) => skill.path === entry || skill.path.startsWith(`${entry}/`));
+  });
+}
+
+function skillEvalGate(workspaceRoot = process.cwd(), scope = {}) {
   const root = path.resolve(workspaceRoot);
-  const skills = changedSkillFiles(root);
+  const changeRoot = path.resolve((scope && scope.changeRoot) || root);
+  const skills = skillsInScope(root, scope || {});
   if (!skills.length) return { ok: true, skipped: true, skills: [] };
 
-  const receipts = readSkillEvalReceipts(root);
+  // Evaluations are saved in the workspace; one run from the branch's own
+  // checkout is saved there instead. Either proves the skill was judged.
+  const receipts = changeRoot === root
+    ? readSkillEvalReceipts(root)
+    : [...readSkillEvalReceipts(root), ...readSkillEvalReceipts(changeRoot)];
   const missing = [];
   const accepted = [];
   for (const skill of skills) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.82.12",
+  "version": "3.82.15",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof. project memory your coding agents share across sessions.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",