atris 3.78.0 → 3.80.0

package/lib/held-pull-requests.js

@@ -234,15 +234,16 @@ const GIT_REPOSITORY_VARIABLES = [
 
 // Which repository a workspace came from: the owner and name its origin remote points at, asked of
 // git in the workspace's own folder. Null when git cannot say (no folder, no origin) or the remote
-// does not read as a GitHub repository.
-function originRepoOf(root, { run = spawnSync } = {}) {
+// does not read as a GitHub repository. `run` and `timeoutMs` (10 seconds unless told) are for the
+// caller that holds git to a limit of its own, and for tests.
+function originRepoOf(root, { run = spawnSync, timeoutMs = 10000 } = {}) {
   if (!root) return null;
   const env = { ...process.env };
   for (const key of GIT_REPOSITORY_VARIABLES) delete env[key];
   const done = run('git', ['-C', String(root), 'remote', 'get-url', 'origin'], {
     encoding: 'utf8',
     env,
-    timeout: 10000,
+    timeout: timeoutMs,
     killSignal: 'SIGKILL',
     stdio: ['ignore', 'pipe', 'ignore'],
   }) || {};
@@ -289,6 +290,14 @@ function leftAloneDetail(reason) {
   return 'it changed while GitHub was being asked, so it was left alone';
 }
 
+// The jobs among `rows` that wait on a pull request, oldest first (by when they were made, then by row id).
+// The order is the order the sweep goes through them in.
+function heldJobsAmong(taskStore, rows) {
+  return rows
+    .filter((row) => row.status === 'review' && taskStore.heldPullRequestOf(row))
+    .sort((a, b) => (Number(a.created_at || 0) - Number(b.created_at || 0)) || String(a.id).localeCompare(String(b.id)));
+}
+
 // Check every held job against GitHub and, unless dryRun, write down what happened.
 //
 //   taskStore      lib/task-db
@@ -298,6 +307,21 @@ function leftAloneDetail(reason) {
 //   ask            how to ask GitHub about a link (askGitHub); asked once per link per run
 //   askBranch      how to ask GitHub for a repository's default branch (askDefaultBranch); asked
 //                  once per repository per run, and only for a pull request that was merged
+//   askOrigin      how to read the repository a workspace came from (originRepoOf); asked once per
+//                  workspace per run, and only for a pull request that was merged or closed
+//   only           a row id: sweep that one job and none of the others (the automatic run goes job
+//                  by job, to say each result as it is made)
+//   listing        task rows already read. Given, this call lists and numbers nothing itself, and `only`
+//                  still picks from it. A job in it is named by its number if the row has one (display_id or
+//                  legacy_ref) and by its id if it has not. The automatic run reads the workspace once for the
+//                  whole run and hands each call its job, because it prints no task number and so has none to
+//                  make. Left out, as the manual sweep leaves it, this call lists and numbers the workspace
+//                  itself.
+//   nameOf         how a refusal names the other job that has the pull request, given its row id. Left
+//                  out, the name is the one that job has in its own workspace's numbering, which lists
+//                  that workspace's tasks and so can start git when checkouts are linked to it. The
+//                  automatic run, which says nothing of a refusal and keeps to a time limit, gives the
+//                  row id itself.
 //
 // Returns { ok, action, dry_run, scope, actor, outage, summary, results }. ok is false only on
 // an outage. Each result is { task_id, ref, title, builder, workspace_root, pull_request,
@@ -305,15 +329,18 @@ function leftAloneDetail(reason) {
 // unknown or not_asked, and action is what was done: landed, released, would_land,
 // would_release, none, left_alone, or refused (the pull request is not this job's build: nothing
 // was written, and detail is the plain line saying why).
-function sweepHeldJobs(taskStore, db, { workspaceRoot = null, actor, dryRun = false, ask = askGitHub, askBranch = askDefaultBranch } = {}) {
+function sweepHeldJobs(taskStore, db, { workspaceRoot = null, actor, dryRun = false, ask = askGitHub, askBranch = askDefaultBranch, askOrigin = originRepoOf, only = null, nameOf = null, listing = null } = {}) {
   if (!actor) throw new Error('actor required');
   const scope = workspaceRoot ? 'workspace' : 'everywhere';
-  // No task list yet means nothing is held.
-  const inScope = db ? taskStore.listTasks(db, { workspaceRoot: workspaceRoot || null }) : [];
-  const held = inScope
-    .filter((row) => row.status === 'review' && taskStore.heldPullRequestOf(row))
-    .sort((a, b) => (Number(a.created_at || 0) - Number(b.created_at || 0)) || String(a.id).localeCompare(String(b.id)));
-  const named = taskStore.withTaskDisplayRefs(held, inScope);
+  let named;
+  if (listing) {
+    named = heldJobsAmong(taskStore, listing).filter((row) => !only || row.id === only);
+  } else {
+    // No task list yet means nothing is held.
+    const inScope = db ? taskStore.listTasks(db, { workspaceRoot: workspaceRoot || null }) : [];
+    const held = heldJobsAmong(taskStore, inScope).filter((row) => !only || row.id === only);
+    named = taskStore.withTaskDisplayRefs(held, inScope);
+  }
 
   // Each question goes to GitHub once per run, whatever the answer: a failure is not asked again.
   const answers = new Map();
@@ -347,17 +374,17 @@ function sweepHeldJobs(taskStore, db, { workspaceRoot = null, actor, dryRun = fa
   // A workspace's origin is read once per run, and only if a pull request needs it.
   const origins = new Map();
   const originOf = (root) => {
-    if (!origins.has(root)) origins.set(root, originRepoOf(root));
+    if (!origins.has(root)) origins.set(root, askOrigin(root));
     return origins.get(root);
   };
 
-  // The name a person reads for a job, in its own workspace's numbering.
-  const refOfJob = (id) => {
+  // The name a person reads for a job, in its own workspace's numbering, unless the caller names jobs itself.
+  const refOfJob = nameOf || ((id) => {
     const task = taskStore.getTask(db, id);
     if (!task) return String(id);
     const [shown] = taskStore.withTaskDisplayRefs([task], taskStore.listTasks(db, { workspaceRoot: task.workspace_root || null }));
     return (shown && (shown.display_id || shown.legacy_ref || shown.id)) || String(id);
-  };
+  });
   // Why this pull request is not this job's to settle, when another job has it.
   const takenReason = (taken, answer) => (taken.how === 'landed'
     ? `pull request ${answer.number} in ${answer.repo} already landed with ${refOfJob(taken.id)}`
@@ -586,4 +613,4 @@ function describeHeldSweep(report) {
   return lines;
 }
 
-module.exports = { ASK_TIMEOUT_MS, askGitHub, askDefaultBranch, branchNamesJob, originRepoOf, sweepHeldJobs, describeHeldSweep };
+module.exports = { ASK_TIMEOUT_MS, askGitHub, askDefaultBranch, branchNamesJob, heldJobsAmong, originRepoOf, sweepHeldJobs, describeHeldSweep };

package/lib/known-commands.js

@@ -3,7 +3,7 @@
 const knownCommands = ['init', 'guide', 'doctor', 'doc-health', 'install', 'workspace', 'log', 'logs', 'later', 'idea', 'done', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', '99', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'revisions', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'team', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'tree', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube', 'x-search',
-                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'campaign', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'scoreboard', 'scorecard', 'rating', 'sync-checkout', 'zen',
+                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'campaign', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'sentinel', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'scoreboard', 'scorecard', 'rating', 'sync-checkout', 'zen',
                        'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'balance', 'usage', 'spend', 'api-key', 'agent-client', 'topup', 'buy', 'transactions', 'hire', 'hires', 'mail', 'design', 'mcp', 'gmail', 'google', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
                        'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'link', 'playbook', 'feed', 'brief', 'social', 'host', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join', 'rsi', 'pay', 'trust'];
 

package/lib/member-autoland.js

@@ -176,7 +176,7 @@ function latestRunReceipt(missionId, cwd) {
 // mission's own state and no commit made after it. Every tick in that run
 // must have passed its check and a verdict from a reviewer engine other than
 // the member and every engine that did the work.
-function reviewHold(mission, workerEngine, cwd, pin = {}) {
+function reviewHold(mission, workerEngine, cwd, pin = {}, doneLooksLikes = []) {
   const receipt = latestRunReceipt(mission.id, cwd);
   if (!receipt) return 'no run receipt for this mission could be read';
   const result = receipt.result && typeof receipt.result === 'object' ? receipt.result : {};
@@ -220,6 +220,18 @@ function reviewHold(mission, workerEngine, cwd, pin = {}) {
     if (!reviewer || self.has(reviewer)) return 'the latest run was reviewed by the same engine that did the work';
   }
   if (lastTick.reviewed_git_tree !== head.stdout) return 'the review did not see the code that is checked out now';
+  const doneLines = [
+    ...(Array.isArray(doneLooksLikes) ? doneLooksLikes : []),
+    mission.done_looks_like,
+  ].map((line) => String(line || '').trim()).filter(Boolean);
+  if (doneLines.length) {
+    const { missingDoneLooksLikeClaim } = require('../commands/mission');
+    const reviewOutput = String(lastTick.referee_result?.output || '');
+    for (const doneLine of doneLines) {
+      const missing = missingDoneLooksLikeClaim(doneLine, { cwd, reviewOutput });
+      if (missing) return `missing: ${missing}`;
+    }
+  }
   pin.tree = head.stdout;
   return null;
 }
@@ -459,6 +471,7 @@ function autolandMemberRun({ mission, cwd, summary = '', workerEngine = '', load
   if (missionLane) return held('protected', `this mission sits in a protected area (${missionLane})`);
   const taskIds = linkedTaskIds(mission);
   if (!taskIds) return held('protected', 'the mission\'s linked tasks are not a clean list of ids');
+  const doneLooksLikes = [];
   for (const id of taskIds) {
     let task = null;
     try {
@@ -475,12 +488,18 @@ function autolandMemberRun({ mission, cwd, summary = '', workerEngine = '', load
     if (approvals.some((value) => ['revise', 'revised', 'rejected'].includes(String(value || '').trim().toLowerCase()))) {
       return held('approval', 'a linked task was turned down; it needs fresh proof before it can go to github');
     }
+    try {
+      const explanation = require('./task-explanation').taskExplanation(task);
+      if (explanation.sources?.done_looks_like === 'explicit' && explanation.done_looks_like) {
+        doneLooksLikes.push(explanation.done_looks_like);
+      }
+    } catch {}
   }
 
   const unsaved = unsavedHold(cwd);
   if (unsaved) return held('unsaved', unsaved);
   const pin = {};
-  const reviewGap = reviewHold(mission, workerEngine, cwd, pin);
+  const reviewGap = reviewHold(mission, workerEngine, cwd, pin, doneLooksLikes);
   if (reviewGap) return held('review', reviewGap);
   // Pin the commit the review passed on. Only this commit (or a map-only
   // merge built on it) is pushed and merged, so a commit made after this

package/lib/member-board.js

@@ -261,9 +261,9 @@ function progressEvent(member, raw) {
 // so a line half written before the stream started still arrives once done;
 // files that appear later are read from the top. scan() is sync, so watch
 // and poll can both call it without racing.
-function afterLastNewline(file) {
+function afterLastNewline(file, onError = () => {}) {
   let fd;
-  try { fd = fs.openSync(file, 'r'); } catch { return 0; }
+  try { fd = fs.openSync(file, 'r'); } catch (error) { onError(`open ${file}`, error); return 0; }
   try {
     const buf = Buffer.alloc(64 * 1024);
     for (let end = fs.fstatSync(fd).size; end > 0;) {
@@ -274,14 +274,16 @@ function afterLastNewline(file) {
       end = start;
     }
     return 0;
-  } catch { return 0; } finally { fs.closeSync(fd); }
+  } catch (error) { onError(`read ${file}`, error); return 0; } finally { fs.closeSync(fd); }
 }
 
-function followBoard({ dir = progressDir(), emit, pollMs = 1000, orderByTime = false } = {}) {
+function followBoard({ dir = progressDir(), emit, pollMs = 1000, orderByTime = false, onError = () => {} } = {}) {
   const offsets = new Map();
-  const sizeOf = (file) => { try { return fs.statSync(file).size; } catch { return null; } };
-  const list = () => { try { return fs.readdirSync(dir).filter((f) => f.endsWith('.log')); } catch { return []; } };
-  for (const f of list()) offsets.set(f, afterLastNewline(path.join(dir, f)));
+  let directorySeen = false;
+  const report = (context, error) => { if (error.code !== 'ENOENT' || directorySeen) onError(context, error); };
+  const sizeOf = (file) => { try { return fs.statSync(file).size; } catch (error) { report(`stat ${file}`, error); return null; } };
+  const list = () => { try { const files = fs.readdirSync(dir); directorySeen = true; return files.filter((f) => f.endsWith('.log')); } catch (error) { report(`list ${dir}`, error); return []; } };
+  for (const f of list()) offsets.set(f, afterLastNewline(path.join(dir, f), report));
 
   function readNew(f, events) {
     const file = path.join(dir, f);
@@ -297,7 +299,7 @@ function followBoard({ dir = progressDir(), emit, pollMs = 1000, orderByTime = f
         buf = Buffer.alloc(size - from);
         buf = buf.subarray(0, fs.readSync(fd, buf, 0, buf.length, from));
       } finally { fs.closeSync(fd); }
-    } catch { return; }
+    } catch (error) { report(`read ${file}`, error); return; }
     // Stop at the last newline; a half-written tail waits for the next scan.
     const end = buf.lastIndexOf(0x0a);
     if (end < 0) { offsets.set(f, from); return; }
@@ -316,8 +318,8 @@ function followBoard({ dir = progressDir(), emit, pollMs = 1000, orderByTime = f
     if (!watcher) {
       try {
         watcher = fs.watch(dir, () => scan());
-        watcher.on('error', () => { try { watcher.close(); } catch {} watcher = null; });
-      } catch { watcher = null; }
+        watcher.on('error', (error) => { report(`watch ${dir}`, error); try { watcher.close(); } catch (closeError) { report(`close watcher ${dir}`, closeError); } watcher = null; });
+      } catch (error) { report(`watch ${dir}`, error); watcher = null; }
     }
     const events = [];
     for (const f of list()) readNew(f, events);