atris 3.16.1 → 3.22.0

package/commands/mission.js

@@ -4,6 +4,10 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { spawn, spawnSync } = require('child_process');
+const {
+  resolveClaudeRunnerModel,
+  resolveClaudeRunnerBin,
+} = require('../lib/runner-command');
 
 const VALID_STATUSES = new Set(['planning', 'running', 'ready', 'paused', 'blocked', 'stopped', 'complete']);
 const TERMINAL_STATUSES = new Set(['stopped', 'complete']);
@@ -425,7 +429,7 @@ function renderMemberNowMarkdown(owner, missions) {
     lines.push(`- id: ${mission.id}`);
     lines.push(`- status: ${mission.status}`);
     lines.push(`- cadence: ${mission.cadence}`);
-    lines.push(`- runner: ${mission.runner}`);
+    lines.push(`- runner: ${mission.runner}${mission.model ? ` (${mission.model})` : ''}`);
     lines.push(`- lane: ${mission.lane}`);
     if (mission.xp_task?.ref) lines.push(`- AgentXP task: ${mission.xp_task.ref}`);
     if (mission.verifier) lines.push(`- verifier: ${mission.verifier}`);
@@ -515,6 +519,7 @@ function missionFromArgs(args) {
     '--stop',
     '--task',
     '--ask',
+    '--model',
   ], ['--json', '--always-on', '--xp-task', '--agent-xp', '--worktree']).join(' ').trim();
   if (!objective) {
     exitMissionError('Usage: atris mission start "<objective>" --owner <member> [--verify "..."] [--cadence manual] [--worktree]', 1, wantsJson(args));
@@ -522,6 +527,7 @@ function missionFromArgs(args) {
   const owner = readFlag(args, '--owner', process.env.ATRIS_AGENT_ID || 'mission-lead');
   const cadence = readFlag(args, '--cadence', readFlag(args, '--loop', 'manual')) || 'manual';
   const runner = readFlag(args, '--runner', 'manual');
+  const model = readFlag(args, '--model', '') || (String(runner).toLowerCase() === 'atris2' ? 'atris:fast' : '');
   const lane = readFlag(args, '--lane', 'workspace');
   const verifier = readFlag(args, '--verify', '');
   assertMissionVerifier(verifier, wantsJson(args));
@@ -540,6 +546,7 @@ function missionFromArgs(args) {
     status: 'planning',
     cadence,
     runner,
+    ...(model ? { model } : {}),
     lane,
     verifier,
     always_on: alwaysOn,
@@ -661,6 +668,7 @@ function statusMission(args) {
         `  id: ${mission.id}`,
         `  owner: ${mission.owner}`,
         `  state: ${mission.status}`,
+        ...missionHeartbeatLines(mission),
         ...(mission.worktree_root ? [`  worktree: ${mission.worktree_root}`] : []),
         `  next: ${mission.next_action || 'tick or verify'}`,
         ...(mission.receipt_path ? [`  proof: ${mission.receipt_path}`] : []),
@@ -671,6 +679,68 @@ function statusMission(args) {
   );
 }
 
+// `atris mission watch [id]` — read-only live heartbeat. Prints a line per tick as it
+// lands so a human (or any terminal) can see the loop is alive without rerunning status.
+function watchMission(args) {
+  const ref = stripKnownFlags(args, ['--interval', '--idle-every'], [])[0] || '';
+  const intervalSeconds = Math.max(1, parseInt(readFlag(args, '--interval', '2'), 10) || 2);
+  const idleEverySeconds = Math.max(1, parseInt(readFlag(args, '--idle-every', '30'), 10) || 30);
+  const loadTargets = () => {
+    if (ref) {
+      const mission = resolveMission(ref);
+      return mission ? [mission] : [];
+    }
+    return listMissions().filter((mission) => !HEARTBEAT_TERMINAL_STATUSES.has(mission.status));
+  };
+  if (ref && !loadTargets().length) {
+    exitMissionError(`Mission "${ref}" not found.`, 1, false);
+  }
+  const stamp = () => new Date().toTimeString().slice(0, 8);
+  const shortId = (mission) => mission.id.length > 20 ? `…${mission.id.slice(-8)}` : mission.id;
+  const emit = (mission, note) => console.log(`[${stamp()}] ${mission.owner} ${shortId(mission)} — ${note}`);
+  const fingerprint = (mission) => [mission.status, mission.last_tick_at, mission.last_tick_index, mission.receipt_path].join('|');
+  const tickNote = (mission) => {
+    const heartbeat = missionHeartbeatLines(mission).map((line) => line.trim()).join(', ');
+    return `${heartbeat || `state: ${mission.status}`}${mission.receipt_path ? ` — proof: ${mission.receipt_path}` : ''}`;
+  };
+  const seen = new Map();
+  let lastIdleAt = Date.now();
+  console.log(`watching ${ref || 'active missions'} every ${intervalSeconds}s — ctrl+c to stop`);
+  const poll = () => {
+    const targets = loadTargets();
+    if (!targets.length && !seen.size) {
+      emitOnce('no active missions yet — waiting');
+    }
+    let changed = false;
+    for (const mission of targets) {
+      const fp = fingerprint(mission);
+      if (seen.get(mission.id) !== fp) {
+        seen.set(mission.id, fp);
+        emit(mission, tickNote(mission));
+        changed = true;
+      }
+    }
+    if (changed) {
+      lastIdleAt = Date.now();
+    } else if (Date.now() - lastIdleAt >= idleEverySeconds * 1000) {
+      lastIdleAt = Date.now();
+      for (const mission of targets) {
+        emit(mission, `alive, ${missionHeartbeatLines(mission).map((line) => line.trim()).join(', ') || `state: ${mission.status}`}`);
+      }
+    }
+  };
+  let warnedEmpty = false;
+  const emitOnce = (message) => {
+    if (warnedEmpty) return;
+    warnedEmpty = true;
+    console.log(`[${stamp()}] ${message}`);
+  };
+  poll();
+  setInterval(poll, intervalSeconds * 1000);
+  // The bin router exits when the command's promise settles; watch runs until ctrl+c.
+  return new Promise(() => {});
+}
+
 function writeReceipt(mission, result, root = process.cwd()) {
   const paths = statePaths(root);
   fs.mkdirSync(paths.runsDir, { recursive: true });
@@ -957,6 +1027,37 @@ function secondsUntilMissionDue(mission, now = new Date()) {
   return Math.max(0, Math.ceil((dueAt - now.getTime()) / 1000));
 }
 
+function formatDurationShort(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return null;
+  if (seconds < 60) return `${Math.round(seconds)}s`;
+  if (seconds < 3600) return `${Math.round(seconds / 60)}m`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ${Math.round((seconds % 3600) / 60)}m`;
+  return `${Math.floor(seconds / 86400)}d`;
+}
+
+const HEARTBEAT_TERMINAL_STATUSES = new Set(['complete', 'stopped', 'paused']);
+
+function missionHeartbeatLines(mission, now = new Date()) {
+  const lines = [];
+  const lastTickAt = mission.last_tick_at ? Date.parse(mission.last_tick_at) : NaN;
+  if (Number.isFinite(lastTickAt)) {
+    const age = formatDurationShort((now.getTime() - lastTickAt) / 1000);
+    const verifier = mission.verifier
+      ? (mission.verifier_result ? (mission.verifier_result.passed ? 'verifier passed' : 'verifier failed') : 'verifier not run')
+      : 'no verifier';
+    const tickIdx = mission.last_tick_index != null ? `#${mission.last_tick_index}, ` : '';
+    const layerSuffix = mission.last_tick_layer ? `, layer: ${mission.last_tick_layer}` : '';
+    lines.push(`  last tick: ${age} ago (${tickIdx}${mission.last_tick_status || 'unknown'}, ${verifier}${layerSuffix})`);
+  } else if (!HEARTBEAT_TERMINAL_STATUSES.has(mission.status)) {
+    lines.push('  last tick: never');
+  }
+  if (parseCadenceSeconds(mission.cadence) > 0 && !HEARTBEAT_TERMINAL_STATUSES.has(mission.status)) {
+    const dueIn = secondsUntilMissionDue(mission, now);
+    lines.push(dueIn === 0 ? '  due: now' : `  due: in ${formatDurationShort(dueIn)}`);
+  }
+  return lines;
+}
+
 function missionHasHumanAsks(mission) {
   return Array.isArray(mission?.human_asks)
     && mission.human_asks.some((ask) => String(ask || '').trim());
@@ -1214,6 +1315,22 @@ function consecutiveVerifierFails(ticks) {
   return n;
 }
 
+// Count the trailing run of errored ticks that all share the most-recent error's
+// reason. Backoff caps at 10min, so an error that recurs identically (claude-timeout,
+// atris2-error, a dead model) otherwise retries forever until max-ticks/max-wall.
+// Two identical failures in a row is the MEMBER.md "same approach failed twice" signal.
+function consecutiveSameReasonErrors(ticks) {
+  const last = ticks[ticks.length - 1];
+  if (!last || last.status !== 'errored' || !last.reason) return { reason: null, count: 0 };
+  let count = 0;
+  for (let i = ticks.length - 1; i >= 0; i--) {
+    const t = ticks[i];
+    if (t.status === 'errored' && t.reason === last.reason) count++;
+    else break;
+  }
+  return { reason: last.reason, count };
+}
+
 function isWithinActiveHours(activeHours, now = new Date()) {
   if (!activeHours || !activeHours.start || !activeHours.end) return true;
   const tz = activeHours.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
@@ -1255,8 +1372,9 @@ function releaseMissionLock(lock) {
 }
 
 function probeClaudeBinary() {
-  const help = spawnSync('claude', ['--help'], { encoding: 'utf8', timeout: 8000 });
-  if (help.status !== 0) return { ok: false, error: 'claude --help failed' };
+  const runnerBin = resolveClaudeRunnerBin();
+  const help = spawnSync(runnerBin, ['--help'], { encoding: 'utf8', timeout: 8000 });
+  if (help.status !== 0) return { ok: false, error: `${runnerBin} --help failed` };
   const text = String(help.stdout || '');
   const required = ['--output-format', '--permission-mode', '--resume', '--session-id', '--include-partial-messages'];
   const missing = required.filter((flag) => !text.includes(flag));
@@ -1279,6 +1397,7 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen) {
     ``,
     `## Your task`,
     `Do ONE increment of work toward the stop condition. ONE. No more.`,
+    `- You are the member "${mission.owner}". Read atris/team/${mission.owner}/MEMBER.md (and SOUL.md if present) before acting — work in that identity, inside its scope and stop rules. After your work, append what you did and what you learned to atris/team/${mission.owner}/logs/<today's date>.md.`,
     `- FIRST: inspect current mission/task state before acting. Read the relevant files, run \`atris mission status ${mission.id}\`, \`git status\`, or \`atris task list\` as needed so you know what's already done.`,
     `- Pick the smallest concrete action that moves the mission forward.`,
     `- Edit / run / research as needed for the lane.`,
@@ -1291,7 +1410,7 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen) {
     `- Do NOT start new missions, modify other missions, or expand scope.`,
     `- Do NOT run destructive commands without strong evidence they're correct.`,
     ``,
-    `When done, output a short receipt: (1) the exact files edited / commands run / artifacts produced — name them, (2) the metric of progress, (3) what the next tick should pick up.`,
+    `When done, output a short receipt: (1) the exact files edited / commands run / artifacts produced — name them, (2) the metric of progress, (3) what the next tick should pick up. End the receipt with one line naming the layer this tick touched: \`layer: identity|beliefs|capabilities|behaviors|environment\` (final line — the harness parses it).`,
   ];
   if (mission.task_ids?.length) {
     lines.push('', `## Task ids`, mission.task_ids.map((t) => `- ${t}`).join('\n'));
@@ -1302,8 +1421,43 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen) {
   return lines.join('\n');
 }
 
+// resolveClaudeRunnerModel / resolveClaudeRunnerBin + the runner-resolution rationale now live in
+// lib/runner-command.js so missions, autopilot, and run share one resolver
+// (imported at the top, re-exported below for test/mission-model-resolution.test.js).
+
+// The claude CLI prints "...issue with the selected model (<id>). It may not exist
+// or you may not have access to it." when a model id is retired or inaccessible.
+// Detect it so the tick reason becomes the actionable 'model-unavailable' (+the id)
+// instead of a generic 'claude-error' that buries the root cause.
+function detectUnavailableModel(text) {
+  const s = String(text || '');
+  const m = s.match(/issue with the selected model \(([^)]+)\)/i);
+  if (m) return m[1].trim();
+  if (/selected model/i.test(s) && /may not (?:exist|have access)/i.test(s)) return 'unknown';
+  return null;
+}
+
+// Human-facing guidance written to a paused mission's next_action. Most pauses just
+// need a resume; a model-unavailable pause is a config error a bare resume won't fix,
+// so name the dead id and the two knobs that change it.
+function missionPauseNextAction(pauseReason, missionId, deadModel = null, lastErrorReason = null) {
+  if (pauseReason === 'model-unavailable' && deadModel) {
+    return `model "${deadModel}" is unavailable — set a live model (mission.model, ATRIS_RUNNER_MODEL, or legacy ATRIS_CLAUDE_MODEL), then: atris mission run ${missionId}`;
+  }
+  if (typeof pauseReason === 'string' && pauseReason.startsWith('repeated-error:')) {
+    const reason = pauseReason.slice('repeated-error:'.length);
+    return `tick kept failing with "${reason}" — inspect the last receipt, fix the cause, then: atris mission run ${missionId}`;
+  }
+  // Single-tick cron runs pause via max-ticks-reached on the very first errored tick.
+  // A bare "resume" there just re-errors; point the operator at the cause instead.
+  if (pauseReason === 'max-ticks-reached' && lastErrorReason) {
+    return `hit the tick budget while erroring ("${lastErrorReason}") — inspect the last receipt before resuming: atris mission run ${missionId}`;
+  }
+  return `resume with: atris mission run ${missionId}`;
+}
+
 function spawnClaudeTick(mission, opts) {
-  const { sessionMode, sessionId, cwd, signal, timeoutMs, prompt } = opts;
+  const { sessionMode, sessionId, cwd, signal, timeoutMs, prompt, model } = opts;
   return new Promise((resolve) => {
     const args = [
       '-p', prompt,
@@ -1312,11 +1466,12 @@ function spawnClaudeTick(mission, opts) {
       '--permission-mode', 'bypassPermissions',
       '--include-partial-messages',
     ];
+    if (model) args.push('--model', model);
     if (sessionMode === 'set') args.push('--session-id', sessionId);
     else if (sessionMode === 'resume') args.push('--resume', sessionId);
 
     const startedAt = Date.now();
-    const proc = spawn('claude', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+    const proc = spawn(resolveClaudeRunnerBin(), args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
 
     let stdoutBuf = '';
     let observedSessionIds = new Set();
@@ -1523,6 +1678,7 @@ async function runMission(args) {
     sessionId = mission.claude_session_id || null;
     pendingSessionId = mission.pending_session_id || null;
     const callerSessionRunner = runnerUsesCallerSession(mission.runner);
+    const atris2Runner = String(mission.runner || '').trim().toLowerCase() === 'atris2';
     const skipWorker = skipClaude || callerSessionRunner;
 
     // Freeze run-start contract (verifier, lane). Stored on receipts, not the mission record.
@@ -1539,7 +1695,8 @@ async function runMission(args) {
     const effectiveMaxTicks = (cadenceSeconds === 0 && !maxTicksFlag) ? 1 : maxTicks;
 
     // Session setup: only Claude-backed workers need a persisted session id.
-    if (!skipWorker && !sessionId && !pendingSessionId) {
+    // atris2 turns are stateless per tick — continuity lives on disk (logs, receipts, now.md).
+    if (!skipWorker && !atris2Runner && !sessionId && !pendingSessionId) {
       pendingSessionId = crypto.randomUUID();
       mission = saveMission({ ...mission, pending_session_id: pendingSessionId }, cwd, 'mission_session_pending', { session_id: pendingSessionId }).mission;
     }
@@ -1548,7 +1705,11 @@ async function runMission(args) {
     let backoffAttempt = 0;
     let lastRateLimit = null;
 
-    const sessionLabel = skipWorker ? 'caller-session' : (sessionId || `pending=${pendingSessionId}`);
+    const sessionLabel = skipWorker
+      ? 'caller-session'
+      : atris2Runner
+        ? `atris2 (${mission.model || 'atris:fast'})`
+        : (sessionId || `pending=${pendingSessionId}`);
     console.error(`[mission run] ${mission.id}\n  objective: ${mission.objective}\n  lane: ${frozen.lane}\n  cadence: ${cadence} (${cadenceSeconds}s)\n  max_ticks: ${effectiveMaxTicks}, max_wall: ${maxWallSeconds}s\n  session: ${sessionLabel}`);
 
     while (ticks.length < effectiveMaxTicks) {
@@ -1587,6 +1748,32 @@ async function runMission(args) {
           ran: true,
           claude: { skipped: true, reason: callerSessionRunner ? 'runner-uses-caller-session' : 'no-claude-mode' },
         };
+      } else if (atris2Runner) {
+        const prompt = buildTickPrompt(mission, tickIdx, effectiveMaxTicks, frozen);
+        const { runAtris2Turn } = require('./probe');
+        const turn = await runAtris2Turn({
+          prompt,
+          model: mission.model || 'atris:fast',
+          maxTurns: 16,
+          signal: controller.signal,
+        });
+        result.atris2 = {
+          ok: turn.ok,
+          engine: turn.engine,
+          model: mission.model || 'atris:fast',
+          tools_run: turn.tools_run,
+          unsupported: turn.unsupported,
+          duration_ms: turn.duration_ms,
+          error: turn.error,
+          receipt_text: String(turn.text || '').slice(0, 4000),
+        };
+        if (controller.signal.aborted) { pauseReason = 'aborted-during-atris2'; break; }
+        if (turn.error === 'not-logged-in') { pauseReason = 'auth-required'; break; }
+        if (!turn.ok || !String(turn.text || '').trim()) {
+          result = { ...result, status: 'errored', reason: 'atris2-error' };
+        } else {
+          result = { ...result, status: 'ran', reason: 'tick-ok', ran: true };
+        }
       } else {
         const sessionMode = sessionId ? 'resume' : 'set';
         const useId = sessionId || pendingSessionId;
@@ -1594,6 +1781,7 @@ async function runMission(args) {
         const claudeResult = await spawnClaudeTick(mission, {
           sessionMode, sessionId: useId, cwd, signal: controller.signal,
           timeoutMs: MISSION_RUN_DEFAULTS.claudeTimeoutMs, prompt,
+          model: resolveClaudeRunnerModel(mission),
         });
         result.claude = {
           ok: claudeResult.ok,
@@ -1619,7 +1807,10 @@ async function runMission(args) {
         if (claudeResult.authExpired) { pauseReason = 'auth-required'; break; }
 
         if (!claudeResult.ok) {
-          result = { ...result, status: 'errored', reason: claudeResult.timedOut ? 'claude-timeout' : 'claude-error' };
+          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; }
+          result = { ...result, status: 'errored', reason };
         } else {
           // Promote pending session id ONLY if claude confirmed the exact UUID we requested.
           // Mismatch is an invariant failure (we sent --session-id X, got Y) → pause, don't rotate.
@@ -1660,6 +1851,13 @@ async function runMission(args) {
       }
       const tickWorktree = worktreeReceipt(tickWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: frozen.verifier, baseline: runWorktreeBaseline });
 
+      // Layer classification needs the receipt text AND the worktree receipt, so it
+      // runs here — after both exist — covering the claude and atris2 branches alike.
+      const tickReceiptText = result.atris2?.receipt_text || result.claude?.receipt_text || '';
+      const layerInfo = extractLayerFromReceiptText(tickReceiptText, tickWorktree?.new_since_baseline_sample);
+      result.layer = layerInfo.layer;
+      result.layer_source = layerInfo.source;
+
       // Persist tick to mission state + write structured receipt
       const finishedAt = stampIso();
       const tickRecord = { ...result, started_at: tickStart, finished_at: finishedAt, worktree: tickWorktree };
@@ -1699,17 +1897,20 @@ async function runMission(args) {
         last_tick_status: result.status,
         last_tick_reason: result.reason,
         last_tick_index: tickIdx,
+        last_tick_layer: result.layer,
+        last_tick_layer_source: result.layer_source,
         verifier_result: verifierResult || mission.verifier_result || null,
         receipt_path: receiptPath,
         next_action: nextAction,
       }, cwd, 'mission_tick', {
-        tick_index: tickIdx, status: result.status, reason: result.reason, receipt_path: receiptPath,
+        tick_index: tickIdx, status: result.status, reason: result.reason, receipt_path: receiptPath, layer: result.layer,
       }).mission;
       appendMemberLog(mission.owner, `Mission run tick ${tickIdx}`, {
         mission: mission.objective,
         state: mission.status,
         tick_status: result.status,
         reason: result.reason,
+        layer: result.layer || undefined,
         verifier: verifierResult ? (verifierResult.passed ? 'passed' : 'failed') : 'not_run',
         receipt: receiptPath,
       });
@@ -1726,6 +1927,16 @@ async function runMission(args) {
 
       if (newStatus === 'complete' || (newStatus === 'ready' && !mission.always_on)) break;
       if (consecutiveVerifierFails(ticks) >= 2) { pauseReason = 'consecutive-verifier-fails'; break; }
+      // A retired/inaccessible model is deterministic: the id is fixed for the run, so
+      // every remaining tick (and every future cron firing) fails identically. Backoff
+      // only slows the bleeding. Stop on first detection and surface the dead id —
+      // CLI-245 named this failure; this stops the loop from grinding on it forever.
+      if (result.status === 'errored' && result.reason === 'model-unavailable') { pauseReason = 'model-unavailable'; break; }
+      // Any OTHER error that recurs identically (claude-timeout, atris2-error, claude-error)
+      // is the same trap one step less deterministic: keep retrying and the loop burns every
+      // tick + cron firing on it. Halt at two-in-a-row and surface the reason for a human.
+      const errStreak = consecutiveSameReasonErrors(ticks);
+      if (errStreak.count >= 2) { pauseReason = `repeated-error:${errStreak.reason}`; break; }
 
       // Sleep until next tick
       let sleepMs = 0;
@@ -1752,13 +1963,16 @@ async function runMission(args) {
     }
 
     if (pauseReason && !['complete', 'ready', 'max-wall-reached'].includes(pauseReason)) {
+      const lastTick = ticks[ticks.length - 1];
+      const deadModel = pauseReason === 'model-unavailable' ? (lastTick && lastTick.model_unavailable) || null : null;
+      const lastErrorReason = lastTick && lastTick.status === 'errored' ? lastTick.reason : null;
       mission = saveMission({
         ...mission,
         status: 'paused',
         paused_at: stampIso(),
         stop_reason: pauseReason,
-        next_action: `resume with: atris mission run ${mission.id}`,
-      }, cwd, 'mission_run_paused', { reason: pauseReason }).mission;
+        next_action: missionPauseNextAction(pauseReason, mission.id, deadModel, lastErrorReason),
+      }, cwd, 'mission_run_paused', { reason: pauseReason, ...(deadModel ? { model_unavailable: deadModel } : {}) }).mission;
     }
 
     const summaryWorktree = worktreeReceipt(runWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: frozen.verifier, baseline: runWorktreeBaseline });
@@ -1844,6 +2058,9 @@ function tickMission(args) {
     }
     const tickWorktree = worktreeReceipt(tickWorktreeBefore, gitWorktreeSnapshot(cwd), { verifier: mission.verifier, baseline: worktreeBaseline });
 
+    // Same layer classification as the run-tick path; manual ticks carry their
+    // receipt text in --summary.
+    const layerInfo = extractLayerFromReceiptText(summary || '', tickWorktree?.new_since_baseline_sample);
     const tickRecord = {
       status: 'ran',
       reason: 'tick-recorded',
@@ -1852,6 +2069,8 @@ function tickMission(args) {
       started_at: tickStart,
       claude: { skipped: true, reason: 'orchestrator-is-caller-session' },
       summary: summary || null,
+      layer: layerInfo.layer,
+      layer_source: layerInfo.source,
       verifier_passed: verifierResult ? !!verifierResult.passed : null,
       finished_at: stampIso(),
       worktree: tickWorktree,
@@ -1880,24 +2099,31 @@ function tickMission(args) {
       status = 'blocked';
       nextAction = 'fix verifier failure or revise mission';
     }
+    const clearsPauseState = !['paused', 'stopped'].includes(status);
     const nextMission = {
       ...mission,
       status,
+      paused_at: clearsPauseState ? null : mission.paused_at || null,
+      stop_reason: clearsPauseState ? null : mission.stop_reason || null,
+      resumed_at: clearsPauseState && mission.status === 'paused' ? tickRecord.finished_at : mission.resumed_at || null,
       receipt_path: receiptPath,
       last_tick_at: tickRecord.finished_at,
       last_tick_status: tickRecord.status,
       last_tick_reason: tickRecord.reason,
       last_tick_index: tickIdx,
+      last_tick_layer: tickRecord.layer,
+      last_tick_layer_source: tickRecord.layer_source,
       verifier_result: verifierResult || mission.verifier_result || null,
       next_action: nextAction,
     };
     const { mission: saved } = saveMission(nextMission, cwd, 'mission_tick', {
-      tick_index: tickIdx, verify, verifier_result: verifierResult, receipt_path: receiptPath,
+      tick_index: tickIdx, verify, verifier_result: verifierResult, receipt_path: receiptPath, layer: tickRecord.layer,
     });
     const logPath = appendMemberLog(saved.owner, 'Mission tick', {
       mission: saved.objective,
       state: saved.status,
       tick_index: tickIdx,
+      layer: tickRecord.layer || undefined,
       verifier: verifierResult ? (verifierResult.passed ? 'passed' : 'failed') : 'not_run',
       receipt: receiptPath,
       summary: summary || undefined,
@@ -2140,7 +2366,14 @@ function help() {
 atris mission - durable goal + loop + owner + proof state
 
   atris mission start "<objective>" --owner <member> [--verify "..."] [--always-on] [--xp-task] [--worktree]
+                      [--runner manual|claude|atris2|codex_goal] [--model <id>]
+                      (runner claude spawns local claude -p per tick, --model passes through;
+                       runner atris2 runs each tick as one /atris2/turn on the AtrisOS backend,
+                       default model atris:fast; runner codex_goal publishes the goal for a live
+                       Codex session to pull via atris mission goal)
   atris mission status [id] [--status <state>] [--limit <n>] [--local] [--json]
+  atris mission watch [id] [--interval <s>] [--idle-every <s>]   Live heartbeat: prints a line per tick as it lands
+  atris mission layers [--mission <id-substr>] [--since <date>] [--json]   Per-layer growth curve across tick receipts
                        (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]
@@ -2189,6 +2422,153 @@ State:
 `.trim());
 }
 
+// Extract layer classification from receipt text.
+// Priority: layer tag on the last non-empty line (source: explicit) >
+// last strictly-matching layer line anywhere in the text (source: explicit-inline) >
+// changed-path classification (source: fallback). The single-token regex keeps the
+// enum docs line ("layer: identity|beliefs|...") from ever matching.
+function extractLayerFromReceiptText(text, fallbackPaths = []) {
+  const text_str = String(text || '').trim();
+
+  if (text_str) {
+    // Matches a standalone "layer: x" line, or a one-line summary ending in
+    // "...; layer: x". Quoted bullets ("- layer: x") and the enum-doc line stay inert.
+    const layerPattern = /^(?:.*;\s*)?layer:\s*(identity|beliefs|capabilities|behaviors|environment)\s*$/i;
+    const lines = text_str.split(/\r?\n/).reverse();
+    let isLastNonEmpty = true;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const match = trimmed.match(layerPattern);
+      if (match) {
+        return { layer: match[1].toLowerCase(), source: isLastNonEmpty ? 'explicit' : 'explicit-inline' };
+      }
+      isLastNonEmpty = false;
+    }
+  }
+
+  // Fallback to path classification
+  if (Array.isArray(fallbackPaths) && fallbackPaths.length > 0) {
+    const classified = classifyPathsByLayer(fallbackPaths);
+    if (classified && classified.layer) {
+      return { layer: classified.layer, source: classified.source };
+    }
+  }
+
+  return { layer: null, source: 'unknown' };
+}
+
+// Classify paths into layers. Returns { layer: string, source: string, confidence: number }
+// Rules: atris/team/ => identity, atris/lessons.md|atris/wiki/ => beliefs,
+// test/|skills/ => capabilities, commands/|bin/ => behaviors, else environment
+function classifyPathsByLayer(paths) {
+  if (!Array.isArray(paths) || paths.length === 0) {
+    return { layer: null, source: 'unknown' };
+  }
+
+  const counts = {
+    identity: 0,
+    beliefs: 0,
+    capabilities: 0,
+    behaviors: 0,
+    environment: 0,
+  };
+
+  for (const pathStr of paths) {
+    const p = String(pathStr || '');
+    if (p.includes('atris/team/')) {
+      counts.identity++;
+    } else if (p.includes('atris/lessons.md') || p.includes('atris/wiki/')) {
+      counts.beliefs++;
+    } else if (p.includes('test/') || p.includes('skills/')) {
+      counts.capabilities++;
+    } else if (p.includes('commands/') || p.includes('bin/')) {
+      counts.behaviors++;
+    } else {
+      counts.environment++;
+    }
+  }
+
+  // Find max with tie-break: identity > beliefs > capabilities > behaviors > environment
+  const tieBreakOrder = ['identity', 'beliefs', 'capabilities', 'behaviors', 'environment'];
+  let maxCount = 0;
+  let winnerLayer = null;
+  for (const layer of tieBreakOrder) {
+    if (counts[layer] > maxCount) {
+      maxCount = counts[layer];
+      winnerLayer = layer;
+    }
+  }
+
+  return winnerLayer ? { layer: winnerLayer, source: 'fallback' } : { layer: null, source: 'unknown' };
+}
+
+// `atris mission layers` — per-layer growth curve across tick receipts. The member
+// proof standard says: if every tick is one layer and none touch the others, the
+// loop is doing work but not getting smarter. This makes that check one command.
+function layersMission(args) {
+  const asJson = args.includes('--json');
+  const missionFilter = readFlag(args, '--mission', '');
+  const sinceRaw = readFlag(args, '--since', '');
+  // --since accepts a date (2026-06-13) or full ISO; filters on the receipt's `at`
+  // stamp so the curve can be read over a window (e.g. "what did today's ticks touch?").
+  const sinceMs = sinceRaw ? Date.parse(sinceRaw) : null;
+  if (sinceRaw && Number.isNaN(sinceMs)) {
+    exitMissionError(`--since "${sinceRaw}" is not a parseable date (try 2026-06-13 or an ISO timestamp).`, 1, asJson);
+  }
+  const paths = statePaths(process.cwd());
+  const LAYERS = ['identity', 'beliefs', 'capabilities', 'behaviors', 'environment'];
+  const byLayer = Object.fromEntries(LAYERS.map((l) => [l, 0]));
+  const bySource = { explicit: 0, 'explicit-inline': 0, fallback: 0, unknown: 0 };
+  let total = 0;
+  let untagged = 0;
+  let files = [];
+  try {
+    files = fs.readdirSync(paths.runsDir).filter((f) => f.startsWith('mission-') && f.endsWith('.json'));
+  } catch {
+    files = [];
+  }
+  for (const file of files) {
+    if (missionFilter && !file.includes(missionFilter)) continue;
+    let receipt;
+    try {
+      receipt = JSON.parse(fs.readFileSync(path.join(paths.runsDir, file), 'utf8'));
+    } catch {
+      continue;
+    }
+    if (sinceMs != null) {
+      const atMs = Date.parse(receipt && receipt.at);
+      if (Number.isNaN(atMs) || atMs < sinceMs) continue;
+    }
+    const tick = receipt?.result?.tick;
+    if (!tick) continue; // summaries, stop receipts, legacy shapes
+    total++;
+    const layer = String(tick.layer || '').toLowerCase();
+    const source = String(tick.layer_source || 'unknown');
+    if (LAYERS.includes(layer)) {
+      byLayer[layer]++;
+      bySource[source in bySource ? source : 'unknown']++;
+    } else {
+      untagged++;
+    }
+  }
+  const tagged = total - untagged;
+  const dominant = LAYERS.reduce((a, b) => (byLayer[b] > byLayer[a] ? b : a), LAYERS[0]);
+  const skewed = tagged >= 5 && byLayer[dominant] / tagged >= 0.8;
+  const scopeBits = [
+    missionFilter ? `mission filter: ${missionFilter}` : null,
+    sinceRaw ? `since: ${sinceRaw}` : null,
+  ].filter(Boolean);
+  const lines = [
+    `Layer growth curve${scopeBits.length ? ` (${scopeBits.join(', ')})` : ''}: ${tagged} tagged / ${total} tick receipts`,
+    ...LAYERS.map((l) => `  ${l.padEnd(12)} ${String(byLayer[l]).padStart(3)}${byLayer[l] ? ' ' + '█'.repeat(Math.min(byLayer[l], 40)) : ''}`),
+    ...(untagged ? [`  untagged     ${String(untagged).padStart(3)} (pre-layer receipts or missing tag)`] : []),
+    `  provenance: explicit ${bySource.explicit}, explicit-inline ${bySource['explicit-inline']}, fallback ${bySource.fallback}`,
+    ...(skewed ? [`  rebalance: ${Math.round((byLayer[dominant] / tagged) * 100)}% of tagged ticks are "${dominant}" — the proof standard wants the other layers moving too`] : []),
+  ];
+  printJsonOrText({ ok: true, since: sinceRaw || null, total, tagged, untagged, by_layer: byLayer, by_source: bySource, dominant: tagged ? dominant : null, skewed }, lines, asJson);
+}
+
 function missionCommand(args) {
   const subcommand = args[0] || 'status';
   const rest = args.slice(1);
@@ -2201,6 +2581,10 @@ function missionCommand(args) {
     case 'list':
     case 'ls':
       return statusMission(rest);
+    case 'watch':
+      return watchMission(rest);
+    case 'layers':
+      return layersMission(rest);
     case 'goal':
     case 'codex-goal':
       return goalMission(rest);
@@ -2228,6 +2612,7 @@ function missionCommand(args) {
 
 module.exports = {
   missionCommand,
+  missionHeartbeatLines,
   listMissions,
   loadMissionMap,
   renderMissionStatus,
@@ -2235,4 +2620,11 @@ module.exports = {
   selectCodexGoalMission,
   usefulClaudeReceiptSummary,
   cappedClaudeReceiptText,
+  extractLayerFromReceiptText,
+  classifyPathsByLayer,
+  resolveClaudeRunnerModel,
+  resolveClaudeRunnerBin,
+  detectUnavailableModel,
+  missionPauseNextAction,
+  consecutiveSameReasonErrors,
 };