atris 3.30.8 → 3.31.0

package/lib/mission-runtime-loop.js

@@ -0,0 +1,320 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn, spawnSync } = require('child_process');
+
+function stripMissionQuotes(value) {
+  const text = String(value || '').trim();
+  if (text.length >= 2) {
+    const first = text[0];
+    const last = text[text.length - 1];
+    if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+      return text.slice(1, -1).trim();
+    }
+  }
+  return text;
+}
+
+function extractMissionFlag(text, flagName) {
+  const source = String(text || '');
+  const inline = new RegExp(`(^|\\s)${flagName}=([^\\s]+)(?=\\s|$)`).exec(source);
+  if (inline) {
+    return {
+      value: inline[2],
+      text: `${source.slice(0, inline.index)}${inline[1] || ''}${source.slice(inline.index + inline[0].length)}`.replace(/\s+/g, ' ').trim(),
+    };
+  }
+  const split = new RegExp(`(^|\\s)${flagName}\\s+([^\\s]+)(?=\\s|$)`).exec(source);
+  if (split) {
+    return {
+      value: split[2],
+      text: `${source.slice(0, split.index)}${split[1] || ''}${source.slice(split.index + split[0].length)}`.replace(/\s+/g, ' ').trim(),
+    };
+  }
+  return { value: null, text: source.trim() };
+}
+
+function stripBooleanFlag(text, flagName) {
+  return String(text || '').replace(new RegExp(`(^|\\s)${flagName}(?=\\s|$)`, 'g'), ' ').replace(/\s+/g, ' ').trim();
+}
+
+function hasBooleanFlag(text, flagName) {
+  return new RegExp(`(^|\\s)${flagName}(?=\\s|$)`).test(String(text || ''));
+}
+
+function missionRunIntentFromMessage(message) {
+  const text = String(message || '').trim();
+  const match = /^atris\s+mission\s+run(?:\s+([\s\S]+))?$/i.exec(text);
+  if (!match) return null;
+
+  let rest = String(match[1] || '').trim();
+  const ownerFlag = extractMissionFlag(rest, '--owner');
+  rest = ownerFlag.text;
+  const maxTicksFlag = extractMissionFlag(rest, '--max-ticks');
+  rest = maxTicksFlag.text;
+  const maxWallFlag = extractMissionFlag(rest, '--max-wall');
+  rest = maxWallFlag.text;
+  const cadenceFlag = extractMissionFlag(rest, '--cadence');
+  rest = cadenceFlag.text;
+  const noRun = hasBooleanFlag(rest, '--no-run') || hasBooleanFlag(rest, '--no-loop');
+  const noComplete = hasBooleanFlag(rest, '--no-complete');
+  rest = stripBooleanFlag(stripBooleanFlag(stripBooleanFlag(rest, '--no-run'), '--no-loop'), '--no-complete');
+  rest = rest.replace(/(^|\s)--json(?=\s|$)/g, ' ').replace(/\s+/g, ' ').trim();
+
+  const wantsLongRun = /\b(24\s*h|24\s*hours?|overnight|forever)\b/i.test(text);
+  return {
+    objective: stripMissionQuotes(rest),
+    owner: ownerFlag.value || process.env.ATRIS_AGENT_ID || 'mission-lead',
+    maxTicks: positiveInteger(maxTicksFlag.value, wantsLongRun ? 96 : 1),
+    maxWallSeconds: positiveInteger(maxWallFlag.value, wantsLongRun ? 86400 : 300),
+    cadence: cadenceFlag.value || (wantsLongRun ? '15m' : ''),
+    noRun,
+    noComplete,
+  };
+}
+
+function positiveInteger(value, fallback) {
+  const parsed = Number(value);
+  if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
+  return fallback;
+}
+
+function parseJson(stdout) {
+  const text = String(stdout || '').trim();
+  if (!text) return null;
+  return JSON.parse(text);
+}
+
+function runCliJsonSync(cliPath, args, options = {}) {
+  const result = spawnSync(process.execPath, [cliPath, ...args], {
+    cwd: options.cwd || process.cwd(),
+    encoding: 'utf8',
+    timeout: options.timeoutMs || 30000,
+    env: {
+      ...process.env,
+      ATRIS_SKIP_UPDATE_CHECK: '1',
+      ...(options.env || {}),
+    },
+  });
+  if (result.error) {
+    return { ok: false, status: 1, error: result.error.message || String(result.error), stdout: result.stdout || '', stderr: result.stderr || '' };
+  }
+  let payload = null;
+  try { payload = parseJson(result.stdout); } catch (error) {
+    return { ok: false, status: result.status || 1, error: `invalid JSON: ${error.message}`, stdout: result.stdout || '', stderr: result.stderr || '' };
+  }
+  return { ok: result.status === 0 && payload?.ok !== false, status: result.status || 0, payload, stdout: result.stdout || '', stderr: result.stderr || '' };
+}
+
+function runCliJsonStreaming(cliPath, args, options = {}) {
+  return new Promise((resolve) => {
+    const startedAt = Date.now();
+    const proc = spawn(process.execPath, [cliPath, ...args], {
+      cwd: options.cwd || process.cwd(),
+      env: {
+        ...process.env,
+        ATRIS_SKIP_UPDATE_CHECK: '1',
+        ...(options.env || {}),
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    let done = false;
+    let killedByTimeout = false;
+    let progressTimer = null;
+    const finish = (status) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      if (progressTimer) clearInterval(progressTimer);
+      let payload = null;
+      let error = '';
+      try { payload = parseJson(stdout); } catch (err) { error = `invalid JSON: ${err.message}`; }
+      resolve({
+        ok: status === 0 && !error && payload?.ok !== false,
+        status: status || 0,
+        payload,
+        stdout,
+        stderr,
+        error: killedByTimeout ? 'timeout' : error,
+      });
+    };
+    const timer = setTimeout(() => {
+      killedByTimeout = true;
+      try { proc.kill('SIGTERM'); } catch {}
+      setTimeout(() => { try { proc.kill('SIGKILL'); } catch {} }, 3000).unref();
+    }, options.timeoutMs || 660000);
+    progressTimer = options.onProgress
+      ? setInterval(() => {
+          options.onProgress(`still_running ${Math.max(1, Math.round((Date.now() - startedAt) / 1000))}`);
+        }, options.progressEveryMs || 15000)
+      : null;
+    if (progressTimer?.unref) progressTimer.unref();
+    proc.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+    proc.stderr.on('data', (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      if (options.onProgress) {
+        for (const line of text.split(/\r?\n/).map((item) => item.trim()).filter(Boolean)) {
+          options.onProgress(line);
+        }
+      }
+    });
+    proc.on('error', (error) => {
+      stderr += error.message || String(error);
+      finish(1);
+    });
+    proc.on('close', finish);
+  });
+}
+
+function missionGoalFromPayload(payload) {
+  const mission = payload?.mission || {};
+  const goal = payload?.atris_goal_state?.goal || {};
+  return {
+    objective: goal.objective || mission.objective,
+    mission_id: goal.mission_id || mission.id,
+    mission_status: goal.mission_status || mission.status,
+    runner: goal.runner || mission.runner || 'atris2',
+    next_command: goal.next_command || payload?.next_command || mission.next_action,
+  };
+}
+
+function firstUsefulLine(text, fallback = '') {
+  return String(text || '')
+    .split(/\r?\n/)
+    .map((line) => line.replace(/^[-*\s#]+/, '').trim())
+    .filter(Boolean)
+    .find((line) => !/^(receipt|summary|final|final answer|result)$/i.test(line))
+    || fallback;
+}
+
+function lastTickFromRun(runPayload) {
+  const ticks = Array.isArray(runPayload?.ticks) ? runPayload.ticks : [];
+  return ticks[ticks.length - 1] || null;
+}
+
+function workerLine(runPayload) {
+  const tick = lastTickFromRun(runPayload);
+  if (!tick) return '';
+  if (tick.atris2) return firstUsefulLine(tick.atris2.receipt_text, tick.atris2.ok ? 'Atris2 worker ran.' : 'Atris2 worker failed.');
+  if (tick.claude) return firstUsefulLine(tick.claude.receipt_text || tick.summary, 'Worker tick recorded.');
+  return tick.summary || tick.reason || '';
+}
+
+function formatRuntimeMissionLoopReceipt(result) {
+  const lines = [];
+  const goal = missionGoalFromPayload(result.start?.payload || {});
+  if (result.start?.payload) {
+    lines.push('Atris mission started');
+    lines.push(`Goal: ${goal.objective || '?'}`);
+    lines.push(`Mission: ${goal.mission_id || '?'} - ${goal.mission_status || '?'} - ${goal.runner || 'atris2'}`);
+  }
+  if (result.noRun) {
+    lines.push('Pursuing: not run (--no-run)');
+    lines.push('Achieved: no');
+    if (goal.next_command) lines.push(`Next: ${goal.next_command}`);
+    return lines.join('\n');
+  }
+  lines.push('Atris mission pursued');
+  if (result.run?.payload) {
+    const ran = Number(result.run.payload.ran_ticks || 0);
+    const total = Number(result.run.payload.tick_count || 0);
+    lines.push(`Ticks: ${ran}/${total}`);
+    const summary = workerLine(result.run.payload);
+    if (summary) lines.push(`Work: ${summary}`);
+  }
+  lines.push(`Achieved: ${result.achieved ? 'yes' : 'no'}`);
+  if (result.complete?.payload?.landing?.happened) lines.push(`Landing: ${result.complete.payload.landing.happened}`);
+  else if (result.run?.payload?.pause_reason) lines.push(`Blocked: ${result.run.payload.pause_reason}`);
+  else if (result.error) lines.push(`Blocked: ${result.error}`);
+  const proof = result.complete?.payload?.mission?.proof || result.run?.payload?.summary_receipt || result.start?.payload?.state_path;
+  if (proof) lines.push(`Proof: ${proof}`);
+  const nextGoal = result.complete?.payload?.continuation_goal?.mission?.objective;
+  if (nextGoal) lines.push(`Next goal: ${nextGoal}`);
+  const nextCommand = result.complete?.payload?.atris_goal_state?.goal?.next_command || result.run?.payload?.atris_goal_state?.goal?.next_command || goal.next_command;
+  if (nextCommand && !nextGoal) lines.push(`Next: ${nextCommand}`);
+  return lines.join('\n');
+}
+
+async function runRuntimeMissionLoop(intent, options = {}) {
+  const cliPath = options.cliPath;
+  const cwd = options.cwd || process.cwd();
+  if (!cliPath) return { ok: false, status: 1, error: 'missing cliPath', text: 'Blocked: missing cliPath' };
+  if (!intent?.objective) return { ok: false, status: 1, error: 'missing objective', text: 'Usage: atris mission run "<objective>"' };
+
+  const startArgs = ['mission', 'run', intent.objective, '--runner', 'atris2', '--owner', intent.owner || 'mission-lead', '--json'];
+  if (intent.cadence) startArgs.push('--cadence', intent.cadence);
+  const start = runCliJsonSync(cliPath, startArgs, { cwd, timeoutMs: 30000 });
+  const result = { ok: start.ok, status: start.status, start, noRun: intent.noRun === true, achieved: false };
+  if (!start.ok || !start.payload?.mission?.id) {
+    result.error = start.error || start.payload?.error || 'mission start failed';
+    result.text = formatRuntimeMissionLoopReceipt(result);
+    return result;
+  }
+  if (intent.noRun) {
+    result.text = formatRuntimeMissionLoopReceipt(result);
+    return result;
+  }
+
+  if (options.onProgress) options.onProgress(`pursuing ${start.payload.mission.id}`);
+  const maxWallSeconds = positiveInteger(intent.maxWallSeconds, 600);
+  const run = await runCliJsonStreaming(
+    cliPath,
+    ['mission', 'run', start.payload.mission.id, '--max-ticks', String(positiveInteger(intent.maxTicks, 1)), '--max-wall', String(maxWallSeconds), '--complete-on-pass', '--json'],
+    {
+      cwd,
+      timeoutMs: (maxWallSeconds + 60) * 1000,
+      onProgress: options.onProgress,
+    },
+  );
+  result.run = run;
+  if (!run.ok) {
+    result.ok = false;
+    result.status = run.status || 1;
+    result.error = run.error || run.payload?.error || 'mission run failed';
+    result.text = formatRuntimeMissionLoopReceipt(result);
+    return result;
+  }
+
+  if (run.payload?.mission?.status === 'complete') {
+    result.achieved = true;
+    result.ok = true;
+    result.text = formatRuntimeMissionLoopReceipt(result);
+    return result;
+  }
+
+  const mission = run.payload?.mission || {};
+  const ranTicks = Number(run.payload?.ran_ticks || 0);
+  const proof = run.payload?.summary_receipt || mission.receipt_path;
+  if (!intent.noComplete && ranTicks > 0 && !String(mission.verifier || '').trim() && proof) {
+    if (options.onProgress) options.onProgress(`landing ${mission.id}`);
+    const complete = runCliJsonSync(cliPath, ['mission', 'complete', mission.id, '--proof', proof, '--json'], { cwd, timeoutMs: 30000 });
+    result.complete = complete;
+    result.achieved = complete.ok && complete.payload?.action === 'mission_completed';
+    result.ok = result.achieved;
+    if (!complete.ok) result.error = complete.error || complete.payload?.error || 'mission complete failed';
+  } else {
+    result.ok = false;
+    result.error = run.payload?.pause_reason || (ranTicks > 0 ? 'mission still running' : 'no tick proof');
+  }
+  result.text = formatRuntimeMissionLoopReceipt(result);
+  return result;
+}
+
+function readAtrisGoalState(cwd = process.cwd()) {
+  try {
+    const file = path.join(cwd, '.atris', 'state', 'atris_goal.json');
+    if (!fs.existsSync(file)) return null;
+    return JSON.parse(fs.readFileSync(file, 'utf8'))?.goal || null;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  missionRunIntentFromMessage,
+  runRuntimeMissionLoop,
+  formatRuntimeMissionLoopReceipt,
+  readAtrisGoalState,
+};

package/lib/next-moves.js

@@ -21,6 +21,27 @@ function norm(title) {
   return String(title == null ? '' : title).trim().toLowerCase();
 }
 
+function titleKey(title) {
+  return norm(String(title == null ? '' : title).replace(/\s+/g, ' ').replace(/^title\s*:\s*/i, ''));
+}
+
+function isGenericInboxPlaceholder(title) {
+  const key = titleKey(title);
+  return /^(dogfood tick|autopilot tick|mission tick|run (one )?tick|tick|test idea|sample idea|placeholder idea|idea|todo|tbd)$/.test(key);
+}
+
+function cleanInboxMoveTitle(title) {
+  const raw = String(title == null ? '' : title).trim();
+  if (!raw) return null;
+  const titleLine = raw.match(/^title\s*:\s*(.+)$/i);
+  if (/^(task|status|action|tag|member|actor|proof|verify|checked|saved|changed|result|files?|commands?)\s*:/i.test(raw)) {
+    return null;
+  }
+  const cleaned = titleLine ? titleLine[1].trim() : raw;
+  if (isGenericInboxPlaceholder(cleaned)) return null;
+  return cleaned;
+}
+
 // Short, stable id so a kill on Tuesday still suppresses the same move on
 // Wednesday. Pure function of (source, title).
 function moveId(source, title) {
@@ -33,7 +54,8 @@ function moveId(source, title) {
   return `m_${(h >>> 0).toString(36)}`;
 }
 
-const WEIGHT = { roadmap: 100, task: 60, inbox: 40 };
+const WEIGHT = { roadmap: 100, mission: 90, endgame: 80, task: 60, inbox: 40 };
+const SELF_IMPROVEMENT_SEED_TITLE = 'Create the next proof-backed self-improvement task';
 
 // One section-boundary shape for every reader and writer: tolerate a header
 // suffix (e.g. "(priority)"), stop at a sibling/parent heading (## or #) or a
@@ -93,17 +115,119 @@ function readActiveTasks(root) {
   const tasks = Array.isArray(proj && proj.tasks) ? proj.tasks : [];
   return tasks
     .filter((t) => t && t.title && ['open', 'claimed'].includes(String(t.status || '').toLowerCase()))
+    .filter((t) => !isInternalNextMoveTask(t))
     .map((t) => ({
       title: String(t.title).trim(),
       why: `task in flight (${t.status}${t.claimed_by ? `, ${t.claimed_by}` : ''})`,
       source: 'task',
+      task_id: t.id || null,
       ref: t.display_id || t.id || null,
       weight: WEIGHT.task,
     }));
 }
 
+function isInternalNextMoveTask(task) {
+  const title = String(task?.title || '').trim();
+  const tags = [task?.tag, ...(Array.isArray(task?.tags) ? task.tags : [])]
+    .filter(Boolean)
+    .map((tag) => String(tag).toLowerCase());
+  return tags.includes('agent-xp') || /^mission xp\s*:/i.test(title);
+}
+
+function readHandledTaskTitles(root) {
+  const text = safeRead(path.join(root, '.atris', 'state', 'tasks.projection.json'));
+  if (!text) return [];
+  let proj;
+  try { proj = JSON.parse(text); } catch { return []; }
+  const tasks = Array.isArray(proj && proj.tasks) ? proj.tasks : [];
+  return tasks
+    .filter((t) => t && t.title && ['review', 'done'].includes(String(t.status || '').toLowerCase()))
+    .map((t) => String(t.title).trim())
+    .filter(Boolean);
+}
+
+function readJsonLines(file) {
+  const text = safeRead(file);
+  if (!text) return [];
+  return text.split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try { return JSON.parse(line); } catch { return null; }
+    })
+    .filter(Boolean);
+}
+
+function readActiveMissions(root) {
+  const rows = readJsonLines(path.join(root, '.atris', 'state', 'missions.jsonl'));
+  const latest = new Map();
+  for (const row of rows) {
+    if (row && row.id) latest.set(row.id, row);
+  }
+  return Array.from(latest.values())
+    .filter((m) => m && m.objective && !['complete', 'stopped', 'paused'].includes(String(m.status || '').toLowerCase()))
+    .map((m) => ({
+      title: String(m.objective).trim(),
+      why: `active mission (${m.status || 'unknown'}${m.owner ? `, ${m.owner}` : ''})`,
+      source: 'mission',
+      ref: m.id || null,
+      weight: m.status === 'blocked' ? WEIGHT.mission + 5 : WEIGHT.mission,
+    }));
+}
+
+function activeEndgameTaskCount(root) {
+  const text = safeRead(path.join(root, '.atris', 'state', 'tasks.projection.json'));
+  if (!text) return 0;
+  let proj;
+  try { proj = JSON.parse(text); } catch { return 0; }
+  const tasks = Array.isArray(proj && proj.tasks) ? proj.tasks : [];
+  return tasks.filter((t) => {
+    if (!t) return false;
+    const status = String(t.status || '').toLowerCase();
+    const tags = [t.tag, ...(Array.isArray(t.tags) ? t.tags : [])].filter(Boolean).map((tag) => String(tag).toLowerCase());
+    return tags.includes('endgame') && ['open', 'claimed', 'review'].includes(status);
+  }).length;
+}
+
+function todoKeepsEndgameActive(root) {
+  const text = safeRead(path.join(root, 'atris', 'TODO.md'));
+  if (!text) return true;
+  if (activeEndgameTaskCount(root) > 0) return true;
+
+  let sawEndgameHeader = false;
+  let section = '';
+  for (const raw of text.split(/\r?\n/)) {
+    const heading = raw.match(/^##\s+(.+?)\s*$/);
+    if (heading) {
+      section = heading[1].trim().toLowerCase();
+      if (section === 'endgame') sawEndgameHeader = true;
+      continue;
+    }
+    if (!/\[endgame\]/i.test(raw)) continue;
+    if (['backlog', 'in progress', 'review'].includes(section)) return true;
+  }
+  return !sawEndgameHeader;
+}
+
+function readEndgameMove(root) {
+  if (!todoKeepsEndgameActive(root)) return [];
+  let state = null;
+  try { state = JSON.parse(safeRead(path.join(root, 'atris', 'brain', 'state.json'))); } catch { state = null; }
+  const horizon = String(state?.endgame?.horizon || '').trim();
+  if (!horizon) return [];
+  return [{
+    title: horizon,
+    why: state?.endgame?.source ? `endgame: ${state.endgame.source}` : 'endgame horizon from compiled brain',
+    source: 'endgame',
+    weight: WEIGHT.endgame,
+  }];
+}
+
 function inboxItemsFrom(text) {
-  return parseInboxTitles(text).map((title) => ({ title, why: 'fresh idea in today\'s inbox', source: 'inbox', weight: WEIGHT.inbox }));
+  return parseInboxTitles(text)
+    .map(cleanInboxMoveTitle)
+    .filter(Boolean)
+    .map((title) => ({ title, why: 'fresh idea in today\'s inbox', source: 'inbox', weight: WEIGHT.inbox }));
 }
 
 // Most recent journal under atris/logs/YYYY/, parsed for ## Inbox items. Used to
@@ -132,6 +256,8 @@ function todayInboxItems(root) {
 function gatherCandidates(root = process.cwd()) {
   return [
     ...readRoadmapOpenItems(root),
+    ...readActiveMissions(root),
+    ...readEndgameMove(root),
     ...readActiveTasks(root),
     ...latestInboxItems(root),
   ];
@@ -144,16 +270,25 @@ function gatherCandidates(root = process.cwd()) {
 // only suppressed for IDEAS (roadmap/inbox), never for a real `task`, so killing
 // or approving an idea can't hide a genuine in-flight task that happens to share
 // the title.
-function pickNextMoves(candidates, { limit = 3, killedIds = [], killedTitles = [], approvedIds = [], approvedTitles = [] } = {}) {
+function pickNextMoves(candidates, {
+  limit = 3,
+  killedIds = [],
+  killedTitles = [],
+  approvedIds = [],
+  approvedTitles = [],
+  handledTaskTitles = [],
+} = {}) {
   const blockedIds = new Set([...killedIds, ...approvedIds]);
-  const blockedTitles = new Set([...killedTitles, ...approvedTitles].map(norm));
+  const blockedTitles = new Set([...killedTitles, ...approvedTitles].map(titleKey));
+  const handledTitles = new Set(handledTaskTitles.map(titleKey));
   const seen = new Set();
   return candidates
-    .map((c) => ({ ...c, id: moveId(c.source, c.title), _key: norm(c.title) }))
+    .map((c) => ({ ...c, id: moveId(c.source, c.title), _key: titleKey(c.title) }))
     .filter((c) => {
       if (!c._key) return false;
       if (blockedIds.has(c.id)) return false;
       if (c.source !== 'task' && blockedTitles.has(c._key)) return false;
+      if (c.source !== 'task' && handledTitles.has(c._key)) return false;
       return true;
     })
     .sort((a, b) => (b.weight || 0) - (a.weight || 0))
@@ -166,6 +301,63 @@ function pickNextMoves(candidates, { limit = 3, killedIds = [], killedTitles = [
     .slice(0, limit);
 }
 
+function cleanSuggestedTargetTitle(text) {
+  const clean = String(text || '')
+    .replace(/[`*_#>]+/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/[.!?:;,]+$/g, '');
+  if (!clean) return '';
+  return clean.charAt(0).toUpperCase() + clean.slice(1);
+}
+
+function suggestedTargetFromReportText(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const match = lines[index].match(/^\s*Suggested target:\s*(.+?)\s*$/i);
+    if (match) return cleanSuggestedTargetTitle(match[1]);
+  }
+  return '';
+}
+
+function latestSuggestedTarget(root = process.cwd()) {
+  const reportsDir = path.join(root, 'atris', 'reports');
+  let files;
+  try {
+    files = fs.readdirSync(reportsDir).filter((file) => /\.md$/i.test(file)).sort().reverse();
+  } catch {
+    return '';
+  }
+  for (const file of files) {
+    const target = suggestedTargetFromReportText(safeRead(path.join(reportsDir, file)));
+    if (target) return target;
+  }
+  return '';
+}
+
+function addMissionOnlyFallback(moves, limit = 3, root = process.cwd()) {
+  if (!Array.isArray(moves) || moves.length !== 1 || limit <= 1) return moves;
+  const mission = moves[0];
+  if (!mission || mission.source !== 'mission') return moves;
+  const suggested = latestSuggestedTarget(root);
+  const target = suggested && !isGenericInboxPlaceholder(suggested)
+    ? suggested
+    : SELF_IMPROVEMENT_SEED_TITLE;
+  return [
+    mission,
+    {
+      title: target,
+      why: target === SELF_IMPROVEMENT_SEED_TITLE
+        ? 'active mission has no concrete task queued'
+        : 'latest proof timeline suggested this self-improvement target',
+      source: 'mission',
+      ref: mission.ref || null,
+      weight: WEIGHT.mission - 35,
+      id: moveId('mission', target),
+    },
+  ].slice(0, limit);
+}
+
 const DECISIONS_FILE = ['.atris', 'state', 'moves.decisions.jsonl'];
 
 function decisionsPath(root) {
@@ -336,20 +528,34 @@ function pickRoadmapSeed(root = process.cwd()) {
 // so the ranking inputs live in one place.
 function nextMoves(root = process.cwd(), limit = 3) {
   const { killedIds, killedTitles, approvedIds, approvedTitles } = readDecisions(root);
-  return pickNextMoves(gatherCandidates(root), { limit, killedIds, killedTitles, approvedIds, approvedTitles });
+  const handledTaskTitles = readHandledTaskTitles(root);
+  const picked = pickNextMoves(gatherCandidates(root), { limit, killedIds, killedTitles, approvedIds, approvedTitles, handledTaskTitles });
+  return addMissionOnlyFallback(picked, limit, root);
 }
 
 module.exports = {
   moveId,
   norm,
+  titleKey,
+  isGenericInboxPlaceholder,
   WEIGHT,
+  SELF_IMPROVEMENT_SEED_TITLE,
+  cleanSuggestedTargetTitle,
+  suggestedTargetFromReportText,
+  latestSuggestedTarget,
   parseInboxTitles,
+  cleanInboxMoveTitle,
   readRoadmapOpenItems,
+  readActiveMissions,
+  readEndgameMove,
   readActiveTasks,
+  isInternalNextMoveTask,
+  readHandledTaskTitles,
   latestInboxItems,
   todayInboxItems,
   gatherCandidates,
   pickNextMoves,
+  addMissionOnlyFallback,
   nextMoves,
   readDecisions,
   recordDecision,