atris 3.34.0 → 3.35.0

package/commands/drive.js

@@ -0,0 +1,187 @@
+// atris drive — self-driving tick over the mission plane.
+// One tick: run mission doctor, auto-execute the fixes it prescribes that are
+// safe to run (stale ready receipts -> verify tick), and log everything that
+// still needs a human as an explicit disengagement. The metric that matters:
+// disengagements per tick, driven to zero.
+//
+// State: .atris/state/drive.jsonl (one line per tick, append-only).
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const BIN = path.join(__dirname, '..', 'bin', 'atris.js');
+
+function runAtris(args, cwd) {
+  const res = spawnSync(process.execPath, [BIN, ...args], {
+    cwd,
+    encoding: 'utf8',
+    timeout: 120000,
+    maxBuffer: 16 * 1024 * 1024,
+  });
+  return { code: res.status, stdout: res.stdout || '', stderr: res.stderr || '' };
+}
+
+function parseJsonLoose(text) {
+  if (!text) return null;
+  const start = text.indexOf('{');
+  if (start === -1) return null;
+  try { return JSON.parse(text.slice(start)); } catch (err) { return null; }
+}
+
+function statePath(cwd) {
+  return path.join(cwd, '.atris', 'state', 'drive.jsonl');
+}
+
+function loadHistory(cwd, limit = 20) {
+  try {
+    const lines = fs.readFileSync(statePath(cwd), 'utf8').trim().split('\n');
+    return lines.slice(-limit).map((l) => { try { return JSON.parse(l); } catch (e) { return null; } }).filter(Boolean);
+  } catch (err) { return []; }
+}
+
+function appendState(cwd, record) {
+  const file = statePath(cwd);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, JSON.stringify(record) + '\n');
+}
+
+async function driveCommand(argv) {
+  const cwd = process.cwd();
+  const json = argv.includes('--json');
+  const dryRun = argv.includes('--dry-run');
+
+  if (argv.includes('--help') || argv.includes('-h')) {
+    console.log('atris drive - one self-driving tick over the mission plane');
+    console.log('');
+    console.log('  atris drive [--dry-run] [--json]   doctor -> auto-fix safe findings -> count disengagements');
+    console.log('  atris drive status [--json]        disengagement trend from past ticks');
+    console.log('');
+    console.log('  Auto-handled: stale_ready_receipt (runs the verify tick, completes on pass).');
+    console.log('  Everything else = a disengagement: the system needed a human. Logged, counted, escalated.');
+    return 0;
+  }
+
+  if (argv[0] === 'status') {
+    const history = loadHistory(cwd);
+    if (!history.length) { console.log('No drive ticks yet. Run: atris drive'); return 0; }
+    if (json) { console.log(JSON.stringify({ ok: true, ticks: history }, null, 2)); return 0; }
+    console.log('drive — disengagements per tick (goal: 0)\n');
+    for (const t of history) {
+      console.log(`  ${t.at}  fixed ${t.fixed}/${t.findings}  disengagements ${t.disengagements}`);
+    }
+    return 0;
+  }
+
+  const doctor = runAtris(['mission', 'doctor', '--json'], cwd);
+  const report = parseJsonLoose(doctor.stdout);
+  if (!report || !Array.isArray(report.findings)) {
+    console.error('drive: mission doctor returned no parseable findings.');
+    if (doctor.stderr) console.error(doctor.stderr.slice(0, 500));
+    return 1;
+  }
+
+  const fixed = [];
+  const disengagements = [];
+
+  // Missions the doctor says have no verifier. A verify-tick physically cannot
+  // pass without one, so promising to verify-tick such a mission is a phantom
+  // fix that never sticks — count it as a wheel-grab instead.
+  const noVerifier = new Set(
+    report.findings.filter((f) => f.code === 'missing_verifier' && f.mission_id).map((f) => f.mission_id),
+  );
+
+  for (const f of report.findings) {
+    if (f.code === 'stale_ready_receipt' && f.mission_id && noVerifier.has(f.mission_id)) {
+      disengagements.push({ ...pick(f), reason: 'ready_without_verifier' });
+      continue;
+    }
+    if (f.code === 'stale_ready_receipt' && f.mission_id && !dryRun) {
+      const tick = runAtris(['mission', 'tick', f.mission_id, '--verify', '--complete-on-pass', '--json'], cwd);
+      const result = parseJsonLoose(tick.stdout);
+      const passed = tick.code === 0 && result && result.ok !== false;
+      if (passed) {
+        fixed.push({ mission_id: f.mission_id, action: 'verify_tick', objective: f.objective });
+        continue;
+      }
+      disengagements.push({ ...pick(f), reason: 'verify_tick_failed' });
+      continue;
+    }
+    if (f.code === 'stale_ready_receipt' && dryRun) {
+      fixed.push({ mission_id: f.mission_id, action: 'would_verify_tick', objective: f.objective });
+      continue;
+    }
+    // No verifier and stale (planning >24h old, or already paused): park it.
+    // A paused mission is reversible; a zombie in planning is a permanent disengagement.
+    if (f.code === 'missing_verifier' && f.mission_id && isParkable(f)) {
+      if (dryRun) {
+        fixed.push({ mission_id: f.mission_id, action: 'would_park', objective: f.objective });
+        continue;
+      }
+      const stop = runAtris(['mission', 'stop', f.mission_id, '--pause', '--reason', 'drive: no verifier + stale, auto-parked (restart with a --verify to resume)'], cwd);
+      if (stop.code === 0) {
+        fixed.push({ mission_id: f.mission_id, action: 'parked', objective: f.objective });
+        continue;
+      }
+      disengagements.push({ ...pick(f), reason: 'park_failed' });
+      continue;
+    }
+    disengagements.push({ ...pick(f), reason: f.code });
+  }
+
+  // One stuck mission is one wheel-grab, even if it trips several findings.
+  // Count disengagements per mission so the metric tracks "how many missions
+  // still need a human", not "how many symptoms did we print".
+  const dedupedDisengagements = [];
+  const seenDisengaged = new Set();
+  for (const d of disengagements) {
+    const key = d.mission_id || `${d.reason}:${d.objective || ''}`;
+    if (seenDisengaged.has(key)) continue;
+    seenDisengaged.add(key);
+    dedupedDisengagements.push(d);
+  }
+  disengagements.length = 0;
+  disengagements.push(...dedupedDisengagements);
+
+  function isParkable(f) {
+    if (f.status === 'paused') return true;
+    if (f.status !== 'planning') return false;
+    const m = /^mission-(\d{4}-\d{2}-\d{2})-/.exec(f.mission_id || '');
+    if (!m) return false;
+    return (Date.now() - new Date(m[1] + 'T00:00:00Z').getTime()) > 24 * 3600 * 1000;
+  }
+
+  function pick(f) {
+    return { mission_id: f.mission_id, code: f.code, owner: f.owner, objective: (f.objective || '').slice(0, 120), next: f.next };
+  }
+
+  const record = {
+    at: new Date().toISOString(),
+    findings: report.findings.length,
+    checked: report.checked_count,
+    fixed: fixed.length,
+    disengagements: disengagements.length,
+    dry_run: dryRun,
+    fixed_detail: fixed,
+    disengagement_detail: disengagements,
+  };
+  if (!dryRun) appendState(cwd, record);
+
+  if (json) { console.log(JSON.stringify({ ok: true, ...record }, null, 2)); return 0; }
+
+  console.log(`drive tick — ${report.checked_count} missions checked, ${report.findings.length} findings`);
+  console.log(`  auto-fixed:      ${fixed.length}`);
+  for (const x of fixed) console.log(`    ✓ ${x.action} ${x.mission_id}`);
+  console.log(`  disengagements:  ${disengagements.length}  (a human has to grab the wheel)`);
+  const byCode = {};
+  for (const d of disengagements) byCode[d.reason] = (byCode[d.reason] || 0) + 1;
+  for (const [code, n] of Object.entries(byCode)) console.log(`    ✋ ${code} ×${n}`);
+  const history = loadHistory(cwd, 5);
+  if (history.length > 1) {
+    console.log(`  trend: ${history.map((t) => t.disengagements).join(' → ')}`);
+  }
+  console.log(`  next: atris drive status · fix the ✋ list · re-run atris drive`);
+  return disengagements.length > 0 ? 0 : 0;
+}
+
+module.exports = { driveCommand };

package/commands/engine.js

@@ -23,6 +23,7 @@ const {
   RUNNER_PROFILE_NAMES,
   buildRunnerCommand,
 } = require('../lib/runner-command');
+const { FLEET_CAPABLE, runDispatchFlight } = require('../lib/fleet');
 
 const HOUSE_ENGINE = 'atris-fast';
 
@@ -240,11 +241,79 @@ function runEngineTest(targets, { json, root } = {}) {
   return failures.length ? 1 : 0;
 }
 
+// One-command dispatch: claim -> worktree start -> bounded prompt -> engine
+// -> re-run Check: -> ship -> task ready, in one call instead of the 6
+// hand-rolled Bash calls per task the manual version took. Task ids are
+// positional; --engine/--prompt-file are the only flags, so parse by hand
+// instead of the generic "anything starting with --" split used above (that
+// split would swallow an --engine value like "cursor" as a task id).
+function parseDispatchArgs(args) {
+  const taskIds = [];
+  let engine = '';
+  let promptFile = '';
+  let base = '';
+  let json = false;
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    if (a === '--engine') { engine = args[i + 1] || ''; i += 1; continue; }
+    if (a.startsWith('--engine=')) { engine = a.slice('--engine='.length); continue; }
+    if (a === '--prompt-file') { promptFile = args[i + 1] || ''; i += 1; continue; }
+    if (a.startsWith('--prompt-file=')) { promptFile = a.slice('--prompt-file='.length); continue; }
+    if (a === '--base') { base = args[i + 1] || ''; i += 1; continue; }
+    if (a.startsWith('--base=')) { base = a.slice('--base='.length); continue; }
+    if (a === '--json') { json = true; continue; }
+    if (a.startsWith('--')) continue;
+    taskIds.push(a);
+  }
+  return { taskIds, engine, promptFile, base, json };
+}
+
+function runDispatchCommand(args, root) {
+  const { taskIds, engine, promptFile, base, json } = parseDispatchArgs(args);
+  if (!taskIds.length || !engine) {
+    console.error('usage: atris engine dispatch <task-id> [<task-id> ...] --engine cursor|codex [--prompt-file <f>]');
+    return 2;
+  }
+  const canonical = canonicalEngineName(engine);
+  if (!canonical || !FLEET_CAPABLE.includes(canonical)) {
+    console.error(`engine dispatch: --engine must be one of ${FLEET_CAPABLE.join(', ')}`);
+    return 2;
+  }
+  // Argument-shape errors surface before environment errors: --prompt-file
+  // with multiple ids is wrong on any machine, installed CLI or not.
+  let promptOverride = '';
+  if (promptFile) {
+    if (taskIds.length > 1) {
+      console.error('engine dispatch: --prompt-file only supports a single task id');
+      return 2;
+    }
+    try {
+      promptOverride = fs.readFileSync(promptFile, 'utf8');
+    } catch (err) {
+      console.error(`engine dispatch: could not read --prompt-file ${promptFile}: ${err.message}`);
+      return 2;
+    }
+  }
+  const def = RUNNER_PROFILE_DEFS[canonical];
+  if (!binInstalled(def.bin)) {
+    console.error(`engine dispatch: ${canonical} CLI (${def.bin}) is not installed here`);
+    return 2;
+  }
+  return runDispatchFlight({ root, taskIds, engine: canonical, prompt: promptOverride, ...(base ? { checkoutBase: base } : {}) }).then((flight) => {
+    if (json) console.log(JSON.stringify(flight, null, 2));
+    return flight.paused.length ? 1 : 0;
+  });
+}
+
 function engineCommand(args = []) {
+  const root = process.cwd();
+  if ((args[0] || '').trim() === 'dispatch') {
+    return runDispatchCommand(args.slice(1), root);
+  }
+
   const json = args.includes('--json');
   const positional = args.filter((a) => !a.startsWith('--'));
   const sub = (positional[0] || '').trim();
-  const root = process.cwd();
 
   if (sub === 'test') {
     return runEngineTest(positional.slice(1), { json, root });
@@ -269,7 +338,7 @@ function engineCommand(args = []) {
   }
 
   if (sub === 'help') {
-    console.log('\n  atris engine            roster + current default\n  atris engine <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\n  atris engine reset      back to the house default\n  --engine <name>         one run on that engine (mission run / autopilot / run)\n');
+    console.log('\n  atris engine            roster + current default\n  atris engine <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\n  atris engine dispatch <task-id> [<task-id> ...] --engine cursor|codex [--prompt-file <f>]\n                           one-command claim, worktree, build, verify, ship, ready\n  atris engine reset      back to the house default\n  --engine <name>         one run on that engine (mission run / autopilot / run)\n');
     return 0;
   }
 
@@ -295,5 +364,7 @@ module.exports = {
   roster,
   probeEngine,
   runEngineTest,
+  parseDispatchArgs,
+  runDispatchCommand,
   HOUSE_ENGINE,
 };

package/commands/feed.js

@@ -0,0 +1,202 @@
+'use strict';
+
+// Feed: the business group feed from the terminal — read receipts, post receipts.
+// Auth: existing atris login. Business: nearest .atris/business.json above cwd.
+
+const fs = require('fs');
+const path = require('path');
+const { ensureValidCredentials } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+
+function showHelp() {
+  console.log('');
+  console.log('Usage: atris feed [list] [n] [--author <name>] [--since <7d|24h>] [--full] [--json]');
+  console.log('       atris feed post "<content>"');
+  console.log('');
+  console.log('Description:');
+  console.log('  Read and write the business group feed (the same feed as the web GM dashboard).');
+  console.log('  Posts should be receipts and state changes only: what shipped, what blocked, what changed.');
+  console.log('');
+  console.log('Options:');
+  console.log('  --author <name>   Only posts whose author matches (name, email prefix, or id prefix).');
+  console.log('  --since <window>  Only posts newer than e.g. 7d, 48h.');
+  console.log('  --full            Print full post bodies instead of one line each.');
+  console.log('  --json            Machine-readable output.');
+  console.log('  --help, -h        Show this help.');
+  console.log('');
+}
+
+function findBusiness(startDir) {
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    const file = path.join(dir, '.atris', 'business.json');
+    if (fs.existsSync(file)) {
+      try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (parsed.business_id) return { businessId: parsed.business_id, name: parsed.name || parsed.slug, root: dir };
+      } catch { /* fall through to parent dirs */ }
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+function loadAuthorAliases(workspaceRoot) {
+  const file = path.join(workspaceRoot, '.atris', 'feed_authors.json');
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function parseSince(raw) {
+  const match = /^(\d+)([dh])$/.exec(String(raw || '').trim());
+  if (!match) return null;
+  const amount = parseInt(match[1], 10);
+  const ms = match[2] === 'd' ? amount * 24 * 3600 * 1000 : amount * 3600 * 1000;
+  return Date.now() - ms;
+}
+
+function authorLabel(post, aliases, selfId, selfEmail) {
+  if (post.post_type === 'agent_post') return post.agent_name || post.author_display_name || 'agent';
+  if (post.author_display_name) return post.author_display_name;
+  const id = post.author_id || '';
+  if (aliases[id]) return aliases[id];
+  if (selfId && id === selfId) return (selfEmail || 'me').split('@')[0];
+  return id ? id.slice(0, 8) : '?';
+}
+
+async function fetchPosts(businessId, token, want) {
+  const pageSize = 100;
+  let all = [];
+  for (let offset = 0; all.length < want; offset += pageSize) {
+    const res = await apiRequestJson(
+      `/business/${businessId}/feed?limit=${pageSize}&offset=${offset}`,
+      { token, timeoutMs: 20000 }
+    );
+    const statusCode = res.statusCode || res.status;
+    if (statusCode && statusCode >= 400) {
+      throw new Error(`Feed fetch failed (${statusCode}): ${JSON.stringify(res.data)}`);
+    }
+    const page = Array.isArray(res.data?.posts) ? res.data.posts : Array.isArray(res.data) ? res.data : [];
+    all = all.concat(page);
+    if (page.length < pageSize) break;
+  }
+  return all;
+}
+
+async function feedCommand(args = []) {
+  if (args.includes('--help') || args.includes('-h')) {
+    showHelp();
+    return 0;
+  }
+
+  const business = findBusiness(process.cwd());
+  if (!business) {
+    console.error('✗ No .atris/business.json found above this directory. Run from a bound workspace.');
+    return 1;
+  }
+
+  const auth = await ensureValidCredentials(apiRequestJson);
+  if (auth.error || !auth.credentials?.token) {
+    console.error(`✗ Not logged in (${auth.error || 'no token'}). Run: atris login`);
+    return 1;
+  }
+  const token = auth.credentials.token;
+  const selfId = auth.credentials.user_id || auth.user?.id || null;
+  const selfEmail = auth.credentials.email || auth.user?.email || null;
+
+  const positional = args.filter((a) => !a.startsWith('--'));
+  const sub = positional[0] || 'list';
+
+  if (sub === 'post') {
+    const content = positional.slice(1).join(' ').trim();
+    if (!content) {
+      console.error('✗ Nothing to post. Usage: atris feed post "<content>"');
+      return 1;
+    }
+    const res = await apiRequestJson(`/business/${business.businessId}/feed`, {
+      method: 'POST',
+      token,
+      body: { content: content.slice(0, 10000) },
+      timeoutMs: 20000,
+    });
+    if (!res.data?.id) {
+      console.error(`✗ Post failed: ${JSON.stringify(res.data)}`);
+      return 1;
+    }
+    console.log(`✓ Posted to ${business.name || 'business'} feed (${res.data.id})`);
+    return 0;
+  }
+
+  if (sub !== 'list') {
+    console.error(`✗ Unknown subcommand: ${sub}`);
+    showHelp();
+    return 1;
+  }
+
+  const countArg = parseInt(positional[1], 10);
+  const count = Number.isFinite(countArg) ? Math.max(1, Math.min(300, countArg)) : 15;
+  const authorFlag = args.includes('--author') ? String(args[args.indexOf('--author') + 1] || '').toLowerCase() : null;
+  const sinceFlag = args.includes('--since') ? parseSince(args[args.indexOf('--since') + 1]) : null;
+  if (args.includes('--since') && sinceFlag === null) {
+    console.error('✗ Bad --since window. Use forms like 7d or 48h.');
+    return 1;
+  }
+  const full = args.includes('--full');
+  const json = args.includes('--json');
+
+  const aliases = loadAuthorAliases(business.root);
+  // Over-fetch when filtering so the filtered result can still reach `count`.
+  const fetchWant = authorFlag || sinceFlag ? 300 : count;
+  let posts = await fetchPosts(business.businessId, token, fetchWant);
+
+  if (sinceFlag) posts = posts.filter((p) => Date.parse(p.created_at) >= sinceFlag);
+  if (authorFlag) {
+    posts = posts.filter((p) => {
+      const label = authorLabel(p, aliases, selfId, selfEmail).toLowerCase();
+      return label.includes(authorFlag) || String(p.author_id || '').startsWith(authorFlag);
+    });
+  }
+  posts = posts.slice(0, count);
+
+  if (json) {
+    console.log(JSON.stringify(posts.map((p) => ({
+      id: p.id,
+      author: authorLabel(p, aliases, selfId, selfEmail),
+      type: p.post_type,
+      created_at: p.created_at,
+      content: p.content,
+    })), null, 2));
+    return 0;
+  }
+
+  if (!posts.length) {
+    console.log('No posts matched.');
+    return 0;
+  }
+
+  for (const p of posts) {
+    const when = String(p.created_at || '').slice(0, 16).replace('T', ' ');
+    const who = authorLabel(p, aliases, selfId, selfEmail);
+    if (full) {
+      console.log(`─── ${who} — ${when}`);
+      console.log(String(p.content || '').trim());
+      console.log('');
+    } else {
+      const oneLine = String(p.content || '').replace(/\s+/g, ' ').slice(0, 120);
+      console.log(`[${when}] ${who}: ${oneLine}`);
+    }
+  }
+  return 0;
+}
+
+module.exports = {
+  feedCommand,
+  findBusiness,
+  loadAuthorAliases,
+  parseSince,
+  authorLabel,
+  fetchPosts,
+};

package/commands/github.js

@@ -0,0 +1,38 @@
+const { createOfficialCliCommand } = require('../lib/official-cli-integration');
+
+const githubCommand = createOfficialCliCommand({
+  name: 'github',
+  binary: 'gh',
+  versionArgs: ['--version'],
+  authArgs: ['auth', 'status'],
+  installHint: 'https://cli.github.com/',
+  loginHint: 'gh auth login',
+  commands: [
+    {
+      usage: 'pr list',
+      match: ['pr', 'list'],
+      forward: ['pr', 'list'],
+      description: 'list pull requests',
+    },
+    {
+      usage: 'pr create',
+      match: ['pr', 'create'],
+      forward: ['pr', 'create'],
+      description: 'create a pull request',
+    },
+    {
+      usage: 'pr checks',
+      match: ['pr', 'checks'],
+      forward: ['pr', 'checks'],
+      description: 'show pull request checks',
+    },
+    {
+      usage: 'pr view',
+      match: ['pr', 'view'],
+      forward: ['pr', 'view'],
+      description: 'show pull request details',
+    },
+  ],
+});
+
+module.exports = { githubCommand };