atris 3.62.0 → 3.64.0

package/commands/improve.js

@@ -18,10 +18,13 @@
  * fallback, and scorecard writes can all be faked in tests.
  */
 
+const crypto = require('crypto');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const gitSpawn = require('../lib/git-spawn');
+const ignoredCache = require('../lib/ignored-cache');
 const { apiRequestJson, getApiBaseUrl } = require('../utils/api');
 const { loadCredentials } = require('../utils/auth');
 const pulse = require('../lib/pulse');
@@ -1085,8 +1088,9 @@ function parseRevisionsArgs(argv = []) {
   return opts;
 }
 
-function gitLines(cwdRoot, gitArgs) {
-  const r = spawnSync('git', gitArgs, { cwd: cwdRoot, encoding: 'utf8' });
+// Through the module object so tests can count git spawns with a spy.
+function gitLines(cwdRoot, gitArgs, { input, maxBuffer } = {}) {
+  const r = gitSpawn.runGit(gitArgs, { cwd: cwdRoot, check: false, input, maxBuffer });
   if (r.status !== 0) {
     const err = new Error(String(r.stderr || `git ${gitArgs[0]} exited ${r.status}`).trim());
     err.gitFailed = true;
@@ -1095,17 +1099,129 @@ function gitLines(cwdRoot, gitArgs) {
   return String(r.stdout || '');
 }
 
+// File names come back NUL-separated and never quoted, whatever core.quotePath
+// says, so a name reads the same fresh from git and from the saved cache.
+const NAME_ARGS = ['-c', 'core.quotePath=false'];
+
+function splitNames(out) {
+  return String(out || '').split('\0').filter(Boolean);
+}
+
 /**
  * Files changed by one commit. Merge commits are attributed by their
  * first-parent diff (what the merge actually brought onto the mainline);
  * plain commits use diff-tree. Root commits list their initial files.
+ * The rename choice is spelled out so a user's diff.renames setting cannot
+ * change the lists: merges find renames (git diff's default), plain commits
+ * do not (diff-tree's default).
  */
 function commitFiles(cwdRoot, commit) {
   const parents = commit.parents;
   const out = parents.length >= 2
-    ? gitLines(cwdRoot, ['diff', '--name-only', `${commit.hash}^1`, commit.hash])
-    : gitLines(cwdRoot, ['diff-tree', '--no-commit-id', '--name-only', '-r', '--root', commit.hash]);
-  return out.split('\n').map((line) => line.trim()).filter(Boolean);
+    ? gitLines(cwdRoot, [...NAME_ARGS, 'diff', '--name-only', '--find-renames', '-z', `${commit.hash}^1`, commit.hash])
+    : gitLines(cwdRoot, [...NAME_ARGS, 'diff-tree', '--no-commit-id', '--name-only', '--no-renames', '-z', '-r', '--root', commit.hash]);
+  return splitNames(out);
+}
+
+/**
+ * Files changed by many plain commits in one git process: the same diff-tree
+ * per-commit call above, fed every hash on stdin. --always prints the hash
+ * even for an empty commit. Raw output frames every file as a ':'-led status
+ * field followed by its path, so a path is never mistaken for a commit hash,
+ * even a path spelled exactly like the next one.
+ */
+function plainCommitFiles(cwdRoot, commits) {
+  const found = new Map(commits.map((commit) => [commit.hash, []]));
+  if (!commits.length) return found;
+  const hashes = commits.map((commit) => commit.hash);
+  const out = gitLines(cwdRoot, [...NAME_ARGS, 'diff-tree', '--stdin', '--always', '--raw', '--no-renames', '-z', '-r', '--root'], {
+    input: `${hashes.join('\n')}\n`,
+    // Many commits' lists in one reply; the per-commit calls each had 1MB.
+    maxBuffer: Math.max(1, hashes.length) * 1024 * 1024,
+  });
+  const fields = splitNames(out);
+  let current = null;
+  for (let i = 0; i < fields.length; i++) {
+    const field = fields[i];
+    if (field.startsWith(':')) {
+      // Status field; with --no-renames exactly one path follows it.
+      if (current && i + 1 < fields.length) current.push(fields[i + 1]);
+      i += 1;
+    } else {
+      current = found.get(field) || null;
+    }
+  }
+  return found;
+}
+
+// Where git keeps state shared by every checkout of this repo (a linked
+// worktree points at its main repo). null when it cannot be found on disk.
+function gitCommonDir(root) {
+  if (process.env.GIT_DIR || process.env.GIT_COMMON_DIR) return null;
+  let dir = path.resolve(root);
+  for (;;) {
+    const dotGit = path.join(dir, '.git');
+    let stat = null;
+    try { stat = fs.statSync(dotGit); } catch { stat = null; }
+    if (stat && stat.isDirectory()) return dotGit;
+    if (stat && stat.isFile()) {
+      const match = fs.readFileSync(dotGit, 'utf8').match(/^gitdir:\s*(.+)$/m);
+      if (!match) return null;
+      const gitDir = path.resolve(dir, match[1].trim());
+      try {
+        return path.resolve(gitDir, fs.readFileSync(path.join(gitDir, 'commondir'), 'utf8').trim());
+      } catch {
+        return gitDir;
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+// A shallow clone cuts history at boundary commits, and those commits list
+// different files once the history is fetched. The saved lists are only good
+// for the shallow state they were read under; null means do not cache.
+function shallowStamp(root) {
+  const common = gitCommonDir(root);
+  if (!common) return null;
+  try {
+    return crypto.createHash('sha1').update(fs.readFileSync(path.join(common, 'shallow'))).digest('hex');
+  } catch (error) {
+    return error.code === 'ENOENT' ? 'full' : null;
+  }
+}
+
+// A commit's file list never changes, so it is saved by hash in the ignored
+// .atris/cache and the gauge (shown on every boot) only asks git about commits
+// it has not seen. Hashes this read used come first; older ones stay until the
+// cap, so a 7-day boot read and a 14-day report read do not evict each other.
+const REVISION_FILES_CACHE = 'revision-files.json';
+const REVISION_FILES_CACHE_MAX = 5000;
+
+function loadRevisionFilesCache(root) {
+  const shallow = ignoredCache.cacheEnabled(root) ? shallowStamp(root) : null;
+  const cache = { root, shallow, entries: {}, used: {}, dirty: false, writable: Boolean(shallow) };
+  if (!cache.writable) return cache;
+  const parsed = ignoredCache.readCacheJson(root, REVISION_FILES_CACHE);
+  if (parsed && parsed.version === 1 && parsed.shallow === shallow && parsed.entries && typeof parsed.entries === 'object') {
+    cache.entries = parsed.entries;
+  }
+  return cache;
+}
+
+function saveRevisionFilesCache(cache) {
+  if (!cache.writable || !cache.dirty) return;
+  const entries = { ...cache.used };
+  let count = Object.keys(entries).length;
+  for (const [hash, files] of Object.entries(cache.entries)) {
+    if (count >= REVISION_FILES_CACHE_MAX) break;
+    if (entries[hash] || !Array.isArray(files)) continue;
+    entries[hash] = files;
+    count += 1;
+  }
+  ignoredCache.writeCacheJson(cache.root, REVISION_FILES_CACHE, { version: 1, shallow: cache.shallow, entries });
 }
 
 /**
@@ -1150,10 +1266,27 @@ function collectRevisionSignals(root, options = {}) {
   // commits count as revision signals.
   const humans = commits.filter((c) => !c.isAgent && c.parents.length < 2);
 
-  const filesCache = new Map();
+  // Every landing's files are needed, and a human commit's only when it falls
+  // inside some landing's window. Plain commits missing from the cache are
+  // read in one batch; merges keep their own first-parent diff.
+  const cache = loadRevisionFilesCache(root);
+  const needed = [...landings, ...humans.filter((human) => landings.some((landing) => human.ms > landing.ms && human.ms <= landing.ms + REVISION_WINDOW_MS))];
+  const missing = [];
+  for (const commit of needed) {
+    const hit = cache.entries[commit.hash];
+    if (Array.isArray(hit)) cache.used[commit.hash] = hit;
+    else if (commit.parents.length < 2) missing.push(commit);
+  }
+  for (const [hash, files] of plainCommitFiles(root, missing)) {
+    cache.used[hash] = files;
+    cache.dirty = true;
+  }
   const filesOf = (commit) => {
-    if (!filesCache.has(commit.hash)) filesCache.set(commit.hash, commitFiles(root, commit));
-    return filesCache.get(commit.hash);
+    if (!cache.used[commit.hash]) {
+      cache.used[commit.hash] = commitFiles(root, commit);
+      cache.dirty = true;
+    }
+    return cache.used[commit.hash];
   };
 
   const revisions = [];
@@ -1177,6 +1310,7 @@ function collectRevisionSignals(root, options = {}) {
       });
     }
   }
+  saveRevisionFilesCache(cache);
 
   return {
     schema: REVISIONS_SCHEMA,

package/commands/integrations.js

@@ -33,11 +33,12 @@ const {
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { stateHome } = require('../lib/state-home');
 const readline = require('readline');
 const { spawnSync } = require('child_process');
 const { sleepSync } = require('../lib/sleep-sync');
 
-const CALENDAR_CACHE_PATH = path.join(os.homedir(), '.atris', 'calendar-events-cache.json');
+const CALENDAR_CACHE_PATH = path.join(stateHome(), '.atris', 'calendar-events-cache.json');
 const GMAIL_CONNECT_POLL_MS = 3000;
 const GMAIL_CONNECT_TIMEOUT_MS = 3 * 60 * 1000;
 const GMAIL_SEND_USAGE = 'usage: atris gmail send <to> <subject> <body...> [--body-file <path>] [--account <id>]';
@@ -182,7 +183,7 @@ function parseGmailVerdictsArgs(args = []) {
 
 function gmailAccountStatePath() {
   return process.env.ATRIS_GMAIL_ACCOUNT_FILE
-    || path.join(os.homedir(), '.atris', 'gmail-account.json');
+    || path.join(stateHome(), '.atris', 'gmail-account.json');
 }
 
 function readGmailStickyAccount() {
@@ -1794,7 +1795,7 @@ function normalizeContactLabel(value) {
 }
 
 function imessageLookupCachePath() {
-  return path.join(os.homedir(), '.atris', 'cache', 'imessage-contacts.json');
+  return path.join(stateHome(), '.atris', 'cache', 'imessage-contacts.json');
 }
 
 function readImessageLookupCache() {

package/commands/loops.js

@@ -13,6 +13,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { stateHome } = require('../lib/state-home');
 const { execSync, spawnSync } = require('child_process');
 
 const MAX_LOG_AGE_DAYS = 14;
@@ -26,7 +27,7 @@ const SCAFFOLD_FILES = [
 ];
 
 function heartbeatDir() {
-  return process.env.ATRIS_HEARTBEAT_DIR || path.join(os.homedir(), '.atris', 'heartbeat');
+  return process.env.ATRIS_HEARTBEAT_DIR || path.join(stateHome(), '.atris', 'heartbeat');
 }
 
 function readJson(filePath, fallback) {

package/commands/member.js

@@ -7,6 +7,7 @@ const { loadCredentials } = require('../utils/auth');
 const { resolveBackendRoot } = require('../utils/backend-root');
 const { apiRequestJson } = require('../utils/api');
 const { runAliveTick } = require('../lib/member-alive');
+const { memberRefusalReason } = require('../lib/member-type');
 const { defaultObjectiveRunner } = require('../lib/default-runner');
 const { readJson, writeJson } = require('../lib/json-file');
 const { sleepSync } = require('../lib/sleep-sync');
@@ -306,6 +307,28 @@ function nearestMemberSlug(name, slugs) {
   return bestScore <= Math.max(2, Math.floor(needle.length / 3)) ? best : null;
 }
 
+// A person is never run as an agent. Reads the member's own type and returns
+// the plain refusal sentence, or '' when the member can run.
+function memberRefusalFor(name, memberFile) {
+  try {
+    return memberRefusalReason(name, parseFrontmatter(fs.readFileSync(memberFile, 'utf8')) || {});
+  } catch {
+    return '';
+  }
+}
+
+// Same as requireMemberDir, then stops with a non-zero exit for a human or
+// odd-typed member. Every path that runs a member as an agent starts here.
+function requireRunnableMember(name) {
+  const paths = requireMemberDir(name);
+  const reason = memberRefusalFor(name, paths.memberFile);
+  if (reason) {
+    console.error(reason);
+    process.exit(1);
+  }
+  return paths;
+}
+
 function requireMemberDir(name) {
   if (!name) {
     console.error('Usage: atris member <goal|tick|review> <name> ...');
@@ -1077,7 +1100,7 @@ function memberRun(name, ...args) {
   }
 
   const asJson = hasFlag(args, '--json');
-  const paths = requireMemberDir(name);
+  const paths = requireRunnableMember(name);
   // Parking only hides a member from the team views; a run by name still goes.
   const { isParkedText } = require('../lib/member-park');
   try {
@@ -4221,6 +4244,8 @@ name: ${name}
 role: ${role}
 description: ${description || `Handles ${role.toLowerCase()} tasks`}
 version: 1.0.0
+# ai or human; a human member is a person and Atris never acts as them
+type: ai
 
 skills: []
 
@@ -5418,7 +5443,12 @@ function isWikiMinerNoiseName(value) {
   const name = compactSentence(value || '', 120);
   if (!name) return true;
   if (/^[A-Z]{2,}$/.test(name)) return false;
-  return /^(?:i|me|my|mine|myself|we|us|our|ours|ourselves|you|your|yours|yourself|yourselves|he|him|his|himself|she|her|hers|herself|it|its|itself|they|them|their|theirs|themselves|this|that|these|those|the|wiki|mission)$/i.test(name);
+  return /^(?:i|me|my|mine|myself|we|us|our|ours|ourselves|you|your|yours|yourself|yourselves|he|him|his|himself|she|her|hers|herself|it|its|itself|they|them|their|theirs|themselves|this|that|these|those|here|there|where|when|what|who|whom|which|why|how|everything|nothing|something|anything|everyone|anyone|someone|nobody|everybody|anybody|somebody|none|the|wiki|mission)$/i.test(name);
+}
+
+function isWikiMinerSelfLoop(relationship) {
+  const from = lowerCompact(relationship?.from);
+  return from !== '' && from === lowerCompact(relationship?.to);
 }
 
 function normalizeWikiMinerExtraction(raw) {
@@ -5437,7 +5467,7 @@ function normalizeWikiMinerExtraction(raw) {
       to: compactSentence(relationship?.to || '', 120),
       type: allowedRelationTypes.has(String(relationship?.type || '').toLowerCase()) ? String(relationship.type).toLowerCase() : 'uses',
     }))
-    .filter((relationship) => !isWikiMinerNoiseName(relationship.from) && !isWikiMinerNoiseName(relationship.to));
+    .filter((relationship) => !isWikiMinerNoiseName(relationship.from) && !isWikiMinerNoiseName(relationship.to) && !isWikiMinerSelfLoop(relationship));
   return { entities, relationships };
 }
 
@@ -5459,7 +5489,9 @@ function heuristicWikiMinerExtraction(pagePath, pageContent) {
   }
   const entities = [{ type: 'concept', name: title }];
   for (const name of [...candidates].slice(0, 12)) entities.push({ type: /agent|api|sdk|cli|hub|system/i.test(name) ? 'system' : 'concept', name });
-  const relationships = [...candidates].slice(0, 12).map((name) => ({ from: title, to: name, type: 'uses' }));
+  const relationships = [...candidates].slice(0, 12)
+    .map((name) => ({ from: title, to: name, type: 'uses' }))
+    .filter((relationship) => !isWikiMinerSelfLoop(relationship));
   return { entities, relationships };
 }
 
@@ -5513,11 +5545,12 @@ function mergeWikiGraph(graph, extraction, sourcePath) {
 
   const relationshipMap = new Map();
   for (const relationship of graph.relationships || []) {
-    if (isWikiMinerNoiseName(relationship.from) || isWikiMinerNoiseName(relationship.to)) continue;
+    if (isWikiMinerNoiseName(relationship.from) || isWikiMinerNoiseName(relationship.to) || isWikiMinerSelfLoop(relationship)) continue;
     const key = `${lowerCompact(relationship.from)}|${String(relationship.type || 'uses').toLowerCase()}|${lowerCompact(relationship.to)}`;
     relationshipMap.set(key, { ...relationship, sources: Array.isArray(relationship.sources) ? relationship.sources : [] });
   }
   for (const relationship of extraction.relationships || []) {
+    if (isWikiMinerNoiseName(relationship.from) || isWikiMinerNoiseName(relationship.to) || isWikiMinerSelfLoop(relationship)) continue;
     const key = `${lowerCompact(relationship.from)}|${relationship.type}|${lowerCompact(relationship.to)}`;
     const existing = relationshipMap.get(key) || { from: relationship.from, to: relationship.to, type: relationship.type, sources: [] };
     if (sourcePath && !existing.sources.includes(sourcePath)) existing.sources.push(sourcePath);
@@ -5794,7 +5827,6 @@ async function callSupervisorLlm(receipts, logs) {
     const output = { isTTY: false, write() { return true; } };
     const result = await postTurn(supervisorPrompt(receipts, logs), {
       mode: process.env.ATRIS_SUPERVISOR_LLM_MODE || 'fast',
-      route: 'local',
       cwd: process.cwd(),
       output,
       color: false,
@@ -5880,11 +5912,21 @@ async function runSupervisorWake(name, paths, { execute = false } = {}) {
       analysis = normalizeSupervisorAnalysis(llm.analysis, { status: 'ok', llm_source: llm.source });
       if (!analysis) {
         reason = 'llm_json_parse_failed';
-        analysis = emptySupervisorRecommendations({ status: 'parse_error', llm_source: llm.source, llm_error: 'invalid_analysis_shape' });
+        analysis = {
+          ...fallbackSupervisorAnalysis(receipts),
+          status: 'parse_error',
+          llm_source: llm.source,
+          llm_error: 'invalid_analysis_shape',
+        };
       }
     } else if (llm?.error) {
       reason = llm.error === 'invalid_json' ? 'llm_json_parse_failed' : 'llm_analysis_failed';
-      analysis = emptySupervisorRecommendations({ status: llm.error === 'invalid_json' ? 'parse_error' : 'llm_error', llm_source: llm.source, llm_error: llm.error });
+      analysis = {
+        ...fallbackSupervisorAnalysis(receipts),
+        status: llm.error === 'invalid_json' ? 'parse_error' : 'llm_error',
+        llm_source: llm.source,
+        llm_error: llm.error,
+      };
     } else {
       reason = 'llm_not_configured';
       analysis = fallbackSupervisorAnalysis(receipts);
@@ -7326,7 +7368,7 @@ async function runGeneralistWake(name, paths, { execute = false, domainInput = {
     record: domain.ok && proof.status === 'ok',
     libraryBefore: crossDomainLibraryBefore,
     receiptPath,
-    proofPath,
+    proofPath: execute ? proofPath : null,
   });
   proof.learning = {
     library_path: path.relative(root, learning.library_path),
@@ -7757,6 +7799,24 @@ function wakeRuleDirtyMemberScope(ctx) {
   };
 }
 
+// Rule: a goal pinned to a terminal mission must not mint another doomed tick.
+// The goal stays active until a human retires it or revives the mission, so the
+// wake surfaces that decision instead of proposing `member tick --goal` on a
+// dead spine. Unknown mission ids pass through: they may live in a worktree.
+function wakeRuleTerminalMissionGoal(ctx) {
+  const mission = ctx.goalTerminalMission;
+  if (!ctx.goal || !mission) return null;
+  return {
+    decision: 'ask',
+    reason: `goal_mission_terminal:${mission.status}`,
+    needs_user: true,
+    ask: `Goal "${ctx.goal.title}" is pinned to mission ${mission.id} (${mission.status}). Retire the goal or revive the mission, then wake again.`,
+    next_command: `atris member goal-from-mission ${ctx.name}`,
+    goal: ctx.goal,
+    current_experiment: ctx.current || null,
+  };
+}
+
 // Rule: nothing blocks the member, so take the safe next bounded step.
 function wakeRuleSafeBoundedTick(ctx) {
   return {
@@ -7777,6 +7837,7 @@ const WAKE_DECISION_RULES = [
   wakeRuleOpenReviewableProposal,
   wakeRuleScoredNonTickCandidate,
   wakeRuleDirtyMemberScope,
+  wakeRuleTerminalMissionGoal,
   wakeRuleSafeBoundedTick,
 ];
 
@@ -7790,6 +7851,8 @@ function wakeDecision(name, paths, { force = false, runtimeKind = memberRuntimeK
   const steering = readSteeringMemory(paths, name);
   const state = loadMemberGoals(name, paths);
   const goal = activeGoal(state);
+  const pinnedMission = goal?.mission_id ? memberRunMissionMap().get(String(goal.mission_id).trim()) || null : null;
+  const goalTerminalMission = pinnedMission && MISSION_TERMINAL_STATUSES.has(lowerCompact(pinnedMission.status || '')) ? pinnedMission : null;
   const current = memberOpenExperiment(state);
   const generalistDecision = wakeRuleGeneralistDomainFile(name, { purpose, steering, state, goal, current });
   if (generalistDecision) return generalistDecision;
@@ -7835,7 +7898,7 @@ function wakeDecision(name, paths, { force = false, runtimeKind = memberRuntimeK
     next_command: wakeScores.selected.next_command,
   } : null;
 
-  const ctx = { name, force, purpose, nowFile, steering, state, goal, current, blocked, evidence, workspace, checks, wakeScores };
+  const ctx = { name, force, purpose, nowFile, steering, state, goal, goalTerminalMission, current, blocked, evidence, workspace, checks, wakeScores };
   for (const rule of WAKE_DECISION_RULES) {
     const verdict = rule(ctx);
     if (verdict) return composeWakeDecision(ctx, verdict);
@@ -7863,6 +7926,8 @@ function wakeMemberEngine(name, root = process.cwd()) {
 
 async function runMemberWake(name, { execute = false, confirmed = false, force = false, domainInput = {} } = {}) {
   const paths = requireMemberDir(name);
+  const refusal = memberRefusalFor(name, paths.memberFile);
+  if (refusal) throw new Error(refusal);
   const runtimeKind = paths.runtimeKind || memberRuntimeKind(name);
   if (runtimeKind === 'auto-improver') {
     return runAutoImproverWake(name, paths, { execute, confirmed });
@@ -8176,6 +8241,7 @@ function clipText(value, max = 70) {
 }
 
 async function memberWake(name, ...args) {
+  if (name) requireRunnableMember(name);
   const asJson = hasFlag(args, '--json');
   const execute = hasFlag(args, '--execute') && !hasFlag(args, '--dry-run');
   const confirmed = hasFlag(args, '--confirm-autonomy-policy');
@@ -8223,14 +8289,15 @@ function collectFleetActivationRows(root = process.cwd()) {
       const goalPlane = memberGoalPlaneStatus(slug, paths);
       const activeMission = memberLiveMission(slug, missionMap);
       const latestMission = memberLatestMission(slug, missionMap);
-      const skipped = !goalPlane.goal && !activeMission;
+      const refusal = memberRefusalFor(slug, paths.memberFile);
+      const skipped = Boolean(refusal) || (!goalPlane.goal && !activeMission);
       return {
         member: slug,
         goal: goalPlane.goal || null,
         active_mission: activeMission || null,
         latest_mission: latestMission || null,
         skipped,
-        skip_reason: skipped ? 'no_goal_and_no_active_mission' : null,
+        skip_reason: refusal ? 'not_ai' : skipped ? 'no_goal_and_no_active_mission' : null,
       };
     })
     .sort((a, b) => a.member.localeCompare(b.member));
@@ -8263,7 +8330,7 @@ async function memberLoopAll(kind, ...args) {
   for (const row of rows) {
     if (row.skipped) {
       skipped.push(row);
-      if (!asJson) console.log(`Skip ${row.member}: no goal and no active mission.`);
+      if (!asJson) console.log(`Skip ${row.member}: ${row.skip_reason === 'not_ai' ? 'not an AI member.' : 'no goal and no active mission.'}`);
       continue;
     }
     if (!asJson) console.log(`Activate ${row.member}: ${row.goal ? 'goal' : `mission ${row.active_mission?.id || 'active'}`}`);
@@ -8675,7 +8742,7 @@ function memberLoopRecordResult(name, paths, lease, run) {
 // Driver: the phases above do the work; this reads as setup -> gate -> run -> record.
 async function memberLoop(name, ...args) {
   if (name === '--all' || name === 'all') return memberLoopAll('loop', ...args);
-  requireMemberDir(name);
+  requireRunnableMember(name);
   const asJson = hasFlag(args, '--json');
   const aliveMode = hasFlag(args, '--alive');
   const execute = hasFlag(args, '--execute');
@@ -8739,7 +8806,7 @@ async function memberLoop(name, ...args) {
 }
 
 async function memberTick(name, ...args) {
-  const paths = requireMemberDir(name);
+  const paths = requireRunnableMember(name);
   const asJson = hasFlag(args, '--json');
   const force = hasFlag(args, '--force');
   const goalId = readFlag(args, '--goal', '');

package/commands/mission.js

@@ -22,6 +22,7 @@ const {
 const {
   resolveClaudeRunnerModel,
   resolvePinnedRunnerModel,
+  runnerModelFor,
   resolveClaudeRunnerBin,
   resolveClaudeRunnerCommandTemplate,
   buildRunnerCommand,
@@ -568,6 +569,8 @@ function applyMissionRunnerProfile(runner) {
 // default model pin. Every other engine's CLI rejects a claude model name, so
 // it only ever takes an explicit pin (the mission's model or the roster
 // line's); '' lets the engine ride its own default.
+// A mission often still carries the claude model it was created with; an
+// engine that runs only its own models (codex, grok) drops it.
 const CLAUDE_FAMILY_RUNNER_ENGINES = new Set(['claude', 'fable', 'haiku']);
 
 function resolveMissionTickRunnerModel(mission) {
@@ -575,7 +578,7 @@ function resolveMissionTickRunnerModel(mission) {
   if (!engine || CLAUDE_FAMILY_RUNNER_ENGINES.has(engine)) {
     return resolveClaudeRunnerModel(mission);
   }
-  return resolvePinnedRunnerModel(mission);
+  return runnerModelFor(engine, resolvePinnedRunnerModel(mission));
 }
 
 function exitMissionError(message, code = 1, asJson = false) {

package/commands/pack-craft.js

@@ -1,8 +1,8 @@
 'use strict';
 
 const fs = require('fs');
-const os = require('os');
 const path = require('path');
+const { stateHome } = require('../lib/state-home');
 
 function slugify(value, fallback = 'atris-pack') {
   return String(value || fallback)
@@ -69,7 +69,7 @@ function isNonEmptyTarget(targetDir) {
 function defaultAuthor() {
   try {
     const creds = JSON.parse(
-      fs.readFileSync(path.join(os.homedir(), '.atris', 'credentials.json'), 'utf8')
+      fs.readFileSync(path.join(stateHome(), '.atris', 'credentials.json'), 'utf8')
     );
     if (creds && typeof creds.email === 'string' && creds.email.trim()) return creds.email.trim();
   } catch {

package/commands/publish.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
+const { stateHome } = require('../lib/state-home');
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 
@@ -104,7 +104,7 @@ async function publishAtris() {
   }
 
   // Save local copy
-  const localDir = path.join(os.homedir(), '.atris', 'templates', name.toLowerCase().replace(/[^a-z0-9-]/g, '-'));
+  const localDir = path.join(stateHome(), '.atris', 'templates', name.toLowerCase().replace(/[^a-z0-9-]/g, '-'));
   fs.mkdirSync(localDir, { recursive: true });
 
   for (const f of files) {

package/commands/radar.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { stateHome } = require('../lib/state-home');
 const { execFileSync } = require('child_process');
 const { parseScopeFlag, pathUnderRoot } = require('../lib/cli-scope');
 
@@ -346,7 +347,7 @@ function loadBusinessCollaboration(root, deps, team = {}, scorecardCount = count
   const business = readJsonFile(path.join(root, '.atris', 'business.json'), deps, null);
   const runtime = readJsonFile(path.join(root, '.atris', 'state', 'runtime.json'), deps, null);
   const sync = readJsonFile(path.join(root, '.atris', 'state', '_sync.json'), deps, null);
-  const cache = readJsonFile(path.join(deps.homeDir || os.homedir(), '.atris', 'businesses.json'), deps, {}) || {};
+  const cache = readJsonFile(path.join(deps.homeDir || stateHome(), '.atris', 'businesses.json'), deps, {}) || {};
   const slug = business?.slug || sync?.workspace_slug || null;
   const cacheEntry = slug && cache ? cache[slug] : null;
   const hasAtris = deps.exists(path.join(root, 'atris'));
@@ -804,7 +805,7 @@ function collectRadar(options = {}) {
     readlink: options.readlinkSync || fs.readlinkSync,
     readdir: options.readdirSync || fs.readdirSync,
     platform: options.platform || os.platform(),
-    homeDir: options.homeDir || os.homedir(),
+    homeDir: options.homeDir || stateHome(),
   };
   const nowMs = options.nowMs || Date.now();
   const tasks = loadTasks(root, deps);

package/commands/router.js

@@ -2,8 +2,8 @@
 
 const crypto = require('node:crypto');
 const fs = require('node:fs');
-const os = require('node:os');
 const path = require('node:path');
+const { stateHome } = require('../lib/state-home');
 const { spawnSync } = require('node:child_process');
 const { loadOverrides, pickLane } = require('../lib/ax-auto-lane');
 
@@ -28,7 +28,7 @@ function readFirstNamedFlag(args, names) {
 }
 
 function resolveRouterPaths(args = [], env = process.env) {
-  const home = env.HOME || os.homedir();
+  const home = stateHome(env);
   return {
     picks: path.resolve(readFirstNamedFlag(args, ['--picks', '--picks-path'])
       || env.ATRIS_ROUTER_PICKS_PATH