atris 3.68.8 → 3.69.0

package/commands/mission.js

@@ -8,7 +8,7 @@ const { spawn, spawnSync } = require('child_process');
 const { hasFlag, readFlag, readIntFlag } = require('../lib/arg-parser');
 const { memberProcessPrompt } = require('../lib/member-context');
 const { memberIdentityLine, missionObjectiveLine } = require('../lib/member-identity');
-const { formatToolStep, appendProgress, reportProgress } = require('../lib/member-progress');
+const { formatToolStep, formatCodexEvent, appendProgress, reportProgress, startedLine, newRunToken, runMarker } = require('../lib/member-progress');
 const {
   compactErrorPayload,
   compactSuccessPayload,
@@ -28,6 +28,7 @@ const {
   resolveClaudeRunnerBin,
   resolveClaudeRunnerCommandTemplate,
   buildRunnerCommand,
+  codexJsonEventsCommand,
   RUNNER_PROFILE_DEFS,
   RUNNER_PROFILE_ALIASES,
   RUNNER_PROFILE_NAMES,
@@ -6509,9 +6510,16 @@ function writeReceipt(mission, result, root = process.cwd()) {
   const receiptPath = path.join(paths.runsDir, `mission-${mission.id}-${safeTime}.json`);
   const relativeReceiptPath = path.relative(root, receiptPath);
   const finalResult = normalizeMissionReceiptResult(mission, result, relativeReceiptPath);
+  // tree_hash covers only doctrine files; git_tree pins the code the run's
+  // checks saw, so a later reader can tell whether the code has moved since.
+  // With unsaved changes the checks saw more than any commit holds, so no
+  // code tree is recorded and clean is false.
+  const codeState = require('../lib/member-autoland').gitCodeState(root);
   const receipt = {
     schema: 'atris.mission_receipt.v1',
     tree_hash: treeHashFor(root),
+    clean: codeState.clean,
+    git_tree: codeState.clean ? codeState.tree : null,
     mission_id: mission.id,
     objective: mission.objective,
     owner: mission.owner,
@@ -9181,11 +9189,20 @@ function spawnGenericRunnerTick(mission, opts) {
   if (dispatchDepth.tooDeep) return Promise.resolve(tooDeepRunnerResult(dispatchDepth));
   return new Promise((resolve) => {
     let promptFile = null;
+    let lastMessageFile = null;
     let cmd = '';
     let briefId = null;
     try {
       promptFile = writeRunnerPromptFile(cwd, mission.id, prompt);
       cmd = buildRunnerCommand({ promptFile, model, ...(mission.roster_effort ? { effort: mission.roster_effort } : {}) });
+      // A codex that prints JSONL events gets live step lines; its final
+      // answer comes from the last-message file, the same text stdout held.
+      const lastFile = promptFile.replace(/\.md$/, '.last.txt');
+      const eventsCmd = codexJsonEventsCommand(cmd, lastFile);
+      if (eventsCmd) {
+        cmd = eventsCmd;
+        lastMessageFile = lastFile;
+      }
       const engine = canonicalEngineName(mission.runner);
       if (engine) {
         const record = appendBriefRecord(cwd, {
@@ -9232,13 +9249,31 @@ function spawnGenericRunnerTick(mission, opts) {
       env: { ...gitGuard.env, ATRIS_DISPATCH_DEPTH: String(dispatchDepth.depth + 1) },
     });
     updateMissionLockOwner(missionLock, proc.pid, { phase: 'tick' });
+    const progressMember = mission.owner || 'mission';
+    const seenItemIds = new Set();
+    if (lastMessageFile) appendProgress(progressMember, `started: ${mission.objective || ''}`, mission.id);
     let stdout = '';
+    let eventBuf = '';
+    let lastAgentMessage = '';
     let stderr = '';
     let timedOut = false;
     let aborted = false;
 
     const cleanupPrompt = () => {
       try { if (promptFile) fs.unlinkSync(promptFile); } catch {}
+      try { if (lastMessageFile) fs.unlinkSync(lastMessageFile); } catch {}
+    };
+    const readCodexEvent = (line) => {
+      let ev;
+      try { ev = JSON.parse(line); } catch { return; }
+      const item = ev && ev.item;
+      if (ev.type === 'item.completed' && item && item.type === 'agent_message' && typeof item.text === 'string') {
+        lastAgentMessage = item.text;
+      }
+      const step = formatCodexEvent(ev, cwd);
+      if (!step || (item && item.id && seenItemIds.has(item.id))) return;
+      if (item && item.id) seenItemIds.add(item.id);
+      reportProgress(progressMember, step, mission.id);
     };
     const kill = () => {
       const killGroup = (sig) => {
@@ -9254,18 +9289,36 @@ function spawnGenericRunnerTick(mission, opts) {
       else signal.addEventListener('abort', onAbort, { once: true });
     }
 
-    proc.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+    proc.stdout.on('data', (chunk) => {
+      const text = chunk.toString();
+      stdout += text;
+      if (!lastMessageFile) return;
+      eventBuf += text;
+      let nl;
+      while ((nl = eventBuf.indexOf('\n')) !== -1) {
+        const line = eventBuf.slice(0, nl).trim();
+        eventBuf = eventBuf.slice(nl + 1);
+        if (line) readCodexEvent(line);
+      }
+    });
     proc.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
 
     proc.on('close', (code) => {
       clearTimeout(timer);
+      if (lastMessageFile && eventBuf.trim()) readCodexEvent(eventBuf.trim());
+      let finalText = String(stdout || '').trim();
+      if (lastMessageFile) {
+        let lastMessage = '';
+        try { lastMessage = fs.readFileSync(lastMessageFile, 'utf8'); } catch {}
+        finalText = String(lastMessage || lastAgentMessage || '').trim();
+      }
       cleanupPrompt();
       gitGuard.cleanup();
       if (signal) signal.removeEventListener?.('abort', onAbort);
       updateMissionLockOwner(missionLock, missionLock?.driverPid);
-      const finalText = String(stdout || '').trim();
       const errStr = String(stderr || '').slice(-2000);
       const ok = code === 0 && !timedOut && !aborted;
+      if (lastMessageFile) appendProgress(progressMember, `finished: ${ok ? 'ok' : 'failed'}`, mission.id);
       const authExpired = !ok && missionRunnerAuthExpired(errStr, finalText);
       resolve({
         ok,
@@ -9355,8 +9408,10 @@ function spawnClaudeTick(mission, opts) {
       });
       return;
     }
+    const runToken = newRunToken();
+    const runOwner = mission.owner || 'mission';
     const args = [
-      '-p', prompt,
+      '-p', `${runMarker(runOwner, runToken)}\n${prompt}`,
       '--output-format', 'stream-json',
       '--verbose',
       '--permission-mode', 'bypassPermissions',
@@ -9380,7 +9435,7 @@ function spawnClaudeTick(mission, opts) {
     updateMissionLockOwner(missionLock, proc.pid, { phase: 'tick' });
     const progressMember = mission.owner || 'mission';
     const seenToolIds = new Set();
-    appendProgress(progressMember, `started: ${mission.objective || ''}`, mission.id);
+    appendProgress(progressMember, startedLine(mission.objective, { pid: proc.pid, engine: 'claude', run: runToken }), mission.id);
 
     let stdoutBuf = '';
     let observedSessionIds = new Set();
@@ -9532,10 +9587,13 @@ function engineVerifierResultFromRun(engineResult, engine = 'codex') {
 }
 
 function pickCrossEngineVerifier(mission, cwd = process.cwd(), preferredEngine = '') {
-  const explicit = canonicalEngineName(preferredEngine || mission?.referee_engine || '');
-  if (explicit) return explicit;
+  // The reviewer must not be the builder: a builder grading itself is no review.
+  // A named reviewer is used unless it is the builder's own engine.
   const workerEngine = canonicalEngineName(mission?.runner) || 'claude';
-  const candidates = workerEngine === 'codex' ? ['claude', 'fable', 'codex'] : ['codex', 'claude'];
+  const explicit = canonicalEngineName(preferredEngine || mission?.referee_engine || '');
+  if (explicit && explicit !== workerEngine) return explicit;
+  const candidates = (workerEngine === 'codex' ? ['claude', 'fable'] : ['codex', 'claude'])
+    .filter((candidate) => candidate !== workerEngine);
   try {
     const engines = engineRegistryView(cwd);
     for (const candidate of candidates) {
@@ -10704,12 +10762,22 @@ async function verifyMissionRunTickPhase(context) {
         || (!currentTick.storedVerifier && !process.env.NODE_TEST_CONTEXT)
       );
     if (shouldRunReferee) {
-      const refereeResult = await runEngineVerifier(currentTick.tickRuntimeMission, {
+      // Pin the code before the referee looks; a referee that changes the
+      // code or its unsaved state has not reviewed what would merge.
+      const { gitCodeState, codeStatus } = require('../lib/member-autoland');
+      const beforeReview = gitCodeState(cwd);
+      const reviewed = await runEngineVerifier(currentTick.tickRuntimeMission, {
         cwd,
         signal: controller.signal,
         tickIndex: currentTick.tickIdx,
         refereeEngine: context.refereeEngine,
       });
+      const afterReview = gitCodeState(cwd);
+      const codeMoved = beforeReview.tree !== afterReview.tree
+        || codeStatus(beforeReview) !== codeStatus(afterReview)
+        || beforeReview.hidden !== afterReview.hidden;
+      const refereeResult = codeMoved ? { ...reviewed, passed: false, reason: 'code changed during review' } : reviewed;
+      result.reviewed_git_tree = beforeReview.clean ? beforeReview.tree : null;
       result.referee_result = refereeResult;
       if (!verifierResult || !refereeResult.passed) {
         verifierResult = verifierResult

package/commands/sync.js

@@ -3,6 +3,7 @@ const path = require('path');
 const os = require('os');
 const { ensureWikiScaffold } = require('../lib/wiki');
 const { upsertAtrisClaudeBootBlock } = require('../lib/claude-boot-block');
+const { ensureRunIgnore } = require('../lib/gitignore');
 const {
   upsertAgentVoiceCard,
   upsertClaudeVoiceHook,
@@ -83,6 +84,23 @@ function ensureRealDirectory(dir) {
   fs.mkdirSync(dir, { recursive: true });
 }
 
+// A hook script the project already has is never replaced. Projects harden
+// their hooks (nonce checks, queues, proof before pop); a sync must not
+// downgrade them to the shipped copy.
+function isProtectedHook(destPath) {
+  return path.basename(path.dirname(destPath)) === 'hooks' && fs.existsSync(destPath);
+}
+
+// A member retired to team/_archived/<name>-<date>/ must never come back.
+function isArchivedMember(teamDir, name) {
+  const archiveDir = path.join(teamDir, '_archived');
+  try {
+    return fs.readdirSync(archiveDir).some(entry => entry === name || (entry.startsWith(`${name}-`) && /^\d{4}-\d{2}-\d{2}$/.test(entry.slice(name.length + 1))));
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Sync the canonical skill set from atris-cli/atris/skills/* into a
  * workspace's atris/skills/* (plus ensure .claude/skills/ symlinks).
@@ -128,7 +146,9 @@ function syncPackageSkills(targetAtrisDir, opts = {}) {
         } else {
           const srcContent = fs.readFileSync(srcPath, 'utf8');
           const destContent = fs.existsSync(destPath) ? fs.readFileSync(destPath, 'utf8') : '';
-          if (srcContent !== destContent) {
+          if (srcContent !== destContent && isProtectedHook(destPath)) {
+            if (verbose) console.log(`- Kept atris/skills/${skillName}/${relPath} (differs from shipped hook, not replaced)`);
+          } else if (srcContent !== destContent) {
             if (!dryRun) {
               fs.writeFileSync(destPath, srcContent);
               if (entry.endsWith('.sh')) fs.chmodSync(destPath, 0o755);
@@ -348,6 +368,12 @@ function syncWorkspaceTemplate(targetRoot, bizMeta, options = {}) {
     try { templateContent = fs.readFileSync(templatePath, 'utf-8'); } catch { continue; }
     const finalContent = _substituteParams(templateContent, params);
 
+    const memberMatch = targetRelPath.split(path.sep).join('/').match(/^team\/([^/_][^/]*)\//);
+    if (memberMatch && isArchivedMember(path.join(targetAtrisDir, 'team'), memberMatch[1])) {
+      skipped++;
+      continue;
+    }
+
     if (!fs.existsSync(targetPath)) {
       addedList.push(targetRelPath); added++;
       if (!dryRun) {
@@ -358,7 +384,7 @@ function syncWorkspaceTemplate(targetRoot, bizMeta, options = {}) {
       const existing = fs.readFileSync(targetPath, 'utf-8');
       if (existing === finalContent) {
         skipped++;
-      } else if (force) {
+      } else if (force && !memberMatch) {
         updatedList.push(targetRelPath); updated++;
         if (!dryRun) fs.writeFileSync(targetPath, finalContent);
       } else {
@@ -467,6 +493,10 @@ function syncAtris(options = {}) {
         dryRun,
         force,
       });
+      const bizRunIgnore = ensureRunIgnore(process.cwd(), { dryRun });
+      if (bizRunIgnore.changed) {
+        console.log(`${dryRun ? 'Would update' : '✓ Updated'} .gitignore (atris run output ignored)`);
+      }
       exportTeamAfterUpdate(process.cwd(), { dryRun });
       if (!yes) {
         console.log('\nPlan only. Re-run with --yes to write these files.');
@@ -565,6 +595,17 @@ function syncAtris(options = {}) {
       return;
     }
 
+    // Team members belong to the project. Update never adds a member (init
+    // does that, and a missing member may have been retired to
+    // team/_archived/) and never replaces one the project has changed.
+    if (target.startsWith('team/')) {
+      if (fs.existsSync(targetFile)) {
+        console.log(`- Kept ${target} (newer template exists in the package, yours not replaced)`);
+      }
+      skipped++;
+      return;
+    }
+
     if (!dryRun) {
       fs.mkdirSync(path.dirname(targetFile), { recursive: true });
       fs.copyFileSync(sourceFile, targetFile);
@@ -694,6 +735,14 @@ Key behaviors:
     applyClaudeUpdate(content, 'create CLAUDE.md with atris block', 'created CLAUDE.md with atris block');
   }
 
+  // Member run output must stay out of git or member self-merge never fires
+  // on a dirty tree. Append-only; plan-only mode prints instead of writing.
+  const runIgnore = ensureRunIgnore(process.cwd(), { dryRun });
+  if (runIgnore.changed) {
+    console.log(`${dryRun ? 'Would update' : '✓ Updated'} .gitignore (atris run output ignored)`);
+    updated++;
+  }
+
   if (dryRun) {
     console.log(`\nDry run: ${updated} file(s) would update, ${skipped} unchanged; no changes made.`);
     if (!yes) {
@@ -728,7 +777,9 @@ function syncRecursiveCount(src, dest, label, silent) {
     } else {
       const srcBuf = fs.readFileSync(srcPath);
       const destBuf = fs.existsSync(destPath) ? fs.readFileSync(destPath) : Buffer.alloc(0);
-      if (!srcBuf.equals(destBuf)) {
+      if (!srcBuf.equals(destBuf) && isProtectedHook(destPath)) {
+        if (!silent) console.log(`- Kept ${label}/${entry} (differs from shipped hook, not replaced)`);
+      } else if (!srcBuf.equals(destBuf)) {
         fs.writeFileSync(destPath, srcBuf);
         if (entry.endsWith('.sh')) {
           fs.chmodSync(destPath, 0o755);

package/lib/auto-accept-certified.js

@@ -1396,6 +1396,7 @@ function evaluateAutoAccept(task, options = {}) {
 module.exports = {
   AGENT_CERTIFICATION_REVIEW_PASSES,
   DENIED_TAGS,
+  deniedTagOf,
   candidatePolicyGate,
   declaredProtectedLane,
   sniffedProtectedLane,

package/lib/engine-registry.js

@@ -182,11 +182,12 @@ const ENGINE_SEED_META = Object.freeze({
     // bake the effort into the model.
     models: Object.freeze([
       'gemini-3.8-flash',
+      // Matches `agy models` on agy 1.3.4, verified 2026-10-13.
+      'gemini-4-argon-high',
+      'gemini-4-argon-medium',
       'gemini-3.8-flash-high',
-      'gemini-3.7-flash-high',
-      'gemini-3.1-pro-high',
-      'claude-sonnet-4-6',
-      'claude-opus-4-6-thinking',
+      'claude-opus-5-5-high',
+      'claude-sonnet-5-5-high',
       'gpt-oss-120b-medium',
     ]),
     duty: 'errands',

package/lib/gitignore.js

@@ -0,0 +1,56 @@
+'use strict';
+
+// Member runs drop receipts and status files under atris/runs/ and
+// atris/status/. A project that never ignores them stays dirty forever and
+// member self-merge never fires, so init and update pin these entries in the
+// project .gitignore. Git repos only: a plain folder gets no new file.
+
+const fs = require('fs');
+const path = require('path');
+
+const RUN_IGNORE_COMMENT = '# atris run output';
+const RUN_IGNORE_ENTRIES = ['atris/runs/', 'atris/status/'];
+
+// .git can be a directory or a worktree pointer file; either counts.
+function isGitRepo(root) {
+  return fs.existsSync(path.join(root, '.git'));
+}
+
+// What the project .gitignore still needs, or null when it needs nothing
+// (not a git repo, or every entry already present). Pure read; callers decide
+// whether to write (update's plan-only mode prints the change instead).
+function planRunIgnore(root) {
+  if (!isGitRepo(root)) return null;
+  const file = path.join(root, '.gitignore');
+  const exists = fs.existsSync(file);
+  const content = exists ? fs.readFileSync(file, 'utf8') : '';
+  const lines = content.split(/\r?\n/).map((line) => line.trim());
+  const missing = RUN_IGNORE_ENTRIES.filter((entry) => !lines.includes(entry));
+  if (missing.length === 0) return null;
+  const additions = lines.includes(RUN_IGNORE_COMMENT) ? missing : [RUN_IGNORE_COMMENT, ...missing];
+  const gap = content === '' ? '' : content.endsWith('\n') ? '\n' : '\n\n';
+  return { file, created: !exists, missing, block: `${gap}${additions.join('\n')}\n` };
+}
+
+// Append-only write: existing lines, their order, and the rest of the file
+// are never touched. Best-effort: an unreadable or unwritable .gitignore must
+// not fail init or update, it just reports nothing changed.
+function ensureRunIgnore(root, { dryRun = false } = {}) {
+  let plan = null;
+  try {
+    plan = planRunIgnore(root);
+  } catch {
+    return { changed: false };
+  }
+  if (!plan) return { changed: false };
+  if (!dryRun) {
+    try {
+      fs.appendFileSync(plan.file, plan.block);
+    } catch {
+      return { changed: false };
+    }
+  }
+  return { changed: true, ...plan };
+}
+
+module.exports = { ensureRunIgnore };