atris 3.40.0 → 3.42.0

package/bin/atris.js

@@ -1709,6 +1709,18 @@ function showWelcomeVisualization() {
     console.log(row('tidy', tidyBits.join(', ')));
   }
 
+  // The guarantee gauge, only when it has bad news: landings a human had to
+  // fix this week. Zero is the healthy state and stays silent; no git history
+  // (not a repo, git missing) also stays silent.
+  try {
+    const rev = require('../commands/improve').collectRevisionSignals(cwd, { days: 7 });
+    if (rev.revised > 0) {
+      console.log(`  ${rev.revised} landing${rev.revised === 1 ? '' : 's'} this week needed a human fix; run atris improve revisions`);
+    }
+  } catch {
+    // Silent: the gauge never blocks boot.
+  }
+
   let wikiNudge = '';
   try {
     wikiNudge = require('../lib/wiki').wikiMetabolismNudge(cwd);
@@ -2732,7 +2744,7 @@ if (command === 'init') {
   const subcommand = process.argv[3];
   const args = process.argv.slice(4);
   require('../commands/business').businessCommand(subcommand, ...args)
-    .then(() => process.exit(0))
+    .then(() => process.exit(process.exitCode || 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'soul') {
   const args = process.argv.slice(3);

package/commands/activate.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const escapeRegExp = require('../lib/escape-regexp');
 const { getLogPath, ensureLogDirectory, createLogFile } = require('../lib/journal');
 const { detectWorkspaceState, loadContext } = require('../lib/state-detection');
 const { readWikiStatus } = require('../lib/wiki');
@@ -13,10 +14,6 @@ const CLARITY_FIELDS = [
   { key: 'leash', label: 'Leash' },
 ];
 
-function escapeRegExp(value) {
-  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
 function readClarityMarkdownProfile(mdPath) {
   try {
     const content = fs.readFileSync(mdPath, 'utf8');

package/commands/computer.js

@@ -4384,6 +4384,7 @@ async function runComputer(argv = process.argv.slice(3), deps = {}) {
     default:
       console.error(`Unknown subcommand: ${sub}`);
       console.log('Run: atris computer --help');
+      process.exitCode = 1;
   }
 }
 
@@ -4399,4 +4400,23 @@ module.exports = {
   extractAttachedWorkspaceMismatch,
   contextForAttachedWorkspaceMismatch,
   printRecruitingLocalSyncOutcome,
+  // Hermetic parsing/formatting layer, exported for test/computer.test.js.
+  parseComputerOptions,
+  parseComputerCreateArgs,
+  computerCreateArgsHaveName,
+  normalizeComputerType,
+  formatComputerTypeList,
+  parseComputerDeleteArgs,
+  parseComputerCardArgs,
+  renderComputerCard,
+  renderComputerCardMarkdown,
+  formatLeaseAge,
+  formatWorkspaceRef,
+  workspaceMatchesInput,
+  resolveWorkspaceFromList,
+  workspaceMatchesComputerType,
+  looksLikeWorkspaceId,
+  shellQuote,
+  withoutRecruitingWrapperFlags,
+  formatCloudSelection,
 };

package/commands/improve.js

@@ -348,6 +348,13 @@ function plural(n, word) {
   return `${n} ${word}${n === 1 ? '' : 's'}`;
 }
 
+// Spell small counts as words so the vitals read as prose; digits above nine.
+const SMALL_NUMBER_WORDS = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'];
+
+function countWord(n) {
+  return n >= 0 && n < SMALL_NUMBER_WORDS.length ? SMALL_NUMBER_WORDS[n] : String(n);
+}
+
 function formatReward(value) {
   const n = Number(value) || 0;
   if (Number.isInteger(n)) return String(n);
@@ -505,6 +512,26 @@ function collectImproveVitals(options = {}, deps = {}) {
     sentence: plainSentence(usageSentence),
   };
 
+  // The guarantee gauge: agent landings vs human fixes over the last 14 days.
+  // Collection is bounded by --since so a huge repo only walks a fortnight.
+  // No git history (not a repo, git missing) means the line is omitted silently.
+  let guarantee = null;
+  try {
+    const collect = deps.collectRevisionSignals || collectRevisionSignals;
+    const rev = collect(root, { days: 14, now: nowMs });
+    const landingsPhrase = `${countWord(rev.landings)} landing${rev.landings === 1 ? '' : 's'} this fortnight`;
+    const fixPhrase = `${countWord(rev.revised)} needed a human fix`;
+    guarantee = {
+      days: rev.days,
+      landings: rev.landings,
+      revised: rev.revised,
+      rate: rev.rate,
+      sentence: plainSentence(`${landingsPhrase}, ${fixPhrase}.`),
+    };
+  } catch {
+    guarantee = null;
+  }
+
   const sentences = [
     heartbeat.sentence,
     exploit.sentence,
@@ -512,6 +539,7 @@ function collectImproveVitals(options = {}, deps = {}) {
     excrete.sentence,
     ...(topOverdueSentence ? [`the top overdue loop says ${topOverdueSentence}`] : []),
     usage.sentence,
+    ...(guarantee ? [guarantee.sentence] : []),
   ];
   const groups = [
     [heartbeat.sentence, installNudge].filter(Boolean),
@@ -519,6 +547,7 @@ function collectImproveVitals(options = {}, deps = {}) {
     [explore.sentence],
     [excrete.sentence, ...(topOverdueSentence ? [`the top overdue loop says ${topOverdueSentence}`] : [])],
     [usage.sentence],
+    ...(guarantee ? [[guarantee.sentence]] : []),
   ];
 
   return {
@@ -529,6 +558,7 @@ function collectImproveVitals(options = {}, deps = {}) {
     explore,
     excrete,
     usage,
+    guarantee,
     install_nudge: installNudge,
     sentences,
     groups,
@@ -887,6 +917,190 @@ function formatImproveReport(result = {}) {
   return lines.join('\n');
 }
 
+// ---------------------------------------------------------------------------
+// atris improve revisions — the gauge for the north-star metric:
+// operator revisions after landing = 0. an agent landing is a commit carrying
+// the atris co-author trailer (atris-builder[bot]); if a human commit touches
+// any of the same files within 72 hours, that landing failed the guarantee.
+//
+// renames are NOT followed: `git log --follow` is per-file and would cost one
+// subprocess per file per landing, so a post-landing rename reads as "no
+// overlap". that undercounts revisions slightly; accepted on purpose.
+
+const REVISIONS_SCHEMA = 'atris.improve_revisions.v1';
+const REVISION_WINDOW_HOURS = 72;
+const REVISION_WINDOW_MS = REVISION_WINDOW_HOURS * 60 * 60 * 1000;
+const AGENT_TRAILER_MARKER = 'atris-builder[bot]';
+const DEFAULT_REVISIONS_DAYS = 14;
+
+function parseRevisionsArgs(argv = []) {
+  const args = Array.isArray(argv) ? argv : [];
+  const opts = { days: DEFAULT_REVISIONS_DAYS, json: false, help: false };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--help' || a === '-h') { opts.help = true; continue; }
+    if (a === '--json') { opts.json = true; continue; }
+    if (a === '--days') { const v = Number(args[++i]); if (Number.isFinite(v) && v > 0) opts.days = Math.round(v); continue; }
+    if (a.startsWith('--days=')) { const v = Number(a.split('=')[1]); if (Number.isFinite(v) && v > 0) opts.days = Math.round(v); continue; }
+  }
+  return opts;
+}
+
+function gitLines(cwdRoot, gitArgs) {
+  const r = spawnSync('git', gitArgs, { cwd: cwdRoot, encoding: 'utf8' });
+  if (r.status !== 0) {
+    const err = new Error(String(r.stderr || `git ${gitArgs[0]} exited ${r.status}`).trim());
+    err.gitFailed = true;
+    throw err;
+  }
+  return String(r.stdout || '');
+}
+
+/**
+ * Files changed by one commit. Merge commits are attributed by their
+ * first-parent diff (what the merge actually brought onto the mainline);
+ * plain commits use diff-tree. Root commits list their initial files.
+ */
+function commitFiles(cwdRoot, commit) {
+  const parents = commit.parents;
+  const out = parents.length >= 2
+    ? gitLines(cwdRoot, ['diff', '--name-only', `${commit.hash}^1`, commit.hash])
+    : gitLines(cwdRoot, ['diff-tree', '--no-commit-id', '--name-only', '-r', '--root', commit.hash]);
+  return out.split('\n').map((line) => line.trim()).filter(Boolean);
+}
+
+/**
+ * Read the last N days of history and pair every agent landing with the
+ * human commits that touched the same files within the 72-hour window.
+ */
+function collectRevisionSignals(root, options = {}) {
+  const days = Number.isFinite(options.days) && options.days > 0 ? Math.round(options.days) : DEFAULT_REVISIONS_DAYS;
+  const nowMs = options.now != null ? new Date(options.now).getTime() : Date.now();
+  const sinceIso = new Date(nowMs - days * DAY_MS).toISOString();
+
+  let raw = '';
+  try {
+    raw = gitLines(root, ['log', `--since=${sinceIso}`, '--date=iso-strict', '--pretty=format:%H%x1f%P%x1f%aI%x1f%s%x1f%B%x1e']);
+  } catch (e) {
+    // a repo with no commits yet exits non-zero on `git log`; that is the
+    // empty-history case, not an error. anything else (not a repo) rethrows.
+    if (!/does not have any commits|bad default revision|unknown revision/i.test(e.message)) throw e;
+    raw = '';
+  }
+
+  const commits = raw.split('\x1e')
+    .map((chunk) => chunk.replace(/^\n/, ''))
+    .filter((chunk) => chunk.trim())
+    .map((chunk) => {
+      const [hash, parents, at, subject, body] = chunk.split('\x1f');
+      return {
+        hash: String(hash || '').trim(),
+        parents: String(parents || '').trim().split(/\s+/).filter(Boolean),
+        at: String(at || '').trim(),
+        ms: timestampMs(at),
+        subject: String(subject || '').trim(),
+        isAgent: String(body || '').includes(AGENT_TRAILER_MARKER),
+      };
+    })
+    .filter((c) => c.hash && c.ms != null);
+
+  const landings = commits.filter((c) => c.isAgent);
+  // A merge that carries agent work onto the mainline is a landing action,
+  // not a human correction; counting merges as revisions made the first live
+  // reading say 85 percent on a healthy repo. Only single-parent human
+  // commits count as revision signals.
+  const humans = commits.filter((c) => !c.isAgent && c.parents.length < 2);
+
+  const filesCache = new Map();
+  const filesOf = (commit) => {
+    if (!filesCache.has(commit.hash)) filesCache.set(commit.hash, commitFiles(root, commit));
+    return filesCache.get(commit.hash);
+  };
+
+  const revisions = [];
+  for (const landing of landings) {
+    const landedFiles = new Set(filesOf(landing));
+    if (!landedFiles.size) continue;
+    const revisedBy = [];
+    const touched = new Set();
+    for (const human of humans) {
+      if (human.ms <= landing.ms || human.ms > landing.ms + REVISION_WINDOW_MS) continue;
+      const overlap = filesOf(human).filter((f) => landedFiles.has(f));
+      if (!overlap.length) continue;
+      revisedBy.push({ hash: human.hash, subject: human.subject, at: human.at });
+      overlap.forEach((f) => touched.add(f));
+    }
+    if (revisedBy.length) {
+      revisions.push({
+        landing: { hash: landing.hash, subject: landing.subject, at: landing.at },
+        revised_by: revisedBy,
+        files: [...touched].sort(),
+      });
+    }
+  }
+
+  return {
+    schema: REVISIONS_SCHEMA,
+    generated_at: new Date(nowMs).toISOString(),
+    days,
+    window_hours: REVISION_WINDOW_HOURS,
+    landings: landings.length,
+    revised: revisions.length,
+    rate: landings.length ? revisions.length / landings.length : 0,
+    revisions,
+  };
+}
+
+function listFilesPhrase(files = []) {
+  const shown = files.slice(0, 3);
+  const rest = files.length - shown.length;
+  return rest > 0 ? `${shown.join(', ')} and ${plural(rest, 'more file')}` : shown.join(', ');
+}
+
+function formatRevisionsReport(summary = {}) {
+  const days = summary.days || DEFAULT_REVISIONS_DAYS;
+  if (!summary.landings) {
+    return `no agent landings found in the last ${plural(days, 'day')}. nothing to measure yet.`;
+  }
+  const lines = [];
+  lines.push(`agent landings in the last ${plural(days, 'day')}: ${summary.landings}.`);
+  lines.push(`landings a human then revised: ${summary.revised}.`);
+  lines.push(`revision rate: ${Math.round((summary.rate || 0) * 100)} percent. the target is zero.`);
+  for (const item of Array.isArray(summary.revisions) ? summary.revisions : []) {
+    lines.push('');
+    lines.push(`an agent landed "${plainSentence(item.landing.subject)}". a human then changed ${listFilesPhrase(item.files)} within ${REVISION_WINDOW_HOURS} hours.`);
+  }
+  return lines.join('\n');
+}
+
+function showRevisionsHelp() {
+  console.log(`atris improve revisions - measure operator revisions after landing
+
+Usage:
+  atris improve revisions [--days N] [--json]
+
+Reads git history for the last N days (default ${DEFAULT_REVISIONS_DAYS}). A commit with the
+atris co-author trailer is an agent landing; a later human commit touching
+the same files within ${REVISION_WINDOW_HOURS} hours is a revision signal. The north-star
+metric is a revision rate of zero.`);
+}
+
+function runRevisions(argv = []) {
+  const opts = parseRevisionsArgs(argv);
+  if (opts.help) { showRevisionsHelp(); return 0; }
+  let summary;
+  try {
+    summary = collectRevisionSignals(process.cwd(), { days: opts.days });
+  } catch (e) {
+    console.log('this folder has no readable git history, so there are no landings to measure.');
+    if (!e.gitFailed) console.error(`  ${e.message}`);
+    return 1;
+  }
+  if (opts.json) console.log(JSON.stringify(summary));
+  else console.log(formatRevisionsReport(summary));
+  return 0;
+}
+
 function showHelp() {
   console.log(`atris improve - show the self-improvement metabolism vitals
 
@@ -894,6 +1108,7 @@ Usage:
   atris improve
   atris improve --json
   atris improve doctor [--json] [--fix] [--check <kind>]
+  atris improve revisions [--days N] [--json]
   atris improve tick [mode] [options]
   atris improve [mode|history] [options]
 
@@ -903,6 +1118,7 @@ Modes (positional or --mode):
   delegate    queue the tick for a local Claude Code session
   history     show the tick history (reward trend, credits, pass rate)
   doctor      scan loop receipts and optionally file one repair mission
+  revisions   measure operator revisions after agent landings (target: zero)
 
 Options:
   --member <name>  attribute the tick to a member (the loop's owner)
@@ -1074,6 +1290,9 @@ async function run(argv = [], deps = {}) {
     const result = runLoopDoctor(args.slice(1), deps);
     return result.check && !result.check.ok ? 1 : 0;
   }
+  if (args[0] === 'revisions') {
+    return runRevisions(args.slice(1));
+  }
   if (isBareVitalsArgs(args)) {
     const vitals = (deps.collectImproveVitals || collectImproveVitals)({ workspace: process.cwd() }, deps);
     if (args.includes('--json')) console.log(JSON.stringify(vitals));
@@ -1129,6 +1348,8 @@ module.exports = {
   formatTickHistory,
   improveApiPath,
   runLoopDoctor,
+  collectRevisionSignals,
+  formatRevisionsReport,
   runLocalFallback,
   summarizeLocalMissionRun,
   LOCAL_FALLBACK_ARGS,

package/commands/mission.js

@@ -6,6 +6,7 @@ const crypto = require('crypto');
 const readline = require('readline');
 const { spawn, spawnSync } = require('child_process');
 const { hasFlag, readFlag, readIntFlag } = require('../lib/arg-parser');
+const escapeRegExp = require('../lib/escape-regexp');
 const {
   appendBriefRecord,
   stampBriefOutcome,
@@ -1901,7 +1902,7 @@ function missionLastLanding(mission, root = process.cwd()) {
 
 function missionLandingChangedIsGenericTick(mission, changed) {
   const text = String(changed || '').trim();
-  const objective = String(mission?.objective || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const objective = escapeRegExp(mission?.objective || '');
   if (!objective) return false;
   return new RegExp(`^${objective} recorded tick \\d+\\.$`).test(text);
 }

package/commands/site-deploy.js

@@ -221,10 +221,21 @@ function parseResponseData(result) {
   try { return JSON.parse(text); } catch { return null; }
 }
 
+function validationDetail(items) {
+  const messages = items.map((item) => {
+    if (!item || typeof item !== 'object') return String(item);
+    const message = item.msg || item.message || item.type || 'validation failed';
+    const location = Array.isArray(item.loc) ? item.loc.join('.') : '';
+    return location ? `${location}: ${message}` : message;
+  });
+  return messages.join('; ');
+}
+
 function errorDetail(result) {
   const data = parseResponseData(result);
   if (data && typeof data === 'object') {
     const detail = data.detail || data.error || data.message;
+    if (Array.isArray(detail)) return validationDetail(detail);
     if (detail) return typeof detail === 'string' ? detail : JSON.stringify(detail);
   }
   return responseText(result).trim() || 'request failed';
@@ -314,9 +325,13 @@ async function uploadPages(sitesUrl, slug, pages, token, deps = {}) {
   const url = `${sitesUrl}/${slug}/pages`;
   for (let start = 0; start < pages.length; start += BATCH_SIZE) {
     const batch = pages.slice(start, start + BATCH_SIZE);
-    const result = await requestJson('PUT', url, token, {
-      pages: batch.map((page) => pagePayload(page, fileSystem)),
-    }, deps);
+    const result = await requestJson(
+      'PUT',
+      url,
+      token,
+      batch.map((page) => pagePayload(page, fileSystem)),
+      deps,
+    );
     if (result.status < 200 || result.status >= 300) throw requestError('PUT', url, result);
     for (const page of batch) log(`  published ${page.path} (${formatBytes(page.size)})`);
   }
@@ -846,13 +861,13 @@ async function run(argv, deps = {}) {
   log(`\n  deploying ${pages.length} file${pages.length === 1 ? '' : 's'} to ${liveUrl}`);
   try {
     await createSite(sitesUrl, options.name, options.spa, credentials.token, { ...deps, log });
+    await registerSubdomain(options.name, { ...deps, log });
     await uploadPages(sitesUrl, options.name, pages, credentials.token, { ...deps, log });
   } catch (error) {
     errorLog(`  deploy failed: ${error.message}`);
     return 1;
   }
 
-  await registerSubdomain(options.name, { ...deps, log });
   log(`\n  live at ${liveUrl}`);
   return 0;
 }

package/commands/slop.js

@@ -18,6 +18,7 @@
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
+const escapeRegExp = require('../lib/escape-regexp');
 
 const SCAN_EXTS = new Set(['.css', '.scss', '.sass', '.less', '.tsx', '.jsx', '.ts', '.js', '.mjs', '.html', '.vue', '.svelte', '.astro',
   '.md', '.mdx', '.txt']); // prose too: the voice doctrine (em-dash, hype-copy) is enforceable, not just advice
@@ -418,7 +419,7 @@ function findDeadCode(root = process.cwd(), opts = {}) {
   const allRepoJs = [...new Set([...listJsFiles(root)])];
   const mentionedBy = (file, predicate) => {
     const stem = path.basename(file).replace(/\.(js|mjs|cjs)$/, '');
-    const re = new RegExp(`['"\`/]${stem.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:\\.js)?['"\`]`);
+    const re = new RegExp(`['"\`/]${escapeRegExp(stem)}(?:\\.js)?['"\`]`);
     return allRepoJs.some((f) => {
       if (f === file || !predicate(f)) return false;
       try { return re.test(fs.readFileSync(f, 'utf8')); } catch { return false; }

package/commands/stream.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const { hasFlag, readFlag } = require('../lib/arg-parser');
+const escapeRegExp = require('../lib/escape-regexp');
 const { runGit: spawnGit } = require('../lib/git-spawn');
 const { collectBoard } = require('./land');
 const { listWorktrees } = require('./worktree');
@@ -236,7 +237,7 @@ function sanitizeAgent(value) {
 }
 
 function stripLeadingAgent(summary, agent) {
-  const cleanAgent = String(agent || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const cleanAgent = escapeRegExp(agent || '');
   if (!cleanAgent) return summary;
   return String(summary || '').replace(new RegExp(`^${cleanAgent}\\s+`, 'i'), '');
 }

package/commands/strings.js

@@ -22,6 +22,7 @@
 const fs = require('fs');
 const path = require('path');
 const { gitChangedLines } = require('./slop'); // reuse the diff parser — DRY
+const escapeRegExp = require('../lib/escape-regexp');
 
 const CODE_EXTS = new Set(['.tsx', '.jsx', '.ts', '.js', '.mjs', '.vue', '.svelte', '.astro', '.html']);
 const TEXT_EXTS = new Set([...CODE_EXTS, '.md', '.mdx', '.txt']);
@@ -232,7 +233,7 @@ function check(argv) {
   }
   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 matchers = reg.terms.map((t) => ({ ...t, re: new RegExp(`\\b${escapeRegExp(t.ban)}\\b`, 'i') }));
   const findings = [];
   for (const file of files) {
     if (path.resolve(file) === regAbs) continue; // never flag the registry itself

package/commands/team.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const fs = require('fs');
 const path = require('path');
 
 const { canonicalEngineName } = require('../lib/engine-registry');
@@ -115,12 +116,83 @@ function renderTeamRoster(roster) {
     .join('\n');
 }
 
+// The pruning pass keeps the team lean like a real company: it flags members
+// with no recent signal, and it never deletes anything. A signal is the newest
+// of MEMBER.md, any logs/*.md, or a mission the member owns that is still
+// active or running.
+const PRUNE_ACTIVE_MISSION_STATUSES = new Set(['active', 'running']);
+const DEFAULT_PRUNE_DAYS = 30;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+function newestSignalMs(member) {
+  const times = [];
+  const stamp = (file) => {
+    try { times.push(fs.statSync(file).mtimeMs); } catch { /* missing file is just no signal */ }
+  };
+  if (member?.path) stamp(member.path);
+  if (member?.dir) {
+    const logsDir = path.join(member.dir, 'logs');
+    let entries = [];
+    try { entries = fs.readdirSync(logsDir); } catch { entries = []; }
+    for (const entry of entries) {
+      if (entry.endsWith('.md')) stamp(path.join(logsDir, entry));
+    }
+  }
+  return times.length ? Math.max(...times) : 0;
+}
+
+function collectTeamPrune(deps = {}) {
+  const root = deps.root || repoRoot(deps.cwd || process.cwd());
+  const days = Number.isFinite(deps.days) && deps.days > 0 ? deps.days : DEFAULT_PRUNE_DAYS;
+  const nowMs = typeof deps.now === 'function' ? deps.now() : Date.now();
+  const activeOwners = new Set();
+  for (const mission of collectMissions(root, deps)) {
+    if (!PRUNE_ACTIVE_MISSION_STATUSES.has(String(mission?.status || '').toLowerCase())) continue;
+    const owner = String(mission?.owner || mission?.member || '').trim().toLowerCase();
+    if (owner) activeOwners.add(owner);
+  }
+  const quiet = [];
+  let activeCount = 0;
+  for (const member of collectMembers(root, deps)) {
+    const name = String(member?.name || '').trim().toLowerCase();
+    if (!name) continue;
+    const signalMs = newestSignalMs(member);
+    if (activeOwners.has(name) || (signalMs && nowMs - signalMs < days * DAY_MS)) {
+      activeCount += 1;
+      continue;
+    }
+    quiet.push({
+      name,
+      days_quiet: signalMs ? Math.floor((nowMs - signalMs) / DAY_MS) : null,
+      last_signal: signalMs ? new Date(signalMs).toISOString() : null,
+    });
+  }
+  quiet.sort((a, b) => a.name.localeCompare(b.name));
+  return { quiet, active_count: activeCount };
+}
+
+function renderTeamPrune(report, days = DEFAULT_PRUNE_DAYS) {
+  if (!report.quiet.length && !report.active_count) {
+    return 'no team members yet. create one with: atris member create <name> --role="..."';
+  }
+  if (!report.quiet.length) {
+    return `everyone on the team has a signal newer than ${days} days. nothing to prune.`;
+  }
+  const lines = report.quiet.map((entry) => (entry.days_quiet === null
+    ? `${entry.name} has no recorded activity; keep, hand off, or retire.`
+    : `${entry.name} has been quiet for ${entry.days_quiet} days; keep, hand off, or retire.`));
+  lines.push(`${report.active_count} member${report.active_count === 1 ? ' is' : 's are'} still active. nothing was deleted; this is a report.`);
+  return lines.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',
+    'atris team prune - flag members with no recent activity; deletes nothing',
     '',
     'usage: atris team [roster|presence] [--json]',
+    'usage: atris team prune [--days N] [--json]',
   ].join('\n');
 }
 
@@ -129,6 +201,27 @@ function teamCommand(args = [], deps = {}) {
     (deps.write || process.stdout.write.bind(process.stdout))(`${helpText()}\n`);
     return 0;
   }
+  if (args[0] === 'prune') {
+    const rest = args.slice(1);
+    let days = DEFAULT_PRUNE_DAYS;
+    let json = false;
+    let bad = false;
+    for (let i = 0; i < rest.length; i += 1) {
+      const arg = rest[i];
+      if (arg === '--json') { json = true; continue; }
+      if (arg === '--days') { i += 1; days = Number(rest[i]); continue; }
+      if (arg.startsWith('--days=')) { days = Number(arg.slice('--days='.length)); continue; }
+      bad = true;
+    }
+    if (bad || !Number.isFinite(days) || days <= 0) {
+      (deps.error || process.stderr.write.bind(process.stderr))('usage: atris team prune [--days N] [--json]\n');
+      return 2;
+    }
+    const report = deps.prune || collectTeamPrune({ ...deps, days });
+    const output = json ? JSON.stringify(report, null, 2) : renderTeamPrune(report, days);
+    (deps.write || process.stdout.write.bind(process.stdout))(`${output}\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);
@@ -139,7 +232,7 @@ function teamCommand(args = [], deps = {}) {
     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 [roster|presence] [--json]\n');
+    (deps.error || process.stderr.write.bind(process.stderr))('usage: atris team [roster|presence|prune] [--json]\n');
     return 2;
   }
   const presence = deps.presence || collectTeamPresence(deps);
@@ -150,4 +243,4 @@ function teamCommand(args = [], deps = {}) {
   return 0;
 }
 
-module.exports = { collectMissions, collectTasks, collectTeamPresence, collectTeamRoster, renderTeamRoster, teamCommand };
+module.exports = { collectMissions, collectTasks, collectTeamPresence, collectTeamPrune, collectTeamRoster, renderTeamPrune, renderTeamRoster, teamCommand };

package/lib/lesson-preflight.js

@@ -2,6 +2,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const escapeRegExp = require('./escape-regexp');
 
 const ACTIVE_STATUSES = new Set(['observed', 'open', 'attempted']);
 const KEYWORD_STOP_WORDS = new Set([
@@ -80,7 +81,7 @@ function slugKeywords(slug) {
 }
 
 function keywordAppears(text, keyword) {
-  const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const escaped = escapeRegExp(keyword);
   return new RegExp(`(^|[^a-z0-9])${escaped}([^a-z0-9]|$)`, 'i').test(text);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.40.0",
+  "version": "3.42.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {