atris 3.37.1 → 3.38.0

package/commands/mission.js

@@ -78,6 +78,11 @@ const {
   resolveDefaultVerifier,
 } = require('../lib/default-verifier');
 const { redirectToWorkspaceRoot } = require('../lib/mission-root');
+const {
+  inspectMissionProtectedDiff,
+  prepareMissionGitGuard,
+  unreadableMissionGuard,
+} = require('../lib/mission-protected-lane');
 
 const VALID_STATUSES = new Set(['planning', 'running', 'ready', 'paused', 'blocked', 'stopped', 'complete']);
 const TERMINAL_STATUSES = new Set(['stopped', 'complete']);
@@ -1697,6 +1702,16 @@ function missionLastStepSummary(ticks = []) {
   return '';
 }
 
+function verifierElapsedSeconds(verifierResult) {
+  const ms = Number(verifierResult && verifierResult.elapsed_ms);
+  return Number.isFinite(ms) ? Math.round(ms / 1000) : 0;
+}
+
+function verifierTimeoutSeconds(verifierResult) {
+  const ms = Number(verifierResult && verifierResult.timeout_ms);
+  return Number.isFinite(ms) ? Math.round(ms / 1000) : 0;
+}
+
 function missionVerifierCheckedText(verifierResult, mission) {
   if (!verifierResult) return 'UNVERIFIED: tick recorded but nothing was checked; treat this increment as unproven.';
   if (verifierResult.mode === 'engine-unavailable') {
@@ -1708,6 +1723,9 @@ function missionVerifierCheckedText(verifierResult, mission) {
       : 'VERIFY FAILED: the engine verify pass did not end with VERDICT: PASS.';
   }
   const command = verifierResult.command || mission.verifier || 'configured verifier';
+  if (!verifierResult.passed && verifierResult.timed_out) {
+    return `VERIFY TIMED OUT: the check ran past its ${verifierTimeoutSeconds(verifierResult)}s window (took ${verifierElapsedSeconds(verifierResult)}s); the code is not failing, the suite is slow. Rerun with more room.`;
+  }
   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.';
@@ -1732,6 +1750,9 @@ function missionVerifierHighLevelTestText(verifierResult, mission) {
       : 'The verify engine did not provide a passing changed-surface verdict.';
   }
   const command = verifierResult.command || mission.verifier || 'configured verifier';
+  if (!verifierResult.passed && verifierResult.timed_out) {
+    return `Verifier command timed out after ${verifierElapsedSeconds(verifierResult)}s against a ${verifierTimeoutSeconds(verifierResult)}s window: ${command}. No pass/fail verdict was reached; the suite outran the window rather than the code failing.`;
+  }
   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.`;
@@ -1964,12 +1985,22 @@ function shouldMissionRunTrustedRoom(rawObjective, args = []) {
   return missionRunTrustedRoomSignals(rawObjective);
 }
 
+const MISSION_BARE_COMMAND_WORDS = new Set(['go', 'keep', 'going', 'do', 'it', 'start', 'run', 'continue']);
+
+function missionObjectiveIsJunk(value) {
+  const objective = String(value || '').trim();
+  if (!objective || objective.startsWith('-')) return true;
+  if (/[\u0000-\u001f\u007f-\u009f\ufffd]/u.test(objective)) return true;
+  if (objective.replace(/\s/g, '').length < 8) return true;
+  const words = objective.toLowerCase().match(/[a-z]+/g) || [];
+  return words.length > 0
+    && objective.replace(/[^a-z]+/gi, '').length > 0
+    && words.every((word) => MISSION_BARE_COMMAND_WORDS.has(word));
+}
+
 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;
+  return missionObjectiveIsJunk(title) ? '' : title;
 }
 
 function selectMissionRunUsefulTarget(rawObjective, root = process.cwd()) {
@@ -2207,6 +2238,9 @@ function missionFullBudgetRemainingSeconds(mission, nowMs = Date.now()) {
 }
 
 function missionBudgetContinuationText(mission, nowMs = Date.now()) {
+  // Paused/stopped/blocked missions are not running: never sell remaining time
+  // as a live commitment (CLI-1192: paused overnight loops read as healthy).
+  if (!GOAL_LOOP_STATUSES.has(String(mission?.status || ''))) return null;
   const remaining = missionFullBudgetRemainingSeconds(mission, nowMs);
   if (remaining <= 0) return null;
   const budget = String(mission?.budget_contract?.budget_label || 'promised time').trim();
@@ -2218,10 +2252,15 @@ function missionBudgetContinuationText(mission, nowMs = Date.now()) {
 }
 
 function missionHumanStatusText(mission, nowMs = Date.now()) {
+  const rawStatus = String(mission?.status || 'unknown');
+  if (rawStatus === 'paused') {
+    const reason = String(mission?.stop_reason || mission?.pause_reason || '').trim();
+    return gateForHuman(reason ? `paused: ${reason}` : 'paused').text;
+  }
   const continuation = missionBudgetContinuationText(mission, nowMs);
   const status = continuation
     ? `working for the full ${String(mission?.budget_contract?.budget_label || 'promised time').trim()}`
-    : String(mission?.status || 'unknown');
+    : rawStatus;
   return gateForHuman(status).text;
 }
 
@@ -3852,16 +3891,15 @@ function findActiveTwinMission(objective, owner, root = process.cwd()) {
 function startMission(args, options = {}) {
   const asJson = wantsJson(args);
   const firstArg = String(args[0] || '').trim().toLowerCase();
-  if (hasFlag(args, '--help') || hasFlag(args, '-h') || firstArg === 'help') {
+  if (args.length === 1 && (firstArg === '--help' || firstArg === '-h' || firstArg === 'help')) {
     console.log('Usage: atris mission start "<objective>" --owner <member> --verify "..." [--destination "..."] [--no-verify] [--always-on] [--budget quick|long|deep] [--runner manual|claude|atris2|codex_goal|auto]');
     console.log('Run `atris mission --help` for the full option list.');
     process.exit(0);
   }
   let mission = applyMissionStartPatch(missionFromArgs(args), options.missionPatch);
-  // 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);
+  if (missionObjectiveIsJunk(rawObjective)) {
+    exitMissionError(`mission start refused junk objective: ${rawObjective ? `"${rawObjective}"` : 'nothing'}`, 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.
@@ -4251,6 +4289,11 @@ async function startMissionFromRunObjective(objective, args) {
 
 function attachMissionTask(args) {
   const asJson = wantsJson(args);
+  if (hasFlag(args, '--help') || hasFlag(args, '-h') || String(args[0] || '').trim() === 'help') {
+    console.log('Usage: atris mission attach-task <id> [--json]');
+    console.log('Run `atris mission --help` for the full option list.');
+    process.exit(0);
+  }
   const ref = stripKnownFlags(args, [], ['--json'])[0] || '';
   if (!ref) {
     exitMissionError('Usage: atris mission attach-task <id> [--json]', 1, asJson);
@@ -5148,12 +5191,24 @@ function missionReportFor(mission, root = process.cwd()) {
   const timeline = missionReportTimeline(mission, root);
   const verificationDebt = missionVerificationDebt(mission, root);
   const workerCheckedIn = Boolean(explicitWorkerReceipt) || timeline.length > 0;
+  const driver = missionDriverHealth(mission, root);
+  const driverAlive = Boolean(driver && driver.alive);
   const workerReceiptPath = mission.worker_receipt_path || (receipt && verifierReceiptPath) || null;
   const verifierPassed = mission.verifier_result && mission.verifier_result.passed === true;
   const pendingBudgetContinuation = missionBudgetContinuationText(mission);
   const budgetContinuation = workerCheckedIn ? pendingBudgetContinuation : null;
-  const operatorOutcome = !workerCheckedIn && pendingBudgetContinuation
+  const awaitingFirstWorker = !workerCheckedIn && Boolean(pendingBudgetContinuation);
+  // An active status implies a worker is running. With no receipt AND no live
+  // driver, that claim is a lie: report that no worker is running and name the
+  // command that starts one instead of saying the mission is in progress.
+  const noLiveWorker = !workerCheckedIn
+    && !driverAlive
+    && !pendingBudgetContinuation
+    && GOAL_LOOP_STATUSES.has(String(mission.status || ''));
+  const operatorOutcome = awaitingFirstWorker
     ? 'No worker has checked in yet.'
+    : noLiveWorker
+    ? 'No worker is running; nothing has produced a receipt yet.'
     : budgetContinuation
     ? 'The last verifier passed; full-budget work is continuing.'
     : mission.operator_outcome
@@ -5162,8 +5217,10 @@ function missionReportFor(mission, root = process.cwd()) {
     id: mission.id,
     objective: mission.objective,
     status: mission.status,
-    human_status: !workerCheckedIn && pendingBudgetContinuation
+    human_status: awaitingFirstWorker
       ? 'waiting for the first worker check-in'
+      : noLiveWorker
+      ? 'no live worker (nothing is running)'
       : missionHumanStatusText(mission),
     budget_continuation: budgetContinuation,
     operator_outcome: operatorOutcome,
@@ -5175,9 +5232,10 @@ function missionReportFor(mission, root = process.cwd()) {
     verifier_receipt_path: verifierReceiptPath,
     proof_text: mission.receipt_path ? missionStatusProofText(mission) : null,
     operator_next: budgetContinuation
-      || (!workerCheckedIn && pendingBudgetContinuation ? 'Wait for the first worker check-in.' : null)
+      || (awaitingFirstWorker ? 'Wait for the first worker check-in.' : null)
       || mission.operator_next
       || mission.next_action
+      || (noLiveWorker ? `Start a worker: atris mission run ${mission.id}` : null)
       || 'Review the mission state.',
   };
 }
@@ -5857,19 +5915,29 @@ function runVerifier(command, root = process.cwd()) {
   if (!command) return null;
   const resolvedCommand = resolveVerifierCommand(command);
   const { envWithNodeDir } = require('../lib/spawn-env');
+  const timeoutMs = missionVerifierTimeoutMs();
+  const startedAt = Date.now();
   const result = spawnSync(resolvedCommand, {
     cwd: root,
     shell: true,
     encoding: 'utf8',
-    timeout: missionVerifierTimeoutMs(),
+    timeout: timeoutMs,
     env: envWithNodeDir(process.env),
   });
+  const elapsedMs = Date.now() - startedAt;
+  // A verifier that blows its window is not a failing check: the code may be
+  // fine and the suite merely slow (or starved by a concurrent flight). Report
+  // it as a distinct timed-out state so operators do not read slow as broken.
+  const timedOut = result.error ? result.error.code === 'ETIMEDOUT' : false;
   return {
     command,
     resolved_command: resolvedCommand === command ? null : resolvedCommand,
     status: result.status,
     signal: result.signal || null,
     passed: result.status === 0,
+    timed_out: timedOut,
+    elapsed_ms: elapsedMs,
+    timeout_ms: timeoutMs,
     stdout: String(result.stdout || '').slice(-4000),
     stderr: String(result.stderr || '').slice(-4000),
   };
@@ -5952,8 +6020,14 @@ function gitWorktreeSnapshot(root = process.cwd()) {
   }
   const entries = String(status.stdout || '').split(/\r?\n/).filter(Boolean).sort();
   const digest = crypto.createHash('sha1').update(entries.join('\n')).digest('hex');
+  const head = spawnSync('git', ['rev-parse', '--verify', 'HEAD'], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: 5000,
+  });
   return {
     available: true,
+    head: head.status === 0 ? String(head.stdout || '').trim() : null,
     dirty_count: entries.length,
     dirty_hash: digest,
     dirty_sample: entries.slice(0, 25),
@@ -5961,6 +6035,49 @@ function gitWorktreeSnapshot(root = process.cwd()) {
   };
 }
 
+function missionProtectedTags(mission, root = process.cwd()) {
+  const tags = [
+    mission?.tag,
+    mission?.lane,
+    ...(Array.isArray(mission?.tags) ? mission.tags : []),
+  ].filter(Boolean);
+  const taskRefs = new Set([
+    mission?.task_id,
+    mission?.task_ref,
+    ...(Array.isArray(mission?.task_ids) ? mission.task_ids : []),
+  ].filter(Boolean).map(String));
+  if (!taskRefs.size) return tags;
+  try {
+    const projection = JSON.parse(fs.readFileSync(path.join(root, '.atris', 'state', 'tasks.projection.json'), 'utf8'));
+    for (const task of Array.isArray(projection?.tasks) ? projection.tasks : []) {
+      if (!task || ![task.id, task.display_id, task.legacy_ref].some((ref) => taskRefs.has(String(ref || '')))) continue;
+      if (task.tag) tags.push(task.tag);
+      if (Array.isArray(task.tags)) tags.push(...task.tags);
+    }
+  } catch {}
+  return tags;
+}
+
+function inspectMissionTickProtectedDiff(mission, before, root = process.cwd()) {
+  const after = gitWorktreeSnapshot(root);
+  if (before?.reason === 'not-git-worktree' && after?.reason === 'not-git-worktree') {
+    return {
+      ok: true,
+      allowed: true,
+      status: 'clear',
+      reason: 'no git worktree exists, so this tick cannot commit or land',
+      unreadable: false,
+      surfaces: [],
+      matches: [],
+    };
+  }
+  return inspectMissionProtectedDiff({
+    root,
+    baseRef: before?.head || '',
+    tags: missionProtectedTags(mission, root),
+  });
+}
+
 // Porcelain v1 entries are "XY path" or "XY old -> new"; baselines compare by
 // post-rename path so a status-letter change alone never counts as new dirt.
 function porcelainEntryPath(line) {
@@ -6264,7 +6381,14 @@ function missionSortTime(mission) {
 }
 
 function selectDueMission(root = process.cwd(), now = new Date(), options = {}) {
-  const candidates = listMissions(root)
+  const missions = listMissions(root);
+  for (const mission of missions) {
+    if (!missionIsRunnable(mission) || !missionObjectiveIsJunk(mission.objective)) continue;
+    stopMissionRecord(mission, 'junk_objective_gate', root, { writeStopReceipt: false });
+    console.error(`auto-stopped junk mission: "${String(mission.objective || '')}"`);
+  }
+  const candidates = missions
+    .filter((mission) => !missionObjectiveIsJunk(mission.objective))
     .filter((mission) => missionSelectableForLoop(mission, now))
     .filter((mission) => !options.headlessOnly || !runnerUsesCallerSession(mission.runner))
     .filter((mission) => !missionTaskHumanAcceptWaiting(mission))
@@ -7876,6 +8000,14 @@ function spawnMissionDriver(mission, root = process.cwd()) {
       log_path: logPath,
     }, null, 2) + '\n', 'utf8');
     child.unref();
+    // A returned pid is not proof the engine is running: spawn can hand back a
+    // pid for a child that never execs or exits immediately. Verify the process
+    // is actually alive before claiming a live worker, and drop the misleading
+    // driver-state file when it is not.
+    if (!child.pid || !missionLockOwnerIsAlive(child.pid)) {
+      try { fs.rmSync(paths.stateFile, { force: true }); } catch {}
+      return { ok: false, error: 'mission driver exited before it could start', pid: child.pid || null };
+    }
     return {
       ok: true,
       pid: child.pid,
@@ -7949,7 +8081,13 @@ function detachMissionRun(args, mission, root = process.cwd(), asJson = false) {
 
 function probeClaudeBinary() {
   const runnerBin = resolveClaudeRunnerBin();
-  if (resolveClaudeRunnerCommandTemplate()) {
+  const commandTemplate = resolveClaudeRunnerCommandTemplate();
+  if (commandTemplate) {
+    // A command template fully replaces the claude invocation (GLM/OpenAI/
+    // local runners). The runner bin only matters when the template actually
+    // references {bin}; requiring `claude` on PATH otherwise defeats the
+    // template's purpose and breaks generic runners on claude-less machines.
+    if (!commandTemplate.includes('{bin}')) return { ok: true };
     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 };
@@ -8072,6 +8210,9 @@ function detectUnavailableModel(text) {
 // need a resume; a model-unavailable pause is a config error a bare resume won't fix,
 // so name the dead id and the two knobs that change it.
 function missionPauseNextAction(pauseReason, missionId, deadModel = null, lastErrorReason = null) {
+  if (pauseReason === 'protected-lane-review') {
+    return `review the protected diff and its receipt before resuming: atris mission run ${missionId}`;
+  }
   if (pauseReason === 'too-deep') {
     return 'stopped: helpers were spawning helpers too many levels deep';
   }
@@ -8260,13 +8401,31 @@ function spawnGenericRunnerTick(mission, opts) {
       resolve({ ok: false, error: e.message, sessionIds: [], aborted: false, timedOut: false, authExpired: false, brief_id: briefId });
       return;
     }
+    let gitGuard;
+    try {
+      gitGuard = prepareMissionGitGuard({ root: cwd, tags: missionProtectedTags(mission, cwd) });
+    } catch (error) {
+      resolve({
+        ok: false,
+        reason: 'protected-diff-unreadable',
+        error: error.message || String(error),
+        protected_lane_guard: unreadableMissionGuard(error),
+        sessionIds: [],
+        aborted: false,
+        timedOut: false,
+        authExpired: false,
+        brief_id: briefId,
+      });
+      return;
+    }
 
     const startedAt = Date.now();
-    const proc = spawn('sh', ['-lc', cmd], {
+    const guardedCommand = `PATH=${shellQuote(gitGuard.pathPrefix)}:$PATH; export PATH; ${cmd}`;
+    const proc = spawn('sh', ['-lc', guardedCommand], {
       cwd,
       stdio: ['ignore', 'pipe', 'pipe'],
       detached: true,
-      env: { ...process.env, ATRIS_DISPATCH_DEPTH: String(dispatchDepth.depth + 1) },
+      env: { ...gitGuard.env, ATRIS_DISPATCH_DEPTH: String(dispatchDepth.depth + 1) },
     });
     updateMissionLockOwner(missionLock, proc.pid, { phase: 'tick' });
     let stdout = '';
@@ -8297,6 +8456,7 @@ function spawnGenericRunnerTick(mission, opts) {
     proc.on('close', (code) => {
       clearTimeout(timer);
       cleanupPrompt();
+      gitGuard.cleanup();
       if (signal) signal.removeEventListener?.('abort', onAbort);
       updateMissionLockOwner(missionLock, missionLock?.driverPid);
       const finalText = String(stdout || '').trim();
@@ -8325,6 +8485,7 @@ function spawnGenericRunnerTick(mission, opts) {
     proc.on('error', (e) => {
       clearTimeout(timer);
       cleanupPrompt();
+      gitGuard.cleanup();
       if (signal) signal.removeEventListener?.('abort', onAbort);
       updateMissionLockOwner(missionLock, missionLock?.driverPid);
       resolve({ ok: false, error: e.message, sessionIds: [], aborted, timedOut, authExpired: false, brief_id: briefId });
@@ -8373,6 +8534,22 @@ function spawnClaudeTick(mission, opts) {
   const dispatchDepth = missionDispatchDepth();
   if (dispatchDepth.tooDeep) return Promise.resolve(tooDeepRunnerResult(dispatchDepth));
   return new Promise((resolve) => {
+    let gitGuard;
+    try {
+      gitGuard = prepareMissionGitGuard({ root: cwd, tags: missionProtectedTags(mission, cwd) });
+    } catch (error) {
+      resolve({
+        ok: false,
+        reason: 'protected-diff-unreadable',
+        error: error.message || String(error),
+        protected_lane_guard: unreadableMissionGuard(error),
+        sessionIds: [],
+        aborted: false,
+        timedOut: false,
+        authExpired: false,
+      });
+      return;
+    }
     const args = [
       '-p', prompt,
       '--output-format', 'stream-json',
@@ -8392,7 +8569,7 @@ function spawnClaudeTick(mission, opts) {
       cwd,
       stdio: ['ignore', 'pipe', 'pipe'],
       detached: true,
-      env: { ...process.env, ATRIS_DISPATCH_DEPTH: String(dispatchDepth.depth + 1) },
+      env: { ...gitGuard.env, ATRIS_DISPATCH_DEPTH: String(dispatchDepth.depth + 1) },
     });
     updateMissionLockOwner(missionLock, proc.pid, { phase: 'tick' });
 
@@ -8455,6 +8632,7 @@ function spawnClaudeTick(mission, opts) {
 
     proc.on('close', (code) => {
       clearTimeout(timer);
+      gitGuard.cleanup();
       if (signal) signal.removeEventListener?.('abort', onAbort);
       updateMissionLockOwner(missionLock, missionLock?.driverPid);
       const ok = code === 0 && !isError && !timedOut && !aborted;
@@ -8484,6 +8662,7 @@ function spawnClaudeTick(mission, opts) {
 
     proc.on('error', (e) => {
       clearTimeout(timer);
+      gitGuard.cleanup();
       updateMissionLockOwner(missionLock, missionLock?.driverPid);
       resolve({ ok: false, error: e.message, sessionIds: [], aborted, timedOut, authExpired: false });
     });
@@ -8826,6 +9005,10 @@ async function runMission(args) {
     const startedAt = Date.now();
     let backoffAttempt = 0;
     let lastRateLimit = null;
+    // A usage-wall cooldown belongs to the engine that hit it, not the whole run.
+    // Tracking which engine set it lets an auto-runner swap to another ready engine
+    // and keep working instead of waiting the wall out (or pausing for a human).
+    let rateLimitedEngineId = null;
     let continuationGoal = null;
 
     const sessionLabel = skipWorker
@@ -8885,6 +9068,18 @@ async function runMission(args) {
         result.engine_fallback_reason = tickSelection.engine_fallback_reason;
       }
 
+      // Usage-wall engine swap: when a prior tick's engine hit a rate-limit wall and
+      // the auto runner has already resolved this tick to a *different* ready engine
+      // (the walled one is now credit_out and excluded from resolution), the run-wide
+      // cooldown no longer applies. Clear it so the fresh engine runs now instead of
+      // the loop sleeping through — or pausing on `rate-limit-exceeded-wall` for — a
+      // wall this engine never hit.
+      if (lastRateLimit && rateLimitedEngineId && tickEngineId && tickEngineId !== rateLimitedEngineId) {
+        result.engine_swapped_from = rateLimitedEngineId;
+        lastRateLimit = null;
+        rateLimitedEngineId = null;
+      }
+
       // Active-hours gate
       if (engineBackedTick && !tickEngineId) {
         result = { ...result, status: 'errored', reason: 'no-ready-engine' };
@@ -8916,55 +9111,76 @@ async function runMission(args) {
           drill: drillResult,
         };
       } else if (tickAtris2Runner) {
-        const pingDrain = consumeMissionPings(mission, cwd);
-        mission = pingDrain.mission;
-        runtimeMission = runtimeView(mission);
-        const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pingDrain.pings);
-        const { runAtris2Turn } = require('./probe');
-        const businessId = businessIdForAtris2Mission(tickRuntimeMission, cwd);
-        const tickController = new AbortController();
-        let wallExpired = false;
-        const abortTick = () => tickController.abort();
-        controller.signal.addEventListener('abort', abortTick, { once: true });
-        const tickTimer = setTimeout(() => {
-          wallExpired = true;
-          tickController.abort();
-        }, Math.max(1, Math.floor(remainingWall * 1000)));
-        let turn;
+        let atris2GitGuard = null;
         try {
-          turn = await runAtris2Turn({
-            prompt,
-            model: tickRuntimeMission.model || 'atris:fast',
-            business: businessId,
-            maxTurns: 16,
-            signal: tickController.signal,
-            // CLI-231: mission ticks execute relayed ops in the mission's own
-            // workspace, not the hosted ai-computer filesystem.
-            localCwd: cwd,
-          });
-        } finally {
-          clearTimeout(tickTimer);
-          controller.signal.removeEventListener('abort', abortTick);
+          atris2GitGuard = prepareMissionGitGuard({ root: cwd, tags: missionProtectedTags(mission, cwd) });
+        } catch (error) {
+          result = {
+            ...result,
+            status: 'ran',
+            reason: 'protected-diff-unreadable',
+            ran: true,
+            atris2: {
+              ok: false,
+              error: error.message || String(error),
+              protected_lane_guard: unreadableMissionGuard(error),
+            },
+          };
         }
-        result.atris2 = {
-          ok: turn.ok,
-          engine: turn.engine,
-          model: tickRuntimeMission.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 (wallExpired) {
-          result = { ...result, status: 'errored', reason: 'wall-exceeded-during-tick' };
-        } else if (!turn.ok || !String(turn.text || '').trim()) {
-          result = { ...result, status: 'errored', reason: atris2TurnErrorReason(turn.error) };
-        } else {
-          result = { ...result, status: 'ran', reason: 'tick-ok', ran: true };
+        if (atris2GitGuard) {
+          const pingDrain = consumeMissionPings(mission, cwd);
+          mission = pingDrain.mission;
+          runtimeMission = runtimeView(mission);
+          const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pingDrain.pings);
+          const { runAtris2Turn } = require('./probe');
+          const businessId = businessIdForAtris2Mission(tickRuntimeMission, cwd);
+          const tickController = new AbortController();
+          let wallExpired = false;
+          const abortTick = () => tickController.abort();
+          controller.signal.addEventListener('abort', abortTick, { once: true });
+          const tickTimer = setTimeout(() => {
+            wallExpired = true;
+            tickController.abort();
+          }, Math.max(1, Math.floor(remainingWall * 1000)));
+          let turn;
+          try {
+            turn = await runAtris2Turn({
+              prompt,
+              model: tickRuntimeMission.model || 'atris:fast',
+              business: businessId,
+              maxTurns: 16,
+              signal: tickController.signal,
+              // CLI-231: mission ticks execute relayed ops in the mission's own
+              // workspace, not the hosted ai-computer filesystem.
+              localCwd: cwd,
+              localEnv: atris2GitGuard.env,
+              localPathPrefix: atris2GitGuard.pathPrefix,
+            });
+          } finally {
+            atris2GitGuard.cleanup();
+            clearTimeout(tickTimer);
+            controller.signal.removeEventListener('abort', abortTick);
+          }
+          result.atris2 = {
+            ok: turn.ok,
+            engine: turn.engine,
+            model: tickRuntimeMission.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 (wallExpired) {
+            result = { ...result, status: 'errored', reason: 'wall-exceeded-during-tick' };
+          } else if (!turn.ok || !String(turn.text || '').trim()) {
+            result = { ...result, status: 'errored', reason: atris2TurnErrorReason(turn.error) };
+          } else {
+            result = { ...result, status: 'ran', reason: 'tick-ok', ran: true };
+          }
         }
       } else {
         let sessionMode = sessionId ? 'resume' : 'set';
@@ -9006,6 +9222,7 @@ async function runMission(args) {
         result.claude = {
           ok: claudeResult.ok,
           reason: claudeResult.reason,
+          protected_lane_guard: claudeResult.protected_lane_guard || null,
           brief_id: claudeResult.brief_id || null,
           summary: claudeResult.summary,
           receipt_text: claudeResult.receipt_text,
@@ -9026,6 +9243,7 @@ async function runMission(args) {
           // treating an allowed resetsAt as one pauses every timed run after
           // tick 1 with rate-limit-exceeded-wall.
           lastRateLimit = claudeResult.rate_limit_info.status === 'allowed' ? null : claudeResult.rate_limit_info;
+          rateLimitedEngineId = lastRateLimit ? tickEngineId : null;
         }
         if (claudeResult.aborted) { pauseReason = 'aborted-during-claude'; break; }
         if (claudeResult.authExpired) { pauseReason = 'auth-required'; break; }
@@ -9091,6 +9309,19 @@ async function runMission(args) {
       // and caller-session ticks must not launch it behind the operator's
       // back. Leaving verifier_passed unset also lets the idle-stop breaker
       // judge these ticks from the worktree signal instead of hanging here.
+      const runnerGuard = result.claude?.protected_lane_guard || result.atris2?.protected_lane_guard || null;
+      if (result.status === 'ran' || runnerGuard) {
+        const protectedLaneGuard = runnerGuard?.allowed === false
+          ? runnerGuard
+          : inspectMissionTickProtectedDiff(mission, tickWorktreeBefore, cwd);
+        result.protected_lane_guard = protectedLaneGuard;
+        if (!protectedLaneGuard.allowed) {
+          result.status = 'paused-for-review';
+          result.reason = 'protected-lane-review';
+          result.ran = false;
+          pauseReason = 'protected-lane-review';
+        }
+      }
       let verifierResult = null;
       let receiptPath = null;
       if (result.status === 'ran' && verifyEach) {
@@ -9246,6 +9477,7 @@ async function runMission(args) {
         break;
       }
 
+      if (pauseReason === 'protected-lane-review') break;
       if (callerSessionRunner && result.status === 'ran') break;
       if (newStatus === 'complete' || (newStatus === 'ready' && !mission.always_on && !fullBudgetMode)) break;
       // BCK-1324: two consecutive ticks that each self-report "ran" but leave no
@@ -9516,6 +9748,7 @@ function tickMission(args) {
     const tickIdx = lastTickIndex + 1;
     const tickWorktreeBefore = gitWorktreeSnapshot(cwd);
     const worktreeBaseline = loadMissionWorktreeBaseline(mission.id, cwd);
+    const protectedLaneGuard = inspectMissionTickProtectedDiff(mission, tickWorktreeBefore, cwd);
 
     const effectiveVerifier = effectiveMissionVerifier(mission);
     const verifierCommand = verify
@@ -9524,7 +9757,7 @@ function tickMission(args) {
     if (verifierCommand) assertMissionVerifier(verifierCommand, asJson);
 
     let verifierResult = null;
-    if (verify && verifierCommand) {
+    if (protectedLaneGuard.allowed && verify && verifierCommand) {
       verifierResult = runVerifier(verifierCommand);
     }
     const tickWorktree = worktreeReceipt(tickWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: verifierCommand || effectiveVerifier, baseline: worktreeBaseline });
@@ -9533,16 +9766,17 @@ function tickMission(args) {
     // receipt text in --summary.
     const layerInfo = extractLayerFromReceiptText(summary || '', tickWorktree?.new_since_baseline_sample);
     const tickRecord = {
-      status: 'ran',
-      reason: 'tick-recorded',
+      status: protectedLaneGuard.allowed ? 'ran' : 'paused-for-review',
+      reason: protectedLaneGuard.allowed ? 'tick-recorded' : 'protected-lane-review',
       tick_index: tickIdx,
-      ran: true,
+      ran: protectedLaneGuard.allowed,
       started_at: tickStart,
       claude: { skipped: true, reason: 'orchestrator-is-caller-session' },
       summary: summary || null,
       layer: layerInfo.layer,
       layer_source: layerInfo.source,
       verifier_passed: verifierResult ? !!verifierResult.passed : null,
+      protected_lane_guard: protectedLaneGuard,
       finished_at: stampIso(),
       worktree: tickWorktree,
     };
@@ -9555,6 +9789,7 @@ function tickMission(args) {
         started_at: tickStart,
       },
       verifier_result: verifierResult,
+      protected_lane_guard: protectedLaneGuard,
       rate_limit_info: null,
       worktree: tickWorktree,
     });
@@ -9566,7 +9801,10 @@ function tickMission(args) {
 	        ? nextCandidateTickAction(mission)
 	        : 'attach task, verifier, or proof');
 	    const nextGoalChain = advanceMissionGoalChain(mission.goal_chain, summary, verifierResult);
-	    if (verifierResult?.passed && nextGoalChain && !nextGoalChain.pause_ready) {
+	    if (!protectedLaneGuard.allowed) {
+	      status = 'paused';
+	      nextAction = `review the protected diff and receipt before resuming: atris mission run ${mission.id}`;
+	    } else if (verifierResult?.passed && nextGoalChain && !nextGoalChain.pause_ready) {
 	      status = 'running';
 	      nextAction = missionGoalChainNextAction(nextGoalChain);
     } else if (verifierResult?.passed) {
@@ -9591,10 +9829,10 @@ function tickMission(args) {
 	    }
 	    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,
+      ...mission,
+      status,
+      paused_at: clearsPauseState ? null : tickRecord.finished_at,
+      stop_reason: clearsPauseState ? null : tickRecord.reason,
       resumed_at: clearsPauseState && mission.status === 'paused' ? tickRecord.finished_at : mission.resumed_at || null,
       receipt_path: receiptPath,
       last_tick_at: tickRecord.finished_at,
@@ -9698,6 +9936,11 @@ function missionCompletionGate(mission, proof, root = process.cwd()) {
 
 function completeMission(args) {
   const asJson = wantsJson(args);
+  if (hasFlag(args, '--help') || hasFlag(args, '-h') || String(args[0] || '').trim() === 'help') {
+    console.log('Usage: atris mission complete <id> --proof "..."');
+    console.log('Run `atris mission --help` for the full option list.');
+    process.exit(0);
+  }
   const force = hasFlag(args, '--force');
   const proof = readFlag(args, '--proof', '');
   const ref = stripKnownFlags(args, ['--proof'], ['--json', '--force'])[0] || '';
@@ -9773,31 +10016,21 @@ function completeMission(args) {
   );
 }
 
-function stopMission(args) {
-  const asJson = wantsJson(args);
-  const reason = readFlag(args, '--reason', 'stopped by operator');
-  const pause = hasFlag(args, '--pause');
-  const ref = stripKnownFlags(args, ['--reason'], ['--json', '--pause'])[0] || '';
-  if (!ref) {
-    exitMissionError('Usage: atris mission stop <id> [--pause] [--reason "..."]', 1, asJson);
-  }
-  const mission = resolveMission(ref);
-  if (!mission) {
-    exitMissingMission(ref, 1, asJson);
-  }
+function stopMissionRecord(mission, reason, root = process.cwd(), options = {}) {
+  const pause = options.pause === true;
   const status = pause ? 'paused' : 'stopped';
   // Full stops abandon work, so leave evidence: snapshot the worktree against
   // the mission baseline (what did this mission leave dirty?) before pruning it.
   let receiptPath = null;
-  if (!pause) {
-    const snapshot = gitWorktreeSnapshot(process.cwd());
+  if (!pause && options.writeStopReceipt !== false) {
+    const snapshot = gitWorktreeSnapshot(root);
     const worktree = worktreeReceipt(snapshot, snapshot, {
       verifier: mission.verifier,
-      baseline: loadMissionWorktreeBaseline(mission.id, process.cwd()),
+      baseline: loadMissionWorktreeBaseline(mission.id, root),
     });
-    receiptPath = writeReceipt(mission, { kind: 'mission_stop', reason, worktree });
+    receiptPath = writeReceipt(mission, { kind: 'mission_stop', reason, worktree }, root);
   }
-  const baselineSummary = pause ? null : pruneMissionWorktreeBaseline(mission, process.cwd());
+  const baselineSummary = pause ? null : pruneMissionWorktreeBaseline(mission, root);
   const next = {
     ...mission,
     status,
@@ -9808,9 +10041,32 @@ function stopMission(args) {
     worktree_baseline: baselineSummary || mission.worktree_baseline || null,
     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 });
+  const { mission: saved } = saveMission(next, root, pause ? 'mission_paused' : 'mission_stopped', { reason, receipt_path: receiptPath });
+  const directGoalRequestCleared = pause ? false : clearDirectRunCodexGoalRequestForMission(saved.id, root);
+  const logPath = appendMemberLog(saved.owner, pause ? 'Mission paused' : 'Mission stopped', { mission: saved.objective, reason }, root);
+  return { saved, receiptPath, directGoalRequestCleared, logPath };
+}
+
+function stopMission(args) {
+  const asJson = wantsJson(args);
+  // Help is read-only: `mission stop <id> --help` must never resolve the id and
+  // stop the mission just to be asked for usage.
+  if (hasFlag(args, '--help') || hasFlag(args, '-h') || String(args[0] || '').trim() === 'help') {
+    console.log('Usage: atris mission stop <id> [--pause] [--reason "..."]');
+    console.log('Run `atris mission --help` for the full option list.');
+    process.exit(0);
+  }
+  const reason = readFlag(args, '--reason', 'stopped by operator');
+  const pause = hasFlag(args, '--pause');
+  const ref = stripKnownFlags(args, ['--reason'], ['--json', '--pause'])[0] || '';
+  if (!ref) {
+    exitMissionError('Usage: atris mission stop <id> [--pause] [--reason "..."]', 1, asJson);
+  }
+  const mission = resolveMission(ref);
+  if (!mission) {
+    exitMissingMission(ref, 1, asJson);
+  }
+  const { saved, receiptPath, directGoalRequestCleared, logPath } = stopMissionRecord(mission, reason, process.cwd(), { pause });
   printJsonOrText(
     { ok: true, action: pause ? 'mission_paused' : 'mission_stopped', mission: saved, receipt_path: receiptPath, log_path: logPath, direct_goal_request_cleared: directGoalRequestCleared },
     [
@@ -10506,6 +10762,11 @@ function inspectMission(args) {
 // output so callers (member ping) can compose their own multi-lane report.
 function pingMission(args, opts = {}) {
   const asJson = args.includes('--json');
+  if (!opts.silent && (hasFlag(args, '--help') || hasFlag(args, '-h') || String(args[0] || '').trim() === 'help')) {
+    console.log('Usage: atris mission ping <id> "<note>" [--from <who>] [--json]');
+    console.log('Run `atris mission --help` for the full option list.');
+    process.exit(0);
+  }
   const rest = args.filter((a) => a !== '--json');
   let from = process.env.USER || 'operator';
   const fromIdx = rest.indexOf('--from');
@@ -10674,6 +10935,7 @@ module.exports = {
   extractCheckFeedback,
   loadMissionMap,
   renderMissionStatus,
+  missionObjectiveIsJunk,
   selectDueMission,
   selectAtrisGoalMission,
   selectCodexGoalMission,
@@ -10682,29 +10944,22 @@ module.exports = {
   cappedClaudeReceiptText,
   extractLayerFromReceiptText,
   classifyPathsByLayer,
-  collectMissionDoctorFindings,
   resolveClaudeRunnerModel,
   resolveClaudeRunnerBin,
   businessIdForAtris2Mission,
   detectUnavailableModel,
   missionPauseNextAction,
-  HUMAN_BLOCKING_PAUSE_REASONS,
   composeHumanBlockingPauseMessage,
   escalateHumanBlockingPause,
-  humanBlockingPauseReason,
   consecutiveSameReasonErrors,
   missionVerifierTimeoutMs,
   missionLandingStepSummary,
   missionLandingLines,
   missionVerifierCheckedText,
   missionVerifierHighLevelTestText,
-  missionTickVerification,
-  missionVerificationDebt,
-  missionVerificationDebtLine,
-  missionReportFor,
-  renderMemberNowMarkdown,
   buildEngineVerifyPrompt,
   engineVerifierResultFromRun,
+  runVerifier,
   missionFullBudgetRemainingSeconds,
   missionBudgetContinuationText,
   missionHumanStatusText,
@@ -10718,4 +10973,6 @@ module.exports = {
   missionJudgmentCard,
   missionShippedCard,
   appendMissionJudgmentCard,
+  acquireMissionLock,
+  releaseMissionLock,
 };