atris 3.34.0 → 3.36.0

package/commands/member.js

@@ -6,6 +6,7 @@ const { execFileSync, spawnSync } = require('child_process');
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 const { runAliveTick } = require('../lib/member-alive');
+const { defaultObjectiveRunner } = require('../lib/default-runner');
 
 function todayLogName() {
   const now = new Date();
@@ -211,6 +212,12 @@ function resolveMemberRuntime(name) {
 function memberPaths(name) {
   const teamDir = path.join(process.cwd(), 'atris', 'team');
   const memberDir = path.join(teamDir, name || '');
+  // Steering signals live in the workspace's single .atris/state store. Resolve
+  // the shared workspace root (spine -> git -> cwd) so a member run from a
+  // subdirectory reads steering from the real store instead of a nonexistent
+  // nested .atris — the same resolver the mission/task/usage/autopilot state
+  // uses. (teamDir markdown discovery is a separate cwd concern, filed.)
+  const workspaceRoot = require('../lib/mission-root').resolveWorkspaceRoot(process.cwd());
   return {
     teamDir,
     memberDir,
@@ -218,7 +225,7 @@ function memberPaths(name) {
     missionFile: path.join(memberDir, 'MISSION.md'),
     goalsJson: path.join(memberDir, 'goals.json'),
     goalsMd: path.join(memberDir, 'goals.md'),
-    steeringJsonl: path.join(process.cwd(), '.atris', 'state', 'steering.jsonl'),
+    steeringJsonl: path.join(workspaceRoot, '.atris', 'state', 'steering.jsonl'),
   };
 }
 
@@ -252,6 +259,50 @@ function ensureMissionFile(memberDir, { name, role, description } = {}) {
   return missionPath;
 }
 
+function listExistingMemberSlugs() {
+  const teamDir = path.join(process.cwd(), 'atris', 'team');
+  try {
+    return fs.readdirSync(teamDir, { withFileTypes: true })
+      .filter(entry => entry.isDirectory() && !entry.name.startsWith('_'))
+      .map(entry => entry.name)
+      .filter(slug => fs.existsSync(path.join(teamDir, slug, 'MEMBER.md')))
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+function editDistance(a, b) {
+  const rows = a.length + 1;
+  const cols = b.length + 1;
+  const dist = Array.from({ length: rows }, (_, i) => [i, ...Array(cols - 1).fill(0)]);
+  for (let j = 0; j < cols; j++) dist[0][j] = j;
+  for (let i = 1; i < rows; i++) {
+    for (let j = 1; j < cols; j++) {
+      dist[i][j] = Math.min(
+        dist[i - 1][j] + 1,
+        dist[i][j - 1] + 1,
+        dist[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1),
+      );
+    }
+  }
+  return dist[rows - 1][cols - 1];
+}
+
+function nearestMemberSlug(name, slugs) {
+  const needle = String(name || '').toLowerCase();
+  let best = null;
+  let bestScore = Infinity;
+  for (const slug of slugs) {
+    const score = editDistance(needle, slug.toLowerCase());
+    if (score < bestScore) {
+      best = slug;
+      bestScore = score;
+    }
+  }
+  return bestScore <= Math.max(2, Math.floor(needle.length / 3)) ? best : null;
+}
+
 function requireMemberDir(name) {
   if (!name) {
     console.error('Usage: atris member <goal|tick|review> <name> ...');
@@ -266,6 +317,15 @@ function requireMemberDir(name) {
   if (!fs.existsSync(paths.memberFile)) {
     const aliasHint = resolved.aliasOf ? ` or atris/team/${resolved.aliasOf}/MEMBER.md` : '';
     console.error(`Member "${name}" not found at atris/team/${name}/MEMBER.md${aliasHint}`);
+    const team = listExistingMemberSlugs();
+    const nearest = nearestMemberSlug(name, team);
+    if (nearest) {
+      console.error(`Did you mean "${nearest}"?`);
+    } else if (team.length) {
+      console.error(`Team here: ${team.join(', ')}`);
+    } else {
+      console.error(`No team members exist here yet. Create one: atris member create ${name} --role="..."`);
+    }
     process.exit(1);
   }
   return {
@@ -440,6 +500,170 @@ function memberRunOwnedActiveMissionId(name, missionMap) {
   return candidates[0]?.id || '';
 }
 
+const MEMBER_LIVE_MISSION_STATUSES = new Set(['running', 'planning']);
+const MEMBER_ACTIVE_ACTIVITY_MS = 24 * 60 * 60 * 1000;
+const MEMBER_RECENT_ACTIVITY_MS = 72 * 60 * 60 * 1000;
+
+function memberSlugFromRecord(member) {
+  if (member?.format === 'directory' && member.dir) return path.basename(member.dir);
+  if (member?.format === 'flat' && member.path) return path.basename(member.path, '.md');
+  return lowerCompact(member?.name || '');
+}
+
+function isFleetMember(member) {
+  if (!member || member.format !== 'directory') return false;
+  const slug = memberSlugFromRecord(member);
+  return Boolean(slug) && !new Set(['_archive', '_archived', '_template']).has(slug);
+}
+
+function missionTimeMs(mission) {
+  return Date.parse(mission?.last_tick_at || mission?.updated_at || mission?.created_at || '') || 0;
+}
+
+function memberOwnedMissions(name, missionMap = memberRunMissionMap()) {
+  const owner = lowerCompact(name);
+  return Array.from(missionMap.values())
+    .filter((mission) => lowerCompact(mission?.owner) === owner)
+    .sort((a, b) => missionTimeMs(b) - missionTimeMs(a));
+}
+
+function memberLatestMission(name, missionMap = memberRunMissionMap()) {
+  return memberOwnedMissions(name, missionMap)[0] || null;
+}
+
+function memberLiveMission(name, missionMap = memberRunMissionMap()) {
+  return memberOwnedMissions(name, missionMap)
+    .find((mission) => MEMBER_LIVE_MISSION_STATUSES.has(String(mission?.status || '').toLowerCase())) || null;
+}
+
+function missionShortName(mission, max = 36) {
+  return compactSentence(mission?.slug || mission?.title || mission?.objective || mission?.id || '', max) || '-';
+}
+
+function ageLabelFromMs(ms, nowMs = Date.now()) {
+  if (!ms) return '-';
+  const seconds = Math.max(0, Math.floor((nowMs - ms) / 1000));
+  if (seconds < 60) return 'now';
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) return `${hours}h`;
+  return `${Math.floor(hours / 24)}d`;
+}
+
+function timestampMs(value) {
+  const ms = Date.parse(value || '');
+  return Number.isFinite(ms) ? ms : 0;
+}
+
+function newestMtimeRecursive(root) {
+  if (!fs.existsSync(root)) return 0;
+  let newest = 0;
+  const stack = [root];
+  while (stack.length) {
+    const current = stack.pop();
+    let stat = null;
+    try {
+      stat = fs.statSync(current);
+    } catch {
+      continue;
+    }
+    newest = Math.max(newest, stat.mtimeMs || 0);
+    if (!stat.isDirectory()) continue;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(current);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) stack.push(path.join(current, entry));
+  }
+  return newest;
+}
+
+function newestRunActivityMtime(name, root = process.cwd()) {
+  const runsDir = path.join(root, 'atris', 'runs');
+  if (!fs.existsSync(runsDir)) return 0;
+  const needle = lowerCompact(name);
+  let newest = 0;
+  for (const entry of fs.readdirSync(runsDir)) {
+    if (!lowerCompact(entry).includes(needle)) continue;
+    try {
+      newest = Math.max(newest, fs.statSync(path.join(runsDir, entry)).mtimeMs || 0);
+    } catch { /* ignore unreadable activity entries */ }
+  }
+  return newest;
+}
+
+function memberLastActivity(name, paths = memberPaths(name), root = process.cwd()) {
+  const logsMs = newestMtimeRecursive(path.join(paths.memberDir, 'logs'));
+  const runsMs = newestRunActivityMtime(name, root);
+  const ms = Math.max(logsMs, runsMs);
+  return {
+    at_ms: ms,
+    age: ageLabelFromMs(ms),
+  };
+}
+
+function memberMissionSummary(name, missionMap = memberRunMissionMap()) {
+  const latest = memberLatestMission(name, missionMap);
+  const live = memberLiveMission(name, missionMap);
+  const lastTickMs = timestampMs(latest?.last_tick_at);
+  return {
+    latest,
+    live,
+    name: missionShortName(latest),
+    state: latest?.status || '-',
+    last_tick_at: latest?.last_tick_at || null,
+    last_tick_age: ageLabelFromMs(lastTickMs),
+    live_mission: Boolean(live),
+  };
+}
+
+function memberVerdict({ mission, activity }, nowMs = Date.now()) {
+  const activityAge = activity?.at_ms ? nowMs - activity.at_ms : Number.POSITIVE_INFINITY;
+  if (mission?.live_mission || activityAge < MEMBER_ACTIVE_ACTIVITY_MS) return 'ACTIVE';
+  if (activityAge < MEMBER_RECENT_ACTIVITY_MS) return 'RECENT';
+  return 'IDLE';
+}
+
+function memberGoalPlaneStatus(name, paths = requireMemberDir(name)) {
+  const state = loadMemberGoals(name, paths);
+  const goal = activeGoal(state);
+  const current = memberOpenExperiment(state);
+  const lastReviewed = memberLastReviewedExperiment(state);
+  const value = memberValueSummary(state);
+  const logs = recentLogLines(paths.memberDir);
+  const needsUser = current?.status === 'blocked';
+  const stateLabel = !goal
+    ? 'no_goal'
+    : needsUser
+      ? 'needs_user'
+      : current
+        ? current.status
+        : 'ready';
+  const ask = needsUser ? (current.block?.ask || 'Needs operator input.') : null;
+  const nextCommand = !goal
+    ? `atris member goal ${name} "..."`
+    : needsUser
+      ? `atris member review ${name} ${current.id} --discard --proof "..."`
+      : current
+        ? `atris member review ${name} ${current.id} --accept --proof "..." --value 4`
+        : `atris member tick ${name}`;
+  return {
+    state,
+    goal,
+    current,
+    lastReviewed,
+    value,
+    logs,
+    needsUser,
+    stateLabel,
+    ask,
+    nextCommand,
+  };
+}
+
 function resolveMemberRunMissionId(name, args = []) {
   const override = readFlag(args, '--mission', '') || readFlag(args, '--mission-id', '');
   if (override) return override;
@@ -450,8 +674,10 @@ function resolveMemberRunMissionId(name, args = []) {
   const runtimeId = memberRunRunnableMissionId(purpose.runtimeMission?.id, missionMap);
   if (runtimeId) return runtimeId;
 
+  // strictly active: activeGoal()'s goals[0] fallback would resurrect a
+  // paused goal's stale mission pointer and error the leg every hour
   const goals = loadMemberGoals(name, paths);
-  const goal = activeGoal(goals);
+  const goal = (goals.goals || []).find((candidate) => candidate.status === 'active') || null;
   const goalId = memberRunRunnableMissionId(goal?.mission_id, missionMap);
   if (goalId) return goalId;
 
@@ -482,6 +708,7 @@ const MEMBER_RUN_START_VALUE_FLAGS = [
 
 const MEMBER_RUN_START_BOOLEAN_FLAGS = [
   '--json',
+  '--no-verify',
   '--worktree',
   '--shared-checkout',
   '--no-worktree',
@@ -517,16 +744,34 @@ function memberRunTruthRule(args = []) {
     || 'say what changed, what was checked, and what is still unproven';
 }
 
+function operatorWaitingWishTexts(root = process.cwd()) {
+  // Wishes waiting on operator answers are not actionable candidates: seeding
+  // them into member runs spawned three parallel verifier-less wrapper
+  // missions chewing the same unanswered sentence (seen live 2026-07-07).
+  try {
+    const { waitingOperatorWishes } = require('../lib/wish-delegate');
+    return new Set(
+      waitingOperatorWishes(root)
+        .map((wish) => cleanMemberRunPhrase(wish?.text || wish?.task_text || '').toLowerCase())
+        .filter(Boolean),
+    );
+  } catch {
+    return new Set();
+  }
+}
+
 function memberRunUsefulTarget() {
   try {
     const { nextMoves: pickNextMoves, isGenericInboxPlaceholder } = require('../lib/next-moves');
     const moves = pickNextMoves(process.cwd(), 5);
+    const waitingWishes = operatorWaitingWishTexts();
     const candidate = moves.find((move) => {
       const title = cleanMemberRunPhrase(move?.title);
       if (!title) return false;
       if (isGenericInboxPlaceholder(title)) return false;
       if (/^mission xp\s*:/i.test(title)) return false;
       if (/^decide and start the next useful mission after:/i.test(title)) return false;
+      if (waitingWishes.has(title.toLowerCase())) return false;
       return true;
     });
     return candidate?.title ? cleanMemberRunPhrase(candidate.title) : '';
@@ -569,17 +814,18 @@ function pushFlagWhenPresent(out, args, name) {
   if (hasFlag(args, name)) out.push(name);
 }
 
-function startMemberRunMission(name, missionText, args = []) {
-  const paths = requireMemberDir(name);
-  const owner = paths.storageName || name;
+function buildMemberRunStartArgs(owner, missionText, args = [], cwd = process.cwd()) {
   const startArgs = [
     'mission',
     'start',
     missionText,
     '--owner',
     owner,
+    // codex_goal stalls unattended (no live codex session drives its native goal
+    // slot). Default to claude unless a live codex session is signalled; explicit
+    // --runner still wins. Proven footgun 2026-07-16. See lib/default-runner.js.
     '--runner',
-    readFlag(args, '--runner', 'codex_goal'),
+    readFlag(args, '--runner', defaultObjectiveRunner(args)),
     '--lane',
     readFlag(args, '--lane', 'workspace'),
   ];
@@ -591,14 +837,43 @@ function startMemberRunMission(name, missionText, args = []) {
   pushFlagValue(startArgs, args, '--minutes');
   pushFlagValue(startArgs, args, '--hours');
   pushFlagValue(startArgs, args, '--base');
+  // A member-run mission is driven immediately by its runner, not parked on
+  // the queue — so the mission-start verifier gate (built for parked planning
+  // wishes) would only kill autonomous legs like autopilot's "member chooses
+  // useful work". When the caller named no verifier, opt out explicitly.
+  if (hasFlag(args, '--no-verify') || !readFlag(args, '--verify', '')) {
+    startArgs.push('--no-verify');
+  }
   pushFlagWhenPresent(startArgs, args, '--always-on');
   pushFlagWhenPresent(startArgs, args, '--xp-task');
   pushFlagWhenPresent(startArgs, args, '--agent-xp');
   pushFlagWhenPresent(startArgs, args, '--spend-full-budget');
   pushFlagWhenPresent(startArgs, args, '--use-whole-budget');
   pushFlagWhenPresent(startArgs, args, '--stop-when-done');
-  if (!hasFlag(args, '--shared-checkout') && !hasFlag(args, '--no-worktree')) startArgs.push('--worktree');
+  // Default to an isolated worktree only when there is a git repo to cut it
+  // from. A plain (non-git) workspace would fail every mission start with
+  // "fatal: not a git repository" — degrade to the shared checkout instead.
+  if (!hasFlag(args, '--shared-checkout') && !hasFlag(args, '--no-worktree') && insideGitRepo(cwd)) {
+    startArgs.push('--worktree');
+  }
   if (hasFlag(args, '--json')) startArgs.push('--json');
+  return startArgs;
+}
+
+function insideGitRepo(startDir) {
+  let dir = path.resolve(startDir || process.cwd());
+  while (true) {
+    if (fs.existsSync(path.join(dir, '.git'))) return true;
+    const parent = path.dirname(dir);
+    if (parent === dir) return false;
+    dir = parent;
+  }
+}
+
+function startMemberRunMission(name, missionText, args = []) {
+  const paths = requireMemberDir(name);
+  const owner = paths.storageName || name;
+  const startArgs = buildMemberRunStartArgs(owner, missionText, args);
 
   const cliPath = path.join(__dirname, '..', 'bin', 'atris.js');
   try {
@@ -1439,14 +1714,43 @@ function readRecentWakeReceiptEvidence(name) {
 }
 
 function readJsonlRowsIfExists(filePath, maxRows = 80) {
+  const tailBytes = 256 * 1024;
+  let fd;
   let text = '';
+  let truncated = false;
   try {
-    text = fs.readFileSync(filePath, 'utf8');
+    fd = fs.openSync(filePath, 'r');
+    const stat = fs.fstatSync(fd);
+    const bytesToRead = Math.min(stat.size, tailBytes);
+    const start = Math.max(0, stat.size - bytesToRead);
+    const buffer = Buffer.alloc(bytesToRead);
+    let bytesRead = 0;
+    while (bytesRead < bytesToRead) {
+      const count = fs.readSync(
+        fd,
+        buffer,
+        bytesRead,
+        bytesToRead - bytesRead,
+        start + bytesRead
+      );
+      if (count === 0) break;
+      bytesRead += count;
+    }
+    text = buffer.toString('utf8', 0, bytesRead);
+    truncated = start > 0;
   } catch {
     return [];
+  } finally {
+    if (fd !== undefined) {
+      try { fs.closeSync(fd); } catch {}
+    }
   }
   const rows = [];
-  const lines = text.split(/\r?\n/).filter((line) => line.trim()).slice(-Math.max(1, maxRows));
+  const lines = text
+    .split(/\r?\n/)
+    .slice(truncated ? 1 : 0)
+    .filter((line) => line.trim())
+    .slice(-Math.max(1, maxRows));
   for (const line of lines) {
     try {
       rows.push(JSON.parse(line));
@@ -2706,6 +3010,17 @@ function failureCoveredByPassLesson(line, passLessonText = '') {
     return /spawnSync\s+\/bin\/sh\s+ETIMEDOUT/i.test(passLessonText)
       && (!target || passLessonText.includes(target) || (targetTail && passLessonText.includes(targetTail)));
   }
+  // General remediation channel: a pass lesson that quotes the failure's
+  // normalized pattern marks it fixed. Old log lines stay on disk but stop
+  // feeding the pain score, so pain can actually go down after a fix.
+  const pattern = normalizeFailurePattern(text);
+  const bare = pattern.replace(/^#+\s*[#:.]*\s*·\s*/, '').trim();
+  for (const candidate of [pattern, bare]) {
+    if (candidate && candidate.length >= 12
+      && passLessonText.toLowerCase().includes(candidate.toLowerCase())) {
+      return true;
+    }
+  }
   return false;
 }
 
@@ -3540,8 +3855,8 @@ function findAllMembers(teamDir) {
   const entries = fs.readdirSync(teamDir);
 
   for (const entry of entries) {
-    // Skip template directory and hidden files
-    if (entry === '_template' || entry.startsWith('.')) continue;
+    // Skip template/archive directories and hidden files
+    if (entry === '_template' || entry === '_archive' || entry === '_archived' || entry.startsWith('.')) continue;
 
     const fullPath = path.join(teamDir, entry);
     const stat = fs.statSync(fullPath);
@@ -3598,6 +3913,7 @@ function findAllMembers(teamDir) {
       const content = fs.readFileSync(fullPath, 'utf8');
       const fm = parseFrontmatter(content);
       if (!fm) continue; // No frontmatter = not a member
+      if (fm.type && fm.type !== 'member') continue; // Index/doc files (e.g. ASSIGNMENTS.md, type: index) are not members
 
       const name = entry.replace('.md', '');
       members.push({
@@ -6876,6 +7192,7 @@ function readMemberScope(name, paths) {
 function isAutoGeneratedArtifact(filePath, name) {
   const memberLogs = `atris/team/${name}/logs/`;
   if (filePath.startsWith(memberLogs)) return true;
+  if (filePath === `atris/team/${name}/goals.json`) return true;
   if (filePath === `atris/team/${name}/now.md`) return true;
   return false;
 }
@@ -7404,6 +7721,127 @@ async function runMemberWake(name, { execute = false, confirmed = false, force =
   };
 }
 
+// --- Wake boot rendering: the human face of `gm <member>` ---
+// The JSON contract (atris.member_wake.v1) is untouched; this only changes what a person sees.
+
+const WAKE_REASON_TEXT = {
+  mission_missing_or_placeholder: "it has no North Star yet, and it won't guess at important work",
+  no_active_goal: 'it has no active goal to push on yet',
+  execute_requires_confirm_autonomy_policy: 'autonomous execution waits for your explicit go-ahead',
+  workspace_dirty_in_member_scope: "there are uncommitted changes in its own lane — it won't build on a dirty floor",
+  blocked_experiment: 'its current experiment is blocked on a human answer',
+  tick_executed_experiment_proposed: 'it proposed one bounded experiment and queued it for your review',
+  safe_next_bounded_step: 'it found a safe bounded next step',
+  loop_already_active: 'another loop already holds the lease, so it stepped back instead of double-working',
+  member_archived: 'this member is archived',
+  llm_not_configured: 'no model is configured for autonomous reasoning here',
+  insufficient_data: "it doesn't have enough evidence yet to act with confidence",
+  proof_not_successful: 'the last proof did not pass, so it stopped instead of stacking work on a failure',
+  auto_improver_task_create_failed: 'it found an improvement but could not put the task on the board',
+  heuristic_cross_domain_proof_written: 'it wrote a cross-domain proof using its built-in heuristics',
+  heuristic_objective_proposal_written: 'it drafted an objective proposal using its built-in heuristics',
+  install_requires_clean_git: 'installing needs a clean git tree first',
+  insufficient_world_model_data: 'its world model is too thin to act on yet',
+  llm_json_parse_failed: 'the model reply did not parse, so it stopped rather than act on garbage',
+  llm_json_parse_failed_heuristic_used: 'the model reply did not parse, so it fell back to built-in heuristics',
+  missing_domain_input: 'it needs a domain file or domain text from you to work on',
+  no_crontab: 'no crontab is available on this machine, so the loop cannot be scheduled',
+};
+
+const WAKE_DECISION_TEXT = {
+  ask: 'needs one thing from you',
+  wait: 'decided to hold',
+  tick: 'picked one bounded step',
+  close_loop: 'is closing the loop',
+  report_proof: 'has proof ready for you',
+  create_missing_task: 'is putting the missing task on the board',
+  create_task: 'is putting a new task on the board',
+  stop: 'stopped on purpose',
+  task_create_failed: 'tried to put a task on the board and could not',
+  set_objective: 'set its own objective',
+  generate_objective: 'drafted a new objective for review',
+  supervise: 'reviewed the rest of the team',
+  wiki_mine: 'is mining the wiki for its next move',
+  process_domain_file: 'is digesting the domain file you gave it',
+  cross_domain_generalize: 'is distilling patterns across domains',
+};
+
+function wakeDecisionText(decision) {
+  if (WAKE_DECISION_TEXT[decision]) return WAKE_DECISION_TEXT[decision];
+  const words = String(decision || '').replace(/_/g, ' ').trim();
+  return words ? `decided: ${words}` : 'decided nothing';
+}
+
+function wakeStyle() {
+  const on = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+  const wrap = (code) => (text) => (on ? `\x1b[${code}m${text}\x1b[0m` : String(text));
+  return { bold: wrap('1'), dim: wrap('2'), cyan: wrap('36') };
+}
+
+function wakeMemberRole(name) {
+  try {
+    const content = fs.readFileSync(memberPaths(name).memberFile, 'utf8');
+    const fm = parseFrontmatter(content);
+    return (fm && fm.role) || null;
+  } catch {
+    return null;
+  }
+}
+
+function wakeReasonText(reason) {
+  if (WAKE_REASON_TEXT[reason]) return WAKE_REASON_TEXT[reason];
+  if (reason === 'open_experiment_proposed') return 'it already has an experiment on the table, waiting for your review';
+  if (reason === 'open_experiment_running') return 'its current experiment is still running';
+  const openExperiment = String(reason || '').match(/^open_experiment_([a-z_]+)$/);
+  if (openExperiment) return `its current experiment is ${openExperiment[1].replace(/_/g, ' ')}`;
+  return String(reason || '').replace(/_/g, ' ');
+}
+
+function wakeBootLines(name, result) {
+  const s = wakeStyle();
+  const role = wakeMemberRole(name);
+  const decisionText = wakeDecisionText(result.decision);
+  const goal = result.active_goal && result.active_goal.title;
+  const experiment = result.current_experiment && result.current_experiment.title;
+  const northStar = result.mission && result.mission.north_star;
+  const laneCandidates = result.evidence && result.evidence.task_projection
+    ? result.evidence.task_projection.candidate_count
+    : null;
+
+  const lines = [
+    '',
+    `${s.cyan('\u25c8')} ${s.bold(name)} is waking up${role ? ` ${s.dim(`\u00b7 ${role}`)}` : ''}`,
+    '',
+    `  mission   ${northStar ? clipText(northStar, 70) : s.dim('no North Star yet')}`,
+    `  goal      ${goal ? clipText(goal, 70) : s.dim('none yet')}`,
+    ...(experiment ? [`  working   ${clipText(experiment, 70)}`] : []),
+    ...(laneCandidates !== null ? [`  lane      ${laneCandidates} task${laneCandidates === 1 ? '' : 's'} waiting in ${name}'s lane`] : []),
+    '',
+    `  ${s.bold(name)} looked around and ${s.bold(decisionText)}.`,
+    `  ${s.dim(`Why: ${wakeReasonText(result.reason)}.`)}`,
+  ];
+
+  if (result.created_task && result.created_task.title) {
+    lines.push('', `  On the board: ${result.created_task.display_id || result.created_task.legacy_ref || ''} ${clipText(result.created_task.title, 70)}`.trimEnd());
+  }
+  if (result.ask) {
+    lines.push('', `  ${s.bold('One thing from you:')}`, `    ${result.ask}`);
+  }
+  if (result.next_command) {
+    const ballWithHuman = result.needs_user === true
+      || result.decision === 'ask'
+      || /^open_experiment_/.test(result.reason || '');
+    lines.push('', `  ${s.bold(ballWithHuman ? 'Your move' : 'Next step')}`, `    ${s.cyan(result.next_command)}`);
+  }
+  lines.push('', `  ${s.dim(`receipt \u00b7 ${path.relative(process.cwd(), result.receipt_path)}`)}`, '');
+  return lines;
+}
+
+function clipText(value, max = 70) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  return text.length <= max ? text : `${text.slice(0, Math.max(0, max - 1)).trim()}\u2026`;
+}
+
 async function memberWake(name, ...args) {
   const asJson = hasFlag(args, '--json');
   const execute = hasFlag(args, '--execute') && !hasFlag(args, '--dry-run');
@@ -7414,28 +7852,127 @@ async function memberWake(name, ...args) {
     file: readFlag(args, '--domain-file', ''),
     name: readFlag(args, '--domain-name', ''),
   };
+  // Honor per-member sleep switch before any tick dispatch.
+  try {
+    const { isMemberAwake } = require('../lib/member-switches');
+    if (name && !isMemberAwake(name)) {
+      const skipped = {
+        ok: true,
+        skipped: true,
+        reason: 'asleep',
+        member: name,
+        decision: 'stop',
+      };
+      printJsonOrText(skipped, [`${name} is asleep`], asJson);
+      return skipped;
+    }
+  } catch {
+    // switch store unreadable: fail open and continue wake
+  }
   const result = await runMemberWake(name, { execute, confirmed, force, domainInput });
-  printJsonOrText(
-    result,
-    [
-      `Wake: ${name}`,
-      `Decision: ${result.decision}`,
-      `Reason: ${result.reason}`,
-      `Mode: ${result.mode}${result.executed ? ' executed' : ''}`,
-      ...(result.ask ? [`Ask: ${result.ask}`] : []),
-      `Next: ${result.next_command}`,
-      `Receipt: ${path.relative(process.cwd(), result.receipt_path)}`,
-    ],
-    asJson,
-  );
+  printJsonOrText(result, wakeBootLines(name, result), asJson);
 }
 
 function memberAlive(name, ...args) {
+  if (name === '--all' || name === 'all') return memberAliveAll(...args);
   const nextArgs = args.includes('--alive') ? args : [...args, '--alive'];
   return memberLoop(name, ...nextArgs);
 }
 
+function collectFleetActivationRows(root = process.cwd()) {
+  const teamDir = path.join(root, 'atris', 'team');
+  const missionMap = memberRunMissionMap();
+  return findAllMembers(teamDir)
+    .filter(isFleetMember)
+    .map((member) => {
+      const slug = memberSlugFromRecord(member);
+      const paths = memberPaths(slug);
+      const goalPlane = memberGoalPlaneStatus(slug, paths);
+      const activeMission = memberLiveMission(slug, missionMap);
+      const latestMission = memberLatestMission(slug, missionMap);
+      const skipped = !goalPlane.goal && !activeMission;
+      return {
+        member: slug,
+        goal: goalPlane.goal || null,
+        active_mission: activeMission || null,
+        latest_mission: latestMission || null,
+        skipped,
+        skip_reason: skipped ? 'no_goal_and_no_active_mission' : null,
+      };
+    })
+    .sort((a, b) => a.member.localeCompare(b.member));
+}
+
+async function callMemberLoopForFleet(kind, member, args, captureOutput) {
+  if (!captureOutput) {
+    if (kind === 'alive') return memberAlive(member, ...args);
+    return memberLoop(member, ...args);
+  }
+  const captured = [];
+  const originalLog = console.log;
+  console.log = (...parts) => captured.push(parts.join(' '));
+  try {
+    const result = kind === 'alive'
+      ? await memberAlive(member, ...args)
+      : await memberLoop(member, ...args);
+    return { result, output: captured };
+  } finally {
+    console.log = originalLog;
+  }
+}
+
+async function memberLoopAll(kind, ...args) {
+  const asJson = hasFlag(args, '--json');
+  const rows = collectFleetActivationRows();
+  const activated = [];
+  const skipped = [];
+  if (!asJson) console.log(`Member fleet ${kind}`);
+  for (const row of rows) {
+    if (row.skipped) {
+      skipped.push(row);
+      if (!asJson) console.log(`Skip ${row.member}: no goal and no active mission.`);
+      continue;
+    }
+    if (!asJson) console.log(`Activate ${row.member}: ${row.goal ? 'goal' : `mission ${row.active_mission?.id || 'active'}`}`);
+    const result = await callMemberLoopForFleet(kind, row.member, args, asJson);
+    activated.push({
+      member: row.member,
+      reason: row.goal ? 'has_goal' : 'has_active_mission',
+      mission_id: row.active_mission?.id || null,
+      result: asJson ? result?.result || null : null,
+      output: asJson ? result?.output || [] : undefined,
+    });
+  }
+  const reasonCounts = skipped.reduce((acc, row) => {
+    acc[row.skip_reason] = (acc[row.skip_reason] || 0) + 1;
+    return acc;
+  }, {});
+  const payload = {
+    ok: true,
+    action: `${kind}_all`,
+    activated: activated.length,
+    skipped: skipped.length,
+    skipped_reasons: reasonCounts,
+    activated_members: activated,
+    skipped_members: skipped.map((row) => ({
+      member: row.member,
+      reason: row.skip_reason,
+      latest_mission_id: row.latest_mission?.id || null,
+      latest_mission_status: row.latest_mission?.status || null,
+    })),
+  };
+  printJsonOrText(payload, [
+    `Summary: ${activated.length} activated, ${skipped.length} skipped (${Object.entries(reasonCounts).map(([reason, count]) => `${reason} x${count}`).join(', ') || 'none'}).`,
+  ], asJson);
+  return payload;
+}
+
+function memberAliveAll(...args) {
+  return memberLoopAll('alive', ...args);
+}
+
 async function memberLoop(name, ...args) {
+  if (name === '--all' || name === 'all') return memberLoopAll('loop', ...args);
   requireMemberDir(name);
   const asJson = hasFlag(args, '--json');
   const aliveMode = hasFlag(args, '--alive');
@@ -7615,6 +8152,13 @@ async function memberLoop(name, ...args) {
   let earlyExit = null;
   let consecutiveIdle = 0;
   const idleBreakThreshold = 2;
+  // Repeated identical `ask:*` wake decisions (e.g. ask:mission_missing_or_placeholder) mean the
+  // member is stuck asking the same question every tick regardless of --execute; the idle
+  // early-exit above only fires in execute mode, so without this a dry-run loop burns every
+  // remaining tick re-asking. Reuse the same blocked_on_human handoff once we see the ask repeat.
+  let lastAskKey = null;
+  let consecutiveIdenticalAsk = 0;
+  const identicalAskBreakThreshold = 2;
 
   try {
     for (let index = 0; index < ticks; index += 1) {
@@ -7686,6 +8230,29 @@ async function memberLoop(name, ...args) {
         };
         tickResults.push(tick);
         fs.appendFileSync(tickLogPath, JSON.stringify(tick) + '\n', 'utf8');
+
+        if (wake.decision === 'ask') {
+          if (key === lastAskKey) {
+            consecutiveIdenticalAsk += 1;
+          } else {
+            lastAskKey = key;
+            consecutiveIdenticalAsk = 1;
+          }
+          if (consecutiveIdenticalAsk >= identicalAskBreakThreshold) {
+            earlyExit = {
+              after_tick: tick.tick,
+              decision: tick.decision || null,
+              reason: tick.reason || 'idle',
+              needs_user: tick.needs_user === true,
+              blocked_on_human: true,
+              next_command: tick.next_command || null,
+              stop: 'repeated_identical_ask',
+            };
+          }
+        } else {
+          lastAskKey = null;
+          consecutiveIdenticalAsk = 0;
+        }
         }
       } catch (error) {
         failed = true;
@@ -7700,6 +8267,7 @@ async function memberLoop(name, ...args) {
         fs.appendFileSync(tickLogPath, JSON.stringify(tick) + '\n', 'utf8');
         break;
       }
+      if (earlyExit) break;
       if (execute) {
         const last = tickResults[tickResults.length - 1];
         if (last && last.productive) {
@@ -7748,6 +8316,7 @@ async function memberLoop(name, ...args) {
     duration_ms_actual: Date.parse(finishedAt) - Date.parse(startedAt),
     decisions,
     early_exit: earlyExit,
+    stop: earlyExit?.stop || null,
     blocked_on_human: earlyExit?.blocked_on_human === true,
     needs_user: earlyExit?.needs_user === true,
     next_command: earlyExit?.next_command || null,
@@ -7962,58 +8531,173 @@ function memberBlock(name, experimentId, ...args) {
   );
 }
 
+function collectFleetMemberStatus(root = process.cwd()) {
+  const teamDir = path.join(root, 'atris', 'team');
+  const missionMap = memberRunMissionMap();
+  return findAllMembers(teamDir)
+    .filter(isFleetMember)
+    .map((member) => {
+      const slug = memberSlugFromRecord(member);
+      const paths = memberPaths(slug);
+      const goalPlane = memberGoalPlaneStatus(slug, paths);
+      const mission = memberMissionSummary(slug, missionMap);
+      const activity = memberLastActivity(slug, paths, root);
+      const verdict = memberVerdict({ mission, activity });
+      return {
+        member: slug,
+        role: member.role,
+        goal_state: goalPlane.stateLabel,
+        goal_title: goalPlane.goal?.title || null,
+        mission: mission.latest ? {
+          id: mission.latest.id || null,
+          name: mission.name,
+          state: mission.state,
+          last_tick_at: mission.last_tick_at,
+          last_tick_age: mission.last_tick_age,
+          live: mission.live_mission,
+        } : null,
+        last_activity: activity,
+        verdict,
+      };
+    })
+    .sort((a, b) => a.member.localeCompare(b.member));
+}
+
+function clipCell(value, width) {
+  const clean = String(value || '-').replace(/\s+/g, ' ').trim() || '-';
+  if (clean.length <= width) return clean.padEnd(width);
+  if (width <= 3) return clean.slice(0, width);
+  return `${clean.slice(0, width - 3)}...`;
+}
+
+function renderMemberFleetStatusTable(rows) {
+  if (!rows.length) return ['No active team members found in atris/team/.'];
+  const widths = {
+    member: 18,
+    goal: 11,
+    mission: 34,
+    state: 10,
+    tick: 8,
+    activity: 8,
+    verdict: 8,
+  };
+  const header = [
+    clipCell('Member', widths.member),
+    clipCell('Goal', widths.goal),
+    clipCell('Mission', widths.mission),
+    clipCell('State', widths.state),
+    clipCell('Tick', widths.tick),
+    clipCell('Activity', widths.activity),
+    clipCell('Verdict', widths.verdict),
+  ].join(' ');
+  const rule = [
+    '-'.repeat(widths.member),
+    '-'.repeat(widths.goal),
+    '-'.repeat(widths.mission),
+    '-'.repeat(widths.state),
+    '-'.repeat(widths.tick),
+    '-'.repeat(widths.activity),
+    '-'.repeat(widths.verdict),
+  ].join(' ');
+  return [
+    'Member fleet status',
+    header,
+    rule,
+    ...rows.map((row) => [
+      clipCell(row.member, widths.member),
+      clipCell(row.goal_state, widths.goal),
+      clipCell(row.mission?.name || '-', widths.mission),
+      clipCell(row.mission?.state || '-', widths.state),
+      clipCell(row.mission?.last_tick_age || '-', widths.tick),
+      clipCell(row.last_activity?.age || '-', widths.activity),
+      clipCell(row.verdict, widths.verdict),
+    ].join(' ')),
+  ];
+}
+
+function memberStatusAll(...args) {
+  const asJson = hasFlag(args, '--json');
+  const rows = collectFleetMemberStatus();
+  printJsonOrText(
+    {
+      ok: true,
+      action: 'status_all',
+      members: rows,
+    },
+    renderMemberFleetStatusTable(rows),
+    asJson,
+  );
+}
+
 function memberStatus(name, ...args) {
+  if (name === '--all' || name === 'all') return memberStatusAll(...args);
   const paths = requireMemberDir(name);
   const asJson = hasFlag(args, '--json');
-  const state = loadMemberGoals(name, paths);
-  const goal = activeGoal(state);
-  const current = memberOpenExperiment(state);
-  const lastReviewed = memberLastReviewedExperiment(state);
-  const value = memberValueSummary(state);
-  const logs = recentLogLines(paths.memberDir);
-  const needsUser = current?.status === 'blocked';
-  const stateLabel = !goal
-    ? 'no_goal'
-    : needsUser
-      ? 'needs_user'
-      : current
-        ? current.status
-        : 'ready';
-  const ask = needsUser ? (current.block?.ask || 'Needs operator input.') : null;
-  const nextCommand = !goal
-    ? `atris member goal ${name} "..."`
-    : needsUser
-      ? `atris member review ${name} ${current.id} --discard --proof "..."`
-      : current
-        ? `atris member review ${name} ${current.id} --accept --proof "..." --value 4`
-        : `atris member tick ${name}`;
+  const goalPlane = memberGoalPlaneStatus(name, paths);
+  const owner = paths.storageName || name;
+  const mission = memberMissionSummary(owner, memberRunMissionMap());
+  const activity = memberLastActivity(owner, paths);
+  const verdict = memberVerdict({ mission, activity });
+  let memberSwitch = { awake: true, loops: {} };
+  try {
+    const { getMemberSwitch } = require('../lib/member-switches');
+    memberSwitch = getMemberSwitch(name);
+  } catch {
+    // default awake
+  }
+  const loopEntries = Object.entries(memberSwitch.loops || {})
+    .map(([id, on]) => `${id}:${on === false ? 'asleep' : 'awake'}`);
+  const switchLabel = memberSwitch.awake === false ? 'asleep' : 'awake';
   const payload = {
     ok: true,
     action: 'status',
     member: name,
-    state: stateLabel,
-    needs_user: needsUser,
-    ask,
-    active_goal: goal || null,
-    current_experiment: current || null,
-    last_reviewed: lastReviewed || null,
-    value,
-    next_command: nextCommand,
-    recent_log: logs,
+    state: goalPlane.stateLabel,
+    needs_user: goalPlane.needsUser,
+    ask: goalPlane.ask,
+    active_goal: goalPlane.goal || null,
+    current_experiment: goalPlane.current || null,
+    last_reviewed: goalPlane.lastReviewed || null,
+    value: goalPlane.value,
+    switch: {
+      awake: memberSwitch.awake !== false,
+      loops: memberSwitch.loops || {},
+    },
+    mission: mission.latest ? {
+      id: mission.latest.id || null,
+      name: mission.name,
+      state: mission.state,
+      last_tick_at: mission.last_tick_at,
+      last_tick_age: mission.last_tick_age,
+      live: mission.live_mission,
+    } : null,
+    last_activity: activity,
+    verdict,
+    next_command: goalPlane.nextCommand,
+    recent_log: goalPlane.logs,
     goals_path: paths.goalsJson,
     goals_md_path: paths.goalsMd,
   };
+  const s = wakeStyle();
+  const role = wakeMemberRole(name);
+  const ballWithHuman = goalPlane.needsUser === true || goalPlane.current?.status === 'proposed';
   printJsonOrText(
     payload,
     [
-      `Member: ${name}`,
-      `State: ${stateLabel}`,
-      `Goal: ${goal?.title || 'No goal yet'}`,
-      `Current: ${current ? `${current.status} - ${current.title}` : 'No open experiment'}`,
-      ...(ask ? [`Ask: ${ask}`] : []),
-      `Value: ${value.line}`,
-      `Next: ${nextCommand}`,
-      ...(logs.length ? ['Recent log:', ...logs.map((line) => `  ${line}`)] : []),
+      '',
+      `${s.cyan('\u25c8')} ${s.bold(name)}${role ? ` ${s.dim(`\u00b7 ${role}`)}` : ''} ${s.dim(`\u00b7 ${verdict.toLowerCase()}, last activity ${activity.age}`)}`,
+      '',
+      `  goal      ${goalPlane.goal?.title ? clipText(goalPlane.goal.title, 70) : s.dim('none yet')}`,
+      `  working   ${goalPlane.current ? `${clipText(goalPlane.current.title, 60)} ${s.dim(`(${goalPlane.current.status})`)}` : s.dim('no open experiment')}`,
+      `  value     ${goalPlane.value.line}`,
+      `  switch    ${switchLabel}${loopEntries.length ? ` ${s.dim(`(${loopEntries.join(', ')})`)}` : ''}`,
+      `  mission   ${mission.latest ? `${mission.name} ${s.dim(`(${mission.state}, last tick ${mission.last_tick_age})`)}` : s.dim('none owned')}`,
+      ...(goalPlane.ask ? ['', `  ${s.bold('One thing from you:')}`, `    ${goalPlane.ask}`] : []),
+      '',
+      `  ${s.bold(ballWithHuman ? 'Your move' : 'Next step')}`,
+      `    ${s.cyan(goalPlane.nextCommand)}`,
+      ...(goalPlane.logs.length ? ['', `  ${s.dim('recent')}`, ...goalPlane.logs.map((line) => `  ${s.dim(line)}`)] : []),
+      '',
     ],
     asJson,
   );
@@ -8107,6 +8791,143 @@ function memberHistory(name, ...args) {
   }
 }
 
+// --- Live backend status (heartbeat + projection) ---
+
+function parseLiveFlags(args) {
+  const flags = { scope: 'personal', scopeId: null, json: false, state: null, note: null, days: null };
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--json') flags.json = true;
+    else if (a === '--done') flags.state = 'done';
+    else if (a === '--error') flags.state = 'error';
+    else if (a === '--running') flags.state = 'running';
+    else if (a === '--scope') flags.scope = args[++i];
+    else if (a.startsWith('--scope=')) flags.scope = a.slice(8);
+    else if (a === '--scope-id') flags.scopeId = args[++i];
+    else if (a.startsWith('--scope-id=')) flags.scopeId = a.slice(11);
+    else if (a === '--note' || a === '--on') flags.note = args[++i];
+    else if (a.startsWith('--note=')) flags.note = a.slice(7);
+    else if (a === '--days') flags.days = parseInt(args[++i], 10);
+    else if (a.startsWith('--days=')) flags.days = parseInt(a.slice(7), 10);
+    else positional.push(a);
+  }
+  return { flags, positional };
+}
+
+function memberScopeQuery(flags) {
+  let q = `scope=${encodeURIComponent(flags.scope)}`;
+  if (flags.scopeId) q += `&scope_id=${encodeURIComponent(flags.scopeId)}`;
+  return q;
+}
+
+// atris member live — what the iPhone app and web see: GET /api/members projection.
+async function memberLive(...args) {
+  const { flags } = parseLiveFlags(args);
+  const creds = loadCredentials();
+  if (!creds || !creds.token) {
+    console.error('Not logged in. Run: atris login');
+    process.exit(1);
+  }
+  const result = await apiRequestJson(`/members?${memberScopeQuery(flags)}`, { token: creds.token });
+  if (!result.ok) {
+    console.error(`Failed to fetch members: ${result.error || 'Unknown error'}`);
+    process.exit(1);
+  }
+  const members = (result.data?.members || result.data || []).filter((m) => m && m.member_type === 'ai');
+  if (flags.json) {
+    console.log(JSON.stringify(members, null, 2));
+    return;
+  }
+  console.log('');
+  console.log(`live members (${flags.scope}${flags.scopeId ? `:${flags.scopeId}` : ''}) — same projection the app renders`);
+  console.log('');
+  for (const m of members) {
+    const loop = m.loop_status || {};
+    const dot = loop.running ? '●' : '○';
+    const state = loop.state || m.status || '-';
+    const workingOn = loop.working_on || loop.now || '';
+    const lastActive = loop.last_active || '';
+    console.log(`  ${dot} ${m.display_name}  [${state}]${workingOn ? `  ${workingOn}` : ''}${lastActive ? `  (last active ${lastActive})` : ''}`);
+  }
+  if (members.length === 0) console.log('  (no AI members in this scope)');
+  console.log('');
+}
+
+// atris member heartbeat — tell the backend this member is running/done, so
+// every surface (iOS, web) shows it live. POST /api/members/{name}/heartbeat.
+async function memberHeartbeat(name, ...args) {
+  if (!name) {
+    console.error('Usage: atris member heartbeat <name> [--note "what it is doing"] [--done|--error] [--scope business --scope-id <id>] [--json]');
+    process.exit(1);
+  }
+  const { flags } = parseLiveFlags(args);
+  const creds = loadCredentials();
+  if (!creds || !creds.token) {
+    console.error('Not logged in. Run: atris login');
+    process.exit(1);
+  }
+  const body = { state: flags.state || 'running', scope: flags.scope };
+  if (flags.note) body.working_on = flags.note;
+  if (flags.scopeId) body.scope_id = flags.scopeId;
+  const result = await apiRequestJson(`/members/${encodeURIComponent(name)}/heartbeat`, {
+    method: 'POST',
+    body: JSON.stringify(body),
+    headers: { 'Content-Type': 'application/json' },
+    token: creds.token,
+  });
+  if (!result.ok) {
+    console.error(`Heartbeat failed: ${result.error || 'Unknown error'}`);
+    process.exit(1);
+  }
+  if (flags.json) {
+    console.log(JSON.stringify(result.data, null, 2));
+    return;
+  }
+  const d = result.data || {};
+  console.log(`${d.running ? '●' : '○'} ${d.member || name} → ${d.state}${d.working_on ? ` — ${d.working_on}` : ''} (visible on every surface)`);
+}
+
+// atris member improvements — what the business computer improved, day by day.
+// GET /api/business/{id}/improvements/daily.
+async function memberImprovements(businessId, ...args) {
+  if (!businessId) {
+    console.error('Usage: atris member improvements <business-id> [--days N] [--json]');
+    process.exit(1);
+  }
+  const { flags } = parseLiveFlags(args);
+  const creds = loadCredentials();
+  if (!creds || !creds.token) {
+    console.error('Not logged in. Run: atris login');
+    process.exit(1);
+  }
+  const days = flags.days && Number.isFinite(flags.days) ? flags.days : 30;
+  const result = await apiRequestJson(`/business/${encodeURIComponent(businessId)}/improvements/daily?days=${days}`, { token: creds.token });
+  if (!result.ok) {
+    console.error(`Failed to fetch improvements: ${result.error || 'Unknown error'}`);
+    process.exit(1);
+  }
+  if (flags.json) {
+    console.log(JSON.stringify(result.data, null, 2));
+    return;
+  }
+  const history = result.data?.history || [];
+  console.log('');
+  console.log(`daily improvements — business ${businessId}`);
+  console.log('');
+  if (history.length === 0) {
+    console.log('  (no improvement history yet — first entry lands after the next nightly self-improve run)');
+  }
+  for (const day of history) {
+    console.log(`  ${day.date}: ${day.agents_improved}/${day.agents_total} agents improved`);
+    for (const agent of day.agents || []) {
+      const note = agent.note ? ` — ${agent.note}` : '';
+      console.log(`    ${agent.kept_count > 0 ? '+' : ' '} ${agent.name} (kept ${agent.kept_count}, score ${agent.best_score})${note}`);
+    }
+  }
+  console.log('');
+}
+
 // --- Command Dispatcher ---
 
 async function memberCommand(subcommand, ...args) {
@@ -8158,6 +8979,13 @@ async function memberCommand(subcommand, ...args) {
       return memberBlock(args[0], args[1], ...args.slice(2));
     case 'status':
       return memberStatus(args[0], ...args.slice(1));
+    case 'live':
+      return memberLive(...args);
+    case 'heartbeat':
+    case 'hb':
+      return memberHeartbeat(args[0], ...args.slice(1));
+    case 'improvements':
+      return memberImprovements(args[0], ...args.slice(1));
     case 'history':
       return memberHistory(args[0], ...args.slice(1));
     case 'supervisor':
@@ -8186,11 +9014,14 @@ async function memberCommand(subcommand, ...args) {
       console.log('  goal-from-score <name>    Create/reuse an active goal from Team score evidence');
       console.log('  wake <name>         Read Mission state and decide tick/wait/ask/stop');
       console.log('  run <name> ["..."]  Start a budgeted member mission, or run its active Mission Runtime');
-      console.log('  loop <name>         Repeat wake on a bounded cadence with a no-overlap lease');
+      console.log('  loop <name|--all>   Repeat wake on a bounded cadence with a no-overlap lease');
       console.log('  tick <name>         Propose the next bounded experiment');
       console.log('  review <name> <id>  Accept/discard an experiment with proof');
       console.log('  block <name> <id>   Mark an experiment blocked with a human/orchestrator ask');
-      console.log('  status <name>       Show goal, open experiment, value, ask, and recent log');
+      console.log('  status <name|--all> Show goal, mission, activity, value, ask, and recent log');
+      console.log('  live                Show backend member projection (what iOS/web render) [--scope business --scope-id <id>]');
+      console.log('  heartbeat <name>    Mark a member running/done on every surface [--note "..."] [--done|--error]');
+      console.log('  improvements <biz>  Show daily self-improve history for a business [--days N]');
       console.log('  history <name>      Show git history of member identity files (MEMBER.md, SOUL.md)');
       console.log('  supervisor recommendations  Show advisory supervisor recommendations');
       console.log('  objective-generator proposals  Show autonomous objective proposal');
@@ -8225,10 +9056,12 @@ async function memberCommand(subcommand, ...args) {
       console.log('  atris member loop growth --minutes 10 --interval 60 --json');
       console.log('  atris member alive growth --hourly --forever --execute --confirm-autonomy-policy --json');
       console.log('  atris member alive growth --install --hourly --forever --execute --confirm-autonomy-policy --json');
+      console.log('  atris member alive --all --install --hourly --forever --dry-run');
       console.log('  atris member alive growth --minutes 480 --interval 900 --execute --confirm-autonomy-policy --json');
       console.log('  atris member loop growth --ticks 2 --interval 0 --json');
       console.log('  atris member tick growth --json');
       console.log('  atris member status growth');
+      console.log('  atris member status --all');
       console.log('  atris member review growth exp_123 --accept --proof "validated" --value 4');
       console.log('  atris member archive old-member');
       console.log('  atris member purge-archived --days=60 --confirm "delete archived members"');
@@ -8236,4 +9069,4 @@ async function memberCommand(subcommand, ...args) {
   }
 }
 
-module.exports = { memberCommand, findAllMembers, parseFrontmatter };
+module.exports = { memberCommand, findAllMembers, parseFrontmatter, wakeBootLines, buildMemberRunStartArgs };