atris 3.31.0 → 3.33.3

package/commands/mission.js

@@ -29,6 +29,16 @@ const {
   runsPruneLines,
   formatBytes,
 } = require('../lib/runs-prune');
+const { operatorReady, hasAgentJargon } = require('./autoland');
+const {
+  MISSION_INSPECT_FIELDS,
+  readFieldsFlag,
+  stripInspectArgs,
+  validateFields,
+  missionInspectFieldValues,
+  inspectTextLines,
+  buildInspectPayload,
+} = require('../lib/inspect-fields');
 
 const VALID_STATUSES = new Set(['planning', 'running', 'ready', 'paused', 'blocked', 'stopped', 'complete']);
 const TERMINAL_STATUSES = new Set(['stopped', 'complete']);
@@ -90,6 +100,28 @@ function exitMissionError(message, code = 1, asJson = false) {
   process.exit(code);
 }
 
+// Write-time warnings judge only what a machine can truly judge: identifiers,
+// flags, and task ids. Whether a why is present is a judgment call — the tick
+// prompt demands it, the review pass judges it. A warning that cries wolf on
+// plain sentences teaches agents to ignore it (golden-path papercut). The
+// strict operatorReady bar stays at the digest surface, where under-showing
+// is cheap. Boundary pinned by the marker-free fixture in mission-status tests.
+function warnIfSummaryNeedsOperatorWhy(summary) {
+  const text = String(summary || '').trim();
+  if (!text || !hasAgentJargon(text)) return null;
+  const warning = 'Warning: this tick summary contains flags, ids, or code identifiers. Rewrite it in words the operator can use; identifiers belong in the receipt body.';
+  console.error(warning);
+  return warning;
+}
+
+function warnIfTaskTitleNeedsOperatorWhy(title) {
+  const text = String(title || '').trim();
+  if (!text || !hasAgentJargon(text)) return null;
+  const warning = 'Warning: this task title contains flags, ids, or code identifiers. Rewrite it in words the operator can use; identifiers belong in the task body.';
+  console.error(warning);
+  return warning;
+}
+
 function readPositiveIntegerFlag(args, name, fallback = null, options = {}) {
   const raw = readFlag(args, name, '');
   if (!raw) return fallback;
@@ -171,6 +203,7 @@ function printJsonOrText(payload, lines, asJson) {
 }
 
 const MISSION_RUN_VALUE_FLAGS = [
+  '--slots',
   '--max-ticks',
   '--max-wall',
   '--minutes',
@@ -190,6 +223,8 @@ const MISSION_RUN_VALUE_FLAGS = [
 const MISSION_RUN_BOOLEAN_FLAGS = [
   '--json',
   '--due',
+  '--fleet',
+  '--dry-run',
   '--no-claude',
   '--no-verify',
   '--complete-on-pass',
@@ -204,6 +239,7 @@ const MISSION_RUN_BOOLEAN_FLAGS = [
   '--no-room-auto-run',
   '--allow-native-goal-supersede',
   '--supersede-paused-native-goal',
+  '--take-goal-slot',
   '--always-on',
   '--xp-task',
   '--agent-xp',
@@ -328,6 +364,7 @@ function createMissionXpTask(mission, root = process.cwd(), asJson = false) {
   const db = taskDb.open();
   const workspaceRoot = taskDb.workspaceRoot(root);
   const title = `Mission XP: ${mission.objective}`;
+  const operatorTitleWarning = warnIfTaskTitleNeedsOperatorWhy(title);
   const ownerResolution = resolveMissionOwner(mission, workspaceRoot);
   const owner = ownerResolution.owner;
   const metadata = {
@@ -371,6 +408,7 @@ function createMissionXpTask(mission, root = process.cwd(), asJson = false) {
     task_id: result.id,
     ref: missionTaskRef(task) || result.id,
     title,
+    operator_title_warning: operatorTitleWarning,
     status: task?.status || 'claimed',
     assigned_to: owner,
     owner_resolution: ownerResolution.reason,
@@ -499,10 +537,72 @@ function listWorktreeRollupMissions(root = process.cwd()) {
   return rolled;
 }
 
+function missionMatchesRef(mission, ref) {
+  return mission && (mission.id === ref || mission.id.startsWith(ref) || mission.slug === ref);
+}
+
+function listSiblingWorkspaceMissionHints(ref, root = process.cwd(), limit = 5) {
+  if (!ref) return [];
+  const baseRoot = path.resolve(root);
+  const parent = path.dirname(baseRoot);
+  let here = baseRoot;
+  try {
+    here = fs.realpathSync(baseRoot);
+  } catch { /* keep raw path */ }
+  let entries = [];
+  try {
+    entries = fs.readdirSync(parent, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const hints = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+    const candidateRoot = path.join(parent, entry.name);
+    let candidateReal = candidateRoot;
+    try {
+      candidateReal = fs.realpathSync(candidateRoot);
+    } catch {
+      continue;
+    }
+    if (candidateReal === here) continue;
+    if (!fs.existsSync(path.join(candidateRoot, '.atris', 'state', 'missions.jsonl'))) continue;
+    const mission = listMissions(candidateRoot).find((row) => missionMatchesRef(row, ref));
+    if (!mission) continue;
+    hints.push({
+      id: mission.id,
+      status: mission.status,
+      objective: mission.objective,
+      workspace_root: candidateRoot,
+      command: `cd ${shellQuote(candidateRoot)} && atris mission status ${mission.id}`,
+    });
+    if (hints.length >= limit) break;
+  }
+  return hints;
+}
+
+function exitMissingMission(ref, code = 1, asJson = false) {
+  const error = `Mission "${ref}" not found.`;
+  const hints = listSiblingWorkspaceMissionHints(ref);
+  if (asJson) {
+    const payload = { ok: false, error };
+    if (hints.length) payload.workspace_hint = hints[0];
+    if (hints.length > 1) payload.workspace_hints = hints;
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.error(error);
+    if (hints.length) {
+      console.error(`Workspace hint: mission ${hints[0].id} exists in ${hints[0].workspace_root}.`);
+      console.error(`Run: ${hints[0].command}`);
+    }
+  }
+  process.exit(code);
+}
+
 function resolveMission(ref, root = process.cwd()) {
   const missions = listMissions(root);
   if (!ref) return missions.find((mission) => !TERMINAL_STATUSES.has(mission.status)) || missions[0] || null;
-  return missions.find((mission) => mission.id === ref || mission.id.startsWith(ref) || mission.slug === ref) || null;
+  return missions.find((mission) => missionMatchesRef(mission, ref)) || null;
 }
 
 function missionMatchesStatusFilter(mission, statusFilter) {
@@ -1532,7 +1632,7 @@ 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']).join(' ').trim();
+  ], ['--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();
   if (!objective) {
     exitMissionError('Usage: atris mission start "<objective>" --owner <member> [--verify "..."] [--cadence manual] [--worktree]', 1, wantsJson(args));
   }
@@ -2008,7 +2108,51 @@ function normalizeMissionOwner(value) {
   return String(value || '').trim().toLowerCase();
 }
 
-function missionMemberTasteProfile(owner) {
+function readMissionMemberRole(owner, root = process.cwd()) {
+  const dir = memberDir(owner, root);
+  if (!dir) return '';
+  try {
+    const text = fs.readFileSync(path.join(dir, 'MEMBER.md'), 'utf8');
+    const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match) return '';
+    const role = match[1].match(/^role:\s*(.+)$/im);
+    return role ? role[1].replace(/^["']|["']$/g, '').trim() : '';
+  } catch {
+    return '';
+  }
+}
+
+function missionTasteProfileForRole(role) {
+  const text = String(role || '').toLowerCase();
+  if (!text) return null;
+  if (/\b(security|risk|trust|privacy|compliance|safety|safe|guard|inspector)\b/.test(text)) {
+    return {
+      id: 'security_guard',
+      name: 'Security / trust',
+      bias: 'Prefer work that prevents unsafe behavior, privacy mistakes, or quiet trust breaks.',
+      role_reason: 'Member role says guard risk before spending tokens.',
+    };
+  }
+  if (/\b(demo|reliability|ux|usability|support|operator|launcher|customer|growth|onboarding)\b/.test(text)) {
+    return {
+      id: 'usability_operator',
+      name: 'Usability / demo',
+      bias: 'Prefer work that makes the product easier, faster, clearer, or more demo-ready.',
+      role_reason: 'Member role says optimize usability before spending tokens.',
+    };
+  }
+  if (/\b(technical|engineer|architect|research|improver|runtime|compiler|infra|backend|agent|model)\b/.test(text)) {
+    return {
+      id: 'technical_homerun',
+      name: 'Technical homerun',
+      bias: 'Prefer technical leaps, but require a usability or proof gate before spending serious tokens.',
+      role_reason: 'Member role says chase validated technical homeruns.',
+    };
+  }
+  return null;
+}
+
+function missionOwnerTasteProfile(owner) {
   const key = normalizeMissionOwner(owner);
   if (/\b(security|sync-inspector|proof-inspector|validator)\b/.test(key)) {
     return {
@@ -2031,13 +2175,25 @@ function missionMemberTasteProfile(owner) {
   };
 }
 
+function missionMemberTasteProfile(owner, root = process.cwd()) {
+  const role = readMissionMemberRole(owner, root);
+  const roleProfile = missionTasteProfileForRole(role);
+  const profile = roleProfile || missionOwnerTasteProfile(owner);
+  return {
+    ...profile,
+    role: role || null,
+    role_source: roleProfile ? `atris/team/${normalizeMissionOwner(owner)}/MEMBER.md` : null,
+    role_reason: roleProfile?.role_reason || null,
+  };
+}
+
 function missionValueSignals(title) {
   const text = String(title || '').toLowerCase();
   const signals = [];
   const add = (id, label, pattern) => {
     if (pattern.test(text)) signals.push({ id, label });
   };
-  add('usability', 'simplifies use', /\b(simple|simplify|preview|clear|plain|feynman|demo|onboarding|ux|workflow|usable|understand)\b/);
+  add('usability', 'simplifies use', /\b(simple|simplify|previews?|clear|plain|feynman|demos?|onboarding|ux|workflow|usable|understand)\b/);
   add('speed', 'speeds the process', /\b(speed|fast|faster|latency|token|waste|friction|shortcut|automation|auto)\b/);
   add('users_revenue', 'can help users or revenue', /\b(user|users|customer|revenue|payment|checkout|pricing|conversion|retention|demo)\b/);
   add('trust', 'protects trust', /\b(security|safe|safety|trust|permission|approval|auth|privacy|gmail|email|connector|leak|isolation)\b/);
@@ -2265,6 +2421,7 @@ function missionTasteMemoryReason(tasteMemory, signals) {
 
 function missionPreviewWhyNow(move, profile, signals, tasteMemory = null) {
   const ids = new Set((signals || []).map((signal) => signal.id));
+  const roleReason = profile?.role_reason ? `${profile.role_reason} ` : '';
   let base = '';
   if (profile.id === 'technical_homerun') {
     base = ids.has('technical')
@@ -2282,7 +2439,7 @@ function missionPreviewWhyNow(move, profile, signals, tasteMemory = null) {
     base = move?.why || 'This needs a clear reason before it should spend serious tokens.';
   }
   const memoryReason = missionTasteMemoryReason(tasteMemory, signals);
-  return memoryReason ? `${base} Taste memory says: ${memoryReason}` : base;
+  return memoryReason ? `${roleReason}${base} Taste memory says: ${memoryReason}` : `${roleReason}${base}`;
 }
 
 function missionPreviewRisk(signals) {
@@ -2301,7 +2458,7 @@ function missionPreviewValidation(signals) {
 }
 
 function missionValuePreview(move, mission, root = process.cwd()) {
-  const profile = missionMemberTasteProfile(mission?.owner);
+  const profile = missionMemberTasteProfile(mission?.owner, root);
   const signals = missionValueSignals(move?.title);
   const tasteMemory = readMissionTasteMemory(root, mission?.owner);
   const score = missionValueScore(signals, profile, tasteMemory);
@@ -2651,6 +2808,9 @@ function startMission(args) {
   const warnings = [missingVerifierWarning(mission)].filter(Boolean);
   ensureMemberMissionFile(mission.owner, process.cwd(), mission.objective);
   const { mission: saved } = saveMission(mission, process.cwd(), 'mission_started', { objective: mission.objective });
+  const goalSlotHandoff = hasFlag(args, '--take-goal-slot') && isCodexGoalMission(saved)
+    ? takeCodexGoalSlotForMission(saved, process.cwd())
+    : null;
   const memberState = renderMemberMissionState(saved.owner);
   const logPath = appendMemberLog(saved.owner, 'Mission started', {
     mission: saved.objective,
@@ -2661,7 +2821,7 @@ function startMission(args) {
   });
   const worktreeBaseline = captureMissionWorktreeBaseline(saved, process.cwd());
   printJsonOrText(
-    { ok: true, action: 'mission_started', mission: saved, warnings, state_path: statePaths().missionsJsonl, member_state: memberState, log_path: logPath, worktree_baseline: worktreeBaseline ? { path: path.relative(process.cwd(), missionBaselinePath(saved.id)), dirty_count: worktreeBaseline.dirty_count, dirty_hash: worktreeBaseline.dirty_hash } : null },
+    { ok: true, action: 'mission_started', mission: saved, warnings, goal_slot_handoff: goalSlotHandoff, state_path: statePaths().missionsJsonl, member_state: memberState, log_path: logPath, worktree_baseline: worktreeBaseline ? { path: path.relative(process.cwd(), missionBaselinePath(saved.id)), dirty_count: worktreeBaseline.dirty_count, dirty_hash: worktreeBaseline.dirty_hash } : null },
     [
       `Started mission: ${saved.objective}`,
       `Owner: ${saved.owner}`,
@@ -2776,6 +2936,9 @@ function startMissionFromRunObjective(objective, args) {
     ...(nativeGoalObjective ? { nativeGoalObjective } : {}),
     ...(hasFlag(args, '--allow-native-goal-supersede') || hasFlag(args, '--supersede-paused-native-goal') ? { allowNativeGoalSupersede: true } : {}),
   };
+  const goalSlotHandoff = hasFlag(args, '--take-goal-slot') && isCodexGoalMission(saved)
+    ? takeCodexGoalSlotForMission(saved, process.cwd(), nativeGoalOptions)
+    : null;
   const atrisGoalState = refreshAtrisGoalController(process.cwd(), { missionId: saved.id });
   const codexGoalState = runnerUsesCallerSession(saved.runner)
     ? refreshCodexGoalController(process.cwd(), { missionId: saved.id, ...nativeGoalOptions })
@@ -2800,6 +2963,7 @@ function startMissionFromRunObjective(objective, args) {
       } : null,
       completed_continuation_goal: completedContinuationGoal,
       direct_goal_request: directGoalRequest,
+      goal_slot_handoff: goalSlotHandoff,
       atris_goal_state: atrisGoalState,
       codex_goal_state: codexGoalState,
       requires_native_goal_start: codexGoalState?.requires_native_goal_start === true || codexGoalState?.goal?.requires_native_goal_start === true,
@@ -2821,7 +2985,7 @@ function attachMissionTask(args) {
   }
   let mission = resolveMission(ref);
   if (!mission) {
-    exitMissionError(`Mission "${ref}" not found.`, 1, asJson);
+    exitMissingMission(ref, 1, asJson);
   }
 
   const lock = acquireMissionLock(mission.id, process.cwd(), { waitMs: 2000 });
@@ -2965,7 +3129,7 @@ function statusMission(args) {
   if (!ref && statusFilter) missions = missions.filter((mission) => missionMatchesStatusFilter(mission, statusFilter));
   if (!ref && limit) missions = missions.slice(0, limit);
   if (ref && !missions.length) {
-    exitMissionError(`Mission "${ref}" not found.`, 1, asJson);
+    exitMissingMission(ref, 1, asJson);
   }
   const missionViews = missions.map(missionStatusView);
   // Member state renders are cwd-local writes; rolled-up missions stay read-only.
@@ -3147,7 +3311,7 @@ function missionReportTimeline(mission, root = process.cwd(), limit = 6) {
   return items.slice(Math.max(0, items.length - limit));
 }
 
-function missionLandingTimeline(mission, root = process.cwd(), limit = 12) {
+function missionLandingTimeline(mission, root = process.cwd(), limit = 12, { kind = null, since = null } = {}) {
   const paths = statePaths(root);
   let files = [];
   try {
@@ -3158,6 +3322,8 @@ function missionLandingTimeline(mission, root = process.cwd(), limit = 12) {
     files = [];
   }
 
+  const kindFilter = kind ? String(kind).trim() : null;
+  const sinceFilter = since ? String(since).trim() : null;
   const items = [];
   const seen = new Set();
   for (const file of files) {
@@ -3168,6 +3334,9 @@ function missionLandingTimeline(mission, root = process.cwd(), limit = 12) {
       continue;
     }
     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;
+    if (sinceFilter && String(receipt.at || '') < sinceFilter) continue;
     const landing = receipt.result && receipt.result.landing;
     if (landing && landing.timeline_visible === false) continue;
     const changed = String(landing && landing.changed || '').trim();
@@ -3426,7 +3595,7 @@ function reportMission(args) {
     missions.sort((a, b) => String(b.updated_at || b.created_at || '').localeCompare(String(a.updated_at || a.created_at || '')));
   }
   if (ref && !missions.length) {
-    exitMissionError(`Mission "${ref}" not found.`, 1, asJson);
+    exitMissingMission(ref, 1, asJson);
   }
   missions = missions.slice(0, limit);
   const reports = missions.map((mission) => missionReportFor(mission, mission.worktree_root || process.cwd()));
@@ -3458,14 +3627,16 @@ function timelineMission(args) {
   const all = hasFlag(args, '--all');
   const prunePreviewRequested = hasFlag(args, '--prune-preview');
   const outputPath = readFlag(args, '--output', '') || readFlag(args, '--out', '');
-  const ref = stripKnownFlags(args, ['--limit', '--output', '--out'], ['--json', '--write', '--all', '--prune-preview'])[0] || '';
+  const kindFilter = readFlag(args, '--kind', '') || null;
+  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) {
-    exitMissionError(`Mission "${ref}" not found.`, 1, asJson);
+    exitMissingMission(ref, 1, asJson);
   }
   if (!mission) {
     printJsonOrText(
@@ -3482,7 +3653,7 @@ function timelineMission(args) {
     return;
   }
   const root = mission.worktree_root || process.cwd();
-  const timelineResult = missionLandingTimeline(mission, root, limit);
+  const timelineResult = missionLandingTimeline(mission, root, limit, { kind: kindFilter, since: sinceFilter });
   const timeline = timelineResult.items;
   const currentLanding = missionTimelineCurrentLanding(timeline);
   const timelineItemDisplay = (item) => ({
@@ -3652,8 +3823,14 @@ function timelineMission(args) {
       label: 'Filters',
       active_label: 'Active filter',
       active: all ? 'full_history' : 'latest',
+      mission_label: 'Mission',
+      mission: mission.id,
       limit_label: 'Limit',
       limit: timelineResult.meta.limit,
+      kind_label: 'Kind',
+      kind: kindFilter,
+      since_label: 'Since',
+      since: sinceFilter,
       shown_count: timelineResult.meta.shown_count,
       total_count: timelineResult.meta.total_count,
       hidden_count: timelineResult.meta.hidden_count,
@@ -3930,7 +4107,7 @@ function watchMission(args) {
     return listMissions().filter((mission) => !HEARTBEAT_TERMINAL_STATUSES.has(mission.status));
   };
   if (ref && !loadTargets().length) {
-    exitMissionError(`Mission "${ref}" not found.`, 1, false);
+    exitMissingMission(ref, 1, false);
   }
   const stamp = () => new Date().toTimeString().slice(0, 8);
   const shortId = (mission) => mission.id.length > 20 ? `…${mission.id.slice(-8)}` : mission.id;
@@ -4225,6 +4402,15 @@ const MISSION_RUN_DEFAULTS = {
   backoff: { initialMs: 30_000, maxMs: 10 * 60_000, factor: 2, jitter: 0.3 },
 };
 
+// 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
+// ran ticks. Failure-path rotation (stale lock) stays separate below.
+const CLAUDE_SESSION_CONTEXT_ROTATE_TICKS = Math.max(
+  1,
+  Number(process.env.ATRIS_CLAUDE_SESSION_ROTATE_TICKS) || 8,
+);
+
 function runnerUsesCallerSession(runner) {
   return new Set(['codex_goal', 'caller_session', 'current_agent']).has(String(runner || '').trim().toLowerCase());
 }
@@ -4328,6 +4514,16 @@ function missionIsRunnable(mission) {
     && !missionHasHumanAsks(mission);
 }
 
+// Fresh goal selection: moving work outranks review-parked work. A ready
+// mission stays selectable (its next action is native-goal completion /
+// review), but it must never beat a running or planning mission on recency.
+const GOAL_SELECTION_STATUS_RANK = { running: 0, planning: 1, ready: 2 };
+
+function missionGoalSelectionRank(mission) {
+  const rank = GOAL_SELECTION_STATUS_RANK[String(mission?.status || '')];
+  return Number.isFinite(rank) ? rank : 3;
+}
+
 function missionSortTime(mission) {
   return Date.parse(mission?.updated_at || mission?.created_at || '') || 0;
 }
@@ -4382,6 +4578,10 @@ function selectCodexGoalMission(root = process.cwd(), options = {}, now = new Da
   }
 
   candidates.sort((a, b) => {
+    const aRank = missionGoalSelectionRank(a);
+    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;
@@ -4409,6 +4609,10 @@ function selectAtrisGoalMission(root = process.cwd(), options = {}, now = new Da
     if (exact) return { mission: exact, reason: 'selected' };
   }
   runnable.sort((a, b) => {
+    const aRank = missionGoalSelectionRank(a);
+    const bRank = missionGoalSelectionRank(b);
+    if (aRank !== bRank) return aRank - bRank;
+
     const aDue = effectiveMissionVerifier(a) && missionDueAt(a, now) ? 1 : 0;
     const bDue = effectiveMissionVerifier(b) && missionDueAt(b, now) ? 1 : 0;
     if (aDue !== bDue) return bDue - aDue;
@@ -4427,14 +4631,50 @@ function codexGoalObjective(mission) {
   return mission.objective;
 }
 
-function codexNativeGoalAck(mission, objective = codexGoalObjective(mission)) {
+function codexNativeGoalAck(mission) {
   const ack = mission?.native_goal_ack || null;
   if (!ack || String(ack.runtime || '').toLowerCase() !== 'codex') return null;
   if (ack.status !== 'active') return null;
-  if (String(ack.objective || '') !== String(objective || '')) return null;
+  if (ack.mission_id && String(ack.mission_id) !== String(mission?.id || '')) return null;
   return ack;
 }
 
+function supersedeOtherCodexNativeGoalAcks(root, activeMission, activeAck) {
+  const activeMissionId = String(activeMission?.id || '');
+  if (!activeMissionId) return [];
+  const supersededAt = stampIso();
+  const superseded = [];
+  for (const mission of listMissions(root)) {
+    if (String(mission.id || '') === activeMissionId) continue;
+    const priorAck = codexNativeGoalAck(mission);
+    if (!priorAck) continue;
+    const nextAck = {
+      ...priorAck,
+      status: 'superseded',
+      superseded_at: supersededAt,
+      superseded_by_mission_id: activeMissionId,
+      superseded_by_objective: activeAck?.objective || activeMission.objective,
+    };
+    const { mission: saved } = saveMission(
+      { ...mission, native_goal_ack: nextAck },
+      root,
+      'mission_native_goal_ack_superseded',
+      {
+        superseded_by_mission_id: activeMissionId,
+        superseded_by_objective: activeAck?.objective || activeMission.objective,
+        previous_ack: priorAck,
+      },
+    );
+    superseded.push({
+      mission_id: saved.id,
+      objective: saved.objective,
+      previous_ack: priorAck,
+      native_goal_ack: nextAck,
+    });
+  }
+  return superseded;
+}
+
 function codexRuntimeGoalStateFromOptions(options = {}) {
   const status = String(options.nativeGoalStatus || options.visibleGoalStatus || '').trim().toLowerCase();
   const objective = String(options.nativeGoalObjective || options.visibleGoalObjective || '').trim();
@@ -4601,6 +4841,33 @@ function activeCodexVisibleGoalOwner(root = process.cwd(), excludeId = '', now =
   return candidates[0] || null;
 }
 
+function pauseMissionRecord(mission, reason, root = process.cwd()) {
+  const next = {
+    ...mission,
+    status: 'paused',
+    paused_at: stampIso(),
+    stop_reason: reason,
+    next_action: `resume with: atris mission tick ${mission.id}`,
+  };
+  const { mission: saved } = saveMission(next, root, 'mission_paused', { reason, source: 'goal_slot_handoff' });
+  appendMemberLog(saved.owner, 'Mission paused', { mission: saved.objective, reason });
+  return saved;
+}
+
+function takeCodexGoalSlotForMission(newMission, root = process.cwd(), options = {}) {
+  if (!newMission || !isCodexGoalMission(newMission)) return null;
+  const runtimeGoalState = codexRuntimeGoalStateFromOptions(options);
+  const activeOwner = activeCodexVisibleGoalOwner(root, newMission.id, new Date(), runtimeGoalState);
+  if (!activeOwner) return null;
+  const reason = `visible goal replaced by ${newMission.id}`;
+  const paused = pauseMissionRecord(activeOwner, reason, root);
+  return {
+    paused_mission_id: paused.id,
+    paused_mission: missionStatusView(paused),
+    reason,
+  };
+}
+
 function codexGoalActiveConflictPayload(newMission, activeMission, request = null, heartbeatMode = false, runtimeGoalState = null) {
   const newObjective = codexGoalObjective(newMission);
   const pausedConflict = runtimeGoalState?.status === 'paused';
@@ -4899,7 +5166,7 @@ function buildCodexGoalPayload(root = process.cwd(), options = {}) {
   const taskSpine = missionTaskSpine(mission);
   const missionView = missionStatusView(mission);
   const objective = codexGoalObjective(mission);
-  const ack = codexNativeGoalAck(mission, objective);
+  const ack = codexNativeGoalAck(mission);
   const runtimeNeedsReplace = !ack && codexRuntimeGoalNeedsReplace(runtimeGoalState, objective);
   const nativeGoalAction = ack
     ? null
@@ -5315,9 +5582,30 @@ function probeClaudeBinary() {
   return { ok: true };
 }
 
-function buildTickPrompt(mission, tickIndex, maxTicks, frozen) {
+// Pull unread operator pings off the mission and mark them consumed, so the
+// next tick's prompt carries them exactly once. Pings are how a human talks to
+// an always-on member mid-run: atris member ping <name> "<msg>".
+function consumeMissionPings(mission, cwd) {
+  const pending = (Array.isArray(mission.pings) ? mission.pings : []).filter((p) => p && !p.consumed_at);
+  if (!pending.length) return { mission, pings: [] };
+  const consumedAt = stampIso();
+  const pings = (mission.pings || []).map((p) => (p && !p.consumed_at ? { ...p, consumed_at: consumedAt } : p));
+  const saved = saveMission({ ...mission, pings }, cwd, 'mission_pings_consumed', { count: pending.length }).mission;
+  return { mission: saved, pings: pending };
+}
+
+function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = []) {
+  const pingLines = pings.length
+    ? [
+      ``,
+      `## Operator pings (read these first)`,
+      `Your operator sent ${pings.length === 1 ? 'a message' : 'messages'} mid-run. Treat them as fresh direction for this tick (they do not change the frozen verifier or lane):`,
+      ...pings.map((p) => `- [${p.at}] ${p.from || 'operator'}: ${p.text}`),
+    ]
+    : [];
   const lines = [
     `# Mission Tick ${tickIndex}/${maxTicks}`,
+    ...pingLines,
     ``,
     `**Objective:** ${mission.objective}`,
     `**Owner:** ${mission.owner}`,
@@ -5336,6 +5624,7 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen) {
     `- Pick the smallest concrete action that moves the mission forward.`,
     `- Edit / run / research as needed for the lane.`,
     `- After your work, the harness runs the frozen verifier — make sure it'll pass.`,
+    `- Write the tick summary in operator language: what changed and what it buys or costs in plain words, with no flags, task ids, or code identifiers.`,
     `- If you can't make progress this tick, say why explicitly. Don't fake it.`,
     ``,
     `## Constraints`,
@@ -5405,7 +5694,10 @@ function spawnClaudeTick(mission, opts) {
     else if (sessionMode === 'resume') args.push('--resume', sessionId);
 
     const startedAt = Date.now();
-    const proc = spawn(resolveClaudeRunnerBin(), args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+    // detached: the runner spawns its own children; killing only the direct
+    // child on timeout leaves them holding the session lock, and the next
+    // tick's resume fails with "Session ID ... is already in use".
+    const proc = spawn(resolveClaudeRunnerBin(), args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], detached: true });
 
     let stdoutBuf = '';
     let observedSessionIds = new Set();
@@ -5422,8 +5714,11 @@ function spawnClaudeTick(mission, opts) {
     let aborted = false;
 
     const kill = (reason) => {
-      try { proc.kill('SIGTERM'); } catch {}
-      setTimeout(() => { try { proc.kill('SIGKILL'); } catch {} }, 3000).unref();
+      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('timeout'); }, timeoutMs);
     const onAbort = () => { aborted = true; kill('aborted'); };
@@ -5529,6 +5824,21 @@ async function runMission(args) {
     help();
     return;
   }
+  // --fleet: staff every idle capable engine on the board's claimable
+  // safe-lane tasks, build in parallel worktrees, land serially. Humble flag,
+  // full loop — see lib/fleet.js. --dry-run previews the staffing only.
+  if (hasFlag(args, '--fleet')) {
+    const { runFleetFlight } = require('../lib/fleet');
+    const slots = Math.max(1, Number(readFlag(args, '--slots', '')) || 3);
+    const flight = await runFleetFlight({
+      slots,
+      dryRun: hasFlag(args, '--dry-run'),
+      log: asJson ? () => {} : console.log,
+    });
+    if (asJson) console.log(JSON.stringify(flight, null, 2));
+    process.exitCode = flight.paused && flight.paused.length > 0 ? 1 : 0;
+    return;
+  }
   const dueMode = hasFlag(args, '--due');
   const skipClaude = hasFlag(args, '--no-claude');
   const verifyEach = !hasFlag(args, '--no-verify');
@@ -5715,7 +6025,9 @@ async function runMission(args) {
           claude: { skipped: true, reason: callerSessionRunner ? 'runner-uses-caller-session' : 'no-claude-mode' },
         };
       } else if (atris2Runner) {
-        const prompt = buildTickPrompt(mission, tickIdx, effectiveMaxTicks, frozen);
+        const pingDrain = consumeMissionPings(mission, cwd);
+        mission = pingDrain.mission;
+        const prompt = buildTickPrompt(mission, tickIdx, effectiveMaxTicks, frozen, pingDrain.pings);
         const { runAtris2Turn } = require('./probe');
         const businessId = businessIdForAtris2Mission(mission, cwd);
         const turn = await runAtris2Turn({
@@ -5745,7 +6057,9 @@ async function runMission(args) {
       } else {
         const sessionMode = sessionId ? 'resume' : 'set';
         const useId = sessionId || pendingSessionId;
-        const prompt = buildTickPrompt(mission, tickIdx, effectiveMaxTicks, frozen);
+        const pingDrain = consumeMissionPings(mission, cwd);
+        mission = pingDrain.mission;
+        const prompt = buildTickPrompt(mission, tickIdx, effectiveMaxTicks, frozen, pingDrain.pings);
         const claudeResult = await spawnClaudeTick(mission, {
           sessionMode, sessionId: useId, cwd, signal: controller.signal,
           timeoutMs: MISSION_RUN_DEFAULTS.claudeTimeoutMs, prompt,
@@ -5766,10 +6080,11 @@ async function runMission(args) {
           aborted: claudeResult.aborted,
         };
         if (claudeResult.rate_limit_info) {
-          lastRateLimit = claudeResult.rate_limit_info;
-          if (lastRateLimit.status && lastRateLimit.status !== 'allowed') {
-            // throttled / overage
-          }
+          // Claude reports the five-hour window's resetsAt on every turn, even
+          // when status is "allowed". Only a non-allowed status is a cooldown;
+          // 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;
         }
         if (claudeResult.aborted) { pauseReason = 'aborted-during-claude'; break; }
         if (claudeResult.authExpired) { pauseReason = 'auth-required'; break; }
@@ -5778,6 +6093,20 @@ async function runMission(args) {
           const deadModel = detectUnavailableModel(claudeResult.summary || claudeResult.receipt_text);
           let reason = claudeResult.timedOut ? 'claude-timeout' : 'claude-error';
           if (deadModel) { reason = 'model-unavailable'; result.model_unavailable = deadModel; }
+          // A killed tick (usually claude-timeout) can leave the session lock
+          // held, so the next resume fails with "already in use". Session
+          // continuity is disposable — mission state lives on disk (receipts,
+          // logs, now.md) — so rotate to a fresh id instead of grinding the
+          // repeated-error breaker on a stale lock.
+          if (/session id .* is already in use/i.test(claudeResult.stderr || '')) {
+            reason = 'claude-session-busy';
+            pendingSessionId = crypto.randomUUID();
+            sessionId = null;
+            mission = saveMission(
+              { ...mission, claude_session_id: null, pending_session_id: pendingSessionId },
+              cwd, 'mission_session_rotated', { reason: 'session-lock-busy', session_id: pendingSessionId },
+            ).mission;
+          }
           result = { ...result, status: 'errored', reason };
         } else {
           // Promote pending session id ONLY if claude confirmed the exact UUID we requested.
@@ -5865,6 +6194,11 @@ async function runMission(args) {
       } else if (result.status === 'ran' && mission.always_on) {
         nextAction = nextCandidateTickAction(mission);
       }
+      // Context hygiene: count ran claude ticks on this session; at the
+      // rotation threshold, drop the session so the next tick starts fresh.
+      const claudeRanTick = Boolean(result.claude) && result.status === 'ran';
+      const claudeSessionTicks = claudeRanTick ? Number(mission.claude_session_ticks || 0) + 1 : Number(mission.claude_session_ticks || 0);
+      const rotateSessionForContext = claudeRanTick && claudeSessionTicks >= CLAUDE_SESSION_CONTEXT_ROTATE_TICKS;
       mission = saveMission({
         ...mission,
         status: newStatus,
@@ -5879,9 +6213,23 @@ async function runMission(args) {
         verifier_result: verifierResult || mission.verifier_result || null,
         receipt_path: receiptPath,
         next_action: nextAction,
+        claude_session_ticks: rotateSessionForContext ? 0 : claudeSessionTicks,
       }, cwd, 'mission_tick', {
         tick_index: tickIdx, status: result.status, reason: result.reason, receipt_path: receiptPath, layer: result.layer,
       }).mission;
+      if (rotateSessionForContext) {
+        // Same shape as the stale-lock rotation above: mint the fresh pending
+        // id AND reset the loop locals, or the next tick resumes the old
+        // session from its stale local and the rotation is a no-op.
+        pendingSessionId = crypto.randomUUID();
+        sessionId = null;
+        mission = saveMission(
+          { ...mission, claude_session_id: null, pending_session_id: pendingSessionId },
+          cwd, 'mission_session_rotated', {
+            reason: 'context-refresh', after_ticks: claudeSessionTicks, session_id: pendingSessionId,
+          },
+        ).mission;
+      }
       appendMemberLog(mission.owner, `Mission run tick ${tickIdx}`, {
         mission: mission.objective,
         state: mission.status,
@@ -5904,7 +6252,10 @@ async function runMission(args) {
       if (result.status === 'ran') {
         ranTicks++;
         backoffAttempt = 0;
-      } else if (result.status === 'errored') {
+      } else if (result.status === 'errored' && result.reason !== 'claude-session-busy') {
+        // A rotated session is already healed — the next tick starts on a
+        // fresh id, so backing off just burns wall clock. If rotation itself
+        // keeps failing, the repeated-error breaker below still stops the run.
         backoffAttempt++;
       }
 
@@ -5924,7 +6275,7 @@ async function runMission(args) {
 
       // Sleep until next tick
       let sleepMs = 0;
-      if (result.status === 'errored') {
+      if (result.status === 'errored' && result.reason !== 'claude-session-busy') {
         sleepMs = computeBackoff(MISSION_RUN_DEFAULTS.backoff, backoffAttempt);
       } else if (cadenceSeconds > 0) {
         sleepMs = cadenceSeconds * 1000;
@@ -6009,10 +6360,12 @@ function tickMission(args) {
   const verifyOverride = readFlag(args, '--verify', '');
   const completeOnPass = hasFlag(args, '--complete-on-pass');
   const summary = readFlag(args, '--summary', '');
+  const operatorSummaryWarning = warnIfSummaryNeedsOperatorWhy(summary);
   const ref = stripKnownFlags(args, ['--summary', '--verify'], ['--json', '--complete-on-pass'])[0] || '';
   let mission = resolveMission(ref);
   if (!mission) {
-    exitMissionError(ref ? `Mission "${ref}" not found.` : 'No mission found. Run: atris mission start "..."', 1, asJson);
+    if (ref) exitMissingMission(ref, 1, asJson);
+    exitMissionError('No mission found. Run: atris mission start "..."', 1, asJson);
   }
 
   // Same per-mission flock that `mission run` uses. Without it, a tick could
@@ -6154,7 +6507,7 @@ function tickMission(args) {
     const atrisGoalState = refreshAtrisGoalController(process.cwd(), { missionId: outputMission.id });
     const codexGoalState = refreshCodexGoalController(process.cwd());
     printJsonOrText(
-      { ok: true, action: 'mission_tick', mission: outputMission, tick: tickRecord, verifier_result: verifierResult, receipt_path: receiptPath, log_path: logPath, atris_goal_state: atrisGoalState, codex_goal_state: codexGoalState, continuation_goal: continuationGoal },
+      { ok: true, action: 'mission_tick', mission: outputMission, tick: tickRecord, verifier_result: verifierResult, receipt_path: receiptPath, log_path: logPath, atris_goal_state: atrisGoalState, codex_goal_state: codexGoalState, continuation_goal: continuationGoal, operator_summary_warning: operatorSummaryWarning },
       [
         ...missionTickResultLines(outputMission, tickIdx, receiptPath, verifierResult, summary),
         ...(continuationGoal?.mission ? [`Next goal: ${continuationGoal.mission.objective}`] : []),
@@ -6223,7 +6576,7 @@ function completeMission(args) {
   }
   const mission = resolveMission(ref);
   if (!mission) {
-    exitMissionError(`Mission "${ref}" not found.`, 1, asJson);
+    exitMissingMission(ref, 1, asJson);
   }
   const gate = missionCompletionGate(mission, proof, root);
   if (!gate.ok && !force) {
@@ -6299,7 +6652,7 @@ function stopMission(args) {
   }
   const mission = resolveMission(ref);
   if (!mission) {
-    exitMissionError(`Mission "${ref}" not found.`, 1, asJson);
+    exitMissingMission(ref, 1, asJson);
   }
   const status = pause ? 'paused' : 'stopped';
   // Full stops abandon work, so leave evidence: snapshot the worktree against
@@ -6415,7 +6768,7 @@ function ackMissionGoal(args) {
   const status = String(readFlag(args, '--status', 'active') || 'active').trim().toLowerCase();
   let mission = resolveMission(ref);
   if (!mission) {
-    exitMissionError(`Mission "${ref}" not found.`, 1, asJson);
+    exitMissingMission(ref, 1, asJson);
   }
   if (runtime !== 'codex' || status !== 'active') {
     exitMissionError('Native goal ack requires --runtime codex --status active.', 2, asJson);
@@ -6432,16 +6785,15 @@ function ackMissionGoal(args) {
       releaseMissionLock(lock);
       exitMissionError(`Mission "${ref}" uses runner=${mission.runner || 'manual'}; native Codex goal ack is only for runner=codex_goal.`, 2, asJson);
     }
-    const expectedObjective = codexGoalObjective(mission);
-    const objective = readFlag(args, '--objective', expectedObjective);
-    if (objective !== expectedObjective) {
-      releaseMissionLock(lock);
-      exitMissionError(`Native goal objective mismatch. Expected: ${expectedObjective}`, 2, asJson);
-    }
+    const 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 = {
@@ -6449,6 +6801,7 @@ function ackMissionGoal(args) {
       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 payload = refreshCodexGoalController(process.cwd());
     printJsonOrText(
@@ -6457,6 +6810,7 @@ function ackMissionGoal(args) {
         action: 'native_goal_acknowledged',
         mission: saved,
         native_goal_ack: ack,
+        superseded_native_goal_acks: supersededNativeGoalAcks,
         codex_goal_state: payload,
         next_command: payload.goal?.next_command || `atris mission tick ${saved.id} --summary "<what changed>"`,
       },
@@ -6555,13 +6909,15 @@ function help() {
   console.log(`
 atris mission - durable goal + loop + owner + proof state
 
-  atris mission start "<objective>" --owner <member> [--verify "..."] [--always-on] [--xp-task] [--worktree]
+  atris mission start "<objective>" --owner <member> [--verify "..."] [--always-on] [--xp-task] [--worktree] [--take-goal-slot]
                       [--runner manual|claude|atris2|codex_goal] [--model <id>]
                       (runner claude spawns local claude -p per tick, --model passes through;
                        runner atris2 runs each tick as one /atris2/turn on the AtrisOS backend,
                        default model atris:fast; runner codex_goal publishes the goal for a live
                        Codex session to pull via atris mission goal)
   atris mission status [id] [--status <state>] [--limit <n>] [--local] [--json]
+  atris mission inspect <id> --fields status,runner,ack,pings [--json]
+                       Field-selectable mission state (status, runner, native goal ack, ping counts)
   atris mission doctor [--local] [--json]   Flag no-verifier missions, help missions, stale ready receipts, and blocked always-on loops
   atris mission attach-task <id> [--json]   Create the missing task spine for an existing active mission
   atris mission report [id] [--limit <n>] [--local] [--json]   Plain outcome, worker receipt, verifier receipt, and next move
@@ -6576,8 +6932,9 @@ atris mission - durable goal + loop + owner + proof state
   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 "<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]
+                                [--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]
                                 [--room-auto-run|--no-room-auto-run]
                                 [--no-claude] [--no-verify] [--complete-on-pass] [--no-drain] [--create-next] [--json]
@@ -6838,6 +7195,98 @@ function pruneRunsMission(args) {
   if (result.errors.length) process.exitCode = 1;
 }
 
+// Locate a mission whose state may live in a sibling worktree (--worktree
+// missions keep their jsonl there). Returns the mission plus the root whose
+// state file owns it, so writes land where the runner reads.
+function findMissionAcrossWorktrees(ref, root = process.cwd()) {
+  const local = resolveMission(ref, root);
+  if (local) return { mission: local, root };
+  for (const rolled of listWorktreeRollupMissions(root)) {
+    if (rolled.id === ref || rolled.id.startsWith(ref) || rolled.slug === ref) {
+      const { worktree_root, worktree_branch, ...mission } = rolled;
+      return { mission, root: worktree_root };
+    }
+  }
+  return null;
+}
+
+// atris mission ping <id> "<message>" — leave a note the mission's next tick
+// reads (and consumes) as operator direction. This is how you talk to an
+// always-on member mid-run without stopping it.
+function inspectMission(args) {
+  const asJson = wantsJson(args);
+  const parsed = readFieldsFlag(args, '--fields');
+  if (!parsed || parsed.error) {
+    exitMissionError(
+      parsed?.error || 'Usage: atris mission inspect <id> --fields status,runner,ack,pings [--json]',
+      2,
+      asJson,
+    );
+  }
+  const fieldError = validateFields(parsed.fields, MISSION_INSPECT_FIELDS, 'mission');
+  if (fieldError) exitMissionError(fieldError, 2, asJson);
+  const ref = stripInspectArgs(args)[0] || '';
+  if (!ref) {
+    exitMissionError('Usage: atris mission inspect <id> --fields status,runner,ack,pings [--json]', 2, asJson);
+  }
+  const found = findMissionAcrossWorktrees(ref);
+  if (!found) exitMissingMission(ref, 1, asJson);
+  const { mission } = found;
+  const values = missionInspectFieldValues(mission, parsed.fields);
+  const payload = buildInspectPayload({
+    action: 'mission_inspect',
+    idKey: 'mission_id',
+    idValue: mission.id,
+    fields: parsed.fields,
+    values,
+  });
+  printJsonOrText(payload, inspectTextLines(parsed.fields, values), asJson);
+}
+
+// always-on member mid-run without stopping it. opts.silent skips console
+// output so callers (member ping) can compose their own multi-lane report.
+function pingMission(args, opts = {}) {
+  const asJson = args.includes('--json');
+  const rest = args.filter((a) => a !== '--json');
+  let from = process.env.USER || 'operator';
+  const fromIdx = rest.indexOf('--from');
+  if (fromIdx !== -1) {
+    from = rest[fromIdx + 1] || from;
+    rest.splice(fromIdx, 2);
+  }
+  const [ref, ...textParts] = rest;
+  const text = textParts.join(' ').trim();
+  if (!ref || !text) {
+    console.error('usage: atris mission ping <id> "<message>" [--from <name>]');
+    process.exit(2);
+  }
+  const found = findMissionAcrossWorktrees(ref);
+  if (!found) {
+    exitMissingMission(ref, 1, asJson);
+  }
+  const { mission, root } = found;
+  if (TERMINAL_STATUSES.has(mission.status)) {
+    console.error(`Mission ${mission.id} is ${mission.status}; pings only reach live missions.`);
+    process.exit(1);
+  }
+  const ping = { at: stampIso(), from, text };
+  const saved = saveMission(
+    { ...mission, pings: [...(Array.isArray(mission.pings) ? mission.pings : []), ping] },
+    root,
+    'mission_ping',
+    { from, text: text.slice(0, 200) },
+  ).mission;
+  const pending = (saved.pings || []).filter((p) => p && !p.consumed_at).length;
+  if (!opts.silent) {
+    if (asJson) {
+      console.log(JSON.stringify({ ok: true, action: 'mission_ping', mission_id: saved.id, pending_pings: pending, ping }));
+    } else {
+      console.log(`pinged ${saved.id} — the next tick reads it (${pending} unread).`);
+    }
+  }
+  return saved;
+}
+
 function missionCommand(args) {
   const subcommand = args[0] || 'status';
   const rest = args.slice(1);
@@ -6882,6 +7331,10 @@ function missionCommand(args) {
     case 'goal-loop':
     case 'codex-goal-loop':
       return goalLoopMission(rest);
+    case 'ping':
+      return pingMission(rest);
+    case 'inspect':
+      return inspectMission(rest);
     case 'tick':
       return tickMission(rest);
     case 'run':
@@ -6904,11 +7357,15 @@ function missionCommand(args) {
 
 module.exports = {
   missionCommand,
+  inspectMission,
   missionHeartbeatLines,
   listMissions,
+  listWorktreeRollupMissions,
+  pingMission,
   loadMissionMap,
   renderMissionStatus,
   selectDueMission,
+  selectAtrisGoalMission,
   selectCodexGoalMission,
   usefulClaudeReceiptSummary,
   cappedClaudeReceiptText,