atris 3.69.0 → 3.71.0

package/commands/mission.js

@@ -2,6 +2,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const crypto = require('crypto');
 const readline = require('readline');
 const { spawn, spawnSync } = require('child_process');
@@ -115,6 +116,8 @@ const {
 
 const VALID_STATUSES = new Set(['planning', 'running', 'ready', 'paused', 'blocked', 'stopped', 'complete']);
 const TERMINAL_STATUSES = new Set(['stopped', 'complete']);
+// Campaign hooks load on first use, so missions without a campaign never open its store.
+const campaignMissions = () => require('../lib/campaign-missions');
 const GOAL_LOOP_STATUSES = new Set(['planning', 'running', 'ready']);
 const STATUS_ALIASES = new Set(['active']);
 const CODEX_NATIVE_GOAL_SLOT_STATUSES = new Set(['active', 'paused', 'usage_limited']);
@@ -425,16 +428,41 @@ async function missionTickPrep(root, { mission, runtimeMission, job, prompt, ask
 
 // A tick's time limit: the time left on the mission, capped by the roster
 // line's "max 20 min" when it sets one, else by the default tick cap.
-function missionTickTimeoutMs(mission, remainingMs) {
-  const cap = Number(mission && mission.roster_max_seconds) > 0
+function missionTickCapMs(mission) {
+  return Number(mission && mission.roster_max_seconds) > 0
     ? Number(mission.roster_max_seconds) * 1000
     : MISSION_RUN_DEFAULTS.claudeTimeoutMs;
-  return clampTimeoutMs(remainingMs, cap);
+}
+
+function missionTickTimeoutMs(mission, remainingMs) {
+  return clampTimeoutMs(remainingMs, missionTickCapMs(mission));
+}
+
+// True when the time left on the mission, not the tick's own cap, set the
+// tick's limit, so a kill there means the mission clock ran out.
+function missionTickWallBound(mission, remainingMs) {
+  return remainingMs <= missionTickCapMs(mission);
+}
+
+// The reason a member log shows for a tick. A failed engine tick names its
+// engine beside the reason, so a codex run that timed out stops counting as
+// a claude timeout in the repeat-problem scan. The reason itself is left as
+// is because engine health and backoff match on it.
+function memberLogTickReason(result) {
+  const reason = result && result.reason;
+  if (!reason || !result.engine_id || result.status !== 'errored') return reason;
+  return `${reason} (engine: ${result.engine_id})`;
 }
 
 function resolveMissionTickRunner(mission, root = process.cwd(), options = {}) {
   if (String(mission && mission.runner || '').trim().toLowerCase() !== MISSION_AUTO_RUNNER) {
-    return { mission, engine_id: null, requested_engine: null, engine_fallback_reason: null };
+    // A named engine still gets the roster's time limit for that engine.
+    const runner = String(mission && mission.runner || '').trim().toLowerCase();
+    const pin = runner && !(Number(mission && mission.roster_max_seconds) > 0)
+      ? require('../lib/engine-registry').rosterPinFor('executor', runner, root, options)
+      : {};
+    const limited = pin.roster_max_seconds ? { ...mission, roster_max_seconds: pin.roster_max_seconds } : mission;
+    return { mission: limited, engine_id: null, requested_engine: null, engine_fallback_reason: null };
   }
   // A mission owned by a team member runs on that member's roster pick. An
   // explicit preferred engine (or a run's --engine) still wins, and with no
@@ -736,6 +764,8 @@ const MISSION_RUN_VALUE_FLAGS = [
   '--engine',
   '--referee-engine',
   '--budget',
+  '--campaign',
+  '--reserve',
   '--repo',
   '--native-goal-status',
   '--native-goal-objective',
@@ -1472,14 +1502,24 @@ function nearestMissionCandidates(missions, ref, limit = 5) {
     .map((entry) => entry.mission);
 }
 
-function listSiblingWorkspaceMissionHints(ref, root = process.cwd(), limit = 5) {
+// Sibling folders looked at for a hint. A missing-id error waited 26 seconds
+// on a temp folder holding 276,000 entries, so the scan is capped and never
+// walks the system temp folder.
+const SIBLING_HINT_SCAN_LIMIT = 2000;
+
+function listSiblingWorkspaceMissionHints(ref, root = process.cwd(), limit = 5, { scanLimit = SIBLING_HINT_SCAN_LIMIT, tmpRoot = os.tmpdir() } = {}) {
   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 */ }
+  const real = (target) => {
+    try {
+      return fs.realpathSync(target);
+    } catch {
+      return target;
+    }
+  };
+  const here = real(baseRoot);
+  if (real(parent) === real(tmpRoot)) return [];
   let entries = [];
   try {
     entries = fs.readdirSync(parent, { withFileTypes: true });
@@ -1487,17 +1527,11 @@ function listSiblingWorkspaceMissionHints(ref, root = process.cwd(), limit = 5)
     return [];
   }
   const hints = [];
-  for (const entry of entries) {
+  for (const entry of entries.slice(0, scanLimit)) {
     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;
+    if (real(candidateRoot) === here) continue;
     const mission = listMissions(candidateRoot).find((row) => missionMatchesRef(row, ref));
     if (!mission) continue;
     hints.push({
@@ -1690,6 +1724,7 @@ function saveMission(mission, root = process.cwd(), eventType = 'mission_updated
   // this file several times, so unbounded snapshot history taxes everything.
   try { compactMissionLedger(paths.missionsJsonl); } catch {}
   const event = appendEvent(eventType, next, payload, root);
+  if (next.campaign_id) campaignMissions().recordCampaignMissionEnded(root, existing, next, TERMINAL_STATUSES);
   renderMissionStatus(root);
   renderMemberMissionState(next.owner, root);
   return { mission: next, event };
@@ -1723,7 +1758,18 @@ function appendMemberLog(owner, title, fields = {}, root = process.cwd()) {
       .map(([key, value]) => `- ${key}: ${String(value).replace(/\n/g, ' ')}`),
     '',
   ];
-  fs.appendFileSync(logPath, rows.join('\n'), 'utf8');
+  let lead = '';
+  try {
+    const size = fs.statSync(logPath).size;
+    if (size > 0) {
+      const fd = fs.openSync(logPath, 'r');
+      const last = Buffer.alloc(1);
+      fs.readSync(fd, last, 0, 1, size - 1);
+      fs.closeSync(fd);
+      if (last[0] !== 0x0a) lead = '\n';
+    }
+  } catch {}
+  fs.appendFileSync(logPath, lead + rows.join('\n'), 'utf8');
   return logPath;
 }
 
@@ -3152,6 +3198,9 @@ function missionFromArgs(args) {
     '--base',
     '--task',
     '--ask',
+    '--campaign',
+    '--reserve',
+    '--mission-id',
     '--model',
     '--destination',
     '--native-goal-status',
@@ -3168,6 +3217,7 @@ function missionFromArgs(args) {
   const budgetContract = inferRunObjectiveBudgetContract(objective, args);
   const maxTicksOverride = readPositiveIntegerFlag(args, '--max-ticks', null, { json: wantsJson(args) });
   const requestedOwner = readFlag(args, '--owner', process.env.ATRIS_AGENT_ID || 'mission-lead');
+  const campaignId = readFlag(args, '--campaign', '');
   const cadence = readFlag(args, '--cadence', readFlag(args, '--loop', 'manual')) || 'manual';
   const engineFlag = readFlag(args, '--engine', '');
   const runnerSelection = engineFlag
@@ -3195,7 +3245,13 @@ function missionFromArgs(args) {
   const alwaysOn = hasFlag(args, '--always-on');
   const xpTaskEnabled = hasFlag(args, '--xp-task') || hasFlag(args, '--agent-xp');
   const businessBinding = readBusinessBinding(process.cwd());
-  const id = missionId(objective);
+  // A campaign proposes a mission under an id before it runs; --mission-id
+  // keeps that id so the campaign and the mission name the same thing.
+  const givenId = readFlag(args, '--mission-id', '');
+  if (givenId && !/^[a-z0-9][a-z0-9-]{2,120}$/.test(givenId)) {
+    exitMissionError('--mission-id takes lowercase letters, digits, and dashes', 2, wantsJson(args));
+  }
+  const id = givenId || missionId(objective);
   const mission = {
     schema: 'atris.mission.v1',
     id,
@@ -3221,6 +3277,7 @@ function missionFromArgs(args) {
     stop_condition: stopCondition,
     task_ids: taskIds,
     human_asks: humanAsks,
+    ...(campaignId ? { campaign_id: campaignId } : {}),
     ...(drive ? { drive } : {}),
     next_action: verifier ? 'run verifier with `atris mission tick <id> --verify`' : 'define verifier or run next task',
     receipt_path: null,
@@ -3910,6 +3967,30 @@ function readTasteReviewHistory(root, limit = 4) {
   return { accepted, revised };
 }
 
+// Why the mission's own task was last sent back, or '' when it was not. Ticks
+// run in a worktree, so fall back to the main checkout's task projection.
+function readBoundTaskTurnDown(mission, root) {
+  const bound = mission?.xp_task || mission?.selected_target_task || null;
+  if (!bound) return '';
+  const keys = new Set([bound.task_id, bound.id, bound.ref, bound.task_ref].filter(Boolean).map(String));
+  if (!keys.size) return '';
+  const roots = [root];
+  const common = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd: root, encoding: 'utf8' });
+  if (common.status === 0 && String(common.stdout || '').trim()) roots.push(path.dirname(String(common.stdout).trim()));
+  for (const dir of roots) {
+    const projection = readJson(path.join(dir, '.atris', 'state', 'tasks.projection.json'));
+    const tasks = Array.isArray(projection?.tasks) ? projection.tasks : [];
+    const task = tasks.find((row) => row && [row.id, row.display_id, row.legacy_ref].some((key) => key && keys.has(String(key))));
+    if (!task) continue;
+    const metadata = task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+    if (metadata.approval_status && metadata.approval_status !== 'revise') return '';
+    const events = (Array.isArray(task.events) ? task.events : []).filter((event) => event?.event_type === 'revision_requested');
+    const note = metadata.human_revision_note || events[events.length - 1]?.payload?.note || '';
+    return missionTasteSnippet(String(note), 600);
+  }
+  return '';
+}
+
 function missionTasteMemorySignals(text) {
   const definitions = [
     ['plain_language', 'the operator asks for plain English', /\b(plain|jargon|feynman|understand|simple|clarify|clarity)\b/i],
@@ -4310,6 +4391,7 @@ function seedMissionRunContinuation(parent, root = process.cwd(), proof = '') {
     ...mission,
     started_from: 'mission_run_continuation',
     parent_mission_id: parent.id,
+    ...(parent.campaign_id && campaignMissions().checkCampaignStart(root, parent.campaign_id, { reserveUsd: 0 }).ok ? { campaign_id: parent.campaign_id } : {}),
     parent_objective: parent.objective,
     continue_on_complete: false,
     continuation_policy: 'choose_next_mission',
@@ -4326,6 +4408,7 @@ function seedMissionRunContinuation(parent, root = process.cwd(), proof = '') {
     parent_objective: parent.objective,
     proof: proof || null,
   });
+  if (saved.campaign_id) campaignMissions().recordCampaignMissionStarted(root, saved, 0);
   const worktreeBaseline = captureMissionWorktreeBaseline(saved, root);
   const seededAt = stampIso();
   const { mission: updatedParent } = saveMission({
@@ -4411,7 +4494,7 @@ function startMission(args, options = {}) {
   const asJson = wantsJson(args);
   const firstArg = String(args[0] || '').trim().toLowerCase();
   if (args.length === 1 && (firstArg === '--help' || firstArg === '-h' || firstArg === 'help')) {
-    console.log('Usage: atris mission start "<objective>" --owner <member> --verify "..." [--destination "..."] [--no-verify] [--always-on] [--budget quick|long|deep] [--runner manual|claude|atris2|codex_goal|auto]');
+    console.log('Usage: atris mission start "<objective>" --owner <member> --verify "..." [--destination "..."] [--no-verify] [--always-on] [--budget quick|long|deep] [--runner manual|claude|atris2|codex_goal|auto] [--campaign <id> [--reserve <dollars>]]');
     console.log('Run `atris mission --help` for the full option list.');
     process.exit(0);
   }
@@ -4498,6 +4581,18 @@ function startMission(args, options = {}) {
       asJson,
     );
   }
+  // --campaign: the campaign must be open and able to hold this mission's
+  // reserve. Checked before any state exists, so a refusal leaves nothing behind.
+  let campaignReserve = 0;
+  if (mission.campaign_id) {
+    const check = campaignMissions().checkCampaignStart(process.cwd(), mission.campaign_id, { missionId: mission.id, reserveUsd: readFlag(args, '--reserve', '') });
+    if (!check.ok) exitMissionError(`mission start refused: ${check.error}`, 2, asJson);
+    try {
+      campaignMissions().reserveCampaignMission(process.cwd(), mission.campaign_id, mission.id, check.reserve, mission.owner || 'mission-lead');
+    } catch (error) {
+      exitMissionError(`mission start refused: ${error.message}`, 2, asJson);
+    }
+  }
   // --worktree: bind the mission to its own isolated checkout. We chdir before
   // any state writes so the mission record, baseline sidecar, receipts, and
   // member files all land inside the worktree, ticks run there, and the main
@@ -4589,6 +4684,7 @@ function startMission(args, options = {}) {
   const warnings = [missingVerifierWarning(mission), missingOwnerMemberWarning(mission.owner)].filter(Boolean);
   ensureMemberMissionFile(mission.owner, process.cwd(), mission.objective);
   const { mission: saved } = saveMission(assignMissionNumber(mission, process.cwd()), process.cwd(), 'mission_started', { objective: mission.objective });
+  if (saved.campaign_id) campaignMissions().recordCampaignMissionStarted(process.cwd(), saved, campaignReserve);
   const goalSlotHandoff = hasFlag(args, '--take-goal-slot') && isCodexGoalMission(saved)
     ? takeCodexGoalSlotForMission(saved, process.cwd())
     : null;
@@ -4709,6 +4805,8 @@ async function startMissionFromRunObjective(objective, args) {
   ];
   if (verifier) startArgs.push('--verify', verifier);
   if (budgetTier) startArgs.push('--budget', budgetTier.name);
+  const campaignFlag = readFlag(args, '--campaign', '');
+  if (campaignFlag) startArgs.push('--campaign', campaignFlag);
   if (maxTicksOverride) startArgs.push('--max-ticks', String(maxTicksOverride));
   const model = readFlag(args, '--model', '');
   if (model) startArgs.push('--model', model);
@@ -4716,6 +4814,16 @@ async function startMissionFromRunObjective(objective, args) {
   if (hasFlag(args, '--xp-task') || hasFlag(args, '--agent-xp') || missionRunPreflight?.task_spine_required) startArgs.push('--xp-task');
 
   const mission = markMissionRunContinuation(missionFromArgs(startArgs));
+  let campaignReserve = 0;
+  if (mission.campaign_id) {
+    const check = campaignMissions().checkCampaignStart(process.cwd(), mission.campaign_id, { missionId: mission.id, reserveUsd: readFlag(args, '--reserve', '') });
+    if (!check.ok) exitMissionError(`mission start refused: ${check.error}`, 2, wantsJson(args));
+    try {
+      campaignMissions().reserveCampaignMission(process.cwd(), mission.campaign_id, mission.id, check.reserve, mission.owner || 'mission-lead');
+    } catch (error) {
+      exitMissionError(`mission start refused: ${error.message}`, 2, wantsJson(args));
+    }
+  }
   if (landOwnerResolution) {
     mission.owner = runOwner;
     mission.owner_resolution = landOwnerResolution.reason || mission.owner_resolution;
@@ -4799,6 +4907,7 @@ async function startMissionFromRunObjective(objective, args) {
   const warnings = [missingVerifierWarning(mission), missingOwnerMemberWarning(mission.owner)].filter(Boolean);
   ensureMemberMissionFile(mission.owner, process.cwd(), mission.objective);
   const { mission: saved } = saveMission(assignMissionNumber(mission, process.cwd()), process.cwd(), 'mission_started', { objective: mission.objective, source: 'mission_run_objective' });
+  if (saved.campaign_id) campaignMissions().recordCampaignMissionStarted(process.cwd(), saved, campaignReserve);
   if (landRun) {
     const memberState = renderMemberMissionState(saved.owner);
     const logPath = appendMemberLog(saved.owner, 'Mission landing flight dispatched', {
@@ -6556,7 +6665,7 @@ function runVerifier(command, root = process.cwd()) {
   const resolvedCommand = resolveVerifierCommand(command);
   const { envWithNodeDir } = require('../lib/spawn-env');
   const timeoutMs = missionVerifierTimeoutMs();
-  const startedAt = Date.now();
+  const startedAt = process.hrtime.bigint();
   const result = spawnSync(resolvedCommand, {
     cwd: root,
     shell: true,
@@ -6564,11 +6673,15 @@ function runVerifier(command, root = process.cwd()) {
     timeout: timeoutMs,
     env: envWithNodeDir(process.env),
   });
-  const elapsedMs = Date.now() - startedAt;
   // A verifier that blows its window is not a failing check: the code may be
   // fine and the suite merely slow (or starved by a concurrent flight). Report
   // it as a distinct timed-out state so operators do not read slow as broken.
   const timedOut = result.error ? result.error.code === 'ETIMEDOUT' : false;
+  // Steady clock, not wall time: the wall clock can slew, and a kill at the
+  // window once read as 927ms of a 1000ms window. A timed-out run used the
+  // whole window by definition.
+  const measuredMs = Number((process.hrtime.bigint() - startedAt) / 1000000n);
+  const elapsedMs = timedOut ? Math.max(measuredMs, timeoutMs) : measuredMs;
   return {
     command,
     resolved_command: resolvedCommand === command ? null : resolvedCommand,
@@ -6588,17 +6701,29 @@ const CHECK_FEEDBACK_TRIM_MARKER = 'output trimmed';
 
 function extractCheckFeedback(verifierResult) {
   if (!verifierResult || verifierResult.passed !== false) return '';
-  const lines = [verifierResult.output, verifierResult.stdout, verifierResult.stderr]
+  // A reviewer turn-down goes first: when the tests passed, it is the only
+  // real reason the try failed, and passing test names must not crowd it out.
+  const referee = verifierResult.referee && verifierResult.referee.passed === false
+    ? verifierResult.referee
+    : null;
+  const refereeLines = referee
+    ? [referee.reason, referee.output].filter((value) => String(value || '').trim())
+    : [];
+  const lines = [...new Set([...refereeLines, verifierResult.output, verifierResult.stdout, verifierResult.stderr]
     .filter((value) => String(value || '').trim())
     .flatMap((value) => String(value).split(/\r?\n/))
     .map((line) => line.trim())
-    .filter(Boolean);
+    .filter(Boolean))];
   if (!lines.length) return '';
 
+  const refereeSet = new Set(refereeLines.flatMap((value) => String(value).split(/\r?\n/)).map((line) => line.trim()).filter(Boolean));
+  const passingLine = /^(?:✔|ℹ )/;
   const usefulPattern = /\b(?:error|fail|expected|assert)\w*\b|(?:^|\s|\()[^:\s()]+:\d+(?::\d+)?(?:\b|$)/i;
-  const useful = lines.filter((line) => usefulPattern.test(line));
-  const context = lines.filter((line) => !usefulPattern.test(line));
-  const feedback = [...useful, ...context].join('\n');
+  const rest = lines.filter((line) => !refereeSet.has(line));
+  const useful = rest.filter((line) => !passingLine.test(line) && usefulPattern.test(line));
+  const context = rest.filter((line) => !passingLine.test(line) && !usefulPattern.test(line));
+  const passing = rest.filter((line) => passingLine.test(line));
+  const feedback = [...lines.filter((line) => refereeSet.has(line)), ...useful, ...context, ...passing].join('\n');
   if (feedback.length <= CHECK_FEEDBACK_LIMIT) return feedback;
 
   const contentLimit = CHECK_FEEDBACK_LIMIT - CHECK_FEEDBACK_TRIM_MARKER.length - 1;
@@ -6837,7 +6962,10 @@ function worktreeReceipt(before, after, { verifier = '', baseline = null } = {})
 const MISSION_RUN_DEFAULTS = {
   maxTicks: 4,
   maxWallSeconds: 3600,
-  claudeTimeoutMs: 10 * 60 * 1000,
+  // Sized from real runs: claude ticks that landed 10/08-10/14 ran a median
+  // 4 min, but 15 of 92 needed more than 10 and the slowest 5% took 17+.
+  // A 10 min cap killed 12 runs at exactly 10:00; 20 min fits 89 of 92.
+  claudeTimeoutMs: 20 * 60 * 1000,
   backoff: { initialMs: 30_000, maxMs: 10 * 60_000, factor: 2, jitter: 0.3 },
 };
 
@@ -8824,6 +8952,45 @@ function consumeMissionPings(mission, cwd) {
   return { mission: saved, pings: pending };
 }
 
+// A one-tick job has no next prompt. Deliver notes that arrived while the
+// worker ran before checking its work, within the same wall budget. Only a
+// successful worker response acknowledges a batch; failed delivery can retry.
+async function deliverLateMissionPings(mission, cwd, firstResult, { run, remainingMs, prompt }) {
+  let result = firstResult;
+  let delivered = 0;
+  while (result.ok) {
+    const latest = resolveMission(mission.id, cwd) || mission;
+    const pending = pendingMissionPings(latest);
+    if (!pending.length || TERMINAL_STATUSES.has(latest.status)) break;
+    if (remainingMs() <= 0) {
+      return { ...result, ok: false, timedOut: true, error: 'unread notes at the wall limit' };
+    }
+    const next = await run([
+      prompt,
+      '',
+      '## Notes received before this job finished',
+      'This is the same work step. Read and apply these notes before returning the final receipt. Do not start a second slice.',
+      ...pending.map((p) => `- [${p.at}] ${p.from || 'operator'}: ${p.text}`),
+      '',
+      'Previous work receipt:',
+      result.receipt_text || result.result || '',
+    ].join('\n'));
+    if (!next.ok) return next;
+    // Re-read so notes sent during delivery survive the acknowledgement.
+    const fresh = resolveMission(mission.id, cwd) || latest;
+    const keys = new Set(pending.map((p) => JSON.stringify([p.at, p.from, p.text])));
+    const consumedAt = stampIso();
+    saveMission({
+      ...fresh,
+      pings: (fresh.pings || []).map((p) => p && !p.consumed_at && keys.has(JSON.stringify([p.at, p.from, p.text]))
+        ? { ...p, consumed_at: consumedAt } : p),
+    }, cwd, 'mission_pings_consumed', { count: pending.length });
+    delivered += pending.length;
+    result = { ...next, operator_notes_read: delivered };
+  }
+  return result;
+}
+
 function readBoundedContextFile(filePath, maxChars = 1600) {
   try {
     if (!fs.existsSync(filePath)) return '';
@@ -8938,6 +9105,16 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = [], cwd =
       checkFeedback,
     ]
     : [];
+  let turnDown = '';
+  try { turnDown = readBoundTaskTurnDown(mission, mission.worktree_root || mission.worktree?.path || cwd); } catch {}
+  const turnDownLines = turnDown
+    ? [
+      ``,
+      `## why the last try was turned down`,
+      `the reviewer sent this task back. fix this before anything else.`,
+      turnDown,
+    ]
+    : [];
   const preloadedContextLines = buildPreloadedMemberContextLines(mission, cwd);
   const lines = [
     `# Mission Tick ${tickIndex}/${maxTicks}`,
@@ -8953,6 +9130,7 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = [], cwd =
     `**Last tick:** ${mission.last_tick_at || 'never'}`,
     ...missionBudgetPromptLines(mission),
     ...checkFeedbackLines,
+    ...turnDownLines,
     ...(sharedProcess ? ['', sharedProcess] : []),
     ...preloadedContextLines,
     ``,
@@ -9183,6 +9361,22 @@ function tooDeepRunnerResult(depth) {
   };
 }
 
+// Machine memory and load at both ends of a tick, like a dispatch, so a
+// killed tick still says whether the machine was short on memory. The
+// returned end writes once, whichever of close or error comes first.
+function startTickResource(cwd, engine, mission) {
+  const { recordEngineResource } = require('../lib/engine-resource');
+  const resource = { engine: engine || 'runner', task: mission.task_id || mission.id || '', run_id: crypto.randomUUID() };
+  recordEngineResource(cwd, { phase: 'start', ...resource });
+  const startedAt = process.hrtime.bigint();
+  let ended = false;
+  return ({ signal = null, timedOut = false, error = '' } = {}) => {
+    if (ended) return;
+    ended = true;
+    recordEngineResource(cwd, { phase: 'end', ...resource, signal, timed_out: timedOut, error, duration_ms: Math.round(Number(process.hrtime.bigint() - startedAt) / 1e6) });
+  };
+}
+
 function spawnGenericRunnerTick(mission, opts) {
   const { sessionId, cwd, signal, timeoutMs, prompt, model, missionLock } = opts;
   const dispatchDepth = missionDispatchDepth();
@@ -9241,7 +9435,17 @@ function spawnGenericRunnerTick(mission, opts) {
     }
 
     const startedAt = Date.now();
-    const guardedCommand = `PATH=${shellQuote(gitGuard.pathPrefix)}:$PATH; export PATH; ${cmd}`;
+    const endResource = startTickResource(cwd, canonicalEngineName(mission.runner), mission);
+    const progressMember = mission.owner || 'mission';
+    // A codex run opens its shell script with the run marker as a no-op, so
+    // member stop can prove the shell leading this group is this run. Only
+    // names member stop accepts go into the shell line.
+    const runToken = lastMessageFile && /^[A-Za-z0-9._-]+$/.test(progressMember) ? newRunToken() : '';
+    const markerPrefix = runToken ? `: ${runMarker(progressMember, runToken)}; ` : '';
+    // The trailing exit keeps a shell like dash from replacing itself with
+    // codex, which would take the marker out of the process list.
+    const markerSuffix = runToken ? '; exit $?' : '';
+    const guardedCommand = `${markerPrefix}PATH=${shellQuote(gitGuard.pathPrefix)}:$PATH; export PATH; ${cmd}${markerSuffix}`;
     const proc = spawn('sh', ['-lc', guardedCommand], {
       cwd,
       stdio: ['ignore', 'pipe', 'pipe'],
@@ -9249,9 +9453,11 @@ function spawnGenericRunnerTick(mission, opts) {
       env: { ...gitGuard.env, ATRIS_DISPATCH_DEPTH: String(dispatchDepth.depth + 1) },
     });
     updateMissionLockOwner(missionLock, proc.pid, { phase: 'tick' });
-    const progressMember = mission.owner || 'mission';
     const seenItemIds = new Set();
-    if (lastMessageFile) appendProgress(progressMember, `started: ${mission.objective || ''}`, mission.id);
+    if (lastMessageFile) {
+      const tag = runToken ? { pid: proc.pid, engine: 'codex', run: runToken } : {};
+      appendProgress(progressMember, startedLine(mission.objective, tag), mission.id);
+    }
     let stdout = '';
     let eventBuf = '';
     let lastAgentMessage = '';
@@ -9303,8 +9509,10 @@ function spawnGenericRunnerTick(mission, opts) {
     });
     proc.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
 
-    proc.on('close', (code) => {
+    proc.on('close', (code, closeSignal) => {
       clearTimeout(timer);
+      // The shell returns 128 + 9 when its engine child was force-killed.
+      endResource({ signal: closeSignal || (code === 137 ? 'SIGKILL' : null), timedOut, error: code === 0 ? '' : stderr.slice(-2000) });
       if (lastMessageFile && eventBuf.trim()) readCodexEvent(eventBuf.trim());
       let finalText = String(stdout || '').trim();
       if (lastMessageFile) {
@@ -9342,6 +9550,7 @@ function spawnGenericRunnerTick(mission, opts) {
 
     proc.on('error', (e) => {
       clearTimeout(timer);
+      endResource({ timedOut, error: e.message });
       cleanupPrompt();
       gitGuard.cleanup();
       if (signal) signal.removeEventListener?.('abort', onAbort);
@@ -9426,6 +9635,7 @@ function spawnClaudeTick(mission, opts) {
     // 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 endResource = startTickResource(cwd, 'claude', mission);
     const proc = spawn(resolveClaudeRunnerBin(), args, {
       cwd,
       stdio: ['ignore', 'pipe', 'pipe'],
@@ -9504,8 +9714,9 @@ function spawnClaudeTick(mission, opts) {
 
     proc.stderr.on('data', (c) => { stderr += c.toString(); });
 
-    proc.on('close', (code) => {
+    proc.on('close', (code, closeSignal) => {
       clearTimeout(timer);
+      endResource({ signal: closeSignal, timedOut, error: code === 0 ? '' : stderr.slice(-2000) });
       gitGuard.cleanup();
       if (signal) signal.removeEventListener?.('abort', onAbort);
       updateMissionLockOwner(missionLock, missionLock?.driverPid);
@@ -9538,6 +9749,7 @@ function spawnClaudeTick(mission, opts) {
 
     proc.on('error', (e) => {
       clearTimeout(timer);
+      endResource({ timedOut, error: e.message });
       gitGuard.cleanup();
       updateMissionLockOwner(missionLock, missionLock?.driverPid);
       resolve({ ok: false, error: e.message, sessionIds: [], aborted, timedOut, authExpired: false });
@@ -9548,14 +9760,42 @@ function spawnClaudeTick(mission, opts) {
 const ENGINE_VERIFY_TIMEOUT_MS = 5 * 60 * 1000;
 const ENGINE_VERIFY_OUTPUT_LIMIT = 4000;
 
-function buildEngineVerifyPrompt(mission, tickIndex) {
+// The job's own done-looks-like line, so the reviewer judges the work against
+// what the job promised instead of the mission headline alone. Only a line the
+// job wrote down counts: a derived fallback ("it clears review") hands the
+// reviewer a target that says nothing. Any lookup failure means no line.
+function missionDoneLooksLike(mission, root = process.cwd()) {
+  try {
+    const task = findOpenTaskMatchingMissionObjective(mission, root, true);
+    if (!task) return '';
+    const explanation = require('../lib/task-explanation').taskExplanation(task);
+    return explanation.sources.done_looks_like === 'explicit' ? explanation.done_looks_like : '';
+  } catch {
+    return '';
+  }
+}
+
+function buildEngineVerifyPrompt(mission, tickIndex, doneLooksLike = '', { timeoutMs = ENGINE_VERIFY_TIMEOUT_MS, checkPassed = '' } = {}) {
+  const doneLine = String(doneLooksLike || '').replace(/\s+/g, ' ').trim();
+  const minutes = Math.max(1, Math.round(timeoutMs / 60000));
   return [
     `# Verify Mission Tick ${tickIndex}`,
     ``,
     `This is a bounded verify-only pass for mission: ${mission.objective}`,
+    ...(doneLine ? [
+      `The job says done looks like: ${doneLine}`,
+      `Compare the work against that line. If the work does not show it, the verdict is FAIL even when the checks pass.`,
+      `Split that line into each separate thing it promises and check every one. List each part as met or missing.`,
+      `Work that does only some of the parts is not done. If any part is missing, end with 'VERDICT: FAIL; missing: <that part>'.`,
+    ] : []),
     `Read the diff this tick produced. Do not edit files and do not start another work slice.`,
     `ACTUALLY RUN the changed surface on this computer using real commands and real exit codes.`,
     `Paste the commands and their real output. Do not accept a receipt claim or static inspection as execution proof.`,
+    // Reviews that outran the clock were 11 of 25 turn-downs (10/11 to 10/14).
+    `You have ${minutes} minutes. Leave time to write the verdict; running out of time counts as a fail.`,
+    ...(checkPassed ? [`The mission check \`${checkPassed}\` already passed on this exact code. Do not run it again.`] : []),
+    `Prove the change with the narrowest real run: the changed command, or one test file or one named test.`,
+    `Do not run whole test suites or large test files; on a busy machine they outlast your time.`,
     `End your reply with a final line exactly 'VERDICT: PASS' or 'VERDICT: FAIL'.`,
   ].join('\n');
 }
@@ -9617,7 +9857,10 @@ async function runEngineVerifier(mission, options = {}) {
       cwd,
       signal: options.signal,
       timeoutMs: ENGINE_VERIFY_TIMEOUT_MS,
-      prompt: buildEngineVerifyPrompt(mission, options.tickIndex || 1),
+      prompt: buildEngineVerifyPrompt(mission, options.tickIndex || 1, missionDoneLooksLike(mission, cwd), {
+        timeoutMs: ENGINE_VERIFY_TIMEOUT_MS,
+        checkPassed: options.checkPassed || '',
+      }),
       model: resolveMissionTickRunnerModel(verifyMission),
     });
   } catch (error) {
@@ -9671,6 +9914,20 @@ function cappedClaudeReceiptText(text, limit = 4000) {
   return clean.slice(0, limit - 16).trimEnd() + '\n...[truncated]';
 }
 
+// The receipt keeps a capped copy of the runner's report. When the report is
+// longer than that, the whole text goes to its own file beside the receipts
+// so nothing the member wrote is lost.
+function saveFullRunnerReport(mission, text, root = process.cwd()) {
+  const clean = String(text || '').trim();
+  if (!clean || cappedClaudeReceiptText(clean) === clean) return null;
+  const runsDir = statePaths(root).runsDir;
+  fs.mkdirSync(runsDir, { recursive: true });
+  const safeTime = stampIso().replace(/[:.]/g, '-');
+  const reportPath = path.join(runsDir, `mission-${mission.id}-${safeTime}-report.md`);
+  fs.writeFileSync(reportPath, clean + '\n', 'utf8');
+  return path.relative(root, reportPath);
+}
+
 async function parseAndValidateMissionRunPhase(args) {
   const asJson = wantsJson(args);
   const context = {
@@ -10062,6 +10319,9 @@ async function executeMissionRunTicksPhase(context) {
     let cycleTickLimit = effectiveMaxTicks;
     while (true) {
       while (ticks.length < cycleTickLimit) {
+        // A campaign that is done, paused, or out of money stops its missions.
+        const campaignStop = mission.campaign_id ? campaignMissions().campaignGate(cwd, mission) : null;
+        if (campaignStop) { pauseReason = campaignStop; break; }
         // 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.
@@ -10201,8 +10461,8 @@ async function executeMissionRunTicksPhase(context) {
           }, Math.max(1, Math.floor(remainingWall * 1000)));
           let turn;
           try {
-            turn = await runAtris2Turn({
-              prompt,
+            const runTurn = (direction) => runAtris2Turn({
+              prompt: direction,
               model: tickRuntimeMission.model || 'atris:fast',
               business: businessId,
               maxTurns: 16,
@@ -10213,6 +10473,16 @@ async function executeMissionRunTicksPhase(context) {
               localEnv: atris2GitGuard.env,
               localPathPrefix: atris2GitGuard.pathPrefix,
             });
+            turn = await runTurn(prompt);
+            turn = await deliverLateMissionPings(mission, cwd, { ...turn, receipt_text: turn.text }, {
+              prompt,
+              remainingMs: () => (maxWallSeconds * 1000) - (Date.now() - startedAt),
+              run: async (direction) => {
+                const next = await runTurn(direction);
+                return { ...next, receipt_text: next.text };
+              },
+            });
+            mission = resolveMission(mission.id, cwd) || mission;
           } finally {
             atris2GitGuard.cleanup();
             clearTimeout(tickTimer);
@@ -10228,6 +10498,7 @@ async function executeMissionRunTicksPhase(context) {
             error: turn.error,
             backend_unavailable: isTransientAtris2BackendError(turn.error) || undefined,
             receipt_text: String(turn.text || '').slice(0, 4000),
+            operator_notes_read: turn.operator_notes_read,
           };
           tickWorkerRun = { endedMs: Date.now(), usage: {} };
           if (controller.signal.aborted) { pauseReason = 'aborted-during-atris2'; break; }
@@ -10261,14 +10532,14 @@ async function executeMissionRunTicksPhase(context) {
         const restoreTickRunnerProfile = tickEngineId ? applyMissionRunnerProfile(tickEngineId) : () => {};
         let claudeResult;
         let sessionBusyRetried = false;
-        const runClaudeSession = () => spawnClaudeTick(tickRuntimeMission, {
+        const runClaudeSession = (direction = workerPrompt) => spawnClaudeTick(tickRuntimeMission, {
           sessionMode, sessionId: useId, cwd, signal: controller.signal,
           missionLock: lock,
           timeoutMs: missionTickTimeoutMs(
             tickRuntimeMission,
             (maxWallSeconds - ((Date.now() - startedAt) / 1000)) * 1000,
           ),
-          prompt: workerPrompt,
+          prompt: direction,
           model: resolveMissionTickRunnerModel(tickRuntimeMission),
         });
         try {
@@ -10285,17 +10556,30 @@ async function executeMissionRunTicksPhase(context) {
             useId = pendingSessionId;
             claudeResult = await runClaudeSession();
           }
+          claudeResult = await deliverLateMissionPings(mission, cwd, claudeResult, {
+            prompt: workerPrompt,
+            remainingMs: () => (maxWallSeconds * 1000) - (Date.now() - startedAt),
+            run: (direction) => {
+              // Claude needs to resume the session it just confirmed. Generic
+              // runners receive the earlier receipt in the delivery prompt.
+              if (claudeResult.sessionIds?.includes(useId)) sessionMode = 'resume';
+              return runClaudeSession(direction);
+            },
+          });
+          mission = resolveMission(mission.id, cwd) || mission;
         } finally {
           restoreTickRunnerProfile();
         }
         tickWorkerRun = { endedMs: Date.now(), usage: (claudeResult && claudeResult.run_usage) || {}, prep: tickPrep, startedAt: workerStartedAt };
         result.claude = {
           ok: claudeResult.ok,
+          error: claudeResult.error,
           reason: claudeResult.reason,
           protected_lane_guard: claudeResult.protected_lane_guard || null,
           brief_id: claudeResult.brief_id || null,
           summary: claudeResult.summary,
           receipt_text: claudeResult.receipt_text,
+          report_path: saveFullRunnerReport(mission, claudeResult.result, cwd),
           stop_reason: claudeResult.stop_reason,
           api_equivalent_estimate: claudeResult.api_equivalent_estimate,
           duration_total_ms: claudeResult.duration_total_ms,
@@ -10306,6 +10590,7 @@ async function executeMissionRunTicksPhase(context) {
           timed_out: claudeResult.timedOut,
           aborted: claudeResult.aborted,
           session_busy_retry: sessionBusyRetried || undefined,
+          operator_notes_read: claudeResult.operator_notes_read,
         };
         if (claudeResult.rate_limit_info) {
           // Claude reports the five-hour window's resetsAt on every turn, even
@@ -10320,7 +10605,7 @@ async function executeMissionRunTicksPhase(context) {
 
         if (!claudeResult.ok) {
           const deadModel = detectUnavailableModel(claudeResult.summary || claudeResult.receipt_text);
-          const wallBoundTimeout = remainingWall * 1000 <= MISSION_RUN_DEFAULTS.claudeTimeoutMs;
+          const wallBoundTimeout = missionTickWallBound(tickRuntimeMission, remainingWall * 1000);
           let reason = claudeResult.reason === 'too-deep'
             ? 'too-deep'
             : claudeResult.timedOut
@@ -10410,6 +10695,7 @@ async function executeMissionRunTicksPhase(context) {
           prep: tickWorkerRun.prep || null,
         });
       }
+      if (mission.campaign_id && !cachedStep) campaignMissions().recordCampaignTick(cwd, mission, { ...((tickWorkerRun && tickWorkerRun.usage) || {}), ...(tickEngineId ? { engine: tickEngineId } : {}) });
       let receiptPath = cachedStep ? cachedStep.receipt_path : null;
 
       // Review-lane drain: always-on loops sweep the agent-safe review actions
@@ -10557,7 +10843,7 @@ async function executeMissionRunTicksPhase(context) {
         mission: mission.objective,
         state: mission.status,
         tick_status: result.status,
-        reason: result.reason,
+        reason: memberLogTickReason(result),
         layer: result.layer || undefined,
         verifier: verifierResult ? (verifierResult.passed ? 'passed' : 'failed') : 'not_run',
         summary: tickSummaryText ? tickSummaryText.slice(0, 240) : undefined,
@@ -10771,6 +11057,7 @@ async function verifyMissionRunTickPhase(context) {
         signal: controller.signal,
         tickIndex: currentTick.tickIdx,
         refereeEngine: context.refereeEngine,
+        checkPassed: verifierResult?.passed ? currentTick.frozen.verifier : '',
       });
       const afterReview = gitCodeState(cwd);
       const codeMoved = beforeReview.tree !== afterReview.tree
@@ -12415,6 +12702,7 @@ function missionCommand(args) {
 }
 
 module.exports = {
+  listSiblingWorkspaceMissionHints,
   missionProtectedLaneHold,
   missionCommand,
   startMission,
@@ -12467,6 +12755,7 @@ module.exports = {
   missionVerifierCheckedText,
   missionVerifierHighLevelTestText,
   buildEngineVerifyPrompt,
+  missionDoneLooksLike,
   engineVerifierResultFromRun,
   pickCrossEngineVerifier,
   runVerifier,
@@ -12477,6 +12766,8 @@ module.exports = {
   resolveMissionTickRunner,
   resolveMissionTickRunnerModel,
   missionTickTimeoutMs,
+  missionTickWallBound,
+  memberLogTickReason,
   engineFailureHealthStatus,
   recordMissionEngineTickOutcome,
   recordMissionTickRosterRun,