atris 3.74.4 → 3.74.6

package/commands/idea.js

@@ -0,0 +1,263 @@
+'use strict';
+
+// atris idea: feed ideas, Atris delegates.
+//   atris idea "<sentence>" [--repo <path>] [--verify "<cmd>"]   save one idea
+//   atris idea [--repo <path>] [--json]                          list ideas
+//   atris idea retry <n> [--repo <path>]                         put one back in line
+//   atris idea tick [--repo <path>] [--max-minutes <n>]          build the oldest waiting idea
+//   atris idea on|off [--repo <path>] [--dry-run]                 tick every 10 minutes, or stop
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { argsWantHelp } = require('../lib/noninteractive');
+const {
+  addIdea,
+  findIdea,
+  ideaRefusal,
+  oneLine,
+  readIdeas,
+  updateIdea,
+} = require('../lib/idea-inbox');
+const { ideaScore, readOutcomes, scoreLine } = require('../lib/idea-ledger');
+
+const VALUE_FLAGS = new Set(['--repo', '--verify', '--max-minutes']);
+
+function ideaUsage() {
+  return [
+    'Usage: atris idea "<sentence>" [--repo <path>] [--verify "<cmd>"]',
+    '       atris idea [--repo <path>] [--json]',
+    '       atris idea retry <n> [--repo <path>] [--verify "<cmd>"]',
+    '       atris idea tick [--repo <path>] [--max-minutes <n>]',
+    '       atris idea on|off [--repo <path>] [--dry-run]',
+  ].join('\n');
+}
+
+function parseArgs(args = []) {
+  const list = Array.isArray(args) ? args.map(String) : [];
+  const flags = {};
+  const words = [];
+  for (let i = 0; i < list.length; i += 1) {
+    const arg = list[i];
+    const eq = arg.match(/^(--[a-z-]+)=(.*)$/);
+    if (eq && VALUE_FLAGS.has(eq[1])) {
+      flags[eq[1].slice(2)] = eq[2];
+    } else if (VALUE_FLAGS.has(arg)) {
+      flags[arg.slice(2)] = list[i + 1] || '';
+      i += 1;
+    } else if (arg === '--json') {
+      flags.json = true;
+    } else if (arg === '--dry-run') {
+      flags.dryRun = true;
+    } else if (!arg.startsWith('--')) {
+      words.push(arg);
+    }
+  }
+  return { flags, words };
+}
+
+// The repo an idea belongs to: --repo when given, else the git top of the
+// current folder, else the folder itself.
+function resolveRepo(repo, cwd = process.cwd()) {
+  const start = path.resolve(cwd, repo || '.');
+  const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd: start, encoding: 'utf8' });
+  return top.status === 0 && String(top.stdout || '').trim() ? String(top.stdout).trim() : start;
+}
+
+const TICK_EVERY_SECONDS = 600;
+
+// The timer that runs `atris idea tick` for one repo: launchd on macOS, cron
+// elsewhere, through the same planner `atris campaign keep` uses.
+function ideaTimerPlan(repo, keepDeps = {}) {
+  const { planKeep } = require('../lib/campaign-keep');
+  return planKeep({
+    root: repo,
+    home: path.join(os.homedir(), '.atris', 'overnight'),
+    atrisBin: path.resolve(__dirname, '..', 'bin', 'atris.js'),
+    job: {
+      name: 'idea-tick',
+      args: ['idea', 'tick'],
+      every_seconds: TICK_EVERY_SECONDS,
+      marker: 'ATRIS_IDEA_TICK',
+      log: `idea-tick-${path.basename(repo)}.log`,
+    },
+    ...(keepDeps.plan || {}),
+  });
+}
+
+function ideaTimerOn(plan, keepDeps = {}) {
+  if (plan.kind === 'launchd') return fs.existsSync(plan.file);
+  const spawn = keepDeps.spawn || spawnSync;
+  const listed = spawn('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
+  return listed.status === 0 && String(listed.stdout || '').includes(plan.marker);
+}
+
+function switchTimer(turnOn, { repo, dryRun, json, log, keepDeps }) {
+  const { installKeep, removeKeep } = require('../lib/campaign-keep');
+  const plan = ideaTimerPlan(repo, keepDeps);
+  const where = plan.kind === 'launchd' ? plan.file : 'your crontab';
+  if (dryRun) {
+    if (json) log(JSON.stringify({ schema: 'atris.idea_timer.v1', ok: true, on: turnOn, dry_run: true, plan }, null, 2));
+    else log(`would ${turnOn ? 'start' : 'stop'} a ${plan.kind} timer in ${where}:\n  every ${plan.every_seconds / 60} minutes: ${plan.command}\n  in ${repo}\n  log ${plan.log_path}`);
+    return 0;
+  }
+  const result = (turnOn ? installKeep : removeKeep)(plan, keepDeps);
+  if (json) log(JSON.stringify({ schema: 'atris.idea_timer.v1', on: turnOn, ...result, plan }, null, 2));
+  if (!result.ok) {
+    if (!json) log(`could not ${turnOn ? 'start' : 'stop'} the timer: ${result.error}`);
+    return 1;
+  }
+  if (json) return 0;
+  if (turnOn) {
+    log(`on. every ${plan.every_seconds / 60} minutes the oldest idea in ${path.basename(repo)} gets built and checked.`);
+    log(`log: ${plan.log_path}`);
+    log('stop it: atris idea off');
+  } else {
+    log(result.removed === false ? 'the idea timer was not on here.' : 'off. ideas stay saved; nothing builds them until you turn it back on.');
+  }
+  return 0;
+}
+
+function ideaJson(idea) {
+  return {
+    n: idea.n,
+    id: idea.id,
+    text: idea.text,
+    status: idea.status,
+    reason: idea.reason || null,
+    task_id: idea.task_id || null,
+    link: idea.link || null,
+    at: idea.at,
+    tag: idea.tag || null,
+  };
+}
+
+// Ideas the loop files about itself land in the loop's own code, so they go
+// to this atris checkout when it is a git checkout, else to the same repo.
+function loopHome(repo) {
+  const home = path.resolve(__dirname, '..');
+  return fs.existsSync(path.join(home, '.git')) ? home : repo;
+}
+
+function renderIdeaList(ideas, { repo, timerOn = null, score = null } = {}) {
+  const lines = [];
+  if (score && score.builds) {
+    lines.push(scoreLine(score));
+    lines.push('');
+  }
+  if (!ideas.length) {
+    lines.push('no ideas here yet.');
+    lines.push('');
+    lines.push('drop one: atris idea "make the inbox search faster"');
+    return lines.join('\n');
+  }
+  lines.push(`ideas in ${path.basename(repo || '.')}: ${ideas.length}`);
+  lines.push('');
+  const width = String(ideas.length).length;
+  const pad = ' '.repeat(width + 4 + 10);
+  for (const idea of ideas) {
+    const tag = idea.tag === 'loop' ? '[loop] ' : '';
+    lines.push(`  ${String(idea.n).padStart(width)}. ${idea.status.padEnd(9)} ${tag}${oneLine(idea.text, 80)}`);
+    if (idea.status === 'landed' && idea.link) lines.push(`${pad}${idea.link}`);
+    if (idea.status === 'refused' && idea.reason) lines.push(`${pad}${oneLine(idea.reason, 100)}`);
+    if (idea.status === 'building' && idea.task_id) lines.push(`${pad}task ${idea.task_id}`);
+  }
+  const waiting = ideas.filter((idea) => idea.status === 'waiting').length;
+  if (waiting) {
+    lines.push('');
+    lines.push(`${waiting} waiting. they build one at a time, oldest first.`);
+    if (timerOn === true) lines.push('the next one starts within 10 minutes.');
+    if (timerOn === false) lines.push('nothing builds them yet. start it: atris idea on');
+  }
+  return lines.join('\n');
+}
+
+function saveIdea(sentence, { repo, verify, json, log }) {
+  const idea = addIdea(repo, sentence, { verify });
+  if (json) {
+    log(JSON.stringify({ schema: 'atris.idea.v1', ok: true, repo, idea: ideaJson(idea) }, null, 2));
+    return 0;
+  }
+  if (idea.status === 'refused') {
+    log(`saved idea ${idea.n}, but I will not build it alone: ${idea.reason}.`);
+    log('');
+    log('it stays on the list so you can pick it up yourself.');
+    return 0;
+  }
+  log(`saved idea ${idea.n}: ${oneLine(idea.text, 80)}`);
+  log('');
+  log('it gets built and checked when the idea tick runs, one idea at a time.');
+  log('see where it is: atris idea');
+  return 0;
+}
+
+function retryIdea(ref, { repo, verify = '', json, log }) {
+  const idea = findIdea(readIdeas(repo), ref);
+  if (!idea) {
+    log(`no idea ${ref || '(missing number)'} here. see the list: atris idea`);
+    return 2;
+  }
+  if (idea.status === 'building' || idea.status === 'landed') {
+    log(`idea ${idea.n} is ${idea.status}; nothing to retry.`);
+    return 2;
+  }
+  const refusal = ideaRefusal(idea.text);
+  if (refusal) {
+    log(`idea ${idea.n} still ${refusal.replace(/, needs owner$/, '')}. it needs you, not a retry.`);
+    return 2;
+  }
+  const next = updateIdea(repo, idea.id, { status: 'waiting', reason: '', attempts: 0, ...(verify ? { verify } : {}) });
+  if (json) log(JSON.stringify({ schema: 'atris.idea.v1', ok: true, repo, idea: ideaJson(next) }, null, 2));
+  else log(`idea ${next.n} is back in line.`);
+  return 0;
+}
+
+function ideaAtris(args = process.argv.slice(3), { cwd = process.cwd(), log = console.log, keepDeps = {} } = {}) {
+  const list = Array.isArray(args) ? args : [];
+  if (argsWantHelp(list)) {
+    log(ideaUsage());
+    return 0;
+  }
+  const { flags, words } = parseArgs(list);
+  const repo = resolveRepo(flags.repo, cwd);
+  const json = flags.json === true;
+  const verb = words[0];
+
+  if (verb === 'retry' && words.length <= 2) return retryIdea(words[1], { repo, verify: flags.verify || '', json, log });
+  if ((verb === 'on' || verb === 'off') && words.length === 1) {
+    return switchTimer(verb === 'on', { repo, dryRun: flags.dryRun === true, json, log, keepDeps });
+  }
+  if (verb === 'tick' && words.length === 1) {
+    const minutes = Number(flags['max-minutes']);
+    const { runIdeaTick, DEFAULT_BUILD_SECONDS } = require('../lib/idea-tick');
+    return runIdeaTick({
+      root: repo,
+      log: json ? () => {} : log,
+      loopRepo: loopHome(repo),
+      maxSeconds: Number.isFinite(minutes) && minutes > 0 ? Math.floor(minutes * 60) : DEFAULT_BUILD_SECONDS,
+    }).then((outcome) => {
+      if (json) log(JSON.stringify({ schema: 'atris.idea_tick.v1', repo, ...outcome }, null, 2));
+      return 0;
+    });
+  }
+  if (verb === 'list' && words.length === 1) words.length = 0;
+
+  const sentence = words.join(' ').trim();
+  if (sentence) return saveIdea(sentence, { repo, verify: flags.verify || '', json, log });
+
+  const ideas = readIdeas(repo);
+  const score = ideaScore(readOutcomes(repo));
+  if (json) {
+    log(JSON.stringify({ schema: 'atris.idea_list.v1', repo, score: { ...score, line: scoreLine(score) }, ideas: ideas.map(ideaJson) }, null, 2));
+    return 0;
+  }
+  let timerOn = null;
+  try { timerOn = ideaTimerOn(ideaTimerPlan(repo, keepDeps), keepDeps); } catch {}
+  log(renderIdeaList(ideas, { repo, timerOn, score }));
+  return 0;
+}
+
+module.exports = {
+  ideaAtris,
+};

package/commands/init.js

@@ -4,6 +4,7 @@ const { ensureMemberBundle } = require('../lib/member-scaffold');
 const { ensureExperimentsFramework } = require('./experiments');
 const { ensureWorkspaceBrain } = require('../lib/workspace-scaffold');
 const { upsertAtrisClaudeBootBlock } = require('../lib/claude-boot-block');
+const { openingLinesForRoot, renderAgentsOpeningBlock, upsertAgentsOpeningLines } = require('../lib/opening-lines');
 const { ensureRunIgnore } = require('../lib/gitignore');
 const { snapshotBeforeInit, commitInitFiles } = require('../lib/init-commit');
 const { INTENTS } = require('../lib/intents');
@@ -648,6 +649,8 @@ tools: []
   // Create agent instruction files for different tools
   if (withAdapters) {
   const intentTable = renderIntentTable();
+  const openingLines = openingLinesForRoot(process.cwd());
+  const agentsOpeningBlock = renderAgentsOpeningBlock(openingLines);
   const agentInstructions = `# AGENTS.md: Universal Agent Instructions
 
 > Works with: Claude Code, Cursor, Codex, OpenClaw, Windsurf, and any AI coding agent.
@@ -666,6 +669,8 @@ atris atris.md
 
 This is the Atris boot sequence. Show the output to the user, then respond naturally.
 
+${agentsOpeningBlock}
+
 ## You translate
 
 The person you work for does not know atris words and never has to learn them. Never tell them to run an atris command or learn a term.
@@ -870,6 +875,10 @@ member -> mission start --verify -> status --status active -> one bounded step -
   if (agentsVoiceResult.action !== 'unchanged') {
     markReady('adapters', 'AGENTS.md voice card', '✓ Pinned the Atris voice card in AGENTS.md');
   }
+  const agentsOpeningResult = upsertAgentsOpeningLines(agentsMdFile, openingLines);
+  if (agentsOpeningResult.action !== 'unchanged') {
+    markReady('adapters', 'AGENTS.md operating rules', '✓ Added the atris.md operating rules to AGENTS.md');
+  }
 
   // .devin/config.local.json for Devin for Terminal
   const devinConfigDir = path.join(process.cwd(), '.devin');
@@ -1100,7 +1109,7 @@ Read atris/MAP.md. Begin iteration 1.`;
   const rootClaudeMd = path.join(process.cwd(), 'CLAUDE.md');
   if (fs.existsSync(rootClaudeMd)) {
     const source = fs.readFileSync(rootClaudeMd, 'utf8');
-    const result = upsertAtrisClaudeBootBlock(source);
+    const result = upsertAtrisClaudeBootBlock(source, { openingLines: openingLinesForRoot(process.cwd()) });
     fs.writeFileSync(rootClaudeMd, result.content);
     if (result.action === 'repaired') {
       markReady('adapters', 'CLAUDE.md', '✓ repaired atris block in CLAUDE.md (missing end marker)');
@@ -1111,7 +1120,7 @@ Read atris/MAP.md. Begin iteration 1.`;
     }
   } else {
     // Create new CLAUDE.md with just Atris block
-    fs.writeFileSync(rootClaudeMd, upsertAtrisClaudeBootBlock().content);
+    fs.writeFileSync(rootClaudeMd, upsertAtrisClaudeBootBlock('', { openingLines: openingLinesForRoot(process.cwd()) }).content);
     markReady('adapters', 'CLAUDE.md', '✓ created CLAUDE.md with atris block');
   }
   }

package/commands/land.js

@@ -14,7 +14,8 @@ function runGit(args, opts) {
   return gitSpawn.runGit(args, opts);
 }
 
-const CHERRY_CACHE_FILE = path.join('.atris', 'state', 'cherry-cache.json');
+const CHERRY_CACHE_FILE = path.join('atris', 'cherry-cache.json');
+const LEGACY_CHERRY_CACHE_FILE = path.join('.atris', 'state', 'cherry-cache.json');
 const CHERRY_CACHE_MAX = 2000;
 
 // Pluralize a count + noun ("1 change", "2 changes").
@@ -218,29 +219,49 @@ function cherryStats(root, base, ref) {
 }
 
 // `git cherry <base> <ref>` depends only on the two commit shas, so its
-// counts are cached per (base sha, ref sha) under .atris/state. The cache is
-// only written where .atris already exists; a missing or corrupt file means
-// recompute. Entries for refs not seen this run are dropped on save.
+// counts are cached per (base sha, ref sha). The file lives in the shared git
+// dir, so a fresh worktree (which has no .atris yet) reuses what any other
+// worktree of the repo already computed. Only repos that use atris (.atris or
+// atris/ at the root) get a cache; a missing or corrupt file means recompute.
+// Entries for refs not seen this run are dropped on save.
 function cherryCachePath(root) {
-  return path.join(root, CHERRY_CACHE_FILE);
+  const result = runGit(['rev-parse', '--git-common-dir'], { cwd: root, check: false });
+  if (result.status !== 0 || !result.stdout.trim()) return '';
+  return path.join(path.resolve(root, result.stdout.trim()), CHERRY_CACHE_FILE);
 }
 
-function loadCherryCache(root) {
-  const cache = { file: cherryCachePath(root), entries: {}, used: {}, dirty: false, writable: false };
-  try {
-    cache.writable = fs.statSync(path.join(root, '.atris')).isDirectory();
-  } catch {
-    cache.writable = false;
-  }
-  if (!cache.writable) return cache;
-  try {
-    const parsed = JSON.parse(fs.readFileSync(cache.file, 'utf8'));
-    if (parsed && parsed.version === 1 && parsed.entries && typeof parsed.entries === 'object') {
-      cache.entries = parsed.entries;
+function usesAtris(root) {
+  return ['.atris', 'atris'].some((name) => {
+    try {
+      return fs.statSync(path.join(root, name)).isDirectory();
+    } catch {
+      return false;
     }
+  });
+}
+
+function readCherryEntries(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (parsed && parsed.version === 1 && parsed.entries && typeof parsed.entries === 'object') return parsed.entries;
   } catch {
-    cache.entries = {};
+    // missing or corrupt: recompute
   }
+  return null;
+}
+
+function loadCherryCache(root) {
+  const cache = { file: '', entries: {}, used: {}, dirty: false, writable: false };
+  if (!usesAtris(root)) return cache;
+  cache.file = cherryCachePath(root);
+  if (!cache.file) return cache;
+  cache.writable = true;
+  // Older versions kept the cache under .atris/state; read it once so an
+  // upgrade does not pay for a cold board.
+  const current = readCherryEntries(cache.file);
+  const legacy = current ? null : readCherryEntries(path.join(root, LEGACY_CHERRY_CACHE_FILE));
+  cache.entries = current || legacy || {};
+  cache.dirty = Boolean(legacy);
   return cache;
 }
 

package/commands/mission.js

@@ -4814,11 +4814,12 @@ function startMission(args, options = {}) {
     lane: saved.lane,
     verifier: saved.verifier,
   });
-  if (saved.yes_lock_parent && saved.yes_locks && saved.yes_locks.steps) {
-    // the lock record names the job it came from, before any command is held
+  if ((saved.yes_lock_parent || process.env.ATRIS_HANDOFF_YES_LOCK) && saved.yes_locks && saved.yes_locks.steps) {
+    // the lock record names the member and the job it came from, before any
+    // command is held, so a yes card can say who is asking
     try {
       require('../lib/yes-lock').writeYesLocks(path.join(require('../lib/state-home').atrisHome(), 'state'), saved.id,
-        { seal: saved.yes_locks.steps, parentMissionId: saved.yes_lock_parent });
+        { seal: saved.yes_locks.steps, parentMissionId: saved.yes_lock_parent || null, owner: saved.owner || null });
     } catch {}
   }
   const worktreeBaseline = captureMissionWorktreeBaseline(saved, process.cwd(), codeBaseline);