atris 3.65.0 → 3.66.0

package/lib/trust-tiers.js

@@ -7,6 +7,10 @@ const HISTORY_FILES = [
   path.join('.atris', 'state', 'career_xp_receipts.jsonl'),
   path.join('.atris', 'state', 'scorecards.jsonl'),
 ];
+// Where a legacy history row's builder is recovered from: the row only names
+// its task, and these name who built that task.
+const EPISODES_FILE = path.join('.atris', 'state', 'task_episodes.jsonl');
+const PROJECTION_FILE = path.join('.atris', 'state', 'tasks.projection.json');
 
 const PASS_OUTCOMES = new Set(['accepted', 'approved', 'done', 'pass', 'passed', 'success', 'succeeded']);
 const FAIL_OUTCOMES = new Set(['bounced', 'fail', 'failed', 'rejected', 'revised', 'rework_requested']);
@@ -15,17 +19,34 @@ function normalizedActor(value) {
   return String(value || '').trim().toLowerCase();
 }
 
-function rowActor(row) {
-  return normalizedActor(row?.claimed_by || row?.metadata?.executed_by);
+// Trust belongs to whoever BUILT the work, never to whoever approved it.
+// History rows record `actor` as the approving reviewer (one human on 1,029
+// of 1,057 receipts in one busy project), so keying on it, or on fields the
+// rows never carried, left every builder at zero history and "still earning
+// trust" forever. `actor` is deliberately not read here.
+function stampedBuilder(row) {
+  return normalizedActor(
+    row?.builder
+    || row?.built_by
+    || row?.claimed_by
+    || row?.metadata?.built_by
+    || row?.metadata?.executed_by,
+  );
+}
+
+function rowTaskId(row) {
+  return String(row?.source_task_id || row?.task_id || '').trim();
 }
 
 function rowPassed(row) {
   for (const value of [row?.passed, row?.verify_passed, row?.metadata?.verify_passed]) {
     if (typeof value === 'boolean') return value;
   }
-  const outcome = String(row?.outcome || row?.status || '').trim().toLowerCase();
-  if (PASS_OUTCOMES.has(outcome)) return true;
-  if (FAIL_OUTCOMES.has(outcome)) return false;
+  for (const value of [row?.outcome, row?.status, row?.rl_label]) {
+    const outcome = String(value || '').trim().toLowerCase();
+    if (PASS_OUTCOMES.has(outcome)) return true;
+    if (FAIL_OUTCOMES.has(outcome)) return false;
+  }
   return null;
 }
 
@@ -37,6 +58,53 @@ function rowTime(row) {
   return null;
 }
 
+function fileStamp(file) {
+  try {
+    const stat = fs.statSync(file);
+    return `${stat.size}:${stat.mtimeMs}`;
+  } catch {
+    return 'missing';
+  }
+}
+
+function eachJsonLine(file, fn) {
+  let text;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    return;
+  }
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const row = JSON.parse(line);
+      if (row && typeof row === 'object' && !Array.isArray(row)) fn(row);
+    } catch {
+      // A torn line in the episode log only costs that one lookup.
+    }
+  }
+}
+
+// task id -> builder, from the episode log (every review snapshot carries the
+// task's built_by / claimed_by) and the live projection.
+function readTaskBuilders(root) {
+  const builders = new Map();
+  const remember = (taskId, task) => {
+    const id = String(taskId || '').trim();
+    const builder = normalizedActor(task?.metadata?.built_by || task?.claimed_by);
+    if (id && builder) builders.set(id, builder);
+  };
+  eachJsonLine(path.join(root, EPISODES_FILE), (episode) => remember(episode.task_id, episode.state));
+  try {
+    const projection = JSON.parse(fs.readFileSync(path.join(root, PROJECTION_FILE), 'utf8'));
+    const tasks = Array.isArray(projection) ? projection : projection?.tasks;
+    for (const task of Array.isArray(tasks) ? tasks : []) remember(task?.id, task);
+  } catch {
+    // No projection: episode builders still apply.
+  }
+  return builders;
+}
+
 function readHistory(root) {
   const rows = [];
   let sequence = 0;
@@ -62,16 +130,58 @@ function readHistory(root) {
   return rows;
 }
 
-function computeTrustTier(actor, root = process.cwd()) {
-  const target = normalizedActor(actor);
-  if (!target) return 'probation';
+// One outcome per review episode: a receipt and a scorecard written for the
+// same episode are the same verdict, not two.
+function builderOutcomes(root) {
   const history = readHistory(root);
-  if (!history) return 'probation';
+  if (!history) return null;
+  let builders = null;
+  const byBuilder = new Map();
+  const seenEpisodes = new Set();
+  for (const entry of history) {
+    const passed = rowPassed(entry.row);
+    if (passed === null) continue;
+    const episode = String(entry.row.source_episode_id || '').trim();
+    if (episode) {
+      if (seenEpisodes.has(episode)) continue;
+      seenEpisodes.add(episode);
+    }
+    let builder = stampedBuilder(entry.row);
+    if (!builder && rowTaskId(entry.row)) {
+      if (!builders) builders = readTaskBuilders(root);
+      builder = builders.get(rowTaskId(entry.row)) || '';
+    }
+    if (!builder) continue;
+    if (!byBuilder.has(builder)) byBuilder.set(builder, []);
+    byBuilder.get(builder).push({ ...entry, passed });
+  }
+  return byBuilder;
+}
 
-  const outcomes = history
-    .filter(({ row }) => rowActor(row) === target)
-    .map((entry) => ({ ...entry, passed: rowPassed(entry.row) }))
-    .filter(({ passed }) => passed !== null)
+// Called once per waiting task on every status and tick, against a 12 MB
+// episode log; memoize per root until one of the files changes.
+const outcomeCache = new Map();
+
+function cachedBuilderOutcomes(root) {
+  const resolved = path.resolve(root);
+  const stamp = [...HISTORY_FILES, EPISODES_FILE, PROJECTION_FILE]
+    .map((relative) => fileStamp(path.join(resolved, relative)))
+    .join('|');
+  const hit = outcomeCache.get(resolved);
+  if (hit && hit.stamp === stamp) return hit.value;
+  const value = builderOutcomes(resolved);
+  outcomeCache.set(resolved, { stamp, value });
+  return value;
+}
+
+function computeTrustTier(builder, root = process.cwd()) {
+  const target = normalizedActor(builder);
+  if (!target) return 'probation';
+  const byBuilder = cachedBuilderOutcomes(root);
+  if (!byBuilder) return 'probation';
+
+  const outcomes = (byBuilder.get(target) || [])
+    .slice()
     .sort((a, b) => {
       if (a.time !== null && b.time !== null && a.time !== b.time) return a.time - b.time;
       if (a.time !== null && b.time === null) return 1;
@@ -87,4 +197,11 @@ function computeTrustTier(actor, root = process.cwd()) {
   return 'probation';
 }
 
-module.exports = { computeTrustTier };
+// The builder of a task: the stamped builder first, then whoever claimed it.
+// Never the approver.
+function taskTrustSubject(task) {
+  const metadata = task?.metadata || {};
+  return normalizedActor(metadata.built_by || task?.claimed_by || metadata.executed_by) || null;
+}
+
+module.exports = { computeTrustTier, taskTrustSubject };

package/lib/verify-worktree-rewrite.js

@@ -0,0 +1,115 @@
+'use strict';
+
+// Member agents build in temporary copies of the repo
+// (<arena>/.agent-worktrees/<project>/<name>, older ones under
+// <arena>/agent-work-trees/...) and record their proof check pointed at that
+// copy: "cd <arena>/.agent-worktrees/<project>/x && node scripts/t.mjs".
+// The landing gate only runs checks relative to the main checkout, so it
+// refused 201 of 218 finished items in project-obelisk every hour. Rewrite
+// such a check relative to the main checkout so the landing pass reruns it
+// there, and say in plain words when it cannot (the file it runs only exists
+// on the agent's branch).
+
+const fs = require('fs');
+const path = require('path');
+
+function escapeRegex(text) {
+  return String(text).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function arenaDirFor(root) {
+  let cursor = root;
+  while (cursor && cursor !== path.dirname(cursor)) {
+    if (path.basename(cursor) === 'arena') return cursor;
+    cursor = path.dirname(cursor);
+  }
+  return path.dirname(root);
+}
+
+function copyRootPattern(root) {
+  const arena = escapeRegex(arenaDirFor(root));
+  const project = escapeRegex(path.basename(root));
+  const name = '[A-Za-z0-9._-]+';
+  return `(?:${[
+    `${arena}/\\.agent-worktrees/${project}/${name}`,
+    `${arena}/agent-work-trees/${project}/${name}`,
+    `\\.\\./\\.agent-worktrees/${project}/${name}`,
+    escapeRegex(root),
+  ].join('|')})(?![A-Za-z0-9._-])`;
+}
+
+function stripQuotes(token) {
+  return token.replace(/^'(.*)'$/, '$1').replace(/^"(.*)"$/, '$1');
+}
+
+// Returns { command, rewritten, from }. `rewritten` is true only when the
+// command named an agent copy (or the main checkout by absolute path) and
+// now runs relative to the main checkout. A command that still names an
+// agent copy after the rewrite is returned untouched with rewritten:false.
+function rewriteWorktreeVerify(command, workspaceRoot) {
+  const original = String(command || '').trim();
+  const unchanged = { command: original, rewritten: false, from: null };
+  if (!original || !workspaceRoot) return unchanged;
+  const root = path.resolve(workspaceRoot);
+  const anyRoot = copyRootPattern(root);
+  if (!new RegExp(anyRoot).test(original)) return unchanged;
+
+  let cmd = original;
+  // ( cd X && cmd )  ->  cd X && cmd
+  const paren = /^\((.*)\)$/s.exec(cmd);
+  if (paren) cmd = paren[1].trim();
+  // cd '<copy>[/sub]' && rest  ->  [cd sub && ]rest
+  const cd = new RegExp(`^cd\\s+(['"]?)${anyRoot}(/[^'"\\s]*)?\\1\\s+&&\\s+(.+)$`, 's').exec(cmd);
+  if (cd) {
+    const sub = (cd[2] || '').replace(/^\/+|\/+$/g, '');
+    cmd = sub ? `cd ${sub} && ${cd[3]}` : cd[3];
+  }
+  // npm --prefix <copy> run x  ->  npm run x
+  cmd = cmd.replace(new RegExp(`\\bnpm\\s+--prefix\\s+(['"]?)${anyRoot}/?\\1\\s+`, 'g'), 'npm ');
+  // '<copy>/a/b' -> a/b ; bare '<copy>' -> .
+  cmd = cmd.replace(new RegExp(`(['"]?)${anyRoot}/([^'"\\s]+)\\1`, 'g'), (_m, _q, rest) => rest);
+  cmd = cmd.replace(new RegExp(`(['"]?)${anyRoot}/?\\1(?=\\s|$)`, 'g'), '.');
+  // Only plain path quoting is stripped; quoted text with spaces stays put.
+  cmd = cmd.split(/(\s+)/).map((part) => (/^\s+$/.test(part) ? part : stripQuotes(part))).join('').trim();
+  if (new RegExp(anyRoot).test(cmd) || /\.agent-worktrees|agent-work-trees/.test(cmd)) return unchanged;
+  return { command: cmd, rewritten: true, from: original };
+}
+
+// Files a parsed check step reads by relative path: its folder, the script
+// it runs, the file it tests. Used to tell "this check cannot run on main
+// because its file only exists on the agent's branch" from a real failure.
+function stepReferencedPaths(step) {
+  const argv = Array.isArray(step?.argv) ? step.argv : [];
+  const paths = [];
+  if (step?.cwd) paths.push({ path: step.cwd, kind: 'dir' });
+  const [bin, first, second] = argv;
+  const looksLikePath = (token) => Boolean(token) && !String(token).startsWith('-') && /[/.]/.test(String(token));
+  if (bin === 'node' && first === '--check' && looksLikePath(second)) paths.push({ path: second, kind: 'file' });
+  else if (bin === 'node' && first === '--test') {
+    for (const token of argv.slice(2)) {
+      if (looksLikePath(token) && !String(token).includes('*') && /\.[cm]?[jt]s$/.test(token)) paths.push({ path: token, kind: 'file' });
+    }
+  } else if (bin === 'node' && looksLikePath(first)) paths.push({ path: first, kind: 'file' });
+  if ((bin === 'python' || bin === 'python3' || /venv\/bin\/python3?$/.test(String(bin || ''))) && looksLikePath(first) && first !== '-m') {
+    paths.push({ path: first, kind: 'file' });
+  }
+  if (bin === 'test' && (first === '-f' || first === '-s') && looksLikePath(second)) paths.push({ path: second, kind: 'file' });
+  return paths;
+}
+
+// First referenced path missing from the main checkout, or null.
+function missingOnMain(steps, workspaceRoot) {
+  const root = path.resolve(workspaceRoot || process.cwd());
+  for (const step of steps || []) {
+    const base = step?.cwd ? path.resolve(root, step.cwd) : root;
+    for (const ref of stepReferencedPaths(step)) {
+      const target = ref.kind === 'dir' ? path.resolve(root, ref.path) : path.resolve(base, ref.path);
+      if (!fs.existsSync(target)) {
+        return path.relative(root, target) || ref.path;
+      }
+    }
+  }
+  return null;
+}
+
+module.exports = { rewriteWorktreeVerify, missingOnMain, stepReferencedPaths };

package/lib/voice-gate.js

@@ -255,6 +255,8 @@ const LANDING_REASON_SENTENCES = {
   verifier_is_builder: 'the re-check actor built this row, another actor must re-check',
   verify_command_not_allowed: 'its recorded check is not on the list this machine may run alone, run it yourself to unblock',
   verify_failed: 'its check command failed on re-run, fix the failure and re-certify',
+  verify_failed_on_main: 'its check was recorded in an agent copy and fails when rerun from main, so its work is likely still on the agent branch',
+  verify_only_on_agent_branch: 'its check runs a file that only exists on the agent branch, not on main yet, so that branch has to land first',
   verify_passed: 'its check command passed on re-run',
   verify_unrunnable: 'its check command could not even start, fix the command and re-certify',
   verify_workdir_missing: 'the folder its check was recorded in is gone, re-run the check from a real folder',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.65.0",
+  "version": "3.66.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {

package/scripts/det/ytnotes

@@ -373,7 +373,7 @@ run_grok() {
 }
 
 run_haiku() {
-  run_with_timeout 240 claude -p "$PROMPT" --model "${1:-claude-haiku-4-5}"
+  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