atris 3.82.12 → 3.82.14

package/atris/skills/README.md

@@ -55,6 +55,7 @@ Each line says what the skill does and when to open it. A skill with a review po
 - Backend rules that keep code simple. Open [backend](backend/SKILL.md) when you build an API or service. Policy: `policies/atris-backend.md`.
 - Essay process with gates. Open [writing](writing/SKILL.md) when you draft an essay or long post. Policy: `policies/writing.md`.
 - Find and fix generated-sounding writing. Open [copy-editor](copy-editor/SKILL.md) when you edit a draft before it ships.
+- Cut interface text that should not be on the screen. Open [clean-copy](clean-copy/SKILL.md) when you write or review labels, hints, empty states or button text.
 - Content written to get cited by AI answer engines. Open [aeo](aeo/SKILL.md) when a page should show up in AI answers.
 - Write a release post. Open [launch](launch/SKILL.md) after a release ships.
 - Author Atris block documents: docs, decks and reports. Open [blocks](blocks/SKILL.md) when you write a doc for the Atris editor.

package/atris/skills/clean-copy/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: clean-copy
+description: Cut interface copy that should not exist. Captions that restate a label, hints that answer a worry the user never had, lines that defend a choice or give permission for a button already on screen. Use when writing or reviewing any user-facing string (labels, hints, empty states, toasts, confirmations, button text) or when asked to clean up or tighten copy. Triggers on clean copy, tighten copy, cut copy, review strings, too much text, ui copy.
+version: 1.1.0
+tags:
+  - copy
+  - interface
+  - writing
+  - quality
+---
+
+# Cleaning copy
+
+Most bad copy is not badly written. It is copy that should not be on the screen. Editing it for tone just makes the wrong thing read better. The first question is never "how should this be phrased". It is **should this exist**.
+
+Every example below is a real line from an Atris screen and what happened to it.
+
+## The ladder
+
+Walk a string down these in order. Stop at the first one that fires. Cut the string or cut the part that fired.
+
+1. **Does this need to surface at all?**
+   Would the user ever have wondered about this, unprompted? If not, you are not answering a question. You are planting one. Under the theme picker sat "Theme changes apply instantly across the entire app". Nobody picks a theme wondering whether it will reach the whole app. The line went and the picker lost nothing.
+
+2. **Does the caption need to exist?**
+   A caption earns its place only when the thing beside it is meaningless without it. A checkbox labelled "Require sign-in" had "Users must sign in before accessing this app." beneath it. A heading "Recent payments" had "The latest payments received by this business." Both went. A bare "30" does need "minutes" beside it. That one stays.
+
+3. **Is it answering something the user would never have had to consider?**
+   The tell: copy that rules out a failure, defends a choice or hedges about something that simply works.
+
+   > Bring the existing site into blocks.
+   > *Your current index.html will become one custom HTML block, so every byte stays intact.*
+
+   The first half says what will happen. The second half denies a loss the user had not imagined until we named it. A list of job postings said "Every link is a real posting." An error said "Could not regenerate the scoreboard. Your current one is unchanged." Each one hands the reader a worry they arrived without. The same goes for a line that remembers an old bug. **The fix for a fixed bug is the fix. Not a caption about the fix.**
+
+4. **Rewrite to remove the part that fired. If nothing is left, delete the element.**
+   Do not preserve a hint just because there was a hint there. An empty `hint` prop comes off the component. An explanatory `<p>` gets deleted, not shortened to a stub.
+
+## What survives
+
+Copy stays when the user cannot act without it. These lines went through the same review and stayed word for word:
+
+- A real consequence at the moment of choosing. *"Remove Dana from the team? Their notes are kept."* They need it before they click and they cannot infer it.
+- A fact about scope they cannot see. *"Visitor chat history from the last 90 days."* Nothing else on the page says where the history stops.
+- What a blank or stuck state means and what to do next. *"This computer is asleep. Send it one message to wake it, then come back."*
+- Units, scale or format on a bare value.
+
+A line can be half of each. *"Only work you start uses it. Your teammates never do, and you can disconnect any time."* The first part is scope the user cannot see. The last part tells them they may press a Disconnect button that is already on the screen. Keep the scope. Cut the permission slip.
+
+## Working style
+
+- Read the string next to what is on screen around it: the label, the value, the button. Redundancy is invisible when you read the string alone.
+- Cut whole clauses, not words. Noticing which half of a two-sentence hint does no work beats trimming three words from both halves.
+- When reviewing a batch, report as `file:line` with the current string and either the rewrite or `cut`. Say in a few words which rung it failed. Do not rewrite copy that passes.
+- If a string matters only in a rare state, consider whether it belongs in that state instead of sitting on the page all the time.
+
+## Get a second reader before you cut
+
+Cutting is easy to overdo. On the first real run the first reader marked 40 lines and a second reader kept 15 of them, mostly lines about billing and failed states that told the user something they could not see.
+
+- Hand the batch to a second reader on a different model. Give it the strings and this skill, not your verdicts or your reasons.
+- Mix in lines you are sure should stay. A reader that cuts those is cutting too much and its other verdicts are not worth much.
+- Change a line only where both readers agree. When they disagree the line stays.
+
+## After the cut
+
+- A removed line takes its spacing with it. Look at the gap it leaves between the heading and the button.
+- Tests often quote the old string. Search for it before you run them.
+
+## Go deeper
+
+- [../copy-editor/SKILL.md](../copy-editor/SKILL.md): fixes how a sentence reads. Run this skill first, since a deleted string needs no editing.
+- [../taste/SKILL.md](../taste/SKILL.md): where the taste of the people you work for lives.
+- [../design/SKILL.md](../design/SKILL.md): the visual rules for the screen the copy sits on.

package/bin/atris.js

@@ -666,6 +666,7 @@ function showHelpAll() {
   console.log('  meet       - onboard a stranger in one sitting and print their /book link');
   console.log('  avail      - Booking availability (/book/{username} weekly windows)');
   console.log('  scoreboard - Today\'s github contributions vs your best day, streak, repo commits (--watch, --json)');
+  console.log('  growth     - Signups, paying, revenue, cli installs and countries, same as the growth page (--open, --json, note "...")');
   console.log('  scorecard  - Which AI can do your team\'s work: past changes graded by their own tests, run on your Claude plan (find, run, show)');
   console.log('  rating     - The Atris Rating, 25 to 99: how much real work each engine and member finishes (atris rating opus)');
   console.log('  brain      - Compile MAP/TODO/wiki/state into a loadable agent brain');
@@ -2253,6 +2254,10 @@ if (command === 'guide') {
   Promise.resolve().then(() => require('../commands/scoreboard').scoreboardCommand(process.argv.slice(3)))
     .then((code) => exitAfterStdoutDrain(typeof code === 'number' ? code : 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'growth') {
+  Promise.resolve().then(() => require('../commands/growth').growthCommand(process.argv.slice(3)))
+    .then((code) => exitAfterStdoutDrain(typeof code === 'number' ? code : 0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'scorecard') {
   Promise.resolve().then(() => require('../commands/scorecard').scorecardCommand(process.argv.slice(3)))
     .then((code) => exitAfterStdoutDrain(typeof code === 'number' ? code : 0))

package/commands/autoland.js

@@ -830,6 +830,25 @@ function acceptedNotLandedNote(receipt) {
   return `, ${rows.length} accepted but not proven landed (${rows.map((r) => `${r.ref} ${r.status}`).join(', ')})`;
 }
 
+// Every job a run leaves waiting keeps its reason. Counts alone hid one cause
+// holding every finished job for five days: the record said "8 skipped" and
+// nothing on disk said why.
+function waitingReasonRows(results) {
+  return (Array.isArray(results) ? results : [])
+    .filter((row) => row && row.action === 'skipped' && row.ref)
+    .map((row) => ({ ref: String(row.ref), reason: String(row.reason || 'unknown') }));
+}
+
+function waitingReasonSummary(receipt) {
+  const rows = Array.isArray(receipt.waiting_reasons) ? receipt.waiting_reasons : [];
+  const counts = new Map();
+  for (const row of rows) counts.set(row.reason, (counts.get(row.reason) || 0) + 1);
+  return [...counts.entries()]
+    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+    .map(([reason, count]) => `${count} ${reason}`)
+    .join(', ');
+}
+
 function stuckBacklogNote(receipt) {
   const parts = [];
   const scanned = Number(receipt.scanned || 0);
@@ -838,7 +857,8 @@ function stuckBacklogNote(receipt) {
   // separately (accepted_not_landed), not misread as a wedged queue.
   const accepted = Array.isArray(receipt.accepted) ? receipt.accepted.length : receipt.landed.length;
   if (scanned > 0 && accepted === 0) {
-    parts.push(`${certified}/${scanned} certified in review, none landed`);
+    const why = waitingReasonSummary(receipt);
+    parts.push(`${certified}/${scanned} certified in review, none landed${why ? ` (${why})` : ''}`);
   }
   const unrunnable = Array.isArray(receipt.unrunnable_verifiers) ? receipt.unrunnable_verifiers.length : 0;
   if (unrunnable > 0) {
@@ -1118,6 +1138,8 @@ async function runTickBody(root, { json, policy, receipt, engineValidationDeps =
     receipt.scanned = parsed.scanned ?? null;
     receipt.revised = parsed.revised ?? null;
     receipt.skipped = parsed.skipped ?? null;
+    const waiting = waitingReasonRows(results);
+    if (waiting.length) receipt.waiting_reasons = waiting;
     receipt.undercounted = Boolean(parsed.undercounted);
   } catch (err) {
     receipt.accept_error = describeAcceptKillCause(accept) || accept.stderr.slice(0, 200) || 'auto-accept output unreadable';
@@ -1513,6 +1535,8 @@ module.exports = {
   hasAgentJargon,
   runEngineAnswerValidation,
   runTickBody,
+  stuckBacklogNote,
+  waitingReasonRows,
   acceptCommandArgs,
   runSshAgentSweep,
   sshAgentSweepNote,

package/commands/business-connect.js

@@ -0,0 +1,148 @@
+'use strict';
+
+/**
+ * atris business connect [service] [--business slug]
+ *
+ * Connects a service to a business on the server, the same thing the
+ * Integrations tab on the web does. With no service it shows what is
+ * connected. Bot services take a token here; OAuth services open the
+ * approval page in the browser.
+ */
+
+const { apiRequestJson } = require('../utils/api');
+const { loadCredentials, openBrowser } = require('../utils/auth');
+const { detectBusinessSlug } = require('../lib/business-core');
+const { NOT_LOGGED_IN, wantsHelp, wantsJson, tokenFrom, oneLine, printResult } = require('../lib/developer-api');
+
+/** Each business service: how to connect it, and the words to show for it. */
+const SERVICES = {
+  slack: { kind: 'oauth', label: 'Slack', fields: ['team_name'] },
+  'google-drive': { kind: 'oauth', label: 'Google Drive', key: 'google_drive' },
+  hubspot: { kind: 'oauth', label: 'HubSpot' },
+  telegram: { kind: 'token', label: 'Telegram', body: (f) => ({ bot_token: f.token }), need: '--token <bot token from @BotFather>', fields: ['bot_username'] },
+  discord: { kind: 'token', label: 'Discord', body: (f) => ({ bot_token: f.token, guild_id: f.guild || null }), need: '--token <bot token> [--guild <server id>]', fields: ['guild_name'] },
+  whatsapp: { kind: 'token', label: 'WhatsApp', body: (f) => ({ access_token: f['access-token'], phone_number_id: f['phone-id'] }), need: '--access-token <token> --phone-id <id>', fields: ['phone_number_id'] },
+};
+const PERSONAL_ONLY = ['linear', 'notion', 'github', 'jira', 'salesforce', 'microsoft', 'gmail', 'calendar', 'mercury', 'brex', 'robinhood', 'x', 'twitter', 'linkedin'];
+
+function showConnectHelp(log = console.log) {
+  log('usage: atris business connect [business]                       what is connected');
+  log('       atris business connect [business] slack                 opens the approval page');
+  log('       atris business connect [business] google-drive | hubspot');
+  log('       atris business connect [business] telegram --token <bot token>');
+  log('       atris business connect [business] discord --token <bot token> [--guild <server id>]');
+  log('       atris business connect [business] whatsapp --access-token <token> --phone-id <id>');
+  log('       atris business connect [business] <service> --off      disconnect it');
+  log('the business comes from the folder you are in when you leave it out. --no-open prints the url instead of opening it.');
+  log('linear, notion, github and the rest connect to your own account, not a business: atris.ai/dashboard/integrations');
+}
+
+function readFlags(args, names) {
+  const flags = {};
+  const rest = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (names.includes(arg)) {
+      flags[arg.slice(2)] = args[i + 1];
+      i += 1;
+    } else if (!['--json', '--off', '--no-open'].includes(arg)) {
+      rest.push(arg);
+    }
+  }
+  return { flags, rest };
+}
+
+function failure(result) {
+  const status = Number(result && result.status);
+  if (status === 401) return NOT_LOGGED_IN;
+  if (status === 403) return 'only the owner or an admin of this business can change its connections';
+  if (status === 404) return 'no business with that name that you can see. try: atris business list';
+  return oneLine(result && (result.errorMessage || result.error)) || `HTTP ${status || '?'}`;
+}
+
+/** The status as short lines: one per service, connected ones first with their detail. */
+function statusText(business, status = {}) {
+  const lines = [`${business}:`];
+  for (const [name, svc] of Object.entries(SERVICES)) {
+    const entry = status[svc.key || name] || {};
+    if (entry.connected) {
+      const detail = (svc.fields || []).map((f) => entry[f]).filter(Boolean).join(', ');
+      lines.push(`  ${svc.label.padEnd(13)} connected${detail ? `, ${detail}` : ''}`);
+    } else {
+      lines.push(`  ${svc.label.padEnd(13)} not connected   atris business connect ${business} ${name}${svc.need ? ` ${svc.need}` : ''}`);
+    }
+  }
+  const google = status.google || {};
+  if (google.connected || google.account_email) lines.push(`  ${'Google'.padEnd(13)} ${google.account_email || 'connected'}`);
+  return lines.join('\n');
+}
+
+async function connectCommand(args = [], deps = {}) {
+  const io = { log: deps.log || console.log, err: deps.err || console.error };
+  if (wantsHelp(args)) {
+    showConnectHelp(io.log);
+    return 0;
+  }
+  const json = wantsJson(args);
+  const fail = (error, extra = {}) => {
+    printResult({ json, ok: false, error, payload: { ok: false, error, ...extra } }, io);
+    return 1;
+  };
+  const { flags, rest } = readFlags(args, ['--business', '--token', '--guild', '--access-token', '--phone-id']);
+  // The service is whichever word is a known service; the other word, if any, is the business.
+  let service = null;
+  let business = flags.business || null;
+  for (const word of rest) {
+    if (!service && (SERVICES[word] || PERSONAL_ONLY.includes(word))) service = word;
+    else if (!business) business = word;
+  }
+  business = (deps.detectBusinessSlug || detectBusinessSlug)(business);
+  if (!business) return fail('say which business: atris business connect sunset-ink');
+  if (service && PERSONAL_ONLY.includes(service)) {
+    return fail(`${service} connects to your own account, not to a business. open atris.ai/dashboard/integrations`);
+  }
+  const token = tokenFrom((deps.loadCredentials || loadCredentials)());
+  if (!token) return fail(NOT_LOGGED_IN);
+  const request = deps.apiRequestJson || apiRequestJson;
+  const base = `/business/${encodeURIComponent(business)}/integrations`;
+
+  try {
+    if (!service) {
+      const result = await request(base, { method: 'GET', token });
+      if (!result || !result.ok) return fail(failure(result), { status: result && result.status });
+      printResult({ json, ok: true, text: statusText(business, result.data || {}), payload: { ok: true, business, integrations: result.data } }, io);
+      return 0;
+    }
+    const svc = SERVICES[service];
+    if (args.includes('--off')) {
+      const result = await request(`${base}/${service}`, { method: 'DELETE', token });
+      if (!result || !result.ok) return fail(failure(result), { status: result && result.status });
+      printResult({ json, ok: true, text: `${svc.label} is off for ${business}`, payload: { ok: true, business, service, connected: false } }, io);
+      return 0;
+    }
+    if (svc.kind === 'token') {
+      const body = svc.body(flags);
+      if (Object.values(body).some((v) => v === undefined || v === '')) return fail(`${svc.label} needs ${svc.need}`);
+      const result = await request(`${base}/${service}`, { method: 'POST', token, retries: 0, body });
+      if (!result || !result.ok) return fail(failure(result), { status: result && result.status });
+      const data = result.data || {};
+      const detail = (svc.fields || []).map((f) => data[f]).filter(Boolean).join(', ');
+      printResult({ json, ok: true, text: `${svc.label} is connected to ${business}${detail ? ` as ${detail}` : ''}`, payload: { ok: true, business, service, ...data } }, io);
+      return 0;
+    }
+    const result = await request(`${base}/${service}/start`, { method: 'POST', token, retries: 0, body: {} });
+    if (!result || !result.ok) return fail(failure(result), { status: result && result.status });
+    const url = (result.data || {}).auth_url || (result.data || {}).url;
+    if (!url) return fail(`the server gave no approval page for ${svc.label}`);
+    const opened = !args.includes('--no-open') && Boolean((deps.openBrowser || openBrowser)(url));
+    const text = opened
+      ? `opening ${svc.label}'s approval page. finish there, then check: atris business connect ${business}\n${url}`
+      : `open this to approve ${svc.label} for ${business}:\n${url}`;
+    printResult({ json, ok: true, text, payload: { ok: true, business, service, auth_url: url, opened } }, io);
+    return 0;
+  } catch (error) {
+    return fail(oneLine(error && error.message) || 'request failed');
+  }
+}
+
+module.exports = { connectCommand, statusText, showConnectHelp, SERVICES };

package/commands/business-scoreboard.js

@@ -0,0 +1,216 @@
+'use strict';
+
+/**
+ * atris business scoreboard <business>
+ *
+ * One board of normalized units for any business: revenue, payments, orders,
+ * visitors, credits, plus custom numbers the owner records by hand. The same
+ * numbers render as text here, as JSON, or as an Atris doc with live blocks.
+ */
+
+const fs = require('node:fs');
+const { apiRequestJson } = require('../utils/api');
+const { loadCredentials } = require('../utils/auth');
+const { detectBusinessSlug } = require('../lib/business-core');
+const { NOT_LOGGED_IN, wantsHelp, wantsJson, tokenFrom, oneLine, printResult } = require('../lib/developer-api');
+
+function showScoreboardHelp(log = console.log) {
+  log('usage: atris business scoreboard [business] [--days N] [--json]');
+  log('       atris business scoreboard [business] --doc [--out FILE]');
+  log('       atris business scoreboard [business] add "Label" [--kind money|count|percent] [--id slug] [--target N]');
+  log('       atris business scoreboard [business] add "Label" --event signup [--people]');
+  log('       atris business scoreboard [business] add "Label" --formula "revenue / customers"');
+  log('       atris business scoreboard [business] set <unit> <value> [--day YYYY-MM-DD]');
+  log('       atris business scoreboard [business] target <unit> <N|none>');
+  log('       atris business scoreboard [business] layout <unit,unit,...>');
+  log('       atris business scoreboard [business] remove <unit>');
+  log('revenue, payments, orders, visitors and credits for one business, plus your own numbers.');
+  log('  --event    count an event your site sends (atris business track); --people counts distinct visitors');
+  log('  --formula  a number made from other units with + - * / and parentheses');
+  log('  --days   window for the time-boxed units (default 30)');
+  log('  --doc    print the board as an Atris doc with metric, gauge and chart blocks');
+  log('  --out    write the doc to a file instead of printing it');
+  log('  --json   print the full board once as one json object');
+  log('the business comes from the folder you are in when you leave it out.');
+}
+
+const money = (value) => (Number(value) >= 100
+  ? `$${Math.round(Number(value)).toLocaleString('en-US')}`
+  : `$${Number(value).toFixed(2)}`);
+
+function formatValue(unit = {}) {
+  if (unit.value === null || unit.value === undefined) return 'no data';
+  if (unit.kind === 'money') return money(unit.value);
+  if (unit.kind === 'percent') return `${Number(unit.value)}%`;
+  return Number(unit.value).toLocaleString('en-US');
+}
+
+function periodText(unit = {}) {
+  const period = String(unit.period || '');
+  return period === 'now' ? 'now' : `last ${period.replace(/d$/, '')} days`;
+}
+
+/** The board as aligned lines: label, value, period, and a target when one is set. */
+function scoreboardText(board = {}) {
+  const units = Array.isArray(board.units) ? board.units : [];
+  const name = (board.business && (board.business.name || board.business.slug)) || 'business';
+  if (!units.length) return `${name}: no units on the board yet. add one: atris business scoreboard add "Leads"`;
+  const width = Math.max(...units.map((u) => String(u.label || u.id).length));
+  const lines = [`${name}, ${board.days || 30} day window`];
+  for (const unit of units) {
+    let line = `${String(unit.label || unit.id).padEnd(width)}  ${formatValue(unit).padStart(10)}  ${periodText(unit)}`;
+    if (unit.target !== null && unit.target !== undefined && unit.value !== null && unit.value !== undefined) {
+      line += `, target ${formatValue({ ...unit, value: unit.target })}`;
+    }
+    if (unit.note) line += `  (${unit.note})`;
+    lines.push(line);
+  }
+  const custom = units.filter((u) => u.builtin === false).map((u) => u.id);
+  if (custom.length) lines.push(`record one: atris business scoreboard set ${custom[0]} <value>`);
+  return lines.join('\n');
+}
+
+/** Pull `--flag value` pairs out of args; returns {flags, rest}. */
+function readFlags(args, names) {
+  const flags = {};
+  const rest = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (names.includes(arg)) {
+      flags[arg.slice(2)] = args[i + 1];
+      i += 1;
+    } else if (arg !== '--json' && arg !== '--doc') {
+      rest.push(arg);
+    }
+  }
+  return { flags, rest };
+}
+
+const ACTIONS = new Set(['add', 'set', 'layout', 'remove', 'target']);
+
+function failure(result) {
+  const status = Number(result && result.status);
+  if (status === 401) return NOT_LOGGED_IN;
+  if (status === 403) return 'only the owner or an admin of this business can change its scoreboard';
+  if (status === 404) return 'no business with that name that you can see. try: atris business list';
+  return oneLine(result && (result.errorMessage || result.error)) || `HTTP ${status || '?'}`;
+}
+
+async function scoreboardCommand(args = [], deps = {}) {
+  const io = { log: deps.log || console.log, err: deps.err || console.error };
+  if (wantsHelp(args)) {
+    showScoreboardHelp(io.log);
+    return 0;
+  }
+  const json = wantsJson(args);
+  const fail = (error, extra = {}) => {
+    printResult({ json, ok: false, error, payload: { ok: false, error, ...extra } }, io);
+    return 1;
+  };
+
+  const { flags, rest } = readFlags(args, ['--days', '--out', '--kind', '--id', '--target', '--day', '--event', '--formula']);
+  // The business is the first word unless that word is an action, then it comes from the folder.
+  let business = null;
+  if (rest.length && !ACTIONS.has(rest[0])) business = rest.shift();
+  business = (deps.detectBusinessSlug || detectBusinessSlug)(business);
+  if (!business) return fail('say which business: atris business scoreboard sunset-ink');
+
+  const token = tokenFrom((deps.loadCredentials || loadCredentials)());
+  if (!token) return fail(NOT_LOGGED_IN);
+  const request = deps.apiRequestJson || apiRequestJson;
+  const base = `/business/${encodeURIComponent(business)}/scoreboard`;
+  const days = flags.days ? Number(flags.days) : 30;
+  if (!Number.isInteger(days) || days < 1 || days > 365) return fail('--days takes a whole number from 1 to 365');
+
+  try {
+    const action = rest[0];
+    if (action === 'add') {
+      const label = rest.slice(1).join(' ').trim();
+      if (!label) return fail('name the unit: atris business scoreboard add "Shirts printed"');
+      const body = { label, kind: flags.kind || 'count' };
+      if (flags.id) body.id = flags.id;
+      if (flags.target !== undefined) {
+        body.target = Number(flags.target);
+        if (!Number.isFinite(body.target)) return fail('--target takes a number');
+      }
+      if (flags.event && flags.formula) return fail('a unit reads an event or a formula, not both');
+      if (flags.event) {
+        body.event = String(flags.event).trim();
+        body.measure = args.includes('--people') ? 'people' : 'count';
+      }
+      if (flags.formula) body.formula = String(flags.formula).trim();
+      const result = await request(`${base}/units`, { method: 'POST', token, retries: 0, body });
+      if (!result || !result.ok) return fail(failure(result), { status: result && result.status });
+      const unit = result.data || {};
+      const next = unit.event
+        ? `it counts ${unit.measure === 'people' ? 'people who send' : 'every'} ${unit.event}`
+        : unit.formula ? `it is ${unit.formula}` : `record one: atris business scoreboard set ${unit.id} <value>`;
+      printResult({ json, ok: true, text: `added ${unit.label} (${unit.id}). ${next}`, payload: { ok: true, unit } }, io);
+      return 0;
+    }
+    if (action === 'target') {
+      const [unit, raw] = rest.slice(1);
+      if (!unit || raw === undefined) return fail('say the unit and the goal: atris business scoreboard target revenue 5000 (or none)');
+      const target = raw === 'none' ? null : Number(raw);
+      if (target !== null && !(Number.isFinite(target) && target > 0)) return fail('the target has to be a number above zero, or none');
+      const result = await request(`${base}/units/${encodeURIComponent(unit)}/target`, { method: 'PUT', token, retries: 0, body: { target } });
+      if (!result || !result.ok) return fail(failure(result), { status: result && result.status });
+      printResult({ json, ok: true, text: target === null ? `${unit} has no target now` : `${unit} aims for ${target}`, payload: { ok: true, unit, target } }, io);
+      return 0;
+    }
+    if (action === 'set') {
+      const [unit, raw] = rest.slice(1);
+      const value = Number(raw);
+      if (!unit || raw === undefined) return fail('say the unit and the number: atris business scoreboard set shirts_printed 12');
+      if (!Number.isFinite(value)) return fail('the value has to be a number');
+      if (flags.day !== undefined && !/^\d{4}-\d{2}-\d{2}$/.test(String(flags.day))) return fail('write the day as YYYY-MM-DD');
+      const body = flags.day ? { value, day: flags.day } : { value };
+      const result = await request(`${base}/units/${encodeURIComponent(unit)}/values`, { method: 'POST', token, retries: 0, body });
+      if (!result || !result.ok) return fail(failure(result), { status: result && result.status });
+      const saved = result.data || {};
+      printResult({ json, ok: true, text: `${unit} is ${saved.value} for ${saved.day}`, payload: { ok: true, value: saved } }, io);
+      return 0;
+    }
+    if (action === 'layout') {
+      const units = rest.slice(1).join(',').split(',').map((s) => s.trim()).filter(Boolean);
+      if (!units.length) return fail('list the units in order: atris business scoreboard layout revenue,orders,leads');
+      const result = await request(`${base}/layout`, { method: 'PUT', token, body: { units } });
+      if (!result || !result.ok) return fail(failure(result), { status: result && result.status });
+      const layout = (result.data || {}).layout || units;
+      printResult({ json, ok: true, text: `board shows ${layout.join(', ')}`, payload: { ok: true, layout } }, io);
+      return 0;
+    }
+    if (action === 'remove') {
+      const unit = rest[1];
+      if (!unit) return fail('say which unit: atris business scoreboard remove leads');
+      const result = await request(`${base}/units/${encodeURIComponent(unit)}`, { method: 'DELETE', token });
+      if (!result || !result.ok) return fail(failure(result), { status: result && result.status });
+      printResult({ json, ok: true, text: `removed ${unit}`, payload: { ok: true, removed: unit } }, io);
+      return 0;
+    }
+    if (rest.length) return fail(`unknown action ${rest[0]}. try: atris business scoreboard --help`);
+
+    if (args.includes('--doc')) {
+      const result = await request(`${base}/doc?days=${days}`, { method: 'GET', token });
+      if (!result || !result.ok) return fail(failure(result), { status: result && result.status });
+      const doc = result.text || (typeof result.data === 'string' ? result.data : '');
+      if (flags.out) {
+        (deps.writeFile || fs.writeFileSync)(flags.out, doc);
+        printResult({ json, ok: true, text: `wrote ${flags.out}`, payload: { ok: true, path: flags.out } }, io);
+      } else {
+        io.log(doc);
+      }
+      return 0;
+    }
+
+    const result = await request(`${base}?days=${days}`, { method: 'GET', token });
+    if (!result || !result.ok) return fail(failure(result), { status: result && result.status });
+    const board = result.data || {};
+    printResult({ json, ok: true, text: scoreboardText(board), payload: { ok: true, ...board } }, io);
+    return 0;
+  } catch (error) {
+    return fail(oneLine(error && error.message));
+  }
+}
+
+module.exports = { scoreboardCommand, scoreboardText, formatValue, showScoreboardHelp };

package/commands/business.js

@@ -1158,93 +1158,6 @@ async function businessTeam(slug) {
   console.log('');
 }
 
-async function connectService(connector, ...flags) {
-  if (!connector) {
-    console.log('Usage: atris business connect <service> [--business <slug>]');
-    console.log('');
-    console.log('Available connectors:');
-    // List skills that look like integrations
-    const skillDirs = [
-      path.join(__dirname, '..', '..', '.claude', 'skills'),
-      path.join(require('os').homedir(), '.claude', 'skills'),
-    ];
-    const seen = new Set();
-    for (const dir of skillDirs) {
-      if (!fs.existsSync(dir)) continue;
-      for (const name of fs.readdirSync(dir)) {
-        const skillFile = path.join(dir, name, 'SKILL.md');
-        if (fs.existsSync(skillFile) && !seen.has(name)) {
-          seen.add(name);
-        }
-      }
-    }
-    const integrations = [...seen].filter(s =>
-      ['slack', 'hubspot', 'linear', 'notion', 'google-drive', 'github',
-       'calendar', 'email-agent', 'x-search', 'youtube', 'ramp'].includes(s)
-    ).sort();
-    for (const s of integrations) {
-      console.log(`  ${s}`);
-    }
-    if (integrations.length === 0) console.log('  (none found, install skills first)');
-    return;
-  }
-
-  // Parse --business flag
-  let bizSlug = null;
-  for (let i = 0; i < flags.length; i++) {
-    if ((flags[i] === '--business' || flags[i] === '-b') && flags[i + 1]) {
-      bizSlug = flags[i + 1];
-      i++;
-    }
-  }
-
-  // Find the skill
-  const skillDirs = [
-    path.join(__dirname, '..', '..', '.claude', 'skills', connector),
-    path.join(require('os').homedir(), '.claude', 'skills', connector),
-  ];
-  let skillPath = null;
-  for (const dir of skillDirs) {
-    const p = path.join(dir, 'SKILL.md');
-    if (fs.existsSync(p)) { skillPath = p; break; }
-  }
-
-  if (!skillPath) {
-    console.error(`Skill "${connector}" not found.`);
-    console.error('Check: .claude/skills/ or ~/.claude/skills/');
-    process.exit(1);
-  }
-
-  console.log(`\n  Connecting: ${connector}`);
-  console.log(`  Skill:     ${skillPath}`);
-  if (bizSlug) console.log(`  Business:  ${bizSlug}`);
-
-  // Read skill to check for required secrets
-  const skillContent = fs.readFileSync(skillPath, 'utf8');
-  const secretMatches = skillContent.match(/[A-Z][A-Z0-9_]*_(?:KEY|TOKEN|SECRET|PASSWORD|API_KEY)/g) || [];
-  const uniqueSecrets = [...new Set(secretMatches)];
-
-  if (uniqueSecrets.length > 0) {
-    console.log(`\n  Required secrets:`);
-    for (const secret of uniqueSecrets) {
-      console.log(`    ${secret}`);
-    }
-    console.log(`\n  Store secrets with: atris computer run "echo $${uniqueSecrets[0]}"`);
-    console.log(`  Or set in: ~/.atris/secrets/${connector}/`);
-  }
-
-  // Create local secrets directory
-  const secretsDir = path.join(stateHome(), '.atris', 'secrets', connector);
-  if (!fs.existsSync(secretsDir)) {
-    fs.mkdirSync(secretsDir, { recursive: true });
-    console.log(`\n  Created secrets dir: ${secretsDir}/`);
-  }
-
-  console.log(`\n  Connected "${connector}" skill.`);
-  console.log(`  Agent can now use ${connector} capabilities.`);
-  console.log('');
-}
-
 async function setNotificationMode(mode, ...flags) {
   const validModes = ['digest', 'silent', 'push'];
   if (!mode || !validModes.includes(mode)) {
@@ -1588,6 +1501,7 @@ function printBusinessHelp() {
   console.log('  add <slug>           Register an existing cloud business');
   console.log('  list                 Show registered businesses');
   console.log('  room [slug]          Show wallet, members, apps, store, and recent orders');
+  console.log('  scoreboard [slug]    Revenue, orders, visitors, credits and your own numbers as one board (--doc, --json, add, set, layout)');
   console.log('  products [slug]      List store products');
   console.log('  orders [slug]        List store orders');
   console.log('  store on [slug]      Enable the store with its current catalog');
@@ -1596,7 +1510,7 @@ function printBusinessHelp() {
   console.log('  health [slug]        Full health dashboard');
   console.log('  audit                Audit all businesses');
   console.log('  doctor [--fix]       Find stale business cache, alias, and folder bindings');
-  console.log('  connect <service>    Connect a skill/integration');
+  console.log('  connect [service]    See or make a business connection (slack, telegram, discord, whatsapp, google-drive, hubspot)');
   console.log('  notify <mode>        Set notification mode (digest/silent/push)');
   console.log('  deploy <slug>        Push local business to cloud');
   console.log('  onboard              Seed brief, person, first loop, safe next action, and one-pager from sparse input');
@@ -1678,6 +1592,13 @@ async function businessCommand(subcommand, ...args) {
     case 'room':
       await businessRoom(args[0]);
       break;
+    case 'scoreboard':
+    case 'board':
+    case 'numbers': {
+      const code = await require('./business-scoreboard').scoreboardCommand(args);
+      if (code) process.exitCode = code;
+      break;
+    }
     case 'products':
     case 'product':
       await businessProducts(args[0]);
@@ -1705,7 +1626,7 @@ async function businessCommand(subcommand, ...args) {
       await businessDoctor(...args);
       break;
     case 'connect':
-      await connectService(args[0], ...args.slice(1));
+      process.exitCode = await require('./business-connect').connectCommand(args);
       break;
     case 'notify':
     case 'notification':

package/commands/computer-login.js

@@ -0,0 +1,327 @@
+'use strict';
+
+// `atris computer login`: put your own Claude or Codex subscription on the
+// cloud computers you own, with one browser approval and nothing to answer.
+//
+// The sign-in happens on this laptop, where the browser is. The result is sent
+// straight to Atris, stored encrypted, and used only on runs you start. It is
+// never printed and never written to a file here.
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const { loadCredentials } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+const engineLogin = require('../lib/engine-login');
+
+const ENGINES = ['claude', 'codex'];
+const WORKER_FOR = { claude: 'claude', codex: 'openai' };
+const TEST_MESSAGE = 'Reply with only the word OK.';
+
+function parseLoginArgs(args = []) {
+  const options = { engine: 'claude', business: '', status: false, unlink: false, check: false, test: true, help: false, error: '' };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (ENGINES.includes(arg)) options.engine = arg;
+    else if (arg === '--status' || arg === 'status') options.status = true;
+    else if (arg === '--unlink' || arg === 'unlink' || arg === 'logout') options.unlink = true;
+    else if (arg === '--check' || arg === 'check') options.check = true;
+    else if (arg === '--no-test') options.test = false;
+    else if (arg === '--help' || arg === '-h' || arg === 'help') options.help = true;
+    else if (arg === '--business') {
+      options.business = String(args[i + 1] || '').trim();
+      i += 1;
+      if (!options.business) options.error = '--business needs a computer name';
+    } else if (arg.startsWith('--business=')) options.business = arg.slice('--business='.length).trim();
+    else options.error = `unknown option: ${arg}`;
+  }
+  return options;
+}
+
+function printHelp(log) {
+  log('Usage: atris computer login [claude|codex] [--business <name>]');
+  log('');
+  log('Puts your own subscription on the cloud computers you own.');
+  log('One browser approval. It is used only on runs you start.');
+  log('');
+  log('  atris computer login                 Claude, on every computer you own');
+  log('  atris computer login codex           Codex instead (a computer holds one at a time)');
+  log('  atris computer login --business x    only the computer named x');
+  log('  atris computer login --status        which computers have a subscription');
+  log('  atris computer login --check         run one small job and show how it was paid');
+  log('  atris computer login --unlink        remove it; add --business x for one');
+  log('  --no-test                            skip the test run at the end');
+}
+
+function findComputer(computers, name) {
+  const wanted = String(name || '').trim().toLowerCase();
+  if (!wanted) return null;
+  return computers.find((item) => [item.slug, item.name, item.business_id]
+    .some((value) => String(value || '').toLowerCase() === wanted)) || null;
+}
+
+function printStatus(computers, log) {
+  if (!computers.length) {
+    log('You do not own any computers on this account.');
+    return;
+  }
+  const width = Math.max(...computers.map((item) => String(item.name || item.slug || '').length));
+  for (const item of computers) {
+    const name = String(item.name || item.slug || item.business_id).padEnd(width);
+    log(`  ${name}  ${item.linked ? `${item.engine} subscription` : 'no subscription'}`);
+  }
+}
+
+// What the server said, in plain words. Never includes the sign-in.
+function explainFailure(result) {
+  if (result.status === 404) return 'The server does not have this yet. It needs the latest deploy.';
+  if (result.status === 403) return String(result.error || 'This is not switched on for your account.');
+  if (result.status === 401) return 'Your Atris sign-in ran out. Run: atris login';
+  if (result.status === 400) return String(result.error || 'The server did not accept that sign-in.');
+  return 'The server did not answer. Try again in a minute.';
+}
+
+// Claude: its own long-lived sign-in command, approved in the browser.
+function claudeSignIn(deps) {
+  const lib = deps.engineLogin || engineLogin;
+  const recorded = lib.recordSetupToken();
+  let token = lib.findToken(recorded.text);
+  if (!token) token = lib.askToken();
+  if (!/^sk-ant-oat/.test(token)) return { error: 'No sign-in came back from Claude.' };
+  // Claude prints the sign-in on screen. Wipe it, scrollback included.
+  (deps.clearScreen || (() => process.stdout.write('\x1b[2J\x1b[3J\x1b[H')))();
+  const check = lib.checkToken(token);
+  if (!check.ok) return { error: `The new sign-in did not work on this laptop (${check.detail}).` };
+  return { credential: token };
+}
+
+// Codex: a fresh sign-in in a throwaway folder, so the cloud gets its own
+// session and this laptop's Codex sign-in is left alone.
+function codexSignIn(deps) {
+  const spawn = deps.spawnSync || spawnSync;
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-codex-login-'));
+  fs.chmodSync(home, 0o700);
+  try {
+    const result = spawn('codex', ['login', '-c', 'cli_auth_credentials_store="file"'], {
+      stdio: 'inherit',
+      env: { ...process.env, CODEX_HOME: home },
+    });
+    if (result.error && result.error.code === 'ENOENT') return { error: 'Codex is not installed on this laptop.' };
+    const file = path.join(home, 'auth.json');
+    if (!fs.existsSync(file)) return { error: 'No sign-in came back from Codex.' };
+    const content = fs.readFileSync(file, 'utf8').trim();
+    try {
+      if (typeof JSON.parse(content) !== 'object') throw new Error('not an object');
+    } catch {
+      return { error: 'Codex wrote a sign-in this tool could not read.' };
+    }
+    return { credential: content };
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+}
+
+function defaultRunTest(computer, engine) {
+  const result = spawnSync(process.execPath, [
+    path.join(__dirname, '..', 'bin', 'atris.js'), 'computer', 'chat',
+    '--business', String(computer.slug || computer.business_id),
+    '--worker', WORKER_FOR[engine], '--message', TEST_MESSAGE,
+  ], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 300000 });
+  const lines = `${result.stdout || ''}`.trim().split('\n').filter(Boolean);
+  return { ok: result.status === 0, reply: lines[lines.length - 1] || '' };
+}
+
+async function lastRun(api, token, computer) {
+  const result = await api(`/ai-computer/subscription/last-run?business_id=${encodeURIComponent(computer.business_id)}`, {
+    method: 'GET', token, timeoutMs: 15000, retries: 1,
+  });
+  return result.ok && result.data ? { ok: true, run: result.data.run || null } : { ok: false, run: null };
+}
+
+// Runs one tiny job as you, then asks the server how that run was paid for.
+// "New" means a different run than the newest one before the test, so no
+// clocks are compared.
+async function proveSubscription({ api, token, computer, engine, deps, log }) {
+  const name = computer.name || computer.slug;
+  const before = await lastRun(api, token, computer);
+  if (!before.ok) {
+    log('Could not read this computer\'s run records, so this is not proven yet.');
+    return false;
+  }
+  log(`Running one small job on ${name}. It may take a minute to wake.`);
+  const test = (deps.runTest || defaultRunTest)(computer, engine);
+  const after = await lastRun(api, token, computer);
+  const record = after.run;
+  const isNew = record && record.execution_id && (!before.run || record.execution_id !== before.run.execution_id);
+  if (!isNew) {
+    log('The test job left no new record, so this is not proven yet.');
+    return false;
+  }
+  if (!record.on_subscription) {
+    log(`Not working: that job was paid as "${record.billing_mode || 'unknown'}", not your subscription.`);
+    return false;
+  }
+  if (record.status !== 'completed' || !/\bok\b/i.test(test.reply || '')) {
+    log(`Not proven: the job was sent to your ${engine} subscription but did not finish cleanly (${record.status || 'unknown'}).`);
+    return false;
+  }
+  if (computer.shared_sign_in) {
+    log(`That job ran on a ${engine} subscription. ${name} also has the older shared sign-in,`);
+    log('so this result cannot tell the two apart.');
+    return true;
+  }
+  log(`Proven: that job ran on your ${engine} subscription.`);
+  return true;
+}
+
+// Ctrl-C during a sign-in goes to the sign-in program. Holding the signal here
+// lets cleanup of its screen recording run instead of dying mid-way.
+function holdingInterrupt(work) {
+  const hold = () => {};
+  process.on('SIGINT', hold);
+  try {
+    return work();
+  } finally {
+    process.removeListener('SIGINT', hold);
+  }
+}
+
+async function computerLogin(args = [], deps = {}) {
+  const log = deps.log || console.log;
+  const fail = deps.error || console.error;
+  const options = parseLoginArgs(args);
+  if (!options.business && deps.business) options.business = String(deps.business).trim();
+  if (options.help) {
+    printHelp(log);
+    return 0;
+  }
+  if (options.error) {
+    fail(options.error);
+    return 1;
+  }
+
+  const credentials = await (deps.loadCredentials || loadCredentials)();
+  if (!credentials || !credentials.token) {
+    fail('Not signed in to Atris. Run: atris login');
+    return 1;
+  }
+  const token = credentials.token;
+  const api = deps.apiRequestJson || apiRequestJson;
+
+  const listed = await api('/ai-computer/subscription', { method: 'GET', token, timeoutMs: 15000, retries: 1 });
+  if (!listed.ok) {
+    fail(explainFailure(listed));
+    return 1;
+  }
+  const computers = Array.isArray(listed.data && listed.data.computers) ? listed.data.computers : [];
+
+  if (options.status) {
+    printStatus(computers, log);
+    return 0;
+  }
+
+  let target = null;
+  if (options.business) {
+    target = findComputer(computers, options.business);
+    if (!target) {
+      fail(`You do not own a computer named "${options.business}".`);
+      return 1;
+    }
+  }
+  if (!computers.length) {
+    fail('You do not own any computers on this account, so there is nothing to sign in to.');
+    return 1;
+  }
+
+  if (options.unlink) {
+    const removed = await api('/ai-computer/subscription/unlink', {
+      method: 'POST', token, body: target ? { business_id: target.business_id } : {}, timeoutMs: 30000, retries: 0,
+    });
+    if (!removed.ok) {
+      fail(explainFailure(removed));
+      return 1;
+    }
+    const count = (removed.data && removed.data.unlinked ? removed.data.unlinked : []).length;
+    const stuck = (removed.data && removed.data.failed ? removed.data.failed : []).length;
+    log(`Removed your subscription from ${count} computer${count === 1 ? '' : 's'}.`);
+    if (stuck) {
+      fail(`${stuck} could not be removed. See which: atris computer login --status`);
+      return 1;
+    }
+    return 0;
+  }
+
+  const binding = (deps.readBusinessBinding || (() => null))();
+  const bound = binding ? findComputer(computers, binding.business_id || binding.id || binding.slug) : null;
+
+  if (options.check) {
+    const checked = target || bound;
+    if (!checked) {
+      fail('Name the computer to check: atris computer login --check --business <name>');
+      return 1;
+    }
+    if (!checked.linked) {
+      fail(`${checked.name || checked.slug} has no subscription yet. Run: atris computer login`);
+      return 1;
+    }
+    const proven = await proveSubscription({ api, token, computer: checked, engine: checked.engine, deps, log });
+    return proven ? 0 : 2;
+  }
+
+  const engine = options.engine;
+  log(`Signing in to ${engine}. A browser page opens. Approve it there.`);
+  const signIn = holdingInterrupt(() => (engine === 'claude'
+    ? (deps.claudeSignIn || claudeSignIn)(deps)
+    : (deps.codexSignIn || codexSignIn)(deps)));
+  if (signIn.error) {
+    fail(`${signIn.error} Nothing was changed.`);
+    return 1;
+  }
+
+  const linked = await api('/ai-computer/subscription/link', {
+    method: 'POST',
+    token,
+    body: { engine, credential: signIn.credential, ...(target ? { business_id: target.business_id } : {}) },
+    timeoutMs: 60000,
+    retries: 0,
+  });
+  if (!linked.ok) {
+    // A refusal means nothing was stored. Anything else (a timeout, a server
+    // error) may have stored it on some computers, so do not claim otherwise.
+    const refused = [400, 401, 403, 404].includes(linked.status);
+    fail(refused
+      ? `${explainFailure(linked)} Nothing was changed.`
+      : 'The server did not confirm. Some computers may have it. See which: atris computer login --status');
+    return 1;
+  }
+  const done = linked.data && Array.isArray(linked.data.linked) ? linked.data.linked : [];
+  const missed = linked.data && Array.isArray(linked.data.failed) ? linked.data.failed : [];
+  const names = done
+    .map((item) => computers.find((computer) => computer.business_id === item.business_id))
+    .filter(Boolean)
+    .map((computer) => computer.name || computer.slug);
+  log(`Your ${engine} subscription is on ${done.length} computer${done.length === 1 ? '' : 's'}${names.length ? `: ${names.join(', ')}` : ''}.`);
+  log('It is used only on runs you start.');
+  if (missed.length) {
+    const missedNames = missed.map((id) => {
+      const computer = computers.find((item) => item.business_id === id);
+      return computer ? (computer.name || computer.slug) : id;
+    });
+    fail(`It could not be added to ${missed.length}: ${missedNames.join(', ')}. Run the command again to retry.`);
+  }
+
+  if (!done.length) return 1;
+  if (!options.test) return missed.length ? 1 : 0;
+  const proofTarget = target || (bound && done.some((item) => item.business_id === bound.business_id) ? bound : null);
+  if (!proofTarget) {
+    log('To prove it on one computer: atris computer login --check --business <name>');
+    return missed.length ? 1 : 0;
+  }
+  const proven = await proveSubscription({ api, token, computer: proofTarget, engine, deps, log });
+  if (!proven) return 2;
+  return missed.length ? 1 : 0;
+}
+
+module.exports = { computerLogin, parseLoginArgs, findComputer, explainFailure, claudeSignIn, codexSignIn };

package/commands/computer.js

@@ -1943,6 +1943,19 @@ async function runComputer(argv = process.argv.slice(3), deps = {}) {
   const cloudOptions = parsed.options;
   const sub = args[0];
 
+  if (sub === 'login') {
+    const { computerLogin } = require('./computer-login');
+    // The shared option reader takes --business wherever it sits, so hand it
+    // on; otherwise a flag typed before `login` would be dropped silently.
+    const code = await computerLogin(argv.slice(argv.indexOf('login') + 1), {
+      readBusinessBinding,
+      business: cloudOptions.businessSlug || '',
+      ...deps,
+    });
+    if (code !== 0) process.exitCode = code;
+    return code;
+  }
+
   if (sub === 'setup') {
     const code = await computerSetup(deps);
     if (code !== 0) process.exitCode = code;

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/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/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.14",
   "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",