atris 3.38.0 → 3.40.0

package/commands/mission.js

@@ -5,6 +5,7 @@ const path = require('path');
 const crypto = require('crypto');
 const readline = require('readline');
 const { spawn, spawnSync } = require('child_process');
+const { hasFlag, readFlag, readIntFlag } = require('../lib/arg-parser');
 const {
   appendBriefRecord,
   stampBriefOutcome,
@@ -78,6 +79,11 @@ const {
   resolveDefaultVerifier,
 } = require('../lib/default-verifier');
 const { redirectToWorkspaceRoot } = require('../lib/mission-root');
+const { readJson, writeJson } = require('../lib/json-file');
+const {
+  normalizeHumanAsks,
+  openHumanAsks,
+} = require('../lib/mission-human-asks');
 const {
   inspectMissionProtectedDiff,
   prepareMissionGitGuard,
@@ -318,28 +324,6 @@ function readMissionRouteProposal(args, asJson) {
   };
 }
 
-function hasFlag(args, name) {
-  return args.includes(name);
-}
-
-function unquote(value) {
-  const text = String(value);
-  if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
-    return text.slice(1, -1);
-  }
-  return text;
-}
-
-function readFlag(args, name, fallback = '') {
-  const prefix = `${name}=`;
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = String(args[i]);
-    if (arg === name && args[i + 1] && !String(args[i + 1]).startsWith('--')) return unquote(args[i + 1]);
-    if (arg.startsWith(prefix)) return unquote(arg.slice(prefix.length));
-  }
-  return fallback;
-}
-
 const MISSION_NATIVE_RUNNER_NAMES = Object.freeze(['manual', 'claude', 'atris2', 'codex_goal', 'caller_session', 'current_agent', 'drill']);
 const MISSION_NATIVE_RUNNER_SET = new Set(MISSION_NATIVE_RUNNER_NAMES);
 const MISSION_AUTO_RUNNER = 'auto';
@@ -513,11 +497,11 @@ function readRepeatedFlag(args, name) {
   for (let i = 0; i < args.length; i += 1) {
     const arg = String(args[i]);
     if (arg === name && args[i + 1] && !String(args[i + 1]).startsWith('--')) {
-      values.push(unquote(args[i + 1]));
+      values.push(readFlag([name, args[i + 1]], name, ''));
       i += 1;
       continue;
     }
-    if (arg.startsWith(prefix)) values.push(unquote(arg.slice(prefix.length)));
+    if (arg.startsWith(prefix)) values.push(readFlag([arg], name, ''));
   }
   return values.filter(Boolean);
 }
@@ -739,8 +723,7 @@ function loadTaskDb(asJson = false) {
 function writeMissionTaskProjection(taskDb, db, workspaceRoot) {
   const projection = taskDb.taskProjection(db, { workspaceRoot, limit: 500 });
   const outPath = path.join(workspaceRoot, '.atris', 'state', 'tasks.projection.json');
-  fs.mkdirSync(path.dirname(outPath), { recursive: true });
-  fs.writeFileSync(outPath, JSON.stringify(projection, null, 2) + '\n', 'utf8');
+  writeJson(outPath, projection);
   return { projection, outPath };
 }
 
@@ -839,16 +822,13 @@ function statePaths(root = process.cwd()) {
 
 function readBusinessBinding(root = process.cwd()) {
   const file = path.join(root, '.atris', 'business.json');
-  try {
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-    return {
-      business_id: parsed.business_id || '',
-      workspace_id: parsed.workspace_id || '',
-      slug: parsed.slug || '',
-    };
-  } catch {
-    return null;
-  }
+  const parsed = readJson(file);
+  if (parsed == null) return null;
+  return {
+    business_id: parsed.business_id || '',
+    workspace_id: parsed.workspace_id || '',
+    slug: parsed.slug || '',
+  };
 }
 
 function businessIdForAtris2Mission(mission, cwd = process.cwd()) {
@@ -935,9 +915,11 @@ function terminalNextAction(status) {
 
 function normalizeMissionState(mission) {
   if (!mission) return mission;
-  let normalized = mission;
-  const nextAction = terminalNextAction(mission.status);
-  if (nextAction && mission.next_action !== nextAction) {
+  let normalized = Array.isArray(mission.human_asks)
+    ? { ...mission, human_asks: normalizeHumanAsks(mission.human_asks) }
+    : mission;
+  const nextAction = terminalNextAction(normalized.status);
+  if (nextAction && normalized.next_action !== nextAction) {
     normalized = { ...normalized, next_action: nextAction };
   }
   const effectiveVerifier = effectiveMissionVerifier(normalized);
@@ -1524,9 +1506,10 @@ function renderMemberNowMarkdown(owner, missions, root = process.cwd()) {
     if (mission.stop_condition) lines.push(`- stop: ${mission.stop_condition}`);
     if (budgetContinuation || mission.next_action) lines.push(`- next: ${budgetContinuation || mission.next_action}`);
     if (mission.receipt_path) lines.push(`- proof: ${missionStatusProofText(mission)}`);
-    if (mission.human_asks?.length) {
+    const humanAsks = openHumanAsks(mission.human_asks);
+    if (humanAsks.length) {
       lines.push('- human asks:');
-      for (const ask of mission.human_asks) lines.push(`  - ${ask}`);
+      for (const ask of humanAsks) lines.push(`  - ${ask.text}`);
     }
     lines.push('');
   }
@@ -1734,7 +1717,7 @@ function missionVerifierCheckedText(verifierResult, mission) {
     if (/(?:node\s+\S*atris\.js|\batris)\s+drill\b/i.test(command)) return 'I ran the no-model end-to-end workflow drill.';
     return `Verifier passed: ${command}.`;
   }
-  if (/^git\s+diff\s+--check\b/i.test(command)) return 'VERIFY FAILED: diff cleanliness check failed.';
+  if (/^git\s+diff\s+--check\b/i.test(command)) return 'VERIFY FAILED: diff cleanliness check failed. Trailing whitespace in markdown is auto-fixable: npm run audit:markdown-whitespace -- --fix';
   if (/\bnode\s+--test\b/i.test(command)) return 'VERIFY FAILED: behavior checks failed.';
   return `VERIFY FAILED: ${command}.`;
 }
@@ -1755,7 +1738,8 @@ function missionVerifierHighLevelTestText(verifierResult, mission) {
   }
   const outcome = verifierResult.passed ? 'passed' : 'failed';
   if (/^git\s+diff\s+--check\b/i.test(command)) {
-    return `Diff cleanliness check ${outcome}: no whitespace or patch-format issues in the changed files.`;
+    if (verifierResult.passed) return `Diff cleanliness check passed: no whitespace or patch-format issues in the changed files.`;
+    return `Diff cleanliness check ${outcome}: whitespace or patch-format issues in the changed files. Trailing whitespace in markdown is auto-fixable: npm run audit:markdown-whitespace -- --fix`;
   }
   if (/\bnode\s+--test\b/i.test(command) && /\btest\/mission-status\.test\.js\b/i.test(command)) {
     return `Mission behavior checks ${outcome}: mission start, tick, completion, timeline landing, goal-chain, next-mission, and human-accept boundaries were exercised.`;
@@ -2980,12 +2964,8 @@ function handledContinuationTargetKeys(root, moves) {
 
 function readTaskProjectionForMission(root = process.cwd()) {
   const file = path.join(root, '.atris', 'state', 'tasks.projection.json');
-  try {
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-    return Array.isArray(parsed?.tasks) ? parsed.tasks : [];
-  } catch {
-    return [];
-  }
+  const parsed = readJson(file);
+  return Array.isArray(parsed?.tasks) ? parsed.tasks : [];
 }
 
 function taskTags(task) {
@@ -3367,8 +3347,7 @@ function readRecentTasteLogs(root, owner, limit = 3) {
 
 function readTasteReviewHistory(root, limit = 4) {
   const file = path.join(root, '.atris', 'state', 'tasks.projection.json');
-  let projection = null;
-  try { projection = JSON.parse(fs.readFileSync(file, 'utf8')); } catch { projection = null; }
+  const projection = readJson(file);
   const tasks = Array.isArray(projection?.tasks) ? projection.tasks : [];
   const accepted = [];
   const revised = [];
@@ -4738,11 +4717,7 @@ function statusMission(args) {
 function readMissionReceipt(receiptPath, root = process.cwd()) {
   if (!receiptPath) return null;
   const file = path.isAbsolute(receiptPath) ? receiptPath : path.join(root, receiptPath);
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {
-    return null;
-  }
+  return readJson(file);
 }
 
 function firstUsefulLine(text, fallback = '') {
@@ -4867,12 +4842,7 @@ function missionVerificationDebt(mission, root = process.cwd()) {
   let unchecked = 0;
   const seen = new Set();
   for (const file of files) {
-    let receipt = null;
-    try {
-      receipt = JSON.parse(fs.readFileSync(file, 'utf8'));
-    } catch {
-      continue;
-    }
+    const receipt = readJson(file);
     if (!receipt || receipt.mission_id !== mission.id) continue;
     for (const tick of missionReceiptTicks(receipt)) {
       if (!tick || tick.status !== 'ran') continue;
@@ -4909,12 +4879,7 @@ function missionReportTimeline(mission, root = process.cwd(), limit = 6) {
   const items = [];
   const seen = new Set();
   for (const file of files) {
-    let receipt = null;
-    try {
-      receipt = JSON.parse(fs.readFileSync(file, 'utf8'));
-    } catch {
-      continue;
-    }
+    const receipt = readJson(file);
     if (!receipt || receipt.mission_id !== mission.id) continue;
     const receiptPath = path.relative(root, file);
     for (const tick of missionReceiptTicks(receipt)) {
@@ -4957,12 +4922,7 @@ function missionLandingTimeline(mission, root = process.cwd(), limit = 12, { kin
   const items = [];
   const seen = new Set();
   for (const file of files) {
-    let receipt = null;
-    try {
-      receipt = JSON.parse(fs.readFileSync(file, 'utf8'));
-    } catch {
-      continue;
-    }
+    const receipt = readJson(file);
     if (!receipt || receipt.mission_id !== mission.id) continue;
     const receiptKind = receipt.result && receipt.result.kind ? String(receipt.result.kind) : (receipt.kind ? String(receipt.kind) : '');
     if (kindFilter && receiptKind !== kindFilter) continue;
@@ -5312,14 +5272,11 @@ function timelineMission(args) {
   const sinceFilter = readFlag(args, '--since', '') || null;
   const ref = stripKnownFlags(args, ['--limit', '--output', '--out', '--kind', '--since'], ['--json', '--write', '--all', '--prune-preview'])[0] || '';
   const limit = all ? Number.MAX_SAFE_INTEGER : readPositiveIntegerFlag(args, '--limit', 12, { json: asJson });
-  const missions = listMissions();
-  const mission = ref
-    ? resolveMission(ref)
-    : (missions.find((row) => !TERMINAL_STATUSES.has(row.status)) || missions[0] || null);
-  if (ref && !mission) {
+  const data = loadTimelineData(ref, { limit, kindFilter, sinceFilter, write, prunePreviewRequested, outputPath });
+  if (ref && !data.mission) {
     exitMissingMission(ref, 1, asJson);
   }
-  if (!mission) {
+  if (!data.mission) {
     printJsonOrText(
       {
         ok: true,
@@ -5333,8 +5290,40 @@ function timelineMission(args) {
     );
     return;
   }
+  const { payload, lines } = groupTimeline(data, { all, kindFilter, sinceFilter });
+  renderTimeline(payload, lines, asJson);
+}
+
+function loadTimelineData(ref, { limit, kindFilter, sinceFilter, write, prunePreviewRequested, outputPath }) {
+  const missions = listMissions();
+  const mission = ref
+    ? resolveMission(ref)
+    : (missions.find((row) => !TERMINAL_STATUSES.has(row.status)) || missions[0] || null);
+  if (!mission) return { mission: null };
   const root = mission.worktree_root || process.cwd();
   const timelineResult = missionLandingTimeline(mission, root, limit, { kind: kindFilter, since: sinceFilter });
+  const generatedAt = stampIso();
+  let artifactPath = null;
+  let prunePreview = null;
+  if (write || prunePreviewRequested) {
+    try {
+      prunePreview = pruneRuns(root, { keepNewest: 200, keepDays: 14 });
+    } catch (error) {
+      prunePreview = { error: error.message || String(error) };
+    }
+  }
+  if (write) {
+    const outPath = outputPath
+      ? path.resolve(root, outputPath)
+      : defaultMissionTimelinePath(root, mission);
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, missionTimelineMarkdown(mission, timelineResult.items, { prunePreview, generatedAt, timelineMeta: timelineResult.meta }), 'utf8');
+    artifactPath = path.relative(root, outPath);
+  }
+  return { mission, timelineResult, generatedAt, prunePreview, artifactPath };
+}
+
+function groupTimeline({ mission, timelineResult, generatedAt, prunePreview, artifactPath }, { all, kindFilter, sinceFilter }) {
   const timeline = timelineResult.items;
   const currentLanding = missionTimelineCurrentLanding(timeline);
   const timelineItemDisplay = (item) => ({
@@ -5363,24 +5352,6 @@ function timelineMission(args) {
     ...timelineItemDisplay(item),
   }));
   const nextMove = missionTimelineNextMove(mission, currentLanding);
-  const generatedAt = stampIso();
-  let artifactPath = null;
-  let prunePreview = null;
-  if (write || prunePreviewRequested) {
-    try {
-      prunePreview = pruneRuns(root, { keepNewest: 200, keepDays: 14 });
-    } catch (error) {
-      prunePreview = { error: error.message || String(error) };
-    }
-  }
-  if (write) {
-    const outPath = outputPath
-      ? path.resolve(root, outputPath)
-      : defaultMissionTimelinePath(root, mission);
-    fs.mkdirSync(path.dirname(outPath), { recursive: true });
-    fs.writeFileSync(outPath, missionTimelineMarkdown(mission, timeline, { prunePreview, generatedAt, timelineMeta: timelineResult.meta }), 'utf8');
-    artifactPath = path.relative(root, outPath);
-  }
   const pruneSummary = missionTimelinePruneSummaryObject(prunePreview);
   const pruneDisplay = {
     label: 'Prune preview',
@@ -5645,6 +5616,10 @@ function timelineMission(args) {
   if (artifactPath) lines.push(`Saved: ${artifactPath}`);
   const pruneLine = missionTimelinePruneSummaryLine(prunePreview);
   if (pruneLine) lines.push(pruneLine);
+  return { payload, lines };
+}
+
+function renderTimeline(payload, lines, asJson) {
   printJsonOrText(payload, lines, asJson);
 }
 
@@ -5814,8 +5789,8 @@ function watchMission(args) {
     return;
   }
   const ref = stripKnownFlags(args, ['--interval', '--idle-every'], [])[0] || '';
-  const intervalSeconds = Math.max(1, parseInt(readFlag(args, '--interval', '2'), 10) || 2);
-  const idleEverySeconds = Math.max(1, parseInt(readFlag(args, '--idle-every', '30'), 10) || 30);
+  const intervalSeconds = Math.max(1, readIntFlag(args, '--interval', 2) || 2);
+  const idleEverySeconds = Math.max(1, readIntFlag(args, '--idle-every', 30) || 30);
   const loadTargets = () => {
     if (ref) {
       const mission = resolveMission(ref);
@@ -6047,14 +6022,12 @@ function missionProtectedTags(mission, root = process.cwd()) {
     ...(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 {}
+  const projection = readJson(path.join(root, '.atris', 'state', 'tasks.projection.json'));
+  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);
+  }
   return tags;
 }
 
@@ -6118,18 +6091,13 @@ function captureMissionWorktreeBaseline(mission, root = process.cwd()) {
     dirty_hash: snapshot.dirty_hash,
     paths: Array.from(paths).sort(),
   };
-  fs.mkdirSync(path.dirname(baselineFile), { recursive: true });
-  fs.writeFileSync(baselineFile, JSON.stringify(baseline, null, 2) + '\n', 'utf8');
+  writeJson(baselineFile, baseline);
   return baseline;
 }
 
 function loadMissionWorktreeBaseline(missionId, root = process.cwd()) {
-  try {
-    const baseline = JSON.parse(fs.readFileSync(missionBaselinePath(missionId, root), 'utf8'));
-    return Array.isArray(baseline?.paths) ? baseline : null;
-  } catch {
-    return null;
-  }
+  const baseline = readJson(missionBaselinePath(missionId, root));
+  return Array.isArray(baseline?.paths) ? baseline : null;
 }
 
 // Closed missions no longer tick, so the sidecar is dead weight; prune it and
@@ -6208,6 +6176,12 @@ const MISSION_RUN_DEFAULTS = {
   backoff: { initialMs: 30_000, maxMs: 10 * 60_000, factor: 2, jitter: 0.3 },
 };
 
+// Clamp a remaining-wall timeout to [1, capMs]. Used by spawn plumbing so a
+// nearly-expired wall cannot schedule a zero or multi-hour child wait.
+function clampTimeoutMs(remainingMs, capMs = MISSION_RUN_DEFAULTS.claudeTimeoutMs) {
+  return Math.min(capMs, Math.max(1, Math.floor(remainingMs)));
+}
+
 // Claude sessions accumulate context across resumed ticks; an always-on
 // mission would grow without bound. Continuity lives on disk (receipts, logs,
 // now.md), so a healthy session is disposable: rotate to a fresh one every N
@@ -6217,6 +6191,25 @@ const CLAUDE_SESSION_CONTEXT_ROTATE_TICKS = Math.max(
   Number(process.env.ATRIS_CLAUDE_SESSION_ROTATE_TICKS) || 8,
 );
 
+// A mission that sits in a protected lane must not tick unattended: the
+// worker lands its own diffs, so the only safe moment to stop a wrong one is
+// before the tick fires. Same tag-plus-text routing the task lane uses
+// (CLI-1189). An operator override is explicit: protected_lane_ack in the
+// mission metadata, set by a human, or ATRIS_ALLOW_PROTECTED_MISSION=1.
+function missionProtectedLaneHold(mission) {
+  if (process.env.ATRIS_ALLOW_PROTECTED_MISSION === '1') return null;
+  if (mission?.metadata?.protected_lane_ack) return null;
+  const { DENIED_TAGS } = require('../lib/fleet');
+  const { declaredProtectedLane, sniffedProtectedLane } = require('../lib/auto-accept-certified');
+  const lane = String(mission?.lane || '').toLowerCase();
+  if (DENIED_TAGS.includes(lane)) return { pause_reason: `protected-lane-${lane}` };
+  const probe = { title: mission?.objective, objective: mission?.stop_condition, metadata: mission?.metadata || {} };
+  if (declaredProtectedLane(probe)) return { pause_reason: 'protected-lane-declared' };
+  const sniffed = sniffedProtectedLane(probe);
+  if (sniffed) return { pause_reason: `protected-lane-${sniffed.lane}` };
+  return null;
+}
+
 function runnerUsesCallerSession(runner) {
   return new Set(['codex_goal', 'caller_session', 'current_agent']).has(String(runner || '').trim().toLowerCase());
 }
@@ -6339,8 +6332,7 @@ function missionHeartbeatLines(mission, now = new Date()) {
 }
 
 function missionHasHumanAsks(mission) {
-  return Array.isArray(mission?.human_asks)
-    && mission.human_asks.some((ask) => String(ask || '').trim());
+  return openHumanAsks(mission?.human_asks).length > 0;
 }
 
 function missionTaskHumanAcceptWaiting(mission) {
@@ -6427,7 +6419,10 @@ function missionSelectableForCodexGoal(mission, now = new Date()) {
 function selectCodexGoalMission(root = process.cwd(), options = {}, now = new Date()) {
   const requestedId = String(options.missionId || '').trim();
   const candidates = listMissions(root)
-    .filter((mission) => runnerUsesCallerSession(mission.runner))
+    // caller_session/current_agent missions run in this process, but they do
+    // not own the native Codex goal handshake. Keep selection aligned with
+    // ackMissionGoal(), which intentionally accepts only codex_goal runners.
+    .filter((mission) => isCodexGoalMission(mission))
     .filter((mission) => missionSelectableForCodexGoal(mission, now));
   if (requestedId) {
     const exact = candidates.find((mission) => missionMatchesRef(mission, requestedId));
@@ -6442,10 +6437,6 @@ function selectCodexGoalMission(root = process.cwd(), options = {}, now = new Da
     const bRank = missionGoalSelectionRank(b);
     if (aRank !== bRank) return aRank - bRank;
 
-    const aCaller = runnerUsesCallerSession(a.runner) ? 1 : 0;
-    const bCaller = runnerUsesCallerSession(b.runner) ? 1 : 0;
-    if (aCaller !== bCaller) return bCaller - aCaller;
-
     const aVerifier = effectiveMissionVerifier(a) ? 1 : 0;
     const bVerifier = effectiveMissionVerifier(b) ? 1 : 0;
     if (aVerifier !== bVerifier) return bVerifier - aVerifier;
@@ -6738,19 +6729,13 @@ function writeDirectRunCodexGoalRequest(mission, root = process.cwd()) {
     requested_at: stampIso(),
   };
   const paths = statePaths(root);
-  fs.mkdirSync(path.dirname(paths.codexGoalRequestJson), { recursive: true });
-  fs.writeFileSync(paths.codexGoalRequestJson, JSON.stringify(request, null, 2) + '\n', 'utf8');
+  writeJson(paths.codexGoalRequestJson, request);
   return request;
 }
 
 function readDirectRunCodexGoalRequest(root = process.cwd(), now = new Date()) {
   const file = statePaths(root).codexGoalRequestJson;
-  let request = null;
-  try {
-    request = JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {
-    return null;
-  }
+  const request = readJson(file);
   const missionId = String(request?.mission_id || '').trim();
   if (!missionId) return null;
   const mission = resolveMission(missionId, root);
@@ -6761,13 +6746,9 @@ function readDirectRunCodexGoalRequest(root = process.cwd(), now = new Date()) {
 
 function clearDirectRunCodexGoalRequestForMission(missionId, root = process.cwd()) {
   const file = statePaths(root).codexGoalRequestJson;
-  let request = null;
-  try {
-    request = JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {
-    return false;
-  }
-  if (String(request?.mission_id || '') !== String(missionId || '')) return false;
+  const request = readJson(file);
+  if (!request) return false;
+  if (String(request.mission_id || '') !== String(missionId || '')) return false;
   try {
     fs.rmSync(file, { force: true });
     return true;
@@ -7085,8 +7066,7 @@ function writeCodexGoalState(payload, root = process.cwd()) {
     updated_at: stampIso(),
     ...payload,
   };
-  fs.mkdirSync(path.dirname(paths.codexGoalJson), { recursive: true });
-  fs.writeFileSync(paths.codexGoalJson, JSON.stringify(state, null, 2) + '\n', 'utf8');
+  writeJson(paths.codexGoalJson, state);
 
   const lines = [
     '# Codex Goal Controller',
@@ -7357,8 +7337,7 @@ function writeAtrisGoalState(payload, root = process.cwd()) {
     updated_at: stampIso(),
     ...payload,
   };
-  fs.mkdirSync(path.dirname(paths.atrisGoalJson), { recursive: true });
-  fs.writeFileSync(paths.atrisGoalJson, JSON.stringify(state, null, 2) + '\n', 'utf8');
+  writeJson(paths.atrisGoalJson, state);
 
   const lines = [
     '# Atris Goal Controller',
@@ -7600,8 +7579,37 @@ function missionJudgmentTopic(mission) {
   return plain.split(/\s+/).filter(Boolean).slice(0, 14).join(' ');
 }
 
+// Words that leave a title hanging mid-thought when they land at the end:
+// articles, prepositions, conjunctions, subordinators, and auxiliary/linking
+// verbs. A hard 8-word slice of an objective often stops on one of these
+// ("...runner away from", "...say work is"), which reads as a truncation bug.
+const DANGLING_TAIL_WORDS = new Set([
+  'a', 'an', 'the',
+  'of', 'to', 'in', 'on', 'at', 'for', 'from', 'with', 'by', 'into', 'onto',
+  'over', 'under', 'about', 'after', 'before', 'between', 'through', 'during',
+  'without', 'within', 'away', 'up', 'off', 'out',
+  'and', 'or', 'but', 'nor', 'so', 'yet', 'when', 'while', 'if', 'that',
+  'which', 'because', 'although', 'though', 'since', 'whether', 'as',
+  'is', 'are', 'was', 'were', 'be', 'been', 'being', 'am', 'has', 'have',
+  'had', 'do', 'does', 'did', 'will', 'would', 'shall', 'should', 'can',
+  'could', 'may', 'might', 'must',
+]);
+
+// Drop trailing function words so the title ends where a thought ends, never
+// on a preposition or auxiliary. Falls back to the raw slice if trimming would
+// empty the title.
+function trimDanglingTail(words) {
+  const trimmed = [...words];
+  while (trimmed.length > 1 && DANGLING_TAIL_WORDS.has(trimmed[trimmed.length - 1].toLowerCase())) {
+    trimmed.pop();
+  }
+  return trimmed.length ? trimmed : words;
+}
+
 function missionJudgmentTitle(mission) {
-  const words = missionJudgmentTopic(mission).split(/\s+/).filter(Boolean).slice(0, 8);
+  const words = trimDanglingTail(
+    missionJudgmentTopic(mission).split(/\s+/).filter(Boolean).slice(0, 8),
+  );
   const title = words.join(' ') || 'Mission needs a new direction';
   return title.charAt(0).toUpperCase() + title.slice(1);
 }
@@ -7766,12 +7774,11 @@ function missionDriverPaths(mission, root = process.cwd()) {
 }
 
 function readMissionDriverState(stateFile) {
-  try { return JSON.parse(fs.readFileSync(stateFile, 'utf8')) || {}; } catch { return {}; }
+  return readJson(stateFile, {}) || {};
 }
 
 function writeMissionDriverState(stateFile, state) {
-  fs.mkdirSync(path.dirname(stateFile), { recursive: true });
-  fs.writeFileSync(stateFile, JSON.stringify(state, null, 2) + '\n', 'utf8');
+  writeJson(stateFile, state);
 }
 
 function missionDriverError(error) {
@@ -7864,10 +7871,8 @@ function installDetachedMissionDriverLifecycle(mission, root = process.cwd()) {
 
 function missionDriverHealth(mission, root = process.cwd()) {
   const paths = missionDriverPaths(mission, root);
-  let driverState = null;
-  let lockState = null;
-  try { driverState = JSON.parse(fs.readFileSync(paths.stateFile, 'utf8')); } catch {}
-  try { lockState = JSON.parse(fs.readFileSync(paths.lockFile, 'utf8')); } catch {}
+  const driverState = readJson(paths.stateFile);
+  const lockState = readJson(paths.lockFile);
   const candidates = [
     driverState ? { ...driverState, source: 'driver_state' } : null,
     lockState ? { ...lockState, source: 'mission_lock' } : null,
@@ -7902,8 +7907,7 @@ function acquireMissionLock(missionId, root = process.cwd(), options = {}) {
       return { ok: true, lockFile, fd, missionId, driverPid: process.pid, startedAt, recordLength: record.length };
     } catch (e) {
       if (e.code === 'EEXIST') {
-        let info = {};
-        try { info = JSON.parse(fs.readFileSync(lockFile, 'utf8') || '{}'); } catch {}
+        const info = readJson(lockFile, {}) || {};
         const holderPid = Number(info.pid);
         const holderKnown = Number.isInteger(holderPid) && holderPid > 0;
         // A lock is created empty (openSync 'wx') and its pid record is written a
@@ -8184,8 +8188,9 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = []) {
   if (mission.task_ids?.length) {
     lines.push('', `## Task ids`, mission.task_ids.map((t) => `- ${t}`).join('\n'));
   }
-  if (mission.human_asks?.length) {
-    lines.push('', `## Human asks (don't act on these — surface them)`, mission.human_asks.map((t) => `- ${t}`).join('\n'));
+  const humanAsks = openHumanAsks(mission.human_asks);
+  if (humanAsks.length) {
+    lines.push('', `## Human asks (don't act on these — surface them)`, humanAsks.map((ask) => `- ${ask.text}`).join('\n'));
   }
   return lines.join('\n');
 }
@@ -8761,16 +8766,28 @@ function cappedClaudeReceiptText(text, limit = 4000) {
   return clean.slice(0, limit - 16).trimEnd() + '\n...[truncated]';
 }
 
-async function runMission(args) {
+async function parseAndValidateMissionRunPhase(args) {
   const asJson = wantsJson(args);
+  const context = {
+    args,
+    asJson,
+    cwd: process.cwd(),
+    handled: false,
+    returnValue: undefined,
+    lock: null,
+    error: null,
+  };
   if (hasFlag(args, '--help') || hasFlag(args, '-h')) {
     help();
-    return;
+    context.handled = true;
+    return context;
   }
   if (hasFlag(args, '--cloud')) {
     const result = await runCloudMissionCommand(args);
     process.exitCode = result.exitCode;
-    return result;
+    context.handled = true;
+    context.returnValue = result;
+    return context;
   }
   // --fleet: staff every idle capable engine on the board's claimable
   // safe-lane tasks, build in parallel worktrees, land serially. Humble flag,
@@ -8789,7 +8806,8 @@ async function runMission(args) {
     });
     if (asJson) console.log(JSON.stringify(flight, null, 2));
     process.exitCode = flight.paused && flight.paused.length > 0 ? 1 : 0;
-    return;
+    context.handled = true;
+    return context;
   }
   const dueMode = hasFlag(args, '--due');
   const headlessOnly = hasFlag(args, '--headless');
@@ -8825,22 +8843,70 @@ async function runMission(args) {
   const ref = input.ref;
   const runArgs = input.args;
 
+  Object.assign(context, {
+    dueMode,
+    headlessOnly,
+    selfDrive,
+    skipClaude,
+    verifyEach,
+    completeOnPass,
+    skipDrain,
+    createNext,
+    budgetTier,
+    maxTicksFlag,
+    maxTicks,
+    maxWallFlag,
+    explicitMaxWallSeconds,
+    runBudgetContract,
+    maxWallSeconds,
+    cadenceOverride,
+    runnerOverride,
+    modelOverride,
+    runtimeView,
+    input,
+    ref,
+    runArgs,
+  });
+  return context;
+}
+
+async function resolveMissionRunPhase(context) {
+  const {
+    args,
+    asJson,
+    cwd,
+    dueMode,
+    headlessOnly,
+    budgetTier,
+    maxTicksFlag,
+    maxWallFlag,
+    explicitMaxWallSeconds,
+    runBudgetContract,
+    runtimeView,
+    input,
+    ref,
+    runArgs,
+  } = context;
+  let { maxTicks, maxWallSeconds } = context;
+
   if (!dueMode && !ref) {
     if (asJson || !process.stdin.isTTY || !process.stderr.isTTY) {
       missionRunInputRequired(asJson, input.owner);
     }
     const prompted = await promptMissionRunInput(runArgs);
     await startMissionFromRunObjective(prompted.objective, prompted.args);
+    context.handled = true;
     return;
   }
 
-  let mission = dueMode && !ref ? selectDueMission(process.cwd(), new Date(), { headlessOnly }) : resolveMission(ref);
+  let mission = dueMode && !ref ? selectDueMission(cwd, new Date(), { headlessOnly }) : resolveMission(ref, cwd);
   if (!mission && dueMode && !ref) {
     printJsonOrText(
       { ok: true, action: 'run_skipped', reason: 'no_due_mission', mission: null },
       ['No due mission found.'],
       asJson,
     );
+    context.handled = true;
     return;
   }
   // BCK-1319: a bare single token that looks like an id/suffix/number (no
@@ -8854,6 +8920,7 @@ async function runMission(args) {
   }
   if (!mission && ref) {
     await startMissionFromRunObjective(ref, runArgs);
+    context.handled = true;
     return;
   }
   if (!mission) {
@@ -8867,7 +8934,8 @@ async function runMission(args) {
   } else if (!maxWallFlag && Number(mission.budget_contract?.requested_seconds) > 0) {
     maxWallSeconds = Math.max(60, Number(mission.budget_contract.requested_seconds));
   }
-  const detachedDriverLifecycle = installDetachedMissionDriverLifecycle(mission, process.cwd());
+  const detachedDriverLifecycle = installDetachedMissionDriverLifecycle(mission, cwd);
+  context.detachedDriverLifecycle = detachedDriverLifecycle;
   if (['complete', 'stopped'].includes(mission.status)) {
     detachedDriverLifecycle?.setExitReason(mission.status);
     if (asJson) {
@@ -8876,18 +8944,20 @@ async function runMission(args) {
         [],
         true,
       );
+      context.handled = true;
       return;
     }
     console.error(`Mission ${mission.id} is ${mission.status}; nothing to run.`);
     process.exit(0);
   }
   if (hasFlag(args, '--detach')) {
-    detachMissionRun(args, mission, process.cwd(), asJson);
+    detachMissionRun(args, mission, cwd, asJson);
+    context.handled = true;
     return;
   }
 
   const nativeGoalRunOptions = codexNativeGoalOptionsFromArgs(args);
-  const autoAck = maybeAutoAckCodexNativeGoal(mission, process.cwd(), nativeGoalRunOptions);
+  const autoAck = maybeAutoAckCodexNativeGoal(mission, cwd, nativeGoalRunOptions);
   if (autoAck) mission = autoAck.saved;
   maybeBlockUntilCodexNativeGoalStarted(runtimeView(mission), asJson, nativeGoalRunOptions);
 
@@ -8896,37 +8966,63 @@ async function runMission(args) {
   // (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);
+  const lock = acquireMissionLock(mission.id, cwd);
   if (!lock.ok) {
     exitMissionError(`another driver is already running mission ${mission.id} (pid ${lock.holder?.pid || '?'})`, 3, asJson);
   }
 
-  // Everything past lock acquisition runs inside try/finally so the lock + signal handlers
-  // always get cleaned up — including saveMission failures during pending-session setup.
-  let pauseReason = null;
-  let sessionId = null;
-  let pendingSessionId = null;
-  let ranTicks = 0;
-  const ticks = [];
-  let onSig = null;
-  let restoreRunnerProfile = null;
-  let blocker = null;
+  Object.assign(context, {
+    mission,
+    maxTicks,
+    maxWallSeconds,
+    nativeGoalRunOptions,
+    lock,
+    pauseReason: null,
+    sessionId: null,
+    pendingSessionId: null,
+    ranTicks: 0,
+    ticks: [],
+    onSig: null,
+    restoreRunnerProfile: null,
+    blocker: null,
+  });
+}
 
-  try {
-    const cwd = process.cwd();
+async function executeMissionRunTicksPhase(context) {
+    const {
+      asJson,
+      cwd,
+      explicitMaxWallSeconds,
+      runBudgetContract,
+      runtimeView,
+      runnerOverride,
+      skipClaude,
+      verifyEach,
+      completeOnPass,
+      skipDrain,
+      maxTicksFlag,
+      budgetTier,
+      cadenceOverride,
+      detachedDriverLifecycle,
+      lock,
+      nativeGoalRunOptions,
+    } = context;
+    let { mission, maxTicks, maxWallSeconds, pauseReason, sessionId, pendingSessionId, ranTicks } = context;
+    const ticks = context.ticks;
     const controller = new AbortController();
-    onSig = (signal) => {
+    context.controller = controller;
+    context.onSig = (signal) => {
       detachedDriverLifecycle?.setExitReason(`signal-${String(signal || 'abort').toLowerCase()}`);
       controller.abort();
     };
-    process.on('SIGINT', onSig);
-    process.on('SIGTERM', onSig);
+    process.on('SIGINT', context.onSig);
+    process.on('SIGTERM', context.onSig);
 
     // Re-read inside the lock. The initial resolveMission ran pre-lock, so a concurrent
     // `mission tick` could have written between resolveMission and acquireMissionLock.
     // 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;
+    mission = resolveMission(mission.id, cwd) || mission;
     if (explicitMaxWallSeconds && runBudgetContract) {
       mission = saveMission({
         ...mission,
@@ -8941,10 +9037,12 @@ async function runMission(args) {
     if (['complete', 'stopped'].includes(mission.status)) {
       detachedDriverLifecycle?.setExitReason(mission.status);
       console.error(`Mission ${mission.id} is ${mission.status}; nothing to run.`);
+      context.handled = true;
       return;
     }
     if (returnIfCodexNativeGoalNotStarted(runtimeMission, asJson, nativeGoalRunOptions)) {
       detachedDriverLifecycle?.setExitReason('native-goal-not-started');
+      context.handled = true;
       return;
     }
     if (mission.status === 'paused') {
@@ -8961,7 +9059,7 @@ async function runMission(args) {
     sessionId = mission.claude_session_id || null;
     pendingSessionId = mission.pending_session_id || null;
     const autoRunner = String(runtimeMission.runner || '').trim().toLowerCase() === MISSION_AUTO_RUNNER;
-    restoreRunnerProfile = autoRunner ? () => {} : applyMissionRunnerProfile(runtimeMission.runner);
+    context.restoreRunnerProfile = autoRunner ? () => {} : applyMissionRunnerProfile(runtimeMission.runner);
     const callerSessionRunner = runnerUsesCallerSession(runtimeMission.runner);
     const runnerName = String(runtimeMission.runner || '').trim().toLowerCase();
     const atris2Runner = runnerName === 'atris2';
@@ -9028,7 +9126,7 @@ async function runMission(args) {
         // Re-read before measuring the wall. Detached full-budget drivers use
         // the mission contract as their wall so process startup drift cannot
         // shorten the promised work window.
-        mission = resolveMission(mission.id) || mission;
+        mission = resolveMission(mission.id, cwd) || mission;
         runtimeMission = runtimeView(mission);
         const contractualRemaining = detachedDriverLifecycle && mission.always_on && missionSpendsFullBudget(mission)
           ? missionFullBudgetRemainingSeconds(mission)
@@ -9045,6 +9143,8 @@ async function runMission(args) {
       if (['complete', 'stopped', 'paused'].includes(mission.status)) { pauseReason = mission.status; break; }
       if (effectiveMissionVerifier(mission) !== storedVerifier) { pauseReason = 'verifier-mutated'; break; }
       if ((mission.lane || 'workspace') !== frozen.lane) { pauseReason = 'lane-mutated'; break; }
+      const protectedHold = missionProtectedLaneHold(mission);
+      if (protectedHold) { pauseReason = protectedHold.pause_reason; break; }
 
       const tickIdx = Number(mission.last_tick_index || 0) + 1;
       const tickStart = stampIso();
@@ -9195,9 +9295,9 @@ async function runMission(args) {
         const runClaudeSession = () => spawnClaudeTick(tickRuntimeMission, {
           sessionMode, sessionId: useId, cwd, signal: controller.signal,
           missionLock: lock,
-          timeoutMs: Math.min(
+          timeoutMs: clampTimeoutMs(
+            (maxWallSeconds - ((Date.now() - startedAt) / 1000)) * 1000,
             MISSION_RUN_DEFAULTS.claudeTimeoutMs,
-            Math.max(1, Math.floor((maxWallSeconds - ((Date.now() - startedAt) / 1000)) * 1000)),
           ),
           prompt,
           model: resolveClaudeRunnerModel(tickRuntimeMission),
@@ -9304,39 +9404,22 @@ async function runMission(args) {
         if (engineHealth) result.engine_health = engineHealth.health;
       }
 
-      // An explicit verifier is safe and useful in no-worker mode. The
-      // fallback engine verifier is itself worker activity, so --no-claude
-      // 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;
+      context.pauseReason = pauseReason;
+      context.currentTick = {
+        mission,
+        result,
+        tickWorktreeBefore,
+        tickRuntimeMission,
+        tickSkipWorker,
+        tickIdx,
+        frozen,
+      };
+      await verifyMissionRunTickPhase(context);
+      result = context.currentTick.result;
+      const verifierResult = context.currentTick.verifierResult;
+      pauseReason = context.pauseReason;
+      context.currentTick = null;
       let receiptPath = null;
-      if (result.status === 'ran' && verifyEach) {
-        if (frozen.verifier) {
-          verifierResult = runVerifier(frozen.verifier);
-        } else if (!tickSkipWorker) {
-          verifierResult = await runEngineVerifier(tickRuntimeMission, {
-            cwd,
-            signal: controller.signal,
-            tickIndex: tickIdx,
-          });
-        }
-        if (verifierResult) result.verifier_passed = verifierResult.passed;
-      }
-      stampMissionRunnerBrief(cwd, result.claude?.brief_id, result, verifierResult);
 
       // Review-lane drain: always-on loops sweep the agent-safe review actions
       // each tick so proof-backed work reaches certified on cadence with zero
@@ -9477,7 +9560,7 @@ async function runMission(args) {
         break;
       }
 
-      if (pauseReason === 'protected-lane-review') break;
+      if (['mission-diff-unreadable', 'protected-lane-review'].includes(pauseReason)) 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
@@ -9525,7 +9608,7 @@ async function runMission(args) {
         if (lastTick && lastTick.status !== 'ran' && !missionRunKeepsRetryingError(lastTick.reason)) pauseReason = 'max-ticks-reached';
       }
 
-      mission = resolveMission(mission.id) || mission;
+      mission = resolveMission(mission.id, cwd) || mission;
       const remainingBudgetSeconds = missionFullBudgetRemainingSeconds(mission);
       const explicitExit = ['complete', 'stopped', 'paused'].includes(String(mission.status || ''));
       const healthyCycleBoundary = !pauseReason || pauseReason === 'max-ticks-reached';
@@ -9557,6 +9640,97 @@ async function runMission(args) {
       cycleTickLimit = ticks.length + effectiveMaxTicks;
     }
 
+    Object.assign(context, {
+      mission,
+      pauseReason,
+      sessionId,
+      pendingSessionId,
+      ranTicks,
+      frozen,
+      runWorktreeBefore,
+      runWorktreeBaseline,
+      effectiveMaxTicks,
+      startedAt,
+      continuationGoal,
+      runtimeMission,
+    });
+}
+
+async function verifyMissionRunTickPhase(context) {
+  const { cwd, verifyEach, controller, currentTick } = context;
+  let { result } = currentTick;
+
+  // An explicit verifier is safe and useful in no-worker mode. The fallback
+  // engine verifier is worker activity, so no-worker ticks must not launch it.
+  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(currentTick.mission, currentTick.tickWorktreeBefore, cwd);
+    result.protected_lane_guard = protectedLaneGuard;
+    if (!protectedLaneGuard.allowed) {
+      const guardPauseReason = protectedLaneGuard.unreadable
+        ? 'mission-diff-unreadable'
+        : 'protected-lane-review';
+      result.status = protectedLaneGuard.status;
+      result.reason = guardPauseReason;
+      result.ran = false;
+      context.pauseReason = guardPauseReason;
+    }
+  }
+
+  let verifierResult = null;
+  if (result.status === 'ran' && verifyEach) {
+    if (currentTick.frozen.verifier) {
+      verifierResult = runVerifier(currentTick.frozen.verifier);
+    } else if (!currentTick.tickSkipWorker) {
+      verifierResult = await runEngineVerifier(currentTick.tickRuntimeMission, {
+        cwd,
+        signal: controller.signal,
+        tickIndex: currentTick.tickIdx,
+      });
+    }
+    if (verifierResult) result.verifier_passed = verifierResult.passed;
+  }
+  stampMissionRunnerBrief(cwd, result.claude?.brief_id, result, verifierResult);
+  currentTick.result = result;
+  currentTick.verifierResult = verifierResult;
+}
+
+function completeMissionRunPhase(context) {
+  const {
+    asJson,
+    cwd,
+    selfDrive,
+    createNext,
+    runtimeView,
+    runnerOverride,
+    runBudgetContract,
+    detachedDriverLifecycle,
+    lock,
+    frozen,
+    runWorktreeBefore,
+    runWorktreeBaseline,
+    effectiveMaxTicks,
+    startedAt,
+  } = context;
+  const ticks = context.ticks || [];
+  let {
+    mission,
+    pauseReason,
+    ranTicks,
+    sessionId,
+    blocker,
+    continuationGoal,
+  } = context;
+
+  try {
+    if (context.error) {
+      detachedDriverLifecycle?.finish('run-error', context.error);
+      return;
+    }
+    if (context.handled) return;
+
     // BCK-1324: no-progress is a clean, honest stop — the run did what it
     // could and correctly recognized there was nothing left to do. It is NOT
     // a failure/blocker: pausing it (resumable, retried by cron/self-drive)
@@ -9670,18 +9844,35 @@ async function runMission(args) {
     detachedDriverLifecycle?.finish('run-error', error);
     throw error;
   } finally {
-    if (onSig) {
-      try { process.removeListener('SIGINT', onSig); } catch {}
-      try { process.removeListener('SIGTERM', onSig); } catch {}
+    if (context.onSig) {
+      try { process.removeListener('SIGINT', context.onSig); } catch {}
+      try { process.removeListener('SIGTERM', context.onSig); } catch {}
     }
-    if (restoreRunnerProfile) {
-      try { restoreRunnerProfile(); } catch {}
+    if (context.restoreRunnerProfile) {
+      try { context.restoreRunnerProfile(); } catch {}
     }
     releaseMissionLock(lock);
     detachedDriverLifecycle?.finish();
   }
 }
 
+async function runMission(args) {
+  const context = await parseAndValidateMissionRunPhase(args);
+  if (context.handled) return context.returnValue;
+
+  try {
+    await resolveMissionRunPhase(context);
+    if (!context.handled) await executeMissionRunTicksPhase(context);
+  } catch (error) {
+    context.error = error;
+    throw error;
+  } finally {
+    if (context.lock) completeMissionRunPhase(context);
+  }
+
+  return context.returnValue;
+}
+
 function tickMission(args) {
   const asJson = wantsJson(args);
   if (hasFlag(args, '--help') || hasFlag(args, '-h') || String(args[0] || '').trim() === 'help') {
@@ -9765,9 +9956,12 @@ function tickMission(args) {
     // Same layer classification as the run-tick path; manual ticks carry their
     // receipt text in --summary.
     const layerInfo = extractLayerFromReceiptText(summary || '', tickWorktree?.new_since_baseline_sample);
+    const guardPauseReason = protectedLaneGuard.unreadable
+      ? 'mission-diff-unreadable'
+      : 'protected-lane-review';
     const tickRecord = {
-      status: protectedLaneGuard.allowed ? 'ran' : 'paused-for-review',
-      reason: protectedLaneGuard.allowed ? 'tick-recorded' : 'protected-lane-review',
+      status: protectedLaneGuard.allowed ? 'ran' : protectedLaneGuard.status,
+      reason: protectedLaneGuard.allowed ? 'tick-recorded' : guardPauseReason,
       tick_index: tickIdx,
       ran: protectedLaneGuard.allowed,
       started_at: tickStart,
@@ -9803,7 +9997,9 @@ function tickMission(args) {
 	    const nextGoalChain = advanceMissionGoalChain(mission.goal_chain, summary, verifierResult);
 	    if (!protectedLaneGuard.allowed) {
 	      status = 'paused';
-	      nextAction = `review the protected diff and receipt before resuming: atris mission run ${mission.id}`;
+	      nextAction = protectedLaneGuard.unreadable
+	        ? `repair the mission diff tooling failure, then rerun: atris mission run ${mission.id}`
+	        : `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);
@@ -9892,12 +10088,8 @@ function tickMission(args) {
 // (free text, command strings, missing paths) reads as null and falls back
 // to durable mission state.
 function readReceiptProof(proof, root = process.cwd()) {
-  try {
-    const parsed = JSON.parse(fs.readFileSync(path.resolve(root, String(proof || '')), 'utf8'));
-    return parsed?.schema === 'atris.mission_receipt.v1' ? parsed : null;
-  } catch {
-    return null;
-  }
+  const parsed = readJson(path.resolve(root, String(proof || '')));
+  return parsed?.schema === 'atris.mission_receipt.v1' ? parsed : null;
 }
 
 function receiptShowsPass(receipt) {
@@ -10599,12 +10791,7 @@ function layersMission(args) {
   }
   for (const file of files) {
     if (missionFilter && !file.includes(missionFilter)) continue;
-    let receipt;
-    try {
-      receipt = JSON.parse(fs.readFileSync(path.join(paths.runsDir, file), 'utf8'));
-    } catch {
-      continue;
-    }
+    const receipt = readJson(path.join(paths.runsDir, file));
     if (sinceMs != null) {
       const atMs = Date.parse(receipt && receipt.at);
       if (Number.isNaN(atMs) || atMs < sinceMs) continue;
@@ -10807,6 +10994,36 @@ function pingMission(args, opts = {}) {
   return saved;
 }
 
+function answerMissionHumanAsk(ref, askIndex, answer, note = '') {
+  const found = findMissionAcrossWorktrees(ref);
+  if (!found) throw new Error(`mission not found: ${ref}`);
+  const { mission, root } = found;
+  const humanAsks = normalizeHumanAsks(mission.human_asks);
+  const ask = humanAsks[askIndex];
+  if (!ask || !ask.text.trim()) throw new Error(`human ask not found at index ${askIndex}`);
+  if (ask.answered_at) throw new Error('human ask is already answered');
+  const normalizedAnswer = String(answer || '').toLowerCase();
+  if (!['yes', 'no'].includes(normalizedAnswer)) throw new Error('human ask answer must be yes or no');
+  const answeredAt = stampIso();
+  humanAsks[askIndex] = {
+    ...ask,
+    answered_at: answeredAt,
+    answer: normalizedAnswer,
+    note: String(note || '').trim(),
+  };
+  return saveMission(
+    { ...mission, human_asks: humanAsks },
+    root,
+    'mission_human_ask_answered',
+    {
+      ask_index: askIndex,
+      text: ask.text.slice(0, 200),
+      answer: normalizedAnswer,
+      note: String(note || '').trim(),
+    },
+  ).mission;
+}
+
 function missionCommand(args) {
   const subcommand = args[0] || 'status';
   const rest = args.slice(1);
@@ -10915,6 +11132,7 @@ function missionCommand(args) {
 }
 
 module.exports = {
+  missionProtectedLaneHold,
   missionCommand,
   startMission,
   spawnMissionDriver,
@@ -10931,6 +11149,7 @@ module.exports = {
   findActiveTwinMission,
   TWIN_ACTIVE_STATUSES,
   pingMission,
+  answerMissionHumanAsk,
   buildTickPrompt,
   extractCheckFeedback,
   loadMissionMap,