atris 3.56.0 → 3.56.1

package/commands/mission.js

@@ -983,6 +983,62 @@ function hasLocalMissionState(root = process.cwd()) {
     .some((mission) => mission && mission.id && mission.cloud !== true);
 }
 
+const LIVE_MISSION_TICK_MS = 24 * 60 * 60 * 1000;
+
+function isLiveInFlightMission(mission, now = Date.now(), root = process.cwd()) {
+  if (!mission || !mission.id || mission.cloud === true) return false;
+  const status = String(mission.status || '');
+  if (TERMINAL_STATUSES.has(status) || status === 'paused' || status === 'blocked') return false;
+  if (status === 'running') return true;
+  const lastTickAt = Date.parse(mission.last_tick_at || '');
+  if (!Number.isFinite(lastTickAt)) return false;
+  const age = now - lastTickAt;
+  if (!(age >= 0 && age <= LIVE_MISSION_TICK_MS)) return false;
+  // ready/planning with a recent receipt is still parked unless a driver is
+  // alive. A stalled ready row is the archive, not the live card.
+  return missionDriverHealth(mission, root).alive === true;
+}
+
+function pickLiveLocalMission(root = process.cwd()) {
+  return listMissions(root).find((mission) => isLiveInFlightMission(mission, Date.now(), root)) || null;
+}
+
+function wantsBareMissionArchive(args = []) {
+  return hasFlag(args, '--all')
+    && args.every((value) => value === '--all' || value === '--json');
+}
+
+function missionStatusRef(args = []) {
+  return stripKnownFlags(args, ['--status', '--limit'], ['--json', '--local', '--all'])[0] || '';
+}
+
+function wantsSpokenMissionStatus(args = []) {
+  if (hasFlag(args, '--all') || hasFlag(args, '--local') || hasFlag(args, '--cloud')) return false;
+  if (readFlag(args, '--status', '') || readFlag(args, '--limit', '')) return false;
+  return !missionStatusRef(args);
+}
+
+function speakMissionDoor(args = [], root = resolveWorkspaceRoot()) {
+  const asJson = args.includes('--json');
+  const live = pickLiveLocalMission(root);
+  if (live) {
+    return statusMission(asJson ? [live.id, '--json'] : [live.id]);
+  }
+  if (isFreshWorkspace(root) || hasLocalMissionState(root)) {
+    const code = speakFirstMinute({
+      root,
+      fresh: isFreshWorkspace(root),
+      asJson,
+    });
+    process.exitCode = code;
+    return code;
+  }
+  return require('./human-missions').currentMissionCommand(args, {
+    root,
+    fallbackOnMissing: true,
+  });
+}
+
 function terminalNextAction(status) {
   if (status === 'complete') return 'mission complete';
   if (status === 'stopped') return 'mission stopped';
@@ -4811,9 +4867,16 @@ function statusMission(args) {
     console.log('Use --status active for planning, running, ready, paused, and blocked missions.');
     return;
   }
+  const root = resolveWorkspaceRoot();
+  if (isFreshWorkspace(root) && !missionStatusRef(args)) {
+    return speakMissionDoor(args, root);
+  }
+  if (wantsSpokenMissionStatus(args)) {
+    return speakMissionDoor(args, root);
+  }
   const asJson = wantsJson(args);
   const localOnly = hasFlag(args, '--local');
-  const ref = stripKnownFlags(args, ['--status', '--limit'], ['--json', '--local'])[0] || '';
+  const ref = missionStatusRef(args);
   const statusFilter = readFlag(args, '--status', '');
   if (statusFilter && !VALID_STATUSES.has(statusFilter) && !STATUS_ALIASES.has(statusFilter)) {
     exitMissionError(`Invalid --status: ${statusFilter}`, 2, asJson);
@@ -4871,7 +4934,7 @@ function statusMission(args) {
         ...missionStatusLandingLines(mission.last_landing),
         ...(completionGateLabel(mission.completion_gate) ? [`  gate: ${completionGateLabel(mission.completion_gate)}`] : []),
       ])
-      : ['No missions yet. Run: atris mission start "..." --owner <member>'],
+      : ['No missions yet.'],
     asJson,
   );
 }
@@ -9014,7 +9077,7 @@ async function parseAndValidateMissionRunPhase(args) {
     error: null,
   };
   if (hasFlag(args, '--help') || hasFlag(args, '-h')) {
-    help();
+    console.log('Usage: atris mission run <id|objective> [--max-ticks 4] [--max-wall 3600]');
     context.handled = true;
     return context;
   }
@@ -10933,10 +10996,36 @@ async function goalLoopMission(args) {
   if (completedTaskClosed) process.exitCode = 2;
 }
 
-function help() {
+function help(args = []) {
+  if (hasFlag(args, '--full')) {
+    helpFull();
+    return;
+  }
+  console.log(`
+Usage: atris mission
+
+Keep working on one goal.
+
+  atris mission          what's in front of you
+  atris mission start    begin one goal
+  atris mission status   same as atris mission
+  atris mission stop     stop the live goal
+  atris mission list     every saved goal
+  atris mission inspect <id> --fields status,runner,ack,pings
+
+Hours of keep-working: atris spaceship
+Keep going until you stop: atris autopilot
+
+More flags: atris mission help --full
+`.trim());
+}
+
+function helpFull() {
   console.log(`
 atris mission - durable goal + loop + owner + proof state
 
+  atris mission                 Same next as bare atris, or the one live mission
+  atris mission list | --all    Full mission archive
   atris mission start "<objective>" --owner <member> [--destination "<text>"] [--verify "..."] [--always-on] [--budget quick|long|deep] [--xp-task] [--worktree] [--take-goal-slot]
                       [--runner manual|claude|atris2|codex_goal] [--model <id>]
                       (runner claude spawns local claude -p per tick, --model passes through;
@@ -11372,23 +11461,20 @@ function missionCommand(args) {
   if (args[0] === 'answer') {
     return require('./human-missions').answerCommand(args.slice(1));
   }
-  if (isBareMission && !hasLocalMissionState(resolveWorkspaceRoot())) {
+  if (isBareMission) {
+    // Empty folder talks like bare atris. A live in-flight mission shows
+    // that one card. Completed, stopped, stalled, or ready-with-no-driver
+    // rows stay in the archive. After init with no live mission, speak the
+    // desk next.
+    return speakMissionDoor(args);
+  }
+  if (wantsBareMissionArchive(args)) {
     const root = resolveWorkspaceRoot();
-    // Empty folder talks like bare atris. After init, stay on the current
-    // card or an honest no-mission, and do not bounce back to init.
-    if (isFreshWorkspace(root)) {
-      const code = speakFirstMinute({
-        root,
-        fresh: true,
-        asJson: args.includes('--json'),
-      });
-      process.exitCode = code;
-      return code;
-    }
-    return require('./human-missions').currentMissionCommand(args);
+    if (isFreshWorkspace(root)) return speakMissionDoor(args, root);
+    return statusMission(args);
   }
-  const subcommand = isBareMission ? 'status' : (args[0] || 'status');
-  const rest = isBareMission ? args : args.slice(1);
+  const subcommand = args[0] || 'status';
+  const rest = args.slice(1);
   // Every mission verb resolves its state store from process.cwd(). Running one
   // from a subdirectory used to create a nested .atris store the fleet never
   // reads (proven footgun: a nested .atris appeared under
@@ -11404,8 +11490,6 @@ function missionCommand(args) {
     case 'new':
       return startMission(rest);
     case 'status':
-    case 'list':
-    case 'ls':
     case 'show':
     case 'info':
     case 'view':
@@ -11416,6 +11500,16 @@ function missionCommand(args) {
         });
       }
       return statusMission(rest);
+    case 'list':
+    case 'ls': {
+      if (hasFlag(rest, '--help') || hasFlag(rest, '-h') || String(rest[0] || '').trim() === 'help') {
+        console.log('Usage: atris mission list [--status <state>] [--limit <n>] [--local] [--json]');
+        return;
+      }
+      const listRoot = resolveWorkspaceRoot();
+      if (isFreshWorkspace(listRoot)) return speakMissionDoor(rest, listRoot);
+      return statusMission(rest.includes('--all') ? rest : ['--all', ...rest]);
+    }
     case 'doctor':
     case 'check':
       return doctorMission(rest);
@@ -11469,7 +11563,7 @@ function missionCommand(args) {
     case 'help':
     case '--help':
     case '-h':
-      return help();
+      return help(rest);
     default: {
       const first = String(subcommand || '');
       if (first && !first.startsWith('-')) {
@@ -11505,6 +11599,7 @@ module.exports = {
   reapPausedMissions,
   missionHeartbeatLines,
   listMissions,
+  pickLiveLocalMission,
   freezeMissionVerifier,
   markMissionReviewReady,
   listWorktreeRollupMissions,

package/commands/next.js

@@ -1,5 +1,14 @@
 'use strict';
 
+const { argsWantHelp, wantsJson } = require('../lib/noninteractive');
+const {
+  buildFirstMinute,
+  folderName,
+  freshMinuteJson,
+  isFreshWorkspace,
+  listUserVisibleWork,
+} = require('../lib/first-minute');
+const { loadContext } = require('../lib/state-detection');
 const {
   claimRoadmapItem,
   nextCards,
@@ -9,70 +18,146 @@ const {
   seedInboxFromMove,
 } = require('../lib/next-moves');
 
-function showHelp() {
-  console.log('');
-  console.log('Usage: atris next [yes|no|skip]');
-  console.log('');
-  console.log('Shows one next move card.');
-  console.log('');
+function showHelp(log = console.log) {
+  log('Usage: atris next [--json]');
   return 0;
 }
 
-function cardLabel(card) {
-  return String(card?.label || card?.title || '').trim();
+function spokenWin(text) {
+  return String(text || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .find(Boolean) || '';
 }
 
-function cardWhy(card) {
-  const why = String(card?.why || '').trim();
-  if (why) return why;
-  const status = String(card?.status || '').trim();
-  if (status) return status;
-  if (card?.source === 'task' || card?.source === 'mission') return 'working';
-  return 'new';
+function minuteText(screen) {
+  const win = spokenWin(screen && screen.text);
+  const next = String(screen && screen.nextCommand || '').trim();
+  if (!next) return win || 'nothing is waiting.';
+  return `${win}\n\nnext: ${next}`;
+}
+
+function minuteJson(screen, extra = {}) {
+  const reason = spokenWin(screen && screen.text).replace(/\.$/, '');
+  const next = String((screen && screen.nextCommand) || extra.next_action || '').trim();
+  const fresh = extra.fresh === true;
+  return {
+    schema: 'atris.one_lap.v1',
+    ok: Boolean(next) && !fresh,
+    status: fresh ? 'stuck' : (next ? 'ok' : 'stuck'),
+    reason,
+    next_action: next,
+  };
+}
+
+function printMinute(screen, { asJson = false, log = console.log, fresh = false } = {}) {
+  if (asJson) {
+    log(JSON.stringify(minuteJson(screen, { fresh }), null, 2));
+    return 0;
+  }
+  log('');
+  log(minuteText(screen));
+  return 0;
+}
+
+function nextScreen(root) {
+  const fresh = isFreshWorkspace(root);
+  if (fresh) {
+    return {
+      fresh: true,
+      screen: buildFirstMinute({ root, fresh: true }),
+    };
+  }
+  return {
+    fresh: false,
+    screen: buildFirstMinute({
+      root,
+      fresh: false,
+      context: loadContext(root),
+    }),
+  };
+}
+
+function speakNext(root, { asJson = false, log = console.log } = {}) {
+  const { fresh, screen } = nextScreen(root);
+  if (asJson && fresh) {
+    log(JSON.stringify(freshMinuteJson(folderName(root), listUserVisibleWork(root), { root }), null, 2));
+    return 0;
+  }
+  return printMinute(screen, { asJson, log, fresh });
+}
+
+function cardLabel(card) {
+  return String(card?.label || card?.title || '').trim();
 }
 
-function renderCard(card) {
-  if (!card) return 'Nothing to do. Rest or wish.';
-  return [
-    cardLabel(card),
-    `Why now: ${cardWhy(card)}`,
-    'Do it? yes / no / skip',
-  ].join('\n');
+function cardNextCommand(card) {
+  if (!card) return '';
+  const action = card.next_action || {};
+  const prompt = String(action.prompt || '').trim();
+  if (/^(atris|ax)\b/i.test(prompt)) return prompt;
+  if (action.type === 'mission_complete' && action.mission_id) {
+    if (action.proof_path) {
+      return `atris mission complete ${action.mission_id} --proof ${action.proof_path}`;
+    }
+    return `atris mission status ${action.mission_id}`;
+  }
+  if (action.type === 'mission_review_prompt' && action.mission_id) {
+    return `atris mission status ${action.mission_id}`;
+  }
+  if (action.type === 'wish_answer_prompt') return 'atris wish answer "your words"';
+  if (card.source === 'inbox') return 'atris plan';
+  if (card.source === 'task' || card.source === 'roadmap' || card.source === 'endgame') {
+    return 'atris do';
+  }
+  if (card.source === 'mission') {
+    const id = action.mission_id || card.ref;
+    return id ? `atris mission status ${id}` : 'atris mission status --status active';
+  }
+  return '';
 }
 
-function printCard(card) {
-  console.log(renderCard(card));
+function speakCard(card, { asJson = false, log = console.log } = {}) {
+  if (!card) {
+    return printMinute({ text: 'nothing is waiting.', nextCommand: '' }, { asJson, log });
+  }
+  const next = cardNextCommand(card);
+  const label = cardLabel(card) || 'this';
+  return printMinute({
+    text: `${label} is waiting.`,
+    nextCommand: next,
+  }, { asJson, log });
 }
 
 function wishPromptTitle(label) {
   return String(label || 'this').replace(/^(#\d+)\s+/, '$1: ');
 }
 
-function printWishAnswerPrompt(card) {
+function printWishAnswerPrompt(card, log = console.log) {
   const action = card.next_action || {};
-  console.log(`Got it, wish ${wishPromptTitle(action.label || cardLabel(card))}.`);
-  console.log(String(action.question || 'What should be different when this wish comes true?'));
-  console.log('Answer with: atris wish answer "your words"');
+  log(`Got it, wish ${wishPromptTitle(action.label || cardLabel(card))}.`);
+  log(String(action.question || 'What should be different when this wish comes true?'));
+  log('Answer with: atris wish answer "your words"');
   return 0;
 }
 
-function approveMove(card, root) {
+function approveMove(card, root, log = console.log) {
   recordDecision(root, card, 'approve', new Date().toISOString());
   if (['roadmap', 'inbox', 'endgame'].includes(card.source)) {
     seedInboxFromMove(root, card);
     if (card.source === 'roadmap') claimRoadmapItem(root, card.title);
-    console.log(`${cardLabel(card)} is working.`);
+    log(`${cardLabel(card)} is working.`);
     return 0;
   }
   const prompt = card.next_action && card.next_action.prompt;
-  console.log(prompt || `${cardLabel(card)} is working.`);
+  log(prompt || `${cardLabel(card)} is working.`);
   return 0;
 }
 
-function completeMissionFromCard(card) {
+function completeMissionFromCard(card, log = console.log) {
   const action = card.next_action || {};
   if (!action.mission_id || !action.proof_path) {
-    console.log('Review the proof, then complete this mission.');
+    log('Review the proof, then complete this mission.');
     return 0;
   }
   const { completeMission } = require('./mission');
@@ -80,57 +165,62 @@ function completeMissionFromCard(card) {
   return 0;
 }
 
-function executeCard(card, root) {
+function executeCard(card, root, log = console.log) {
   const action = card && card.next_action;
-  if (!card) {
-    printCard(null);
-    return 0;
-  }
-  if (action?.type === 'wish_answer_prompt') return printWishAnswerPrompt(card);
-  if (action?.type === 'mission_complete') return completeMissionFromCard(card);
+  if (!card) return speakCard(null, { log });
+  if (action?.type === 'wish_answer_prompt') return printWishAnswerPrompt(card, log);
+  if (action?.type === 'mission_complete') return completeMissionFromCard(card, log);
   if (action?.type === 'wish_review_prompt' || action?.type === 'mission_review_prompt') {
-    console.log(action.prompt || 'Review the proof, then choose done or stuck.');
+    log(action.prompt || 'Review the proof, then choose done or stuck.');
     return 0;
   }
-  return approveMove(card, root);
+  return approveMove(card, root, log);
 }
 
-function nextCommand(args = [], root = process.cwd()) {
-  const action = String(args[0] || '').trim().toLowerCase();
-  if (action === 'help' || action === '--help' || action === '-h') return showHelp();
+function actionToken(args = []) {
+  const list = Array.isArray(args) ? args : [];
+  const token = list.find((arg) => {
+    const text = String(arg || '').trim();
+    if (!text || text.startsWith('-')) return false;
+    return true;
+  });
+  return String(token || '').trim().toLowerCase();
+}
+
+function nextCommand(args = [], root = process.cwd(), { log = console.log } = {}) {
+  const list = Array.isArray(args) ? args : [];
+  if (argsWantHelp(list)) return showHelp(log);
+
+  const asJson = wantsJson(list);
+  const action = actionToken(list);
+
+  if (!action || action === 'json') return speakNext(root, { asJson, log });
 
   const current = nextCards(root, 1)[0] || null;
-  if (!action) {
-    printCard(current);
-    if (current?.source === 'dream') markDreamCardConsumed(root, current, new Date().toISOString(), 'dealt');
-    return 0;
-  }
 
   if (action === 'skip') {
     const following = current ? nextCards(root, 1, { skipIds: [current.id] })[0] : null;
-    if (current?.source === 'dream') markDreamCardConsumed(root, current, new Date().toISOString(), 'skipped');
-    printCard(following);
-    if (following?.source === 'dream') markDreamCardConsumed(root, following, new Date().toISOString(), 'dealt');
-    return 0;
+    if (current?.source === 'dream') {
+      markDreamCardConsumed(root, current, new Date().toISOString(), 'skipped');
+    }
+    if (following?.source === 'dream') {
+      markDreamCardConsumed(root, following, new Date().toISOString(), 'dealt');
+    }
+    return speakCard(following, { asJson, log });
   }
 
   if (action === 'no') {
-    if (!current) {
-      printCard(null);
-      return 0;
-    }
+    if (!current) return speakCard(null, { asJson, log });
     parkNextCard(root, current);
-    console.log(`Parked ${cardLabel(current)}.`);
+    log(`Parked ${cardLabel(current)}.`);
     return 0;
   }
 
-  if (action === 'yes') return executeCard(current, root);
+  if (action === 'yes') return executeCard(current, root, log);
 
-  console.log('Say yes, no, or skip.');
-  return 2;
+  return speakNext(root, { asJson, log });
 }
 
 module.exports = {
   nextCommand,
-  renderCard,
 };

package/commands/now.js

@@ -576,6 +576,31 @@ function refreshNowFile(root = process.cwd(), options = {}) {
   return { path: nowPath, preserved: false };
 }
 
+function stripAnsi(text) {
+  return String(text || '').replace(/\u001b\[[0-9;]*m/g, '');
+}
+
+function spokenCurrent(text) {
+  const line = stripAnsi(text).split(/\n/).map((part) => part.trim()).find(Boolean) || '';
+  return line.replace(/^hey\s+[^,]+,\s*/i, '').replace(/\.$/, '');
+}
+
+function printNowJson(payload) {
+  console.log(JSON.stringify(payload, null, 2));
+}
+
+function nowJsonPayload(root = process.cwd()) {
+  const { buildFirstMinute, isFreshWorkspace } = require('../lib/first-minute');
+  const fresh = isFreshWorkspace(root);
+  const screen = buildFirstMinute({ root, fresh });
+  const payload = { ok: !fresh };
+  const current = spokenCurrent(screen && screen.text);
+  const next = stripAnsi(screen && screen.nextCommand);
+  if (current) payload.current = current;
+  if (next) payload.next = next;
+  return payload;
+}
+
 function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
   const help = args.includes('--help') || args.includes('-h') || args[0] === 'help';
   if (help) {
@@ -588,8 +613,8 @@ function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
     console.log('  atris now --refresh Regenerate a small local now.md');
     console.log('  atris now --all     Refresh this parent and every child Atris workspace');
     console.log('  atris now --path    Print the file path only');
-    console.log('  atris now --json    Emit path and content as JSON');
-    return;
+    console.log('  atris now --json    Print ok, next or current as JSON');
+    return 0;
   }
 
   const init = args.includes('--init');
@@ -598,48 +623,65 @@ function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
   const pathOnly = args.includes('--path');
   const asJson = args.includes('--json');
 
-  let result;
-  if (all) {
-    const workspaces = findChildWorkspaces(root);
-    for (const workspace of workspaces) {
-      refreshNowFile(workspace.root);
+  try {
+    if (asJson && !init && !refresh && !all && !pathOnly) {
+      const payload = nowJsonPayload(root);
+      printNowJson(payload);
+      return payload.ok ? 0 : 2;
     }
-    result = refreshNowFile(root);
-    if (!pathOnly && !asJson) {
-      console.log(`Refreshed ${workspaces.length} child workspace${workspaces.length === 1 ? '' : 's'}.`);
-      console.log('');
+
+    let result;
+    if (all) {
+      const workspaces = findChildWorkspaces(root);
+      for (const workspace of workspaces) {
+        refreshNowFile(workspace.root);
+      }
+      result = refreshNowFile(root);
+      if (!pathOnly && !asJson) {
+        console.log(`Refreshed ${workspaces.length} child workspace${workspaces.length === 1 ? '' : 's'}.`);
+        console.log('');
+      }
+    } else if (refresh) {
+      result = refreshNowFile(root);
+    } else if (init) {
+      result = ensureNowFile(root);
+    } else {
+      result = ensureNowFile(root);
     }
-  } else if (refresh) {
-    result = refreshNowFile(root);
-  } else if (init) {
-    result = ensureNowFile(root);
-  } else {
-    result = ensureNowFile(root);
-  }
 
-  const rel = path.relative(root, result.path);
-  if (pathOnly) {
-    console.log(rel);
-    return;
-  }
+    const rel = path.relative(root, result.path);
+    if (pathOnly) {
+      console.log(rel);
+      return 0;
+    }
 
-  const content = fs.readFileSync(result.path, 'utf8').trimEnd();
-  if (asJson) {
-    console.log(JSON.stringify({
-      ok: true,
-      path: rel,
-      created: Boolean(result.created),
-      content,
-    }, null, 2));
-    return;
-  }
+    if (asJson) {
+      const payload = nowJsonPayload(root);
+      printNowJson(payload);
+      return payload.ok ? 0 : 2;
+    }
 
-  if (result.created) {
-    console.log(`Created ${rel}`);
-    console.log('');
-  }
+    const content = fs.readFileSync(result.path, 'utf8').trimEnd();
+    if (result.created) {
+      console.log(`Created ${rel}`);
+      console.log('');
+    }
 
-  console.log(content);
+    console.log(content);
+    return 0;
+  } catch (err) {
+    const message = stripAnsi(err && err.message ? err.message : String(err));
+    if (asJson) {
+      printNowJson({
+        ok: false,
+        current: message.replace(/\.$/, ''),
+        next: 'atris init --yes',
+      });
+      return 2;
+    }
+    console.error(message);
+    return 1;
+  }
 }
 
 module.exports = {