atris 3.58.6 → 3.58.8

package/commands/mission.js

@@ -6,12 +6,14 @@ const crypto = require('crypto');
 const readline = require('readline');
 const { spawn, spawnSync } = require('child_process');
 const { hasFlag, readFlag, readIntFlag } = require('../lib/arg-parser');
+const { memberProcessPrompt } = require('../lib/member-context');
 const {
   compactErrorPayload,
   compactSuccessPayload,
   printCliJson,
 } = require('../lib/cli-json');
 const escapeRegExp = require('../lib/escape-regexp');
+const { sleepSync } = require('../lib/sleep-sync');
 const {
   appendBriefRecord,
   stampBriefOutcome,
@@ -111,6 +113,15 @@ const CODEX_NATIVE_GOAL_CLOSED_STATUSES = new Set(['complete', 'completed', 'ach
 const DEFAULT_LONG_RUN_VERIFIER = 'git diff --check';
 const SLEEP_LENGTH_BUDGET_SECONDS = 3600;
 const HUMAN_BLOCKING_PAUSE_REASONS = new Set(['auth-required', 'model-unavailable', 'rate-limit-exceeded-wall']);
+// Claude prints its logged-out message on stdout ("Invalid API key · Please
+// run /login"), not stderr, so the check has to read the captured result text
+// too or a dead login masquerades as a generic claude-error.
+const MISSION_RUNNER_AUTH_EXPIRED_RE = /not authenticated|please log in|login required|auth(?:entication)? expired|invalid (?:api|connection) key|run \/login/i;
+
+function missionRunnerAuthExpired(...texts) {
+  return texts.some((text) => Boolean(text) && MISSION_RUNNER_AUTH_EXPIRED_RE.test(String(text)));
+}
+
 const MISSION_BUDGET_TIERS = Object.freeze({
   quick: Object.freeze({ max_ticks: 4, requested_seconds: 15 * 60 }),
   long: Object.freeze({ max_ticks: 12, requested_seconds: 60 * 60 }),
@@ -3558,8 +3569,8 @@ function readTasteReviewHistory(root, limit = 4) {
 
 function missionTasteMemorySignals(text) {
   const definitions = [
-    ['plain_language', 'Keshav asks for plain English', /\b(plain|jargon|feynman|understand|simple|clarify|clarity)\b/i],
-    ['proof_gate', 'Keshav wants proof before accept', /\b(proof|receipt|verify|verified|checked|tested|accept|approval)\b/i],
+    ['plain_language', 'the operator asks for plain English', /\b(plain|jargon|feynman|understand|simple|clarify|clarity)\b/i],
+    ['proof_gate', 'the operator wants proof before accept', /\b(proof|receipt|verify|verified|checked|tested|accept|approval)\b/i],
     ['runway_revenue', 'runway pushes user or revenue work', /\b(runway|revenue|cash|user|users|customer|demo|adoption|retention)\b/i],
     ['technical_ambition', 'technical advancement still matters', /\b(technical|homerun|research|runtime|architecture|model|benchmark|agent)\b/i],
     ['trust_boundary', 'trust and approval boundaries matter', /\b(security|safe|safety|trust|privacy|approval|permission|gmail|email|connector)\b/i],
@@ -3658,9 +3669,9 @@ function missionPlainTaskPreview(title) {
 function missionTasteMemoryReason(tasteMemory, signals) {
   const candidateIds = new Set((signals || []).map((signal) => signal.id));
   const memoryIds = new Set((tasteMemory?.signals || []).map((signal) => signal.id));
-  if (memoryIds.has('runway_revenue') && candidateIds.has('users_revenue')) return 'Keshav has been steering toward user/revenue proof because runway is tight.';
-  if (memoryIds.has('plain_language') && candidateIds.has('usability')) return 'Keshav keeps asking for plain-English, understandable work.';
-  if (memoryIds.has('proof_gate') && (candidateIds.has('trust') || candidateIds.has('technical'))) return 'Keshav wants proof and receipts before serious work is accepted.';
+  if (memoryIds.has('runway_revenue') && candidateIds.has('users_revenue')) return 'the operator has been steering toward user/revenue proof because runway is tight.';
+  if (memoryIds.has('plain_language') && candidateIds.has('usability')) return 'the operator keeps asking for plain-English, understandable work.';
+  if (memoryIds.has('proof_gate') && (candidateIds.has('trust') || candidateIds.has('technical'))) return 'the operator wants proof and receipts before serious work is accepted.';
   if (memoryIds.has('working_memory')) return 'Recent logs are being used as working memory for what matters now.';
   if (memoryIds.has('technical_ambition') && candidateIds.has('technical')) return 'The member memory still values technical advancement when it has proof.';
   return '';
@@ -4150,14 +4161,61 @@ function startMission(args, options = {}) {
   // checkout's dirt never reaches the mission baseline.
   if (hasFlag(args, '--worktree')) {
     let created;
+    const sourceTop = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd: process.cwd(), encoding: 'utf8' });
+    const sourceCheckout = sourceTop.status === 0 ? String(sourceTop.stdout).trim() : process.cwd();
+    let nodeModulesSource = null;
     try {
       const { createAgentWorktree } = require('./worktree');
       const base = readFlag(args, '--base', '') || inheritedWorktreeBase(process.cwd());
       created = createAgentWorktree({ member: mission.owner, task: mission.objective, ...(base ? { base } : {}) });
+      const packageFile = path.join(sourceCheckout, 'package.json');
+      const sourceModules = path.join(sourceCheckout, 'node_modules');
+      const targetModules = path.join(created.path, 'node_modules');
+      try {
+        let targetExists = false;
+        try {
+          fs.lstatSync(targetModules);
+          targetExists = true;
+        } catch (error) {
+          if (error.code !== 'ENOENT') throw error;
+        }
+        if (fs.existsSync(packageFile) && fs.existsSync(sourceModules) && !targetExists) {
+          const manifest = JSON.parse(fs.readFileSync(packageFile, 'utf8'));
+          const hasDependencies = ['dependencies', 'devDependencies', 'optionalDependencies']
+            .some((field) => manifest[field] && Object.keys(manifest[field]).length > 0);
+          if (hasDependencies) {
+            const checkIgnored = () => {
+              const result = spawnSync('git', ['check-ignore', '-q', 'node_modules'], { cwd: created.path, encoding: 'utf8' });
+              if (result.error || (result.status !== 0 && result.status !== 1)) {
+                throw new Error(result.error?.message || String(result.stderr || 'git check-ignore failed').trim());
+              }
+              return result.status === 0;
+            };
+            if (!checkIgnored()) {
+              const commonDir = spawnSync('git', ['rev-parse', '--git-common-dir'], { cwd: created.path, encoding: 'utf8' });
+              if (commonDir.error || commonDir.status !== 0) {
+                throw new Error(commonDir.error?.message || String(commonDir.stderr || 'could not find shared git directory').trim());
+              }
+              const excludeFile = path.resolve(created.path, String(commonDir.stdout).trim(), 'info', 'exclude');
+              fs.mkdirSync(path.dirname(excludeFile), { recursive: true });
+              const exclude = fs.existsSync(excludeFile) ? fs.readFileSync(excludeFile, 'utf8') : '';
+              if (!exclude.split(/\r?\n/).includes('/node_modules')) {
+                fs.appendFileSync(excludeFile, `${exclude && !exclude.endsWith('\n') ? '\n' : ''}/node_modules\n`);
+              }
+            }
+            if (!checkIgnored()) throw new Error('git still tracks node_modules after updating the shared exclude file');
+            fs.symlinkSync(sourceModules, targetModules, 'dir');
+            nodeModulesSource = sourceModules;
+          }
+        }
+      } catch (error) {
+        console.warn(`warning: could not link node_modules: ${String(error.message).split(/\r?\n/)[0]}`);
+      }
     } catch (e) {
       exitMissionError(`[mission start] worktree creation failed: ${e.message}`, 2, asJson);
     }
     mission.worktree = { path: created.path, branch: created.branch, base: created.base };
+    if (nodeModulesSource) mission.node_modules_source = nodeModulesSource;
     process.chdir(created.path);
   }
   if (mission.xp_task_enabled) {
@@ -4215,6 +4273,8 @@ function startMission(args, options = {}) {
       dirty_count: worktreeBaseline.dirty_count,
       dirty_hash: worktreeBaseline.dirty_hash,
     } : null,
+    node_modules_linked: Boolean(saved.node_modules_source),
+    node_modules_source: saved.node_modules_source || null,
     ...(saved.remap_reason ? { remap_reason: saved.remap_reason } : {}),
   };
   if (!options.silent) {
@@ -4226,6 +4286,7 @@ function startMission(args, options = {}) {
         `State: ${saved.status}`,
         ...(saved.remap_reason ? [`Remap: ${saved.remap_reason}`] : []),
         ...(saved.worktree ? [`Worktree: ${saved.worktree.path}`, `Branch: ${saved.worktree.branch}`] : []),
+        ...(saved.node_modules_source ? [`linked node_modules from ${saved.node_modules_source}`] : []),
         ...warnings.map((warning) => `Warning: ${warning.message}`),
         ...(saved.xp_task ? [`AgentXP task: ${saved.xp_task.ref}`] : []),
         ...(saved.worktree ? [`Next: cd ${saved.worktree.path} && ${nextTickCommand}`] : [`Next: ${nextTickCommand}`]),
@@ -8039,12 +8100,6 @@ function isWithinActiveHours(activeHours, now = new Date()) {
   return cur >= start || cur < end;
 }
 
-function sleepSync(ms) {
-  const waitMs = Math.max(0, Number(ms) || 0);
-  if (!waitMs) return;
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, waitMs);
-}
-
 function missionLockOwnerIsAlive(pid) {
   const ownerPid = Number(pid);
   if (!Number.isInteger(ownerPid) || ownerPid <= 0) return false;
@@ -8406,8 +8461,12 @@ function probeClaudeBinary() {
 // Pull unread operator pings off the mission and mark them consumed, so the
 // next tick's prompt carries them exactly once. Pings are how a human talks to
 // an always-on member mid-run: atris member ping <name> "<msg>".
+function pendingMissionPings(mission) {
+  return (Array.isArray(mission.pings) ? mission.pings : []).filter((p) => p && !p.consumed_at);
+}
+
 function consumeMissionPings(mission, cwd) {
-  const pending = (Array.isArray(mission.pings) ? mission.pings : []).filter((p) => p && !p.consumed_at);
+  const pending = pendingMissionPings(mission);
   if (!pending.length) return { mission, pings: [] };
   const consumedAt = stampIso();
   const pings = (mission.pings || []).map((p) => (p && !p.consumed_at ? { ...p, consumed_at: consumedAt } : p));
@@ -8415,7 +8474,8 @@ function consumeMissionPings(mission, cwd) {
   return { mission: saved, pings: pending };
 }
 
-function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = []) {
+function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = [], cwd = process.cwd()) {
+  const sharedProcess = memberProcessPrompt(cwd);
   const pingLines = pings.length
     ? [
       ``,
@@ -8447,6 +8507,7 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = []) {
     `**Last tick:** ${mission.last_tick_at || 'never'}`,
     ...missionBudgetPromptLines(mission),
     ...checkFeedbackLines,
+    ...(sharedProcess ? ['', sharedProcess] : []),
     ``,
     `## Your task`,
     `Do ONE increment of work toward the stop condition. ONE. No more.`,
@@ -8765,7 +8826,7 @@ function spawnGenericRunnerTick(mission, opts) {
       const finalText = String(stdout || '').trim();
       const errStr = String(stderr || '').slice(-2000);
       const ok = code === 0 && !timedOut && !aborted;
-      const authExpired = /not authenticated|please log in|login required|auth(?:entication)? expired/i.test(errStr);
+      const authExpired = !ok && missionRunnerAuthExpired(errStr, finalText);
       resolve({
         ok,
         brief_id: briefId,
@@ -8940,7 +9001,7 @@ function spawnClaudeTick(mission, opts) {
       updateMissionLockOwner(missionLock, missionLock?.driverPid);
       const ok = code === 0 && !isError && !timedOut && !aborted;
       const errStr = stderr.slice(-2000);
-      const authExpired = /not authenticated|please log in|login required|auth(?:entication)? expired/i.test(errStr);
+      const authExpired = !ok && missionRunnerAuthExpired(errStr, finalText, stdoutBuf);
       resolve({
         ok,
         timedOut,
@@ -9521,6 +9582,9 @@ async function executeMissionRunTicksPhase(context) {
           drill: drillResult,
         };
       } else if (tickAtris2Runner) {
+        // Build before consuming direction or allocating the guard: a shared
+        // process read error must leave operator pings available for retry.
+        const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pendingMissionPings(mission), cwd);
         let atris2GitGuard = null;
         try {
           atris2GitGuard = prepareMissionGitGuard({ root: cwd, tags: missionProtectedTags(mission, cwd) });
@@ -9541,7 +9605,6 @@ async function executeMissionRunTicksPhase(context) {
           const pingDrain = consumeMissionPings(mission, cwd);
           mission = pingDrain.mission;
           runtimeMission = runtimeView(mission);
-          const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pingDrain.pings);
           const { runAtris2Turn } = require('./probe');
           const businessId = businessIdForAtris2Mission(tickRuntimeMission, cwd);
           const tickController = new AbortController();
@@ -9593,12 +9656,12 @@ async function executeMissionRunTicksPhase(context) {
           }
         }
       } else {
+        const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pendingMissionPings(mission), cwd);
         let sessionMode = sessionId ? 'resume' : 'set';
         let useId = sessionId || pendingSessionId;
         const pingDrain = consumeMissionPings(mission, cwd);
         mission = pingDrain.mission;
         runtimeMission = runtimeView(mission);
-        const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pingDrain.pings);
         const restoreTickRunnerProfile = tickEngineId ? applyMissionRunnerProfile(tickEngineId) : () => {};
         let claudeResult;
         let sessionBusyRetried = false;
@@ -9813,6 +9876,14 @@ async function executeMissionRunTicksPhase(context) {
       const claudeRanTick = Boolean(result.claude) && result.status === 'ran';
       const claudeSessionTicks = claudeRanTick ? Number(mission.claude_session_ticks || 0) + 1 : Number(mission.claude_session_ticks || 0);
       const rotateSessionForContext = claudeRanTick && claudeSessionTicks >= CLAUDE_SESSION_CONTEXT_ROTATE_TICKS;
+      // Heartbeat missions run one tick per invocation, so the in-run ticks
+      // array alone can never see two identical errors. Persist the trailing
+      // same-reason errored count so the breaker below trips across runs.
+      const errorStreakCount = result.status === 'errored' && result.reason
+        ? (latestOnDisk.last_tick_status === 'errored' && latestOnDisk.last_tick_reason === result.reason
+          ? Number(latestOnDisk.error_streak_count || 0) + 1
+          : 1)
+        : 0;
       // Base on latestOnDisk so mid-tick complete proof/completed_at survive.
       mission = saveMission({
         ...latestOnDisk,
@@ -9825,6 +9896,7 @@ async function executeMissionRunTicksPhase(context) {
         last_tick_index: tickIdx,
         last_tick_layer: result.layer,
         last_tick_layer_source: result.layer_source,
+        error_streak_count: errorStreakCount,
         verifier_result: verifierResult || (verifyEach && result.protected_lane_guard && result.protected_lane_guard.allowed === false ? null : latestOnDisk.verifier_result) || null,
         last_check_feedback: verifierResult
           ? extractCheckFeedback(verifierResult)
@@ -9902,9 +9974,12 @@ async function executeMissionRunTicksPhase(context) {
       // is the same trap one step less deterministic: keep retrying and the loop burns every
       // tick + cron firing on it. Halt at two-in-a-row and surface the reason for a human.
       const errStreak = consecutiveSameReasonErrors(ticks);
+      // The in-run ticks array only sees this invocation; the persisted streak
+      // carries identical errors across heartbeat runs of one tick each.
+      const errStreakCount = Math.max(errStreak.count, errStreak.reason ? Number(mission.error_streak_count || 0) : 0);
       // Sleeping Atris2 backends are different: leave the mission running so the
       // next tick or heartbeat can catch the backend after it wakes.
-      if (errStreak.count >= 2 && !missionRunKeepsRetryingError(errStreak.reason)) { pauseReason = `repeated-error:${errStreak.reason}`; break; }
+      if (errStreakCount >= 2 && !missionRunKeepsRetryingError(errStreak.reason)) { pauseReason = `repeated-error:${errStreak.reason}`; break; }
 
       // Sleep until next tick
       let sleepMs = 0;
@@ -11599,6 +11674,7 @@ module.exports = {
   missionProtectedLaneHold,
   missionCommand,
   startMission,
+  resolveMission,
   spawnMissionDriver,
   missionRunnerNeedsLiveSession,
   completeMission,

package/commands/pack.js

@@ -1622,7 +1622,7 @@ async function publishPack(rawArgs, cwd = process.cwd(), options = {}) {
   }
 
   // pack.json belongs to the pack, not to whatever repo happens to contain it
-  // (2026-07-27: publishing ~/arena/atrisos-backend/atris wrote a pack.json
+  // (2026-07-27: publishing a backend workspace's atris folder wrote a pack.json
   // into atrisos-backend/ and polluted the source repo).
   const manifestPath = path.join(sourceDir, 'pack.json');
   const existing = readJson(manifestPath);
@@ -2453,7 +2453,7 @@ function printCapabilityTrustCard(policy, trust, receiptPath, userDenyRuleCount
   if (options.operatorInput) {
     console.log(`  operator input: ${options.operatorInput.bytes} bytes injected; source path withheld from the pack and receipt`);
   }
-  console.log(`  host shell: ${policy.grantedCapabilities.includes('host.shell') ? 'GRANTED \u2014 Bash can reach host files and network' : 'denied'}`);
+  console.log(`  host shell: ${policy.grantedCapabilities.includes('host.shell') ? 'granted, bash can reach host files and network' : 'denied'}`);
   console.log('  receipt coverage: Atris hook tool events; direct slash-skill invocations and later Claude or policy denials may not appear');
   console.log(`  receipt: ${receiptPath}`);
 }

package/commands/probe.js

@@ -454,18 +454,24 @@ async function probeCommand(argv) {
   const detail = ok
     ? `answer: ${resultText.slice(0, 80).replace(/\n/g, ' ')}`
     : `dead-end: ${deadEnd}`;
-  const line = `- **atris-probe** \`${stamp}\` \u2014 ${where} · ${a.model}`
+  const line = buildProbeLine({ stamp, where, model: a.model, member, engine, ok, secs, toolsRun, calendar: a.calendar, cliCalendarOps, detail });
+  console.log(line);
+  return ok ? 0 : 1;
+}
+
+function buildProbeLine({ stamp, where, model, member, engine, ok, secs, toolsRun, calendar, cliCalendarOps, detail }) {
+  const line = `- **atris-probe** \`${stamp}\` - ${where} · ${model}`
     + (member ? ` · member=${member}` : '')
     + (engine ? ` · engine=${engine}` : '')
-    + ` · ${ok ? 'PASS' : 'FAIL'} · ${secs}s · tools=${toolsRun}`
-    + (a.calendar ? ` cal_cli=${cliCalendarOps}` : '')
+    + ` · ${ok ? 'pass' : 'fail'} · ${secs}s · tools=${toolsRun}`
+    + (calendar ? ` cal_cli=${cliCalendarOps}` : '')
     + ` · ${detail}`;
-  console.log(line);
-  return ok ? 0 : 1;
+  return line.replace(/\s*\u2014\s*/g, ', ');
 }
 
 module.exports = {
   probeCommand,
+  buildProbeLine,
   runAtris2Turn,
   // exported for tests
   normalizePath,

package/commands/pull.js

@@ -722,7 +722,7 @@ async function pullBusiness(slug) {
         fs.mkdirSync(path.dirname(localPath), { recursive: true });
         fs.writeFileSync(localPath, content);
       }
-      console.log(`  \u26A0 ${p.replace(/^\//, '')}  CONFLICT \u2014 both you and the computer changed this`);
+      console.log(`  \u26A0 ${p.replace(/^\//, '')}: conflict, both you and the computer changed this`);
       console.log(`    \u2192 Remote version saved as ${p.replace(/^\//, '')}.remote`);
       conflictCount++;
     }

package/commands/pulse.js

@@ -18,6 +18,7 @@ const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const pulse = require('../lib/pulse');
+const rsi = require('../lib/rsi-record');
 const { DEFAULT_CLAUDE_RUNNER_MODEL } = require('../lib/runner-command');
 const { hasFlag } = require('../lib/arg-parser');
 
@@ -267,6 +268,14 @@ function tickCommand(args, root = process.cwd()) {
     orbIngestError,
   }));
 
+  // Dream-RSI: record this tick as one attempt when the workspace has the
+  // recorder. Best-effort; a missing or failing recorder never changes the
+  // tick's outcome. The engine spawns claude-backed runners by default.
+  const rsiLog = (m) => { if (!asJson) process.stderr.write(`rsi: ${m}\n`); };
+  const rsiAttempt = rsi.beginAttempt(root, { lane: rsi.IMPROVE_LANE, engine: 'claude', log: rsiLog });
+  const rsiBefore = rsiAttempt ? rsi.gitSnapshot(root) : null;
+  let rsiOutcome = null;
+
   let engine;
   let verify = { passed: null, cmd: verifyCmd };
   try {
@@ -312,6 +321,14 @@ function tickCommand(args, root = process.cwd()) {
         ? 'no due mission; heartbeat alive (no-op)'
         : `mission ${engine.reason}${changedTail}`;
 
+    rsiOutcome = {
+      status: !engine.ok || verify.passed === false ? 'failed' : producedWork ? 'shipped' : 'nothing',
+      verify: verify.passed === true ? 'pass' : verify.passed === false ? 'fail' : 'skipped',
+      elapsed_s: Math.round(elapsedMs / 100) / 10,
+      engine_calls: 1,
+      reason: String(what || '').slice(0, 200),
+    };
+
     const receipt = pulse.buildPulseReceipt({
       tickIndex,
       phase: 'finished',
@@ -426,11 +443,32 @@ function tickCommand(args, root = process.cwd()) {
       orb_policy_lesson: orbPolicy,
     };
     if (orbIngestError) out.orb_ingest_error = orbIngestError;
+    rsiOutcome = {
+      status: 'failed',
+      verify: 'skipped',
+      elapsed_s: Math.round((Date.now() - startedAt) / 100) / 10,
+      engine_calls: 1,
+      reason: String(err && err.message ? err.message : err).slice(-200),
+    };
     if (!asJson) process.stdout.write(`pulse tick #${tickIndex} crashed: ${out.error}\n`);
     return emit(out, asJson);
   } finally {
     process.removeListener('SIGINT', finishInterrupted);
     process.removeListener('SIGTERM', finishInterrupted);
+    if (rsiAttempt) {
+      const delta = rsi.gitDelta(root, rsiBefore);
+      rsi.finishAttempt(root, rsiAttempt, {
+        commits: delta.commits,
+        files: delta.files,
+        ...(rsiOutcome || {
+          status: 'failed',
+          verify: 'skipped',
+          elapsed_s: Math.round((Date.now() - startedAt) / 100) / 10,
+          engine_calls: 1,
+          reason: 'tick ended without an outcome',
+        }),
+      }, { log: rsiLog });
+    }
     pulse.releaseLock(root);
   }
 }

package/commands/push.js

@@ -985,7 +985,7 @@ async function pushAtris() {
       console.log(`    ... +${failedToLand.length - shown.length} more`);
     }
     console.log('');
-    console.log('  Common causes: path is outside the workspace (e.g. absolute /Users/... path),');
+    console.log('  common causes: path is outside the workspace (for example, an absolute home path),');
     console.log('  your role lacks write permission for that folder, or warm runner returned an error.');
     console.log('  These files will appear as drift on your next push so you can retry.');
   }

package/commands/rainmaker.js

@@ -9,22 +9,9 @@
  */
 
 const fs = require('fs');
-const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
-
-function resolveBackendRoot() {
-  const candidates = [
-    process.env.ATRIS_BACKEND_DIR,
-    path.resolve(__dirname, '..', '..', 'atrisos-backend'),
-    path.resolve(process.cwd(), '..', 'atrisos-backend'),
-    path.join(os.homedir(), 'arena', 'atrisos-backend'),
-  ].filter(Boolean);
-  for (const root of candidates) {
-    if (fs.existsSync(path.join(root, 'scripts', 'rainmaker.py'))) return root;
-  }
-  return null;
-}
+const { BACKEND_ROOT_HINT, resolveBackendRoot } = require('../utils/backend-root');
 
 function rainmakerCommand(args = []) {
   if (args[0] === '--help' || args[0] === '-h') {
@@ -32,8 +19,8 @@ function rainmakerCommand(args = []) {
     return 0;
   }
   const root = resolveBackendRoot();
-  if (!root) {
-    console.error('Cannot find scripts/rainmaker.py. Set ATRIS_BACKEND_DIR to atrisos-backend.');
+  if (!root || !fs.existsSync(path.join(root, 'scripts', 'rainmaker.py'))) {
+    console.error(BACKEND_ROOT_HINT);
     return 1;
   }
   const script = path.join(root, 'scripts', 'rainmaker.py');

package/commands/rsi.js

@@ -0,0 +1,156 @@
+'use strict';
+
+// atris rsi - read the Dream-RSI attempt ledger in plain words.
+//
+// Prints trees and attempts by lane, the most recent day's attempts and
+// outcomes, the live policy id, and the last dream receipt. Read-only: it
+// never touches record.py, never writes state, and exits 0 even when the
+// workspace has no ledger yet.
+
+const fs = require('fs');
+const rsi = require('../lib/rsi-record');
+
+function readJsonl(file) {
+  try {
+    return fs.readFileSync(file, 'utf8')
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => { try { return JSON.parse(line); } catch { return null; } })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function dayOf(node) {
+  return String((node && node.created_at) || '').slice(0, 10);
+}
+
+function collectStatus(root) {
+  const nodes = rsi.latestNodes(root);
+  const lanes = new Map();
+  for (const n of nodes) {
+    const lane = String(n.lane || 'unknown');
+    if (!lanes.has(lane)) {
+      lanes.set(lane, { trees: new Set(), nodes: 0, shipped: 0, failed: 0, nothing: 0, open: 0 });
+    }
+    const l = lanes.get(lane);
+    l.trees.add(String(n.tree_id || ''));
+    l.nodes += 1;
+    const st = n.outcome && n.outcome.status;
+    if (st === 'shipped') l.shipped += 1;
+    else if (st === 'failed') l.failed += 1;
+    else if (st === 'nothing') l.nothing += 1;
+    else l.open += 1; // running / waiting / unlabeled
+  }
+  const days = [...new Set(nodes.map(dayOf).filter(Boolean))].sort();
+  const lastDay = days.length ? days[days.length - 1] : null;
+  const lastAttempts = lastDay ? nodes.filter((n) => dayOf(n) === lastDay) : [];
+  const policyFile = `${root}/atris/rsi/policy.current`;
+  const policy = fs.existsSync(policyFile) ? rsi.currentPolicyId(root) : 'p-0001 (default)';
+  const dreams = readJsonl(rsi.dreamsPath(root));
+  return {
+    lanes,
+    lastDay,
+    lastAttempts,
+    policy,
+    lastDream: dreams.length ? dreams[dreams.length - 1] : null,
+    totalNodes: nodes.length,
+    ledger: rsi.attemptsPath(root),
+  };
+}
+
+function outcomeWord(status, verify) {
+  if (status === 'shipped') return verify === 'pass' ? 'shipped, verify passed' : 'shipped';
+  if (status === 'failed') return 'failed';
+  if (status === 'nothing') return 'found nothing to do';
+  return 'still open';
+}
+
+function formatStatus(s) {
+  const lines = ['rsi attempts ledger', `  ${s.ledger}`, ''];
+  if (!s.totalNodes) {
+    lines.push('  no attempts recorded yet.');
+    lines.push('');
+    lines.push(`  policy: ${s.policy}`);
+    if (s.lastDream) lines.push(`  last dream: ${dreamLine(s.lastDream)}`);
+    else lines.push('  no dreams yet.');
+    return lines.join('\n');
+  }
+  const totalTrees = [...s.lanes.values()].reduce((a, l) => a + l.trees.size, 0);
+  lines.push(`  ${totalTrees} tree${totalTrees === 1 ? '' : 's'}, ${s.totalNodes} attempt${s.totalNodes === 1 ? '' : 's'} across ${s.lanes.size} lane${s.lanes.size === 1 ? '' : 's'}:`);
+  for (const [lane, l] of [...s.lanes.entries()].sort()) {
+    const parts = [];
+    if (l.shipped) parts.push(`${l.shipped} shipped`);
+    if (l.failed) parts.push(`${l.failed} failed`);
+    if (l.nothing) parts.push(`${l.nothing} nothing`);
+    if (l.open) parts.push(`${l.open} open`);
+    lines.push(`    ${lane}: ${l.trees.size} tree${l.trees.size === 1 ? '' : 's'}, ${l.nodes} attempt${l.nodes === 1 ? '' : 's'}${parts.length ? ` (${parts.join(', ')})` : ''}`);
+  }
+  lines.push('');
+  lines.push(`  last night (${s.lastDay}): ${s.lastAttempts.length} attempt${s.lastAttempts.length === 1 ? '' : 's'}`);
+  for (const n of s.lastAttempts.slice(0, 10)) {
+    const reason = String((n.outcome && n.outcome.reason) || '').replace(/\s+/g, ' ').trim().slice(0, 80);
+    lines.push(`    ${n.id}: ${outcomeWord(n.outcome && n.outcome.status, n.outcome && n.outcome.verify)}${reason ? ` - ${reason}` : ''}`);
+  }
+  if (s.lastAttempts.length > 10) lines.push(`    ...and ${s.lastAttempts.length - 10} more`);
+  lines.push('');
+  lines.push(`  policy: ${s.policy}`);
+  lines.push(s.lastDream ? `  last dream: ${dreamLine(s.lastDream)}` : '  no dreams yet.');
+  return lines.join('\n');
+}
+
+function dreamLine(receipt) {
+  const deployed = receipt.deployed ? `deployed ${receipt.deployed}` : `kept ${receipt.current || 'current policy'}`;
+  const reason = String(receipt.reason || '').replace(/\s+/g, ' ').trim().slice(0, 120);
+  return `${receipt.at || '(no date)'} · ${deployed}${reason ? ` · ${reason}` : ''}`;
+}
+
+function showHelp() {
+  console.log(`atris rsi - read the Dream-RSI attempt ledger
+
+Usage:
+  atris rsi            same as status
+  atris rsi status     trees + attempts by lane, last night's outcomes, policy, last dream
+  atris rsi status --json   machine-readable status
+
+Read-only. State lives in .atris/state/rsi/ (or $ATRIS_RSI_STATE).`);
+}
+
+function run(argv = []) {
+  const args = Array.isArray(argv) ? argv : [];
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    showHelp();
+    return 0;
+  }
+  const sub = args[0] && !args[0].startsWith('-') ? args[0] : 'status';
+  if (sub !== 'status') {
+    console.log(`unknown rsi subcommand: ${sub}`);
+    showHelp();
+    return 2;
+  }
+  const root = process.cwd();
+  const s = collectStatus(root);
+  if (args.includes('--json')) {
+    const lanes = {};
+    for (const [lane, l] of s.lanes.entries()) {
+      lanes[lane] = { trees: l.trees.size, nodes: l.nodes, shipped: l.shipped, failed: l.failed, nothing: l.nothing, open: l.open };
+    }
+    console.log(JSON.stringify({
+      ok: true,
+      ledger: s.ledger,
+      total_nodes: s.totalNodes,
+      lanes,
+      last_day: s.lastDay,
+      last_day_attempts: s.lastAttempts.length,
+      policy: s.policy,
+      last_dream: s.lastDream,
+    }));
+    return 0;
+  }
+  console.log(formatStatus(s));
+  return 0;
+}
+
+module.exports = { run, collectStatus, formatStatus };

package/commands/spaceship.js

@@ -4,7 +4,7 @@
  * atris spaceship, bounded, self-reporting overnight runner.
  *
  * Thin wrapper over scripts/spaceship.sh. The script is the implementation
- * (a supervised loop that survives bad ticks and emails Keshav on every
+ * (a supervised loop that survives bad ticks and emails the operator on every
  * meaningful state change); this module just makes it reachable as
  * `atris spaceship ...` and integrates with the CLI's command dispatch.
  *