atris 3.79.0 → 3.80.0

package/lib/engine-ask.js

@@ -868,6 +868,7 @@ async function runEngineAskCommand(args, root = process.cwd(), deps = {}) {
 
 module.exports = {
   MAX_ASK_CONCURRENCY,
+  askRosterPin,
   MAX_ASK_JOBS,
   MAX_ASK_PROMPT_BYTES,
   parseEngineAskArgs,

package/lib/handoff-wake.js

@@ -25,7 +25,7 @@ const { DEFAULT_MAX } = require('./member-up');
 // wakes, so the next handoff counts it even before its mission says running.
 const LOCK_FILE = 'handoff-wake.lock';
 const RECENT_FILE = 'handoff-wakes.json';
-// A holder that died, or one stuck past this long, no longer holds.
+// Malformed locks get this grace period; a live owner always retains its lock.
 const STALE_LOCK_MS = 5 * 60 * 1000;
 const WAIT_LOCK_MS = 3 * 60 * 1000;
 const RECENT_MS = 30 * 60 * 1000;
@@ -51,16 +51,18 @@ function takeLock(file, { staleMs, waitMs, now }) {
     }
     try {
       const stat = fs.statSync(file);
+      const raw = fs.readFileSync(file, 'utf8');
       let owner = null;
-      try { owner = JSON.parse(fs.readFileSync(file, 'utf8')); } catch {}
+      try { owner = JSON.parse(raw); } catch (error) { if (!(error instanceof SyntaxError)) throw error; }
       const dead = owner && Number.isInteger(owner.pid) && !pidAlive(owner.pid);
       const old = now() - stat.mtimeMs > staleMs;
-      if ((dead || old) && fs.statSync(file).ino === stat.ino) {
+      if ((dead || (!Number.isInteger(owner?.pid) && old)) && fs.statSync(file).ino === stat.ino) {
         fs.unlinkSync(file);
         continue;
       }
-    } catch {
-      continue;
+    } catch (error) {
+      if (error.code === 'ENOENT') continue;
+      throw error;
     }
     if (now() >= until) return null;
     sleepSync(100);
@@ -68,7 +70,7 @@ function takeLock(file, { staleMs, waitMs, now }) {
 }
 
 // Runs fn() while holding an exclusive lock file. A holder that died, or
-// one older than staleMs, is cleared. Throws when the lock stays held past
+// malformed lock older than staleMs, is cleared. Throws when the lock stays held past
 // waitMs, so a caller never writes without it.
 function withFileLock(lockFile, fn, { staleMs = STALE_LOCK_MS, waitMs = WAIT_LOCK_MS, now = Date.now } = {}) {
   fs.mkdirSync(path.dirname(lockFile), { recursive: true });

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);