atris 3.52.0 → 3.55.0

package/commands/recap.js

@@ -1,5 +1,7 @@
 const fs = require('fs');
 const path = require('path');
+const { isCertifiedReview, personName } = require('../lib/first-minute');
+const { isRealTestRunnerProof, quoteVerifierCommand } = require('../lib/verifier-quality');
 
 const DAY_MS = 24 * 60 * 60 * 1000;
 const DEFAULT_DAYS = 7;
@@ -30,8 +32,10 @@ function loadTasks(root) {
       const db = taskDb.open();
       const ws = taskDb.workspaceRoot(root);
       const rows = taskDb.listTasks(db, { workspaceRoot: ws });
-      const refs = taskDb.taskDisplayRefMap(rows);
-      return rows.map(row => ({ ...row, display_id: refs.get(row.id) || row.id.slice(-6) }));
+      if (Array.isArray(rows) && rows.length) {
+        const refs = taskDb.taskDisplayRefMap(rows);
+        return rows.map(row => ({ ...row, display_id: refs.get(row.id) || row.id.slice(-6) }));
+      }
     } catch (e) {
       // fall through to projection
     }
@@ -59,14 +63,22 @@ function plainCheck(proof, width = 70) {
   const checks = [];
   const add = label => { if (!checks.includes(label)) checks.push(label); };
 
+  const quoted = quoteVerifierCommand(flat);
+  if (quoted) add(`ran \`${quoted}\``);
+
   if (/\b(PR|pull request)\b.*\b(merged|MERGED)\b|\bmerged\b.*\b(PR|pull request)\b/i.test(flat)) add('merged');
-  if (/\b(node --test|npm test|npm run test|pytest|go test|cargo test|test\/|tests?)\b/i.test(flat)
-    && /\b(pass|passed|green|ok|0 failures?|9\/9|12\/12)\b/i.test(flat)) add('tests passed');
-  if (/\b(node --check|git diff --check|git diff --exit-code|git diff --quiet|rg\b|grep\b|diff --brief|cmp -s)\b/i.test(flat)) add('code check passed');
+  // Only say "tests passed" when a real test runner appears in the proof.
+  // A bare `test -f` / file-exists check must not claim tests ran.
+  if (isRealTestRunnerProof(flat)) add('tests passed');
+  if (/\b(node --check|git diff --check|git diff --exit-code|git diff --quiet)\b/i.test(flat)) add('code check passed');
+  if (/\b(?:\brg\b|\bgrep\b)\b/i.test(flat) && !/\btest\s+-[efsd]\b/i.test(flat)) add('content check passed');
   if (/\b(bench|benchmark|measured|latency|speed)\b/i.test(flat)) add('measured improvement');
   if (/\brepeated agent review\b|\bagent review\b/i.test(flat)) add('reviewed repeatedly');
   if (/\batris\/runs\/[^\s]+\.json\b|receipt\b/i.test(flat)) add('record saved');
   if (/\b(human approved|accepted by|accepted_at|reward)\b/i.test(flat)) add('human accepted');
+  if (/\btest\s+-[efsd]\b|\b\[\s+-[efsd]\b/i.test(flat) && !isRealTestRunnerProof(flat)) {
+    add(quoted ? 'file check' : 'file check only');
+  }
 
   if (checks.length) return checks.join(', ');
   return shortProof(proof, width);
@@ -99,28 +111,38 @@ function buildRecapData(root = process.cwd(), { days = DEFAULT_DAYS } = {}) {
     done_at: t.done_at || null,
   });
 
+  const newestFirst = (a, b) => (
+    Number(b.updated_at || b.created_at || 0) - Number(a.updated_at || a.created_at || 0)
+  );
   const shipped = tasks
     .filter(t => t.status === 'done' && Number(t.done_at || 0) >= cutoff)
     .sort((a, b) => Number(b.done_at || 0) - Number(a.done_at || 0))
     .map(pick);
-  const waiting = tasks
-    .filter(t => t.status === 'review')
-    .sort((a, b) => Number(b.updated_at || 0) - Number(a.updated_at || 0))
+  const reviewTasks = tasks.filter(t => t.status === 'review');
+  const waiting = reviewTasks
+    .filter(isCertifiedReview)
+    .sort(newestFirst)
+    .map(pick);
+  const checking = reviewTasks
+    .filter(t => !isCertifiedReview(t))
+    .sort(newestFirst)
     .map(pick);
   const inProgress = tasks
     .filter(t => t.status === 'open' || t.status === 'claimed')
     .map(pick);
 
-  const withProof = [...shipped, ...waiting].filter(t => t.proof).length;
+  const withProof = [...shipped, ...waiting, ...checking].filter(t => t.proof).length;
   return {
     empty: false,
     days: windowDays,
     workspace: path.basename(root),
     shipped,
     waiting,
+    checking,
     inProgress,
+    next: waiting.length ? `atris task accept ${waiting[0].id}` : null,
     proof_attached: withProof,
-    proof_total: shipped.length + waiting.length,
+    proof_total: shipped.length + waiting.length + checking.length,
   };
 }
 
@@ -140,8 +162,9 @@ function renderRecap(data) {
   const headline = [];
   if (data.shipped.length) headline.push(`${data.shipped.length} done`);
   if (data.waiting.length) headline.push(`${data.waiting.length} needs you`);
+  if (data.checking.length) headline.push(`${data.checking.length} still being checked`);
   if (data.inProgress.length) headline.push(`${data.inProgress.length} still working`);
-  lines.push(headline.length ? headline.join(' · ') : 'Quiet window — no movement in this period.');
+  lines.push(headline.length ? headline.join(' · ') : 'Quiet window. nothing moved in this period.');
 
   if (data.shipped.length) {
     lines.push('');
@@ -163,7 +186,16 @@ function renderRecap(data) {
       if (check) lines.push(`          checked: ${check}`);
     }
     if (data.waiting.length > 10) lines.push(`  … and ${data.waiting.length - 10} more`);
-    lines.push('  next: run atris task reviews');
+    if (data.next) lines.push(`  next: ${data.next}`);
+  }
+
+  if (data.checking.length) {
+    lines.push('');
+    lines.push(`STILL BEING CHECKED — ${data.checking.length}`);
+    for (const t of data.checking.slice(0, 10)) {
+      lines.push(`  ${t.id}  ${shortTitle(t.title)}`);
+    }
+    if (data.checking.length > 10) lines.push(`  … and ${data.checking.length - 10} more`);
   }
 
   if (data.inProgress.length) {
@@ -187,6 +219,7 @@ function renderShare(data) {
   lines.push('');
   if (data.shipped.length) lines.push(`- ${data.shipped.length} done and accepted`);
   if (data.waiting.length) lines.push(`- ${data.waiting.length} ready for you to approve or send back`);
+  if (data.checking.length) lines.push(`- ${data.checking.length} still being checked`);
   if (data.inProgress.length) lines.push(`- ${data.inProgress.length} still being worked on`);
   const highlights = [...data.shipped, ...data.waiting].filter(t => t.proof).slice(0, 5);
   if (highlights.length) {
@@ -201,17 +234,83 @@ function renderShare(data) {
   return lines.join('\n');
 }
 
+function recapSoftTitle(title, maxWords = 5) {
+  const words = String(title || '').replace(/\s+/g, ' ').trim().split(' ').filter(Boolean);
+  if (!words.length) return '';
+  const text = words.slice(0, maxWords).join(' ').replace(/[.,;:!?]+$/g, '');
+  return `"${text.toLowerCase()}"`;
+}
+
+function renderRecapMinute(data, { person } = {}) {
+  const who = person != null ? person : personName();
+  const greet = who ? `hey ${who}, ` : '';
+  if (data.empty) {
+    return [
+      `${greet}no task history yet.`,
+      '',
+      'next: atris init --minimal',
+    ].join('\n');
+  }
+
+  const waiting = Array.isArray(data.waiting) ? data.waiting : [];
+  const checking = Array.isArray(data.checking) ? data.checking : [];
+  const shipped = Array.isArray(data.shipped) ? data.shipped : [];
+  const inProgress = Array.isArray(data.inProgress) ? data.inProgress : [];
+  const certified = waiting[0] || null;
+  const title = certified ? recapSoftTitle(certified.title) : '';
+
+  if (certified) {
+    const win = title
+      ? `${greet}${title} is waiting for your ok.`
+      : `${greet}one finished thing is waiting for your ok.`;
+    const lines = [win];
+    if (checking.length === 1) lines.push('1 still being checked.');
+    if (checking.length > 1) lines.push(`${checking.length} still being checked.`);
+    if (data.next) {
+      lines.push('');
+      lines.push(`next: ${data.next}`);
+    }
+    return lines.join('\n');
+  }
+
+  if (checking.length === 1) {
+    const named = recapSoftTitle(checking[0] && checking[0].title);
+    if (named) return `${greet}${named} is still being checked.`;
+    return `${greet}1 finished thing is still being checked.`;
+  }
+  if (checking.length > 1) {
+    return `${greet}${checking.length} finished things are still being checked.`;
+  }
+
+  if (shipped.length) {
+    const named = recapSoftTitle(shipped[0].title);
+    return named
+      ? `${greet}you already shipped ${named}.`
+      : `${greet}you already shipped the last finished thing.`;
+  }
+
+  if (inProgress.length) {
+    const item = inProgress[0];
+    const named = recapSoftTitle(item && item.title);
+    if (item && item.owner && named) return `${greet}${named} is already yours.`;
+    if (named) return `${greet}${named} is ready to claim.`;
+  }
+
+  return `${greet}quiet window. nothing moved in this period.`;
+}
+
 function printRecapHelp() {
   console.log(`
-atris recap - what got done, in plain English
+atris recap - what got done, in spoken lines
 
-  atris recap              Last 7 days: done, needs you, still working
-  atris recap --days 30    Widen the window
-  atris recap --share      Paste-ready summary for Slack, email, or a customer
-  atris recap --json       Structured output for agents and dashboards
+  atris recap              a few spoken lines: waiting for your ok, still being checked
+  atris recap --verbose    the old report
+  atris recap --days 30    widen the window
+  atris recap --share      paste-ready summary for Slack, email, or a customer
+  atris recap --json       structured output for agents and dashboards
 
-Looks at Atris' saved work and explains it without internal jargon:
-what changed, how it was checked, and what still needs you.
+certified work names atris task accept. uncertified stays still being checked.
+use --verbose or --share for the old report.
 `);
 }
 
@@ -227,7 +326,15 @@ function recapAtris(args = []) {
     console.log(JSON.stringify(data, null, 2));
     return;
   }
-  console.log(args.includes('--share') ? renderShare(data) : renderRecap(data));
+  if (args.includes('--share')) {
+    console.log(renderShare(data));
+    return;
+  }
+  if (args.includes('--verbose') || args.includes('--full')) {
+    console.log(renderRecap(data));
+    return;
+  }
+  console.log(renderRecapMinute(data));
 }
 
-module.exports = { recapAtris, buildRecapData, renderRecap, renderShare };
+module.exports = { recapAtris, buildRecapData, renderRecap, renderRecapMinute, renderShare };

package/commands/release.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
-const { execFileSync } = require('child_process');
+const { execFileSync, spawnSync } = require('child_process');
+const { runGit } = require('../lib/checkout-sync');
 
 /**
  * atris release [--dry-run] - Tag a release, create GitHub release, draft /launch post
@@ -181,4 +182,103 @@ function printLaunchPost(version, commitLines) {
   console.log('--- end launch post ---');
 }
 
-module.exports = { releaseAtris };
+function readPackageVersion(cwd) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+    return typeof pkg.version === 'string' && pkg.version.trim() ? pkg.version.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+function runFullTestSuite(cwd) {
+  return spawnSync('npm', ['test'], {
+    cwd,
+    env: { ...process.env, CI: 'true' },
+    stdio: 'inherit',
+  });
+}
+
+function gitStdout(result) {
+  return result && result.status === 0 ? String(result.stdout || '').trim() : '';
+}
+
+/**
+ * atris release preflight
+ *
+ * Enforced checks before pushing a v* tag from master. Prints pass/fail for
+ * each check and exits nonzero if any fail. Skips the test suite when earlier
+ * git checks already failed so a bad checkout does not burn a full run.
+ */
+function releasePreflight({ cwd = process.cwd(), runTests = runFullTestSuite } = {}) {
+  let failed = false;
+
+  const branchResult = runGit(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+  const branch = gitStdout(branchResult);
+  if (branch === 'master') {
+    console.log('pass: current branch is master');
+  } else {
+    failed = true;
+    console.log(`fail: current branch is ${branch || 'unknown'}, need master`);
+  }
+
+  const statusResult = runGit(['status', '--porcelain'], cwd);
+  if (statusResult.status === 0 && String(statusResult.stdout || '').trim() === '') {
+    console.log('pass: working tree is clean');
+  } else {
+    failed = true;
+    console.log('fail: working tree is not clean');
+  }
+
+  const localMaster = gitStdout(runGit(['rev-parse', 'master'], cwd));
+  const originMaster = gitStdout(runGit(['rev-parse', 'origin/master'], cwd));
+  if (!localMaster) {
+    failed = true;
+    console.log('fail: local master is missing');
+  } else if (!originMaster) {
+    failed = true;
+    console.log('fail: origin/master is missing');
+  } else if (localMaster !== originMaster) {
+    failed = true;
+    console.log('fail: local master does not match origin/master');
+  } else {
+    console.log('pass: local master matches origin/master');
+  }
+
+  const version = readPackageVersion(cwd);
+  if (!version) {
+    failed = true;
+    console.log('fail: package.json version is missing');
+  } else {
+    const tagName = `v${version}`;
+    const tagList = gitStdout(runGit(['tag', '--list', tagName], cwd));
+    if (tagList) {
+      failed = true;
+      console.log(`fail: tag ${tagName} already exists`);
+    } else {
+      console.log(`pass: no tag ${tagName}`);
+    }
+  }
+
+  if (failed) {
+    console.log('skip: test suite (earlier checks failed)');
+  } else {
+    const testResult = runTests(cwd);
+    if (testResult && testResult.error) {
+      failed = true;
+      console.log(`fail: test suite could not run (${testResult.error.message})`);
+    } else if (testResult && testResult.status === 0) {
+      console.log('pass: test suite');
+    } else {
+      const code = testResult && typeof testResult.status === 'number' ? testResult.status : 1;
+      failed = true;
+      console.log(`fail: test suite exited ${code}`);
+    }
+  }
+
+  console.log('');
+  console.log(failed ? 'release preflight failed' : 'release preflight passed');
+  return failed ? 1 : 0;
+}
+
+module.exports = { releaseAtris, releasePreflight, runFullTestSuite };

package/commands/review.js

@@ -30,24 +30,19 @@ function findReviewEngine() {
 }
 
 function printMissingReviewEngine(jsonMode) {
+  const install = 'atris skill install code-review';
   if (jsonMode) {
     console.log(JSON.stringify({
       ok: false,
-      error: 'Review engine not found.',
+      error: 'not installed',
       expected: 'atris/business/claude-code-review/workspace/review_engine.py',
       specialists: ['Security', 'Testing', 'Performance', 'Maintainability', 'Database', 'Async'],
-      install: 'copy review_engine.py to your project',
+      install,
     }, null, 2));
   } else {
-    console.error('Review engine not found.');
-    console.error('Expected at: atris/business/claude-code-review/workspace/review_engine.py');
-    console.error('');
-    console.error('The review engine runs 6 specialists:');
-    console.error('  Security, Testing, Performance, Maintainability, Database, Async');
-    console.error('');
-    console.error('Install: copy review_engine.py to your project');
+    console.error(`not installed; ${install}`);
   }
-  process.exit(1);
+  process.exit(2);
 }
 
 function exitReviewError(message, jsonMode, extra = {}) {

package/commands/revisions.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const {
+  appendDailySummary,
+  computeRevisionMetric,
+} = require('../lib/revision-metric');
+
+function plural(count, word) {
+  return `${count} ${word}${count === 1 ? '' : 's'}`;
+}
+
+function plainSubject(subject) {
+  return String(subject || 'untitled landing')
+    .replace(/—/g, ',')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+function formatRevisionMetric(metric, saved) {
+  const summary = metric.rolling_7_days;
+  const lines = [
+    `revision signals in the last seven days: ${summary.revision_count} across ${plural(summary.landed_changes, 'atris-assisted landing')}.`,
+    `clean so far: ${summary.clean_so_far}. still observing: ${summary.still_observing}. the target is zero revisions.`,
+    'this is a same-file git signal, not proof of automatic landing or why a human changed the file.',
+  ];
+  for (const change of (metric.changes || []).filter((item) => item.revision_count > 0)) {
+    lines.push(`"${plainSubject(change.subject)}": ${plural(change.revision_count, 'possible revision')}.`);
+  }
+  lines.push(saved.appended
+    ? `daily summary saved for ${saved.row.date}.`
+    : `daily summary for ${saved.row.date} was already saved.`);
+  return lines.join('\n');
+}
+
+function revisionsCommand(args = [], deps = {}) {
+  const root = deps.root || process.cwd();
+  const json = args.includes('--json');
+  let metric;
+  try {
+    metric = (deps.computeRevisionMetric || computeRevisionMetric)(root, {
+      now: deps.now,
+      ref: deps.ref,
+    });
+  } catch {
+    console.error('this folder has no readable git history, so revisions cannot be measured.');
+    return 1;
+  }
+  const saved = (deps.appendDailySummary || appendDailySummary)(root, metric, deps.stateOptions);
+  if (json) console.log(JSON.stringify({ ...metric, daily_summary: saved }));
+  else console.log(formatRevisionMetric(metric, saved));
+  return 0;
+}
+
+module.exports = { formatRevisionMetric, plainSubject, revisionsCommand };

package/commands/run-front.js

@@ -65,19 +65,27 @@ function runnerDrivableForFrontDoor(runner, options = {}) {
   return false;
 }
 
-// Most logical mission: a moving one beats a planned one, newer beats older.
-// ready is excluded — it waits for review, not for another worker pass.
+// Most logical mission: a moving one beats a planned one, ready waits for a
+// resume when nothing else is moving, and newer beats older.
 function pickRunnableMission(root = process.cwd(), missionMap = null, options = {}) {
   let map = missionMap;
   if (!map) {
     try { map = require('./mission').loadMissionMap(root); } catch { return null; }
   }
+  const rank = (status) => {
+    if (status === 'running') return 0;
+    if (status === 'planning') return 1;
+    if (status === 'ready') return 2;
+    return 9;
+  };
   const candidates = Array.from(map.values())
-    .filter((mission) => mission && (mission.status === 'running' || mission.status === 'planning'))
+    .filter((mission) => mission && (mission.status === 'running' || mission.status === 'planning' || mission.status === 'ready'))
     .filter((mission) => runnerDrivableForFrontDoor(mission?.runner, options))
     .filter((mission) => !/^decide and start the next useful mission after:/i.test(String(mission?.objective || '')))
     .sort((a, b) => {
-      if (a.status !== b.status) return a.status === 'running' ? -1 : 1;
+      const ra = rank(a.status);
+      const rb = rank(b.status);
+      if (ra !== rb) return ra - rb;
       return String(b.updated_at || b.created_at || '').localeCompare(String(a.updated_at || a.created_at || ''));
     });
   return candidates[0] || null;

package/commands/scout.js

@@ -90,6 +90,17 @@ function runScout(question, { dir, model, engine, timeoutMs }) {
 
 async function scoutCommand(argv) {
   const args = [...argv];
+  const { refuseHeadlessUnless } = require('../lib/noninteractive');
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    showHelp();
+    return 0;
+  }
+  if (refuseHeadlessUnless(args, {
+    allowYes: true,
+    usage: 'Usage: atris scout [--yes] "<question>"\nHeadless scout needs --yes.',
+  })) {
+    return 2;
+  }
   const questions = [];
   let dir = process.cwd();
   let model = MODELS.haiku;
@@ -105,7 +116,7 @@ async function scoutCommand(argv) {
       if (!ENGINES[engine]) { console.error(`✗ unknown engine "${engine}" (claude|cursor|devin|fast)`); return 1; }
     }
     else if (a === '--timeout') timeoutMs = (parseInt(args.shift(), 10) || 180) * 1000;
-    else if (a === '--help' || a === '-h') { showHelp(); return 0; }
+    else if (a === '--help' || a === '-h' || a === '--yes' || a === '-y') { /* handled above / proceed flag */ }
     else questions.push(a);
   }