atris 3.35.0 → 3.37.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 {
@@ -614,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;
 
@@ -646,6 +708,7 @@ const MEMBER_RUN_START_VALUE_FLAGS = [
 
 const MEMBER_RUN_START_BOOLEAN_FLAGS = [
   '--json',
+  '--no-verify',
   '--worktree',
   '--shared-checkout',
   '--no-worktree',
@@ -681,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) : '';
@@ -733,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'),
   ];
@@ -755,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 {
@@ -1603,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));
@@ -2870,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;
 }
 
@@ -3762,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({
@@ -7569,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');
@@ -7579,20 +7852,25 @@ 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) {
@@ -7874,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) {
@@ -7945,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;
@@ -7959,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) {
@@ -8007,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,
@@ -8328,6 +8638,16 @@ function memberStatus(name, ...args) {
   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',
@@ -8339,6 +8659,10 @@ function memberStatus(name, ...args) {
     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,
@@ -8354,20 +8678,26 @@ function memberStatus(name, ...args) {
     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: ${goalPlane.stateLabel}`,
-      `Goal: ${goalPlane.goal?.title || 'No goal yet'}`,
-      `Current: ${goalPlane.current ? `${goalPlane.current.status} - ${goalPlane.current.title}` : 'No open experiment'}`,
-      ...(goalPlane.ask ? [`Ask: ${goalPlane.ask}`] : []),
-      `Value: ${goalPlane.value.line}`,
-      `Mission: ${mission.latest ? `${mission.name} (${mission.state}, last tick ${mission.last_tick_age})` : 'No owned mission'}`,
-      `Activity: ${activity.age}`,
-      `Verdict: ${verdict}`,
-      `Next: ${goalPlane.nextCommand}`,
-      ...(goalPlane.logs.length ? ['Recent log:', ...goalPlane.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,
   );
@@ -8461,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) {
@@ -8512,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':
@@ -8545,6 +9019,9 @@ async function memberCommand(subcommand, ...args) {
       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|--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');
@@ -8592,4 +9069,4 @@ async function memberCommand(subcommand, ...args) {
   }
 }
 
-module.exports = { memberCommand, findAllMembers, parseFrontmatter };
+module.exports = { memberCommand, findAllMembers, parseFrontmatter, wakeBootLines, buildMemberRunStartArgs };