atris 3.30.8 → 3.31.0

package/commands/play.js

@@ -417,7 +417,7 @@ function modeState(args = []) {
       prompt: latestMessage(events),
     } : null,
     proof_recipe: proofRecipe(),
-    xp_rule: 'AgentXP lands only after a useful artifact has verifier proof and review accepts it.',
+    xp_rule: 'AgentXP is awarded only after a useful artifact has verifier proof and accepted review.',
     global_sync_rule: AGENTXP_GLOBAL_SYNC_RULE,
     leaderboard_url: AGENTXP_LEADERBOARD_URL,
     next_commands: commandList,

package/commands/pulse.js

@@ -18,6 +18,7 @@ const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const pulse = require('../lib/pulse');
+const { DEFAULT_CLAUDE_RUNNER_MODEL } = require('../lib/runner-command');
 
 function hasFlag(args, name) {
   return args.includes(name);
@@ -51,6 +52,7 @@ Options:
   --verify "<cmd>"       Verifier for changed-work ticks (default: npm test)
   --cadence "<cron>"     Cron cadence for install
   --days <n>             Auto-expire installed heartbeat after n days
+  --hours <n>            Auto-expire installed heartbeat after n hours
   --model <id>           Runner model alias/id for installed heartbeat
   --runner-profile <n>   Runner profile for installed heartbeat (e.g. atris-fast)
   --runner-bin <path>    Runner binary for installed heartbeat
@@ -197,6 +199,26 @@ function tickCommand(args, root = process.cwd()) {
   }
 
   const tickIndex = pulse.nextTickIndex(root);
+  const signalExitCode = { SIGINT: 130, SIGTERM: 143 };
+  let interrupted = false;
+  const finishInterrupted = (signal) => {
+    if (interrupted) return;
+    interrupted = true;
+    try {
+      pulse.appendPulseReceipt(root, pulse.buildInterruptedPulseReceipt({
+        tickIndex,
+        signal,
+        startedAt,
+        prevTickStale: priorStale.stale,
+      }));
+    } catch {}
+    try {
+      pulse.releaseLock(root);
+    } catch {}
+    process.exit(signalExitCode[signal] || 1);
+  };
+  process.once('SIGINT', finishInterrupted);
+  process.once('SIGTERM', finishInterrupted);
 
   // 'started' receipt - if the tick dies after this, the orphan surfaces as a ghost.
   pulse.appendPulseReceipt(root, pulse.buildPulseReceipt({
@@ -260,7 +282,7 @@ function tickCommand(args, root = process.cwd()) {
         what,
         changedFiles,
         elapsedMs,
-        model: process.env.ATRIS_RUNNER_MODEL || process.env.ATRIS_CLAUDE_MODEL || 'opus',
+        model: process.env.ATRIS_RUNNER_MODEL || process.env.ATRIS_CLAUDE_MODEL || DEFAULT_CLAUDE_RUNNER_MODEL,
       }));
       scorecardWritten = true;
     }
@@ -301,6 +323,8 @@ function tickCommand(args, root = process.cwd()) {
     if (!asJson) process.stdout.write(`pulse tick #${tickIndex} crashed: ${out.error}\n`);
     return emit(out, asJson);
   } finally {
+    process.removeListener('SIGINT', finishInterrupted);
+    process.removeListener('SIGTERM', finishInterrupted);
     pulse.releaseLock(root);
   }
 }
@@ -372,14 +396,45 @@ function resolveEngineBinDirs(extraBins = []) {
 
 function installCommand(args, root = process.cwd()) {
   const asJson = wantsJson(args);
-  const cron = readFlag(args, '--cadence', pulse.DEFAULT_CADENCE_CRON);
-  const days = Math.max(1, Number(readFlag(args, '--days', '7')) || 7);
+  const cadenceInput = readFlag(args, '--cadence', pulse.DEFAULT_CADENCE_CRON);
+  let cron;
+  try {
+    cron = pulse.normalizeCronCadence(cadenceInput);
+  } catch (error) {
+    const out = {
+      ok: false,
+      action: 'pulse_install',
+      reason: 'invalid_cadence',
+      detail: error && error.message ? error.message : String(error),
+      cadence: cadenceInput,
+    };
+    if (!asJson) process.stdout.write(`pulse install failed: ${out.detail}\n`);
+    return emit(out, asJson);
+  }
+  let expiry;
+  try {
+    expiry = pulse.normalizeExpiryDuration({
+      hours: readFlag(args, '--hours', null),
+      days: readFlag(args, '--days', '7'),
+    });
+  } catch (error) {
+    const out = {
+      ok: false,
+      action: 'pulse_install',
+      reason: 'invalid_expiry',
+      detail: error && error.message ? error.message : String(error),
+      hours: readFlag(args, '--hours', null),
+      days: readFlag(args, '--days', '7'),
+    };
+    if (!asJson) process.stdout.write(`pulse install failed: ${out.detail}\n`);
+    return emit(out, asJson);
+  }
   const verifyCmd = readFlag(args, '--verify', 'npm test');
-  const model = readFlag(args, '--model', process.env.ATRIS_RUNNER_MODEL || process.env.ATRIS_CLAUDE_MODEL || 'opus');
+  const model = readFlag(args, '--model', process.env.ATRIS_RUNNER_MODEL || process.env.ATRIS_CLAUDE_MODEL || DEFAULT_CLAUDE_RUNNER_MODEL);
   const runnerProfile = readFlag(args, '--runner-profile', process.env.ATRIS_RUNNER_PROFILE || '');
   const runnerBin = readFlag(args, '--runner-bin', process.env.ATRIS_RUNNER_BIN || process.env.ATRIS_CLAUDE_BIN || '');
   const runnerCommandTemplate = readFlag(args, '--runner-template', process.env.ATRIS_RUNNER_COMMAND_TEMPLATE || process.env.ATRIS_CLAUDE_COMMAND_TEMPLATE || '');
-  const deadlineEpoch = Math.floor(Date.now() / 1000) + days * 86400;
+  const deadlineEpoch = Math.floor(Date.now() / 1000) + expiry.seconds;
 
   fs.mkdirSync(STATE_HOME, { recursive: true });
   const scriptPath = path.join(STATE_HOME, 'tick.sh');
@@ -414,7 +469,10 @@ function installCommand(args, root = process.cwd()) {
     script_path: scriptPath,
     crontab_line: line,
     cadence: cron,
-    expires_in_days: days,
+    cadence_input: cadenceInput,
+    expires_in_days: expiry.days,
+    expires_in_hours: expiry.hours,
+    expires_in_seconds: expiry.seconds,
     deadline_epoch: deadlineEpoch,
     runner_profile: runnerProfile || null,
     runner_bin: runnerBin || null,
@@ -425,7 +483,7 @@ function installCommand(args, root = process.cwd()) {
       process.stdout.write([
         `pulse installed. heartbeat fires '${cron}' against ${root}.`,
         `script: ${scriptPath}`,
-        `auto-expires in ${days} days. stop early: atris pulse uninstall`,
+        `auto-expires in ${expiry.hours ? `${expiry.hours} hours` : `${expiry.days} days`}. stop early: atris pulse uninstall`,
       ].join('\n') + '\n');
     } else {
       process.stdout.write(`pulse install failed to write crontab: ${apply.stderr || apply.status}\nscript written to ${scriptPath}; add this line to your crontab manually:\n${line}\n`);

package/commands/run.js

@@ -15,7 +15,7 @@ const { parseTodo } = require('../lib/todo');
 const {
   buildRunnerCommand,
   buildRunnerAvailabilityCommand,
-  resolveClaudeRunnerBin,
+  runnerAvailabilityFailureMessage,
 } = require('../lib/runner-command');
 const { cleanAtris } = require('./clean');
 
@@ -384,8 +384,8 @@ async function runAtris(options = {}) {
   // Check configured runner CLI is available.
   try {
     execSync(buildRunnerAvailabilityCommand(), { stdio: 'pipe' });
-  } catch {
-    console.error(`${resolveClaudeRunnerBin()} CLI not found. Set ATRIS_RUNNER_BIN (or legacy ATRIS_CLAUDE_BIN), or install the configured runner first.`);
+  } catch (err) {
+    console.error(runnerAvailabilityFailureMessage(err));
     process.exit(1);
   }
 

package/commands/strings.js

@@ -0,0 +1,301 @@
+// atris strings — a content design system built from live codebase content (no LLM).
+//
+// The missing pillar next to `atris slop`: slop catches HOW copy is written (tells,
+// hype, em-dashes); strings governs WHAT words you ship. It scans the repo for
+// user-facing strings, builds a terminology registry in .atris/strings.json, flags
+// the same string written three different ways (the "unnecessary variant" tell), and
+// enforces preferred terms at the commit/PR gate so you rename "live" -> "active"
+// once and it holds everywhere.
+//
+// Zero external deps (Node built-ins only) — repo contract. Deterministic: a finding
+// is a fact (file:line + term), not a taste opinion, so it drops into CI + the gate.
+//
+// Usage:
+//   atris strings scan [path]        # extract UI strings -> .atris/strings.json
+//   atris strings variants           # the same string written N different ways
+//   atris strings term --ban live --prefer active --why "..."   # codify a rule
+//   atris strings check --staged     # gate: banned terms in changed lines (exit 1)
+//   atris strings list               # dump the registry
+//
+// Exit code: 0 = clean, 1 = violation/variants found, 2 = bad usage.
+
+const fs = require('fs');
+const path = require('path');
+const { gitChangedLines } = require('./slop'); // reuse the diff parser — DRY
+
+const CODE_EXTS = new Set(['.tsx', '.jsx', '.ts', '.js', '.mjs', '.vue', '.svelte', '.astro', '.html']);
+const TEXT_EXTS = new Set([...CODE_EXTS, '.md', '.mdx', '.txt']);
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.astro', 'coverage', '.cache', 'out', 'vendor']);
+
+const REGISTRY_FILE = path.join('.atris', 'strings.json');
+const MAX_LOCATIONS = 12; // cap stored locations per string so the registry stays readable
+
+function walk(target, out, exts) {
+  let stat;
+  try { stat = fs.statSync(target); } catch { return out; }
+  if (stat.isFile()) {
+    if (exts.has(path.extname(target))) out.push(target);
+    return out;
+  }
+  if (stat.isDirectory()) {
+    if (SKIP_DIRS.has(path.basename(target))) return out;
+    for (const name of fs.readdirSync(target)) {
+      if (name.startsWith('.') && name !== '.') continue;
+      walk(path.join(target, name), out, exts);
+    }
+  }
+  return out;
+}
+
+// Is this captured literal a user-facing string, or just code/classes/identifiers?
+// High precision on purpose: a noisy registry gets ignored. minWords lets JSX text
+// nodes (>Settings<) keep single-word labels while quoted literals require a phrase.
+function isUserFacing(s, minWords) {
+  if (s.length < 2 || s.length > 200) return false;
+  if (!/[A-Za-z]/.test(s)) return false;
+  if (/[<>{}=]|\$\{|=>|&&|\|\||::|\/\/|\/\*|\*\//.test(s)) return false; // code
+  if (/^https?:/i.test(s) || /\bwww\.[a-z]/i.test(s)) return false;       // urls
+  if (/^[./~#@\\]/.test(s)) return false;                                  // path/anchor/hex/handle
+  if (/^#[0-9a-fA-F]{3,8}$/.test(s)) return false;                         // hex color
+  if (/^[A-Z0-9_]{2,}$/.test(s)) return false;                             // CONSTANT_CASE
+  const words = s.split(/\s+/);
+  // className / token-list reject: multi-token where most tokens look like classes
+  if (words.length > 1
+    && words.every((w) => /^[\w:[\]\-./%@]+$/.test(w))
+    && words.filter((w) => w.includes('-')).length >= Math.ceil(words.length / 2)) return false;
+  if (words.length === 1) {
+    if (minWords > 1) return false;                 // quoted single tokens are usually identifiers
+    return /^[A-Z][a-zA-Z]{2,}$/.test(s);           // a real Label word, e.g. "Settings"
+  }
+  const prose = (s.match(/[A-Za-z ]/g) || []).length;
+  return prose / s.length >= 0.55;                  // reads like a sentence, not a payload
+}
+
+// Extract candidate user-facing strings from one file's text.
+function extractStrings(text) {
+  const out = [];
+  const lines = text.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const push = (raw, minWords) => { const s = raw.trim(); if (isUserFacing(s, minWords)) out.push({ text: s, line: i + 1 }); };
+    let m;
+    const jsx = />([^<>{}\n]{2,})</g; while ((m = jsx.exec(line))) push(m[1], 1);          // JSX/HTML text node
+    const dq = /"([^"\\\n]{2,}?)"/g; while ((m = dq.exec(line))) push(m[1], 2);            // "double"
+    const sq = /'([^'\\\n]{2,}?)'/g; while ((m = sq.exec(line))) push(m[1], 2);            // 'single'
+    const tq = /`([^`$\\\n]{2,}?)`/g; while ((m = tq.exec(line))) push(m[1], 2);           // `template` (no ${})
+  }
+  return out;
+}
+
+// Canonical form for variant detection: same meaning, different surface (case / punct / spacing).
+function normalize(s) {
+  return s.toLowerCase()
+    .replace(/…/g, '').replace(/\.\.\.$/, '')
+    .replace(/\s+/g, ' ')
+    .replace(/[.!?,;:]+$/, '')
+    .trim();
+}
+
+function loadRegistry(root = process.cwd()) {
+  try { return JSON.parse(fs.readFileSync(path.join(root, REGISTRY_FILE), 'utf8')); }
+  catch { return { version: 1, scannedAt: null, root: null, strings: [], terms: [] }; }
+}
+
+function saveRegistry(reg, root = process.cwd()) {
+  const file = path.join(root, REGISTRY_FILE);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(reg, null, 2) + '\n');
+  return file;
+}
+
+// Group strings by normalized form; a cluster with >1 distinct surface form is an inconsistency.
+function variantClusters(strings) {
+  const byNorm = new Map();
+  for (const s of strings) {
+    if (!byNorm.has(s.norm)) byNorm.set(s.norm, []);
+    byNorm.get(s.norm).push(s);
+  }
+  const clusters = [];
+  for (const [norm, group] of byNorm) {
+    const surfaces = [...new Set(group.map((g) => g.text))];
+    if (surfaces.length > 1) {
+      clusters.push({ norm, surfaces, count: group.reduce((n, g) => n + g.count, 0) });
+    }
+  }
+  return clusters.sort((a, b) => b.count - a.count);
+}
+
+function scan(argv) {
+  const json = argv.includes('--json');
+  const target = argv.find((a) => !a.startsWith('-')) || '.';
+  const files = walk(path.resolve(target), [], CODE_EXTS);
+
+  const byText = new Map(); // text -> { text, norm, count, locations[] }
+  for (const file of files) {
+    let text; try { text = fs.readFileSync(file, 'utf8'); } catch { continue; }
+    const rel = path.relative(process.cwd(), file);
+    for (const hit of extractStrings(text)) {
+      let entry = byText.get(hit.text);
+      if (!entry) { entry = { text: hit.text, norm: normalize(hit.text), count: 0, locations: [] }; byText.set(hit.text, entry); }
+      entry.count++;
+      if (entry.locations.length < MAX_LOCATIONS) entry.locations.push(`${rel}:${hit.line}`);
+    }
+  }
+
+  const reg = loadRegistry();
+  reg.scannedAt = new Date().toISOString();
+  reg.root = path.relative(process.cwd(), path.resolve(target)) || '.';
+  reg.strings = [...byText.values()].sort((a, b) => b.count - a.count);
+  const file = saveRegistry(reg);
+  const clusters = variantClusters(reg.strings);
+
+  if (json) {
+    console.log(JSON.stringify({
+      ok: true, scanned: files.length, strings: reg.strings.length,
+      occurrences: reg.strings.reduce((n, s) => n + s.count, 0),
+      variantClusters: clusters.length, registry: path.relative(process.cwd(), file),
+    }, null, 2));
+    return 0;
+  }
+  console.log(`\n  scanned ${files.length} file${files.length === 1 ? '' : 's'} -> ${reg.strings.length} unique string${reg.strings.length === 1 ? '' : 's'}`);
+  console.log(`  registry: ${path.relative(process.cwd(), file)}`);
+  if (clusters.length) console.log(`\n  ⚠ ${clusters.length} variant cluster${clusters.length === 1 ? '' : 's'} (same string, different casing/punctuation) — run: atris strings variants`);
+  else console.log(`\n  ✓ no inconsistent variants`);
+  console.log('');
+  return 0;
+}
+
+function variants(argv) {
+  const json = argv.includes('--json');
+  const reg = loadRegistry();
+  if (!reg.strings.length) { console.error('  no registry yet — run: atris strings scan'); return 2; }
+  const clusters = variantClusters(reg.strings);
+  if (json) { console.log(JSON.stringify({ ok: clusters.length === 0, clusters }, null, 2)); return clusters.length ? 1 : 0; }
+  if (!clusters.length) { console.log(`\n  ✓ clean — every string is written one way\n`); return 0; }
+  console.log(`\n  ${clusters.length} variant cluster${clusters.length === 1 ? '' : 's'} — same string, inconsistent surface form:\n`);
+  for (const c of clusters) {
+    console.log(`  ⚠ ${c.surfaces.map((s) => JSON.stringify(s)).join('  vs  ')}   (${c.count}×)`);
+  }
+  console.log(`\n  pick one per cluster, then: atris strings term --ban "<wrong>" --prefer "<right>"\n`);
+  return 1;
+}
+
+function term(argv) {
+  const get = (flag) => { const i = argv.indexOf(flag); return i >= 0 ? argv[i + 1] : null; };
+  const ban = get('--ban');
+  const prefer = get('--prefer');
+  const why = get('--why') || '';
+  if (argv.includes('--list') || (!ban && !argv.includes('--remove'))) {
+    const reg = loadRegistry();
+    if (!reg.terms.length) { console.log('\n  no terms yet — add one: atris strings term --ban "live" --prefer "active"\n'); return 0; }
+    console.log('\n  preferred terms (enforced by: atris strings check):\n');
+    for (const t of reg.terms) console.log(`  ✗ "${t.ban}" → "${t.prefer}"${t.why ? `   (${t.why})` : ''}`);
+    console.log('');
+    return 0;
+  }
+  const reg = loadRegistry();
+  if (argv.includes('--remove')) {
+    const before = reg.terms.length;
+    reg.terms = reg.terms.filter((t) => t.ban.toLowerCase() !== String(get('--remove') || ban || '').toLowerCase());
+    saveRegistry(reg);
+    console.log(`  ${before === reg.terms.length ? 'no match' : 'removed'}: "${get('--remove') || ban}"`);
+    return 0;
+  }
+  if (!ban || !prefer) { console.error('  usage: atris strings term --ban <word> --prefer <word> [--why "..."]'); return 2; }
+  reg.terms = reg.terms.filter((t) => t.ban.toLowerCase() !== ban.toLowerCase());
+  reg.terms.push({ ban, prefer, why });
+  const file = saveRegistry(reg);
+  console.log(`  ✓ "${ban}" → "${prefer}" added to ${path.relative(process.cwd(), file)}`);
+  console.log(`    enforce it: atris strings check --staged`);
+  return 0;
+}
+
+function check(argv) {
+  const json = argv.includes('--json');
+  const quiet = argv.includes('--quiet');
+  const staged = argv.includes('--staged');
+  const diffMode = staged || argv.includes('--diff');
+  const reg = loadRegistry();
+  if (!reg.terms.length) {
+    if (json) { console.log(JSON.stringify({ ok: true, terms: 0, findings: [] }, null, 2)); }
+    else if (!quiet) console.log('\n  no terms to enforce — add one: atris strings term --ban "live" --prefer "active"\n');
+    return 0;
+  }
+
+  let files, changed = null;
+  if (diffMode) {
+    changed = gitChangedLines(staged);
+    files = [...changed.keys()].filter((f) => TEXT_EXTS.has(path.extname(f)) && fs.existsSync(f));
+  } else {
+    const target = argv.find((a) => !a.startsWith('-')) || '.';
+    files = walk(path.resolve(target), [], TEXT_EXTS);
+  }
+  const regAbs = path.resolve(process.cwd(), REGISTRY_FILE);
+
+  const matchers = reg.terms.map((t) => ({ ...t, re: new RegExp(`\\b${t.ban.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i') }));
+  const findings = [];
+  for (const file of files) {
+    if (path.resolve(file) === regAbs) continue; // never flag the registry itself
+    let text; try { text = fs.readFileSync(file, 'utf8'); } catch { continue; }
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      if (diffMode && changed && !(changed.get(path.resolve(file)) && changed.get(path.resolve(file)).has(i + 1))) continue;
+      for (const t of matchers) {
+        if (t.re.test(lines[i])) findings.push({ file: path.relative(process.cwd(), file), line: i + 1, ban: t.ban, prefer: t.prefer, why: t.why });
+      }
+    }
+  }
+
+  if (json) { console.log(JSON.stringify({ ok: findings.length === 0, scanned: files.length, terms: reg.terms.length, findings }, null, 2)); return findings.length ? 1 : 0; }
+  if (!findings.length) { if (!quiet) console.log(`\n  ✓ clean — no banned terms in ${files.length} file${files.length === 1 ? '' : 's'}\n`); else console.log('  ✓ clean · exit 0'); return 0; }
+  if (!quiet) {
+    console.log('');
+    const w = Math.max(...findings.map((f) => `${f.file}:${f.line}`.length));
+    for (const f of findings) console.log(`  ✗ ${`${f.file}:${f.line}`.padEnd(w)}  "${f.ban}" → "${f.prefer}"${f.why ? `   ${f.why}` : ''}`);
+  }
+  console.log(`\n  ${findings.length} banned-term use${findings.length === 1 ? '' : 's'} · exit 1\n`);
+  return 1;
+}
+
+function list(argv) {
+  const json = argv.includes('--json');
+  const reg = loadRegistry();
+  if (json) { console.log(JSON.stringify(reg, null, 2)); return 0; }
+  if (!reg.strings.length) { console.error('  no registry yet — run: atris strings scan'); return 2; }
+  const top = Number((argv[argv.indexOf('--top') + 1]) || 30);
+  console.log(`\n  ${reg.strings.length} strings (scanned ${reg.scannedAt || '?'}), top ${Math.min(top, reg.strings.length)} by use:\n`);
+  for (const s of reg.strings.slice(0, top)) console.log(`  ${String(s.count).padStart(3)}×  ${JSON.stringify(s.text)}`);
+  console.log('');
+  return 0;
+}
+
+function stringsCommand(argv) {
+  const sub = argv[0];
+  const rest = argv.slice(1);
+  if (sub === 'scan') return scan(rest);
+  if (sub === 'variants' || sub === 'dupes') return variants(rest);
+  if (sub === 'term' || sub === 'terms') return term(rest);
+  if (sub === 'check' || sub === 'gate') return check(rest);
+  if (sub === 'list' || sub === 'ls') return list(rest);
+  console.log(`
+  atris strings — a content design system from your live codebase (no LLM)
+
+    atris strings scan [path]      extract user-facing strings -> .atris/strings.json
+    atris strings variants         the same string written N different ways (pick one)
+    atris strings term --ban <a> --prefer <b> [--why "..."]   codify a preferred term
+    atris strings term --list      show the preferred terms
+    atris strings check [--staged] gate: flag banned terms in changed lines (exit 1)
+    atris strings list [--top N]   the registry, most-used first
+    add --json to scan/variants/check/list for machine output
+
+  Pairs with 'atris slop' (how copy reads) — strings governs what words you ship.
+  The registry lives in .atris/strings.json. Wire 'check --staged' into the pre-commit gate.
+`);
+  return 0;
+}
+
+module.exports = {
+  stringsCommand, scan, variants, term, check, list,
+  isUserFacing, extractStrings, normalize, variantClusters,
+  loadRegistry, saveRegistry, walk, CODE_EXTS, TEXT_EXTS,
+};