atris 3.15.56 → 3.16.0

package/commands/mission.js

@@ -191,7 +191,7 @@ function createMissionXpTask(mission, root = process.cwd(), asJson = false) {
     taskDb.noteTask(db, {
       id: task.id,
       actor: process.env.ATRIS_AGENT_ID || mission.owner || 'mission-lead',
-      content: `Mission goal loop XP bridge for ${mission.id}. Proof goes through task ready; AgentXP lands only after human accept.`,
+      content: `Mission goal loop XP bridge for ${mission.id}. Proof goes through task current-step; AgentXP lands only after human accept.`,
     });
   }
   const { outPath } = writeMissionTaskProjection(taskDb, db, workspaceRoot);
@@ -262,6 +262,36 @@ function listMissions(root = process.cwd()) {
     .sort((a, b) => String(b.updated_at || b.created_at || '').localeCompare(String(a.updated_at || a.created_at || '')));
 }
 
+// Cross-worktree rollup: missions started with --worktree keep their state inside
+// that worktree, so a plain `mission status` from any single checkout is blind to
+// them. Enumerate sibling git worktrees and surface their missions read-only.
+function listWorktreeRollupMissions(root = process.cwd()) {
+  let entries = [];
+  try {
+    entries = require('./worktree').listWorktrees(root);
+  } catch {
+    return []; // not a git repo (or git unavailable): nothing to roll up
+  }
+  let here = root;
+  try {
+    here = fs.realpathSync(root);
+  } catch { /* keep raw path */ }
+  const rolled = [];
+  for (const entry of entries) {
+    let wtRoot;
+    try {
+      wtRoot = fs.realpathSync(entry.path);
+    } catch {
+      continue; // stale worktree record
+    }
+    if (wtRoot === here) continue;
+    for (const mission of listMissions(wtRoot)) {
+      rolled.push({ ...mission, worktree_root: entry.path, worktree_branch: entry.branch });
+    }
+  }
+  return rolled;
+}
+
 function resolveMission(ref, root = process.cwd()) {
   const missions = listMissions(root);
   if (!ref) return missions.find((mission) => !TERMINAL_STATUSES.has(mission.status)) || missions[0] || null;
@@ -422,6 +452,13 @@ function renderMemberMissionState(owner, root = process.cwd()) {
   return { missionPath, nowPath };
 }
 
+// One glanceable label for how a mission earned its completion: evidence
+// source when the gate passed, an explicit marker when an operator forced it.
+function completionGateLabel(gate) {
+  if (!gate) return null;
+  return gate.forced ? `forced override (${gate.source})` : gate.source;
+}
+
 function renderMissionStatus(root = process.cwd()) {
   const paths = statePaths(root);
   const missions = listMissions(root);
@@ -443,6 +480,8 @@ function renderMissionStatus(root = process.cwd()) {
       lines.push(`  - next: ${mission.next_action || 'tick or verify'}`);
       if (mission.xp_task?.ref) lines.push(`  - AgentXP task: ${mission.xp_task.ref}`);
       if (mission.receipt_path) lines.push(`  - proof: ${mission.receipt_path}`);
+      const gateLabel = completionGateLabel(mission.completion_gate);
+      if (gateLabel) lines.push(`  - gate: ${gateLabel}`);
     }
     lines.push('');
   }
@@ -461,7 +500,8 @@ function missionXpTaskRefFromMission(mission) {
 function missionXpReadyAction(mission, receiptPath) {
   const ref = missionXpTaskRefFromMission(mission);
   if (!ref || !receiptPath) return null;
-  return `queue AgentXP review: atris task ready ${ref} --proof "${receiptPath}"`;
+  const owner = mission.owner || process.env.ATRIS_AGENT_ID || 'mission-lead';
+  return `queue AgentXP review: atris task current-step --goal-id ${mission.id} --as ${owner} --proof "${receiptPath}" --json`;
 }
 
 function missionFromArgs(args) {
@@ -475,9 +515,9 @@ function missionFromArgs(args) {
     '--stop',
     '--task',
     '--ask',
-  ], ['--json', '--always-on', '--xp-task', '--agent-xp']).join(' ').trim();
+  ], ['--json', '--always-on', '--xp-task', '--agent-xp', '--worktree']).join(' ').trim();
   if (!objective) {
-    exitMissionError('Usage: atris mission start "<objective>" --owner <member> [--verify "..."] [--cadence manual]', 1, wantsJson(args));
+    exitMissionError('Usage: atris mission start "<objective>" --owner <member> [--verify "..."] [--cadence manual] [--worktree]', 1, wantsJson(args));
   }
   const owner = readFlag(args, '--owner', process.env.ATRIS_AGENT_ID || 'mission-lead');
   const cadence = readFlag(args, '--cadence', readFlag(args, '--loop', 'manual')) || 'manual';
@@ -527,12 +567,27 @@ function missingVerifierWarning(mission) {
 function startMission(args) {
   const asJson = wantsJson(args);
   const mission = missionFromArgs(args);
+  // --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
+  // checkout's dirt never reaches the mission baseline.
+  if (hasFlag(args, '--worktree')) {
+    let created;
+    try {
+      const { createAgentWorktree } = require('./worktree');
+      created = createAgentWorktree({ member: mission.owner, task: mission.objective });
+    } catch (e) {
+      exitMissionError(`[mission start] worktree creation failed: ${e.message}`, 2, asJson);
+    }
+    mission.worktree = { path: created.path, branch: created.branch, base: created.base };
+    process.chdir(created.path);
+  }
   if (mission.xp_task_enabled) {
     const xpTask = createMissionXpTask(mission, process.cwd(), asJson);
     mission.xp_task = xpTask;
     mission.task_ids = Array.from(new Set([...(mission.task_ids || []), xpTask.task_id]));
     if (!mission.verifier && !mission.always_on) {
-      mission.next_action = `work task then run: atris task ready ${xpTask.ref} --proof "<proof>"`;
+      mission.next_action = `work task then run: atris task current-step --goal-id ${mission.id} --as ${mission.owner} --proof "<proof>" --json`;
     }
   }
   const warnings = [missingVerifierWarning(mission)].filter(Boolean);
@@ -546,15 +601,17 @@ function startMission(args) {
     lane: saved.lane,
     verifier: saved.verifier,
   });
+  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 },
+    { 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 },
     [
       `Started mission: ${saved.objective}`,
       `Owner: ${saved.owner}`,
       `State: ${saved.status}`,
+      ...(saved.worktree ? [`Worktree: ${saved.worktree.path}`, `Branch: ${saved.worktree.branch}`] : []),
       ...warnings.map((warning) => `Warning: ${warning.message}`),
       ...(saved.xp_task ? [`AgentXP task: ${saved.xp_task.ref}`] : []),
-      `Next: atris mission tick ${saved.id}`,
+      ...(saved.worktree ? [`Next: cd ${saved.worktree.path} && atris mission tick ${saved.id}`] : [`Next: atris mission tick ${saved.id}`]),
     ],
     asJson,
   );
@@ -562,19 +619,30 @@ function startMission(args) {
 
 function statusMission(args) {
   const asJson = wantsJson(args);
-  const ref = stripKnownFlags(args, ['--status', '--limit'], ['--json'])[0] || '';
+  const localOnly = hasFlag(args, '--local');
+  const ref = stripKnownFlags(args, ['--status', '--limit'], ['--json', '--local'])[0] || '';
   const statusFilter = readFlag(args, '--status', '');
   if (statusFilter && !VALID_STATUSES.has(statusFilter) && !STATUS_ALIASES.has(statusFilter)) {
     exitMissionError(`Invalid --status: ${statusFilter}`, 2, asJson);
   }
   const limit = readPositiveIntegerFlag(args, '--limit', null, { json: asJson });
   let missions = ref ? [resolveMission(ref)].filter(Boolean) : listMissions();
+  if (!ref && !localOnly) {
+    const seen = new Set(missions.map((mission) => mission.id));
+    for (const rolled of listWorktreeRollupMissions()) {
+      if (seen.has(rolled.id)) continue;
+      seen.add(rolled.id);
+      missions.push(rolled);
+    }
+    missions.sort((a, b) => String(b.updated_at || b.created_at || '').localeCompare(String(a.updated_at || a.created_at || '')));
+  }
   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);
   }
-  for (const owner of new Set(missions.map((mission) => mission.owner).filter(Boolean))) {
+  // Member state renders are cwd-local writes; rolled-up missions stay read-only.
+  for (const owner of new Set(missions.filter((mission) => !mission.worktree_root).map((mission) => mission.owner).filter(Boolean))) {
     renderMemberMissionState(owner);
   }
   const payload = {
@@ -593,8 +661,10 @@ function statusMission(args) {
         `  id: ${mission.id}`,
         `  owner: ${mission.owner}`,
         `  state: ${mission.status}`,
+        ...(mission.worktree_root ? [`  worktree: ${mission.worktree_root}`] : []),
         `  next: ${mission.next_action || 'tick or verify'}`,
         ...(mission.receipt_path ? [`  proof: ${mission.receipt_path}`] : []),
+        ...(completionGateLabel(mission.completion_gate) ? [`  gate: ${completionGateLabel(mission.completion_gate)}`] : []),
       ])
       : ['No missions yet. Run: atris mission start "..." --owner <member>'],
     asJson,
@@ -657,6 +727,38 @@ function runVerifier(command, root = process.cwd()) {
   };
 }
 
+const REVIEW_LANE_DRAIN_TIMEOUT_MS = 120000;
+
+// Bounded agent-side review sweep, recorded on the tick. Failures never break
+// the mission loop; they surface in the tick record instead.
+function runReviewLaneDrain(root = process.cwd()) {
+  const cliPath = path.resolve(__dirname, '..', 'bin', 'atris.js');
+  const res = spawnSync(process.execPath, [cliPath, 'task', 'review-lane-run', '--json'], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: REVIEW_LANE_DRAIN_TIMEOUT_MS,
+  });
+  let receipt = null;
+  try {
+    receipt = JSON.parse(res.stdout);
+  } catch { /* fall through to error shape */ }
+  if (!receipt) {
+    return {
+      ok: false,
+      error: 'review_lane_run_unparseable',
+      status: res.status ?? null,
+      stderr: String(res.stderr || '').slice(-400),
+    };
+  }
+  return {
+    ok: receipt.ok === true,
+    run_count: receipt.run_count ?? null,
+    total_acted_count: receipt.total_acted_count ?? 0,
+    stopped_reason: receipt.stopped_reason || null,
+    receipt_path: receipt.receipt_path || null,
+  };
+}
+
 function gitWorktreeSnapshot(root = process.cwd()) {
   const inside = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], {
     cwd: root,
@@ -689,7 +791,77 @@ function gitWorktreeSnapshot(root = process.cwd()) {
   };
 }
 
-function worktreeReceipt(before, after, { verifier = '' } = {}) {
+// Porcelain v1 entries are "XY path" or "XY old -> new"; baselines compare by
+// post-rename path so a status-letter change alone never counts as new dirt.
+function porcelainEntryPath(line) {
+  const trimmed = String(line || '').slice(3);
+  const arrow = trimmed.indexOf(' -> ');
+  return arrow >= 0 ? trimmed.slice(arrow + 4) : trimmed;
+}
+
+const LOOP_EXHAUST_PREFIXES = ['.atris/', 'atris/runs/', 'atris/status/'];
+
+function isLoopExhaustPath(entryPath) {
+  return LOOP_EXHAUST_PREFIXES.some((prefix) => String(entryPath).startsWith(prefix));
+}
+
+function missionBaselinePath(missionId, root = process.cwd()) {
+  return path.join(root, '.atris', 'state', 'mission-baselines', `${missionId}.json`);
+}
+
+// Write-once sidecar capturing the dirt the mission inherited. Receipts subtract
+// these paths so pre-existing workspace noise stops flagging unverified_dirty.
+// Stored outside missions.jsonl because that log re-appends the full mission
+// record on every save. Captured after start bookkeeping so the mission's own
+// state writes land inside the baseline, not in new_since_baseline.
+function captureMissionWorktreeBaseline(mission, root = process.cwd()) {
+  const snapshot = gitWorktreeSnapshot(root);
+  if (!snapshot.available) return null;
+  const baselineFile = missionBaselinePath(mission.id, root);
+  const paths = new Set((snapshot.entries || []).map(porcelainEntryPath));
+  // The sidecar itself and the per-tick lock are mission bookkeeping; without
+  // these the mission would flag its own state files as unverified dirt.
+  paths.add(path.relative(root, baselineFile));
+  paths.add(path.relative(root, path.join(root, '.atris', 'state', `mission-${mission.id}.lock`)));
+  const baseline = {
+    schema: 'atris.mission_worktree_baseline.v1',
+    mission_id: mission.id,
+    captured_at: stampIso(),
+    dirty_count: snapshot.dirty_count,
+    dirty_hash: snapshot.dirty_hash,
+    paths: Array.from(paths).sort(),
+  };
+  fs.mkdirSync(path.dirname(baselineFile), { recursive: true });
+  fs.writeFileSync(baselineFile, JSON.stringify(baseline, null, 2) + '\n', 'utf8');
+  return baseline;
+}
+
+function loadMissionWorktreeBaseline(missionId, root = process.cwd()) {
+  try {
+    const baseline = JSON.parse(fs.readFileSync(missionBaselinePath(missionId, root), 'utf8'));
+    return Array.isArray(baseline?.paths) ? baseline : null;
+  } catch {
+    return null;
+  }
+}
+
+// Closed missions no longer tick, so the sidecar is dead weight; prune it and
+// fold a compact audit summary into the mission record (full path lists stay
+// out of missions.jsonl, which re-appends the whole record on every save).
+// Paused missions keep their sidecar — resume ticks still subtract it.
+function pruneMissionWorktreeBaseline(mission, root = process.cwd()) {
+  const baseline = loadMissionWorktreeBaseline(mission.id, root);
+  try { fs.rmSync(missionBaselinePath(mission.id, root), { force: true }); } catch {}
+  if (!baseline) return null;
+  return {
+    captured_at: baseline.captured_at,
+    dirty_count: baseline.dirty_count,
+    dirty_hash: baseline.dirty_hash,
+    path_count: baseline.paths.length,
+  };
+}
+
+function worktreeReceipt(before, after, { verifier = '', baseline = null } = {}) {
   if (!before?.available || !after?.available) {
     return {
       available: false,
@@ -703,12 +875,27 @@ function worktreeReceipt(before, after, { verifier = '' } = {}) {
   const clearedDirty = (before.entries || []).filter((entry) => !afterSet.has(entry));
   const changed = before.dirty_hash !== after.dirty_hash;
   const hasVerifier = !!String(verifier || '').trim();
+  // Baseline = dirt the mission inherited (mission-start sidecar when present,
+  // tick-start snapshot for legacy missions). Only paths dirtied beyond that
+  // baseline count toward the unverified signal. Loop exhaust the mission
+  // writes about itself (state plane, receipts, rendered status) is not work
+  // product, so it never counts — otherwise every multi-tick mission in a repo
+  // that doesn't gitignore those dirs would flag its own bookkeeping.
+  const baselinePaths = baseline
+    ? new Set(baseline.paths)
+    : new Set((before.entries || []).map(porcelainEntryPath));
+  const newSinceBaseline = Array.from(new Set((after.entries || []).map(porcelainEntryPath)))
+    .filter((entryPath) => !baselinePaths.has(entryPath) && !isLoopExhaustPath(entryPath));
   return {
     available: true,
     before_dirty_count: before.dirty_count,
     after_dirty_count: after.dirty_count,
     changed,
-    unverified_dirty: !hasVerifier && after.dirty_count > 0,
+    baseline_source: baseline ? 'mission_start' : 'tick_start',
+    baseline_dirty_count: baseline ? baseline.dirty_count : before.dirty_count,
+    new_since_baseline_count: newSinceBaseline.length,
+    new_since_baseline_sample: newSinceBaseline.slice(0, 25),
+    unverified_dirty: !hasVerifier && newSinceBaseline.length > 0,
     unverified_change: !hasVerifier && changed,
     new_dirty_count: newDirty.length,
     cleared_dirty_count: clearedDirty.length,
@@ -739,7 +926,8 @@ function runnerUsesCallerSession(runner) {
 }
 
 function nextCandidateTickAction(mission) {
-  return `next move: run atris mission run ${mission.id} --complete-on-pass`;
+  const completeFlag = mission.always_on ? '' : ' --complete-on-pass';
+  return `next move: run atris mission run ${mission.id}${completeFlag}`;
 }
 
 function missionVerifierPassed(mission) {
@@ -803,9 +991,17 @@ function selectDueMission(root = process.cwd(), now = new Date()) {
   return candidates[0] || null;
 }
 
+function missionSelectableForCodexGoal(mission, now = new Date()) {
+  if (!missionIsRunnable(mission)) return false;
+  if (mission.always_on && missionVerifierPassed(mission) && !missionDueAt(mission, now)) {
+    return parseCadenceSeconds(mission.cadence) > 0;
+  }
+  return true;
+}
+
 function selectCodexGoalMission(root = process.cwd(), now = new Date()) {
   const candidates = listMissions(root)
-    .filter((mission) => missionSelectableForLoop(mission, now));
+    .filter((mission) => missionSelectableForCodexGoal(mission, now));
 
   candidates.sort((a, b) => {
     const aCaller = runnerUsesCallerSession(a.runner) ? 1 : 0;
@@ -837,7 +1033,8 @@ function codexGoalNextCommand(mission) {
     if (xpAction) return xpAction.replace(/^queue AgentXP review: /, '');
   }
   if (mission.verifier && missionDueAt(mission)) {
-    return 'atris mission run --due --max-ticks 1 --complete-on-pass';
+    const completeFlag = mission.always_on ? '' : ' --complete-on-pass';
+    return `atris mission run --due --max-ticks 1${completeFlag}`;
   }
   if (mission.verifier) {
     return `atris mission tick ${mission.id} --verify --summary "<what changed>"`;
@@ -1243,11 +1440,12 @@ async function runMission(args) {
   const skipClaude = hasFlag(args, '--no-claude');
   const verifyEach = !hasFlag(args, '--no-verify');
   const completeOnPass = hasFlag(args, '--complete-on-pass');
+  const skipDrain = hasFlag(args, '--no-drain');
   const maxTicksFlag = readFlag(args, '--max-ticks', '');
   const maxTicks = Math.max(1, Number(maxTicksFlag) || MISSION_RUN_DEFAULTS.maxTicks);
   const maxWallSeconds = Math.max(60, Number(readFlag(args, '--max-wall', '')) || MISSION_RUN_DEFAULTS.maxWallSeconds);
   const cadenceOverride = readFlag(args, '--cadence', '');
-  const ref = stripKnownFlags(args, ['--max-ticks', '--max-wall', '--cadence'], ['--json', '--due', '--no-claude', '--no-verify', '--complete-on-pass'])[0] || '';
+  const ref = stripKnownFlags(args, ['--max-ticks', '--max-wall', '--cadence'], ['--json', '--due', '--no-claude', '--no-verify', '--complete-on-pass', '--no-drain'])[0] || '';
 
   let mission = dueMode && !ref ? selectDueMission() : resolveMission(ref);
   if (!mission && dueMode && !ref) {
@@ -1334,6 +1532,7 @@ async function runMission(args) {
       started_at: stampIso(),
     };
     const runWorktreeBefore = gitWorktreeSnapshot(cwd);
+    const runWorktreeBaseline = loadMissionWorktreeBaseline(mission.id, cwd);
     const cadence = cadenceOverride || mission.cadence || 'manual';
     let cadenceSeconds = parseCadenceSeconds(cadence);
     // cadence=manual|once: exactly 1 tick unless user explicitly raised --max-ticks
@@ -1450,7 +1649,16 @@ async function runMission(args) {
         verifierResult = runVerifier(frozen.verifier);
         result.verifier_passed = verifierResult.passed;
       }
-      const tickWorktree = worktreeReceipt(tickWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: frozen.verifier });
+
+      // Review-lane drain: always-on loops sweep the agent-safe review actions
+      // each tick so proof-backed work reaches certified on cadence with zero
+      // human turns. Human accept stays the only path to Done; --no-drain opts out.
+      if (mission.always_on && result.status === 'ran') {
+        result.review_lane = skipDrain
+          ? { skipped: true, reason: 'no-drain-flag' }
+          : runReviewLaneDrain(cwd);
+      }
+      const tickWorktree = worktreeReceipt(tickWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: frozen.verifier, baseline: runWorktreeBaseline });
 
       // Persist tick to mission state + write structured receipt
       const finishedAt = stampIso();
@@ -1553,7 +1761,7 @@ async function runMission(args) {
       }, cwd, 'mission_run_paused', { reason: pauseReason }).mission;
     }
 
-    const summaryWorktree = worktreeReceipt(runWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: frozen.verifier });
+    const summaryWorktree = worktreeReceipt(runWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: frozen.verifier, baseline: runWorktreeBaseline });
     const finalReceipt = writeReceipt(mission, {
       kind: 'mission_run_summary',
       frozen,
@@ -1628,12 +1836,13 @@ function tickMission(args) {
     const lastTickIndex = Number(mission.last_tick_index || 0);
     const tickIdx = lastTickIndex + 1;
     const tickWorktreeBefore = gitWorktreeSnapshot(cwd);
+    const worktreeBaseline = loadMissionWorktreeBaseline(mission.id, cwd);
 
     let verifierResult = null;
     if (verify && mission.verifier) {
       verifierResult = runVerifier(mission.verifier);
     }
-    const tickWorktree = worktreeReceipt(tickWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: mission.verifier });
+    const tickWorktree = worktreeReceipt(tickWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: mission.verifier, baseline: worktreeBaseline });
 
     const tickRecord = {
       status: 'ran',
@@ -1710,10 +1919,49 @@ function tickMission(args) {
   }
 }
 
+// Proof receipts are JSON files written by writeReceipt(); anything else
+// (free text, command strings, missing paths) reads as null and falls back
+// to durable mission state.
+function readReceiptProof(proof, root = process.cwd()) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(path.resolve(root, String(proof || '')), 'utf8'));
+    return parsed?.schema === 'atris.mission_receipt.v1' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function receiptShowsPass(receipt) {
+  const result = receipt?.result;
+  return result?.passed === true
+    || result?.verifier_result?.passed === true
+    || result?.tick?.verifier_passed === true;
+}
+
+// Terminal gate: a verifier mission may only complete on real evidence — a
+// passing receipt belonging to this mission, or durable state showing the
+// verifier passed. Mirrors the task plane's proof-only accept guard so the
+// final transition consumes the receipts instead of trusting free text.
+function missionCompletionGate(mission, proof, root = process.cwd()) {
+  if (!String(mission.verifier || '').trim()) return { ok: true, source: 'no_verifier' };
+  const receipt = readReceiptProof(proof, root);
+  if (receipt) {
+    if (receipt.mission_id !== mission.id) {
+      return { ok: false, source: 'receipt', reason: `proof receipt belongs to mission ${receipt.mission_id}, not ${mission.id}` };
+    }
+    return receiptShowsPass(receipt)
+      ? { ok: true, source: 'receipt', receipt_path: String(proof) }
+      : { ok: false, source: 'receipt', reason: 'proof receipt does not show a passing verifier' };
+  }
+  if (mission.verifier_result?.passed === true) return { ok: true, source: 'mission_state' };
+  return { ok: false, source: 'mission_state', reason: 'verifier has not passed for this mission and proof is not a passing receipt' };
+}
+
 function completeMission(args) {
   const asJson = wantsJson(args);
+  const force = hasFlag(args, '--force');
   const proof = readFlag(args, '--proof', '');
-  const ref = stripKnownFlags(args, ['--proof'], ['--json'])[0] || '';
+  const ref = stripKnownFlags(args, ['--proof'], ['--json', '--force'])[0] || '';
   if (!ref || !proof) {
     exitMissionError('Usage: atris mission complete <id> --proof "..."', 1, asJson);
   }
@@ -1721,14 +1969,21 @@ function completeMission(args) {
   if (!mission) {
     exitMissionError(`Mission "${ref}" not found.`, 1, asJson);
   }
+  const gate = missionCompletionGate(mission, proof, process.cwd());
+  if (!gate.ok && !force) {
+    exitMissionError(`[mission complete] ${gate.reason}. Run: atris mission tick ${mission.id} --verify (or override as operator with --force)`, 2, asJson);
+  }
+  const baselineSummary = pruneMissionWorktreeBaseline(mission, process.cwd());
   const next = {
     ...mission,
     status: 'complete',
     completed_at: stampIso(),
     proof,
+    completion_gate: { ...gate, forced: force && !gate.ok },
+    worktree_baseline: baselineSummary || mission.worktree_baseline || null,
     next_action: 'mission complete',
   };
-  const { mission: saved } = saveMission(next, process.cwd(), 'mission_completed', { proof });
+  const { mission: saved } = saveMission(next, process.cwd(), 'mission_completed', { proof, completion_gate: next.completion_gate });
   const logPath = appendMemberLog(saved.owner, 'Mission completed', { mission: saved.objective, proof });
   const codexGoalState = refreshCodexGoalController(process.cwd());
   const xpNextCommand = missionXpReadyAction(saved, proof);
@@ -1752,19 +2007,37 @@ function stopMission(args) {
     exitMissionError(`Mission "${ref}" not found.`, 1, asJson);
   }
   const status = pause ? 'paused' : 'stopped';
+  // Full stops abandon work, so leave evidence: snapshot the worktree against
+  // the mission baseline (what did this mission leave dirty?) before pruning it.
+  let receiptPath = null;
+  if (!pause) {
+    const snapshot = gitWorktreeSnapshot(process.cwd());
+    const worktree = worktreeReceipt(snapshot, snapshot, {
+      verifier: mission.verifier,
+      baseline: loadMissionWorktreeBaseline(mission.id, process.cwd()),
+    });
+    receiptPath = writeReceipt(mission, { kind: 'mission_stop', reason, worktree });
+  }
+  const baselineSummary = pause ? null : pruneMissionWorktreeBaseline(mission, process.cwd());
   const next = {
     ...mission,
     status,
     stopped_at: status === 'stopped' ? stampIso() : mission.stopped_at || null,
     paused_at: status === 'paused' ? stampIso() : mission.paused_at || null,
     stop_reason: reason,
+    receipt_path: receiptPath || mission.receipt_path || null,
+    worktree_baseline: baselineSummary || mission.worktree_baseline || null,
     next_action: status === 'paused' ? `resume with: atris mission tick ${mission.id}` : 'mission stopped',
   };
-  const { mission: saved } = saveMission(next, process.cwd(), pause ? 'mission_paused' : 'mission_stopped', { reason });
+  const { mission: saved } = saveMission(next, process.cwd(), pause ? 'mission_paused' : 'mission_stopped', { reason, receipt_path: receiptPath });
   const logPath = appendMemberLog(saved.owner, pause ? 'Mission paused' : 'Mission stopped', { mission: saved.objective, reason });
   printJsonOrText(
-    { ok: true, action: pause ? 'mission_paused' : 'mission_stopped', mission: saved, log_path: logPath },
-    [`${pause ? 'Paused' : 'Stopped'} mission: ${saved.objective}`, `Reason: ${reason}`],
+    { ok: true, action: pause ? 'mission_paused' : 'mission_stopped', mission: saved, receipt_path: receiptPath, log_path: logPath },
+    [
+      `${pause ? 'Paused' : 'Stopped'} mission: ${saved.objective}`,
+      `Reason: ${reason}`,
+      ...(receiptPath ? [`Receipt: ${receiptPath}`] : []),
+    ],
     asJson,
   );
 }
@@ -1866,13 +2139,15 @@ function help() {
   console.log(`
 atris mission - durable goal + loop + owner + proof state
 
-  atris mission start "<objective>" --owner <member> [--verify "..."] [--always-on] [--xp-task]
-  atris mission status [id] [--status <state>] [--limit <n>] [--json]
+  atris mission start "<objective>" --owner <member> [--verify "..."] [--always-on] [--xp-task] [--worktree]
+  atris mission status [id] [--status <state>] [--limit <n>] [--local] [--json]
+                       (rolls up sibling git-worktree missions; --local scopes to this checkout)
   atris mission goal [--heartbeat] [--json]
   atris mission goal-loop [--max-wall 28800] [--max-iterations 32] [--no-claude] [--json]
   atris mission tick <id> [--verify] [--complete-on-pass] [--summary "..."] [--json]
   atris mission run <id|--due> [--max-ticks 4] [--max-wall 3600] [--cadence "15m"]
-                                [--no-claude] [--no-verify] [--complete-on-pass] [--json]
+                                [--no-claude] [--no-verify] [--complete-on-pass] [--no-drain] [--json]
+                       (always-on runs drain the review lane each tick; --no-drain skips)
   atris mission complete <id> --proof "..."
   atris mission stop <id> [--pause] [--reason "..."]
 
@@ -1886,7 +2161,7 @@ Autonomy recipe:
   4. Do one bounded step, then record it:
      atris mission tick <id> --verify --summary "what changed"
   5. Close or continue from the receipt:
-     atris task ready <xp_task_ref> --proof "<receipt_path>"  (if --xp-task)
+     atris task current-step --goal-id <mission_id> --as <owner> --proof "<receipt_path>" --json  (if --xp-task)
      atris task accept <xp_task_ref> --reward <n>             (human accept mints AgentXP)
      atris mission complete <id> --proof "<receipt_path>"
      repeat status -> step -> tick for current-agent work