atris 3.38.0 → 3.41.0

package/commands/xp.js

@@ -5,6 +5,7 @@ const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
 const { spawnSync } = require('child_process');
+const { hasFlag: hasExactFlag } = require('../lib/arg-parser');
 
 const DEFAULT_GRAPH_DAYS = 365;
 const MAX_SYNC_GRAPH_DAYS = 370;
@@ -277,7 +278,8 @@ function currentForm(payload) {
   };
 }
 
-function readFlag(args, name, fallback = null) {
+// Preserve the existing rule that any inline value wins over a split value.
+function readInlineFirstFlag(args, name, fallback = null) {
   const inline = args.find(arg => arg.startsWith(`${name}=`));
   if (inline) {
     return inline.slice(name.length + 1);
@@ -291,7 +293,7 @@ function readFlag(args, name, fallback = null) {
 
 function readFirstFlag(args, names, fallback = null) {
   for (const name of names) {
-    const value = readFlag(args, name, null);
+    const value = readInlineFirstFlag(args, name, null);
     if (value !== null && value !== undefined && value !== '') return value;
   }
   return fallback;
@@ -313,8 +315,9 @@ function readFlagValues(args, names) {
   return values.filter(Boolean);
 }
 
-function hasFlag(args, name) {
-  return args.includes(name) || args.some(arg => arg.startsWith(`${name}=`));
+// This command treats --name=value as flag presence as well as a standalone flag.
+function hasFlagOrValue(args, name) {
+  return hasExactFlag(args, name) || args.some(arg => arg.startsWith(`${name}=`));
 }
 
 function levelFromXp(careerXp) {
@@ -1040,7 +1043,7 @@ function buildCareerXpProjection(receipts, workspace, integrity = {}) {
 }
 
 function collectLocalXpProjectionState(args = [], { write = true } = {}) {
-  const workspace = path.resolve(readFlag(args, '--workspace', defaultXpWorkspace()));
+  const workspace = path.resolve(readInlineFirstFlag(args, '--workspace', defaultXpWorkspace()));
   const episodePath = path.join(workspace, TASK_EPISODES_FILE);
   const receiptsPath = path.join(workspace, CAREER_XP_RECEIPTS_FILE);
   const projectionPath = path.join(workspace, CAREER_XP_PROJECTION_FILE);
@@ -1170,7 +1173,7 @@ function defaultAllSearchRoots(args = []) {
   if (explicitRoots.length) return uniquePaths(explicitRoots);
 
   const roots = [];
-  const workspace = readFlag(args, '--workspace', null);
+  const workspace = readInlineFirstFlag(args, '--workspace', null);
   if (workspace) roots.push(workspace);
   roots.push(process.cwd());
   roots.push(path.join(os.homedir(), 'arena'));
@@ -1575,7 +1578,7 @@ function codexHasThreadsTable(dbPath) {
 }
 
 function readCodexGoalsForSession(args, workspace, sinceMs, untilMs) {
-  const explicitDb = readFlag(args, '--codex-state', readFlag(args, '--state', process.env.CODEX_STATE_DB || ''));
+  const explicitDb = readInlineFirstFlag(args, '--codex-state', readInlineFirstFlag(args, '--state', process.env.CODEX_STATE_DB || ''));
   const dbPath = explicitDb
     ? path.resolve(expandHome(explicitDb))
     : path.resolve(fs.existsSync(CODEX_GOALS_FILE) ? CODEX_GOALS_FILE : CODEX_STATE_FILE);
@@ -1592,7 +1595,7 @@ function readCodexGoalsForSession(args, workspace, sinceMs, untilMs) {
     }
   }
 
-  const threadId = readFlag(args, '--thread', process.env.CODEX_THREAD_ID || '');
+  const threadId = readInlineFirstFlag(args, '--thread', process.env.CODEX_THREAD_ID || '');
   const clauses = [];
   if (threadId) clauses.push(`tg.thread_id = ${sqlString(threadId)}`);
   const workspaceCandidates = workspacePathCandidates(workspace);
@@ -1632,9 +1635,9 @@ LIMIT 25
 }
 
 function buildCareerXpSessionCapsule(args = []) {
-  const workspace = path.resolve(readFlag(args, '--workspace', defaultXpWorkspace()));
-  const sinceInput = readFlag(args, '--since', 'today');
-  const untilInput = readFlag(args, '--until', null);
+  const workspace = path.resolve(readInlineFirstFlag(args, '--workspace', defaultXpWorkspace()));
+  const sinceInput = readInlineFirstFlag(args, '--since', 'today');
+  const untilInput = readInlineFirstFlag(args, '--until', null);
   const since = parseSessionBoundary(sinceInput, startOfToday());
   const until = parseSessionBoundary(untilInput, new Date());
   const sinceMs = since.getTime();
@@ -1643,7 +1646,7 @@ function buildCareerXpSessionCapsule(args = []) {
     throw new Error('--since must be before --until');
   }
 
-  const writeEnabled = !hasFlag(args, '--no-write') && !hasFlag(args, '--dry-run');
+  const writeEnabled = !hasFlagOrValue(args, '--no-write') && !hasFlagOrValue(args, '--dry-run');
   const projectionState = collectLocalXpProjectionState(['--workspace', workspace], { write: writeEnabled });
   const projection = projectionState.projection;
   const receiptsPath = path.join(workspace, CAREER_XP_RECEIPTS_FILE);
@@ -1675,7 +1678,7 @@ function buildCareerXpSessionCapsule(args = []) {
   });
   const windowXp = acceptedReceipts.reduce((sum, receipt) => sum + asNumber(receipt.xp), 0);
   const afterTotalXp = asNumber(projection.total_xp);
-  const missionFlag = readFlag(args, '--mission', null);
+  const missionFlag = readInlineFirstFlag(args, '--mission', null);
   const episodeGoals = readJsonl(path.join(workspace, TASK_EPISODES_FILE), { allowPartialTail: true })
     .filter(episode => inWindow(episode?.created_at, sinceMs, untilMs))
     .map(episode => episode.goal);
@@ -1890,8 +1893,8 @@ function syncScopeFields(attribution = {}) {
 }
 
 function publicAgentXpOverride(args = []) {
-  if (hasFlag(args, '--public')) return true;
-  if (hasFlag(args, '--private') || hasFlag(args, '--internal')) return false;
+  if (hasFlagOrValue(args, '--public')) return true;
+  if (hasFlagOrValue(args, '--private') || hasFlagOrValue(args, '--internal')) return false;
   return null;
 }
 
@@ -1946,9 +1949,9 @@ function syncPlayer(args, projection) {
 }
 
 function buildAgentXpSyncPacket(args = []) {
-  const localMode = hasFlag(args, '--local') || hasFlag(args, '--workspace') || hasFlag(args, '--operator');
+  const localMode = hasFlagOrValue(args, '--local') || hasFlagOrValue(args, '--workspace') || hasFlagOrValue(args, '--operator');
   const projectionArgs = args.filter(arg => !['--dry-run', '--no-post', '--packet', '--public', '--private', '--internal'].includes(arg));
-  const projection = hasFlag(args, '--all') || !localMode
+  const projection = hasFlagOrValue(args, '--all') || !localMode
     ? collectAllLocalXpProjection(projectionArgs)
     : collectLocalXpProjection(projectionArgs);
   const player = syncPlayer(args, projection);
@@ -2086,10 +2089,10 @@ function buildAgentXpSyncPacket(args = []) {
 
 async function syncAgentXp(args = []) {
   const preview = buildAgentXpSyncPacket(args);
-  const dryRun = hasFlag(args, '--dry-run') || hasFlag(args, '--no-post') || hasFlag(args, '--packet');
+  const dryRun = hasFlagOrValue(args, '--dry-run') || hasFlagOrValue(args, '--no-post') || hasFlagOrValue(args, '--packet');
   if (dryRun) return preview;
 
-  const token = readFlag(args, '--token', process.env.ATRIS_AGENTXP_SYNC_TOKEN || process.env.AGENTXP_SYNC_TOKEN || '');
+  const token = readInlineFirstFlag(args, '--token', process.env.ATRIS_AGENTXP_SYNC_TOKEN || process.env.AGENTXP_SYNC_TOKEN || '');
   const envToken = process.env.ATRIS_TOKEN && process.env.ATRIS_TOKEN.trim() ? process.env.ATRIS_TOKEN.trim() : '';
   const options = {
     method: 'POST',
@@ -2298,11 +2301,11 @@ async function xpCommand(...args) {
     const commandArgs = args.slice(1);
     let payload;
     try {
-      const explicitLocal = hasFlag(commandArgs, '--local')
-        || hasFlag(commandArgs, '--workspace')
-        || hasFlag(commandArgs, '--operator');
+      const explicitLocal = hasFlagOrValue(commandArgs, '--local')
+        || hasFlagOrValue(commandArgs, '--workspace')
+        || hasFlagOrValue(commandArgs, '--operator');
       const accountStatus = (subcommand === 'status' || subcommand === 'card') && !explicitLocal;
-      payload = hasFlag(commandArgs, '--all') || accountStatus
+      payload = hasFlagOrValue(commandArgs, '--all') || accountStatus
         ? collectAllLocalXpProjection(commandArgs)
         : collectLocalXpProjection(commandArgs);
     } catch (error) {
@@ -2324,7 +2327,7 @@ async function xpCommand(...args) {
   }
 
   const jsonMode = args.includes('--json');
-  const localMode = hasFlag(args, '--local') || hasFlag(args, '--workspace') || hasFlag(args, '--operator');
+  const localMode = hasFlagOrValue(args, '--local') || hasFlagOrValue(args, '--workspace') || hasFlagOrValue(args, '--operator');
   if (localMode) {
     let payload;
     try {

package/lib/accept-verify-gate.js

@@ -101,12 +101,16 @@ function evaluateAcceptVerify(task, workspaceRoot, { cache = null } = {}) {
 
   const result = runVerifyCommandCached(command, workspaceRoot, cache);
   if (!result.ok) {
+    const diffCheck = /^git\s+diff\s+--check\b/i.test(command.trim());
+    const fixHint = diffCheck
+      ? '; trailing whitespace in markdown is auto-fixable: npm run audit:markdown-whitespace -- --fix'
+      : '';
     return {
       ok: false,
       reason: result.reason || 'verify_failed',
       detail: result.reason === 'verify_workdir_missing' || result.reason === 'verify_worktree_missing'
         ? 'the stored verify command points at a directory that no longer exists'
-        : `the stored verify command did not pass (${result.reason || 'nonzero exit'})`,
+        : `the stored verify command did not pass (${result.reason || 'nonzero exit'})${fixHint}`,
       command,
       ran: true,
       exit_code: typeof result.status === 'number' ? result.status : null,

package/lib/arg-parser.js

@@ -0,0 +1,41 @@
+'use strict';
+
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+
+function unquote(value) {
+  const text = String(value);
+  if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
+    return text.slice(1, -1);
+  }
+  return text;
+}
+
+function readFlag(args, name, fallback = '') {
+  const prefix = `${name}=`;
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = String(args[i]);
+    if (arg === name && args[i + 1] && !String(args[i + 1]).startsWith('--')) {
+      return unquote(args[i + 1]);
+    }
+    if (arg.startsWith(prefix)) return unquote(arg.slice(prefix.length));
+  }
+  return fallback;
+}
+
+function readIntFlag(args, name, fallback = null) {
+  const raw = readFlag(args, name, '');
+  if (!raw) return fallback;
+  const value = Number.parseInt(raw, 10);
+  return Number.isFinite(value) ? value : null;
+}
+
+function readNumberFlag(args, name, fallback = null) {
+  const raw = readFlag(args, name, '');
+  if (!raw) return fallback;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : null;
+}
+
+module.exports = { hasFlag, readFlag, readIntFlag, readNumberFlag };

package/lib/auto-accept-certified.js

@@ -13,7 +13,7 @@ const AGENT_CERTIFICATION_REVIEW_PASSES = 2;
 // once powered is gone. Passes alone never land work, an independent
 // reviewer does.
 const AUTO_ACCEPT_HIGH_CONFIDENCE_PASSES = 3;
-const DENIED_TAGS = new Set(['billing', 'deploy', 'feedback', 'security', 'customer', 'external']);
+const DENIED_TAGS = new Set(['billing', 'money', 'payments', 'deploy', 'feedback', 'security', 'customer', 'external']);
 
 const SIMPLE_VERIFY_TOKEN_RE = /^[a-zA-Z0-9_./:@=+-]+$/;
 const GIT_WORKTREE_PATH_RE = /^[a-zA-Z0-9_./@=+-]+$/;
@@ -447,7 +447,41 @@ function isAutoCertifyVerifyCommandAllowed(verify) {
   return parseVerifyCommand(verify).ok;
 }
 
+// Re-entrancy guard: every verify child carries ATRIS_VERIFY_IN_PROGRESS=1
+// (see verifyCommandEnv). A verify that shells back into the CLI and reaches
+// another verify would otherwise recurse without bound — that cycle
+// fork-bombed the fleet on 2026-07-29 when a stored pytest called
+// `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;
+let verifySpawnCount = 0;
+
+function verifyRefusal(unrunnableCause, extra) {
+  return {
+    ok: false,
+    reason: 'verify_unrunnable',
+    unrunnable_cause: unrunnableCause,
+    alarm: true,
+    ...(extra || {}),
+  };
+}
+
 function runVerifyCommand(verify, workspaceRoot) {
+  if (process.env[VERIFY_IN_PROGRESS_ENV]) {
+    return verifyRefusal('verify_reentrant', {
+      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) {
+    return verifyRefusal('verify_spawn_cap', {
+      detail: `this process already ran ${verifySpawnCount} verifies (cap ${VERIFY_SPAWN_CAP}); refusing more`,
+    });
+  }
+  verifySpawnCount += 1;
   const parsed = parseVerifyCommand(verify);
   if (!parsed.ok) return parsed;
   const cwdCheck = validateCommandCwd(parsed, workspaceRoot);
@@ -503,6 +537,7 @@ function verifyCommandEnv(extraEnv) {
   if (binDir && !alreadyPresent) {
     base.PATH = current ? `${binDir}${path.delimiter}${current}` : binDir;
   }
+  base[VERIFY_IN_PROGRESS_ENV] = '1';
   return base;
 }
 
@@ -528,6 +563,63 @@ function runVerifyCommandCached(verify, workspaceRoot, cache = null) {
   return { ...result, reused: false };
 }
 
+// Pre-land hygiene: dead exports used to surface only AFTER landing, when the
+// full suite's repo-hygiene ratchet went red on master (lesson:
+// engine-dead-exports — engines export every internal helper, the task's own
+// verify command stays green, and the breakage lands). In repos that carry the
+// ratchet (test/repo-hygiene.test.js), run the same detector before landing so
+// the gate refuses the work instead of master discovering it. Memoized per
+// root: one scan covers every task in a sweep.
+const repoHygieneCache = new Map();
+
+function repoHygieneGate(workspaceRoot) {
+  const root = path.resolve(workspaceRoot || process.cwd());
+  if (repoHygieneCache.has(root)) return repoHygieneCache.get(root);
+  let result = { ok: true, skipped: true };
+  if (fs.existsSync(path.join(root, 'test', 'repo-hygiene.test.js'))) {
+    try {
+      const { findDeadCode, findOrphanedExports, listJsFiles } = require('../commands/slop');
+      const dead = findDeadCode(root).dead;
+      const files = ['commands', 'lib'].flatMap((d) => listJsFiles(path.join(root, d)));
+      const orphans = findOrphanedExports(root, files, listJsFiles(root));
+      const offenders = [
+        ...dead.map((f) => path.relative(root, f)),
+        ...orphans.map((o) => `${path.relative(root, o.file)} → ${o.name}`),
+      ];
+      result = offenders.length
+        ? {
+          ok: false,
+          reason: 'dead_exports',
+          offenders: offenders.slice(0, 12),
+          message: 'this work leaves code or exports nothing uses, so the full test suite fails right after landing; delete the unused pieces and land again.',
+        }
+        : { ok: true };
+    } catch (err) {
+      // "I could not run the detector" is not a verdict on the work — same
+      // rule as verify_unrunnable, but hygiene is a repo-wide ratchet the
+      // suite still enforces, so failing open here only delays the red.
+      result = { ok: true, skipped: true, error: String((err && err.message) || err).slice(0, 200) };
+    }
+  }
+  repoHygieneCache.set(root, result);
+  return result;
+}
+
+// Shared by both landing lanes so the check cannot ship in one dispatch branch
+// and silently skip the sibling (lesson: parallel-paths-drift).
+function hygieneBlockResult(task, ref) {
+  const hygiene = repoHygieneGate(task.workspace_root || process.cwd());
+  if (hygiene.ok) return null;
+  return {
+    eligible: false,
+    ref,
+    reason: hygiene.reason,
+    message: hygiene.message,
+    offenders: hygiene.offenders,
+    next_action: 'run `node --test test/repo-hygiene.test.js` in the workspace, delete what it names, then re-certify',
+  };
+}
+
 function strictVerifyMissingResult(ref) {
   return {
     eligible: false,
@@ -721,6 +813,19 @@ function evaluateAutoAccept(task, options = {}) {
     if (trustTier === 'probation' && !reviewIntegrity.hasIndependentReview(task)) {
       return { eligible: false, ref, reason: 'probation_needs_review' };
     }
+    // The read-only status path (executeVerify:false) must apply the same
+    // command allowlist the landing gate applies, or status promises a landing
+    // the gate will refuse every hour: five rows read "lands itself" for a
+    // whole night while every tick skipped them as verify_command_not_allowed.
+    // Sits after the probation gate so it reports the gate's own refusal
+    // order, not a new one.
+    if (verify && !executeVerify && !isAutoCertifyVerifyCommandAllowed(verify)) {
+      return { eligible: false, ref, reason: 'verify_command_not_allowed', verify };
+    }
+    if (executeVerify) {
+      const hygieneBlock = hygieneBlockResult(task, ref);
+      if (hygieneBlock) return hygieneBlock;
+    }
     return {
       eligible: true,
       ref,
@@ -788,9 +893,18 @@ function evaluateAutoAccept(task, options = {}) {
       if (!verifyResult.ok) {
         return { eligible: false, ref, reason: verifyResult.reason, verify, ...verifyResult };
       }
+    } else if (!isAutoCertifyVerifyCommandAllowed(verify)) {
+      // Same truth rule as above: the read-only path may not promise a
+      // landing the allowlist will refuse.
+      return { eligible: false, ref, reason: 'verify_command_not_allowed', verify };
     }
   }
 
+  if (executeVerify) {
+    const hygieneBlock = hygieneBlockResult(task, ref);
+    if (hygieneBlock) return hygieneBlock;
+  }
+
   return {
     eligible: true,
     ref,
@@ -812,6 +926,7 @@ module.exports = {
   isAutoCertifyVerifyCommandAllowed,
   isAgentCertified,
   parseVerifyCommand,
+  repoHygieneGate,
   runVerifyCommand,
   runVerifyCommandCached,
 };

package/lib/autoland.js

@@ -120,6 +120,66 @@ function liveAcceptAuthorization(root = process.cwd()) {
   return { ok: true, actor, policy: 'autoland', strictVerify: policy.strict_verify !== false };
 }
 
+// Tick receipts are local file reads and prove the loop ran. A receipt from
+// the last couple of hours means the hourly pass is alive; older or missing
+// means surfaces must not promise "next tick" landing.
+const HEARTBEAT_LIVE_HOURS = 2;
+const STALE_HEARTBEAT_LANDING = 'once the hourly heartbeat runs (start one with atris autoland tick)';
+
+function lastTickAgeHours(root) {
+  try {
+    const runsDir = path.join(root, 'atris', 'runs');
+    const newest = fs.readdirSync(runsDir)
+      .filter((f) => f.startsWith('autoland-tick-') && f.endsWith('.json'))
+      .sort()
+      .pop();
+    if (!newest) return null;
+    const stamp = fs.statSync(path.join(runsDir, newest)).mtimeMs;
+    return (Date.now() - stamp) / 3_600_000;
+  } catch {
+    return null;
+  }
+}
+
+function heartbeatIsLive(root) {
+  const ageHours = lastTickAgeHours(root);
+  return ageHours !== null && ageHours <= HEARTBEAT_LIVE_HOURS;
+}
+
+function heartbeatLiveness(root, policy) {
+  return typeof policy?.heartbeat_installed === 'boolean' ? policy.heartbeat_installed : null;
+}
+
+function heartbeatStatusText(root, policy) {
+  const ageHours = lastTickAgeHours(root);
+  const ageText = ageHours === null
+    ? null
+    : ageHours < 1 ? 'under an hour' : `${Math.floor(ageHours)}h`;
+  // Evidence first: a receipt from the last couple of hours proves the loop is
+  // alive no matter what the policy file remembers. The hourly cron makes two
+  // missed hours an outage rather than jitter — and a heartbeat that has gone
+  // quiet is the single most useful thing this line can say, because that is
+  // the state nobody notices.
+  if (ageHours !== null && ageHours <= HEARTBEAT_LIVE_HOURS) return `running hourly (last tick ${ageText} ago)`;
+  if (ageHours !== null) return `SILENT - last tick ${ageText} ago; run atris autoland tick`;
+  const installed = heartbeatLiveness(root, policy);
+  if (installed === false) return 'not installed - run atris autoland on';
+  if (installed === true) return 'installed, but no tick has ever run - run atris autoland tick';
+  return 'unknown - run atris autoland on to check and repair';
+}
+
+// Operator-facing schedule: only promise "next tick" when a recent receipt
+// proves the loop is alive. Otherwise name the honest gate.
+function whenAutolandLands(root) {
+  return heartbeatIsLive(root) ? 'on the next tick' : STALE_HEARTBEAT_LANDING;
+}
+
+function certifiedWorkLandsPhrase(root) {
+  return heartbeatIsLive(root)
+    ? 'certified work lands itself'
+    : `certified work lands ${STALE_HEARTBEAT_LANDING}`;
+}
+
 function cronMarker(root) {
   const slug = path.basename(root).replace(/[^a-zA-Z0-9]+/g, '_').toUpperCase();
   return `ATRIS_AUTOLAND_${slug}`;
@@ -654,8 +714,10 @@ function sendImessage(root, to, text) {
 module.exports = {
   DEFAULT_ALARM_HOURS,
   DEFAULT_DIGEST_HOUR,
+  STALE_HEARTBEAT_LANDING,
   acceptedInLastDay,
   buildCronLine,
+  certifiedWorkLandsPhrase,
   clarify,
   composeAlarm,
   composeDigest,
@@ -665,6 +727,9 @@ module.exports = {
   digestLine,
   dejargon,
   explainResult,
+  heartbeatIsLive,
+  heartbeatLiveness,
+  heartbeatStatusText,
   installCron,
   liveAcceptAuthorization,
   markAlerted,
@@ -684,6 +749,7 @@ module.exports = {
   statePath,
   uninstallCron,
   waitingOnHuman,
+  whenAutolandLands,
   writePolicy,
   writeState,
 };

package/lib/bench/runner.js

@@ -219,6 +219,22 @@ async function runSetup(spec, ctx) {
   await setup(ctx);
 }
 
+// The one live prompt gate (lesson: benchmark-prompt-paths): receipt tests run
+// the solution/null engines, which never read the prompt, so a malformed
+// prompt.md sails through green dry-runs and only a paid real-engine run finds
+// it. Every prompt an engine receives flows through here, and the tests assert
+// real task prompts against the same function.
+function readTaskPrompt(spec) {
+  const text = fs.readFileSync(spec.promptPath, 'utf8');
+  if (!text.trim() || text.trim().length < 20) {
+    throw new BenchInfraError(`${spec.id}: prompt.md is empty or too short to brief an engine`);
+  }
+  if (/\{\{[^}]*\}\}|<%|\uFFFD|\u0000/.test(text)) {
+    throw new BenchInfraError(`${spec.id}: prompt.md carries unresolved template or encoding artifacts`);
+  }
+  return text;
+}
+
 function formatEngineFailure(engineName, result) {
   const stdout = String(result && result.stdout ? result.stdout : '').trim();
   const stderr = String(result && result.stderr ? result.stderr : '').trim();
@@ -256,7 +272,7 @@ async function runAgentTaskSpec(spec, options = {}) {
     }
 
     await runSetup(spec, ctx);
-    const promptText = fs.readFileSync(spec.promptPath, 'utf8');
+    const promptText = readTaskPrompt(spec);
     const engineResult = await withTimeout(Promise.resolve(engine.run(promptText, ctx.workspace, timeoutMs)), spec, timeoutMs);
     if (!engineResult || engineResult.status !== 0) {
       throw new Error(formatEngineFailure(options.engine, engineResult));
@@ -493,8 +509,10 @@ module.exports = {
   BenchInfraError,
   DEFAULT_PACK,
   findPython,
+  loadTaskSpecs,
   packMetadata,
   readResultRecords,
+  readTaskPrompt,
   runBench,
   summarizeTasks,
   taskMetadata,

package/lib/context-gatherer.js

@@ -28,7 +28,13 @@ function hasContextProfile(root = process.cwd()) {
 function compactText(value, max = 160) {
   const text = String(value || '').replace(/\s+/g, ' ').trim();
   if (!text) return '';
-  return text.length > max ? `${text.slice(0, Math.max(0, max - 3)).trim()}...` : text;
+  if (text.length <= max) return text;
+  const slice = text.slice(0, Math.max(0, max - 3));
+  const lastSpace = slice.lastIndexOf(' ');
+  // Cut on a word boundary so a title never ends on half a word ("...an autonomo...").
+  // Fall back to the hard slice only when a single word already fills the limit.
+  const body = lastSpace > 0 ? slice.slice(0, lastSpace) : slice;
+  return `${body.replace(/[\s,;:.!?-]+$/, '')}...`;
 }
 
 function inferDomain(answer) {