atris 3.31.0 → 3.33.3

package/commands/autopilot-front.js

@@ -0,0 +1,273 @@
+// atris autopilot: point it at the workspace and it keeps going.
+// Each leg picks the most logical work — a moving mission first, then a
+// member choosing useful work, then a self-chosen mission — and drives it
+// through the mission runtime. It loops until stopped:
+//   atris autopilot stop   (from any terminal)  or Ctrl-C here.
+// The old suggest→justify→execute loop lives on behind `atris autopilot --legacy`.
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { pickRunnableMission, runBudgetSeconds } = require('./run-front');
+
+const CLI_PATH = path.join(__dirname, '..', 'bin', 'atris.js');
+const DEFAULT_LEG_WALL_SECONDS = 3600;
+const LEG_TICKS = 12;
+const FAST_FAIL_SECONDS = 30;
+const MAX_FAST_FAILS = 5;
+
+function statePath(root) { return path.join(root, '.atris', 'state', 'autopilot.json'); }
+function stopPath(root) { return path.join(root, '.atris', 'state', 'autopilot.stop'); }
+
+function readState(root) {
+  try { return JSON.parse(fs.readFileSync(statePath(root), 'utf8')); } catch { return null; }
+}
+
+function writeState(root, state) {
+  fs.mkdirSync(path.dirname(statePath(root)), { recursive: true });
+  fs.writeFileSync(statePath(root), `${JSON.stringify(state, null, 2)}\n`);
+}
+
+function clearState(root) {
+  try { fs.unlinkSync(statePath(root)); } catch {}
+}
+
+function stopRequested(root) { return fs.existsSync(stopPath(root)); }
+function requestStop(root) {
+  fs.mkdirSync(path.dirname(stopPath(root)), { recursive: true });
+  fs.writeFileSync(stopPath(root), `${new Date().toISOString()}\n`);
+}
+function clearStop(root) { try { fs.unlinkSync(stopPath(root)); } catch {} }
+
+function pidAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+function readValueFlag(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 && index + 1 < args.length ? args[index + 1] : null;
+}
+
+function positiveNumber(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+// Most logical member: the one who owns the newest mission, else the first
+// member on the team. Null when the workspace has no members yet.
+function pickMember(root, preferredOwner = '') {
+  let members = [];
+  try {
+    const { findAllMembers } = require('./member');
+    members = findAllMembers(path.join(root, 'atris', 'team')) || [];
+  } catch {
+    return null;
+  }
+  if (!members.length) return null;
+  const owner = String(preferredOwner || '').trim().toLowerCase();
+  if (owner) {
+    const owned = members.find((member) => String(member?.name || '').trim().toLowerCase() === owner);
+    if (owned) return owned.name;
+  }
+  return members[0]?.name || null;
+}
+
+function newestMissionOwner(root) {
+  let map;
+  try { map = require('./mission').loadMissionMap(root); } catch { return ''; }
+  const newest = Array.from(map.values())
+    .sort((a, b) => String(b?.updated_at || b?.created_at || '').localeCompare(String(a?.updated_at || a?.created_at || '')));
+  return newest[0]?.owner || '';
+}
+
+function legPlan(root, legWallSeconds) {
+  const mission = pickRunnableMission(root);
+  if (mission) {
+    return {
+      kind: 'mission',
+      label: `mission ${mission.id}: ${mission.objective}`,
+      args: ['mission', 'run', mission.id, '--max-ticks', String(LEG_TICKS), '--max-wall', String(legWallSeconds), '--complete-on-pass'],
+    };
+  }
+  const member = pickMember(root, newestMissionOwner(root));
+  if (member) {
+    // --runner atris2: member run defaults to codex_goal, which waits for a
+    // live Codex session; a headless leg would tick it without doing work.
+    return {
+      kind: 'member',
+      label: `member ${member} chooses useful work`,
+      args: ['member', 'run', member, '--runner', 'atris2', '--minutes', String(Math.max(5, Math.round(legWallSeconds / 60)))],
+    };
+  }
+  return {
+    kind: 'auto-mission',
+    label: 'self-chosen mission from Atris state',
+    args: [
+      'mission', 'run',
+      'Choose one bounded useful task from Atris state, complete it, and show plain proof.',
+      '--owner', 'mission-lead',
+      '--runner', 'atris2',
+      '--max-ticks', String(LEG_TICKS),
+      '--max-wall', String(legWallSeconds),
+    ],
+  };
+}
+
+function driveLeg(root, legArgs, current) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [CLI_PATH, ...legArgs], { cwd: root, stdio: 'inherit' });
+    current.child = child;
+    // Stop fast: a stop file written by `atris autopilot stop` in another
+    // terminal terminates the running leg, not just the loop between legs.
+    const poll = setInterval(() => {
+      if (stopRequested(root)) { try { child.kill('SIGTERM'); } catch {} }
+    }, 2000);
+    if (poll.unref) poll.unref();
+    const finish = (code) => {
+      clearInterval(poll);
+      current.child = null;
+      resolve(Number.isFinite(code) ? code : 1);
+    };
+    child.on('error', () => finish(1));
+    child.on('close', finish);
+  });
+}
+
+function sleep(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
+
+function autopilotStop(root = process.cwd()) {
+  requestStop(root);
+  const state = readState(root);
+  if (state && pidAlive(state.pid)) {
+    try { process.kill(state.pid, 'SIGTERM'); } catch {}
+    console.log(`Stopping autopilot (pid ${state.pid}).`);
+  } else {
+    console.log('No live autopilot process; stop marker written so the next start clears it.');
+  }
+  return 0;
+}
+
+function autopilotStatus(root = process.cwd()) {
+  const state = readState(root);
+  if (!state) { console.log('Autopilot is not running.'); return 0; }
+  const alive = pidAlive(state.pid);
+  console.log(`Autopilot ${alive ? 'running' : 'not running (stale state)'} — pid ${state.pid}, started ${state.started_at}, legs ${state.legs || 0}`);
+  if (state.current_leg) console.log(`Current leg: ${state.current_leg}`);
+  if (!alive) clearState(root);
+  return 0;
+}
+
+function showFrontHelp() {
+  console.log('');
+  console.log('Usage: atris autopilot [options]');
+  console.log('');
+  console.log('Keeps the workspace moving: picks the most logical mission or member,');
+  console.log('drives it through the mission runtime, then picks the next one.');
+  console.log('Runs until you stop it.');
+  console.log('');
+  console.log('Options:');
+  console.log('  --minutes N | --hours N   Total budget (default: unlimited)');
+  console.log('  --leg-wall N              Seconds per leg (default: 3600)');
+  console.log('  --once                    Run a single leg, then exit');
+  console.log('  --legacy                  Old suggest→justify→execute loop');
+  console.log('');
+  console.log('Control:');
+  console.log('  atris autopilot stop      Stop fast, from any terminal');
+  console.log('  atris autopilot status    Show what the loop is doing');
+  console.log('');
+}
+
+async function autopilotFront(args = []) {
+  const root = process.cwd();
+  if (args[0] === 'stop') return autopilotStop(root);
+  if (args[0] === 'status') return autopilotStatus(root);
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') { showFrontHelp(); return 0; }
+
+  const existing = readState(root);
+  if (existing && pidAlive(existing.pid) && existing.pid !== process.pid) {
+    console.log(`Autopilot already running (pid ${existing.pid}). Stop it first: atris autopilot stop`);
+    return 1;
+  }
+
+  clearStop(root);
+  const budgetSeconds = runBudgetSeconds(args);
+  const legWallDefault = positiveNumber(readValueFlag(args, '--leg-wall')) || DEFAULT_LEG_WALL_SECONDS;
+  const once = args.includes('--once');
+  const startedAt = Date.now();
+  const state = { pid: process.pid, started_at: new Date().toISOString(), legs: 0 };
+  writeState(root, state);
+
+  const current = { child: null };
+  // `autopilot stop` SIGTERMs this pid directly, so the farewell must print
+  // here — the signal always beats the loop's own stop-file check.
+  const onSignal = () => {
+    if (current.child) { try { current.child.kill('SIGTERM'); } catch {} }
+    const reason = stopRequested(root) ? 'stop requested' : 'interrupted';
+    console.log(`\nAutopilot off (${reason}). Legs run: ${state.legs}.`);
+    clearState(root);
+    clearStop(root);
+    process.exit(130);
+  };
+  process.on('SIGINT', onSignal);
+  process.on('SIGTERM', onSignal);
+
+  console.log('Autopilot on. Stop anytime: Ctrl-C here, or `atris autopilot stop` anywhere.');
+
+  let fastFails = 0;
+  let stopReason = '';
+  while (true) {
+    if (stopRequested(root)) { stopReason = 'stop requested'; break; }
+    const elapsed = Math.round((Date.now() - startedAt) / 1000);
+    if (budgetSeconds && elapsed >= budgetSeconds) { stopReason = 'budget spent'; break; }
+    const legWall = budgetSeconds ? Math.min(legWallDefault, budgetSeconds - elapsed) : legWallDefault;
+
+    const plan = legPlan(root, Math.max(60, legWall));
+    state.legs += 1;
+    state.current_leg = plan.label;
+    state.updated_at = new Date().toISOString();
+    writeState(root, state);
+    console.log(`\nautopilot leg ${state.legs}: ${plan.label}`);
+
+    const legStarted = Date.now();
+    const code = await driveLeg(root, plan.args, current);
+    state.last_exit = code;
+    writeState(root, state);
+
+    if (once) { stopReason = 'single leg (--once)'; break; }
+    if (stopRequested(root)) { stopReason = 'stop requested'; break; }
+
+    // A leg that finishes in seconds means no real work happened — a crash,
+    // or a degenerate mission whose ticks record instantly (exit 0). Either
+    // way, back off and stop instead of hot-looping on it.
+    const legSeconds = (Date.now() - legStarted) / 1000;
+    if (legSeconds < FAST_FAIL_SECONDS) {
+      fastFails += 1;
+      if (fastFails >= MAX_FAST_FAILS) {
+        stopReason = `${MAX_FAST_FAILS} fast legs in a row (${code === 0 ? 'no progress' : 'failures'})`;
+        break;
+      }
+      await sleep(code === 0 ? 5000 : 15000);
+    } else {
+      fastFails = 0;
+      await sleep(2000);
+    }
+  }
+
+  clearStop(root);
+  clearState(root);
+  console.log(`\nAutopilot off (${stopReason}). Legs run: ${state.legs}.`);
+  return stopReason.includes('fast legs') ? 1 : 0;
+}
+
+module.exports = {
+  autopilotFront,
+  autopilotStop,
+  autopilotStatus,
+  legPlan,
+  pickMember,
+  stopRequested,
+  requestStop,
+  clearStop,
+  readState,
+  writeState,
+};

package/commands/engine.js

@@ -0,0 +1,299 @@
+'use strict';
+
+// atris engine: bring any intelligence.
+// Every installed headless coding CLI is a swappable worker behind one
+// contract (bounded prompt in, verified proof out, engines never
+// self-certify). This command shows the roster, flips the default, and the
+// same names ride --engine on mission run / autopilot / run.
+//
+//   atris engine            roster + current default
+//   atris engine cursor     make cursor the default engine here
+//   atris engine reset      back to the house default (atris-fast)
+//
+// The default persists to .atris/engine.json. Per-run flags and
+// ATRIS_RUNNER_PROFILE always beat the file.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const {
+  RUNNER_PROFILE_DEFS,
+  RUNNER_PROFILE_ALIASES,
+  RUNNER_PROFILE_NAMES,
+  buildRunnerCommand,
+} = require('../lib/runner-command');
+
+const HOUSE_ENGINE = 'atris-fast';
+
+function engineFile(root = process.cwd()) {
+  return path.join(root, '.atris', 'engine.json');
+}
+
+function binInstalled(bin) {
+  const safe = String(bin || '').replace(/[^A-Za-z0-9_.-]/g, '');
+  if (!safe) return false;
+  const probe = spawnSync('sh', ['-c', `command -v ${safe}`], { encoding: 'utf8' });
+  return probe.status === 0 && Boolean(String(probe.stdout || '').trim());
+}
+
+function canonicalEngineName(name) {
+  const trimmed = String(name || '').trim();
+  if (!trimmed) return '';
+  if (RUNNER_PROFILE_DEFS[trimmed]) return trimmed;
+  if (RUNNER_PROFILE_ALIASES[trimmed]) return RUNNER_PROFILE_ALIASES[trimmed];
+  return '';
+}
+
+function readSavedEngine(root = process.cwd()) {
+  try {
+    const saved = JSON.parse(fs.readFileSync(engineFile(root), 'utf8'));
+    return canonicalEngineName(saved.default);
+  } catch {
+    return '';
+  }
+}
+
+// The default engine for this workspace, in precedence order:
+// env (per-run flags land here) -> .atris/engine.json -> house default.
+// The house default is our own intelligence when it is installed.
+function resolveDefaultEngine(root = process.cwd()) {
+  const env = canonicalEngineName(process.env.ATRIS_RUNNER_PROFILE);
+  if (env) return { name: env, source: 'env' };
+  const saved = readSavedEngine(root);
+  if (saved) return { name: saved, source: 'saved' };
+  if (binInstalled(RUNNER_PROFILE_DEFS[HOUSE_ENGINE].bin)) return { name: HOUSE_ENGINE, source: 'house' };
+  const fallback = RUNNER_PROFILE_NAMES.find((name) => binInstalled(RUNNER_PROFILE_DEFS[name].bin));
+  return fallback ? { name: fallback, source: 'detected' } : { name: HOUSE_ENGINE, source: 'none' };
+}
+
+function roster(root = process.cwd()) {
+  const current = resolveDefaultEngine(root);
+  return RUNNER_PROFILE_NAMES.map((name) => ({
+    name,
+    bin: RUNNER_PROFILE_DEFS[name].bin,
+    installed: binInstalled(RUNNER_PROFILE_DEFS[name].bin),
+    default: name === current.name,
+  }));
+}
+
+function setEngine(name, root = process.cwd()) {
+  const canonical = canonicalEngineName(name);
+  if (!canonical) {
+    throw new Error(`Unknown engine "${name}". Known engines: ${RUNNER_PROFILE_NAMES.join(', ')}`);
+  }
+  const file = engineFile(root);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify({ default: canonical, set_at: new Date().toISOString() }, null, 2)}\n`);
+  return canonical;
+}
+
+function resetEngine(root = process.cwd()) {
+  try { fs.unlinkSync(engineFile(root)); return true; } catch { return false; }
+}
+
+function printRoster(root) {
+  const list = roster(root);
+  const found = list.filter((e) => e.installed).length;
+  const current = resolveDefaultEngine(root);
+  console.log('');
+  console.log(`  engines — ${found} intelligence${found === 1 ? '' : 's'} found`);
+  console.log('');
+  for (const engine of list) {
+    const mark = engine.default ? '→' : ' ';
+    const state = engine.installed ? 'ready' : 'not installed';
+    console.log(`  ${mark} ${engine.name.padEnd(12)} ${state}`);
+  }
+  console.log('');
+  console.log(`  default: ${current.name}${current.source === 'saved' ? ' (set here)' : current.source === 'env' ? ' (this session)' : ''}`);
+  console.log(`  switch:  atris engine <name>   ·   one run: --engine <name> on mission run / autopilot / run`);
+  console.log('');
+}
+
+// Preflight: run one engine CLI headless with a reply-OK prompt and report
+// pass/fail. A dead login, missing binary, or hung spawn is a one-command
+// diagnosis instead of a failed overnight flight. `name` is canonical.
+const PROBE_PROMPT = 'Reply with exactly the two characters: OK';
+// Real engines think before replying: cursor measured at ~68s for a one-word
+// answer on 2026-07-02. 30s produced a false FAIL on a healthy engine.
+const PROBE_DEFAULT_TIMEOUT_MS = 120000;
+
+function probeEngine(name, { timeout = PROBE_DEFAULT_TIMEOUT_MS } = {}) {
+  const def = RUNNER_PROFILE_DEFS[name];
+  if (!binInstalled(def.bin)) {
+    return {
+      engine: name,
+      bin: def.bin,
+      pass: false,
+      reason: 'not-installed',
+      message: `${def.bin} CLI not installed`,
+      stdout: '',
+      stderr: '',
+      durationMs: 0,
+    };
+  }
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-engine-probe-'));
+  const promptFile = path.join(tmpDir, 'prompt.txt');
+  fs.writeFileSync(promptFile, `${PROBE_PROMPT}\n`);
+  let cmd;
+  const prevProfile = process.env.ATRIS_RUNNER_PROFILE;
+  process.env.ATRIS_RUNNER_PROFILE = name;
+  try {
+    cmd = buildRunnerCommand({ promptFile });
+  } finally {
+    if (prevProfile === undefined) delete process.env.ATRIS_RUNNER_PROFILE;
+    else process.env.ATRIS_RUNNER_PROFILE = prevProfile;
+  }
+  const start = Date.now();
+  let res;
+  try {
+    res = spawnSync('sh', ['-c', cmd], { encoding: 'utf8', timeout });
+  } catch (err) {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    return {
+      engine: name,
+      bin: def.bin,
+      pass: false,
+      reason: 'spawn-error',
+      message: String(err && err.message ? err.message : err),
+      stdout: '',
+      stderr: '',
+      durationMs: Date.now() - start,
+    };
+  }
+  const durationMs = Date.now() - start;
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+  const stdout = res.stdout || '';
+  const stderr = res.stderr || '';
+  const timedOut = res.status === null && Boolean(res.signal) && String(res.signal).toLowerCase().includes('term');
+  const combined = `${stdout}\n${stderr}`.trim();
+  const ok = res.status === 0 && /OK/i.test(combined);
+  let reason;
+  if (ok) reason = 'ok';
+  else if (timedOut) reason = 'timeout';
+  else if (res.status !== 0 && res.status !== null) reason = 'bad-exit';
+  else if (!/OK/i.test(combined)) reason = 'no-ok';
+  else reason = 'unknown';
+  return {
+    engine: name,
+    bin: def.bin,
+    pass: ok,
+    reason,
+    message: ok
+      ? 'responded OK'
+      : (timedOut ? `no reply within ${timeout}ms` : `did not reply OK (exit ${res.status}, signal ${res.signal})`),
+    stdout,
+    stderr,
+    durationMs,
+  };
+}
+
+function runEngineTest(targets, { json, root } = {}) {
+  let enginesToTest;
+  if (targets && targets.length) {
+    enginesToTest = targets.map((n) => {
+      const c = canonicalEngineName(n);
+      if (!c) {
+        throw new Error(`Unknown engine "${n}". Known engines: ${RUNNER_PROFILE_NAMES.join(', ')}`);
+      }
+      return c;
+    });
+  } else {
+    enginesToTest = RUNNER_PROFILE_NAMES.filter((n) => binInstalled(RUNNER_PROFILE_DEFS[n].bin));
+    if (!enginesToTest.length) {
+      if (json) {
+        console.log(JSON.stringify({ ok: false, results: [], summary: { pass: 0, fail: 0 } }, null, 2));
+      } else {
+        console.error('\n  no installed engines to test\n');
+      }
+      return 1;
+    }
+  }
+  const results = enginesToTest.map((name) => probeEngine(name));
+  const failures = results.filter((r) => !r.pass);
+  const passed = results.length - failures.length;
+  if (json) {
+    console.log(JSON.stringify({
+      ok: failures.length === 0,
+      results,
+      summary: { pass: passed, fail: failures.length },
+    }, null, 2));
+  } else {
+    console.log('');
+    for (const r of results) {
+      const mark = r.pass ? '✓' : '✗';
+      const line = r.pass
+        ? `  ${mark} ${r.engine.padEnd(12)} pass — ${r.message} (${r.durationMs}ms)`
+        : `  ${mark} ${r.engine.padEnd(12)} FAIL — ${r.message}`;
+      if (r.pass) console.log(line);
+      else console.error(line);
+    }
+    console.log('');
+    if (failures.length) {
+      console.error(`  ${failures.length} engine${failures.length === 1 ? '' : 's'} failed: ${failures.map((f) => f.engine).join(', ')}`);
+      console.error(`  fix the login/binary, then re-run: atris engine test${targets && targets.length ? ' ' + targets.join(' ') : ''}`);
+    } else {
+      console.log(`  all engines responded — clear for flight`);
+    }
+    console.log('');
+  }
+  return failures.length ? 1 : 0;
+}
+
+function engineCommand(args = []) {
+  const json = args.includes('--json');
+  const positional = args.filter((a) => !a.startsWith('--'));
+  const sub = (positional[0] || '').trim();
+  const root = process.cwd();
+
+  if (sub === 'test') {
+    return runEngineTest(positional.slice(1), { json, root });
+  }
+
+  if (!sub || sub === 'list' || sub === 'status') {
+    if (json) {
+      const current = resolveDefaultEngine(root);
+      console.log(JSON.stringify({ engines: roster(root), default: current.name, source: current.source }, null, 2));
+      return 0;
+    }
+    printRoster(root);
+    return 0;
+  }
+
+  if (sub === 'reset' || sub === 'off') {
+    const removed = resetEngine(root);
+    console.log(removed
+      ? `\n  default engine reset — back to ${resolveDefaultEngine(root).name}\n`
+      : `\n  nothing to reset — no engine was set here\n`);
+    return 0;
+  }
+
+  if (sub === 'help') {
+    console.log('\n  atris engine            roster + current default\n  atris engine <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\n  atris engine reset      back to the house default\n  --engine <name>         one run on that engine (mission run / autopilot / run)\n');
+    return 0;
+  }
+
+  // atris engine <name> — flip the default.
+  const canonical = setEngine(sub, root);
+  const def = RUNNER_PROFILE_DEFS[canonical];
+  const installed = binInstalled(def.bin);
+  console.log('');
+  console.log(`  default engine: ${canonical}`);
+  if (!installed) console.log(`  heads up: its CLI (${def.bin}) is not installed here yet — runs will fail until it is.`);
+  console.log(`  every mission run / autopilot / run tick now rides it. one-off: --engine <name>. undo: atris engine reset`);
+  console.log('');
+  return 0;
+}
+
+module.exports = {
+  engineCommand,
+  resolveDefaultEngine,
+  canonicalEngineName,
+  readSavedEngine,
+  setEngine,
+  resetEngine,
+  roster,
+  probeEngine,
+  runEngineTest,
+  HOUSE_ENGINE,
+};

package/commands/init.js

@@ -660,6 +660,20 @@ Do not rely on chat context. Put the task, file pointers, and proof on disk.
 Do not write new operating doctrine here first; add it to Atris policy, skills,
 wiki, or \`atris/atris.md\`, then regenerate this adapter if needed.
 
+## How to Report
+
+The human approves work by reading, so how you report IS the product. Rules:
+
+- **Results are capabilities.** State what someone can do now that they
+  couldn't before, then what it means for them or the business. Tests are one
+  word ("verified"); the meaning is the sentence. Shape: "We did X, so you can
+  now Y." Detail stays under the hood; the reader asks if they want more.
+- **Three results, air between them, rest on ask.** A report fits one screen
+  with no scrolling. Reading it is one glance.
+- **Stake first, then the move.** "Agents burn tokens hand-rolling parsers:
+  add one shared view." Plain words; flags, ids, and identifiers belong in the
+  body, never the headline.
+
 Native goals and task approval are separate gates:
 
 \`\`\`text
@@ -980,6 +994,13 @@ Read atris/MAP.md. Begin iteration 1.`;
     console.log('✓ Created .claude/settings.json (auto-loads Atris on startup)');
   }
 
+  // Co-author trailer: commits in this workspace credit Atris, same as Claude/Cursor do
+  try {
+    const { installSignHook } = require('./sign');
+    const { already } = installSignHook();
+    if (!already) console.log('✓ Installed co-author hook (commits credit Atris — remove with `atris sign off`)');
+  } catch {} // not a git repo — skip quietly
+
   // Update root CLAUDE.md with Atris block (prepend with markers)
   const rootClaudeMd = path.join(process.cwd(), 'CLAUDE.md');
   const atrisBlock = `<!-- ATRIS:START - Auto-generated, do not edit -->