atris 3.70.0 → 3.71.0

package/lib/task-receipt.js

@@ -51,7 +51,12 @@ function writeTaskReceipt({ taskId, command, root = process.cwd(), runner } = {}
   if (!taskId) return { ok: false, passed: false, reason: 'task_id_required' };
   if (!cmd) return { ok: false, passed: false, reason: 'verify_command_required' };
   const run = runner || spawnSync;
-  const result = run('bash', ['-lc', cmd], {
+  // A login shell can put an older node first on PATH (macOS path_helper puts
+  // /usr/local/bin ahead), so the check would run on a node atris does not
+  // support. Put the node running atris first, after the profile has loaded.
+  const nodeDir = path.dirname(process.execPath).replace(/'/g, `'\\''`);
+  const script = `export PATH='${nodeDir}':"$PATH"\n${cmd}`;
+  const result = run('bash', ['-lc', script], {
     cwd: root,
     encoding: 'utf8',
     timeout: 120000,

package/mcp/atris-mcp/index.mjs

@@ -1,9 +1,13 @@
 #!/usr/bin/env node
-// atris mcp, a stdio Model Context Protocol server exposing the design API.
-// Tools: design_extract, design_check, design_search.
-// Auth resolves the same way as the CLI: ATRIS_API_KEY, then
-// the logged-in atris token, then ~/.atris/design-api-key.
+// atris mcp, a stdio Model Context Protocol server.
+// Design tools (design_extract, design_check, design_search) call the design
+// API. Auth resolves the same way as the CLI: ATRIS_API_KEY, then the
+// logged-in atris token, then ~/.atris/design-api-key.
+// Campaign tools (campaign_list, campaign_show, campaign_new, campaign_start,
+// campaign_run, campaign_ask, campaign_answer) run `atris campaign ... --json`
+// in the workspace and need no key.
 
+import { spawn } from 'node:child_process';
 import { readFileSync, realpathSync } from 'node:fs';
 import { createInterface } from 'node:readline';
 import { fileURLToPath } from 'node:url';
@@ -11,7 +15,7 @@ import designApi from '../../lib/design-api.js';
 
 const { resolveDesignKey, designRequest, pollDesignJob, billingOf } = designApi;
 
-export const TOOLS = [
+const DESIGN_TOOLS = [
   {
     name: 'design_extract',
     description: 'extract a site\'s design system (colors, typography, layout, voice) as json. costs 10 credits, 2 on a cache hit.',
@@ -49,6 +53,104 @@ export const TOOLS = [
   },
 ];
 
+const CWD = { type: 'string', description: 'workspace folder to run in; defaults to the folder this server started in' };
+const ID = { type: 'string', description: 'campaign id, e.g. cmp-ship-billing-1a2b' };
+const AS = { type: 'string', description: 'the member you are working as, e.g. builder; writes are never recorded as a person' };
+
+export const CAMPAIGN_TOOLS = [
+  {
+    name: 'campaign_list',
+    description: 'list every atris campaign with its state, money spent, and the next move. a campaign is a long goal with a judge (a command that exits 0 when the goal is met), a budget, and members.',
+    inputSchema: { type: 'object', properties: { cwd: CWD } },
+  },
+  {
+    name: 'campaign_show',
+    description: 'show one campaign: judge and its last reading, budget, seats, missions, open asks, and the next move.',
+    inputSchema: { type: 'object', properties: { id: ID, cwd: CWD }, required: ['id'] },
+  },
+  {
+    name: 'campaign_new',
+    description: 'the easiest start: give a goal in plain words. the owner\'s engine drafts a judge script, atris runs it to prove it fails today, and returns the draft. start: true also starts the campaign. budget defaults to $20.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        goal: { type: 'string', description: 'the goal in plain words' },
+        budget: { type: 'number', description: 'dollars the campaign may spend (default 20)' },
+        owner: { type: 'string', description: 'member who owns it (default mission-lead)' },
+        start: { type: 'boolean', description: 'start the campaign once the drafted judge fails today' },
+        cwd: CWD,
+      },
+      required: ['goal'],
+    },
+  },
+  {
+    name: 'campaign_start',
+    description: 'start a campaign with a judge you wrote. the judge runs first and a judge that already passes is refused: it must fail today. print graded output like "ℹ pass 3" and "ℹ fail 2" so progress shows.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'short name for the goal' },
+        judge: { type: 'string', description: 'shell command that exits 0 only when the goal is met' },
+        budget: { type: 'number', description: 'dollars the campaign may spend' },
+        owner: { type: 'string', description: 'member who owns it (default mission-lead)' },
+        seats: { type: 'array', items: { type: 'string' }, description: 'members who work on it, as member or member:role' },
+        bet: { type: 'string', description: 'what you think will work' },
+        id: { type: 'string', description: 'optional id, cmp-<lowercase-words>' },
+        as: AS,
+        cwd: CWD,
+      },
+      required: ['title', 'judge', 'budget'],
+    },
+  },
+  {
+    name: 'campaign_run',
+    description: 'let the campaign run itself for at most max_steps steps: it judges, proposes missions, and runs them. it stops early when the judge passes, the money runs out, or a person must answer an ask. returns the stop reason.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: ID,
+        max_steps: { type: 'number', description: 'steps before it stops, 1 to 20 (default 3)' },
+        parallel: { type: 'number', description: 'missions at once, 1 to 5 (default 3)' },
+        as: AS,
+        cwd: CWD,
+      },
+      required: ['id'],
+    },
+  },
+  {
+    name: 'campaign_ask',
+    description: 'stop for a person before anything that cannot be undone: sending, paying, deleting, deploying, publishing. the campaign waits until a person answers.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: ID,
+        question: { type: 'string', description: 'the question, with what happens on yes' },
+        mission: { type: 'string', description: 'mission id the ask belongs to' },
+        as: AS,
+        cwd: CWD,
+      },
+      required: ['id', 'question'],
+    },
+  },
+  {
+    name: 'campaign_answer',
+    description: 'pass along a person\'s answer to an open ask. an agent cannot close an ask: the answer is recorded and the ask stays open until the person runs the returned person_command in their own terminal.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: ID,
+        ask_id: { type: 'string', description: 'ask id from campaign_show, e.g. a-1b2c3d' },
+        answer: { type: 'string', description: 'the person\'s answer in their words' },
+        as: AS,
+        cwd: CWD,
+      },
+      required: ['id', 'ask_id', 'answer'],
+    },
+  },
+];
+
+export const TOOLS = [...DESIGN_TOOLS, ...CAMPAIGN_TOOLS];
+
 function terminal(job) {
   const s = String((job && job.status) || '').toLowerCase();
   return s === 'completed' || s === 'failed' || s === 'error' || s === 'succeeded';
@@ -112,6 +214,100 @@ async function runJob(first, pollPath, key) {
   return job;
 }
 
+const CLI = fileURLToPath(new URL('../../bin/atris.js', import.meta.url));
+
+function text(value) {
+  return String(value ?? '').trim();
+}
+
+function bounded(value, min, max, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) ? Math.min(max, Math.max(min, Math.round(n))) : fallback;
+}
+
+// The argv for `atris campaign` for one tool call, or { error }.
+export function campaignArgs(name, args = {}) {
+  const as = text(args.as) ? ['--as', text(args.as)] : [];
+  const need = (...keys) => keys.filter((key) => !text(args[key]));
+  if (name === 'campaign_list') return ['campaign', 'list', '--json'];
+  if (name === 'campaign_show') {
+    if (need('id').length) return { error: 'campaign_show needs an id' };
+    return ['campaign', 'show', text(args.id), '--json'];
+  }
+  if (name === 'campaign_new') {
+    if (need('goal').length) return { error: 'campaign_new needs a goal' };
+    const out = ['campaign', 'new', text(args.goal)];
+    if (args.budget !== undefined) out.push('--budget', String(args.budget));
+    if (text(args.owner)) out.push('--owner', text(args.owner));
+    if (args.start === true) out.push('--yes');
+    return [...out, '--json'];
+  }
+  if (name === 'campaign_start') {
+    const missing = need('title', 'judge');
+    if (missing.length || args.budget === undefined) return { error: 'campaign_start needs a title, a judge, and a budget' };
+    const out = ['campaign', 'start', text(args.title), '--judge', text(args.judge), '--budget', String(args.budget)];
+    if (text(args.owner)) out.push('--owner', text(args.owner));
+    for (const seat of Array.isArray(args.seats) ? args.seats : []) if (text(seat)) out.push('--seat', text(seat));
+    if (text(args.bet)) out.push('--bet', text(args.bet));
+    if (text(args.id)) out.push('--id', text(args.id));
+    return [...out, ...as, '--json'];
+  }
+  if (name === 'campaign_run') {
+    if (need('id').length) return { error: 'campaign_run needs an id' };
+    return ['campaign', 'run', text(args.id), '--max-steps', String(bounded(args.max_steps, 1, 20, 3)),
+      '--parallel', String(bounded(args.parallel, 1, 5, 3)), ...as, '--json'];
+  }
+  if (name === 'campaign_ask') {
+    if (need('id', 'question').length) return { error: 'campaign_ask needs an id and a question' };
+    const out = ['campaign', 'ask', text(args.id), text(args.question)];
+    if (text(args.mission)) out.push('--mission', text(args.mission));
+    return [...out, ...as, '--json'];
+  }
+  if (name === 'campaign_answer') {
+    if (need('id', 'ask_id', 'answer').length) return { error: 'campaign_answer needs an id, an ask_id, and an answer' };
+    return ['campaign', 'answer', text(args.id), text(args.ask_id), text(args.answer), ...as, '--json'];
+  }
+  return { error: `unknown tool: ${name}` };
+}
+
+// Every write from here is an agent's: the CLI never records it as a person.
+function runCli(argv, cwd) {
+  const env = { ...process.env, ATRIS_SKIP_UPDATE_CHECK: '1', ATRIS_NONINTERACTIVE: '1', ATRIS_AGENT_ID: process.env.ATRIS_AGENT_ID || 'mcp-agent' };
+  delete env.ATRIS_HUMAN;
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [CLI, ...argv], { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.on('error', (error) => resolve({ code: null, stdout, stderr: error.message }));
+    child.on('close', (code) => resolve({ code, stdout, stderr }));
+  });
+}
+
+function lastJson(stdout) {
+  const lines = String(stdout).split('\n').map((line) => line.trim()).filter(Boolean).reverse();
+  for (const line of lines) {
+    try { return JSON.parse(line); } catch {}
+  }
+  return null;
+}
+
+export async function handleCampaignTool(name, args = {}) {
+  const argv = campaignArgs(name, args);
+  if (!Array.isArray(argv)) return fail(argv.error);
+  const ran = await runCli(argv, text(args.cwd) || process.cwd());
+  const data = lastJson(ran.stdout);
+  if (!data) return fail(`atris campaign gave no json (exit ${ran.code}): ${text(ran.stderr || ran.stdout).slice(-400)}`);
+  if (name === 'campaign_answer' && data.campaign && data.campaign.asks.some((ask) => ask.id === text(args.ask_id))) {
+    data.still_open = true;
+    data.person_command = `atris campaign answer ${text(args.id)} ${text(args.ask_id)} ${JSON.stringify(text(args.answer))}`;
+  }
+  const result = { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+  if (data.ok === false) result.isError = true;
+  return result;
+}
+
 export async function handleTool(name, args = {}, key) {
   if (name === 'design_extract') {
     const url = String(args.url || '').trim();
@@ -184,13 +380,19 @@ async function serveStdio() {
     } else if (request.method === 'tools/call') {
       const pending = { cancelled: false };
       const work = (async () => {
+        const toolName = String(request.params?.name || '');
+        const isCampaign = toolName.startsWith('campaign_');
         try {
-          const key = resolveDesignKey();
-          result = key
-            ? await handleTool(request.params?.name, request.params?.arguments || {}, key)
-            : fail('no api key found. set ATRIS_API_KEY or run: atris login (or save a key in ~/.atris/design-api-key)');
+          if (isCampaign) {
+            result = await handleCampaignTool(toolName, request.params?.arguments || {});
+          } else {
+            const key = resolveDesignKey();
+            result = key
+              ? await handleTool(request.params?.name, request.params?.arguments || {}, key)
+              : fail('no api key found. set ATRIS_API_KEY or run: atris login (or save a key in ~/.atris/design-api-key)');
+          }
         } catch (error) {
-          result = fail(`design call failed: ${(error && error.message) || error}`);
+          result = fail(`${isCampaign ? 'campaign' : 'design'} call failed: ${(error && error.message) || error}`);
         }
         if (!pending.cancelled) {
           await new Promise((resolve, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.70.0",
+  "version": "3.71.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {
@@ -73,6 +73,7 @@
     "test:fast": "xargs node --test < test/fast-tests.txt",
     "lint:decks": "node scripts/lint-all-decks.js",
     "audit:markdown-whitespace": "node scripts/audit-markdown-whitespace.js",
+    "validate:campaign": "node scripts/campaign-conformance.js --merged",
     "publish:release": "node scripts/publish-atris-release.js",
     "prepare": "cp scripts/pre-commit .git/hooks/pre-commit 2>/dev/null && cp scripts/commit-msg .git/hooks/commit-msg 2>/dev/null && cp scripts/prepare-commit-msg .git/hooks/prepare-commit-msg 2>/dev/null && chmod +x .git/hooks/pre-commit .git/hooks/commit-msg .git/hooks/prepare-commit-msg || true"
   },

package/scripts/det/engine-reading.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+'use strict';
+
+// Machine readings for an engine a shell script launches, written to the
+// caller's Atris workspace like every other engine run.
+//   engine-reading.js start <engine> <task> <pid>        prints a token
+//   engine-reading.js end <engine> <task> <token> <status>  prints the kill cause, if any
+// The token is the run id and the start time, so the end can say how long it ran.
+// The pid is the calling script's, which outlives this helper, so a sweep
+// closes the run only once the script itself is gone.
+// A shell sees a SIGKILL as exit 137 and an alarm as 142. Outside an Atris
+// workspace (no atris/ folder) it writes nothing and prints nothing.
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { recordEngineResource } = require('../../lib/engine-resource');
+
+const [phase, engine, task, tokenOrPid, status] = process.argv.slice(2);
+const root = process.cwd();
+
+if (fs.existsSync(path.join(root, 'atris'))) {
+  if (phase === 'start') {
+    const id = crypto.randomUUID();
+    recordEngineResource(root, { phase: 'start', engine, task, run_id: id }, { pid: Number(tokenOrPid) });
+    process.stdout.write(`${id}@${Date.now()}`);
+  } else if (phase === 'end' && tokenOrPid) {
+    const [runId, startedAt] = tokenOrPid.split('@');
+    const code = Number(status);
+    const signal = code === 137 ? 'SIGKILL' : null;
+    const timedOut = code === 142;
+    const error = code && !signal && !timedOut ? `exited ${code}` : '';
+    const durationMs = Math.max(0, Date.now() - Number(startedAt));
+    const entry = recordEngineResource(root, { phase: 'end', engine, task, run_id: runId, signal, timed_out: timedOut, error, duration_ms: durationMs });
+    if (entry && entry.cause) process.stdout.write(entry.cause);
+  }
+}

package/scripts/det/ytnotes

@@ -315,6 +315,28 @@ run_with_timeout() {
   perl -e '$seconds = shift @ARGV; alarm $seconds; exec @ARGV or do { print STDERR "$ARGV[0]: not installed\n"; exit 127 }' "$seconds" "$@"
 }
 
+# Machine memory and load at both ends of one writer launch, in the caller's
+# Atris workspace, so a writer killed with SIGKILL says whether the machine
+# was short on memory. A reading that fails never stops the notes.
+engine_reading() {
+  (cd "$CALLER_CWD" && node "$SCRIPT_DIR/engine-reading.js" "$@") 2>/dev/null || true
+}
+
+with_readings() {
+  local engine="$1" token cause status=0
+  shift
+  token=$(engine_reading start "$engine" "youtube notes" "$$")
+  "$@" || status=$?
+  [ -n "$token" ] || return "$status"
+  cause=$(engine_reading end "$engine" "youtube notes" "$token" "$status")
+  if [ -n "$cause" ]; then
+    echo "$engine stopped by SIGKILL; $cause" >&2
+    # auto sends writer errors to a file; it shows this line on screen.
+    echo "$engine stopped by SIGKILL; $cause" > "$WORK/yt_${ID}.kill"
+  fi
+  return "$status"
+}
+
 run_atris_fast() {
   if [ ! -d "$CALLER_CWD/atris" ]; then
     echo "atris-fast requires ytnotes to run from an initialized Atris workspace" >&2
@@ -392,12 +414,12 @@ process.stdin.on("end", () => {
 }
 
 run_grok() {
-  run_with_timeout 240 grok --verbatim --no-memory --no-plan --no-subagents \
+  with_readings grok run_with_timeout 240 grok --verbatim --no-memory --no-plan --no-subagents \
     --disable-web-search --max-turns 3 -p "$PROMPT"
 }
 
 run_haiku() {
-  run_with_timeout 240 claude -p "$PROMPT" --model "${1:-claude-haiku-5-5}"
+  with_readings claude run_with_timeout 240 claude -p "$PROMPT" --model "${1:-claude-haiku-5-5}"
 }
 
 # Gemini Flash through the Antigravity CLI (agy). On an 85-minute transcript it
@@ -426,7 +448,7 @@ run_gemini() {
   command -v agy >/dev/null 2>&1 || { echo "agy is not installed" >&2; return 127; }
   agy_is_cli || { echo "agy on PATH is the Antigravity editor launcher, which has no -p mode. Install the Antigravity CLI for Gemini notes." >&2; return 127; }
   agy_signed_in || { echo "agy is installed but not signed in. Run: agy (sign in once) for Gemini notes." >&2; return 127; }
-  run_with_timeout 120 agy -p "$PROMPT" --model "${ATRIS_YTNOTES_GEMINI_MODEL:-${1:-gemini-3.8-flash}}" \
+  with_readings agy run_with_timeout 120 agy -p "$PROMPT" --model "${ATRIS_YTNOTES_GEMINI_MODEL:-${1:-gemini-3.8-flash}}" \
     --effort "${2:-low}" --print-timeout 110s </dev/null
 }
 
@@ -483,8 +505,8 @@ run_writer() {
   case "$1" in
     agy) run_gemini "$model" "${3:-}" ;;
     claude) run_haiku "$model" ;;
-    codex) run_with_timeout 240 codex exec ${model:+-m "$model"} --sandbox read-only --skip-git-repo-check "$PROMPT" </dev/null ;;
-    cursor-agent) run_with_timeout 240 cursor-agent --trust ${model:+--model "$model"} -p "$PROMPT" ;;
+    codex) with_readings codex run_with_timeout 240 codex exec ${model:+-m "$model"} --sandbox read-only --skip-git-repo-check "$PROMPT" </dev/null ;;
+    cursor-agent) with_readings cursor-agent run_with_timeout 240 cursor-agent --trust ${model:+--model "$model"} -p "$PROMPT" ;;
   esac
 }
 
@@ -501,11 +523,13 @@ run_auto() {
     if [ -n "$tried" ]; then
       echo "$tried did not answer; writing the notes with $label instead." >&2
     fi
+    rm -f "$WORK/yt_${ID}.kill"
     if out=$(run_writer "$cmd" "$model" "$effort" 2>>"$WORK/yt_${ID}.engine.err") && printf '%s' "$out" | grep -q '[[:alnum:]]'; then
       printf '%s\n' "$out"
       echo "notes by $label" >&2
       return 0
     fi
+    [ -f "$WORK/yt_${ID}.kill" ] && cat "$WORK/yt_${ID}.kill" >&2
     tried="$label"
   done
   if [ -n "$tried" ]; then