atris 3.78.0 → 3.80.0

package/commands/member.js

@@ -15,637 +15,23 @@ const { hasFlag, readFlag, readNumberFlag } = require('../lib/arg-parser');
 const { ensureMemberBundle, memberBundlePresent, updateMemberSkills } = require('../lib/member-scaffold');
 const { memberProcessPrompt, MEMBER_PROCESS_PATH } = require('../lib/member-context');
 
-function findWorkspaceBusinessId(startDir = process.cwd()) {
-  let dir = path.resolve(startDir);
-  while (true) {
-    const file = path.join(dir, '.atris', 'business.json');
-    if (fs.existsSync(file)) {
-      try {
-        return JSON.parse(fs.readFileSync(file, 'utf8')).business_id || null;
-      } catch (error) {
-        console.warn(`Warning: could not parse ${file}: ${error.message}`);
-        return null;
-      }
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-
-function todayLogName() {
-  const now = new Date();
-  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}.md`;
-}
-
-function ensureMemberLog(memberDir, { name, role, description, source = 'cli' } = {}) {
-  const logsDir = path.join(memberDir, 'logs');
-  fs.mkdirSync(logsDir, { recursive: true });
-  const logPath = path.join(logsDir, todayLogName());
-  if (fs.existsSync(logPath)) return logPath;
-  const stamp = new Date().toTimeString().slice(0, 5);
-  const content = [
-    `## ${stamp} · Member initialized`,
-    `- team: ${name || path.basename(memberDir)}`,
-    role ? `- role: ${role}` : '',
-    description ? `- mission: ${description}` : '',
-    `- source: ${source}`,
-    '- status: ready_for_room',
-  ].filter(Boolean).join('\n') + '\n';
-  fs.writeFileSync(logPath, content, 'utf8');
-  return logPath;
-}
-
-function appendMemberLifecycleLog(memberDir, name, action, detail = '') {
-  const logsDir = path.join(memberDir, 'logs');
-  fs.mkdirSync(logsDir, { recursive: true });
-  const logPath = path.join(logsDir, todayLogName());
-  const stamp = new Date().toTimeString().slice(0, 5);
-  const content = [
-    `## ${stamp} · Member ${action}`,
-    `- team: ${name || path.basename(memberDir)}`,
-    detail ? `- detail: ${detail}` : '',
-    `- status: ${action}`,
-    '',
-  ].filter(Boolean).join('\n');
-  fs.appendFileSync(logPath, content, 'utf8');
-  return logPath;
-}
-
-function archiveName(name) {
-  return `${name}-${todayLogName().replace(/\.md$/, '')}`;
-}
-
-function uniqueArchiveDir(archiveRoot, name) {
-  const base = archiveName(name);
-  let candidate = path.join(archiveRoot, base);
-  let i = 2;
-  while (fs.existsSync(candidate)) {
-    candidate = path.join(archiveRoot, `${base}-${i}`);
-    i += 1;
-  }
-  return candidate;
-}
-
-function parseDaysFlag(flags, fallback = 60) {
-  const joined = flags.join(' ');
-  const match = joined.match(/--days[=\s]+(\d+)/);
-  const days = match ? Number(match[1]) : fallback;
-  return Number.isFinite(days) && days >= 0 ? days : fallback;
-}
-
-function parseConfirmFlag(flags) {
-  const joined = flags.join(' ');
-  return joined.match(/--confirm[=\s]+["']?([^"']+)["']?/)?.[1] || '';
-}
-
-function readRepeatedFlag(args, name) {
-  const values = [];
-  const prefix = `${name}=`;
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = String(args[i]);
-    if (arg === name && args[i + 1] && !String(args[i + 1]).startsWith('--')) {
-      values.push(String(args[i + 1]).replace(/^["']|["']$/g, ''));
-      i += 1;
-      continue;
-    }
-    if (arg.startsWith(prefix)) values.push(arg.slice(prefix.length).replace(/^["']|["']$/g, ''));
-  }
-  return values.filter(Boolean);
-}
-
-function stripKnownFlags(args, valueNames, booleanNames = []) {
-  const out = [];
-  const valueSet = new Set(valueNames);
-  const booleanSet = new Set(['--full', '--verbose', ...booleanNames]);
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = String(args[i]);
-    const key = arg.includes('=') ? arg.slice(0, arg.indexOf('=')) : arg;
-    if (booleanSet.has(key)) continue;
-    if (valueSet.has(key)) {
-      if (!arg.includes('=') && args[i + 1] && !String(args[i + 1]).startsWith('--')) i += 1;
-      continue;
-    }
-    out.push(args[i]);
-  }
-  return out;
-}
-
-function stampIso() {
-  return new Date().toISOString();
-}
-
-function fileSafeStamp() {
-  return stampIso().replace(/[:.]/g, '-');
-}
-
-function slugHash(value) {
-  return crypto.createHash('sha1').update(String(value || '')).digest('hex').slice(0, 8);
-}
-
-function makeGoalId(title) {
-  return `goal-${todayLogName().replace(/\.md$/, '')}-${slugHash(title)}`;
-}
-
-function uniqueGoalId(state, baseId) {
-  const existingIds = new Set((state.goals || []).map((goal) => goal.id).filter(Boolean));
-  if (!existingIds.has(baseId)) return baseId;
-  let index = 2;
-  let id = `${baseId}-${index}`;
-  while (existingIds.has(id)) {
-    index += 1;
-    id = `${baseId}-${index}`;
-  }
-  return id;
-}
-
-function makeExperimentId(goalId, title) {
-  return `exp-${slugHash(`${goalId}:${title}:${Date.now()}`)}`;
-}
-
-const MEMBER_RUNTIME_ALIASES = Object.freeze({
-  'problem-finder': 'signal-scout',
-  'info-organizer': 'wiki-miner',
-  coordinator: 'supervisor',
-  'task-planner': 'objective-generator',
-  improver: 'architect',
-  'problem-solver': 'generalist',
-});
-
-function memberRuntimeKind(name) {
-  const key = lowerCompact(name);
-  return MEMBER_RUNTIME_ALIASES[key] || key;
-}
-
-function resolveMemberRuntime(name) {
-  const requestedName = String(name || '').trim();
-  const requestedPaths = memberPaths(requestedName);
-  const runtimeKind = memberRuntimeKind(requestedName);
-  const aliasOf = runtimeKind !== lowerCompact(requestedName) ? runtimeKind : null;
-  if (requestedName && fs.existsSync(requestedPaths.memberFile)) {
-    return {
-      requestedName,
-      storageName: requestedName,
-      runtimeKind,
-      aliasOf,
-      paths: requestedPaths,
-    };
-  }
-  if (aliasOf) {
-    const legacyPaths = memberPaths(runtimeKind);
-    if (fs.existsSync(legacyPaths.memberFile)) {
-      return {
-        requestedName,
-        storageName: runtimeKind,
-        runtimeKind,
-        aliasOf,
-        paths: legacyPaths,
-      };
-    }
-  }
-  return {
-    requestedName,
-    storageName: requestedName,
-    runtimeKind,
-    aliasOf,
-    paths: requestedPaths,
-  };
-}
-
-function memberPaths(name) {
-  const teamDir = path.join(process.cwd(), 'atris', 'team');
-  const memberDir = path.join(teamDir, name || '');
-  // Steering signals live in the workspace's single .atris/state store. Resolve
-  // the shared workspace root (spine -> git -> cwd) so a member run from a
-  // subdirectory reads steering from the real store instead of a nonexistent
-  // nested .atris, the same resolver the mission/task/usage/autopilot state
-  // uses. (teamDir markdown discovery is a separate cwd concern, filed.)
-  const workspaceRoot = require('../lib/mission-root').resolveWorkspaceRoot(process.cwd());
-  return {
-    teamDir,
-    memberDir,
-    memberFile: path.join(memberDir, 'MEMBER.md'),
-    missionFile: path.join(memberDir, 'MISSION.md'),
-    goalsJson: path.join(memberDir, 'goals.json'),
-    goalsMd: path.join(memberDir, 'goals.md'),
-    steeringJsonl: path.join(workspaceRoot, '.atris', 'state', 'steering.jsonl'),
-  };
-}
-
-function missionFileMarkdown({ name, role, description } = {}) {
-  const title = role || name || 'Member';
-  const purpose = description || `Define why ${name || 'this member'} exists and how it chooses goals.`;
-  return [
-    '# Mission',
-    '',
-    '<!-- Human-authored purpose file. Keep this durable; runtime state belongs in .atris/state/*.jsonl and now.md. -->',
-    '',
-    '## North Star',
-    '',
-    purpose,
-    '',
-    '## How To Choose Goals',
-    '',
-    `- Use MEMBER.md to stay inside ${title}'s identity, authority, and tools.`,
-    '- Choose one useful bounded goal toward this mission.',
-    '- Verify the work, write the receipt, and update the log.',
-    '- Ask the human when vision, taste, risk, or uncertainty matters.',
-    '',
-  ].join('\n');
-}
-
-function ensureMissionFile(memberDir, { name, role, description } = {}) {
-  const missionPath = path.join(memberDir, 'MISSION.md');
-  if (!fs.existsSync(missionPath)) {
-    fs.writeFileSync(missionPath, missionFileMarkdown({ name, role, description }), 'utf8');
-  }
-  return missionPath;
-}
-
-function listExistingMemberSlugs() {
-  const teamDir = path.join(process.cwd(), 'atris', 'team');
-  try {
-    return fs.readdirSync(teamDir, { withFileTypes: true })
-      .filter(entry => entry.isDirectory() && !entry.name.startsWith('_'))
-      .map(entry => entry.name)
-      .filter(slug => fs.existsSync(path.join(teamDir, slug, 'MEMBER.md')))
-      .sort();
-  } catch {
-    return [];
-  }
-}
-
-function editDistance(a, b) {
-  const rows = a.length + 1;
-  const cols = b.length + 1;
-  const dist = Array.from({ length: rows }, (_, i) => [i, ...Array(cols - 1).fill(0)]);
-  for (let j = 0; j < cols; j++) dist[0][j] = j;
-  for (let i = 1; i < rows; i++) {
-    for (let j = 1; j < cols; j++) {
-      dist[i][j] = Math.min(
-        dist[i - 1][j] + 1,
-        dist[i][j - 1] + 1,
-        dist[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1),
-      );
-    }
-  }
-  return dist[rows - 1][cols - 1];
-}
-
-function nearestMemberSlug(name, slugs) {
-  const needle = String(name || '').toLowerCase();
-  let best = null;
-  let bestScore = Infinity;
-  for (const slug of slugs) {
-    const score = editDistance(needle, slug.toLowerCase());
-    if (score < bestScore) {
-      best = slug;
-      bestScore = score;
-    }
-  }
-  return bestScore <= Math.max(2, Math.floor(needle.length / 3)) ? best : null;
-}
-
-// A person is never run as an agent. Reads the member's own type and returns
-// the plain refusal sentence, or '' when the member can run.
-function memberRefusalFor(name, memberFile) {
-  try {
-    return memberRefusalReason(name, parseFrontmatter(fs.readFileSync(memberFile, 'utf8')) || {});
-  } catch {
-    return '';
-  }
-}
-
-// Same as requireMemberDir, then stops with a non-zero exit for a human or
-// odd-typed member. Every path that runs a member as an agent starts here.
-function requireRunnableMember(name) {
-  const paths = requireMemberDir(name);
-  const reason = memberRefusalFor(name, paths.memberFile);
-  if (reason) {
-    console.error(reason);
-    process.exit(1);
-  }
-  return paths;
-}
-
-function requireMemberDir(name) {
-  if (!name) {
-    console.error('Usage: atris member <goal|tick|review> <name> ...');
-    process.exit(1);
-  }
-  if (!/^[a-zA-Z0-9._-]+$/.test(name)) {
-    console.error('Member name must be a local slug: letters, numbers, dots, underscores, or dashes.');
-    process.exit(1);
-  }
-  const resolved = resolveMemberRuntime(name);
-  const paths = resolved.paths;
-  if (!fs.existsSync(paths.memberFile)) {
-    const aliasHint = resolved.aliasOf ? ` or atris/team/${resolved.aliasOf}/MEMBER.md` : '';
-    console.error(`Member "${name}" not found at atris/team/${name}/MEMBER.md${aliasHint}`);
-    const team = listExistingMemberSlugs();
-    const nearest = nearestMemberSlug(name, team);
-    if (nearest) {
-      console.error(`Did you mean "${nearest}"?`);
-    } else if (team.length) {
-      console.error(`Team here: ${team.join(', ')}`);
-    } else {
-      console.error(`No team members exist here yet. Create one: atris member create ${name} --role="..."`);
-    }
-    process.exit(1);
-  }
-  return {
-    ...paths,
-    requestedName: resolved.requestedName,
-    storageName: resolved.storageName,
-    runtimeKind: resolved.runtimeKind,
-    aliasOf: resolved.aliasOf,
-  };
-}
-
-function emptyMemberGoals(name) {
-  return {
-    schema: 'atris.member_goals.v1',
-    member: name,
-    updated_at: stampIso(),
-    goals: [],
-  };
-}
-
-function loadMemberGoals(name, paths = memberPaths(name)) {
-  const parsed = readJson(paths.goalsJson, {}) || {};
-  return {
-    ...emptyMemberGoals(name),
-    ...parsed,
-    goals: Array.isArray(parsed.goals) ? parsed.goals : [],
-  };
-}
-
-function activeGoal(goalsState, goalId = '') {
-  if (goalId) return goalsState.goals.find((goal) => goal.id === goalId) || 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) {
-  const out = [];
-  for (const goal of state.goals || []) {
-    for (const experiment of goal.experiments || []) out.push({ goal, experiment });
-  }
-  return out;
-}
-
-function findExperiment(state, experimentId) {
-  for (const item of allExperiments(state)) {
-    if (item.experiment.id === experimentId) return item;
-  }
-  return { goal: null, experiment: null };
-}
-
-function latestByTime(items, field = 'created_at') {
-  return items
-    .filter(Boolean)
-    .slice()
-    .sort((a, b) => String(b[field] || '').localeCompare(String(a[field] || '')))[0] || null;
-}
-
-function recentLogLines(memberDir, maxLines = 8) {
-  const logsDir = path.join(memberDir, 'logs');
-  if (!fs.existsSync(logsDir)) return [];
-  const logs = fs.readdirSync(logsDir)
-    .filter((name) => /^\d{4}-\d{2}-\d{2}\.md$/.test(name))
-    .sort();
-  const latest = logs[logs.length - 1];
-  if (!latest) return [];
-  return fs.readFileSync(path.join(logsDir, latest), 'utf8')
-    .split(/\r?\n/)
-    .filter((line) => line.trim())
-    .slice(-maxLines);
-}
-
-function readOptionalText(filePath) {
-  try {
-    return fs.readFileSync(filePath, 'utf8');
-  } catch {
-    return '';
-  }
-}
-
-function extractMarkdownSection(text, heading) {
-  const lines = String(text || '').split(/\r?\n/);
-  const target = String(heading || '').trim().toLowerCase();
-  const start = lines.findIndex((line) => {
-    const match = line.match(/^##\s+(.+?)\s*$/);
-    return match && match[1].trim().toLowerCase() === target;
-  });
-  if (start === -1) return '';
-  const out = [];
-  for (let i = start + 1; i < lines.length; i += 1) {
-    if (/^##\s+/.test(lines[i])) break;
-    out.push(lines[i]);
-  }
-  return out.join('\n').trim();
-}
-
-function firstUsefulLine(text) {
-  return String(text || '')
-    .split(/\r?\n/)
-    .map((line) => line.replace(/^[-*]\s+/, '').trim())
-    .find((line) => line && !line.startsWith('<!--')) || '';
-}
-
-function compactSentence(text, max = 120) {
-  const clean = String(text || '').replace(/\s+/g, ' ').trim();
-  if (clean.length <= max) return clean;
-  // Cut at a word boundary so titles never end mid-word ("rollb...").
-  const cut = clean.slice(0, Math.max(0, max - 1));
-  const lastSpace = cut.lastIndexOf(' ');
-  return `${(lastSpace > max * 0.6 ? cut.slice(0, lastSpace) : cut).trim()}...`;
-}
-
-function activeRuntimeMissionFromNow(nowText) {
-  const heading = String(nowText || '').match(/^##\s+(.+?)\s*$/m)?.[1]?.trim() || '';
-  const id = String(nowText || '').match(/^- id:\s*(.+?)\s*$/m)?.[1]?.trim() || '';
-  const status = String(nowText || '').match(/^- status:\s*(.+?)\s*$/m)?.[1]?.trim() || '';
-  const next = String(nowText || '').match(/^- next:\s*(.+?)\s*$/m)?.[1]?.trim() || '';
-  return { heading, id, status, next };
-}
-
-function missionPurpose(paths) {
-  const missionText = readOptionalText(paths.missionFile);
-  const nowText = readOptionalText(path.join(paths.memberDir, 'now.md'));
-  const northStar = firstUsefulLine(extractMarkdownSection(missionText, 'North Star'));
-  const goalGuidance = extractMarkdownSection(missionText, 'How To Choose Goals');
-  const runtimeMission = activeRuntimeMissionFromNow(nowText);
-  const meaningful = Boolean(northStar) && !/define why .* exists/i.test(northStar);
-  return {
-    missionText,
-    nowText,
-    northStar,
-    goalGuidance,
-    runtimeMission,
-    meaningful,
-  };
-}
-
-const MEMBER_RUN_RUNNABLE_STATUSES = new Set(['planning', 'running', 'ready']);
-const MISSION_TERMINAL_STATUSES = new Set(['complete', 'stopped', 'failed']);
-
-function memberRunMissionMap(root = process.cwd()) {
-  try {
-    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();
-  }
-}
-
-function memberRunRunnableMissionId(candidateId, missionMap) {
-  const id = String(candidateId || '').trim();
-  if (!id) return '';
-  const mission = missionMap.get(id);
-  // Unknown here can mean a worktree-held mission; let mission run decide.
-  if (!mission) return id;
-  return MEMBER_RUN_RUNNABLE_STATUSES.has(mission.status) ? id : '';
-}
-
-function memberRunOwnedActiveMissionId(name, missionMap) {
-  // Discovery fallback when the member's own pointers are stale: resume the
-  // member's newest moving mission. ready is excluded, it waits for review.
-  const owner = String(name || '').trim().toLowerCase();
-  const candidates = Array.from(missionMap.values())
-    .filter((mission) => String(mission?.owner || '').trim().toLowerCase() === owner)
-    .filter((mission) => mission.status === 'running' || mission.status === 'planning')
-    .filter((mission) => !/^decide and start the next useful mission after:/i.test(String(mission?.objective || '')))
-    .sort((a, b) => {
-      if (a.status !== b.status) return a.status === 'running' ? -1 : 1;
-      return String(b.updated_at || b.created_at || '').localeCompare(String(a.updated_at || a.created_at || ''));
-    });
-  return candidates[0]?.id || '';
-}
-
-const MEMBER_LIVE_MISSION_STATUSES = new Set(['running', 'planning']);
-const MEMBER_ACTIVE_ACTIVITY_MS = 24 * 60 * 60 * 1000;
-const MEMBER_RECENT_ACTIVITY_MS = 72 * 60 * 60 * 1000;
-
-function memberSlugFromRecord(member) {
-  if (member?.format === 'directory' && member.dir) return path.basename(member.dir);
-  if (member?.format === 'flat' && member.path) return path.basename(member.path, '.md');
-  return lowerCompact(member?.name || '');
-}
-
-function isFleetMember(member) {
-  if (!member || member.format !== 'directory') return false;
-  const slug = memberSlugFromRecord(member);
-  return Boolean(slug) && !new Set(['_archive', '_archived', '_template']).has(slug);
-}
-
-function missionTimeMs(mission) {
-  return Date.parse(mission?.last_tick_at || mission?.updated_at || mission?.created_at || '') || 0;
-}
-
-function memberOwnedMissions(name, missionMap = memberRunMissionMap()) {
-  const owner = lowerCompact(name);
-  return Array.from(missionMap.values())
-    .filter((mission) => lowerCompact(mission?.owner) === owner)
-    .sort((a, b) => missionTimeMs(b) - missionTimeMs(a));
-}
-
-function memberLatestMission(name, missionMap = memberRunMissionMap()) {
-  return memberOwnedMissions(name, missionMap)[0] || null;
-}
-
-function memberLiveMission(name, missionMap = memberRunMissionMap()) {
-  return memberOwnedMissions(name, missionMap)
-    .find((mission) => {
-      if (!MEMBER_LIVE_MISSION_STATUSES.has(String(mission?.status || '').toLowerCase())) return false;
-      // A closed window can leave a running row behind. Only a known dead
-      // process proves it is free; missing process records still hold it.
-      try {
-        const root = mission.worktree_root || mission.worktree?.path || process.cwd();
-        const health = require('./mission').missionDriverHealth(mission, root);
-        return !health.pid || health.alive;
-      } catch { return true; }
-    }) || null;
-}
-
-function missionShortName(mission, max = 36) {
-  return compactSentence(mission?.slug || mission?.title || mission?.objective || mission?.id || '', max) || '-';
-}
-
-function ageLabelFromMs(ms, nowMs = Date.now()) {
-  if (!ms) return '-';
-  const seconds = Math.max(0, Math.floor((nowMs - ms) / 1000));
-  if (seconds < 60) return 'now';
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 60) return `${minutes}m`;
-  const hours = Math.floor(minutes / 60);
-  if (hours < 48) return `${hours}h`;
-  return `${Math.floor(hours / 24)}d`;
-}
-
-function timestampMs(value) {
-  const ms = Date.parse(value || '');
-  return Number.isFinite(ms) ? ms : 0;
-}
-
-function newestMtimeRecursive(root) {
-  if (!fs.existsSync(root)) return 0;
-  let newest = 0;
-  const stack = [root];
-  while (stack.length) {
-    const current = stack.pop();
-    let stat = null;
-    try {
-      stat = fs.statSync(current);
-    } catch {
-      continue;
-    }
-    newest = Math.max(newest, stat.mtimeMs || 0);
-    if (!stat.isDirectory()) continue;
-    let entries = [];
-    try {
-      entries = fs.readdirSync(current);
-    } catch {
-      continue;
-    }
-    for (const entry of entries) stack.push(path.join(current, entry));
-  }
-  return newest;
-}
-
-function newestRunActivityMtime(name, root = process.cwd()) {
-  const runsDir = path.join(root, 'atris', 'runs');
-  if (!fs.existsSync(runsDir)) return 0;
-  const needle = lowerCompact(name);
-  let newest = 0;
-  for (const entry of fs.readdirSync(runsDir)) {
-    if (!lowerCompact(entry).includes(needle)) continue;
-    try {
-      newest = Math.max(newest, fs.statSync(path.join(runsDir, entry)).mtimeMs || 0);
-    } catch { /* ignore unreadable activity entries */ }
-  }
-  return newest;
-}
-
-function memberLastActivity(name, paths = memberPaths(name), root = process.cwd()) {
-  const logsMs = newestMtimeRecursive(path.join(paths.memberDir, 'logs'));
-  const runsMs = newestRunActivityMtime(name, root);
-  const ms = Math.max(logsMs, runsMs);
-  return {
-    at_ms: ms,
-    age: ageLabelFromMs(ms),
-  };
-}
+// Runtime aliases: problem-finder, info-organizer, coordinator, task-planner, improver, problem-solver
+// memberPaths resolves steeringJsonl: path.join(workspaceRoot, '.atris', 'state', 'steering.jsonl')
+const {
+  findWorkspaceBusinessId, todayLogName, ensureMemberLog, appendMemberLifecycleLog, archiveName,
+  uniqueArchiveDir, parseDaysFlag, parseConfirmFlag, readRepeatedFlag, stripKnownFlags,
+  stampIso, fileSafeStamp, slugHash, makeGoalId, uniqueGoalId, makeExperimentId,
+  MEMBER_RUNTIME_ALIASES, memberRuntimeKind, resolveMemberRuntime, memberPaths,
+  missionFileMarkdown, ensureMissionFile, listExistingMemberSlugs, editDistance, nearestMemberSlug,
+  memberRefusalFor, requireRunnableMember, requireMemberDir, emptyMemberGoals, loadMemberGoals,
+  activeGoal, allExperiments, findExperiment, latestByTime, recentLogLines, readOptionalText,
+  extractMarkdownSection, firstUsefulLine, compactSentence, activeRuntimeMissionFromNow, missionPurpose,
+  MEMBER_RUN_RUNNABLE_STATUSES, MISSION_TERMINAL_STATUSES, memberRunMissionMap,
+  memberRunRunnableMissionId, memberRunOwnedActiveMissionId, MEMBER_LIVE_MISSION_STATUSES,
+  MEMBER_ACTIVE_ACTIVITY_MS, MEMBER_RECENT_ACTIVITY_MS, memberSlugFromRecord, isFleetMember,
+  missionTimeMs, memberOwnedMissions, memberLatestMission, memberLiveMission, missionShortName,
+  ageLabelFromMs, timestampMs, newestMtimeRecursive, newestRunActivityMtime, memberLastActivity,
+} = require('../lib/member-core');
 
 function memberMissionSummary(name, missionMap = memberRunMissionMap(), root = process.cwd()) {
   const latest = memberLatestMission(name, missionMap);
@@ -1711,17 +1097,7 @@ function steeringWakeDirective(steering, name, goal) {
   return null;
 }
 
-function taskRef(task) {
-  return task?.display_id || task?.displayId || task?.legacy_ref || task?.legacyRef || task?.ref || task?.id || null;
-}
-
-function lowerCompact(value) {
-  return String(value || '').trim().toLowerCase();
-}
-
-function shellQuote(value) {
-  return `'${String(value || '').replace(/'/g, "'\\''")}'`;
-}
+const { taskRef, lowerCompact, shellQuote } = require('../lib/member-core');
 
 function taskCandidateOwnerValues(task) {
   return [
@@ -2263,53 +1639,7 @@ function readRecentWakeReceiptEvidence(name) {
   };
 }
 
-function readJsonlRowsIfExists(filePath, maxRows = 80) {
-  const tailBytes = 256 * 1024;
-  let fd;
-  let text = '';
-  let truncated = false;
-  try {
-    fd = fs.openSync(filePath, 'r');
-    const stat = fs.fstatSync(fd);
-    const bytesToRead = Math.min(stat.size, tailBytes);
-    const start = Math.max(0, stat.size - bytesToRead);
-    const buffer = Buffer.alloc(bytesToRead);
-    let bytesRead = 0;
-    while (bytesRead < bytesToRead) {
-      const count = fs.readSync(
-        fd,
-        buffer,
-        bytesRead,
-        bytesToRead - bytesRead,
-        start + bytesRead
-      );
-      if (count === 0) break;
-      bytesRead += count;
-    }
-    text = buffer.toString('utf8', 0, bytesRead);
-    truncated = start > 0;
-  } catch {
-    return [];
-  } finally {
-    if (fd !== undefined) {
-      try { fs.closeSync(fd); } catch {}
-    }
-  }
-  const rows = [];
-  const lines = text
-    .split(/\r?\n/)
-    .slice(truncated ? 1 : 0)
-    .filter((line) => line.trim())
-    .slice(-Math.max(1, maxRows));
-  for (const line of lines) {
-    try {
-      rows.push(JSON.parse(line));
-    } catch {
-      // Bad rows should not block discovery from valid rows in the same stream.
-    }
-  }
-  return rows;
-}
+const { readJsonlRowsIfExists } = require('../lib/member-core');
 
 function stringFromSignalValue(value) {
   if (typeof value === 'string') return value.trim();
@@ -3135,50 +2465,7 @@ function createAutonomousDiscoveryTask(candidate) {
   }
 }
 
-function writeAutonomousDiscoveryReceipt(name, candidate, taskResult) {
-  const runsDir = path.join(process.cwd(), 'atris', 'runs');
-  fs.mkdirSync(runsDir, { recursive: true });
-  const payload = {
-    schema: 'atris.signal_scout_autonomous_discovery.v1',
-    created_at: stampIso(),
-    member: name,
-    source: candidate.source,
-    action: taskResult.existing ? 'existing_task_found' : 'task_created',
-    task_ref: taskResult.task_ref || null,
-    task_id: taskResult.task_id || taskResult.task?.id || null,
-    task_title: candidate.task_title || candidate.objective_title || candidate.title || null,
-    error_pattern: candidate.error_pattern || null,
-    error_count: candidate.error_count || null,
-    evidence_paths: candidate.evidence_paths || [],
-    command: taskResult.command || candidate.next_command || null,
-    ok: taskResult.ok === true,
-    error: taskResult.error || null,
-  };
-  const receiptPath = path.join(runsDir, `signal-scout-autonomous-discovery-${fileSafeStamp()}.json`);
-  fs.writeFileSync(receiptPath, JSON.stringify(payload, null, 2) + '\n', 'utf8');
-  const fields = {
-    team: name,
-    decision: 'auto-discovery',
-    pattern: payload.error_pattern,
-    count: payload.error_count,
-    task: payload.task_ref,
-    receipt: path.relative(process.cwd(), receiptPath),
-  };
-  const projectLogPath = appendProjectLog('Signal Scout autonomous problem discovery', fields);
-  return {
-    receipt_path: receiptPath,
-    project_log_path: projectLogPath,
-    payload,
-  };
-}
-
-function writeWakeReceipt(name, payload) {
-  const runsDir = path.join(process.cwd(), 'atris', 'runs');
-  fs.mkdirSync(runsDir, { recursive: true });
-  const receiptPath = path.join(runsDir, `member-wake-${name}-${fileSafeStamp()}.json`);
-  fs.writeFileSync(receiptPath, JSON.stringify(payload, null, 2) + '\n', 'utf8');
-  return receiptPath;
-}
+const { writeAutonomousDiscoveryReceipt, writeWakeReceipt } = require('../lib/member-core');
 
 function memberLoopPaths(name) {
   const stateDir = path.join(process.cwd(), '.atris', 'state', 'member-loops');
@@ -3432,102 +2719,10 @@ function memberAliveCronStatus(name, paths = memberLoopPaths(name)) {
   };
 }
 
-function writeMemberLoopReceipt(name, payload) {
-  const runsDir = path.join(process.cwd(), 'atris', 'runs');
-  fs.mkdirSync(runsDir, { recursive: true });
-  const receiptPath = path.join(runsDir, `member-loop-${name}-${fileSafeStamp()}.json`);
-  fs.writeFileSync(receiptPath, JSON.stringify(payload, null, 2) + '\n', 'utf8');
-  return receiptPath;
-}
-
-function isPidAlive(pid) {
-  const numeric = Number(pid);
-  if (!Number.isFinite(numeric) || numeric <= 0) return false;
-  try {
-    process.kill(numeric, 0);
-    return true;
-  } catch (error) {
-    return error?.code === 'EPERM';
-  }
-}
-
-function safeReadText(filePath, maxBytes = 250000) {
-  try {
-    const stat = fs.statSync(filePath);
-    if (!stat.isFile() || stat.size > maxBytes) return '';
-    return fs.readFileSync(filePath, 'utf8');
-  } catch {
-    return '';
-  }
-}
-
-function repoRelative(root, filePath) {
-  return path.relative(root, filePath).replace(/\\/g, '/');
-}
-
-function dateFromLogPath(relativePath) {
-  const match = String(relativePath || '').match(/\b(\d{4}-\d{2}-\d{2})\b/);
-  return match ? match[1] : null;
-}
-
-// Mission driver logs, goals files, and the wiki log have no date in their
-// name; without one they skipped the 7-day window and months-old lines kept
-// counting as this week's pain. The last write date stands in for them.
-function logDateForScan(relativePath, filePath) {
-  const named = dateFromLogPath(relativePath);
-  if (named) return named;
-  try {
-    // Local calendar day, like the dated journal names beside it;
-    // toISOString is UTC and calls an evening write tomorrow's.
-    const mtime = fs.statSync(filePath).mtime;
-    return `${mtime.getFullYear()}-${String(mtime.getMonth() + 1).padStart(2, '0')}-${String(mtime.getDate()).padStart(2, '0')}`;
-  } catch {
-    return null;
-  }
-}
-
-function compareLogEvidenceRecentFirst(a, b) {
-  const dateA = a?.date || '';
-  const dateB = b?.date || '';
-  if (dateA !== dateB) return dateB.localeCompare(dateA);
-  const pathCompare = String(a?.path || '').localeCompare(String(b?.path || ''));
-  if (pathCompare !== 0) return pathCompare;
-  return Number(a?.line || 0) - Number(b?.line || 0);
-}
-
-function compareRepeatedFailureSignals(a, b) {
-  const countCompare = Number(b?.count || 0) - Number(a?.count || 0);
-  if (countCompare !== 0) return countCompare;
-  const evidenceCompare = compareLogEvidenceRecentFirst(a?.evidence?.[0], b?.evidence?.[0]);
-  if (evidenceCompare !== 0) return evidenceCompare;
-  return String(a?.pattern || '').localeCompare(String(b?.pattern || ''));
-}
-
-function listFilesBounded(rootDir, { maxFiles = 220, extensions = ['.md', '.txt', '.json', '.jsonl'] } = {}) {
-  const files = [];
-  const stack = [rootDir];
-  const skipDirs = new Set(['.git', 'node_modules', '.next', 'dist', 'build', '__pycache__']);
-  while (stack.length && files.length < maxFiles) {
-    const current = stack.pop();
-    let entries = [];
-    try {
-      entries = fs.readdirSync(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      if (files.length >= maxFiles) break;
-      const fullPath = path.join(current, entry.name);
-      if (entry.isDirectory()) {
-        if (!skipDirs.has(entry.name) && !entry.name.startsWith('.')) stack.push(fullPath);
-        continue;
-      }
-      if (!entry.isFile()) continue;
-      if (extensions.includes(path.extname(entry.name))) files.push(fullPath);
-    }
-  }
-  return files;
-}
+const {
+  writeMemberLoopReceipt, isPidAlive, safeReadText, repoRelative, dateFromLogPath,
+  logDateForScan, compareLogEvidenceRecentFirst, compareRepeatedFailureSignals, listFilesBounded,
+} = require('../lib/member-core');
 
 function stripAutoImproverTitleNoise(text) {
   let clean = String(text || '').replace(/\s+/g, ' ').trim();
@@ -4133,13 +3328,7 @@ function createAutoImproverTask(candidate, receiptPath) {
   }
 }
 
-function writeAutoImproverReceipt(name, payload, receiptPath = null) {
-  const finalReceiptPath = receiptPath || path.join(process.cwd(), 'atris', 'runs', `auto-improver-dogfood-${fileSafeStamp()}.json`);
-  writeJson(finalReceiptPath, payload);
-  const latestPath = path.join(process.cwd(), '.atris', 'state', 'auto-improver-dogfood-latest.json');
-  writeJson(latestPath, { ...payload, receipt_path: finalReceiptPath });
-  return { receiptPath: finalReceiptPath, latestPath };
-}
+const { writeAutoImproverReceipt } = require('../lib/member-core');
 
 async function runAutoImproverWake(name, paths, { execute = false, confirmed = false } = {}) {
   const scan = collectAutoImproverScan(process.cwd());
@@ -4396,92 +3585,7 @@ function archiveMemberLoopState(name) {
   return payload;
 }
 
-function appendMemberGoalLog(memberDir, name, title, fields = {}) {
-  const logsDir = path.join(memberDir, 'logs');
-  fs.mkdirSync(logsDir, { recursive: true });
-  const logPath = path.join(logsDir, todayLogName());
-  const stamp = new Date().toTimeString().slice(0, 5);
-  const rows = [
-    `## ${stamp} · ${title}`,
-    `- team: ${name}`,
-    ...Object.entries(fields)
-      .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');
-  return logPath;
-}
-
-function appendProjectLog(title, fields = {}) {
-  const today = todayLogName();
-  const year = today.slice(0, 4);
-  const logsDir = path.join(process.cwd(), 'atris', 'logs', year);
-  fs.mkdirSync(logsDir, { recursive: true });
-  const logPath = path.join(logsDir, today);
-  const stamp = new Date().toTimeString().slice(0, 5);
-  const rows = [
-    `## ${stamp} · ${title}`,
-    ...Object.entries(fields)
-      .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');
-  return logPath;
-}
-
-// --- YAML Frontmatter Parser (shared with skill.js) ---
-
-function parseFrontmatter(content) {
-  // \r?\n so a CRLF-line-ending MEMBER.md (Windows-edited) still parses; otherwise
-  // the delimiter never matched (and trailing \r broke the per-line key matchers),
-  // silently dropping the member's entire frontmatter: role, skills, permissions, tools.
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match) return null;
-
-  const yaml = match[1];
-  const result = {};
-  let currentKey = null;
-
-  for (const line of yaml.split(/\r?\n/)) {
-    const listMatch = line.match(/^\s+-\s+(.+)$/);
-    if (listMatch && currentKey) {
-      if (!Array.isArray(result[currentKey])) result[currentKey] = [];
-      result[currentKey].push(listMatch[1].trim());
-      continue;
-    }
-
-    const nestedMatch = line.match(/^\s+([a-z_-]+):\s*(.*)$/);
-    if (nestedMatch && currentKey && typeof result[currentKey] === 'object' && !Array.isArray(result[currentKey])) {
-      const val = nestedMatch[2].trim();
-      result[currentKey][nestedMatch[1]] = val === 'true' ? true : val === 'false' ? false : val || true;
-      continue;
-    }
-
-    const kvMatch = line.match(/^([a-z_-]+):\s*(.*)$/);
-    if (kvMatch) {
-      currentKey = kvMatch[1];
-      const val = kvMatch[2].trim();
-      if (val === '') {
-        result[currentKey] = {};
-      } else if (val.startsWith('[') && val.endsWith(']')) {
-        result[currentKey] = val.slice(1, -1).split(',').map(s => s.trim().replace(/^["']|["']$/g, ''));
-      } else {
-        // Unwrap only a matching outer pair: `verify: node -e "process.exit(0)"`
-        // must keep its closing quote or the check is a shell syntax error.
-        const quoted = val.match(/^(["'])([\s\S]*)\1$/);
-        result[currentKey] = quoted ? quoted[2] : val;
-      }
-    }
-  }
-
-  return result;
-}
+const { appendMemberGoalLog, appendProjectLog, parseFrontmatter } = require('../lib/member-core');
 
 // --- Member Discovery ---
 
@@ -10312,6 +9416,10 @@ function scrubFeedJargon(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*(commit\s*)?\)/gi, '')
+    .replace(/\s+\bas\s+(?:``|''|""|(?=[.,;!?]|$))/gi, '')
+    .replace(/\s+(?:in|on|at|from)\s+(?:``|''|"")(?=[.,;!?]|\s|$)/gi, '')
+    .replace(/\s*(?:``|''|"")/g, '')
+    .replace(/\s+([.,;!?])/g, '$1')
     .replace(/\s+/g, ' ')
     .trim();
 }
@@ -10350,6 +9458,9 @@ function isFeedFillerText(text) {
   if (/^member (wake|goal-from-mission|goal created|initialized)\b/i.test(t)) return true;
   if (/^\[?logged update\]?$/i.test(t)) return true;
   if (/^(next[_ ]push|verdict):/i.test(t)) return true;
+  if (/^reading additional input from stdin\b/i.test(t)) return true;
+  if (/^openai codex\b/i.test(t)) return true;
+  if (/^(?:workdir|model|provider|approval|sandbox|reasoning effort|reasoning summaries|session id):/i.test(t)) return true;
   if (/^[`'"]?atris\s/i.test(t) || /\batris\s+[a-z-]+\s+[a-z-]+\s+--[a-z]/i.test(t)) return true;
   return false;
 }
@@ -10530,13 +9641,94 @@ function listMemberUnlockedSkills(memberDir, frontmatterSkills = []) {
 
 function resolveMemberEngineSeat(memberSlug, root = process.cwd()) {
   const slug = String(memberSlug || '').trim().toLowerCase();
-  const engineRole = slug === 'navigator'
+  const fallbackRole = slug === 'navigator'
     ? 'navigator'
     : (slug === 'validator' || slug === 'architect')
       ? 'validator'
       : 'executor';
   try {
-    const { resolveEngineForRoleRanked } = require('../lib/engine-registry');
+    const {
+      resolveEngineForMember,
+      readMemberCard,
+      autoJobForMember,
+    } = require('../lib/member-engine');
+    const { rosterEngine } = require('../lib/gm-season');
+    const {
+      ENGINE_JOBS,
+      readRosterState,
+      resolveEngineForRoleRanked,
+      rosterPickFromValue,
+    } = require('../lib/engine-registry');
+    const card = readMemberCard(root, slug);
+    const kind = autoJobForMember(slug, card.role || '');
+    const engineRole = ENGINE_JOBS[kind] || fallbackRole;
+    const state = readRosterState(root);
+    const localRosterState = {
+      ...state,
+      machine: { picks: {}, team: [], file: null, path: null },
+    };
+    const fromProjectRoster = rosterEngine(slug, root, {
+      rosterState: localRosterState,
+      role: card.role || '',
+      hasCard: Boolean(card.found),
+    });
+    if (fromProjectRoster && fromProjectRoster.engine) {
+      return {
+        engine_id: fromProjectRoster.engine,
+        tier: 'pro',
+        models: fromProjectRoster.model ? [fromProjectRoster.model] : [fromProjectRoster.engine],
+        role: engineRole,
+        reason: fromProjectRoster.source ? `${fromProjectRoster.engine} from ${fromProjectRoster.source}.` : `${fromProjectRoster.engine} from roster.`,
+      };
+    }
+    let fm = {};
+    try {
+      const cardPath = path.join(root, 'atris', 'team', slug, 'MEMBER.md');
+      if (fs.existsSync(cardPath)) {
+        fm = parseFrontmatter(fs.readFileSync(cardPath, 'utf8')) || {};
+      }
+    } catch {}
+    const explicitEngine = fm.engine || fm.executed_by || '';
+    if (explicitEngine) {
+      let explicitId = String(explicitEngine).trim().toLowerCase();
+      try {
+        const parsedPick = rosterPickFromValue(String(explicitEngine), engineRole);
+        if (parsedPick && parsedPick.engine) explicitId = parsedPick.engine;
+      } catch {}
+      return {
+        engine_id: explicitId,
+        tier: 'pro',
+        models: fm.model ? [fm.model] : [explicitId],
+        role: engineRole,
+        reason: `${explicitId} declared in MEMBER.md.`,
+      };
+    }
+    const fromMember = resolveEngineForMember(slug, root, { quiet: true, rosterState: state });
+    if (fromMember && fromMember.roster_backed && fromMember.engine) {
+      return {
+        engine_id: fromMember.engine.id,
+        tier: fromMember.engine.tier || 'pro',
+        models: fromMember.model
+          ? [fromMember.model]
+          : (Array.isArray(fromMember.engine.models) ? fromMember.engine.models : []),
+        role: fromMember.role || engineRole,
+        reason: fromMember.reason || `${fromMember.engine.id} selected for ${slug}.`,
+      };
+    }
+    const fromAnyRoster = rosterEngine(slug, root, {
+      rosterState: state,
+      role: card.role || '',
+      hasCard: Boolean(card.found),
+    });
+    if (fromAnyRoster && fromAnyRoster.engine) {
+      return {
+        engine_id: fromAnyRoster.engine,
+        tier: 'pro',
+        models: fromAnyRoster.model ? [fromAnyRoster.model] : [fromAnyRoster.engine],
+        role: engineRole,
+        reason: fromAnyRoster.source ? `${fromAnyRoster.engine} from ${fromAnyRoster.source}.` : `${fromAnyRoster.engine} from roster.`,
+      };
+    }
     const picked = resolveEngineForRoleRanked(engineRole, root, { taskType: engineRole });
     if (picked && picked.engine) {
       return {
@@ -10552,7 +9744,7 @@ function resolveMemberEngineSeat(memberSlug, root = process.cwd()) {
     engine_id: 'claude',
     tier: 'pro',
     models: ['claude'],
-    role: engineRole,
+    role: fallbackRole,
     reason: 'Default engine seat.',
   };
 }
@@ -10587,9 +9779,12 @@ function buildMemberCard(name, root = process.cwd()) {
   const recentWork = collectMemberWorkFeed(root, { member: owner, limit: 3 });
   const engineSeat = resolveMemberEngineSeat(owner, root);
 
+  const rawMissionSummary = !isFeedFillerText(mission.latest?.last_summary)
+    ? mission.latest?.last_summary
+    : '';
   const doingNow = mission.latest
     ? {
-        summary: compactSentence(scrubFeedJargon(mission.latest.last_summary || mission.objective || mission.name || ''), 120),
+        summary: compactSentence(scrubFeedJargon(rawMissionSummary || mission.objective || mission.name || ''), 120),
         state: plainFeedStatusLabel(mission.latest),
         engine: mission.runner || engineSeat.engine_id || null,
         model: mission.model || null,
@@ -11177,16 +10372,12 @@ function memberUpTeam(root) {
 // 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), member: name, job, requireCheck: true, recoverClaimed: true })
-      .find((task) => !taken.has(task.id)) || null;
-  } catch {
-    return null;
-  }
+  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), member: name, job, requireCheck: true, recoverClaimed: true })
+    .find((task) => !taken.has(task.id)) || null;
 }
 
 // An empty job list: write the member's next job from its own mission.
@@ -11205,16 +10396,12 @@ function memberUpWriteNextJob(root, name, { dryRun = false } = {}) {
 
 // Every open task a member could start, with the job it needs.
 function memberUpWaiting(root) {
-  try {
-    const taskDb = require('../lib/task-db');
-    const { fittingTasks } = require('../lib/member-task-pick');
-    const db = taskDb.open();
-    const workspaceRoot = taskDb.workspaceRoot(root);
-    return ['build', 'review', 'search'].flatMap((job) => fittingTasks(taskDb, db, { workspaceRoot, job, requireCheck: true })
-      .map((task) => ({ id: task.id, title: task.title, job })));
-  } catch {
-    return [];
-  }
+  const taskDb = require('../lib/task-db');
+  const { fittingTasks } = require('../lib/member-task-pick');
+  const db = taskDb.open();
+  const workspaceRoot = taskDb.workspaceRoot(root);
+  return ['build', 'review', 'search'].flatMap((job) => fittingTasks(taskDb, db, { workspaceRoot, job, requireCheck: true })
+    .map((task) => ({ id: task.id, title: task.title, job })));
 }
 
 function memberUpSpawn(root, name, onExit, onClaim) {
@@ -11250,7 +10437,9 @@ function memberUpSpawn(root, name, onExit, onClaim) {
       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 {
+    } catch (error) {
+      console.error(`[member-up] could not read ${name}'s run log:`, error);
+    } finally {
       if (fd !== undefined) fs.closeSync(fd);
     }
     const { memberUpResult } = require('../lib/member-up');
@@ -11299,9 +10488,16 @@ async function memberUp(...args) {
     }),
   };
   if (parsed.dryRun) {
-    const up = createMemberUp(deps, { max, only, dryRun: true });
+    let failed = false;
+    const up = createMemberUp({ ...deps, reportError: (context, error) => {
+      failed = true;
+      console.error(`[member-up] ${context}:`, error);
+    } }, { max, only, dryRun: true });
     const started = up.check();
-    if (!started.length && up.working() >= up.max) {
+    if (failed) {
+      console.error('team preview incomplete because of errors');
+      process.exitCode = 1;
+    } else 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');
@@ -11646,14 +10842,29 @@ function memberHandoff(from, to, ...args) {
   return handoff;
 }
 
+function isBusyStandupStatus(status) {
+  const s = String(status || '').trim().toLowerCase();
+  return Boolean(s) && s !== 'idle' && s !== 'dormant';
+}
+
 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 baseOrder = [
+    ...coreOrder.filter((s) => allSlugs.includes(s)),
+    ...allSlugs.filter((s) => !coreOrder.includes(s)),
+  ];
+  const rawCards = baseOrder.map((slug) => buildMemberCard(slug, root));
+  const cardStatus = (c) => (c.roadmap.doing_now ? c.roadmap.doing_now.state : c.verdict.toLowerCase());
+  const cards = [...rawCards].sort((a, b) => {
+    const aBusy = isBusyStandupStatus(cardStatus(a)) ? 0 : 1;
+    const bBusy = isBusyStandupStatus(cardStatus(b)) ? 0 : 1;
+    return aBusy - bBusy;
+  });
+  const ordered = cards.map((c) => c.member);
   const feed = collectMemberWorkFeed(root, { limit: 6 });
 
   const standup = cards.map((c) => {
@@ -11805,22 +11016,36 @@ function standupTableData(standup, cwd = process.cwd()) {
 // (member, role, ovr, engine, status) with each member's found and push
 // lines under it; piped, or when the box cannot fit, the boxes it always had.
 function memberStandupLines(standup, { bordered = false, width = process.stdout.columns, cells = null } = {}) {
-  if (bordered && cells && standup.length) {
-    const table = require('../lib/gm-bet').teamBox(standup.map((s) => ({ member: s.member, status: s.status })), cells, { width: Number(width) - 2 });
+  const ordered = [
+    ...standup.filter((s) => isBusyStandupStatus(s.status)),
+    ...standup.filter((s) => !isBusyStandupStatus(s.status)),
+  ];
+  if (bordered && cells && ordered.length) {
+    const table = require('../lib/gm-bet').teamBox(ordered.map((s) => ({ member: s.member, status: s.status })), cells, { width: Number(width) - 2 });
     if (table) {
       return [
         ...table.split('\n').map((line) => `  ${line}`),
-        ...standup.flatMap((s) => [`  ${s.member}`, `    found: ${s.latest_update}`, `    push:  ${s.next_push}`]),
+        ...ordered.flatMap((s) => (
+          isBusyStandupStatus(s.status)
+            ? [`  ${s.member}`, `    found: ${s.latest_update}`, `    push:  ${s.next_push}`]
+            : [`  ${s.member} · ${s.status} · engine:${s.engine} · ${s.latest_update}`]
+        )),
       ];
     }
   }
-  return standup.flatMap((s, idx) => [
-    `+-----------------------------------------------------------------------+`,
-    `| ${idx + 1}. ${s.member.toUpperCase()} (${s.role}) · ${s.status} · engine:${s.engine}`,
-    `|    Found:   ${s.latest_update}`,
-    `|    Push:    ${s.next_push}`,
-    `+-----------------------------------------------------------------------+`,
-  ]);
+  return ordered.flatMap((s, idx) => (
+    isBusyStandupStatus(s.status)
+      ? [
+          `+-----------------------------------------------------------------------+`,
+          `| ${idx + 1}. ${s.member.toUpperCase()} (${s.role}) · ${s.status} · engine:${s.engine}`,
+          `|    Found:   ${s.latest_update}`,
+          `|    Push:    ${s.next_push}`,
+          `+-----------------------------------------------------------------------+`,
+        ]
+      : [
+          `  ${idx + 1}. ${s.member} (${s.role}) · ${s.status} · engine:${s.engine} · ${s.latest_update}`,
+        ]
+  ));
 }
 
 async function memberRoom(...args) {
@@ -11843,7 +11068,7 @@ async function memberRoom(...args) {
 
   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.'];
+    : ['  - No handoffs waiting right now.'];
 
   const oneOnOneRows = room.one_on_ones.length
     ? room.one_on_ones.map((o) => `  - ${o.member}: ${o.reason} -> ${o.command}`)
@@ -11860,13 +11085,13 @@ async function memberRoom(...args) {
     '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>"`):',
+    '2. Who is handing work to whom (`atris member handoff <from> <to> "<slice>"`):',
     ...handoffRows,
     '',
     '3. Your 1-on-1s Today (`atris member 1on1 <name>`):',
     ...oneOnOneRows,
     '',
-    'Live Consequence Feed:',
+    'What happened lately:',
     ...feedRows,
     '',
     'Controls: atris member standup --walk | atris member go | atris member "<prompt>" | atris member 1on1 <name> | atris member sleep',
@@ -12192,6 +11417,4 @@ module.exports = {
   memberRunSaveDecision,
   buildMemberSubagentShell,
   pickMemberForIdea,
-  appendMemberGoalLog,
-  appendProjectLog,
 };