atris 3.30.12 → 3.32.0

package/commands/loop-front.js

@@ -14,6 +14,7 @@
 //   atris loop status             liveness, last tick, reward   -> pulse.js
 //   atris loop stop               remove the durable heartbeat  -> pulse.js
 //   atris loop wiki               wiki upkeep (the old `loop`)  -> loop.js
+//   atris loop create-next        create + claim the suggested task
 //
 // The loop reads ROADMAP.md for what to pursue.
 
@@ -21,6 +22,13 @@ function isFlag(arg) {
   return typeof arg === 'string' && arg.startsWith('-');
 }
 
+function flagValue(argv, name) {
+  const index = argv.indexOf(name);
+  if (index === -1) return null;
+  const value = argv[index + 1];
+  return value && !isFlag(value) ? value : true;
+}
+
 // Pure router: decide what `atris loop ...` means without executing anything.
 // Kept side-effect-free so it is trivially testable.
 function routeLoop(argv = []) {
@@ -36,6 +44,10 @@ function routeLoop(argv = []) {
       return { action: 'status' };
     case 'stop':
       return { action: 'stop' };
+    case 'create-next':
+    case 'claim-next':
+    case 'take-next':
+      return { action: 'create-next' };
     case 'wiki':
       // Forward the remaining args (e.g. --json, --limit=) to wiki upkeep.
       return { action: 'wiki', rest: argv.filter((a) => a.toLowerCase() !== 'wiki') };
@@ -57,7 +69,7 @@ function routeLoop(argv = []) {
   }
 }
 
-function renderLoopHome(route = { action: 'home' }) {
+function renderLoopHome(route = { action: 'home' }, moves = []) {
   const lines = [
     '',
     'atris loop: the self-improvement loop',
@@ -73,6 +85,7 @@ function renderLoopHome(route = { action: 'home' }) {
     '    atris loop start              run it now, here (local)',
     '    atris loop start --once       one cycle, then stop',
     '    atris loop start --overnight  install the durable heartbeat (~15m)',
+    '    atris loop start --overnight --hours 6',
     '',
     '  watch it',
     '    atris loop status             liveness, last tick, reward',
@@ -85,6 +98,16 @@ function renderLoopHome(route = { action: 'home' }) {
     '  wiki upkeep is at: atris loop wiki',
     '',
   ];
+  if (Array.isArray(moves) && moves.length) {
+    lines.splice(lines.length - 2, 0, '  ranked next moves');
+    moves.slice(0, 3).forEach((move) => {
+      lines.splice(lines.length - 2, 0, `    [${move.source}] ${move.title}`);
+    });
+    lines.splice(lines.length - 2, 0, '');
+  }
+  lines.splice(lines.length - 2, 0, '  act on it');
+  lines.splice(lines.length - 2, 0, '    atris loop create-next       create + claim the suggested task');
+  lines.splice(lines.length - 2, 0, '');
   if (route && route.unknown) {
     lines.splice(1, 0, `  (unknown: "${route.unknown}". here is the loop:)`);
   }
@@ -95,7 +118,11 @@ function renderLoopHome(route = { action: 'home' }) {
 }
 
 function printLoopHome(route) {
-  console.log(renderLoopHome(route));
+  let moves = [];
+  try {
+    moves = require('../lib/next-moves').nextMoves(process.cwd(), 3);
+  } catch { /* next moves are optional on a fresh checkout */ }
+  console.log(renderLoopHome(route, moves));
 }
 
 // Parse the handful of local-run flags `atris loop start` forwards to run.js.
@@ -148,7 +175,7 @@ function printLocalRunSummary() {
 // Combined machine-readable status: the overnight pulse heartbeat and the local
 // runs in one object. Best-effort per engine so a missing one does not fail it.
 function loopStatusJson(root = process.cwd()) {
-  const out = { ok: true, action: 'loop_status', pulse: null, local_runs: { count: 0, latest: null } };
+  const out = { ok: true, action: 'loop_status', pulse: null, local_runs: { count: 0, latest: null }, next_moves: [] };
   try {
     const lp = require('../lib/pulse');
     const { cronInstalled } = require('./pulse');
@@ -158,9 +185,88 @@ function loopStatusJson(root = process.cwd()) {
   try {
     out.local_runs = localRunSummary(require('./run').getRunLogDir());
   } catch { /* runs optional */ }
+  try {
+    out.next_moves = require('../lib/next-moves').nextMoves(root, 5);
+  } catch { /* next moves optional */ }
   return out;
 }
 
+function loopSeedMove(root = process.cwd()) {
+  const moves = require('../lib/next-moves').nextMoves(root, 5);
+  const activeTask = moves.find((move) => move && move.source === 'task');
+  if (activeTask) return { ok: false, reason: 'active_task', move: activeTask, moves };
+  const seed = moves.find((move) => (
+    move
+    && move.source === 'mission'
+    && (
+      move.why === 'active mission has no concrete task queued'
+      || move.why === 'latest proof timeline suggested this self-improvement target'
+    )
+  ));
+  if (!seed) return { ok: false, reason: 'no_seed', moves };
+  return { ok: true, move: seed, moves };
+}
+
+function createNextLoopTask(argv = [], root = process.cwd(), options = {}) {
+  const shouldPrint = options.print !== false;
+  const json = argv.includes('--json');
+  const owner = flagValue(argv, '--as') || flagValue(argv, '--owner') || process.env.ATRIS_AGENT_ID || 'auto-improver';
+  const seed = loopSeedMove(root);
+  if (!seed.ok) {
+    const payload = { ok: false, action: 'create_next_skipped', reason: seed.reason, move: seed.move || null };
+    if (shouldPrint) {
+      if (json) console.log(JSON.stringify(payload, null, 2));
+      else if (seed.reason === 'active_task') console.log(`not created: active task already exists (${seed.move.ref || seed.move.title})`);
+      else console.log('not created: no loop seed is available');
+    }
+    return payload;
+  }
+
+  const note = `Goal: ${seed.move.title}. Files: inspect atris/MAP.md first, then the relevant code. Done: one bounded proof-backed self-improvement task is moved to Review. Check: focused verifier; git diff --check; atris clean --dry-run --json; atris brain compile --root . --verify.`;
+  const taskArgs = [
+    'task',
+    'delegate',
+    seed.move.title,
+    '--tag', 'loop',
+    '--claim',
+    '--as', String(owner),
+    '--note', note,
+    '--json',
+  ];
+  const { spawnSync } = require('child_process');
+  const path = require('path');
+  const cli = path.join(__dirname, '..', 'bin', 'atris.js');
+  const child = spawnSync(process.execPath, [cli, ...taskArgs], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: 20000,
+    env: { ...process.env, ATRIS_SKIP_UPDATE_CHECK: '1' },
+  });
+  if (child.status !== 0) {
+    const payload = { ok: false, action: 'create_next_failed', reason: 'task_delegate_failed', stderr: child.stderr, stdout: child.stdout };
+    if (shouldPrint) {
+      if (json) console.log(JSON.stringify(payload, null, 2));
+      else console.error(child.stderr || child.stdout || 'task creation failed');
+    }
+    return payload;
+  }
+  let delegated = null;
+  try { delegated = JSON.parse(child.stdout); } catch { delegated = null; }
+  const task = delegated && delegated.task ? delegated.task : null;
+  const payload = { ok: true, action: 'created_next', owner: String(owner), move: seed.move, task, delegated };
+  if (shouldPrint) {
+    if (json) {
+      console.log(JSON.stringify(payload, null, 2));
+    } else {
+      const ref = task?.display_id || task?.id || 'task';
+      console.log(`created next loop task: ${ref} ${seed.move.title}`);
+      console.log(`claimed by: ${owner}`);
+      console.log(`next: atris task show ${ref}`);
+    }
+  }
+  return payload;
+}
+
 // The evidence that the loop is improving things: ROADMAP items it has handled,
 // what is in flight and queued, and the heartbeat's reward/verify trend. Pure of
 // console so it is testable.
@@ -170,7 +276,7 @@ function loopReport(root = process.cwd()) {
   try {
     roadmap = require('../lib/next-moves').roadmapItemsByState(root);
   } catch { /* roadmap optional */ }
-  return { ok: true, action: 'loop_report', roadmap, pulse: status.pulse, local_runs: status.local_runs };
+  return { ok: true, action: 'loop_report', roadmap, next_moves: status.next_moves, pulse: status.pulse, local_runs: status.local_runs };
 }
 
 function renderLoopReport(rep) {
@@ -193,6 +299,11 @@ function renderLoopReport(rep) {
     lines.push('  next up:');
     r.open.slice(0, 4).forEach((t) => lines.push(`    [ ] ${t}`));
   }
+  if (Array.isArray(rep.next_moves) && rep.next_moves.length) {
+    lines.push('');
+    lines.push('  ranked next:');
+    rep.next_moves.slice(0, 5).forEach((move) => lines.push(`    [${move.source}] ${move.title}`));
+  }
   if (rep.pulse) {
     lines.push('');
     lines.push(`  heartbeat: ${rep.pulse.total_ticks} ticks, reward ${rep.pulse.reward_sum}, verify ${rep.pulse.verify_pass}/${rep.pulse.verify_fail}`);
@@ -236,6 +347,11 @@ function loopFront(argv = []) {
       return Promise.resolve(0);
     }
 
+    case 'create-next': {
+      const result = createNextLoopTask(argv, process.cwd());
+      return Promise.resolve(result.ok ? 0 : 1);
+    }
+
     case 'status': {
       if (jsonFlag.length) {
         // One machine-readable object covering BOTH engines (overnight pulse
@@ -284,6 +400,8 @@ module.exports = {
   startLocalOptions,
   localRunSummary,
   loopStatusJson,
+  loopSeedMove,
+  createNextLoopTask,
   loopReport,
   renderLoopReport,
   loopFront,