atris 3.68.8 → 3.69.0

package/commands/member.js

@@ -1017,6 +1017,12 @@ function startMemberRunMission(name, missionText, args = []) {
   return memberRunCli(startArgs, process.cwd());
 }
 
+// An ignited run asks a second engine to review the work by default, so every
+// run ends with a verdict. --no-referee skips it; an explicit --referee is kept.
+function memberRunWantsReferee(runArgs, ignite) {
+  return Boolean(ignite) && !hasFlag(runArgs, '--referee') && !hasFlag(runArgs, '--no-referee');
+}
+
 function memberRunCli(args, cwd, { live = false, missionId = '' } = {}) {
   const cliPath = path.join(__dirname, '..', 'bin', 'atris.js');
   const runsDir = path.join(cwd, 'atris', 'runs');
@@ -1232,6 +1238,7 @@ function memberRun(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('pick for me: atris member run "fix the flaky login test" (the best member takes it and runs it)');
     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');
@@ -1240,6 +1247,7 @@ function memberRunWith(name, args, { quiet = false } = {}) {
     console.log('truth: useful work must improve revenue, reliability, speed, security, clarity, or trust, then show plain proof.');
     console.log('isolation: new missions use --worktree by default; add --shared-checkout to stay here.');
     console.log('check: --verify or a verify field in the member file adds a mission check.');
+    console.log('review: an --ignite run has a different engine review the work; add --no-referee to skip it.');
     return;
   }
 
@@ -1305,6 +1313,7 @@ function memberRunWith(name, args, { quiet = false } = {}) {
     const progressDir = process.env.ATRIS_PROGRESS_DIR || '~/.atris/progress';
     console.log(`watch: tail -f ${progressDir}/${String(name).replace(/[^A-Za-z0-9._-]/g, '_')}.log`);
     console.log('board: atris member board --watch');
+    console.log('stop: atris member stop <name>');
   }
 
   const cwd = mission.worktree?.path || process.cwd();
@@ -1324,6 +1333,7 @@ function memberRunWith(name, args, { quiet = false } = {}) {
     ['--mission', '--mission-id', '--minutes', '--hours', '--industry', '--domain', '--value', '--outcome', '--truth', '--proof', '--base'],
     ['--worktree', '--shared-checkout', '--no-worktree', '--choose-work', '--auto', '--ignite', '--wait', '--sync']);
   if (ignite && !hasFlag(runArgs, '--complete-on-pass')) runArgs.push('--complete-on-pass');
+  if (memberRunWantsReferee(runArgs, ignite)) runArgs.push('--referee');
   const budgetSeconds = memberRunBudgetSeconds(args);
   if (!readFlag(runArgs, '--max-ticks', '')) {
     runArgs.push('--max-ticks', budgetSeconds ? String(Math.max(4, Math.ceil(budgetSeconds / 300))) : '1');
@@ -1365,6 +1375,16 @@ function memberRunWith(name, args, { quiet = false } = {}) {
     result.ask = `${name} is waiting on you: ${payload.human_asks[0]}`;
     result.next_command = payload.next_command || 'atris decide';
   }
+  // A finished ignited run whose check passed hands its branch to GitHub
+  // auto-merge, only past the local gates; any held gate leaves the branch.
+  if (ignite && ok && started && !reviewAsk && finalMission.verifier_result?.passed === true) {
+    const ticks = Array.isArray(payload.ticks) ? payload.ticks : [];
+    const summary = ticks.map((tick) => tick?.summary || tick?.claude?.summary).filter(Boolean).pop() || '';
+    const workerEngine = ticks.map((tick) => tick?.engine_id).filter(Boolean).pop()
+      || runnerSwap?.to || readFlag(args, '--runner', '') || '';
+    result.autoland = require('../lib/member-autoland').autolandMemberRun({ mission: finalMission, cwd, summary, workerEngine });
+    if (!asJson && !quiet) console.log(result.autoland.line);
+  }
   if (!ok) {
     result.error = result.ask || payload.detail || payload.error || payload.reason || payload.next_action
       || run.stderr || 'mission did not run a work step';
@@ -9796,11 +9816,35 @@ const IDEA_ARCHETYPE_RULES = [
   },
 ];
 
-// Dispatch defaults to the core team. Other members (experiments, one-off
-// workers) win only when the idea names them or out-scores the core by 2x.
-const CORE_DISPATCH_MEMBERS = new Set([
-  'executor', 'architect', 'auto-improver', 'navigator', 'validator', 'customer-lead', 'researcher',
-]);
+// Keep specialized idea rules, then fall back to the same job inference used
+// by the engine roster. Renamed members get the same job score as built-ins.
+const ARCHETYPE_FOR_JOB = { build: 'executor', review: 'validator', search: 'researcher' };
+const EXPERIMENT_STATUSES = new Set(['experimental', 'one-off']);
+
+function ideaRuleFor(slug, record, text) {
+  const own = IDEA_ARCHETYPE_RULES.find((rule) => rule.slugs.includes(slug));
+  if (own && own.pattern.test(text)) return own;
+  const { autoJobForMember } = require('../lib/member-engine');
+  const archetype = ARCHETYPE_FOR_JOB[autoJobForMember(slug, record.role)];
+  return IDEA_ARCHETYPE_RULES.find((rule) => rule.slugs.includes(archetype)) || null;
+}
+
+// 0 = normal, 1 = experiment or one-off, 2 = parked, human, or odd-typed.
+function dispatchTier(record) {
+  const frontmatter = record.frontmatter || {};
+  const status = String(frontmatter.status || '').trim().toLowerCase();
+  if (status === 'parked' || memberRefusalReason(memberSlugFromRecord(record), frontmatter)) return 2;
+  if (EXPERIMENT_STATUSES.has(status)) return 1;
+  return 0;
+}
+
+// Lower tier wins first, then higher score, then name order for a stable pick.
+function outranksDispatch(candidate, best) {
+  if (!best) return true;
+  if (candidate.tier !== best.tier) return candidate.tier < best.tier;
+  if (candidate.score !== best.score) return candidate.score > best.score;
+  return candidate.member.localeCompare(best.member) < 0;
+}
 
 function ideaNamesMember(text, slug) {
   const escaped = slug.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/-/g, '[-\\s]+');
@@ -9835,15 +9879,17 @@ function pickMemberForIdea(ideaText, root = process.cwd(), preferredMember = '')
   let best = null;
   for (const record of members) {
     const slug = memberSlugFromRecord(record);
+    const named = ideaNamesMember(text, slug);
+    // Naming an experiment in the idea is the owner's pick, so it ranks normally.
+    const baseTier = dispatchTier(record);
+    const tier = named && baseTier === 1 ? 0 : baseTier;
     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 rule = ideaRuleFor(slug, record, text);
+    if (rule && rule.pattern.test(text)) {
+      score += 30;
+      matchedReason = rule.reason;
     }
 
     const missionFile = path.join(teamDir, slug, 'MISSION.md');
@@ -9856,14 +9902,10 @@ function pickMemberForIdea(ideaText, root = process.cwd(), preferredMember = '')
     }
     score += overlapCount * 4;
     if (Number(record.skillCount || 0) > 0) score += 2;
-    if (slug === 'executor') score += 3;
-    if (slug === 'auto-improver') score += 2;
 
-    if (ideaNamesMember(text, slug)) {
+    if (named) {
       score += 40;
       matchedReason = 'named in the idea';
-    } else if (!CORE_DISPATCH_MEMBERS.has(slug)) {
-      score = Math.floor(score / 2);
     }
 
     if (!matchedReason) {
@@ -9877,10 +9919,9 @@ function pickMemberForIdea(ideaText, root = process.cwd(), preferredMember = '')
       role: record.role || 'Team Member',
       reason: matchedReason,
       score,
+      tier,
     };
-    if (!best || candidate.score > best.score || (candidate.score === best.score && candidate.member.localeCompare(best.member) < 0)) {
-      best = candidate;
-    }
+    if (outranksDispatch(candidate, best)) best = candidate;
   }
 
   return best;
@@ -9938,7 +9979,7 @@ function memberDispatch(...args) {
     printJsonOrText(
       payload,
       [
-        `${picked.member} (${picked.role}) will take this because it ${picked.reason.replace(/^[A-Z]/, (c) => c.toLowerCase())}.`,
+        `${picked.member} (${picked.role}) will take this: ${picked.reason.replace(/\.$/, '')}.`,
         '',
         commandPreview,
       ],
@@ -9948,7 +9989,7 @@ function memberDispatch(...args) {
   }
 
   if (!asJson) {
-    console.log(`${picked.member} (${picked.role}) is taking this because it ${picked.reason.replace(/^[A-Z]/, (c) => c.toLowerCase())}.`);
+    console.log(`${picked.member} (${picked.role}) is taking this: ${picked.reason.replace(/\.$/, '')}.`);
   }
   // --ignite means do the work now, the same as the previewed member run;
   // without it dispatch only opens the mission.
@@ -10371,7 +10412,70 @@ function isKnownMemberSlug(token, root = process.cwd()) {
     || fs.existsSync(path.join(root, 'atris', 'team', `${clean}.md`));
 }
 
+// The job a member does (build, review or search), read from the same team
+// roster that picks its engine.
+function memberGoJob(owner, root) {
+  const byRole = { navigator: 'search', executor: 'build', validator: 'review' };
+  try {
+    const seat = require('../lib/member-engine').resolveEngineForMember(owner, root);
+    return byRole[seat.role] || byRole[seat.job_key] || 'build';
+  } catch {
+    return 'build';
+  }
+}
+
+// With no idea given, member go takes the next real job from the task list:
+// the oldest open task that fits the member's job. A dry run only looks.
+// requireCheck: only tasks with a runnable check count.
+function memberGoTask(owner, root, { claim, requireCheck = false }) {
+  try {
+    const taskDb = require('../lib/task-db');
+    const picker = require('../lib/member-task-pick');
+    const db = taskDb.open();
+    const job = memberGoJob(owner, root);
+    const workspaceRoot = taskDb.workspaceRoot(root);
+    if (claim) {
+      const got = picker.claimTaskForMember(taskDb, db, { workspaceRoot, member: owner, job, requireCheck });
+      return got ? { ...got, job } : null;
+    }
+    const task = picker.pickTaskForMember(taskDb, db, { workspaceRoot, job, requireCheck });
+    return task ? { task, objective: picker.taskObjective(task), job } : null;
+  } catch (error) {
+    console.error(`could not take a task from the list: ${String(error && error.message || error).split('\n')[0]}`);
+    return null;
+  }
+}
+
+// A pulled task leaves the run in review when the run's check passed (the
+// mission is complete, or ready: checked and waiting on a person), else back
+// on the list with a one-line reason.
+function memberGoFinishTask(owner, task, result, thrown = null) {
+  const taskDb = require('../lib/task-db');
+  const db = taskDb.open();
+  const mission = (result && result.mission) || {};
+  const receipt = (result && result.work_step && result.work_step.receipt_path) || mission.receipt_path || '';
+  const required = require('../lib/member-task-pick').taskCheck(task).command;
+  const checked = mission.verifier_result && mission.verifier_result.passed === true
+    && (!required || String(mission.verifier_result.command || '').trim() === required);
+  if (!thrown && result && result.started && ['complete', 'ready'].includes(mission.status) && checked) {
+    const proof = [`[verified] ${owner} ran mission ${result.mission_id} and its check passed.`,
+      receipt ? `Receipt: ${receipt}` : ''].filter(Boolean).join('\n');
+    const ready = taskDb.readyTask(db, { id: task.id, actor: owner, proof });
+    if (ready.ready !== false) return { id: task.id, title: task.title, outcome: 'review', receipt: receipt || null };
+  }
+  const why = thrown ? thrown.message
+    : (result && result.error) || (result && result.started ? 'the check did not pass' : 'the run did not start');
+  const reason = String(why || 'the run did not finish').split(/\r?\n/)[0].trim().slice(0, 200);
+  try { taskDb.noteTask(db, { id: task.id, actor: owner, content: `Released by ${owner}: ${reason}` }); } catch {}
+  const released = taskDb.releaseTask(db, { id: task.id, actor: owner });
+  return { id: task.id, title: task.title, outcome: released.released ? 'released' : 'left_claimed', reason };
+}
+
 async function memberSteerOrDispatch(...rawArgs) {
+  return memberSteerOrDispatchWith({}, rawArgs);
+}
+
+async function memberSteerOrDispatchWith({ pullTask = false } = {}, 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]');
@@ -10381,6 +10485,9 @@ async function memberSteerOrDispatch(...rawArgs) {
   const root = process.cwd();
   const asJson = hasFlag(rawArgs, '--json');
   const dryRun = hasFlag(rawArgs, '--dry-run');
+  // Set by `member up`: run only a claimed task with a runnable check, never
+  // the member's own goal text.
+  const needsCheck = pullTask && hasFlag(rawArgs, '--needs-check');
   const valueFlags = new Set(['--engine', '--model', '--verify', '--referee-engine', '--minutes', '--hours', '--max-ticks', '--from']);
   const positionals = [];
   const flagArgs = [];
@@ -10388,6 +10495,7 @@ async function memberSteerOrDispatch(...rawArgs) {
     const token = String(rawArgs[i] || '');
     if (!token) continue;
     if (token.startsWith('-')) {
+      if (token === '--needs-check') continue;
       flagArgs.push(token);
       if (valueFlags.has(token) && i + 1 < rawArgs.length) {
         flagArgs.push(rawArgs[i + 1]);
@@ -10419,18 +10527,31 @@ async function memberSteerOrDispatch(...rawArgs) {
     fm = parseFrontmatter(fs.readFileSync(paths.memberFile, 'utf8')) || {};
   } catch {}
   const goalPlane = memberGoalPlaneStatus(owner, paths);
+  const missionMap = memberRunMissionMap(root);
+  const missionSummary = memberMissionSummary(owner, missionMap, root);
+  // A human or odd-typed member never takes a task: it would be claimed and
+  // then stranded when the run refuses the member.
+  const pulled = pullTask && !prompt && !missionSummary.live && !memberRefusalFor(targetMember, paths.memberFile)
+    ? memberGoTask(owner, root, { claim: !dryRun, requireCheck: needsCheck })
+    : null;
+  if (needsCheck && !pulled) {
+    const payload = { ok: true, action: 'member_go', mode: 'idle', member: owner, reason: 'no task with a check' };
+    printJsonOrText(payload, [`${owner} is idle, no task with a check`], asJson);
+    process.exitCode = require('../lib/member-up').IDLE_EXIT;
+    return payload;
+  }
   const effectivePrompt = prompt
+    || pulled?.objective
     || goalPlane.goal?.next_push
     || goalPlane.goal?.title
     || extractMemberNorthStar(paths.memberDir, '');
-
-  const missionMap = memberRunMissionMap(root);
-  const missionSummary = memberMissionSummary(owner, missionMap, root);
+  const pulledTask = pulled ? { id: pulled.task.id, title: pulled.task.title, job: pulled.job } : null;
+  if (pulled) whyPicked = `${whyPicked} Took the oldest open ${pulled.job} task from the list.`.trim();
   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) {
+  if (effectivePrompt && !pulled) {
     try {
       autoQueueMemberNextPush(owner, effectivePrompt, missionSummary.live?.objective || '', root);
     } catch {}
@@ -10494,11 +10615,13 @@ async function memberSteerOrDispatch(...rawArgs) {
       engine_reason: engineSeat.reason,
       prompt: effectivePrompt,
       why: whyPicked,
+      task: pulledTask,
       command,
       subagent_shell: subagentShell,
     };
     const lines = [
       `Routed to ${owner} on engine ${engineSeat.engine_id}: ${whyPicked}`,
+      ...(pulledTask ? [`Task: ${pulledTask.title}`] : []),
       `Objective: ${effectivePrompt}`,
       `Next: ${command}`,
     ];
@@ -10511,7 +10634,25 @@ async function memberSteerOrDispatch(...rawArgs) {
   }
   const hasExplicitEngine = flagArgs.includes('--engine');
   const nextFlags = hasExplicitEngine ? flagArgs : ['--engine', engineSeat.engine_id, ...flagArgs];
-  return memberRun(owner, effectivePrompt, '--ignite', ...nextFlags);
+  if (!pulled) return memberRun(owner, effectivePrompt, '--ignite', ...nextFlags);
+  // A pulled task runs with the check it requires, not the member's own.
+  const required = require('../lib/member-task-pick').taskCheck(pulled.task).command;
+  const runFlags = required ? [...stripKnownFlags(nextFlags, ['--verify'], []), '--verify', required] : nextFlags;
+  let result = null;
+  try {
+    result = await memberRunWith(owner, [effectivePrompt, '--ignite', ...runFlags], { quiet: asJson });
+  } catch (error) {
+    memberGoFinishTask(owner, pulled.task, null, error);
+    throw error;
+  }
+  const task = memberGoFinishTask(owner, pulled.task, result);
+  const merged = { ...(result || {}), task };
+  if (asJson) console.log(JSON.stringify(needsCheck
+    ? { task, work_step: { summary: result?.work_step?.summary || null }, error: result?.error || null }
+    : merged));
+  else if (task.outcome === 'review') console.log(`Task "${task.title}" is ready for review.`);
+  else console.log(`Task "${task.title}" went back on the list: ${task.reason}`);
+  return merged;
 }
 
 async function memberGo(...rawArgs) {
@@ -10522,7 +10663,7 @@ async function memberGo(...rawArgs) {
   }
   const nonFlags = rawArgs.filter((a) => a && !String(a).startsWith('-'));
   if (nonFlags.length > 0) {
-    return memberSteerOrDispatch(...rawArgs);
+    return memberSteerOrDispatchWith({ pullTask: true }, rawArgs);
   }
   const root = process.cwd();
   const teamDir = path.join(root, 'atris', 'team');
@@ -10542,7 +10683,155 @@ async function memberGo(...rawArgs) {
     const fallback = findAllMembers(teamDir).filter(isFleetMember)[0];
     if (fallback) chosen = memberSlugFromRecord(fallback);
   }
-  return memberSteerOrDispatch(chosen, ...rawArgs);
+  return memberSteerOrDispatchWith({ pullTask: true }, [chosen, ...rawArgs]);
+}
+
+// Where a running `atris member up` leaves its pid, so a whole-team sleep
+// can end it.
+function memberUpPidFile(root) {
+  return path.join(root, '.atris', 'state', 'member-up.json');
+}
+
+// A member slept by name stays asleep for member up until someone wakes it;
+// a whole-team sleep only rests the team for now.
+function memberSleepingByChoice(latest) {
+  return Boolean(latest && latest.status === 'paused' && latest.stop_reason === 'member-sleep'
+    && latest.sleep_target === 'member');
+}
+
+function memberUpTeam(root) {
+  const { isMemberParked } = require('../lib/member-park');
+  const missionMap = memberRunMissionMap(root);
+  return findAllMembers(path.join(root, 'atris', 'team')).filter(isFleetMember).map((record) => {
+    const name = memberSlugFromRecord(record);
+    const summary = memberMissionSummary(name, missionMap, root);
+    return {
+      name,
+      parked: isMemberParked(root, name),
+      human: Boolean(memberRefusalFor(name, path.join(root, 'atris', 'team', name, 'MEMBER.md'))),
+      sleeping: memberSleepingByChoice(summary.latest),
+      live: Boolean(summary.live_mission),
+    };
+  });
+}
+
+// The task `member go <name>` would claim, skipping ones already handed out.
+// Looks only; the child claims it.
+function memberUpPick(root, name, taken) {
+  try {
+    const taskDb = require('../lib/task-db');
+    const { fittingTasks } = require('../lib/member-task-pick');
+    const db = taskDb.open();
+    const job = memberGoJob(name, root);
+    return fittingTasks(taskDb, db, { workspaceRoot: taskDb.workspaceRoot(root), job, requireCheck: true })
+      .find((task) => !taken.has(task.id)) || null;
+  } catch {
+    return null;
+  }
+}
+
+function memberUpSpawn(root, name, onExit) {
+  const { spawn } = require('child_process');
+  const logDir = path.join(root, '.atris', 'state', 'member-up');
+  fs.mkdirSync(logDir, { recursive: true });
+  const logFile = path.join(logDir, `${name}.log`);
+  const out = fs.openSync(logFile, 'a');
+  const start = fs.fstatSync(out).size;
+  let child;
+  try {
+    child = spawn(process.execPath, [path.join(__dirname, '..', 'bin', 'atris.js'), 'member', 'go', name, '--needs-check', '--json'], {
+      cwd: root,
+      detached: true,
+      // Children keep their log handle when the foreground supervisor stops.
+      stdio: ['ignore', out, out],
+      env: process.env,
+    });
+  } finally {
+    fs.closeSync(out);
+  }
+  child.on('error', (error) => onExit(null, { ok: false, reason: error.message }));
+  child.on('close', (code, signal) => {
+    let output = '';
+    let fd;
+    try {
+      fd = fs.openSync(logFile, 'r');
+      const size = fs.fstatSync(fd).size;
+      const from = Math.max(start, size - 64 * 1024);
+      const buf = Buffer.alloc(Math.max(0, size - from));
+      const read = fs.readSync(fd, buf, 0, buf.length, from);
+      output = buf.subarray(0, read).toString('utf8');
+    } catch {} finally {
+      if (fd !== undefined) fs.closeSync(fd);
+    }
+    const { memberUpResult } = require('../lib/member-up');
+    onExit(code, memberUpResult(output, '', signal));
+  });
+  return child;
+}
+
+async function memberUp(...args) {
+  if (hasFlag(args, '--help') || hasFlag(args, '-h')) {
+    console.log('Usage: atris member up [--max N] [--only a,b] [--dry-run]');
+    console.log('Keeps the team working: every minute, starts each free member that has a fitting task with a runnable check.');
+    console.log('A member with no such task stays idle; it never runs its own goal instead.');
+    console.log('--only limits it to those members. Same as atris member wake 5 or atris member wake a b.');
+    console.log('Ctrl-C or atris member sleep --all ends it. Runs it started keep going.');
+    return;
+  }
+  const root = process.cwd();
+  const { createMemberUp, runMemberUp, parseMemberUpArgs, DEFAULT_MAX } = require('../lib/member-up');
+  const parsed = parseMemberUpArgs(args);
+  if (parsed.error) {
+    console.error(parsed.error);
+    process.exitCode = 1;
+    return;
+  }
+  const { max, only } = parsed;
+  const deps = {
+    listMembers: () => memberUpTeam(root),
+    pickTask: (name, taken) => memberUpPick(root, name, taken),
+    spawn: (name, onExit) => memberUpSpawn(root, name, onExit),
+    now: () => Date.now(),
+  };
+  if (parsed.dryRun) {
+    const up = createMemberUp(deps, { max, only, dryRun: true });
+    const started = up.check();
+    if (!started.length && up.working() >= up.max) {
+      console.log(`nothing to start: ${up.working()} already working, the limit is ${up.max}`);
+    } else if (!started.length) {
+      console.log('nothing to start: no free member has a task with a runnable check');
+    }
+    return started;
+  }
+  const pidFile = memberUpPidFile(root);
+  fs.mkdirSync(path.dirname(pidFile), { recursive: true });
+  fs.writeFileSync(pidFile, JSON.stringify({ pid: process.pid, started_at: new Date().toISOString() }));
+  const loop = runMemberUp(deps, { max, only });
+  const end = () => loop.stop();
+  process.once('SIGINT', end);
+  process.once('SIGTERM', end);
+  const who = only ? ` for ${only.join(', ')}` : '';
+  console.log(`team is up${who} (at most ${max || DEFAULT_MAX} at once). Ctrl-C to stop.`);
+  await loop.done;
+  process.removeListener('SIGINT', end);
+  process.removeListener('SIGTERM', end);
+  try {
+    if (JSON.parse(fs.readFileSync(pidFile, 'utf8')).pid === process.pid) fs.unlinkSync(pidFile);
+  } catch {}
+  const working = loop.up.running();
+  console.log(working.length ? `team is down; still finishing: ${working.join(', ')}` : 'team is down');
+}
+
+// Ends a running `atris member up`. Returns true when one was told to stop.
+function stopMemberUp(root) {
+  try {
+    const { pid } = JSON.parse(fs.readFileSync(memberUpPidFile(root), 'utf8'));
+    if (!Number.isInteger(pid) || pid === process.pid) return false;
+    process.kill(pid, 'SIGTERM');
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 function memberSleep(target, ...args) {
@@ -10568,6 +10857,7 @@ function memberSleep(target, ...args) {
       status: 'paused',
       paused_at: new Date().toISOString(),
       stop_reason: 'member-sleep',
+      sleep_target: filterMember ? 'member' : 'all',
       next_action: `sleeping; wake with: atris member go ${owner || ''}`.trim(),
       updated_at: new Date().toISOString(),
     };
@@ -10577,9 +10867,11 @@ function memberSleep(target, ...args) {
     slept.push({ mission_id: m.id, member: owner || 'mission-lead', objective: m.objective });
   }
 
+  const supervisorStopped = !filterMember && stopMemberUp(root);
   const payload = {
     ok: true,
     action: 'member_sleep',
+    supervisor_stopped: supervisorStopped,
     target: filterMember || 'all',
     slept_count: slept.length,
     slept,
@@ -10595,6 +10887,7 @@ function memberSleep(target, ...args) {
         `All members are already resting.`,
         `Wake anytime: ${payload.wake_command}`,
       ];
+  if (supervisorStopped) lines.unshift('Stopped member up; it starts nobody new.');
   printJsonOrText(payload, lines, asJson);
   return payload;
 }
@@ -10927,13 +11220,25 @@ function memberExport(...args) {
   return result;
 }
 
+function memberTidy(...args) {
+  const { tidyMemberCopies, formatTidy } = require('../lib/member-tidy');
+  const dirIndex = args.indexOf('--dir');
+  const result = tidyMemberCopies({
+    dryRun: args.includes('--dry-run'),
+    worktreesDir: dirIndex >= 0 ? args[dirIndex + 1] : undefined,
+  });
+  console.log(formatTidy(result));
+  if (result.aborted) process.exitCode = 1;
+  return result;
+}
+
 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', 'dispatch', 'route', 'feed', 'stream',
-    'card', 'cards', 'go', 'work', 'steer', 'sleep', 'rest', '1on1', 'interview',
+    'card', 'cards', 'go', 'work', 'up', 'steer', 'sleep', 'rest', '1on1', 'interview',
     'room', 'ui', 'day', 'standup', 'handoff', 'handoffs',
   ]);
   const explicitHelp = subcommand === 'help' || subcommand === '--help' || subcommand === '-h'
@@ -10971,9 +11276,17 @@ async function memberCommand(subcommand, ...args) {
     case 'tick':
       return memberTick(args[0], ...args.slice(1));
     case 'wake':
-      return memberWake(args[0], ...args.slice(1));
+      return require('../lib/member-verbs').memberWakeVerb(args, {
+        wake: memberWake,
+        up: memberUp,
+      });
     case 'run':
-      return memberRun(args[0], ...args.slice(1));
+      return require('../lib/member-verbs').memberRunVerb(args, {
+        root: process.cwd(),
+        aliasOf: memberRuntimeKind,
+        run: memberRun,
+        dispatch: memberDispatch,
+      });
     case 'result': {
       const code = require('../lib/member-result').memberResultCommand(args);
       if (code) process.exitCode = code;
@@ -10982,6 +11295,8 @@ async function memberCommand(subcommand, ...args) {
     case 'go':
     case 'work':
       return memberGo(...args);
+    case 'up':
+      return memberUp(...args);
     case 'steer':
       return memberSteerOrDispatch(...args);
     case 'sleep':
@@ -11006,6 +11321,8 @@ async function memberCommand(subcommand, ...args) {
       return memberFeed(...args);
     case 'board':
       return require('../lib/member-board').memberBoardCommand(...args);
+    case 'stop':
+      return require('../lib/member-board').memberStopCommand(args[0]);
     case 'card':
     case 'cards':
       return memberCard(args[0], ...args.slice(1));
@@ -11042,6 +11359,8 @@ async function memberCommand(subcommand, ...args) {
       return memberArchive(args[0]);
     case 'purge-archived':
       return memberPurgeArchived(...args);
+    case 'tidy':
+      return memberTidy(...args);
     case undefined:
     case '--json':
       if (fs.existsSync(path.join(process.cwd(), 'atris', 'team'))) {
@@ -11056,6 +11375,9 @@ async function memberCommand(subcommand, ...args) {
         }
         return memberSteerOrDispatch(subcommand, ...args);
       }
+      console.log('run "<job>"          pick the right member and run it: atris member run "fix the flaky login test"');
+      console.log('wake <N|names>       keep members working: atris member wake 5  or  atris member wake navigator executor');
+      console.log('sleep [name|--all]   rest the team: atris member sleep --all');
       console.log('');
       console.log('Usage: atris member <subcommand|"<prompt>"> [name]');
       console.log('');
@@ -11072,6 +11394,7 @@ async function memberCommand(subcommand, ...args) {
       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');
       console.log('  list [--json]       Show all team members');
+      console.log('  tidy [--dry-run]    Put away member copies of the repo whose work already landed');
       console.log('  export [--dry-run]  Write each member as a subagent for Claude Code, Cursor, and Codex');
       console.log('  activate <name>     Symlink member skills, show context and permissions');
       console.log('  upgrade <name>      Convert flat file (name.md) to directory format');
@@ -11080,10 +11403,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>         Decide tick/wait/ask/stop, then run one bounded work step on the roster engine (--plan to only decide)');
+      console.log('  wake <name>         Decide tick/wait/ask/stop, then run one bounded work step on the roster engine (--plan to only decide; --keep keeps it working)');
+      console.log('  run "<job>"         Pick the best member for the job and run it (same as dispatch "<job>" --ignite)');
       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('  up [--max N] [--only a,b]  Keep the team working: start free members on fitting tasks every minute (wake 5 / wake a b)');
       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');
@@ -11144,7 +11469,9 @@ async function memberCommand(subcommand, ...args) {
 }
 
 module.exports = {
+  memberRunWantsReferee,
   proposalPromptForGoal,
+  memberGoFinishTask,
   appendMemberGoalLog,
   appendProjectLog,
   memberCommand,