atris 3.53.0 → 3.55.0

package/commands/feedback.js

@@ -6,6 +6,7 @@
  *   atris feedback submit "message here"       Submit feedback
  *   atris feedback                              List feedback
  *   atris feedback list                         List feedback
+ *   atris feedback triage <id> [--dispatch]     Build or dispatch a reproduction brief
  *   atris feedback resolve <id> "<resolution>"  Mark resolved (admin)
  *   atris feedback close <id>                   Close as wontfix (admin)
  *   atris feedback delete <id>                  Delete feedback (admin)
@@ -18,10 +19,17 @@ const fs = require('fs');
 const path = require('path');
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
+const {
+  planFeedbackTriage,
+  renderFeedbackTriageBrief,
+  dispatchFeedbackTriage,
+  recordFeedbackTriageVerdict,
+} = require('../lib/feedback-triage');
 
 const KNOWN_FEEDBACK_COMMANDS = new Set([
   'list',
   'submit',
+  'triage',
   'resolve',
   'close',
   'delete',
@@ -151,6 +159,43 @@ async function resolveIdPrefix(prefix, { token, businessId }) {
   return { id: matches[0].id, item: matches[0] };
 }
 
+function findFeedbackItem(prefix, items) {
+  const requested = String(prefix || '').trim();
+  if (!requested) return { error: 'feedback id is required' };
+  const matches = (items || []).filter((item) => String(item && item.id || '').startsWith(requested));
+  if (matches.length === 0) return { error: `No feedback matches id prefix "${requested}"` };
+  if (matches.length > 1) return { error: `Ambiguous id "${requested}"; matches ${matches.length} items. Use a longer prefix.` };
+  return { item: matches[0] };
+}
+
+async function triageFeedback(idPrefix, options = {}) {
+  const workspace = path.resolve(options.workspace || process.cwd());
+  const token = options.token || getAuth().token;
+  const fetchItems = options.fetchFeedbackItems || fetchFeedbackItems;
+  const items = await fetchItems({ token, businessId: options.businessId, limit: 200 });
+  const lookup = findFeedbackItem(idPrefix, items);
+  if (lookup.error) throw new Error(lookup.error);
+
+  const brief = planFeedbackTriage(lookup.item, workspace);
+  const write = options.write || console.log;
+  write(renderFeedbackTriageBrief(brief));
+  if (!options.dispatch) return { brief, dispatch: null, verdict: null };
+
+  const dispatchBrief = options.dispatchFeedbackTriage || dispatchFeedbackTriage;
+  const dispatched = await dispatchBrief(brief, workspace, options.dispatchDeps || {});
+  const recordVerdict = options.recordFeedbackTriageVerdict || recordFeedbackTriageVerdict;
+  const recorded = recordVerdict(lookup.item, workspace, {
+    verdict: dispatched.verdict,
+    evidence: dispatched.evidence,
+    verify_command: brief.verify_command,
+    engine: dispatched.engine,
+  });
+  write('');
+  write(`verdict: ${recorded.record.verdict}`);
+  write(`${recorded.appended ? 'recorded' : 'already recorded'}: ${path.relative(workspace, recorded.path)}`);
+  return { brief, dispatch: dispatched, verdict: recorded };
+}
+
 async function resolveFeedback(idPrefix, resolution) {
   if (!idPrefix || !resolution) {
     console.error('Usage: atris feedback resolve <id> "<resolution>"');
@@ -236,6 +281,8 @@ function printHelp(write = console.log) {
   write('  atris feedback submit "msg" --business <slug>');
   write('  atris feedback                         List feedback');
   write('  atris feedback list                    List feedback');
+  write('  atris feedback triage <id>             Print a reproduction brief');
+  write('  atris feedback triage <id> --dispatch  Run triage and record its verdict');
   write('  atris feedback resolve <id> "<note>"   Mark resolved (admin)');
   write('  atris feedback close <id>              Close as wontfix (admin)');
   write('  atris feedback delete <id>             Delete feedback (admin)');
@@ -296,7 +343,8 @@ function rejectUnknownFeedbackCommand(subcommand) {
 
 async function feedbackCommand() {
   const rawArgs = process.argv.slice(3);
-  const [businessArg, args] = extractFlag(rawArgs, '--business', '-b');
+  const dispatchRequested = rawArgs.includes('--dispatch');
+  const [businessArg, args] = extractFlag(rawArgs.filter((arg) => arg !== '--dispatch'), '--business', '-b');
   const businessId = resolveBusinessArg(businessArg);
   if (businessArg && !businessId) {
     console.error(`Error: unknown business "${businessArg}". Check ~/.atris/businesses.json`);
@@ -329,6 +377,14 @@ async function feedbackCommand() {
     return;
   }
 
+  if (subcommand === 'triage') {
+    if (!args[1] || args.length !== 2) {
+      throw new Error('usage: atris feedback triage <id> [--dispatch]');
+    }
+    await triageFeedback(args[1], { businessId, dispatch: dispatchRequested });
+    return;
+  }
+
   if (subcommand === 'resolve') {
     const id = args[1];
     const resolution = args.slice(2).join(' ');
@@ -359,4 +415,7 @@ async function feedbackCommand() {
   rejectUnknownFeedbackCommand(subcommand);
 }
 
-module.exports = { feedbackCommand };
+module.exports = {
+  feedbackCommand,
+  triageFeedback,
+};

package/commands/fleet-report.js

@@ -15,6 +15,8 @@
 
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
+const { requireAccountBound, refuseAccountGlobal } = require('../lib/account-bound');
+const { argsWantHelp, wantsJson } = require('../lib/noninteractive');
 
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
@@ -157,15 +159,33 @@ async function leaderboard(token, businesses) {
 
 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('--'));
+  const usage = 'Usage: atris fleet-report <business> [--wake] | --all-alive [--dry-run] | --leaderboard';
+  if (argsWantHelp(args) || wantsJson(args)) {
+    if (wantsJson(args)) {
+      console.log(JSON.stringify({
+        ok: false,
+        command: 'fleet-report',
+        error: 'usage',
+        usage,
+      }, null, 2));
+    } else {
+      console.log(usage);
+    }
+    process.exit(2);
+  }
+
+  const gate = requireAccountBound(args);
+  if (!gate.ok) process.exit(refuseAccountGlobal());
+
+  const allAlive = gate.args.includes('--all-alive');
+  const wake = gate.args.includes('--wake');
+  const dryRun = gate.args.includes('--dry-run');
+  const board = gate.args.includes('--leaderboard');
+  const slug = gate.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);
+    console.log(usage);
+    process.exit(2);
   }
 
   const creds = loadCredentials();

package/commands/fleet.js

@@ -19,6 +19,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
+const { parseScopeFlag } = require('../lib/cli-scope');
 
 // ── Config ──────────────────────────────────────────────
 
@@ -327,21 +328,74 @@ async function fleetWatch(state, intervalSec = 10) {
   });
 }
 
+async function fleetWorkspaceStatus(root = process.cwd(), { json = false } = {}) {
+  const teamDir = path.join(root, 'atris', 'team');
+  const members = [];
+  if (fs.existsSync(teamDir)) {
+    for (const name of fs.readdirSync(teamDir).filter((n) => !n.startsWith('_') && !n.startsWith('.'))) {
+      const memberFile = path.join(teamDir, name, 'MEMBER.md');
+      if (!fs.existsSync(memberFile)) continue;
+      members.push({ member_id: name, member_name: name, member_type: 'agent', source: 'workspace' });
+    }
+  }
+  const missionsPath = path.join(root, '.atris', 'state', 'missions.jsonl');
+  let activeMissions = 0;
+  if (fs.existsSync(missionsPath)) {
+    const seen = new Map();
+    for (const line of fs.readFileSync(missionsPath, 'utf8').split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const rec = JSON.parse(line);
+        const id = rec.id || rec.mission_id;
+        if (id) seen.set(id, rec);
+      } catch {}
+    }
+    activeMissions = [...seen.values()].filter((m) => ['ready', 'running', 'planning', 'paused'].includes(m.status)).length;
+  }
+  const payload = {
+    scope: 'workspace',
+    hub: null,
+    members: { count: members.length, members },
+    claims: { count: 0, claims: [] },
+    missions_active: activeMissions,
+    note: 'workspace scope only. pass --global to query the machine Swarlo hub.',
+  };
+  if (json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  console.log(`\n  Fleet (workspace)`);
+  console.log(`  ─────────────────────────────────`);
+  console.log(`  Scope:   workspace`);
+  console.log(`  Members: ${members.length} (from atris/team)`);
+  for (const mem of members.slice(0, 24)) {
+    console.log(`    ${mem.member_name}`);
+  }
+  console.log(`  Missions active: ${activeMissions}`);
+  console.log(`  Hub:     not queried (use --global for localhost Swarlo)`);
+  console.log();
+}
+
 // ── Main ────────────────────────────────────────────────
 
 async function fleet(args = []) {
-  const subcommand = (args[0] || 'status').toLowerCase();
-  const rest = args.slice(1).join(' ');
+  const scope = parseScopeFlag(args);
+  const argv = scope.args.filter((a) => !String(a).startsWith('-'));
+  const flags = scope.args.filter((a) => String(a).startsWith('-'));
+  const subcommand = (argv[0] || 'status').toLowerCase();
+  const rest = argv.slice(1).join(' ');
+  const json = flags.includes('--json') || args.includes('--json');
 
   if (subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
     console.log('');
     console.log('  atris fleet — coordinate agent swarm via Swarlo');
     console.log('');
-    console.log('  fleet              show board status');
-    console.log('  fleet post <msg>   post message to board');
-    console.log('  fleet task <prompt> create a task for agents');
-    console.log('  fleet claim <key>  claim a task');
-    console.log('  fleet done <key>   report task complete');
+    console.log('  fleet              show workspace fleet (default)');
+    console.log('  fleet --global     query the machine Swarlo hub');
+    console.log('  fleet post <msg>   post message to board (global)');
+    console.log('  fleet task <prompt> create a task for agents (global)');
+    console.log('  fleet claim <key>  claim a task (global)');
+    console.log('  fleet done <key>   report task complete (global)');
     console.log('  fleet members      who is online');
     console.log('  fleet prune [min]  remove stale members (default 60m)');
     console.log('  fleet watch [sec]  live-tail the board (default 10s)');
@@ -349,12 +403,42 @@ async function fleet(args = []) {
     return;
   }
 
+  if (!scope.global && (subcommand === 'status' || subcommand === 'st' || subcommand === 'members' || subcommand === 'who')) {
+    await fleetWorkspaceStatus(process.cwd(), { json });
+    return;
+  }
+
+  if (!scope.global && ['post', 'say', 'task', 'claim', 'done', 'report', 'prune', 'watch', 'tail'].includes(subcommand)) {
+    console.error('fleet mutations need the machine hub. re-run with --global.');
+    process.exitCode = 1;
+    return;
+  }
+
   const state = await ensureRegistered();
 
   switch (subcommand) {
     case 'status':
     case 'st':
-      await fleetStatus(state);
+      if (json) {
+        const hubUrl = getHubUrl();
+        const hubId = getHubId();
+        const h = authHeaders(state);
+        const [members, posts, claims] = await Promise.all([
+          request('GET', `${hubUrl}/api/${hubId}/members`, null, h),
+          request('GET', `${hubUrl}/api/${hubId}/channels/general/posts?limit=5`, null, h),
+          request('GET', `${hubUrl}/api/${hubId}/claims`, null, h),
+        ]);
+        console.log(JSON.stringify({
+          scope: 'global',
+          hub: { id: hubId, url: hubUrl },
+          you: state.member_id,
+          members: members.data,
+          claims: claims.data,
+          recent: posts.data,
+        }, null, 2));
+      } else {
+        await fleetStatus(state);
+      }
       break;
     case 'post':
     case 'say':
@@ -387,9 +471,12 @@ async function fleet(args = []) {
       await fleetWatch(state, parseInt(rest) || 10);
       break;
     default:
-      // If no subcommand match, treat the whole thing as status
-      await fleetStatus(state);
+      if (!scope.global) {
+        await fleetWorkspaceStatus(process.cwd(), { json });
+      } else {
+        await fleetStatus(state);
+      }
   }
 }
 
-module.exports = { fleet };
+module.exports = { fleet, fleetWorkspaceStatus };

package/commands/founder.js

@@ -41,11 +41,23 @@ function parseArgs(args = []) {
   let index = args[0] === 'score' ? 1 : 0;
   let root = null;
   let days = DEFAULT_DAYS;
+  let json = false;
+  let global = false;
 
   while (index < args.length) {
     const arg = String(args[index]);
     if (arg === '--help' || arg === '-h' || arg === 'help') {
-      return { help: true, root, days };
+      return { help: true, root, days, json, global };
+    }
+    if (arg === '--json') {
+      json = true;
+      index += 1;
+      continue;
+    }
+    if (arg === '--global' || arg === '-g') {
+      global = true;
+      index += 1;
+      continue;
     }
     if (arg === '--root' || arg.startsWith('--root=')) {
       const value = arg.startsWith('--root=') ? arg.slice('--root='.length) : args[++index];
@@ -65,7 +77,7 @@ function parseArgs(args = []) {
     throw new Error(`unknown founder option: ${arg}`);
   }
 
-  return { help: false, root, days };
+  return { help: false, root, days, json, global };
 }
 
 function founderNow(env = process.env) {
@@ -156,17 +168,26 @@ function discoverRepos(root) {
     .sort((left, right) => path.basename(left).localeCompare(path.basename(right)));
 }
 
-function collectRepoScorecards(root, bounds) {
-  return discoverRepos(root).map((repoRoot) => {
-    const branch = defaultBranch(repoRoot);
-    const history = commitHistory(repoRoot, branch, bounds);
-    return {
-      repo: path.basename(repoRoot),
-      commitsThisWeek: totalInRange(history.timestamps, bounds.currentWindowStart, bounds.until, true),
-      commitsLastWeek: totalInRange(history.timestamps, bounds.priorWindowStart, bounds.currentWindowStart),
-      perDay: history.perDay,
-    };
-  }).sort((left, right) => (
+function scoreOneRepo(repoRoot, bounds) {
+  const branch = defaultBranch(repoRoot);
+  const history = commitHistory(repoRoot, branch, bounds);
+  return {
+    repo: path.basename(repoRoot),
+    commitsThisWeek: totalInRange(history.timestamps, bounds.currentWindowStart, bounds.until, true),
+    commitsLastWeek: totalInRange(history.timestamps, bounds.priorWindowStart, bounds.currentWindowStart),
+    perDay: history.perDay,
+  };
+}
+
+function collectRepoScorecards(root, bounds, { singleRepo = false, workspace = null } = {}) {
+  if (singleRepo) {
+    const target = workspace || root;
+    if (fs.existsSync(path.join(target, '.git')) || runGit(target, ['rev-parse', '--is-inside-work-tree']).ok) {
+      return [scoreOneRepo(target, bounds)];
+    }
+    return [];
+  }
+  return discoverRepos(root).map((repoRoot) => scoreOneRepo(repoRoot, bounds)).sort((left, right) => (
     right.commitsThisWeek - left.commitsThisWeek
     || right.commitsLastWeek - left.commitsLastWeek
     || left.repo.localeCompare(right.repo)
@@ -220,12 +241,18 @@ function percentChange(current, previous) {
   return Math.round(((current - previous) / previous) * 100);
 }
 
-function buildFounderScorecard(root, { days = DEFAULT_DAYS, now = new Date() } = {}) {
+function buildFounderScorecard(root, {
+  days = DEFAULT_DAYS,
+  now = new Date(),
+  singleRepo = false,
+  workspace = null,
+} = {}) {
   const bounds = historyBounds(now, days);
-  const perRepo = collectRepoScorecards(root, bounds);
+  const perRepo = collectRepoScorecards(root, bounds, { singleRepo, workspace });
   const commitsThisWeek = perRepo.reduce((total, repo) => total + repo.commitsThisWeek, 0);
   const commitsLastWeek = perRepo.reduce((total, repo) => total + repo.commitsLastWeek, 0);
-  const tasks = readTaskScorecard(root, bounds);
+  const taskRoot = singleRepo ? (workspace || root) : root;
+  const tasks = readTaskScorecard(taskRoot, bounds);
 
   return {
     ts: now.toISOString(),
@@ -272,8 +299,10 @@ function renderFounderScorecard(scorecard) {
 }
 
 function showFounderHelp() {
-  console.log('usage: atris founder [score] [--days n] [--root dir]');
+  console.log('usage: atris founder [score] [--days n] [--root dir] [--json] [--global]');
   console.log('shows the last 7 days against the prior 7 days from git and task receipts.');
+  console.log('default scope is this workspace. pass --global to scan sibling repos.');
+  console.log('supported flags: --days, --root, --json, --global, --help, -h');
 }
 
 function founderCommand(args = [], options = {}) {
@@ -282,7 +311,8 @@ function founderCommand(args = [], options = {}) {
     parsed = parseArgs(args);
   } catch (error) {
     console.error(`error: ${error.message}`);
-    return 1;
+    console.error('supported flags: --days, --root, --json, --global, --help, -h');
+    return 2;
   }
   if (parsed.help) {
     showFounderHelp();
@@ -293,11 +323,20 @@ function founderCommand(args = [], options = {}) {
   const currentWorkspace = workspaceRoot(cwd);
   const root = parsed.root
     ? path.resolve(cwd, parsed.root)
-    : defaultScanRoot(cwd, currentWorkspace);
+    : (parsed.global ? defaultScanRoot(cwd, currentWorkspace) : currentWorkspace);
   const now = founderNow(options.env || process.env);
-  const scorecard = buildFounderScorecard(root, { days: parsed.days, now });
+  const scorecard = buildFounderScorecard(root, {
+    days: parsed.days,
+    now,
+    singleRepo: !parsed.global && !parsed.root,
+    workspace: currentWorkspace,
+  });
   appendFounderScorecard(currentWorkspace, scorecard);
-  console.log(renderFounderScorecard(scorecard));
+  if (parsed.json) {
+    console.log(JSON.stringify(scorecard, null, 2));
+  } else {
+    console.log(renderFounderScorecard(scorecard));
+  }
   return 0;
 }
 

package/commands/human-missions.js

@@ -13,6 +13,8 @@ const {
 } = require('../lib/cloud-mission');
 const { apiRequestJson } = require('../utils/api');
 const { decodeJwtClaims, loadCredentials } = require('../utils/auth');
+const { isHelpToken } = require('../lib/noninteractive');
+const { isFreshWorkspace, speakFirstMinute } = require('../lib/first-minute');
 
 const PACKAGE_PATH = path.join(__dirname, '..', 'package.json');
 const HUMAN_STATES = Object.freeze({
@@ -138,6 +140,50 @@ function readBusinessBinding(root) {
   }
 }
 
+function isBoundCloudComputer(root = process.cwd()) {
+  return Boolean(readBusinessBinding(root));
+}
+
+function parseMissionId(args = []) {
+  const list = Array.isArray(args) ? args : [];
+  for (let i = 0; i < list.length; i += 1) {
+    const value = String(list[i] || '');
+    if (value === '--mission' || value === '--mission-id' || value === '--id') {
+      const next = list[i + 1];
+      if (next && !String(next).startsWith('-') && !isHelpToken(next)) return String(next).trim();
+      return '';
+    }
+    if (value.startsWith('--mission=') || value.startsWith('--mission-id=') || value.startsWith('--id=')) {
+      return value.slice(value.indexOf('=') + 1).trim();
+    }
+  }
+  // Bare positional id for stop/ready/approve (never treat free-sentence ask text as an id).
+  const flags = new Set(['--json', '--help', '-h', 'help']);
+  const positional = list.find((value) => value && !String(value).startsWith('-') && !flags.has(value));
+  if (!positional) return '';
+  // Mission ids are compact tokens, not multi-word wants.
+  if (list.filter((value) => value && !String(value).startsWith('-') && !flags.has(value)).length > 1) return '';
+  return String(positional).trim();
+}
+
+/**
+ * Scratch / unbound folders must not drive account-current cloud work.
+ * Require an explicit mission/task id: atris stop --mission <id>
+ */
+function refuseUnboundCloudComputer(args = [], options = {}, commandName = 'stop') {
+  const root = options.root || process.cwd();
+  if (options.businessId || isBoundCloudComputer(root)) return null;
+  if (commandName !== 'ask') {
+    const missionId = parseMissionId(args);
+    if (missionId) return null;
+  }
+  return new HumanCommandError(
+    'This folder is not a bound cloud-computer (missing .atris/business.json).',
+    `Pass --mission <id>: atris ${commandName} --mission <id>`,
+    2,
+  );
+}
+
 function credentialUserId(credentials) {
   const claims = decodeJwtClaims(credentials && credentials.token);
   return String(
@@ -488,12 +534,30 @@ function credentialsOrThrow(options = {}) {
   return credentials;
 }
 
+function isBareAsk(args = []) {
+  return (Array.isArray(args) ? args : []).every((value) => value === '--json');
+}
+
 async function askCommand(args, options = {}) {
   const asJson = args.includes('--json');
   if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
     (options.log || console.log)('Usage: atris ask "what you want" [--budget <usd>] [--json]');
     return 0;
   }
+  const root = options.root || process.cwd();
+  const fresh = isFreshWorkspace(root);
+  // Empty folder talks like bare atris. Do not start a mission or hit the
+  // network. After init, bare ask stays in the room.
+  if (!options.businessId && (fresh || isBareAsk(args))) {
+    return speakFirstMinute({
+      root,
+      fresh,
+      asJson,
+      log: options.log || console.log,
+    });
+  }
+  const unbound = refuseUnboundCloudComputer(args, options, 'ask');
+  if (unbound) return reportError(unbound, 'start that mission', asJson, options);
   try {
     const parsed = parseAskArgs(args);
     const credentials = credentialsOrThrow(options);
@@ -620,17 +684,26 @@ async function proofCommand(args = [], options = {}) {
 
 async function changeCurrentMission(action, body, args, options = {}) {
   const asJson = args.includes('--json');
+  const commandName = action === 'approve' ? 'approve' : action === 'answer' ? 'mission answer' : 'stop';
+  const unbound = refuseUnboundCloudComputer(args, options, commandName === 'mission answer' ? 'stop' : commandName);
+  if (unbound) return reportError(unbound, action === 'approve' ? 'approve that step' : action === 'answer' ? 'send that answer' : 'stop that mission', asJson, options);
   try {
     credentialsOrThrow(options);
-    const current = await loadCurrentMission(options);
-    const currentCard = missionCard(current, {}, options.now ? options.now() : Date.now());
+    const explicitId = parseMissionId(args);
+    let currentCard;
+    if (explicitId) {
+      currentCard = missionCard({ mission_id: explicitId }, {}, options.now ? options.now() : Date.now());
+    } else {
+      const current = await loadCurrentMission(options);
+      currentCard = missionCard(current, {}, options.now ? options.now() : Date.now());
+    }
     if (!currentCard.mission_id) {
       throw new HumanCommandError(
         'Atris could not identify the current mission.',
         'Run: atris mission',
       );
     }
-    if (['approve', 'answer'].includes(action) && currentCard.state !== 'your_turn') {
+    if (['approve', 'answer'].includes(action) && currentCard.state !== 'your_turn' && !explicitId) {
       throw new HumanCommandError(
         action === 'approve'
           ? 'Nothing is waiting for your approval.'
@@ -658,7 +731,7 @@ async function approveCommand(args, options = {}) {
 
 async function stopCommand(args, options = {}) {
   if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
-    (options.log || console.log)('Usage: atris stop [--json]');
+    (options.log || console.log)('Usage: atris stop [--mission <id>] [--json]');
     return 0;
   }
   return changeCurrentMission('stop', {}, args, options);
@@ -776,6 +849,8 @@ async function readyCommand(args, options = {}) {
     (options.log || console.log)('Usage: atris ready --json');
     return 0;
   }
+  const unbound = refuseUnboundCloudComputer(args, options, 'ready');
+  if (unbound) return reportError(unbound, 'check readiness', asJson, options);
   const request = options.apiRequestJson || apiRequestJson;
   const load = options.loadCredentials || loadCredentials;
   const credentials = load() || {};

package/commands/improve.js

@@ -433,10 +433,19 @@ function collectImproveVitals(options = {}, deps = {}) {
   const cronFn = deps.cronInstalled || cronInstalled;
   // Per-repo slots (pr 310): the crontab marker is derived from the root, so
   // the check must ask about THIS repo's markers, not the legacy default.
-  const slotMarkers = (() => {
-    try { return pulse.resolvePulseSlot(root).markers; } catch { return undefined; }
+  const slot = (() => {
+    try { return pulse.resolvePulseSlot(root); } catch { return null; }
   })();
-  const installed = Boolean(slotMarkers ? cronFn(slotMarkers) : cronFn());
+  const slotMarkers = slot ? slot.markers : undefined;
+  const legacyCronInstalled = Boolean(slotMarkers ? cronFn(slotMarkers) : cronFn());
+  const homeDir = deps.homeDir || os.homedir();
+  const launchdInstalled = (() => {
+    if (!slot) return false;
+    const label = `com.atris.pulse.${slot.marker.toLowerCase().replace(/^atris_pulse_/, '').replace(/[^a-z0-9]+/g, '-')}`;
+    const plistPath = path.join(homeDir, 'Library', 'LaunchAgents', `${label}.plist`);
+    return fs.existsSync(plistPath);
+  })();
+  const installed = launchdInstalled || legacyCronInstalled;
   const installNudge = installed ? null : 'the scheduled improve loop is off. turn it on: atris pulse install --model claude-sonnet-5';
 
   const experimentsPath = path.join(root, '.atris', 'state', 'experiments-daily.json');
@@ -803,6 +812,29 @@ async function runImprove(opts = {}, deps = {}) {
     };
   };
 
+  // Dry-run is a local plan only. Never call the paid /api/improve endpoint.
+  if (opts.dryRun) {
+    const finishedAt = now();
+    return {
+      ok: true,
+      source: 'local',
+      reason: 'dry_run',
+      summary: {
+        shipped: '(dry-run) no paid improve call',
+        verify: null,
+        reward: null,
+        credits: null,
+        files: [],
+        dry_run: true,
+      },
+      scorecardPath: null,
+      journalPath: null,
+      receipt: 'skipped',
+      startedAt,
+      finishedAt,
+    };
+  }
+
   // No auth → local fallback (or report if fallback disabled).
   if (!creds || !creds.token) {
     if (!localFallbackEligible) {
@@ -934,6 +966,24 @@ function formatImproveReport(result = {}) {
 
 const REVISIONS_SCHEMA = 'atris.improve_revisions.v1';
 const REVISION_WINDOW_HOURS = 72;
+// Shared journal and state files are touched by agents and humans alike as a
+// matter of routine (daily logs, now.md, run receipts), so overlap there says
+// nothing about the quality of a landing. On 2026-08-21 half the "revisions"
+// in a live reading were journal commits following journal commits. Only
+// product-file overlap counts.
+const REVISION_IGNORED_FILES = [
+  /^atris\/logs\//,
+  /^atris\/runs\//,
+  /^atris\/team\/[^/]+\/(?:logs|now\.md)/,
+  /^atris\/(?:now|thinking|TODO)\.md$/,
+  /^atris\/brain\//,
+  /^atris\/status\//,
+  /^\.atris\//,
+];
+
+function isRevisionSignalFile(file) {
+  return !REVISION_IGNORED_FILES.some((re) => re.test(String(file || '')));
+}
 const REVISION_WINDOW_MS = REVISION_WINDOW_HOURS * 60 * 60 * 1000;
 const AGENT_TRAILER_MARKERS = [
   'atris-builder[bot]',
@@ -1041,7 +1091,7 @@ function collectRevisionSignals(root, options = {}) {
 
   const revisions = [];
   for (const landing of landings) {
-    const landedFiles = new Set(filesOf(landing));
+    const landedFiles = new Set(filesOf(landing).filter(isRevisionSignalFile));
     if (!landedFiles.size) continue;
     const revisedBy = [];
     const touched = new Set();