atris 3.31.0 → 3.32.0

package/commands/autoland.js

@@ -6,6 +6,7 @@ const os = require('os');
 const { spawnSync } = require('child_process');
 
 const autoland = require('../lib/autoland');
+const { operatorReady, hasAgentJargon } = autoland;
 
 function repoRoot(cwd = process.cwd()) {
   const result = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8' });
@@ -17,6 +18,25 @@ function projectName(root) {
   return path.basename(root);
 }
 
+// The digest's "next, if you agree" section: top candidate moves from Atris
+// state, each with the member best suited to own it. Moves that can't explain
+// themselves are counted, not shown. Never blocks the digest.
+function digestNextMoves(root) {
+  try {
+    const { nextMoves } = require('../lib/next-moves');
+    const { resolveFunctionalOwner } = require('../lib/functional-owner');
+    const all = (nextMoves(root, 5) || []).filter((move) => move && move.title);
+    const ready = all.filter((move) => operatorReady(move.title)).slice(0, 3).map((move) => {
+      let owner = null;
+      try { owner = resolveFunctionalOwner({ title: move.title, root })?.owner || null; } catch {}
+      return { title: move.title, owner };
+    });
+    return { moves: ready, unexplained: all.length - ready.length };
+  } catch {
+    return { moves: [], unexplained: 0 };
+  }
+}
+
 function flag(args, name, fallback = '') {
   const idx = args.indexOf(name);
   if (idx === -1) return fallback;
@@ -24,9 +44,11 @@ function flag(args, name, fallback = '') {
 }
 
 function runOwnCli(root, cliArgs) {
-  const bin = path.join(root, 'bin', 'atris.js');
-  const argv = fs.existsSync(bin) ? [process.execPath, [bin, ...cliArgs]] : ['atris', [cliArgs].flat()];
-  const result = spawnSync(argv[0], argv[1], { cwd: root, encoding: 'utf8', timeout: 300000 });
+  // Always spawn the bin this module shipped with. Resolving through the
+  // target root or a global `atris` breaks whenever the tick runs a project
+  // that isn't the CLI repo on a machine without a global install (CI, cron).
+  const bin = path.resolve(__dirname, '..', 'bin', 'atris.js');
+  const result = spawnSync(process.execPath, [bin, ...cliArgs], { cwd: root, encoding: 'utf8', timeout: 300000 });
   return { status: result.status, stdout: String(result.stdout || ''), stderr: String(result.stderr || '') };
 }
 
@@ -186,6 +208,7 @@ function runDigest(root, args, { forceSend = false } = {}) {
     waiting: autoland.waitingOnHuman(tasks),
     landed: landSummarySafe(root),
     project: projectName(root),
+    nextMoves: digestNextMoves(root),
   });
   console.log(text);
   // the full story: what each piece actually was, in its own words
@@ -195,10 +218,15 @@ function runDigest(root, args, { forceSend = false } = {}) {
     return t && (t.review?.landing?.happened || t.metadata?.landing_happened);
   });
   if (storied.length > 0) {
-    console.log('');
+    let printedStoryHeader = false;
     for (const item of storied) {
       const t = byRef.get(item.ref);
       const happened = String(t.review?.landing?.happened || t.metadata?.landing_happened || '').replace(/\s+/g, ' ').slice(0, 160);
+      if (!operatorReady(happened)) continue;
+      if (!printedStoryHeader) {
+        console.log('');
+        printedStoryHeader = true;
+      }
       console.log(`  ${item.ref}  ${happened}`);
     }
   }
@@ -221,7 +249,22 @@ function runTick(root, args) {
     return 0;
   }
 
-  // 1. land what is eligible — the policy is the standing authorization
+  // 1. certify what has executable proof — re-run the runnable check named in
+  // each Review proof as a second actor. Without this the tick only lands rows
+  // some always-on mission happened to certify, and everything else waits on a
+  // human who never needed to look. Denied lanes and check-less proofs still wait.
+  if (policy.drain_reviews !== false) {
+    const certify = runOwnCli(root, ['task', 'certify-verified', '--json']);
+    try {
+      const parsed = JSON.parse(certify.stdout);
+      receipt.reviews_certified = parsed.certified ?? 0;
+      if (parsed.ok !== true) receipt.certify_error = 'certify-verified failed';
+    } catch {
+      receipt.certify_error = certify.stderr.slice(0, 200) || 'certify-verified output unreadable';
+    }
+  }
+
+  // 2. land what is eligible — the policy is the standing authorization
   const cliArgs = ['task', 'auto-accept-certified', '--json', '--limit', '12'];
   if (policy.strict_verify !== false) cliArgs.push('--strict-verify');
   const accept = runOwnCli(root, cliArgs);
@@ -232,7 +275,23 @@ function runTick(root, args) {
     receipt.accept_error = accept.stderr.slice(0, 200) || 'auto-accept output unreadable';
   }
 
-  // 2. alarm on anything waiting on a human past the line
+  // 2b. tell the operator the moment something lands: one text, one landing
+  // sentence per piece (the day-one PM sentence written at finish time),
+  // capped at three with the rest counted. Off with live_updates: false.
+  const tasksForLive = readProjection(root);
+  if (receipt.landed.length > 0 && policy.imessage_to && policy.live_updates !== false) {
+    const text = autoland.composeLiveUpdate({
+      landedRefs: receipt.landed,
+      tasks: tasksForLive,
+      project: projectName(root),
+    });
+    if (text) {
+      const sent = autoland.sendImessage(root, policy.imessage_to, text);
+      receipt.live_update_sent = sent.ok;
+    }
+  }
+
+  // 3. alarm on anything waiting on a human past the line
   const state = autoland.readState(root);
   const tasks = readProjection(root);
   const waiting = autoland.waitingOnHuman(tasks);
@@ -247,7 +306,7 @@ function runTick(root, args) {
     }
   }
 
-  // 3. daily digest at the configured hour
+  // 4. daily digest at the configured hour
   const today = new Date().toISOString().slice(0, 10);
   const digestHour = Number(policy.digest_hour ?? autoland.DEFAULT_DIGEST_HOUR);
   if (new Date().getHours() === digestHour && state.last_digest_date !== today) {
@@ -256,6 +315,7 @@ function runTick(root, args) {
       waiting,
       landed: landSummarySafe(root),
       project: projectName(root),
+      nextMoves: digestNextMoves(root),
     });
     if (policy.imessage_to) {
       const sent = autoland.sendImessage(root, policy.imessage_to, text);
@@ -264,7 +324,7 @@ function runTick(root, args) {
     receipt.digest_text = text;
     state.last_digest_date = today;
 
-    // 4. once a day, keep the receipt shelf lean: compress old run receipts
+    // 5. once a day, keep the receipt shelf lean: compress old run receipts
     // into the manifest and drop unreferenced clutter, newest 200 kept.
     const prune = runOwnCli(root, ['mission', 'prune-runs', '--apply', '--days', '14', '--keep-newest', '200', '--json']);
     try {
@@ -278,7 +338,7 @@ function runTick(root, args) {
 
   if (json) console.log(JSON.stringify(receipt));
   else {
-    console.log(`autoland tick: ${receipt.landed.length} landed${receipt.landed.length ? ` (${receipt.landed.join(', ')})` : ''}, ${receipt.alarms} alarms, digest ${receipt.digest_sent ? 'sent' : 'not due'}`);
+    console.log(`autoland tick: ${receipt.reviews_certified ?? 0} reviews certified, ${receipt.landed.length} landed${receipt.landed.length ? ` (${receipt.landed.join(', ')})` : ''}, ${receipt.alarms} alarms, digest ${receipt.digest_sent ? 'sent' : 'not due'}`);
   }
   return 0;
 }
@@ -316,4 +376,4 @@ function autolandCommand(args = []) {
   return 1;
 }
 
-module.exports = { autolandCommand };
+module.exports = { autolandCommand, operatorReady, hasAgentJargon };

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/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 -->

package/commands/member.js

@@ -611,6 +611,36 @@ function startMemberRunMission(name, missionText, args = []) {
   }
 }
 
+// atris member ping <name> "<message>" — talk to an always-on member mid-run.
+// Finds the member's most recently touched live mission (including --worktree
+// missions in sibling checkouts) and leaves the note its next tick consumes.
+function memberPing(name, ...args) {
+  if (!name || name === '--help' || name === '-h') {
+    console.log('Usage: atris member ping <name> "<message>" [--json]');
+    console.log('Leaves a note on the member\'s active mission; the next tick reads it as operator direction.');
+    return;
+  }
+  const text = args.filter((a) => !a.startsWith('--')).join(' ').trim();
+  if (!text) {
+    console.error('atris member ping: message required');
+    process.exit(2);
+  }
+  const missionMod = require('./mission');
+  const terminal = new Set(['complete', 'stopped', 'failed']);
+  const candidates = [
+    ...missionMod.listMissions(process.cwd()),
+    ...missionMod.listWorktreeRollupMissions(process.cwd()),
+  ]
+    .filter((m) => m && m.owner === name && !terminal.has(m.status))
+    .sort((a, b) => String(b.updated_at || b.created_at || '').localeCompare(String(a.updated_at || a.created_at || '')));
+  if (!candidates.length) {
+    console.error(`atris member ping: no live mission owned by "${name}". Start one: atris member run ${name} "<objective>"`);
+    process.exit(1);
+  }
+  const passthrough = args.filter((a) => a.startsWith('--'));
+  return missionMod.pingMission([candidates[0].id, text, ...passthrough]);
+}
+
 function memberRun(name, ...args) {
   if (!name || name === '--help' || name === '-h' || hasFlag(args, '--help') || hasFlag(args, '-h')) {
     console.log('Usage: atris member run <name> ["mission text"] [--minutes N|--hours N] [--json]');
@@ -8063,6 +8093,8 @@ async function memberCommand(subcommand, ...args) {
       return memberWake(args[0], ...args.slice(1));
     case 'run':
       return memberRun(args[0], ...args.slice(1));
+    case 'ping':
+      return memberPing(args[0], ...args.slice(1));
     case 'loop':
       return memberLoop(args[0], ...args.slice(1));
     case 'alive':