atris 3.74.4 → 3.74.5

package/lib/campaign-loop.js

@@ -5,6 +5,7 @@
 
 'use strict';
 
+const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { spawn } = require('child_process');
@@ -37,6 +38,18 @@ function proposalId(objective) {
   return `m-${slug || 'mission'}-${crypto.randomBytes(3).toString('hex')}`;
 }
 
+function briefPath(root, campaignId) {
+  return path.join(root, 'atris', 'campaigns', campaignId, 'BRIEF.md');
+}
+
+function readBrief(root, campaignId) {
+  try {
+    return fs.readFileSync(briefPath(root, campaignId), 'utf8').trim();
+  } catch {
+    return '';
+  }
+}
+
 function rankCampaignMembers(view, rsiSummary = null, events = null) {
   const seats = Array.isArray(view && view.seats) ? view.seats.map((s) => s.member).filter(Boolean) : [];
   const candidates = [...new Set([view && view.owner, ...seats].filter(Boolean))];
@@ -99,7 +112,7 @@ function completionOrderedMissions(view, events) {
 
 // What the owner's engine reads before proposing: the goal, how it is judged,
 // what has been tried, and how it went.
-function proposalPrompt(view, count, judgeOutput = null, lessons = '', rsiSummary = null, events = null) {
+function proposalPrompt(view, count, judgeOutput = null, lessons = '', rsiSummary = null, events = null, brief = '') {
   const tried = view.missions.slice(-12).map((m) => `- ${m.id}: ${m.status}${m.outcome ? ` (${m.outcome})` : ''}${m.cost_usd !== null ? `, $${m.cost_usd}` : ''}${typeof m.reward === 'number' ? `, reward ${m.reward >= 0 ? '+' : ''}${m.reward}` : ''}`).join('\n') || '- none yet';
   const ranked = rankCampaignMembers(view, rsiSummary, events);
   const memberLine = ranked.map((r) => {
@@ -113,6 +126,7 @@ function proposalPrompt(view, count, judgeOutput = null, lessons = '', rsiSummar
     `You plan the next missions for an Atris campaign. Answer with JSON only.`,
     ``,
     `Campaign: ${view.title}`,
+    brief ? `Brief:\n${brief}` : '',
     `Judge (the campaign is done when this command exits 0): ${view.judge}`,
     `Last judge reading: ${view.last_judge ? `${view.last_judge.passed ? 'passed' : 'failed'}${typeof view.last_judge.reading === 'number' ? ` (${view.last_judge.reading} of 1)` : ''}: ${view.answer.text || ''}` : 'never run'}`,
     judgeOutput ? `Last judge output:\n\`\`\`\n${judgeOutput.replace(/```/g, "'''")}\n\`\`\`` : '',
@@ -231,7 +245,8 @@ function makeLoop(root, options = {}, deps = {}) {
       });
       rsiSummary = summarizeStoreRsi(store);
     } catch {}
-    const prompt = proposalPrompt(current, count, latestJudgeOutput(events), deps.lessons ? deps.lessons(id) : '', rsiSummary, events);
+    const brief = (deps.brief ? deps.brief(id) : readBrief(root, id)).trim();
+    const prompt = proposalPrompt(current, count, latestJudgeOutput(events), deps.lessons ? deps.lessons(id) : '', rsiSummary, events, brief);
     const answer = await ask(root, current, prompt);
     const proposals = parseProposals(answer.text, current, count, rsiSummary, events);
     // Planning costs money too. It rides on the first mission it produced as a
@@ -242,8 +257,10 @@ function makeLoop(root, options = {}, deps = {}) {
     if (typeof answer.cost_usd === 'number') plan.cost_usd = answer.cost_usd;
     proposals.forEach((proposal, index) => {
       const missionId = proposalId(proposal.objective);
+      const key = claimKey(proposal.objective);
+      if (brief && !proposal.objective.includes(brief)) proposal.objective = `${proposal.objective}\n\n${brief}`;
       append(id, 'mission_proposed', { mission_id: missionId, member: proposal.member, objective: proposal.objective, verify: proposal.verify, estimate_usd: proposal.estimate_usd || undefined }, proposal.member);
-      append(id, 'mission_claimed', { mission_id: missionId, claim_key: claimKey(proposal.objective) }, proposal.member);
+      append(id, 'mission_claimed', { mission_id: missionId, claim_key: key }, proposal.member);
       if (index === 0) append(id, 'step', { mission_id: missionId, ...plan }, current.owner);
     });
     return proposals;
@@ -264,8 +281,10 @@ function makeLoop(root, options = {}, deps = {}) {
   async function startAndRun(id, work) {
     const current = view(id);
     const reserve = work.estimate_usd || defaultReserve(current);
+    const brief = (deps.brief ? deps.brief(id) : readBrief(root, id)).trim();
+    const objective = brief && !work.objective.includes(brief) ? `${work.objective}\n\n${brief}` : work.objective;
     const started = await cli([
-      'mission', 'start', work.objective, '--mission-id', work.mission_id, '--owner', work.member,
+      'mission', 'start', objective, '--mission-id', work.mission_id, '--owner', work.member,
       '--runner', runner, '--verify', work.verify || current.judge, '--campaign', id, '--reserve', String(reserve),
       '--max-wall', String(missionMinutes * 60), '--json',
     ]);
@@ -419,4 +438,4 @@ function makeLoop(root, options = {}, deps = {}) {
   return { step, tick, run, propose };
 }
 
-module.exports = { ACTIVITY_LINE, askOwner, makeLoop, parseProposals, proposalPrompt, rankCampaignMembers, readingKey, runCli };
+module.exports = { ACTIVITY_LINE, askOwner, briefPath, makeLoop, parseProposals, proposalPrompt, rankCampaignMembers, readBrief, readingKey, runCli };

package/lib/claude-boot-block.js

@@ -1,9 +1,12 @@
 'use strict';
 
+const { openingLinesForRoot, renderOpeningLinesBlock } = require('./opening-lines');
+
 const ATRIS_START_MARKER = '<!-- ATRIS:START - Auto-generated, do not edit -->';
 const ATRIS_END_MARKER = '<!-- ATRIS:END -->';
 
-function renderAtrisClaudeBootBlock() {
+function renderAtrisClaudeBootBlock(openingLines = openingLinesForRoot()) {
+  const opening = renderOpeningLinesBlock(openingLines, 'CLAUDE.md');
   return `${ATRIS_START_MARKER}
 ## Atris System
 
@@ -14,12 +17,12 @@ You are now running inside Atris, an AI workspace operating system.
 After displaying the boot output, respond to the user naturally.
 
 The person does not know atris words. Translate their plain English; when unsure run \`atris guide "<their words>"\`.
-${ATRIS_END_MARKER}
+${opening ? `\n${opening}\n` : ''}${ATRIS_END_MARKER}
 `;
 }
 
-function upsertAtrisClaudeBootBlock(source = '') {
-  const atrisBlock = renderAtrisClaudeBootBlock();
+function upsertAtrisClaudeBootBlock(source = '', options = {}) {
+  const atrisBlock = renderAtrisClaudeBootBlock(options.openingLines);
   const startIdx = source.indexOf('<!-- ATRIS:START');
   const prependBlock = (preserved) => {
     const remainder = preserved.replace(/^\n+/, '');

package/lib/engine-registry.js

@@ -914,6 +914,7 @@ function rosterPickFromValue(value, role, options = {}) {
   const primary = resolveRosterWords(main);
   if (!options.anyEngine && !engineCanTake(primary.engine, role)) throw new Error(`${primary.engine} cannot do ${kind} work`);
   let backup = null;
+  const moreBackups = [];
   let until = '';
   let untilYearless = '';
   let maxSeconds = null;
@@ -966,6 +967,11 @@ function rosterPickFromValue(value, role, options = {}) {
     } else if (backupMatch && !backup) {
       backup = resolveRosterWords(backupMatch[1]);
       if (!options.anyEngine && !engineCanTake(backup.engine, role)) throw new Error(`the backup ${backup.engine} cannot do ${kind} work`);
+    } else if (backupMatch) {
+      // every backup after the first steps in next, in written order
+      const more = resolveRosterWords(backupMatch[1]);
+      if (!options.anyEngine && !engineCanTake(more.engine, role)) throw new Error(`the backup ${more.engine} cannot do ${kind} work`);
+      moreBackups.push({ engine: more.engine, model: more.model || '', ...(more.effort ? { effort: more.effort } : {}) });
     } else if (untilMatch && !until) {
       const words = untilMatch[1].trim();
       until = parseRosterUntilWords(words);
@@ -989,6 +995,7 @@ function rosterPickFromValue(value, role, options = {}) {
     backup: backup ? backup.engine : '',
     ...(backup && backup.model ? { backup_model: backup.model } : {}),
     ...(backup && backup.effort ? { backup_effort: backup.effort } : {}),
+    ...(moreBackups.length ? { more_backups: moreBackups } : {}),
     ...(maxSeconds ? { max_seconds: maxSeconds } : {}),
     ...(prep ? { prep } : {}),
     until,
@@ -1102,6 +1109,19 @@ function pickWorkers(pick) {
       ...(pick.line ? { line: pick.line } : {}),
     });
   }
+  for (const more of Array.isArray(pick.more_backups) ? pick.more_backups : []) {
+    list.push({
+      engine: more.engine,
+      model: more.model || '',
+      ...(more.effort ? { effort: more.effort } : {}),
+      ...cap,
+      until: '',
+      never_expires: true,
+      lenient_model: true,
+      backup: true,
+      ...(pick.line ? { line: pick.line } : {}),
+    });
+  }
   return list;
 }
 
@@ -1114,6 +1134,7 @@ function parseRosterMarkdown(text, file, options = {}) {
   const display = rosterFileLabel(file, options.root || process.cwd());
   const picks = {};
   const team = [];
+  const shortlist = [];
   const warnings = [];
   const warn = (entry, message) => warnings.push({ file: display, line: entry.lineNumber, text: entry.raw, message });
   const scan = scanRosterMarkdown(text);
@@ -1171,6 +1192,27 @@ function parseRosterMarkdown(text, file, options = {}) {
       }
       continue;
     }
+    if (entry.section === 'picks') {
+      // "- claude · <model>": the tool, a middle dot, then the model as the
+      // owner writes it. Without the dot the words read like a roster line.
+      const dot = entry.value.indexOf('\u00b7');
+      const toolWords = dot === -1 ? '' : entry.value.slice(0, dot).trim();
+      const modelWords = dot === -1 ? '' : entry.value.slice(dot + 1).trim();
+      let engine = toolWords ? rosterToolName(toolWords) : '';
+      let model = modelWords;
+      if (dot === -1) {
+        try {
+          const read = resolveRosterWords(entry.value);
+          engine = read.engine;
+          model = read.model ? workerModelText(read.engine, read.model) : '';
+        } catch {
+          engine = '';
+        }
+      }
+      if (!engine) warn(entry, 'is not "tool · model", so the pick is skipped');
+      else shortlist.push({ engine, model, line: entry.lineNumber, text: entry.raw, file: display });
+      continue;
+    }
     if (entry.malformed) {
       warn(entry, entry.section === 'team' ? 'is not "member: job or engine", so it is skipped' : 'is not "job: engine", so it is skipped');
       continue;
@@ -1217,7 +1259,7 @@ function parseRosterMarkdown(text, file, options = {}) {
       warn(entry, `${error.message}, so ${label} uses the next pick in line`);
     }
   }
-  return { picks, team, warnings };
+  return { picks, team, warnings, ...(shortlist.length ? { shortlist } : {}) };
 }
 
 function readRosterMarkdownLayer(scope, file, options = {}) {
@@ -1602,6 +1644,25 @@ function assignedWorkerLines(key, engineName, options, context) {
   });
   const heading = jobHeadingText(key, builtIn ? '' : kind);
   if (options.add) return { lines: [...currentLines, line], heading };
+  // keepLead (roster set): the new lead goes on top and every old worker
+  // stays below it as written, the old lead first, so it becomes the first
+  // backup. A line that already names this tool and model moves up as
+  // written instead. A new line takes the old lead's time cap and prep: those
+  // belong to the job, not the tool.
+  if (options.keepLead) {
+    const found = currentWorkers.findIndex((worker) => worker.engine === engine.id && (worker.model || '') === model);
+    if (found !== -1) return { lines: [currentLines[found], ...currentLines.filter((text, index) => index !== found)], heading };
+    const old = currentWorkers[0] || {};
+    const carried = workerLineText({
+      engine: engine.id,
+      model,
+      ...(effort ? { effort } : {}),
+      ...(maxSeconds || old.max_seconds ? { max_seconds: maxSeconds || old.max_seconds } : {}),
+      ...(prep || (old.prep && old.prep !== key) ? { prep: prep || old.prep } : {}),
+      until: days ? rosterUntil(now, days) : '',
+    });
+    return { lines: [carried, ...currentLines], heading };
+  }
   // A note the person left at the end of the old lead line stays with the lead.
   const leadNote = currentLines.length ? /\s*(<!--.*?-->)\s*$/.exec(currentLines[0]) : null;
   const lead = leadNote ? `${line} ${leadNote[1]}` : line;
@@ -1690,6 +1751,79 @@ function setRosterPick(jobName, engineName, options = {}, root = process.cwd())
   return target.scope === 'machine' ? readMachineRoster(options) : readProjectRoster(root, options).picks;
 }
 
+// Give one member its own line under "## team" ("- builder: codex, model:
+// <name>"), replacing that member's line in place or adding it. Same files
+// and layers as setRosterPick (session, everywhere, or this project), and the
+// same rewrite into sections first. role is the member's kind of work; the
+// line must read back as a pick the engine can do, or nothing is written.
+// A member's one-line pick with only its lead changed: the old lead (its
+// tool, model, and effort) goes to the front of the backups, a backup that
+// already names the new lead goes, and every other part stays as written:
+// backups, max, prep, until, verified. null when the old value is not a pick
+// (a job name, or a line that does not read), so the whole value is replaced.
+function teamValueWithLead(oldValue, engineId, model, role, options = {}) {
+  let old;
+  try {
+    old = rosterPickFromValue(oldValue, role, options);
+  } catch {
+    return null;
+  }
+  const parts = String(oldValue || '').split(',').map((part) => part.trim()).filter(Boolean);
+  for (let i = parts.length - 1; i > 0; i -= 1) {
+    if (/^\d{4}$/.test(parts[i])) parts.splice(i - 1, 2, `${parts[i - 1]} ${parts[i]}`);
+  }
+  const [main, ...rest] = parts;
+  const inlineMax = /\s+(max\s+\d+(?:\.\d+)?\s*[a-z]+)$/i.exec(main || '');
+  const extras = inlineMax ? [inlineMax[1], ...rest] : rest;
+  const words = (engine, pinned, effort) => [rosterToolLabel(engine), pinned ? workerModelText(engine, pinned) : '', effort || ''].filter(Boolean).join(' ');
+  const namesNewLead = (text) => {
+    try {
+      const read = resolveRosterWords(text);
+      return read.engine === engineId && (read.model || '') === model;
+    } catch {
+      return false;
+    }
+  };
+  // model and effort parts belong to the old lead, so they go with it
+  const kept = extras
+    .filter((part) => !/^(model|effort)\s*(?::|\s)/i.test(part))
+    .filter((part) => {
+      const named = /^backup\s+(.+)$/i.exec(part);
+      return !(named && namesNewLead(named[1]));
+    });
+  if (!(old.engine === engineId && (old.model || '') === model)) {
+    const at = kept.findIndex((part) => /^backup\s+/i.test(part));
+    kept.splice(at === -1 ? 0 : at, 0, `backup ${words(old.engine, old.model, old.effort)}`);
+  }
+  const lead = [rosterToolLabel(engineId), ...(model ? [`model: ${workerModelText(engineId, model)}`] : [])];
+  return [...lead, ...kept].join(', ');
+}
+
+function setTeamPick(memberName, engineName, options = {}, root = process.cwd()) {
+  const { replaceTeamLine, scanRosterMarkdown } = require('./roster-markdown');
+  const member = String(memberName || '').trim().toLowerCase();
+  if (!/^[a-z0-9._-]+$/.test(member)) throw new Error(`"${memberName}" is not a member name`);
+  const registry = readEngineRegistry(root, { persist: false });
+  const engineId = rosterToolName(engineName);
+  if (!registry.engines.some((entry) => entry.id === engineId)) throw new Error(`unknown engine "${engineName}"`);
+  const model = normalizeRosterModel(engineId, options.model);
+  if (model && !engineTakesModel(engineId)) throw new Error(`${engineId} runs one fixed model and cannot take "${model}"`);
+  const role = options.role || 'executor';
+  const target = rosterWriteTarget(options, root);
+  const layer = target.layer || readProjectRoster(root, { ...options, registry });
+  const file = target.file;
+  const existing = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : null;
+  const base = existing !== null ? sectionedRosterText(existing, file, { ...options, root }) : rosterMarkdownFromPicks(layer.picks);
+  // a swap changes only the lead of the member's line already in this file
+  const line = scanRosterMarkdown(base).entries.find((entry) => entry.section === 'team' && !entry.malformed && entry.name.trim().toLowerCase() === member);
+  const value = (line && teamValueWithLead(line.value, engineId, model, role, { root }))
+    || workerLineText({ engine: engineId, model }).replace(/^-\s+/, '');
+  rosterPickFromValue(value, role, { root });
+  writeAtomic(file, replaceTeamLine(base, member, value));
+  if (target.scope === 'session') sweepStaleSessionRosters(options);
+  return { member, engine: engineId, model, value, scope: target.scope, file };
+}
+
 function renewRoster(roster, date) {
   const next = { ...(roster || {}) };
   for (const key of [...ENGINE_ROLES, ...customRosterJobKeys(next)]) {
@@ -2317,7 +2451,11 @@ module.exports = {
   rosterChoiceForPick,
   customRosterJobKeys,
   setRosterPick,
+  setTeamPick,
   confirmRoster,
+  engineHasRole,
+  engineHosted,
+  rosterToolName,
   normalizeRosterModel,
   currentClaudeModel,
   claudeModelId,

package/lib/fleet.js

@@ -1922,6 +1922,10 @@ function reviewOnlyEngineEnvironment(worktreePath, options = {}) {
     GIT_CONFIG_NOSYSTEM: '1',
     CODEX_HOME: path.join(runtimeHome, '.codex'),
     CLAUDE_CONFIG_DIR: path.join(runtimeHome, '.claude'),
+    // Claude Code keeps its own temp files under /tmp/claude-<uid> unless this
+    // is set. The sealed profile cannot read /tmp, so without it every sealed
+    // claude build died at start ("EEXIST: mkdir /tmp/claude-501").
+    CLAUDE_CODE_TMPDIR: runtimeTmp,
     ATRIS_ONE_LAP_SANDBOX_PROFILE: sandboxProfile,
     ATRIS_ONE_LAP_RUNTIME_DIR: runtimeTmp,
     ATRIS_ONE_LAP_CONTROL_DIR: controlTmp,
@@ -3442,6 +3446,9 @@ async function runDispatchFlight({
   // search" on its roster line), and an injectable ask for that prep pass.
   prep = '',
   prepAsk = undefined,
+  // Extra house rules a caller appends to the builder's brief (atris idea
+  // tick sends the four values and the no-force-push, no-hook-skip rules).
+  brief = '',
 } = {}) {
   if (!engine) throw new Error('runDispatchFlight: engine is required');
   if (!DISPATCH_CAPABLE.includes(engine)) {
@@ -3563,13 +3570,15 @@ async function runDispatchFlight({
       }
       const worktreePath = enforceRemoteBoundary ? remoteBoundary.worktreePath : landingWorktreePath;
       const startCommit = yolo ? readStartCommit({ worktreePath }) : '';
-      const basePrompt = promptOverride || buildFleetPrompt(task, { worktreePath, yolo: yolo && !localOnly });
+      const briefNote = String(brief || '').trim();
+      const builtPrompt = promptOverride || buildFleetPrompt(task, { worktreePath, yolo: yolo && !localOnly });
+      const basePrompt = briefNote ? `${builtPrompt}\n\n${briefNote}` : builtPrompt;
       const safetyPrompt = proofOnly
         ? `${basePrompt}\n\nSafety boundary: edit and test this checkout only. Do not push, merge, deploy, publish, send messages, change cloud state, install dependencies, or use credentials.`
         : basePrompt;
       const trustedPrompt = trustedVerifier
         ? `${safetyPrompt}\n\nTrusted verifier (run it bare before reporting done): ${trustedVerifier}`
-        : (localOnly ? safetyPrompt : promptOverride);
+        : (localOnly ? safetyPrompt : (briefNote ? basePrompt : promptOverride));
       prepared.push({
         task,
         taskId,