atris 3.16.1 → 3.22.0

package/commands/autopilot.js

@@ -12,6 +12,11 @@ const { execSync, execFileSync, spawnSync } = require('child_process');
 const readline = require('readline');
 const { getLogPath, ensureLogDirectory, createLogFile } = require('../lib/journal');
 const { parseTodo } = require('../lib/todo');
+const {
+  buildRunnerCommand,
+  buildRunnerAvailabilityCommand,
+  resolveClaudeRunnerBin,
+} = require('../lib/runner-command');
 const { findStalePages, findStaleTasks, healBrokenMapRefs } = require('./clean');
 const {
   buildScorecardData,
@@ -194,7 +199,7 @@ async function suggestNextTask(cwd, skipped = new Set(), { auto = false } = {})
   const { logFile } = getLogPath();
   if (fs.existsSync(logFile)) {
     const content = fs.readFileSync(logFile, 'utf8');
-    const inboxMatch = content.match(/## Inbox\n([\s\S]*?)(?=\n##|$)/);
+    const inboxMatch = content.match(/## Inbox\r?\n([\s\S]*?)(?=\r?\n##|$)/);
     if (inboxMatch && inboxMatch[1].trim()) {
       const items = inboxMatch[1].trim().split('\n').filter(l => {
         const t = l.trim();
@@ -393,12 +398,23 @@ function askHuman(taskTitle) {
 }
 
 /**
- * Type-check a child_process error as a timeout/kill. Node's execSync attaches
- * `code: 'ETIMEDOUT'` and `signal` on timeout — it does NOT set `killed`, so a
- * `killed`-only guard is dead code on the exact error it was written for
- * (lesson: etimedout-error-shape, 2026-06-10).
+ * Type-check a child_process error as a real wall-clock timeout. Node's
+ * execSync attaches `code: 'ETIMEDOUT'` (plus `signal`) on timeout — it does
+ * NOT set `killed`, so a `killed`-only guard is dead code on the exact error
+ * it was written for (lesson: etimedout-error-shape, 2026-06-10). A bare
+ * `signal` without ETIMEDOUT is NOT a timeout: it's an OOM SIGKILL or an
+ * external SIGTERM, and calling it a timeout misdiagnoses the cause.
  */
 function isPhaseTimeoutError(err) {
+  return Boolean(err && err.code === 'ETIMEDOUT');
+}
+
+/**
+ * Any abnormal child death — timeout or signal kill. The group sweep in
+ * execPhaseCommandSync uses this wider net (orphans need sweeping either
+ * way); the thrown message uses the narrow predicate to name the cause.
+ */
+function isPhaseKillError(err) {
   return Boolean(err && (err.killed || err.code === 'ETIMEDOUT' || err.signal));
 }
 
@@ -416,7 +432,7 @@ function execPhaseCommandSync(cmd, opts = {}) {
   try {
     return execSync(cmd, { ...opts, detached: true });
   } catch (err) {
-    if (isPhaseTimeoutError(err) && err.pid) {
+    if (isPhaseKillError(err) && err.pid) {
       try {
         process.kill(-err.pid, 'SIGKILL');
       } catch (sweepErr) {
@@ -428,7 +444,7 @@ function execPhaseCommandSync(cmd, opts = {}) {
 }
 
 /**
- * Run a phase via claude -p subprocess.
+ * Run a phase via the configured runner subprocess.
  */
 function executePhaseDetailed(phase, context, options = {}) {
   const { verbose = false, timeout = PHASE_TIMEOUT } = options;
@@ -439,7 +455,7 @@ function executePhaseDetailed(phase, context, options = {}) {
 
   try {
     const cmd = options.cmdOverride
-      || `claude -p "$(cat '${tmpFile.replace(/'/g, "'\\''")}')" --allowedTools "Bash,Read,Write,Edit,Glob,Grep"`;
+      || buildRunnerCommand({ promptFile: tmpFile, allowedTools: 'Bash,Read,Write,Edit,Glob,Grep' });
     const env = { ...process.env };
     delete env.CLAUDECODE;
     const output = execPhaseCommandSync(cmd, {
@@ -456,7 +472,10 @@ function executePhaseDetailed(phase, context, options = {}) {
   } catch (err) {
     try { fs.unlinkSync(tmpFile); } catch {}
     if (isPhaseTimeoutError(err)) {
-      throw new Error(`${phase} phase timed out after ${timeout / 1000}s (claude -p hit the wall; any work it committed survives — reconcile from pre-tick HEADs)`);
+      throw new Error(`${phase} phase timed out after ${timeout / 1000}s (configured runner hit the wall; any work it committed survives — reconcile from pre-tick HEADs)`);
+    }
+    if (isPhaseKillError(err)) {
+      throw new Error(`${phase} phase killed by ${err.signal || 'a signal'} before the ${timeout / 1000}s wall — not a timeout; check memory pressure or an external supervisor`);
     }
     if (err.stdout) {
       return { prompt, output: err.stdout };
@@ -1178,14 +1197,14 @@ function parseProposedBlock(lines) {
 }
 
 /**
- * Default executor for plan-review: spawn a fresh claude -p call.
+ * Default executor for plan-review: spawn a fresh configured runner call.
  * Kept thin so tests can inject a stub via options.planReviewExec.
  */
 function defaultPlanReviewExecutor(prompt, { cwd, timeout = 180000 } = {}) {
   const tmpFile = path.join(cwd, '.autopilot-plan-review.tmp');
   fs.writeFileSync(tmpFile, prompt);
   try {
-    const cmd = `claude -p "$(cat '${tmpFile.replace(/'/g, "'\\''")}')" --allowedTools "Bash,Read,Grep,Glob"`;
+    const cmd = buildRunnerCommand({ promptFile: tmpFile, allowedTools: 'Bash,Read,Grep,Glob' });
     const env = { ...process.env };
     delete env.CLAUDECODE;
     const output = execPhaseCommandSync(cmd, {
@@ -2827,7 +2846,7 @@ function getLessonVerdict(lessonLine) {
 /**
  * Propose 3 candidate next horizons for the autopilot loop. Combines
  * `getIdleTickCount` + `getRecentSignals` into a prompt asking the LLM
- * to imagine what to work on next, spawns `claude -p`, and parses the
+ * to imagine what to work on next, uses the shared runner command, and parses the
  * JSON response into `[{ title, confidence, rationale }]`.
  *
  * Filters out candidates derived from resolved lessons (bug pattern no
@@ -2882,7 +2901,7 @@ Reply with the JSON array and nothing else.`;
 
   let output = '';
   try {
-    const cmd = `claude -p "$(cat '${tmpFile.replace(/'/g, "'\\''")}')"`;
+    const cmd = buildRunnerCommand({ promptFile: tmpFile });
     const env = { ...process.env };
     delete env.CLAUDECODE;
     output = execPhaseCommandSync(cmd, {
@@ -2897,6 +2916,9 @@ Reply with the JSON array and nothing else.`;
     if (isPhaseTimeoutError(err)) {
       throw new Error(`horizon-proposal phase timed out after ${PHASE_TIMEOUT / 1000}s`);
     }
+    if (isPhaseKillError(err)) {
+      throw new Error(`horizon-proposal phase killed by ${err.signal || 'a signal'} before the ${PHASE_TIMEOUT / 1000}s wall — not a timeout`);
+    }
     throw err;
   } finally {
     try { fs.unlinkSync(tmpFile); } catch {}
@@ -2905,7 +2927,7 @@ Reply with the JSON array and nothing else.`;
   const start = output.indexOf('[');
   const end = output.lastIndexOf(']');
   if (start === -1 || end === -1 || end <= start) {
-    throw new Error('proposeCandidateHorizons: claude -p returned no JSON array');
+    throw new Error('proposeCandidateHorizons: configured runner returned no JSON array');
   }
   const jsonText = output.slice(start, end + 1);
 
@@ -3000,8 +3022,8 @@ async function autopilotAtris(description, options = {}) {
     process.exit(1);
   }
 
-  try { execSync('which claude', { stdio: 'pipe' }); } catch {
-    console.error('claude CLI not found. Install Claude Code first.');
+  try { execSync(buildRunnerAvailabilityCommand(), { stdio: 'pipe' }); } catch {
+    console.error(`${resolveClaudeRunnerBin()} CLI not found. Set ATRIS_RUNNER_BIN (or legacy ATRIS_CLAUDE_BIN), or install the configured runner first.`);
     process.exit(1);
   }
 
@@ -3546,7 +3568,7 @@ function isStillTrue(fact, cwd) {
 /**
  * Ask a local model whether a task/fact is still relevant.
  * Called when isStillTrue returns 'unverified' — the mechanical check
- * couldn't confirm or deny, so we ask claude -p to inspect the codebase.
+ * couldn't confirm or deny, so we ask the configured runner to inspect the codebase.
  *
  * @param {{ title: string, age: number, source?: string }} fact
  * @param {string} cwd - workspace root
@@ -3569,7 +3591,7 @@ Search the codebase to verify. Reply: YES <reason> or NO <reason>`;
   try {
     const env = { ...process.env };
     delete env.CLAUDECODE;
-    const cmd = `claude -p "$(cat '${tmpFile.replace(/'/g, "'\\''")}')" --allowedTools "Bash,Read,Glob,Grep"`;
+    const cmd = buildRunnerCommand({ promptFile: tmpFile, allowedTools: 'Bash,Read,Glob,Grep' });
     const output = execPhaseCommandSync(cmd, {
       cwd,
       encoding: 'utf8',
@@ -3636,6 +3658,7 @@ module.exports = {
   scanAnomalies,
   verifyJudgeIntegrity,
   maybeWriteCompletedEndgameScorecard,
+  readEndgameState,
   renderHumanSuggestion,
   renderHumanTickIntro,
   proposeCandidateHorizons,
@@ -3653,6 +3676,7 @@ module.exports = {
   shouldSkipAutoHumanGate,
   writeLesson,
   isPhaseTimeoutError,
+  isPhaseKillError,
   execPhaseCommandSync,
   executePhaseDetailed,
   lessonSlug

package/commands/brain.js

@@ -3,6 +3,8 @@ const path = require('path');
 const crypto = require('crypto');
 const { spawnSync } = require('child_process');
 const { refreshNowFile } = require('./now');
+const escapeRegExp = require('../lib/escape-regexp');
+const { hasRenderedSections, isOpenSection, isDoneSection } = require('../lib/todo-sections');
 
 const GENERATED_START = '<!-- ATRIS_BRAIN_COMPILE:START -->';
 const GENERATED_END = '<!-- ATRIS_BRAIN_COMPILE:END -->';
@@ -296,7 +298,8 @@ function resolveStateRoot(root) {
 
 function countTodoItems(todoText) {
   const text = String(todoText || '');
-  const hasRenderedSections = /^##\s+(Backlog|In Progress|Blocked|Completed)\s*$/m.test(text);
+  // Section classification (incl. emoji-decorated headings) lives in lib/todo-sections.
+  const rendered = hasRenderedSections(text);
   let section = null;
   let unchecked = 0;
   let checked = 0;
@@ -317,22 +320,46 @@ function countTodoItems(todoText) {
     const isTitled = /^\s*-\s+(?:\[[ xX]\]\s+)?\*\*[^*]+:?\*\*/.test(line);
     if (isUnchecked) unchecked += 1;
     if (isChecked) checked += 1;
-    if (!hasRenderedSections && (isUnchecked || (isTitled && !isChecked))) legacyOpen += 1;
+    if (!rendered && (isUnchecked || (isTitled && !isChecked))) legacyOpen += 1;
     if (!isTitled) continue;
 
     titled += 1;
-    if (hasRenderedSections && ['Backlog', 'In Progress'].includes(section)) renderedOpen += 1;
-    if (hasRenderedSections && section === 'Completed') renderedDone += 1;
+    if (rendered && isOpenSection(section)) renderedOpen += 1;
+    if (rendered && isDoneSection(section)) renderedDone += 1;
   }
 
   return {
-    open: hasRenderedSections ? renderedOpen : legacyOpen,
+    open: rendered ? renderedOpen : legacyOpen,
     checked,
     titled,
-    done: hasRenderedSections ? renderedDone : checked + (text.match(/~~|DONE|✅/g) || []).length,
+    done: rendered ? renderedDone : checked + (text.match(/~~|DONE|✅/g) || []).length,
   };
 }
 
+function parseTodoEndgame(todoText) {
+  const text = String(todoText || '');
+  const fields = {};
+  let inEndgame = false;
+
+  for (const line of text.split(/\r?\n/)) {
+    const heading = line.match(/^##\s+(.+?)\s*$/);
+    if (heading) {
+      inEndgame = heading[1].trim().toLowerCase() === 'endgame';
+      continue;
+    }
+    if (!inEndgame) continue;
+
+    const field = line.match(/^\*\*(Slug|Horizon|Source):\*\*\s*(.*?)\s*$/i);
+    if (field) fields[field[1].toLowerCase()] = field[2].trim();
+  }
+
+  const slug = fields.slug || null;
+  const horizon = fields.horizon || null;
+  const source = fields.source || null;
+  if (!slug && !horizon && !source) return null;
+  return { slug, horizon, source };
+}
+
 const EXECUTABLE_TASK_STATUSES = new Set(['open', 'claimed']);
 const COMPLETED_TASK_STATUSES = new Set(['done', 'completed', 'accepted']);
 
@@ -350,15 +377,33 @@ function isCertifiedReviewTask(task) {
   return Boolean(metadata.agent_certified || review.agent_certified || passCount >= 2);
 }
 
+function isAgentNeededReviewTask(task) {
+  if (String(task?.status || '').toLowerCase() !== 'review') return false;
+  if (isCertifiedReviewTask(task)) return false;
+  const metadata = task.metadata || {};
+  const review = task.review || {};
+  const approvalStatus = String(metadata.approval_status || review.approval_status || 'pending').toLowerCase();
+  if (approvalStatus && approvalStatus !== 'pending') return false;
+  const passCount = Number(metadata.agent_review_pass_count || review.agent_review_pass_count || 0);
+  return passCount < 2;
+}
+
 function summarizeTaskProjection(root) {
   const tasks = readTaskProjectionTasks(root);
   if (!tasks) return null;
 
   const counts = {};
   const certifiedReviewTasks = [];
+  const agentNeededReviewTasks = [];
   for (const task of tasks) {
     const status = String(task?.status || '').toLowerCase();
     counts[status] = (counts[status] || 0) + 1;
+    if (isAgentNeededReviewTask(task)) {
+      agentNeededReviewTasks.push({
+        ref: task.display_id || task.legacy_ref || task.id,
+        title: task.title || 'Untitled task',
+      });
+    }
     if (isCertifiedReviewTask(task)) {
       certifiedReviewTasks.push({
         ref: task.display_id || task.legacy_ref || task.id,
@@ -370,6 +415,7 @@ function summarizeTaskProjection(root) {
   return {
     tasks,
     counts,
+    agentNeededReviewTasks,
     certifiedReviewTasks,
   };
 }
@@ -466,6 +512,7 @@ function collectState(root) {
     slug: business.slug || path.basename(root),
     business,
     todo: countWorkItems(root, todoText),
+    endgame: parseTodoEndgame(todoText),
     taskProjection: summarizeTaskProjection(root),
     hasNow: nowText.length > 0,
     nowHeading: firstHeading(nowText, null),
@@ -628,7 +675,7 @@ function parseContributionCard(text, member) {
   if (!text || !member) return null;
   const firstName = String(member.name || member.slug || '').split(/\s+/)[0].toLowerCase();
   const sections = String(text).split(/\n(?=##\s+)/);
-  const memberSections = sections.filter(section => new RegExp(`^##\\s+${firstName}\\b`, 'i').test(section.trim()));
+  const memberSections = sections.filter(section => new RegExp(`^##\\s+${escapeRegExp(firstName)}\\b`, 'i').test(section.trim()));
   const section = (
     memberSections.find(candidate => /current_score_signal\s*:/i.test(candidate))
     || memberSections[0]
@@ -708,12 +755,25 @@ function memberNextMove(member, state = null) {
   const name = member.name || member.slug;
   const context = `${member.startHere}\n${member.goals}`;
   const identity = `${member.slug}\n${member.name}`;
+  const agentNeededReview = state?.taskProjection?.agentNeededReviewTasks?.[0] || null;
+  const agentNeededReviewMove = agentNeededReview
+    ? `${name}: run the agent-safe review lane for ${agentNeededReview.ref}: ` +
+      `\`atris task review-chat ${agentNeededReview.ref} --as codex-review\`, then run the verifier named in the review packet and certify or revise without accepting XP.`
+    : null;
   const certifiedReview = state?.taskProjection?.certifiedReviewTasks?.[0] || null;
+  const certifiedReviewRefs = (state?.taskProjection?.certifiedReviewTasks || [])
+    .map(task => task.ref)
+    .filter(Boolean);
   const certifiedReviewMove = certifiedReview
     ? `${name}: hand off certified review ${certifiedReview.ref} to the operator: run ` +
       `\`atris task accept ${certifiedReview.ref}\` if approved or ` +
       `\`atris task revise ${certifiedReview.ref} --note "<what must change>"\` if not; do not create new work until this checkpoint is clear.`
     : null;
+  const codexEndgameMove = certifiedReviewRefs.length > 0 && member.slug === 'codex-executor'
+    ? `${name}: certified reviews ${certifiedReviewRefs.slice(0, 3).join(', ')} are human-only; do not accept XP. ` +
+      `Create the next bounded Codex task from Endgame ${state?.endgame?.slug || 'current-horizon'}: ` +
+      `${state?.endgame?.horizon || 'the highest-leverage system gap'}; include files, verifier, and stop rule before editing.`
+    : null;
   if (member.slug === 'justin' || /justin/i.test(member.name || '')) {
     return `${name}: run one customer-moving GTM rep, update the relevant workspace state within 10 minutes, and leave a scorecard.`;
   }
@@ -728,6 +788,7 @@ function memberNextMove(member, state = null) {
     return `${name}: choose or create one bounded mission step, run its verifier, and close it with proof, a scorecard, and the next move.`;
   }
   if (/validator|reviewer/i.test(identity)) {
+    if (agentNeededReviewMove) return agentNeededReviewMove;
     if (certifiedReviewMove) return certifiedReviewMove;
     if ((state?.todo?.open || 0) === 0 && (state?.todo?.done || 0) === 0) {
       return `${name}: wait for one concrete artifact or ask Navigator to create a reviewable task with verifier, proof target, and residual-risk checklist.`;
@@ -736,6 +797,8 @@ function memberNextMove(member, state = null) {
   }
   if (/executor|builder/i.test(identity)) {
     if ((state?.todo?.open || 0) === 0) {
+      if (agentNeededReviewMove) return agentNeededReviewMove;
+      if (codexEndgameMove) return codexEndgameMove;
       if (certifiedReviewMove) return certifiedReviewMove;
       return `${name}: ask Navigator to create one bounded task with files, verifier, and stop rule before making a patch.`;
     }
@@ -745,6 +808,7 @@ function memberNextMove(member, state = null) {
     return `${name}: turn one messy or unclaimed intent into a MAP-backed plan with ASCII visualization, exact files, verifier, rollback, and a review-ready task.`;
   }
   if (/launcher|closer/i.test(identity)) {
+    if (agentNeededReviewMove) return agentNeededReviewMove;
     if (certifiedReviewMove) return certifiedReviewMove;
     if ((state?.todo?.done || 0) === 0) {
       return `${name}: wait for one validated task receipt before closeout, or ask Validator to produce a review decision with proof.`;
@@ -1571,4 +1635,7 @@ module.exports = {
   verifyActivationCard,
   verifyActivationGallery,
   verifyBrain,
+  parseContributionCard,
+  escapeRegExp,
+  countTodoItems,
 };

package/commands/brainstorm.js

@@ -2,6 +2,15 @@ const fs = require('fs');
 const path = require('path');
 const readline = require('readline');
 const { getLogPath, ensureLogDirectory, createLogFile } = require('../lib/journal');
+// Inbox helpers live canonically (and CRLF-tolerant) in lib/file-ops; brainstorm
+// used to carry byte-identical local copies that silently missed CRLF journals.
+const {
+  parseInboxItems,
+  replaceInboxSection,
+  addInboxItemToContent,
+  getNextInboxId,
+  addInboxIdea,
+} = require('../lib/file-ops');
 const { loadConfig } = require('../utils/config');
 const { loadCredentials, ensureValidCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
@@ -351,69 +360,11 @@ function brainstormAbortError() {
   return error;
 }
 
-function addInboxIdea(logFile, summary) {
-  const content = fs.readFileSync(logFile, 'utf8');
-  const nextId = getNextInboxId(content);
-  const updated = addInboxItemToContent(content, nextId, summary);
-  fs.writeFileSync(logFile, updated);
-  return nextId;
-}
-
-function parseInboxItems(content) {
-  const match = content.match(/## Inbox\n([\s\S]*?)(?=\n##|\n---|$)/);
-  if (!match) {
-    return [];
-  }
-  const body = match[1];
-  const lines = body.split('\n');
-  const items = [];
-  lines.forEach((line) => {
-    const trimmed = line.trim();
-    if (!trimmed) return;
-    if (trimmed.startsWith('(Empty')) return;
-    const parsed = trimmed.match(/^- \*\*I(\d+):\*\*\s*(.+)$|^- \*\*I(\d+):\s+(.+)$/);
-    if (parsed) {
-      const id = parseInt(parsed[1] || parsed[3], 10);
-      const text = parsed[2] || parsed[4];
-      items.push({ id, text, line: trimmed });
-    }
-  });
-  return items;
-}
-
-function replaceInboxSection(content, items) {
-  const regex = /(## Inbox\n)([\s\S]*?)(\n---|\n##|$)/;
-  if (!regex.test(content)) {
-    const lines = items.length ? items.map((item) => item.line).join('\n') : '(Empty - inbox zero achieved)';
-    return `${content}\n\n## Inbox\n\n${lines}\n`;
-  }
-
-  return content.replace(regex, (match, header, body, suffix) => {
-    const inner = items.length
-      ? `\n${items.map((item) => item.line).join('\n')}\n`
-      : '\n(Empty - inbox zero achieved)\n';
-    return `${header}${inner}${suffix}`;
-  });
-}
-
-function addInboxItemToContent(content, id, summary) {
-  const items = parseInboxItems(content).filter((item) => item.id !== id);
-  const newItem = { id, text: summary, line: `- **I${id}:** ${summary}` };
-  const updatedItems = [newItem, ...items];
-  return replaceInboxSection(content, updatedItems);
-}
-
 function removeInboxItemFromContent(content, id) {
   const items = parseInboxItems(content).filter((item) => item.id !== id);
   return replaceInboxSection(content, items);
 }
 
-function getNextInboxId(content) {
-  const items = parseInboxItems(content);
-  if (items.length === 0) return 1;
-  return items.reduce((max, item) => (item.id > max ? item.id : max), 0) + 1;
-}
-
 function insertIntoNotesSection(content, block) {
   const regex = /(## Notes\n)([\s\S]*?)(\n---|\n##|$)/;
   const match = content.match(regex);

package/commands/clean.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const escapeRegExp = require('../lib/escape-regexp');
 
 /**
  * atris clean - Workspace housekeeping with auto-heal
@@ -396,10 +397,6 @@ function findSymbolLine(fileContent, symbol) {
   return null;
 }
 
-function escapeRegExp(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
 /**
  * Find wiki pages whose sources have been modified after last_compiled.
  * Scans all .md files under atris/ for frontmatter with last_compiled + sources.

package/commands/compile.js

@@ -6,7 +6,7 @@
  * the promoted artifact runs token-free.
  *
  *   atris compile record <name> --input <json|@file> --output <json|@file>
- *   atris compile build <name>        (uses claude -p, like atris run)
+ *   atris compile build <name>        (uses the shared runner command)
  *   atris compile backtest <name>
  *   atris compile promote <name>
  *   atris compile exec <name> --input <json|@file> [--record]
@@ -18,6 +18,11 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
+const {
+  buildRunnerAvailabilityCommand,
+  buildRunnerCommand,
+  resolveClaudeRunnerBin,
+} = require('../lib/runner-command');
 
 const DEFAULT_THRESHOLD = 0.99;
 const SAMPLE_RECORDS_FOR_BUILD = 25;
@@ -275,9 +280,9 @@ function executeBuild(root, name, options = {}) {
 
   if (!cmdOverride) {
     try {
-      execSync('which claude', { stdio: 'pipe' });
+      execSync(buildRunnerAvailabilityCommand(), { stdio: 'pipe' });
     } catch {
-      throw new Error('claude CLI not found. Install Claude Code first.');
+      throw new Error(`${resolveClaudeRunnerBin()} CLI not found. Set ATRIS_RUNNER_BIN (or legacy ATRIS_CLAUDE_BIN), or install the configured runner first.`);
     }
   }
 
@@ -287,7 +292,7 @@ function executeBuild(root, name, options = {}) {
   fs.writeFileSync(tmpFile, prompt);
 
   try {
-    const cmd = cmdOverride || `claude -p "$(cat '${tmpFile.replace(/'/g, "'\\''")}')" --allowedTools "Read,Write,Edit,Glob,Grep"`;
+    const cmd = cmdOverride || buildRunnerCommand({ promptFile: tmpFile, allowedTools: 'Read,Write,Edit,Glob,Grep' });
     const env = { ...process.env };
     delete env.CLAUDECODE;
     execSync(cmd, {

package/commands/console.js

@@ -3,6 +3,7 @@ const path = require('path');
 const os = require('os');
 const { spawn, spawnSync } = require('child_process');
 const readline = require('readline');
+const { resolveClaudeRunnerBin } = require('../lib/runner-command');
 
 // ── Context Gathering ──────────────────────────────────────────────
 
@@ -206,7 +207,10 @@ function renderSkillsBar(ctx) {
 // ── Backend Detection & Auth ───────────────────────────────────────
 
 function detectBackend(requested) {
-  const hasClaude = spawnSync('which', ['claude'], { stdio: 'pipe' }).status === 0;
+  const claudeBin = resolveClaudeRunnerBin();
+  const hasClaude = claudeBin.includes(path.sep)
+    ? fs.existsSync(claudeBin)
+    : spawnSync('which', [claudeBin], { stdio: 'pipe' }).status === 0;
   const hasCodex = spawnSync('which', ['codex'], { stdio: 'pipe' }).status === 0;
 
   if (requested) {
@@ -277,20 +281,21 @@ function checkAuth(backend) {
 // ── Launch ──────────────────────────────────────────────────────────
 
 function launchClaude(systemPrompt, extraArgs) {
+  const runnerBin = resolveClaudeRunnerBin();
   const args = [
     '--dangerously-skip-permissions',
     '--append-system-prompt', systemPrompt,
     ...extraArgs,
   ];
 
-  const child = spawnSync('claude', args, {
+  const child = spawnSync(runnerBin, args, {
     cwd: process.cwd(),
     stdio: 'inherit',
     env: { ...process.env, CLAUDECODE: undefined },
   });
 
   if (child.error) {
-    console.error(`✗ Failed to start claude: ${child.error.message}`);
+    console.error(`✗ Failed to start ${runnerBin}: ${child.error.message}`);
     process.exit(1);
   }
   process.exit(child.status ?? 0);