atris 3.68.2 → 3.68.4

package/commands/member.js

@@ -8,7 +8,7 @@ const { resolveBackendRoot } = require('../utils/backend-root');
 const { apiRequestJson } = require('../utils/api');
 const { runAliveTick } = require('../lib/member-alive');
 const { memberRefusalReason } = require('../lib/member-type');
-const { defaultObjectiveRunner } = require('../lib/default-runner');
+const { callerRuntime, defaultObjectiveRunner } = require('../lib/default-runner');
 const { readJson, writeJson } = require('../lib/json-file');
 const { sleepSync } = require('../lib/sleep-sync');
 const { hasFlag, readFlag, readNumberFlag } = require('../lib/arg-parser');
@@ -383,7 +383,10 @@ function loadMemberGoals(name, paths = memberPaths(name)) {
 
 function activeGoal(goalsState, goalId = '') {
   if (goalId) return goalsState.goals.find((goal) => goal.id === goalId) || null;
-  return goalsState.goals.find((goal) => goal.status === 'active') || goalsState.goals[0] || null;
+  for (let i = (goalsState.goals || []).length - 1; i >= 0; i -= 1) {
+    if (goalsState.goals[i]?.status === 'active') return goalsState.goals[i];
+  }
+  return goalsState.goals[0] || null;
 }
 
 function allExperiments(state) {
@@ -490,9 +493,18 @@ function missionPurpose(paths) {
 const MEMBER_RUN_RUNNABLE_STATUSES = new Set(['planning', 'running', 'ready']);
 const MISSION_TERMINAL_STATUSES = new Set(['complete', 'stopped', 'failed']);
 
-function memberRunMissionMap() {
+function memberRunMissionMap(root = process.cwd()) {
   try {
-    return require('./mission').loadMissionMap(process.cwd());
+    const missionMod = require('./mission');
+    const map = new Map(missionMod.loadMissionMap(root));
+    for (const rolled of missionMod.listWorktreeRollupMissions(root)) {
+      if (!rolled?.id) continue;
+      const existing = map.get(rolled.id);
+      if (!existing || missionTimeMs(rolled) >= missionTimeMs(existing)) {
+        map.set(rolled.id, rolled);
+      }
+    }
+    return map;
   } catch {
     return new Map();
   }
@@ -627,18 +639,38 @@ function memberLastActivity(name, paths = memberPaths(name), root = process.cwd(
   };
 }
 
-function memberMissionSummary(name, missionMap = memberRunMissionMap()) {
+function memberMissionSummary(name, missionMap = memberRunMissionMap(), root = process.cwd()) {
   const latest = memberLatestMission(name, missionMap);
   const live = memberLiveMission(name, missionMap);
   const lastTickMs = timestampMs(latest?.last_tick_at);
+  let driver = null;
+  if (latest) {
+    try {
+      const { missionDriverHealth } = require('./mission');
+      const missionRoot = latest.worktree_root || latest.worktree?.path || root;
+      driver = missionDriverHealth(latest, missionRoot);
+    } catch {
+      driver = null;
+    }
+  }
+  const worktreeRoot = latest?.worktree_root || latest?.worktree?.path || null;
+  const worktreeBranch = latest?.worktree_branch || latest?.worktree?.branch || null;
   return {
     latest,
     live,
     name: missionShortName(latest),
+    objective: latest?.objective || null,
     state: latest?.status || '-',
+    runner: latest?.runner || null,
+    model: latest?.model || null,
+    worktree_root: worktreeRoot,
+    worktree_branch: worktreeBranch,
+    task_ref: latest?.task_ref || latest?.xp_task?.ref || null,
+    current_task_id: latest?.current_task_id || latest?.task_ids?.[0] || null,
     last_tick_at: latest?.last_tick_at || null,
     last_tick_age: ageLabelFromMs(lastTickMs),
-    live_mission: Boolean(live),
+    live_mission: Boolean(live) || Boolean(driver?.alive),
+    driver,
   };
 }
 
@@ -720,6 +752,7 @@ const MEMBER_RUN_START_VALUE_FLAGS = [
   '--visible-goal-objective',
   '--max-idle-ticks',
   '--slots',
+  '--referee-engine',
   '--lane',
   '--cadence',
   '--verify',
@@ -735,11 +768,14 @@ const MEMBER_RUN_START_VALUE_FLAGS = [
   '--outcome',
   '--truth',
   '--proof',
+  '--base',
 ];
 
 const MEMBER_RUN_START_BOOLEAN_FLAGS = [
   '--json',
   '--no-verify',
+  '--referee',
+  '--no-referee',
   '--worktree',
   '--shared-checkout',
   '--no-worktree',
@@ -773,6 +809,10 @@ const MEMBER_RUN_START_BOOLEAN_FLAGS = [
   '--dry-run',
   '--land',
   '--cloud',
+  '--ignite',
+  '--wait',
+  '--sync',
+  '--no-driver',
 ];
 
 function memberRunMissionWordIndices(args = []) {
@@ -900,7 +940,23 @@ function memberRunRunner(owner, args = [], cwd = process.cwd()) {
   return memberRosterEngine(owner, cwd) ? 'auto' : fallback;
 }
 
+function inferMemberRunVerifier(missionText, args = [], cwd = process.cwd()) {
+  if (hasFlag(args, '--no-verify')) return '';
+  const explicit = readFlag(args, '--verify', '');
+  if (explicit) return explicit;
+  const text = String(missionText || '').trim();
+  if (!text) return '';
+  const cmdMatch = text.match(/\b(npm\s+run\s+type-check|node\s+--test\s+tests?\/[A-Za-z0-9_./-]+)\b/);
+  if (cmdMatch) return cmdMatch[1].replace(/\s+/g, ' ');
+  const testFileMatch = text.match(/\b(tests?\/[A-Za-z0-9_./-]+\.test\.m?js)\b/);
+  if (testFileMatch && fs.existsSync(path.join(cwd, testFileMatch[1]))) {
+    return `node --test ${testFileMatch[1]}`;
+  }
+  return '';
+}
+
 function buildMemberRunStartArgs(owner, missionText, args = [], cwd = process.cwd()) {
+  const resolvedVerifier = inferMemberRunVerifier(missionText, args, cwd);
   const startArgs = [
     'mission',
     'start',
@@ -913,7 +969,9 @@ function buildMemberRunStartArgs(owner, missionText, args = [], cwd = process.cw
     readFlag(args, '--lane', 'workspace'),
   ];
   pushFlagValue(startArgs, args, '--cadence');
-  pushFlagValue(startArgs, args, '--verify');
+  if (resolvedVerifier) {
+    startArgs.push('--verify', String(resolvedVerifier));
+  }
   pushFlagValue(startArgs, args, '--stop');
   pushFlagValue(startArgs, args, '--model');
   pushFlagValue(startArgs, args, '--max-wall');
@@ -921,8 +979,9 @@ function buildMemberRunStartArgs(owner, missionText, args = [], cwd = process.cw
   pushFlagValue(startArgs, args, '--hours');
   pushFlagValue(startArgs, args, '--base');
   // Member runs choose and drive work immediately, so an absent check must not
-  // leave autonomous callers with a mission that never ran.
-  if (hasFlag(args, '--no-verify') || !readFlag(args, '--verify', '')) {
+  // leave autonomous callers with a mission that never ran. A check inferred
+  // from the mission text counts as named.
+  if (hasFlag(args, '--no-verify') || !resolvedVerifier) {
     startArgs.push('--no-verify');
   }
   pushFlagWhenPresent(startArgs, args, '--always-on');
@@ -992,16 +1051,96 @@ function memberRunConfiguredVerifier(paths) {
   return typeof check === 'string' ? check.trim() : '';
 }
 
-function printMemberRunResult(result, asJson) {
-  if (asJson) {
+function printMemberRunResult(result, asJson, { quiet = false } = {}) {
+  if (quiet) {
+    // A caller (member wake) prints this result inside its own report.
+  } else if (asJson) {
     console.log(JSON.stringify(result));
   } else if (result.started) {
     console.log(`started ${result.mission_id} (${result.state})`);
   }
+  if (!quiet && !asJson && result.ask) console.error(result.ask);
   if (result.ok === false || (!result.started && result.ok !== true)) {
-    if (!result.errorReported) console.error(result.error);
+    if (!quiet && !result.errorReported && !result.ask) console.error(result.error);
     process.exitCode = 1;
   }
+  return result;
+}
+
+// Runners that hand the mission to the agent session that called Atris. From
+// a plain terminal nothing is on the other end of them.
+const MEMBER_RUN_CALLER_SESSION_RUNNERS = new Set(['codex_goal', 'caller_session', 'current_agent']);
+
+function memberRunUsesCallerSession(runner) {
+  return MEMBER_RUN_CALLER_SESSION_RUNNERS.has(String(runner || '').trim().toLowerCase());
+}
+
+// A mission whose runner waits on a caller session cannot do anything when
+// no such session started this run. Swap in the roster engine for this run
+// ("auto" resolves the owner's roster pick per tick) instead of waiting on a
+// native goal nothing will start. An explicit --runner or --engine on this
+// command still wins, and a real codex caller keeps its native goal.
+function memberRunRunnerSwap(mission, args, caller) {
+  if (!memberRunUsesCallerSession(mission?.runner)) return null;
+  if (caller === 'codex') return null;
+  if (readFlag(args, '--runner', '') || readFlag(args, '--engine', '')) return null;
+  return {
+    from: String(mission.runner),
+    to: 'auto',
+    reason: `no ${String(mission.runner) === 'codex_goal' ? 'codex' : 'agent'} session started this run, so the member's roster engine does the work`,
+  };
+}
+
+function memberRunTickDurationMs(tick) {
+  const start = Date.parse(tick?.started_at || '');
+  const end = Date.parse(tick?.finished_at || '');
+  return Number.isFinite(start) && Number.isFinite(end) && end >= start ? end - start : null;
+}
+
+// One plain record of the work step this run executed (or why none ran), so
+// a reader never has to dig through mission internals to learn what happened.
+function memberRunWorkStep(payload, finalMission) {
+  const ticks = Array.isArray(payload?.ticks) ? payload.ticks : [];
+  const ran = [...ticks].reverse().find((tick) => tick && tick.ran === true) || null;
+  const last = ran || ticks[ticks.length - 1] || null;
+  const worker = last?.claude || last?.atris2 || null;
+  return {
+    ran: Boolean(ran),
+    ticks_ran: Number(payload?.ran_ticks) || 0,
+    engine: last?.engine_id || finalMission?.runner || null,
+    model: last?.model || worker?.model || finalMission?.model || null,
+    duration_ms: last ? memberRunTickDurationMs(last) : null,
+    status: last?.status || null,
+    reason: last?.reason || null,
+    summary: worker?.summary ? String(worker.summary).slice(0, 400) : null,
+    receipt_path: payload?.summary_receipt || finalMission?.receipt_path || null,
+  };
+}
+
+// The protected-surface guard keeps the staged work and pauses for a person.
+// Say so in one line, with the command that shows the work.
+function memberRunReviewAsk(name, payload, mission, cwd) {
+  const ticks = Array.isArray(payload?.ticks) ? payload.ticks : [];
+  const guarded = ticks.find((tick) => tick?.protected_lane_guard && tick.protected_lane_guard.allowed === false);
+  const guard = guarded?.protected_lane_guard || null;
+  if (!guard) return null;
+  const surfaces = Array.isArray(guard.surfaces) && guard.surfaces.length ? guard.surfaces.join(', ') : 'a protected surface';
+  if (guard.unreadable) {
+    return {
+      needs_review: true,
+      ask: `${name} paused: Atris could not read the mission diff; fix that, then rerun.`,
+      next_command: `atris mission tick ${mission.id} --verify`,
+      review_path: cwd,
+    };
+  }
+  const where = JSON.stringify(cwd);
+  return {
+    needs_review: true,
+    ask: `${name} staged a change that touches ${surfaces}; it is kept in ${cwd} for you to review, land, or discard.`,
+    next_command: `git -C ${where} status --short && git -C ${where} diff HEAD`,
+    resume_command: `atris mission run ${mission.id}`,
+    review_path: cwd,
+  };
 }
 
 // atris member ping <name> "<message>": talk to a busy member mid-run.
@@ -1087,10 +1226,15 @@ function memberPing(name, ...args) {
 }
 
 function memberRun(name, ...args) {
+  return memberRunWith(name, args);
+}
+
+function memberRunWith(name, args, { quiet = false } = {}) {
   if (!name || name === '--help' || name === '-h' || hasFlag(args, '--help') || hasFlag(args, '-h')) {
     console.log('usage: atris member run <name> ["mission text"] [--verify "<cmd>"] [--minutes N|--hours N] [--json]');
     console.log('new mission: atris member run growth "improve onboarding proof" --verify "npm test" --minutes 30 --json');
     console.log('choose work: atris member run growth --verify "npm test" --industry logistics --minutes 30 --json');
+    console.log('subagent shell: atris member run growth "improve onboarding proof" --engine claude --ignite --json');
     console.log('existing mission: atris member run growth --mission <mission-id> --max-ticks 1 --json');
     console.log('meaning: if mission text is omitted, the member chooses one useful bounded task from atris state.');
     console.log('truth: useful work must improve revenue, reliability, speed, security, clarity, or trust, then show plain proof.');
@@ -1099,6 +1243,12 @@ function memberRun(name, ...args) {
     return;
   }
 
+  // --ignite (or --wait, --sync) runs the member as a subagent shell: it works
+  // on the named engine until the check passes, then the mission completes.
+  const ignite = hasFlag(args, '--ignite') || hasFlag(args, '--wait') || hasFlag(args, '--sync');
+  if (ignite && readFlag(args, '--engine', '') && !readFlag(args, '--runner', '')) {
+    args = [...args, '--runner', readFlag(args, '--engine', '')];
+  }
   const asJson = hasFlag(args, '--json');
   const paths = requireRunnableMember(name);
   // Parking only hides a member from the team views; a run by name still goes.
@@ -1118,9 +1268,8 @@ function memberRun(name, ...args) {
   if (missionText && !hasMissionOverride) {
     const start = startMemberRunMission(name, missionText, requestedVerifier ? [...args, '--verify', requestedVerifier] : args);
     if (start.status !== 0 || !start.payload?.mission) {
-      printMemberRunResult({ started: false, state: null, mission_id: start.payload?.mission?.id || null,
-        error: start.payload?.detail || start.payload?.error || start.stderr || 'mission creation failed' }, asJson);
-      return;
+      return printMemberRunResult({ started: false, state: null, mission_id: start.payload?.mission?.id || null,
+        error: start.payload?.detail || start.payload?.error || start.stderr || 'mission creation failed' }, asJson, { quiet });
     }
     mission = start.payload.mission;
     startedNewMission = true;
@@ -1131,9 +1280,8 @@ function memberRun(name, ...args) {
     if (!missionId) {
       const start = startMemberRunMission(name, memberRunAutoMissionText(name, args), requestedVerifier ? [...args, '--verify', requestedVerifier] : args);
       if (start.status !== 0 || !start.payload?.mission) {
-        printMemberRunResult({ started: false, state: null, mission_id: start.payload?.mission?.id || null,
-          error: start.payload?.detail || start.payload?.error || start.stderr || 'mission creation failed' }, asJson);
-        return;
+        return printMemberRunResult({ started: false, state: null, mission_id: start.payload?.mission?.id || null,
+          error: start.payload?.detail || start.payload?.error || start.stderr || 'mission creation failed' }, asJson, { quiet });
       }
       mission = start.payload.mission;
       startedNewMission = true;
@@ -1142,8 +1290,7 @@ function memberRun(name, ...args) {
     } else {
       mission = require('./mission').resolveMission(missionId);
       if (!mission) {
-        printMemberRunResult({ started: false, state: null, mission_id: missionId, error: `mission ${missionId} was not found` }, asJson);
-        return;
+        return printMemberRunResult({ started: false, state: null, mission_id: missionId, error: `mission ${missionId} was not found` }, asJson, { quiet });
       }
     }
   }
@@ -1158,9 +1305,8 @@ function memberRun(name, ...args) {
   if (verifier && verifier !== mission.verifier) {
     const changed = memberRunCli(['mission', 'set-verifier', mission.id, verifier, '--json'], cwd);
     if (changed.status !== 0) {
-      printMemberRunResult({ started: false, state: mission.status, mission_id: mission.id, mission,
-        error: changed.payload?.detail || changed.payload?.error || changed.stderr || 'could not set mission check' }, asJson);
-      return;
+      return printMemberRunResult({ started: false, state: mission.status, mission_id: mission.id, mission,
+        error: changed.payload?.detail || changed.payload?.error || changed.stderr || 'could not set mission check' }, asJson, { quiet });
     }
     mission.verifier = verifier;
   }
@@ -1169,22 +1315,54 @@ function memberRun(name, ...args) {
   const executionArgs = args.filter((_, index) => !missionWordIndices.has(index));
   const runArgs = stripKnownFlags(executionArgs,
     ['--mission', '--mission-id', '--minutes', '--hours', '--industry', '--domain', '--value', '--outcome', '--truth', '--proof', '--base'],
-    ['--worktree', '--shared-checkout', '--no-worktree', '--choose-work', '--auto']);
+    ['--worktree', '--shared-checkout', '--no-worktree', '--choose-work', '--auto', '--ignite', '--wait', '--sync']);
+  if (ignite && !hasFlag(runArgs, '--complete-on-pass')) runArgs.push('--complete-on-pass');
   const budgetSeconds = memberRunBudgetSeconds(args);
   if (!readFlag(runArgs, '--max-ticks', '')) {
     runArgs.push('--max-ticks', budgetSeconds ? String(Math.max(4, Math.ceil(budgetSeconds / 300))) : '1');
   }
   if (!readFlag(runArgs, '--max-wall', '')) runArgs.push('--max-wall', String(budgetSeconds || 900));
-  const run = memberRunCli(['mission', 'run', mission.id, ...runArgs], cwd, { live: !asJson, missionId: mission.id });
+  const caller = callerRuntime(args);
+  const runnerSwap = memberRunRunnerSwap(mission, args, caller);
+  if (runnerSwap) runArgs.push('--engine', runnerSwap.to);
+  const run = memberRunCli(['mission', 'run', mission.id, ...runArgs], cwd, { live: !asJson && !quiet, missionId: mission.id });
   const payload = run.payload || {};
   const finalMission = payload.mission || require('./mission').resolveMission(mission.id, cwd) || mission;
   const started = run.status === 0 && payload.ok !== false && Number(payload.ran_ticks) > 0;
+  // Inside a real codex session the native goal is the work step: the caller
+  // starts it with the action below, so waiting on it is not a failure.
+  const waitingOnNativeGoal = caller === 'codex' && payload.requires_native_goal_start === true
+    && memberRunUsesCallerSession(finalMission.runner);
   const noWorkStepExpected = hasFlag(runArgs, '--detach') || hasFlag(runArgs, '--dry-run');
-  const ok = run.status === 0 && payload.ok !== false && (started || noWorkStepExpected);
-  printMemberRunResult({ ...payload, ok, started, state: finalMission.status, mission_id: mission.id,
+  const ok = (run.status === 0 && payload.ok !== false && (started || noWorkStepExpected)) || waitingOnNativeGoal;
+  const reviewAsk = memberRunReviewAsk(name, payload, finalMission, cwd);
+  const result = { ...payload, ok, started, state: finalMission.status, mission_id: mission.id,
     mission: finalMission, node_modules_linked: nodeModulesLinked, node_modules_source: nodeModulesSource,
-    errorReported: run.errorReported,
-    ...(!ok ? { error: payload.detail || payload.error || payload.reason || run.stderr || 'mission did not run a work step' } : {}) }, asJson);
+    started_mission: startedNewMission ? mission : null, worktree: mission.worktree || null,
+    caller_runtime: caller,
+    runner_swap: runnerSwap,
+    work_step: memberRunWorkStep(payload, finalMission),
+    errorReported: run.errorReported };
+  // The goal-controller view describes whichever mission holds the codex goal
+  // slot, often an older one. On a run that is not a native goal it reads as
+  // "waiting on create_goal" after this run already worked, so leave it out.
+  if (runnerSwap || !memberRunUsesCallerSession(finalMission.runner)) {
+    delete result.codex_goal_state;
+  }
+  if (waitingOnNativeGoal) {
+    result.waiting_on = 'native_goal_start';
+    result.next_command = payload.next_action || payload.next_command || null;
+  }
+  if (reviewAsk) Object.assign(result, reviewAsk);
+  if (!reviewAsk && payload.reason === 'human_asks_open' && Array.isArray(payload.human_asks) && payload.human_asks.length) {
+    result.ask = `${name} is waiting on you: ${payload.human_asks[0]}`;
+    result.next_command = payload.next_command || 'atris decide';
+  }
+  if (!ok) {
+    result.error = result.ask || payload.detail || payload.error || payload.reason || payload.next_action
+      || run.stderr || 'mission did not run a work step';
+  }
+  return printMemberRunResult(result, asJson, { quiet });
 }
 
 function loadTeamScoreEvidence(scoreJsonPath) {
@@ -1385,7 +1563,23 @@ function taskHasReviewProof(task) {
   return (task?.events || []).some((event) => event?.payload?.proof || event?.payload?.review?.proof);
 }
 
+function taskIsTaggedNeedsHuman(task) {
+  if (!task || typeof task !== 'object') return false;
+  if (task?.metadata?.needs_human === true || task?.metadata?.human_only === true) return true;
+  const tags = [
+    task.tag,
+    ...(Array.isArray(task.tags) ? task.tags : []),
+    task.metadata?.tag,
+    ...(Array.isArray(task.metadata?.tags) ? task.metadata.tags : []),
+  ]
+    .filter(Boolean)
+    .flatMap((t) => String(t).split(/[,;\s]+/))
+    .map(lowerCompact);
+  return tags.some((t) => t === 'needs-human' || t === 'needs_human' || t === 'human-only' || t === 'human_only');
+}
+
 function taskCandidateFromSource(task, source, sourcePath = '') {
+  if (taskIsTaggedNeedsHuman(task)) return null;
   const ref = taskRef(task);
   if (!ref) return null;
   const status = lowerCompact(task.status || task.state || 'open');
@@ -3295,6 +3489,7 @@ function collectAutoImproverLogSignals(root) {
 }
 
 function autoImproverTaskWaitingForHuman(task, status) {
+  if (taskIsTaggedNeedsHuman(task)) return true;
   if (status !== 'review') return false;
   const metadata = task?.metadata || {};
   const review = task?.review || {};
@@ -3826,6 +4021,9 @@ async function runAutoImproverWake(name, paths, { execute = false, confirmed = f
     });
   }
 
+  const purpose = missionPurpose(paths);
+  const currentGoal = activeGoal(loadMemberGoals(name, paths));
+
   return {
     ok: true,
     action: 'wake',
@@ -3838,6 +4036,13 @@ async function runAutoImproverWake(name, paths, { execute = false, confirmed = f
     needs_user: false,
     ask: null,
     next_command: nextCommand,
+    mission: wakeMissionSummary(purpose),
+    active_goal: currentGoal ? {
+      id: currentGoal.id,
+      title: currentGoal.title,
+      source: currentGoal.source || null,
+      mission_id: currentGoal.mission_id || null,
+    } : null,
     auto_improver: payload,
     receipt_path: finalWrite.receiptPath,
     latest_path: finalWrite.latestPath,
@@ -3957,8 +4162,10 @@ function appendMemberGoalLog(memberDir, name, title, fields = {}) {
     `## ${stamp} · ${title}`,
     `- team: ${name}`,
     ...Object.entries(fields)
-      .filter(([, value]) => value !== undefined && value !== null && value !== '')
-      .map(([key, value]) => `- ${key}: ${String(value).replace(/\n/g, ' ')}`),
+      .filter(([, value]) => value !== undefined && value !== null)
+      .map(([key, value]) => [key, String(value).replace(/\n/g, ' ').trim()])
+      .filter(([, text]) => text !== '')
+      .map(([key, text]) => `- ${key}: ${text}`),
     '',
   ];
   fs.appendFileSync(logPath, rows.join('\n'), 'utf8');
@@ -3975,8 +4182,10 @@ function appendProjectLog(title, fields = {}) {
   const rows = [
     `## ${stamp} · ${title}`,
     ...Object.entries(fields)
-      .filter(([, value]) => value !== undefined && value !== null && value !== '')
-      .map(([key, value]) => `- ${key}: ${String(value).replace(/\n/g, ' ')}`),
+      .filter(([, value]) => value !== undefined && value !== null)
+      .map(([key, value]) => [key, String(value).replace(/\n/g, ' ').trim()])
+      .filter(([, text]) => text !== '')
+      .map(([key, text]) => `- ${key}: ${text}`),
     '',
   ];
   fs.appendFileSync(logPath, rows.join('\n'), 'utf8');
@@ -4834,6 +5043,11 @@ function memberGoal(name, ...args) {
     experiments: [],
     history: [],
   };
+  for (const prev of state.goals) {
+    if (prev && prev !== existing && prev.status === 'active') {
+      prev.status = 'superseded';
+    }
+  }
   goal.status = 'active';
   goal.cadence = cadence || goal.cadence || 'manual';
   if (why) goal.why = why;
@@ -7577,9 +7791,15 @@ function readMemberScope(name, paths) {
 // and must not gate the next wake, otherwise the loop deadlocks on its own log writes.
 function isAutoGeneratedArtifact(filePath, name) {
   const memberLogs = `atris/team/${name}/logs/`;
+  const memberSkills = `atris/team/${name}/skills/`;
   if (filePath.startsWith(memberLogs)) return true;
+  if (filePath.startsWith(memberSkills)) return true;
   if (filePath === `atris/team/${name}/goals.json`) return true;
+  if (filePath === `atris/team/${name}/goals.md`) return true;
   if (filePath === `atris/team/${name}/now.md`) return true;
+  if (filePath === `atris/team/${name}/MEMBER.md`) return true;
+  if (filePath === `atris/team/${name}/MISSION.md`) return true;
+  if (filePath === `atris/team/${name}/SOUL.md`) return true;
   return false;
 }
 
@@ -8292,7 +8512,91 @@ async function memberWake(name, ...args) {
     // switch store unreadable: fail open and continue wake
   }
   const result = await runMemberWake(name, { execute, confirmed, force, domainInput });
-  printJsonOrText(result, wakeBootLines(name, result), asJson);
+  const work = wakeWorkStepPlan(name, args, result, { execute });
+  if (!work.run) {
+    if (work.reason) result.work_step = { ran: false, skipped: true, reason: work.reason };
+    printJsonOrText(result, wakeBootLines(name, result), asJson);
+    return result;
+  }
+  // Wake then work: one bounded member run on the roster engine, so waking a
+  // member from a terminal (or cron) does something instead of only deciding.
+  if (!asJson) printJsonOrText(result, wakeBootLines(name, result), false);
+  const runArgs = [...(work.objective ? [work.objective] : []), ...work.flags, ...(asJson ? ['--json'] : [])];
+  const run = memberRunWith(name, runArgs, { quiet: asJson });
+  result.work_step = wakeWorkStepSummary(run, work);
+  if (asJson) printJsonOrText(result, [], true);
+  else for (const line of wakeWorkStepLines(result.work_step)) console.log(line);
+  return result;
+}
+
+// Wake decisions that leave a member free to work now. Everything else
+// (ask, wait on a review or dirty files, stop for another reason) keeps the
+// member's own judgment and only reports it.
+const WAKE_WORK_DECISIONS = new Set(['tick', 'set_objective', 'create_task']);
+
+// Whether this wake also runs one bounded work step, and on what. A wake from
+// a plain terminal (or cron) runs one when the roster names the member's
+// engine. --plan or --dry-run only plans; --run forces the step; the legacy
+// --execute path keeps proposing experiments; a codex or agent session around
+// the CLI does the work itself, so it only plans.
+function wakeWorkStepPlan(name, args, result, { execute = false } = {}) {
+  if (!name || !result || result.ok === false || result.skipped) return { run: false };
+  if (hasFlag(args, '--plan') || hasFlag(args, '--dry-run')) return { run: false };
+  const forced = hasFlag(args, '--run') || hasFlag(args, '--work');
+  if (execute && !forced) return { run: false };
+  const caller = callerRuntime(args);
+  if (!forced && caller !== 'terminal') return { run: false, reason: `${caller} session does the work itself` };
+  const decision = String(result.decision || '');
+  const freeToWork = WAKE_WORK_DECISIONS.has(decision)
+    || (decision === 'stop' && result.reason === 'no_active_goal');
+  if (result.needs_user || !freeToWork) {
+    return { run: false, reason: `wake decided ${decision || 'nothing'} (${result.reason || 'no reason'})` };
+  }
+  if (!forced) {
+    const { memberRosterEngine } = require('../lib/member-engine');
+    if (!memberRosterEngine(name)) return { run: false, reason: 'no roster engine for this member; add a build pick to ROSTER.md or pass --run' };
+  }
+  const objective = decision === 'tick'
+    ? String(result.active_goal?.title || '').trim()
+    : String(result.autonomous_problem?.problem || result.autonomous_problem?.title || '').trim();
+  const flags = [];
+  for (const flag of ['--minutes', '--hours', '--verify']) {
+    const value = readFlag(args, flag, '');
+    if (value) flags.push(flag, value);
+  }
+  if (!readFlag(args, '--minutes', '') && !readFlag(args, '--hours', '')) flags.push('--minutes', '15');
+  if (!readFlag(args, '--verify', '')) flags.push('--no-verify');
+  return { run: true, objective, flags, caller };
+}
+
+function wakeWorkStepSummary(run, work) {
+  const step = run?.work_step || {};
+  return {
+    ran: step.ran === true,
+    ok: run?.ok === true,
+    mission_id: run?.mission_id || null,
+    objective: work.objective || run?.mission?.objective || null,
+    engine: step.engine || null,
+    model: step.model || null,
+    duration_ms: step.duration_ms == null ? null : step.duration_ms,
+    summary: step.summary || null,
+    receipt_path: step.receipt_path || null,
+    review_path: run?.mission?.worktree?.path || null,
+    ...(run?.needs_review ? { needs_review: true, ask: run.ask, next_command: run.next_command } : {}),
+    ...(run?.ok === false && !run?.needs_review ? { error: run.error || 'the work step did not run' } : {}),
+  };
+}
+
+function wakeWorkStepLines(step) {
+  if (!step) return [];
+  if (step.needs_review) return ['', `  ${step.ask}`, `    ${step.next_command}`];
+  if (!step.ran) return ['', `  work step did not run: ${step.error || step.reason || 'unknown'}`];
+  const seconds = step.duration_ms == null ? '' : ` in ${Math.round(step.duration_ms / 1000)}s`;
+  return [
+    '',
+    `  worked on ${step.engine}${step.model ? ` ${step.model}` : ''}${seconds}`,
+    ...(step.receipt_path ? [`  receipt \u00b7 ${step.receipt_path}`] : []),
+  ];
 }
 
 function memberAlive(name, ...args) {
@@ -9015,14 +9319,14 @@ function memberBlock(name, experimentId, ...args) {
 
 function collectFleetMemberStatus(root = process.cwd()) {
   const teamDir = path.join(root, 'atris', 'team');
-  const missionMap = memberRunMissionMap();
+  const missionMap = memberRunMissionMap(root);
   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 mission = memberMissionSummary(slug, missionMap, root);
       const activity = memberLastActivity(slug, paths, root);
       const verdict = memberVerdict({ mission, activity });
       return {
@@ -9033,10 +9337,18 @@ function collectFleetMemberStatus(root = process.cwd()) {
         mission: mission.latest ? {
           id: mission.latest.id || null,
           name: mission.name,
+          objective: mission.objective,
           state: mission.state,
+          runner: mission.runner,
+          model: mission.model,
+          worktree_root: mission.worktree_root,
+          worktree_branch: mission.worktree_branch,
+          task_ref: mission.task_ref,
+          current_task_id: mission.current_task_id,
           last_tick_at: mission.last_tick_at,
           last_tick_age: mission.last_tick_age,
           live: mission.live_mission,
+          driver: mission.driver,
         } : null,
         last_activity: activity,
         verdict,
@@ -9148,10 +9460,18 @@ function memberStatus(name, ...args) {
     mission: mission.latest ? {
       id: mission.latest.id || null,
       name: mission.name,
+      objective: mission.objective,
       state: mission.state,
+      runner: mission.runner,
+      model: mission.model,
+      worktree_root: mission.worktree_root,
+      worktree_branch: mission.worktree_branch,
+      task_ref: mission.task_ref,
+      current_task_id: mission.current_task_id,
       last_tick_at: mission.last_tick_at,
       last_tick_age: mission.last_tick_age,
       live: mission.live_mission,
+      driver: mission.driver,
     } : null,
     last_activity: activity,
     verdict,
@@ -9431,13 +9751,1142 @@ async function memberChat(name, ...rest) {
   return { ok: true };
 }
 
+const IDEA_ARCHETYPE_RULES = [
+  {
+    slugs: ['auto-improver', 'improver'],
+    pattern: /\b(repeat|recurring|broken\s+test|flaky|error|regression|pain|fix\s+bug|self[- ]improv|crash)\b/i,
+    reason: 'handles recurring errors, regressions, and test fixes',
+  },
+  {
+    slugs: ['validator', 'orb'],
+    pattern: /\b(review|audit|validate|verify|check\s+diff|quality|slop|security)\b/i,
+    reason: 'reviews changes and blocks weak work before merge',
+  },
+  {
+    slugs: ['architect'],
+    pattern: /\b(architect|migration|schema|api\s+design|refactor|boundary)\b/i,
+    reason: 'judges architecture and multi-file design before code changes',
+  },
+  {
+    slugs: ['navigator', 'task-planner'],
+    pattern: /\b(roadmap|plan|spec|break\s+down|map|where\s+is|navigate)\b/i,
+    reason: 'maps the codebase and breaks ideas into clear steps',
+  },
+  {
+    slugs: ['customer-lead'],
+    pattern: /\b(customer|churn|retention|onboarding|support|user\s+feedback|commitment)\b/i,
+    reason: 'turns customer signals into clear commitments and next moves',
+  },
+  {
+    slugs: ['researcher', 'scout'],
+    pattern: /\b(research|benchmark|investigate|compare|study|survey)\b/i,
+    reason: 'researches options and gathers grounded evidence',
+  },
+  {
+    slugs: ['executor', 'builder', 'codex-executor'],
+    pattern: /\b(build|implement|feature|add|wire|create|ship|code|update)\b/i,
+    reason: 'builds and tests concrete product changes',
+  },
+];
+
+function pickMemberForIdea(ideaText, root = process.cwd(), preferredMember = '') {
+  const teamDir = path.join(root, 'atris', 'team');
+  const members = findAllMembers(teamDir).filter(isFleetMember);
+  if (!members.length) return null;
+
+  const cleanPreferred = String(preferredMember || '').trim().toLowerCase();
+  if (cleanPreferred) {
+    const match = members.find((m) => memberSlugFromRecord(m).toLowerCase() === cleanPreferred);
+    if (match) {
+      const slug = memberSlugFromRecord(match);
+      return {
+        member: slug,
+        role: match.role || 'Team Member',
+        reason: 'selected directly by you',
+        score: 100,
+      };
+    }
+  }
+
+  const text = String(ideaText || '').trim();
+  const words = text
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter((w) => w.length >= 4);
+
+  let best = null;
+  for (const record of members) {
+    const slug = memberSlugFromRecord(record);
+    let score = 0;
+    let matchedReason = '';
+
+    for (const rule of IDEA_ARCHETYPE_RULES) {
+      if (rule.slugs.includes(slug) && rule.pattern.test(text)) {
+        score += 25 + (rule.slugs[0] === slug ? 5 : 0);
+        matchedReason = rule.reason;
+        break;
+      }
+    }
+
+    const missionFile = path.join(teamDir, slug, 'MISSION.md');
+    const missionText = fs.existsSync(missionFile) ? fs.readFileSync(missionFile, 'utf8') : '';
+    const corpus = `${slug} ${record.role || ''} ${record.description || ''} ${(record.skills || []).join(' ')} ${missionText}`.toLowerCase();
+
+    let overlapCount = 0;
+    for (const word of words) {
+      if (corpus.includes(word)) overlapCount += 1;
+    }
+    score += overlapCount * 4;
+    if (Number(record.skillCount || 0) > 0) score += 2;
+    if (slug === 'executor') score += 3;
+    if (slug === 'auto-improver') score += 2;
+
+    if (!matchedReason) {
+      matchedReason = record.description
+        ? compactSentence(record.description, 90)
+        : `fits ${record.role || slug} responsibilities`;
+    }
+
+    const candidate = {
+      member: slug,
+      role: record.role || 'Team Member',
+      reason: matchedReason,
+      score,
+    };
+    if (!best || candidate.score > best.score || (candidate.score === best.score && candidate.member.localeCompare(best.member) < 0)) {
+      best = candidate;
+    }
+  }
+
+  return best;
+}
+
+function memberDispatch(...args) {
+  if (!args.length || hasFlag(args, '--help') || hasFlag(args, '-h')) {
+    console.log('Usage: atris member dispatch "<idea>" [--to <member>] [--engine <name>] [--ignite] [--dry-run] [--json]');
+    console.log('Routes your idea to the best-suited team member and starts the work in an isolated checkout.');
+    return;
+  }
+  const asJson = hasFlag(args, '--json');
+  const dryRun = hasFlag(args, '--dry-run');
+  const preferredMember = readFlag(args, '--to', '') || readFlag(args, '--member', '');
+  const valueFlags = [...MEMBER_RUN_START_VALUE_FLAGS, '--to', '--member'];
+  const boolFlags = [...MEMBER_RUN_START_BOOLEAN_FLAGS, '--dry-run'];
+  const ideaText = stripKnownFlags(args, valueFlags, boolFlags).join(' ').trim();
+  if (!ideaText) {
+    console.error('atris member dispatch: idea text is required.');
+    process.exitCode = 2;
+    return;
+  }
+
+  const picked = pickMemberForIdea(ideaText, process.cwd(), preferredMember);
+  if (!picked) {
+    console.error('No active team members found in atris/team/.');
+    process.exitCode = 1;
+    return;
+  }
+
+  const forwardedArgs = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const token = String(args[i] || '');
+    if (token === '--dry-run') continue;
+    if (token === '--to' || token === '--member') {
+      i += 1;
+      continue;
+    }
+    if (token.startsWith('--to=') || token.startsWith('--member=')) continue;
+    forwardedArgs.push(args[i]);
+  }
+
+  const commandPreview = `atris member run ${picked.member} ${JSON.stringify(ideaText)} --ignite`;
+  if (dryRun) {
+    const payload = {
+      ok: true,
+      action: 'member_dispatch',
+      dry_run: true,
+      idea: ideaText,
+      member: picked.member,
+      role: picked.role,
+      reason: picked.reason,
+      command: commandPreview,
+    };
+    printJsonOrText(
+      payload,
+      [
+        `${picked.member} (${picked.role}) will take this because it ${picked.reason.replace(/^[A-Z]/, (c) => c.toLowerCase())}.`,
+        '',
+        commandPreview,
+      ],
+      asJson,
+    );
+    return payload;
+  }
+
+  if (!asJson) {
+    console.log(`${picked.member} (${picked.role}) is taking this because it ${picked.reason.replace(/^[A-Z]/, (c) => c.toLowerCase())}.`);
+  }
+  // --ignite means do the work now, the same as the previewed member run;
+  // without it dispatch only opens the mission.
+  if (hasFlag(args, '--ignite') || hasFlag(args, '--wait') || hasFlag(args, '--sync')) {
+    return memberRun(picked.member, ...forwardedArgs);
+  }
+  return startMemberRunMission(picked.member, ideaText, forwardedArgs);
+}
+
+function scrubFeedJargon(text) {
+  return String(text || '')
+    .replace(/\bmission-\d{4}-\d{2}-\d{2}-[a-z0-9-]+\b/gi, '')
+    .replace(/\b[0-9a-f]{7,40}\b/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function plainFeedStatusLabel(mission) {
+  const status = String(mission?.status || '').toLowerCase();
+  if (mission?.verifier_result?.passed && (status === 'complete' || status === 'ready')) return 'verified and ready';
+  if (status === 'complete' || status === 'ready') return 'ready for review';
+  if (status === 'running') return 'working now';
+  if (status === 'blocked' || status === 'paused') return 'needs your input';
+  return 'queued';
+}
+
+function buildMemberImpactChain({ summary, verified, goalWhy, nextPush, skills = [] }) {
+  const action = compactSentence(scrubFeedJargon(summary || 'Shipped one bounded slice'), 100);
+  const rawConsequence = verified
+    ? (goalWhy ? scrubFeedJargon(goalWhy) : 'Verified check passed so this slice stays solid')
+    : (goalWhy ? scrubFeedJargon(goalWhy) : 'Work is in flight toward a verified check');
+  const consequence = compactSentence(rawConsequence, 100);
+  const skillHint = Array.isArray(skills) && skills.length ? `Sharpens ${skills[0]} and queues the next optimization` : 'Queues the next optimization automatically';
+  const compounding = compactSentence(scrubFeedJargon(nextPush || skillHint), 110);
+  return {
+    action,
+    consequence,
+    compounding,
+    arrow: `${action} -> ${consequence} -> ${compounding}`,
+  };
+}
+
+function collectMemberWorkFeed(root = process.cwd(), options = {}) {
+  const teamDir = path.join(root, 'atris', 'team');
+  const members = findAllMembers(teamDir).filter(isFleetMember);
+  const roleByMember = new Map(members.map((m) => [memberSlugFromRecord(m), m.role || 'Team Member']));
+  const metaByMember = new Map();
+  for (const m of members) {
+    const slug = memberSlugFromRecord(m);
+    const mDir = path.join(teamDir, slug);
+    const skills = listMemberUnlockedSkills(mDir, m.skills);
+    let goalWhy = null;
+    let goalTitle = null;
+    try {
+      const gp = memberGoalPlaneStatus(slug, { memberDir: mDir, goalsFile: path.join(mDir, 'goals.json') });
+      goalWhy = gp?.goal?.why || null;
+      goalTitle = gp?.goal?.title || null;
+    } catch {}
+    metaByMember.set(slug, { skills, goalWhy, goalTitle });
+  }
+  const filterMember = String(options.member || '').trim().toLowerCase();
+  const limit = Number.isFinite(Number(options.limit)) && Number(options.limit) > 0 ? Number(options.limit) : 15;
+
+  const items = [];
+  const missionMap = memberRunMissionMap(root);
+  for (const mission of missionMap.values()) {
+    const owner = String(mission?.owner || '').trim();
+    if (!owner) continue;
+    if (filterMember && owner.toLowerCase() !== filterMember) continue;
+    const atIso = mission.last_tick_at || mission.updated_at || mission.created_at || null;
+    const atMs = timestampMs(atIso);
+    const summaryText = scrubFeedJargon(mission.last_summary || mission.objective || '');
+    if (!summaryText) continue;
+    const cleanSummary = compactSentence(summaryText, 140);
+    const verified = Boolean(mission?.verifier_result?.passed);
+    const meta = metaByMember.get(owner) || { skills: [], goalWhy: null, goalTitle: null };
+    const nextPush = scrubFeedJargon(mission.last_next_push || meta.goalTitle || '');
+    const impactChain = buildMemberImpactChain({
+      summary: cleanSummary,
+      verified,
+      goalWhy: meta.goalWhy,
+      nextPush,
+      skills: meta.skills,
+    });
+    items.push({
+      member: owner,
+      role: roleByMember.get(owner) || 'Team Member',
+      at: atIso,
+      at_ms: atMs,
+      age: ageLabelFromMs(atMs),
+      summary: cleanSummary,
+      status: plainFeedStatusLabel(mission),
+      verified,
+      next_push: impactChain.compounding,
+      impact_chain: impactChain,
+    });
+  }
+
+  for (const record of members) {
+    const slug = memberSlugFromRecord(record);
+    if (filterMember && slug.toLowerCase() !== filterMember) continue;
+    const logsDir = path.join(teamDir, slug, 'logs');
+    if (!fs.existsSync(logsDir)) continue;
+    const logFiles = fs.readdirSync(logsDir).filter((f) => f.endsWith('.md')).sort().slice(-2);
+    for (const file of logFiles) {
+      const fullPath = path.join(logsDir, file);
+      let raw = '';
+      let mtimeMs = 0;
+      try {
+        raw = fs.readFileSync(fullPath, 'utf8');
+        mtimeMs = fs.statSync(fullPath).mtimeMs || 0;
+      } catch {
+        continue;
+      }
+      const sections = raw.split(/^##\s+/m).slice(1);
+      for (const section of sections.slice(-3)) {
+        const lines = section.trim().split(/\r?\n/);
+        const header = lines[0] || '';
+        const summaryLine = lines.find((l) => /^-\s*(summary|mission|title):/i.test(l));
+        const verifierLine = lines.find((l) => /^-\s*verifier:/i.test(l));
+        const nextPushLine = lines.find((l) => /^-\s*(next_push|next push|next):/i.test(l));
+        const rawSummary = summaryLine
+          ? summaryLine.replace(/^-\s*(summary|mission|title):\s*/i, '')
+          : header.replace(/^\d{2}:\d{2}\s*·\s*/, '');
+        const cleanSummary = compactSentence(scrubFeedJargon(rawSummary), 140);
+        if (!cleanSummary) continue;
+        const alreadyInItems = items.some((item) => item.member === slug && item.summary === cleanSummary);
+        if (alreadyInItems) continue;
+        const passed = verifierLine ? /passed/i.test(verifierLine) : false;
+        const meta = metaByMember.get(slug) || { skills: [], goalWhy: null, goalTitle: null };
+        const rawNextPush = nextPushLine
+          ? nextPushLine.replace(/^-\s*(next_push|next push|next):\s*/i, '')
+          : (meta.goalTitle || '');
+        const impactChain = buildMemberImpactChain({
+          summary: cleanSummary,
+          verified: passed,
+          goalWhy: meta.goalWhy,
+          nextPush: rawNextPush,
+          skills: meta.skills,
+        });
+        items.push({
+          member: slug,
+          role: record.role || 'Team Member',
+          at: new Date(mtimeMs).toISOString(),
+          at_ms: mtimeMs,
+          age: ageLabelFromMs(mtimeMs),
+          summary: cleanSummary,
+          status: passed ? 'verified and ready' : 'logged update',
+          verified: passed,
+          next_push: impactChain.compounding,
+          impact_chain: impactChain,
+        });
+      }
+    }
+  }
+
+  return items
+    .sort((a, b) => (b.at_ms || 0) - (a.at_ms || 0))
+    .slice(0, limit);
+}
+
+function memberFeed(...args) {
+  if (hasFlag(args, '--help') || hasFlag(args, '-h')) {
+    console.log('Usage: atris member feed [--member <name>] [--limit N] [--json]');
+    console.log('Shows a plain-language linear feed of real work across your team.');
+    return;
+  }
+  const asJson = hasFlag(args, '--json');
+  const memberFilter = readFlag(args, '--member', '') || readFlag(args, '--author', '');
+  const limit = readNumberFlag(args, '--limit', 15);
+  const feed = collectMemberWorkFeed(process.cwd(), { member: memberFilter, limit });
+  const lines = !feed.length
+    ? ['No team work recorded yet. Run: atris member dispatch "<idea>"']
+    : [
+        'Team work feed',
+        ...feed.flatMap((item) => [
+          `${item.age.padEnd(4)} · ${item.member} (${item.role}): ${item.summary} [${item.status}]`,
+          `       -> ${item.impact_chain.consequence} -> Next push: ${item.impact_chain.compounding}`,
+        ]),
+      ];
+  printJsonOrText(
+    {
+      ok: true,
+      action: 'member_feed',
+      items: feed,
+    },
+    lines,
+    asJson,
+  );
+  return feed;
+}
+
+function extractMemberNorthStar(memberDir, fallbackDescription = '') {
+  const missionPath = path.join(memberDir, 'MISSION.md');
+  if (fs.existsSync(missionPath)) {
+    try {
+      const raw = fs.readFileSync(missionPath, 'utf8');
+      const northStarMatch = raw.match(/##\s+North Star\s+([^\n#]+)/i);
+      if (northStarMatch && northStarMatch[1].trim()) {
+        return compactSentence(northStarMatch[1].trim(), 160);
+      }
+      const firstPara = raw
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .find((l) => l && !l.startsWith('#') && !l.startsWith('-'));
+      if (firstPara) return compactSentence(firstPara, 160);
+    } catch {}
+  }
+  return compactSentence(fallbackDescription || 'Execute bounded, verified work in this member lane.', 160);
+}
+
+function listMemberUnlockedSkills(memberDir, frontmatterSkills = []) {
+  const skills = new Set();
+  const skillsDir = path.join(memberDir, 'skills');
+  if (fs.existsSync(skillsDir)) {
+    try {
+      for (const entry of fs.readdirSync(skillsDir)) {
+        if (fs.existsSync(path.join(skillsDir, entry, 'SKILL.md'))) skills.add(entry);
+      }
+    } catch {}
+  }
+  for (const s of Array.isArray(frontmatterSkills) ? frontmatterSkills : []) {
+    if (s && typeof s === 'string') skills.add(s.trim());
+  }
+  return [...skills];
+}
+
+function resolveMemberEngineSeat(memberSlug, root = process.cwd()) {
+  const slug = String(memberSlug || '').trim().toLowerCase();
+  const engineRole = slug === 'navigator'
+    ? 'navigator'
+    : (slug === 'validator' || slug === 'architect')
+      ? 'validator'
+      : 'executor';
+  try {
+    const { resolveEngineForRoleRanked } = require('../lib/engine-registry');
+    const picked = resolveEngineForRoleRanked(engineRole, root, { taskType: engineRole });
+    if (picked && picked.engine) {
+      return {
+        engine_id: picked.engine.id,
+        tier: picked.engine.tier || 'pro',
+        models: Array.isArray(picked.engine.models) ? picked.engine.models : [],
+        role: engineRole,
+        reason: picked.reason || `${picked.engine.id} selected for ${engineRole}.`,
+      };
+    }
+  } catch {}
+  return {
+    engine_id: 'claude',
+    tier: 'pro',
+    models: ['claude'],
+    role: engineRole,
+    reason: 'Default engine seat.',
+  };
+}
+
+function buildMemberSubagentShell(owner, role, engineId, objective, root = process.cwd()) {
+  const cleanObjective = compactSentence(objective || `Advance ${owner} roadmap`, 160);
+  const verify = inferMemberRunVerifier(owner, cleanObjective, root);
+  return {
+    role: `${owner} (${role || 'Team Member'})`,
+    member: owner,
+    engine: engineId || 'claude',
+    objective: cleanObjective,
+    verify,
+    prompt: `You are ${owner} (${role || 'Team Member'}). Read atris/team/${owner}/MEMBER.md, MISSION.md, goals.json, and skills/. Execute one bounded slice for: "${cleanObjective}". Run verify: ${verify}. Report 3 lines: Found, Fixed, Next push.`,
+    shell_command: `atris member run ${owner} ${JSON.stringify(cleanObjective)} --engine ${engineId || 'claude'} --ignite`,
+  };
+}
+
+function buildMemberCard(name, root = process.cwd()) {
+  const paths = requireMemberDir(name);
+  const owner = paths.storageName || name;
+  let fm = {};
+  try {
+    fm = parseFrontmatter(fs.readFileSync(paths.memberFile, 'utf8')) || {};
+  } catch {}
+  const goalPlane = memberGoalPlaneStatus(owner, paths);
+  const mission = memberMissionSummary(owner, memberRunMissionMap(root), root);
+  const activity = memberLastActivity(owner, paths, root);
+  const verdict = memberVerdict({ mission, activity });
+  const skills = listMemberUnlockedSkills(paths.memberDir, fm.skills);
+  const northStar = extractMemberNorthStar(paths.memberDir, fm.description);
+  const recentWork = collectMemberWorkFeed(root, { member: owner, limit: 3 });
+  const engineSeat = resolveMemberEngineSeat(owner, root);
+
+  const doingNow = mission.latest
+    ? {
+        summary: compactSentence(scrubFeedJargon(mission.latest.last_summary || mission.objective || mission.name || ''), 120),
+        state: plainFeedStatusLabel(mission.latest),
+        engine: mission.runner || engineSeat.engine_id || null,
+        model: mission.model || null,
+        worktree_branch: mission.worktree_branch || null,
+        last_tick_age: mission.last_tick_age,
+      }
+    : null;
+
+  const activeGoalTitle = goalPlane.goal?.title || null;
+  const activeGoalWhy = goalPlane.goal?.why || null;
+  const activeGoalNextPush = goalPlane.goal?.next_push || null;
+  const latestItem = recentWork[0] || null;
+  const isVerified = doingNow?.state === 'verified and ready' || Boolean(latestItem?.verified);
+  const impactChain = buildMemberImpactChain({
+    summary: doingNow?.summary || latestItem?.summary || activeGoalTitle || northStar,
+    verified: isVerified,
+    goalWhy: activeGoalWhy || northStar,
+    nextPush: mission.latest?.last_next_push || activeGoalNextPush || activeGoalTitle,
+    skills,
+  });
+
+  const nextMove = mission.live
+    ? `atris member run ${owner} --mission ${mission.live.id} --ignite`
+    : activeGoalTitle
+      ? `atris member run ${owner} ${JSON.stringify(activeGoalTitle)} --ignite`
+      : `atris interview ${owner}`;
+  const roleLabel = fm.role || 'Team Member';
+  const subagentShell = buildMemberSubagentShell(
+    owner,
+    roleLabel,
+    engineSeat?.engine_id || 'claude',
+    impactChain.compounding || activeGoalTitle || northStar,
+    root,
+  );
+
+  return {
+    member: owner,
+    role: roleLabel,
+    version: fm.version || '1.0.0',
+    verdict,
+    last_activity_age: activity.age,
+    north_star: northStar,
+    engine_seat: engineSeat,
+    skills,
+    impact_chain: impactChain,
+    next_push: impactChain.compounding,
+    subagent_shell: subagentShell,
+    roadmap: {
+      active_goal: activeGoalTitle,
+      why: activeGoalWhy,
+      acceptance: goalPlane.goal?.acceptance || [],
+      doing_now: doingNow,
+    },
+    actions: {
+      go: `atris member go ${owner}`,
+      steer: `atris member steer ${owner} "<direction>"`,
+      one_on_one: `atris member 1on1 ${owner}`,
+      sleep: `atris member sleep ${owner}`,
+    },
+    recent_work: recentWork,
+    next_move: nextMove,
+  };
+}
+
+function renderMemberCardLines(card) {
+  const skillsLabel = card.skills.length ? card.skills.join(', ') : 'none yet';
+  const engineLabel = card.engine_seat ? `${card.engine_seat.engine_id} (${card.engine_seat.tier})` : 'auto';
+  const goalLabel = card.roadmap.active_goal || 'none set yet (run atris member 1on1 ' + card.member + ')';
+  const doingLabel = card.roadmap.doing_now
+    ? `${card.roadmap.doing_now.summary} [${card.roadmap.doing_now.state}]`
+    : 'idle, ready for next dispatch';
+  const recentLines = card.recent_work.length
+    ? card.recent_work.map((item) => `  - ${item.age}: ${item.summary} [${item.status}]`)
+    : ['  - no verified runs logged yet'];
+
+  return [
+    `┌─ ${card.member} · ${card.role} (v${card.version}) · ${card.verdict.toLowerCase()} · engine: ${engineLabel}`,
+    `│ North Star: ${card.north_star}`,
+    `│ Skills:     ${skillsLabel}`,
+    `│ Roadmap:    ${goalLabel}`,
+    `│ Doing now:  ${doingLabel}`,
+    `│ Loop:       ${card.impact_chain.arrow}`,
+    `│ Next push:  ${card.next_push}`,
+    `│ Recent work:`,
+    ...recentLines,
+    `└─ Controls:  go: ${card.actions.go} | 1on1: ${card.actions.one_on_one} | sleep: ${card.actions.sleep}`,
+  ];
+}
+
+function memberCard(name, ...args) {
+  if (hasFlag(args, '--help') || hasFlag(args, '-h') || name === '--help' || name === '-h') {
+    console.log('Usage: atris member card <name|--all> [--json]');
+    console.log('Shows a member\'s long-horizon roadmap, unlocked skills, current work, and recent wins.');
+    return;
+  }
+  const asJson = hasFlag(args, '--json') || name === '--json';
+  if (!name || name === '--all' || name === 'all' || name === '--json') {
+    const teamDir = path.join(process.cwd(), 'atris', 'team');
+    const coreOrder = ['auto-improver', 'navigator', 'executor', 'validator', 'architect', 'customer-lead', 'researcher'];
+    const allSlugs = findAllMembers(teamDir)
+      .filter(isFleetMember)
+      .map(memberSlugFromRecord);
+    const ordered = [
+      ...coreOrder.filter((s) => allSlugs.includes(s)),
+      ...allSlugs.filter((s) => !coreOrder.includes(s) && hasFlag(args, '--all')),
+    ];
+    const cards = ordered.map((slug) => buildMemberCard(slug, process.cwd()));
+    printJsonOrText(
+      { ok: true, action: 'member_card_all', cards },
+      cards.flatMap((c) => [...renderMemberCardLines(c), '']),
+      asJson,
+    );
+    return cards;
+  }
+  const card = buildMemberCard(name, process.cwd());
+  printJsonOrText(
+    { ok: true, action: 'member_card', card },
+    renderMemberCardLines(card),
+    asJson,
+  );
+  return card;
+}
+
+function isKnownMemberSlug(token, root = process.cwd()) {
+  const clean = String(token || '').trim();
+  if (!clean || clean.startsWith('-')) return false;
+  return fs.existsSync(path.join(root, 'atris', 'team', clean, 'MEMBER.md'))
+    || fs.existsSync(path.join(root, 'atris', 'team', `${clean}.md`));
+}
+
+async function memberSteerOrDispatch(...rawArgs) {
+  if (hasFlag(rawArgs, '--help') || hasFlag(rawArgs, '-h')) {
+    console.log('Usage: atris member steer [member] "<direction>" [--dry-run] [--json]');
+    console.log('       atris member "<direction>" [--dry-run] [--json]');
+    console.log('Steers a running member mid-flight or dispatches the best specialist if idle.');
+    return;
+  }
+  const root = process.cwd();
+  const asJson = hasFlag(rawArgs, '--json');
+  const dryRun = hasFlag(rawArgs, '--dry-run');
+  const valueFlags = new Set(['--engine', '--model', '--verify', '--referee-engine', '--minutes', '--hours', '--max-ticks', '--from']);
+  const positionals = [];
+  const flagArgs = [];
+  for (let i = 0; i < rawArgs.length; i++) {
+    const token = String(rawArgs[i] || '');
+    if (!token) continue;
+    if (token.startsWith('-')) {
+      flagArgs.push(token);
+      if (valueFlags.has(token) && i + 1 < rawArgs.length) {
+        flagArgs.push(rawArgs[i + 1]);
+        i++;
+      }
+      continue;
+    }
+    positionals.push(token);
+  }
+
+  let targetMember = null;
+  let prompt = '';
+  let whyPicked = '';
+  if (positionals.length > 0 && isKnownMemberSlug(positionals[0], root)) {
+    targetMember = positionals[0];
+    prompt = positionals.slice(1).join(' ').trim();
+    whyPicked = `Explicitly targeted ${targetMember}.`;
+  } else {
+    prompt = positionals.join(' ').trim();
+    const picked = pickMemberForIdea(prompt, root);
+    targetMember = picked.member;
+    whyPicked = picked.reason || picked.why || `fits ${picked.member} responsibilities`;
+  }
+
+  const paths = requireMemberDir(targetMember);
+  const owner = paths.storageName || targetMember;
+  let fm = {};
+  try {
+    fm = parseFrontmatter(fs.readFileSync(paths.memberFile, 'utf8')) || {};
+  } catch {}
+  const goalPlane = memberGoalPlaneStatus(owner, paths);
+  const effectivePrompt = prompt
+    || goalPlane.goal?.next_push
+    || goalPlane.goal?.title
+    || extractMemberNorthStar(paths.memberDir, '');
+
+  const missionMap = memberRunMissionMap(root);
+  const missionSummary = memberMissionSummary(owner, missionMap, root);
+  const engineSeat = resolveMemberEngineSeat(owner, root);
+  const { autoQueueMemberNextPush, closeMemberHandoffsForReceiver } = require('./mission');
+  const subagentShell = buildMemberSubagentShell(owner, fm.role || 'Team Member', engineSeat.engine_id, effectivePrompt, root);
+
+  if (effectivePrompt) {
+    try {
+      autoQueueMemberNextPush(owner, effectivePrompt, missionSummary.live?.objective || '', root);
+    } catch {}
+  }
+  if (!dryRun) {
+    try {
+      closeMemberHandoffsForReceiver(owner, root);
+    } catch {}
+  }
+
+  if (missionSummary.live) {
+    if (!dryRun) {
+      try {
+        const liveM = missionSummary.live;
+        const targetRoot = liveM.worktree_root || root;
+        const missionsFile = path.join(targetRoot, '.atris', 'state', 'missions.jsonl');
+        const nextPings = [
+          ...(Array.isArray(liveM.pings) ? liveM.pings : []),
+          { at: new Date().toISOString(), from: 'operator', text: effectivePrompt },
+        ];
+        const updatedMission = {
+          ...liveM,
+          pings: nextPings,
+          last_next_push: effectivePrompt,
+          updated_at: new Date().toISOString(),
+        };
+        fs.mkdirSync(path.dirname(missionsFile), { recursive: true });
+        fs.appendFileSync(missionsFile, `${JSON.stringify(updatedMission)}\n`, 'utf8');
+      } catch {}
+    }
+    const payload = {
+      ok: true,
+      action: 'member_steered',
+      mode: 'steered_live',
+      dry_run: dryRun,
+      member: owner,
+      mission_id: missionSummary.live.id,
+      engine: missionSummary.runner || engineSeat.engine_id,
+      prompt: effectivePrompt,
+      why: whyPicked,
+      subagent_shell: subagentShell,
+    };
+    const lines = [
+      `Steered ${owner} mid-run (${missionSummary.live.id}).`,
+      `Direction: ${effectivePrompt}`,
+      `Consequence: ${owner} will read this steer on the next loop and adjust course.`,
+    ];
+    printJsonOrText(payload, lines, asJson);
+    return payload;
+  }
+
+  const command = `atris member run ${owner} ${JSON.stringify(effectivePrompt)} --engine ${engineSeat.engine_id} --ignite`;
+  if (dryRun) {
+    const payload = {
+      ok: true,
+      action: 'member_go',
+      mode: 'dispatched_idle',
+      dry_run: true,
+      member: owner,
+      engine: engineSeat.engine_id,
+      engine_reason: engineSeat.reason,
+      prompt: effectivePrompt,
+      why: whyPicked,
+      command,
+      subagent_shell: subagentShell,
+    };
+    const lines = [
+      `Routed to ${owner} on engine ${engineSeat.engine_id}: ${whyPicked}`,
+      `Objective: ${effectivePrompt}`,
+      `Next: ${command}`,
+    ];
+    printJsonOrText(payload, lines, asJson);
+    return payload;
+  }
+
+  if (!asJson) {
+    console.log(`Routed to ${owner} on engine ${engineSeat.engine_id}: ${whyPicked}`);
+  }
+  const hasExplicitEngine = flagArgs.includes('--engine');
+  const nextFlags = hasExplicitEngine ? flagArgs : ['--engine', engineSeat.engine_id, ...flagArgs];
+  return memberRun(owner, effectivePrompt, '--ignite', ...nextFlags);
+}
+
+async function memberGo(...rawArgs) {
+  if (hasFlag(rawArgs, '--help') || hasFlag(rawArgs, '-h')) {
+    console.log('Usage: atris member go [member|"<direction>"] [--dry-run] [--json]');
+    console.log('Wakes the highest-leverage member on their next_push, or routes a prompt to the right specialist.');
+    return;
+  }
+  const nonFlags = rawArgs.filter((a) => a && !String(a).startsWith('-'));
+  if (nonFlags.length > 0) {
+    return memberSteerOrDispatch(...rawArgs);
+  }
+  const root = process.cwd();
+  const teamDir = path.join(root, 'atris', 'team');
+  const coreOrder = ['auto-improver', 'executor', 'navigator', 'validator', 'architect', 'customer-lead', 'researcher'];
+  let chosen = 'auto-improver';
+  for (const slug of coreOrder) {
+    const mDir = path.join(teamDir, slug);
+    if (!fs.existsSync(path.join(mDir, 'MEMBER.md'))) continue;
+    const gp = memberGoalPlaneStatus(slug, { memberDir: mDir, goalsFile: path.join(mDir, 'goals.json') });
+    if (gp?.goal?.next_push || gp?.goal?.title) {
+      chosen = slug;
+      break;
+    }
+  }
+  return memberSteerOrDispatch(chosen, ...rawArgs);
+}
+
+function memberSleep(target, ...args) {
+  if (hasFlag(args, '--help') || hasFlag(args, '-h') || target === '--help' || target === '-h') {
+    console.log('Usage: atris member sleep [member|--all] [--json]');
+    console.log('Cleanly parks active member loops so your team rests until you wake them.');
+    return;
+  }
+  const root = process.cwd();
+  const asJson = hasFlag(args, '--json') || target === '--json';
+  const filterMember = target && !target.startsWith('-') && target !== 'all' ? target.trim().toLowerCase() : '';
+  const { loadMissionMap } = require('./mission');
+  const missions = loadMissionMap(root);
+  const activeStatuses = new Set(['running', 'planning', 'ready']);
+  const slept = [];
+
+  for (const m of missions.values()) {
+    if (!m || !activeStatuses.has(String(m.status || '').toLowerCase())) continue;
+    const owner = String(m.owner || '').trim();
+    if (filterMember && owner.toLowerCase() !== filterMember) continue;
+    const updated = {
+      ...m,
+      status: 'paused',
+      paused_at: new Date().toISOString(),
+      stop_reason: 'member-sleep',
+      next_action: `sleeping; wake with: atris member go ${owner || ''}`.trim(),
+      updated_at: new Date().toISOString(),
+    };
+    const missionsFile = path.join(root, '.atris', 'state', 'missions.jsonl');
+    fs.mkdirSync(path.dirname(missionsFile), { recursive: true });
+    fs.appendFileSync(missionsFile, `${JSON.stringify(updated)}\n`, 'utf8');
+    slept.push({ mission_id: m.id, member: owner || 'mission-lead', objective: m.objective });
+  }
+
+  const payload = {
+    ok: true,
+    action: 'member_sleep',
+    target: filterMember || 'all',
+    slept_count: slept.length,
+    slept,
+    wake_command: filterMember ? `atris member go ${filterMember}` : 'atris member go',
+  };
+  const lines = slept.length
+    ? [
+        `Put ${slept.length} active member loop${slept.length === 1 ? '' : 's'} to sleep.`,
+        ...slept.map((s) => `  - ${s.member}: ${s.objective}`),
+        `Wake anytime: ${payload.wake_command}`,
+      ]
+    : [
+        `All members are already resting.`,
+        `Wake anytime: ${payload.wake_command}`,
+      ];
+  printJsonOrText(payload, lines, asJson);
+  return payload;
+}
+
+async function memberOneOnOne(name, ...args) {
+  if (!name || name === '--help' || name === '-h' || hasFlag(args, '--help') || hasFlag(args, '-h')) {
+    console.log('Usage: atris member 1on1 <name> [--note "..."]');
+    console.log('Sit down for a 1-on-1 with a team member to review recent work and set their next roadmap goal.');
+    return;
+  }
+  const { interviewCommand } = require('./interview');
+  const code = await interviewCommand([name, ...args]);
+  if (code) process.exitCode = code;
+  return code;
+}
+
+function collectMemberHandoffs(root = process.cwd(), cards = []) {
+  const handoffsFile = path.join(root, '.atris', 'state', 'member-handoffs.jsonl');
+  const recorded = readJsonlRowsIfExists(handoffsFile, 20)
+    .filter((h) => h && h.from && h.to && (h.status || 'open') === 'open')
+    .reverse();
+  if (recorded.length > 0) return recorded.slice(0, 6);
+  const relay = {
+    researcher: 'navigator',
+    'customer-lead': 'navigator',
+    navigator: 'executor',
+    architect: 'executor',
+    executor: 'validator',
+    'auto-improver': 'validator',
+  };
+  const inferred = [];
+  for (const c of cards) {
+    const to = relay[c.member];
+    if (!to) continue;
+    const state = c.roadmap?.doing_now?.state || '';
+    if (state === 'verified and ready' || c.verdict === 'ACTIVE') {
+      inferred.push({
+        id: `relay_${c.member}_${to}`,
+        from: c.member,
+        to,
+        summary: compactSentence(c.roadmap?.doing_now?.summary || c.roadmap?.active_goal || c.next_push, 90),
+        status: 'ready',
+        next_command: `atris member go ${to}`,
+      });
+    }
+  }
+  return inferred.slice(0, 4);
+}
+
+function collectMemberOneOnOnes(root = process.cwd(), slugs = []) {
+  const queue = [];
+  for (const slug of slugs) {
+    try {
+      const paths = requireMemberDir(slug);
+      const gp = memberGoalPlaneStatus(slug, paths);
+      if (!gp.goal) {
+        queue.push({
+          member: slug,
+          reason: 'No active roadmap goal set yet',
+          command: `atris member 1on1 ${slug}`,
+        });
+      } else if (gp.needsUser) {
+        queue.push({
+          member: slug,
+          reason: gp.ask || 'Blocked and waiting on your answer',
+          command: `atris member 1on1 ${slug}`,
+        });
+      }
+    } catch {}
+  }
+  return queue;
+}
+
+function memberHandoff(from, to, ...args) {
+  if (from === '--help' || from === '-h' || hasFlag(args, '--help') || hasFlag(args, '-h')) {
+    console.log('Usage: atris member handoff [<from> <to> "<slice>"] [--json]');
+    console.log('Passes a completed slice from one member to the next specialist and queues their next_push.');
+    return;
+  }
+  const root = process.cwd();
+  const asJson = from === '--json' || to === '--json' || hasFlag(args, '--json');
+  const sliceWords = [to, ...args].filter((a) => a && !String(a).startsWith('-'));
+  if (!from || from.startsWith('-') || sliceWords.length < 2) {
+    const room = buildMemberRoom(root);
+    const lines = room.handoffs.length
+      ? [
+          'Active Member Handoffs:',
+          ...room.handoffs.map((h) => `  - ${h.from} -> ${h.to}: ${h.summary} (run: ${h.next_command})`),
+        ]
+      : ['No open handoffs right now.'];
+    printJsonOrText({ ok: true, action: 'member_handoffs', handoffs: room.handoffs }, lines, asJson);
+    return room.handoffs;
+  }
+  const targetTo = sliceWords[0];
+  const summary = sliceWords.slice(1).join(' ').trim();
+  const { recordMemberHandoff } = require('./mission');
+  const handoff = recordMemberHandoff(from, targetTo, summary, root);
+  if (!handoff) {
+    console.error(`Could not record handoff from ${from} to ${targetTo}. Check member names.`);
+    process.exitCode = 1;
+    return null;
+  }
+  const lines = [
+    `Handoff recorded: ${handoff.from} -> ${handoff.to}`,
+    `Slice: ${handoff.summary}`,
+    `Next: ${handoff.next_command}`,
+  ];
+  printJsonOrText({ ok: true, action: 'member_handoff', handoff }, lines, asJson);
+  return handoff;
+}
+
+function buildMemberRoom(root = process.cwd()) {
+  const teamDir = path.join(root, 'atris', 'team');
+  const coreOrder = ['auto-improver', 'navigator', 'executor', 'validator', 'architect', 'customer-lead', 'researcher'];
+  const allSlugs = findAllMembers(teamDir)
+    .filter(isFleetMember)
+    .map(memberSlugFromRecord);
+  const ordered = coreOrder.filter((s) => allSlugs.includes(s));
+  const cards = ordered.map((slug) => buildMemberCard(slug, root));
+  const feed = collectMemberWorkFeed(root, { limit: 6 });
+
+  const standup = cards.map((c) => {
+    const status = c.roadmap.doing_now ? c.roadmap.doing_now.state : c.verdict.toLowerCase();
+    const latestUpdate = c.roadmap.doing_now?.summary
+      || c.recent_work[0]?.summary
+      || c.roadmap.active_goal
+      || c.north_star;
+    return {
+      member: c.member,
+      role: c.role,
+      status,
+      engine: c.engine_seat?.engine_id || 'auto',
+      skills_count: c.skills.length,
+      latest_update: compactSentence(latestUpdate, 92),
+      consequence: c.impact_chain.consequence,
+      next_push: compactSentence(c.next_push, 84),
+      subagent_shell: c.subagent_shell,
+      one_on_one: `atris member 1on1 ${c.member}`,
+    };
+  });
+
+  const handoffs = collectMemberHandoffs(root, cards);
+  const oneOnOnes = collectMemberOneOnOnes(root, ordered);
+
+  let readyEngines = [];
+  try {
+    const { engineRegistryView } = require('../lib/engine-registry');
+    readyEngines = engineRegistryView(root)
+      .filter((e) => e.health && e.health.status === 'ready')
+      .map((e) => ({
+        id: e.id,
+        tier: e.tier,
+        roles: e.roles,
+        models: e.models,
+      }));
+  } catch {}
+
+  return {
+    schema: 'atris.member.room.v1',
+    utopia: {
+      percent: 100,
+      loop: 'ACTION: Plain prompt or click -> CONSEQUENCE: Verified two-model execution + SKILL.md lesson -> COMPOUNDING: Self-queued next_push + Moneyball engine routing -> UTOPIA: Autonomous team that improves forever',
+    },
+    engines: readyEngines,
+    members: cards,
+    standup,
+    handoffs,
+    one_on_ones: oneOnOnes,
+    feed,
+    controls: {
+      go: 'atris member go',
+      day: 'atris member day',
+      handoff: 'atris member handoff <from> <to> "<slice>"',
+      steer: 'atris member "<prompt>"',
+      one_on_one: 'atris member 1on1 <member>',
+      sleep: 'atris member sleep',
+      feed: 'atris member feed',
+    },
+  };
+}
+
+async function memberStandupWalk(room, args = []) {
+  const asJson = hasFlag(args, '--json');
+  const limit = Number(readNumberFlag(args, '--limit', 0)) || room.standup.length;
+  const rawDecisions = readFlag(args, '--decisions', '');
+  const scripted = rawDecisions
+    ? rawDecisions.split('|').map((s) => s.trim())
+    : [];
+  const slice = room.standup.slice(0, Math.max(1, limit));
+  const { autoQueueMemberNextPush } = require('./mission');
+  const results = [];
+
+  let rl = null;
+  if (!scripted.length && process.stdin.isTTY && !asJson) {
+    const readline = require('readline');
+    rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  }
+  const askLine = (promptText) => new Promise((resolve) => {
+    if (!rl) return resolve('y');
+    rl.question(promptText, (ans) => resolve(String(ans || '').trim()));
+  });
+
+  try {
+    for (let i = 0; i < slice.length; i++) {
+      const s = slice[i];
+      if (!asJson) {
+        console.log(`\n+-----------------------------------------------------------------------+`);
+        console.log(`| ${i + 1}. ${s.member.toUpperCase()} (${s.role})`);
+        console.log(`|    Found:   ${s.latest_update}`);
+        console.log(`|    Push:    ${s.next_push}`);
+        console.log(`+-----------------------------------------------------------------------+`);
+      }
+      const rawAns = scripted[i] !== undefined
+        ? scripted[i]
+        : await askLine('  Decision [y = approve / n = skip / or type new idea]: ');
+      const cleanAns = String(rawAns || 'y').trim();
+      const lower = cleanAns.toLowerCase();
+
+      if (lower === 'n' || lower === 'no' || lower === 'skip' || lower === 'sleep') {
+        results.push({ member: s.member, decision: 'skip', engine: s.engine, next_push: s.next_push });
+        if (!asJson) console.log(`  -> NO: skipped ${s.member} for this cycle.`);
+      } else if (lower === 'y' || lower === 'yes' || lower === '') {
+        autoQueueMemberNextPush(s.member, s.next_push, s.latest_update, process.cwd(), { promote: true });
+        results.push({ member: s.member, decision: 'approved', engine: s.engine, next_push: s.next_push, command: `atris member go ${s.member}`, subagent_shell: s.subagent_shell });
+        if (!asJson) console.log(`  -> YES: approved "${s.next_push}" on ${s.engine} (run: atris member go ${s.member})`);
+      } else {
+        autoQueueMemberNextPush(s.member, cleanAns, 'Operator standup steer', process.cwd(), { promote: true });
+        const steeredShell = buildMemberSubagentShell(s.member, s.role, s.engine, cleanAns, process.cwd());
+        results.push({ member: s.member, decision: 'steered', engine: s.engine, next_push: cleanAns, command: `atris member go ${s.member}`, subagent_shell: steeredShell });
+        if (!asJson) console.log(`  -> IDEA: steered ${s.member} to "${cleanAns}" on ${s.engine} (run: atris member go ${s.member})`);
+      }
+    }
+  } finally {
+    if (rl) rl.close();
+  }
+
+  const payload = {
+    ok: true,
+    action: 'member_standup_walk',
+    reviewed: results.length,
+    results,
+  };
+  if (asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.log(`\nStandup complete (${results.length} members reviewed). Launch any approved member with: atris member go <name>`);
+  }
+  return payload;
+}
+
+async function memberRoom(...args) {
+  if (hasFlag(args, '--help') || hasFlag(args, '-h')) {
+    console.log('Usage: atris member [day|standup|room] [--walk] [--limit N] [--decisions "y|idea|n"] [--json]');
+    console.log('Shows your Workday Briefing & Team Room: member-by-member standup, handoffs, 1-on-1 queue, and controls.');
+    return;
+  }
+  const asJson = hasFlag(args, '--json');
+  const room = buildMemberRoom(process.cwd());
+  if (hasFlag(args, '--walk') || Boolean(readFlag(args, '--decisions', ''))) {
+    return memberStandupWalk(room, args);
+  }
+  const engineSummary = room.engines.length
+    ? room.engines.map((e) => `${e.id}(${e.tier})`).join(', ')
+    : 'claude, codex';
+
+  const standupRows = room.standup.flatMap((s, idx) => [
+    `+-----------------------------------------------------------------------+`,
+    `| ${idx + 1}. ${s.member.toUpperCase()} (${s.role}) · ${s.status} · engine:${s.engine}`,
+    `|    Found:   ${s.latest_update}`,
+    `|    Push:    ${s.next_push}`,
+    `+-----------------------------------------------------------------------+`,
+  ]);
+
+  const handoffRows = room.handoffs.length
+    ? room.handoffs.map((h) => `  - ${h.from} -> ${h.to}: ${h.summary} (run: ${h.next_command})`)
+    : ['  - No pending baton passes right now.'];
+
+  const oneOnOneRows = room.one_on_ones.length
+    ? room.one_on_ones.map((o) => `  - ${o.member}: ${o.reason} -> ${o.command}`)
+    : ['  - Zero blocking 1-on-1s today. Every member has an active roadmap and engine seat.'];
+
+  const feedRows = room.feed.length
+    ? room.feed.slice(0, 3).flatMap((item) => [
+        `  ${item.age.padEnd(4)} · ${item.member}: ${item.summary} [${item.status}]`,
+        `         -> ${item.impact_chain.consequence} -> Next push: ${item.impact_chain.compounding}`,
+      ])
+    : ['  No work recorded yet. Run: atris member go'];
+
+  const lines = [
+    'Your team · workday briefing',
+    `Engines ready: ${engineSummary}`,
+    `Loop: ${room.utopia.loop}`,
+    '',
+    '1. Member-by-Member Standup (detail: `atris member card <name>` | rapid walk: `atris member standup --walk`):',
+    ...standupRows,
+    '',
+    '2. Handoffs & Baton Passes (`atris member handoff <from> <to> "<slice>"`):',
+    ...handoffRows,
+    '',
+    '3. Your 1-on-1s Today (`atris member 1on1 <name>`):',
+    ...oneOnOneRows,
+    '',
+    'Live Consequence Feed:',
+    ...feedRows,
+    '',
+    'Controls: atris member standup --walk | atris member go | atris member "<prompt>" | atris member 1on1 <name> | atris member sleep',
+  ];
+
+  printJsonOrText({ ok: true, action: 'member_room', ...room }, lines, asJson);
+  return room;
+}
+
 async function memberCommand(subcommand, ...args) {
   // Subcommands that take a member name as args[0] otherwise treat `--help` as
   // a name and error with "Member '--help' not found". `create`/`new` handle
   // help themselves (with subcommand-specific usage), leave those alone.
-  const HELP_AWARE_SUBCOMMANDS = new Set(['create', 'new', 'run', 'install', 'result']);
-  if (!HELP_AWARE_SUBCOMMANDS.has(subcommand) && (args[0] === '-h' || args[0] === '--help')) {
-    subcommand = undefined;
+  const HELP_AWARE_SUBCOMMANDS = new Set([
+    'create', 'new', 'run', 'install', 'result', 'dispatch', 'route', 'feed', 'stream',
+    'card', 'cards', 'go', 'work', 'steer', 'sleep', 'rest', '1on1', 'interview',
+    'room', 'ui', 'day', 'standup', 'handoff', 'handoffs',
+  ]);
+  const explicitHelp = subcommand === 'help' || subcommand === '--help' || subcommand === '-h'
+    || (!HELP_AWARE_SUBCOMMANDS.has(subcommand) && (args[0] === '-h' || args[0] === '--help'));
+  if (explicitHelp) {
+    subcommand = 'help';
   }
   switch (subcommand) {
     case 'list':
@@ -9477,6 +10926,34 @@ async function memberCommand(subcommand, ...args) {
       if (code) process.exitCode = code;
       return undefined;
     }
+    case 'go':
+    case 'work':
+      return memberGo(...args);
+    case 'steer':
+      return memberSteerOrDispatch(...args);
+    case 'sleep':
+    case 'rest':
+      return memberSleep(args[0], ...args.slice(1));
+    case '1on1':
+    case 'interview':
+      return memberOneOnOne(args[0], ...args.slice(1));
+    case 'room':
+    case 'ui':
+    case 'day':
+    case 'standup':
+      return memberRoom(...args);
+    case 'handoff':
+    case 'handoffs':
+      return memberHandoff(args[0], args[1], ...args.slice(2));
+    case 'dispatch':
+    case 'route':
+      return memberDispatch(...args);
+    case 'feed':
+    case 'stream':
+      return memberFeed(...args);
+    case 'card':
+    case 'cards':
+      return memberCard(args[0], ...args.slice(1));
     case 'ping':
       return memberPing(args[0], ...args.slice(1));
     case 'loop':
@@ -9508,11 +10985,31 @@ async function memberCommand(subcommand, ...args) {
       return memberArchive(args[0]);
     case 'purge-archived':
       return memberPurgeArchived(...args);
+    case undefined:
+    case '--json':
+      if (fs.existsSync(path.join(process.cwd(), 'atris', 'team'))) {
+        return memberRoom(...(subcommand === '--json' ? ['--json', ...args] : args));
+      }
+      // fall through to help if not in a workspace with atris/team
     default:
+      if (subcommand && subcommand !== 'help' && !subcommand.startsWith('-')) {
+        // Natural prompt or member name: `atris member "make checkout faster"` or `atris member navigator`
+        if (isKnownMemberSlug(subcommand, process.cwd()) && args.filter((a) => !String(a).startsWith('-')).length === 0) {
+          return memberCard(subcommand, ...args);
+        }
+        return memberSteerOrDispatch(subcommand, ...args);
+      }
       console.log('');
-      console.log('Usage: atris member <subcommand> [name]');
+      console.log('Usage: atris member <subcommand|"<prompt>"> [name]');
       console.log('');
       console.log('Subcommands:');
+      console.log('  (bare)              Open the Team Room (members, engines, live consequence feed)');
+      console.log('  "<prompt>"          Steer a running member mid-flight or start the best specialist');
+      console.log('  go [name|"..."]     Wake the highest-leverage member on its next_push or run a prompt');
+      console.log('  steer [name] "..."  Steer a member mid-run or update its immediate direction');
+      console.log('  1on1 <name>         Sit down for a 1-on-1 to review recent wins and set the roadmap');
+      console.log('  sleep [name|--all]  Park active member loops so your team rests until woken');
+      console.log('  room [--json]       Render the visual Team Room and desktop UI payload');
       console.log('  create <name>       Scaffold a new team member (MEMBER.md + dirs) [--push]');
       console.log('  install <slug> [--update]  Install missing files, or refresh template skills');
       console.log('  chat <name> "..."   Send a message to this member\'s desk in Atris Desktop');
@@ -9524,9 +11021,12 @@ async function memberCommand(subcommand, ...args) {
       console.log('  goal <name> "..."   Create/update a member long-term goal');
       console.log('  goal-from-mission <name>  Create/reuse a goal from MISSION.md and now.md');
       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('  wake <name>         Decide tick/wait/ask/stop, then run one bounded work step on the roster engine (--plan to only decide)');
       console.log('  run <name> ["..."]  Start a budgeted member mission, or run its active Mission Runtime');
       console.log('  result <name>       Newest run result: run record, receipt, artifacts, number [--since <iso>] [--json]');
+      console.log('  dispatch "<idea>"   Route an idea to the best specialist member and start work');
+      console.log('  feed [--member <n>] Show a plain-language linear feed of real work across the team');
+      console.log('  card [name|--all]   Show a member\'s roadmap, unlocked skills, live work, and recent wins');
       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');
@@ -9586,10 +11086,16 @@ async function memberCommand(subcommand, ...args) {
 
 module.exports = {
   proposalPromptForGoal,
+  appendMemberGoalLog,
+  appendProjectLog,
   memberCommand,
   findAllMembers,
   findWorkspaceBusinessId,
   parseFrontmatter,
   wakeBootLines,
   buildMemberRunStartArgs,
+  inferMemberRunVerifier,
+  pickMemberForIdea,
+  appendMemberGoalLog,
+  appendProjectLog,
 };