atris 3.55.0 → 3.56.1

package/commands/log.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const readline = require('readline');
 const { getLogPath, ensureLogDirectory, createLogFile, addInboxIdea } = require('../lib/file-ops');
+const { isFreshWorkspace, speakFirstMinute } = require('../lib/first-minute');
 const { isForcedNonInteractive } = require('../lib/noninteractive');
 
 function readPipedStdin() {
@@ -12,42 +13,89 @@ function readPipedStdin() {
   }
 }
 
-function logAtris() {
-  const targetDir = path.join(process.cwd(), 'atris');
+function journalRel(logFile) {
+  return (path.relative(process.cwd(), logFile) || logFile).split(path.sep).join('/');
+}
+
+function printLogJson(payload) {
+  console.log(JSON.stringify(payload, null, 2));
+}
 
-  if (!fs.existsSync(targetDir)) {
-    console.error('✗ Error: atris/ folder not found. Run "atris init" first.');
-    process.exit(1);
+function printReplNeeded(asJson, dateFormatted, rel) {
+  const error = `Daily log REPL needs a terminal (${dateFormatted}).`;
+  if (asJson) {
+    printLogJson({
+      ok: false,
+      error,
+      journal: rel,
+      next_command: 'atris log "note"',
+    });
+    return;
   }
+  console.log(error);
+  console.log(`journal: ${rel}`);
+  console.log('Next: atris log --repl   # in a terminal, or atris log "note" / atris wish --json --no-mission');
+}
 
-  ensureLogDirectory();
-  const { logFile, dateFormatted } = getLogPath();
+function captureNotes(logFile, notes) {
+  return notes.map((note) => addInboxIdea(logFile, note));
+}
 
-  if (!fs.existsSync(logFile)) {
-    createLogFile(logFile, dateFormatted);
+function printCapture(asJson, ids, notes, rel) {
+  if (asJson) {
+    const payload = {
+      ok: true,
+      action: 'inbox_capture',
+      journal: rel,
+      next_command: 'atris logs',
+    };
+    if (notes.length === 1) {
+      payload.id = `I${ids[0]}`;
+      payload.note = notes[0];
+    } else {
+      payload.count = notes.length;
+      payload.ids = ids.map((id) => `I${id}`);
+      payload.notes = notes;
+    }
+    printLogJson(payload);
+    return;
+  }
+  if (notes.length === 1) {
+    console.log(`captured I${ids[0]}: ${notes[0]}`);
+    console.log(`journal: ${rel}`);
+    console.log('Next: atris logs');
+    return;
   }
+  console.log(`captured ${notes.length} note${notes.length === 1 ? '' : 's'} in ${rel}`);
+}
 
+function logAtris() {
+  const root = process.cwd();
   const args = process.argv.slice(3);
-  const rel = path.relative(process.cwd(), logFile) || logFile;
+  const asJson = args.includes('--json');
   const forced = isForcedNonInteractive(args);
   const wantsRepl = args.includes('--repl');
   const positional = args.filter((arg) => !String(arg).startsWith('-'));
   const note = positional.join(' ').trim();
 
-  // `atris log "sentence"` (or multi-word args) appends to today's Inbox.
-  if (note && !wantsRepl) {
-    const id = addInboxIdea(logFile, note);
-    console.log(`captured I${id}: ${note}`);
-    console.log(`journal: ${rel}`);
-    console.log('Next: atris logs');
-    return;
+  // Empty folder talks like bare atris. Do not create atris/ or write
+  // a journal. After init, a note still captures.
+  if (isFreshWorkspace(root)) {
+    process.exit(speakFirstMinute({ root, fresh: true, asJson }));
   }
 
-  // Forced headless: never open a REPL.
-  if (forced) {
-    console.log(`Daily log REPL needs a terminal (${dateFormatted}).`);
-    console.log(`journal: ${rel}`);
-    console.log('Next: atris log --repl   # in a terminal, or atris log "note" / atris wish --json --no-mission');
+  ensureLogDirectory();
+  const { logFile, dateFormatted } = getLogPath();
+
+  if (!fs.existsSync(logFile)) {
+    createLogFile(logFile, dateFormatted);
+  }
+
+  const rel = journalRel(logFile);
+
+  // `atris log "sentence"` (or one slug-like word) appends to today's Inbox.
+  if (note && !wantsRepl) {
+    printCapture(asJson, captureNotes(logFile, [note]), [note], rel);
     return;
   }
 
@@ -56,16 +104,17 @@ function logAtris() {
     const piped = readPipedStdin();
     const lines = piped.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
     const notes = lines.filter((line) => line.toLowerCase() !== 'exit');
-    if (notes.length === 0) {
-      console.log(`Daily log REPL needs a terminal (${dateFormatted}).`);
-      console.log(`journal: ${rel}`);
-      console.log('Next: atris log --repl   # in a terminal, or atris log "note" / atris logs --json');
+    if (notes.length > 0 && !wantsRepl) {
+      printCapture(asJson, captureNotes(logFile, notes), notes, rel);
       return;
     }
-    for (const noteLine of notes) {
-      addInboxIdea(logFile, noteLine);
-    }
-    console.log(`captured ${notes.length} note${notes.length === 1 ? '' : 's'} in ${rel}`);
+    printReplNeeded(asJson, dateFormatted, rel);
+    return;
+  }
+
+  // Forced headless: never open a REPL.
+  if (forced) {
+    printReplNeeded(asJson, dateFormatted, rel);
     return;
   }
 

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,
 };