atris 3.56.0 → 3.56.2

package/commands/land.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const { runGit } = require('../lib/git-spawn');
+const { compactErrorPayload, printCliJson } = require('../lib/cli-json');
 const { listWorktrees, statusCounts } = require('./worktree');
 
 const DEFAULT_TTL_DAYS = 7;
@@ -236,14 +237,18 @@ function collectBoard(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_S
 // merged branch residue.
 function landSummary(cwd = process.cwd(), ttlDays = DEFAULT_TTL_DAYS) {
   const root = repoRoot(cwd);
-  if (!root) return null;
-  const board = collectBoard(root, { ttlDays, light: true });
-  return {
-    branches: board.summary.active + board.summary.due,
-    due: board.summary.due,
-    stale: board.summary.stale,
-    ttlDays,
-  };
+  if (!root || !hasCommits(root)) return null;
+  try {
+    const board = collectBoard(root, { ttlDays, light: true });
+    return {
+      branches: board.summary.active + board.summary.due,
+      due: board.summary.due,
+      stale: board.summary.stale,
+      ttlDays,
+    };
+  } catch {
+    return null;
+  }
 }
 
 function salvageDir(root) {
@@ -636,6 +641,40 @@ function readFollowingFlag(args, name, fallback = '') {
   return args[idx + 1] || fallback;
 }
 
+const EMPTY_LAND = {
+  not_a_git_repo: 'this folder is not a git repo yet, so there is nothing to land.',
+  no_commits: 'nothing is in the air yet because this folder has no commits.',
+  no_base: 'no master or main branch yet, so there is nothing to land.',
+};
+
+function emptyLandKindFromError(err) {
+  if (err && err.code === 'LAND_NO_BASE') return 'no_base';
+  const msg = String(err && err.message || err || '');
+  if (/not a git/i.test(msg)) return 'not_a_git_repo';
+  if (/no commits/i.test(msg)) return 'no_commits';
+  if (/no master\/main/i.test(msg)) return 'no_base';
+  return '';
+}
+
+function printEmptyLand(kind, json) {
+  const reason = EMPTY_LAND[kind] ? kind : 'no_base';
+  const detail = EMPTY_LAND[reason];
+  if (json) {
+    const payload = compactErrorPayload({ reason, detail });
+    printCliJson(payload, payload, ['--json']);
+  } else {
+    console.log(detail);
+  }
+  return 2;
+}
+
+function finishLandError(err, json) {
+  const kind = emptyLandKindFromError(err);
+  if (kind) return printEmptyLand(kind, json);
+  console.error(String(err && err.message || err).split('\n')[0]);
+  return 2;
+}
+
 function showHelp() {
   console.log('');
   console.log('atris land: the landing, what is actually done vs still in the air');
@@ -666,20 +705,14 @@ function landCommand(args = []) {
     showHelp();
     return 0;
   }
+  const json = args.includes('--json');
   const root = repoRoot();
-  if (!root) {
-    console.error('not a git repository. fix: git init -b main');
-    return 1;
-  }
-  if (!hasCommits(root)) {
-    console.error('no commits yet. fix: git commit --allow-empty -m init');
-    return 1;
-  }
+  if (!root) return printEmptyLand('not_a_git_repo', json);
+  if (!hasCommits(root)) return printEmptyLand('no_commits', json);
   const ttlRaw = readFollowingFlag(args, '--ttl', '');
   const ttlParsed = Number(ttlRaw);
   const ttlDays = ttlRaw !== '' && Number.isFinite(ttlParsed) && ttlParsed >= 0 ? ttlParsed : DEFAULT_TTL_DAYS;
   const base = readFollowingFlag(args, '--base', '');
-  const json = args.includes('--json');
 
   if (args.includes('--reap')) {
     try {
@@ -688,8 +721,7 @@ function landCommand(args = []) {
       else printReceipt(receipt);
       return 0;
     } catch (err) {
-      console.error(String(err && err.message || err));
-      return 1;
+      return finishLandError(err, json);
     }
   }
 
@@ -706,8 +738,7 @@ function landCommand(args = []) {
       else printStory(story);
       return 0;
     } catch (err) {
-      console.error(String(err && err.message || err));
-      return 1;
+      return finishLandError(err, json);
     }
   }
 
@@ -717,8 +748,7 @@ function landCommand(args = []) {
     else printBoard(board);
     return 0;
   } catch (err) {
-    console.error(String(err && err.message || err));
-    return 1;
+    return finishLandError(err, json);
   }
 }
 

package/commands/later.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const { argsWantHelp } = require('../lib/noninteractive');
+const {
+  laterNotePath,
+  listUserVisibleWork,
+  personName,
+  renderLaterRemember,
+  spokenLaterNote,
+  writeLaterNote,
+} = require('../lib/first-minute');
+
+function laterUsage() {
+  return 'Usage: atris later "<sentence>"';
+}
+
+function laterSentence(args = []) {
+  return spokenLaterNote((Array.isArray(args) ? args : [])
+    .filter((arg) => !String(arg).startsWith('-'))
+    .join(' '));
+}
+
+function laterAtris(args = process.argv.slice(3), {
+  root = process.cwd(),
+  log = console.log,
+} = {}) {
+  const list = Array.isArray(args) ? args : [];
+  if (argsWantHelp(list)) {
+    log(laterUsage());
+    return 0;
+  }
+  const sentence = laterSentence(list);
+  if (!sentence) {
+    log(laterUsage());
+    return 2;
+  }
+  writeLaterNote(root, sentence);
+  const files = listUserVisibleWork(root);
+  log('');
+  log(renderLaterRemember({
+    person: personName(),
+    sentence,
+    files,
+    root,
+  }));
+  return 0;
+}
+
+module.exports = {
+  laterAtris,
+  laterNotePath,
+};

package/commands/launchpad.js

@@ -3,6 +3,14 @@
 const fs = require('fs');
 const path = require('path');
 const { hasFlag, readFlag } = require('../lib/arg-parser');
+const {
+  isFreshWorkspace,
+  isKeepWorkingMinute,
+  isClaimMinute,
+  buildFirstMinute,
+  speakFirstMinute,
+  speakKeepWorkingMinute,
+} = require('../lib/first-minute');
 
 const ACTIVE_MISSION_STATUSES = new Set(['planning', 'running', 'ready']);
 
@@ -185,15 +193,18 @@ function loadTaskProjection(root) {
   };
 }
 
-function chooseNextAction({ root, actor, tasks, missions, brain, endgame }) {
-  if (!fs.existsSync(path.join(root, 'atris'))) {
-    return {
-      kind: 'bootstrap',
-      label: 'Initialize this workspace',
-      command: 'atris init',
-      why: 'No atris/ directory exists yet.',
-    };
+function hasLiveKeepWorkingRun(root = process.cwd()) {
+  try {
+    const { pickLiveLocalMission } = require('./mission');
+    return Boolean(pickLiveLocalMission(root));
+  } catch {
+    return false;
   }
+}
+
+function chooseNextAction({ actor, tasks, missions, brain, endgame }) {
+  // No-room folders belong to first-minute, not factory init.
+  // launchpadCommand speaks those two lines before this ranking runs.
 
   const ownClaimed = newest(tasks.filter(task => (
     task.status === 'claimed'
@@ -609,8 +620,32 @@ function launchpadCommand(args = []) {
     showLaunchpadHelp();
     return 0;
   }
-  const payload = collectLaunchpad(process.cwd(), args);
-  if (hasFlag(args, '--json')) {
+  const asJson = hasFlag(args, '--json');
+  const root = process.cwd();
+
+  // Fresh folder: empty talks first-talk. A file already here
+  // names that file, same as bare atris. Do not mint a room.
+  if (isFreshWorkspace(root)) {
+    return speakFirstMinute({ root, fresh: true, asJson });
+  }
+
+  // Just-minted file folder, nothing running: same two lines as
+  // first-minute / the next keep-working ready. After init, next is claim: same
+  // two lines as bare atris / status / now. Not factory init.
+  // A live mission still gets the board. --json on the claim
+  // path keeps the factory card for scripts.
+  if (!hasLiveKeepWorkingRun(root)) {
+    const minute = buildFirstMinute({ root });
+    if (isKeepWorkingMinute(minute)) {
+      return speakKeepWorkingMinute({ root, asJson });
+    }
+    if (!asJson && isClaimMinute(minute)) {
+      return speakFirstMinute({ root });
+    }
+  }
+
+  const payload = collectLaunchpad(root, args);
+  if (asJson) {
     console.log(JSON.stringify(payload, null, 2));
   } else {
     process.stdout.write(renderLaunchpad(payload));

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,