atris 3.31.0 → 3.32.0

package/commands/mission.js

@@ -29,6 +29,7 @@ const {
   runsPruneLines,
   formatBytes,
 } = require('../lib/runs-prune');
+const { operatorReady, hasAgentJargon } = require('./autoland');
 
 const VALID_STATUSES = new Set(['planning', 'running', 'ready', 'paused', 'blocked', 'stopped', 'complete']);
 const TERMINAL_STATUSES = new Set(['stopped', 'complete']);
@@ -90,6 +91,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;
@@ -328,6 +351,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 +395,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 +524,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) {
@@ -2008,7 +2095,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 +2162,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 +2408,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 +2426,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 +2445,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);
@@ -2821,7 +2965,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 +3109,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 +3291,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 +3302,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 +3314,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 +3575,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 +3607,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 +3633,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 +3803,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 +4087,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 +4382,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 +4494,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 +4558,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 +4589,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;
@@ -4435,6 +4619,42 @@ function codexNativeGoalAck(mission, objective = codexGoalObjective(mission)) {
   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();
@@ -5315,9 +5535,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 +5577,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 +5647,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 +5667,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'); };
@@ -5715,7 +5963,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 +5995,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 +6018,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 +6031,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 +6132,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 +6151,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 +6190,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 +6213,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 +6298,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 +6445,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 +6514,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 +6590,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 +6706,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);
@@ -6449,6 +6740,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 +6749,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>"`,
       },
@@ -6838,6 +7131,64 @@ 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 pingMission(args) {
+  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 (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 +7233,8 @@ function missionCommand(args) {
     case 'goal-loop':
     case 'codex-goal-loop':
       return goalLoopMission(rest);
+    case 'ping':
+      return pingMission(rest);
     case 'tick':
       return tickMission(rest);
     case 'run':
@@ -6906,9 +7259,12 @@ module.exports = {
   missionCommand,
   missionHeartbeatLines,
   listMissions,
+  listWorktreeRollupMissions,
+  pingMission,
   loadMissionMap,
   renderMissionStatus,
   selectDueMission,
+  selectAtrisGoalMission,
   selectCodexGoalMission,
   usefulClaudeReceiptSummary,
   cappedClaudeReceiptText,