atris 3.37.1 → 3.40.0

package/lib/ax-auto-lane.js

@@ -1,5 +1,9 @@
 'use strict';
 
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
 const SHORT_LOOKUP_MAX_CHARS = 140;
 const LONG_INPUT_MIN_CHARS = 1200;
 const TINY_MESSAGE_MAX_CHARS = 20;
@@ -9,14 +13,14 @@ const TRADEOFF_DEPTH_MIN_CHARS = 100;
 
 // Anchored to the start: a lookup word mid-sentence is usually a subordinate
 // clause (my fan spins when i run tests), not a lookup.
-const LOOKUP_START_RE = /^(?:(?:please|pls|hey|hi|yo)[,: ]+)?(?:whats|whos|wheres|what|who|when|where|list|show|define)\b/i;
+const LOOKUP_START_RE = /^(?:(?:please|pls|hey|hi|yo)[,: ]+)?(?:whats|whos|wheres|whens|what|who|when|where|list|show|define)\b/i;
 // Words that turn a lookup-shaped message into a judgment call: never fast.
-const JUDGMENT_WORD_RE = /\b(?:should|tradeoffs?|better|best|recommend|worth|good way)\b/i;
+const JUDGMENT_WORD_RE = /\b(?:should|tradeoffs?|better|best|recommend|worth|good way)\b|\b(?:legal|compliance|gdpr|lawsuit|liability|subpoena)\b/i;
 const HEAVY_REASONING_RE = /\b(?:design(?:s|ed|ing)?|architect(?:s|ed|ing)?|prov(?:e|es|ed|ing)|analy(?:ze|zes|zed|zing|se|ses|sed|sing)|compar(?:e|es|ed|ing)|plan(?:s|ned|ning)?|sketch(?:es|ed|ing)?)\b|\bwalk(?:s|ed|ing)? (?:me |us )?through\b/i;
 const DECISION_PHRASE_RE = /\b(?:should|whether|decide|deciding)\b/i;
-const ARGUE_BOTH_RE = /\bargue\b|\bboth sides\b|\bsteelman\b/i;
+const ARGUE_BOTH_RE = /\bargue\b|\bboth sides\b|\bsteelman\b|\bmath it out\b|\bdo the math\b|\bshow your math\b/i;
 const CODE_EDIT_RE = /\b(?:fix(?:es|ed|ing)?|refactor(?:s|ed|ing)?|renam(?:e|es|ed|ing)|debug(?:s|ged|ging)?)\b/i;
-const CODE_DIAGNOSIS_RE = /\bwhy\b|\bwrong\b|\bfail(?:s|ed|ing)?\b|\bresolv(?:e|es|ed|ing)?\b|\bbroken\b|\bnot work/i;
+const CODE_DIAGNOSIS_RE = /\bwhy\b|\bwrong\b|\bbug\b|\bfail(?:s|ed|ing)?\b|\bresolv(?:e|es|ed|ing)?\b|\bbroken\b|\bnot work/i;
 const CODE_CONTEXT_RE = /```|\bregexp?\b|(?:^|\n)\s*(?:traceback\b|(?:[a-z]+)?(?:error|exception):|at\s+\S+\s+\()/im;
 const ERROR_EXPLAIN_RE = /\bexplain (?:this|the) error\b|\bwhat does (?:this|the) error mean\b/i;
 // Yes/no capability checks are lookups even without a lookup keyword.
@@ -25,6 +29,12 @@ const YESNO_LOOKUP_RE = /^(?:does|is|are|can|do)\b/i;
 const HOWTO_LOOKUP_RE = /^how (?:do|does|did) (?:i|we|you)\b/i;
 const HOWTO_LOOKUP_MAX_CHARS = 40;
 const YESNO_LOOKUP_MAX_CHARS = 80;
+// Incidents and legal surfaces are stakes, not size: never route them cheap.
+const INCIDENT_RE = /\b(?:prod(?:uction)? is down|outage|everything (?:500|about:blank|fail)|users can'?t (?:login|log in)|data loss|site is down for everyone)\b/i;
+const LEGAL_DRAFT_RE = /\b(?:terms of service|privacy policy|\bdpa\b|contract)\b/i;
+const STAKES_WORD_RE = /\b(?:legal|compliance|gdpr|lawsuit|liability|subpoena)\b/i;
+// Abstract topics have no cheap correct answer even when the ask is short.
+const DEEP_TOPIC_RE = /\b(?:consciousness|free will|sentien\w*|computab\w*|meaning of life|the universe|morality|ethics of)\b/i;
 // Troubleshooting language means advice, not recall: keep it out of fast.
 const TROUBLE_RE = /\bfail(?:s|ed|ing)?\b|\bcrash(?:es|ed|ing)?\b|\bbroken\b|\bnot working\b/i;
 const WEIGHING_WORD_RE = /\b(?:consider|weigh|rank|estimate|think (?:about|through))\b/i;
@@ -42,6 +52,38 @@ function threshold(value, fallback) {
   return Number.isFinite(value) && value >= 0 ? value : fallback;
 }
 
+function words(text) {
+  return String(text || '').toLowerCase().match(/[a-z0-9]+/g) || [];
+}
+
+function overrideMatches(text, override) {
+  if (!override || typeof override !== 'object' || !override.id || !override.test
+    || !override.lane || !override.reason) return false;
+  const test = override.test;
+  const normalized = text.toLowerCase();
+  if (test.startsWith !== undefined
+    && !normalized.startsWith(String(test.startsWith).toLowerCase())) return false;
+  if (Array.isArray(test.includesAll)) {
+    const messageWords = new Set(words(text));
+    if (!test.includesAll.every((word) => messageWords.has(String(word).toLowerCase()))) return false;
+  }
+  if (Number.isFinite(test.maxChars) && text.length > test.maxChars) return false;
+  if (Number.isFinite(test.minChars) && text.length < test.minChars) return false;
+  return true;
+}
+
+function loadOverrides(filePath) {
+  const resolved = filePath
+    || process.env.ATRIS_ROUTER_OVERRIDES_PATH
+    || path.join(os.homedir(), '.atris', 'router-overrides.json');
+  try {
+    const parsed = JSON.parse(fs.readFileSync(resolved, 'utf8'));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch (_) {
+    return [];
+  }
+}
+
 function pickLane(message, opts = {}) {
   const text = String(message || '').trim();
   const shortLookupMaxChars = threshold(opts.shortLookupMaxChars, SHORT_LOOKUP_MAX_CHARS);
@@ -50,6 +92,17 @@ function pickLane(message, opts = {}) {
   const commaCount = (text.match(/,/g) || []).length;
   const hasCodeContext = CODE_CONTEXT_RE.test(text);
 
+  const overrides = Array.isArray(opts.overrides) ? opts.overrides : [];
+  for (const override of overrides) {
+    if (overrideMatches(text, override)) {
+      return {
+        lane: override.lane,
+        reason: override.reason,
+        override_id: override.id,
+      };
+    }
+  }
+
   if (text.length > longInputMinChars) {
     return { lane: 'max', reason: 'max fits this long input.' };
   }
@@ -64,6 +117,12 @@ function pickLane(message, opts = {}) {
     || (WEIGHING_WORD_RE.test(text) && commaCount >= WEIGHING_FACTOR_MIN_COMMAS)) {
     return { lane: 'max', reason: 'max fits a decision weighing several factors.' };
   }
+  if (INCIDENT_RE.test(text)) {
+    return { lane: 'max', reason: 'max fits a live incident, stakes beat size.' };
+  }
+  if (LEGAL_DRAFT_RE.test(text) && /\b(?:draft|write|cover|review)\b/i.test(text)) {
+    return { lane: 'max', reason: 'max fits drafting legal terms.' };
+  }
   if (HEAVY_REASONING_RE.test(text)) {
     return { lane: 'max', reason: 'max fits this reasoning-heavy request.' };
   }
@@ -99,13 +158,15 @@ function pickLane(message, opts = {}) {
   if (text.length <= YESNO_LOOKUP_MAX_CHARS
     && YESNO_LOOKUP_RE.test(text)
     && !JUDGMENT_WORD_RE.test(text)
-    && !TROUBLE_RE.test(text)) {
+    && !TROUBLE_RE.test(text)
+    && !DEEP_TOPIC_RE.test(text)) {
     return { lane: 'fast', reason: 'fast fits this yes or no lookup.' };
   }
   if (text.length <= shortLookupMaxChars
     && LOOKUP_START_RE.test(text)
     && !JUDGMENT_WORD_RE.test(text)
-    && !TROUBLE_RE.test(text)) {
+    && !TROUBLE_RE.test(text)
+    && !DEEP_TOPIC_RE.test(text)) {
     return { lane: 'fast', reason: 'fast fits this short factual lookup.' };
   }
   return { lane: 'pro', reason: 'pro fits this general request.' };
@@ -114,6 +175,6 @@ function pickLane(message, opts = {}) {
 module.exports = {
   LONG_INPUT_MIN_CHARS,
   SHORT_LOOKUP_MAX_CHARS,
-  TINY_MESSAGE_MAX_CHARS,
+  loadOverrides,
   pickLane,
 };

package/lib/bench/context.js

@@ -140,8 +140,6 @@ async function withBenchContext(options, fn) {
 }
 
 module.exports = {
-  PROFILE_ENV_KEYS,
   createBenchContext,
-  hermeticEnv,
   withBenchContext,
 };

package/lib/bench/report.js

@@ -134,7 +134,6 @@ function renderBenchReportText(report) {
 
 module.exports = {
   DEFAULT_PACK,
-  REPORT_SCHEMA,
   buildBenchReport,
   renderBenchReportText,
 };

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));
@@ -492,21 +508,12 @@ function packMetadata(options = {}) {
 module.exports = {
   BenchInfraError,
   DEFAULT_PACK,
-  appendResultRecord,
-  benchmarksRoot,
-  defaultTasksDir,
-  discoverPacks,
-  exitCodeForRecord,
   findPython,
-  isInfraFailure,
   loadTaskSpecs,
   packMetadata,
   readResultRecords,
+  readTaskPrompt,
   runBench,
-  runTaskSpec,
-  runTaskSpecs,
-  selectTaskSpecs,
   summarizeTasks,
   taskMetadata,
-  writeBaselineRecord,
 };

package/lib/brief-ledger.js

@@ -331,17 +331,11 @@ function renderBriefReview(review = {}, { lessons = false } = {}) {
 }
 
 module.exports = {
-  LEDGER_FILE,
-  OUTCOMES,
   appendBriefRecord,
-  authorFromWorktree,
-  briefSignals,
   buildBriefReview,
-  buildLessons,
   ledgerPath,
   latestBriefs,
   mirrorBriefRecord,
-  normalizeRecord,
   readBriefLedger,
   renderBriefReview,
   stampBriefOutcome,

package/lib/business-simulate.js

@@ -0,0 +1,382 @@
+'use strict';
+
+const os = require('node:os');
+const path = require('node:path');
+
+const SIMULATE_USAGE = 'Usage: atris business simulate "<idea>" [--roles a,b,c,d] [--name <business name>] [--dry-run]';
+const DEFAULT_ROLE_NAMES = Object.freeze(['maker', 'voice', 'builder', 'ops']);
+
+const NAME_STOP_WORDS = new Set([
+  'a', 'an', 'and', 'at', 'build', 'by', 'create', 'for', 'from', 'in',
+  'launch', 'make', 'my', 'of', 'on', 'our', 'sell', 'start', 'the', 'to',
+  'with',
+]);
+
+const ROLE_TEMPLATES = Object.freeze([
+  {
+    key: 'maker',
+    role: 'Product and design',
+    description: 'Owns product direction, design, and concrete product artifacts',
+    mission: (idea) => `Turn "${idea}" into a concrete product direction with usable design artifacts.`,
+    goals: (idea, roleNames) => [
+      `Define the smallest product version of "${idea}" that a customer could understand and use`,
+      'Create the core product or design artifacts needed by the rest of the team',
+      `Hand the ${roleNames[1]} and ${roleNames[2]} roles clear inputs, constraints, and final source files`,
+    ],
+    doneWhen: '`product/` holds a clear product brief, final source artifacts, and handoff notes the other roles can use.',
+    rules: [
+      'Make concrete artifacts, not moodboards or vague strategy.',
+      'Do not claim something is ready until the source files and proof are in the workspace.',
+    ],
+  },
+  {
+    key: 'voice',
+    role: 'Brand and copy',
+    description: 'Owns positioning, brand voice, product copy, and launch drafts',
+    mission: (idea) => `Make "${idea}" understandable in five seconds and memorable the next day.`,
+    goals: (_idea, roleNames) => [
+      'Write a one-page brand brief with audience, promise, voice, and a short story',
+      `Write the customer-facing product and surface copy the ${roleNames[2]} role needs`,
+      'Draft a small launch package without posting or contacting anyone',
+    ],
+    doneWhen: '`brand/` holds the brand brief, final product copy, and clearly marked launch drafts.',
+    rules: [
+      'Use plain, specific language and remove generic hype.',
+      'Draft only. Never publish, message customers, or make external claims without approval.',
+    ],
+  },
+  {
+    key: 'builder',
+    role: 'Surface and storefront',
+    description: 'Owns the customer-facing surface and the path through it',
+    mission: (idea) => `Build a working customer-facing surface for "${idea}" that makes the next action obvious.`,
+    goals: () => [
+      'Build the smallest complete surface that presents the real product and copy',
+      'Connect every primary action to a safe simulated or test-mode path',
+      'Verify the full path at phone and desktop sizes and record the proof',
+    ],
+    doneWhen: 'A customer can open the surface, understand the offer, and complete the simulated path without a broken step.',
+    rules: [
+      'Use only existing approved accounts and deployment rails.',
+      'Keep payments, publishing, and customer contact simulated until a human approves them.',
+    ],
+  },
+  {
+    key: 'ops',
+    role: 'Numbers and fulfillment',
+    description: 'Owns economics, operating choices, fulfillment, and the human handoff',
+    mission: (idea) => `Make the numbers and operating path for "${idea}" honest enough to act on tomorrow morning.`,
+    goals: () => [
+      'Build simple unit economics with sourced assumptions and the key margin or viability test',
+      'Compare practical fulfillment or delivery options and recommend one with reasons',
+      'Write the exact checklist of account, payment, legal, or external steps left for a human',
+    ],
+    doneWhen: '`ops/` holds the economics, the operating recommendation, and a human-steps checklist.',
+    rules: [
+      'Use sourced numbers and label every assumption.',
+      'Never create accounts, spend money, enter payment details, or hide a human-only step.',
+    ],
+  },
+]);
+
+function compactText(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
+function slugify(value) {
+  return compactText(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function titleCaseWord(word) {
+  return String(word || '')
+    .toLowerCase()
+    .split('-')
+    .map((part) => part ? part.charAt(0).toUpperCase() + part.slice(1) : '')
+    .join('-');
+}
+
+function titleCase(value) {
+  return compactText(value)
+    .split(/[\s_-]+/)
+    .filter(Boolean)
+    .map(titleCaseWord)
+    .join(' ');
+}
+
+function deriveBusinessName(idea, fallback = 'Business Simulation') {
+  const words = compactText(idea).match(/[A-Za-z0-9]+(?:['-][A-Za-z0-9]+)*/g) || [];
+  const meaningful = words.filter((word) => !NAME_STOP_WORDS.has(word.toLowerCase()));
+  if (meaningful.length === 0) return fallback;
+  return meaningful.slice(0, 3).map(titleCaseWord).join(' ');
+}
+
+function normalizeRoleNames(value) {
+  const rawNames = Array.isArray(value)
+    ? value
+    : String(value || '').split(',');
+  const names = rawNames.map((name) => slugify(name)).filter(Boolean);
+
+  if (names.length !== ROLE_TEMPLATES.length) {
+    throw new Error(`--roles requires exactly ${ROLE_TEMPLATES.length} comma-separated role names.`);
+  }
+  if (new Set(names).size !== names.length) {
+    throw new Error('--roles must contain four distinct role names.');
+  }
+  return names;
+}
+
+function parseRoleNames(value) {
+  if (value === undefined || value === null || compactText(value) === '') {
+    return [...DEFAULT_ROLE_NAMES];
+  }
+  return normalizeRoleNames(value);
+}
+
+function buildRoleSet(idea, roleNames = DEFAULT_ROLE_NAMES) {
+  const cleanIdea = compactText(idea);
+  const names = normalizeRoleNames(roleNames);
+
+  return ROLE_TEMPLATES.map((template, index) => ({
+    key: template.key,
+    name: names[index],
+    title: titleCase(names[index]),
+    role: template.role,
+    description: template.description,
+    mission: template.mission(cleanIdea),
+    goals: template.goals(cleanIdea, names),
+    doneWhen: template.doneWhen,
+    rules: [...template.rules],
+  }));
+}
+
+function renderMemberMarkdown(role) {
+  return [
+    '---',
+    `name: ${role.name}`,
+    `role: ${role.title}`,
+    `description: ${role.description}`,
+    'version: 1.0.0',
+    '',
+    'skills: []',
+    '',
+    'permissions:',
+    '  can-read: true',
+    '  can-execute: true',
+    '  can-approve: false',
+    '  can-accept-task: false',
+    '  approval-required: []',
+    '',
+    'tools: []',
+    '---',
+    '',
+    `# ${role.title}`,
+    '',
+    '## Mission',
+    role.mission,
+    '',
+    '## Goals',
+    ...role.goals.map((goal) => `- ${goal}`),
+    '',
+    '## Done when',
+    role.doneWhen,
+    '',
+    '## Rules',
+    ...role.rules.map((rule) => `- ${rule}`),
+    '',
+  ].join('\n');
+}
+
+function renderMissionMarkdown(role) {
+  return [
+    `# ${role.title} Mission`,
+    '',
+    '## North Star',
+    role.mission,
+    '',
+    '## Loop',
+    '',
+    '1. Read `atris/ENDGAME.md` and the latest tick log.',
+    '2. Take the smallest unfinished item owned by this role.',
+    '3. Write the artifact and proof into the workspace.',
+    '4. Append the result, blocker, and next handoff to the tick log.',
+    '',
+    '## Stop condition',
+    '',
+    `Stop when ${role.doneWhen.charAt(0).toLowerCase()}${role.doneWhen.slice(1)}`,
+    '',
+  ].join('\n');
+}
+
+function formatCreationTime(createdAt) {
+  const date = createdAt instanceof Date ? createdAt : new Date(createdAt);
+  if (Number.isNaN(date.getTime())) throw new Error(`Invalid simulation creation time: ${createdAt}`);
+  return date.toISOString().replace('T', ' ').slice(0, 16) + ' UTC';
+}
+
+function renderEndgame({ businessName, idea, roles, createdAt }) {
+  const definition = roles.map((role, index) =>
+    `${index + 1}. [ ] ${role.title} (${role.name}): ${role.doneWhen}`
+  );
+  definition.push(`${roles.length + 1}. [ ] Integration: all four role outputs work together as one coherent, verified customer path.`);
+
+  return [
+    `# ${businessName} - Endgame`,
+    '',
+    `One night, one goal: make "${compactText(idea)}" launch-ready as a coherent business simulation. Everything done except the steps only a human can do.`,
+    '',
+    '## Definition of done',
+    ...definition,
+    '',
+    '## Blocked on human (by design)',
+    'Real accounts, money, legal acceptance, publishing, customer contact, and irreversible external actions stay on the operator checklist.',
+    '',
+    '## Tick log',
+    `- ${formatCreationTime(createdAt)} - business created, team hired, missions written. Ready for the first loop.`,
+    '',
+  ].join('\n');
+}
+
+function parseSimulationArgs(args = []) {
+  const positional = [];
+  let explicitName = '';
+  let rolesValue;
+  let dryRun = false;
+
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    const next = args[index + 1];
+
+    if (arg === '--dry-run' || arg === '-n') {
+      dryRun = true;
+    } else if (arg === '--name') {
+      if (!next || next.startsWith('-')) throw new Error(`Missing value for --name.\n${SIMULATE_USAGE}`);
+      explicitName = next;
+      index++;
+    } else if (arg.startsWith('--name=')) {
+      explicitName = arg.slice('--name='.length);
+    } else if (arg === '--roles') {
+      if (!next || next.startsWith('-')) throw new Error(`Missing value for --roles.\n${SIMULATE_USAGE}`);
+      rolesValue = next;
+      index++;
+    } else if (arg.startsWith('--roles=')) {
+      rolesValue = arg.slice('--roles='.length);
+    } else if (arg.startsWith('-')) {
+      throw new Error(`Unknown option: ${arg}\n${SIMULATE_USAGE}`);
+    } else {
+      positional.push(arg);
+    }
+  }
+
+  const idea = compactText(positional.join(' '));
+  if (!idea) throw new Error(SIMULATE_USAGE);
+
+  const businessName = compactText(explicitName) || deriveBusinessName(idea);
+  const businessSlug = slugify(businessName);
+  if (!businessSlug) throw new Error(`Business name must contain a letter or number.\n${SIMULATE_USAGE}`);
+
+  return {
+    idea,
+    businessName,
+    businessSlug,
+    roleNames: parseRoleNames(rolesValue),
+    dryRun,
+  };
+}
+
+function shellQuote(value) {
+  return JSON.stringify(String(value));
+}
+
+function buildSimulationPlan({
+  idea,
+  businessName,
+  businessSlug,
+  roleNames = DEFAULT_ROLE_NAMES,
+  createdAt,
+  homeDir = os.homedir(),
+  workspacePath,
+}) {
+  const cleanIdea = compactText(idea);
+  const name = compactText(businessName) || deriveBusinessName(cleanIdea);
+  const slug = slugify(businessSlug || name) || 'business-simulation';
+  const roles = buildRoleSet(cleanIdea, roleNames);
+  const created = createdAt || new Date().toISOString();
+  const root = workspacePath || path.join(homeDir, 'arena', 'atris-business', slug);
+
+  const files = [];
+  for (const role of roles) {
+    files.push({
+      path: `atris/team/${role.name}/MEMBER.md`,
+      content: renderMemberMarkdown(role),
+      kind: 'member',
+      role,
+    });
+    files.push({
+      path: `atris/team/${role.name}/MISSION.md`,
+      content: renderMissionMarkdown(role),
+      kind: 'mission',
+      role,
+    });
+  }
+  files.push({
+    path: 'atris/ENDGAME.md',
+    content: renderEndgame({ businessName: name, idea: cleanIdea, roles, createdAt: created }),
+    kind: 'endgame',
+  });
+
+  return {
+    idea: cleanIdea,
+    businessName: name,
+    businessSlug: slug,
+    workspacePath: root,
+    createdAt: created,
+    roles,
+    files,
+    commands: [
+      `atris business init ${shellQuote(name)}`,
+      ...roles.flatMap((role) => [
+        `atris member create ${role.name} --role=${shellQuote(role.title)} --description=${shellQuote(role.description)}`,
+        `atris member push ${role.name}`,
+      ]),
+    ],
+  };
+}
+
+function renderDryRun(plan) {
+  const lines = [
+    'dry run: no cloud calls made and no files written.',
+    '',
+    `business:  ${plan.businessName} (${plan.businessSlug})`,
+    `idea:      ${plan.idea}`,
+    `workspace: ${plan.workspacePath}`,
+    '',
+    'would run:',
+    ...plan.commands.map((command) => `  ${command}`),
+    '',
+    `roster: ${plan.roles.map((role) => `${role.name} (${role.role})`).join(', ')}`,
+  ];
+
+  for (const file of plan.files) {
+    lines.push('', `--- ${file.path} ---`, file.content.trimEnd());
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
+module.exports = {
+  SIMULATE_USAGE,
+  buildRoleSet,
+  buildSimulationPlan,
+  deriveBusinessName,
+  parseRoleNames,
+  parseSimulationArgs,
+  renderDryRun,
+  renderEndgame,
+  renderMemberMarkdown,
+  slugify,
+};

package/lib/chat-log-scan.js

@@ -369,9 +369,4 @@ module.exports = {
   SCHEMA,
   scanChatLogs,
   writeLatestScan,
-  readLatestScan,
-  ensureChatScan,
-  topChatFindings,
-  cursorTranscriptRoots,
-  axLogDirs,
 };

package/lib/checkout-sync.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const { spawnSync } = require('node:child_process');
+
+function runGit(args, cwd = process.cwd()) {
+  return spawnSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    timeout: 30000,
+  });
+}
+
+function checkoutBehind(cwd = process.cwd()) {
+  const countResult = runGit(['rev-list', '--count', 'HEAD..@{upstream}'], cwd);
+  if (countResult.status !== 0) return null;
+
+  const count = Number.parseInt(countResult.stdout.trim(), 10);
+  if (!Number.isInteger(count) || count < 1) return null;
+
+  const upstreamResult = runGit(
+    ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'],
+    cwd
+  );
+  const upstream = upstreamResult.status === 0
+    ? upstreamResult.stdout.trim()
+    : 'origin';
+  const remote = upstream.includes('/') ? upstream.split('/')[0] : upstream;
+
+  return { count, upstream, remote };
+}
+
+function checkoutBehindMessage(cwd = process.cwd()) {
+  const behind = checkoutBehind(cwd);
+  if (!behind) return null;
+  const unit = behind.count === 1 ? 'commit' : 'commits';
+  return `this checkout is ${behind.count} ${unit} behind ${behind.remote}; run atris sync-checkout`;
+}
+
+function trackedTreeIsClean(cwd = process.cwd()) {
+  const unstaged = runGit(['diff', '--quiet', '--'], cwd);
+  if (unstaged.status !== 0) return false;
+
+  const staged = runGit(['diff', '--cached', '--quiet', '--'], cwd);
+  return staged.status === 0;
+}
+
+module.exports = {
+  checkoutBehind,
+  checkoutBehindMessage,
+  runGit,
+  trackedTreeIsClean,
+};