atris 3.17.0 → 3.23.0

package/atris.md

@@ -62,12 +62,12 @@ Labels used below:
 
 What you ship should not read as generated. The test: if someone said "an AI made this," would they believe it instantly? If yes, that is the bug. The model has no words for restraint and it falls into gravity wells. Beat both.
 
-- **Gate it.** `atris slop detect <path>` is deterministic: no model, exit 1 on a tell, built for CI and the review stage. A finding is a fact (file:line + rule), not an opinion. `guarded` once wired into review.
+- **Gate it.** `atris slop detect <path>` is deterministic: no model, exit 1 on a tell, built for CI and the review stage. A finding is a fact (file:line + rule), not an opinion. `--diff`/`--staged` scopes it to changed lines for a commit gate; `--fix` repairs the safe tells. `guarded` once wired into review.
 - **Name the move.** Vague prompts make vague output. Direct with craft words: vertical rhythm, negative space, hierarchy, contrast, bolder here / quieter there, restraint. Precise language is the lever. Own it.
 - **Refuse the wells** (named so you can): purple/indigo gradients, gradient-filled text, glassmorphism, Inter/Roboto defaults, claude-beige, neon-on-dark, hero-metric rows, identical card grids, eyebrow/tracked-caps labels, pulsing live-dots, em dashes.
 - **Commit to constraints.** One distinctive font, one accent hue, a small spacing scale. Taste is subtraction, not addition.
-- **Generate it right.** `atris deck` (slides) and the `design` policy apply the system by default: own backgrounds and fonts, never the tool's stock template.
-- **Compound it.** A new tell becomes a typed lesson with a `detector:` regex, so the gate grows instead of leaning on memory. Taste lives in code, not vibes.
+- **Generate it right.** `atris deck` (slides), `atris deck from <doc.md> --html` (a web page from a plain doc, in the web app's design tokens), `atris site <dir>` (a whole markdown folder into a navigable site), and `atris recap --html` (a memory-updates page) all apply the system by default: own backgrounds and fonts, never the tool's stock template. Output as an AppBlock with `--block` to drop into a web app.
+- **Compound it.** A new tell becomes a project rule in `.atris/slop.rules.json` (`atris slop rules --add`), and a project's brand lives in `.atris/theme.json` (`atris theme create` builds your own by feel, or `atris theme init` scaffolds one) so every deck, page, and site is on-brand by default, and one line of text becomes an on-brand image with `atris card`. The gate and the look grow per project instead of leaning on memory. Taste lives in code, not vibes.
 
 ## voice
 

package/bin/atris.js

@@ -363,6 +363,9 @@ function showHelp() {
   console.log('  review     - Validate work (tests, safety checks, docs)');
   console.log('  slop       - Detect frontend AI-slop tells (deterministic, exit 1 = found)');
   console.log('  deck       - Generate a premium Google Slides deck from a content spec');
+  console.log('  site       - Build a beautiful static site from a folder of markdown');
+  console.log('  theme      - Brand themes: "theme create" builds your own by feel (deck/html/site)');
+  console.log('  card       - One line of text into an on-brand image (uses your theme)');
   console.log('  run        - Auto-chain plan→do→review (autonomous loop, auto-pushes)');
   console.log('  run logs   - Browse glass run logs (phase reasoning persisted to disk)');
   console.log('  run search - Search phase reasoning across all run logs');
@@ -376,7 +379,7 @@ function showHelp() {
   console.log('  radar      - Show live agents joined with tasks, missions, and worktrees');
   console.log('  ctop       - Show a process-first live agent CPU/memory view');
   console.log('  status     - See local work and completions (`atris status <business>` for remote)');
-  console.log('  recap      - What your AI team did, in plain English (--share for paste-ready)');
+  console.log('  recap      - What your AI team did, in plain English (--share, or --html for a memory page)');
   console.log('  xp         - Show Career XP and contribution graph');
   console.log('  analytics  - Show recent productivity from journals');
   console.log('  search     - Search journal history (atris search <keyword>)');
@@ -828,7 +831,7 @@ if (command === '2' && ['fast', 'pro'].includes(String(firstCommandArg || '').to
 const knownCommands = ['init', 'log', 'now', 'radar', 'ctop', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'verify', 'search', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'plugin', 'experiments', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube',
-                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'probe', 'worktree', 'aeo', 'slop', 'deck', 'improve', 'xp', 'play', 'gm', 'x', 'recap',
+                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'probe', 'worktree', 'aeo', 'slop', 'deck', 'site', 'theme', 'card', 'improve', 'xp', 'play', 'gm', 'x', 'recap',
                        'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
                        'fork', 'browse', 'publish', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'compile', 'spaceship'];
 
@@ -1352,6 +1355,21 @@ if (command === 'init') {
   Promise.resolve(require('../commands/deck').run(process.argv.slice(3)))
     .then((code) => process.exit(typeof code === 'number' ? code : 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'site') {
+  // Site: beautiful static site from a folder of markdown, in the anti-slop design system.
+  Promise.resolve(require('../commands/site').run(process.argv.slice(3)))
+    .then((code) => process.exit(typeof code === 'number' ? code : 0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'theme') {
+  // Theme: brand themes (.atris/theme.json) for the whole design system (deck/html/site).
+  Promise.resolve(require('../commands/theme').run(process.argv.slice(3)))
+    .then((code) => process.exit(typeof code === 'number' ? code : 0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'card') {
+  // Card: one line of text into an on-brand image (uses your theme + the design system).
+  Promise.resolve(require('../commands/card').run(process.argv.slice(3)))
+    .then((code) => process.exit(typeof code === 'number' ? code : 0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'aeo') {
   // AEO: AI Engine Optimization — credit-metered citation drafting against the customer workspace.
   Promise.resolve(require('../commands/aeo').run(process.argv.slice(3)))

package/commands/card.js

@@ -0,0 +1,121 @@
+// atris card — one line of text -> a beautiful, on-brand image (your theme).
+//
+//   atris card "Ship faster" --kind statement --theme brand --size og
+//   atris card "It just works" --kind quote --by "a happy user"
+//   atris card --kind stat --number "10x" --label "faster reviews"
+//
+// Writes an .html (always) and a .png (when headless Chrome is available).
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execFileSync, spawnSync } = require('child_process');
+const { buildCard, SIZES, KINDS } = require('../lib/card');
+
+function parseFlags(argv) {
+  const flags = {}; const pos = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--html-only') { flags.htmlOnly = true; continue; }
+    if (a.startsWith('--')) {
+      const key = a.slice(2);
+      const next = argv[i + 1];
+      if (next != null && !next.startsWith('--')) { flags[key] = next; i++; } else flags[key] = true;
+      continue;
+    }
+    pos.push(a);
+  }
+  return { flags, pos };
+}
+
+// find an installed Chrome/Chromium without adding a dependency
+function findChrome() {
+  if (process.env.CHROME_PATH && fs.existsSync(process.env.CHROME_PATH)) return process.env.CHROME_PATH;
+  const macApps = [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+  ];
+  for (const p of macApps) if (fs.existsSync(p)) return p;
+  for (const name of ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser', 'chrome']) {
+    const r = spawnSync('command', ['-v', name], { shell: true, encoding: 'utf8' });
+    if (r.status === 0 && r.stdout.trim()) return r.stdout.trim();
+  }
+  return null;
+}
+
+function renderPng(chrome, html, width, height, outPng) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-card-'));
+  const htmlFile = path.join(tmp, 'card.html');
+  fs.writeFileSync(htmlFile, html);
+  const args = [
+    '--headless=new', '--disable-gpu', '--hide-scrollbars',
+    '--force-device-scale-factor=2',
+    `--window-size=${width},${height}`,
+    '--virtual-time-budget=4000',
+    `--screenshot=${outPng}`,
+    `file://${htmlFile}`,
+  ];
+  execFileSync(chrome, args, { stdio: 'ignore', timeout: 60000 });
+  return fs.existsSync(outPng);
+}
+
+function run(argv) {
+  const { flags, pos } = parseFlags(argv);
+
+  if (pos[0] === 'help' || flags.help) {
+    console.log(`\n  atris card — one line of text into an on-brand image\n
+  atris card "Your headline" [--kind statement|quote|stat] [--theme <name>] [--size og|wide|square|story]
+  flags: --sub --kicker --by --number --label --brand --version --out <file.png> --html-only\n
+  examples:
+    atris card "Design that builds itself" --kicker "Atris v3.23.0" --theme brand
+    atris card "It just works." --kind quote --by "a founder" --size square
+    atris card --kind stat --number "1260" --label "tests, all green"\n`);
+    return 0;
+  }
+
+  const text = pos.join(' ').trim();
+  const kind = flags.kind || 'statement';
+  if (!KINDS.includes(kind)) { console.error(`  unknown kind "${kind}". try: ${KINDS.join(', ')}`); return 2; }
+  if (flags.size && !SIZES[flags.size]) { console.error(`  unknown size "${flags.size}". try: ${Object.keys(SIZES).join(', ')}`); return 2; }
+  if (kind === 'stat' && !flags.number && !text) { console.error('  stat cards need --number (e.g. --number "10x")'); return 2; }
+  if (kind !== 'stat' && !text) { console.error('  give the card some text: atris card "Your headline"'); return 2; }
+
+  const spec = {
+    kind, text, headline: text,
+    theme: flags.theme, size: flags.size,
+    sub: flags.sub, kicker: flags.kicker, by: flags.by,
+    number: flags.number, label: flags.label,
+    brand: flags.brand, version: flags.version,
+  };
+
+  let card;
+  try { card = buildCard(spec); }
+  catch (e) { console.error(`  could not build card: ${e.message}`); return 1; }
+
+  const base = (flags.out ? String(flags.out).replace(/\.png$/i, '') : `card-${kind}-${card.theme}-${card.size}`);
+  const outPng = path.resolve(`${base}.png`);
+  const outHtml = path.resolve(`${base}.html`);
+  fs.writeFileSync(outHtml, card.html);
+
+  if (flags.htmlOnly) {
+    console.log(`\n  ✓ ${card.kind} card (${card.width}x${card.height}, theme ${card.theme})\n    html: ${outHtml}\n    open it, or render a png with Chrome installed.\n`);
+    return 0;
+  }
+
+  const chrome = findChrome();
+  if (!chrome) {
+    console.log(`\n  ✓ wrote html: ${outHtml}\n    no Chrome found for png. open the html, or set CHROME_PATH and re-run.\n`);
+    return 0;
+  }
+  try {
+    renderPng(chrome, card.html, card.width, card.height, outPng);
+    console.log(`\n  ✓ ${card.kind} card, ${card.width}x${card.height}, theme ${card.theme}\n    ${outPng}\n`);
+    return 0;
+  } catch (e) {
+    console.log(`\n  ! png render failed (${e.message.split('\n')[0]})\n    html is ready: ${outHtml}\n`);
+    return 0;
+  }
+}
+
+module.exports = { run };

package/commands/deck.js

@@ -14,6 +14,8 @@ const fs = require('fs');
 const https = require('https');
 const os = require('os');
 const { buildDeck, THEMES } = require('../lib/slides-deck');
+const { parseMarkdownToSpec } = require('../lib/deck-from-md');
+const { mergedThemes } = require('../lib/theme');
 
 const BASE = 'api.atris.ai';
 const PFX = '/api/integrations/google-slides';
@@ -60,9 +62,69 @@ const SAMPLE = {
   ],
 };
 
+// shared: spec -> live deck. Returns the URL.
+async function publishDeck(spec, { title, updateId, tok }) {
+  const { requests } = buildDeck(spec, { themes: mergedThemes(THEMES) });
+  let id, firstSlide;
+  if (updateId) {
+    id = updateId;
+    const got = await api('GET', `/presentations/${id}`, null, tok);
+    const slides = got.slides || (got.presentation && got.presentation.slides) || [];
+    firstSlide = slides[0] && slides[0].objectId;
+  } else {
+    const pres = await api('POST', '/presentations', { title }, tok);
+    id = pres.presentationId || pres.id || (pres.presentation && pres.presentation.presentationId);
+    const slides = pres.slides || (pres.presentation && pres.presentation.slides) || [];
+    firstSlide = slides[0] && slides[0].objectId;
+  }
+  const reqs = firstSlide ? [...requests, { deleteObject: { objectId: firstSlide } }] : requests;
+  console.log(`  building ${spec.slides.length} slides (${spec.theme}) · ${reqs.length} ops...`);
+  await api('POST', `/presentations/${id}/batch-update`, { requests: reqs }, tok);
+  return `https://docs.google.com/presentation/d/${id}/edit`;
+}
+
+// beautiful HTML output (page or AppBlock JSON) from a content spec
+function outputHtml(spec, argv, srcLabel) {
+  const { renderHtml, renderBlock, THEMES: HTML_THEMES } = require('../lib/html-render');
+  const themes = mergedThemes(HTML_THEMES);
+  if (!themes[spec.theme]) spec.theme = 'atris';
+  const title = flag(argv, '--title');
+  if (hasFlag(argv, '--block')) {
+    console.log(JSON.stringify(renderBlock(spec, { title, themes }), null, 2));
+    return 0;
+  }
+  const html = renderHtml(spec, { title, themes });
+  const out = flag(argv, '--out');
+  if (out) { fs.writeFileSync(out, html); console.log(`\n  ✓ html written: ${out}${srcLabel ? ` (from ${srcLabel})` : ''}\n`); }
+  else process.stdout.write(html + '\n');
+  return 0;
+}
+
 async function run(argv) {
   const sub = argv[0];
 
+  if (sub === 'from') {
+    const docPath = argv.slice(1).find((a) => !a.startsWith('-'));
+    if (!docPath) { console.error('  usage: atris deck from <doc.md> [--theme x] [--brand Name] [--build] [--title T]'); return 2; }
+    let md;
+    try { md = fs.readFileSync(docPath, 'utf8'); }
+    catch (e) { console.error(`  cannot read doc: ${e.message}`); return 2; }
+    const spec = parseMarkdownToSpec(md, { theme: flag(argv, '--theme'), brandName: flag(argv, '--brand') });
+    if (hasFlag(argv, '--html') || hasFlag(argv, '--block')) return outputHtml(spec, argv, docPath);
+    { const dt = mergedThemes(THEMES); if (!dt[spec.theme]) { console.error(`  unknown theme "${spec.theme}". try: ${Object.keys(dt).join(', ')}`); return 2; } }
+    if (!hasFlag(argv, '--build')) {
+      // default: print the spec so the PM can tweak before building
+      console.log(JSON.stringify(spec, null, 2));
+      return 0;
+    }
+    const tok = token();
+    if (!tok) { console.error('  no credentials at ~/.atris/credentials.json — run `atris login` and connect Google Drive.'); return 1; }
+    const title = flag(argv, '--title') || `${(spec.brand && spec.brand.name) || 'Atris'} deck`;
+    const url = await publishDeck(spec, { title, updateId: flag(argv, '--update'), tok });
+    console.log(`\n  ✓ deck from ${docPath} ready: ${url}\n`);
+    return 0;
+  }
+
   if (sub === 'themes') {
     console.log('\n  atris deck themes:\n');
     for (const [name, t] of Object.entries(THEMES)) {
@@ -85,51 +147,38 @@ async function run(argv) {
     try { spec = JSON.parse(fs.readFileSync(specPath, 'utf8')); }
     catch (e) { console.error(`  cannot read spec: ${e.message}`); return 2; }
     const themeOverride = flag(argv, '--theme'); if (themeOverride) spec.theme = themeOverride;
-    if (!THEMES[spec.theme]) { console.error(`  unknown theme "${spec.theme}". try: ${Object.keys(THEMES).join(', ')}`); return 2; }
+    if (hasFlag(argv, '--html') || hasFlag(argv, '--block')) return outputHtml(spec, argv, specPath);
+    { const dt = mergedThemes(THEMES); if (!dt[spec.theme]) { console.error(`  unknown theme "${spec.theme}". try: ${Object.keys(dt).join(', ')}`); return 2; } }
     const title = flag(argv, '--title') || `${(spec.brand && spec.brand.name) || 'Atris'} deck`;
 
     const tok = token();
     if (!tok) { console.error('  no credentials at ~/.atris/credentials.json — run `atris login` and connect Google Drive.'); return 1; }
 
-    const { requests } = buildDeck(spec);
-
-    let id, firstSlide;
-    const updateId = flag(argv, '--update');
-    if (updateId) {
-      id = updateId;
-      const got = await api('GET', `/presentations/${id}`, null, tok);
-      const slides = got.slides || (got.presentation && got.presentation.slides) || [];
-      firstSlide = slides[0] && slides[0].objectId;
-    } else {
-      const pres = await api('POST', '/presentations', { title }, tok);
-      id = pres.presentationId || pres.id || (pres.presentation && pres.presentation.presentationId);
-      const slides = pres.slides || (pres.presentation && pres.presentation.slides) || [];
-      firstSlide = slides[0] && slides[0].objectId;
-    }
-
-    const reqs = firstSlide ? [...requests, { deleteObject: { objectId: firstSlide } }] : requests;
-    console.log(`  building ${spec.slides.length} slides (${spec.theme}) · ${reqs.length} ops...`);
-    await api('POST', `/presentations/${id}/batch-update`, { requests: reqs }, tok);
-
-    const url = `https://docs.google.com/presentation/d/${id}/edit`;
+    const url = await publishDeck(spec, { title, updateId: flag(argv, '--update'), tok });
     console.log(`\n  ✓ deck ready: ${url}\n`);
     return 0;
   }
 
   console.log(`
-  atris deck — premium Google Slides from a plain content spec
+  atris deck — premium Google Slides from a plain content spec or a markdown doc
 
-    atris deck sample [--theme paper] > my.json   start from a sample spec
+    atris deck from doc.md [--build] [--title T]   turn a markdown doc into a deck
+    atris deck from doc.md --html --out page.html  beautiful HTML page (theme: atris|terminal|paper)
+    atris deck from doc.md --block                 emit the AppBlock JSON for a web app
+    atris deck sample [--theme paper] > my.json    start from a sample spec
     atris deck build my.json [--title "Q3 review"] create the deck, print the URL
-    atris deck build my.json --update <id>         rebuild into an existing deck
+    atris deck build my.json --html --out p.html   render the spec as HTML instead of slides
     atris deck themes                              list design themes
 
-  Design system is baked in: distinctive fonts, one accent, real data panels,
-  and no AI tells (em dashes sanitized, sentence-case labels, no gradient text).
+  'from' maps headings to slides (## with bullets -> columns, "**X** label" -> a
+  big number, Close -> a closing slide). Without --build it prints the spec to tweak.
+  Design system is baked in: distinctive fonts, one accent, real data panels, and
+  no AI tells (em dashes sanitized, sentence-case labels, no gradient text).
 `);
   return 0;
 }
 
 function flag(argv, name) { const i = argv.indexOf(name); return i !== -1 ? argv[i + 1] : null; }
+function hasFlag(argv, name) { return argv.includes(name); }
 
-module.exports = { run, SAMPLE };
+module.exports = { run, SAMPLE, publishDeck };

package/commands/recap.js

@@ -220,6 +220,22 @@ function recapAtris(args = []) {
     printRecapHelp();
     return;
   }
+  if (args.includes('--html')) {
+    // another way to view memory updates: a beautiful HTML page of what the workspace learned
+    const { buildMemorySpec } = require('../lib/memory-view');
+    const { renderHtml, renderBlock, THEMES: HTML_THEMES } = require('../lib/html-render');
+    const { mergedThemes } = require('../lib/theme');
+    const themes = mergedThemes(HTML_THEMES);
+    const flagVal = (n) => { const i = args.indexOf(n); return i !== -1 ? args[i + 1] : null; };
+    const spec = buildMemorySpec(process.cwd(), { theme: flagVal('--theme'), brand: flagVal('--brand') });
+    if (!themes[spec.theme]) spec.theme = 'atris';
+    if (args.includes('--block')) { console.log(JSON.stringify(renderBlock(spec, { title: 'Workspace memory', themes }), null, 2)); return; }
+    const html = renderHtml(spec, { title: 'Workspace memory', themes });
+    const out = flagVal('--out');
+    if (out) { fs.writeFileSync(out, html); console.log(`\n  ✓ memory view written: ${out}\n`); }
+    else process.stdout.write(html + '\n');
+    return;
+  }
   const daysIdx = args.indexOf('--days');
   const days = daysIdx !== -1 ? Number(args[daysIdx + 1]) : DEFAULT_DAYS;
   const data = buildRecapData(process.cwd(), { days });

package/commands/site.js

@@ -0,0 +1,48 @@
+// atris site — turn a folder of markdown (docs, your wiki, memory) into a
+// beautiful, navigable static site in the design system. Built on lib/site.js.
+//
+//   atris site <dir|doc.md> [--out dist] [--theme atris|terminal|paper] [--title T] [--serve]
+
+const { buildSite, serveSite } = require('../lib/site');
+
+function flag(argv, name) { const i = argv.indexOf(name); return i !== -1 ? argv[i + 1] : null; }
+function hasFlag(argv, name) { return argv.includes(name); }
+
+async function run(argv) {
+  const input = argv.find((a) => !a.startsWith('-'));
+  if (!input || input === 'help' || hasFlag(argv, '--help')) {
+    console.log(`
+  atris site — a beautiful static site from a folder of markdown
+
+    atris site <dir|doc.md> [--out dist] [--theme atris|terminal|paper] [--title T]
+    atris site atris/wiki --title "Atris Wiki" --serve
+
+  Each .md becomes a page; an index links them all. Same anti-slop design system,
+  semantic data-atris-block sections, ready for the web app. --serve previews it.
+`);
+    return input === 'help' || hasFlag(argv, '--help') ? 0 : 2;
+  }
+
+  let res;
+  try {
+    res = buildSite(input, {
+      out: flag(argv, '--out') || 'dist',
+      theme: flag(argv, '--theme'),
+      title: flag(argv, '--title'),
+      brand: flag(argv, '--brand'),
+    });
+  } catch (e) { console.error(`  ${e.message}`); return 2; }
+
+  console.log(`\n  ✓ site built: ${res.pages.length} page${res.pages.length === 1 ? '' : 's'} + index -> ${res.outDir}/`);
+  console.log(`    open ${res.indexPath}`);
+
+  if (hasFlag(argv, '--serve')) {
+    const port = Number(flag(argv, '--port')) || 4321;
+    const { url } = await serveSite(res.outDir, port);
+    console.log(`\n  serving at ${url} (ctrl-c to stop)\n`);
+    await new Promise(() => {}); // keep alive until killed
+  }
+  return 0;
+}
+
+module.exports = { run };

package/commands/slop.js

@@ -17,6 +17,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { execFileSync } = require('child_process');
 
 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
@@ -60,6 +61,7 @@ const RULES = [
     why: 'decorative emoji in UI copy' },
   { id: 'em-dash', sev: 'warn',
     re: /—/,
+    fix: (s) => s.replace(/\s*—\s*/g, ', '), // safe deterministic repair (prose)
     why: 'em dash: a top AI-writing tell; use a comma, colon, or period' },
   { id: 'hype-copy', sev: 'error',
     re: /\b(boost your productivity|supercharge|unleash|game[- ]?chang(?:er|ing)|seamlessly|effortlessly|revolutioniz(?:e|ing)|take your .{1,30} to the next level|elevate your|cutting[- ]edge|powered by ai|next[- ]generation)\b/i,
@@ -68,6 +70,86 @@ const RULES = [
 
 const ICON = { error: '✗', warn: '⚠' }; // ✗  ⚠
 
+const PROJECT_RULES_FILE = path.join('.atris', 'slop.rules.json');
+
+// Compounding: projects grow their own anti-slop ruleset in .atris/slop.rules.json.
+// Each entry: { id, pattern, flags?, why?, sev? }. Loaded on top of the built-ins.
+function loadProjectRules(root = process.cwd()) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(path.join(root, PROJECT_RULES_FILE), 'utf8'));
+    const arr = Array.isArray(raw) ? raw : (raw.rules || []);
+    return arr.map((r) => {
+      if (!r || !r.id || !r.pattern) return null;
+      let re; try { re = new RegExp(r.pattern, r.flags || 'i'); } catch { return null; }
+      return { id: r.id, sev: r.sev === 'error' ? 'error' : 'warn', re, why: r.why || r.id, project: true };
+    }).filter(Boolean);
+  } catch { return []; }
+}
+
+function addProjectRule(rule, root = process.cwd()) {
+  const file = path.join(root, PROJECT_RULES_FILE);
+  let arr = [];
+  try { const raw = JSON.parse(fs.readFileSync(file, 'utf8')); arr = Array.isArray(raw) ? raw : (raw.rules || []); } catch {}
+  arr = arr.filter((r) => r.id !== rule.id);
+  arr.push(rule);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(arr, null, 2) + '\n');
+  return file;
+}
+
+// Map<absFile, Set<changedLineNumber>> from the working-tree (or --cached) git diff.
+function gitChangedLines(staged, cwd = process.cwd()) {
+  const map = new Map();
+  let out;
+  try { out = execFileSync('git', ['diff', '--unified=0', ...(staged ? ['--cached'] : [])], { encoding: 'utf8', cwd }); }
+  catch { return map; }
+  let cur = null;
+  for (const line of out.split('\n')) {
+    const f = line.match(/^\+\+\+ b\/(.+)$/);
+    if (f) { cur = path.resolve(cwd, f[1]); map.set(cur, map.get(cur) || new Set()); continue; }
+    const h = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+    if (h && cur) { const start = +h[1], count = h[2] != null ? +h[2] : 1; for (let i = 0; i < count; i++) map.get(cur).add(start + i); }
+  }
+  return map;
+}
+
+// Install a pre-commit hook that gates staged changes through `atris slop detect --staged`.
+// Idempotent and non-destructive: appends a marked block, skips gracefully if atris is absent.
+function installHook(root = process.cwd()) {
+  if (!fs.existsSync(path.join(root, '.git'))) throw new Error('not a git repo (no .git here)');
+  const hookDir = path.join(root, '.git', 'hooks');
+  fs.mkdirSync(hookDir, { recursive: true });
+  const hookPath = path.join(hookDir, 'pre-commit');
+  const marker = '# atris slop gate';
+  let content = '';
+  try { content = fs.readFileSync(hookPath, 'utf8'); } catch {}
+  if (content.includes(marker)) return { hookPath, already: true };
+  if (!content) content = '#!/bin/sh\n';
+  if (!content.endsWith('\n')) content += '\n';
+  content += `\n${marker}\nif command -v atris >/dev/null 2>&1; then atris slop detect --staged --quiet || exit 1; fi\n`;
+  fs.writeFileSync(hookPath, content);
+  fs.chmodSync(hookPath, 0o755);
+  return { hookPath, already: false };
+}
+
+// Apply every fixable rule's safe transform in place. Returns { fixedCount, fixedFiles }.
+function applyFixes(files, rules) {
+  const fixable = rules.filter((r) => typeof r.fix === 'function');
+  let fixedCount = 0; const fixedFiles = [];
+  for (const file of files) {
+    let text; try { text = fs.readFileSync(file, 'utf8'); } catch { continue; }
+    const lines = text.split('\n');
+    let touched = false;
+    for (let i = 0; i < lines.length; i++) {
+      let line = lines[i];
+      for (const r of fixable) { if (r.re.test(line)) { const nl = r.fix(line); if (nl !== line) { line = nl; fixedCount++; } } }
+      if (line !== lines[i]) { lines[i] = line; touched = true; }
+    }
+    if (touched) { fs.writeFileSync(file, lines.join('\n')); fixedFiles.push(file); }
+  }
+  return { fixedCount, fixedFiles };
+}
+
 function walk(target, out) {
   let stat;
   try { stat = fs.statSync(target); } catch { return out; }
@@ -85,14 +167,14 @@ function walk(target, out) {
   return out;
 }
 
-function scanFile(file) {
+function scanFile(file, rules = RULES) {
   const findings = [];
   let text;
   try { text = fs.readFileSync(file, 'utf8'); } catch { return findings; }
   const lines = text.split('\n');
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    for (const rule of RULES) {
+    for (const rule of rules) {
       const m = rule.re.exec(line);
       if (m) {
         findings.push({
@@ -108,15 +190,38 @@ function scanFile(file) {
 function detect(argv) {
   const json = argv.includes('--json');
   const quiet = argv.includes('--quiet');
-  const target = argv.find((a) => !a.startsWith('-')) || '.';
+  const doFix = argv.includes('--fix');
+  const staged = argv.includes('--staged');
+  const diffMode = staged || argv.includes('--diff');
+  const rules = RULES.concat(loadProjectRules());
 
-  const files = walk(path.resolve(target), []);
-  const findings = files.flatMap(scanFile);
+  // pick the file set: a git diff (changed files) or a path walk
+  let files, changed = null;
+  if (diffMode) {
+    changed = gitChangedLines(staged);
+    files = [...changed.keys()].filter((f) => SCAN_EXTS.has(path.extname(f)) && fs.existsSync(f));
+  } else {
+    const target = argv.find((a) => !a.startsWith('-')) || '.';
+    files = walk(path.resolve(target), []);
+  }
+
+  let fixed = null;
+  if (doFix) {
+    fixed = applyFixes(files, rules);
+    if (!json && fixed.fixedCount) {
+      console.log(`\n  ✎ fixed ${fixed.fixedCount} tell${fixed.fixedCount === 1 ? '' : 's'} in ${fixed.fixedFiles.length} file${fixed.fixedFiles.length === 1 ? '' : 's'}`);
+    }
+  }
+
+  let findings = files.flatMap((f) => scanFile(f, rules));
+  if (diffMode && changed) findings = findings.filter((f) => changed.get(f.file) && changed.get(f.file).has(f.line));
   const errors = findings.filter((f) => f.sev === 'error').length;
 
   if (json) {
     console.log(JSON.stringify({
       ok: findings.length === 0, scanned: files.length,
+      mode: diffMode ? (staged ? 'staged' : 'diff') : 'path',
+      fixed: fixed ? fixed.fixedCount : 0,
       slop: findings.length, errors,
       findings: findings.map((f) => ({ ...f, file: path.relative(process.cwd(), f.file) })),
     }, null, 2));
@@ -146,28 +251,57 @@ function detect(argv) {
 
 function slopCommand(argv) {
   const sub = argv[0];
-  if (!sub || sub === 'detect' || sub.startsWith('-') || !['detect', 'rules', 'help'].includes(sub)) {
+  if (!sub || sub === 'detect' || sub.startsWith('-') || !['detect', 'rules', 'help', 'hook', 'install-hook'].includes(sub)) {
     // default + `detect`: scan. Bare `atris slop` scans cwd too.
     const rest = sub === 'detect' ? argv.slice(1) : argv;
     return detect(rest);
   }
+  if (sub === 'hook' || sub === 'install-hook') {
+    try {
+      const { hookPath, already } = installHook();
+      console.log(already
+        ? `\n  already installed: ${path.relative(process.cwd(), hookPath)}\n`
+        : `\n  ✓ slop pre-commit gate installed: ${path.relative(process.cwd(), hookPath)}\n    every commit now runs: atris slop detect --staged\n`);
+      return 0;
+    } catch (e) { console.error(`  ${e.message}`); return 2; }
+  }
+
   if (sub === 'rules') {
+    if (argv.includes('--add')) {
+      const rest = argv.slice(argv.indexOf('--add') + 1).filter((a) => !a.startsWith('-'));
+      const [id, pattern, ...whyParts] = rest;
+      if (!id || !pattern) { console.error('  usage: atris slop rules --add <id> <regex-pattern> <why...> [--sev error|warn]'); return 2; }
+      let valid = true; try { new RegExp(pattern, 'i'); } catch { valid = false; }
+      if (!valid) { console.error(`  invalid regex: ${pattern}`); return 2; }
+      const sev = (argv[argv.indexOf('--sev') + 1] === 'error') ? 'error' : 'warn';
+      const file = addProjectRule({ id, pattern, why: whyParts.join(' ') || id, sev });
+      console.log(`  ✓ added project rule "${id}" to ${path.relative(process.cwd(), file)}`);
+      return 0;
+    }
+    const project = loadProjectRules();
     console.log('\n  atris slop — deterministic rules:\n');
     for (const r of RULES) console.log(`  ${ICON[r.sev]} ${r.id.padEnd(20)} ${r.why}`);
-    console.log('');
+    for (const r of project) console.log(`  ${ICON[r.sev]} ${r.id.padEnd(20)} ${r.why}  (project)`);
+    console.log(`\n  ${RULES.length} built-in${project.length ? ` + ${project.length} project` : ''} rule${RULES.length + project.length === 1 ? '' : 's'}\n`);
     return 0;
   }
   // help
   console.log(`
-  atris slop — deterministic frontend-slop detector (no LLM)
+  atris slop — deterministic slop detector + repairer (no LLM)
 
-    atris slop detect [path]     scan a file or dir (default: .)
-    atris slop detect src --json machine output for CI / the loop
-    atris slop rules             list the active rules
+    atris slop detect [path]      scan a file or dir (default: .)
+    atris slop detect --diff      scan only changed lines (commit/PR gate)
+    atris slop detect --staged    scan only staged changes (pre-commit hook)
+    atris slop detect --fix       auto-repair the safe tells (em dashes), report the rest
+    atris slop detect [path] --json   machine output for CI / the loop
+    atris slop rules              list active rules (built-in + project)
+    atris slop rules --add <id> <pattern> <why>   grow the project ruleset
+    atris slop hook               install a pre-commit gate (runs --staged)
 
+  Project rules live in .atris/slop.rules.json and compound over time.
   exit 0 = clean, 1 = slop found. Wire into PR checks and the autopilot gate.
 `);
   return 0;
 }
 
-module.exports = { slopCommand, detect, scanFile, RULES };
+module.exports = { slopCommand, detect, scanFile, RULES, loadProjectRules, addProjectRule, gitChangedLines, applyFixes, installHook };