atris 3.68.1 → 3.68.3

package/commands/task.js

@@ -25,6 +25,7 @@ const {
   evaluateAutoAccept,
   isAgentCertified,
   isAutoCertifyVerifyCommandAllowed,
+  parseVerifyChain,
   parseVerifyCommand,
   runVerifyCommand,
   runVerifyCommandCached,
@@ -2204,6 +2205,7 @@ function taskReviewCleanEvidenceCommand(command) {
     /\s+\(?(?:passed|ok|clean|failed|errored|timed out|succeeded|succeeds|successful|confirmed)\)?$/i,
     /\s+\(?\d+\/\d+(?:\s+(?:tests?|checks?|passed|pass|ok|clean|failed|failures?))?\)?$/i,
     /\s+\d+\/\d+(?:\s+(?:tests?|checks?|passed|pass|ok|clean|failed|failures?))?$/i,
+    /\s+(?:passed|exited\s+0)(?:\s*\(\s*exit\s+0\s*\))?(?:\.(?:\s.*)?)?$/i,
   ];
   for (const pattern of tailPatterns) {
     clean = taskReviewTrimOutsideQuotedTail(clean, pattern);
@@ -2254,7 +2256,7 @@ function taskReviewCommandIsDescribedSubject(clause, commandIndex) {
 function taskReviewEvidenceCommands(text, limit = 8) {
   const source = String(text || '').trim();
   if (!source) return [];
-  const commandWord = '(?:npm|node|git|atris|npx|pnpm|yarn|python3?|pytest|bash|sh|tsc|vitest|curl|gh|rg)';
+  const commandWord = '(?:npm|node|git|atris|npx|pnpm|yarn|python3?|pytest|bash|sh|tsc|vitest|curl|gh|rg|test(?=\\s+-[sf]\\b))';
   const envPrefix = '(?:(?:[A-Z_][A-Z0-9_]*=[^\\s,;|]+)\\s+)*';
   const prosePrefix = '(?:(?:rechecked|reran|re-run|run|verified|validated|passed|validation(?:\\s+passed)?|verification(?:\\s+passed)?|focused|live|scoped|installed|direct|full|current|fresh|then|and|commands?|checks?)[:\\s]+)*';
   const commandStart = `${prosePrefix}${envPrefix}${commandWord}\\b`;
@@ -10460,16 +10462,35 @@ function certifyVerifyCandidate(task) {
   const review = task.review || {};
   const recorded = typeof metadata.verify === 'string' && metadata.verify.trim() ? [metadata.verify.trim()] : [];
   const proof = String(review.proof || metadata.latest_agent_proof || '');
-  for (const raw of [...recorded, ...taskReviewEvidenceCommands(proof)]) {
+  // The extractor splits on &&, so rebuild chains the proof actually wrote
+  // ("a && b") and try each one before its pieces.
+  const flatProof = proof.replace(/`/g, '').replace(/\s+/g, ' ');
+  const pieces = taskReviewEvidenceCommands(proof);
+  const ordered = [];
+  for (let i = 0; i < pieces.length; i += 1) {
+    for (let j = pieces.length; j > i + 1; j -= 1) {
+      const chain = pieces.slice(i, j).join(' && ');
+      if (flatProof.includes(chain)) ordered.push(chain);
+    }
+    ordered.push(pieces[i]);
+  }
+  for (const raw of [...recorded, ...ordered]) {
     // The evidence extractor can keep trailing prose ("git diff --check. Evidence
     // inspected: ..."); try the full clause, then the first sentence of it.
     for (const candidate of [raw, raw.split(/\.(?:\s|$)/)[0]].map((c) => String(c || '').trim())) {
-      if (candidate && parseVerifyCommand(candidate).ok) return candidate;
+      if (candidate && isAutoCertifyVerifyCommandAllowed(candidate) && !verifyIsOnlyFileChecks(candidate)) return candidate;
     }
   }
   return null;
 }
 
+// "File exists" is not certification: a verify made only of test -s / test -f
+// steps does not qualify on its own.
+function verifyIsOnlyFileChecks(verify) {
+  const chain = parseVerifyChain(verify);
+  return chain.ok && chain.steps.every((step) => step.argv[0] === 'test' && /^-[sf]$/.test(step.argv[1] || ''));
+}
+
 function stampCertifyVerifyMetadata(taskDb, db, taskId, actor, verify) {
   const row = taskDb.getTask(db, taskId);
   if (!row) return;
@@ -13573,4 +13594,6 @@ module.exports = {
   taskApprovalFor,
   taskPageContract,
   taskDescriptionForCloud,
+  taskReviewCleanEvidenceCommand,
+  certifyVerifyCandidate,
 };

package/commands/workflow.js

@@ -83,7 +83,7 @@ function reviewSoftTitle(title, maxWords = 5) {
 
 function isHumanDeskNext(command) {
   const text = String(command || '');
-  return /^atris do\b/.test(text) || /^atris task (?:claim|show|ready|accept)\b/.test(text);
+  return /^atris do\b/.test(text) || /^atris done\b/.test(text) || /^atris task (?:claim|show|ready|accept)\b/.test(text);
 }
 
 function loadReviewTasks(root = process.cwd()) {

package/commands/worktree.js

@@ -7,6 +7,7 @@ const { hasFlag, readFlag } = require('../lib/arg-parser');
 const { stampLatestOpenBriefForWorktree } = require('../lib/brief-ledger');
 const { isConductorArtifact } = require('../lib/conductor-artifacts');
 const { fixMapDocs } = require('../lib/map-refs');
+const { sleepSync } = require('../lib/sleep-sync');
 const close = require('./close');
 
 const REGEN_ADAPTER_FILES = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md'];
@@ -16,15 +17,48 @@ const ONE_LAP_PROOF_REF_PATTERN = /^refs\/atris\/one-lap\/([0-9a-f]{40,64})$/;
 const DAY_MS = 24 * 60 * 60 * 1000;
 const SHIP_HEALTH_SOURCE = 'ship-health:experiments-daily';
 
+function gitNetworkEnvironment(source = process.env, cwd = process.cwd()) {
+  const env = { ...source, GIT_TERMINAL_PROMPT: '0' };
+  // Custom commands may be wrappers that do not accept OpenSSH flags.
+  // Leave Git's own command/config/program precedence intact.
+  if (source.GIT_SSH_COMMAND || source.GIT_SSH) return env;
+  const configured = spawnSync('git', ['config', '--get', 'core.sshCommand'], {
+    cwd, encoding: 'utf8', env: source, timeout: 5000, killSignal: 'SIGKILL',
+  });
+  if (configured.status === 0 && String(configured.stdout || '').trim()) return env;
+  env.GIT_SSH_COMMAND = 'ssh -o BatchMode=yes -o ConnectTimeout=10 -o ServerAliveInterval=15';
+  return env;
+}
+
+// A killed network call leaves stderr empty; name the timeout instead.
+function gitFailureDetail(result) {
+  if (result && result.error && result.error.code === 'ETIMEDOUT') return 'timed out';
+  return String((result && (result.stderr || result.stdout)) || '').trim();
+}
+
 function runGit(args, { cwd = process.cwd(), check = true, timeout } = {}) {
-  const result = spawnSync('git', args, { cwd, encoding: 'utf8', timeout });
+  const network = ['fetch', 'push', 'ls-remote'].includes(args[0]);
+  // Only network calls need the SSH probe; local calls skip its extra git spawn.
+  const options = { cwd, encoding: 'utf8', timeout: timeout ?? (network ? 30000 : undefined),
+    killSignal: 'SIGKILL', env: network ? gitNetworkEnvironment(process.env, cwd) : undefined };
+  let result = spawnSync('git', args, options);
+  // Linked checkouts share config. A concurrent start must not silently lose
+  // its owner/base metadata, but real config errors still stop immediately.
+  for (let retry = 1; args[0] === 'config' && retry < 3 && configLocked(result); retry += 1) {
+    sleepSync(100 * retry);
+    result = spawnSync('git', args, options);
+  }
   if (check && result.status !== 0) {
-    const msg = (result.stderr || result.stdout || `git ${args.join(' ')} failed`).trim();
-    throw new Error(msg);
+    const detail = gitFailureDetail(result);
+    throw new Error(detail === 'timed out' ? `git ${args[0]} timed out` : (detail || `git ${args.join(' ')} failed`));
   }
   return result;
 }
 
+function configLocked(result) {
+  return result.status !== 0 && /could not lock config file/i.test(`${result.stderr || ''}${result.stdout || ''}`);
+}
+
 function runCommand(command, { cwd = process.cwd(), check = true } = {}) {
   const result = spawnSync(command, {
     cwd,
@@ -285,6 +319,23 @@ function currentUpstream(root) {
 }
 
 function remoteHead(root) {
+  // The saved origin/HEAD survives branch renames. Ask the remote before
+  // trusting it, keeping the offline fallback when the remote is unavailable.
+  const remote = runGit(['remote', 'get-url', 'origin'], { cwd: root, check: false });
+  if (remote.status === 0) {
+    const live = runGit(['ls-remote', '--symref', 'origin', 'HEAD'], { cwd: root, check: false, timeout: 5000 });
+    const match = live.status === 0 && String(live.stdout || '').match(/^ref: refs\/heads\/(.+)\s+HEAD$/m);
+    if (match) {
+      const head = `origin/${match[1]}`;
+      if (!refExists(root, head)) {
+        const fetched = runGit(['fetch', 'origin', `refs/heads/${match[1]}:refs/remotes/${head}`], { cwd: root, check: false, timeout: 5000 });
+        if (fetched.status !== 0 || !refExists(root, head)) {
+          throw new Error('could not fetch the remote default branch; stop and retry when the remote is available');
+        }
+      }
+      return head;
+    }
+  }
   const result = runGit(['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'], { cwd: root, check: false });
   return result.status === 0 ? result.stdout.trim() : '';
 }
@@ -311,7 +362,7 @@ function normalizeTargetRef(root, target) {
 function defaultMainlineBase(root) {
   const head = remoteHead(root);
   if (head && refExists(root, head)) return head;
-  for (const candidate of ['origin/master', 'origin/main']) {
+  for (const candidate of ['origin/main', 'origin/master']) {
     if (refExists(root, candidate)) return candidate;
   }
   return 'HEAD';
@@ -342,7 +393,7 @@ function defaultShipTarget(root) {
   }
   const head = remoteHead(root);
   if (head && refExists(root, head)) return head;
-  for (const candidate of ['origin/master', 'origin/main']) {
+  for (const candidate of ['origin/main', 'origin/master']) {
     if (refExists(root, candidate)) return candidate;
   }
   return 'HEAD';
@@ -351,7 +402,8 @@ function defaultShipTarget(root) {
 function refreshRemoteRef(root, ref) {
   if (!ref.startsWith('origin/')) return;
   const remoteBranch = ref.slice('origin/'.length);
-  runGit(['fetch', 'origin', remoteBranch], { cwd: root, check: false });
+  const fetched = runGit(['fetch', 'origin', remoteBranch], { cwd: root, check: false, timeout: 5000 });
+  return fetched.status === 0 ? '' : (gitFailureDetail(fetched) || 'fetch failed');
 }
 
 function baseBranchName(ref) {
@@ -456,7 +508,7 @@ function printStatus() {
 // worktree ship` targets, recorded as branch.<branch>.atris-base) are kept
 // separate on purpose. checkoutBase defaults to the launcher's own
 // upstream/default remote base, so the agent starts from current work.
-// shipBase defaults to origin/master for agent/member worktrees regardless of
+// shipBase defaults to the remote mainline for agent/member worktrees regardless of
 // what branch the launcher happened to have checked out. recording the
 // launcher's own feature branch as the ship target false-landed two PRs on
 // 2026-07-04 (ship merged into the launcher's branch, never reached master).
@@ -465,48 +517,85 @@ function printStatus() {
 function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task, branch: branchOverride, path: pathOverride, base: baseOverride, now = new Date() } = {}) {
   const owner = member || agent;
   if (!owner || !task) throw new Error('createAgentWorktree: owner (member/agent) and task required');
+  // Pin the caller's flight base, or resolve it once for this new flight.
+  const mainline = baseOverride || defaultMainlineBase(root);
   // Every new flight pays down completed checkout debt before adding another
   // full repo copy. Branches and commits survive worktree removal, while real
   // uncommitted changes remain protected by cleanupWorktrees.
   let reapedBeforeStart = [];
   let cachePrunedBeforeStart = [];
   try {
-    const cleaned = cleanupWorktrees({ root, base: defaultMainlineBase(root), apply: true });
+    const cleaned = cleanupWorktrees({ root, base: mainline, apply: true, by: 'atris worktree start' });
     reapedBeforeStart = cleaned.removed;
     cachePrunedBeforeStart = cleaned.cachePruned;
   } catch {}
   const branch = branchOverride || branchName(owner, task, now);
   const target = path.resolve(pathOverride || defaultWorktreePath(root, owner, task, now));
-  const explicitBase = Boolean(baseOverride);
   // Agent/member worktrees always cut from the mainline: honoring the
   // launcher checkout's upstream let a dispatch inherit another session's
   // in-progress feature branch (2026-07-09: an auth fix arrived carrying 13
   // unpushed commits from a parallel session and could not merge).
-  const checkoutBase = normalizeTargetRef(root, baseOverride || defaultMainlineBase(root));
-  const shipBase = explicitBase ? checkoutBase : normalizeTargetRef(root, 'origin/master');
+  const checkoutBase = normalizeTargetRef(root, mainline);
+  const shipBase = checkoutBase;
   if (fs.existsSync(target)) throw new Error(`worktree path already exists: ${target}`);
   fs.mkdirSync(path.dirname(target), { recursive: true });
-  refreshRemoteRef(root, checkoutBase);
-  runGit(['worktree', 'add', '-b', branch, target, checkoutBase], { cwd: root });
-  runGit(['config', `branch.${branch}.atris-base`, shipBase], { cwd: target, check: false });
-  runGit(['config', `branch.${branch}.atris-owner`, owner], { cwd: target, check: false });
-  runGit(['config', `branch.${branch}.atris-task`, task], { cwd: target, check: false });
-  fs.mkdirSync(path.join(target, '.atris'), { recursive: true });
-  fs.writeFileSync(
-    path.join(target, '.atris', 'agent-worktree.json'),
-    JSON.stringify({
-      agent: agent || null,
-      member: member || null,
-      owner,
-      task,
-      branch,
-      base: shipBase,
-      checkout_base: checkoutBase,
-      workspace_root: root,
-      created_at: now.toISOString(),
-    }, null, 2) + '\n',
-    'utf8'
-  );
+  const staleBase = refreshRemoteRef(root, checkoutBase);
+  const ref = `refs/heads/${branch}`;
+  const existed = runGit(['show-ref', '--verify', '--quiet', ref], { cwd: root, check: false }).status !== 1;
+  const baseCommit = runGit(['rev-parse', '--verify', `${checkoutBase}^{commit}`], { cwd: root, check: false });
+  const startCommit = baseCommit.status === 0 ? baseCommit.stdout.trim() : '';
+  // With no local copy the start fails on its own; only a real cut gets the warning.
+  if (staleBase && startCommit) {
+    console.error(`warning: could not refresh ${checkoutBase} (${staleBase.split('\n')[0]}); the new worktree starts from the local copy, which may be behind`);
+  }
+  const discardFailedStart = () => {
+    if (existed || !startCommit) return;
+    const registered = listWorktrees(root).find((wt) => wt.branch === branch);
+    if (registered) {
+      if (!fs.existsSync(target) || fs.realpathSync(registered.path) !== fs.realpathSync(target)
+        || registered.head !== startCommit) return;
+      const dirt = statusCounts(target, { ignoreUntracked: isConductorArtifact });
+      if (!dirt || dirt.staged || dirt.unstaged || dirt.untracked) return;
+      // No engine has started. Normal removal still refuses unexpected dirt.
+      runGit(['worktree', 'remove', target], { cwd: root });
+    }
+    if (!fs.existsSync(target)) runGit(['update-ref', '-d', ref, startCommit], { cwd: root });
+  };
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const added = runGit(['worktree', 'add', '-b', branch, target, checkoutBase], { cwd: root, check: false });
+    if (added.status === 0) break;
+    // Git can create the branch before failing to write its tracking config.
+    // Drop only that untouched ref, never an existing branch or a checkout.
+    if (!/already exists|already used by worktree/i.test(added.stderr || '')) discardFailedStart();
+    if (!configLocked(added) || attempt === 2) {
+      throw new Error(String(added.stderr || added.stdout || 'worktree start failed').trim());
+    }
+    sleepSync(100 * (attempt + 1));
+  }
+  try {
+    runGit(['config', `branch.${branch}.atris-base`, shipBase], { cwd: target });
+    runGit(['config', `branch.${branch}.atris-owner`, owner], { cwd: target });
+    runGit(['config', `branch.${branch}.atris-task`, task], { cwd: target });
+    fs.mkdirSync(path.join(target, '.atris'), { recursive: true });
+    fs.writeFileSync(
+      path.join(target, '.atris', 'agent-worktree.json'),
+      JSON.stringify({
+        agent: agent || null,
+        member: member || null,
+        owner,
+        task,
+        branch,
+        base: shipBase,
+        checkout_base: checkoutBase,
+        workspace_root: root,
+        created_at: now.toISOString(),
+      }, null, 2) + '\n',
+      'utf8'
+    );
+  } catch (error) {
+    discardFailedStart();
+    throw error;
+  }
   return { path: target, branch, base: shipBase, checkoutBase, owner, reapedBeforeStart, cachePrunedBeforeStart };
 }
 
@@ -903,7 +992,7 @@ function shipWorktree(args) {
             throw new Error((switched.stderr || switched.stdout || `git switch ${targetBranch} failed`).trim());
           }
         }
-        const primaryCounts = statusCounts(primary) || { staged: 0, unstaged: 0, untracked: 0 };
+        const primaryCounts = statusCounts(primary, { ignoreUntracked: isConductorArtifact }) || { staged: 0, unstaged: 0, untracked: 0 };
         if (primaryCounts.staged || primaryCounts.unstaged || primaryCounts.untracked) {
           throw new Error(
             `primary checkout dirty staged=${primaryCounts.staged} ` +
@@ -1058,6 +1147,20 @@ function worktreeHasActiveProcess(worktreePath, activeCwds) {
   });
 }
 
+// Every work-folder removal leaves one line naming who removed it and why, in
+// the main checkout's state so the line outlives the folder it describes.
+function recordWorktreeRemoval(root, { path: removedPath, branch = '', by, reason }) {
+  try {
+    const common = runGit(['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd: root, check: false });
+    const main = common.status === 0 ? path.dirname(common.stdout.trim()) : root;
+    const file = path.join(main, '.atris', 'state', 'worktree_removals.jsonl');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${JSON.stringify({
+      at: new Date().toISOString(), path: removedPath, branch: branch || null, by, reason, pid: process.pid,
+    })}\n`);
+  } catch {}
+}
+
 function pruneGeneratedWorktreeCaches(worktreePath, { apply = false } = {}) {
   const candidates = [];
   const pruned = [];
@@ -1079,7 +1182,7 @@ function pruneGeneratedWorktreeCaches(worktreePath, { apply = false } = {}) {
   return { candidates, pruned };
 }
 
-function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply = false, activeCwds: activeCwdsOverride } = {}) {
+function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply = false, activeCwds: activeCwdsOverride, by = 'atris worktree cleanup' } = {}) {
   const worktrees = listWorktrees(root);
   const primary = worktrees[0]?.path ? path.resolve(worktrees[0].path) : '';
   const current = path.resolve(root);
@@ -1167,6 +1270,7 @@ function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply =
       const removedResult = runGit(removeArgs, { cwd: root, check: false });
       if (removedResult.status === 0) {
         removed.push(candidate);
+        recordWorktreeRemoval(root, { path: wt.path, branch: wt.branch, by, reason: candidate.reason });
       } else {
         kept.push({ ...item, reason: 'remove_failed', error: (removedResult.stderr || removedResult.stdout || '').trim() });
       }
@@ -1185,6 +1289,7 @@ function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply =
     const removedResult = runGit(removeArgs, { cwd: root, check: false });
     if (removedResult.status === 0) {
       removed.push(candidate);
+      recordWorktreeRemoval(root, { path: wt.path, branch: wt.branch, by, reason: candidate.reason });
     } else {
       kept.push({ ...item, reason: 'remove_failed', error: (removedResult.stderr || removedResult.stdout || '').trim() });
     }
@@ -1302,12 +1407,16 @@ module.exports = {
   cleanupWorktrees,
   defaultMainlineBase,
   defaultStartBase,
+  gitFailureDetail,
+  gitNetworkEnvironment,
   describeFlightAge,
   flightStampMs,
+  listActiveProcessCwds,
   listWorktrees,
   parseAgentFlightName,
   parseWorktrees,
   normalizeTargetRef,
+  recordWorktreeRemoval,
   refreshMovedMapRefs,
   slugify,
   taskTokens,
@@ -1315,4 +1424,5 @@ module.exports = {
   swarloClaim,
   runShipHealthCheck,
   worktreeCommand,
+  worktreeHasActiveProcess,
 };

package/lib/auto-accept-certified.js

@@ -578,7 +578,8 @@ function runVerifyStep(parsed, workspaceRoot) {
   if (!gitPathCheck.ok) return gitPathCheck;
   const pythonPathCheck = validatePythonBinaryPath(parsed.argv, workspaceRoot, cwdCheck.cwd);
   if (!pythonPathCheck.ok) return pythonPathCheck;
-  const result = spawnSync(parsed.argv[0], parsed.argv.slice(1), {
+  const bin = parsed.argv[0] === 'node' ? process.execPath : parsed.argv[0];
+  const result = spawnSync(bin, parsed.argv.slice(1), {
     cwd: cwdCheck.cwd,
     env: verifyCommandEnv(parsed.env),
     shell: false,
@@ -620,11 +621,10 @@ function runVerifyStep(parsed, workspaceRoot) {
 function verifyCommandEnv(extraEnv) {
   const base = extraEnv ? { ...process.env, ...extraEnv } : { ...process.env };
   const binDir = path.dirname(process.execPath);
-  const current = String(base.PATH || '');
-  const alreadyPresent = current.split(path.delimiter).includes(binDir);
-  if (binDir && !alreadyPresent) {
-    base.PATH = current ? `${binDir}${path.delimiter}${current}` : binDir;
-  }
+  // Caller PATH order wins (a test may put a fake binary first); the node bin
+  // dir and Homebrew only fill in at the end when missing.
+  const currentParts = String(base.PATH || '').split(path.delimiter).filter(Boolean);
+  base.PATH = [...new Set([...currentParts, binDir, '/opt/homebrew/bin'].filter(Boolean))].join(path.delimiter);
   base[VERIFY_IN_PROGRESS_ENV] = '1';
   // A verifier that inherits a test-runner context joins the outer runner as
   // a child and reports instant exit 0 without running anything. Strip it so
@@ -1409,4 +1409,5 @@ module.exports = {
   repoHygieneGate,
   runVerifyCommand,
   runVerifyCommandCached,
+  verifyCommandEnv,
 };

package/lib/codex-flight.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { spawn, spawnSync } = require('child_process');
+const { defaultMainlineBase } = require('../commands/worktree');
 const { SHARED_BRIEF_RULES } = require('./brief-rules');
 
 // Worktree flights need full file access to edit and ship the requested repo.
@@ -78,15 +79,10 @@ function renderCommand(argv) {
 function runWorktreeAdd(repoPath, branch, worktreePath) {
   fs.mkdirSync(path.dirname(worktreePath), { recursive: true });
   const baseArgs = ['-C', repoPath, 'worktree', 'add', '-b', branch, worktreePath];
-  const master = spawnSync('git', [...baseArgs, 'origin/master'], { encoding: 'utf8' });
-  if (master.status === 0) return { baseRef: 'origin/master' };
-  const main = spawnSync('git', [...baseArgs, 'origin/main'], { encoding: 'utf8' });
-  if (main.status === 0) return { baseRef: 'origin/main' };
-  const detail = [
-    `origin/master: ${(master.stderr || master.stdout || '').trim()}`,
-    `origin/main: ${(main.stderr || main.stdout || '').trim()}`,
-  ].join('\n');
-  throw new Error(`git worktree add failed for ${worktreePath}\n${detail}`);
+  const baseRef = defaultMainlineBase(repoPath);
+  const result = spawnSync('git', [...baseArgs, baseRef], { encoding: 'utf8' });
+  if (result.status === 0) return { baseRef };
+  throw new Error(`git worktree add failed for ${worktreePath}\n${baseRef}: ${(result.stderr || result.stdout || '').trim()}`);
 }
 
 function parseTaskId(stdout) {
@@ -152,12 +148,10 @@ async function dispatchCodexFlight({ repoPath, slug, brief, verifyCmd, dryRun =
   const branch = `codex/${flightSlug}-${flightStamp}`;
   const worktreePath = path.join(repo.arenaRoot, '.agent-worktrees', repo.repoName, `codex-${flightSlug}-${flightStamp}`);
   const prompt = buildPrompt({ worktreePath, branch, brief, verifyCmd });
-  const worktreeCommand = ['git', '-C', repo.repoPath, 'worktree', 'add', '-b', branch, worktreePath, 'origin/master'];
-  const fallbackCommand = ['git', '-C', repo.repoPath, 'worktree', 'add', '-b', branch, worktreePath, 'origin/main'];
+  const worktreeCommand = ['git', '-C', repo.repoPath, 'worktree', 'add', '-b', branch, worktreePath, defaultMainlineBase(repo.repoPath)];
 
   if (dryRun) {
     console.log(`Worktree command: ${renderCommand(worktreeCommand)}`);
-    console.log(`Fallback command: ${renderCommand(fallbackCommand)}`);
     console.log(`Codex cwd: ${worktreePath}`);
     console.log('Prompt:');
     console.log(prompt);

package/lib/conductor-artifacts.js

@@ -8,10 +8,12 @@
 const CONDUCTOR_UNTRACKED_PATTERN =
   /^\.atris\/(?:agent-worktree\.json|fleet-prompt-[^/]+\.md|codex-watchdog\.js|codex-watchdog-[^/]+\.json|runtime-tmp(?:\/.*)?|state\/briefs\.jsonl)$/;
 const CONDUCTOR_ROOT_OUTPUT_PATTERN = /^\.codex-last-message\.txt$/;
+const CONDUCTOR_RUN_OUTPUT_PATTERN = /^atris\/runs\/[^/]+\.(?:json|live\.log)$/;
 
 function isConductorArtifact(file) {
   const value = String(file || '');
-  return CONDUCTOR_UNTRACKED_PATTERN.test(value) || CONDUCTOR_ROOT_OUTPUT_PATTERN.test(value);
+  return CONDUCTOR_UNTRACKED_PATTERN.test(value) || CONDUCTOR_ROOT_OUTPUT_PATTERN.test(value)
+    || CONDUCTOR_RUN_OUTPUT_PATTERN.test(value);
 }
 
 // Accepts a `git status --porcelain` line ("?? .atris/fleet-prompt-BCK-1.md").

package/lib/default-runner.js

@@ -19,27 +19,62 @@ function hasFlag(args, name) {
   return list.some((token) => String(token) === name || String(token).startsWith(`${name}=`));
 }
 
+// Codex exports CODEX_THREAD_ID (and CODEX_SESSION_ID on some builds) into
+// every shell command its agent runs, so a CLI started by a codex session can
+// see it. ATRIS_CALLER_RUNTIME names the caller outright and wins over the
+// sniffing: codex, agent (claude code, cursor, devin), or terminal.
+const CODEX_SESSION_ENV = Object.freeze(['CODEX_THREAD_ID', 'CODEX_SESSION_ID']);
+const AGENT_SESSION_ENV = Object.freeze(['CLAUDECODE', 'CLAUDE_CODE_ENTRYPOINT', 'CURSOR_AGENT', 'DEVIN_SESSION_ID']);
+
+function envSet(env, name) {
+  return String((env && env[name]) || '').trim() !== '';
+}
+
+function declaredCallerRuntime(env = process.env) {
+  const named = String((env && env.ATRIS_CALLER_RUNTIME) || '').trim().toLowerCase();
+  return ['codex', 'agent', 'terminal'].includes(named) ? named : '';
+}
+
+function codexSessionFromEnv(env = process.env) {
+  const named = declaredCallerRuntime(env);
+  if (named) return named === 'codex';
+  return CODEX_SESSION_ENV.some((name) => envSet(env, name));
+}
+
 // A live codex session drives a run by passing its native goal slot state
-// (--native-goal-* / --visible-goal-*) or by explicitly claiming the slot
-// (--take-goal-slot). Absent those, nothing is on the other end.
-function runHasLiveCodexSession(args) {
+// (--native-goal-* / --visible-goal-*), by explicitly claiming the slot
+// (--take-goal-slot), or by being the process around this CLI (its session
+// env). Absent those, nothing is on the other end.
+function runHasLiveCodexSession(args, env = process.env) {
   return Boolean(
     flagValue(args, '--native-goal-status')
     || flagValue(args, '--visible-goal-status')
     || flagValue(args, '--native-goal-objective')
     || flagValue(args, '--visible-goal-objective')
-    || hasFlag(args, '--take-goal-slot'),
+    || hasFlag(args, '--take-goal-slot')
+    || codexSessionFromEnv(env),
   );
 }
 
+// Who started this CLI: 'codex' (a codex session that can start a native
+// goal), 'agent' (another agent session that does the work itself), or
+// 'terminal' (a plain shell, cron, or launchd, where nothing else will do the
+// work unless Atris starts an engine).
+function callerRuntime(args = [], env = process.env) {
+  if (runHasLiveCodexSession(args, env)) return 'codex';
+  const named = declaredCallerRuntime(env);
+  if (named) return named;
+  return AGENT_SESSION_ENV.some((name) => envSet(env, name)) ? 'agent' : 'terminal';
+}
+
 // Default runner for the run-objective path (`atris mission run "<objective>"`,
 // `member run`). codex_goal hands the mission to a live codex session's native
 // goal slot; with no such session (cron, fleet, a plain shell) it stalls forever
 // waiting for a native goal start that never comes (proven footgun 2026-07-16).
 // So codex_goal only when a live codex session is driving; otherwise claude,
 // which drives itself headless. An explicit --runner always wins over this.
-function defaultObjectiveRunner(args) {
-  return runHasLiveCodexSession(args) ? 'codex_goal' : 'claude';
+function defaultObjectiveRunner(args, env = process.env) {
+  return runHasLiveCodexSession(args, env) ? 'codex_goal' : 'claude';
 }
 
-module.exports = { runHasLiveCodexSession, defaultObjectiveRunner };
+module.exports = { callerRuntime, runHasLiveCodexSession, defaultObjectiveRunner };

package/lib/engine-ask.js

@@ -11,6 +11,7 @@ const {
 } = require('./runner-command');
 const {
   canonicalEngineName,
+  claudeModelId,
   currentClaudeModel,
   engineFailureHealthStatus,
   setEngineHealth,
@@ -242,7 +243,13 @@ function assertAskModelSupported(engine, model) {
 
 function resolveAskModel(engine, modelName = '') {
   const requested = String(modelName || '').trim();
-  if (requested) return currentClaudeModel(requested);
+  if (requested) {
+    // A display name ("opus 5.5") becomes an id only for the claude cli; every
+    // other engine gets its model name as typed.
+    return engine === 'claude' || engine === 'fable' || engine === 'haiku'
+      ? claudeModelId(requested)
+      : currentClaudeModel(requested);
+  }
   if (engine !== 'claude' && engine !== 'fable' && engine !== 'haiku') return '';
   return RUNNER_PROFILE_DEFS[engine]?.model || DEFAULT_CLAUDE_RUNNER_MODEL;
 }

package/lib/engine-registry.js

@@ -592,6 +592,7 @@ const CLAUDE_MODEL_ALIASES = Object.freeze(['opus', 'sonnet', 'haiku', 'fable',
 // A retired model runs as its replacement, so a saved pick keeps working
 // after the upgrade. Retiring the next one is one line here.
 const RETIRED_CLAUDE_MODELS = Object.freeze({
+  'claude-fable-5': 'claude-fable-5-1',
   'claude-haiku-4-5': 'claude-haiku-5-5',
   'claude-haiku-4-5-20251001': 'claude-haiku-5-5',
 });
@@ -619,6 +620,21 @@ function currentClaudeModel(value) {
   return next ? `${next}${suffix}` : raw;
 }
 
+// The id the claude cli accepts for a display name typed with a space:
+// "opus 5.5" is claude-opus-5-5, "fable 5.1" is claude-fable-5-1. A full id,
+// a bare alias ("opus"), a "[1m]" tail and anything else pass through as given
+// (a retired id still becomes its replacement).
+const CLAUDE_DISPLAY_NAME = /^(opus|sonnet|haiku|fable)\s+(\d+)(?:\.(\d+))?$/i;
+
+function claudeModelId(value) {
+  const raw = String(value || '').trim();
+  const suffix = CLAUDE_LONG_CONTEXT.test(raw) ? '[1m]' : '';
+  const base = raw.replace(CLAUDE_LONG_CONTEXT, '').trim();
+  const match = CLAUDE_DISPLAY_NAME.exec(base);
+  if (!match) return currentClaudeModel(raw);
+  return currentClaudeModel(`claude-${match[1].toLowerCase()}-${match[2]}${match[3] ? `-${match[3]}` : ''}${suffix}`);
+}
+
 // The retired models a roster file's text still names, by id or spelled
 // out, each once, so the roster can say they were upgraded.
 function retiredModelsNamed(text) {
@@ -2386,6 +2402,7 @@ module.exports = {
   confirmRoster,
   normalizeRosterModel,
   currentClaudeModel,
+  claudeModelId,
   retiredModelsNamed,
   RETIRED_CLAUDE_MODELS,
   isClaudeFamilyModel,

package/lib/falsifier-probe.js

@@ -47,10 +47,16 @@ function probeVerifierCanFail({ command, runner, tmpRoot } = {}) {
   const dir = fs.mkdtempSync(path.join(tmpRoot || os.tmpdir(), 'atris-falsifier-probe-'));
   try {
     const run = runner || spawnSync;
+    // A probe that inherits a test-runner context joins the outer runner as a
+    // child and exits 0 without running anything, so every check would look
+    // like it cannot fail. Same strip as verifyCommandEnv.
+    const env = { ...process.env };
+    delete env.NODE_TEST_CONTEXT;
     const result = run('bash', ['-lc', cmd], {
       cwd: dir,
       encoding: 'utf8',
       timeout: PROBE_TIMEOUT_MS,
+      env,
     });
     if (result.error) {
       const timedOut = /ETIMEDOUT/i.test(String(result.error.code || result.error.message || ''));