atris 3.52.0 → 3.55.0

package/commands/playbook.js

@@ -0,0 +1,381 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { execFile } = require('child_process');
+
+const TRIAL_PROMPTS = [
+  'Write a brief status update telling your manager the deploy finished and one alert needs review.',
+  'Explain to a teammate in a few sentences why the cache change made startup faster.',
+  'Write a short note announcing that exports now run on a schedule.',
+  'Summarize for a non-engineer what changed in this week\'s release.',
+  'Write a two-paragraph answer on whether we should switch to the new logging library.',
+  'Draft a short reply declining a meeting and proposing async notes instead.',
+];
+const TRIAL_DRAFTS_PER_ARM = 2;
+const TRIAL_BET = 0.5;
+const JARGON_WORDS = /\b(?:leverage|seamless|robust|delve|synergy)\b/i;
+
+function playbookFile(root = process.cwd()) {
+  return path.join(root, '.atris', 'state', 'playbook.json');
+}
+
+function readPlaybook(root = process.cwd()) {
+  try {
+    const value = JSON.parse(fs.readFileSync(playbookFile(root), 'utf8'));
+    return { version: 1, rules: Array.isArray(value.rules) ? value.rules : [] };
+  } catch (err) {
+    if (err.code === 'ENOENT') return { version: 1, rules: [] };
+    throw err;
+  }
+}
+
+function writePlaybook(playbook, root = process.cwd()) {
+  const file = playbookFile(root);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(playbook, null, 2)}\n`);
+}
+
+function optionValue(args, name) {
+  const index = args.indexOf(name);
+  if (index === -1) return null;
+  if (!args[index + 1] || args[index + 1].startsWith('--')) {
+    throw new Error(`${name} needs a value`);
+  }
+  return args[index + 1];
+}
+
+function printHelp(output) {
+  output('usage: atris playbook [show] [--family <family>] [--json]');
+  output('       atris playbook add <family> <rule> [--source <source>]');
+  output('       atris playbook inject [--family <family>]');
+  output('       atris playbook remove <id>');
+  output('       atris playbook verify <id> --with <score> --without <score> [--method <method>]');
+  output('       atris playbook trial [--engine <cmd>] [--max-pairs <n>] [--alpha <a>]');
+}
+
+function filteredRules(playbook, family) {
+  return family ? playbook.rules.filter((entry) => entry.family === family) : playbook.rules;
+}
+
+function mean(values) {
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+
+function sentenceCount(paragraph) {
+  const value = paragraph.trim();
+  if (!value) return 0;
+  const endings = value.match(/[.!?]+(?=\s|$)/g) || [];
+  return endings.length + (/[.!?]["')\]]*\s*$/.test(value) ? 0 : 1);
+}
+
+function gradeText(text) {
+  const value = String(text || '').trim();
+  const paragraphs = value ? value.split(/\n\s*\n/) : [''];
+  const checks = [
+    !value.includes('\u2014'),
+    paragraphs.every((paragraph) => sentenceCount(paragraph) <= 2),
+    !JARGON_WORDS.test(value),
+    !/\b[A-Z]{4,}\b/.test(value),
+    !value.includes('!'),
+  ];
+  return checks.filter(Boolean).length / checks.length;
+}
+
+function bettingEvidence(differences, direction) {
+  const logEvidence = differences.reduce((sum, difference) => (
+    sum + Math.log(1 + (direction * TRIAL_BET * difference))
+  ), 0);
+  return Math.exp(Math.min(logEvidence, Math.log(Number.MAX_VALUE)));
+}
+
+function trialPrompt(rules, prompt) {
+  const system = [
+    'You are a sharp, plain-spoken assistant. Answer directly and briefly.',
+    rules.length ? `Follow every writing rule that applies:\n${rules.map((rule) => `- ${rule}`).join('\n')}` : '',
+  ].filter(Boolean).join('\n\n');
+  return { system, argv: `${system}\n\nPrompt:\n${prompt}` };
+}
+
+function runShellEngine(command, prompt) {
+  return new Promise((resolve, reject) => {
+    execFile('/bin/sh', ['-c', `${command} "$1"`, 'atris-playbook-engine', prompt], {
+      timeout: 120000,
+      maxBuffer: 1024 * 1024,
+    }, (err, stdout) => {
+      if (err) {
+        reject(new Error(`trial engine failed: ${err.message || err}`));
+        return;
+      }
+      const reply = String(stdout || '').trim();
+      if (!reply) {
+        reject(new Error('trial engine returned an empty reply'));
+        return;
+      }
+      resolve(reply);
+    });
+  });
+}
+
+async function runLocalEngine(system, prompt, fetchImpl) {
+  let lastError = null;
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    try {
+      const response = await fetchImpl('http://localhost:11434/v1/chat/completions', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          model: 'qwen2.5:7b',
+          temperature: 0.8,
+          messages: [
+            { role: 'system', content: system },
+            { role: 'user', content: prompt },
+          ],
+        }),
+        signal: AbortSignal.timeout(120000),
+      });
+      if (!response.ok) {
+        lastError = new Error(`local trial engine returned status ${response.status}`);
+        continue;
+      }
+      const body = await response.json();
+      const reply = String(body.choices?.[0]?.message?.content || '').trim();
+      if (reply) return reply;
+      lastError = new Error('local trial engine returned an empty reply');
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  throw new Error(`local trial engine failed: ${lastError?.message || 'no reply'}`);
+}
+
+async function armScore(rules, prompt, options) {
+  const prepared = trialPrompt(rules, prompt);
+  const drafts = [];
+  for (let index = 0; index < TRIAL_DRAFTS_PER_ARM; index += 1) {
+    drafts.push(options.engine
+      ? await runShellEngine(options.engine, prepared.argv)
+      : await runLocalEngine(prepared.system, prompt, options.fetchImpl));
+  }
+  return Math.max(...drafts.map(gradeText));
+}
+
+function numberedPrompt(index) {
+  const base = TRIAL_PROMPTS[index % TRIAL_PROMPTS.length];
+  const cycle = Math.floor(index / TRIAL_PROMPTS.length);
+  return cycle === 0 ? base : `${base} Variation ${cycle}.`;
+}
+
+function trialStats(rule, alphaBudget) {
+  const differences = Array.isArray(rule.trial_diffs) ? rule.trial_diffs : [];
+  if (differences.length === 0) return null;
+  return {
+    pairs: differences.length,
+    difference: mean(differences),
+    killEvidence: bettingEvidence(differences, 1),
+    certifyEvidence: bettingEvidence(differences, -1),
+    threshold: 1 / alphaBudget,
+  };
+}
+
+function applyTrialVerdict(rule, stats, options) {
+  const quarantined = stats.killEvidence >= stats.threshold;
+  const certified = stats.certifyEvidence >= stats.threshold;
+  if (!quarantined && !certified) return null;
+  const withScores = Array.isArray(rule.trial_scores_with) ? rule.trial_scores_with : [];
+  const withoutScores = Array.isArray(rule.trial_scores_without) ? rule.trial_scores_without : [];
+  rule.quarantined = quarantined;
+  rule.verified = {
+    method: 'paired-trial',
+    score_with: withScores.length ? mean(withScores) : null,
+    score_without: withoutScores.length ? mean(withoutScores) : null,
+    pairs: stats.pairs,
+    mean_difference: stats.difference,
+    kill_evidence: stats.killEvidence,
+    certify_evidence: stats.certifyEvidence,
+    evidence_threshold: stats.threshold,
+    alpha: options.alphaBudget,
+    at: options.now(),
+  };
+  return quarantined ? 'quarantined' : 'certified';
+}
+
+async function runRuleTrial(rule, playbook, options) {
+  const activeRules = playbook.rules.filter((entry) => entry !== rule && !entry.quarantined);
+  const rulesWithout = activeRules.map((entry) => entry.rule);
+  const rulesWith = [...rulesWithout, rule.rule];
+  rule.trial_diffs = Array.isArray(rule.trial_diffs) ? rule.trial_diffs : [];
+  rule.trial_scores_with = Array.isArray(rule.trial_scores_with) ? rule.trial_scores_with : [];
+  rule.trial_scores_without = Array.isArray(rule.trial_scores_without) ? rule.trial_scores_without : [];
+  options.output(`on trial: ${rule.id} (${rule.trial_diffs.length} prior pairs)`);
+
+  let stats = trialStats(rule, options.alphaBudget);
+  let verdict = stats ? applyTrialVerdict(rule, stats, options) : null;
+  while (!verdict && rule.trial_diffs.length < options.maxPairs) {
+    const start = rule.trial_diffs.length;
+    const prompt = numberedPrompt(start);
+    const [scoreWith, scoreWithout] = await Promise.all([
+      armScore(rulesWith, prompt, options),
+      armScore(rulesWithout, prompt, options),
+    ]);
+    rule.trial_scores_with.push(scoreWith);
+    rule.trial_scores_without.push(scoreWithout);
+    rule.trial_diffs.push(Number((scoreWithout - scoreWith).toFixed(6)));
+    stats = trialStats(rule, options.alphaBudget);
+    verdict = applyTrialVerdict(rule, stats, options);
+    writePlaybook(playbook, options.root);
+  }
+
+  if (verdict) {
+    writePlaybook(playbook, options.root);
+    options.output(`rule ${verdict}: ${rule.id} after ${stats.pairs} pairs`);
+    return;
+  }
+  options.output(`rule undecided after ${rule.trial_diffs.length} pairs: ${rule.id}`);
+}
+
+async function runTrials(playbook, rest, options) {
+  const rawMaxPairs = optionValue(rest, '--max-pairs');
+  const rawAlpha = optionValue(rest, '--alpha');
+  const maxPairs = rawMaxPairs === null ? 30 : Number(rawMaxPairs);
+  const alpha = rawAlpha === null ? 0.05 : Number(rawAlpha);
+  if (!Number.isInteger(maxPairs) || maxPairs < 1) throw new Error('--max-pairs needs a positive integer');
+  if (!Number.isFinite(alpha) || alpha <= 0 || alpha >= 1) throw new Error('--alpha needs a number between 0 and 1');
+  const engine = optionValue(rest, '--engine');
+  const unresolved = playbook.rules.filter((rule) => !rule.verified && rule.quarantined !== true);
+  if (unresolved.length === 0) {
+    options.output('no unresolved rules');
+    return 0;
+  }
+  const alphaBudget = alpha / Math.max(1, playbook.rules.length);
+  for (const rule of unresolved) {
+    await runRuleTrial(rule, playbook, {
+      ...options,
+      engine,
+      maxPairs,
+      alphaBudget,
+    });
+  }
+  return 0;
+}
+
+function playbookCommand(args = [], options = {}) {
+  const root = options.root || process.cwd();
+  const output = options.output || console.log;
+  const now = options.now || (() => new Date().toISOString());
+  const makeId = options.makeId || (() => crypto.randomUUID().slice(0, 8));
+  const subcommand = args[0] && !args[0].startsWith('--') ? args[0] : 'show';
+  const rest = subcommand === 'show' && args[0] !== 'show' ? args : args.slice(1);
+
+  if (args.includes('--help') || args.includes('-h') || subcommand === 'help') {
+    printHelp(output);
+    return 0;
+  }
+
+  const playbook = readPlaybook(root);
+  if (subcommand === 'trial') {
+    return runTrials(playbook, rest, {
+      root,
+      output,
+      now,
+      fetchImpl: options.fetch || globalThis.fetch,
+    });
+  }
+  if (subcommand === 'show') {
+    const family = optionValue(rest, '--family');
+    const rules = filteredRules(playbook, family);
+    if (rest.includes('--json')) {
+      output(JSON.stringify({ version: 1, rules }, null, 2));
+      return 0;
+    }
+    if (rules.length === 0) {
+      output('no style rules saved');
+      return 0;
+    }
+    const families = [...new Set(rules.map((entry) => entry.family))];
+    for (const name of families) {
+      output(`${name}:`);
+      for (const entry of rules.filter((rule) => rule.family === name)) {
+        const state = entry.quarantined ? ' (quarantined)' : '';
+        output(`- ${entry.id}: ${entry.rule}${state}`);
+      }
+    }
+    return 0;
+  }
+
+  if (subcommand === 'add') {
+    const family = rest[0];
+    const rule = rest[1];
+    if (!family || !rule || family.startsWith('--') || rule.startsWith('--')) {
+      throw new Error('add needs a family and rule');
+    }
+    const duplicate = playbook.rules.find((entry) => entry.family === family && entry.rule === rule);
+    if (duplicate) {
+      output(`rule already exists: ${duplicate.id}`);
+      return 0;
+    }
+    const entry = {
+      id: makeId(),
+      family,
+      rule,
+      source: optionValue(rest, '--source') || '',
+      verified: null,
+      created_at: now(),
+    };
+    playbook.rules.push(entry);
+    writePlaybook(playbook, root);
+    output(`rule added: ${entry.id}`);
+    return 0;
+  }
+
+  if (subcommand === 'inject') {
+    const family = optionValue(rest, '--family');
+    const rules = filteredRules(playbook, family).filter((entry) => !entry.quarantined);
+    if (rules.length === 0) return 0;
+    output('Workspace style rules (follow every rule that applies):');
+    for (const entry of rules) output(`- ${entry.rule}`);
+    return 0;
+  }
+
+  if (subcommand === 'remove') {
+    const id = rest[0];
+    if (!id) throw new Error('remove needs a rule id');
+    const index = playbook.rules.findIndex((entry) => entry.id === id);
+    if (index === -1) throw new Error(`rule not found: ${id}`);
+    playbook.rules.splice(index, 1);
+    writePlaybook(playbook, root);
+    output(`rule removed: ${id}`);
+    return 0;
+  }
+
+  if (subcommand === 'verify') {
+    const id = rest[0];
+    const rawScoreWith = optionValue(rest, '--with');
+    const rawScoreWithout = optionValue(rest, '--without');
+    const scoreWith = Number(rawScoreWith);
+    const scoreWithout = Number(rawScoreWithout);
+    if (!id) throw new Error('verify needs a rule id');
+    if (rawScoreWith === null || rawScoreWithout === null ||
+        !Number.isFinite(scoreWith) || !Number.isFinite(scoreWithout)) {
+      throw new Error('verify needs numeric --with and --without scores');
+    }
+    const entry = playbook.rules.find((rule) => rule.id === id);
+    if (!entry) throw new Error(`rule not found: ${id}`);
+    entry.verified = {
+      method: optionValue(rest, '--method') || 'replay',
+      score_with: scoreWith,
+      score_without: scoreWithout,
+      at: now(),
+    };
+    if (scoreWith < scoreWithout) entry.quarantined = true;
+    else delete entry.quarantined;
+    writePlaybook(playbook, root);
+    output(entry.quarantined ? `rule quarantined: ${id}` : `rule verified: ${id}`);
+    return 0;
+  }
+
+  throw new Error(`unknown playbook command: ${subcommand}`);
+}
+
+module.exports = { playbookCommand, playbookFile, readPlaybook, gradeText };

package/commands/plugin.js

@@ -334,6 +334,10 @@ function showPluginInfo() {
 // --- PUBLISH subcommand ---
 
 function publishPlugin(...args) {
+  if (args.some((arg) => arg === '--help' || arg === '-h' || arg === 'help')) {
+    console.error('Usage: atris plugin publish [--repo=path]');
+    process.exit(2);
+  }
   const projectDir = process.cwd();
   const skillsDir = path.join(projectDir, 'atris', 'skills');
 
@@ -446,6 +450,18 @@ function publishPlugin(...args) {
 // --- Main Dispatcher ---
 
 function pluginCommand(subcommand, ...args) {
+  if (!subcommand || subcommand === '--help' || subcommand === '-h' || subcommand === 'help'
+    || args.some((a) => a === '--help' || a === '-h' || a === 'help')) {
+    console.log('');
+    console.log('Usage: atris plugin <subcommand>');
+    console.log('');
+    console.log('Subcommands:');
+    console.log('  build [--output=path]  - Package skills into .plugin for Cowork');
+    console.log('  publish [--repo=path]  - Sync skills to marketplace repo and push');
+    console.log('  info                   - Preview what will be included');
+    console.log('');
+    process.exit(0);
+  }
   switch (subcommand) {
     case 'build':
       buildPlugin(...args);

package/commands/radar.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execFileSync } = require('child_process');
+const { parseScopeFlag, pathUnderRoot } = require('../lib/cli-scope');
 
 function safeJson(text, fallback = null) {
   try { return JSON.parse(text); } catch { return fallback; }
@@ -54,23 +55,39 @@ function agentTypeForCommand(command) {
   if (/(^|\s|\/)claude(\s|$)/.test(cmd) && !/Claude\.app/.test(cmd)) return 'claude';
   if (/(^|\s|\/)opencode(\s|$)/.test(cmd)) return 'opencode';
   if (/(^|\s|\/)devin(\s|$)/.test(cmd)) return 'devin';
+  if (/(^|\s|\/)agy(\s|$)/.test(cmd)) return 'agy';
   if (/(^|\s|\/)droid(\s|$)/.test(cmd)) return 'droid';
   return null;
 }
 
-function processCwd(pid, deps) {
+// Resolve cwd for many pids at once: one lsof call on darwin instead of one
+// per process. Returns a Map of pid (string) -> cwd; missing pids stay absent.
+function processCwds(pids, deps) {
   const { platform, execFile } = deps;
-  try {
-    if (platform === 'linux') {
-      return deps.readlink(`/proc/${pid}/cwd`);
+  const byPid = new Map();
+  if (!pids.length) return byPid;
+  if (platform === 'linux') {
+    for (const pid of pids) {
+      try { byPid.set(String(pid), deps.readlink(`/proc/${pid}/cwd`)); } catch {}
     }
-    if (platform === 'darwin') {
-      const out = execFile('lsof', ['-a', '-p', String(pid), '-d', 'cwd', '-Fn'], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
-      const line = String(out).split(/\r?\n/).find(value => value.startsWith('n'));
-      return line ? line.slice(1) : '';
+    return byPid;
+  }
+  if (platform === 'darwin') {
+    let out = '';
+    try {
+      out = execFile('lsof', ['-a', '-d', 'cwd', '-Fn', '-p', pids.map(String).join(',')], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
+    } catch (error) {
+      // lsof exits non-zero when any pid in the batch is gone; keep the rows it
+      // did print instead of losing every cwd.
+      out = error && error.stdout ? error.stdout : '';
     }
-  } catch {}
-  return '';
+    let currentPid = '';
+    for (const line of String(out).split(/\r?\n/)) {
+      if (line.startsWith('p')) currentPid = line.slice(1).trim();
+      else if (line.startsWith('n') && currentPid) byPid.set(currentPid, line.slice(1));
+    }
+  }
+  return byPid;
 }
 
 function gitBranch(cwd, execFile) {
@@ -93,22 +110,28 @@ function collectAgents(deps) {
     .map(row => ({ ...row, agent: agentTypeForCommand(row.command) }))
     .filter(row => row.agent);
   const parentPids = new Set(agentRows.map(row => String(row.ppid || '')).filter(Boolean));
-  return agentRows
-    .filter(row => !parentPids.has(String(row.pid)))
-    .map(row => {
-      const cwd = processCwd(row.pid, deps);
-      return {
-        pid: row.pid,
-        agent: row.agent,
-        command: row.command,
-        status: row.stat.includes('Z') ? 'zombie' : row.stat.includes('T') ? 'stopped' : 'active',
-        cwd,
-        repo: repoLabel(cwd),
-        branch: gitBranch(cwd, deps.execFile),
-        cpu: row.cpu,
-        mem: row.mem,
-      };
-    });
+  const topRows = agentRows.filter(row => !parentPids.has(String(row.pid)));
+  const cwdByPid = processCwds(topRows.map(row => row.pid), deps);
+  const branchByCwd = new Map();
+  const branchFor = (cwd) => {
+    if (!cwd) return '';
+    if (!branchByCwd.has(cwd)) branchByCwd.set(cwd, gitBranch(cwd, deps.execFile));
+    return branchByCwd.get(cwd);
+  };
+  return topRows.map(row => {
+    const cwd = cwdByPid.get(String(row.pid)) || '';
+    return {
+      pid: row.pid,
+      agent: row.agent,
+      command: row.command,
+      status: row.stat.includes('Z') ? 'zombie' : row.stat.includes('T') ? 'stopped' : 'active',
+      cwd,
+      repo: repoLabel(cwd),
+      branch: branchFor(cwd),
+      cpu: row.cpu,
+      mem: row.mem,
+    };
+  });
 }
 
 function loadTasks(root, deps) {
@@ -287,8 +310,11 @@ function loadTeam(root, deps) {
   };
 }
 
-function loadBrain(root, deps) {
-  const scorecards = readJsonLines(path.join(root, '.atris', 'state', 'scorecards.jsonl'), deps.readFile, deps.exists);
+function loadScorecards(root, deps) {
+  return readJsonLines(path.join(root, '.atris', 'state', 'scorecards.jsonl'), deps.readFile, deps.exists);
+}
+
+function loadBrain(root, deps, scorecards = loadScorecards(root, deps)) {
   const operatorDir = path.join(root, '.atris', 'state', 'operator-scorecards');
   let operatorScorecards = 0;
   try {
@@ -316,7 +342,7 @@ function countDirectoryEntries(dir, deps, predicate = () => true) {
   return listNames(dir, deps).filter(predicate).length;
 }
 
-function loadBusinessCollaboration(root, deps, team = {}) {
+function loadBusinessCollaboration(root, deps, team = {}, scorecardCount = countJsonLines(path.join(root, '.atris', 'state', 'scorecards.jsonl'), deps)) {
   const business = readJsonFile(path.join(root, '.atris', 'business.json'), deps, null);
   const runtime = readJsonFile(path.join(root, '.atris', 'state', 'runtime.json'), deps, null);
   const sync = readJsonFile(path.join(root, '.atris', 'state', '_sync.json'), deps, null);
@@ -335,7 +361,7 @@ function loadBusinessCollaboration(root, deps, team = {}) {
   const localReceipts = countDirectoryEntries(path.join(root, '.atris', 'receipts'), deps, name => /\.(json|md|txt)$/i.test(name));
   const events = countJsonLines(path.join(root, '.atris', 'state', 'events.jsonl'), deps);
   const episodes = countJsonLines(path.join(root, '.atris', 'state', 'episodes.jsonl'), deps);
-  const scorecards = countJsonLines(path.join(root, '.atris', 'state', 'scorecards.jsonl'), deps);
+  const scorecards = scorecardCount;
   const computerDirs = countDirectoryEntries(path.join(root, 'atris', 'computers'), deps, name => !name.startsWith('.'));
   const hasOnboarding = ingestPacks > 0 || starterBriefs > 0 || onePagers > 0;
   const hasProofLoop = events > 0 || episodes > 0 || scorecards > 0 || localReceipts > 0;
@@ -770,6 +796,7 @@ function nextAction(tasks, missions, worktrees, agents, os = {}) {
 
 function collectRadar(options = {}) {
   const root = options.root || process.cwd();
+  const scopeKind = options.scope === 'global' ? 'global' : 'workspace';
   const deps = {
     execFile: options.execFileSync || execFileSync,
     readFile: options.readFileSync || fs.readFileSync,
@@ -785,13 +812,23 @@ function collectRadar(options = {}) {
   const identityCache = new Map();
   const missions = loadMissions(root, deps, nowMs);
   identityCache.set(root, { missions, missionLocks: loadMissionLocks(path.join(root, '.atris', 'state'), deps), memberLocks: loadMemberLoopLocks(path.join(root, '.atris', 'state'), deps) });
-  const worktrees = loadWorktrees(root, deps);
-  const agents = collectAgents(deps).map(agent => {
+  let worktrees = loadWorktrees(root, deps);
+  if (scopeKind !== 'global') {
+    // Refuse other-repo dirty worktrees in the default workspace view.
+    worktrees = worktrees.filter((wt) => pathUnderRoot(wt.path, root));
+  }
+  const branchIdentityCache = new Map();
+  const branchIdentityFor = (cwd) => {
+    if (!cwd) return null;
+    if (!branchIdentityCache.has(cwd)) branchIdentityCache.set(cwd, branchIdentityAtCwd(cwd, deps.execFile));
+    return branchIdentityCache.get(cwd);
+  };
+  let agents = collectAgents(deps).map(agent => {
     const taskWorkspaceRoot = findTaskWorkspaceRoot(agent.cwd, deps);
     const agentTasks = taskWorkspaceRoot ? loadTasksCached(taskWorkspaceRoot, deps, taskCache) : [];
     const identity = taskWorkspaceRoot ? loadWorkspaceIdentity(taskWorkspaceRoot, deps, identityCache, nowMs) : { missions: [], missionLocks: [], memberLocks: [] };
     const sidecar = loadAgentWorktreeSidecar(agent.cwd, deps);
-    const branchIdentity = branchIdentityAtCwd(agent.cwd, deps.execFile);
+    const branchIdentity = branchIdentityFor(agent.cwd);
     const sessionId = parseSessionIdFromCommand(agent.command);
     const interactive = agent.agent === 'claude' && isInteractiveClaudeCommand(agent.command);
     const resolved = resolveAgentTaskBinding({
@@ -823,21 +860,38 @@ function collectRadar(options = {}) {
       task_action: task ? taskSessionAction(agent, task, taskWorkspaceRoot) : untaskedAction(agent, taskWorkspaceRoot, agentTasks, resolved),
     };
   });
+  if (scopeKind !== 'global') {
+    agents = agents.filter((agent) => pathUnderRoot(agent.cwd, root)
+      || (agent.task_workspace && pathUnderRoot(findTaskWorkspaceRoot(agent.cwd, deps), root)));
+  }
+  const scorecards = loadScorecards(root, deps);
   const osState = {
     xp: loadXp(root, deps),
     team: loadTeam(root, deps),
-    brain: loadBrain(root, deps),
+    brain: loadBrain(root, deps, scorecards),
     swarlo: loadSwarlo(tasks),
     loop: loadLoop(missions, root, deps),
   };
-  osState.business = loadBusinessCollaboration(root, deps, osState.team);
-  return { root, generated_at: new Date(nowMs).toISOString(), summary: summarize(tasks, missions, worktrees, agents), os: osState, next_action: nextAction(tasks, missions, worktrees, agents, osState), agents, tasks, missions, worktrees };
+  osState.business = loadBusinessCollaboration(root, deps, osState.team, scorecards.length);
+  return {
+    scope: scopeKind,
+    root,
+    generated_at: new Date(nowMs).toISOString(),
+    summary: summarize(tasks, missions, worktrees, agents),
+    os: osState,
+    next_action: nextAction(tasks, missions, worktrees, agents, osState),
+    agents,
+    tasks,
+    missions,
+    worktrees,
+  };
 }
 
 function renderRadar(data) {
   const lines = [];
   const s = data.summary;
   lines.push('Operator radar');
+  lines.push(`Scope: ${data.scope || 'workspace'}${data.scope === 'global' ? ' (machine)' : ' (this workspace)'}`);
   lines.push('');
   lines.push(`Agents: ${s.agents.active}/${s.agents.total} active`);
   lines.push(`Tasks: ${s.tasks.open} open, ${s.tasks.claimed} claimed, ${s.tasks.review} review (${s.tasks.certifiedReview} certified)`);
@@ -1178,17 +1232,19 @@ function renderAgentTop(data) {
 
 function radarCommand(args = [], options = {}) {
   if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
-    console.log('Usage: atris radar [--json] [--agents]');
+    console.log('Usage: atris radar [--json] [--agents] [--global]');
     console.log('Usage: atris radar agents');
     console.log('Usage: atris ctop');
     console.log('');
     console.log('Shows live agent processes joined with Atris tasks, missions, and worktrees.');
+    console.log('Default scope is this workspace. Pass --global for the whole machine.');
     console.log('Use --agents or ctop for a process-first CPU/memory view.');
     return 0;
   }
-  const data = collectRadar(options);
-  const agentsOnly = args.includes('--agents') || args[0] === 'agents';
-  if (args.includes('--json')) console.log(JSON.stringify(agentsOnly ? agentTopPayload(data) : data, null, 2));
+  const scope = parseScopeFlag(args);
+  const data = collectRadar({ ...options, scope: scope.kind });
+  const agentsOnly = scope.args.includes('--agents') || scope.args[0] === 'agents';
+  if (scope.args.includes('--json') || args.includes('--json')) console.log(JSON.stringify(agentsOnly ? { ...agentTopPayload(data), scope: data.scope } : data, null, 2));
   else if (agentsOnly) console.log(renderAgentTop(data));
   else console.log(renderRadar(data));
   return 0;