@arjunkhera/atlas 0.3.6 → 0.3.8

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "atlas",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Atlas: the delivery lifecycle, its crews and the Atlas tools, for any repository.",
   "author": {
     "name": "Arjun Khera"

package/agents/verifier.md

@@ -76,6 +76,35 @@ Verified at <the head commit>, in a fresh worktree.
 Links made for this run: <none, or each ignored file linked>.
 ```
 
+## Scenario proofs
+
+Use this section when the definition of done names scenario assertions,
+such as `week-conflict/e3#a1b2c3`. The steps above still apply. These steps
+replace step 2 for those lines.
+
+1. Make a fresh worktree of the branch, as in the steps above.
+2. Start the product from `atlas/tests.yaml` with run secrets. The kit in
+   `<area>/test/atlas/` does this when the scenarios run. Set `ATLAS_GUARDS_FROM`
+   to `atlas/tests.yaml` of the main branch. A scenario that needs a provided
+   secret follows the rules of the section "Ignored files and secrets".
+3. Run the scenarios that the line names, with the runner command of `tests.yaml`.
+   Note the run id. Evidence goes to `<area>/test/evidence/<run id>/`.
+4. For each named assertion, make your own check through a raw driver of
+   the kit (`test/atlas/drivers/`). Do not use the actions of the repo or its tests.
+   Write a short script in your scratch folder. It starts the environment, sends the
+   calls of the assertion, and reads the answers. Keep the answer that proves the result.
+5. Write the `--own` file in your scratch folder. It is a JSON object with one
+   entry for each assertion: `{ "week-conflict/e3": { "result": "pass", "proof": "refused, revision 2" } }`.
+6. Print the table with `atlas tests proof`. Give it `--root` for the area,
+   `--run` for the run id, and `--own` for your file.
+   Put the table under the heading of the proof comment. A blocked or failed way
+   in shows its reason in the table.
+7. Run the privacy check on the comment, and post it, as the steps above say.
+   In a cloud session `gh pr comment` may be blocked. Then do not retry.
+   Return the path of the comment file to the caller. The caller posts it.
+8. A line is PASS only when the run and your own check both pass. If they
+   differ, mark the line FAIL and show both results.
+
 ## Never-read and never-quote paths (rules in `${CLAUDE_PLUGIN_ROOT}/work/protected-paths.json`)
 
 These deny rules bind every sub-agent that reads a repo.

package/door/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // The atlas command: install, upgrade, doctor, check, status, the tooling
-// writer, the kind drift report, the code-read resolver, the STE check and
-// the design check.
+// writer, the kind drift report, the code-read resolver, the STE check, the
+// design check and the tests verbs (the link check and the test kit writer).
 //
 // Stage 1 of the target design retired `setup`, `change`, `helpers` and
 // `test onboarding`: code that guesses meaning retires (decided 28
@@ -24,6 +24,8 @@ import { install, upgrade, doctor } from './lib/install.mjs';
 import { checkPaths, LIMITS } from './lib/ste.mjs';
 import { checkDesignFile, MAX_STEP_SENTENCES } from './lib/design.mjs';
 import { loadPrivateTerms } from './lib/privacy.mjs';
+import { checkCommand as testsCheck, writeCommand as testsWrite } from './lib/tests.mjs';
+import { proofCommand as testsProof } from './lib/proof.mjs';
 
 export const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const ATLAS_VERSION = packagePackageVersion(PACKAGE_ROOT);
@@ -46,6 +48,16 @@ const HELP = `atlas — the door into a repo's Atlas files
       --terms <file>                   private terms; default ~/.config/atlas/private-terms.txt
   atlas design <file> …                check a walkthrough design doc: summary, parts, an example and a picture in each step
 
+  atlas tests check --root <area>      run the link check on the tests of an area
+      --halves <list>                  static, lint, run; default all three
+      --evidence <dir>                 where the evidence files are; default <area>/test/evidence
+      --guards-from <file>             tests.yaml of the main branch; a changed guard part is a finding
+      --run <id>                       read the evidence of this run only; default the newest run
+  atlas tests write --root <area>      copy the shipped test kit into <area>/test/atlas/
+  atlas tests proof --root <area>      print the proof table of one run, one row for each assertion
+      --run <id>                       the run; default the newest run in the evidence folder
+      --own <file>                     JSON of the verifier's own checks: { id: { result, proof } }
+
   atlas install                        install Atlas for every folder on this Mac
   atlas upgrade [--version <v>]        check, show and install a newer release
   atlas doctor                         is Atlas installed and working here
@@ -71,6 +83,7 @@ export const FLAGS = Object.freeze({
   check: { root: 'optional', repo: 'value', 'fail-on': 'value' },
   ste: { share: 'switch', terms: 'value' },
   design: {},
+  tests: { root: 'optional', halves: 'value', evidence: 'value', 'guards-from': 'value', tests: 'value', 'dry-run': 'switch', run: 'value', own: 'value' },
   install: { local: 'switch', from: 'value', 'skip-global': 'switch', yes: 'switch' },
   upgrade: { version: 'optional', yes: 'switch' },
   doctor: {},
@@ -220,6 +233,17 @@ function designCommand(chosen) {
   return count ? 1 : 0;
 }
 
+function testsCommand(chosen) {
+  const root = rootOf(chosen);
+  const what = chosen._[1];
+  if (what === 'check') {
+    return testsCheck({ halves: chosen.halves, evidence: chosen.evidence, tests: chosen.tests, guardsFrom: chosen['guards-from'], run: chosen.run }, root, line, PACKAGE_ROOT);
+  }
+  if (what === 'write') return testsWrite({ dryRun: Boolean(chosen['dry-run']) }, root, PACKAGE_ROOT, line);
+  if (what === 'proof') return testsProof({ run: chosen.run, own: chosen.own, evidence: chosen.evidence }, root, line);
+  throw new Error(`there is no tests verb "${what ?? ''}". Use check, write or proof.`);
+}
+
 function checkCommand(chosen) {
   const root = rootOf(chosen);
   const report = scan({ root, repoId: chosen.repo ?? null });
@@ -250,6 +274,7 @@ export async function main(argv = process.argv.slice(2)) {
     case 'check': return checkCommand(chosen);
     case 'ste': return steCommand(chosen);
     case 'design': return designCommand(chosen);
+    case 'tests': return testsCommand(chosen);
     default: throw new Error(`there is no verb "${command}". Run "atlas help".`);
   }
 }

package/door/kit-releases.json

@@ -0,0 +1,4 @@
+{
+  "note": "Every kit of the folder tests/ that a release of Atlas shipped, as the kit hash of its manifest (the sha256 of the sorted lines of path and file hash). The kit of this package is always accepted and need not be listed. When a release changes anything in tests/, add the kit hash of the release before it here. atlas tests check reads this list; git history is never read.",
+  "releases": []
+}

package/door/lib/proof.mjs

@@ -0,0 +1,127 @@
+// `atlas tests proof`: the proof table of design section 5.7, made from the
+// evidence of ONE run, or with no --run the newest run of each scenario.
+//
+//   atlas tests proof --root <area> [--run <id>] [--own <file>] [--evidence <dir>]
+//
+// One row for each assertion, one column for each way in, a column for the
+// verifier's own check, and a short proof. `--own` is a JSON file of
+// { "<scenario>/e1": { "result": "pass", "proof": "revision 1" } }; a full id
+// (with its #fingerprint) works as a key too. A way that is blocked or failed
+// shows its reason in the proof column. Evidence of a fault run is left out.
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { newestRunPerScenario } from '../../tests/link-check.mjs';
+
+const MAX_CELL = 110;
+
+const clean = (text) => String(text ?? '').replace(/\s+/g, ' ').replace(/\|/g, '\\|').trim();
+const clip = (text, n = MAX_CELL) => { const t = clean(text); return t.length > n ? `${t.slice(0, n - 3)}...` : t; };
+const label = (result) => String(result ?? '').toUpperCase();
+
+function summary(value) {
+  if (value === undefined || value === null) return '';
+  return typeof value === 'string' ? value : JSON.stringify(value);
+}
+
+const usage = (message) => Object.assign(new Error(message), { usage: true });
+
+// Reads the --own file. Throws an Error with a plain message on a bad file.
+export function readOwn(file) {
+  let data;
+  try { data = JSON.parse(readFileSync(file, 'utf8')); } catch (error) { throw usage(`--own ${file} cannot be read as JSON: ${error.code ?? error.message}`); }
+  if (!data || typeof data !== 'object' || Array.isArray(data)) throw usage('--own must hold a JSON object of { id: { result, proof } }');
+  for (const [id, one] of Object.entries(data)) {
+    if (!one || typeof one !== 'object' || typeof one.result !== 'string') throw usage(`--own: the entry "${id}" must be { "result": "pass", "proof": "..." }`);
+  }
+  return data;
+}
+
+export function buildProof({ evidenceDir, runId = null, own = {} }) {
+  const perScenario = runId ? null : newestRunPerScenario(evidenceDir);
+  if (!runId && !perScenario.size) throw new Error(`there is no run in ${evidenceDir}`);
+  const names = runId ? [runId] : [...new Set(perScenario.values())].sort();
+  const newest = new Map();
+  const used = new Set();
+  let faultRuns = 0;
+  for (const id of names) {
+    const dir = join(evidenceDir, id);
+    if (!existsSync(dir)) throw new Error(`the run "${id}" has no folder in ${evidenceDir}`);
+    for (const name of readdirSync(dir).sort()) {
+      if (!name.endsWith('.json')) continue;
+      let data;
+      try { data = JSON.parse(readFileSync(join(dir, name), 'utf8')); } catch { continue; }
+      if (data?.evidence !== 1) continue;
+      if (data.fault_run) { faultRuns += 1; continue; }
+      if (perScenario && perScenario.get(data.scenario) !== id) continue;
+      used.add(id);
+      const before = newest.get(data.scenario);
+      if (!before || String(data.started) >= String(before.started)) newest.set(data.scenario, data);
+    }
+  }
+  const id = runId ?? [...used].sort().join(', ');
+  if (!newest.size) throw new Error(`the run "${id}" has no evidence file that counts${faultRuns ? ' (only fault runs)' : ''}`);
+  const scenarios = [...newest.values()].sort((a, b) => (a.scenario < b.scenario ? -1 : 1));
+  const ways = [...new Set(scenarios.flatMap((s) => Object.keys(s.ways ?? {})))];
+  const rows = [];
+  const blocked = [];
+  for (const s of scenarios) {
+    for (const [way, w] of Object.entries(s.ways ?? {})) {
+      if (w.verdict === 'blocked' || w.verdict === 'fail') blocked.push(`${s.scenario} through ${way} is ${w.verdict}${w.reason ? `: ${clip(w.reason, 200)}` : ''}`);
+    }
+    const ids = [...new Set((s.assertions ?? []).map((a) => a.id))];
+    for (const full of ids) {
+      const short = full.replace(/#[0-9a-f]+$/, '');
+      const entries = (s.assertions ?? []).filter((a) => a.id === full);
+      const cells = Object.fromEntries(ways.map((way) => {
+        const e = entries.find((x) => x.way === way);
+        return [way, e ? label(e.result) : '-'];
+      }));
+      const problems = entries.filter((e) => e.result !== 'pass' && e.result !== 'not here').map((e) => {
+        const why = e.proof?.error ?? e.proof?.why ?? s.ways?.[e.way]?.reason ?? '';
+        return `${e.way} ${e.result}${why ? `: ${why}` : ''}`;
+      });
+      const passed = entries.find((e) => e.result === 'pass' && e.proof?.value !== undefined);
+      const mine = own[full] ?? own[short] ?? null;
+      const parts = [];
+      if (problems.length) parts.push(problems.join('; '));
+      else if (passed) parts.push(summary(passed.proof.value));
+      if (mine?.proof) parts.push(`own: ${summary(mine.proof)}`);
+      rows.push({
+        label: `${short.replace('/', ' ')}`, full, cells, own: mine ? label(mine.result) : '-',
+        proof: clip(parts.join(' | ')),
+      });
+    }
+  }
+  return { runId: id, environment: scenarios[0].environment, ways, rows, blocked, faultRuns, scenarios: scenarios.map((s) => s.scenario) };
+}
+
+export function renderProof(proof) {
+  const out = [];
+  out.push(`${proof.runId.includes(', ') ? 'Runs' : 'Run'} ${proof.runId}, environment ${proof.environment}, ${proof.scenarios.length} scenario(s): ${proof.scenarios.join(', ')}.`);
+  out.push('');
+  out.push(`| Assertion | ${proof.ways.join(' | ')} | Verifier's own check | Proof |`);
+  out.push(`|---|${proof.ways.map(() => '---').join('|')}|---|---|`);
+  for (const r of proof.rows) out.push(`| ${r.label} | ${proof.ways.map((w) => r.cells[w]).join(' | ')} | ${r.own} | ${r.proof} |`);
+  if (proof.blocked.length) {
+    out.push('');
+    out.push('Blocked or failed ways in:');
+    for (const b of proof.blocked) out.push(`- ${clean(b)}`);
+  }
+  if (proof.faultRuns) {
+    out.push('');
+    out.push(`${proof.faultRuns} evidence file(s) of fault runs were left out.`);
+  }
+  return out;
+}
+
+export function proofCommand(chosen, root, line) {
+  try {
+    const own = chosen.own ? readOwn(resolve(chosen.own)) : {};
+    const evidenceDir = resolve(chosen.evidence ?? join(root, 'test', 'evidence'));
+    for (const text of renderProof(buildProof({ evidenceDir, runId: chosen.run ?? null, own }))) line(text);
+    return 0;
+  } catch (error) {
+    line(`proof: ${error.message}`);
+    return error.usage ? 2 : 1;
+  }
+}

package/door/lib/tests.mjs

@@ -0,0 +1,190 @@
+// The two verbs of `atlas tests`.
+//
+//   atlas tests check --root <area>   run the link check on an area
+//   atlas tests write --root <area>   copy the shipped test kit into <area>/test/atlas/
+//   atlas tests proof --root <area>   print the proof table of one run (proof.mjs)
+//
+// The kit is the folder `tests/` of this package: the contract library, the
+// drivers, the stand-in helper and the link check. `write` copies each file
+// byte for byte and writes `manifest.json` beside them, with the package
+// version and the sha256 of each file. It refuses to replace a file whose hash
+// the manifest does not list, so a hand edit is never lost. It refuses to write
+// through a link. It also writes <area>/test/evidence/.gitignore (ignore
+// everything) and, at the repo root, a .gitignore line for .env.test when it
+// is missing, and it says what it added. A person merges every file that it
+// writes.
+import { createHash } from 'node:crypto';
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { checkArea, formatFinding, HALVES, kitHashOf, loadKitReleases } from '../../tests/link-check.mjs';
+import { packagePackageVersion } from './releases.mjs';
+
+export const KIT_SOURCE = 'tests';
+export const KIT_TARGET = 'test/atlas';
+export const MANIFEST = 'manifest.json';
+
+const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
+
+export class KitRefusal extends Error {
+  constructor(message) { super(message); this.name = 'KitRefusal'; }
+}
+
+function filesUnder(dir, prefix = '') {
+  const out = [];
+  for (const name of readdirSync(dir).sort()) {
+    const full = join(dir, name);
+    if (statSync(full).isDirectory()) out.push(...filesUnder(full, `${prefix}${name}/`));
+    else out.push(`${prefix}${name}`);
+  }
+  return out;
+}
+
+// The kit hash of this package, and the hashes of every kit a release shipped.
+// The current kit is always accepted, so a release need not list itself.
+export const KIT_RELEASES_FILE = join('door', 'kit-releases.json');
+
+export function currentKitHash(packageRoot) {
+  return kitHashOf(Object.fromEntries([...kitFiles(packageRoot)].map(([path, bytes]) => [path, sha256(bytes)])));
+}
+
+export function acceptedKitHashes(packageRoot) {
+  const file = join(packageRoot, KIT_RELEASES_FILE);
+  return [...(existsSync(file) ? loadKitReleases(file) : []), currentKitHash(packageRoot)];
+}
+
+// A path under `root` must not be a link, and none of its parents under `root`.
+function assertPlain(root, path) {
+  const parts = relative(root, path).split(/[\\/]/).filter(Boolean);
+  let at = root;
+  for (const part of parts) {
+    at = join(at, part);
+    const stat = lstatSyncSafe(at);
+    if (!stat) return;
+    if (stat.isSymbolicLink()) throw new KitRefusal(`${relative(root, at) || at} is a link. "atlas tests write" never writes through a link. Nothing was written. Replace the link with a plain folder or file.`);
+  }
+}
+function lstatSyncSafe(path) { try { return lstatSync(path); } catch { return null; } }
+
+// The repo root of an area: the nearest folder above it with a .git, or the area itself.
+function repoRootOf(root) {
+  let dir = resolve(root);
+  for (;;) {
+    if (existsSync(join(dir, '.git'))) return dir;
+    const up = dirname(dir);
+    if (up === dir) return resolve(root);
+    dir = up;
+  }
+}
+
+// Makes sure that a .gitignore file has each line. Returns { state, file, added }.
+function ensureLines(file, lines, dryRun) {
+  const have = existsSync(file) ? readFileSync(file, 'utf8') : null;
+  const present = new Set((have ?? '').split('\n').map((l) => l.trim()));
+  const added = lines.filter((l) => !present.has(l));
+  if (!added.length) return { state: 'current', file, added };
+  if (!dryRun) {
+    mkdirSync(dirname(file), { recursive: true });
+    const base = have === null ? '' : (have.endsWith('\n') || have === '' ? have : `${have}\n`);
+    writeFileSync(file, `${base}${added.join('\n')}\n`);
+  }
+  return { state: have === null ? 'new' : 'add', file, added };
+}
+
+export function kitFiles(packageRoot) {
+  const dir = join(packageRoot, KIT_SOURCE);
+  return new Map(filesUnder(dir).map((path) => [path, readFileSync(join(dir, path))]));
+}
+
+// Writes the kit into <root>/test/atlas. Returns { version, rows, changed }.
+export function writeKit(root, packageRoot, { dryRun = false } = {}) {
+  const version = packagePackageVersion(packageRoot);
+  const target = join(root, KIT_TARGET);
+  const manifestPath = join(target, MANIFEST);
+  let known = {};
+  if (existsSync(manifestPath)) {
+    try { known = JSON.parse(readFileSync(manifestPath, 'utf8')).files ?? {}; } catch { throw new KitRefusal(`${KIT_TARGET}/${MANIFEST} is not JSON; move it away and run again`); }
+  }
+  const files = kitFiles(packageRoot);
+  assertPlain(root, join(root, 'test'));
+  assertPlain(root, target);
+  assertPlain(root, manifestPath);
+  for (const path of files.keys()) assertPlain(root, join(target, path));
+  const evidenceIgnore = join(root, 'test', 'evidence', '.gitignore');
+  const repoRoot = repoRootOf(root);
+  const rootIgnore = join(repoRoot, '.gitignore');
+  assertPlain(root, join(root, 'test', 'evidence'));
+  assertPlain(root, evidenceIgnore);
+  if (repoRoot === resolve(root)) assertPlain(root, rootIgnore);
+  else if (existsSync(rootIgnore) && lstatSync(rootIgnore).isSymbolicLink()) throw new KitRefusal(`${rootIgnore} is a link. "atlas tests write" never writes through a link. Nothing was written.`);
+  const rows = [];
+  const refused = [];
+  for (const [path, bytes] of files) {
+    const hash = sha256(bytes);
+    const file = join(target, path);
+    if (!existsSync(file)) { rows.push({ state: 'new', path, sha256: hash }); continue; }
+    const have = sha256(readFileSync(file));
+    if (have === hash) rows.push({ state: 'current', path, sha256: hash });
+    else if (known[path] === have) rows.push({ state: 'replace', path, sha256: hash });
+    else refused.push(path);
+  }
+  if (refused.length) {
+    throw new KitRefusal(`${refused.length} file(s) in ${KIT_TARGET}/ differ from the manifest, so they were edited by hand or came from an unknown copy: ${refused.slice(0, 5).join(', ')}. Nothing was written. Restore them, or move them away.`);
+  }
+  for (const path of Object.keys(known)) if (!files.has(path)) rows.push({ state: 'orphan', path, sha256: known[path] });
+  const manifest = `${JSON.stringify({ atlas: version, files: Object.fromEntries([...files].map(([p, b]) => [p, sha256(b)])) }, null, 2)}\n`;
+  const manifestChanged = !existsSync(manifestPath) || readFileSync(manifestPath, 'utf8') !== manifest;
+  const ignores = [
+    ensureLines(evidenceIgnore, ['*', '!.gitignore'], dryRun),
+    ensureLines(rootIgnore, ['.env.test'], dryRun),
+  ];
+  const changed = rows.some((r) => r.state === 'new' || r.state === 'replace') || manifestChanged || ignores.some((i) => i.state !== 'current');
+  if (!dryRun) {
+    for (const row of rows) {
+      if (row.state !== 'new' && row.state !== 'replace') continue;
+      const file = join(target, row.path);
+      mkdirSync(dirname(file), { recursive: true });
+      writeFileSync(file, files.get(row.path));
+    }
+    mkdirSync(target, { recursive: true });
+    if (manifestChanged) writeFileSync(manifestPath, manifest);
+  }
+  return { version, rows, ignores, changed };
+}
+
+// The `check` verb. Prints one line for each finding. Returns the exit code.
+export function checkCommand(chosen, root, line, packageRoot) {
+  const halves = chosen.halves ? String(chosen.halves).split(',').map((s) => s.trim()).filter(Boolean) : [...HALVES];
+  const result = checkArea({
+    root, halves, evidence: chosen.evidence, tests: chosen.tests ?? 'test',
+    guardsFrom: chosen.guardsFrom || process.env.ATLAS_GUARDS_FROM || null,
+    run: chosen.run ?? null,
+    kitReleases: acceptedKitHashes(packageRoot),
+  });
+  for (const finding of result.findings) line(formatFinding(finding));
+  line('');
+  line(`${result.scenarios.length} scenario(s) read; halves: ${halves.join(', ')}; ${result.findings.length} finding(s).`);
+  line(result.findings.length ? 'RED' : 'GREEN');
+  return result.findings.length ? 1 : 0;
+}
+
+export function writeCommand(chosen, root, packageRoot, line) {
+  try {
+    const result = writeKit(root, packageRoot, { dryRun: chosen.dryRun });
+    line(`Atlas ${result.version}: the test kit in ${KIT_TARGET}/`);
+    for (const row of result.rows) line(`  ${row.state.padEnd(8)} ${row.path}  sha256 ${row.sha256.slice(0, 12)}…`);
+    for (const one of result.ignores) {
+      const name = relative(root, one.file) || one.file;
+      if (one.state === 'current') line(`  ${'current'.padEnd(8)} ${name}  (has its lines)`);
+      else line(`  ${(one.state === 'new' ? 'new' : 'add').padEnd(8)} ${name}  ${chosen.dryRun ? 'would add' : 'added'}: ${one.added.join(', ')}`);
+    }
+    line('');
+    line(result.changed
+      ? `${chosen.dryRun ? 'Dry run. Nothing was written. ' : ''}The files come from the package. No edit by hand afterwards. A person merges them.`
+      : 'Nothing changed. Every file already matches the package.');
+    return 0;
+  } catch (error) {
+    if (!(error instanceof KitRefusal)) throw error;
+    line(`Refused: ${error.message}`);
+    return 1;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arjunkhera/atlas",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Atlas: the delivery lifecycle, its crews and the Atlas tools, as a Claude Code plugin for any repository.",
   "type": "module",
   "license": "UNLICENSED",
@@ -20,6 +20,7 @@
     "door/",
     "work/",
     "shape/",
+    "tests/",
     "skills/",
     "agents/",
     ".claude-plugin/",

package/skills/lead/SKILL.md

@@ -56,6 +56,7 @@ say that when you hand over a page.
 | Review a design or a diff | The three reviewer crews, as sdlc-task says |
 | Prove a pull request against its definition of done | The `atlas:verifier` crew |
 | Render a page for the owner | The `atlas:artifact-renderer` crew |
+| Onboard an area to tests, review scenario words, write or convert a test, sort a red test, plant faults | The `atlas:tests` skill |
 
 A crew reads and reports. It never holds the Atlas tools.
 
@@ -99,6 +100,8 @@ set. A test keeps the two lists equal.
 | `atlas kind-drift` | When the repo record and `atlas.yaml` may disagree on the kind; this command retires in stage 2, the onboarding stage |
 | `atlas code-read` | To resolve the citations of a code digest |
 | `atlas ste` | Before each publish; `--share` before a page goes to anyone else |
+| `atlas tests` | `write` puts the test kit in an area. `check` runs before a merge. `proof` prints the proof table of one run |
 | `atlas design` | Before you render a design doc made from the walkthrough template |
 
 A person merges every file that `atlas tooling` writes.
+A person merges every file that `atlas tests write` writes.