atris 3.68.9 → 3.70.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,
@@ -433,7 +434,13 @@ function missionTickTimeoutMs(mission, remainingMs) {
 
 function resolveMissionTickRunner(mission, root = process.cwd(), options = {}) {
   if (String(mission && mission.runner || '').trim().toLowerCase() !== MISSION_AUTO_RUNNER) {
-    return { mission, engine_id: null, requested_engine: null, engine_fallback_reason: null };
+    // A named engine still gets the roster's time limit for that engine.
+    const runner = String(mission && mission.runner || '').trim().toLowerCase();
+    const pin = runner && !(Number(mission && mission.roster_max_seconds) > 0)
+      ? require('../lib/engine-registry').rosterPinFor('executor', runner, root, options)
+      : {};
+    const limited = pin.roster_max_seconds ? { ...mission, roster_max_seconds: pin.roster_max_seconds } : mission;
+    return { mission: limited, engine_id: null, requested_engine: null, engine_fallback_reason: null };
   }
   // A mission owned by a team member runs on that member's roster pick. An
   // explicit preferred engine (or a run's --engine) still wins, and with no
@@ -1722,7 +1729,18 @@ function appendMemberLog(owner, title, fields = {}, root = process.cwd()) {
       .map(([key, value]) => `- ${key}: ${String(value).replace(/\n/g, ' ')}`),
     '',
   ];
-  fs.appendFileSync(logPath, rows.join('\n'), 'utf8');
+  let lead = '';
+  try {
+    const size = fs.statSync(logPath).size;
+    if (size > 0) {
+      const fd = fs.openSync(logPath, 'r');
+      const last = Buffer.alloc(1);
+      fs.readSync(fd, last, 0, 1, size - 1);
+      fs.closeSync(fd);
+      if (last[0] !== 0x0a) lead = '\n';
+    }
+  } catch {}
+  fs.appendFileSync(logPath, lead + rows.join('\n'), 'utf8');
   return logPath;
 }
 
@@ -3909,6 +3927,30 @@ function readTasteReviewHistory(root, limit = 4) {
   return { accepted, revised };
 }
 
+// Why the mission's own task was last sent back, or '' when it was not. Ticks
+// run in a worktree, so fall back to the main checkout's task projection.
+function readBoundTaskTurnDown(mission, root) {
+  const bound = mission?.xp_task || mission?.selected_target_task || null;
+  if (!bound) return '';
+  const keys = new Set([bound.task_id, bound.id, bound.ref, bound.task_ref].filter(Boolean).map(String));
+  if (!keys.size) return '';
+  const roots = [root];
+  const common = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd: root, encoding: 'utf8' });
+  if (common.status === 0 && String(common.stdout || '').trim()) roots.push(path.dirname(String(common.stdout).trim()));
+  for (const dir of roots) {
+    const projection = readJson(path.join(dir, '.atris', 'state', 'tasks.projection.json'));
+    const tasks = Array.isArray(projection?.tasks) ? projection.tasks : [];
+    const task = tasks.find((row) => row && [row.id, row.display_id, row.legacy_ref].some((key) => key && keys.has(String(key))));
+    if (!task) continue;
+    const metadata = task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+    if (metadata.approval_status && metadata.approval_status !== 'revise') return '';
+    const events = (Array.isArray(task.events) ? task.events : []).filter((event) => event?.event_type === 'revision_requested');
+    const note = metadata.human_revision_note || events[events.length - 1]?.payload?.note || '';
+    return missionTasteSnippet(String(note), 600);
+  }
+  return '';
+}
+
 function missionTasteMemorySignals(text) {
   const definitions = [
     ['plain_language', 'the operator asks for plain English', /\b(plain|jargon|feynman|understand|simple|clarify|clarity)\b/i],
@@ -6509,9 +6551,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,
@@ -8930,6 +8979,16 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = [], cwd =
       checkFeedback,
     ]
     : [];
+  let turnDown = '';
+  try { turnDown = readBoundTaskTurnDown(mission, mission.worktree_root || mission.worktree?.path || cwd); } catch {}
+  const turnDownLines = turnDown
+    ? [
+      ``,
+      `## why the last try was turned down`,
+      `the reviewer sent this task back. fix this before anything else.`,
+      turnDown,
+    ]
+    : [];
   const preloadedContextLines = buildPreloadedMemberContextLines(mission, cwd);
   const lines = [
     `# Mission Tick ${tickIndex}/${maxTicks}`,
@@ -8945,6 +9004,7 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = [], cwd =
     `**Last tick:** ${mission.last_tick_at || 'never'}`,
     ...missionBudgetPromptLines(mission),
     ...checkFeedbackLines,
+    ...turnDownLines,
     ...(sharedProcess ? ['', sharedProcess] : []),
     ...preloadedContextLines,
     ``,
@@ -9181,11 +9241,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, {
@@ -9224,7 +9293,16 @@ function spawnGenericRunnerTick(mission, opts) {
     }
 
     const startedAt = Date.now();
-    const guardedCommand = `PATH=${shellQuote(gitGuard.pathPrefix)}:$PATH; export PATH; ${cmd}`;
+    const progressMember = mission.owner || 'mission';
+    // A codex run opens its shell script with the run marker as a no-op, so
+    // member stop can prove the shell leading this group is this run. Only
+    // names member stop accepts go into the shell line.
+    const runToken = lastMessageFile && /^[A-Za-z0-9._-]+$/.test(progressMember) ? newRunToken() : '';
+    const markerPrefix = runToken ? `: ${runMarker(progressMember, runToken)}; ` : '';
+    // The trailing exit keeps a shell like dash from replacing itself with
+    // codex, which would take the marker out of the process list.
+    const markerSuffix = runToken ? '; exit $?' : '';
+    const guardedCommand = `${markerPrefix}PATH=${shellQuote(gitGuard.pathPrefix)}:$PATH; export PATH; ${cmd}${markerSuffix}`;
     const proc = spawn('sh', ['-lc', guardedCommand], {
       cwd,
       stdio: ['ignore', 'pipe', 'pipe'],
@@ -9232,13 +9310,33 @@ function spawnGenericRunnerTick(mission, opts) {
       env: { ...gitGuard.env, ATRIS_DISPATCH_DEPTH: String(dispatchDepth.depth + 1) },
     });
     updateMissionLockOwner(missionLock, proc.pid, { phase: 'tick' });
+    const seenItemIds = new Set();
+    if (lastMessageFile) {
+      const tag = runToken ? { pid: proc.pid, engine: 'codex', run: runToken } : {};
+      appendProgress(progressMember, startedLine(mission.objective, tag), 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 +9352,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 +9471,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 +9498,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 +9650,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) {
@@ -9613,6 +9734,20 @@ function cappedClaudeReceiptText(text, limit = 4000) {
   return clean.slice(0, limit - 16).trimEnd() + '\n...[truncated]';
 }
 
+// The receipt keeps a capped copy of the runner's report. When the report is
+// longer than that, the whole text goes to its own file beside the receipts
+// so nothing the member wrote is lost.
+function saveFullRunnerReport(mission, text, root = process.cwd()) {
+  const clean = String(text || '').trim();
+  if (!clean || cappedClaudeReceiptText(clean) === clean) return null;
+  const runsDir = statePaths(root).runsDir;
+  fs.mkdirSync(runsDir, { recursive: true });
+  const safeTime = stampIso().replace(/[:.]/g, '-');
+  const reportPath = path.join(runsDir, `mission-${mission.id}-${safeTime}-report.md`);
+  fs.writeFileSync(reportPath, clean + '\n', 'utf8');
+  return path.relative(root, reportPath);
+}
+
 async function parseAndValidateMissionRunPhase(args) {
   const asJson = wantsJson(args);
   const context = {
@@ -10238,6 +10373,7 @@ async function executeMissionRunTicksPhase(context) {
           brief_id: claudeResult.brief_id || null,
           summary: claudeResult.summary,
           receipt_text: claudeResult.receipt_text,
+          report_path: saveFullRunnerReport(mission, claudeResult.result, cwd),
           stop_reason: claudeResult.stop_reason,
           api_equivalent_estimate: claudeResult.api_equivalent_estimate,
           duration_total_ms: claudeResult.duration_total_ms,
@@ -10704,12 +10840,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/commands/task.js

@@ -253,6 +253,7 @@ atris task - durable local task state (SQLite, gitignored)
   atris task archive <id> --reason "..." [--from-failed]
                                            Sweep off-roadmap/duplicate work as archived (not failed);
                                            --from-failed opts in to relabel a fail-closed row (never done)
+  atris task reopen <id> [--reason "..."]  Send a done, failed, or archived task back to open
   atris task clear-done [--before <days>] [--dry-run] [--json]  Archive completed rows, oldest first
   atris task prune-test-junk [--yes] [--vacuum] [--json]
                                            Count rows test runs left from temp folders; --yes backs up the db, then removes them
@@ -6243,6 +6244,27 @@ function cmdAdd(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const ws = taskDb.workspaceRoot();
+  // Filing a job that is already open or claimed hands back that job instead
+  // of making a copy. Work already handed in for review can be filed again.
+  const existing = taskDb.findUnfinishedTaskByTitle(db, { workspaceRoot: ws, title });
+  if (existing) {
+    const { projection, outPath } = writeDefaultProjection(taskDb, db);
+    const task = compactTaskFromProjection(projection, existing.id);
+    if (wantsJson(args)) {
+      printJson({
+        ok: true,
+        action: 'reused',
+        task_id: existing.id,
+        inserted: false,
+        operator_title_warning: null,
+        projection_path: outPath,
+        task,
+      });
+      return;
+    }
+    console.log(`${taskRef(task)}\t${existing.title}\t(already on the list, reused)`);
+    return;
+  }
   const operatorTitleWarning = warnIfTaskTitleNeedsOperatorWhy(title);
   // Generation throttle, the named root cause is generation > human-review rate. An AGENT cannot keep
   // minting tasks while a wall of certified-but-unaccepted work waits; that treadmill is what accept-group
@@ -9738,6 +9760,45 @@ function cmdArchive(args) {
   }
 }
 
+// Send a done, failed, or archived task back to open so it can be claimed
+// again. Review sign-offs are cleared; the old status and reason are kept.
+function cmdReopen(args) {
+  const pos = positional(args);
+  const id = pos[0];
+  if (!id) failTask('atris task reopen', 'missing_id', 'task id required');
+  const reason = textFlag(args, ['--reason']) || 'reopened';
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const taskId = requireTaskId(taskDb, db, id, 'atris task reopen');
+  const actor = String(flag(args, '--as') || DEFAULT_OWNER);
+  const result = taskDb.reopenTask(db, { id: taskId, actor, reason });
+  if (!result.reopened) {
+    const detail = `reopen failed: ${taskId} ${result.reason}`;
+    if (wantsJson(args)) {
+      printJson({ ok: false, command: 'atris task reopen', reason: result.reason, task_id: taskId, detail });
+      process.exit(1);
+    }
+    console.error(detail);
+    process.exit(1);
+  }
+  const reopenedFrom = result.row && result.row.metadata && result.row.metadata.reopened_from || null;
+  const { projection, outPath } = writeDefaultProjection(taskDb, db);
+  const task = compactTaskFromProjection(projection, taskId);
+  if (wantsJson(args)) {
+    printJson({
+      ok: true,
+      action: 'reopened',
+      task_id: taskId,
+      reopened_from: reopenedFrom,
+      reason,
+      projection_path: outPath,
+      task,
+    });
+    return;
+  }
+  console.log(`reopened ${taskRef(task)}${reopenedFrom ? ` (was ${reopenedFrom})` : ''}: ${reason}`);
+}
+
 function taskCompletionTime(row) {
   const doneAt = Number(row && row.done_at);
   if (Number.isFinite(doneAt) && doneAt > 0) return doneAt;
@@ -13475,6 +13536,7 @@ async function runTaskCommand(args) {
     case 'finish': return cmdFinish(rest);
     case 'fail':   return cmdDone([...rest, '--failed']);
     case 'archive': return cmdArchive(rest);
+    case 'reopen': return cmdReopen(rest);
     case 'clear-done': return cmdClearDone(rest);
     case 'prune-test-junk': return cmdPruneTestJunk(rest);
     case 'keep': return cmdKeep(rest);
@@ -13521,7 +13583,7 @@ const MUTATING_TASK_COMMANDS = new Set([
   'continue-work', 'continue', 'chat', 'note', 'say', 'retitle', 'tag', 'tags', 'step',
   'ready', 'result', 'accept', 'landing', 'land-review', 'auto-accept-certified',
   'auto-accept', 'sweep', 'audit', 'certify-verified', 'accept-group', 'revise',
-  'done', 'finish', 'fail', 'archive', 'clear-done', 'reap-mission-blockers', 'reap-blockers', 'relabel-archived', 'review', 'import',
+  'done', 'finish', 'fail', 'archive', 'reopen', 'clear-done', 'reap-mission-blockers', 'reap-blockers', 'relabel-archived', 'review', 'import',
   'setup', 'review-lane-act', 'review-act', 'act-review', 'review-lane-loop',
   'review-loop', 'loop-review', 'review-lane-run', 'review-run', 'run-review',
 ]);

package/commands/worktree.js

@@ -159,6 +159,26 @@ function branchName(member, task, now = new Date()) {
   return `codex/${slugify(member, 'member', 24)}-${slugify(task, 'task', 36)}-${stamp(now)}`;
 }
 
+// The newest earlier run of this same member+job, if its commits never reached
+// the base, so a retry continues that work instead of redoing it. Only the
+// newest run counts: once it landed or did nothing, anything older is stale.
+function lastRunBranch(root, owner, task, base, skip) {
+  const prefix = `codex/${slugify(owner, 'member', 24)}-${slugify(task, 'task', 36)}-`;
+  const listed = runGit(['for-each-ref', '--format=%(refname:short)', `refs/heads/${prefix}*`], { cwd: root, check: false });
+  if (listed.status !== 0) return null;
+  // Only exact runs of this job (stamp plus optional same-second number), so
+  // "fix-login" never matches "fix-login-page".
+  const runs = listed.stdout.split('\n').map((name) => name.trim())
+    .map((name) => ({ name, run: name.slice(prefix.length).match(/^(\d{8}-\d{6})(?:-(\d+))?$/) }))
+    .filter(({ name, run }) => run && name !== skip)
+    .sort((a, b) => b.run[1].localeCompare(a.run[1]) || Number(b.run[2] || 1) - Number(a.run[2] || 1));
+  if (!runs.length) return null;
+  const newest = runs[0].name;
+  const cherry = runGit(['cherry', base, newest], { cwd: root, check: false });
+  if (cherry.status !== 0) return null;
+  return cherry.stdout.split('\n').some((line) => line.startsWith('+')) ? newest : null;
+}
+
 function defaultWorktreePath(root, member, task, now = new Date()) {
   const name = `${slugify(member, 'member', 24)}-${slugify(task, 'task', 36)}-${stamp(now)}`;
   return path.join(path.dirname(root), '.agent-worktrees', path.basename(root), name);
@@ -529,8 +549,18 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
     reapedBeforeStart = cleaned.removed;
     cachePrunedBeforeStart = cleaned.cachePruned;
   } catch {}
-  const branch = branchOverride || branchName(owner, task, now);
-  const target = path.resolve(pathOverride || defaultWorktreePath(root, owner, task, now));
+  let branch = branchOverride || branchName(owner, task, now);
+  let target = path.resolve(pathOverride || defaultWorktreePath(root, owner, task, now));
+  // Two runs of the same job in the same second get the same name; number
+  // the later one instead of failing it.
+  if (!pathOverride && !branchOverride) {
+    const baseBranch = branch;
+    const baseTarget = target;
+    for (let n = 2; fs.existsSync(target) && n < 100; n += 1) {
+      branch = `${baseBranch}-${n}`;
+      target = `${baseTarget}-${n}`;
+    }
+  }
   // Agent/member worktrees always cut from the mainline: honoring the
   // launcher checkout's upstream let a dispatch inherit another session's
   // in-progress feature branch (2026-07-09: an auth fix arrived carrying 13
@@ -540,9 +570,15 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
   if (fs.existsSync(target)) throw new Error(`worktree path already exists: ${target}`);
   fs.mkdirSync(path.dirname(target), { recursive: true });
   const staleBase = refreshRemoteRef(root, checkoutBase);
+  // A retry of the same job starts from the last run's unlanded commits; it
+  // still ships to the mainline.
+  const resumedFrom = (!pathOverride && !branchOverride)
+    ? lastRunBranch(root, owner, task, checkoutBase, branch)
+    : null;
+  const startPoint = resumedFrom || checkoutBase;
   const ref = `refs/heads/${branch}`;
   const existed = runGit(['show-ref', '--verify', '--quiet', ref], { cwd: root, check: false }).status !== 1;
-  const baseCommit = runGit(['rev-parse', '--verify', `${checkoutBase}^{commit}`], { cwd: root, check: false });
+  const baseCommit = runGit(['rev-parse', '--verify', `${startPoint}^{commit}`], { cwd: root, check: false });
   const startCommit = baseCommit.status === 0 ? baseCommit.stdout.trim() : '';
   // With no local copy the start fails on its own; only a real cut gets the warning.
   if (staleBase && startCommit) {
@@ -562,7 +598,7 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
     if (!fs.existsSync(target)) runGit(['update-ref', '-d', ref, startCommit], { cwd: root });
   };
   for (let attempt = 0; attempt < 3; attempt += 1) {
-    const added = runGit(['worktree', 'add', '-b', branch, target, checkoutBase], { cwd: root, check: false });
+    const added = runGit(['worktree', 'add', '-b', branch, target, startPoint], { cwd: root, check: false });
     if (added.status === 0) break;
     // Git can create the branch before failing to write its tracking config.
     // Drop only that untouched ref, never an existing branch or a checkout.
@@ -587,6 +623,7 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
         branch,
         base: shipBase,
         checkout_base: checkoutBase,
+        resumed_from: resumedFrom,
         workspace_root: root,
         created_at: now.toISOString(),
       }, null, 2) + '\n',
@@ -596,7 +633,7 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
     discardFailedStart();
     throw error;
   }
-  return { path: target, branch, base: shipBase, checkoutBase, owner, reapedBeforeStart, cachePrunedBeforeStart };
+  return { path: target, branch, base: shipBase, checkoutBase, resumedFrom, owner, reapedBeforeStart, cachePrunedBeforeStart };
 }
 
 function startWorktree(args) {

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-ask.js

@@ -415,6 +415,7 @@ function runAskProcess(invocation, {
   killProcess = process.kill.bind(process),
   signal = null,
   onOutputChunk = null,
+  env = null,
 } = {}) {
   return new Promise((resolve) => {
     const startedAt = Date.now();
@@ -502,7 +503,7 @@ function runAskProcess(invocation, {
     try {
       child = spawnProcess(invocation.bin, invocation.args, {
         cwd,
-        env: buildAskSpawnEnv(),
+        env: buildAskSpawnEnv(env || invocation.env || process.env),
         detached: process.platform !== 'win32',
         stdio: ['ignore', 'pipe', 'pipe'],
       });

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',