atris 3.74.4 → 3.74.6

package/commands/xp.js

@@ -7,6 +7,9 @@ const crypto = require('crypto');
 const { spawnSync } = require('child_process');
 const { hasFlag: hasExactFlag } = require('../lib/arg-parser');
 const { treeHashFor } = require('../lib/tree-hash');
+const { careerXpRoot, careerXpLinkedRoots } = require('../lib/career-xp-root');
+const { withCareerXpLock } = require('../lib/career-xp-lock');
+const { normalizeActor, taskBuilder } = require('../lib/review-integrity');
 
 const DEFAULT_GRAPH_DAYS = 365;
 const MAX_SYNC_GRAPH_DAYS = 370;
@@ -22,15 +25,15 @@ const TASK_PROJECTION_FILE = path.join('.atris', 'state', 'tasks.projection.json
 const CODEX_STATE_FILE = path.join(os.homedir(), '.codex', 'state_5.sqlite');
 
 // Default single-workspace XP root. Local XP reads task_episodes.jsonl (written
-// by task-db at the resolved workspace root) and writes its projection beside
-// it, so the `--workspace` default must resolve the same shared root, otherwise
+// by task-db at the main checkout's workspace root) and writes its projection
+// beside it, so reads must resolve the same shared root, otherwise
 // `xp --local` from a subdir (e.g. backend/) read the wrong/empty episodes and
-// split the projection into a nested .atris. Explicit --workspace still wins;
-// the multi-root roster path (discoverCareerXpWorkspaces) is untouched. Falls
+// split the projection into a nested .atris. Explicit --workspace selects the
+// repository and nested workspace, then also resolves its shared ledger. Falls
 // back to raw cwd if the resolver can't load.
 function defaultXpWorkspace() {
   try {
-    return require('../lib/mission-root').resolveWorkspaceRoot(process.cwd());
+    return careerXpRoot(require('../lib/mission-root').resolveWorkspaceRoot(process.cwd()));
   } catch {
     return process.cwd();
   }
@@ -921,7 +924,7 @@ function receiptFromTaskEpisode(episode, treeHash) {
   );
   const proof = String(episode?.proof || '').trim();
   const reward = asNumber(episode?.career_xp?.reward ?? episode?.reward?.value, 0);
-  if (!episodeId || (!rejected && (!eligible || !proof || reward <= 0))) return null;
+  if (!episodeId || (!rejected && (!eligible || !proof || reward <= 0 || !hasIndependentXpReview(episode)))) return null;
 
   return {
     schema: 'atris.career_xp_receipt.v1',
@@ -1047,8 +1050,55 @@ function buildCareerXpProjection(receipts, workspace, integrity = {}) {
   };
 }
 
-function collectLocalXpProjectionState(args = [], { write = true } = {}) {
-  const workspace = path.resolve(readInlineFirstFlag(args, '--workspace', defaultXpWorkspace()));
+// The eligible flag records acceptance intent, not reviewer independence.
+// Apply the same actor evidence to new episodes and historical recovery.
+function hasIndependentXpReview(episode) {
+  const builder = taskBuilder(episode?.state);
+  if (!builder) return false;
+  const reviewer = normalizeActor(episode.action?.actor);
+  if (reviewer && reviewer !== builder) return true;
+  const metadata = episode.state.metadata || {};
+  const verifier = normalizeActor(metadata.certified_verified_by);
+  const reviewActors = Array.isArray(metadata.agent_review_actors) ? metadata.agent_review_actors.map(normalizeActor) : [];
+  return metadata.agent_certified === true && metadata.machine_verified === true
+    && Boolean(verifier) && verifier !== builder
+    && verifier === normalizeActor(metadata.independent_review_by)
+    && reviewActors.includes(verifier);
+}
+
+function readLinkedXpFile(filePath, options = {}) {
+  try {
+    return readJsonl(filePath, options);
+  } catch {
+    console.error(`warning: skipped unreadable linked xp file at ${filePath}`);
+    return [];
+  }
+}
+
+// Historical linked ledgers predate the shared writer. Require explicit
+// eligibility here; receipt conversion also enforces independent review.
+function recoverLinkedTaskEpisodes(workspace) {
+  return careerXpLinkedRoots(workspace).flatMap(root => readLinkedXpFile(path.join(root, TASK_EPISODES_FILE), { allowPartialTail: true }))
+    .filter(episode => episode?.state?.status === 'done' && episode?.career_xp?.eligible === true
+      && String(episode.proof || '').trim()
+      && asNumber(episode.career_xp.reward ?? episode.reward?.value) > 0
+      && hasIndependentXpReview(episode));
+}
+
+function recoverLinkedReceipts(workspace) {
+  return careerXpLinkedRoots(workspace).flatMap(root => {
+    const chain = normalizeReceiptChain(readLinkedXpFile(path.join(root, CAREER_XP_RECEIPTS_FILE)), { allowLegacyUpgrade: false });
+    return chain.integrity.status === 'verified' ? chain.receipts : [];
+  });
+}
+
+function collectLocalXpProjectionState(args = [], { write = true, resolveSharedRoot = true } = {}) {
+  const selected = path.resolve(readInlineFirstFlag(args, '--workspace', defaultXpWorkspace()));
+  const workspace = resolveSharedRoot ? careerXpRoot(selected) : selected;
+  return withCareerXpLock(workspace, () => collectLockedXpProjectionState(workspace, { write, resolveSharedRoot }));
+}
+
+function collectLockedXpProjectionState(workspace, { write, resolveSharedRoot }) {
   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);
@@ -1075,12 +1125,13 @@ function collectLocalXpProjectionState(args = [], { write = true } = {}) {
     && fileSize(episodePath) > 0
     && fileSize(receiptsPath) === 0;
   const tail = readTaskEpisodeTail(episodePath, cursorPath, { forceReset: replayFromStart });
-  const treeHash = write && tail.episodes.length ? treeHashFor(workspace) : null;
+  const recovered = resolveSharedRoot ? recoverLinkedTaskEpisodes(workspace) : [];
+  const episodes = [...tail.episodes, ...recovered];
+  const treeHash = write && episodes.length ? treeHashFor(workspace) : null;
   const seen = new Set(existingChain.receipts.map(receipt => receipt.receipt_id).filter(Boolean));
   let previousHash = existingChain.integrity.head_hash || null;
-  const newReceipts = tail.episodes
-    .map((episode) => receiptFromTaskEpisode(episode, treeHash))
-    .filter(Boolean)
+  const recoveredReceipts = resolveSharedRoot ? recoverLinkedReceipts(workspace) : [];
+  const newReceipts = [...recoveredReceipts, ...episodes.map(episode => receiptFromTaskEpisode(episode, treeHash)).filter(Boolean)]
     .filter((receipt) => {
       if (seen.has(receipt.receipt_id)) return false;
       seen.add(receipt.receipt_id);
@@ -1381,12 +1432,14 @@ function collectAllLocalXpProjection(args = []) {
   const searchRoots = defaultAllSearchRoots(args).filter(root => fs.existsSync(root));
   const explicitWorkspaces = readFlagValues(args, '--workspace');
   const discovered = searchRoots.flatMap(root => discoverCareerXpWorkspaces(root));
-  const workspaces = uniquePaths([...explicitWorkspaces, ...discovered]);
+  // Local recovery folds old checkout episodes into the durable main ledger.
+  // Canonicalize before aggregation so copies can never earn twice.
+  const workspaces = uniquePaths([...explicitWorkspaces, ...discovered].map(careerXpRoot));
   const projections = workspaces.map((workspace) => {
     try {
       return {
         workspace_root: workspace,
-        projection: collectLocalXpProjection(['--workspace', workspace]),
+        projection: collectLocalXpProjectionState(['--workspace', workspace]).projection,
       };
     } catch (error) {
       return {
@@ -1641,7 +1694,7 @@ LIMIT 25
 }
 
 function buildCareerXpSessionCapsule(args = []) {
-  const workspace = path.resolve(readInlineFirstFlag(args, '--workspace', defaultXpWorkspace()));
+  const workspace = careerXpRoot(path.resolve(readInlineFirstFlag(args, '--workspace', defaultXpWorkspace())));
   const sinceInput = readInlineFirstFlag(args, '--since', 'today');
   const untilInput = readInlineFirstFlag(args, '--until', null);
   const since = parseSessionBoundary(sinceInput, startOfToday());

package/commands/zen.js

@@ -57,9 +57,16 @@ function makeOut(calm) {
   return { dim, line, rake };
 }
 
-function teamLine(n) {
+// Name the three biggest places so a large count reads as "mostly agent
+// notes in atris/" rather than an unexplained total.
+function teamLine(n, places = []) {
   if (!n) return 'no unsaved team notes.';
-  return n === 1 ? '1 unsaved team note left in place.' : `${n} unsaved team notes left in place.`;
+  const head = n === 1 ? '1 unsaved team note left in place' : `${n} unsaved team notes left in place`;
+  if (!places.length) return `${head}.`;
+  const named = places.slice(0, 3).map((p) => `${p.place} ${p.count}`);
+  const rest = places.length - named.length;
+  if (rest) named.push(`and ${rest} more ${rest === 1 ? 'place' : 'places'}`);
+  return `${head}: ${named.join(', ')}.`;
 }
 
 function printYours(yours, line, dim) {
@@ -141,7 +148,7 @@ function printApply(result, out) {
     line('  almost zen. still out of place:');
     for (const text of result.remaining) line(dim(`  - ${text}`));
   }
-  line(dim(`  ${teamLine(result.team_files)}`));
+  line(dim(`  ${teamLine(result.team_files, result.team_places)}`));
   if (result.saved.length) {
     line(dim('  nothing was thrown away. see what zen saved:   git for-each-ref refs/archive refs/heads/zen-backup'));
   }

package/lib/campaign-keep.js

@@ -20,15 +20,30 @@ function shellQuote(text) {
   return `'${String(text).replace(/'/g, `'\\''`)}'`;
 }
 
+// The job a timer runs. Campaign wake is the default; `atris idea on` passes
+// its own (idea tick every ten minutes).
+const CAMPAIGN_WAKE_JOB = Object.freeze({
+  name: 'campaign-wake',
+  args: ['campaign', 'wake', '--json'],
+  every_seconds: 60,
+  marker: MARKER,
+});
+
+function cronSchedule(seconds) {
+  const minutes = Math.max(1, Math.round(Number(seconds || 60) / 60));
+  return minutes === 1 ? '* * * * *' : `*/${minutes} * * * *`;
+}
+
 // One timer per checkout: the label and marker carry a short hash of its root.
-function planKeep({ root, home, platform = process.platform, homeDir = os.homedir(), nodeBin = 'node', atrisBin, envPath = process.env.PATH || '' }) {
+function planKeep({ root, home, platform = process.platform, homeDir = os.homedir(), nodeBin = 'node', atrisBin, envPath = process.env.PATH || '', job = CAMPAIGN_WAKE_JOB }) {
   const slot = crypto.createHash('sha256').update(root).digest('hex').slice(0, 8);
+  const every = Number(job.every_seconds) || 60;
   // node by name on the saved PATH, so upgrading node does not break the timer.
-  const command = ['/usr/bin/env', nodeBin, atrisBin, 'campaign', 'wake', '--json'];
-  const logPath = path.join(home, 'campaign-wake.log');
-  const base = { root, slot, log_path: logPath, command: command.join(' '), every_seconds: 60 };
+  const command = ['/usr/bin/env', nodeBin, atrisBin, ...job.args];
+  const logPath = path.join(home, job.log || `${job.name}.log`);
+  const base = { root, slot, log_path: logPath, command: command.join(' '), every_seconds: every };
   if (platform === 'darwin') {
-    const label = `ai.atris.campaign-wake.${slot}`;
+    const label = `ai.atris.${job.name}.${slot}`;
     const file = path.join(homeDir, 'Library', 'LaunchAgents', `${label}.plist`);
     const contents = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -40,7 +55,7 @@ function planKeep({ root, home, platform = process.platform, homeDir = os.homedi
   <key>WorkingDirectory</key><string>${xml(root)}</string>
   <key>EnvironmentVariables</key>
   <dict><key>PATH</key><string>${xml(envPath)}</string><key>ATRIS_SKIP_UPDATE_CHECK</key><string>1</string></dict>
-  <key>StartInterval</key><integer>60</integer>
+  <key>StartInterval</key><integer>${every}</integer>
   <key>StandardOutPath</key><string>${xml(logPath)}</string>
   <key>StandardErrorPath</key><string>${xml(logPath)}</string>
 </dict>
@@ -48,8 +63,8 @@ function planKeep({ root, home, platform = process.platform, homeDir = os.homedi
 `;
     return { ...base, kind: 'launchd', label, file, contents };
   }
-  const marker = `${MARKER}_${slot}`;
-  const line = `* * * * * cd ${shellQuote(root)} && PATH=${shellQuote(envPath)} ATRIS_SKIP_UPDATE_CHECK=1 ${command.map(shellQuote).join(' ')} >> ${shellQuote(logPath)} 2>&1 # ${marker}`;
+  const marker = `${job.marker || MARKER}_${slot}`;
+  const line = `${cronSchedule(every)} cd ${shellQuote(root)} && PATH=${shellQuote(envPath)} ATRIS_SKIP_UPDATE_CHECK=1 ${command.map(shellQuote).join(' ')} >> ${shellQuote(logPath)} 2>&1 # ${marker}`;
   return { ...base, kind: 'cron', marker, crontab_line: line };
 }
 

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/career-xp-lock.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { sleepSync } = require('./sleep-sync');
+
+function alive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === 'EPERM';
+  }
+}
+
+// Callers resolve the shared root before entering. Do not acquire recursively.
+function withCareerXpLock(workspace, action, { timeoutMs = 10000 } = {}) {
+  const file = path.join(workspace, '.atris', 'state', 'career_xp.lock');
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const holder = JSON.stringify({ pid: process.pid, host: os.hostname() });
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    let fd;
+    try {
+      fd = fs.openSync(file, 'wx');
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+    }
+    if (fd !== undefined) {
+      try {
+        fs.writeFileSync(fd, holder);
+        return action();
+      } finally {
+        fs.closeSync(fd);
+        fs.unlinkSync(file);
+      }
+    }
+    try {
+      const before = fs.statSync(file);
+      let owner;
+      try { owner = JSON.parse(fs.readFileSync(file, 'utf8')); } catch {}
+      // A newly created file may still be receiving its owner record.
+      const stale = owner ? owner.host === os.hostname() && !alive(owner.pid)
+        : Date.now() - before.mtimeMs > 30000;
+      if (stale) {
+        const after = fs.statSync(file);
+        if (before.ino === after.ino && before.mtimeMs === after.mtimeMs) fs.unlinkSync(file);
+        continue;
+      }
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+      continue;
+    }
+    if (Date.now() >= deadline) throw new Error('xp ledger is busy; retry');
+    sleepSync(20);
+  }
+}
+
+module.exports = { withCareerXpLock };

package/lib/career-xp-root.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+// Jobs keep their own checkout for verification. Their durable XP belongs in
+// the main checkout, where removing a landed job's checkout cannot erase it.
+// Preserve a nested workspace's relative path so customer workspaces stay apart.
+function careerXpRoot(workspace) {
+  const root = path.resolve(workspace);
+  try {
+    const top = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+      cwd: root, encoding: 'utf8', timeout: 5000,
+    });
+    if (top.status !== 0 || !top.stdout.trim()) return root;
+    const listing = spawnSync('git', ['worktree', 'list', '--porcelain', '-z'], {
+      cwd: root, encoding: 'utf8', timeout: 5000,
+    });
+    const first = String(listing.stdout || '').split('\0')[0];
+    if (listing.status !== 0 || !first.startsWith('worktree ')) return root;
+    const main = first.slice('worktree '.length);
+    // Bare repositories and separate git storage may name the storage folder,
+    // not a checkout. Never create an XP ledger inside git's internal files.
+    if (!fs.existsSync(path.join(main, '.git'))) return root;
+    const relative = path.relative(top.stdout.trim(), root);
+    if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return root;
+    return path.resolve(main, relative);
+  } catch {
+    return root;
+  }
+}
+
+// Enumerate only checkouts registered to this repository, at the same nested
+// workspace offset. Never crawl unrelated repositories or customer workspaces.
+function careerXpLinkedRoots(workspace) {
+  const root = path.resolve(workspace);
+  try {
+    // A nested workspace may exist only in a linked checkout so far.
+    let existing = root;
+    while (!fs.existsSync(existing) && path.dirname(existing) !== existing) existing = path.dirname(existing);
+    const top = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+      cwd: existing, encoding: 'utf8', timeout: 5000,
+    });
+    if (top.status !== 0 || !top.stdout.trim()) return [];
+    const relative = path.relative(top.stdout.trim(), root);
+    if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return [];
+    const listing = spawnSync('git', ['worktree', 'list', '--porcelain', '-z'], {
+      cwd: existing, encoding: 'utf8', timeout: 5000,
+    });
+    if (listing.status !== 0) return [];
+    return String(listing.stdout || '').split('\0')
+      .filter(field => field.startsWith('worktree '))
+      .map(field => path.resolve(field.slice('worktree '.length), relative))
+      .filter(candidate => candidate !== root);
+  } catch {
+    return [];
+  }
+}
+
+module.exports = { careerXpRoot, careerXpLinkedRoots };

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+/, '');