atris 3.64.0 → 3.66.0

package/lib/auto-accept-certified.js

@@ -6,7 +6,8 @@ const path = require('path');
 const { taskProofState, taskProofExecutionState } = require('./task-proof');
 const { extractReceiptEvidence } = require('./receipt-evidence');
 const reviewIntegrity = require('./review-integrity');
-const { computeTrustTier } = require('./trust-tiers');
+const { computeTrustTier, taskTrustSubject } = require('./trust-tiers');
+const { rewriteWorktreeVerify, missingOnMain } = require('./verify-worktree-rewrite');
 const { policyLessonsForFiles, readPolicyLessons } = require('./policy-lessons');
 const { skillEvalGate } = require('./skill-eval-gate');
 
@@ -457,8 +458,61 @@ function parseVerifyCommand(verify) {
   };
 }
 
+// Members record checks as one command or several joined with `&&`
+// ("npm run test:a && node scripts/test-b.mjs"). Each step must pass the
+// same allowlist on its own; `&&` only runs them in order and stops at the
+// first failure, still with shell:false, so a chain can do nothing its steps
+// could not do one at a time. One leading `cd` applies to every step.
+const MAX_VERIFY_CHAIN_STEPS = 8;
+
+function splitTopLevelAnd(command) {
+  const parts = [];
+  let current = '';
+  let quote = null;
+  for (let i = 0; i < command.length; i += 1) {
+    const char = command[i];
+    if (quote) {
+      if (char === quote) quote = null;
+      current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (char === '&' && command[i + 1] === '&') {
+      parts.push(current.trim());
+      current = '';
+      i += 1;
+      continue;
+    }
+    current += char;
+  }
+  parts.push(current.trim());
+  return parts;
+}
+
+function parseVerifyChain(verify) {
+  const cmd = String(verify || '').trim();
+  if (!cmd) return { ok: false, reason: 'no_verify_command' };
+  const prefixed = parseCdPrefix(cmd);
+  if (!prefixed.ok) return prefixed;
+  const parts = splitTopLevelAnd(prefixed.command);
+  if (parts.length > MAX_VERIFY_CHAIN_STEPS || parts.some((part) => !part || /^cd(\s|$)/.test(part))) {
+    return { ok: false, reason: 'verify_command_not_allowed' };
+  }
+  const steps = [];
+  for (const part of parts) {
+    const parsed = parseVerifyCommand(part);
+    if (!parsed.ok) return parsed;
+    steps.push({ ...parsed, ...(prefixed.cwd ? { cwd: prefixed.cwd } : {}) });
+  }
+  return { ok: true, steps, ...(prefixed.cwd ? { cwd: prefixed.cwd } : {}) };
+}
+
 function isAutoCertifyVerifyCommandAllowed(verify) {
-  return parseVerifyCommand(verify).ok;
+  return parseVerifyChain(verify).ok;
 }
 
 // Re-entrancy guard: every verify child carries ATRIS_VERIFY_IN_PROGRESS=1
@@ -468,12 +522,20 @@ function isAutoCertifyVerifyCommandAllowed(verify) {
 // `atris task status` and the read path re-ran the verify. Refuse loudly.
 const VERIFY_IN_PROGRESS_ENV = 'ATRIS_VERIFY_IN_PROGRESS';
 
-// Spawn cap: a single CLI process has no legitimate reason to run dozens of
-// verifies. Beyond the cap something is looping; refuse and report instead
-// of silently bounding.
-const VERIFY_SPAWN_CAP = 25;
+// Spawn cap: bounds a runaway loop inside one process. The recursion that
+// fork-bombed the fleet is stopped by VERIFY_IN_PROGRESS_ENV above; this cap
+// is the backstop. It was 25, which starved the review queue: every hourly
+// tick re-checked the same first 25 rows and the other 141 waiting rows were
+// refused as verify_spawn_cap forever (measured 2026-10-01). Override with
+// ATRIS_VERIFY_SPAWN_CAP.
+const DEFAULT_VERIFY_SPAWN_CAP = 150;
 let verifySpawnCount = 0;
 
+function verifySpawnCap() {
+  const raw = Number(process.env.ATRIS_VERIFY_SPAWN_CAP);
+  return Number.isInteger(raw) && raw > 0 ? Math.min(raw, 1000) : DEFAULT_VERIFY_SPAWN_CAP;
+}
+
 function verifyRefusal(unrunnableCause, extra) {
   return {
     ok: false,
@@ -490,14 +552,26 @@ function runVerifyCommand(verify, workspaceRoot) {
       detail: `${VERIFY_IN_PROGRESS_ENV} is set: a verify is already running up the call chain; refusing to nest another one`,
     });
   }
-  if (verifySpawnCount >= VERIFY_SPAWN_CAP) {
+  const chain = parseVerifyChain(verify);
+  if (!chain.ok) return chain;
+  let result = null;
+  for (const step of chain.steps) {
+    result = runVerifyStep(step, workspaceRoot);
+    if (!result.ok) {
+      return chain.steps.length > 1 ? { ...result, failed_step: step.argv.join(' ') } : result;
+    }
+  }
+  return result;
+}
+
+function runVerifyStep(parsed, workspaceRoot) {
+  const cap = verifySpawnCap();
+  if (verifySpawnCount >= cap) {
     return verifyRefusal('verify_spawn_cap', {
-      detail: `this process already ran ${verifySpawnCount} verifies (cap ${VERIFY_SPAWN_CAP}); refusing more`,
+      detail: `this process already ran ${verifySpawnCount} verifies (cap ${cap}); refusing more`,
     });
   }
   verifySpawnCount += 1;
-  const parsed = parseVerifyCommand(verify);
-  if (!parsed.ok) return parsed;
   const cwdCheck = validateCommandCwd(parsed, workspaceRoot);
   if (!cwdCheck.ok) return cwdCheck;
   const gitPathCheck = validateGitWorktreePath(parsed.argv, workspaceRoot, cwdCheck.cwd);
@@ -1018,6 +1092,79 @@ function sniffedProtectedLane(task) {
   return null;
 }
 
+// The protected lane a task sits in, or null: a denied tag (whole word,
+// plural-stripped, the same match the landing gate uses), a lane declared in
+// its text, or, for untagged rows, lane terms in its title or objective.
+// Every automatic closer must leave these for a human.
+function deniedTagOf(task) {
+  const tag = String((task && task.tag) || '').trim().toLowerCase();
+  return [...DENIED_TAGS].find((d) =>
+    tag === d || tag.split(/[^a-z0-9]+/).some((w) => w === d || w.replace(/s$/, '') === d)) || null;
+}
+
+function protectedLaneOf(task) {
+  if (!task || typeof task !== 'object') return null;
+  const metadata = task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+  const view = { ...task, objective: task.objective || metadata.objective || '', metadata };
+  const denied = deniedTagOf(view);
+  if (denied) return denied;
+  if (declaredProtectedLane(view)) return 'declared';
+  if (!String(view.tag || '').trim()) {
+    const sniffed = sniffedProtectedLane(view);
+    if (sniffed) return sniffed.lane;
+  }
+  return null;
+}
+
+// The check the landing pass actually runs. A check recorded inside an
+// agent's temporary copy is rewritten to run from the main checkout; when the
+// file it runs only exists on the agent's branch, that is reported in plain
+// words instead of a bare "not on the list this machine may run".
+function resolveTaskVerify(task) {
+  const recorded = String((task.metadata || {}).verify || '').trim();
+  if (!recorded) return { verify: '', recorded: '', rewritten: false, missing: null };
+  const root = task.workspace_root || process.cwd();
+  const rewrite = rewriteWorktreeVerify(recorded, root);
+  const verify = rewrite.command || recorded;
+  let missing = null;
+  if (rewrite.rewritten) {
+    const chain = parseVerifyChain(verify);
+    if (chain.ok) missing = missingOnMain(chain.steps, root);
+  }
+  return { verify, recorded, rewritten: rewrite.rewritten, missing };
+}
+
+// Why the landing pass could never rerun this task's check from main, or
+// null when it can. Independent of the gate's refusal order, so a row held
+// for another reason still reports a check that can never run.
+function verifyRunnability(task) {
+  const resolved = resolveTaskVerify(task);
+  if (!resolved.verify) return 'no_verify_command';
+  if (!isAutoCertifyVerifyCommandAllowed(resolved.verify)) return 'verify_command_not_allowed';
+  if (resolved.missing) return 'verify_only_on_agent_branch';
+  return null;
+}
+
+function agentBranchOnlyResult(ref, resolved) {
+  return {
+    eligible: false,
+    ref,
+    reason: 'verify_only_on_agent_branch',
+    verify: resolved.verify,
+    recorded_verify: resolved.recorded,
+    missing_path: resolved.missing,
+    next_action: `${resolved.missing} is not on main yet; land the agent branch that has it, then the check reruns from main`,
+  };
+}
+
+function runResolvedVerify(resolved, workspaceRoot, cache) {
+  const result = runVerifyCommandCached(resolved.verify, workspaceRoot, cache);
+  if (resolved.rewritten && result.reason === 'verify_failed') {
+    return { ...result, reason: 'verify_failed_on_main', recorded_verify: resolved.recorded };
+  }
+  return resolved.rewritten ? { ...result, recorded_verify: resolved.recorded } : result;
+}
+
 function evaluateAutoAccept(task, options = {}) {
   const {
     strictVerify = true,
@@ -1030,10 +1177,9 @@ function evaluateAutoAccept(task, options = {}) {
   if (task.status !== 'review') return { eligible: false, ref, reason: 'not_in_review' };
   const metadata = task.metadata || {};
   const review = task.review || {};
-  const trustTier = computeTrustTier(
-    task.claimed_by || metadata.executed_by,
-    task.workspace_root || process.cwd(),
-  );
+  // Trust is the builder's, never the approver's: a task built by a member
+  // with a clean record lands without waiting on a human look.
+  const trustTier = computeTrustTier(taskTrustSubject(task), task.workspace_root || process.cwd());
   const tierRequiresStrictVerify = trustTier !== 'trusted';
   const requiresStrictVerify = strictVerify || tierRequiresStrictVerify;
   const approval = String(review.approval_status || metadata.approval_status || 'pending').toLowerCase();
@@ -1107,10 +1253,12 @@ function evaluateAutoAccept(task, options = {}) {
     }
     const evidenceBlock = receiptEvidenceBlock(task, ref);
     if (evidenceBlock) return evidenceBlock;
-    const verify = metadata.verify;
+    const resolvedVerify = resolveTaskVerify(task);
+    const verify = resolvedVerify.verify;
     if (tierRequiresStrictVerify && !verify) return strictVerifyMissingResult(ref);
+    if (resolvedVerify.missing) return agentBranchOnlyResult(ref, resolvedVerify);
     if (verify && executeVerify) {
-      const verifyResult = runVerifyCommandCached(verify, task.workspace_root || process.cwd(), verifyCache);
+      const verifyResult = runResolvedVerify(resolvedVerify, task.workspace_root || process.cwd(), verifyCache);
       // A check that runs and fails blocks. So does a check whose worktree
       // is gone, otherwise the daily reap converts "has a failing check"
       // into "lands unchecked" the morning after it clears the worktree.
@@ -1121,6 +1269,7 @@ function evaluateAutoAccept(task, options = {}) {
       // "the harness could not run the check" into "landed unchecked".
       if ((tierRequiresStrictVerify && !verifyResult.ok)
         || verifyResult.reason === 'verify_failed'
+        || verifyResult.reason === 'verify_failed_on_main'
         || verifyResult.reason === 'verify_unrunnable'
         || verifyResult.reason === 'verify_worktree_missing'
         || verifyResult.reason === 'verify_workdir_missing') {
@@ -1206,11 +1355,13 @@ function evaluateAutoAccept(task, options = {}) {
   }
 
   if (requiresStrictVerify) {
-    const verify = metadata.verify;
+    const resolvedVerify = resolveTaskVerify(task);
+    const verify = resolvedVerify.verify;
     if (!verify) return strictVerifyMissingResult(ref);
+    if (resolvedVerify.missing) return agentBranchOnlyResult(ref, resolvedVerify);
     if (executeVerify) {
       const workspaceRoot = task.workspace_root || process.cwd();
-      const verifyResult = runVerifyCommandCached(verify, workspaceRoot, verifyCache);
+      const verifyResult = runResolvedVerify(resolvedVerify, workspaceRoot, verifyCache);
       if (!verifyResult.ok) {
         return { eligible: false, ref, reason: verifyResult.reason, verify, ...verifyResult };
       }
@@ -1248,8 +1399,11 @@ module.exports = {
   candidatePolicyGate,
   declaredProtectedLane,
   sniffedProtectedLane,
+  protectedLaneOf,
+  verifyRunnability,
   evaluateAutoAccept,
   isAutoCertifyVerifyCommandAllowed,
+  parseVerifyChain,
   isAgentCertified,
   parseVerifyCommand,
   repoHygieneGate,

package/lib/business-target.js

@@ -0,0 +1,131 @@
+'use strict';
+
+// Shared plumbing for business-scoped HTTP commands (`atris hire`, `atris hires`,
+// `atris mail`): parse flags, find which business to act on, get a login token.
+// These commands are HTTP clients of /api/business/{id}/...; no backend code here.
+
+const { apiRequestJson } = require('../utils/api');
+const { ensureValidCredentials } = require('../utils/auth');
+const { findBusiness } = require('../commands/feed');
+const { oneLine } = require('./developer-api');
+
+const NO_BUSINESS = 'no business here. run this inside a business folder, or add --business <slug>';
+
+// --help, --json and --business are allowed on every command.
+const COMMON_SWITCHES = ['help', 'json'];
+const COMMON_VALUES = ['business'];
+
+// --key value, --key=value, and yes/no switches that never take a value.
+// `spec` is { switches: [...], values: [...] }: the only flags the command
+// takes, beyond the common ones. Anything else comes back as `error`, and
+// the command must stop before making any request:
+//   an unknown flag (--dry-run on a command without it),
+//   a value on a switch (--yes=false is refused, never read as yes),
+//   a value flag with nothing after it (--business ""),
+//   the same value flag twice.
+// A plain array is the old lenient form (switch names only), kept for callers
+// that want it; it never reports errors.
+function parseArgs(argv = [], spec = []) {
+  const strict = !Array.isArray(spec);
+  const switchNames = strict ? (spec.switches || []) : spec;
+  const valueNames = strict ? (spec.values || []) : [];
+  const switches = new Set([...switchNames, ...COMMON_SWITCHES, 'yes']);
+  const allowed = new Set([...switchNames, ...valueNames, ...COMMON_SWITCHES, ...COMMON_VALUES]);
+  const flags = {};
+  const pos = [];
+  let error = '';
+  const fail = (message) => { if (!error) error = message; };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = String(argv[i]);
+    if (arg === '-h') { flags.help = true; continue; }
+    if (arg === '-y') {
+      if (strict && !allowed.has('yes')) fail('unknown option -y');
+      else flags.yes = true;
+      continue;
+    }
+    if (arg.startsWith('--')) {
+      const eq = arg.indexOf('=');
+      const raw = eq > 0 ? arg.slice(0, eq) : arg;
+      const key = raw.slice(2).replace(/-/g, '_');
+      if (strict && !allowed.has(key)) { fail(`unknown option ${raw}`); continue; }
+      if (switches.has(key)) {
+        if (eq < 0) flags[key] = true;
+        else if (strict) fail(`${raw} is a switch and takes no value: use ${raw} on its own, or leave it off`);
+        else flags[key] = arg.slice(eq + 1);
+        continue;
+      }
+      let value = true;
+      if (eq > 0) value = arg.slice(eq + 1);
+      else if (argv[i + 1] != null && !String(argv[i + 1]).startsWith('--')) { value = String(argv[i + 1]); i += 1; }
+      if (strict && (typeof value !== 'string' || !value.trim())) { fail(`${raw} needs a value`); continue; }
+      if (strict && Object.prototype.hasOwnProperty.call(flags, key)) { fail(`${raw} was given twice`); continue; }
+      flags[key] = value;
+      continue;
+    }
+    if (strict && arg.length > 1 && arg.startsWith('-')) { fail(`unknown option ${arg}`); continue; }
+    pos.push(arg);
+  }
+  return strict ? { flags, pos, error } : { flags, pos };
+}
+
+// A --business that was given must name a business. An empty or missing
+// value is an error and never falls back to the current folder's business.
+// Without --business: the nearest .atris/business.json above the current
+// folder. Returns { id, name }, { error }, or null when none is found.
+function resolveBusiness(flags = {}, deps = {}) {
+  if (Object.prototype.hasOwnProperty.call(flags, 'business')) {
+    const given = typeof flags.business === 'string' ? flags.business.trim() : '';
+    if (!given) return { error: '--business needs a business slug or id' };
+    return { id: given, name: given };
+  }
+  const found = (deps.findBusiness || findBusiness)(deps.cwd || process.cwd());
+  return found && found.businessId ? { id: found.businessId, name: found.name || 'this business' } : null;
+}
+
+// The business to act on, or says why not (through `err`) and returns null.
+function businessOrSay(flags, deps, err) {
+  const business = resolveBusiness(flags, deps);
+  if (!business) { err(NO_BUSINESS); return null; }
+  if (business.error) { err(business.error); return null; }
+  return business;
+}
+
+async function loginToken(deps = {}) {
+  if (deps.token) return deps.token;
+  const ensure = deps.ensureCredentials || (() => ensureValidCredentials(apiRequestJson));
+  const auth = await ensure();
+  return auth && !auth.error && auth.credentials && auth.credentials.token ? auth.credentials.token : '';
+}
+
+// FastAPI errors arrive as {"detail": "..."}; keep them to one plain line.
+function errorText(result) {
+  if (!result) return 'request failed';
+  if (Number(result.status) === 404 && !(result.data && result.data.detail)) {
+    return 'backend rolling out, try again shortly';
+  }
+  return oneLine((result.data && (result.data.detail || result.data.error)) || result.error || `request failed (${result.status})`);
+}
+
+// "2026-10-02T09:00:00+00:00" -> "in 9 h" / "6 h ago"
+function relativeTime(iso, now = Date.now()) {
+  const at = Date.parse(iso || '');
+  if (!Number.isFinite(at)) return '';
+  const mins = Math.round((at - now) / 60000);
+  const abs = Math.abs(mins);
+  const span = abs < 1 ? 'now' : abs < 90 ? `${abs} min` : abs < 48 * 60 ? `${Math.round(abs / 60)} h` : `${Math.round(abs / 1440)} days`;
+  if (span === 'now') return 'just now';
+  return mins >= 0 ? `in ${span}` : `${span} ago`;
+}
+
+function dollars(value) {
+  if (value == null || !Number.isFinite(Number(value))) return '-';
+  const n = Number(value);
+  return Number.isInteger(n) ? `$${n}` : `$${n.toFixed(2)}`;
+}
+
+function clip(text, width) {
+  const s = String(text == null ? '' : text).replace(/\s+/g, ' ').trim();
+  return s.length > width ? `${s.slice(0, width - 1)}…` : s;
+}
+
+module.exports = { NO_BUSINESS, parseArgs, resolveBusiness, businessOrSay, loginToken, errorText, relativeTime, dollars, clip };

package/lib/cleanup-summary.js

@@ -0,0 +1,129 @@
+'use strict';
+
+// One plain line per cleanup run, in the daily journal's "## <project>
+// overnight" section: the hourly autoland tick writes its own line there and
+// so do project jobs (project-obelisk's review sweep and state sync). The
+// session start screen reads the latest one back, so the owner sees what the
+// background work did without opening anything.
+
+const fs = require('fs');
+const path = require('path');
+
+const CLEANUP_WORDS = /\b(landed|land on|closed|put away|parked|need you|reran|archived)\b/i;
+
+function localDate(now) {
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
+}
+
+function journalFile(root, now) {
+  return path.join(root, 'atris', 'logs', String(now.getFullYear()), `${localDate(now)}.md`);
+}
+
+function sectionName(root) {
+  return `${path.basename(path.resolve(root)).replace(/^project-/, '')} overnight`;
+}
+
+// Same text twice in one day is written once.
+function appendOvernightNote(root, line, now = new Date()) {
+  const text = String(line || '').trim();
+  if (!text || !fs.existsSync(path.join(root, 'atris'))) return false;
+  const file = journalFile(root, now);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const body = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+  const bullet = `- ${text}`;
+  if (body.split('\n').some((l) => l.trim() === bullet)) return false;
+  const marker = `## ${sectionName(root)}`;
+  const idx = body.split('\n').findIndex((l) => l.trim() === marker);
+  let next;
+  if (idx === -1) {
+    next = `${body}${body && !body.endsWith('\n') ? '\n' : ''}\n${marker}\n${bullet}\n`;
+  } else {
+    const lines = body.split('\n');
+    let end = idx + 1;
+    while (end < lines.length && !lines[end].startsWith('## ')) end += 1;
+    let insertAt = end;
+    while (insertAt > idx + 1 && !lines[insertAt - 1].trim()) insertAt -= 1;
+    lines.splice(insertAt, 0, bullet);
+    next = lines.join('\n');
+  }
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs.writeFileSync(tmp, next);
+  fs.renameSync(tmp, file);
+  return true;
+}
+
+function overnightBullets(text) {
+  const bullets = [];
+  let inSection = false;
+  for (const line of String(text || '').split('\n')) {
+    if (line.startsWith('## ')) {
+      inSection = /\bovernight\s*$/i.test(line.trim());
+      continue;
+    }
+    if (inSection && line.trim().startsWith('- ')) bullets.push(line.trim().slice(2).trim());
+  }
+  return bullets;
+}
+
+function parkedBranchCount(root) {
+  try {
+    return fs.readFileSync(path.join(root, 'atris', 'reports', 'parked-branches.md'), 'utf8')
+      .split('\n').filter((l) => /^- \d{4}-\d{2}-\d{2} · /.test(l)).length;
+  } catch {
+    return 0;
+  }
+}
+
+function shorten(text, max) {
+  if (text.length <= max) return text;
+  const cut = text.slice(0, max - 1);
+  const stop = Math.max(cut.lastIndexOf('; '), cut.lastIndexOf(', '));
+  return `${(stop > max * 0.5 ? cut.slice(0, stop) : cut).replace(/[\s,;.]+$/, '')}...`;
+}
+
+// The newest cleanup line from today's journal (yesterday's if today has
+// none), plus the parked-branch count when the line does not already say it.
+// Two small file reads; never throws.
+function latestCleanupLine(root, { now = new Date(), max = 150 } = {}) {
+  try {
+    let line = '';
+    for (const offset of [0, 1]) {
+      const day = new Date(now);
+      day.setDate(day.getDate() - offset);
+      let text = '';
+      try { text = fs.readFileSync(journalFile(root, day), 'utf8'); } catch { continue; }
+      const bullets = overnightBullets(text).filter((b) => CLEANUP_WORDS.test(b));
+      if (bullets.length) { line = bullets[bullets.length - 1]; break; }
+    }
+    const parked = parkedBranchCount(root);
+    if (parked && !/parked/i.test(line)) {
+      const note = `${parked} agent branch${parked === 1 ? '' : 'es'} parked for you`;
+      line = line ? `${shorten(line.replace(/\.$/, ''), max - note.length - 2)}; ${note}` : `${note}.`;
+    }
+    return line ? shorten(line, max) : '';
+  } catch {
+    return '';
+  }
+}
+
+function plural(n, word, many = `${word}s`) {
+  return `${n} ${n === 1 ? word : many}`;
+}
+
+// The autoland tick's own line. Null when the tick did nothing worth a line.
+function tickSummaryLine({ landed = 0, closed = 0, putAway = 0, needYou = 0 } = {}) {
+  const parts = [];
+  if (landed) parts.push(`landed ${plural(landed, 'finished item')}`);
+  if (closed) parts.push(`closed ${plural(closed, 'idle item')} that could never land on their own, each with a plain reason`);
+  if (putAway) parts.push(`put away ${plural(putAway, 'done or long-idle item')}`);
+  if (!parts.length) return null;
+  if (needYou) parts.push(`${needYou} need you (money, deploys, security, or customers)`);
+  const text = parts.join('; ');
+  return `Autoland: ${text.charAt(0).toUpperCase()}${text.slice(1)}.`;
+}
+
+module.exports = {
+  appendOvernightNote,
+  latestCleanupLine,
+  tickSummaryLine,
+};

package/lib/engine-ask.js

@@ -11,6 +11,7 @@ const {
 } = require('./runner-command');
 const {
   canonicalEngineName,
+  currentClaudeModel,
   engineFailureHealthStatus,
   setEngineHealth,
 } = require('./engine-registry');
@@ -241,7 +242,7 @@ function assertAskModelSupported(engine, model) {
 
 function resolveAskModel(engine, modelName = '') {
   const requested = String(modelName || '').trim();
-  if (requested) return requested;
+  if (requested) return currentClaudeModel(requested);
   if (engine !== 'claude' && engine !== 'fable' && engine !== 'haiku') return '';
   return RUNNER_PROFILE_DEFS[engine]?.model || DEFAULT_CLAUDE_RUNNER_MODEL;
 }
@@ -291,7 +292,7 @@ function buildReadOnlyEngineInvocation(engineName, prompt, modelName = '', {
     return {
       engine,
       bin: profile.bin,
-      args: ['exec', ...(model ? ['-m', model] : []), ...effortArgs, '--sandbox', 'read-only', '--ephemeral', '--ignore-user-config', '--ignore-rules', '--color', 'never', request],
+      args: ['exec', ...(model ? ['-m', model] : []), ...effortArgs, '--sandbox', 'read-only', '--ephemeral', '--skip-git-repo-check', '--ignore-user-config', '--ignore-rules', '--color', 'never', request],
     };
   }
   if (engine === 'cursor') {