atris 3.30.12 → 3.32.0

package/commands/play.js

@@ -417,7 +417,7 @@ function modeState(args = []) {
       prompt: latestMessage(events),
     } : null,
     proof_recipe: proofRecipe(),
-    xp_rule: 'AgentXP lands only after a useful artifact has verifier proof and review accepts it.',
+    xp_rule: 'AgentXP is awarded only after a useful artifact has verifier proof and accepted review.',
     global_sync_rule: AGENTXP_GLOBAL_SYNC_RULE,
     leaderboard_url: AGENTXP_LEADERBOARD_URL,
     next_commands: commandList,

package/commands/pulse.js

@@ -18,6 +18,7 @@ const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const pulse = require('../lib/pulse');
+const { DEFAULT_CLAUDE_RUNNER_MODEL } = require('../lib/runner-command');
 
 function hasFlag(args, name) {
   return args.includes(name);
@@ -51,6 +52,7 @@ Options:
   --verify "<cmd>"       Verifier for changed-work ticks (default: npm test)
   --cadence "<cron>"     Cron cadence for install
   --days <n>             Auto-expire installed heartbeat after n days
+  --hours <n>            Auto-expire installed heartbeat after n hours
   --model <id>           Runner model alias/id for installed heartbeat
   --runner-profile <n>   Runner profile for installed heartbeat (e.g. atris-fast)
   --runner-bin <path>    Runner binary for installed heartbeat
@@ -197,6 +199,26 @@ function tickCommand(args, root = process.cwd()) {
   }
 
   const tickIndex = pulse.nextTickIndex(root);
+  const signalExitCode = { SIGINT: 130, SIGTERM: 143 };
+  let interrupted = false;
+  const finishInterrupted = (signal) => {
+    if (interrupted) return;
+    interrupted = true;
+    try {
+      pulse.appendPulseReceipt(root, pulse.buildInterruptedPulseReceipt({
+        tickIndex,
+        signal,
+        startedAt,
+        prevTickStale: priorStale.stale,
+      }));
+    } catch {}
+    try {
+      pulse.releaseLock(root);
+    } catch {}
+    process.exit(signalExitCode[signal] || 1);
+  };
+  process.once('SIGINT', finishInterrupted);
+  process.once('SIGTERM', finishInterrupted);
 
   // 'started' receipt - if the tick dies after this, the orphan surfaces as a ghost.
   pulse.appendPulseReceipt(root, pulse.buildPulseReceipt({
@@ -260,7 +282,7 @@ function tickCommand(args, root = process.cwd()) {
         what,
         changedFiles,
         elapsedMs,
-        model: process.env.ATRIS_RUNNER_MODEL || process.env.ATRIS_CLAUDE_MODEL || 'opus',
+        model: process.env.ATRIS_RUNNER_MODEL || process.env.ATRIS_CLAUDE_MODEL || DEFAULT_CLAUDE_RUNNER_MODEL,
       }));
       scorecardWritten = true;
     }
@@ -301,6 +323,8 @@ function tickCommand(args, root = process.cwd()) {
     if (!asJson) process.stdout.write(`pulse tick #${tickIndex} crashed: ${out.error}\n`);
     return emit(out, asJson);
   } finally {
+    process.removeListener('SIGINT', finishInterrupted);
+    process.removeListener('SIGTERM', finishInterrupted);
     pulse.releaseLock(root);
   }
 }
@@ -372,14 +396,45 @@ function resolveEngineBinDirs(extraBins = []) {
 
 function installCommand(args, root = process.cwd()) {
   const asJson = wantsJson(args);
-  const cron = readFlag(args, '--cadence', pulse.DEFAULT_CADENCE_CRON);
-  const days = Math.max(1, Number(readFlag(args, '--days', '7')) || 7);
+  const cadenceInput = readFlag(args, '--cadence', pulse.DEFAULT_CADENCE_CRON);
+  let cron;
+  try {
+    cron = pulse.normalizeCronCadence(cadenceInput);
+  } catch (error) {
+    const out = {
+      ok: false,
+      action: 'pulse_install',
+      reason: 'invalid_cadence',
+      detail: error && error.message ? error.message : String(error),
+      cadence: cadenceInput,
+    };
+    if (!asJson) process.stdout.write(`pulse install failed: ${out.detail}\n`);
+    return emit(out, asJson);
+  }
+  let expiry;
+  try {
+    expiry = pulse.normalizeExpiryDuration({
+      hours: readFlag(args, '--hours', null),
+      days: readFlag(args, '--days', '7'),
+    });
+  } catch (error) {
+    const out = {
+      ok: false,
+      action: 'pulse_install',
+      reason: 'invalid_expiry',
+      detail: error && error.message ? error.message : String(error),
+      hours: readFlag(args, '--hours', null),
+      days: readFlag(args, '--days', '7'),
+    };
+    if (!asJson) process.stdout.write(`pulse install failed: ${out.detail}\n`);
+    return emit(out, asJson);
+  }
   const verifyCmd = readFlag(args, '--verify', 'npm test');
-  const model = readFlag(args, '--model', process.env.ATRIS_RUNNER_MODEL || process.env.ATRIS_CLAUDE_MODEL || 'opus');
+  const model = readFlag(args, '--model', process.env.ATRIS_RUNNER_MODEL || process.env.ATRIS_CLAUDE_MODEL || DEFAULT_CLAUDE_RUNNER_MODEL);
   const runnerProfile = readFlag(args, '--runner-profile', process.env.ATRIS_RUNNER_PROFILE || '');
   const runnerBin = readFlag(args, '--runner-bin', process.env.ATRIS_RUNNER_BIN || process.env.ATRIS_CLAUDE_BIN || '');
   const runnerCommandTemplate = readFlag(args, '--runner-template', process.env.ATRIS_RUNNER_COMMAND_TEMPLATE || process.env.ATRIS_CLAUDE_COMMAND_TEMPLATE || '');
-  const deadlineEpoch = Math.floor(Date.now() / 1000) + days * 86400;
+  const deadlineEpoch = Math.floor(Date.now() / 1000) + expiry.seconds;
 
   fs.mkdirSync(STATE_HOME, { recursive: true });
   const scriptPath = path.join(STATE_HOME, 'tick.sh');
@@ -414,7 +469,10 @@ function installCommand(args, root = process.cwd()) {
     script_path: scriptPath,
     crontab_line: line,
     cadence: cron,
-    expires_in_days: days,
+    cadence_input: cadenceInput,
+    expires_in_days: expiry.days,
+    expires_in_hours: expiry.hours,
+    expires_in_seconds: expiry.seconds,
     deadline_epoch: deadlineEpoch,
     runner_profile: runnerProfile || null,
     runner_bin: runnerBin || null,
@@ -425,7 +483,7 @@ function installCommand(args, root = process.cwd()) {
       process.stdout.write([
         `pulse installed. heartbeat fires '${cron}' against ${root}.`,
         `script: ${scriptPath}`,
-        `auto-expires in ${days} days. stop early: atris pulse uninstall`,
+        `auto-expires in ${expiry.hours ? `${expiry.hours} hours` : `${expiry.days} days`}. stop early: atris pulse uninstall`,
       ].join('\n') + '\n');
     } else {
       process.stdout.write(`pulse install failed to write crontab: ${apply.stderr || apply.status}\nscript written to ${scriptPath}; add this line to your crontab manually:\n${line}\n`);

package/commands/run-front.js

@@ -0,0 +1,144 @@
+// atris run: thin front door over the mission runtime loop.
+// One bounded pursuit: start a mission from the objective (or resume the most
+// logical runnable mission), tick it, complete on pass, then exit.
+// The old plan→do→review loop lives on behind `atris run --legacy`.
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const CLI_PATH = path.join(__dirname, '..', 'bin', 'atris.js');
+
+const RUN_VALUE_FLAGS = new Set([
+  '--owner',
+  '--cadence',
+  '--minutes',
+  '--hours',
+  '--max-ticks',
+  '--max-wall',
+  '--runner',
+  '--runner-bin',
+  '--runner-template',
+  '--runner-model',
+  '--runner-profile',
+]);
+
+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;
+}
+
+function runBudgetSeconds(args = []) {
+  const hours = positiveNumber(readValueFlag(args, '--hours'));
+  if (hours) return Math.round(hours * 3600);
+  const minutes = positiveNumber(readValueFlag(args, '--minutes'));
+  if (minutes) return Math.round(minutes * 60);
+  return null;
+}
+
+function runObjective(args = []) {
+  const words = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (RUN_VALUE_FLAGS.has(arg)) { i++; continue; }
+    if (arg.startsWith('-')) continue;
+    words.push(arg);
+  }
+  return words.join(' ').trim();
+}
+
+// Runners a spawned `mission run` can drive unattended.
+const HEADLESS_DRIVABLE_RUNNERS = new Set(['claude', 'atris2']);
+const CALLER_SESSION_RUNNERS = new Set(['codex_goal', 'caller_session', 'current_agent']);
+
+function liveCodexSession(env = process.env) {
+  return Boolean(String(env.CODEX_THREAD_ID || '').trim());
+}
+
+function runnerDrivableForFrontDoor(runner, options = {}) {
+  const normalized = String(runner || '').trim().toLowerCase();
+  if (HEADLESS_DRIVABLE_RUNNERS.has(normalized)) return true;
+  if (options.allowCallerSessionRunners && CALLER_SESSION_RUNNERS.has(normalized)) return true;
+  return false;
+}
+
+// Most logical mission: a moving one beats a planned one, newer beats older.
+// ready is excluded — it waits for review, not for another worker pass.
+function pickRunnableMission(root = process.cwd(), missionMap = null, options = {}) {
+  let map = missionMap;
+  if (!map) {
+    try { map = require('./mission').loadMissionMap(root); } catch { return null; }
+  }
+  const candidates = Array.from(map.values())
+    .filter((mission) => mission && (mission.status === 'running' || mission.status === 'planning'))
+    .filter((mission) => runnerDrivableForFrontDoor(mission?.runner, options))
+    .filter((mission) => !/^decide and start the next useful mission after:/i.test(String(mission?.objective || '')))
+    .sort((a, b) => {
+      if (a.status !== b.status) return a.status === 'running' ? -1 : 1;
+      return String(b.updated_at || b.created_at || '').localeCompare(String(a.updated_at || a.created_at || ''));
+    });
+  return candidates[0] || null;
+}
+
+function runTickBudget(args, budgetSeconds) {
+  const explicit = positiveNumber(readValueFlag(args, '--max-ticks'));
+  if (explicit) return Math.floor(explicit);
+  // A timed run is a loop contract: keep picking the next useful move until
+  // the wall clock spends the budget (same rule as member run).
+  return budgetSeconds ? Math.max(4, Math.ceil(budgetSeconds / 300)) : 4;
+}
+
+async function runMissionFront(args = []) {
+  const objective = runObjective(args);
+  const budgetSeconds = runBudgetSeconds(args);
+  const maxTicks = runTickBudget(args, budgetSeconds);
+  const maxWallSeconds = positiveNumber(readValueFlag(args, '--max-wall')) || budgetSeconds || 1200;
+
+  if (objective) {
+    const { runRuntimeMissionLoop } = require('../lib/mission-runtime-loop');
+    const result = await runRuntimeMissionLoop({
+      objective,
+      owner: readValueFlag(args, '--owner') || 'mission-lead',
+      cadence: readValueFlag(args, '--cadence') || '',
+      maxTicks,
+      maxWallSeconds,
+      noComplete: args.includes('--no-complete'),
+    }, {
+      cliPath: CLI_PATH,
+      onProgress: (line) => console.log(`  ${line}`),
+    });
+    console.log(result.text || '');
+    return result.ok ? 0 : 1;
+  }
+
+  const mission = pickRunnableMission(process.cwd(), null, {
+    allowCallerSessionRunners: liveCodexSession(),
+  });
+  if (!mission) {
+    console.log('No objective given and no runnable mission found.');
+    console.log('Start one: atris run "<objective>" [--minutes N] [--owner <member>]');
+    console.log('Or keep going indefinitely: atris autopilot');
+    return 1;
+  }
+  console.log(`Resuming mission ${mission.id} (${mission.status}): ${mission.objective}`);
+  const result = spawnSync(process.execPath, [
+    CLI_PATH, 'mission', 'run', mission.id,
+    '--max-ticks', String(maxTicks),
+    '--max-wall', String(maxWallSeconds),
+    '--complete-on-pass',
+  ], { cwd: process.cwd(), stdio: 'inherit' });
+  return result.status || 0;
+}
+
+module.exports = {
+  runMissionFront,
+  pickRunnableMission,
+  liveCodexSession,
+  runnerDrivableForFrontDoor,
+  runObjective,
+  runBudgetSeconds,
+  runTickBudget,
+};

package/commands/run.js

@@ -15,7 +15,7 @@ const { parseTodo } = require('../lib/todo');
 const {
   buildRunnerCommand,
   buildRunnerAvailabilityCommand,
-  resolveClaudeRunnerBin,
+  runnerAvailabilityFailureMessage,
 } = require('../lib/runner-command');
 const { cleanAtris } = require('./clean');
 
@@ -381,12 +381,15 @@ async function runAtris(options = {}) {
     process.exit(1);
   }
 
-  // Check configured runner CLI is available.
-  try {
-    execSync(buildRunnerAvailabilityCommand(), { stdio: 'pipe' });
-  } catch {
-    console.error(`${resolveClaudeRunnerBin()} CLI not found. Set ATRIS_RUNNER_BIN (or legacy ATRIS_CLAUDE_BIN), or install the configured runner first.`);
-    process.exit(1);
+  // Check configured runner CLI is available. Dry runs preview context only —
+  // they must work on machines (and CI) without the runner installed.
+  if (!dryRun) {
+    try {
+      execSync(buildRunnerAvailabilityCommand(), { stdio: 'pipe' });
+    } catch (err) {
+      console.error(runnerAvailabilityFailureMessage(err));
+      process.exit(1);
+    }
   }
 
   console.log('');

package/commands/sign.js

@@ -0,0 +1,90 @@
+const fs = require('fs');
+const path = require('path');
+
+// atris sign: co-author trailer on every commit in an atris workspace.
+// Installs a prepare-commit-msg hook that appends "Co-authored-by: Atris"
+// when the repo has an atris/ folder — same credit line Claude and Cursor use.
+// Idempotent and non-destructive: appends a marked block, removes only its own block.
+
+const MARKER = '# atris co-author';
+const TRAILER = 'Co-authored-by: Atris <299057014+atris-builder[bot]@users.noreply.github.com>';
+
+const HOOK_BLOCK = `
+${MARKER}
+if [ -d "$(git rev-parse --show-toplevel 2>/dev/null)/atris" ] && [ "$2" != "merge" ] && [ "$2" != "squash" ]; then
+  if ! grep -qi "^co-authored-by: atris" "$1"; then
+    printf '\\nCo-authored-by: Atris <299057014+atris-builder[bot]@users.noreply.github.com>\\n' >> "$1"
+  fi
+fi
+`;
+
+function hookPathFor(root) {
+  return path.join(root, '.git', 'hooks', 'prepare-commit-msg');
+}
+
+// Install the marked block into .git/hooks/prepare-commit-msg. Returns { hookPath, already }.
+function installSignHook(root = process.cwd()) {
+  if (!fs.existsSync(path.join(root, '.git'))) throw new Error('not a git repo (no .git here)');
+  const hookPath = hookPathFor(root);
+  fs.mkdirSync(path.dirname(hookPath), { recursive: true });
+  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 += HOOK_BLOCK;
+  fs.writeFileSync(hookPath, content);
+  fs.chmodSync(hookPath, 0o755);
+  return { hookPath, already: false };
+}
+
+// Remove only our marked block; leave the rest of the hook untouched.
+function removeSignHook(root = process.cwd()) {
+  const hookPath = hookPathFor(root);
+  let content = '';
+  try { content = fs.readFileSync(hookPath, 'utf8'); } catch { return { hookPath, removed: false }; }
+  if (!content.includes(MARKER)) return { hookPath, removed: false };
+  const cleaned = content.replace(HOOK_BLOCK, '');
+  if (cleaned.trim() === '#!/bin/sh') {
+    fs.unlinkSync(hookPath);
+  } else {
+    fs.writeFileSync(hookPath, cleaned);
+  }
+  return { hookPath, removed: true };
+}
+
+function signStatus(root = process.cwd()) {
+  const hookPath = hookPathFor(root);
+  let content = '';
+  try { content = fs.readFileSync(hookPath, 'utf8'); } catch {}
+  return { hookPath, installed: content.includes(MARKER) };
+}
+
+function signCommand(sub) {
+  const rel = (p) => path.relative(process.cwd(), p);
+  if (sub === 'off' || sub === 'remove') {
+    const { hookPath, removed } = removeSignHook();
+    console.log(removed
+      ? `\n  ✓ atris co-author removed: ${rel(hookPath)}\n`
+      : `\n  nothing to remove — atris co-author is not installed\n`);
+    return 0;
+  }
+  if (sub === 'status') {
+    const { hookPath, installed } = signStatus();
+    console.log(installed
+      ? `\n  ✓ atris co-author is on: ${rel(hookPath)}\n    every commit gets: ${TRAILER}\n`
+      : `\n  atris co-author is off — run 'atris sign' to turn it on\n`);
+    return installed ? 0 : 1;
+  }
+  if (sub && sub !== 'on' && sub !== 'install') {
+    console.log(`\n  atris sign — co-author trailer on every commit\n\n  atris sign          install the prepare-commit-msg hook\n  atris sign off      remove it\n  atris sign status   check whether it's installed\n\n  While installed, any commit in a repo with an atris/ folder gets:\n    ${TRAILER}\n`);
+    return 0;
+  }
+  const { hookPath, already } = installSignHook();
+  console.log(already
+    ? `\n  already installed: ${rel(hookPath)}\n`
+    : `\n  ✓ atris co-author installed: ${rel(hookPath)}\n    every commit here now gets: ${TRAILER}\n`);
+  return 0;
+}
+
+module.exports = { signCommand, installSignHook, removeSignHook, signStatus, TRAILER };