atris 3.33.3 → 3.35.0

package/commands/mission.js

@@ -8,6 +8,11 @@ const { spawn, spawnSync } = require('child_process');
 const {
   resolveClaudeRunnerModel,
   resolveClaudeRunnerBin,
+  resolveClaudeRunnerCommandTemplate,
+  buildRunnerCommand,
+  RUNNER_PROFILE_DEFS,
+  RUNNER_PROFILE_ALIASES,
+  RUNNER_PROFILE_NAMES,
 } = require('../lib/runner-command');
 const {
   FUNCTIONAL_MEMBER_TOPICS,
@@ -94,6 +99,76 @@ function readFlag(args, name, fallback = '') {
   return fallback;
 }
 
+const MISSION_NATIVE_RUNNER_NAMES = Object.freeze(['manual', 'claude', 'atris2', 'codex_goal', 'caller_session', 'current_agent']);
+const MISSION_NATIVE_RUNNER_SET = new Set(MISSION_NATIVE_RUNNER_NAMES);
+
+function canonicalEngineName(name) {
+  const trimmed = String(name || '').trim();
+  if (!trimmed) return '';
+  if (RUNNER_PROFILE_DEFS[trimmed]) return trimmed;
+  if (RUNNER_PROFILE_ALIASES[trimmed]) return RUNNER_PROFILE_ALIASES[trimmed];
+  return '';
+}
+
+function knownMissionRunnerText() {
+  return `Known runners: ${MISSION_NATIVE_RUNNER_NAMES.join(', ')}. Known engines: ${RUNNER_PROFILE_NAMES.join(', ')}`;
+}
+
+function resolveMissionRunnerSelection(value, options = {}) {
+  const raw = String(value || '').trim();
+  const asJson = options.asJson === true;
+  const engineOnly = options.engineOnly === true;
+  if (!raw) {
+    exitMissionError(`${options.label || 'runner'} is required. ${knownMissionRunnerText()}.`, 2, asJson);
+  }
+  const engine = canonicalEngineName(raw);
+  if (engine) {
+    return { requested: raw, runner: engine, engine, kind: 'engine' };
+  }
+  const runner = raw.toLowerCase();
+  if (!engineOnly && MISSION_NATIVE_RUNNER_SET.has(runner)) {
+    return { requested: raw, runner, engine: null, kind: 'runner' };
+  }
+  const noun = engineOnly ? 'engine' : 'runner';
+  exitMissionError(`Unknown ${noun} "${raw}". ${knownMissionRunnerText()}.`, 2, asJson);
+}
+
+function runnerModelPatch(runner, model) {
+  const explicitModel = String(model || '').trim();
+  if (explicitModel) return { model: explicitModel };
+  if (String(runner || '').trim().toLowerCase() === 'atris2') return { model: 'atris:fast' };
+  return {};
+}
+
+function missionRunRuntimeView(mission, runnerOverride = null, modelOverride = '') {
+  if (!runnerOverride) return mission;
+  const next = {
+    ...mission,
+    runner: runnerOverride.runner,
+    run_runner_override: {
+      requested: runnerOverride.requested,
+      runner: runnerOverride.runner,
+      stored_runner: mission.runner || null,
+      stored_model: mission.model || null,
+    },
+  };
+  delete next.model;
+  Object.assign(next, runnerModelPatch(runnerOverride.runner, modelOverride));
+  if (next.model) next.run_runner_override.model = next.model;
+  return next;
+}
+
+function applyMissionRunnerProfile(runner) {
+  const engine = canonicalEngineName(runner);
+  if (!engine) return () => {};
+  const previous = process.env.ATRIS_RUNNER_PROFILE;
+  process.env.ATRIS_RUNNER_PROFILE = engine;
+  return () => {
+    if (previous === undefined) delete process.env.ATRIS_RUNNER_PROFILE;
+    else process.env.ATRIS_RUNNER_PROFILE = previous;
+  };
+}
+
 function exitMissionError(message, code = 1, asJson = false) {
   if (asJson) console.log(JSON.stringify({ ok: false, error: message }, null, 2));
   else console.error(message);
@@ -215,6 +290,7 @@ const MISSION_RUN_VALUE_FLAGS = [
   '--verify',
   '--stop',
   '--model',
+  '--engine',
   '--native-goal-status',
   '--native-goal-objective',
   '--visible-goal-status',
@@ -233,10 +309,13 @@ const MISSION_RUN_BOOLEAN_FLAGS = [
   '--spend-full-budget',
   '--use-whole-budget',
   '--stop-when-done',
+  '--preflight',
+  '--no-preflight',
   '--room-preflight',
   '--no-room-preflight',
   '--room-auto-run',
   '--no-room-auto-run',
+  '--manual-ack',
   '--allow-native-goal-supersede',
   '--supersede-paused-native-goal',
   '--take-goal-slot',
@@ -594,6 +673,8 @@ function exitMissingMission(ref, code = 1, asJson = false) {
     if (hints.length) {
       console.error(`Workspace hint: mission ${hints[0].id} exists in ${hints[0].workspace_root}.`);
       console.error(`Run: ${hints[0].command}`);
+    } else {
+      console.error('Mission ids are workspace-local — run this from the workspace that created the mission.');
     }
   }
   process.exit(code);
@@ -675,6 +756,14 @@ function memberMissionFile(owner, root = process.cwd()) {
   return path.join(dir, 'MISSION.md');
 }
 
+function missingOwnerMemberWarning(owner, root = process.cwd()) {
+  if (!owner || fs.existsSync(path.join(root, 'atris', 'team', owner))) return null;
+  return {
+    code: 'missing_owner_member',
+    message: `owner "${owner}" has no atris/team/${owner}/ member. Create it (atris member create ${owner}) or pick an existing member (ls atris/team/).`,
+  };
+}
+
 function ensureMemberMissionFile(owner, root = process.cwd(), objective = '') {
   const missionPath = memberMissionFile(owner, root);
   if (!missionPath || fs.existsSync(missionPath)) return missionPath;
@@ -1075,7 +1164,8 @@ function normalizeMissionReceiptResult(mission, result, receiptPath = '') {
 }
 
 function missionRunStartNextLine(mission, nextCommand, warnings = []) {
-  if (warnings.length) return 'Add a verifier before completion, then run the first proof tick.';
+  const missingVerifier = warnings.some((warning) => warning && warning.code === 'missing_verifier');
+  if (missingVerifier) 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.';
   }
@@ -1105,9 +1195,11 @@ function missionRunPreflightSignals(text) {
 }
 
 function shouldMissionRunRoomPreflight(objective, args = []) {
+  if (hasFlag(args, '--no-preflight')) return false;
   if (hasFlag(args, '--no-room-preflight')) return false;
+  if (hasFlag(args, '--preflight')) return true;
   if (hasFlag(args, '--room-preflight')) return true;
-  return missionRunPreflightSignals(objective) || missionRunTrustedRoomSignals(objective);
+  return true;
 }
 
 function missionRunTrustedRoomSignals(text) {
@@ -1169,6 +1261,8 @@ 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 explicitPreflight = hasFlag(args, '--preflight') || hasFlag(args, '--room-preflight');
+  const signalPreflight = missionRunPreflightSignals(rawObjective) || missionRunTrustedRoomSignals(rawObjective);
   const trustedRun = options.allowTrustedRun !== false && shouldMissionRunTrustedRoom(rawObjective, args);
   const selectedTarget = trustedRun ? selectMissionRunUsefulTarget(rawObjective, root) : null;
   const ownerResolution = resolveFunctionalOwner({
@@ -1191,6 +1285,7 @@ function buildMissionRunRoomPreflight(rawObjective, args = [], options = {}) {
   const shapedObjective = trustedRun
     ? missionRunTrustedObjective(rawObjective, written.room, selectedTarget)
     : missionRunPreflightObjective(rawObjective, written.room, ownerResolution.owner);
+  const taskSpineRequired = !selectedTarget && (explicitPreflight || signalPreflight);
   return {
     schema: 'atris.mission_run_preflight.v1',
     source: 'mission_room',
@@ -1209,10 +1304,10 @@ function buildMissionRunRoomPreflight(rawObjective, args = [], options = {}) {
       ref: selectedTarget.ref || null,
       why: selectedTarget.why || '',
     } : null,
-    task_spine_required: !selectedTarget,
+    task_spine_required: taskSpineRequired,
     next_action: selectedTarget
       ? 'run one proof tick for the selected existing task'
-      : 'attach task spine, then run one proof tick',
+      : (taskSpineRequired ? 'attach task spine, then run one proof tick' : 'run one proof tick'),
   };
 }
 
@@ -1613,7 +1708,7 @@ function missionStatusView(mission) {
 }
 
 function missionFromArgs(args) {
-  const objective = stripKnownFlags(args, [
+  const objectiveParts = stripKnownFlags(args, [
     '--owner',
     '--cadence',
     '--loop',
@@ -1632,7 +1727,9 @@ function missionFromArgs(args) {
     '--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', '--take-goal-slot']).join(' ').trim();
+  ], ['--json', '--always-on', '--xp-task', '--agent-xp', '--worktree', '--duplicate', '--spend-full-budget', '--use-whole-budget', '--stop-when-done', '--preflight', '--no-preflight', '--room-preflight', '--no-room-preflight', '--manual-ack', '--allow-native-goal-supersede', '--supersede-paused-native-goal', '--take-goal-slot'])
+    .filter((part) => String(part || '').trim() !== '...');
+  const objective = objectiveParts.join(' ').trim();
   if (!objective) {
     exitMissionError('Usage: atris mission start "<objective>" --owner <member> [--verify "..."] [--cadence manual] [--worktree]', 1, wantsJson(args));
   }
@@ -2778,9 +2875,82 @@ function inheritedWorktreeBase(cwd) {
   }
 }
 
+// Dedup gate: the same objective + owner already active anywhere in the
+// workspace family (this store or any worktree's) is reused, never cloned.
+// Born 2026-07-02: an hourly alive loop spawned six identical auto-improver
+// missions in six fresh worktrees in one day — pure token burn. --duplicate
+// is the explicit escape hatch.
+const TWIN_ACTIVE_STATUSES = new Set(['planning', 'ready', 'running']);
+
+function normalizedObjective(text) {
+  return String(text || '').toLowerCase().replace(/\s+/g, ' ').trim();
+}
+
+function findActiveTwinMission(objective, owner, root = process.cwd()) {
+  const wantObjective = normalizedObjective(objective);
+  const wantOwner = String(owner || '').trim().toLowerCase();
+  if (!wantObjective) return null;
+  const candidates = [
+    ...listMissions(root),
+    ...listWorktreeRollupMissions(root),
+  ];
+  for (const m of candidates) {
+    if (!m || !TWIN_ACTIVE_STATUSES.has(m.status)) continue;
+    if (normalizedObjective(m.objective) !== wantObjective) continue;
+    if (String(m.owner || '').trim().toLowerCase() !== wantOwner) continue;
+    return m;
+  }
+  return null;
+}
+
 function startMission(args) {
   const asJson = wantsJson(args);
+  const firstArg = String(args[0] || '').trim().toLowerCase();
+  if (hasFlag(args, '--help') || hasFlag(args, '-h') || firstArg === 'help') {
+    console.log('Usage: atris mission start "<objective>" --owner <member> [--verify "..."] [--always-on] [--runner manual|claude|atris2|codex_goal]');
+    console.log('Run `atris mission --help` for the full option list.');
+    process.exit(0);
+  }
   const mission = missionFromArgs(args);
+  // A flag-looking or empty objective is a typo, not a mission.
+  const rawObjective = String(mission.objective || '').trim();
+  if (!rawObjective || rawObjective.startsWith('-')) {
+    exitMissionError(`mission start needs a quoted objective (got ${rawObjective ? `"${rawObjective}"` : 'nothing'}). Usage: atris mission start "<objective>" --owner <member>`, 1, asJson);
+  }
+  // Pasting a mission id where an objective goes is an id mismatch, not a new
+  // mission: recover the existing record or explain where it actually lives.
+  const idLikeObjective = String(mission.objective || '').trim();
+  if (/^mission-\d{4}-\d{2}-\d{2}-/.test(idLikeObjective)) {
+    const existing = resolveMission(idLikeObjective);
+    if (existing) {
+      printJsonOrText(
+        { ok: true, action: 'mission_recovered', recovered: true, mission: existing, note: 'objective looked like a mission id; recovered the existing mission instead of creating a new one' },
+        [
+          `That's a mission id, not an objective — recovered ${existing.id} (${existing.status}).`,
+          `Resume: atris mission run ${existing.id}`,
+        ],
+        asJson,
+      );
+      return;
+    }
+    exitMissingMission(idLikeObjective, 1, asJson);
+  }
+  if (!hasFlag(args, '--duplicate')) {
+    const twin = findActiveTwinMission(mission.objective, mission.owner);
+    if (twin) {
+      printJsonOrText(
+        { ok: true, action: 'mission_reused', reused: true, mission: twin, note: 'an active mission with this objective and owner already exists; resumed instead of cloning (pass --duplicate to force a second one)' },
+        [
+          `Already active: ${twin.id} (${twin.status})`,
+          `Same objective, same owner — reusing it instead of starting a clone.`,
+          `Resume: atris mission run ${twin.id}`,
+          `Really want a second one: re-run with --duplicate`,
+        ],
+        asJson,
+      );
+      return;
+    }
+  }
   // --worktree: bind the mission to its own isolated checkout. We chdir before
   // any state writes so the mission record, baseline sidecar, receipts, and
   // member files all land inside the worktree — ticks run there, and the main
@@ -2805,7 +2975,7 @@ function startMission(args) {
       mission.next_action = `work task then run: atris task current-step --goal-id ${mission.id} --as ${mission.owner} --proof "<proof>" --json`;
     }
   }
-  const warnings = [missingVerifierWarning(mission)].filter(Boolean);
+  const warnings = [missingVerifierWarning(mission), missingOwnerMemberWarning(mission.owner)].filter(Boolean);
   ensureMemberMissionFile(mission.owner, process.cwd(), mission.objective);
   const { mission: saved } = saveMission(mission, process.cwd(), 'mission_started', { objective: mission.objective });
   const goalSlotHandoff = hasFlag(args, '--take-goal-slot') && isCodexGoalMission(saved)
@@ -2915,7 +3085,7 @@ function startMissionFromRunObjective(objective, args) {
     mission.xp_task = xpTask;
     mission.task_ids = Array.from(new Set([...(mission.task_ids || []), xpTask.task_id]));
   }
-  const warnings = [missingVerifierWarning(mission)].filter(Boolean);
+  const warnings = [missingVerifierWarning(mission), missingOwnerMemberWarning(mission.owner)].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());
@@ -2934,6 +3104,7 @@ function startMissionFromRunObjective(objective, args) {
   const nativeGoalOptions = {
     ...(nativeGoalStatus ? { nativeGoalStatus } : {}),
     ...(nativeGoalObjective ? { nativeGoalObjective } : {}),
+    ...(hasFlag(args, '--manual-ack') ? { manualAck: true } : {}),
     ...(hasFlag(args, '--allow-native-goal-supersede') || hasFlag(args, '--supersede-paused-native-goal') ? { allowNativeGoalSupersede: true } : {}),
   };
   const goalSlotHandoff = hasFlag(args, '--take-goal-slot') && isCodexGoalMission(saved)
@@ -2943,6 +3114,7 @@ function startMissionFromRunObjective(objective, args) {
   const codexGoalState = runnerUsesCallerSession(saved.runner)
     ? refreshCodexGoalController(process.cwd(), { missionId: saved.id, ...nativeGoalOptions })
     : null;
+  const outputMission = resolveMission(saved.id, process.cwd()) || saved;
   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>"`;
@@ -2950,7 +3122,7 @@ function startMissionFromRunObjective(objective, args) {
     {
       ok: true,
       action: 'mission_run_started',
-      mission: saved,
+      mission: outputMission,
       budget_contract: saved.budget_contract || null,
       warnings,
       state_path: statePaths().missionsJsonl,
@@ -2972,7 +3144,7 @@ function startMissionFromRunObjective(objective, args) {
       native_goal_ack_command: codexGoalState?.goal?.native_goal_ack_command || codexGoalState?.active_goal_conflict?.commands?.ack_new_mission || null,
       next_command: nextCommand,
     },
-    missionRunTakeoffLines(saved, { warnings, nextCommand }),
+    missionRunTakeoffLines(outputMission, { warnings, nextCommand }),
     asJson,
   );
 }
@@ -3107,6 +3279,74 @@ function attachMissionTask(args) {
   }
 }
 
+function setMissionRunner(args) {
+  const asJson = wantsJson(args);
+  if (hasFlag(args, '--help') || hasFlag(args, '-h') || String(args[0] || '').trim() === 'help') {
+    console.log('Usage: atris mission set-runner <id> <runner|engine> [--model <id>] [--json]');
+    console.log(knownMissionRunnerText());
+    return;
+  }
+  const positionals = stripKnownFlags(args, ['--model'], ['--json']);
+  const ref = String(positionals[0] || '').trim();
+  const runnerArg = String(positionals[1] || '').trim();
+  if (!ref || !runnerArg) {
+    exitMissionError(`Usage: atris mission set-runner <id> <runner|engine> [--model <id>]. ${knownMissionRunnerText()}.`, 1, asJson);
+  }
+
+  const selection = resolveMissionRunnerSelection(runnerArg, { asJson, label: 'runner' });
+  const model = readFlag(args, '--model', '');
+  let mission = resolveMission(ref);
+  if (!mission) exitMissingMission(ref, 1, asJson);
+
+  const lock = acquireMissionLock(mission.id);
+  if (!lock.ok) {
+    exitMissionError(`[mission set-runner] lock busy (held by pid ${lock.holder?.pid || '?'} since ${lock.holder?.started_at || '?'}). Exit.`, 3, asJson);
+  }
+
+  try {
+    mission = resolveMission(mission.id) || mission;
+    const previous = { runner: mission.runner || null, model: mission.model || null };
+    const nextMission = {
+      ...mission,
+      runner: selection.runner,
+      next_action: mission.next_action || `run: atris mission run ${mission.id}`,
+    };
+    delete nextMission.model;
+    Object.assign(nextMission, runnerModelPatch(selection.runner, model));
+
+    const { mission: saved, event } = saveMission(
+      nextMission,
+      process.cwd(),
+      'mission_runner_changed',
+      {
+        previous_runner: previous.runner,
+        previous_model: previous.model,
+        runner: nextMission.runner,
+        requested_runner: selection.requested,
+        kind: selection.kind,
+        model: nextMission.model || null,
+      },
+    );
+    const logPath = appendMemberLog(saved.owner, 'Mission runner changed', {
+      mission: saved.objective,
+      previous_runner: previous.runner || undefined,
+      runner: saved.runner,
+      model: saved.model || undefined,
+    });
+    printJsonOrText(
+      { ok: true, action: 'mission_runner_changed', mission: saved, event, log_path: logPath },
+      [
+        `Mission runner changed: ${saved.id}`,
+        `Runner: ${previous.runner || 'none'} -> ${saved.runner}${saved.model ? ` (${saved.model})` : ''}`,
+        `Next: atris mission run ${saved.id}`,
+      ],
+      asJson,
+    );
+  } finally {
+    releaseMissionLock(lock);
+  }
+}
+
 function statusMission(args) {
   const asJson = wantsJson(args);
   const localOnly = hasFlag(args, '--local');
@@ -3986,6 +4226,12 @@ function missionReceiptHealth(mission, root = process.cwd()) {
   return { ok: true, reason: 'verifier_passed', receipt_path: receiptPath };
 }
 
+function missionIsDriveParked(mission) {
+  if (String(mission?.status || '').toLowerCase() !== 'paused') return false;
+  const reason = String(mission?.stop_reason || '').toLowerCase();
+  return reason.startsWith('drive:') && reason.includes('auto-parked');
+}
+
 function collectMissionDoctorFindings(root = process.cwd(), options = {}) {
   const localOnly = options.localOnly === true;
   let missions = listMissions(root);
@@ -4017,7 +4263,10 @@ function collectMissionDoctorFindings(root = process.cwd(), options = {}) {
     const status = String(mission.status || '');
     const active = !TERMINAL_STATUSES.has(status);
     const objective = String(mission.objective || '').trim();
-    if (active && !effectiveMissionVerifier(mission)) {
+    // Only drive's explicit auto-park reason settles a no-verifier mission.
+    // Other paused no-verifier missions still need a verifier or a deliberate
+    // park, otherwise doctor and drive silently disagree about stale work.
+    if (active && !missionIsDriveParked(mission) && !effectiveMissionVerifier(mission)) {
       add(
         mission,
         'missing_verifier',
@@ -4187,6 +4436,12 @@ function resolveVerifierCommand(command) {
   return `${leading}${shellQuote(process.execPath)} ${shellQuote(cliPath)}${trimmed.slice('atris'.length)}`;
 }
 
+function missionVerifierTimeoutMs(env = process.env) {
+  const parsed = Number(env.ATRIS_MISSION_VERIFIER_TIMEOUT_MS);
+  if (Number.isFinite(parsed) && parsed >= 1000) return Math.floor(parsed);
+  return 120000;
+}
+
 function runVerifier(command, root = process.cwd()) {
   if (!command) return null;
   const resolvedCommand = resolveVerifierCommand(command);
@@ -4194,7 +4449,7 @@ function runVerifier(command, root = process.cwd()) {
     cwd: root,
     shell: true,
     encoding: 'utf8',
-    timeout: 120000,
+    timeout: missionVerifierTimeoutMs(),
     env: process.env,
   });
   return {
@@ -4692,10 +4947,55 @@ function codexRuntimeStateBlocksMissionSlot(runtimeGoalState, mission) {
   return runtimeGoalState.objective === codexGoalObjective(mission);
 }
 
+function codexRuntimeStateCanAutoAckMission(runtimeGoalState, mission) {
+  if (!runtimeGoalState || !mission) return false;
+  if (runtimeGoalState.status !== 'active') return false;
+  if (!runtimeGoalState.objective) return false;
+  return codexRuntimeStateBlocksMissionSlot(runtimeGoalState, mission);
+}
+
 function codexGoalAckCommand(mission, objective = codexGoalObjective(mission)) {
   return `atris mission goal ack ${mission.id} --runtime codex --status active --objective ${shellQuote(objective)} --json`;
 }
 
+function recordCodexNativeGoalAck(mission, root = process.cwd(), options = {}) {
+  const canonicalObjective = codexGoalObjective(mission);
+  const reportedObjective = String(options.reportedObjective || canonicalObjective).trim();
+  const ack = {
+    runtime: 'codex',
+    status: 'active',
+    mission_id: mission.id,
+    objective: canonicalObjective,
+    ...(reportedObjective && reportedObjective !== canonicalObjective ? { reported_objective: reportedObjective } : {}),
+    acknowledged_at: stampIso(),
+  };
+  const nextMission = {
+    ...mission,
+    native_goal_ack: ack,
+    next_action: codexGoalNextCommand({ ...mission, native_goal_ack: ack }),
+  };
+  const supersededNativeGoalAcks = supersedeOtherCodexNativeGoalAcks(root, nextMission, ack);
+  const { mission: saved } = saveMission(
+    nextMission,
+    root,
+    options.eventName || 'mission_native_goal_ack',
+    { ack, ...(options.eventDetail || {}) },
+  );
+  return { saved, ack, supersededNativeGoalAcks };
+}
+
+function maybeAutoAckCodexNativeGoal(mission, root = process.cwd(), options = {}) {
+  if (options.manualAck === true) return null;
+  if (!isCodexGoalMission(mission) || codexNativeGoalAck(mission)) return null;
+  const runtimeGoalState = codexRuntimeGoalStateFromOptions(options);
+  if (!codexRuntimeStateCanAutoAckMission(runtimeGoalState, mission)) return null;
+  return recordCodexNativeGoalAck(mission, root, {
+    reportedObjective: runtimeGoalState.objective,
+    eventName: 'mission_native_goal_auto_ack',
+    eventDetail: { runtime_goal_state: runtimeGoalState },
+  });
+}
+
 function codexNativeGoalReplaceAction(newMission, activeMission, runtimeGoalState = null, commands = {}) {
   const fromObjective = codexGoalObjective(activeMission);
   const toObjective = codexGoalObjective(newMission);
@@ -4966,16 +5266,18 @@ function codexNativeGoalBlockPayload(mission) {
   };
 }
 
-function maybeBlockUntilCodexNativeGoalStarted(mission, asJson) {
+function maybeBlockUntilCodexNativeGoalStarted(mission, asJson, options = {}) {
   if (!isCodexGoalMission(mission) || codexNativeGoalAck(mission)) return;
+  if (options.manualAck === false) return;
   const payload = codexNativeGoalBlockPayload(mission);
   if (asJson) console.log(JSON.stringify(payload, null, 2));
   else console.error(payload.next_action);
   process.exit(2);
 }
 
-function returnIfCodexNativeGoalNotStarted(mission, asJson) {
+function returnIfCodexNativeGoalNotStarted(mission, asJson, options = {}) {
   if (!isCodexGoalMission(mission) || codexNativeGoalAck(mission)) return false;
+  if (options.manualAck === false) return false;
   const payload = codexNativeGoalBlockPayload(mission);
   if (asJson) console.log(JSON.stringify(payload, null, 2));
   else console.error(payload.next_action);
@@ -5162,7 +5464,10 @@ function buildCodexGoalPayload(root = process.cwd(), options = {}) {
     };
   }
 
-  const { mission, reason, direct_goal_request: directGoalRequest, seeded_continuation_goal: seededContinuationGoal } = selected;
+  let { mission } = selected;
+  const { reason, direct_goal_request: directGoalRequest, seeded_continuation_goal: seededContinuationGoal } = selected;
+  const autoNativeGoalAck = maybeAutoAckCodexNativeGoal(mission, root, options);
+  if (autoNativeGoalAck) mission = autoNativeGoalAck.saved;
   const taskSpine = missionTaskSpine(mission);
   const missionView = missionStatusView(mission);
   const objective = codexGoalObjective(mission);
@@ -5198,6 +5503,10 @@ function buildCodexGoalPayload(root = process.cwd(), options = {}) {
     native_goal_action: nativeGoalAction,
     native_goal_ack_command: codexGoalAckCommand(mission, objective),
     native_goal_ack: ack,
+    auto_native_goal_ack: autoNativeGoalAck ? {
+      native_goal_ack: autoNativeGoalAck.ack,
+      superseded_native_goal_acks: autoNativeGoalAck.supersededNativeGoalAcks,
+    } : null,
     direct_goal_request: directGoalRequest || null,
     seeded_continuation_goal: seededContinuationGoal || null,
     next_action_preview: missionChoosesNextMission(mission) ? chooseNextMissionPreview(mission, root) : (mission.next_action_preview || null),
@@ -5213,6 +5522,7 @@ function buildCodexGoalPayload(root = process.cwd(), options = {}) {
     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,
+    auto_native_goal_ack: goal.auto_native_goal_ack,
     runtime_goal_state: runtimeGoalState,
   };
 }
@@ -5517,6 +5827,25 @@ function consecutiveSameReasonErrors(ticks) {
   return { reason: last.reason, count };
 }
 
+function isTransientAtris2BackendError(error) {
+  const text = String(error || '');
+  if (!text) return false;
+  return /\b(?:ECONNREFUSED|ECONNRESET|ETIMEDOUT|EPIPE)\b/i.test(text)
+    || /\b(?:socket hang up|request timeout|no response headers|stream stalled)\b/i.test(text)
+    || /\bHTTP\s+(?:502|503|504|522|523|524)\b/i.test(text)
+    // A stopped AtrisOS computer answers 409 "Computer must be running": the
+    // backend will come back, so the mission keeps waiting instead of pausing.
+    || (/\bHTTP\s+409\b/i.test(text) && /computer must be running/i.test(text));
+}
+
+function atris2TurnErrorReason(error) {
+  return isTransientAtris2BackendError(error) ? 'atris2-backend-unavailable' : 'atris2-error';
+}
+
+function missionRunKeepsRetryingError(reason) {
+  return reason === 'atris2-backend-unavailable';
+}
+
 function isWithinActiveHours(activeHours, now = new Date()) {
   if (!activeHours || !activeHours.start || !activeHours.end) return true;
   const tz = activeHours.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
@@ -5573,6 +5902,11 @@ function releaseMissionLock(lock) {
 
 function probeClaudeBinary() {
   const runnerBin = resolveClaudeRunnerBin();
+  if (resolveClaudeRunnerCommandTemplate()) {
+    const probe = spawnSync('sh', ['-c', `command -v ${shellQuote(runnerBin)}`], { encoding: 'utf8', timeout: 8000 });
+    if (probe.status !== 0) return { ok: false, error: `${runnerBin} CLI not found` };
+    return { ok: true };
+  }
   const help = spawnSync(runnerBin, ['--help'], { encoding: 'utf8', timeout: 8000 });
   if (help.status !== 0) return { ok: false, error: `${runnerBin} --help failed` };
   const text = String(help.stdout || '');
@@ -5679,7 +6013,91 @@ function missionPauseNextAction(pauseReason, missionId, deadModel = null, lastEr
   return `resume with: atris mission run ${missionId}`;
 }
 
+function writeRunnerPromptFile(cwd, missionId, prompt) {
+  const dir = path.join(cwd, '.atris', 'state', 'runner-prompts');
+  fs.mkdirSync(dir, { recursive: true });
+  const file = path.join(dir, `${missionId || 'mission'}-${Date.now()}-${crypto.randomUUID()}.md`);
+  fs.writeFileSync(file, prompt, 'utf8');
+  return file;
+}
+
+function spawnGenericRunnerTick(mission, opts) {
+  const { sessionId, cwd, signal, timeoutMs, prompt, model } = opts;
+  return new Promise((resolve) => {
+    let promptFile = null;
+    let cmd = '';
+    try {
+      promptFile = writeRunnerPromptFile(cwd, mission.id, prompt);
+      cmd = buildRunnerCommand({ promptFile, model });
+    } catch (e) {
+      resolve({ ok: false, error: e.message, sessionIds: [], aborted: false, timedOut: false, authExpired: false });
+      return;
+    }
+
+    const startedAt = Date.now();
+    const proc = spawn('sh', ['-lc', cmd], { cwd, stdio: ['ignore', 'pipe', 'pipe'], detached: true });
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    let aborted = false;
+
+    const cleanupPrompt = () => {
+      try { if (promptFile) fs.unlinkSync(promptFile); } catch {}
+    };
+    const kill = () => {
+      const killGroup = (sig) => {
+        try { process.kill(-proc.pid, sig); } catch { try { proc.kill(sig); } catch {} }
+      };
+      killGroup('SIGTERM');
+      setTimeout(() => killGroup('SIGKILL'), 3000).unref();
+    };
+    const timer = setTimeout(() => { timedOut = true; kill(); }, timeoutMs);
+    const onAbort = () => { aborted = true; kill(); };
+    if (signal) {
+      if (signal.aborted) onAbort();
+      else signal.addEventListener('abort', onAbort, { once: true });
+    }
+
+    proc.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+    proc.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+
+    proc.on('close', (code) => {
+      clearTimeout(timer);
+      cleanupPrompt();
+      if (signal) signal.removeEventListener?.('abort', onAbort);
+      const finalText = String(stdout || '').trim();
+      const errStr = String(stderr || '').slice(-2000);
+      const ok = code === 0 && !timedOut && !aborted;
+      const authExpired = /not authenticated|please log in|login required|auth(?:entication)? expired/i.test(errStr);
+      resolve({
+        ok,
+        timedOut,
+        aborted,
+        authExpired,
+        exitCode: code,
+        sessionIds: sessionId ? [sessionId] : [],
+        result: finalText,
+        summary: usefulClaudeReceiptSummary(finalText || errStr, ok ? 'no-text' : 'error'),
+        receipt_text: cappedClaudeReceiptText(finalText || errStr),
+        duration_total_ms: Date.now() - startedAt,
+        num_turns: null,
+        stop_reason: null,
+        stderr: errStr,
+        parse_errors: 0,
+      });
+    });
+
+    proc.on('error', (e) => {
+      clearTimeout(timer);
+      cleanupPrompt();
+      if (signal) signal.removeEventListener?.('abort', onAbort);
+      resolve({ ok: false, error: e.message, sessionIds: [], aborted, timedOut, authExpired: false });
+    });
+  });
+}
+
 function spawnClaudeTick(mission, opts) {
+  if (resolveClaudeRunnerCommandTemplate()) return spawnGenericRunnerTick(mission, opts);
   const { sessionMode, sessionId, cwd, signal, timeoutMs, prompt, model } = opts;
   return new Promise((resolve) => {
     const args = [
@@ -5830,10 +6248,14 @@ async function runMission(args) {
   if (hasFlag(args, '--fleet')) {
     const { runFleetFlight } = require('../lib/fleet');
     const slots = Math.max(1, Number(readFlag(args, '--slots', '')) || 3);
+    // Default: cut build worktrees from origin/master (checkoutBase). --base
+    // keeps launcher-HEAD only when the operator asks for it explicitly.
+    const baseOverride = readFlag(args, '--base', '');
     const flight = await runFleetFlight({
       slots,
       dryRun: hasFlag(args, '--dry-run'),
       log: asJson ? () => {} : console.log,
+      ...(baseOverride ? { checkoutBase: baseOverride } : {}),
     });
     if (asJson) console.log(JSON.stringify(flight, null, 2));
     process.exitCode = flight.paused && flight.paused.length > 0 ? 1 : 0;
@@ -5850,6 +6272,12 @@ async function runMission(args) {
   const maxWallFlag = readFlag(args, '--max-wall', '');
   let maxWallSeconds = Math.max(60, Number(maxWallFlag) || MISSION_RUN_DEFAULTS.maxWallSeconds);
   const cadenceOverride = readFlag(args, '--cadence', '');
+  const engineOverrideRaw = readFlag(args, '--engine', '');
+  const runnerOverride = engineOverrideRaw
+    ? resolveMissionRunnerSelection(engineOverrideRaw, { asJson, engineOnly: true, label: 'engine' })
+    : null;
+  const modelOverride = readFlag(args, '--model', '');
+  const runtimeView = (baseMission) => missionRunRuntimeView(baseMission, runnerOverride, modelOverride);
   const input = missionRunInputFromArgs(args);
   const ref = input.ref;
   const runArgs = input.args;
@@ -5877,7 +6305,8 @@ async function runMission(args) {
     return;
   }
   if (!mission) {
-    exitMissionError(ref ? `Mission "${ref}" not found.` : 'Usage: atris mission run <id|objective> [--max-ticks 4] [--max-wall 3600]', 1, asJson);
+    if (ref) exitMissingMission(ref, 1, asJson);
+    exitMissionError('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));
@@ -5895,17 +6324,22 @@ async function runMission(args) {
     process.exit(0);
   }
 
-  maybeBlockUntilCodexNativeGoalStarted(mission, asJson);
+  const manualAck = hasFlag(args, '--manual-ack');
+  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 nativeGoalRunOptions = {
+    ...(nativeGoalStatus ? { nativeGoalStatus } : {}),
+    ...(nativeGoalObjective ? { nativeGoalObjective } : {}),
+    ...(manualAck ? { manualAck: true } : {}),
+  };
+  const autoAck = maybeAutoAckCodexNativeGoal(mission, process.cwd(), nativeGoalRunOptions);
+  if (autoAck) mission = autoAck.saved;
+  maybeBlockUntilCodexNativeGoalStarted(runtimeView(mission), asJson, { manualAck });
 
-  const preLockRunner = String(mission.runner || '').trim().toLowerCase();
-  const preLockCallerSession = runnerUsesCallerSession(mission.runner);
-  if (!skipClaude && !preLockCallerSession && preLockRunner !== 'atris2') {
-    const probe = probeClaudeBinary();
-    if (!probe.ok) {
-      console.error(`[mission run] claude probe failed: ${probe.error}`);
-      process.exit(2);
-    }
-  }
+  // No pre-lock claude probe here: the runner profile isn't applied yet, so
+  // probing would test the default claude bin even when the effective runner
+  // (e.g. --engine cursor) never invokes claude. The in-lock probe below runs
+  // after applyMissionRunnerProfile and checks the right binary.
 
   const lock = acquireMissionLock(mission.id);
   if (!lock.ok) {
@@ -5920,6 +6354,7 @@ async function runMission(args) {
   let ranTicks = 0;
   const ticks = [];
   let onSig = null;
+  let restoreRunnerProfile = null;
 
   try {
     const cwd = process.cwd();
@@ -5933,11 +6368,12 @@ async function runMission(args) {
     // Derive sessionId, pendingSessionId, and the frozen contract from the fresh record
     // so a fast tick's writes can't be silently overwritten by this run loop.
     mission = resolveMission(mission.id) || mission;
+    let runtimeMission = runtimeView(mission);
     if (['complete', 'stopped'].includes(mission.status)) {
       console.error(`Mission ${mission.id} is ${mission.status}; nothing to run.`);
       return;
     }
-    if (returnIfCodexNativeGoalNotStarted(mission, asJson)) return;
+    if (returnIfCodexNativeGoalNotStarted(runtimeMission, asJson, { manualAck })) return;
     if (mission.status === 'paused') {
       mission = saveMission({
         ...mission,
@@ -5947,17 +6383,29 @@ async function runMission(args) {
         stop_reason: null,
         next_action: `running: atris mission run ${mission.id}`,
       }, cwd, 'mission_run_resumed', { reason: 'operator-resume' }).mission;
+      runtimeMission = runtimeView(mission);
     }
     sessionId = mission.claude_session_id || null;
     pendingSessionId = mission.pending_session_id || null;
-    const callerSessionRunner = runnerUsesCallerSession(mission.runner);
-    const atris2Runner = String(mission.runner || '').trim().toLowerCase() === 'atris2';
+    restoreRunnerProfile = applyMissionRunnerProfile(runtimeMission.runner);
+    const callerSessionRunner = runnerUsesCallerSession(runtimeMission.runner);
+    const atris2Runner = String(runtimeMission.runner || '').trim().toLowerCase() === 'atris2';
     const skipWorker = skipClaude || callerSessionRunner;
+    if (!skipClaude && !callerSessionRunner && !atris2Runner) {
+      const probe = probeClaudeBinary();
+      if (!probe.ok) {
+        console.error(`[mission run] claude probe failed: ${probe.error}`);
+        process.exit(2);
+      }
+    }
 
     // Freeze run-start contract (verifier, lane). Stored on receipts, not the mission record.
     const frozen = {
       verifier: effectiveMissionVerifier(mission),
       lane: mission.lane || 'workspace',
+      runner: runtimeMission.runner || 'manual',
+      model: runtimeMission.model || null,
+      ...(runnerOverride ? { stored_runner: mission.runner || null, stored_model: mission.model || null } : {}),
       started_at: stampIso(),
     };
     const runWorktreeBefore = gitWorktreeSnapshot(cwd);
@@ -5972,6 +6420,7 @@ async function runMission(args) {
     if (!skipWorker && !atris2Runner && !sessionId && !pendingSessionId) {
       pendingSessionId = crypto.randomUUID();
       mission = saveMission({ ...mission, pending_session_id: pendingSessionId }, cwd, 'mission_session_pending', { session_id: pendingSessionId }).mission;
+      runtimeMission = runtimeView(mission);
     }
 
     const startedAt = Date.now();
@@ -5982,7 +6431,7 @@ async function runMission(args) {
     const sessionLabel = skipWorker
       ? 'caller-session'
       : atris2Runner
-        ? `atris2 (${mission.model || 'atris:fast'})`
+        ? `atris2 (${runtimeMission.model || 'atris:fast'})`
         : (sessionId || `pending=${pendingSessionId}`);
     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}`);
@@ -5996,6 +6445,7 @@ async function runMission(args) {
 
       // Re-read mission, detect mutation of frozen fields
       mission = resolveMission(mission.id) || mission;
+      runtimeMission = runtimeView(mission);
       if (['complete', 'stopped', 'paused'].includes(mission.status)) { pauseReason = mission.status; break; }
       if (effectiveMissionVerifier(mission) !== frozen.verifier) { pauseReason = 'verifier-mutated'; break; }
       if ((mission.lane || 'workspace') !== frozen.lane) { pauseReason = 'lane-mutated'; break; }
@@ -6027,12 +6477,13 @@ async function runMission(args) {
       } else if (atris2Runner) {
         const pingDrain = consumeMissionPings(mission, cwd);
         mission = pingDrain.mission;
-        const prompt = buildTickPrompt(mission, tickIdx, effectiveMaxTicks, frozen, pingDrain.pings);
+        runtimeMission = runtimeView(mission);
+        const prompt = buildTickPrompt(runtimeMission, tickIdx, effectiveMaxTicks, frozen, pingDrain.pings);
         const { runAtris2Turn } = require('./probe');
-        const businessId = businessIdForAtris2Mission(mission, cwd);
+        const businessId = businessIdForAtris2Mission(runtimeMission, cwd);
         const turn = await runAtris2Turn({
           prompt,
-          model: mission.model || 'atris:fast',
+          model: runtimeMission.model || 'atris:fast',
           business: businessId,
           maxTurns: 16,
           signal: controller.signal,
@@ -6040,17 +6491,18 @@ async function runMission(args) {
         result.atris2 = {
           ok: turn.ok,
           engine: turn.engine,
-          model: mission.model || 'atris:fast',
+          model: runtimeMission.model || 'atris:fast',
           tools_run: turn.tools_run,
           unsupported: turn.unsupported,
           duration_ms: turn.duration_ms,
           error: turn.error,
+          backend_unavailable: isTransientAtris2BackendError(turn.error) || undefined,
           receipt_text: String(turn.text || '').slice(0, 4000),
         };
         if (controller.signal.aborted) { pauseReason = 'aborted-during-atris2'; break; }
         if (turn.error === 'not-logged-in') { pauseReason = 'auth-required'; break; }
         if (!turn.ok || !String(turn.text || '').trim()) {
-          result = { ...result, status: 'errored', reason: 'atris2-error' };
+          result = { ...result, status: 'errored', reason: atris2TurnErrorReason(turn.error) };
         } else {
           result = { ...result, status: 'ran', reason: 'tick-ok', ran: true };
         }
@@ -6059,11 +6511,12 @@ async function runMission(args) {
         const useId = sessionId || pendingSessionId;
         const pingDrain = consumeMissionPings(mission, cwd);
         mission = pingDrain.mission;
-        const prompt = buildTickPrompt(mission, tickIdx, effectiveMaxTicks, frozen, pingDrain.pings);
-        const claudeResult = await spawnClaudeTick(mission, {
+        runtimeMission = runtimeView(mission);
+        const prompt = buildTickPrompt(runtimeMission, tickIdx, effectiveMaxTicks, frozen, pingDrain.pings);
+        const claudeResult = await spawnClaudeTick(runtimeMission, {
           sessionMode, sessionId: useId, cwd, signal: controller.signal,
           timeoutMs: MISSION_RUN_DEFAULTS.claudeTimeoutMs, prompt,
-          model: resolveClaudeRunnerModel(mission),
+          model: resolveClaudeRunnerModel(runtimeMission),
         });
         result.claude = {
           ok: claudeResult.ok,
@@ -6159,7 +6612,7 @@ async function runMission(args) {
       const finishedAt = stampIso();
       const tickRecord = { ...result, started_at: tickStart, finished_at: finishedAt, worktree: tickWorktree };
       ticks.push(tickRecord);
-      receiptPath = writeReceipt(mission, {
+      receiptPath = writeReceipt(runtimeMission, {
         kind: 'mission_run_tick',
         tick: tickRecord,
         frozen,
@@ -6271,7 +6724,9 @@ async function runMission(args) {
       // is the same trap one step less deterministic: keep retrying and the loop burns every
       // tick + cron firing on it. Halt at two-in-a-row and surface the reason for a human.
       const errStreak = consecutiveSameReasonErrors(ticks);
-      if (errStreak.count >= 2) { pauseReason = `repeated-error:${errStreak.reason}`; break; }
+      // Sleeping Atris2 backends are different: leave the mission running so the
+      // next tick or heartbeat can catch the backend after it wakes.
+      if (errStreak.count >= 2 && !missionRunKeepsRetryingError(errStreak.reason)) { pauseReason = `repeated-error:${errStreak.reason}`; break; }
 
       // Sleep until next tick
       let sleepMs = 0;
@@ -6294,7 +6749,7 @@ async function runMission(args) {
 
     if (!pauseReason && ticks.length >= effectiveMaxTicks) {
       const lastTick = ticks[ticks.length - 1];
-      if (lastTick && lastTick.status !== 'ran') pauseReason = 'max-ticks-reached';
+      if (lastTick && lastTick.status !== 'ran' && !missionRunKeepsRetryingError(lastTick.reason)) pauseReason = 'max-ticks-reached';
     }
 
     if (pauseReason && !['complete', 'ready', 'max-wall-reached'].includes(pauseReason)) {
@@ -6322,7 +6777,8 @@ async function runMission(args) {
       next: missionRunCreatedNextLine(createdNext, continuationGoal, mission),
     };
     landingSummary.reason = missionHumanReasonText(mission, landingSummary.changed);
-    const finalReceipt = writeReceipt(mission, {
+    const finalRuntimeMission = runtimeView(mission);
+    const finalReceipt = writeReceipt(finalRuntimeMission, {
       kind: 'mission_run_summary',
       frozen,
       pause_reason: pauseReason,
@@ -6341,7 +6797,7 @@ async function runMission(args) {
     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, budget_contract: mission.budget_contract || null, worktree: summaryWorktree, atris_goal_state: atrisGoalState, codex_goal_state: codexGoalState, continuation_goal: continuationGoal, created_next: createdNext },
+      { ok: true, action: 'mission_run', mission, runner_override: runnerOverride ? finalRuntimeMission.run_runner_override : null, 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,
     );
@@ -6350,12 +6806,20 @@ async function runMission(args) {
       try { process.removeListener('SIGINT', onSig); } catch {}
       try { process.removeListener('SIGTERM', onSig); } catch {}
     }
+    if (restoreRunnerProfile) {
+      try { restoreRunnerProfile(); } catch {}
+    }
     releaseMissionLock(lock);
   }
 }
 
 function tickMission(args) {
   const asJson = wantsJson(args);
+  if (hasFlag(args, '--help') || hasFlag(args, '-h') || String(args[0] || '').trim() === 'help') {
+    console.log('Usage: atris mission tick <id> [--verify] [--summary "..."] [--complete-on-pass]');
+    console.log('Run `atris mission --help` for the full option list.');
+    process.exit(0);
+  }
   const verify = hasFlag(args, '--verify');
   const verifyOverride = readFlag(args, '--verify', '');
   const completeOnPass = hasFlag(args, '--complete-on-pass');
@@ -6691,6 +7155,60 @@ function stopMission(args) {
   );
 }
 
+// A mission parked in paused/planning/ready and untouched for a week is
+// abandoned in practice — nobody resumes it, and each one is a line the
+// operator re-reads forever. The daily autoland tick expires them to
+// stopped with a revive hint; running missions and anything touched
+// recently are never aged out, and a tick on an expired id revives it.
+const MISSION_IDLE_EXPIRY_DAYS = 7;
+const EXPIRABLE_STATUSES = new Set(['paused', 'planning', 'ready']);
+
+function expireStaleMissions(root = process.cwd(), { idleDays = MISSION_IDLE_EXPIRY_DAYS, idleHours = null, dryRun = false, statuses = EXPIRABLE_STATUSES } = {}) {
+  const windowMs = idleHours != null ? idleHours * 60 * 60 * 1000 : idleDays * 24 * 60 * 60 * 1000;
+  const windowLabel = idleHours != null
+    ? `${idleHours}+ idle hour${idleHours === 1 ? '' : 's'}`
+    : `${idleDays}+ idle day${idleDays === 1 ? '' : 's'}`;
+  const cutoff = Date.now() - windowMs;
+  const expired = [];
+  for (const mission of listMissions(root)) {
+    const status = String(mission.status || '').toLowerCase();
+    if (!statuses.has(status)) continue;
+    // updated_at and paused_at are machine-polluted — status renders and
+    // goal controllers re-save parked missions daily, so a mission nobody
+    // has run since May reads as "touched today". Real activity is the
+    // last tick (or creation, for missions that never ran).
+    const touched = Math.max(
+      Date.parse(mission.last_tick_at || '') || 0,
+      Date.parse(mission.created_at || '') || 0,
+    );
+    if (!touched || touched > cutoff) continue;
+    const reason = `expired after ${windowLabel} (was ${status}); revive with: atris mission tick ${mission.id}`;
+    if (!dryRun) {
+      const next = {
+        ...mission,
+        status: 'stopped',
+        stopped_at: stampIso(),
+        stop_reason: reason,
+      };
+      const { mission: saved } = saveMission(next, root, 'mission_expired', { reason, previous_status: status, idle_days: idleDays, idle_hours: idleHours });
+      appendMemberLog(saved.owner, 'Mission expired', { mission: saved.objective, reason }, root);
+    }
+    expired.push({ id: mission.id, owner: mission.owner, previous_status: status, objective: String(mission.objective || '').slice(0, 120) });
+  }
+  return expired;
+}
+
+// Zombie-mission reap: a mission left paused past a short leash (48h default)
+// is dead in practice long before the 7-day general idle expiry ever fires —
+// nobody is coming back to it inside a session, and it just sits on
+// `mission list` as noise. Narrower than expireStaleMissions on purpose: only
+// `paused`, never planning/ready, so the weekly cadence for those is unchanged.
+const MISSION_PAUSED_REAP_HOURS = 48;
+
+function reapPausedMissions(root = process.cwd(), { hours = MISSION_PAUSED_REAP_HOURS, dryRun = false } = {}) {
+  return expireStaleMissions(root, { idleHours: hours, dryRun, statuses: new Set(['paused']) });
+}
+
 function goalMission(args) {
   const asJson = wantsJson(args);
   if (args[0] === 'ack') {
@@ -6724,6 +7242,7 @@ function goalMission(args) {
     heartbeat: heartbeatMode,
     ...(nativeGoalStatus ? { nativeGoalStatus } : {}),
     ...(nativeGoalObjective ? { nativeGoalObjective } : {}),
+    ...(hasFlag(args, '--manual-ack') ? { manualAck: true } : {}),
     ...(allowNativeGoalSupersede ? { allowNativeGoalSupersede: true } : {}),
   });
   if (payload.active_goal_conflict) {
@@ -6760,7 +7279,7 @@ function goalMission(args) {
 
 function ackMissionGoal(args) {
   const asJson = wantsJson(args);
-  const ref = stripKnownFlags(args, ['--runtime', '--status', '--objective'], ['--json'])[0] || '';
+  const ref = stripKnownFlags(args, ['--runtime', '--status', '--objective'], ['--json', '--manual-ack'])[0] || '';
   if (!ref) {
     exitMissionError('Usage: atris mission goal ack <mission-id> --runtime codex --status active --objective "<objective>" --json', 1, asJson);
   }
@@ -6770,7 +7289,28 @@ function ackMissionGoal(args) {
   if (!mission) {
     exitMissingMission(ref, 1, asJson);
   }
-  if (runtime !== 'codex' || status !== 'active') {
+  if (runtime !== 'codex') {
+    const payload = {
+      ok: true,
+      action: 'native_goal_ack_skipped',
+      mission: missionStatusView(mission),
+      runtime,
+      status,
+      reason: 'runtime_not_codex',
+      requires_native_goal_start: false,
+      next_command: codexGoalNextCommand(mission),
+    };
+    printJsonOrText(
+      payload,
+      [
+        `Native goal ack skipped for runtime=${runtime}.`,
+        `Next: ${payload.next_command}`,
+      ],
+      asJson,
+    );
+    return;
+  }
+  if (status !== 'active') {
     exitMissionError('Native goal ack requires --runtime codex --status active.', 2, asJson);
   }
 
@@ -6787,22 +7327,7 @@ function ackMissionGoal(args) {
     }
     const canonicalObjective = codexGoalObjective(mission);
     const reportedObjective = readFlag(args, '--objective', canonicalObjective);
-    const objective = canonicalObjective;
-    const ack = {
-      runtime: 'codex',
-      status: 'active',
-      mission_id: mission.id,
-      objective,
-      ...(reportedObjective && reportedObjective !== objective ? { reported_objective: reportedObjective } : {}),
-      acknowledged_at: stampIso(),
-    };
-    const nextMission = {
-      ...mission,
-      native_goal_ack: ack,
-      next_action: codexGoalNextCommand({ ...mission, native_goal_ack: ack }),
-    };
-    const supersededNativeGoalAcks = supersedeOtherCodexNativeGoalAcks(process.cwd(), nextMission, ack);
-    const { mission: saved } = saveMission(nextMission, process.cwd(), 'mission_native_goal_ack', { ack });
+    const { saved, ack, supersededNativeGoalAcks } = recordCodexNativeGoalAck(mission, process.cwd(), { reportedObjective });
     const payload = refreshCodexGoalController(process.cwd());
     printJsonOrText(
       {
@@ -6927,15 +7452,17 @@ atris mission - durable goal + loop + owner + proof state
                        (rolls up sibling git-worktree missions; --local scopes to this checkout)
   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 [--runtime codex|atris] [--heartbeat] [--native-goal-status active|paused] [--native-goal-objective "..."] [--manual-ack] [--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 ["cmd"]] [--complete-on-pass] [--summary "..."] [--json]
+  atris mission set-runner <id> <runner|engine> [--model <id>] [--json]
   atris mission "<objective>" [--owner <member>]   Shortcut for: atris mission run "<objective>"
   atris mission run --fleet [--slots 3] [--dry-run] [--json]   Staff every idle capable engine on claimable safe-lane tasks: parallel worktree builds, serial rebase-before-ship landings, receipt in atris/runs/
   atris mission run ["objective"|<member> ["objective"]|id|--due] [--owner <member>] [--max-ticks 4] [--max-wall 3600] [--cadence "15m"]
-                                [--native-goal-status active|paused] [--native-goal-objective "..."] [--allow-native-goal-supersede] [--take-goal-slot]
-                                [--spend-full-budget|--use-whole-budget|--stop-when-done] [--room-preflight|--no-room-preflight]
+                                [--native-goal-status active|paused] [--native-goal-objective "..."] [--manual-ack] [--allow-native-goal-supersede] [--take-goal-slot]
+                                [--engine <name>]
+                                [--spend-full-budget|--use-whole-budget|--stop-when-done] [--preflight|--no-preflight|--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)
@@ -7337,6 +7864,9 @@ function missionCommand(args) {
       return inspectMission(rest);
     case 'tick':
       return tickMission(rest);
+    case 'set-runner':
+    case 'runner':
+      return setMissionRunner(rest);
     case 'run':
       return runMission(rest);
     case 'complete':
@@ -7358,6 +7888,8 @@ function missionCommand(args) {
 module.exports = {
   missionCommand,
   inspectMission,
+  expireStaleMissions,
+  reapPausedMissions,
   missionHeartbeatLines,
   listMissions,
   listWorktreeRollupMissions,
@@ -7367,6 +7899,7 @@ module.exports = {
   selectDueMission,
   selectAtrisGoalMission,
   selectCodexGoalMission,
+  codexGoalNextCommand,
   usefulClaudeReceiptSummary,
   cappedClaudeReceiptText,
   extractLayerFromReceiptText,
@@ -7378,4 +7911,5 @@ module.exports = {
   detectUnavailableModel,
   missionPauseNextAction,
   consecutiveSameReasonErrors,
+  missionVerifierTimeoutMs,
 };