atris 3.37.0 → 3.38.0

package/commands/play.js

@@ -485,6 +485,4 @@ async function playCommand(...args) {
 
 module.exports = {
   playCommand,
-  modeState,
-  selectMission,
 };

package/commands/probe.js

@@ -26,6 +26,7 @@
 
 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');
@@ -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 || '?');

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');
@@ -41,8 +41,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:
@@ -298,7 +298,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 +497,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 +522,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}`,
@@ -606,8 +619,12 @@ function installCommand(args, root = process.cwd(), options = {}) {
 
   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 +638,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 +666,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 +685,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);
 }
 
@@ -717,6 +749,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 +775,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,
 };