atris 3.37.1 → 3.40.0

package/commands/taste.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const { addTaste, listTaste } = require('../lib/taste-lessons');
+
+const VALID_FLAGS = new Set(['--why', '--scope', '--example']);
+
+function usage(stdout = process.stdout) {
+  stdout.write([
+    'usage: atris taste keep|kill|more "<subject>" --why "<reason>" [--scope writing|design|code|any] [--example path]',
+    '       atris taste list [--scope writing|design|code|any]',
+    '',
+  ].join('\n'));
+}
+
+function flagValue(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) return undefined;
+  const value = args[index + 1];
+  if (!value || value.startsWith('--')) throw new Error(`${flag} needs a value`);
+  return value;
+}
+
+function rejectUnknownArgs(args, positionalCount) {
+  for (let index = positionalCount; index < args.length; index += 1) {
+    const value = args[index];
+    if (!value.startsWith('--')) continue;
+    if (!VALID_FLAGS.has(value)) throw new Error(`unknown option: ${value}`);
+    index += 1;
+  }
+}
+
+function renderTaste(entries, stdout = process.stdout, filtered = false) {
+  if (!entries.length) {
+    stdout.write(`${filtered ? 'no taste lessons match this scope.' : 'no taste lessons have been recorded yet.'}\n`);
+    return;
+  }
+
+  for (const entry of entries) {
+    stdout.write(`the operator's verdict is ${entry.verdict} for "${entry.subject}".\n`);
+    stdout.write(`the reason is: ${entry.why}\n`);
+    stdout.write(`this applies to ${entry.scope}.\n`);
+    if (entry.example) stdout.write(`the example is ${entry.example}.\n`);
+    stdout.write(`this was added on ${entry.added}.\n\n`);
+  }
+}
+
+function tasteCommand(args = [], options = {}) {
+  const stdout = options.stdout || process.stdout;
+  const stderr = options.stderr || process.stderr;
+  const root = options.root || process.cwd();
+  const [subcommand, ...rest] = args;
+
+  if (!subcommand) {
+    renderTaste(listTaste({ root }), stdout);
+    stdout.write('\n');
+    usage(stdout);
+    return 0;
+  }
+  if (subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+    usage(stdout);
+    return 0;
+  }
+
+  try {
+    if (subcommand === 'list') {
+      rejectUnknownArgs(rest, 0);
+      const scope = flagValue(rest, '--scope');
+      renderTaste(listTaste({ root, scope }), stdout, !!scope);
+      return 0;
+    }
+
+    if (!['keep', 'kill', 'more'].includes(subcommand)) {
+      stderr.write(`unknown taste verdict: ${subcommand}.\n`);
+      usage(stderr);
+      return 2;
+    }
+
+    rejectUnknownArgs(rest, 1);
+    const subject = rest[0];
+    const why = flagValue(rest, '--why');
+    const scope = flagValue(rest, '--scope') || 'any';
+    const example = flagValue(rest, '--example');
+    const entry = addTaste({
+      verdict: subcommand,
+      subject,
+      why,
+      scope,
+      example,
+      added: new Date().toISOString().slice(0, 10),
+      root,
+    });
+    stdout.write(`saved the operator's ${entry.verdict} verdict for "${entry.subject}".\n`);
+    return 0;
+  } catch (error) {
+    stderr.write(`taste could not continue: ${error.message}.\n`);
+    usage(stderr);
+    return 2;
+  }
+}
+
+module.exports = { tasteCommand };

package/commands/teach.js

@@ -0,0 +1,86 @@
+'use strict';
+
+/**
+ * atris teach — turn one bad turn into a permanent guard.
+ *
+ *   atris teach                          list cases and which ones are guards
+ *   atris teach add --id <id> --prompt "…" --require "<fragment>" [--complaint "…"]
+ *   atris teach run [<id>]               run one case (or all) and advance state
+ *   atris teach guards                   rerun every promoted guard (regression suite)
+ *
+ * Thin shim over `python -m rl.teach` in the backend venv, which owns the
+ * red gate: a case must be observed FAILING before it can become a guard.
+ * Nonzero exit means a guard regressed.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const BACKEND_ROOT = '/Users/keshavrao/arena/atrisos-backend';
+
+function requireVenvPython() {
+  const venvPython = path.join(BACKEND_ROOT, 'venv/bin/python');
+  if (!fs.existsSync(venvPython)) {
+    console.error(`✗ Backend venv not found: ${venvPython}`);
+    process.exit(1);
+  }
+  return venvPython;
+}
+
+function usage() {
+  console.log('atris teach — a bad turn becomes a failing benchmark, then a guard');
+  console.log('');
+  console.log('  atris teach                  list cases (red = not yet fixed, guard = protected)');
+  console.log('  atris teach add …            record a misbehavior as a red case');
+  console.log('  atris teach run [<id>]       run a case; a red case is SUPPOSED to fail');
+  console.log('  atris teach guards           rerun every guard; nonzero exit = regression');
+  console.log('  atris teach drafts           corrections captured from live turns');
+  console.log('  atris teach fix <id>         brief a fix for a reproduced case (--dispatch to run it)');
+  console.log('  atris teach scaffold …       turn a captured correction into a red case');
+  console.log('  atris teach mine             which recorded tick failures could become cases');
+  console.log('');
+  console.log('  add flags: --id <kebab> --prompt "…" --require "<fragment>" (repeatable)');
+  console.log('             --complaint "…" --file path=@localfile --forbid-changed-files');
+}
+
+/**
+ * Map the operator-facing verbs onto `python -m rl.teach` arguments.
+ * Returns null for help.
+ */
+function buildArgs(subcommand, args) {
+  if (!subcommand || subcommand === 'list') return ['list'];
+  if (subcommand === 'help' || subcommand === '--help' || subcommand === '-h') return null;
+  if (subcommand === 'add') return ['add', ...args];
+  if (subcommand === 'guards') return ['run', '--guards', ...args];
+  if (subcommand === 'mine') return ['mine', ...args];
+  if (subcommand === 'drafts') return ['drafts', ...args];
+  if (subcommand === 'fix') {
+    // `atris teach fix <id>` -> `fix --case <id>`
+    if (args.length && !args[0].startsWith('-')) return ['fix', '--case', args[0], ...args.slice(1)];
+    return ['fix', ...args];
+  }
+  if (subcommand === 'scaffold') return ['scaffold', ...args];
+  if (subcommand === 'run') {
+    // `atris teach run <id>` -> `run --case <id>`; bare `run` runs every case.
+    if (args.length && !args[0].startsWith('-')) return ['run', '--case', args[0], ...args.slice(1)];
+    return ['run', ...args];
+  }
+  // `atris teach <id>` is shorthand for running that one case.
+  if (!subcommand.startsWith('-')) return ['run', '--case', subcommand, ...args];
+  return null;
+}
+
+module.exports = function teach(subcommand, ...args) {
+  const moduleArgs = buildArgs(subcommand, args);
+  if (moduleArgs === null) {
+    usage();
+    return;
+  }
+  const result = spawnSync(requireVenvPython(), ['-m', 'rl.teach', ...moduleArgs], {
+    cwd: path.join(BACKEND_ROOT, 'backend'),
+    stdio: 'inherit',
+  });
+  process.exit(result.status === null ? 1 : result.status);
+};
+

package/commands/team.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const path = require('path');
+
+const { canonicalEngineName } = require('../lib/engine-registry');
 const taskDb = require('../lib/task-db');
 const { buildTeamPresence, DEFAULT_FRESHNESS_WINDOW_MS, renderTeamPresence } = require('../lib/team-presence');
 const { listMissions, listWorktreeRollupMissions } = require('./mission');
@@ -45,11 +48,79 @@ function collectTeamPresence(deps = {}) {
   });
 }
 
+// One team view: member folders under atris/team/ are the who, live missions
+// are the what-they-run-on. The fleet keeps no state file, so an engine
+// "assignment" is read straight from missions still in flight.
+const ROSTER_LIVE_MISSION_STATUSES = new Set(['running', 'planning']);
+
+function collectMembers(root, deps = {}) {
+  if (Array.isArray(deps.members)) return deps.members;
+  const memberModule = deps.memberModule || require('./member');
+  return memberModule.findAllMembers(path.join(root, 'atris', 'team'));
+}
+
+// The MEMBER.md role line, made safe for a human sentence: lowercase, no em
+// dashes, no repeated name prefix ("Linguist - operator language" -> "operator
+// language" when the member is already named on the line).
+function plainRole(member) {
+  // findAllMembers stamps '(no role)' on members without a role line; treat
+  // that placeholder as empty so the description can fill in.
+  const role = String(member?.role || '').trim();
+  const raw = (role && role !== '(no role)' ? role : String(member?.description || '')).trim();
+  const cleaned = raw
+    .replace(/[\u2013\u2014]/g, '-')
+    .replace(/\s+/g, ' ')
+    .toLowerCase()
+    .replace(/[.\s]+$/, '');
+  const name = String(member?.name || '').trim().toLowerCase();
+  const deduped = name && cleaned.startsWith(name)
+    ? cleaned.slice(name.length).replace(/^[\s:,-]+/, '')
+    : cleaned;
+  if (!deduped) return 'no role written yet';
+  // Keep the sentence readable: descriptions can run long, roles never should.
+  if (deduped.length <= 100) return deduped;
+  const cut = deduped.slice(0, 100);
+  return `${cut.slice(0, cut.lastIndexOf(' '))}`.replace(/[,;:]+$/, '');
+}
+
+function missionEngine(mission) {
+  return canonicalEngineName(mission?.runner) || canonicalEngineName(mission?.engine);
+}
+
+function collectTeamRoster(deps = {}) {
+  const root = deps.root || repoRoot(deps.cwd || process.cwd());
+  const engineByOwner = new Map();
+  for (const mission of collectMissions(root, deps)) {
+    if (!ROSTER_LIVE_MISSION_STATUSES.has(String(mission?.status || '').toLowerCase())) continue;
+    const owner = String(mission?.owner || mission?.member || '').trim().toLowerCase();
+    const engine = missionEngine(mission);
+    // Missions arrive newest-first; the first live one per owner wins.
+    if (owner && engine && !engineByOwner.has(owner)) engineByOwner.set(owner, engine);
+  }
+  return collectMembers(root, deps)
+    .map((member) => {
+      const name = String(member?.name || '').trim().toLowerCase();
+      return { name, role: plainRole(member), engine: engineByOwner.get(name) || '' };
+    })
+    .filter((entry) => entry.name)
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function renderTeamRoster(roster) {
+  if (!roster.length) {
+    return 'no team members yet. create one with: atris member create <name> --role="..."';
+  }
+  return roster
+    .map((entry) => `${entry.name} - ${entry.role}${entry.engine ? `, on ${entry.engine}` : ''}.`)
+    .join('\n');
+}
+
 function helpText() {
   return [
+    'atris team - one team view: every member, their role, and any engine running their work',
     'atris team presence - show who is awake and what they are doing',
     '',
-    'usage: atris team presence [--json]',
+    'usage: atris team [roster|presence] [--json]',
   ].join('\n');
 }
 
@@ -58,8 +129,17 @@ function teamCommand(args = [], deps = {}) {
     (deps.write || process.stdout.write.bind(process.stdout))(`${helpText()}\n`);
     return 0;
   }
+  const rosterArgs = args.filter((arg) => arg !== 'roster');
+  if (args[0] !== 'presence' && rosterArgs.every((arg) => arg === '--json')) {
+    const roster = deps.roster || collectTeamRoster(deps);
+    const output = rosterArgs.includes('--json')
+      ? JSON.stringify(roster, null, 2)
+      : renderTeamRoster(roster);
+    (deps.write || process.stdout.write.bind(process.stdout))(`${output}\n`);
+    return 0;
+  }
   if (args[0] !== 'presence' || args.some((arg, index) => index > 0 && arg !== '--json')) {
-    (deps.error || process.stderr.write.bind(process.stderr))('usage: atris team presence [--json]\n');
+    (deps.error || process.stderr.write.bind(process.stderr))('usage: atris team [roster|presence] [--json]\n');
     return 2;
   }
   const presence = deps.presence || collectTeamPresence(deps);
@@ -70,4 +150,4 @@ function teamCommand(args = [], deps = {}) {
   return 0;
 }
 
-module.exports = { collectMissions, collectTasks, collectTeamPresence, teamCommand };
+module.exports = { collectMissions, collectTasks, collectTeamPresence, collectTeamRoster, renderTeamRoster, teamCommand };

package/commands/unknowns.js

@@ -613,15 +613,5 @@ async function unknownsCommand(args = []) {
 module.exports = {
   unknownsCommand,
   showHelp,
-  ensureUnknownsSchema,
-  gatherTerritoryContext,
-  buildUnknownsPrompt,
-  analyzeWithModel,
-  normalizeUnknowns,
-  normalizeQuestions,
   fallbackPayload,
-  insertUnknowns,
-  listUnknownRows,
-  renderUnknownsMarkdown,
-  resolveUnknown,
 };

package/commands/update.js

@@ -40,5 +40,4 @@ function updateSelf(options = {}) {
 
 module.exports = {
   updateSelf,
-  DEFAULT_PACKAGE_ROOT,
 };

package/commands/vercel.js

@@ -12,7 +12,8 @@ const vercelCommand = createOfficialCliCommand({
       usage: 'deploy',
       match: ['deploy'],
       forward: ['deploy'],
-      description: 'deploy the current project',
+      description: 'deploy the current project (grouped output)',
+      summarize: true,
     },
     {
       usage: 'ls',
@@ -24,7 +25,8 @@ const vercelCommand = createOfficialCliCommand({
       usage: 'logs',
       match: ['logs'],
       forward: ['logs'],
-      description: 'stream or inspect deployment logs',
+      description: 'stream or inspect deployment logs (grouped output)',
+      summarize: true,
     },
     {
       usage: 'inspect',

package/commands/visualize.js

@@ -389,9 +389,4 @@ async function visualizeAtris(args = process.argv.slice(3)) {
 
 module.exports = {
   visualizeAtris,
-  parseVisualizeArgs,
-  buildImagePrompt,
-  classifyArtifact,
-  resolveOutputPath,
-  generateVisual,
 };

package/commands/voice.js

@@ -0,0 +1,195 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const deterministicVoice = require('../scripts/det/voice');
+
+const JUDGE_TIMEOUT_MS = 30_000;
+
+function extractVoiceSection(repoRoot = process.cwd()) {
+  const candidates = [
+    path.join(repoRoot, 'atris.md'),
+    path.join(repoRoot, 'atris', 'atris.md'),
+  ];
+
+  for (const file of candidates) {
+    if (!fs.existsSync(file)) continue;
+    const lines = fs.readFileSync(file, 'utf8').split(/\r?\n/);
+    const start = lines.findIndex((line) => /^## voice\s*$/i.test(line));
+    if (start === -1) continue;
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i += 1) {
+      if (/^##\s+/.test(lines[i])) {
+        end = i;
+        break;
+      }
+    }
+    return lines.slice(start, end).join('\n').trim();
+  }
+
+  throw new Error('the voice section was not found');
+}
+
+function findExecutable(name, env = process.env) {
+  const pathValue = env.PATH || '';
+  for (const dir of pathValue.split(path.delimiter)) {
+    if (!dir) continue;
+    const candidate = path.join(dir, name);
+    try {
+      fs.accessSync(candidate, fs.constants.X_OK);
+      return candidate;
+    } catch {
+      // Try the next directory.
+    }
+  }
+  return null;
+}
+
+function judgePrompt(rubric) {
+  return [
+    'Judge only the SHAPE and PLAINNESS of the reply provided on stdin against the rubric below.',
+    'Do not judge factual correctness or technical quality.',
+    'When unsure, PASS. False alarms are worse than misses.',
+    'Return only strict JSON with exactly this shape: {"pass": boolean, "reasons": [strings]}.',
+    '',
+    rubric,
+  ].join('\n');
+}
+
+function parseVerdict(output) {
+  const verdict = JSON.parse(String(output || '').trim());
+  if (!verdict || Array.isArray(verdict) || typeof verdict !== 'object') {
+    throw new Error('the verdict is not an object');
+  }
+  const keys = Object.keys(verdict).sort();
+  if (keys.length !== 2 || keys[0] !== 'pass' || keys[1] !== 'reasons') {
+    throw new Error('the verdict has the wrong fields');
+  }
+  if (typeof verdict.pass !== 'boolean'
+      || !Array.isArray(verdict.reasons)
+      || !verdict.reasons.every((reason) => typeof reason === 'string')) {
+    throw new Error('the verdict has the wrong shape');
+  }
+  return verdict;
+}
+
+function unavailable(stderr, reason) {
+  const cleanReason = String(reason || 'unknown error').replace(/\s+/g, ' ').trim();
+  stderr.write(`voice judge unavailable: ${cleanReason}\n`);
+  return 0;
+}
+
+function runScan(reply, args, stdout) {
+  const mode = args.includes('--json') ? 'json' : 'scan';
+  const result = deterministicVoice.run(mode, reply);
+  if (result.error) return { code: 2, error: result.error };
+  stdout.write(`${result.text}\n`);
+  const passed = result.text.startsWith('PASS') || result.text.startsWith('{"pass":true');
+  return { code: passed ? 0 : 1 };
+}
+
+function runJudge(reply, options = {}) {
+  const repoRoot = options.repoRoot || process.cwd();
+  const env = options.env || process.env;
+  const stdout = options.stdout || process.stdout;
+  const stderr = options.stderr || process.stderr;
+
+  let rubric;
+  try {
+    rubric = extractVoiceSection(repoRoot);
+  } catch (error) {
+    return unavailable(stderr, error.message);
+  }
+
+  const customCommand = String(env.ATRIS_VOICE_JUDGE_CMD || '').trim();
+  const claudePath = customCommand ? null : findExecutable('claude', env);
+  if (!customCommand && !claudePath) {
+    return unavailable(stderr, 'no judge command was found');
+  }
+
+  let tempDir;
+  try {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-voice-'));
+    const rubricPath = path.join(tempDir, 'rubric.md');
+    fs.writeFileSync(rubricPath, rubric, 'utf8');
+    const childEnv = { ...env, ATRIS_VOICE_RUBRIC: rubricPath };
+    const result = customCommand
+      ? spawnSync('/bin/sh', ['-c', customCommand], {
+        input: reply,
+        encoding: 'utf8',
+        env: childEnv,
+        timeout: JUDGE_TIMEOUT_MS,
+        maxBuffer: 1024 * 1024,
+      })
+      : spawnSync(claudePath, ['-p', '--model', 'haiku', judgePrompt(rubric)], {
+        input: reply,
+        encoding: 'utf8',
+        env: childEnv,
+        timeout: JUDGE_TIMEOUT_MS,
+        maxBuffer: 1024 * 1024,
+      });
+
+    if (result.error) return unavailable(stderr, result.error.code === 'ETIMEDOUT' ? 'the judge timed out' : 'the judge command failed');
+    if (result.status !== 0) return unavailable(stderr, 'the judge command failed');
+
+    let verdict;
+    try {
+      verdict = parseVerdict(result.stdout);
+    } catch {
+      return unavailable(stderr, 'the judge returned an unreadable verdict');
+    }
+
+    stdout.write(`${JSON.stringify(verdict)}\n`);
+    return verdict.pass ? 0 : 1;
+  } catch {
+    return unavailable(stderr, 'the judge command failed');
+  } finally {
+    if (tempDir) {
+      try {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      } catch {
+        // Cleanup cannot block the reply.
+      }
+    }
+  }
+}
+
+function showVoiceHelp(stdout = process.stdout) {
+  stdout.write([
+    'usage: atris voice scan [--json]',
+    '       atris voice judge',
+    '',
+    'scan checks binary voice tells. judge checks reply shape and plainness.',
+    '',
+  ].join('\n'));
+}
+
+function voiceCommand(args, options = {}) {
+  const subcommand = args[0];
+  const stdout = options.stdout || process.stdout;
+  const stderr = options.stderr || process.stderr;
+  if (!subcommand || subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+    showVoiceHelp(stdout);
+    return 0;
+  }
+  if (!['scan', 'judge'].includes(subcommand)) {
+    stderr.write('usage: atris voice scan [--json] | atris voice judge\n');
+    return 2;
+  }
+
+  const reply = options.input === undefined ? fs.readFileSync(0, 'utf8') : options.input;
+  if (subcommand === 'scan') {
+    const result = runScan(reply, args.slice(1), stdout);
+    if (result.error) stderr.write(`${result.error}\n`);
+    return result.code;
+  }
+  return runJudge(reply, { ...options, stdout, stderr });
+}
+
+module.exports = {
+  extractVoiceSection,
+  voiceCommand,
+};

package/commands/watch.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const { hasFlag, readFlag } = require('../lib/arg-parser');
 const { startMission, listMissions } = require('./mission');
 
 const CLI_PATH = path.join(__dirname, '..', 'bin', 'atris.js');
@@ -22,28 +23,6 @@ function slugify(value) {
     .slice(0, 48) || 'watch';
 }
 
-function hasFlag(args, name) {
-  return args.includes(name);
-}
-
-function unquote(value) {
-  const text = String(value);
-  if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
-    return text.slice(1, -1);
-  }
-  return text;
-}
-
-function readFlag(args, name, fallback = '') {
-  const prefix = `${name}=`;
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = String(args[i]);
-    if (arg === name && args[i + 1] && !String(args[i + 1]).startsWith('--')) return unquote(args[i + 1]);
-    if (arg.startsWith(prefix)) return unquote(arg.slice(prefix.length));
-  }
-  return fallback;
-}
-
 function parseSentenceArgs(args) {
   const sentenceParts = [];
   let index = 0;
@@ -293,11 +272,5 @@ function watchAtris() {
 
 module.exports = {
   watchAtris,
-  watchCommand,
-  showWatchHelp,
   slugify,
-  buildWatchObjective,
-  activeWatchMissions,
-  resolveWatchMission,
-  watchStatePath,
 };