atris 3.68.9 → 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,
@@ -492,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.');
@@ -730,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) {

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

package/lib/member-autoland.js

@@ -0,0 +1,350 @@
+'use strict';
+
+// After an ignited member run ends with its check passing, hand the branch to
+// GitHub auto-merge. Every local gate fails closed: the branch stays put and
+// one plain line says which gate held it. GitHub then waits for the branch to
+// be up to date and CI green; this never merges, rebases, or polls itself.
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const {
+  deniedTagOf,
+  declaredProtectedLane,
+  sniffedProtectedLane,
+} = require('./auto-accept-certified');
+const { isDecisionHoldTag, isDecisionTask } = require('./task-decision');
+
+// Git replacement refs can make a local check read different code than the
+// commit that gets pushed; every git and gh call here ignores them.
+function run(cmd, args, cwd) {
+  const env = { ...process.env, GIT_NO_REPLACE_OBJECTS: '1' };
+  const res = spawnSync(cmd, args, { cwd, encoding: 'utf8', timeout: 120000, env });
+  return {
+    ok: res.status === 0,
+    stdout: String(res.stdout || '').trim(),
+    stderr: String(res.stderr || res.error?.message || '').trim(),
+  };
+}
+
+// The policy lives in the main checkout, not the mission's worktree copy.
+function mainCheckoutRoot(cwd) {
+  const common = run('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], cwd);
+  if (!common.ok || !common.stdout) return null;
+  return path.dirname(common.stdout);
+}
+
+function policyOn(cwd) {
+  const root = mainCheckoutRoot(cwd);
+  if (!root) return false;
+  try {
+    const policy = JSON.parse(fs.readFileSync(path.join(root, '.atris', 'policy', 'autoland.json'), 'utf8'));
+    return Boolean(policy) && typeof policy === 'object' && policy.enabled === true;
+  } catch {
+    return false;
+  }
+}
+
+const TAG_KEYS = new Set(['tag', 'tags', 'todo_tags', 'lane']);
+const METADATA_DEPTH_LIMIT = 6;
+const METADATA_TEXT_CAP = 64 * 1024;
+
+// Every string anywhere in metadata, and the ones anywhere below a tag key.
+// Metadata too deep or too large to read whole returns null, which holds.
+function metadataStrings(metadata) {
+  const texts = [];
+  const tags = [];
+  let size = 0;
+  const walk = (value, depth, tagged) => {
+    if (typeof value === 'string') {
+      size += value.length;
+      texts.push(value);
+      if (tagged) tags.push(value);
+      return size <= METADATA_TEXT_CAP;
+    }
+    if (!value || typeof value !== 'object') return true;
+    if (depth >= METADATA_DEPTH_LIMIT) return false;
+    if (Array.isArray(value)) return value.every((item) => walk(item, depth + 1, tagged));
+    return Object.entries(value).every(([key, item]) => walk(item, depth + 1, tagged || TAG_KEYS.has(key)));
+  };
+  return walk(metadata, 0, false) ? { texts, tags } : null;
+}
+
+// A row's protected lane, or null. Tags are its own tag and lane, every
+// string under a tag key anywhere in metadata, and '#tag' words in the title.
+// Text is the title, objective, and every string in metadata.
+function protectedLane(row) {
+  if (!row || typeof row !== 'object') return 'unreadable';
+  // Metadata is a plain object or absent; anything else, including stored
+  // text that would not parse, cannot be checked.
+  const meta = row.metadata;
+  if (row.metadata_unreadable || (meta !== undefined && meta !== null && (typeof meta !== 'object' || Array.isArray(meta)))) {
+    return 'metadata could not be read';
+  }
+  const found = metadataStrings(meta);
+  if (!found) return 'metadata too large to check';
+  const title = String(row.title || '');
+  const tags = [
+    row.tag,
+    row.lane,
+    ...(Array.isArray(row.tags) ? row.tags : []),
+    ...found.tags,
+    ...(title.match(/#[A-Za-z0-9_-]+/g) || []).map((t) => t.slice(1)),
+  ];
+  // Decision rows wait for a person; the same rule member go's picker uses.
+  if (isDecisionTask(row)) return 'needs a human decision';
+  for (const tag of tags) {
+    const text = String(tag ?? '');
+    if ([text, ...text.split(/[\s,]+/)].some(isDecisionHoldTag)) return 'needs a human decision';
+    const denied = deniedTagOf({ tag: text });
+    if (denied) return denied;
+  }
+  const objective = [title, typeof row.objective === 'string' ? row.objective : '', ...found.texts].filter(Boolean).join('\n');
+  const view = { title, objective, metadata: {} };
+  const declared = declaredProtectedLane(view);
+  if (declared) return `declared "${declared.phrase}"`;
+  const sniffed = sniffedProtectedLane(view);
+  if (sniffed) return sniffed.lane;
+  return null;
+}
+
+// Every task this mission points at, or null when a link is malformed.
+function linkedTaskIds(mission) {
+  const ids = [];
+  if (mission.task_ids !== undefined) {
+    if (!Array.isArray(mission.task_ids)) return null;
+    for (const id of mission.task_ids) {
+      if (typeof id !== 'string' || !id.trim()) return null;
+      ids.push(id.trim());
+    }
+  }
+  const xp = mission.xp_task;
+  if (xp !== undefined && xp !== null && (typeof xp !== 'object' || Array.isArray(xp))) return null;
+  for (const value of [mission.task_id, mission.task_ref, mission.current_task_id, xp?.task_id, xp?.ref]) {
+    if (value === undefined || value === null || value === '') continue;
+    if (typeof value !== 'string' || !value.trim()) return null;
+    ids.push(value.trim());
+  }
+  return [...new Set(ids)];
+}
+
+function defaultLoadTask(id) {
+  try {
+    const taskDb = require('./task-db');
+    return taskDb.getTask(taskDb.open(), id) || null;
+  } catch {
+    return null;
+  }
+}
+
+const RECEIPT_STAMP_RE = /^\d{4}-\d{2}-\d{2}T[0-9-]+Z\.json$/;
+
+// The newest run receipt this mission wrote in its own folder, or null.
+function latestRunReceipt(missionId, cwd) {
+  if (typeof missionId !== 'string' || !/^[A-Za-z0-9._-]+$/.test(missionId)) return null;
+  const dir = path.join(cwd, 'atris', 'runs');
+  const prefix = `mission-${missionId}-`;
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return null;
+  }
+  const latest = names
+    .filter((name) => name.startsWith(prefix) && RECEIPT_STAMP_RE.test(name.slice(prefix.length)))
+    .sort((a, b) => (a.slice(prefix.length) < b.slice(prefix.length) ? -1 : 1))
+    .pop();
+  if (!latest) return null;
+  try {
+    const receipt = JSON.parse(fs.readFileSync(path.join(dir, latest), 'utf8'));
+    if (!receipt || typeof receipt !== 'object' || receipt.mission_id !== missionId) return null;
+    return receipt;
+  } catch {
+    return null;
+  }
+}
+
+// Review must cover the final code of the final run. The newest receipt for
+// this mission must be a finished run's summary, recorded on a clean folder
+// whose code tree is the one checked out now, with nothing newer in the
+// 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 = {}) {
+  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 : {};
+  if (result.kind !== 'mission_run_summary') return 'the latest run has not finished';
+  const receiptAt = Date.parse(receipt.at || '');
+  if (!Number.isFinite(receiptAt)) return 'the latest run receipt has no time';
+  if (receipt.clean !== true) return 'the latest run ended with unsaved changes';
+  const head = run('git', ['rev-parse', 'HEAD^{tree}'], cwd);
+  if (!head.ok || !head.stdout || receipt.git_tree !== head.stdout) {
+    return 'the latest review was not recorded on the code that is checked out now';
+  }
+  const commitTime = run('git', ['log', '-1', '--format=%ct', 'HEAD'], cwd);
+  const committedAt = Number(commitTime.stdout) * 1000;
+  if (!commitTime.ok || !Number.isFinite(committedAt) || committedAt <= 0 || committedAt > receiptAt) {
+    return 'the code was committed after the latest review';
+  }
+
+  const ticks = Array.isArray(result.ticks) ? result.ticks : [];
+  if (!ticks.length || result.tick_count !== ticks.length) return 'no reviewed work is recorded on the latest run';
+  const lastTick = ticks[ticks.length - 1] || {};
+  const lastTickAt = Date.parse(mission.last_tick_at || '');
+  if (!Number.isFinite(lastTickAt) || lastTickAt > receiptAt) return 'the mission ran again after the latest receipt';
+  if (mission.last_tick_status !== 'ran') return 'the mission\'s last step did not finish cleanly';
+  if (mission.last_tick_index !== undefined && mission.last_tick_index !== lastTick.tick_index) {
+    return 'the mission ran again after the latest receipt';
+  }
+
+  const worker = String(workerEngine || mission.runner || '').trim().toLowerCase();
+  if (!worker || worker === 'auto') return 'the engine that did the work is unknown';
+  const self = new Set([mission.owner, worker, ...ticks.map((tick) => tick && tick.engine_id)]
+    .map((v) => String(v || '').trim().toLowerCase()).filter(Boolean));
+  for (const tick of ticks) {
+    if (!tick || typeof tick !== 'object' || tick.status !== 'ran' || tick.verifier_passed !== true) {
+      return 'a step on the latest run did not pass its check';
+    }
+    const referee = tick.referee_result;
+    if (!referee || typeof referee !== 'object' || referee.mode !== 'engine' || referee.passed !== true) {
+      return 'a reviewer on the latest run did not pass it';
+    }
+    const reviewer = String(referee.engine || '').trim().toLowerCase();
+    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';
+  pin.tree = head.stdout;
+  return null;
+}
+
+// The checked-out code as git sees it with config tricks switched off: every
+// untracked file listed, submodules compared, no file monitor, and no index
+// entry marked assume-unchanged or skip-worktree (anything but an 'H' tag).
+function gitCodeState(cwd) {
+  const status = run('git', [
+    '-c', 'status.showUntrackedFiles=all', '-c', 'core.fsmonitor=false',
+    'status', '--porcelain', '--untracked-files=all', '--ignore-submodules=none',
+  ], cwd);
+  const index = run('git', ['-c', 'core.fsmonitor=false', 'ls-files', '-v'], cwd);
+  const hidden = !index.ok || index.stdout.split('\n').some((line) => line && !line.startsWith('H '));
+  const tree = run('git', ['rev-parse', 'HEAD^{tree}'], cwd);
+  return {
+    clean: status.ok && !status.stdout && !hidden,
+    hidden,
+    status: status.ok ? status.stdout : null,
+    tree: tree.ok && tree.stdout ? tree.stdout : null,
+  };
+}
+
+// New files Atris writes for itself while a run is going (receipts, state,
+// logs). Changed tracked files always count.
+const BOOKKEEPING = /^\?\? (?:\.atris\/|atris\/(?:runs|status|logs)\/|atris\/team\/[^/]+\/logs\/)/;
+
+function codeStatus(state) {
+  if (!state || state.status == null) return null;
+  return state.status.split('\n').filter((line) => line && !BOOKKEEPING.test(line)).join('\n');
+}
+
+function unsavedHold(cwd) {
+  if (!gitCodeState(cwd).clean) return 'unsaved changes; the check may not match what would merge';
+  return null;
+}
+
+function held(gate, line) {
+  return { merged: false, auto_merge: false, gate, line: `left the branch for you: ${line}` };
+}
+
+function autolandMemberRun({ mission, cwd, summary = '', workerEngine = '', loadTask = defaultLoadTask } = {}) {
+  if (!mission || typeof mission !== 'object') return held('mission', 'the mission could not be read');
+  if (mission.verifier_result?.passed !== true) return held('check', 'the check did not pass');
+  if (!policyOn(cwd)) return held('policy', 'self-landing is not switched on in the main checkout');
+
+  const missionLane = protectedLane({ ...mission, title: mission.objective });
+  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');
+  for (const id of taskIds) {
+    let task = null;
+    try {
+      task = loadTask(id, cwd);
+    } catch {
+      task = null;
+    }
+    if (!task || typeof task !== 'object') return held('protected', `a linked task (${id}) could not be read`);
+    const lane = protectedLane(task);
+    if (lane) return held('protected', `a linked task sits in a protected area (${lane})`);
+  }
+
+  const unsaved = unsavedHold(cwd);
+  if (unsaved) return held('unsaved', unsaved);
+  const pin = {};
+  const reviewGap = reviewHold(mission, workerEngine, cwd, pin);
+  if (reviewGap) return held('review', reviewGap);
+  // Pin the commit the review passed on. Only this commit is pushed and
+  // merged, so a commit made after this point never rides along.
+  const headRead = run('git', ['rev-parse', 'HEAD'], cwd);
+  const headSha = headRead.ok ? headRead.stdout : '';
+  if (!/^[0-9a-f]{40,64}$/.test(headSha)) return held('branch', 'the latest commit could not be read');
+  const pinnedTree = () => {
+    const tree = run('git', ['rev-parse', `${headSha}^{tree}`], cwd);
+    return tree.ok && tree.stdout === pin.tree;
+  };
+  if (!pin.tree || !pinnedTree()) return held('review', 'the code moved while the review was being checked');
+
+  const branchRead = run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+  const branch = String(mission.worktree?.branch || branchRead.stdout || '').trim();
+  if (!branch || branch === 'HEAD' || branch === 'master' || branch === 'main') {
+    return held('branch', 'the work is not on its own branch');
+  }
+  const remoteHead = run('git', ['ls-remote', '--symref', 'origin', 'HEAD'], cwd);
+  const base = (remoteHead.stdout.match(/^ref: refs\/heads\/(\S+)\s+HEAD$/m) || [])[1] || '';
+  if (!remoteHead.ok || !base) return held('base', 'the main branch on GitHub could not be read');
+  if (branch === base) return held('branch', 'the work is not on its own branch');
+
+  if (!pinnedTree()) return held('review', 'the reviewed commit no longer holds the reviewed code');
+  const push = run('git', ['push', 'origin', `${headSha}:refs/heads/${branch}`], cwd);
+  if (!push.ok) return held('push', `the branch could not be pushed (${push.stderr.split('\n')[0]})`);
+
+  // Find the open pull request from exactly this branch into the main
+  // branch, or open one. Merge is always addressed by number, never by a
+  // branch name gh might read as a number, and pinned to the pushed commit.
+  const listed = run('gh', [
+    'pr', 'list', '--head', branch, '--base', base, '--state', 'open',
+    '--json', 'number,headRefName,baseRefName,headRefOid,isCrossRepository',
+  ], cwd);
+  if (!listed.ok) return held('pull request', `open pull requests could not be read (${listed.stderr.split('\n')[0]})`);
+  let rows;
+  try {
+    rows = JSON.parse(listed.stdout || '[]');
+  } catch {
+    rows = null;
+  }
+  if (!Array.isArray(rows)) return held('pull request', 'open pull requests could not be read');
+  const matches = rows.filter((pr) => pr && pr.headRefName === branch && pr.baseRefName === base
+    && pr.isCrossRepository === false && Number.isInteger(pr.number) && pr.number > 0);
+  if (matches.length > 1) return held('pull request', 'more than one pull request is open for this branch');
+  let number = matches.length ? matches[0].number : 0;
+  let url = '';
+  if (!number) {
+    const title = String(mission.objective || branch).replace(/\s+/g, ' ').trim().slice(0, 70);
+    const body = String(summary || '').trim() || `Receipt: ${mission.receipt_path || 'none recorded'}`;
+    const created = run('gh', ['pr', 'create', '--head', branch, '--base', base, '--title', title, '--body', body], cwd);
+    url = created.ok ? created.stdout.split('\n').pop().trim() : '';
+    number = Number((url.match(/\/pull\/(\d+)$/) || [])[1] || 0);
+    if (!created.ok || !number) {
+      return held('pull request', `the pull request could not be opened (${(created.stderr || url).split('\n')[0]})`);
+    }
+  }
+  const label = url || `pull request #${number}`;
+
+  const merge = run('gh', ['pr', 'merge', String(number), '--auto', '--merge', '--match-head-commit', headSha], cwd);
+  if (!merge.ok) return held('auto-merge', `auto-merge could not be switched on for ${label}`);
+  return { merged: false, auto_merge: true, gate: null, url: label, line: `merges on its own once checks pass: ${label}` };
+}
+
+module.exports = {
+  autolandMemberRun,
+  codeStatus,
+  gitCodeState,
+};