atris 3.32.0 → 3.34.0

package/commands/loops.js

@@ -0,0 +1,212 @@
+/**
+ * atris loops - one view of every background loop: what runs, what died,
+ * what you can start or stop.
+ *
+ *   atris loops              - the board (registry jobs, launchd agents, missions)
+ *   atris loops stop <id>    - disable a registry job or boot out a launchd agent
+ *   atris loops start <id>   - enable a registry job or kickstart a launchd agent
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+function heartbeatDir() {
+  return process.env.ATRIS_HEARTBEAT_DIR || path.join(os.homedir(), '.atris', 'heartbeat');
+}
+
+function readJson(filePath, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function registryPath() {
+  return path.join(heartbeatDir(), 'registry.json');
+}
+
+function loadRegistry() {
+  const registry = readJson(registryPath(), null);
+  return registry && Array.isArray(registry.jobs) ? registry : { jobs: [] };
+}
+
+function loadRunState() {
+  return readJson(path.join(heartbeatDir(), 'state.json'), {});
+}
+
+function agoText(iso) {
+  const then = Date.parse(iso || '');
+  if (!Number.isFinite(then)) return 'never';
+  const mins = Math.max(0, Math.round((Date.now() - then) / 60000));
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 48) return `${hours}h ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}
+
+function listLaunchdAgents() {
+  let raw = '';
+  try {
+    raw = execSync('launchctl list', { encoding: 'utf8', timeout: 10000 });
+  } catch {
+    return [];
+  }
+  return raw
+    .split('\n')
+    .filter(line => line.includes('com.atris.'))
+    .map(line => {
+      const [pid, exitCode, label] = line.trim().split(/\s+/);
+      return {
+        label,
+        running: pid !== '-',
+        pid: pid !== '-' ? pid : null,
+        lastExit: exitCode,
+      };
+    })
+    .filter(agent => agent.label);
+}
+
+function workspaceMission(cwd) {
+  const goalState = readJson(path.join(cwd, '.atris', 'state', 'atris_goal.json'), null);
+  const goal = goalState && goalState.goal;
+  if (!goal || !goal.objective) return null;
+  const started = Date.parse(goal.created_at || '');
+  const elapsedMins = Number.isFinite(started) ? Math.round((Date.now() - started) / 60000) : null;
+  return {
+    id: goal.mission_id || '?',
+    status: goal.mission_status || '?',
+    objective: String(goal.objective),
+    elapsedMins,
+  };
+}
+
+function showBoard(cwd) {
+  const registry = loadRegistry();
+  const state = loadRunState();
+
+  console.log('background loops');
+  console.log('');
+
+  const enabled = registry.jobs.filter(job => job.enabled !== false && job.disabled !== true);
+  const disabledCount = registry.jobs.length - enabled.length;
+  console.log(`heartbeat registry (${enabled.length} live, ${disabledCount} retired)`);
+  if (!enabled.length) {
+    console.log('  none declared');
+  }
+  for (const job of enabled) {
+    const run = state[job.id] || {};
+    const fails = Number(run.consecutive_fails || 0);
+    const health = fails > 2 ? `${fails} consecutive fails` : fails > 0 ? `${fails} recent fail${fails === 1 ? '' : 's'}` : 'healthy';
+    const cadence = job.cadence_minutes >= 60 ? `${Math.round(job.cadence_minutes / 60)}h` : `${job.cadence_minutes}m`;
+    console.log(`  ${String(job.id).padEnd(22)} every ${String(cadence).padEnd(5)} last ${agoText(run.last_run).padEnd(9)} ${health}`);
+    console.log(`  ${''.padEnd(22)} ${String(job.purpose || '').slice(0, 84)}`);
+  }
+  console.log('');
+
+  const agents = listLaunchdAgents();
+  console.log(`launchd agents (${agents.length})`);
+  for (const agent of agents) {
+    const status = agent.running ? `running pid ${agent.pid}` : `loaded, last exit ${agent.lastExit}`;
+    console.log(`  ${agent.label.padEnd(44)} ${status}`);
+  }
+  if (!agents.length) console.log('  none');
+  console.log('');
+
+  const mission = workspaceMission(cwd);
+  console.log('mission (this workspace)');
+  if (mission) {
+    const elapsed = mission.elapsedMins === null ? '' : ` · ${mission.elapsedMins}m in`;
+    console.log(`  ${mission.id}`);
+    console.log(`  ${mission.status}${elapsed} · ${mission.objective.slice(0, 80)}`);
+  } else {
+    console.log('  none active');
+  }
+  console.log('');
+  console.log('control: atris loops stop <id> · atris loops start <id>');
+  console.log('ids: registry job id, or a com.atris.* launchd label');
+}
+
+function saveRegistry(registry) {
+  const target = registryPath();
+  fs.copyFileSync(target, `${target}.bak`);
+  fs.writeFileSync(target, `${JSON.stringify(registry, null, 2)}\n`);
+}
+
+function setRegistryJob(id, enabled) {
+  const registry = loadRegistry();
+  const job = registry.jobs.find(row => row.id === id);
+  if (!job) return false;
+  job.enabled = enabled;
+  if (enabled) {
+    delete job.disabled;
+    delete job.disabled_reason;
+  } else {
+    job.disabled = true;
+    job.disabled_reason = `stopped via atris loops ${new Date().toISOString().slice(0, 10)}`;
+  }
+  saveRegistry(registry);
+  return true;
+}
+
+function launchdControl(label, action) {
+  const uid = process.getuid();
+  if (action === 'stop') {
+    const result = spawnSync('launchctl', ['bootout', `gui/${uid}/${label}`], { encoding: 'utf8' });
+    return result.status === 0;
+  }
+  const plist = path.join(os.homedir(), 'Library', 'LaunchAgents', `${label}.plist`);
+  if (!fs.existsSync(plist)) return false;
+  const bootstrap = spawnSync('launchctl', ['bootstrap', `gui/${uid}`, plist], { encoding: 'utf8' });
+  if (bootstrap.status === 0) return true;
+  const kick = spawnSync('launchctl', ['kickstart', '-k', `gui/${uid}/${label}`], { encoding: 'utf8' });
+  return kick.status === 0;
+}
+
+function controlLoop(id, action) {
+  const target = String(id || '').trim();
+  if (!target) {
+    console.error(`Usage: atris loops ${action} <id>`);
+    process.exit(1);
+  }
+  if (target.startsWith('com.atris.')) {
+    const ok = launchdControl(target, action);
+    if (!ok) {
+      console.error(`Could not ${action} ${target}. Check: launchctl print gui/$(id -u)/${target}`);
+      process.exit(1);
+    }
+    console.log(`${action === 'stop' ? 'Stopped' : 'Started'} ${target}.`);
+    return;
+  }
+  const ok = setRegistryJob(target, action === 'start');
+  if (!ok) {
+    console.error(`No registry job named "${target}". Run: atris loops`);
+    process.exit(1);
+  }
+  console.log(`${action === 'stop' ? 'Disabled' : 'Enabled'} ${target} in the heartbeat registry (backup written).`);
+}
+
+function loopsCommand(subcommand, ...args) {
+  switch (subcommand) {
+    case undefined:
+    case 'board':
+    case 'list':
+      showBoard(process.cwd());
+      break;
+    case 'stop':
+      controlLoop(args[0], 'stop');
+      break;
+    case 'start':
+      controlLoop(args[0], 'start');
+      break;
+    default:
+      console.log('Loop commands:');
+      console.log('  atris loops              - board: registry jobs, launchd agents, mission');
+      console.log('  atris loops stop <id>    - disable a registry job or stop a launchd agent');
+      console.log('  atris loops start <id>   - enable a registry job or start a launchd agent');
+  }
+}
+
+module.exports = { loopsCommand, showBoard };

package/commands/member.js

@@ -611,16 +611,48 @@ function startMemberRunMission(name, missionText, args = []) {
   }
 }
 
-// atris member ping <name> "<message>" — talk to an always-on member mid-run.
-// Finds the member's most recently touched live mission (including --worktree
-// missions in sibling checkouts) and leaves the note its next tick consumes.
+// atris member ping <name> "<message>" — talk to a busy member mid-run.
+// Two delivery lanes: the member's most recently touched live mission
+// (including --worktree missions in sibling checkouts), whose next tick
+// consumes the note, and the member's claimed task dialogue, which task-loop
+// agents re-read every step without ever ticking a mission. The ping lands on
+// every lane that exists and errors only when neither does.
+function pingClaimedTaskDialogue(name, text, from) {
+  let taskDb;
+  try {
+    taskDb = require('../lib/task-db');
+  } catch {
+    return null;
+  }
+  try {
+    const db = taskDb.open();
+    const local = taskDb.listTasks(db, { workspaceRoot: taskDb.workspaceRoot(), status: 'claimed', claimedBy: name });
+    const pool = local.length ? local : taskDb.listTasks(db, { status: 'claimed', claimedBy: name });
+    if (!pool.length) return null;
+    const task = [...pool].sort((a, b) => Number(b.updated_at || 0) - Number(a.updated_at || 0))[0];
+    const result = taskDb.noteTask(db, { id: task.id, actor: from, content: text });
+    if (!result.noted) return null;
+    return { task_id: task.id, title: task.title };
+  } catch {
+    return null;
+  }
+}
+
 function memberPing(name, ...args) {
   if (!name || name === '--help' || name === '-h') {
-    console.log('Usage: atris member ping <name> "<message>" [--json]');
-    console.log('Leaves a note on the member\'s active mission; the next tick reads it as operator direction.');
+    console.log('Usage: atris member ping <name> "<message>" [--from <who>] [--json]');
+    console.log('Leaves the note on the member\'s active mission and claimed task dialogue; whichever loop the member runs reads it next.');
     return;
   }
-  const text = args.filter((a) => !a.startsWith('--')).join(' ').trim();
+  const asJson = args.includes('--json');
+  const rest = args.filter((a) => a !== '--json');
+  let from = process.env.USER || 'operator';
+  const fromIdx = rest.indexOf('--from');
+  if (fromIdx !== -1) {
+    from = rest[fromIdx + 1] || from;
+    rest.splice(fromIdx, 2);
+  }
+  const text = rest.filter((a) => !a.startsWith('--')).join(' ').trim();
   if (!text) {
     console.error('atris member ping: message required');
     process.exit(2);
@@ -633,12 +665,33 @@ function memberPing(name, ...args) {
   ]
     .filter((m) => m && m.owner === name && !terminal.has(m.status))
     .sort((a, b) => String(b.updated_at || b.created_at || '').localeCompare(String(a.updated_at || a.created_at || '')));
-  if (!candidates.length) {
-    console.error(`atris member ping: no live mission owned by "${name}". Start one: atris member run ${name} "<objective>"`);
+
+  const taskNote = pingClaimedTaskDialogue(name, text, from);
+
+  if (!candidates.length && !taskNote) {
+    console.error(`atris member ping: no live mission or claimed task for "${name}". Start one: atris member run ${name} "<objective>"`);
     process.exit(1);
   }
-  const passthrough = args.filter((a) => a.startsWith('--'));
-  return missionMod.pingMission([candidates[0].id, text, ...passthrough]);
+
+  const mission = candidates.length
+    ? missionMod.pingMission([candidates[0].id, text, '--from', from], { silent: true })
+    : null;
+  const pendingPings = mission ? (mission.pings || []).filter((p) => p && !p.consumed_at).length : null;
+
+  if (asJson) {
+    console.log(JSON.stringify({
+      ok: true,
+      action: 'member_ping',
+      member: name,
+      mission_id: mission ? mission.id : null,
+      pending_pings: pendingPings,
+      task_id: taskNote ? taskNote.task_id : null,
+    }));
+  } else {
+    if (mission) console.log(`pinged ${mission.id} — the next tick reads it (${pendingPings} unread).`);
+    if (taskNote) console.log(`pinged task ${taskNote.task_id} dialogue — ${name} reads it on the next step.`);
+  }
+  return { mission, task_note: taskNote };
 }
 
 function memberRun(name, ...args) {

package/commands/mission.js

@@ -30,6 +30,15 @@ const {
   formatBytes,
 } = require('../lib/runs-prune');
 const { operatorReady, hasAgentJargon } = require('./autoland');
+const {
+  MISSION_INSPECT_FIELDS,
+  readFieldsFlag,
+  stripInspectArgs,
+  validateFields,
+  missionInspectFieldValues,
+  inspectTextLines,
+  buildInspectPayload,
+} = require('../lib/inspect-fields');
 
 const VALID_STATUSES = new Set(['planning', 'running', 'ready', 'paused', 'blocked', 'stopped', 'complete']);
 const TERMINAL_STATUSES = new Set(['stopped', 'complete']);
@@ -194,6 +203,7 @@ function printJsonOrText(payload, lines, asJson) {
 }
 
 const MISSION_RUN_VALUE_FLAGS = [
+  '--slots',
   '--max-ticks',
   '--max-wall',
   '--minutes',
@@ -213,6 +223,8 @@ const MISSION_RUN_VALUE_FLAGS = [
 const MISSION_RUN_BOOLEAN_FLAGS = [
   '--json',
   '--due',
+  '--fleet',
+  '--dry-run',
   '--no-claude',
   '--no-verify',
   '--complete-on-pass',
@@ -227,6 +239,7 @@ const MISSION_RUN_BOOLEAN_FLAGS = [
   '--no-room-auto-run',
   '--allow-native-goal-supersede',
   '--supersede-paused-native-goal',
+  '--take-goal-slot',
   '--always-on',
   '--xp-task',
   '--agent-xp',
@@ -1619,7 +1632,7 @@ function missionFromArgs(args) {
     '--native-goal-objective',
     '--visible-goal-status',
     '--visible-goal-objective',
-  ], ['--json', '--always-on', '--xp-task', '--agent-xp', '--worktree', '--spend-full-budget', '--use-whole-budget', '--stop-when-done', '--allow-native-goal-supersede', '--supersede-paused-native-goal']).join(' ').trim();
+  ], ['--json', '--always-on', '--xp-task', '--agent-xp', '--worktree', '--duplicate', '--spend-full-budget', '--use-whole-budget', '--stop-when-done', '--allow-native-goal-supersede', '--supersede-paused-native-goal', '--take-goal-slot']).join(' ').trim();
   if (!objective) {
     exitMissionError('Usage: atris mission start "<objective>" --owner <member> [--verify "..."] [--cadence manual] [--worktree]', 1, wantsJson(args));
   }
@@ -2765,9 +2778,53 @@ function inheritedWorktreeBase(cwd) {
   }
 }
 
+// Dedup gate: the same objective + owner already active anywhere in the
+// workspace family (this store or any worktree's) is reused, never cloned.
+// Born 2026-07-02: an hourly alive loop spawned six identical auto-improver
+// missions in six fresh worktrees in one day — pure token burn. --duplicate
+// is the explicit escape hatch.
+const TWIN_ACTIVE_STATUSES = new Set(['planning', 'ready', 'running']);
+
+function normalizedObjective(text) {
+  return String(text || '').toLowerCase().replace(/\s+/g, ' ').trim();
+}
+
+function findActiveTwinMission(objective, owner, root = process.cwd()) {
+  const wantObjective = normalizedObjective(objective);
+  const wantOwner = String(owner || '').trim().toLowerCase();
+  if (!wantObjective) return null;
+  const candidates = [
+    ...listMissions(root),
+    ...listWorktreeRollupMissions(root),
+  ];
+  for (const m of candidates) {
+    if (!m || !TWIN_ACTIVE_STATUSES.has(m.status)) continue;
+    if (normalizedObjective(m.objective) !== wantObjective) continue;
+    if (String(m.owner || '').trim().toLowerCase() !== wantOwner) continue;
+    return m;
+  }
+  return null;
+}
+
 function startMission(args) {
   const asJson = wantsJson(args);
   const mission = missionFromArgs(args);
+  if (!hasFlag(args, '--duplicate')) {
+    const twin = findActiveTwinMission(mission.objective, mission.owner);
+    if (twin) {
+      printJsonOrText(
+        { ok: true, action: 'mission_reused', reused: true, mission: twin, note: 'an active mission with this objective and owner already exists; resumed instead of cloning (pass --duplicate to force a second one)' },
+        [
+          `Already active: ${twin.id} (${twin.status})`,
+          `Same objective, same owner — reusing it instead of starting a clone.`,
+          `Resume: atris mission run ${twin.id}`,
+          `Really want a second one: re-run with --duplicate`,
+        ],
+        asJson,
+      );
+      return;
+    }
+  }
   // --worktree: bind the mission to its own isolated checkout. We chdir before
   // any state writes so the mission record, baseline sidecar, receipts, and
   // member files all land inside the worktree — ticks run there, and the main
@@ -2795,6 +2852,9 @@ function startMission(args) {
   const warnings = [missingVerifierWarning(mission)].filter(Boolean);
   ensureMemberMissionFile(mission.owner, process.cwd(), mission.objective);
   const { mission: saved } = saveMission(mission, process.cwd(), 'mission_started', { objective: mission.objective });
+  const goalSlotHandoff = hasFlag(args, '--take-goal-slot') && isCodexGoalMission(saved)
+    ? takeCodexGoalSlotForMission(saved, process.cwd())
+    : null;
   const memberState = renderMemberMissionState(saved.owner);
   const logPath = appendMemberLog(saved.owner, 'Mission started', {
     mission: saved.objective,
@@ -2805,7 +2865,7 @@ function startMission(args) {
   });
   const worktreeBaseline = captureMissionWorktreeBaseline(saved, process.cwd());
   printJsonOrText(
-    { ok: true, action: 'mission_started', mission: saved, warnings, state_path: statePaths().missionsJsonl, member_state: memberState, log_path: logPath, worktree_baseline: worktreeBaseline ? { path: path.relative(process.cwd(), missionBaselinePath(saved.id)), dirty_count: worktreeBaseline.dirty_count, dirty_hash: worktreeBaseline.dirty_hash } : null },
+    { ok: true, action: 'mission_started', mission: saved, warnings, goal_slot_handoff: goalSlotHandoff, state_path: statePaths().missionsJsonl, member_state: memberState, log_path: logPath, worktree_baseline: worktreeBaseline ? { path: path.relative(process.cwd(), missionBaselinePath(saved.id)), dirty_count: worktreeBaseline.dirty_count, dirty_hash: worktreeBaseline.dirty_hash } : null },
     [
       `Started mission: ${saved.objective}`,
       `Owner: ${saved.owner}`,
@@ -2920,6 +2980,9 @@ function startMissionFromRunObjective(objective, args) {
     ...(nativeGoalObjective ? { nativeGoalObjective } : {}),
     ...(hasFlag(args, '--allow-native-goal-supersede') || hasFlag(args, '--supersede-paused-native-goal') ? { allowNativeGoalSupersede: true } : {}),
   };
+  const goalSlotHandoff = hasFlag(args, '--take-goal-slot') && isCodexGoalMission(saved)
+    ? takeCodexGoalSlotForMission(saved, process.cwd(), nativeGoalOptions)
+    : null;
   const atrisGoalState = refreshAtrisGoalController(process.cwd(), { missionId: saved.id });
   const codexGoalState = runnerUsesCallerSession(saved.runner)
     ? refreshCodexGoalController(process.cwd(), { missionId: saved.id, ...nativeGoalOptions })
@@ -2944,6 +3007,7 @@ function startMissionFromRunObjective(objective, args) {
       } : null,
       completed_continuation_goal: completedContinuationGoal,
       direct_goal_request: directGoalRequest,
+      goal_slot_handoff: goalSlotHandoff,
       atris_goal_state: atrisGoalState,
       codex_goal_state: codexGoalState,
       requires_native_goal_start: codexGoalState?.requires_native_goal_start === true || codexGoalState?.goal?.requires_native_goal_start === true,
@@ -4611,11 +4675,11 @@ function codexGoalObjective(mission) {
   return mission.objective;
 }
 
-function codexNativeGoalAck(mission, objective = codexGoalObjective(mission)) {
+function codexNativeGoalAck(mission) {
   const ack = mission?.native_goal_ack || null;
   if (!ack || String(ack.runtime || '').toLowerCase() !== 'codex') return null;
   if (ack.status !== 'active') return null;
-  if (String(ack.objective || '') !== String(objective || '')) return null;
+  if (ack.mission_id && String(ack.mission_id) !== String(mission?.id || '')) return null;
   return ack;
 }
 
@@ -4821,6 +4885,33 @@ function activeCodexVisibleGoalOwner(root = process.cwd(), excludeId = '', now =
   return candidates[0] || null;
 }
 
+function pauseMissionRecord(mission, reason, root = process.cwd()) {
+  const next = {
+    ...mission,
+    status: 'paused',
+    paused_at: stampIso(),
+    stop_reason: reason,
+    next_action: `resume with: atris mission tick ${mission.id}`,
+  };
+  const { mission: saved } = saveMission(next, root, 'mission_paused', { reason, source: 'goal_slot_handoff' });
+  appendMemberLog(saved.owner, 'Mission paused', { mission: saved.objective, reason });
+  return saved;
+}
+
+function takeCodexGoalSlotForMission(newMission, root = process.cwd(), options = {}) {
+  if (!newMission || !isCodexGoalMission(newMission)) return null;
+  const runtimeGoalState = codexRuntimeGoalStateFromOptions(options);
+  const activeOwner = activeCodexVisibleGoalOwner(root, newMission.id, new Date(), runtimeGoalState);
+  if (!activeOwner) return null;
+  const reason = `visible goal replaced by ${newMission.id}`;
+  const paused = pauseMissionRecord(activeOwner, reason, root);
+  return {
+    paused_mission_id: paused.id,
+    paused_mission: missionStatusView(paused),
+    reason,
+  };
+}
+
 function codexGoalActiveConflictPayload(newMission, activeMission, request = null, heartbeatMode = false, runtimeGoalState = null) {
   const newObjective = codexGoalObjective(newMission);
   const pausedConflict = runtimeGoalState?.status === 'paused';
@@ -5119,7 +5210,7 @@ function buildCodexGoalPayload(root = process.cwd(), options = {}) {
   const taskSpine = missionTaskSpine(mission);
   const missionView = missionStatusView(mission);
   const objective = codexGoalObjective(mission);
-  const ack = codexNativeGoalAck(mission, objective);
+  const ack = codexNativeGoalAck(mission);
   const runtimeNeedsReplace = !ack && codexRuntimeGoalNeedsReplace(runtimeGoalState, objective);
   const nativeGoalAction = ack
     ? null
@@ -5777,6 +5868,21 @@ async function runMission(args) {
     help();
     return;
   }
+  // --fleet: staff every idle capable engine on the board's claimable
+  // safe-lane tasks, build in parallel worktrees, land serially. Humble flag,
+  // full loop — see lib/fleet.js. --dry-run previews the staffing only.
+  if (hasFlag(args, '--fleet')) {
+    const { runFleetFlight } = require('../lib/fleet');
+    const slots = Math.max(1, Number(readFlag(args, '--slots', '')) || 3);
+    const flight = await runFleetFlight({
+      slots,
+      dryRun: hasFlag(args, '--dry-run'),
+      log: asJson ? () => {} : console.log,
+    });
+    if (asJson) console.log(JSON.stringify(flight, null, 2));
+    process.exitCode = flight.paused && flight.paused.length > 0 ? 1 : 0;
+    return;
+  }
   const dueMode = hasFlag(args, '--due');
   const skipClaude = hasFlag(args, '--no-claude');
   const verifyEach = !hasFlag(args, '--no-verify');
@@ -6723,16 +6829,15 @@ function ackMissionGoal(args) {
       releaseMissionLock(lock);
       exitMissionError(`Mission "${ref}" uses runner=${mission.runner || 'manual'}; native Codex goal ack is only for runner=codex_goal.`, 2, asJson);
     }
-    const expectedObjective = codexGoalObjective(mission);
-    const objective = readFlag(args, '--objective', expectedObjective);
-    if (objective !== expectedObjective) {
-      releaseMissionLock(lock);
-      exitMissionError(`Native goal objective mismatch. Expected: ${expectedObjective}`, 2, asJson);
-    }
+    const canonicalObjective = codexGoalObjective(mission);
+    const reportedObjective = readFlag(args, '--objective', canonicalObjective);
+    const objective = canonicalObjective;
     const ack = {
       runtime: 'codex',
       status: 'active',
+      mission_id: mission.id,
       objective,
+      ...(reportedObjective && reportedObjective !== objective ? { reported_objective: reportedObjective } : {}),
       acknowledged_at: stampIso(),
     };
     const nextMission = {
@@ -6848,13 +6953,15 @@ function help() {
   console.log(`
 atris mission - durable goal + loop + owner + proof state
 
-  atris mission start "<objective>" --owner <member> [--verify "..."] [--always-on] [--xp-task] [--worktree]
+  atris mission start "<objective>" --owner <member> [--verify "..."] [--always-on] [--xp-task] [--worktree] [--take-goal-slot]
                       [--runner manual|claude|atris2|codex_goal] [--model <id>]
                       (runner claude spawns local claude -p per tick, --model passes through;
                        runner atris2 runs each tick as one /atris2/turn on the AtrisOS backend,
                        default model atris:fast; runner codex_goal publishes the goal for a live
                        Codex session to pull via atris mission goal)
   atris mission status [id] [--status <state>] [--limit <n>] [--local] [--json]
+  atris mission inspect <id> --fields status,runner,ack,pings [--json]
+                       Field-selectable mission state (status, runner, native goal ack, ping counts)
   atris mission doctor [--local] [--json]   Flag no-verifier missions, help missions, stale ready receipts, and blocked always-on loops
   atris mission attach-task <id> [--json]   Create the missing task spine for an existing active mission
   atris mission report [id] [--limit <n>] [--local] [--json]   Plain outcome, worker receipt, verifier receipt, and next move
@@ -6869,8 +6976,9 @@ atris mission - durable goal + loop + owner + proof state
   atris mission goal-loop [--max-wall 28800] [--max-iterations 32] [--no-claude] [--json]
   atris mission tick <id> [--verify ["cmd"]] [--complete-on-pass] [--summary "..."] [--json]
   atris mission "<objective>" [--owner <member>]   Shortcut for: atris mission run "<objective>"
+  atris mission run --fleet [--slots 3] [--dry-run] [--json]   Staff every idle capable engine on claimable safe-lane tasks: parallel worktree builds, serial rebase-before-ship landings, receipt in atris/runs/
   atris mission run ["objective"|<member> ["objective"]|id|--due] [--owner <member>] [--max-ticks 4] [--max-wall 3600] [--cadence "15m"]
-                                [--native-goal-status active|paused] [--native-goal-objective "..."] [--allow-native-goal-supersede]
+                                [--native-goal-status active|paused] [--native-goal-objective "..."] [--allow-native-goal-supersede] [--take-goal-slot]
                                 [--spend-full-budget|--use-whole-budget|--stop-when-done] [--room-preflight|--no-room-preflight]
                                 [--room-auto-run|--no-room-auto-run]
                                 [--no-claude] [--no-verify] [--complete-on-pass] [--no-drain] [--create-next] [--json]
@@ -7149,7 +7257,39 @@ function findMissionAcrossWorktrees(ref, root = process.cwd()) {
 // atris mission ping <id> "<message>" — leave a note the mission's next tick
 // reads (and consumes) as operator direction. This is how you talk to an
 // always-on member mid-run without stopping it.
-function pingMission(args) {
+function inspectMission(args) {
+  const asJson = wantsJson(args);
+  const parsed = readFieldsFlag(args, '--fields');
+  if (!parsed || parsed.error) {
+    exitMissionError(
+      parsed?.error || 'Usage: atris mission inspect <id> --fields status,runner,ack,pings [--json]',
+      2,
+      asJson,
+    );
+  }
+  const fieldError = validateFields(parsed.fields, MISSION_INSPECT_FIELDS, 'mission');
+  if (fieldError) exitMissionError(fieldError, 2, asJson);
+  const ref = stripInspectArgs(args)[0] || '';
+  if (!ref) {
+    exitMissionError('Usage: atris mission inspect <id> --fields status,runner,ack,pings [--json]', 2, asJson);
+  }
+  const found = findMissionAcrossWorktrees(ref);
+  if (!found) exitMissingMission(ref, 1, asJson);
+  const { mission } = found;
+  const values = missionInspectFieldValues(mission, parsed.fields);
+  const payload = buildInspectPayload({
+    action: 'mission_inspect',
+    idKey: 'mission_id',
+    idValue: mission.id,
+    fields: parsed.fields,
+    values,
+  });
+  printJsonOrText(payload, inspectTextLines(parsed.fields, values), asJson);
+}
+
+// always-on member mid-run without stopping it. opts.silent skips console
+// output so callers (member ping) can compose their own multi-lane report.
+function pingMission(args, opts = {}) {
   const asJson = args.includes('--json');
   const rest = args.filter((a) => a !== '--json');
   let from = process.env.USER || 'operator';
@@ -7181,10 +7321,12 @@ function pingMission(args) {
     { from, text: text.slice(0, 200) },
   ).mission;
   const pending = (saved.pings || []).filter((p) => p && !p.consumed_at).length;
-  if (asJson) {
-    console.log(JSON.stringify({ ok: true, action: 'mission_ping', mission_id: saved.id, pending_pings: pending, ping }));
-  } else {
-    console.log(`pinged ${saved.id} — the next tick reads it (${pending} unread).`);
+  if (!opts.silent) {
+    if (asJson) {
+      console.log(JSON.stringify({ ok: true, action: 'mission_ping', mission_id: saved.id, pending_pings: pending, ping }));
+    } else {
+      console.log(`pinged ${saved.id} — the next tick reads it (${pending} unread).`);
+    }
   }
   return saved;
 }
@@ -7235,6 +7377,8 @@ function missionCommand(args) {
       return goalLoopMission(rest);
     case 'ping':
       return pingMission(rest);
+    case 'inspect':
+      return inspectMission(rest);
     case 'tick':
       return tickMission(rest);
     case 'run':
@@ -7257,6 +7401,7 @@ function missionCommand(args) {
 
 module.exports = {
   missionCommand,
+  inspectMission,
   missionHeartbeatLines,
   listMissions,
   listWorktreeRollupMissions,