atris 3.37.1 → 3.40.0

package/commands/play.js

@@ -5,6 +5,7 @@ const os = require('os');
 const fs = require('fs');
 const { spawnSync } = require('child_process');
 const { getSessionProfile, loadCredentials } = require('../utils/auth');
+const { hasFlag: hasExactFlag } = require('../lib/arg-parser');
 
 const AGENTXP_LEADERBOARD_URL = 'https://api.atris.ai/api/agentxp/leaderboard';
 const AGENTXP_GLOBAL_SYNC_RULE = 'Run atris login, then sync. Owner-provided sync tokens are guided-demo fallback only.';
@@ -38,8 +39,9 @@ function flag(args, name) {
   return null;
 }
 
-function hasFlag(args, name) {
-  return args.includes(name) || args.some(arg => arg.startsWith(`${name}=`));
+// This command treats --name=value as flag presence as well as a standalone flag.
+function hasFlagOrValue(args, name) {
+  return hasExactFlag(args, name) || args.some(arg => arg.startsWith(`${name}=`));
 }
 
 function positional(args) {
@@ -284,7 +286,7 @@ function handleSourceLine(state) {
 }
 
 function ensureStarterMission(taskDb, db, workspaceRoot, player, tasks, args = []) {
-  if (hasFlag(args, '--no-seed')) return { tasks, seeded: null };
+  if (hasFlagOrValue(args, '--no-seed')) return { tasks, seeded: null };
   if (selectMission(tasks, player)) return { tasks, seeded: null };
   fs.mkdirSync(path.join(workspaceRoot, 'atris'), { recursive: true });
 
@@ -476,7 +478,7 @@ async function playCommand(...args) {
   }
 
   const state = modeState(args);
-  if (hasFlag(args, '--json')) {
+  if (hasFlagOrValue(args, '--json')) {
     console.log(JSON.stringify(state, null, 2));
     return;
   }
@@ -485,6 +487,4 @@ async function playCommand(...args) {
 
 module.exports = {
   playCommand,
-  modeState,
-  selectMission,
 };

package/commands/probe.js

@@ -26,9 +26,10 @@
 
 const https = require('https');
 const http = require('http');
+const path = require('path');
 const { getApiBaseUrl } = require('../utils/api');
 const { loadCredentials } = require('../utils/auth');
-const { encodeToolResult } = require('../lib/tool-result-encode');
+const { buildToolResultBody } = require('../lib/tool-result-encode');
 
 // G2's honest blocked message (tool_policy_bench.MAX_TURNS_EXHAUSTED_MESSAGE)
 // starts with this — an answer that is only this marker is a dead-end.
@@ -188,10 +189,13 @@ function runTerminal(base, token, command, businessId) {
 // command runs in the mission's OWN workspace directory instead of the hosted
 // ai-computer. Without this, a mission tick in a local workspace read the
 // remote computer's files and reported local members (e.g. maze) as missing.
-function runLocalTerminal(command, cwd) {
+function runLocalTerminal(command, cwd, environment = process.env, pathPrefix = '') {
   const { exec } = require('child_process');
   const { envWithNodeDir } = require('../lib/spawn-env');
-  const env = envWithNodeDir(process.env);
+  const baseEnv = envWithNodeDir(environment);
+  const env = pathPrefix
+    ? { ...baseEnv, PATH: `${pathPrefix}${path.delimiter}${baseEnv.PATH || ''}` }
+    : baseEnv;
   return new Promise((resolve) => {
     exec(command, { cwd, env, timeout: 60000, maxBuffer: 4 * 1024 * 1024, shell: '/bin/bash' }, (error, stdout, stderr) => {
       resolve({
@@ -237,6 +241,8 @@ async function runAtris2Turn(opts = {}) {
     connectTimeoutMs = 60000,
     signal = null,
     localCwd = null,
+    localEnv = null,
+    localPathPrefix = '',
   } = opts;
   const t0 = Date.now();
   const out = { ok: false, text: '', engine: null, tools_run: 0, cli_ops: [], unsupported: [], error: null, duration_ms: 0 };
@@ -322,7 +328,7 @@ async function runAtris2Turn(opts = {}) {
                   unsupported.push(`file_op:${op}`);
                 } else {
                   const term = localCwd
-                    ? await runLocalTerminal(cmd, localCwd)
+                    ? await runLocalTerminal(cmd, localCwd, localEnv || process.env, localPathPrefix)
                     : await runTerminal(base, token, cmd, business);
                   const ok = term.exit_code === 0;
                   out = ok
@@ -341,7 +347,7 @@ async function runAtris2Turn(opts = {}) {
                   unsupported.push(`cli_op:${op || '?'}`);
                 } else {
                   const term = localCwd
-                    ? await runLocalTerminal(cmd, localCwd)
+                    ? await runLocalTerminal(cmd, localCwd, localEnv || process.env, localPathPrefix)
                     : await runTerminal(base, token, cmd, business);
                   out = atrisCliResult(cmd, term);
                   cliOps.push(op || '?');
@@ -351,7 +357,7 @@ async function runAtris2Turn(opts = {}) {
                 unsupported.push(`tool:${name || '?'}`);
               }
               await postJson(`${base}/atris2/turn/tool-result`, token,
-                { call_id: ev.call_id || ev.id, result_base64: encodeToolResult(out) }, 30000);
+                buildToolResultBody(ev.call_id || ev.id, out), 30000);
               resetIdle();
             }).catch((e) => reject(e));
           } else if (et === 'result') {

package/commands/pulse.js

@@ -2,16 +2,16 @@
 
 // `atris pulse` - the durable overnight self-improvement heartbeat for atris-cli.
 //
-//   atris pulse tick      run ONE self-improvement tick (what the cron calls)
+//   atris pulse tick      run ONE self-improvement tick (what launchd calls)
 //   atris pulse status    liveness, reward sum, ghost-tick detection
-//   atris pulse install   write the OS-cron tick script + install the crontab line
-//   atris pulse uninstall remove the crontab line
+//   atris pulse install   write the tick script + install a launchd agent
+//   atris pulse uninstall remove the launchd agent
 //   atris pulse run       run N ticks in the foreground (manual / testing)
 //
 // One tick: lock -> 'started' receipt -> run mission engine -> verify -> write
 // 'finished' receipt (pulse_agi_loop_receipts.jsonl) + reward scorecard
 // (scorecards.jsonl, gated) -> release lock. The whole point is that this fires
-// from an OS cron, so it self-improves overnight without Claude Code open.
+// from launchd, so it self-improves overnight without Claude Code open.
 
 const fs = require('fs');
 const os = require('os');
@@ -19,11 +19,10 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 const pulse = require('../lib/pulse');
 const { DEFAULT_CLAUDE_RUNNER_MODEL } = require('../lib/runner-command');
+const { hasFlag } = require('../lib/arg-parser');
 
-function hasFlag(args, name) {
-  return args.includes(name);
-}
-function readFlag(args, name, fallback = null) {
+// Preserve the existing rule that the next token is a value, even if it is a flag.
+function readFollowingFlag(args, name, fallback = null) {
   const i = args.indexOf(name);
   if (i === -1 || i === args.length - 1) return fallback;
   return args[i + 1];
@@ -41,8 +40,8 @@ Durable overnight self-improvement heartbeat.
 Commands:
   tick        Run one heartbeat tick
   status      Show liveness, reward, and ghost-tick detection
-  install     Install the OS cron heartbeat
-  uninstall   Remove the OS cron heartbeat
+  install     Install the launchd heartbeat
+  uninstall   Remove the launchd heartbeat
   run         Run bounded ticks in the foreground
 
 Options:
@@ -208,7 +207,7 @@ function tickCommand(args, root = process.cwd()) {
   const asJson = wantsJson(args);
   const noClaude = hasFlag(args, '--no-claude');
   const noVerify = hasFlag(args, '--no-verify');
-  const verifyCmd = noVerify ? null : readFlag(args, '--verify', pulse.defaultVerifyCmd(root));
+  const verifyCmd = noVerify ? null : readFollowingFlag(args, '--verify', pulse.defaultVerifyCmd(root));
   const startedAt = Date.now();
 
   // Detect a previous tick that died mid-run before we take the lock.
@@ -298,7 +297,12 @@ function tickCommand(args, root = process.cwd()) {
     }
 
     const elapsedMs = Date.now() - startedAt;
-    const reward = pulse.scoreTick({ verifyPassed: verify.passed, producedWork });
+    const reward = pulse.scoreTick({
+      verifyPassed: verify.passed,
+      producedWork,
+      actorOk: engine.ok,
+      actorReason: engine.reason,
+    });
     const changedTail = committed
       ? ' - committed'
       : (changedFiles.length ? ` - ${changedFiles.length} file(s) changed` : '');
@@ -492,13 +496,21 @@ function statusCommand(args, root = process.cwd(), options = {}) {
   const slot = pulse.resolvePulseSlot(root, options.homeDir ? { homeDir: options.homeDir } : {});
   const receipts = pulse.readPulseReceipts(root);
   const summary = pulse.summarizePulse(receipts);
-  const installed = cronInstalled(slot.markers, options.spawnSync || spawnSync);
+  const label = `com.atris.pulse.${slot.marker.toLowerCase().replace(/^atris_pulse_/, '').replace(/[^a-z0-9]+/g, '-')}`;
+  const homeDir = options.homeDir || os.homedir();
+  const plistPath = path.join(homeDir, 'Library', 'LaunchAgents', `${label}.plist`);
+  const legacyCronInstalled = cronInstalled(slot.markers, options.spawnSync || spawnSync);
+  const installed = fs.existsSync(plistPath) || legacyCronInstalled;
   const expiryBreadcrumb = installed ? null : readPulseExpiryBreadcrumb(root);
   const writeOutput = options.writeOutput || ((text) => process.stdout.write(text));
   const out = {
     ok: true,
     action: 'pulse_status',
     cron_installed: installed,
+    launchd_installed: fs.existsSync(plistPath),
+    legacy_cron_installed: legacyCronInstalled,
+    label,
+    plist_path: plistPath,
     expiry_breadcrumb: expiryBreadcrumb,
     state_home: slot.activeStateHome,
     marker: slot.activeMarker,
@@ -509,7 +521,7 @@ function statusCommand(args, root = process.cwd(), options = {}) {
   };
   if (!asJson) {
     writeOutput([
-      `pulse: ${installed ? 'cron installed' : 'cron not installed (run: atris pulse install)'}`,
+      `pulse: ${installed ? 'scheduler installed' : 'scheduler not installed (run: atris pulse install)'}`,
       expiryBreadcrumb ? `heartbeat expired on ${expiryBreadcrumb.expired_at}; renew with: ${expiryBreadcrumb.renew_command}` : '',
       `state home: ${slot.activeStateHome} marker: ${slot.activeMarker}`,
       `ticks: ${summary.total_ticks} | reward: ${summary.reward_sum} | verify pass/fail: ${summary.verify_pass}/${summary.verify_fail}`,
@@ -564,7 +576,7 @@ function installCommand(args, root = process.cwd(), options = {}) {
   const commandSpawn = options.spawnSync || spawnSync;
   const writeOutput = options.writeOutput || ((text) => process.stdout.write(text));
   const slot = pulse.resolvePulseSlot(root, options.homeDir ? { homeDir: options.homeDir } : {});
-  const cadenceInput = readFlag(args, '--cadence', pulse.DEFAULT_CADENCE_CRON);
+  const cadenceInput = readFollowingFlag(args, '--cadence', pulse.DEFAULT_CADENCE_CRON);
   let cron;
   try {
     cron = pulse.normalizeCronCadence(cadenceInput);
@@ -582,8 +594,8 @@ function installCommand(args, root = process.cwd(), options = {}) {
   let expiry;
   try {
     expiry = pulse.normalizeExpiryDuration({
-      hours: readFlag(args, '--hours', null),
-      days: readFlag(args, '--days', '7'),
+      hours: readFollowingFlag(args, '--hours', null),
+      days: readFollowingFlag(args, '--days', '7'),
     });
   } catch (error) {
     const out = {
@@ -591,23 +603,27 @@ function installCommand(args, root = process.cwd(), options = {}) {
       action: 'pulse_install',
       reason: 'invalid_expiry',
       detail: error && error.message ? error.message : String(error),
-      hours: readFlag(args, '--hours', null),
-      days: readFlag(args, '--days', '7'),
+      hours: readFollowingFlag(args, '--hours', null),
+      days: readFollowingFlag(args, '--days', '7'),
     };
     if (!asJson) process.stdout.write(`pulse install failed: ${out.detail}\n`);
     return emit(out, asJson);
   }
-  const verifyCmd = readFlag(args, '--verify', pulse.defaultVerifyCmd(root));
-  const model = readFlag(args, '--model', process.env.ATRIS_RUNNER_MODEL || process.env.ATRIS_CLAUDE_MODEL || DEFAULT_CLAUDE_RUNNER_MODEL);
-  const runnerProfile = readFlag(args, '--runner-profile', process.env.ATRIS_RUNNER_PROFILE || '');
-  const runnerBin = readFlag(args, '--runner-bin', process.env.ATRIS_RUNNER_BIN || process.env.ATRIS_CLAUDE_BIN || '');
-  const runnerCommandTemplate = readFlag(args, '--runner-template', process.env.ATRIS_RUNNER_COMMAND_TEMPLATE || process.env.ATRIS_CLAUDE_COMMAND_TEMPLATE || '');
+  const verifyCmd = readFollowingFlag(args, '--verify', pulse.defaultVerifyCmd(root));
+  const model = readFollowingFlag(args, '--model', process.env.ATRIS_RUNNER_MODEL || process.env.ATRIS_CLAUDE_MODEL || DEFAULT_CLAUDE_RUNNER_MODEL);
+  const runnerProfile = readFollowingFlag(args, '--runner-profile', process.env.ATRIS_RUNNER_PROFILE || '');
+  const runnerBin = readFollowingFlag(args, '--runner-bin', process.env.ATRIS_RUNNER_BIN || process.env.ATRIS_CLAUDE_BIN || '');
+  const runnerCommandTemplate = readFollowingFlag(args, '--runner-template', process.env.ATRIS_RUNNER_COMMAND_TEMPLATE || process.env.ATRIS_CLAUDE_COMMAND_TEMPLATE || '');
   const deadlineEpoch = Math.floor(Date.now() / 1000) + expiry.seconds;
 
   fs.mkdirSync(slot.stateHome, { recursive: true });
   const scriptPath = path.join(slot.stateHome, 'tick.sh');
-  // Resolve the real bin dirs the engine spawns by bare name, so cron's minimal
-  // PATH doesn't silently break the worker spawn (claude lives in ~/.local/bin).
+  const label = `com.atris.pulse.${slot.marker.toLowerCase().replace(/^atris_pulse_/, '').replace(/[^a-z0-9]+/g, '-')}`;
+  const homeDir = options.homeDir || os.homedir();
+  const launchAgentsDir = path.join(homeDir, 'Library', 'LaunchAgents');
+  const plistPath = path.join(launchAgentsDir, `${label}.plist`);
+  // Resolve the real bin dirs the engine spawns by bare name, so launchd's
+  // minimal PATH doesn't break the worker spawn (claude lives in ~/.local/bin).
   const pathDirs = resolveEngineBinDirs([runnerBin], commandSpawn);
   const script = pulse.buildTickScript({
     root,
@@ -621,18 +637,26 @@ function installCommand(args, root = process.cwd(), options = {}) {
     runnerCommandTemplate,
     verifyCmd,
     pathDirs,
+    launchLabel: label,
+    launchPlistPath: plistPath,
   });
   fs.writeFileSync(scriptPath, script, { mode: 0o755 });
 
-  const line = pulse.buildCrontabLine({ cron, scriptPath, marker: slot.marker });
-  // Append our line to the existing crontab. Strip this repo's new marker and,
-  // when the legacy tick.sh belongs to this root, strip the old single-slot marker too.
+  fs.mkdirSync(path.join(slot.stateHome, 'logs'), { recursive: true });
+  fs.mkdirSync(launchAgentsDir, { recursive: true });
+  fs.writeFileSync(plistPath, pulse.buildLaunchAgentPlist({ label, scriptPath, cron, stateHome: slot.stateHome }), 'utf8');
+
+  // Strip old cron entries while migrating existing installations.
   const existing = commandSpawn('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
   const prior = existing.status === 0 ? String(existing.stdout || '') : '';
   const cleaned = stripMarkedCrontabLines(prior, slot.markers);
-  const next = `${cleaned ? cleaned + '\n' : ''}${line}\n`;
-  const apply = commandSpawn('crontab', ['-'], { input: next, encoding: 'utf8', timeout: 10000 });
+  const legacyHad = slot.markers.some((marker) => prior.includes(marker));
+  if (existing.status === 0 && legacyHad) commandSpawn('crontab', ['-'], { input: cleaned ? `${cleaned}\n` : '', encoding: 'utf8', timeout: 10000 });
+  const uid = options.uid != null ? options.uid : process.getuid();
+  commandSpawn('launchctl', ['bootout', `gui/${uid}/${label}`], { encoding: 'utf8', timeout: 10000 });
+  const apply = commandSpawn('launchctl', ['bootstrap', `gui/${uid}`, plistPath], { encoding: 'utf8', timeout: 10000 });
   const expiryBreadcrumbCleared = apply.status === 0 && clearPulseExpiryBreadcrumb(root);
+  const cadenceMapping = pulse.launchIntervalFromCadence({ cron });
 
   const out = {
     ok: apply.status === 0,
@@ -641,7 +665,11 @@ function installCommand(args, root = process.cwd(), options = {}) {
     state_home: slot.stateHome,
     marker: slot.marker,
     legacy_migrated: slot.legacyMatches,
-    crontab_line: line,
+    label,
+    plist_path: plistPath,
+    crontab_line: null,
+    removed_legacy_crontab: legacyHad,
+    cadence_fallback: cadenceMapping.fallback,
     cadence: cron,
     cadence_input: cadenceInput,
     expires_in_days: expiry.days,
@@ -656,46 +684,49 @@ function installCommand(args, root = process.cwd(), options = {}) {
   if (!asJson) {
     if (apply.status === 0) {
       writeOutput([
-        `pulse installed. heartbeat fires '${cron}' against ${root}.`,
+        `pulse installed. launchd heartbeat fires '${cron}' against ${root}.`,
+        `label: ${label}`,
+        `plist: ${plistPath}`,
         `script: ${scriptPath}`,
+        cadenceMapping.fallback ? `cadence '${cron}' is not directly mappable; using 3600 seconds.` : '',
         `auto-expires in ${expiry.hours ? `${expiry.hours} hours` : `${expiry.days} days`}. stop early: atris pulse uninstall`,
-      ].join('\n') + '\n');
+      ].filter(Boolean).join('\n') + '\n');
     } else {
-      writeOutput(`pulse install failed to write crontab: ${apply.stderr || apply.status}\nscript written to ${scriptPath}; add this line to your crontab manually:\n${line}\n`);
+      writeOutput(`pulse install failed to bootstrap ${label}: ${apply.stderr || apply.status}\nplist: ${plistPath}\n`);
     }
   }
   return emit(out, asJson);
 }
 
-function uninstallCommand(args, root = process.cwd()) {
+function uninstallCommand(args, root = process.cwd(), options = {}) {
   const asJson = wantsJson(args);
-  const slot = pulse.resolvePulseSlot(root);
-  const existing = spawnSync('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
-  if (existing.status !== 0) {
-    const out = {
-      ok: true,
-      action: 'pulse_uninstall',
-      removed: false,
-      reason: 'no_crontab',
-      state_home: slot.activeStateHome,
-      marker: slot.activeMarker,
-    };
-    if (!asJson) process.stdout.write('pulse: no crontab to clean.\n');
-    return emit(out, asJson);
-  }
+  const slot = pulse.resolvePulseSlot(root, options.homeDir ? { homeDir: options.homeDir } : {});
+  const commandSpawn = options.spawnSync || spawnSync;
+  const homeDir = options.homeDir || os.homedir();
+  const label = `com.atris.pulse.${slot.marker.toLowerCase().replace(/^atris_pulse_/, '').replace(/[^a-z0-9]+/g, '-')}`;
+  const plistPath = path.join(homeDir, 'Library', 'LaunchAgents', `${label}.plist`);
+  const uid = options.uid != null ? options.uid : process.getuid();
+  commandSpawn('launchctl', ['bootout', `gui/${uid}/${label}`], { encoding: 'utf8', timeout: 10000 });
+  const plistHad = fs.existsSync(plistPath);
+  fs.rmSync(plistPath, { force: true });
+  const existing = commandSpawn('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
   const prior = String(existing.stdout || '');
   const had = slot.markers.some((marker) => prior.includes(marker));
   const cleaned = stripMarkedCrontabLines(prior, slot.markers);
-  const apply = spawnSync('crontab', ['-'], { input: cleaned ? cleaned + '\n' : '', encoding: 'utf8', timeout: 10000 });
+  let apply = { status: 0 };
+  if (existing.status === 0 && had) apply = commandSpawn('crontab', ['-'], { input: cleaned ? cleaned + '\n' : '', encoding: 'utf8', timeout: 10000 });
   const out = {
     ok: apply.status === 0,
     action: 'pulse_uninstall',
-    removed: had,
+    removed: plistHad || had,
+    label,
+    plist_path: plistPath,
+    removed_legacy_crontab: had,
     state_home: slot.activeStateHome,
     marker: slot.activeMarker,
     legacy_slot: slot.legacyMatches,
   };
-  if (!asJson) process.stdout.write(had ? 'pulse uninstalled (crontab line removed).\n' : 'pulse: no heartbeat line found.\n');
+  if (!asJson) process.stdout.write(plistHad || had ? `pulse uninstalled (${label}).\n` : 'pulse: no heartbeat agent found.\n');
   return emit(out, asJson);
 }
 
@@ -703,7 +734,7 @@ function uninstallCommand(args, root = process.cwd()) {
 
 function runCommand(args, root = process.cwd()) {
   const asJson = wantsJson(args);
-  const maxTicks = Math.max(1, Number(readFlag(args, '--max-ticks', '1')) || 1);
+  const maxTicks = Math.max(1, Number(readFollowingFlag(args, '--max-ticks', '1')) || 1);
   const passthrough = args.filter((a) => a !== '--max-ticks' && a !== String(maxTicks));
   const results = [];
   for (let i = 0; i < maxTicks; i++) {
@@ -717,6 +748,9 @@ function pulseCommand(argv = []) {
   const sub = argv[0];
   const rest = argv.slice(1);
   if (sub === '--help' || sub === '-h' || sub === 'help') return showHelp();
+  // `pulse <sub> --help` is a help request, not a run — never execute the
+  // subcommand (tick/status/etc. have real side effects) just to show usage.
+  if (rest.includes('--help') || rest.includes('-h')) return showHelp();
   switch (sub) {
     case 'tick':
       return tickCommand(rest);
@@ -740,21 +774,11 @@ function pulseCommand(argv = []) {
 
 module.exports = {
   pulseCommand,
-  tickCommand,
   statusCommand,
   cronInstalled,
   crontabHasActiveMarker,
   pulseExpiryBreadcrumbPath,
-  readPulseExpiryBreadcrumb,
-  clearPulseExpiryBreadcrumb,
   installCommand,
-  uninstallCommand,
   runCommand,
-  runMissionEngine,
-  runAutopilotTick,
-  runEngine,
-  gitChangedFiles,
-  runVerify,
   refreshOrbPolicyLessons,
-  stripMarkedCrontabLines,
 };

package/commands/push.js

@@ -1055,7 +1055,6 @@ module.exports = {
   buildPushUploadBatches,
   shouldRetrySyncIndividually,
   resolvePushSourceDir,
-  canonicalWorkspaceRoot,
   basenameOfManifestPath,
   buildCloudHashMap,
   isBusinessWorkspaceRoot,
@@ -1066,9 +1065,6 @@ module.exports = {
   resolveChangedScopePaths,
   mergePushScopes,
   analyzePushSafety,
-  isNestedWorkspacePollutionPath,
-  isSyncReviewArtifactPath,
-  renderPushSafetyBlock,
   renderDriftBlock,
   needsForceBroadWorkspaceConfirm,
   promptConfirm,

package/commands/radar.js

@@ -396,16 +396,21 @@ function loadLoop(missions, root, deps) {
   const events = readJsonLines(path.join(root, '.atris', 'state', 'mission_events.jsonl'), deps.readFile, deps.exists);
   const codexGoal = readJsonFile(path.join(root, '.atris', 'state', 'codex_goal.json'), deps, {}) || {};
   const tickEvents = events.filter(event => event.type === 'mission_tick');
+  // Live missions sit in planning/ready/running; counting only 'running'
+  // reported 0 while a worker was mid-flight (CLI-1183, seen live 2026-07-25).
+  const ACTIVE_MISSION_STATUSES = new Set(['planning', 'running', 'ready']);
+  const isActive = (mission) => ACTIVE_MISSION_STATUSES.has(String(mission.status || ''));
   return {
-    running: missions.filter(mission => mission.status === 'running').length,
+    running: missions.filter(isActive).length,
+    paused: missions.filter(mission => mission.status === 'paused').length,
     always_on: missions.filter(mission => mission.always_on).length,
     stale: missions.filter(mission => mission.stale).length,
-    no_verifier: missions.filter(mission => mission.status === 'running' && !mission.verifier).length,
+    no_verifier: missions.filter(mission => isActive(mission) && !mission.verifier).length,
     ticks: tickEvents.length,
     last_event_at: events[events.length - 1]?.at || null,
     codex_goal: codexGoal.goal?.objective || null,
     codex_goal_mission: codexGoal.goal?.mission_id || null,
-    infinite_loop_risk: missions.some(mission => mission.stale || (mission.status === 'running' && !mission.verifier)),
+    infinite_loop_risk: missions.some(mission => mission.stale || (isActive(mission) && !mission.verifier)),
   };
 }
 
@@ -735,7 +740,11 @@ function summarize(tasks, missions, worktrees, agents) {
       review: count(tasks, t => t.status === 'review'),
       certifiedReview: count(tasks, t => t.status === 'review' && t.metadata && t.metadata.agent_certified),
     },
-    missions: { running: count(missions, m => m.status === 'running'), stale: count(missions, m => m.stale) },
+    missions: {
+      running: count(missions, m => ['planning', 'running', 'ready'].includes(String(m.status || ''))),
+      paused: count(missions, m => m.status === 'paused'),
+      stale: count(missions, m => m.stale),
+    },
     worktrees: { total: worktrees.length, dirty: count(worktrees, w => Number(w.dirty) > 0) },
   };
 }
@@ -832,7 +841,7 @@ function renderRadar(data) {
   lines.push('');
   lines.push(`Agents: ${s.agents.active}/${s.agents.total} active`);
   lines.push(`Tasks: ${s.tasks.open} open, ${s.tasks.claimed} claimed, ${s.tasks.review} review (${s.tasks.certifiedReview} certified)`);
-  lines.push(`Missions: ${s.missions.running} running, ${s.missions.stale} stale/no-verifier`);
+  lines.push(`Missions: ${s.missions.running} active, ${s.missions.paused || 0} paused, ${s.missions.stale} stale/no-verifier`);
   lines.push(`Worktrees: ${s.worktrees.total} registered, ${s.worktrees.dirty} dirty`);
   lines.push(`Next: ${data.next_action}`);
   if (data.os) {
@@ -1188,16 +1197,10 @@ function radarCommand(args = [], options = {}) {
 module.exports = {
   agentTypeForCommand,
   agentTopPayload,
-  branchIdentityAtCwd,
   collectRadar,
-  isInteractiveClaudeCommand,
-  loadAgentWorktreeSidecar,
   parsePsOutput,
-  parseSessionIdFromCommand,
   parseWorktrees,
   radarCommand,
   renderAgentTop,
   renderRadar,
-  resolveAgentTaskBinding,
-  taskForOwner,
 };