atris 3.30.8 → 3.31.0

package/commands/mission.js

@@ -15,11 +15,27 @@ const {
   normalizeOwnerSlug,
   resolveFunctionalOwner,
 } = require('../lib/functional-owner');
+const {
+  buildMissionRoom,
+  writeMissionRoomReceipt,
+  missionRoomLines,
+} = require('../lib/mission-room');
+const {
+  missionArtifactPaths,
+  writeMissionArtifact,
+} = require('../lib/mission-artifact');
+const {
+  pruneRuns,
+  runsPruneLines,
+  formatBytes,
+} = require('../lib/runs-prune');
 
 const VALID_STATUSES = new Set(['planning', 'running', 'ready', 'paused', 'blocked', 'stopped', 'complete']);
 const TERMINAL_STATUSES = new Set(['stopped', 'complete']);
 const GOAL_LOOP_STATUSES = new Set(['planning', 'running', 'ready']);
 const STATUS_ALIASES = new Set(['active']);
+const DEFAULT_LONG_RUN_VERIFIER = 'git diff --check';
+const SLEEP_LENGTH_BUDGET_SECONDS = 3600;
 
 function stampIso() {
   return new Date().toISOString();
@@ -84,6 +100,16 @@ function readPositiveIntegerFlag(args, name, fallback = null, options = {}) {
   return value;
 }
 
+function readNonNegativeIntegerFlag(args, name, fallback = null) {
+  const raw = readFlag(args, name, '');
+  if (!raw) return fallback;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${name} must be a non-negative integer.`);
+  }
+  return value;
+}
+
 function readRepeatedFlag(args, name) {
   const values = [];
   const prefix = `${name}=`;
@@ -147,6 +173,8 @@ function printJsonOrText(payload, lines, asJson) {
 const MISSION_RUN_VALUE_FLAGS = [
   '--max-ticks',
   '--max-wall',
+  '--minutes',
+  '--hours',
   '--cadence',
   '--owner',
   '--runner',
@@ -154,6 +182,10 @@ const MISSION_RUN_VALUE_FLAGS = [
   '--verify',
   '--stop',
   '--model',
+  '--native-goal-status',
+  '--native-goal-objective',
+  '--visible-goal-status',
+  '--visible-goal-objective',
 ];
 const MISSION_RUN_BOOLEAN_FLAGS = [
   '--json',
@@ -162,6 +194,16 @@ const MISSION_RUN_BOOLEAN_FLAGS = [
   '--no-verify',
   '--complete-on-pass',
   '--no-drain',
+  '--create-next',
+  '--spend-full-budget',
+  '--use-whole-budget',
+  '--stop-when-done',
+  '--room-preflight',
+  '--no-room-preflight',
+  '--room-auto-run',
+  '--no-room-auto-run',
+  '--allow-native-goal-supersede',
+  '--supersede-paused-native-goal',
   '--always-on',
   '--xp-task',
   '--agent-xp',
@@ -321,7 +363,7 @@ function createMissionXpTask(mission, root = process.cwd(), asJson = false) {
     taskDb.noteTask(db, {
       id: task.id,
       actor: process.env.ATRIS_AGENT_ID || owner,
-      content: `Mission goal loop XP bridge for ${mission.id}. Proof goes through task current-step; AgentXP lands only after human accept.`,
+      content: `Mission goal loop XP bridge for ${mission.id}. Proof goes through task current-step; AgentXP is awarded only after human approval.`,
     });
   }
   const { outPath } = writeMissionTaskProjection(taskDb, db, workspaceRoot);
@@ -345,7 +387,10 @@ function statePaths(root = process.cwd()) {
     missionsJsonl: path.join(stateDir, 'missions.jsonl'),
     eventsJsonl: path.join(stateDir, 'mission_events.jsonl'),
     codexGoalJson: path.join(stateDir, 'codex_goal.json'),
+    codexGoalRequestJson: path.join(stateDir, 'codex_goal_request.json'),
     codexGoalStatus: path.join(root, 'atris', 'status', 'codex-goal.md'),
+    atrisGoalJson: path.join(stateDir, 'atris_goal.json'),
+    atrisGoalStatus: path.join(root, 'atris', 'status', 'atris-goal.md'),
     statusNow: path.join(root, 'atris', 'status', 'now.md'),
     runsDir: path.join(root, 'atris', 'runs'),
   };
@@ -402,9 +447,21 @@ function terminalNextAction(status) {
 
 function normalizeMissionState(mission) {
   if (!mission) return mission;
+  let normalized = mission;
   const nextAction = terminalNextAction(mission.status);
-  if (!nextAction || mission.next_action === nextAction) return mission;
-  return { ...mission, next_action: nextAction };
+  if (nextAction && mission.next_action !== nextAction) {
+    normalized = { ...normalized, next_action: nextAction };
+  }
+  const effectiveVerifier = effectiveMissionVerifier(normalized);
+  const explicitVerifier = String(normalized.verifier || '').trim();
+  if (effectiveVerifier && effectiveVerifier !== explicitVerifier) {
+    return { ...normalized, effective_verifier: effectiveVerifier };
+  }
+  if (Object.prototype.hasOwnProperty.call(normalized, 'effective_verifier')) {
+    const { effective_verifier, ...withoutDerivedVerifier } = normalized;
+    return withoutDerivedVerifier;
+  }
+  return normalized;
 }
 
 function listMissions(root = process.cwd()) {
@@ -616,6 +673,7 @@ function completionGateLabel(gate) {
 function missionCompletionReceipt(mission, proof, xpNextCommand = null) {
   const gate = mission.completion_gate || {};
   const gateLabel = completionGateLabel(gate) || 'completion gate';
+  const happened = `${mission.objective} is complete.`;
   const checked = gate.source === 'receipt' && gate.receipt_path
     ? `I checked the passing verifier receipt ${gate.receipt_path}.`
     : gate.source === 'mission_state'
@@ -624,21 +682,23 @@ function missionCompletionReceipt(mission, proof, xpNextCommand = null) {
         ? 'No verifier was configured, so completion used the no-verifier gate.'
         : `I checked the ${gateLabel} completion gate.`;
   const tested = mission.verifier_result?.passed
-    ? `Verifier passed: ${mission.verifier_result.command || mission.verifier || 'configured verifier'}.`
+    ? missionVerifierHighLevelTestText(mission.verifier_result, mission)
     : mission.verifier
       ? `Completion proof is attached for verifier: ${mission.verifier}.`
       : 'No verifier command was recorded for this mission.';
   const landing = {
-    happened: `Mission completed: ${mission.objective}.`,
+    happened,
+    reason: missionHumanReasonText(mission, happened),
     checked,
     tested,
-    saved: `Saved complete mission ${mission.id}${proof ? ` with proof ${proof}` : ''}.`,
+    saved: proof ? `Proof saved at ${proof}.` : 'Proof saved in mission state.',
     decision: xpNextCommand
-      ? `Queue AgentXP next: ${xpNextCommand}`
-      : 'Mission is complete; start or resume the next mission if more work remains.',
+      ? 'Ready for human review; accept in Atris if the proof looks right.'
+      : 'Pick the next customer-facing move.',
   };
   const result = {
     changed: landing.happened,
+    reason: landing.reason,
     checked: landing.checked,
     tested: landing.tested,
     saved: landing.saved,
@@ -650,12 +710,657 @@ function missionCompletionReceipt(mission, proof, xpNextCommand = null) {
 function missionResultLines(completion) {
   const landing = completion?.landing || {};
   const result = completion?.result || {};
-  const lines = ['Result:'];
-  if (landing.happened) lines.push(`  What happened: ${landing.happened}`);
+  const lines = ['Landing:'];
+  if (landing.happened) lines.push(`  Changed: ${landing.happened}`);
+  if (landing.reason) lines.push(`  Why it matters: ${landing.reason}`);
+  if (landing.artifact) lines.push(`  Artifact: ${landing.artifact}`);
   if (landing.checked) lines.push(`  How I checked: ${landing.checked}`);
   if (landing.tested) lines.push(`  What I tested: ${landing.tested}`);
-  if (result.saved) lines.push(`  Saved: ${result.saved}`);
-  if (landing.decision) lines.push(`  Decision: ${landing.decision}`);
+  if (result.saved) lines.push(`  Proof: ${result.saved}`);
+  if (landing.decision) lines.push(`  Next: ${landing.decision}`);
+  return lines;
+}
+
+function missionSelfImprovementSeedAction(mission, root = process.cwd()) {
+  try {
+    const moves = require('../lib/next-moves');
+    const seed = moves.nextMoves(root, 3).find((move) => (
+      move
+      && move.source === 'mission'
+      && (!mission?.id || !move.ref || move.ref === mission.id)
+      && move.title !== mission.objective
+    ));
+    return seed ? `${seed.title}.` : '';
+  } catch {
+    return '';
+  }
+}
+
+function missionHumanNextAction(mission, root = process.cwd(), options = {}) {
+  if (!mission) return 'Pick the next customer-facing move.';
+  if (mission.goal_chain?.pause_ready) return 'Mission feels good; review proof, then complete, revise, or choose the next goal.';
+  if (mission.status === 'ready' && /^queue AgentXP review:/i.test(mission.next_action || '')) {
+    return 'Ready for human review; accept in Atris if the proof looks right.';
+  }
+  if (mission.status === 'ready' && mission.always_on) {
+    return options.allowSelfImprovementSeed
+      ? (missionSelfImprovementSeedAction(mission, root) || 'Run the next proof step.')
+      : 'Run the next proof step.';
+  }
+  if (mission.status === 'ready') return 'Review the proof, then complete the mission.';
+  if (mission.status === 'complete') return 'Pick the next customer-facing move.';
+  if (mission.status === 'blocked') return 'Fix the verifier failure or revise the mission.';
+  return 'Keep running the mission.';
+}
+
+function missionLandingStepSummary(summary) {
+  const clean = String(summary || '').replace(/\s+/g, ' ').trim();
+  if (!clean) return '';
+  const withoutLabel = clean
+    .replace(/^(?:landing|changed|summary|result|product proof|proof):\s*/i, '')
+    .trim();
+  if (!withoutLabel) return '';
+  const plainVerified = missionPlainVerifiedSummary(withoutLabel);
+  if (plainVerified) return plainVerified;
+  const beforeChecks = withoutLabel.split(/\s+(?:checks?|verified|proof):\s+/i)[0] || withoutLabel;
+  const clipped = missionLandingSentenceClip(beforeChecks, 220);
+  return clipped ? `${clipped}.` : '';
+}
+
+function missionHumanReasonText(mission, changed = '') {
+  const objective = String(mission?.objective || '').trim();
+  const text = `${objective} ${changed}`.toLowerCase();
+  if (/\b(human|plain|language|landing|proof|receipt|understand|readable)\b/.test(text)) {
+    return 'It makes the result understandable before a human accepts or rejects it.';
+  }
+  if (/\b(update|install|runner|autopilot|mission run|heartbeat)\b/.test(text)) {
+    return 'It proves the workflow works in the place people actually use it.';
+  }
+  return 'It turns the mission into a concrete result a human can accept, reject, or run again.';
+}
+
+function missionPlainVerifiedSummary(text) {
+  const clean = String(text || '').replace(/\s+/g, ' ').trim();
+  const shipped = clean.match(/^Verified\s+(.+?)\s+behavior\s+already\s+shipped\s+on\s+master\s*:/i);
+  if (!shipped) return '';
+  const topic = shipped[1].toLowerCase();
+  if (topic.includes('npm auto-update')) {
+    return 'Verified npm auto-update works for installed npm packages on master.';
+  }
+  if (topic.includes('runner-agnostic heartbeat')) {
+    return 'Verified autopilot and mission run use the same runner setup on master.';
+  }
+  return `Verified ${shipped[1]} is already working on master.`;
+}
+
+function missionLandingSentenceClip(text, max) {
+  const clean = String(text || '').replace(/\s+/g, ' ').trim();
+  if (!clean) return '';
+  if (clean.length <= max) return clean.replace(/[.!?:;,]+$/g, '').trim();
+  const sentence = clean.match(/^(.{24,220}?[.!?])\s+/);
+  const base = sentence ? sentence[1] : clean.slice(0, max);
+  return base
+    .replace(/\s+\S*$/, '')
+    .replace(/[.!?:;,]+$/g, '')
+    .replace(/\b(?:and|or|but|with|to|for|from|by|through|via|using|including|include|includes|plus|then|both|the|a|an|of|in|on|at|as)$/i, '')
+    .trim();
+}
+
+function missionLastStepSummary(ticks = []) {
+  for (let index = ticks.length - 1; index >= 0; index -= 1) {
+    const tick = ticks[index] || {};
+    const summary = missionLandingStepSummary(tick.summary || tick.claude?.summary || tick.atris2?.receipt_text || '');
+    if (summary) return summary;
+  }
+  return '';
+}
+
+function missionVerifierCheckedText(verifierResult, mission) {
+  if (!verifierResult) return 'Tick recorded; no verifier was run.';
+  const command = verifierResult.command || mission.verifier || 'configured verifier';
+  if (verifierResult.passed) {
+    if (/^git\s+diff\s+--check\b/i.test(command)) return 'I ran the diff cleanliness check.';
+    if (/\bnode\s+--test\b/i.test(command)) return 'I ran the behavior checks.';
+    return `Verifier passed: ${command}.`;
+  }
+  if (/^git\s+diff\s+--check\b/i.test(command)) return 'Diff cleanliness check failed.';
+  if (/\bnode\s+--test\b/i.test(command)) return 'Behavior checks failed.';
+  return `Verifier failed: ${command}.`;
+}
+
+function missionVerifierHighLevelTestText(verifierResult, mission) {
+  if (!verifierResult) return 'No automated verifier ran for this receipt; judge it from the receipt, changed files, and next action.';
+  const command = verifierResult.command || mission.verifier || 'configured verifier';
+  const outcome = verifierResult.passed ? 'passed' : 'failed';
+  if (/^git\s+diff\s+--check\b/i.test(command)) {
+    return `Diff cleanliness check ${outcome}: no whitespace or patch-format issues in the changed files.`;
+  }
+  if (/\bnode\s+--test\b/i.test(command) && /\btest\/mission-status\.test\.js\b/i.test(command)) {
+    return `Mission behavior checks ${outcome}: mission start, tick, completion, timeline landing, goal-chain, next-mission, and human-accept boundaries were exercised.`;
+  }
+  if (/\bnode\s+--test\b/i.test(command)) {
+    return `Automated behavior checks ${outcome}: the touched code path was exercised by Node tests.`;
+  }
+  return `Verifier command ${outcome}: ${command}.`;
+}
+
+function missionFallbackChangedText(mission, status, tickIndex, { ranTicks = null, effectiveMaxTicks = null } = {}) {
+  if (mission?.always_on && (status === 'ready' || status === 'running')) {
+    return 'Recorded a proof heartbeat for this always-on mission.';
+  }
+  if (status === 'ready') return `${mission.objective} is ready for review.`;
+  if (status === 'complete') return `${mission.objective} is complete.`;
+  if (status === 'blocked') return `${mission.objective} is blocked.`;
+  if (ranTicks != null && effectiveMaxTicks != null) {
+    return ranTicks > 0
+      ? `${mission.objective} ran ${ranTicks}/${effectiveMaxTicks} tick(s).`
+      : `${mission.objective} did not run a tick.`;
+  }
+  return `${mission.objective} recorded tick ${tickIndex}.`;
+}
+
+function missionTickResultLines(mission, tickIndex, receiptPath, verifierResult = null, stepSummary = '') {
+  return missionLandingLines(missionReceiptLanding(mission, {
+    tick: { tick_index: tickIndex },
+    summary: stepSummary,
+    verifier_result: verifierResult,
+  }, receiptPath));
+}
+
+function missionReceiptSummaryText(result) {
+  const tick = result?.tick || {};
+  return tick.summary
+    || tick.atris2?.receipt_text
+    || tick.claude?.receipt_text
+    || result?.summary
+    || result?.reason
+    || '';
+}
+
+function missionReceiptTickIndex(mission, result) {
+  const value = Number(result?.tick?.tick_index || mission?.last_tick_index || 0);
+  return Number.isFinite(value) && value > 0 ? value : 1;
+}
+
+function missionReceiptStatus(mission, result) {
+  const tickStatus = String(result?.tick?.status || '').trim();
+  if (tickStatus === 'blocked') return 'blocked';
+  if (result?.verifier_result?.passed === false) return 'blocked';
+  if (result?.verifier_result?.passed === true) return 'proof_ready';
+  return String(mission?.status || 'running');
+}
+
+function missionReceiptNextText(mission, result) {
+  if (result?.next) return String(result.next);
+  if (result?.landing?.next) return String(result.landing.next);
+  if (result?.verifier_result?.passed === true) {
+    return mission?.always_on ? 'Run the next proof step.' : 'Review the proof, then complete the mission.';
+  }
+  if (result?.verifier_result) return 'Fix the verifier failure or revise the mission.';
+  return missionHumanNextAction(mission);
+}
+
+function missionReceiptLanding(mission, result, receiptPath = '') {
+  const verifierResult = result?.verifier_result || null;
+  const status = missionReceiptStatus(mission, result);
+  const summary = missionReceiptSummaryText(result);
+  const changed = missionLandingStepSummary(summary)
+    || missionFallbackChangedText(mission, status, missionReceiptTickIndex(mission, result));
+  const checked = missionVerifierCheckedText(verifierResult, mission);
+  const tested = missionVerifierHighLevelTestText(verifierResult, mission);
+  const reason = missionHumanReasonText(mission, changed);
+  return {
+    schema: 'atris.result_landing.v1',
+    status,
+    changed,
+    reason,
+    checked,
+    tested,
+    proof: receiptPath ? `Receipt saved at ${receiptPath}.` : 'Receipt saved in mission run history.',
+    next: missionReceiptNextText(mission, result),
+    timeline_visible: !missionLandingChangedIsGenericTick(mission, changed),
+  };
+}
+
+function missionLandingLines(landing) {
+  if (!landing) return [];
+  return [
+    'Landing:',
+    `  Changed: ${landing.changed || landing.happened || 'Landing recorded.'}`,
+    `  Why it matters: ${landing.reason || landing.why || 'This makes the work easier to judge.'}`,
+    `  How I checked: ${landing.checked || 'No check recorded.'}`,
+    `  What I tested: ${landing.tested || 'No test summary recorded.'}`,
+    `  Proof: ${landing.proof || landing.saved || 'No proof path recorded.'}`,
+    `  Next: ${landing.next || landing.decision || 'Pick the next useful move.'}`,
+  ];
+}
+
+function missionStatusLandingLines(landing) {
+  const lines = missionLandingLines(landing);
+  if (!lines.length) return [];
+  return [
+    '  last landing:',
+    ...lines.slice(1).map((line) => `  ${line.trim()}`),
+  ];
+}
+
+function missionLastLanding(mission, root = process.cwd()) {
+  const receipt = readMissionReceipt(mission?.receipt_path, mission?.worktree_root || root);
+  const landing = receipt?.result?.landing;
+  if (!landing || typeof landing !== 'object') return null;
+  return {
+    ...landing,
+    receipt_path: mission.receipt_path || null,
+  };
+}
+
+function missionLandingChangedIsGenericTick(mission, changed) {
+  const text = String(changed || '').trim();
+  const objective = String(mission?.objective || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  if (!objective) return false;
+  return new RegExp(`^${objective} recorded tick \\d+\\.$`).test(text);
+}
+
+function normalizeMissionReceiptResult(mission, result, receiptPath = '') {
+  const object = result && typeof result === 'object' && !Array.isArray(result)
+    ? { ...result }
+    : { value: result };
+  if (!object.landing) {
+    object.landing = missionReceiptLanding(mission, object, receiptPath);
+  }
+  if (object.verifier_result && !('passed' in object)) {
+    object.passed = !!object.verifier_result.passed;
+  }
+  return object;
+}
+
+function missionRunStartNextLine(mission, nextCommand, warnings = []) {
+  if (warnings.length) return 'Add a verifier before completion, then run the first proof tick.';
+  if (isCodexGoalMission(mission) && !codexNativeGoalAck(mission)) {
+    return 'Start the visible goal, then continue this mission.';
+  }
+  if (/attach-task/.test(nextCommand || '')) return 'Attach task context, then continue this mission.';
+  return 'Run the first proof tick.';
+}
+
+function missionRunTakeoffLines(mission, { warnings = [], nextCommand = '' } = {}) {
+  const checked = mission.verifier
+    ? `Verifier configured: ${mission.verifier}.`
+    : 'No verifier was recorded for this mission.';
+  return [
+    'Takeoff:',
+    `  Goal: ${mission.objective}`,
+    `  Done when: ${mission.stop_condition || 'the mission has proof or a human decision'}.`,
+    ...(missionBudgetLine(mission) ? [`  Budget: ${missionBudgetLine(mission)}`] : []),
+    ...missionGoalChainLines(mission),
+    '  Proof: Mission state saved in .atris/state/missions.jsonl.',
+    `  Check: ${checked}`,
+    `  Next: ${missionRunStartNextLine(mission, nextCommand, warnings)}`,
+  ];
+}
+
+function missionRunPreflightSignals(text) {
+  const lower = String(text || '').toLowerCase().replace(/\s+/g, ' ');
+  return /\b(messy|shower|overnight|nonstop|forever|goal\s+after\s+goal|self[-\s]?improve|figure\s+out|think\s+through|thinkwell|what\s+to\s+do\s+next|keep\s+going|tell\s+me|right\s+mission\s+input|finish[-\s]+line)\b/i.test(lower);
+}
+
+function shouldMissionRunRoomPreflight(objective, args = []) {
+  if (hasFlag(args, '--no-room-preflight')) return false;
+  if (hasFlag(args, '--room-preflight')) return true;
+  return missionRunPreflightSignals(objective) || missionRunTrustedRoomSignals(objective);
+}
+
+function missionRunTrustedRoomSignals(text) {
+  const lower = String(text || '').toLowerCase().replace(/\s+/g, ' ');
+  return /\b(one[-\s]?message|autonomy|autonomous|self[-\s]?improve|improve\s+(atris|this|it)|keep\s+going|work\s+on\s+this|next\s+useful|goes?\s+off|no\s+junk|junk\s+state)\b/i.test(lower);
+}
+
+function shouldMissionRunTrustedRoom(rawObjective, args = []) {
+  if (hasFlag(args, '--no-room-auto-run')) return false;
+  if (hasFlag(args, '--room-auto-run')) return true;
+  return missionRunTrustedRoomSignals(rawObjective);
+}
+
+function missionRunConcreteTitle(value) {
+  const title = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!title) return '';
+  if (/^(go|go go|go go go|keep going|do it|start|run|continue)$/i.test(title)) return '';
+  if (title.length < 8) return '';
+  return title;
+}
+
+function selectMissionRunUsefulTarget(rawObjective, root = process.cwd()) {
+  try {
+    const moves = require('../lib/next-moves');
+    const rawTitle = missionRunConcreteTitle(rawObjective);
+    return moves.nextMoves(root, 8)
+      .filter((move) => missionRunConcreteTitle(move?.title))
+      .filter((move) => !rawTitle || String(move.title).trim() !== rawTitle)
+      .find((move) => move.source === 'task')
+      || moves.nextMoves(root, 8).find((move) => missionRunConcreteTitle(move?.title))
+      || null;
+  } catch {
+    return null;
+  }
+}
+
+function missionRunPreflightSentence(text, max = 140) {
+  const clean = String(text || '').replace(/\s+/g, ' ').trim();
+  if (clean.length <= max) return clean;
+  return `${clean.slice(0, max - 3).replace(/\s+\S*$/, '').trimEnd()}...`;
+}
+
+function missionRunPreflightObjective(rawObjective, room, owner) {
+  const name = room?.name || 'Mission Room';
+  const task = room?.task_plan_preview?.task || room?.truth_snapshot || rawObjective;
+  return `${name} with ${owner}: turn "${missionRunPreflightSentence(task)}" into one visible goal, task spine, proof receipt, and next action.`;
+}
+
+function missionRunTrustedObjective(rawObjective, room, target) {
+  const targetTitle = missionRunConcreteTitle(target?.title);
+  if (targetTitle) return targetTitle;
+  if (missionRunTrustedRoomSignals(rawObjective)) {
+    return 'Improve Atris one-message autonomy without creating junk mission state';
+  }
+  return missionRunPreflightObjective(rawObjective, room, room?.owner || 'mission-lead');
+}
+
+function buildMissionRunRoomPreflight(rawObjective, args = [], options = {}) {
+  if (!shouldMissionRunRoomPreflight(rawObjective, args)) return null;
+  const root = options.root || process.cwd();
+  const owner = options.owner || readFlag(args, '--owner', process.env.ATRIS_AGENT_ID || 'mission-lead');
+  const trustedRun = options.allowTrustedRun !== false && shouldMissionRunTrustedRoom(rawObjective, args);
+  const selectedTarget = trustedRun ? selectMissionRunUsefulTarget(rawObjective, root) : null;
+  const ownerResolution = resolveFunctionalOwner({
+    requestedOwner: owner,
+    title: selectedTarget?.title || rawObjective,
+    tag: readFlag(args, '--lane', 'workspace'),
+    goal: selectedTarget?.title || rawObjective,
+    root,
+    fallbackOwners: ['mission-lead', 'task-planner', 'architect', 'validator'],
+  });
+  const room = buildMissionRoom(rawObjective, {
+    root,
+    owner: ownerResolution.owner,
+    ownerResolution,
+    trustedRun,
+    selectedTarget,
+    verifier: trustedRun ? DEFAULT_LONG_RUN_VERIFIER : '',
+  });
+  const written = writeMissionRoomReceipt(room, { root });
+  const shapedObjective = trustedRun
+    ? missionRunTrustedObjective(rawObjective, written.room, selectedTarget)
+    : missionRunPreflightObjective(rawObjective, written.room, ownerResolution.owner);
+  return {
+    schema: 'atris.mission_run_preflight.v1',
+    source: 'mission_room',
+    raw_objective: rawObjective,
+    shaped_objective: shapedObjective,
+    visible_goal_objective: shapedObjective,
+    room_name: written.room.name,
+    room_receipt_path: written.relativePath,
+    owner: ownerResolution.owner,
+    owner_resolution: ownerResolution.reason,
+    trusted_run: trustedRun,
+    selected_target: selectedTarget ? {
+      title: selectedTarget.title,
+      source: selectedTarget.source,
+      task_id: selectedTarget.task_id || null,
+      ref: selectedTarget.ref || null,
+      why: selectedTarget.why || '',
+    } : null,
+    task_spine_required: !selectedTarget,
+    next_action: selectedTarget
+      ? 'run one proof tick for the selected existing task'
+      : 'attach task spine, then run one proof tick',
+  };
+}
+
+function missionRunTaskLabel(task) {
+  const ref = task?.ref || task?.display_id || task?.id || 'task';
+  return [ref, task?.title].filter(Boolean).join(' ');
+}
+
+function missionRunSelectedTaskTarget(preflight) {
+  const target = preflight?.selected_target;
+  if (!target || target.source !== 'task') return null;
+  const taskId = String(target.task_id || '').trim();
+  const ref = String(target.ref || taskId || '').trim();
+  if (!taskId && !ref) return null;
+  return {
+    task_id: taskId || ref,
+    task_ref: ref || taskId,
+    title: target.title || '',
+  };
+}
+
+function attachSelectedTargetTaskSpine(mission) {
+  const selected = missionRunSelectedTaskTarget(mission?.mission_run_preflight);
+  if (!selected) return mission;
+  const taskIds = Array.from(new Set([...(mission.task_ids || []), selected.task_id].filter(Boolean)));
+  return {
+    ...mission,
+    task_ids: taskIds,
+    current_task_id: selected.task_id,
+    task_ref: selected.task_ref,
+    task_scope_ref: selected.task_ref || selected.task_id,
+    selected_target_task: selected,
+    next_action: `work selected task then run: atris task current-step --goal-id ${selected.task_ref || selected.task_id} --as ${mission.owner} --proof "<proof>" --json`,
+  };
+}
+
+function missionRunCreatedNextChangedText(createdNext) {
+  const createdTask = createdNext?.ok ? createdNext.task : null;
+  if (createdTask) {
+    return `Created and claimed next task: ${missionRunTaskLabel(createdTask)}.`;
+  }
+  const activeTask = createdNext?.reason === 'active_task' ? createdNext.move : null;
+  if (activeTask) {
+    return `Kept active task: ${missionRunTaskLabel(activeTask)}. No duplicate was created.`;
+  }
+  return null;
+}
+
+function missionRunCreatedNextLine(createdNext, continuationGoal, mission) {
+  const createdTask = createdNext?.ok ? createdNext.task : null;
+  if (createdTask) {
+    return `Created next task: ${missionRunTaskLabel(createdTask)}.`;
+  }
+  const activeTask = createdNext?.reason === 'active_task' ? createdNext.move : null;
+  if (activeTask) {
+    return `Continue active task: ${missionRunTaskLabel(activeTask)}.`;
+  }
+  return continuationGoal?.mission
+    ? `Next mission: ${continuationGoal.mission.objective}.`
+    : missionHumanNextAction(mission, process.cwd(), { allowSelfImprovementSeed: true });
+}
+
+function missionRunTimelineCommand(mission) {
+  return `atris mission timeline ${mission.id} --limit 5`;
+}
+
+function missionRunExportCommand(mission) {
+  return `atris mission timeline ${mission.id} --all --write`;
+}
+
+function missionRunPrunePreviewCommand(mission) {
+  return `atris mission timeline ${mission.id} --prune-preview`;
+}
+
+function missionRunChangedText(mission, ranTicks, effectiveMaxTicks, ticks = [], createdNext = null) {
+  const stepChanged = missionLastStepSummary(ticks);
+  const createdNextChanged = missionRunCreatedNextChangedText(createdNext);
+  return createdNextChanged || stepChanged || missionFallbackChangedText(mission, mission.status, null, { ranTicks, effectiveMaxTicks });
+}
+
+function missionBudgetLine(mission) {
+  const contract = mission?.budget_contract;
+  if (!contract) return null;
+  return `${contract.plain_language} Limit: ${contract.budget_label}.`;
+}
+
+function missionSpendsFullBudget(mission) {
+  return mission?.budget_contract?.policy === 'spend_full_budget';
+}
+
+function missionFullBudgetRemainingSeconds(mission, nowMs = Date.now()) {
+  if (!missionSpendsFullBudget(mission)) return 0;
+  const budgetSeconds = Number(mission?.budget_contract?.requested_seconds || mission?.max_wall_seconds || 0);
+  if (!Number.isFinite(budgetSeconds) || budgetSeconds <= 0) return 0;
+  const startedMs = Date.parse(mission.started_at || mission.created_at || mission.updated_at || '');
+  if (!Number.isFinite(startedMs)) return 0;
+  return Math.max(0, Math.ceil((startedMs + budgetSeconds * 1000 - nowMs) / 1000));
+}
+
+function missionGoalChainIntent(text) {
+  const lower = String(text || '').toLowerCase().replace(/\s+/g, ' ');
+  return /\b(3\s*(?:or|-)?\s*4|three\s+or\s+four|multiple|child|subgoals?|goal\s+after\s+goal|keeps?\s+goaling|mission\s+feeling\s+good|feels?\s+good|validated\s+and\s+i\s+can\s+understand)\b/.test(lower)
+    || /\bset\s+a\s+goal\b.{0,160}\b(accomplish|complete|finish|prove)\w*\b.{0,200}\bnext\s+(?:useful\s+)?goal\b/.test(lower);
+}
+
+function missionGoalChainTargetCount(text) {
+  const lower = String(text || '').toLowerCase();
+  if (/\b3\s*(?:or|-)?\s*4\b|\bthree\s+or\s+four\b/.test(lower)) return 4;
+  const explicit = lower.match(/\b([3-4])\s+(?:goals?|child\s+goals?|subgoals?)\b/);
+  if (explicit) return Number(explicit[1]);
+  return 4;
+}
+
+function buildMissionGoalChain(objective, options = {}) {
+  const targetCount = Math.max(3, Math.min(4, Number(options.targetCount || missionGoalChainTargetCount(objective)) || 4));
+  const baseGoals = [
+    {
+      title: 'Find the novel mission',
+      done_when: 'A concrete mission is named with why it matters now.',
+      validation: 'Plain-English reason plus the source signal that made it worth doing.',
+    },
+    {
+      title: 'Split it into child goals',
+      done_when: 'The mission has a 3-4 step path with a clear first move.',
+      validation: 'Each child goal says what proof would make it done.',
+    },
+    {
+      title: 'Run the smallest proof',
+      done_when: 'One real artifact, code change, status output, or receipt exists.',
+      validation: 'A verifier, receipt, or inspectable output proves the work happened.',
+    },
+    {
+      title: 'Explain the pause or next goal',
+      done_when: 'The result says what changed, how it was checked, and whether to accept, revise, or continue.',
+      validation: 'The operator can understand the mission state without reading logs.',
+    },
+  ].slice(0, targetCount).map((goal, index) => ({
+    order: index + 1,
+    status: 'pending',
+    ...goal,
+  }));
+
+  return {
+    schema: 'atris.mission_goal_chain.v1',
+    mode: 'validated_child_goals',
+    status: 'planned',
+    target_count: targetCount,
+    done_count: 0,
+    current_goal_order: 1,
+    plain_language: 'One mission can be reached by several small goals, each with proof.',
+    pause_rule: 'Pause when the chain has proof strong enough to understand, accept, revise, or choose the next mission.',
+    validation_rule: 'Every child goal must leave a receipt, verifier result, artifact, or explicit stop reason.',
+    goals: baseGoals,
+  };
+}
+
+function missionGoalChainCounts(goalChain) {
+  const goals = Array.isArray(goalChain?.goals) ? goalChain.goals : [];
+  const done = goals.filter((goal) => goal?.status === 'done').length;
+  return { done, total: goals.length };
+}
+
+function missionGoalChainPendingGoal(goalChain) {
+  const goals = Array.isArray(goalChain?.goals) ? goalChain.goals : [];
+  return goals.find((goal) => goal?.status !== 'done' && goal?.status !== 'blocked') || null;
+}
+
+function missionGoalChainNextAction(goalChain) {
+  const goal = missionGoalChainPendingGoal(goalChain);
+  if (!goal) return 'continue child-goal chain';
+  return `continue child goal ${goal.order}: ${goal.title}`;
+}
+
+function advanceMissionGoalChain(goalChain, summary, verifierResult = null) {
+  if (!goalChain || !Array.isArray(goalChain.goals) || !goalChain.goals.length) return goalChain || null;
+  const cleanSummary = String(summary || '').replace(/\s+/g, ' ').trim();
+  if (!cleanSummary && !verifierResult) return goalChain;
+
+  const goals = goalChain.goals.map((goal) => ({ ...goal }));
+  const nextIndex = goals.findIndex((goal) => goal.status !== 'done');
+  if (nextIndex === -1) return goalChain;
+
+  const validationResult = verifierResult
+    ? (verifierResult.passed ? 'Verifier passed.' : 'Verifier failed; this goal needs repair.')
+    : 'Summary receipt recorded.';
+  goals[nextIndex] = {
+    ...goals[nextIndex],
+    status: verifierResult && !verifierResult.passed ? 'blocked' : 'done',
+    completed_at: stampIso(),
+    result: cleanSummary.slice(0, 240) || validationResult,
+    validation_result: validationResult,
+  };
+
+  const counts = missionGoalChainCounts({ goals });
+  const blocked = goals.some((goal) => goal.status === 'blocked');
+  const nextPending = goals.find((goal) => goal.status !== 'done' && goal.status !== 'blocked');
+  return {
+    ...goalChain,
+    goals,
+    done_count: counts.done,
+    current_goal_order: nextPending ? nextPending.order : null,
+    status: blocked ? 'blocked' : counts.done >= counts.total ? 'validated' : 'running',
+    pause_ready: !blocked && counts.done >= counts.total,
+  };
+}
+
+function missionGoalChainLines(mission) {
+  const chain = mission?.goal_chain;
+  if (!chain || !Array.isArray(chain.goals) || !chain.goals.length) return [];
+  const counts = missionGoalChainCounts(chain);
+  const lines = [
+    `  goal chain: ${counts.done}/${counts.total} done; ${chain.pause_rule}`,
+  ];
+  for (const goal of chain.goals) {
+    const mark = goal.status === 'done' ? '[x]' : goal.status === 'blocked' ? '[!]' : '[ ]';
+    lines.push(`    ${mark} ${goal.order}. ${goal.title} -> ${goal.validation}`);
+  }
+  return lines;
+}
+
+function missionRunSummaryLines(mission, ranTicks, effectiveMaxTicks, finalReceipt, pauseReason = null, continuationGoal = null, ticks = [], createdNext = null) {
+  const changed = missionRunChangedText(mission, ranTicks, effectiveMaxTicks, ticks, createdNext);
+  const reason = missionHumanReasonText(mission, changed);
+  const verifier = mission.verifier_result;
+  const checked = verifier
+    ? missionVerifierCheckedText(verifier, mission)
+    : pauseReason
+      ? `Run paused: ${pauseReason}.`
+      : 'Run recorded; no verifier was run.';
+  const tested = verifier
+    ? missionVerifierHighLevelTestText(verifier, mission)
+    : mission.verifier
+      ? `Verifier was configured but not completed: ${mission.verifier}.`
+      : 'No verifier command was recorded for this mission.';
+  const nextLine = missionRunCreatedNextLine(createdNext, continuationGoal, mission);
+  const lines = [
+    'Landing:',
+    `  Changed: ${changed}`,
+    `  Why it matters: ${reason}`,
+    ...(missionBudgetLine(mission) ? [`  Budget: ${missionBudgetLine(mission)}`] : []),
+    `  How I checked: ${checked}`,
+    `  What I tested: ${tested}`,
+    `  Proof: Summary receipt saved at ${finalReceipt}.`,
+    `  Timeline: ${missionRunTimelineCommand(mission)}`,
+    `  Export: ${missionRunExportCommand(mission)}`,
+    `  Prune preview: ${missionRunPrunePreviewCommand(mission)}`,
+    `  Next: ${nextLine}`,
+  ];
   return lines;
 }
 
@@ -761,6 +1466,7 @@ function missionTaskSpine(mission) {
   const taskRef = mission.xp_task?.ref
     || mission.task_ref
     || (taskId ? String(taskId) : null);
+  const taskScopeRef = mission.task_scope_ref || mission.id;
   const owner = ownerResolution.owner;
   return {
     schema: 'atris.mission_task_spine.v1',
@@ -776,7 +1482,7 @@ function missionTaskSpine(mission) {
     task_ref: taskRef,
     has_task: Boolean(taskId || taskRef),
     current_step_command: taskId || taskRef
-      ? `atris task current-step --goal-id ${mission.id} --as ${owner} --proof "<proof>" --json`
+      ? `atris task current-step --goal-id ${taskScopeRef} --as ${owner} --proof "<proof>" --json`
       : null,
     ensure_task_command: taskId || taskRef
       ? null
@@ -802,6 +1508,7 @@ function missionStatusView(mission) {
     current_task_id: taskSpine.current_task_id,
     task_ref: taskSpine.task_ref,
     task_spine: taskSpine,
+    last_landing: missionLastLanding(mission),
   };
 }
 
@@ -814,13 +1521,22 @@ function missionFromArgs(args) {
     '--lane',
     '--verify',
     '--stop',
+    '--max-wall',
+    '--minutes',
+    '--hours',
+    '--base',
     '--task',
     '--ask',
     '--model',
-  ], ['--json', '--always-on', '--xp-task', '--agent-xp', '--worktree']).join(' ').trim();
+    '--native-goal-status',
+    '--native-goal-objective',
+    '--visible-goal-status',
+    '--visible-goal-objective',
+  ], ['--json', '--always-on', '--xp-task', '--agent-xp', '--worktree', '--spend-full-budget', '--use-whole-budget', '--stop-when-done', '--allow-native-goal-supersede', '--supersede-paused-native-goal']).join(' ').trim();
   if (!objective) {
     exitMissionError('Usage: atris mission start "<objective>" --owner <member> [--verify "..."] [--cadence manual] [--worktree]', 1, wantsJson(args));
   }
+  const budgetContract = inferRunObjectiveBudgetContract(objective, args);
   const requestedOwner = readFlag(args, '--owner', process.env.ATRIS_AGENT_ID || 'mission-lead');
   const cadence = readFlag(args, '--cadence', readFlag(args, '--loop', 'manual')) || 'manual';
   const runner = readFlag(args, '--runner', 'manual');
@@ -837,7 +1553,7 @@ function missionFromArgs(args) {
   const owner = ownerResolution.owner;
   const verifier = readFlag(args, '--verify', '');
   assertMissionVerifier(verifier, wantsJson(args));
-  const stopCondition = readFlag(args, '--stop', verifier ? 'verifier passes and no human asks remain' : 'human marks complete with proof');
+  const stopCondition = readFlag(args, '--stop', budgetStopCondition(budgetContract) || (verifier ? 'verifier passes and no human asks remain' : 'human marks complete with proof'));
   const taskIds = readRepeatedFlag(args, '--task');
   const humanAsks = readRepeatedFlag(args, '--ask');
   const alwaysOn = hasFlag(args, '--always-on');
@@ -872,12 +1588,16 @@ function missionFromArgs(args) {
     created_at: stampIso(),
     updated_at: stampIso(),
   };
+  if (budgetContract) {
+    mission.budget_contract = budgetContract;
+    if (budgetContract.requested_seconds) mission.max_wall_seconds = budgetContract.requested_seconds;
+  }
   if (alwaysOn) mission.next_action = nextCandidateTickAction(mission);
   return mission;
 }
 
 function missingVerifierWarning(mission) {
-  if (String(mission.verifier || '').trim()) return null;
+  if (effectiveMissionVerifier(mission)) return null;
   return {
     code: 'missing_verifier',
     message: 'Mission has no verifier; it cannot complete automatically and future runs will report unverified worktree side effects.',
@@ -899,6 +1619,9 @@ function missionRunSmokeVerifier() {
     "if(p.action!=='mission_run_started')process.exit(2)",
     "if(p.mission?.runner!=='codex_goal')process.exit(3)",
     "if(p.codex_goal_state?.goal?.visible_goal?.schema!=='atris.visible_chat_goal_bridge.v1')process.exit(4)",
+    "if(p.requires_native_goal_start!==true)process.exit(5)",
+    "if(p.native_goal_action?.tool!=='create_goal')process.exit(6)",
+    "if(!/create_goal/.test(p.next_command||''))process.exit(7)",
   ].join(';');
   return `node -e ${JSON.stringify(script)}`;
 }
@@ -914,57 +1637,844 @@ function inferRunObjectiveVerifier(objective, root = process.cwd()) {
   return missionRunSmokeVerifier();
 }
 
-function markMissionRunContinuation(mission) {
+function durationSecondsFromText(text) {
+  const match = String(text || '').match(/\b(\d+(?:\.\d+)?)[-\s]*(s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days)\b/i);
+  if (!match) return null;
+  const value = Number(match[1]);
+  if (!Number.isFinite(value) || value <= 0) return null;
+  const unit = match[2].toLowerCase();
+  if (/^d/.test(unit)) return Math.round(value * 86400);
+  if (/^h/.test(unit)) return Math.round(value * 3600);
+  if (/^m(?!s)/.test(unit)) return Math.round(value * 60);
+  return Math.round(value);
+}
+
+function durationLabel(seconds, fallback = 'the requested time') {
+  const value = Number(seconds);
+  if (!Number.isFinite(value) || value <= 0) return fallback;
+  if (value % 86400 === 0) {
+    const days = value / 86400;
+    return `${days} day${days === 1 ? '' : 's'}`;
+  }
+  if (value % 3600 === 0) {
+    const hours = value / 3600;
+    return `${hours} hour${hours === 1 ? '' : 's'}`;
+  }
+  if (value % 60 === 0) {
+    const minutes = value / 60;
+    return `${minutes} minute${minutes === 1 ? '' : 's'}`;
+  }
+  return `${value} second${value === 1 ? '' : 's'}`;
+}
+
+function wantsFullBudget(text, args = []) {
+  if (hasFlag(args, '--spend-full-budget') || hasFlag(args, '--use-whole-budget')) return true;
+  if (hasFlag(args, '--hours') || hasFlag(args, '--minutes')) return true;
+  const compact = String(text || '').toLowerCase().replace(/\s+/g, ' ');
+  const duration = '\\d+(?:\\.\\d+)?[-\\s]*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days)';
+  return /\b(use|spend)\s+(the\s+)?(whole|full|entire)\s+(time|budget|window)\b/.test(compact)
+    || /\b(use|spend)\s+(the\s+)?(whole|full|entire)\s+\d/.test(compact)
+    || new RegExp(`\\b(?:spend|use)\\s+${duration}\\b`).test(compact)
+    || new RegExp(`(?:^|\\b)(?:run|work|think|research|investigate|brainstorm|plan|map|audit|explore|study|analyze|build)\\s+(?:[^.!?;]{0,80}\\s+)?for\\s+${duration}\\b`).test(compact)
+    || new RegExp(`^\\s*for\\s+${duration}\\b`).test(compact)
+    || /\bfor\s+the\s+(whole|full|entire)\s+/.test(compact)
+    || /\bkeep\s+going\s+until\s+(time|the\s+time|budget|the\s+budget)\s+(is\s+)?(up|done|spent|used)\b/.test(compact)
+    || /\b(run|work|stop|continue)\s+(until|till)\s+(the\s+)?(time|budget)\s+(is\s+)?(up|done|spent|used)\b/.test(compact);
+}
+
+function sleepLengthBudgetIntent(requestedSeconds, text = '') {
+  const seconds = Number(requestedSeconds);
+  return /\b(overnight|while\s+i\s+(?:sleep|am\s+sleeping|['’]?m\s+sleeping)|sleep(?:ing)?\s+run)\b/i.test(text)
+    || (Number.isFinite(seconds) && seconds >= SLEEP_LENGTH_BUDGET_SECONDS);
+}
+
+function inferRunObjectiveBudgetContract(objective, args = []) {
+  const text = `${objective || ''} ${Array.isArray(args) ? args.join(' ') : ''}`;
+  const explicitHours = Number(readFlag(args, '--hours', ''));
+  const explicitMinutes = Number(readFlag(args, '--minutes', ''));
+  const explicitMaxWall = Number(readFlag(args, '--max-wall', ''));
+  const explicitSeconds = Number.isFinite(explicitHours) && explicitHours > 0
+    ? Math.round(explicitHours * 3600)
+    : (Number.isFinite(explicitMinutes) && explicitMinutes > 0
+      ? Math.round(explicitMinutes * 60)
+      : (Number.isFinite(explicitMaxWall) && explicitMaxWall > 0 ? Math.round(explicitMaxWall) : null));
+  const requestedSeconds = explicitSeconds || durationSecondsFromText(text);
+  const overnight = /\bovernight\b/i.test(text);
+  if (!requestedSeconds && !overnight) return null;
+  const spendBudget = !hasFlag(args, '--stop-when-done')
+    && (wantsFullBudget(text, args) || sleepLengthBudgetIntent(requestedSeconds, text));
+  const policy = spendBudget
+    ? 'spend_full_budget'
+    : 'stop_when_done';
+  const budgetLabel = requestedSeconds
+    ? durationLabel(requestedSeconds)
+    : 'the overnight window';
+  const plainLanguage = policy === 'spend_full_budget'
+    ? 'Use the whole time.'
+    : 'Finish early if solved.';
+  const stopRule = policy === 'spend_full_budget'
+    ? `Use the whole ${budgetLabel}; keep picking the next useful move until time is up, unless blocked or unsafe.`
+    : `Use up to ${budgetLabel}; stop early when the mission is done, proven, or blocked.`;
   return {
-    ...mission,
-    started_from: 'mission_run_objective',
-    continue_on_complete: true,
-    continuation_policy: 'decide_and_start_next_useful_mission',
+    schema: 'atris.mission_budget_contract.v1',
+    requested_seconds: requestedSeconds,
+    budget_label: budgetLabel,
+    policy,
+    plain_language: plainLanguage,
+    stop_rule: stopRule,
   };
 }
 
-function continuationObjective(parent) {
-  return `Decide and start the next useful mission after: ${parent.objective}`;
+function budgetStopCondition(contract) {
+  if (!contract) return '';
+  if (contract.policy === 'spend_full_budget') {
+    return `run for ${contract.budget_label}; use the whole time unless blocked or unsafe`;
+  }
+  return `run for ${contract.budget_label}, or stop early when proof is strong enough`;
 }
 
-function findActiveContinuationMission(parent, root = process.cwd()) {
-  return listMissions(root).find((mission) => (
-    mission.parent_mission_id === parent.id
-    && mission.started_from === 'mission_run_continuation'
-    && !TERMINAL_STATUSES.has(mission.status)
-  )) || null;
+function inferRunObjectiveLoopOptions(objective, args = []) {
+  const text = `${objective || ''} ${Array.isArray(args) ? args.join(' ') : ''}`;
+  const hoursMatch = text.match(/\b(\d+(?:\.\d+)?)\s*(h|hr|hrs|hour|hours)\b/i);
+  const requestedHours = hoursMatch ? Number(hoursMatch[1]) : null;
+  const wantsLongRun = /\b(overnight|nonstop|forever|goal\s+after\s+goal|self[-\s]?improve)\b/i.test(text)
+    || (Number.isFinite(requestedHours) && requestedHours > 0);
+  if (!wantsLongRun) return { wantsLongRun: false, requestedHours: null, cadence: '' };
+  return {
+    wantsLongRun: true,
+    requestedHours: Number.isFinite(requestedHours) && requestedHours > 0 ? requestedHours : null,
+    cadence: readFlag(args, '--cadence', '13m'),
+  };
 }
 
-function findActiveMissionRunContinuation(root = process.cwd(), excludeId = '') {
-  const excluded = String(excludeId || '');
-  const candidates = listMissions(root)
-    .filter((mission) => (
-      mission.id !== excluded
-      && mission.started_from === 'mission_run_continuation'
-      && mission.continuation_policy === 'choose_next_mission'
-      && !TERMINAL_STATUSES.has(mission.status)
-    ));
-  candidates.sort((a, b) => missionSortTime(b) - missionSortTime(a));
-  return candidates[0] || null;
+function missionLongRunIntent(mission) {
+  const text = `${mission?.objective || ''} ${mission?.stop_condition || ''}`;
+  return Boolean(mission?.overnight_loop)
+    || /\b(overnight|nonstop|forever|goal\s+after\s+goal|self[-\s]?improve)\b/i.test(text);
 }
 
-function completeActiveContinuationForStartedMission(nextMission, root = process.cwd()) {
-  const continuation = findActiveMissionRunContinuation(root, nextMission?.id);
-  if (!continuation || !nextMission) return null;
-  if (continuation.objective === nextMission.objective) return null;
+function missionChoosesNextMission(mission) {
+  return mission?.started_from === 'mission_run_continuation'
+    && mission?.continuation_policy === 'choose_next_mission';
+}
 
-  const proof = `Started next mission ${nextMission.id}: ${nextMission.objective}`;
-  const completionGate = { ok: true, source: 'mission_run_continuation', forced: false };
-  const baseNext = {
-    ...continuation,
-    status: 'complete',
-    completed_at: stampIso(),
-    proof,
-    completion_gate: completionGate,
-    continued_by_mission_id: nextMission.id,
-    continued_by_objective: nextMission.objective,
-    next_action: 'mission complete',
-  };
+function isConcreteContinuationTarget(title) {
+  const text = String(title || '').trim();
+  if (!text) return false;
+  if (/^decide and start the next useful mission after:/i.test(text)) return false;
+  if (/<next useful mission>/i.test(text)) return false;
+  if (/^create the next proof-backed self-improvement task$/i.test(text)) return false;
+  return true;
+}
+
+function continuationTargetKey(title) {
+  return String(title || '')
+    .replace(/^mission xp:\s*/i, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+function handledContinuationTargetKeys(root, moves) {
+  const keys = new Set();
+  const add = (title) => {
+    const key = continuationTargetKey(title);
+    if (key) keys.add(key);
+  };
+  try {
+    for (const title of moves.readHandledTaskTitles(root)) add(title);
+  } catch {
+    // Best-effort guard; mission state below still catches completed missions.
+  }
+  try {
+    for (const row of listMissions(root)) {
+      add(row.objective);
+    }
+  } catch {
+    // If mission state is unreadable, fall back to the remaining explicit filters.
+  }
+  return keys;
+}
+
+function readTaskProjectionForMission(root = process.cwd()) {
+  const file = path.join(root, '.atris', 'state', 'tasks.projection.json');
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return Array.isArray(parsed?.tasks) ? parsed.tasks : [];
+  } catch {
+    return [];
+  }
+}
+
+function taskTags(task) {
+  return [
+    task?.tag,
+    ...(Array.isArray(task?.tags) ? task.tags : []),
+    ...(Array.isArray(task?.metadata?.tags) ? task.metadata.tags : []),
+  ]
+    .filter(Boolean)
+    .map((tag) => String(tag).trim().toLowerCase())
+    .filter(Boolean);
+}
+
+function certifiedReviewNextTaskCandidates(root = process.cwd()) {
+  return readTaskProjectionForMission(root)
+    .filter((task) => String(task?.status || '').toLowerCase() === 'review')
+    .filter((task) => task?.review?.agent_certified === true || task?.metadata?.agent_certified === true)
+    .map((task) => ({
+      title: task?.review?.next_task || task?.metadata?.latest_agent_next_task || '',
+      why: `certified review ${task.display_id || task.id || ''} suggested this next task`.trim(),
+      source: 'certified_review_next_task',
+      ref: task.display_id || task.id || null,
+      weight: 95,
+    }))
+    .filter((move) => String(move.title || '').trim());
+}
+
+function endgameBacklogCandidates(root = process.cwd()) {
+  return readTaskProjectionForMission(root)
+    .filter((task) => String(task?.status || '').toLowerCase() === 'open')
+    .filter((task) => taskTags(task).includes('endgame'))
+    .map((task) => ({
+      title: String(task.title || '').trim(),
+      why: `open endgame backlog task ${task.display_id || task.id || ''}`.trim(),
+      source: 'endgame_backlog',
+      ref: task.display_id || task.id || null,
+      weight: 85,
+    }))
+    .filter((move) => move.title);
+}
+
+function cleanWikiNextIngestTitle(value) {
+  return String(value || '')
+    .replace(/`([^`]+)`/g, '$1')
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+    .replace(/^[-*]\s*/, '')
+    .replace(/^next[- ]?ingests?\s*:\s*/i, '')
+    .replace(/^next source\s*:\s*/i, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/[.!?:;,]+$/g, '');
+}
+
+function wikiStatusNextIngestCandidates(root = process.cwd()) {
+  const file = path.join(root, 'atris', 'wiki', 'STATUS.md');
+  let text = '';
+  try { text = fs.readFileSync(file, 'utf8'); } catch { return []; }
+  const out = [];
+  let inSection = false;
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (/^#+\s+next[- ]?ingests?\b/i.test(line)) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && /^#+\s+/.test(line)) inSection = false;
+    const direct = line.match(/^[-*]?\s*next[- ]?ingests?\s*:\s*(.+)$/i)
+      || line.match(/^[-*]?\s*next source\s*:\s*(.+)$/i);
+    if (direct) {
+      const title = cleanWikiNextIngestTitle(direct[1]);
+      if (title) out.push(title);
+      continue;
+    }
+    if (inSection && /^[-*]\s+/.test(line)) {
+      const title = cleanWikiNextIngestTitle(line);
+      if (title) out.push(title);
+    }
+  }
+  return out.map((title) => ({
+    title: /^ingest\b/i.test(title) ? title : `Ingest ${title}`,
+    why: 'wiki STATUS listed this as a next ingest',
+    source: 'wiki_status_next_ingest',
+    ref: 'atris/wiki/STATUS.md',
+    weight: 70,
+  }));
+}
+
+function missionExtraNextCandidates(root = process.cwd()) {
+  return [
+    ...certifiedReviewNextTaskCandidates(root),
+    ...endgameBacklogCandidates(root),
+    ...wikiStatusNextIngestCandidates(root),
+  ];
+}
+
+function uniqueMissionCandidates(candidates) {
+  const seen = new Set();
+  const out = [];
+  for (const candidate of candidates) {
+    const key = continuationTargetKey(candidate?.title);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    out.push(candidate);
+  }
+  return out;
+}
+
+function trustedNextMissionSource(source) {
+  return new Set([
+    'certified_review_next_task',
+    'endgame_backlog',
+    'wiki_status_next_ingest',
+    'mission_report',
+  ]).has(String(source || ''));
+}
+
+function rejectNextMissionCandidate(move, context) {
+  const title = String(move?.title || '').trim();
+  if (!title) return 'empty title';
+  if (context.moves.isGenericInboxPlaceholder(title)) return 'placeholder';
+  if (!isConcreteContinuationTarget(title)) return 'not a concrete mission';
+  const key = continuationTargetKey(title);
+  if (context.handledTargets.has(key)) return 'already handled';
+  if (context.currentObjective && title === context.currentObjective) return 'same as current objective';
+  if (context.parentObjective && title === context.parentObjective) return 'same as parent objective';
+  if (context.mission?.id && move?.ref === context.mission.id && title === context.currentObjective) return 'same as current mission';
+  const preview = missionValuePreview(move, context.mission, context.root);
+  const score = Number(preview?.score?.total || 0);
+  move.value_preview = preview;
+  if (score <= 0 && !trustedNextMissionSource(move.source)) return 'zero value score';
+  return '';
+}
+
+function nearMissPreview(nearMisses) {
+  if (!nearMisses.length) return null;
+  return {
+    schema: 'atris.next_mission_stop_preview.v1',
+    stop_reason: 'no concrete follow-up mission found in Atris state',
+    near_misses: nearMisses.slice(0, 3),
+    feynman: {
+      what: 'Atris found possible next moves, but none passed the mission filter.',
+      why_now: 'Stopping is safer than spending tokens on fake or low-value work.',
+      risk: 'A human may want to promote one near-miss manually.',
+      validation: 'Review the near-miss reasons, then add a concrete next task if one should run.',
+    },
+  };
+}
+
+function chooseNextMissionAnalysis(mission, root = process.cwd()) {
+  try {
+    const moves = require('../lib/next-moves');
+    const currentObjective = String(mission?.objective || '').trim();
+    const parentObjective = String(mission?.parent_objective || '').trim();
+    const handledTargets = handledContinuationTargetKeys(root, moves);
+    const latestTarget = moves.latestSuggestedTarget(root);
+    const reportCandidates = latestTarget
+      ? [{
+        title: latestTarget,
+        why: 'latest proof timeline suggested this follow-up mission',
+        source: 'mission_report',
+        weight: 75,
+      }]
+      : [];
+    const context = { mission, root, moves, currentObjective, parentObjective, handledTargets };
+    const nearMisses = [];
+    const candidates = uniqueMissionCandidates([
+      ...missionExtraNextCandidates(root),
+      ...reportCandidates,
+      ...moves.nextMoves(root, 8),
+    ])
+      .filter((move) => {
+        const reason = rejectNextMissionCandidate(move, context);
+        if (reason) {
+          nearMisses.push({
+            title: String(move?.title || '').trim() || '(empty)',
+            source: move?.source || null,
+            ref: move?.ref || null,
+            reason,
+          });
+          return false;
+        }
+        return true;
+      })
+      .sort((a, b) => {
+        const aScore = Number(a.value_preview?.score?.total || 0);
+        const bScore = Number(b.value_preview?.score?.total || 0);
+        if (aScore !== bScore) return bScore - aScore;
+        return Number(b.weight || 0) - Number(a.weight || 0);
+      });
+    return { target: candidates[0] || null, near_misses: nearMisses.slice(0, 3) };
+  } catch {
+    // Fall through to an explicit stop command; never emit the old placeholder.
+  }
+  return { target: null, near_misses: [] };
+}
+
+function chooseNextMissionTarget(mission, root = process.cwd()) {
+  return chooseNextMissionAnalysis(mission, root).target;
+}
+
+function normalizeMissionOwner(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function missionMemberTasteProfile(owner) {
+  const key = normalizeMissionOwner(owner);
+  if (/\b(security|sync-inspector|proof-inspector|validator)\b/.test(key)) {
+    return {
+      id: 'security_guard',
+      name: 'Security / trust',
+      bias: 'Prefer work that prevents unsafe behavior, privacy mistakes, or quiet trust breaks.',
+    };
+  }
+  if (/\b(researcher|architect|improver|auto-improver|problem-solver|objective-generator)\b/.test(key)) {
+    return {
+      id: 'technical_homerun',
+      name: 'Technical homerun',
+      bias: 'Prefer technical leaps, but require a usability or proof gate before spending serious tokens.',
+    };
+  }
+  return {
+    id: 'usability_operator',
+    name: 'Usability / demo',
+    bias: 'Prefer work that makes the product easier, faster, clearer, or more demo-ready.',
+  };
+}
+
+function missionValueSignals(title) {
+  const text = String(title || '').toLowerCase();
+  const signals = [];
+  const add = (id, label, pattern) => {
+    if (pattern.test(text)) signals.push({ id, label });
+  };
+  add('usability', 'simplifies use', /\b(simple|simplify|preview|clear|plain|feynman|demo|onboarding|ux|workflow|usable|understand)\b/);
+  add('speed', 'speeds the process', /\b(speed|fast|faster|latency|token|waste|friction|shortcut|automation|auto)\b/);
+  add('users_revenue', 'can help users or revenue', /\b(user|users|customer|revenue|payment|checkout|pricing|conversion|retention|demo)\b/);
+  add('trust', 'protects trust', /\b(security|safe|safety|trust|permission|approval|auth|privacy|gmail|email|connector|leak|isolation)\b/);
+  add('technical', 'technical advancement', /\b(agent|ax|connector|isolation|research|benchmark|model|compiler|runtime|architecture|rl|experiment)\b/);
+  add('freshness', 'keeps workflow current', /\b(up[- ]?to[- ]?date|fresh|sync|stale|current|latest)\b/);
+  return signals;
+}
+
+function missionTasteSnippet(value, max = 180) {
+  const text = String(value || '')
+    .replace(/<!--[\s\S]*?-->/g, ' ')
+    .replace(/[`*_#>]+/g, '')
+    .replace(/^[-\d.()[\]\s]+/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!text) return '';
+  return text.length > max ? `${text.slice(0, max - 3).trim()}...` : text;
+}
+
+function missionTasteSnippets(text, limit = 4) {
+  const tastePattern = /\b(plain|jargon|feynman|understand|simple|clarify|clarity|proof|receipt|verify|verified|checked|tested|accept|approval|runway|revenue|cash|user|customer|demo|technical|homerun|security|trust|privacy|logs|working memory|recent|speed|token|waste|simplify)\b/i;
+  const snippets = [];
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const snippet = missionTasteSnippet(line);
+    if (!snippet || !tastePattern.test(snippet)) continue;
+    snippets.push(snippet);
+  }
+  return snippets.slice(-limit);
+}
+
+function readTextFile(root, relativePath) {
+  const file = path.join(root, ...relativePath.split('/'));
+  try {
+    return { path: relativePath, present: true, text: fs.readFileSync(file, 'utf8') };
+  } catch {
+    return { path: relativePath, present: false, text: '' };
+  }
+}
+
+function recentMarkdownFiles(dir, limit = 2) {
+  const files = [];
+  try {
+    for (const entry of fs.readdirSync(dir)) {
+      const full = path.join(dir, entry);
+      const stat = fs.statSync(full);
+      if (stat.isDirectory()) {
+        for (const child of recentMarkdownFiles(full, limit * 4)) files.push(child);
+      } else if (/\.md$/i.test(entry)) {
+        files.push(full);
+      }
+    }
+  } catch {
+    return [];
+  }
+  return files
+    .sort((a, b) => {
+      const aBase = path.basename(a);
+      const bBase = path.basename(b);
+      if (aBase !== bBase) return aBase.localeCompare(bBase);
+      return a.localeCompare(b);
+    })
+    .slice(-limit);
+}
+
+function readRecentTasteLogs(root, owner, limit = 3) {
+  const logFiles = [
+    ...recentMarkdownFiles(path.join(root, 'atris', 'logs'), 2),
+    ...recentMarkdownFiles(path.join(root, 'atris', 'team', owner || '', 'logs'), 2),
+  ];
+  const seen = new Set();
+  return logFiles
+    .filter((file) => {
+      const key = path.resolve(file);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    })
+    .slice(-limit)
+    .map((file) => {
+      let text = '';
+      try { text = fs.readFileSync(file, 'utf8'); } catch { text = ''; }
+      return {
+        path: path.relative(root, file),
+        snippets: missionTasteSnippets(text, 3),
+      };
+    })
+    .filter((entry) => entry.snippets.length);
+}
+
+function readTasteReviewHistory(root, limit = 4) {
+  const file = path.join(root, '.atris', 'state', 'tasks.projection.json');
+  let projection = null;
+  try { projection = JSON.parse(fs.readFileSync(file, 'utf8')); } catch { projection = null; }
+  const tasks = Array.isArray(projection?.tasks) ? projection.tasks : [];
+  const accepted = [];
+  const revised = [];
+  const sorted = tasks
+    .filter(Boolean)
+    .sort((a, b) => Number(b.updated_at || 0) - Number(a.updated_at || 0));
+  for (const task of sorted) {
+    const title = missionTasteSnippet(task.title, 120);
+    for (const event of Array.isArray(task.events) ? task.events : []) {
+      const type = String(event?.event_type || '');
+      const payload = event?.payload || {};
+      if ((type === 'accepted' || (type === 'reviewed' && Number(payload.reward || 0) > 0)) && accepted.length < limit) {
+        accepted.push(missionTasteSnippet(`${title}: ${payload.proof || payload.note || 'accepted'}`));
+      }
+      if (type === 'revision_requested' && revised.length < limit) {
+        revised.push(missionTasteSnippet(`${title}: ${payload.note || 'revision requested'}`));
+      }
+    }
+  }
+  return { accepted, revised };
+}
+
+function missionTasteMemorySignals(text) {
+  const definitions = [
+    ['plain_language', 'Keshav asks for plain English', /\b(plain|jargon|feynman|understand|simple|clarify|clarity)\b/i],
+    ['proof_gate', 'Keshav wants proof before accept', /\b(proof|receipt|verify|verified|checked|tested|accept|approval)\b/i],
+    ['runway_revenue', 'runway pushes user or revenue work', /\b(runway|revenue|cash|user|users|customer|demo|adoption|retention)\b/i],
+    ['technical_ambition', 'technical advancement still matters', /\b(technical|homerun|research|runtime|architecture|model|benchmark|agent)\b/i],
+    ['trust_boundary', 'trust and approval boundaries matter', /\b(security|safe|safety|trust|privacy|approval|permission|gmail|email|connector)\b/i],
+    ['working_memory', 'recent logs are working memory', /\b(logs?|working memory|recent|today|now)\b/i],
+    ['speed_token', 'avoid wasted time and tokens', /\b(speed|fast|faster|token|waste|friction|simplify)\b/i],
+  ];
+  return definitions
+    .filter(([, , pattern]) => pattern.test(text))
+    .map(([id, label]) => ({ id, label }));
+}
+
+function readMissionTasteMemory(root = process.cwd(), owner = '') {
+  const safeOwner = normalizeMissionOwner(owner || process.env.ATRIS_AGENT_ID || 'mission-lead') || 'mission-lead';
+  const thinking = readTextFile(root, 'atris/thinking.md');
+  const memberMission = readTextFile(root, `atris/team/${safeOwner}/MISSION.md`);
+  const recentLogs = readRecentTasteLogs(root, safeOwner);
+  const taskHistory = readTasteReviewHistory(root);
+  const thinkingSnippets = missionTasteSnippets(thinking.text, 5);
+  const memberMissionSnippets = missionTasteSnippets(memberMission.text, 5);
+  const allText = [
+    ...thinkingSnippets,
+    ...memberMissionSnippets,
+    ...recentLogs.flatMap((entry) => entry.snippets),
+    ...taskHistory.accepted,
+    ...taskHistory.revised,
+  ].join('\n');
+  const signals = missionTasteMemorySignals(allText);
+  return {
+    schema: 'atris.mission_taste_memory.v1',
+    owner: safeOwner,
+    sources: {
+      thinking_md: {
+        path: thinking.path,
+        present: thinking.present,
+        snippets: thinkingSnippets,
+      },
+      member_mission: {
+        path: memberMission.path,
+        present: memberMission.present,
+        snippets: memberMissionSnippets,
+      },
+      recent_logs: recentLogs,
+      task_history: taskHistory,
+    },
+    signals,
+  };
+}
+
+function missionTasteMemoryBoost(signals, tasteMemory, profile) {
+  const candidateIds = new Set((signals || []).map((signal) => signal.id));
+  const memoryIds = new Set((tasteMemory?.signals || []).map((signal) => signal.id));
+  const hasCandidate = (id) => candidateIds.has(id) ? 1 : 0;
+  const hasMemory = (id) => memoryIds.has(id);
+  let boost = 0;
+  if (hasMemory('plain_language')) boost += hasCandidate('usability') * 2;
+  if (hasMemory('proof_gate')) boost += (hasCandidate('trust') || hasCandidate('usability') || hasCandidate('technical')) ? 1 : 0;
+  if (hasMemory('runway_revenue')) boost += hasCandidate('users_revenue') * 3;
+  if (hasMemory('technical_ambition')) boost += profile.id === 'technical_homerun' ? hasCandidate('technical') * 2 : hasCandidate('technical');
+  if (hasMemory('trust_boundary')) boost += hasCandidate('trust') * 2;
+  if (hasMemory('working_memory')) boost += (hasCandidate('freshness') || hasCandidate('speed')) ? 1 : 0;
+  if (hasMemory('speed_token')) boost += hasCandidate('speed') * 2;
+  return boost;
+}
+
+function missionValueScore(signals, profile, tasteMemory = null) {
+  const ids = new Set((signals || []).map((signal) => signal.id));
+  const has = (id) => ids.has(id) ? 1 : 0;
+  const base = has('usability') + has('speed') + has('users_revenue') + has('trust') + has('freshness');
+  let profileBoost = 0;
+  if (profile.id === 'technical_homerun') profileBoost = (has('technical') * 2) + has('trust') + has('speed');
+  else if (profile.id === 'security_guard') profileBoost = (has('trust') * 3) + has('freshness');
+  else profileBoost = (has('usability') * 2) + has('speed') + has('users_revenue');
+  const memoryBoost = missionTasteMemoryBoost(signals, tasteMemory, profile);
+  return {
+    total: base + profileBoost + memoryBoost,
+    signals: Array.from(ids),
+    memory_boost: memoryBoost,
+  };
+}
+
+function missionPlainTaskPreview(title) {
+  const text = String(title || '').replace(/\s+/g, ' ').trim();
+  if (!text) return 'Do one concrete useful thing.';
+  if (/ax\b/i.test(text) && /gmail/i.test(text) && /turn isolation/i.test(text)) {
+    return 'Make ax safer with Gmail: keep each chat request separate, and show a clear preview or receipt before Gmail actions.';
+  }
+  const cleaned = text
+    .replace(/^mission xp:\s*/i, '')
+    .replace(/^ship\s+/i, '')
+    .replace(/\bturn isolation\b/ig, 'separate chat requests')
+    .replace(/\breceipt previews?\b/ig, 'clear before/after receipts')
+    .replace(/\bconnector\b/ig, 'connected-app path');
+  return `${cleaned.charAt(0).toUpperCase()}${cleaned.slice(1)}`.replace(/[.!?:;,]+$/g, '') + '.';
+}
+
+function missionTasteMemoryReason(tasteMemory, signals) {
+  const candidateIds = new Set((signals || []).map((signal) => signal.id));
+  const memoryIds = new Set((tasteMemory?.signals || []).map((signal) => signal.id));
+  if (memoryIds.has('runway_revenue') && candidateIds.has('users_revenue')) return 'Keshav has been steering toward user/revenue proof because runway is tight.';
+  if (memoryIds.has('plain_language') && candidateIds.has('usability')) return 'Keshav keeps asking for plain-English, understandable work.';
+  if (memoryIds.has('proof_gate') && (candidateIds.has('trust') || candidateIds.has('technical'))) return 'Keshav wants proof and receipts before serious work is accepted.';
+  if (memoryIds.has('working_memory')) return 'Recent logs are being used as working memory for what matters now.';
+  if (memoryIds.has('technical_ambition') && candidateIds.has('technical')) return 'The member memory still values technical advancement when it has proof.';
+  return '';
+}
+
+function missionPreviewWhyNow(move, profile, signals, tasteMemory = null) {
+  const ids = new Set((signals || []).map((signal) => signal.id));
+  let base = '';
+  if (profile.id === 'technical_homerun') {
+    base = ids.has('technical')
+      ? 'This is a technical bet; run it only because it can make the product stronger without making the user think harder.'
+      : 'This is not a technical homerun on its face, so it needs clear usability proof before it should win.';
+  } else if (profile.id === 'security_guard') {
+    base = ids.has('trust')
+      ? 'This matters because trust failures are expensive and should be blocked before users feel them.'
+      : 'This is not mainly security work, so it should only run if the current trust queue is quiet.';
+  } else if (ids.has('users_revenue')) {
+    base = 'This matters now because it can help demos, users, retention, or revenue.';
+  } else if (ids.has('usability') || ids.has('speed')) {
+    base = 'This matters now because it can make the product easier or faster to use.';
+  } else {
+    base = move?.why || 'This needs a clear reason before it should spend serious tokens.';
+  }
+  const memoryReason = missionTasteMemoryReason(tasteMemory, signals);
+  return memoryReason ? `${base} Taste memory says: ${memoryReason}` : base;
+}
+
+function missionPreviewRisk(signals) {
+  const ids = new Set((signals || []).map((signal) => signal.id));
+  if (ids.has('technical') && !ids.has('usability')) return 'Risk: it becomes clever infrastructure that does not make the product easier.';
+  if (ids.has('trust')) return 'Risk: changing connected-tool behavior can hide or create approval/privacy mistakes.';
+  return 'Risk: it adds complexity without a visible product win.';
+}
+
+function missionPreviewValidation(signals) {
+  const ids = new Set((signals || []).map((signal) => signal.id));
+  if (ids.has('trust')) return 'Validate with a before/after receipt and a test proving unsafe state does not carry across turns.';
+  if (ids.has('users_revenue')) return 'Validate with a customer-visible proof: demo path, signup/payment path, or retention signal.';
+  if (ids.has('technical')) return 'Validate with a small benchmark, regression test, or artifact that proves the technical bet helped.';
+  return 'Validate with a simple before/after check that a human can understand.';
+}
+
+function missionValuePreview(move, mission, root = process.cwd()) {
+  const profile = missionMemberTasteProfile(mission?.owner);
+  const signals = missionValueSignals(move?.title);
+  const tasteMemory = readMissionTasteMemory(root, mission?.owner);
+  const score = missionValueScore(signals, profile, tasteMemory);
+  return {
+    schema: 'atris.mission_value_preview.v1',
+    member: mission?.owner || null,
+    profile,
+    candidate: {
+      title: move?.title || '',
+      source: move?.source || null,
+      ref: move?.ref || null,
+    },
+    feynman: {
+      what: missionPlainTaskPreview(move?.title),
+      why_now: missionPreviewWhyNow(move, profile, signals, tasteMemory),
+      risk: missionPreviewRisk(signals),
+      validation: missionPreviewValidation(signals),
+      taste: missionTasteMemoryReason(tasteMemory, signals) || 'No live taste memory matched this candidate yet.',
+    },
+    value_signals: signals,
+    taste_memory: tasteMemory,
+    score,
+  };
+}
+
+function resumableActiveMissions(mission, root = process.cwd()) {
+  const selfId = String(mission?.id || '');
+  const parentId = String(mission?.parent_mission_id || '');
+  try {
+    // Only planning missions resume: ready missions wait for human review, and
+    // running missions already have an actor.
+    return listMissions(root).filter((row) => {
+      if (!row || row.status !== 'planning') return false;
+      if (row.id === selfId || row.id === parentId) return false;
+      if (String(row.started_from || '') === 'mission_run_continuation') return false;
+      if (!isConcreteContinuationTarget(row.objective)) return false;
+      return true;
+    });
+  } catch {
+    return [];
+  }
+}
+
+function chooseResumeMissionPlan(mission, nearMisses, root = process.cwd()) {
+  const ranked = resumableActiveMissions(mission, root)
+    .map((row) => ({
+      row,
+      preview: missionValuePreview({ title: row.objective, source: 'resume_active_mission', ref: row.id }, mission, root),
+    }))
+    .sort((a, b) => {
+      const aScore = Number(a.preview?.score?.total || 0);
+      const bScore = Number(b.preview?.score?.total || 0);
+      if (aScore !== bScore) return bScore - aScore;
+      return String(b.row.updated_at || '').localeCompare(String(a.row.updated_at || ''));
+    });
+  const best = ranked[0];
+  if (!best) return null;
+  return {
+    target: {
+      title: best.row.objective,
+      source: 'resume_active_mission',
+      ref: best.row.id,
+      value_preview: best.preview,
+    },
+    command: `atris mission run ${best.row.id} --json`,
+    preview: {
+      schema: 'atris.next_mission_resume_preview.v1',
+      resume_mission_id: best.row.id,
+      resume_objective: best.row.objective,
+      resume_status: best.row.status,
+      resume_owner: best.row.owner || null,
+      near_misses: nearMisses.slice(0, 3),
+      feynman: {
+        what: 'Every new candidate is already tracked, and one active mission is still in planning.',
+        why_now: 'Resuming chosen work beats stopping when real work is already on the board.',
+        risk: 'The resumed mission may deserve a fresher objective; stop it if it no longer matters.',
+        validation: 'Run the resume command, then check the mission landing and receipt.',
+      },
+    },
+  };
+}
+
+function chooseNextMissionPlan(mission, root = process.cwd()) {
+  const owner = mission?.owner || process.env.ATRIS_AGENT_ID || 'mission-lead';
+  const analysis = chooseNextMissionAnalysis(mission, root);
+  const target = analysis.target;
+  if (target?.title) {
+    return {
+      target,
+      command: `atris mission run ${shellQuote(target.title)} --owner ${owner}`,
+      preview: target.value_preview || missionValuePreview(target, mission, root),
+    };
+  }
+  const resume = chooseResumeMissionPlan(mission, analysis.near_misses || [], root);
+  if (resume) return resume;
+  const missionId = mission?.id || '<mission-id>';
+  return {
+    target: null,
+    command: `atris mission stop ${missionId} --reason ${shellQuote('no concrete follow-up mission found in Atris state')} --json`,
+    preview: nearMissPreview(analysis.near_misses || []),
+  };
+}
+
+function chooseNextMissionCommand(mission, root = process.cwd()) {
+  return chooseNextMissionPlan(mission, root).command;
+}
+
+function chooseNextMissionPreview(mission, root = process.cwd()) {
+  return chooseNextMissionPlan(mission, root).preview;
+}
+
+function effectiveMissionVerifier(mission) {
+  const explicit = String(mission?.verifier || '').trim();
+  if (explicit) return explicit;
+  if (missionChoosesNextMission(mission)) return '';
+  const runner = String(mission?.runner || '').trim().toLowerCase();
+  if (missionLongRunIntent(mission) && (!runner || runner === 'codex_goal')) {
+    return DEFAULT_LONG_RUN_VERIFIER;
+  }
+  return '';
+}
+
+function markMissionRunContinuation(mission) {
+  return {
+    ...mission,
+    started_from: 'mission_run_objective',
+    continue_on_complete: true,
+    continuation_policy: 'decide_and_start_next_useful_mission',
+  };
+}
+
+function continuationObjective(parent) {
+  return `Decide and start the next useful mission after: ${parent.objective}`;
+}
+
+function findActiveContinuationMission(parent, root = process.cwd()) {
+  return listMissions(root).find((mission) => (
+    mission.parent_mission_id === parent.id
+    && mission.started_from === 'mission_run_continuation'
+    && !TERMINAL_STATUSES.has(mission.status)
+  )) || null;
+}
+
+function findActiveMissionRunContinuation(root = process.cwd(), excludeId = '') {
+  const excluded = String(excludeId || '');
+  const candidates = listMissions(root)
+    .filter((mission) => (
+      mission.id !== excluded
+      && mission.started_from === 'mission_run_continuation'
+      && mission.continuation_policy === 'choose_next_mission'
+      && !TERMINAL_STATUSES.has(mission.status)
+    ));
+  candidates.sort((a, b) => missionSortTime(b) - missionSortTime(a));
+  return candidates[0] || null;
+}
+
+function completeActiveContinuationForStartedMission(nextMission, root = process.cwd()) {
+  const continuation = findActiveMissionRunContinuation(root, nextMission?.id);
+  if (!continuation || !nextMission) return null;
+  if (continuation.objective === nextMission.objective) return null;
+
+  const proof = `Started next mission ${nextMission.id}: ${nextMission.objective}`;
+  const completionGate = { ok: true, source: 'mission_run_continuation', forced: false };
+  const baseNext = {
+    ...continuation,
+    status: 'complete',
+    completed_at: stampIso(),
+    proof,
+    completion_gate: completionGate,
+    continued_by_mission_id: nextMission.id,
+    continued_by_objective: nextMission.objective,
+    next_action: 'mission complete',
+  };
   const completion = missionCompletionReceipt(baseNext, proof);
   const { mission: saved } = saveMission({
     ...baseNext,
@@ -990,26 +2500,47 @@ function completeActiveContinuationForStartedMission(nextMission, root = process
   };
 }
 
+function missionCanSeedContinuation(parent) {
+  if (!parent) return false;
+  if (parent.status === 'complete') return true;
+  return GOAL_LOOP_STATUSES.has(String(parent.status || '')) && missionTaskHumanAcceptWaiting(parent);
+}
+
 function seedMissionRunContinuation(parent, root = process.cwd(), proof = '') {
-  if (!parent || parent.status !== 'complete') return null;
+  if (!missionCanSeedContinuation(parent)) return null;
   if (parent.continue_on_complete !== true) return null;
-  if (parent.continuation_seeded_mission_id) return {
-    inserted: false,
-    reason: 'already_seeded',
-    mission_id: parent.continuation_seeded_mission_id,
-  };
+  if (parent.continuation_seeded_mission_id) {
+    const seeded = resolveMission(parent.continuation_seeded_mission_id, root);
+    if (seeded && TERMINAL_STATUSES.has(String(seeded.status || '')) && seeded.continued_by_mission_id) {
+      return {
+        inserted: false,
+        reason: 'already_continued',
+        mission_id: parent.continuation_seeded_mission_id,
+        mission: null,
+        continued_by_mission_id: seeded.continued_by_mission_id,
+      };
+    }
+    return {
+      inserted: false,
+      reason: 'already_seeded',
+      mission_id: parent.continuation_seeded_mission_id,
+      mission: seeded || null,
+    };
+  }
 
   const existing = findActiveContinuationMission(parent, root);
   if (existing) return { inserted: false, reason: 'active_continuation_exists', mission: existing };
 
   const owner = parent.owner || process.env.ATRIS_AGENT_ID || 'mission-lead';
   const objective = continuationObjective(parent);
+  const parentRunner = String(parent.runner || '').trim().toLowerCase();
+  const continuationRunner = parentRunner === 'atris2' ? 'atris2' : 'codex_goal';
   const mission = missionFromArgs([
     objective,
     '--owner',
     owner,
     '--runner',
-    'codex_goal',
+    continuationRunner,
     '--lane',
     parent.lane || 'workspace',
     '--cadence',
@@ -1025,8 +2556,11 @@ function seedMissionRunContinuation(parent, root = process.cwd(), proof = '') {
     continue_on_complete: false,
     continuation_policy: 'choose_next_mission',
     parent_proof: proof || parent.receipt_path || null,
-    next_action: `decide next mission, then run: atris mission run "<next useful mission>" --owner ${owner}`,
+    next_action: '',
   };
+  const nextPlan = chooseNextMissionPlan(nextMission, root);
+  nextMission.next_action = `decide next mission, then run: ${nextPlan.command}`;
+  nextMission.next_action_preview = nextPlan.preview;
 
   ensureMemberMissionFile(nextMission.owner, root, nextMission.objective);
   const { mission: saved } = saveMission(nextMission, root, 'mission_continuation_started', {
@@ -1057,6 +2591,36 @@ function seedMissionRunContinuation(parent, root = process.cwd(), proof = '') {
   };
 }
 
+function seedNextMoveContinuationGoal(root = process.cwd()) {
+  const candidates = listMissions(root)
+    .filter((mission) => runnerUsesCallerSession(mission.runner))
+    .filter((mission) => mission.continue_on_complete === true)
+    .filter((mission) => missionCanSeedContinuation(mission));
+  candidates.sort((a, b) => missionSortTime(b) - missionSortTime(a));
+  for (const parent of candidates) {
+    const seeded = seedMissionRunContinuation(parent, root, parent.receipt_path || 'agent-certified task waiting for human accept');
+    if (seeded?.mission && missionSelectableForCodexGoal(seeded.mission)) return { ...seeded, parent: seeded.parent || parent };
+  }
+  return null;
+}
+
+// Continuation runs started from inside an existing agent worktree must build
+// on that work, not restart clean from origin/master. Returns the current HEAD
+// sha (a sha survives normalizeTargetRef; an unpushed branch name would be
+// rewritten to a nonexistent origin/ ref) when cwd is an agent worktree.
+function inheritedWorktreeBase(cwd) {
+  try {
+    const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8' });
+    const root = String(top.stdout || '').trim();
+    if (top.status !== 0 || !root) return '';
+    if (!fs.existsSync(path.join(root, '.atris', 'agent-worktree.json'))) return '';
+    const head = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: root, encoding: 'utf8' });
+    return head.status === 0 ? String(head.stdout || '').trim() : '';
+  } catch {
+    return '';
+  }
+}
+
 function startMission(args) {
   const asJson = wantsJson(args);
   const mission = missionFromArgs(args);
@@ -1068,7 +2632,8 @@ function startMission(args) {
     let created;
     try {
       const { createAgentWorktree } = require('./worktree');
-      created = createAgentWorktree({ member: mission.owner, task: mission.objective });
+      const base = readFlag(args, '--base', '') || inheritedWorktreeBase(process.cwd());
+      created = createAgentWorktree({ member: mission.owner, task: mission.objective, ...(base ? { base } : {}) });
     } catch (e) {
       exitMissionError(`[mission start] worktree creation failed: ${e.message}`, 2, asJson);
     }
@@ -1112,35 +2677,88 @@ function startMission(args) {
 
 function startMissionFromRunObjective(objective, args) {
   const asJson = wantsJson(args);
-  const verifier = readFlag(args, '--verify', inferRunObjectiveVerifier(objective));
+  const rawObjective = String(objective || '').trim();
+  const inferredLoop = inferRunObjectiveLoopOptions(rawObjective, args);
+  const budgetContract = inferRunObjectiveBudgetContract(rawObjective, args);
+  const inferredOwner = inferredLoop.wantsLongRun && /\bself[-\s]?improve\b/i.test(rawObjective)
+    ? 'auto-improver'
+    : (process.env.ATRIS_AGENT_ID || 'mission-lead');
+  const preflightOwner = readFlag(args, '--owner', inferredOwner);
+  const missionRunPreflight = buildMissionRunRoomPreflight(rawObjective, args, {
+    root: process.cwd(),
+    owner: preflightOwner,
+    allowTrustedRun: !inferredLoop.wantsLongRun,
+  });
+  const missionObjective = missionRunPreflight?.shaped_objective || rawObjective;
+  const verifier = readFlag(
+    args,
+    '--verify',
+    inferRunObjectiveVerifier(missionObjective)
+      || inferRunObjectiveVerifier(rawObjective)
+      || (missionRunPreflight?.trusted_run ? DEFAULT_LONG_RUN_VERIFIER : '')
+      || (inferredLoop.wantsLongRun ? DEFAULT_LONG_RUN_VERIFIER : ''),
+  );
   const stopCondition = readFlag(
     args,
     '--stop',
-    verifier ? 'verifier passes and visible goal lands' : 'visible goal lands and proof is ready',
+    budgetStopCondition(budgetContract) || (inferredLoop.wantsLongRun
+      ? `run for ${inferredLoop.requestedHours || 'the requested overnight window'} hour${inferredLoop.requestedHours === 1 ? '' : 's'}, or stop when proof is ready`
+      : (verifier ? 'verifier passes and visible goal lands' : 'visible goal lands and proof is ready')),
   );
   const startArgs = [
-    objective,
+    missionObjective,
     '--owner',
-    readFlag(args, '--owner', process.env.ATRIS_AGENT_ID || 'mission-lead'),
+    readFlag(args, '--owner', inferredOwner),
     '--runner',
     readFlag(args, '--runner', 'codex_goal'),
     '--lane',
     readFlag(args, '--lane', 'workspace'),
     '--cadence',
-    readFlag(args, '--cadence', 'manual'),
+    readFlag(args, '--cadence', inferredLoop.wantsLongRun ? inferredLoop.cadence : 'manual'),
     '--stop',
     stopCondition,
   ];
   if (verifier) startArgs.push('--verify', verifier);
   const model = readFlag(args, '--model', '');
   if (model) startArgs.push('--model', model);
-  if (hasFlag(args, '--always-on')) startArgs.push('--always-on');
-  if (hasFlag(args, '--xp-task') || hasFlag(args, '--agent-xp')) startArgs.push('--xp-task');
+  if (hasFlag(args, '--always-on') || inferredLoop.wantsLongRun) startArgs.push('--always-on');
+  if (hasFlag(args, '--xp-task') || hasFlag(args, '--agent-xp') || missionRunPreflight?.task_spine_required) startArgs.push('--xp-task');
 
   const mission = markMissionRunContinuation(missionFromArgs(startArgs));
+  if (missionGoalChainIntent(rawObjective) || missionGoalChainIntent(missionObjective)) {
+    mission.goal_chain = buildMissionGoalChain(missionObjective || rawObjective);
+    mission.next_action = missionGoalChainNextAction(mission.goal_chain);
+  }
+  if (missionRunPreflight) {
+    mission.mission_run_preflight = missionRunPreflight;
+    mission.raw_objective = rawObjective;
+  }
+  const selectedTargetTask = missionRunSelectedTaskTarget(missionRunPreflight);
+  if (selectedTargetTask) {
+    Object.assign(mission, attachSelectedTargetTaskSpine(mission));
+  }
+  if (budgetContract) {
+    mission.budget_contract = budgetContract;
+    if (budgetContract.requested_seconds) mission.max_wall_seconds = budgetContract.requested_seconds;
+  }
+  if (inferredLoop.wantsLongRun) {
+    mission.overnight_loop = {
+      requested_hours: inferredLoop.requestedHours,
+      cadence: mission.cadence,
+      install_command: inferredLoop.requestedHours
+        ? `atris loop start --overnight --cadence ${mission.cadence} --hours ${inferredLoop.requestedHours}`
+        : `atris loop start --overnight --cadence ${mission.cadence}`,
+    };
+  }
+  if (mission.xp_task_enabled && !selectedTargetTask) {
+    const xpTask = createMissionXpTask(mission, process.cwd(), asJson);
+    mission.xp_task = xpTask;
+    mission.task_ids = Array.from(new Set([...(mission.task_ids || []), xpTask.task_id]));
+  }
   const warnings = [missingVerifierWarning(mission)].filter(Boolean);
   ensureMemberMissionFile(mission.owner, process.cwd(), mission.objective);
   const { mission: saved } = saveMission(mission, process.cwd(), 'mission_started', { objective: mission.objective, source: 'mission_run_objective' });
+  const directGoalRequest = writeDirectRunCodexGoalRequest(saved, process.cwd());
   const memberState = renderMemberMissionState(saved.owner);
   const logPath = appendMemberLog(saved.owner, 'Mission started from run', {
     mission: saved.objective,
@@ -1151,12 +2769,26 @@ function startMissionFromRunObjective(objective, args) {
   });
   const worktreeBaseline = captureMissionWorktreeBaseline(saved, process.cwd());
   const completedContinuationGoal = completeActiveContinuationForStartedMission(saved, process.cwd());
-  const codexGoalState = refreshCodexGoalController(process.cwd());
+  const nativeGoalStatus = readFlag(args, '--native-goal-status', readFlag(args, '--visible-goal-status', ''));
+  const nativeGoalObjective = readFlag(args, '--native-goal-objective', readFlag(args, '--visible-goal-objective', ''));
+  const nativeGoalOptions = {
+    ...(nativeGoalStatus ? { nativeGoalStatus } : {}),
+    ...(nativeGoalObjective ? { nativeGoalObjective } : {}),
+    ...(hasFlag(args, '--allow-native-goal-supersede') || hasFlag(args, '--supersede-paused-native-goal') ? { allowNativeGoalSupersede: true } : {}),
+  };
+  const atrisGoalState = refreshAtrisGoalController(process.cwd(), { missionId: saved.id });
+  const codexGoalState = runnerUsesCallerSession(saved.runner)
+    ? refreshCodexGoalController(process.cwd(), { missionId: saved.id, ...nativeGoalOptions })
+    : null;
+  const nativeGoal = codexGoalState?.native_goal_action
+    || (codexGoalState?.goal?.requires_native_goal_start ? codexGoalState.goal.native_goal_action : null);
+  const nextCommand = codexGoalState?.next_command || codexGoalState?.goal?.next_command || atrisGoalState.goal?.next_command || `atris mission tick ${saved.id} --summary "<what changed>"`;
   printJsonOrText(
     {
       ok: true,
       action: 'mission_run_started',
       mission: saved,
+      budget_contract: saved.budget_contract || null,
       warnings,
       state_path: statePaths().missionsJsonl,
       member_state: memberState,
@@ -1167,16 +2799,16 @@ function startMissionFromRunObjective(objective, args) {
         dirty_hash: worktreeBaseline.dirty_hash,
       } : null,
       completed_continuation_goal: completedContinuationGoal,
+      direct_goal_request: directGoalRequest,
+      atris_goal_state: atrisGoalState,
       codex_goal_state: codexGoalState,
-      next_command: codexGoalState.goal?.next_command || `atris mission tick ${saved.id} --verify`,
+      requires_native_goal_start: codexGoalState?.requires_native_goal_start === true || codexGoalState?.goal?.requires_native_goal_start === true,
+      requires_native_goal_replace: codexGoalState?.requires_native_goal_replace === true || codexGoalState?.goal?.requires_native_goal_replace === true,
+      native_goal_action: nativeGoal,
+      native_goal_ack_command: codexGoalState?.goal?.native_goal_ack_command || codexGoalState?.active_goal_conflict?.commands?.ack_new_mission || null,
+      next_command: nextCommand,
     },
-    [
-      `Started mission: ${saved.objective}`,
-      `Owner: ${saved.owner}`,
-      `Runner: ${saved.runner}`,
-      ...(codexGoalState.goal ? [`Visible goal: ${codexGoalState.goal.objective}`] : []),
-      ...warnings.map((warning) => `Warning: ${warning.message}`),
-    ],
+    missionRunTakeoffLines(saved, { warnings, nextCommand }),
     asJson,
   );
 }
@@ -1187,60 +2819,128 @@ function attachMissionTask(args) {
   if (!ref) {
     exitMissionError('Usage: atris mission attach-task <id> [--json]', 1, asJson);
   }
-  const mission = resolveMission(ref);
+  let mission = resolveMission(ref);
   if (!mission) {
     exitMissionError(`Mission "${ref}" not found.`, 1, asJson);
   }
-  if (TERMINAL_STATUSES.has(mission.status)) {
-    exitMissionError(`Mission "${ref}" is ${mission.status}; task spines attach only to active missions.`, 2, asJson);
+
+  const lock = acquireMissionLock(mission.id, process.cwd(), { waitMs: 2000 });
+  if (!lock.ok) {
+    exitMissionError(`[mission attach-task] lock busy (held by pid ${lock.holder?.pid || '?'} since ${lock.holder?.started_at || '?'}). Exit.`, 3, asJson);
   }
 
-  const existingSpine = missionTaskSpine(mission);
-  if (existingSpine?.has_task) {
-    const view = missionStatusView(mission);
+  try {
+    mission = resolveMission(mission.id) || mission;
+    if (TERMINAL_STATUSES.has(mission.status)) {
+      releaseMissionLock(lock);
+      exitMissionError(`Mission "${ref}" is ${mission.status}; task spines attach only to active missions.`, 2, asJson);
+    }
+
+    const existingSpine = missionTaskSpine(mission);
+    if (existingSpine?.has_task) {
+      let currentMission = mission;
+      if (missionChoosesNextMission(currentMission)) {
+        const nextPlan = chooseNextMissionPlan(currentMission);
+        const nextAction = `decide next mission, then run: ${nextPlan.command}`;
+        const currentPreviewTitle = currentMission.next_action_preview?.candidate?.title || null;
+        const nextPreviewTitle = nextPlan.preview?.candidate?.title || null;
+        const previewChanged = Boolean(currentMission.next_action_preview) !== Boolean(nextPlan.preview)
+          || currentPreviewTitle !== nextPreviewTitle;
+        if (currentMission.next_action !== nextAction || previewChanged) {
+          currentMission = saveMission(
+            {
+              ...currentMission,
+              next_action: nextAction,
+              next_action_preview: nextPlan.preview,
+            },
+            process.cwd(),
+            'mission_next_action_refreshed',
+            {
+              next_command: nextPlan.command,
+              target: nextPreviewTitle,
+            },
+          ).mission;
+        }
+      }
+      const view = missionStatusView(currentMission);
+      printJsonOrText(
+        { ok: true, action: 'mission_task_spine_exists', mission: view, task_spine: view.task_spine },
+        [
+          `Mission task spine already exists: ${mission.objective}`,
+          `Task: ${view.task_spine.task_ref}`,
+          `Next: ${view.task_spine.current_step_command}`,
+        ],
+        asJson,
+      );
+      return;
+    }
+
+    const ownership = applyMissionOwnerResolution(mission, process.cwd());
+    const baseMission = ownership.mission;
+    const selectedTargetMission = attachSelectedTargetTaskSpine(baseMission);
+    if (missionTaskSpine(selectedTargetMission)?.has_task) {
+      const { mission: saved } = saveMission(
+        selectedTargetMission,
+        process.cwd(),
+        'mission_selected_task_spine_attached',
+        {
+          task_id: selectedTargetMission.current_task_id || selectedTargetMission.task_ids?.[0] || null,
+          task_ref: selectedTargetMission.task_ref || null,
+        },
+      );
+      const memberState = renderMemberMissionState(saved.owner);
+      const logPath = appendMemberLog(saved.owner, 'Mission selected task spine attached', {
+        mission: saved.objective,
+        task: saved.task_ref || saved.current_task_id,
+      });
+      const view = missionStatusView(saved);
+      printJsonOrText(
+        { ok: true, action: 'mission_selected_task_spine_attached', mission: view, task_spine: view.task_spine, member_state: memberState, log_path: logPath },
+        [
+          `Attached selected task spine: ${saved.objective}`,
+          `Task: ${view.task_spine.task_ref}`,
+          `Next: ${view.task_spine.current_step_command}`,
+        ],
+        asJson,
+      );
+      return;
+    }
+    const xpTask = createMissionXpTask(baseMission, process.cwd(), asJson);
+    const nextMission = {
+      ...baseMission,
+      xp_task_enabled: true,
+      xp_task: xpTask,
+      task_ids: Array.from(new Set([...(baseMission.task_ids || []), xpTask.task_id])),
+    };
+    if (nextMission.status === 'ready' && nextMission.receipt_path) {
+      nextMission.next_action = missionXpReadyAction(nextMission, nextMission.receipt_path) || nextMission.next_action;
+    } else if (missionChoosesNextMission(nextMission)) {
+      const nextPlan = chooseNextMissionPlan(nextMission);
+      nextMission.next_action = `decide next mission, then run: ${nextPlan.command}`;
+      nextMission.next_action_preview = nextPlan.preview;
+    } else if (!nextMission.verifier && !nextMission.always_on) {
+      nextMission.next_action = `work task then run: atris task current-step --goal-id ${nextMission.id} --as ${nextMission.owner} --proof "<proof>" --json`;
+    }
+
+    const { mission: saved } = saveMission(nextMission, process.cwd(), 'mission_task_spine_attached', { task_id: xpTask.task_id, task_ref: xpTask.ref });
+    const memberState = renderMemberMissionState(saved.owner);
+    const logPath = appendMemberLog(saved.owner, 'Mission task spine attached', {
+      mission: saved.objective,
+      task: xpTask.ref,
+    });
+    const view = missionStatusView(saved);
     printJsonOrText(
-      { ok: true, action: 'mission_task_spine_exists', mission: view, task_spine: view.task_spine },
+      { ok: true, action: 'mission_task_spine_attached', mission: view, task: xpTask, task_spine: view.task_spine, member_state: memberState, log_path: logPath },
       [
-        `Mission task spine already exists: ${mission.objective}`,
-        `Task: ${view.task_spine.task_ref}`,
+        `Attached task spine: ${saved.objective}`,
+        `Task: ${xpTask.ref}`,
         `Next: ${view.task_spine.current_step_command}`,
       ],
       asJson,
     );
-    return;
-  }
-
-  const ownership = applyMissionOwnerResolution(mission, process.cwd());
-  const baseMission = ownership.mission;
-  const xpTask = createMissionXpTask(baseMission, process.cwd(), asJson);
-  const nextMission = {
-    ...baseMission,
-    xp_task_enabled: true,
-    xp_task: xpTask,
-    task_ids: Array.from(new Set([...(baseMission.task_ids || []), xpTask.task_id])),
-  };
-  if (nextMission.status === 'ready' && nextMission.receipt_path) {
-    nextMission.next_action = missionXpReadyAction(nextMission, nextMission.receipt_path) || nextMission.next_action;
-  } else if (!nextMission.verifier && !nextMission.always_on) {
-    nextMission.next_action = `work task then run: atris task current-step --goal-id ${nextMission.id} --as ${nextMission.owner} --proof "<proof>" --json`;
+  } finally {
+    releaseMissionLock(lock);
   }
-
-  const { mission: saved } = saveMission(nextMission, process.cwd(), 'mission_task_spine_attached', { task_id: xpTask.task_id, task_ref: xpTask.ref });
-  const memberState = renderMemberMissionState(saved.owner);
-  const logPath = appendMemberLog(saved.owner, 'Mission task spine attached', {
-    mission: saved.objective,
-    task: xpTask.ref,
-  });
-  const view = missionStatusView(saved);
-  printJsonOrText(
-    { ok: true, action: 'mission_task_spine_attached', mission: view, task: xpTask, task_spine: view.task_spine, member_state: memberState, log_path: logPath },
-    [
-      `Attached task spine: ${saved.objective}`,
-      `Task: ${xpTask.ref}`,
-      `Next: ${view.task_spine.current_step_command}`,
-    ],
-    asJson,
-  );
 }
 
 function statusMission(args) {
@@ -1288,14 +2988,17 @@ function statusMission(args) {
         `  id: ${mission.id}`,
         `  owner: ${mission.owner}`,
         ...(mission.executed_by ? [`  executed_by: ${mission.executed_by}`] : []),
-        `  state: ${mission.status}`,
-        ...missionHeartbeatLines(mission),
-        ...(mission.worktree_root ? [`  worktree: ${mission.worktree_root}`] : []),
-        `  next: ${mission.next_action || 'tick or verify'}`,
-        ...(mission.task_spine?.task_ref ? [`  task: ${mission.task_spine.task_ref}`] : []),
+	        `  state: ${mission.status}`,
+	        ...missionHeartbeatLines(mission),
+	        ...(mission.worktree_root ? [`  worktree: ${mission.worktree_root}`] : []),
+	        `  next: ${mission.next_action || 'tick or verify'}`,
+	        ...(mission.next_action_preview?.feynman?.what ? [`  preview: ${mission.next_action_preview.feynman.what}`] : []),
+	        ...missionGoalChainLines(mission),
+	        ...(mission.task_spine?.task_ref ? [`  task: ${mission.task_spine.task_ref}`] : []),
         ...(mission.task_spine?.current_step_command ? [`  task next: ${mission.task_spine.current_step_command}`] : []),
         ...(!mission.task_spine?.has_task && mission.task_spine?.ensure_task_command ? [`  task setup: ${mission.task_spine.ensure_task_command}`] : []),
         ...(mission.receipt_path ? [`  proof: ${mission.receipt_path}`] : []),
+        ...missionStatusLandingLines(mission.last_landing),
         ...(completionGateLabel(mission.completion_gate) ? [`  gate: ${completionGateLabel(mission.completion_gate)}`] : []),
       ])
       : ['No missions yet. Run: atris mission start "..." --owner <member>'],
@@ -1303,48 +3006,381 @@ function statusMission(args) {
   );
 }
 
-function readMissionReceipt(receiptPath, root = process.cwd()) {
-  if (!receiptPath) return null;
-  const file = path.isAbsolute(receiptPath) ? receiptPath : path.join(root, receiptPath);
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {
-    return null;
-  }
+function readMissionReceipt(receiptPath, root = process.cwd()) {
+  if (!receiptPath) return null;
+  const file = path.isAbsolute(receiptPath) ? receiptPath : path.join(root, receiptPath);
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function firstUsefulLine(text, fallback = '') {
+  return String(text || '')
+    .split(/\r?\n/)
+    .map((line) => line.replace(/^[-*\s#]+/, '').trim())
+    .filter(Boolean)
+    .find((line) => !/^(receipt|summary|final|result)$/i.test(line))
+    || fallback;
+}
+
+function missionWorkerLabel(mission) {
+  const runner = String(mission && mission.runner || 'manual').toLowerCase();
+  if (runner === 'atris2') return `Remote Atris2 computer${mission.model ? ` using ${mission.model}` : ''}`;
+  if (runner === 'claude') return `Claude worker${mission.model ? ` using ${mission.model}` : ''}`;
+  if (runner === 'codex_goal') return 'Codex goal handoff';
+  return 'Local mission tick';
+}
+
+function missionWorkerSummary(mission, receipt) {
+  if (mission && mission.worker_summary) return mission.worker_summary;
+  const tick = receipt && receipt.result && (receipt.result.tick || (Array.isArray(receipt.result.ticks) ? receipt.result.ticks[receipt.result.ticks.length - 1] : null));
+  if (!tick) return mission && mission.last_tick_reason ? `Last tick: ${mission.last_tick_reason}` : 'No worker receipt yet.';
+  return missionTickReportSummary(tick);
+}
+
+function missionTickReportSummary(tick) {
+  if (!tick) return 'Worker tick recorded.';
+  if (tick.atris2) {
+    return firstUsefulLine(tick.atris2.receipt_text, tick.atris2.ok ? 'Remote worker ran and returned a response.' : 'Remote worker failed.');
+  }
+  if (tick.claude) {
+    if (tick.claude.skipped) {
+      const skipReason = tick.claude.reason || tick.reason || '';
+      if (!tick.summary && ['runner-uses-caller-session', 'orchestrator-is-caller-session'].includes(skipReason)) {
+        return 'Goal handed to the active Codex session.';
+      }
+      return tick.summary || `Worker step skipped: ${tick.claude.reason || tick.reason || 'not needed'}.`;
+    }
+    return tick.claude.summary || firstUsefulLine(tick.claude.receipt_text, tick.claude.ok ? 'Worker ran and returned a response.' : 'Worker failed.');
+  }
+  if (tick.summary) return tick.summary;
+  return tick.reason ? `Worker tick: ${tick.reason}` : 'Worker tick recorded.';
+}
+
+function missionReceiptTicks(receipt) {
+  const result = receipt && receipt.result;
+  if (!result) return [];
+  if (result.tick) return [result.tick];
+  if (Array.isArray(result.ticks)) return result.ticks.filter(Boolean);
+  return [];
+}
+
+function missionTickAt(receipt, tick) {
+  return tick.finished_at || tick.started_at || receipt.at || '';
+}
+
+function missionTimelineTitle(tick, summary) {
+  const tickIndex = Number(tick && tick.tick_index);
+  const prefix = Number.isInteger(tickIndex) && tickIndex > 0 ? `Goal ${tickIndex}` : 'Goal';
+  const text = String(summary || '').trim();
+  const explicitGoal = text.match(/^(Goal\s+\d+)\s*:\s*(.*)$/i);
+  if (explicitGoal) {
+    return missionTimelineTitleLine(`${explicitGoal[1].replace(/\s+/g, ' ')}: ${explicitGoal[2].trim()}`);
+  }
+  return missionTimelineTitleLine(`${prefix}: ${text.replace(/^Goal\s*:\s*/i, '').trim()}`);
+}
+
+function missionTimelineTitleLine(title) {
+  const text = String(title || '').replace(/\s+/g, ' ').trim();
+  const firstSentence = text.match(/^(.+?[.!?])(?:\s+|$)/);
+  const candidate = firstSentence ? firstSentence[1].trim() : text;
+  if (candidate.length <= 180) return candidate;
+  return `${candidate.slice(0, 177).trimEnd()}...`;
+}
+
+function missionTimelineSummaryIsUseful(summary) {
+  const text = String(summary || '').trim();
+  if (!text) return false;
+  return ![
+    'Goal handed to the active Codex session.',
+    'Worker tick recorded.',
+  ].includes(text) && !/^Worker step skipped:/i.test(text);
+}
+
+function missionTimelineTickIndex(tick) {
+  const tickIndex = Number(tick && tick.tick_index);
+  return Number.isInteger(tickIndex) && tickIndex > 0 ? tickIndex : null;
+}
+
+function missionReportTimeline(mission, root = process.cwd(), limit = 6) {
+  const paths = statePaths(root);
+  let files = [];
+  try {
+    files = fs.readdirSync(paths.runsDir)
+      .filter((file) => file.startsWith('mission-') && file.endsWith('.json'))
+      .map((file) => path.join(paths.runsDir, file));
+  } catch {
+    files = [];
+  }
+
+  const items = [];
+  const seen = new Set();
+  for (const file of files) {
+    let receipt = null;
+    try {
+      receipt = JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch {
+      continue;
+    }
+    if (!receipt || receipt.mission_id !== mission.id) continue;
+    const receiptPath = path.relative(root, file);
+    for (const tick of missionReceiptTicks(receipt)) {
+      const summary = missionTickReportSummary(tick);
+      if (!missionTimelineSummaryIsUseful(summary)) continue;
+      const at = missionTickAt(receipt, tick);
+      const key = `${tick.tick_index || ''}:${at}:${summary}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      items.push({
+        at,
+        tick_index: missionTimelineTickIndex(tick),
+        title: missionTimelineTitle(tick, summary),
+        summary,
+        receipt_path: receiptPath,
+      });
+    }
+  }
+
+  items.sort((a, b) => String(a.at || '').localeCompare(String(b.at || '')));
+  return items.slice(Math.max(0, items.length - limit));
+}
+
+function missionLandingTimeline(mission, root = process.cwd(), limit = 12) {
+  const paths = statePaths(root);
+  let files = [];
+  try {
+    files = fs.readdirSync(paths.runsDir)
+      .filter((file) => file.startsWith('mission-') && file.endsWith('.json'))
+      .map((file) => path.join(paths.runsDir, file));
+  } catch {
+    files = [];
+  }
+
+  const items = [];
+  const seen = new Set();
+  for (const file of files) {
+    let receipt = null;
+    try {
+      receipt = JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch {
+      continue;
+    }
+    if (!receipt || receipt.mission_id !== mission.id) continue;
+    const landing = receipt.result && receipt.result.landing;
+    if (landing && landing.timeline_visible === false) continue;
+    const changed = String(landing && landing.changed || '').trim();
+    const next = String(landing && landing.next || '').trim();
+    if (!changed && !next) continue;
+    const receiptPath = path.relative(root, file);
+    const key = `${receipt.at || ''}:${changed}:${next}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    items.push({
+      at: receipt.at || '',
+      changed,
+      next,
+      receipt_path: receiptPath,
+      created_next: receipt.result.created_next || null,
+    });
+  }
+  items.sort((a, b) => String(a.at || '').localeCompare(String(b.at || '')));
+  const normalizedLimit = Number.isFinite(limit) && limit > 0 ? limit : items.length;
+  const shown = items.slice(Math.max(0, items.length - normalizedLimit));
+  return {
+    items: shown,
+    meta: {
+      shown_count: shown.length,
+      total_count: items.length,
+      hidden_count: Math.max(0, items.length - shown.length),
+      truncated: shown.length < items.length,
+      limit: normalizedLimit === Number.MAX_SAFE_INTEGER ? null : normalizedLimit,
+    },
+  };
+}
+
+function formatInteger(value) {
+  return String(Math.max(0, Number(value || 0))).replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+
+function missionTimelinePruneSummaryMarkdown(prunePreview) {
+  if (!prunePreview) return [];
+  if (prunePreview.error) {
+    return [
+      '',
+      '## Latest prune dry-run',
+      '',
+      `- Not available: ${prunePreview.error}`,
+    ];
+  }
+  return [
+    '',
+    '## Latest prune dry-run',
+    '',
+    `- Policy: keep newest ${formatInteger(prunePreview.policy?.keep_newest)}; keep ${formatInteger(prunePreview.policy?.keep_days)} days`,
+    `- Total run files: ${formatInteger(prunePreview.total_files)}`,
+    `- Total run bytes: ${formatInteger(prunePreview.total_bytes)} (${formatBytes(prunePreview.total_bytes)})`,
+    `- Referenced files kept: ${formatInteger(prunePreview.referenced_files)}`,
+    `- Recent files kept: ${formatInteger(prunePreview.recent_files)}`,
+    `- Would prune: ${formatInteger(prunePreview.prune_count)} files / ${formatInteger(prunePreview.prune_bytes)} bytes (${formatBytes(prunePreview.prune_bytes)})`,
+    `- Deleted files: ${formatInteger(prunePreview.deleted_count)}`,
+  ];
+}
+
+function missionTimelinePruneSummaryLine(prunePreview) {
+  if (!prunePreview) return null;
+  if (prunePreview.error) return `Prune dry-run: not available (${prunePreview.error}).`;
+  return `Prune dry-run: ${formatInteger(prunePreview.prune_count)} files / ${formatBytes(prunePreview.prune_bytes)} would prune; ${formatInteger(prunePreview.deleted_count)} deleted.`;
+}
+
+function missionTimelinePruneSummaryObject(prunePreview) {
+  if (!prunePreview) return null;
+  if (prunePreview.error) {
+    return {
+      ok: false,
+      error: prunePreview.error,
+      text: missionTimelinePruneSummaryLine(prunePreview),
+    };
+  }
+  return {
+    ok: true,
+    text: missionTimelinePruneSummaryLine(prunePreview),
+    total_files: prunePreview.total_files,
+    total_bytes: prunePreview.total_bytes,
+    referenced_files: prunePreview.referenced_files,
+    recent_files: prunePreview.recent_files,
+    prune_count: prunePreview.prune_count,
+    prune_bytes: prunePreview.prune_bytes,
+    prune_bytes_text: formatBytes(prunePreview.prune_bytes),
+    deleted_count: prunePreview.deleted_count,
+  };
+}
+
+function missionTimelineCurrentLanding(timeline) {
+  if (!timeline.length) return null;
+  const latest = timeline[timeline.length - 1];
+  return {
+    at: latest.at || '',
+    changed: latest.changed || '',
+    next: latest.next || '',
+    receipt_path: latest.receipt_path || '',
+  };
+}
+
+function missionTimelineEmptyStateDisplay(mission, timelineLength = 0) {
+  const hasMission = Boolean(mission);
+  const isEmpty = !timelineLength;
+  return {
+    label: 'Empty state',
+    is_empty: isEmpty,
+    has_mission: hasMission,
+    title: isEmpty ? (hasMission ? 'No timeline items yet.' : 'No missions yet.') : null,
+    message: isEmpty
+      ? (hasMission ? 'Run the mission once to create the first timeline item.' : 'Start a mission to create the first timeline item.')
+      : null,
+    action_label: isEmpty ? (hasMission ? 'Run mission' : 'Start mission') : null,
+    command: isEmpty ? (hasMission ? `atris mission run ${mission.id} --create-next` : 'atris mission start "..." --owner <member>') : null,
+  };
+}
+
+function missionTimelineNextMove(mission, landing) {
+  const latestNext = landing ? String(landing.next || '').trim() : '';
+  return latestNext || `atris mission run ${mission.id} --create-next`;
 }
 
-function firstUsefulLine(text, fallback = '') {
-  return String(text || '')
-    .split(/\r?\n/)
-    .map((line) => line.replace(/^[-*\s#]+/, '').trim())
-    .filter(Boolean)
-    .find((line) => !/^(receipt|summary|final|result)$/i.test(line))
-    || fallback;
+function missionTimelineCountLine(meta) {
+  if (!meta) return null;
+  const shown = Number(meta.shown_count || 0);
+  const total = Number(meta.total_count || 0);
+  if (meta.truncated) {
+    return `Showing latest ${formatInteger(shown)} of ${formatInteger(total)} ${total === 1 ? 'item' : 'items'}.`;
+  }
+  return `Showing ${formatInteger(shown)} ${shown === 1 ? 'item' : 'items'}.`;
 }
 
-function missionWorkerLabel(mission) {
-  const runner = String(mission && mission.runner || 'manual').toLowerCase();
-  if (runner === 'atris2') return `Remote Atris2 computer${mission.model ? ` using ${mission.model}` : ''}`;
-  if (runner === 'claude') return `Claude worker${mission.model ? ` using ${mission.model}` : ''}`;
-  if (runner === 'codex_goal') return 'Codex goal handoff';
-  return 'Local mission tick';
+function missionTimelineCurrentLandingLines(landing) {
+  if (!landing) return [];
+  return [
+    'Current landing:',
+    `  Changed: ${landing.changed || 'Landing recorded.'}`,
+    ...(landing.next ? [`  Next: ${landing.next}`] : []),
+    `  Proof: ${landing.receipt_path}`,
+    '',
+  ];
 }
 
-function missionWorkerSummary(mission, receipt) {
-  if (mission && mission.worker_summary) return mission.worker_summary;
-  const tick = receipt && receipt.result && (receipt.result.tick || (Array.isArray(receipt.result.ticks) ? receipt.result.ticks[receipt.result.ticks.length - 1] : null));
-  if (!tick) return mission && mission.last_tick_reason ? `Last tick: ${mission.last_tick_reason}` : 'No worker receipt yet.';
-  if (tick.atris2) {
-    return firstUsefulLine(tick.atris2.receipt_text, tick.atris2.ok ? 'Remote worker ran and returned a response.' : 'Remote worker failed.');
+function missionTimelineMarkdown(mission, timeline, { prunePreview = null, generatedAt = stampIso(), timelineMeta = null } = {}) {
+  const latestLanding = timeline.length ? timeline[timeline.length - 1] : null;
+  const nextMove = missionTimelineNextMove(mission, latestLanding);
+  const lines = [
+    `# Mission timeline: ${mission.objective}`,
+    '',
+    `Mission: ${mission.id}`,
+    `Status: ${mission.status}`,
+    `Generated at: ${generatedAt}`,
+    ...(timelineMeta ? [missionTimelineCountLine(timelineMeta)] : []),
+    '',
+    '## Operator commands',
+    '',
+    `- Timeline: \`${missionRunTimelineCommand(mission)}\``,
+    `- Export: \`${missionRunExportCommand(mission)}\``,
+    `- Prune preview: \`${missionRunPrunePreviewCommand(mission)}\``,
+    '',
+  ];
+  if (latestLanding) {
+    lines.push(
+      '## Current landing',
+      '',
+      `Changed: ${latestLanding.changed || 'Landing recorded.'}`,
+      ...(latestLanding.next ? [`Next: ${latestLanding.next}`] : []),
+      `Proof: ${latestLanding.receipt_path}`,
+      '',
+    );
   }
-  if (tick.claude) {
-    if (tick.claude.skipped) {
-      return tick.summary || `Worker step skipped: ${tick.claude.reason || tick.reason || 'not needed'}.`;
-    }
-    return tick.claude.summary || firstUsefulLine(tick.claude.receipt_text, tick.claude.ok ? 'Worker ran and returned a response.' : 'Worker failed.');
+  if (!timeline.length) {
+    lines.push('No landing receipts yet.');
+    lines.push(
+      '',
+      '## Next move',
+      '',
+      nextMove,
+    );
+    lines.push(
+      '',
+      '## Keep it concise',
+      '',
+      '- Dry run: `atris mission prune-runs --days 14 --keep-newest 200`',
+      '- Apply only after review: add `--apply`.',
+    );
+    lines.push(...missionTimelinePruneSummaryMarkdown(prunePreview));
+    lines.push('');
+    return lines.join('\n');
   }
-  if (tick.summary) return tick.summary;
-  return tick.reason ? `Worker tick: ${tick.reason}` : 'Worker tick recorded.';
+  timeline.forEach((item, index) => {
+    if (index === 0) lines.push('## Full history', '');
+    lines.push(`${index + 1}. ${item.changed || 'Landing recorded.'}`);
+    if (item.next) lines.push(`   - Next: ${item.next}`);
+    lines.push(`   - Proof: ${item.receipt_path}`);
+  });
+  lines.push('', '## Next move', '', nextMove);
+  lines.push(
+    '',
+    '## Keep it concise',
+    '',
+    '- Dry run: `atris mission prune-runs --days 14 --keep-newest 200`',
+    '- Apply only after review: add `--apply`.',
+  );
+  lines.push(...missionTimelinePruneSummaryMarkdown(prunePreview));
+  lines.push('');
+  return lines.join('\n');
+}
+
+function defaultMissionTimelinePath(root, mission) {
+  const safeId = String(mission.id || 'mission')
+    .replace(/[^a-zA-Z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'mission';
+  return path.join(root, 'atris', 'reports', `${safeId}-timeline.md`);
 }
 
 function missionReportFor(mission, root = process.cwd()) {
@@ -1361,12 +3397,19 @@ function missionReportFor(mission, root = process.cwd()) {
     operator_outcome: operatorOutcome,
     worker: mission.worker || missionWorkerLabel(mission),
     worker_summary: missionWorkerSummary(mission, receipt),
+    timeline: missionReportTimeline(mission, root),
     worker_receipt_path: workerReceiptPath,
     verifier_receipt_path: verifierReceiptPath,
     operator_next: mission.operator_next || mission.next_action || 'Review the mission state.',
   };
 }
 
+function missionReportNextText(nextAction) {
+  return String(nextAction || 'Review the mission state.')
+    .replace(/^next move:\s*run\s+/i, '')
+    .trim();
+}
+
 function reportMission(args) {
   const asJson = wantsJson(args);
   const localOnly = hasFlag(args, '--local');
@@ -1396,15 +3439,483 @@ function reportMission(args) {
         `  What happened: ${report.operator_outcome}`,
         `  Worker: ${report.worker}`,
         `  Worker summary: ${report.worker_summary}`,
+        ...(report.timeline && report.timeline.length ? [
+          '  Timeline:',
+          ...report.timeline.map((item) => `    - ${item.title}`),
+        ] : []),
         ...(report.worker_receipt_path ? [`  Worker receipt: ${report.worker_receipt_path}`] : []),
         ...(report.verifier_receipt_path ? [`  Verifier receipt: ${report.verifier_receipt_path}`] : []),
-        `  Next: ${report.operator_next}`,
+        `  Next: ${missionReportNextText(report.operator_next)}`,
       ])
       : ['No missions yet. Run: atris mission start "..." --owner <member>'],
     asJson,
   );
 }
 
+function timelineMission(args) {
+  const asJson = wantsJson(args);
+  const write = hasFlag(args, '--write');
+  const all = hasFlag(args, '--all');
+  const prunePreviewRequested = hasFlag(args, '--prune-preview');
+  const outputPath = readFlag(args, '--output', '') || readFlag(args, '--out', '');
+  const ref = stripKnownFlags(args, ['--limit', '--output', '--out'], ['--json', '--write', '--all', '--prune-preview'])[0] || '';
+  const limit = all ? Number.MAX_SAFE_INTEGER : readPositiveIntegerFlag(args, '--limit', 12, { json: asJson });
+  const missions = listMissions();
+  const mission = ref
+    ? resolveMission(ref)
+    : (missions.find((row) => !TERMINAL_STATUSES.has(row.status)) || missions[0] || null);
+  if (ref && !mission) {
+    exitMissionError(`Mission "${ref}" not found.`, 1, asJson);
+  }
+  if (!mission) {
+    printJsonOrText(
+      {
+        ok: true,
+        action: 'mission_timeline',
+        mission: null,
+        timeline: [],
+        empty_state_display: missionTimelineEmptyStateDisplay(null, 0),
+      },
+      ['No missions yet. Run: atris mission start "..." --owner <member>'],
+      asJson,
+    );
+    return;
+  }
+  const root = mission.worktree_root || process.cwd();
+  const timelineResult = missionLandingTimeline(mission, root, limit);
+  const timeline = timelineResult.items;
+  const currentLanding = missionTimelineCurrentLanding(timeline);
+  const timelineItemDisplay = (item) => ({
+    changed_label: 'Changed',
+    changed: item.changed || 'Landing recorded.',
+    next_label: 'Next',
+    next: item.next || null,
+    proof_label: 'Proof',
+    proof: item.receipt_path || null,
+  });
+  const currentLandingDisplay = currentLanding ? {
+    label: 'Current landing',
+    ...timelineItemDisplay(currentLanding),
+  } : null;
+  const historyWithoutCurrent = currentLanding ? timeline.slice(0, -1) : timeline;
+  const historyWithoutCurrentDisplay = historyWithoutCurrent.map((item, index) => ({
+    index: index + 1,
+    label: `History item ${index + 1}`,
+    ...timelineItemDisplay(item),
+  }));
+  const timelineDisplay = timeline.map((item, index) => ({
+    index: index + 1,
+    label: `Timeline item ${index + 1}`,
+    at_label: 'When',
+    at: item.at || null,
+    ...timelineItemDisplay(item),
+  }));
+  const nextMove = missionTimelineNextMove(mission, currentLanding);
+  const generatedAt = stampIso();
+  let artifactPath = null;
+  let prunePreview = null;
+  if (write || prunePreviewRequested) {
+    try {
+      prunePreview = pruneRuns(root, { keepNewest: 200, keepDays: 14 });
+    } catch (error) {
+      prunePreview = { error: error.message || String(error) };
+    }
+  }
+  if (write) {
+    const outPath = outputPath
+      ? path.resolve(root, outputPath)
+      : defaultMissionTimelinePath(root, mission);
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, missionTimelineMarkdown(mission, timeline, { prunePreview, generatedAt, timelineMeta: timelineResult.meta }), 'utf8');
+    artifactPath = path.relative(root, outPath);
+  }
+  const pruneSummary = missionTimelinePruneSummaryObject(prunePreview);
+  const pruneDisplay = {
+    label: 'Prune preview',
+    command: missionRunPrunePreviewCommand(mission),
+    available: Boolean(pruneSummary),
+    ok: pruneSummary?.ok ?? null,
+    summary: pruneSummary?.text || null,
+    would_prune_label: 'Would prune',
+    prune_count: pruneSummary?.prune_count ?? null,
+    prune_bytes_text: pruneSummary?.prune_bytes_text || null,
+    deleted_label: 'Deleted',
+    deleted_count: pruneSummary?.deleted_count ?? null,
+  };
+  const payload = {
+    ok: true,
+    action: 'mission_timeline',
+    generated_at: generatedAt,
+    generated: {
+      label: 'Generated at',
+      at: generatedAt,
+    },
+    schema_display: {
+      label: 'Schema',
+      name: 'atris.mission_timeline',
+      version: 1,
+      primary_objects: [
+        'display',
+        'summary_display',
+        'navigation_display',
+        'filter_display',
+        'mission_display',
+        'current_landing_display',
+        'history_without_current_display',
+        'timeline_display',
+        'timeline_meta_display',
+        'empty_state_display',
+        'status_display',
+        'actions_display',
+        'proof_display',
+        'receipt_display',
+        'export_display',
+        'prune_display',
+        'artifact_display',
+      ],
+    },
+    summary_display: {
+      label: 'Summary',
+      title: `Mission timeline: ${mission.objective}`,
+      count: missionTimelineCountLine(timelineResult.meta),
+      latest_label: 'Latest',
+      latest: currentLanding?.changed || null,
+      proof_label: 'Proof',
+      proof: currentLanding?.receipt_path || null,
+      next_label: 'Next',
+      next: nextMove,
+    },
+    display: {
+      title: `Mission timeline: ${mission.objective}`,
+      generated: `Generated at: ${generatedAt}`,
+      count: missionTimelineCountLine(timelineResult.meta),
+      current_landing_label: 'Current landing',
+      history_label: 'History',
+      next_label: 'Next',
+    },
+    status_display: {
+      label: 'Status',
+      mission_status_label: 'Mission status',
+      mission_status: mission.status,
+      history_status_label: 'History status',
+      history_status: timelineResult.meta.truncated ? 'Compact history' : 'Full history',
+      count: missionTimelineCountLine(timelineResult.meta),
+      truncated: Boolean(timelineResult.meta.truncated),
+      hidden_count: timelineResult.meta.hidden_count,
+    },
+    empty_state_display: missionTimelineEmptyStateDisplay(mission, timeline.length),
+    mission: {
+      id: mission.id,
+      objective: mission.objective,
+      status: mission.status,
+    },
+    mission_labels: {
+      mission: 'Mission',
+      objective: 'Objective',
+      status: 'Status',
+    },
+    mission_display: {
+      label: 'Mission',
+      title: mission.objective,
+      id: mission.id,
+      status: mission.status,
+    },
+    operator_commands: {
+      timeline: missionRunTimelineCommand(mission),
+      export: missionRunExportCommand(mission),
+      prune_preview: missionRunPrunePreviewCommand(mission),
+    },
+    commands: {
+      timeline: missionRunTimelineCommand(mission),
+      export: missionRunExportCommand(mission),
+      prune_preview: missionRunPrunePreviewCommand(mission),
+    },
+    actions_display: {
+      label: 'Actions',
+      items: [
+        { label: 'Timeline', command: missionRunTimelineCommand(mission) },
+        { label: 'Export', command: missionRunExportCommand(mission) },
+        { label: 'Prune preview', command: missionRunPrunePreviewCommand(mission) },
+      ],
+    },
+    navigation_display: {
+      label: 'Navigation',
+      current_label: 'Current view',
+      current: 'timeline',
+      items: [
+        { key: 'timeline', label: 'Timeline', command: missionRunTimelineCommand(mission), active: true },
+        { key: 'export', label: 'Full history', command: missionRunExportCommand(mission), active: false },
+        { key: 'prune_preview', label: 'Prune preview', command: missionRunPrunePreviewCommand(mission), active: false },
+      ],
+    },
+    filter_display: {
+      label: 'Filters',
+      active_label: 'Active filter',
+      active: all ? 'full_history' : 'latest',
+      limit_label: 'Limit',
+      limit: timelineResult.meta.limit,
+      shown_count: timelineResult.meta.shown_count,
+      total_count: timelineResult.meta.total_count,
+      hidden_count: timelineResult.meta.hidden_count,
+      truncated_label: 'Truncated',
+      truncated: Boolean(timelineResult.meta.truncated),
+      items: [
+        { key: 'latest', label: 'Latest', command: missionRunTimelineCommand(mission), active: !all },
+        { key: 'full_history', label: 'Full history', command: `atris mission timeline ${mission.id} --all`, active: Boolean(all) },
+      ],
+    },
+    current_landing: currentLanding,
+    current_landing_display: currentLandingDisplay,
+    current_landing_label: 'Current landing',
+    history_without_current: historyWithoutCurrent,
+    history_without_current_display: historyWithoutCurrentDisplay,
+    history_without_current_count: historyWithoutCurrent.length,
+    has_history_without_current: historyWithoutCurrent.length > 0,
+    history_label: 'History',
+    labels: {
+      current_landing: 'Current landing',
+      history: 'History',
+    },
+    counts: {
+      timeline: timeline.length,
+      history_without_current: historyWithoutCurrent.length,
+      total: timelineResult.meta.total_count,
+      hidden: timelineResult.meta.hidden_count,
+      shown: timelineResult.meta.shown_count,
+    },
+    booleans: {
+      has_current_landing: Boolean(currentLanding),
+      has_history_without_current: historyWithoutCurrent.length > 0,
+      truncated: Boolean(timelineResult.meta.truncated),
+      all: Boolean(all),
+    },
+    next_move: nextMove,
+    next: {
+      label: 'Next',
+      move: nextMove,
+      has_move: Boolean(nextMove),
+    },
+    timeline,
+    timeline_display: timelineDisplay,
+    timeline_meta: timelineResult.meta,
+    timeline_meta_display: {
+      label: 'Timeline metadata',
+      shown_label: 'Shown',
+      shown_count: timelineResult.meta.shown_count,
+      total_label: 'Total',
+      total_count: timelineResult.meta.total_count,
+      hidden_label: 'Hidden',
+      hidden_count: timelineResult.meta.hidden_count,
+      limit_label: 'Limit',
+      limit: timelineResult.meta.limit,
+      truncated_label: 'Truncated',
+      truncated: Boolean(timelineResult.meta.truncated),
+    },
+    all,
+    prune_summary: pruneSummary,
+    prune_display: pruneDisplay,
+    prune_preview: prunePreview,
+    artifact: {
+      path: artifactPath,
+      written: Boolean(artifactPath),
+      format: artifactPath ? 'markdown' : null,
+    },
+    artifact_display: {
+      label: 'Artifact',
+      path_label: 'Path',
+      path: artifactPath,
+      written_label: 'Written',
+      written: Boolean(artifactPath),
+      format_label: 'Format',
+      format: artifactPath ? 'markdown' : null,
+    },
+    export_display: {
+      label: 'Export',
+      command: missionRunExportCommand(mission),
+      report_label: 'Saved report',
+      report_path: artifactPath,
+      report_written: Boolean(artifactPath),
+      report_format: artifactPath ? 'markdown' : null,
+    },
+    receipt_display: {
+      label: 'Receipts',
+      latest_label: 'Latest receipt',
+      latest_path: currentLanding?.receipt_path || null,
+      has_latest: Boolean(currentLanding?.receipt_path),
+      count_label: 'Receipts',
+      count: timeline.filter((item) => item.receipt_path).length,
+      items: timeline.map((item, index) => ({
+        index: index + 1,
+        label: `Receipt ${index + 1}`,
+        path: item.receipt_path || null,
+        at: item.at || null,
+        current: Boolean(currentLanding?.receipt_path && item.receipt_path === currentLanding.receipt_path),
+      })),
+    },
+    proof_display: {
+      label: 'Proof',
+      latest_receipt_label: 'Latest receipt',
+      latest_receipt_path: currentLanding?.receipt_path || null,
+      report_label: 'Saved report',
+      report_path: artifactPath,
+      report_written: Boolean(artifactPath),
+      report_format: artifactPath ? 'markdown' : null,
+    },
+    artifact_path: artifactPath,
+  };
+  const lines = timeline.length
+    ? [
+      `Mission timeline: ${mission.objective}`,
+      `Generated at: ${generatedAt}`,
+      missionTimelineCountLine(timelineResult.meta),
+      ...missionTimelineCurrentLandingLines(currentLanding),
+      ...(historyWithoutCurrent.length ? ['History:'] : []),
+      ...historyWithoutCurrent.flatMap((item, index) => [
+        `  ${index + 1}. ${item.changed || 'Landing recorded.'}`,
+        ...(item.next ? [`     Next: ${item.next}`] : []),
+        `     Proof: ${item.receipt_path}`,
+      ]),
+    ]
+    : [
+      `Mission timeline: ${mission.objective}`,
+      `Generated at: ${generatedAt}`,
+      missionTimelineCountLine(timelineResult.meta),
+      '  No landing receipts yet.',
+      `  Next: atris mission run ${mission.id} --create-next`,
+    ];
+  if (timelineResult.meta.truncated) lines.push(`Full history: ${missionRunExportCommand(mission)}`);
+  if (artifactPath) lines.push(`Saved: ${artifactPath}`);
+  const pruneLine = missionTimelinePruneSummaryLine(prunePreview);
+  if (pruneLine) lines.push(pruneLine);
+  printJsonOrText(payload, lines, asJson);
+}
+
+function missionReceiptHealth(mission, root = process.cwd()) {
+  const receiptPath = String(mission?.receipt_path || '').trim();
+  if (!receiptPath) return { ok: false, reason: 'missing_receipt_path' };
+  const file = path.isAbsolute(receiptPath) ? receiptPath : path.join(root, receiptPath);
+  let receipt = null;
+  try {
+    receipt = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return { ok: false, reason: 'receipt_not_found', receipt_path: receiptPath };
+  }
+  const missionVerifierPassedState = mission?.verifier_result?.passed === true;
+  const receiptPassed = receipt?.result?.passed === true
+    || receipt?.result?.verifier_result?.passed === true;
+  if (!missionVerifierPassedState || !receiptPassed) {
+    return { ok: false, reason: 'verifier_not_passed', receipt_path: receiptPath };
+  }
+  return { ok: true, reason: 'verifier_passed', receipt_path: receiptPath };
+}
+
+function collectMissionDoctorFindings(root = process.cwd(), options = {}) {
+  const localOnly = options.localOnly === true;
+  let missions = listMissions(root);
+  if (!localOnly) {
+    const seen = new Set(missions.map((mission) => mission.id));
+    for (const rolled of listWorktreeRollupMissions(root)) {
+      if (seen.has(rolled.id)) continue;
+      seen.add(rolled.id);
+      missions.push(rolled);
+    }
+  }
+  missions = missions.map(missionStatusView);
+  const findings = [];
+  const add = (mission, code, message, severity = 'high', extra = {}) => {
+    findings.push({
+      severity,
+      code,
+      mission_id: mission.id,
+      owner: mission.owner,
+      status: mission.status,
+      objective: mission.objective,
+      message,
+      next: extra.next || `atris mission status ${mission.id}`,
+      ...extra,
+    });
+  };
+
+  for (const mission of missions) {
+    const status = String(mission.status || '');
+    const active = !TERMINAL_STATUSES.has(status);
+    const objective = String(mission.objective || '').trim();
+    if (active && !effectiveMissionVerifier(mission)) {
+      add(
+        mission,
+        'missing_verifier',
+        'Mission has no verifier, so it cannot prove done work.',
+        'high',
+        { next: `atris mission start "${objective}" --owner ${mission.owner} --verify "<cmd>"` },
+      );
+    }
+    if (active && /^(?:--)?help$/i.test(objective)) {
+      add(
+        mission,
+        'accidental_help_mission',
+        'Looks like a help flag became a mission.',
+        'medium',
+        { next: `atris mission stop ${mission.id} --reason "accidental help mission"` },
+      );
+    }
+    if (status === 'ready') {
+      const receiptRoot = mission.worktree_root || root;
+      const health = missionReceiptHealth(mission, receiptRoot);
+      if (!health.ok) {
+        add(
+          mission,
+          'stale_ready_receipt',
+          `Ready mission does not have a fresh passing receipt (${health.reason}).`,
+          'high',
+          {
+            receipt_path: health.receipt_path || mission.receipt_path || null,
+            receipt_reason: health.reason,
+            next: `atris mission tick ${mission.id} --verify`,
+          },
+        );
+      }
+    }
+    if (mission.always_on === true && status === 'blocked') {
+      add(
+        mission,
+        'blocked_always_on_loop',
+        'Always-on mission is blocked and will not keep improving.',
+        'high',
+        { next: `atris mission run ${mission.id} --max-ticks 1` },
+      );
+    }
+  }
+
+  findings.sort((a, b) => {
+    const rank = { high: 0, medium: 1, low: 2 };
+    return (rank[a.severity] ?? 9) - (rank[b.severity] ?? 9)
+      || String(a.code).localeCompare(String(b.code))
+      || String(a.objective).localeCompare(String(b.objective));
+  });
+  return { missions, findings };
+}
+
+function doctorMission(args) {
+  const asJson = wantsJson(args);
+  const localOnly = hasFlag(args, '--local');
+  const { missions, findings } = collectMissionDoctorFindings(process.cwd(), { localOnly });
+  const payload = {
+    ok: findings.length === 0,
+    action: 'mission_doctor',
+    checked_count: missions.length,
+    finding_count: findings.length,
+    findings,
+  };
+  const lines = findings.length
+    ? [
+      `Mission doctor: ${findings.length} problem(s) across ${missions.length} mission(s)`,
+      ...findings.map((finding) => `${finding.severity.toUpperCase()} ${finding.code}: ${finding.objective} -> ${finding.next}`),
+    ]
+    : [`Mission doctor: clean (${missions.length} mission(s) checked)`];
+  printJsonOrText(payload, lines, asJson);
+  if (findings.length) process.exitCode = 1;
+}
+
 // `atris mission watch [id]` — read-only live heartbeat. Prints a line per tick as it
 // lands so a human (or any terminal) can see the loop is alive without rerunning status.
 function watchMission(args) {
@@ -1472,11 +3983,8 @@ function writeReceipt(mission, result, root = process.cwd()) {
   fs.mkdirSync(paths.runsDir, { recursive: true });
   const safeTime = stampIso().replace(/[:.]/g, '-');
   const receiptPath = path.join(paths.runsDir, `mission-${mission.id}-${safeTime}.json`);
-  // Back-compat: legacy consumers read receipt.result.passed (verifier-only shape).
-  // New shape nests verifier under result.verifier_result, so mirror .passed at top.
-  const finalResult = (result && typeof result === 'object' && result.verifier_result && !('passed' in result))
-    ? { ...result, passed: !!result.verifier_result.passed }
-    : result;
+  const relativeReceiptPath = path.relative(root, receiptPath);
+  const finalResult = normalizeMissionReceiptResult(mission, result, relativeReceiptPath);
   fs.writeFileSync(receiptPath, JSON.stringify({
     schema: 'atris.mission_receipt.v1',
     mission_id: mission.id,
@@ -1486,7 +3994,7 @@ function writeReceipt(mission, result, root = process.cwd()) {
     verifier: mission.verifier || null,
     result: finalResult,
   }, null, 2) + '\n', 'utf8');
-  return path.relative(root, receiptPath);
+  return relativeReceiptPath;
 }
 
 function shellQuote(value) {
@@ -1721,11 +4229,19 @@ function runnerUsesCallerSession(runner) {
   return new Set(['codex_goal', 'caller_session', 'current_agent']).has(String(runner || '').trim().toLowerCase());
 }
 
+function isCodexGoalMission(mission) {
+  return String(mission?.runner || '').trim().toLowerCase() === 'codex_goal';
+}
+
 function nextCandidateTickAction(mission) {
   const completeFlag = mission.always_on ? '' : ' --complete-on-pass';
   return `next move: run atris mission run ${mission.id}${completeFlag}`;
 }
 
+function nextCandidateRunCommand(mission) {
+  return `atris mission run ${mission.id}`;
+}
+
 function missionVerifierPassed(mission) {
   return (mission && mission.verifier_result && mission.verifier_result.passed) === true;
 }
@@ -1768,7 +4284,7 @@ function missionHeartbeatLines(mission, now = new Date()) {
   const lastTickAt = mission.last_tick_at ? Date.parse(mission.last_tick_at) : NaN;
   if (Number.isFinite(lastTickAt)) {
     const age = formatDurationShort((now.getTime() - lastTickAt) / 1000);
-    const verifier = mission.verifier
+    const verifier = effectiveMissionVerifier(mission)
       ? (mission.verifier_result ? (mission.verifier_result.passed ? 'verifier passed' : 'verifier failed') : 'verifier not run')
       : 'no verifier';
     const tickIdx = mission.last_tick_index != null ? `#${mission.last_tick_index}, ` : '';
@@ -1789,6 +4305,23 @@ function missionHasHumanAsks(mission) {
     && mission.human_asks.some((ask) => String(ask || '').trim());
 }
 
+function missionTaskHumanAcceptWaiting(mission) {
+  const taskId = missionTaskSpine(mission)?.task_id;
+  if (!taskId) return false;
+  try {
+    const taskDb = require('../lib/task-db');
+    const db = taskDb.open();
+    const task = taskDb.getTask(db, taskId);
+    if (!task) return false;
+    const metadata = task.metadata || {};
+    return task.status === 'review'
+      && metadata.approval_status === 'pending'
+      && metadata.agent_certified === true;
+  } catch {
+    return false;
+  }
+}
+
 function missionIsRunnable(mission) {
   return mission
     && GOAL_LOOP_STATUSES.has(String(mission.status || ''))
@@ -1802,7 +4335,8 @@ function missionSortTime(mission) {
 function selectDueMission(root = process.cwd(), now = new Date()) {
   const candidates = listMissions(root)
     .filter((mission) => missionSelectableForLoop(mission, now))
-    .filter((mission) => mission.verifier)
+    .filter((mission) => !missionTaskHumanAcceptWaiting(mission))
+    .filter((mission) => effectiveMissionVerifier(mission) || callerSessionMissionReadyForDue(mission))
     .filter((mission) => mission.always_on || !missionVerifierPassed(mission))
     .filter((mission) => missionDueAt(mission, now));
 
@@ -1811,82 +4345,423 @@ function selectDueMission(root = process.cwd(), now = new Date()) {
     const bCaller = runnerUsesCallerSession(b.runner) ? 1 : 0;
     if (aCaller !== bCaller) return bCaller - aCaller;
 
-    const aTime = missionSortTime(a);
-    const bTime = missionSortTime(b);
-    return bTime - aTime;
+    const aTime = missionSortTime(a);
+    const bTime = missionSortTime(b);
+    return bTime - aTime;
+  });
+  return candidates[0] || null;
+}
+
+function callerSessionMissionReadyForDue(mission) {
+  return runnerUsesCallerSession(mission?.runner)
+    && mission?.always_on === true
+    && Boolean(codexNativeGoalAck(mission))
+    && missionTaskSpine(mission)?.has_task === true;
+}
+
+function missionSelectableForCodexGoal(mission, now = new Date()) {
+  if (!missionIsRunnable(mission)) return false;
+  if (missionTaskHumanAcceptWaiting(mission)) return false;
+  if (mission.always_on && missionVerifierPassed(mission) && !missionDueAt(mission, now)) {
+    return parseCadenceSeconds(mission.cadence) > 0;
+  }
+  return true;
+}
+
+function selectCodexGoalMission(root = process.cwd(), options = {}, now = new Date()) {
+  const requestedId = String(options.missionId || '').trim();
+  const candidates = listMissions(root)
+    .filter((mission) => runnerUsesCallerSession(mission.runner))
+    .filter((mission) => missionSelectableForCodexGoal(mission, now));
+  if (requestedId) {
+    const exact = candidates.find((mission) => mission.id === requestedId || mission.id.startsWith(requestedId));
+    if (exact) {
+      const due = effectiveMissionVerifier(exact) && missionDueAt(exact, now);
+      return { mission: exact, reason: due ? 'due' : 'selected' };
+    }
+  }
+
+  candidates.sort((a, b) => {
+    const aCaller = runnerUsesCallerSession(a.runner) ? 1 : 0;
+    const bCaller = runnerUsesCallerSession(b.runner) ? 1 : 0;
+    if (aCaller !== bCaller) return bCaller - aCaller;
+
+    const aVerifier = effectiveMissionVerifier(a) ? 1 : 0;
+    const bVerifier = effectiveMissionVerifier(b) ? 1 : 0;
+    if (aVerifier !== bVerifier) return bVerifier - aVerifier;
+
+    const aTime = missionSortTime(a);
+    const bTime = missionSortTime(b);
+    return bTime - aTime;
+  });
+
+  const mission = candidates[0] || null;
+  if (!mission) return null;
+  const due = effectiveMissionVerifier(mission) && missionDueAt(mission, now);
+  return { mission, reason: due ? 'due' : 'active' };
+}
+
+function selectAtrisGoalMission(root = process.cwd(), options = {}, now = new Date()) {
+  const requestedId = String(options.missionId || '').trim();
+  const runnable = listMissions(root).filter((mission) => missionIsRunnable(mission));
+  if (requestedId) {
+    const exact = runnable.find((mission) => mission.id === requestedId || mission.id.startsWith(requestedId));
+    if (exact) return { mission: exact, reason: 'selected' };
+  }
+  runnable.sort((a, b) => {
+    const aDue = effectiveMissionVerifier(a) && missionDueAt(a, now) ? 1 : 0;
+    const bDue = effectiveMissionVerifier(b) && missionDueAt(b, now) ? 1 : 0;
+    if (aDue !== bDue) return bDue - aDue;
+
+    const aTime = missionSortTime(a);
+    const bTime = missionSortTime(b);
+    return bTime - aTime;
+  });
+  const mission = runnable[0] || null;
+  if (!mission) return null;
+  const due = effectiveMissionVerifier(mission) && missionDueAt(mission, now);
+  return { mission, reason: due ? 'due' : 'active' };
+}
+
+function codexGoalObjective(mission) {
+  return mission.objective;
+}
+
+function codexNativeGoalAck(mission, objective = codexGoalObjective(mission)) {
+  const ack = mission?.native_goal_ack || null;
+  if (!ack || String(ack.runtime || '').toLowerCase() !== 'codex') return null;
+  if (ack.status !== 'active') return null;
+  if (String(ack.objective || '') !== String(objective || '')) return null;
+  return ack;
+}
+
+function codexRuntimeGoalStateFromOptions(options = {}) {
+  const status = String(options.nativeGoalStatus || options.visibleGoalStatus || '').trim().toLowerCase();
+  const objective = String(options.nativeGoalObjective || options.visibleGoalObjective || '').trim();
+  if (!status && !objective) return null;
+  return {
+    status: status || null,
+    objective: objective || null,
+  };
+}
+
+function codexRuntimeStateBlocksMissionSlot(runtimeGoalState, mission) {
+  if (!runtimeGoalState) return true;
+  if (runtimeGoalState.status && !new Set(['active', 'paused']).has(runtimeGoalState.status)) return false;
+  if (!runtimeGoalState.objective) return new Set(['active', 'paused']).has(runtimeGoalState.status);
+  return runtimeGoalState.objective === codexGoalObjective(mission);
+}
+
+function codexGoalAckCommand(mission, objective = codexGoalObjective(mission)) {
+  return `atris mission goal ack ${mission.id} --runtime codex --status active --objective ${shellQuote(objective)} --json`;
+}
+
+function codexNativeGoalReplaceAction(newMission, activeMission, runtimeGoalState = null, commands = {}) {
+  const fromObjective = codexGoalObjective(activeMission);
+  const toObjective = codexGoalObjective(newMission);
+  return {
+    runtime: 'codex',
+    tool: 'replace_goal',
+    available: false,
+    blocked_by: 'codex_runtime_missing_replace_goal_tool',
+    args: {
+      objective: toObjective,
+      from_objective: fromObjective,
+      to_objective: toObjective,
+      from_mission_id: activeMission.id,
+      to_mission_id: newMission.id,
+      current_status: runtimeGoalState?.status || null,
+    },
+    after_success: {
+      ack_new_mission: commands.ack_new_mission || codexGoalAckCommand(newMission, toObjective),
+    },
+    fallback: {
+      reason: 'This Codex runtime exposes get_goal/create_goal/update_goal but not replace_goal or resume_goal.',
+      commands,
+    },
+  };
+}
+
+function codexNativeGoalRuntimeReplaceAction(newMission, runtimeGoalState = null, commands = {}) {
+  const toObjective = codexGoalObjective(newMission);
+  const fromObjective = runtimeGoalState?.objective || null;
+  const ackNewMission = commands.ack_new_mission || codexGoalAckCommand(newMission, toObjective);
+  const completeCurrentGoal = 'update_goal({ status: "complete" })';
+  const createNewGoal = `create_goal({ objective: ${JSON.stringify(toObjective)} })`;
+  const supersedeApproved = commands.allow_native_goal_supersede === true;
+  return {
+    runtime: 'codex',
+    tool: 'replace_goal',
+    available: false,
+    blocked_by: 'codex_runtime_missing_replace_goal_tool',
+    args: {
+      objective: toObjective,
+      from_objective: fromObjective,
+      to_objective: toObjective,
+      from_mission_id: null,
+      to_mission_id: newMission.id,
+      current_status: runtimeGoalState?.status || null,
+    },
+    after_success: {
+      ack_new_mission: ackNewMission,
+    },
+    fallback: {
+      reason: 'This Codex runtime exposes get_goal/create_goal/update_goal but not replace_goal or resume_goal.',
+      automatic: supersedeApproved,
+      approved: supersedeApproved,
+      executable_now: supersedeApproved,
+      blocked_by: supersedeApproved ? null : 'native_goal_cancel_or_supersede_tool_missing',
+      safe_when: 'Use only when a mission handoff proves the paused goal is intentionally superseded; update_goal complete otherwise misrepresents abandoned work as finished.',
+      sequence_name: 'complete_paused_goal_then_create_new_goal',
+      sequence: [
+        completeCurrentGoal,
+        createNewGoal,
+        ackNewMission,
+      ],
+      commands: {
+        ...commands,
+        complete_current_goal: completeCurrentGoal,
+        create_new_goal: createNewGoal,
+        ack_new_mission: ackNewMission,
+      },
+    },
+  };
+}
+
+function codexRuntimeGoalNeedsReplace(runtimeGoalState, objective) {
+  if (!runtimeGoalState) return false;
+  if (runtimeGoalState.status !== 'paused') return false;
+  if (!runtimeGoalState.objective) return true;
+  return runtimeGoalState.objective !== objective;
+}
+
+function writeDirectRunCodexGoalRequest(mission, root = process.cwd()) {
+  if (!isCodexGoalMission(mission)) return null;
+  const request = {
+    schema: 'atris.codex_goal_direct_run_request.v1',
+    source: 'mission_run_objective',
+    mission_id: mission.id,
+    objective: codexGoalObjective(mission),
+    mission_run_preflight: mission.mission_run_preflight || null,
+    requested_at: stampIso(),
+  };
+  const paths = statePaths(root);
+  fs.mkdirSync(path.dirname(paths.codexGoalRequestJson), { recursive: true });
+  fs.writeFileSync(paths.codexGoalRequestJson, JSON.stringify(request, null, 2) + '\n', 'utf8');
+  return request;
+}
+
+function readDirectRunCodexGoalRequest(root = process.cwd(), now = new Date()) {
+  const file = statePaths(root).codexGoalRequestJson;
+  let request = null;
+  try {
+    request = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+  const missionId = String(request?.mission_id || '').trim();
+  if (!missionId) return null;
+  const mission = resolveMission(missionId, root);
+  if (!mission || !isCodexGoalMission(mission)) return null;
+  if (!missionSelectableForCodexGoal(mission, now)) return null;
+  return { request, mission };
+}
+
+function clearDirectRunCodexGoalRequestForMission(missionId, root = process.cwd()) {
+  const file = statePaths(root).codexGoalRequestJson;
+  let request = null;
+  try {
+    request = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return false;
+  }
+  if (String(request?.mission_id || '') !== String(missionId || '')) return false;
+  try {
+    fs.rmSync(file, { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function activeCodexVisibleGoalOwner(root = process.cwd(), excludeId = '', now = new Date(), runtimeGoalState = null) {
+  const excluded = String(excludeId || '');
+  const candidates = listMissions(root)
+    .filter((mission) => mission.id !== excluded)
+    .filter((mission) => isCodexGoalMission(mission))
+    .filter((mission) => missionSelectableForCodexGoal(mission, now))
+    .filter((mission) => Boolean(codexNativeGoalAck(mission)))
+    .filter((mission) => codexRuntimeStateBlocksMissionSlot(runtimeGoalState, mission));
+  candidates.sort((a, b) => {
+    const aAck = Date.parse(a.native_goal_ack?.acknowledged_at || '') || 0;
+    const bAck = Date.parse(b.native_goal_ack?.acknowledged_at || '') || 0;
+    if (aAck !== bAck) return bAck - aAck;
+    return missionSortTime(b) - missionSortTime(a);
   });
   return candidates[0] || null;
 }
 
-function missionSelectableForCodexGoal(mission, now = new Date()) {
-  if (!missionIsRunnable(mission)) return false;
-  if (mission.always_on && missionVerifierPassed(mission) && !missionDueAt(mission, now)) {
-    return parseCadenceSeconds(mission.cadence) > 0;
-  }
-  return true;
+function codexGoalActiveConflictPayload(newMission, activeMission, request = null, heartbeatMode = false, runtimeGoalState = null) {
+  const newObjective = codexGoalObjective(newMission);
+  const pausedConflict = runtimeGoalState?.status === 'paused';
+  const holdOldMission = `atris mission pause ${activeMission.id} --reason ${shellQuote(`visible goal replaced by ${newMission.id}`)} --json`;
+  const ackNewMission = codexGoalAckCommand(newMission, newObjective);
+  const completeOldMission = `atris mission complete ${activeMission.id} --proof "<proof>" --json`;
+  const refreshAfterResume = `atris mission goal --native-goal-status active --native-goal-objective ${shellQuote(codexGoalObjective(activeMission))} --json`;
+  const nextCommand = pausedConflict
+    ? `Resume the paused Codex goal, then run ${refreshAfterResume}`
+    : `${holdOldMission} && ${ackNewMission}`;
+  const commands = {
+    hold_old_mission: holdOldMission,
+    complete_old_mission: completeOldMission,
+    refresh_after_resume: refreshAfterResume,
+    ack_new_mission: ackNewMission,
+  };
+  const nativeGoalAction = codexNativeGoalReplaceAction(newMission, activeMission, runtimeGoalState, commands);
+  const nativeGoalResolution = {
+    action: 'replace_visible_goal',
+    automatic_decision: true,
+    executable_now: false,
+    blocked_by: nativeGoalAction.blocked_by,
+    required_tool: nativeGoalAction.tool,
+    from_mission_id: activeMission.id,
+    to_mission_id: newMission.id,
+  };
+  const conflict = {
+    schema: 'atris.codex_active_goal_conflict.v1',
+    message: pausedConflict
+      ? `new mission created, but old mission ${activeMission.id} is paused and still occupies the visible slot.`
+      : `new mission created, but old mission ${activeMission.id} still owns the visible slot.`,
+    source: request?.source || 'mission_run_objective',
+    status: pausedConflict ? 'paused_goal_conflict' : 'active_goal_conflict',
+    new_mission_id: newMission.id,
+    new_objective: newObjective,
+    active_mission_id: activeMission.id,
+    active_objective: codexGoalObjective(activeMission),
+    next_command: nextCommand,
+    native_goal_action: nativeGoalAction,
+    native_goal_resolution: nativeGoalResolution,
+    commands,
+    new_mission: missionStatusView(newMission),
+    active_mission: missionStatusView(activeMission),
+    request,
+    runtime_goal_state: runtimeGoalState,
+  };
+  return {
+    ok: true,
+    action: pausedConflict ? 'paused_goal_conflict' : 'active_goal_conflict',
+    active_goal_conflict: conflict,
+    mission: conflict.new_mission,
+    conflicting_mission: conflict.active_mission,
+    goal: null,
+    heartbeat: heartbeatMode ? { heavy_work_performed: false, next_heavy_command: nextCommand } : undefined,
+    requires_native_goal_start: true,
+    requires_native_goal_replace: true,
+    native_goal_action: nativeGoalAction,
+    native_goal_resolution: nativeGoalResolution,
+    next_command: nextCommand,
+  };
 }
 
-function selectCodexGoalMission(root = process.cwd(), now = new Date()) {
-  const candidates = listMissions(root)
-    .filter((mission) => missionSelectableForCodexGoal(mission, now));
+function codexNativeGoalAction(mission, objective = codexGoalObjective(mission)) {
+  return {
+    runtime: 'codex',
+    tool: 'create_goal',
+    args: { objective },
+  };
+}
 
-  candidates.sort((a, b) => {
-    const aCaller = runnerUsesCallerSession(a.runner) ? 1 : 0;
-    const bCaller = runnerUsesCallerSession(b.runner) ? 1 : 0;
-    if (aCaller !== bCaller) return bCaller - aCaller;
+function codexNativeGoalStartInstruction(mission, objective = codexGoalObjective(mission)) {
+  return `Call native Codex create_goal({ objective: ${JSON.stringify(objective)} }), then run ${codexGoalAckCommand(mission, objective)}`;
+}
 
-    const aVerifier = a.verifier ? 1 : 0;
-    const bVerifier = b.verifier ? 1 : 0;
-    if (aVerifier !== bVerifier) return bVerifier - aVerifier;
+function codexNativeGoalReplaceInstruction(mission, runtimeGoalState = null, objective = codexGoalObjective(mission), options = {}) {
+  const fromObjective = runtimeGoalState?.objective
+    ? ` from paused objective ${JSON.stringify(runtimeGoalState.objective)}`
+    : '';
+  if (options.allowNativeGoalSupersede === true) {
+    return `Supersede approved: run update_goal({ status: "complete" }), then create_goal({ objective: ${JSON.stringify(objective)} }), then run ${codexGoalAckCommand(mission, objective)}. Atris records the old paused goal as superseded.`;
+  }
+  return `Native Codex replace_goal is required${fromObjective} to ${JSON.stringify(objective)}, then run ${codexGoalAckCommand(mission, objective)}; this runtime currently lacks replace_goal. Fallback is update_goal({ status: "complete" }) -> create_goal({ objective: ${JSON.stringify(objective)} }) -> mission goal ack only after handoff proof says the paused goal is intentionally superseded.`;
+}
 
-    const aTime = missionSortTime(a);
-    const bTime = missionSortTime(b);
-    return bTime - aTime;
-  });
+function codexNativeGoalBlockPayload(mission) {
+  const objective = codexGoalObjective(mission);
+  return {
+    ok: false,
+    code: 'native_goal_not_started',
+    mission_id: mission.id,
+    objective,
+    requires_native_goal_start: true,
+    native_goal_action: codexNativeGoalAction(mission, objective),
+    native_goal_ack_command: codexGoalAckCommand(mission, objective),
+    next_action: codexNativeGoalStartInstruction(mission, objective),
+  };
+}
 
-  const mission = candidates[0] || null;
-  if (!mission) return null;
-  const due = mission.verifier && missionDueAt(mission, now);
-  return { mission, reason: due ? 'due' : 'active' };
+function maybeBlockUntilCodexNativeGoalStarted(mission, asJson) {
+  if (!isCodexGoalMission(mission) || codexNativeGoalAck(mission)) return;
+  const payload = codexNativeGoalBlockPayload(mission);
+  if (asJson) console.log(JSON.stringify(payload, null, 2));
+  else console.error(payload.next_action);
+  process.exit(2);
 }
 
-function codexGoalObjective(mission) {
-  return mission.objective;
+function returnIfCodexNativeGoalNotStarted(mission, asJson) {
+  if (!isCodexGoalMission(mission) || codexNativeGoalAck(mission)) return false;
+  const payload = codexNativeGoalBlockPayload(mission);
+  if (asJson) console.log(JSON.stringify(payload, null, 2));
+  else console.error(payload.next_action);
+  process.exitCode = 2;
+  return true;
 }
 
 function codexGoalNextCommand(mission) {
+  if (isCodexGoalMission(mission) && !codexNativeGoalAck(mission)) {
+    return codexNativeGoalStartInstruction(mission);
+  }
   const taskSpine = missionTaskSpine(mission);
   if (taskSpine && !taskSpine.has_task && taskSpine.ensure_task_command) {
     return taskSpine.ensure_task_command;
   }
+  if (missionChoosesNextMission(mission)) {
+    return chooseNextMissionCommand(mission);
+  }
+  if (mission.status === 'ready' && mission.always_on) {
+    return nextCandidateRunCommand(mission);
+  }
   if (mission.status === 'ready') {
     const xpAction = missionXpReadyAction(mission, mission.receipt_path);
     if (xpAction) return xpAction.replace(/^queue AgentXP review: /, '');
   }
-  if (mission.verifier && missionDueAt(mission)) {
+  const verifier = effectiveMissionVerifier(mission);
+  if (verifier && missionDueAt(mission)) {
     const completeFlag = mission.always_on ? '' : ' --complete-on-pass';
     return `atris mission run --due --max-ticks 1${completeFlag}`;
   }
-  if (mission.verifier) {
+  if (verifier) {
     return `atris mission tick ${mission.id} --verify --summary "<what changed>"`;
   }
   return `atris mission tick ${mission.id} --summary "<what changed>"`;
 }
 
 function codexVisibleGoalBridge(mission, goalObjective) {
+  const ack = codexNativeGoalAck(mission, goalObjective);
   return {
     schema: 'atris.visible_chat_goal_bridge.v1',
     runtime: 'codex',
     source: 'atris_mission',
     mission_id: mission.id,
     desired_objective: goalObjective,
-    status: 'needs_runtime_write',
+    status: ack ? 'active' : 'needs_runtime_write',
+    acknowledged_at: ack?.acknowledged_at || null,
     state_file: '.atris/state/codex_goal.json',
     status_file: 'atris/status/codex-goal.md',
     operations: {
       read_current_goal: 'get_goal',
       keep_if_matching: 'if current goal objective equals goal.objective, continue the mission',
       create_when_empty_or_completed: 'create_goal({ objective: goal.objective })',
+      ack_after_create: codexGoalAckCommand(mission, goalObjective),
       complete_after_proof: 'update_goal({ status: "complete" })',
       refresh_on_phase_change: 'atris mission goal --json before continuing changed work',
       refresh_next_candidate: 'atris mission goal --json',
@@ -1894,6 +4769,7 @@ function codexVisibleGoalBridge(mission, goalObjective) {
     guardrails: [
       'Do not complete a human-set active goal unless it matches this mission goal or the mission receipt proves handoff.',
       'If create_goal fails because another goal is active, keep this bridge waiting for the visible goal slot.',
+      'Do not run mission work for runner=codex_goal until ack_after_create has been recorded.',
       'When the work changes phase or objective, refresh the mission goal before continuing.',
     ],
   };
@@ -1909,7 +4785,7 @@ function codexGoalToolContract(mission) {
     visible_goal_bridge: 'goal.visible_goal',
     platform_requirement: 'Codex runtime must expose replace_goal/set_goal, or allow update_goal({ status: "complete" }) followed by create_goal({ objective }).',
     phase_change_refresh: 'before changed follow-up work, run atris mission goal --json and mirror the returned visible goal',
-    runtime_tool_sequence: 'get_goal -> update_goal({ status: "complete" }) after proof or phase change -> atris mission goal --json -> create_goal({ objective: goal.objective })',
+    runtime_tool_sequence: 'get_goal -> create_goal({ objective }) -> atris mission goal ack <mission-id> --runtime codex --status active --objective "<objective>" --json -> do work -> update_goal({ status: "complete" }) after proof or phase change -> atris mission goal --json',
     blocked_without_platform_goal_write: true,
     mission_id: mission.id,
   };
@@ -1957,6 +4833,15 @@ function writeCodexGoalState(payload, root = process.cwd()) {
       lines.push(`- visible goal complete: ${state.goal.visible_goal.operations.complete_after_proof}`);
     }
     lines.push(`- platform write blocked: ${state.goal.codex_tool_contract.blocked_without_platform_goal_write}`);
+  } else if (state.active_goal_conflict) {
+    lines.push(`- conflict: ${state.active_goal_conflict.message}`);
+    lines.push(`- new mission: ${state.active_goal_conflict.new_mission_id}`);
+    lines.push(`- active mission: ${state.active_goal_conflict.active_mission_id}`);
+    if (state.active_goal_conflict.native_goal_action) {
+      lines.push(`- native goal action: ${state.active_goal_conflict.native_goal_action.tool}`);
+      lines.push(`- native goal executable now: ${state.active_goal_conflict.native_goal_action.available !== false}`);
+    }
+    lines.push(`- next: ${state.active_goal_conflict.next_command}`);
   } else {
     lines.push('- mission: none');
   }
@@ -1972,7 +4857,34 @@ function writeCodexGoalState(payload, root = process.cwd()) {
 
 function buildCodexGoalPayload(root = process.cwd(), options = {}) {
   const heartbeatMode = options.heartbeat === true;
-  const selected = selectCodexGoalMission(root);
+  const runtimeGoalState = codexRuntimeGoalStateFromOptions(options);
+  const directRequest = options.missionId
+    ? (() => {
+      const mission = resolveMission(options.missionId, root);
+      return mission && isCodexGoalMission(mission) && missionSelectableForCodexGoal(mission)
+        ? { mission, request: null }
+        : null;
+    })()
+    : readDirectRunCodexGoalRequest(root);
+  const activeGoalOwner = directRequest
+    ? activeCodexVisibleGoalOwner(root, directRequest.mission.id, new Date(), runtimeGoalState)
+    : null;
+  if (directRequest && activeGoalOwner) {
+    return codexGoalActiveConflictPayload(directRequest.mission, activeGoalOwner, directRequest.request, heartbeatMode, runtimeGoalState);
+  }
+  let selected = directRequest
+    ? { mission: directRequest.mission, reason: 'direct_run', direct_goal_request: directRequest.request }
+    : selectCodexGoalMission(root, options);
+  if (!selected && !directRequest) {
+    const continuation = seedNextMoveContinuationGoal(root);
+    if (continuation?.mission) {
+      selected = {
+        mission: continuation.mission,
+        reason: continuation.inserted ? 'next_move_continuation_seeded' : 'next_move_continuation_active',
+        seeded_continuation_goal: continuation,
+      };
+    }
+  }
   if (!selected) {
     const heartbeat = heartbeatMode ? codexGoalHeartbeat(null, null) : undefined;
     return {
@@ -1983,10 +4895,20 @@ function buildCodexGoalPayload(root = process.cwd(), options = {}) {
     };
   }
 
-  const { mission, reason } = selected;
+  const { mission, reason, direct_goal_request: directGoalRequest, seeded_continuation_goal: seededContinuationGoal } = selected;
   const taskSpine = missionTaskSpine(mission);
   const missionView = missionStatusView(mission);
   const objective = codexGoalObjective(mission);
+  const ack = codexNativeGoalAck(mission, objective);
+  const runtimeNeedsReplace = !ack && codexRuntimeGoalNeedsReplace(runtimeGoalState, objective);
+  const nativeGoalAction = ack
+    ? null
+    : runtimeNeedsReplace
+      ? codexNativeGoalRuntimeReplaceAction(mission, runtimeGoalState, {
+        ack_new_mission: codexGoalAckCommand(mission, objective),
+        allow_native_goal_supersede: options.allowNativeGoalSupersede === true,
+      })
+      : codexNativeGoalAction(mission, objective);
   const goal = {
     objective,
     mission_id: mission.id,
@@ -1996,10 +4918,23 @@ function buildCodexGoalPayload(root = process.cwd(), options = {}) {
     executed_by: taskSpine?.executed_by || mission.executed_by || null,
     task_spine: taskSpine,
     reason,
-    next_command: codexGoalNextCommand(mission),
+    next_command: runtimeNeedsReplace
+      ? codexNativeGoalReplaceInstruction(mission, runtimeGoalState, objective, {
+        allowNativeGoalSupersede: options.allowNativeGoalSupersede === true,
+      })
+      : codexGoalNextCommand(mission),
     replace_after: 'After proof or verifier pass, run atris mission goal --json again and replace the Codex /goal with the returned objective.',
     visible_goal: codexVisibleGoalBridge(mission, objective),
     codex_tool_contract: codexGoalToolContract(mission),
+    requires_native_goal_start: !ack,
+    requires_native_goal_replace: runtimeNeedsReplace,
+    native_goal_action: nativeGoalAction,
+    native_goal_ack_command: codexGoalAckCommand(mission, objective),
+    native_goal_ack: ack,
+    direct_goal_request: directGoalRequest || null,
+    seeded_continuation_goal: seededContinuationGoal || null,
+    next_action_preview: missionChoosesNextMission(mission) ? chooseNextMissionPreview(mission, root) : (mission.next_action_preview || null),
+    runtime_goal_state: runtimeGoalState,
   };
   const heartbeat = heartbeatMode ? codexGoalHeartbeat(goal, mission) : undefined;
   return {
@@ -2008,6 +4943,10 @@ function buildCodexGoalPayload(root = process.cwd(), options = {}) {
     goal,
     mission: missionView,
     heartbeat,
+    requires_native_goal_start: goal.requires_native_goal_start,
+    requires_native_goal_replace: goal.requires_native_goal_replace,
+    native_goal_action: goal.native_goal_action,
+    runtime_goal_state: runtimeGoalState,
   };
 }
 
@@ -2021,6 +4960,138 @@ function refreshCodexGoalController(root = process.cwd(), options = {}) {
   };
 }
 
+function atrisVisibleGoalBridge(mission, goalObjective) {
+  return {
+    schema: 'atris.visible_goal_bridge.v1',
+    runtime: String(mission.runner || 'manual'),
+    source: 'atris_mission',
+    mission_id: mission.id,
+    desired_objective: goalObjective,
+    status: 'active',
+    state_file: '.atris/state/atris_goal.json',
+    status_file: 'atris/status/atris-goal.md',
+    operations: {
+      read_current_goal: 'atris mission goal --runtime atris --json',
+      update_from_mission: 'atris mission tick <mission-id> --summary "<what changed>" --json',
+      refresh_on_phase_change: 'atris mission goal --runtime atris --json before continuing changed work',
+      complete_after_proof: 'atris mission complete <mission-id> --proof "<receipt_path>" --json',
+    },
+    guardrails: [
+      'Atris owns this goal state; no external native-goal tool ack is required.',
+      'Do not claim completion until the mission has proof or a recorded blocked human ask.',
+      'Use the mission task spine when task_spine.current_step_command is present.',
+    ],
+  };
+}
+
+function atrisGoalToolContract(mission) {
+  return {
+    current_policy: 'keep one Atris-owned visible goal active for mission/chat/fast runtimes',
+    read_current_goal: 'atris mission goal --runtime atris --json',
+    set_next_goal: 'atris mission run "<objective>" --runner atris2|manual|claude',
+    complete_current_goal: 'atris mission complete <mission-id> --proof "<receipt_path>" --json',
+    visible_goal_bridge: 'goal.visible_goal',
+    platform_requirement: 'No native platform goal tool is required; Atris mission/task state is the source of truth.',
+    runtime_tool_sequence: 'atris mission run -> atris_goal_state active -> ax fast / atris chat shows goal -> mission tick/task proof -> mission complete',
+    blocked_without_platform_goal_write: false,
+    mission_id: mission.id,
+  };
+}
+
+function buildAtrisGoalPayload(root = process.cwd(), options = {}) {
+  const heartbeatMode = options.heartbeat === true;
+  const selected = selectAtrisGoalMission(root, options);
+  if (!selected) {
+    return {
+      ok: true,
+      action: heartbeatMode ? 'atris_goal_heartbeat' : 'no_goal_candidate',
+      mission: null,
+      heartbeat: heartbeatMode ? { heavy_work_performed: false, next_heavy_command: null } : undefined,
+    };
+  }
+
+  const { mission, reason } = selected;
+  const taskSpine = missionTaskSpine(mission);
+  const missionView = missionStatusView(mission);
+  const objective = mission.objective;
+  const goal = {
+    objective,
+    mission_id: mission.id,
+    mission_objective: mission.objective,
+    mission_status: mission.status,
+    owner: taskSpine?.owner || mission.owner,
+    executed_by: taskSpine?.executed_by || mission.executed_by || null,
+    runner: mission.runner || 'manual',
+    model: mission.model || null,
+    task_spine: taskSpine,
+    reason,
+    next_command: codexGoalNextCommand(mission),
+    replace_after: 'After proof or phase change, run atris mission goal --runtime atris --json and continue from the returned next_command.',
+    visible_goal: atrisVisibleGoalBridge(mission, objective),
+    atris_tool_contract: atrisGoalToolContract(mission),
+    requires_native_goal_start: false,
+    native_goal_action: null,
+  };
+  return {
+    ok: true,
+    action: heartbeatMode ? 'atris_goal_heartbeat' : 'atris_goal_candidate',
+    goal,
+    mission: missionView,
+    heartbeat: heartbeatMode ? codexGoalHeartbeat(goal, mission) : undefined,
+    requires_native_goal_start: false,
+    native_goal_action: null,
+  };
+}
+
+function writeAtrisGoalState(payload, root = process.cwd()) {
+  const paths = statePaths(root);
+  const state = {
+    schema: 'atris.goal_controller.v1',
+    updated_at: stampIso(),
+    ...payload,
+  };
+  fs.mkdirSync(path.dirname(paths.atrisGoalJson), { recursive: true });
+  fs.writeFileSync(paths.atrisGoalJson, JSON.stringify(state, null, 2) + '\n', 'utf8');
+
+  const lines = [
+    '# Atris Goal Controller',
+    '',
+    '<!-- Generated by Atris. Do not hand-edit. -->',
+    '',
+    `- updated: ${state.updated_at}`,
+    `- action: ${state.action}`,
+  ];
+  if (state.goal) {
+    lines.push(`- mission: ${state.goal.mission_id}`);
+    lines.push(`- runner: ${state.goal.runner}`);
+    lines.push(`- status: ${state.goal.mission_status}`);
+    lines.push(`- reason: ${state.goal.reason}`);
+    lines.push(`- objective: ${state.goal.objective}`);
+    lines.push(`- next: ${state.goal.next_command}`);
+    lines.push(`- visible goal: ${state.goal.visible_goal.status}`);
+  } else {
+    lines.push('- mission: none');
+  }
+  lines.push('');
+  fs.mkdirSync(path.dirname(paths.atrisGoalStatus), { recursive: true });
+  fs.writeFileSync(paths.atrisGoalStatus, lines.join('\n'), 'utf8');
+  return {
+    state_path: paths.atrisGoalJson,
+    status_path: paths.atrisGoalStatus,
+    state,
+  };
+}
+
+function refreshAtrisGoalController(root = process.cwd(), options = {}) {
+  const payload = buildAtrisGoalPayload(root, options);
+  const rendered = writeAtrisGoalState(payload, root);
+  return {
+    ...payload,
+    state_path: rendered.state_path,
+    status_path: rendered.status_path,
+  };
+}
+
 function runAtrisMissionJsonCommand(root, args, options = {}) {
   const cliPath = path.join(__dirname, '..', 'bin', 'atris.js');
   const result = spawnSync(process.execPath, [cliPath, ...args], {
@@ -2089,6 +5160,7 @@ function goalLoopNextCommandPlan(goal) {
 
 function shouldRunGoalLoopCommand(heartbeat, plan) {
   if (!heartbeat?.goal) return false;
+  if (heartbeat.goal.requires_native_goal_start === true) return false;
   if (plan && plan.run_when_due_only === false) return true;
   return heartbeat.heartbeat?.due === true;
 }
@@ -2138,6 +5210,19 @@ function computeBackoff(policy, attempt) {
   return Math.min(policy.maxMs, Math.round(base + jitter));
 }
 
+function missionBudgetPromptLines(mission) {
+  const contract = mission?.budget_contract;
+  if (!contract) return [];
+  return [
+    ``,
+    `## Budget`,
+    `Plain rule: ${contract.plain_language}`,
+    `Limit: ${contract.budget_label}`,
+    `Stop rule: ${contract.stop_rule}`,
+    `Before acting, state the current bottleneck, the next useful move, and what proof or stop reason will make the tick honest.`,
+  ];
+}
+
 function consecutiveVerifierFails(ticks) {
   let n = 0;
   for (let i = ticks.length - 1; i >= 0; i--) {
@@ -2180,22 +5265,36 @@ function isWithinActiveHours(activeHours, now = new Date()) {
   return cur >= start || cur < end;
 }
 
-function acquireMissionLock(missionId, root = process.cwd()) {
+function sleepSync(ms) {
+  const waitMs = Math.max(0, Number(ms) || 0);
+  if (!waitMs) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, waitMs);
+}
+
+function acquireMissionLock(missionId, root = process.cwd(), options = {}) {
   const dir = path.join(root, '.atris', 'state');
   fs.mkdirSync(dir, { recursive: true });
   const lockFile = path.join(dir, `mission-${missionId}.lock`);
+  const waitMs = Math.max(0, Number(options.waitMs) || 0);
+  const deadline = waitMs ? Date.now() + waitMs : 0;
   let fd;
-  try {
-    fd = fs.openSync(lockFile, 'wx');
-    fs.writeSync(fd, JSON.stringify({ pid: process.pid, started_at: stampIso(), mission_id: missionId }));
-    return { ok: true, lockFile, fd };
-  } catch (e) {
-    if (e.code === 'EEXIST') {
-      let info = {};
-      try { info = JSON.parse(fs.readFileSync(lockFile, 'utf8') || '{}'); } catch {}
-      return { ok: false, lockFile, busy: true, holder: info };
+  while (true) {
+    try {
+      fd = fs.openSync(lockFile, 'wx');
+      fs.writeSync(fd, JSON.stringify({ pid: process.pid, started_at: stampIso(), mission_id: missionId }));
+      return { ok: true, lockFile, fd };
+    } catch (e) {
+      if (e.code === 'EEXIST') {
+        let info = {};
+        try { info = JSON.parse(fs.readFileSync(lockFile, 'utf8') || '{}'); } catch {}
+        if (deadline && Date.now() < deadline) {
+          sleepSync(Math.min(25, deadline - Date.now()));
+          continue;
+        }
+        return { ok: false, lockFile, busy: true, holder: info };
+      }
+      return { ok: false, lockFile, error: e.message };
     }
-    return { ok: false, lockFile, error: e.message };
   }
 }
 
@@ -2228,6 +5327,7 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen) {
     `**Verifier (frozen):** ${frozen.verifier || '(none — receipt only)'}`,
     `**Last status:** ${mission.status}`,
     `**Last tick:** ${mission.last_tick_at || 'never'}`,
+    ...missionBudgetPromptLines(mission),
     ``,
     `## Your task`,
     `Do ONE increment of work toward the stop condition. ONE. No more.`,
@@ -2434,9 +5534,11 @@ async function runMission(args) {
   const verifyEach = !hasFlag(args, '--no-verify');
   const completeOnPass = hasFlag(args, '--complete-on-pass');
   const skipDrain = hasFlag(args, '--no-drain');
+  const createNext = hasFlag(args, '--create-next');
   const maxTicksFlag = readFlag(args, '--max-ticks', '');
   const maxTicks = Math.max(1, Number(maxTicksFlag) || MISSION_RUN_DEFAULTS.maxTicks);
-  const maxWallSeconds = Math.max(60, Number(readFlag(args, '--max-wall', '')) || MISSION_RUN_DEFAULTS.maxWallSeconds);
+  const maxWallFlag = readFlag(args, '--max-wall', '');
+  let maxWallSeconds = Math.max(60, Number(maxWallFlag) || MISSION_RUN_DEFAULTS.maxWallSeconds);
   const cadenceOverride = readFlag(args, '--cadence', '');
   const input = missionRunInputFromArgs(args);
   const ref = input.ref;
@@ -2467,6 +5569,9 @@ async function runMission(args) {
   if (!mission) {
     exitMissionError(ref ? `Mission "${ref}" not found.` : 'Usage: atris mission run <id|objective> [--max-ticks 4] [--max-wall 3600]', 1, asJson);
   }
+  if (!maxWallFlag && Number(mission.budget_contract?.requested_seconds) > 0) {
+    maxWallSeconds = Math.max(60, Number(mission.budget_contract.requested_seconds));
+  }
   if (['complete', 'stopped'].includes(mission.status)) {
     if (asJson) {
       printJsonOrText(
@@ -2480,6 +5585,8 @@ async function runMission(args) {
     process.exit(0);
   }
 
+  maybeBlockUntilCodexNativeGoalStarted(mission, asJson);
+
   const preLockRunner = String(mission.runner || '').trim().toLowerCase();
   const preLockCallerSession = runnerUsesCallerSession(mission.runner);
   if (!skipClaude && !preLockCallerSession && preLockRunner !== 'atris2') {
@@ -2520,10 +5627,12 @@ async function runMission(args) {
       console.error(`Mission ${mission.id} is ${mission.status}; nothing to run.`);
       return;
     }
+    if (returnIfCodexNativeGoalNotStarted(mission, asJson)) return;
     if (mission.status === 'paused') {
       mission = saveMission({
         ...mission,
         status: 'running',
+        paused_at: null,
         resumed_at: stampIso(),
         stop_reason: null,
         next_action: `running: atris mission run ${mission.id}`,
@@ -2537,7 +5646,7 @@ async function runMission(args) {
 
     // Freeze run-start contract (verifier, lane). Stored on receipts, not the mission record.
     const frozen = {
-      verifier: mission.verifier || '',
+      verifier: effectiveMissionVerifier(mission),
       lane: mission.lane || 'workspace',
       started_at: stampIso(),
     };
@@ -2565,7 +5674,9 @@ async function runMission(args) {
       : atris2Runner
         ? `atris2 (${mission.model || 'atris:fast'})`
         : (sessionId || `pending=${pendingSessionId}`);
-    console.error(`[mission run] ${mission.id}\n  objective: ${mission.objective}\n  lane: ${frozen.lane}\n  cadence: ${cadence} (${cadenceSeconds}s)\n  max_ticks: ${effectiveMaxTicks}, max_wall: ${maxWallSeconds}s\n  session: ${sessionLabel}`);
+    if (!asJson) {
+      console.error(`[mission run] ${mission.id}\n  objective: ${mission.objective}\n  lane: ${frozen.lane}\n  cadence: ${cadence} (${cadenceSeconds}s)\n  max_ticks: ${effectiveMaxTicks}, max_wall: ${maxWallSeconds}s\n  session: ${sessionLabel}`);
+    }
 
     while (ticks.length < effectiveMaxTicks) {
       const elapsedSec = (Date.now() - startedAt) / 1000;
@@ -2576,7 +5687,7 @@ async function runMission(args) {
       // Re-read mission, detect mutation of frozen fields
       mission = resolveMission(mission.id) || mission;
       if (['complete', 'stopped', 'paused'].includes(mission.status)) { pauseReason = mission.status; break; }
-      if (mission.verifier !== frozen.verifier) { pauseReason = 'verifier-mutated'; break; }
+      if (effectiveMissionVerifier(mission) !== frozen.verifier) { pauseReason = 'verifier-mutated'; break; }
       if ((mission.lane || 'workspace') !== frozen.lane) { pauseReason = 'lane-mutated'; break; }
 
       const tickIdx = Number(mission.last_tick_index || 0) + 1;
@@ -2729,9 +5840,12 @@ async function runMission(args) {
       });
 
       const xpReadyAction = missionXpReadyAction(mission, receiptPath);
+      const budgetRemainingSeconds = missionFullBudgetRemainingSeconds(mission);
+      const fullBudgetMode = budgetRemainingSeconds > 0;
       const newStatus = (verifierResult?.passed && mission.always_on) ? 'ready' :
                         (verifierResult?.passed && xpReadyAction) ? 'ready' :
-                        (verifierResult?.passed && completeOnPass) ? 'complete' :
+                        (verifierResult?.passed && completeOnPass && !fullBudgetMode) ? 'complete' :
+                        (verifierResult?.passed && fullBudgetMode) ? 'running' :
                         (verifierResult?.passed ? 'ready' :
                         (verifierResult ? 'blocked' :
                         (result.status === 'ran' ? 'running' : mission.status)));
@@ -2740,16 +5854,22 @@ async function runMission(args) {
         nextAction = nextCandidateTickAction(mission);
       } else if (verifierResult?.passed && xpReadyAction) {
         nextAction = xpReadyAction;
-      } else if (verifierResult?.passed && completeOnPass) {
+      } else if (verifierResult?.passed && completeOnPass && !fullBudgetMode) {
         nextAction = 'mission complete';
+      } else if (verifierResult?.passed && fullBudgetMode) {
+        nextAction = `proof passed with ${durationLabel(budgetRemainingSeconds)} left on the budget; pick the next useful move, then: atris mission tick ${mission.id} --verify --summary "<what changed>"`;
       } else if (verifierResult?.passed) {
         nextAction = `review proof then run: atris mission complete ${mission.id} --proof "${receiptPath}"`;
       } else if (verifierResult) {
         nextAction = 'fix verifier failure or revise mission';
+      } else if (result.status === 'ran' && mission.always_on) {
+        nextAction = nextCandidateTickAction(mission);
       }
       mission = saveMission({
         ...mission,
         status: newStatus,
+        paused_at: null,
+        stop_reason: null,
         last_tick_at: finishedAt,
         last_tick_status: result.status,
         last_tick_reason: result.reason,
@@ -2777,7 +5897,9 @@ async function runMission(args) {
       }
       refreshCodexGoalController(cwd);
 
-      console.error(`[tick ${tickIdx}] status=${result.status} reason=${result.reason} verifier=${verifierResult ? (verifierResult.passed ? 'pass' : 'fail') : 'skip'} -> ${receiptPath || '-'}`);
+      if (!asJson) {
+        console.error(`[tick ${tickIdx}] status=${result.status} reason=${result.reason} verifier=${verifierResult ? (verifierResult.passed ? 'pass' : 'fail') : 'skip'} -> ${receiptPath || '-'}`);
+      }
 
       if (result.status === 'ran') {
         ranTicks++;
@@ -2786,7 +5908,8 @@ async function runMission(args) {
         backoffAttempt++;
       }
 
-      if (newStatus === 'complete' || (newStatus === 'ready' && !mission.always_on)) break;
+      if (callerSessionRunner && result.status === 'ran') break;
+      if (newStatus === 'complete' || (newStatus === 'ready' && !mission.always_on && !fullBudgetMode)) break;
       if (consecutiveVerifierFails(ticks) >= 2) { pauseReason = 'consecutive-verifier-fails'; break; }
       // A retired/inaccessible model is deterministic: the id is fixed for the run, so
       // every remaining tick (and every future cron firing) fails identically. Backoff
@@ -2837,6 +5960,17 @@ async function runMission(args) {
     }
 
     const summaryWorktree = worktreeReceipt(runWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: frozen.verifier, baseline: runWorktreeBaseline });
+    const createdNext = createNext
+      ? require('./loop-front').createNextLoopTask(['--as', mission.owner || 'auto-improver', '--json'], cwd, { print: false })
+      : null;
+    const landingSummary = {
+      changed: missionRunChangedText(mission, ranTicks, effectiveMaxTicks, ticks, createdNext),
+      timeline_command: missionRunTimelineCommand(mission),
+      export_command: missionRunExportCommand(mission),
+      prune_preview_command: missionRunPrunePreviewCommand(mission),
+      next: missionRunCreatedNextLine(createdNext, continuationGoal, mission),
+    };
+    landingSummary.reason = missionHumanReasonText(mission, landingSummary.changed);
     const finalReceipt = writeReceipt(mission, {
       kind: 'mission_run_summary',
       frozen,
@@ -2847,22 +5981,17 @@ async function runMission(args) {
       session_id: sessionId,
       pending_session_id: mission.pending_session_id || null,
       elapsed_seconds: (Date.now() - startedAt) / 1000,
+      budget_contract: mission.budget_contract || null,
       worktree: summaryWorktree,
+      created_next: createdNext,
+      landing: landingSummary,
     });
+    const atrisGoalState = refreshAtrisGoalController(cwd, { missionId: mission.id });
     const codexGoalState = refreshCodexGoalController(cwd);
 
     printJsonOrText(
-      { ok: true, action: 'mission_run', mission, ran_ticks: ranTicks, tick_count: ticks.length, ticks, pause_reason: pauseReason, session_id: sessionId, summary_receipt: finalReceipt, worktree: summaryWorktree, codex_goal_state: codexGoalState, continuation_goal: continuationGoal },
-      [
-        `Ran mission ${mission.id}`,
-        `  objective: ${mission.objective}`,
-        `  ran_ticks: ${ranTicks}/${effectiveMaxTicks}  (skipped/errored: ${ticks.length - ranTicks})`,
-        `  final state: ${mission.status}`,
-        pauseReason ? `  pause: ${pauseReason}` : null,
-        `  session: ${sessionId || '(none)'}`,
-        `  summary receipt: ${finalReceipt}`,
-        continuationGoal?.mission ? `  next goal: ${continuationGoal.mission.objective}` : null,
-      ].filter(Boolean),
+      { ok: true, action: 'mission_run', mission, ran_ticks: ranTicks, tick_count: ticks.length, ticks, pause_reason: pauseReason, session_id: sessionId, summary_receipt: finalReceipt, budget_contract: mission.budget_contract || null, worktree: summaryWorktree, atris_goal_state: atrisGoalState, codex_goal_state: codexGoalState, continuation_goal: continuationGoal, created_next: createdNext },
+      missionRunSummaryLines(mission, ranTicks, effectiveMaxTicks, finalReceipt, pauseReason, continuationGoal, ticks, createdNext),
       asJson,
     );
   } finally {
@@ -2877,9 +6006,10 @@ async function runMission(args) {
 function tickMission(args) {
   const asJson = wantsJson(args);
   const verify = hasFlag(args, '--verify');
+  const verifyOverride = readFlag(args, '--verify', '');
   const completeOnPass = hasFlag(args, '--complete-on-pass');
   const summary = readFlag(args, '--summary', '');
-  const ref = stripKnownFlags(args, ['--summary'], ['--json', '--verify', '--complete-on-pass'])[0] || '';
+  const ref = stripKnownFlags(args, ['--summary', '--verify'], ['--json', '--complete-on-pass'])[0] || '';
   let mission = resolveMission(ref);
   if (!mission) {
     exitMissionError(ref ? `Mission "${ref}" not found.` : 'No mission found. Run: atris mission start "..."', 1, asJson);
@@ -2902,6 +6032,7 @@ function tickMission(args) {
       printJsonOrText({ ok: true, action: 'tick_skipped', mission: saved }, [`Skipped ${mission.id}: ${mission.status}`], asJson);
       return;
     }
+    if (returnIfCodexNativeGoalNotStarted(mission, asJson)) return;
 
     // Per the /mission skill design, the calling Claude session IS the per-tick LLM.
     // This CLI subcommand records the tick: writes a structured receipt (matching the
@@ -2914,11 +6045,17 @@ function tickMission(args) {
     const tickWorktreeBefore = gitWorktreeSnapshot(cwd);
     const worktreeBaseline = loadMissionWorktreeBaseline(mission.id, cwd);
 
+    const effectiveVerifier = effectiveMissionVerifier(mission);
+    const verifierCommand = verify
+      ? String(verifyOverride || effectiveVerifier || '').trim()
+      : '';
+    if (verifierCommand) assertMissionVerifier(verifierCommand, asJson);
+
     let verifierResult = null;
-    if (verify && mission.verifier) {
-      verifierResult = runVerifier(mission.verifier);
+    if (verify && verifierCommand) {
+      verifierResult = runVerifier(verifierCommand);
     }
-    const tickWorktree = worktreeReceipt(tickWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: mission.verifier, baseline: worktreeBaseline });
+    const tickWorktree = worktreeReceipt(tickWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: verifierCommand || effectiveVerifier, baseline: worktreeBaseline });
 
     // Same layer classification as the run-tick path; manual ticks carry their
     // receipt text in --summary.
@@ -2941,7 +6078,7 @@ function tickMission(args) {
       kind: 'mission_tick',
       tick: tickRecord,
       frozen: {
-        verifier: mission.verifier || '',
+        verifier: verifierCommand || effectiveVerifier || '',
         lane: mission.lane || 'workspace',
         started_at: tickStart,
       },
@@ -2950,21 +6087,40 @@ function tickMission(args) {
       worktree: tickWorktree,
     });
 
-    let status = 'running';
-    let nextAction = mission.verifier ? `run verifier: ${mission.verifier}` : 'attach task, verifier, or proof';
-    if (verifierResult?.passed) {
+	    let status = 'running';
+	    let nextAction = (verifierCommand || effectiveVerifier)
+	      ? `run verifier: ${verifierCommand || effectiveVerifier}`
+	      : (mission.always_on && missionTaskSpine(mission)?.has_task
+	        ? nextCandidateTickAction(mission)
+	        : 'attach task, verifier, or proof');
+	    const nextGoalChain = advanceMissionGoalChain(mission.goal_chain, summary, verifierResult);
+	    if (verifierResult?.passed && nextGoalChain && !nextGoalChain.pause_ready) {
+	      status = 'running';
+	      nextAction = missionGoalChainNextAction(nextGoalChain);
+    } else if (verifierResult?.passed) {
       const xpReadyAction = missionXpReadyAction(mission, receiptPath);
-      status = (completeOnPass && !mission.always_on && !xpReadyAction) ? 'complete' : 'ready';
+      const budgetRemainingSeconds = missionFullBudgetRemainingSeconds(mission);
+      const budgetOpen = budgetRemainingSeconds > 0;
+      status = (completeOnPass && !mission.always_on && !xpReadyAction && !budgetOpen) ? 'complete'
+        : (budgetOpen && !mission.always_on && !xpReadyAction ? 'running' : 'ready');
       nextAction = mission.always_on ? nextCandidateTickAction(mission) :
-        (xpReadyAction || (completeOnPass ? 'mission complete' : `review proof then run: atris mission complete ${mission.id} --proof "${receiptPath}"`));
-    } else if (verifierResult) {
-      status = 'blocked';
-      nextAction = 'fix verifier failure or revise mission';
-    }
-    const clearsPauseState = !['paused', 'stopped'].includes(status);
-    const nextMission = {
-      ...mission,
-      status,
+        (xpReadyAction
+          || (budgetOpen
+            ? `proof passed with ${durationLabel(budgetRemainingSeconds)} left on the budget; pick the next useful move, then: atris mission tick ${mission.id} --verify --summary "<what changed>"`
+            : (completeOnPass ? 'mission complete' : `review proof then run: atris mission complete ${mission.id} --proof "${receiptPath}"`)));
+	    } else if (verifierResult) {
+	      status = 'blocked';
+	      nextAction = 'fix verifier failure or revise mission';
+	    } else if (nextGoalChain?.pause_ready) {
+	      status = 'ready';
+	      nextAction = `mission feels good; review proof then run: atris mission complete ${mission.id} --proof "${receiptPath}"`;
+	    } else if (nextGoalChain) {
+	      nextAction = missionGoalChainNextAction(nextGoalChain);
+	    }
+	    const clearsPauseState = !['paused', 'stopped'].includes(status);
+	    const nextMission = {
+	      ...mission,
+	      status,
       paused_at: clearsPauseState ? null : mission.paused_at || null,
       stop_reason: clearsPauseState ? null : mission.stop_reason || null,
       resumed_at: clearsPauseState && mission.status === 'paused' ? tickRecord.finished_at : mission.resumed_at || null,
@@ -2973,11 +6129,12 @@ function tickMission(args) {
       last_tick_status: tickRecord.status,
       last_tick_reason: tickRecord.reason,
       last_tick_index: tickIdx,
-      last_tick_layer: tickRecord.layer,
-      last_tick_layer_source: tickRecord.layer_source,
-      verifier_result: verifierResult || mission.verifier_result || null,
-      next_action: nextAction,
-    };
+	      last_tick_layer: tickRecord.layer,
+	      last_tick_layer_source: tickRecord.layer_source,
+	      verifier_result: verifierResult || mission.verifier_result || null,
+	      ...(nextGoalChain ? { goal_chain: nextGoalChain } : {}),
+	      next_action: nextAction,
+	    };
     const { mission: saved } = saveMission(nextMission, cwd, 'mission_tick', {
       tick_index: tickIdx, verify, verifier_result: verifierResult, receipt_path: receiptPath, layer: tickRecord.layer,
     });
@@ -2994,15 +6151,12 @@ function tickMission(args) {
       ? seedMissionRunContinuation(saved, cwd, receiptPath)
       : null;
     const outputMission = continuationGoal?.parent || saved;
+    const atrisGoalState = refreshAtrisGoalController(process.cwd(), { missionId: outputMission.id });
     const codexGoalState = refreshCodexGoalController(process.cwd());
     printJsonOrText(
-      { ok: true, action: 'mission_tick', mission: outputMission, tick: tickRecord, verifier_result: verifierResult, receipt_path: receiptPath, log_path: logPath, codex_goal_state: codexGoalState, continuation_goal: continuationGoal },
+      { ok: true, action: 'mission_tick', mission: outputMission, tick: tickRecord, verifier_result: verifierResult, receipt_path: receiptPath, log_path: logPath, atris_goal_state: atrisGoalState, codex_goal_state: codexGoalState, continuation_goal: continuationGoal },
       [
-        `Ticked mission: ${outputMission.objective}`,
-        `State: ${outputMission.status}`,
-        `Tick: ${tickIdx}`,
-        `Next: ${outputMission.next_action}`,
-        ...(receiptPath ? [`Receipt: ${receiptPath}`] : []),
+        ...missionTickResultLines(outputMission, tickIdx, receiptPath, verifierResult, summary),
         ...(continuationGoal?.mission ? [`Next goal: ${continuationGoal.mission.objective}`] : []),
       ],
       asJson,
@@ -3036,7 +6190,14 @@ function receiptShowsPass(receipt) {
 // verifier passed. Mirrors the task plane's proof-only accept guard so the
 // final transition consumes the receipts instead of trusting free text.
 function missionCompletionGate(mission, proof, root = process.cwd()) {
-  if (!String(mission.verifier || '').trim()) return { ok: true, source: 'no_verifier' };
+  const remainingSeconds = missionFullBudgetRemainingSeconds(mission);
+  if (remainingSeconds > 0) {
+    return {
+      ok: false,
+      source: 'budget_contract',
+      reason: `full-budget mission still has ${durationLabel(remainingSeconds)} left; keep picking the next useful move or use --force if blocked/unsafe`,
+    };
+  }
   const receipt = readReceiptProof(proof, root);
   if (receipt) {
     if (receipt.mission_id !== mission.id) {
@@ -3047,6 +6208,7 @@ function missionCompletionGate(mission, proof, root = process.cwd()) {
       : { ok: false, source: 'receipt', reason: 'proof receipt does not show a passing verifier' };
   }
   if (mission.verifier_result?.passed === true) return { ok: true, source: 'mission_state' };
+  if (!effectiveMissionVerifier(mission)) return { ok: true, source: 'no_verifier' };
   return { ok: false, source: 'mission_state', reason: 'verifier has not passed for this mission and proof is not a passing receipt' };
 }
 
@@ -3055,6 +6217,7 @@ function completeMission(args) {
   const force = hasFlag(args, '--force');
   const proof = readFlag(args, '--proof', '');
   const ref = stripKnownFlags(args, ['--proof'], ['--json', '--force'])[0] || '';
+  const root = process.cwd();
   if (!ref || !proof) {
     exitMissionError('Usage: atris mission complete <id> --proof "..."', 1, asJson);
   }
@@ -3062,11 +6225,11 @@ function completeMission(args) {
   if (!mission) {
     exitMissionError(`Mission "${ref}" not found.`, 1, asJson);
   }
-  const gate = missionCompletionGate(mission, proof, process.cwd());
+  const gate = missionCompletionGate(mission, proof, root);
   if (!gate.ok && !force) {
     exitMissionError(`[mission complete] ${gate.reason}. Run: atris mission tick ${mission.id} --verify (or override as operator with --force)`, 2, asJson);
   }
-  const baselineSummary = pruneMissionWorktreeBaseline(mission, process.cwd());
+  const baselineSummary = pruneMissionWorktreeBaseline(mission, root);
   const completionGate = { ...gate, forced: force && !gate.ok };
   const baseNext = {
     ...mission,
@@ -3079,16 +6242,31 @@ function completeMission(args) {
   };
   const xpNextCommand = missionXpReadyAction(baseNext, proof);
   const completion = missionCompletionReceipt(baseNext, proof, xpNextCommand);
+  const artifactPreview = missionArtifactPaths(baseNext, root);
+  completion.landing.artifact = `Open timeline at ${artifactPreview.relativeIndexHtml}.`;
+  completion.result.artifact = artifactPreview.relativeIndexHtml;
   const next = {
     ...baseNext,
     landing: completion.landing,
     result: completion.result,
   };
-  const { mission: saved } = saveMission(next, process.cwd(), 'mission_completed', { proof, completion_gate: next.completion_gate });
-  const continuationGoal = seedMissionRunContinuation(saved, process.cwd(), proof);
+  const { mission: saved } = saveMission(next, root, 'mission_completed', { proof, completion_gate: next.completion_gate });
+  const continuationGoal = seedMissionRunContinuation(saved, root, proof);
   const outputMission = continuationGoal?.parent || saved;
-  const logPath = appendMemberLog(outputMission.owner, 'Mission completed', { mission: outputMission.objective, proof });
-  const codexGoalState = refreshCodexGoalController(process.cwd());
+  const artifact = writeMissionArtifact(outputMission, {
+    root,
+    proof,
+    completion,
+    xpNextCommand,
+    continuationGoal,
+  });
+  const logPath = appendMemberLog(outputMission.owner, 'Mission completed', {
+    mission: outputMission.objective,
+    proof,
+    artifact: artifact.index_html,
+  }, root);
+  const atrisGoalState = refreshAtrisGoalController(root, { missionId: continuationGoal?.mission?.id || outputMission.id });
+  const codexGoalState = refreshCodexGoalController(root);
   printJsonOrText(
     {
       ok: true,
@@ -3096,16 +6274,15 @@ function completeMission(args) {
       mission: outputMission,
       landing: completion.landing,
       result: completion.result,
+      artifact,
       log_path: logPath,
+      atris_goal_state: atrisGoalState,
       codex_goal_state: codexGoalState,
       xp_next_command: xpNextCommand,
       continuation_goal: continuationGoal,
     },
     [
-      `Completed mission: ${outputMission.objective}`,
       ...missionResultLines(completion),
-      `Proof: ${proof}`,
-      ...(xpNextCommand ? [`AgentXP: ${xpNextCommand}`] : []),
       ...(continuationGoal?.mission ? [`Next goal: ${continuationGoal.mission.objective}`] : []),
     ],
     asJson,
@@ -3148,9 +6325,10 @@ function stopMission(args) {
     next_action: status === 'paused' ? `resume with: atris mission tick ${mission.id}` : 'mission stopped',
   };
   const { mission: saved } = saveMission(next, process.cwd(), pause ? 'mission_paused' : 'mission_stopped', { reason, receipt_path: receiptPath });
+  const directGoalRequestCleared = pause ? false : clearDirectRunCodexGoalRequestForMission(saved.id, process.cwd());
   const logPath = appendMemberLog(saved.owner, pause ? 'Mission paused' : 'Mission stopped', { mission: saved.objective, reason });
   printJsonOrText(
-    { ok: true, action: pause ? 'mission_paused' : 'mission_stopped', mission: saved, receipt_path: receiptPath, log_path: logPath },
+    { ok: true, action: pause ? 'mission_paused' : 'mission_stopped', mission: saved, receipt_path: receiptPath, log_path: logPath, direct_goal_request_cleared: directGoalRequestCleared },
     [
       `${pause ? 'Paused' : 'Stopped'} mission: ${saved.objective}`,
       `Reason: ${reason}`,
@@ -3162,8 +6340,50 @@ function stopMission(args) {
 
 function goalMission(args) {
   const asJson = wantsJson(args);
+  if (args[0] === 'ack') {
+    return ackMissionGoal(args.slice(1));
+  }
+  const runtime = String(readFlag(args, '--runtime', 'codex') || 'codex').trim().toLowerCase();
+  if (runtime === 'atris' || runtime === 'atris2' || runtime === 'ax') {
+    const heartbeatMode = hasFlag(args, '--heartbeat');
+    const payload = refreshAtrisGoalController(process.cwd(), { heartbeat: heartbeatMode });
+    if (!payload.goal) {
+      printJsonOrText(payload, ['No active mission found for Atris goal.'], asJson);
+      return;
+    }
+    printJsonOrText(
+      payload,
+      [
+        `Atris goal: ${payload.goal.objective}`,
+        `Runner: ${payload.goal.runner}`,
+        `Next: ${payload.goal.next_command}`,
+        payload.goal.replace_after,
+      ],
+      asJson,
+    );
+    return;
+  }
   const heartbeatMode = hasFlag(args, '--heartbeat');
-  const payload = refreshCodexGoalController(process.cwd(), { heartbeat: heartbeatMode });
+  const nativeGoalStatus = readFlag(args, '--native-goal-status', readFlag(args, '--visible-goal-status', ''));
+  const nativeGoalObjective = readFlag(args, '--native-goal-objective', readFlag(args, '--visible-goal-objective', ''));
+  const allowNativeGoalSupersede = hasFlag(args, '--allow-native-goal-supersede') || hasFlag(args, '--supersede-paused-native-goal');
+  const payload = refreshCodexGoalController(process.cwd(), {
+    heartbeat: heartbeatMode,
+    ...(nativeGoalStatus ? { nativeGoalStatus } : {}),
+    ...(nativeGoalObjective ? { nativeGoalObjective } : {}),
+    ...(allowNativeGoalSupersede ? { allowNativeGoalSupersede: true } : {}),
+  });
+  if (payload.active_goal_conflict) {
+    printJsonOrText(
+      payload,
+      [
+        payload.active_goal_conflict.message,
+        `Next: ${payload.active_goal_conflict.next_command}`,
+      ],
+      asJson,
+    );
+    return;
+  }
   if (!payload.goal) {
     printJsonOrText(
       payload,
@@ -3185,6 +6405,72 @@ function goalMission(args) {
   );
 }
 
+function ackMissionGoal(args) {
+  const asJson = wantsJson(args);
+  const ref = stripKnownFlags(args, ['--runtime', '--status', '--objective'], ['--json'])[0] || '';
+  if (!ref) {
+    exitMissionError('Usage: atris mission goal ack <mission-id> --runtime codex --status active --objective "<objective>" --json', 1, asJson);
+  }
+  const runtime = String(readFlag(args, '--runtime', 'codex') || 'codex').trim().toLowerCase();
+  const status = String(readFlag(args, '--status', 'active') || 'active').trim().toLowerCase();
+  let mission = resolveMission(ref);
+  if (!mission) {
+    exitMissionError(`Mission "${ref}" not found.`, 1, asJson);
+  }
+  if (runtime !== 'codex' || status !== 'active') {
+    exitMissionError('Native goal ack requires --runtime codex --status active.', 2, asJson);
+  }
+
+  const lock = acquireMissionLock(mission.id, process.cwd(), { waitMs: 2000 });
+  if (!lock.ok) {
+    exitMissionError(`[mission goal ack] lock busy (held by pid ${lock.holder?.pid || '?'} since ${lock.holder?.started_at || '?'}). Exit.`, 3, asJson);
+  }
+
+  try {
+    mission = resolveMission(mission.id) || mission;
+    if (!isCodexGoalMission(mission)) {
+      releaseMissionLock(lock);
+      exitMissionError(`Mission "${ref}" uses runner=${mission.runner || 'manual'}; native Codex goal ack is only for runner=codex_goal.`, 2, asJson);
+    }
+    const expectedObjective = codexGoalObjective(mission);
+    const objective = readFlag(args, '--objective', expectedObjective);
+    if (objective !== expectedObjective) {
+      releaseMissionLock(lock);
+      exitMissionError(`Native goal objective mismatch. Expected: ${expectedObjective}`, 2, asJson);
+    }
+    const ack = {
+      runtime: 'codex',
+      status: 'active',
+      objective,
+      acknowledged_at: stampIso(),
+    };
+    const nextMission = {
+      ...mission,
+      native_goal_ack: ack,
+      next_action: codexGoalNextCommand({ ...mission, native_goal_ack: ack }),
+    };
+    const { mission: saved } = saveMission(nextMission, process.cwd(), 'mission_native_goal_ack', { ack });
+    const payload = refreshCodexGoalController(process.cwd());
+    printJsonOrText(
+      {
+        ok: true,
+        action: 'native_goal_acknowledged',
+        mission: saved,
+        native_goal_ack: ack,
+        codex_goal_state: payload,
+        next_command: payload.goal?.next_command || `atris mission tick ${saved.id} --summary "<what changed>"`,
+      },
+      [
+        `Native goal active: ${saved.objective}`,
+        `Next: ${payload.goal?.next_command || saved.next_action}`,
+      ],
+      asJson,
+    );
+  } finally {
+    releaseMissionLock(lock);
+  }
+}
+
 async function goalLoopMission(args) {
   const asJson = wantsJson(args);
   const noClaude = hasFlag(args, '--no-claude');
@@ -3276,18 +6562,29 @@ atris mission - durable goal + loop + owner + proof state
                        default model atris:fast; runner codex_goal publishes the goal for a live
                        Codex session to pull via atris mission goal)
   atris mission status [id] [--status <state>] [--limit <n>] [--local] [--json]
+  atris mission doctor [--local] [--json]   Flag no-verifier missions, help missions, stale ready receipts, and blocked always-on loops
   atris mission attach-task <id> [--json]   Create the missing task spine for an existing active mission
   atris mission report [id] [--limit <n>] [--local] [--json]   Plain outcome, worker receipt, verifier receipt, and next move
+  atris mission timeline [id] [--limit <n>] [--all] [--prune-preview] [--write] [--json]   Saved landing Changed/Next lines from mission receipts
   atris mission watch [id] [--interval <s>] [--idle-every <s>]   Live heartbeat: prints a line per tick as it lands
   atris mission layers [--mission <id-substr>] [--since <date>] [--json]   Per-layer growth curve across tick receipts
                        (rolls up sibling git-worktree missions; --local scopes to this checkout)
-  atris mission goal [--heartbeat] [--json]
+  atris mission room "<messy input>" [--owner <member>] [--room-auto-run] [--json]   Create a Mission Room card and shareable receipt from messy intent
+  atris mission prune-runs [--apply] [--days <n>] [--keep-newest <n>] [--json]   Compress old run receipts into a manifest and prune unreferenced clutter
+  atris mission goal [--runtime codex|atris] [--heartbeat] [--native-goal-status active|paused] [--native-goal-objective "..."] [--allow-native-goal-supersede] [--json]
+  atris mission goal ack <id> --runtime codex --status active --objective "<objective>" --json
   atris mission goal-loop [--max-wall 28800] [--max-iterations 32] [--no-claude] [--json]
-  atris mission tick <id> [--verify] [--complete-on-pass] [--summary "..."] [--json]
+  atris mission tick <id> [--verify ["cmd"]] [--complete-on-pass] [--summary "..."] [--json]
   atris mission "<objective>" [--owner <member>]   Shortcut for: atris mission run "<objective>"
   atris mission run ["objective"|<member> ["objective"]|id|--due] [--owner <member>] [--max-ticks 4] [--max-wall 3600] [--cadence "15m"]
-                                [--no-claude] [--no-verify] [--complete-on-pass] [--no-drain] [--json]
+                                [--native-goal-status active|paused] [--native-goal-objective "..."] [--allow-native-goal-supersede]
+                                [--spend-full-budget|--use-whole-budget|--stop-when-done] [--room-preflight|--no-room-preflight]
+                                [--room-auto-run|--no-room-auto-run]
+                                [--no-claude] [--no-verify] [--complete-on-pass] [--no-drain] [--create-next] [--json]
                        (bare/member-only run prompts; one-word fuzzy intent starts a new visible-goal mission; --due runs the saved queue)
+                       (short time like "20 minutes" means finish early; long/sleep time like "5 hours" keeps using the budget; --stop-when-done overrides)
+                       (messy, shower, and overnight requests preflight through Mission Room before the visible goal is written)
+                       (--room-auto-run makes trusted self-improvement asks preview through Mission Room, select real work, then start one bounded goal)
                        (mission-run completions seed the next visible goal: decide and start the next useful mission)
   atris mission complete <id> --proof "..."
   atris mission stop <id> [--pause] [--reason "..."]
@@ -3296,7 +6593,7 @@ Autonomy recipe:
   1. Pick an owner member: atris member create <member>  (if missing)
   2. Start a current-agent mission with a verifier:
      atris mission start "ship one proof" --owner <member> --runner codex_goal --lane code --verify "npm test" --stop "verifier passes" --xp-task
-  3. Codex sessions: atris mission goal --json, then mirror goal.visible_goal into the native chat goal
+  3. Codex sessions: read native get_goal, then pass its status into atris mission goal --native-goal-status <status> --native-goal-objective "<objective>" --json
      Overnight controller: atris mission goal --heartbeat --json
      Bounded overnight runner: atris mission goal-loop --max-wall 28800 --no-claude --json
   4. Do one bounded step, then record it:
@@ -3477,6 +6774,70 @@ function layersMission(args) {
   printJsonOrText({ ok: true, since: sinceRaw || null, total, tagged, untagged, by_layer: byLayer, by_source: bySource, dominant: tagged ? dominant : null, skewed }, lines, asJson);
 }
 
+function roomMission(args) {
+  const asJson = wantsJson(args);
+  const explicitOwner = readFlag(args, '--owner', '');
+  const input = stripKnownFlags(args, ['--owner'], ['--json', '--room-auto-run', '--no-room-auto-run']).join(' ').trim();
+  if (!input) {
+    exitMissionError('Usage: atris mission room "<messy input>" [--owner <member>] [--room-auto-run] [--json]', 1, asJson);
+  }
+  const requestedOwner = explicitOwner || process.env.ATRIS_AGENT_ID || '';
+  const ownerResolution = resolveFunctionalOwner({
+    requestedOwner,
+    title: input,
+    note: input,
+    root: process.cwd(),
+    fallbackOwners: ['mission-lead', 'task-planner', 'architect', 'validator'],
+  });
+  const owner = ownerResolution.owner || requestedOwner || 'mission-lead';
+
+  let room;
+  try {
+    room = buildMissionRoom(input, {
+      owner,
+      root: process.cwd(),
+      ownerResolution,
+      trustedRun: hasFlag(args, '--room-auto-run') && !hasFlag(args, '--no-room-auto-run'),
+      verifier: DEFAULT_LONG_RUN_VERIFIER,
+    });
+  } catch (error) {
+    exitMissionError(error.message || String(error), 1, asJson);
+  }
+  const { receipt, relativePath, room: persistedRoom } = writeMissionRoomReceipt(room, { root: process.cwd() });
+  const payload = {
+    ok: true,
+    action: 'mission_room_created',
+    room: persistedRoom,
+    receipt_path: relativePath,
+    receipt,
+  };
+  printJsonOrText(payload, missionRoomLines(persistedRoom, relativePath), asJson);
+}
+
+function pruneRunsMission(args) {
+  const asJson = wantsJson(args);
+  let keepNewest;
+  let keepDays;
+  try {
+    keepNewest = readNonNegativeIntegerFlag(args, '--keep-newest', 200);
+    keepDays = readNonNegativeIntegerFlag(args, '--days', 14);
+  } catch (error) {
+    exitMissionError(error.message || String(error), 1, asJson);
+  }
+  const result = pruneRuns(process.cwd(), {
+    apply: hasFlag(args, '--apply'),
+    archive: !hasFlag(args, '--no-archive'),
+    keepNewest,
+    keepDays,
+  });
+  printJsonOrText(
+    { ok: !result.errors.length, ...result },
+    runsPruneLines(result),
+    asJson,
+  );
+  if (result.errors.length) process.exitCode = 1;
+}
+
 function missionCommand(args) {
   const subcommand = args[0] || 'status';
   const rest = args.slice(1);
@@ -3488,7 +6849,13 @@ function missionCommand(args) {
     case 'status':
     case 'list':
     case 'ls':
+    case 'show':
+    case 'info':
+    case 'view':
       return statusMission(rest);
+    case 'doctor':
+    case 'check':
+      return doctorMission(rest);
     case 'attach-task':
     case 'ensure-task':
     case 'task-spine':
@@ -3496,10 +6863,19 @@ function missionCommand(args) {
     case 'report':
     case 'debrief':
       return reportMission(rest);
+    case 'timeline':
+    case 'landings':
+      return timelineMission(rest);
     case 'watch':
       return watchMission(rest);
     case 'layers':
       return layersMission(rest);
+    case 'room':
+      return roomMission(rest);
+    case 'prune-runs':
+    case 'runs-prune':
+    case 'clean-runs':
+      return pruneRunsMission(rest);
     case 'goal':
     case 'codex-goal':
       return goalMission(rest);
@@ -3538,6 +6914,7 @@ module.exports = {
   cappedClaudeReceiptText,
   extractLayerFromReceiptText,
   classifyPathsByLayer,
+  collectMissionDoctorFindings,
   resolveClaudeRunnerModel,
   resolveClaudeRunnerBin,
   businessIdForAtris2Mission,