atris 3.69.0 → 3.70.0

package/README.md

@@ -151,7 +151,28 @@ atris member board --watch
 tail -f ~/.atris/progress/executor.log
 ```
 
-The older words still work as aliases: `dispatch` and `go` do what run does, and `up` does what wake does. Run with a job, wake with a number or names, and `up` need the release after 3.68.9.
+When a member finishes, ask for its result: what it changed, its receipt, and one number. Each member's copy of the repo stays until its work lands, then tidy puts it away.
+
+```bash
+atris member result executor
+atris member tidy --dry-run
+```
+
+The older words still work as aliases: `dispatch` and `go` do what run does, and `up` does what wake does.
+
+### How member work gets checked and lands
+
+Every member job ends with its own check, a command that must pass. Then a second engine reviews the change, and it is never the engine that did the work.
+
+Work lands on its own only after you switch self-landing on, once. From then on Atris pushes the branch, opens a pull request, and turns on GitHub auto-merge, so GitHub merges it when the branch is up to date and CI passes.
+
+```bash
+atris autoland on
+```
+
+Anything else keeps the work on its branch, with one plain line saying why. That covers a failed check or review, unsaved changes, a clash with the main branch, and work that touches a protected area like payments, deploys, or credentials.
+
+A job that fails three times in a row stops and waits for a person.
 
 ## Chat With Atris 2
 

package/commands/member.js

@@ -51,8 +51,7 @@ function ensureMemberLog(memberDir, { name, role, description, source = 'cli' }
     description ? `- mission: ${description}` : '',
     `- source: ${source}`,
     '- status: ready_for_room',
-    '',
-  ].filter(Boolean).join('\n');
+  ].filter(Boolean).join('\n') + '\n';
   fs.writeFileSync(logPath, content, 'utf8');
   return logPath;
 }
@@ -915,6 +914,17 @@ function memberRunBudgetSeconds(args = []) {
   return null;
 }
 
+// A job with no time given gets 15 minutes, or the roster's limit for this
+// member's engine plus ten minutes for the review, whichever is longer.
+function memberRunDefaultWallSeconds(name, cwd = process.cwd()) {
+  let cap = 0;
+  try {
+    const picked = require('../lib/member-engine').memberRosterEngine(name, cwd);
+    cap = Number(picked && picked.engine && picked.engine.roster_max_seconds) || 0;
+  } catch {}
+  return Math.max(900, cap ? cap + 600 : 0);
+}
+
 function pushFlagValue(out, args, name) {
   const value = readFlag(args, name, '');
   if (value) out.push(name, String(value));
@@ -1040,7 +1050,7 @@ function memberRunCli(args, cwd, { live = false, missionId = '' } = {}) {
       : null;
     const receipt = receiptName ? readJson(path.join(runsDir, receiptName), null) : null;
     return { status: result.status, payload: receipt?.result?.kind === 'mission_run_summary'
-      ? { ran_ticks: receipt.result.ran_ticks } : null, stderr: '', errorReported: result.status !== 0 };
+      ? { ran_ticks: receipt.result.ran_ticks, ticks: receipt.result.ticks } : null, stderr: '', errorReported: result.status !== 0 };
   }
   let payload = null;
   try {
@@ -1235,6 +1245,15 @@ function memberRun(name, ...args) {
   return memberRunWith(name, args);
 }
 
+// One plain line for why the reviewing engine refused the work.
+function reviewRefusalLine(refusal) {
+  if (refusal.timed_out) return 'the reviewer ran out of time';
+  const text = String(refusal.output || refusal.reason || '');
+  const verdict = text.match(/VERDICT:\s*FAIL\s*[;:]\s*(.+)/i);
+  const line = verdict ? verdict[1] : (text.split(/\r?\n/).find((l) => l.trim()) || refusal.reason || 'no reason given');
+  return line.trim().slice(0, 200);
+}
+
 function memberRunWith(name, args, { quiet = false } = {}) {
   if (!name || name === '--help' || name === '-h' || hasFlag(args, '--help') || hasFlag(args, '-h')) {
     console.log('usage: atris member run <name> ["mission text"] [--verify "<cmd>"] [--minutes N|--hours N] [--json]');
@@ -1338,7 +1357,7 @@ function memberRunWith(name, args, { quiet = false } = {}) {
   if (!readFlag(runArgs, '--max-ticks', '')) {
     runArgs.push('--max-ticks', budgetSeconds ? String(Math.max(4, Math.ceil(budgetSeconds / 300))) : '1');
   }
-  if (!readFlag(runArgs, '--max-wall', '')) runArgs.push('--max-wall', String(budgetSeconds || 900));
+  if (!readFlag(runArgs, '--max-wall', '')) runArgs.push('--max-wall', String(budgetSeconds || memberRunDefaultWallSeconds(name, cwd)));
   const caller = callerRuntime(args);
   const runnerSwap = memberRunRunnerSwap(mission, args, caller);
   if (runnerSwap) runArgs.push('--engine', runnerSwap.to);
@@ -1351,7 +1370,12 @@ function memberRunWith(name, args, { quiet = false } = {}) {
   const waitingOnNativeGoal = caller === 'codex' && payload.requires_native_goal_start === true
     && memberRunUsesCallerSession(finalMission.runner);
   const noWorkStepExpected = hasFlag(runArgs, '--detach') || hasFlag(runArgs, '--dry-run');
-  const ok = (run.status === 0 && payload.ok !== false && (started || noWorkStepExpected)) || waitingOnNativeGoal;
+  // The work ran but its check failed: the run failed, even though a work
+  // step happened. Scripts and the caller read this from the exit code.
+  const lastRanTick = [...(Array.isArray(payload.ticks) ? payload.ticks : [])].reverse().find((tick) => tick && tick.ran === true);
+  const checkFailed = started && Boolean(String(finalMission.verifier || '').trim())
+    && lastRanTick?.verifier_passed === false && finalMission.status !== 'complete';
+  const ok = ((run.status === 0 && payload.ok !== false && (started || noWorkStepExpected)) || waitingOnNativeGoal) && !checkFailed;
   const reviewAsk = memberRunReviewAsk(name, payload, finalMission, cwd);
   const result = { ...payload, ok, started, state: finalMission.status, mission_id: mission.id,
     mission: finalMission, node_modules_linked: nodeModulesLinked, node_modules_source: nodeModulesSource,
@@ -1385,7 +1409,13 @@ function memberRunWith(name, args, { quiet = false } = {}) {
     result.autoland = require('../lib/member-autoland').autolandMemberRun({ mission: finalMission, cwd, summary, workerEngine });
     if (!asJson && !quiet) console.log(result.autoland.line);
   }
-  if (!ok) {
+  if (checkFailed) {
+    result.check_failed = true;
+    const refusal = lastRanTick?.referee_result?.passed === false ? lastRanTick.referee_result : null;
+    result.error = refusal
+      ? `turned down in review: ${reviewRefusalLine(refusal)}`
+      : `the work ran but its check failed: ${finalMission.verifier || 'completion check'}`;
+  } else if (!ok) {
     result.error = result.ask || payload.detail || payload.error || payload.reason || payload.next_action
       || run.stderr || 'mission did not run a work step';
   }
@@ -4256,7 +4286,10 @@ function parseFrontmatter(content) {
       } else if (val.startsWith('[') && val.endsWith(']')) {
         result[currentKey] = val.slice(1, -1).split(',').map(s => s.trim().replace(/^["']|["']$/g, ''));
       } else {
-        result[currentKey] = val.replace(/^["']|["']$/g, '');
+        // Unwrap only a matching outer pair: `verify: node -e "process.exit(0)"`
+        // must keep its closing quote or the check is a shell syntax error.
+        const quoted = val.match(/^(["'])([\s\S]*)\1$/);
+        result[currentKey] = quoted ? quoted[2] : val;
       }
     }
   }
@@ -10463,12 +10496,43 @@ function memberGoFinishTask(owner, task, result, thrown = null) {
     const ready = taskDb.readyTask(db, { id: task.id, actor: owner, proof });
     if (ready.ready !== false) return { id: task.id, title: task.title, outcome: 'review', receipt: receipt || null };
   }
+  const ticks = Array.isArray(result && result.ticks) ? result.ticks : [];
+  const lastReason = String((ticks[ticks.length - 1] || {}).reason || (ticks[ticks.length - 1] || {}).error || '');
+  const outOfTime = /timeout|wall-exceeded/.test(lastReason);
   const why = thrown ? thrown.message
+    : outOfTime ? 'ran out of time before the work finished'
     : (result && result.error) || (result && result.started ? 'the check did not pass' : 'the run did not start');
   const reason = String(why || 'the run did not finish').split(/\r?\n/)[0].trim().slice(0, 200);
   try { taskDb.noteTask(db, { id: task.id, actor: owner, content: `Released by ${owner}: ${reason}` }); } catch {}
+  // Third failure in a row: hold the task for a person instead of letting
+  // members pick it up again forever.
+  let held = false;
+  if (memberGoFailStreak(taskDb, db, task.id) >= MEMBER_GO_STRIKES) {
+    try {
+      held = taskDb.tagTask(db, { id: task.id, actor: owner, add: ['needs-human'] }).tagged === true;
+      if (held) taskDb.noteTask(db, { id: task.id, actor: owner,
+        content: `Held for a person: failed ${MEMBER_GO_STRIKES} times in a row. Last reason: ${reason}` });
+    } catch {}
+  }
   const released = taskDb.releaseTask(db, { id: task.id, actor: owner });
-  return { id: task.id, title: task.title, outcome: released.released ? 'released' : 'left_claimed', reason };
+  const outcome = released.released ? (held ? 'needs_human' : 'released') : 'left_claimed';
+  return { id: task.id, title: task.title, outcome, reason };
+}
+
+const MEMBER_GO_STRIKES = 3;
+
+// Failed runs on a task since its last pass, review, reopen, or a person
+// clearing its hold.
+function memberGoFailStreak(taskDb, db, taskId) {
+  let streak = 0;
+  for (const event of taskDb.listTaskEvents(db, { taskId })) {
+    const type = event.event_type;
+    const payload = event.payload || {};
+    if (type === 'message' && /^Released by \S+: /.test(String(payload.content || ''))) streak += 1;
+    else if (['proof_ready', 'reviewed', 'reopened'].includes(type)) streak = 0;
+    else if (type === 'task_tags_updated' && (payload.removed || []).includes('needs-human')) streak = 0;
+  }
+  return streak;
 }
 
 async function memberSteerOrDispatch(...rawArgs) {
@@ -10651,6 +10715,7 @@ async function memberSteerOrDispatchWith({ pullTask = false } = {}, rawArgs = []
     ? { task, work_step: { summary: result?.work_step?.summary || null }, error: result?.error || null }
     : merged));
   else if (task.outcome === 'review') console.log(`Task "${task.title}" is ready for review.`);
+  else if (task.outcome === 'needs_human') console.log(`Task "${task.title}" failed three times in a row and now waits for a person: ${task.reason}`);
   else console.log(`Task "${task.title}" went back on the list: ${task.reason}`);
   return merged;
 }
@@ -11239,7 +11304,7 @@ async function memberCommand(subcommand, ...args) {
   const HELP_AWARE_SUBCOMMANDS = new Set([
     'create', 'new', 'run', 'install', 'result', 'dispatch', 'route', 'feed', 'stream',
     'card', 'cards', 'go', 'work', 'up', 'steer', 'sleep', 'rest', '1on1', 'interview',
-    'room', 'ui', 'day', 'standup', 'handoff', 'handoffs',
+    'room', 'ui', 'day', 'standup', 'handoff', 'handoffs', 'report',
   ]);
   const explicitHelp = subcommand === 'help' || subcommand === '--help' || subcommand === '-h'
     || (!HELP_AWARE_SUBCOMMANDS.has(subcommand) && (args[0] === '-h' || args[0] === '--help'));
@@ -11345,6 +11410,8 @@ async function memberCommand(subcommand, ...args) {
       return memberHeartbeat(args[0], ...args.slice(1));
     case 'improvements':
       return memberImprovements(args[0], ...args.slice(1));
+    case 'report':
+      return require('../lib/member-report').memberReportCommand(...args);
     case 'history':
       return memberHistory(args[0], ...args.slice(1));
     case 'supervisor':
@@ -11406,6 +11473,7 @@ async function memberCommand(subcommand, ...args) {
       console.log('  wake <name>         Decide tick/wait/ask/stop, then run one bounded work step on the roster engine (--plan to only decide; --keep keeps it working)');
       console.log('  run "<job>"         Pick the best member for the job and run it (same as dispatch "<job>" --ignite)');
       console.log('  run <name> ["..."]  Start a budgeted member mission, or run its active Mission Runtime');
+      console.log('  report [--since 2h] Short summary per member: merged, finished, turned down, done but not merged yet [--json]');
       console.log('  result <name>       Newest run result: run record, receipt, artifacts, number [--since <iso>] [--json]');
       console.log('  dispatch "<idea>"   Route an idea to the best specialist member and start work');
       console.log('  up [--max N] [--only a,b]  Keep the team working: start free members on fitting tasks every minute (wake 5 / wake a b)');
@@ -11469,6 +11537,7 @@ async function memberCommand(subcommand, ...args) {
 }
 
 module.exports = {
+  memberRunDefaultWallSeconds,
   memberRunWantsReferee,
   proposalPromptForGoal,
   memberGoFinishTask,

package/commands/mission.js

@@ -434,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
@@ -1723,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;
 }
 
@@ -3910,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],
@@ -8938,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}`,
@@ -8953,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,
     ``,
@@ -9241,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'],
@@ -9249,9 +9310,11 @@ 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);
+    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 = '';
@@ -9671,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 = {
@@ -10296,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,

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/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'],
       });