elanous 0.2.23 → 0.2.25

package/src/task-agent/rejudge-on-head.ts

@@ -12,7 +12,17 @@
  *   ③ land: 재게이트 통과 ⊕ 회수한 리뷰가 지금 머리의 pass «또는» warn ⊕ reviewed ⊕ must-fix 0(TA-LAND-WARN-MUSTFIX0)이면 겹침 증거 파일
  *      (`<state>/overlap-evidence/<card>-<pr>-<head12>.json` = {pr, head, gate:{head, baseCommit, passed}, reviewResult} · #26023 꼴)을
  *      쓰고 `executeLiveLand` 를 «다시 부른다»(판정 로직 무변경 · 증거를 완전히 못 갖추면 land 하지 않는다 — fail-closed).
- * - 상한: 같은 머리는 재게이트·리뷰 각 한 번 · 카드·PR 당 재게이트한 머리 `REJUDGE_HEAD_CAP` 개까지 — 넘으면 사유 줄을 남기고 멈춘다.
+ *      LAND-ORDER-LEDGER — executeLiveLand 직후 겹침 쌍·착지 순서 원장(`land-order-ledger.ts` · `<state>/land-order-ledger.jsonl`)에
+ *      한 줄을 붙인다(같은 pr+head 한 줄 · 쓰기 실패는 삼킨다 — land 결과 무변 · 관측 `task-agent.land-order` appended|append-failed).
+ * - 상한: 같은 머리는 재게이트·리뷰 각 한 번 · 카드·PR 당 재게이트 `REJUDGE_HEAD_CAP` 번까지 — 넘으면 사유 줄을 남기고 멈춘다.
+ * - REJUDGE base-stale(OVERLAP-EVIDENCE-BASE-WINDOW 짝 · #26060): land 가 `base-stale-overlap`(재게이트 base 뒤 착지가 PR 파일을 건드렸다)으로
+ *   거절되면 그 시도는 `base-stale` 갈래로 적히고(judgement 1회 규칙과 섞이지 않는다), 다음 틱이 «같은 머리»를 새 base 위에서 한 번 더
+ *   재게이트한다(`staleBase` = 낡은 base · 멱등 키 = 머리 ⊕ staleBase · 상한에 포함). 그 재게이트가 통과하고 base 가 실제로 바뀌었을 때만
+ *   새 baseCommit 으로 증거를 다시 써 land 한다(`gateAt` 으로 앞 base-stale 시도를 소비) — 관측 `rejudge-on-head {step:'regate', reason:'base-stale-overlap …'}`.
+ * - TA-REJUDGE-REBASE-LOOP: 그 1회가 «같은 base» 로 돌아오거나 stale 재게이트에 `baseCommit` 이 없으면 needs-owner 로 멈추지 않는다. origin/main 을
+ *   fetch 한 뒤 PR 가지에 3-way merge(rerere 켬 · ⛔ rebase/force-push/reset/파일째 checkout) 하고 일반 push 로 새 머리를 만든 다음, 그 머리는 기존
+ *   ①②③ 사슬을 탄다. 머리마다 1회 · 카드당 `CATCH_UP_CAP`(기본 2)회. 충돌이면 `merge --abort` ⊕ needs-owner(`main 따라잡기 충돌 · 파일 …`).
+ *   관측 `rejudge-on-head {step:'catch-up', decision: pushed|conflict|cap-reached, fromBase, toBase, newHead}`.
  * - 대상: 카드에 묶인 PR(URL 로 저장소 확인) ⊕ 그 PR 로 TA 가 이미 리뷰를 요청한 카드(= 런이 멈춰 TA 판단이 시작됐다).
  * - 사람의 hold(draft PR)는 뒤집지 않는다 — 재게이트(`noMerge`)와 land 관문이 draft 를 거부한다.
  * - 허용: 설정 `taskAgent.liveMoves` 그대로 — 재게이트·land 는 `propose-land`, 리뷰 재요청은 `review` 가 있을 때만(없으면 «했을 수»).
@@ -20,38 +30,67 @@
  *   한 줄(`event:'rejudge-on-head'` · 같은 머리·같은 단계·같은 판단은 한 번).
  */
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { debug } from '../debug/log.js';
 import type { DetachedSpawn } from '../cli/tasks-cli.js';
+import { appendLandOrderRow, joinLandOrderRow } from './land-order-ledger.js';
 import { recordLiveMoveHistory } from './live-move-history.js';
-import { defaultPrHead, defaultReviewRepoCandidates, executeLiveLand, executeLiveReview, type LiveMoveDeps, type LiveMoveResult, type PrHeadView, type ReviewRepoCandidate, type TaskAgentLiveMove } from './live-moves.js';
-import { capturedLandReview, captureReviewResults, pendingReviewResults } from './review-result-capture.js';
+import { defaultPrHead, defaultReviewRepoCandidates, executeLiveLand, executeLiveReview, landRetryPending, type LiveMoveDeps, type LiveMoveResult, type PrHeadView, type ReviewRepoCandidate, type TaskAgentLiveMove } from './live-moves.js';
+import { capturedLandReview, captureReviewResults, parseReviewResultOutput, pendingReviewResults, type ParsedReviewResult } from './review-result-capture.js';
 import { cardPrNumber, readTaskCard, taskAgentStatePath, updateTaskCard, type TaskCard } from './task-hand.js';
 
 export const REJUDGE_ON_HEAD_EVENT = 'rejudge-on-head';
 /** 카드·PR 당 재게이트하는 머리 수 상한(머리가 바뀔 때마다 하나) — 넘으면 멈추고 사람에게 넘긴다. */
 export const REJUDGE_HEAD_CAP = 3;
+/** 카드당 origin/main 따라잡기(merge⊕push) 상한 — 넘으면 멈추고 사람에게 넘긴다. 머리마다 1회. */
+export const CATCH_UP_CAP = 2;
 /** 떼어 띄운 재게이트 결과를 기다리는 상한 — 지나도 파일이 없으면 «결과 없음»으로 적는다(같은 머리는 다시 안 돌린다). */
 export const REGATE_RESULT_WAIT_MS = 90 * 60_000;
 
-export type RejudgeStep = 'regate' | 'review' | 'land' | 'target';
-export interface RejudgeOutcome { card: string; pr: number | null; fromHead: string | null; toHead: string | null; step: RejudgeStep; decision: string; reason: string }
+export type RejudgeStep = 'regate' | 'review' | 'land' | 'target' | 'catch-up';
+export type CatchUpDecision = 'pushed' | 'conflict' | 'cap-reached' | 'failed';
+export interface RejudgeOutcome {
+  card: string; pr: number | null; fromHead: string | null; toHead: string | null; step: RejudgeStep; decision: string; reason: string;
+  fromBase?: string; toBase?: string; newHead?: string;
+}
 
 export interface RegateRequest { card: string; pr: number; head: string; repoRoot: string; resultPath: string }
+export interface CatchUpRequest { cwd: string; pr: number; head: string; branch?: string; fromBase?: string; worktreePath?: string }
+export interface CatchUpResult {
+  decision: Exclude<CatchUpDecision, 'cap-reached'>;
+  reason: string;
+  fromBase?: string;
+  toBase?: string;
+  newHead?: string;
+  files?: string[];
+  pushArgs?: string[];
+}
+export type CatchUpGit = (cwd: string, args: string[]) => { status: number | null; stdout: string; stderr: string };
 export interface RejudgeDeps {
   live?: LiveMoveDeps;
   liveMoves: ReadonlySet<TaskAgentLiveMove>;
   /** 재게이트를 떼어 띄운다 — 시험은 주입한다. 기본은 `tasks regate-run` 자식(stdio ignore · 결과는 파일). */
   requestRegate?: (request: RegateRequest) => Promise<void>;
+  /** TA-REJUDGE-REBASE-LOOP — origin/main 을 PR 가지에 3-way merge 하고 일반 push. 시험은 주입한다. */
+  catchUpMain?: (request: CatchUpRequest) => Promise<CatchUpResult>;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
   /** 시험 seam — 결과 파일 읽기(없으면 ENOENT). */
   readFile?: (path: string) => string;
 }
 
 const safe = (value: string) => value.replace(/[^A-Za-z0-9._-]/g, '_');
-export function regateResultPath(statePath: string, cardId: string, pr: number, head: string): string {
-  return join(dirname(statePath), 'regate-results', `${safe(cardId)}-${pr}-${safe(head.slice(0, 12))}.json`);
+export function regateResultPath(statePath: string, cardId: string, pr: number, head: string, staleBase?: string): string {
+  const suffix = staleBase ? `-from-${safe(staleBase.slice(0, 12))}` : '';
+  return join(dirname(statePath), 'regate-results', `${safe(cardId)}-${pr}-${safe(head.slice(0, 12))}${suffix}.json`);
+}
+
+/** REJUDGE base-stale — 이 재게이트(요청 시각 `since`) «뒤»에 같은 머리 land 가 base-stale 로 거절된 마지막 시도. */
+export function baseStaleAttemptAfter(card: Pick<TaskCard, 'landAttempts'>, pr: number, head: string, since: string): NonNullable<TaskCard['landAttempts']>[number] | undefined {
+  const from = Date.parse(since);
+  return (card.landAttempts ?? []).filter((entry) => entry.pr === pr && entry.head.toLowerCase() === head.toLowerCase() && entry.ok === false
+    && entry.class === 'base-stale' && Number.isFinite(from) && Date.parse(entry.at) >= from).at(-1);
 }
 export function overlapEvidencePath(statePath: string, cardId: string, pr: number, head: string): string {
   return join(dirname(statePath), 'overlap-evidence', `${safe(cardId)}-${pr}-${safe(head.slice(0, 12))}.json`);
@@ -89,6 +128,83 @@ export function parseRegateResult(text: string, pr: number, head: string): Regat
 const sameUrl = (a: string, b: string) => a.trim().replace(/\/+$/, '').toLowerCase() === b.trim().replace(/\/+$/, '').toLowerCase();
 const sameHead = (a: string, b: string) => a.toLowerCase() === b.toLowerCase();
 
+const defaultCatchUpGit: CatchUpGit = (cwd, args) => {
+  const r = spawnSync('git', args, { cwd, encoding: 'utf8', timeout: 120_000 });
+  return { status: r.status, stdout: String(r.stdout ?? ''), stderr: String(r.stderr ?? '') };
+};
+
+export function catchUpWorktreePath(statePath: string, cardId: string, pr: number, head: string): string {
+  return join(dirname(statePath), 'catch-up-worktrees', `${safe(cardId)}-${pr}-${safe(head.slice(0, 12))}`);
+}
+
+const gitSha = (text: string): string | null => {
+  const value = text.trim();
+  return /^[0-9a-f]{40}$/i.test(value) ? value : null;
+};
+
+const catchUpFail = (reason: string, extra: Partial<CatchUpResult> = {}): CatchUpResult => ({ decision: 'failed', reason, ...extra });
+
+/**
+ * origin/main 을 PR 머리에 3-way merge(rerere 켬) 하고 일반 push 한다.
+ * ⛔ rebase · force-push · reset · 남의 가지 파일째 checkout — 충돌이면 merge --abort.
+ */
+export async function defaultCatchUpMain(request: CatchUpRequest, git: CatchUpGit = defaultCatchUpGit): Promise<CatchUpResult> {
+  const repo = request.cwd;
+  const work = request.worktreePath ?? join(tmpdir(), `ta-catch-up-${request.pr}-${safe(request.head.slice(0, 12))}-${process.pid}`);
+  const gitRepo = (args: string[]) => git(repo, args);
+  const gitWork = (args: string[]) => git(work, args);
+  const fromBase = request.fromBase;
+  if (!request.branch) return catchUpFail('PR head branch name unknown', { fromBase });
+
+  const fetchMain = gitRepo(['fetch', 'origin', 'refs/heads/main']);
+  if (fetchMain.status !== 0) return catchUpFail(`origin/main fetch failed: ${(fetchMain.stderr || fetchMain.stdout).trim().slice(-200)}`, { fromBase });
+  const toBase = gitSha(gitRepo(['rev-parse', 'FETCH_HEAD']).stdout);
+  if (!toBase) return catchUpFail('origin/main sha unreadable', { fromBase });
+
+  const fetchPr = gitRepo(['fetch', 'origin', `pull/${request.pr}/head`]);
+  if (fetchPr.status !== 0) return catchUpFail(`fetch pull/${request.pr}/head failed: ${(fetchPr.stderr || fetchPr.stdout).trim().slice(-200)}`, { fromBase, toBase });
+  const fetchedHead = gitSha(gitRepo(['rev-parse', 'FETCH_HEAD']).stdout);
+  if (!fetchedHead || !sameHead(fetchedHead, request.head)) {
+    return catchUpFail(`fetched PR head ${(fetchedHead ?? '?').slice(0, 12)} ≠ ${request.head.slice(0, 12)}`, { fromBase, toBase });
+  }
+
+  const added = gitRepo(['worktree', 'add', '--detach', work, request.head]);
+  if (added.status !== 0) return catchUpFail(`worktree add failed: ${(added.stderr || added.stdout).trim().slice(-200)}`, { fromBase, toBase });
+  const cleanup = () => { gitRepo(['worktree', 'remove', '--force', work]); };
+
+  gitWork(['config', 'rerere.enabled', 'true']);
+  const merge = gitWork(['merge', '--no-ff', toBase, '-m', `catch-up: merge origin/main into PR #${request.pr}`]);
+  if (merge.status !== 0) {
+    const files = gitWork(['diff', '--name-only', '--diff-filter=U']).stdout.split('\n').map((line) => line.trim()).filter(Boolean);
+    gitWork(['merge', '--abort']);
+    cleanup();
+    return {
+      decision: 'conflict',
+      reason: `main 따라잡기 충돌 · 파일 ${files.join(', ') || '(unknown)'}`,
+      fromBase, toBase, files,
+    };
+  }
+  const newHead = gitSha(gitWork(['rev-parse', 'HEAD']).stdout);
+  if (!newHead) { cleanup(); return catchUpFail('merge produced no head sha', { fromBase, toBase }); }
+  const pushArgs = ['push', 'origin', `HEAD:${request.branch}`];
+  const push = gitWork(pushArgs);
+  cleanup();
+  if (push.status !== 0) return catchUpFail(`push failed: ${(push.stderr || push.stdout).trim().slice(-200)}`, { fromBase, toBase, newHead, pushArgs });
+  return {
+    decision: 'pushed',
+    reason: `merged origin/main ${toBase.slice(0, 12)} → head ${newHead.slice(0, 12)}`,
+    fromBase, toBase, newHead, pushArgs,
+  };
+}
+
+/** 실제로 «시도한» 따라잡기 기록(pushed·conflict·failed) — `cap-reached`·`would-catch-up` 표지는 시도가 아니다. */
+const CATCH_UP_ATTEMPT_EFFECTS: ReadonlySet<string> = new Set(['pushed', 'conflict', 'failed']);
+
+function catchUpHistory(card: Pick<TaskCard, 'history'>, pr: number) {
+  return (card.history ?? []).filter((item) => item.event === REJUDGE_ON_HEAD_EVENT && item.kind === 'catch-up' && item.pr === pr
+    && typeof item.effect === 'string' && CATCH_UP_ATTEMPT_EFFECTS.has(item.effect));
+}
+
 /** 카드의 PR URL 과 같은 PR 을 돌려주는 후보 저장소 — 못 찾으면 이유. */
 async function resolveCardPr(card: TaskCard, pr: number, url: string, deps: LiveMoveDeps): Promise<{ cwd: string; view: PrHeadView } | { reason: string }> {
   let candidates: readonly ReviewRepoCandidate[];
@@ -180,50 +296,106 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
   const { cwd, view } = found;
   const toHead = view.head;
   if (view.state !== 'OPEN') return target('pr-not-open', `PR #${pr} is ${view.state}`, pr, fromHead, toHead);
-  const step = (s: RejudgeStep, decision: string, reason: string, record: boolean) => emit({ card: card!.id, pr, fromHead, toHead, step: s, decision, reason }, record);
+  const step = (s: RejudgeStep, decision: string, reason: string, record: boolean, extra: Partial<RejudgeOutcome> = {}) =>
+    emit({ card: card!.id, pr, fromHead, toHead, step: s, decision, reason, ...extra }, record);
+
+  const tryCatchUp = async (fromBase: string | undefined, why: string): Promise<boolean> => {
+    const prior = catchUpHistory(card!, pr);
+    // 상한은 «실제 push» 만 센다 — 충돌·실패 뒤 사람이 새 머리를 올리면 다시 시도할 수 있어야 한다.
+    const pushed = prior.filter((item) => item.effect === 'pushed').length;
+    if (pushed >= CATCH_UP_CAP) {
+      step('catch-up', 'cap-reached', `${why} · catch-up pushed ${pushed} times already (cap ${CATCH_UP_CAP}) — needs owner`, true, { fromBase });
+      return true;
+    }
+    if (prior.some((item) => item.head && sameHead(item.head, toHead))) {
+      step('catch-up', 'cap-reached', `${why} · already catch-up on this head — needs owner`, true, { fromBase });
+      return true;
+    }
+    if (!deps.liveMoves.has('propose-land')) {
+      step('catch-up', 'would-catch-up', `${why} · propose-land not enabled in taskAgent.liveMoves — shadow`, false, { fromBase });
+      return true;
+    }
+    let result: CatchUpResult;
+    try {
+      result = await (deps.catchUpMain ?? defaultCatchUpMain)({
+        cwd, pr, head: toHead, branch: view.branch, fromBase,
+        worktreePath: catchUpWorktreePath(statePath, card!.id, pr, toHead),
+      });
+    } catch (error) {
+      result = { decision: 'failed', reason: `catch-up threw: ${(error instanceof Error ? error.message : String(error)).slice(-200)}`, fromBase };
+    }
+    const extra: Partial<RejudgeOutcome> = {
+      ...(result.fromBase ? { fromBase: result.fromBase } : fromBase ? { fromBase } : {}),
+      ...(result.toBase ? { toBase: result.toBase } : {}),
+      ...(result.newHead ? { newHead: result.newHead } : {}),
+    };
+    if (result.decision === 'pushed') {
+      step('catch-up', 'pushed', result.reason, true, extra);
+      return true;
+    }
+    if (result.decision === 'conflict') {
+      step('catch-up', 'conflict', result.reason, true, extra);
+      return true;
+    }
+    step('catch-up', result.decision, `${why} · ${result.reason} — needs owner`, true, extra);
+    return true;
+  };
 
   // 머리가 런 멈춤 때 그대로면 재판정하지 않는다 — 그 머리의 재게이트·리뷰·land 판단은 멈춤 때의 판단(슈퍼바이저 틱)이 이미 했다.
-  if (!regates.length && judgedHead && sameHead(toHead, judgedHead)) return target('head-unchanged', `PR #${pr} head is still the judged head`, pr, fromHead, toHead);
+  //   TA-LAND-RETRY-ON-INFRA — 단, 그 머리의 land 가 TA 쪽 인프라 결손으로 실패해 재시도가 남았으면 아래 ①②③ 을 그대로 탄다
+  //   (재게이트·회수한 리뷰·겹침 증거를 다시 갖춘 뒤에만 land — 관문은 그대로).
+  if (!regates.length && judgedHead && sameHead(toHead, judgedHead) && !landRetryPending(card, pr, toHead)) return target('head-unchanged', `PR #${pr} head is still the judged head`, pr, fromHead, toHead);
 
-  // ① 재게이트 — 지금 머리의 기록.
-  const regate = regates.find((entry) => sameHead(entry.head, toHead));
-  if (!regate) {
+  // ① 재게이트 — 지금 머리의 «마지막» 기록(REJUDGE base-stale 로 같은 머리를 다시 잰 기록이 뒤에 붙는다).
+  const regate = regates.filter((entry) => sameHead(entry.head, toHead)).at(-1);
+  // REJUDGE base-stale — 이 머리의 통과한 재게이트로 land 했더니 base-stale-overlap 으로 거절됐다 → 새 base 위에서 한 번 더 잰다.
+  const stale = regate?.passed === true ? baseStaleAttemptAfter(card, pr, toHead, regate.at) : undefined;
+  const staleBase = stale ? regate?.baseCommit : undefined;
+  if (stale && !staleBase) {
+    await tryCatchUp(undefined, `base-stale-overlap on head ${toHead.slice(0, 12)} but the stale regate has no baseCommit`);
+    return outcomes;
+  }
+  if (!regate || staleBase) {
+    const why = staleBase ? `base-stale-overlap — gate base ${staleBase.slice(0, 12)} went stale (${(stale!.reason ?? '').replace(/^base-stale-overlap:\s*/, '').slice(0, 160)})` : '';
     if (regates.length >= REJUDGE_HEAD_CAP) {
-      step('regate', 'cap-reached', `re-gated ${regates.length} heads already (cap ${REJUDGE_HEAD_CAP}) — no more rejudge; needs owner`, true);
+      step('regate', 'cap-reached', `${why ? `${why} · ` : ''}re-gated ${regates.length} times already (cap ${REJUDGE_HEAD_CAP}) — no more rejudge; needs owner`, true);
       return outcomes;
     }
-    if (!deps.liveMoves.has('propose-land')) step('regate', 'would-regate', 'propose-land not enabled in taskAgent.liveMoves — shadow', false);
+    if (!deps.liveMoves.has('propose-land')) step('regate', 'would-regate', `${why ? `${why} · ` : ''}propose-land not enabled in taskAgent.liveMoves — shadow`, false);
     else {
       const at = now().toISOString();
-      const resultPath = regateResultPath(statePath, card.id, pr, toHead);
+      const resultPath = regateResultPath(statePath, card.id, pr, toHead, staleBase);
       let claimed = false;
       let capped = false;
       updateTaskCard(statePath, card.id, (current) => {
         const held = (current?.regates ?? []).filter((entry) => entry.pr === pr);
-        if (!current || held.some((entry) => sameHead(entry.head, toHead))) return undefined;
+        // 멱등 — 처음 재게이트는 «머리», base-stale 재게이트는 «머리 ⊕ 낡은 base» 가 키다(같은 머리·같은 base 로 두 번 안 잰다).
+        if (!current || held.some((entry) => sameHead(entry.head, toHead) && (staleBase ? entry.staleBase !== undefined && sameHead(entry.staleBase, staleBase) : true))) return undefined;
         // 상한은 잠금 안의 «지금» 카드로 다시 잰다 — 다른 머리를 본 두 틱이 겹쳐도 상한을 넘지 않게.
         if (held.length >= REJUDGE_HEAD_CAP) { capped = true; return undefined; }
         claimed = true;
-        return { ...current, regates: [...(current.regates ?? []), { pr, head: toHead, at, resultPath }] };
+        return { ...current, regates: [...(current.regates ?? []), { pr, head: toHead, at, resultPath, ...(staleBase ? { staleBase } : {}) }] };
       });
       if (capped) {
-        step('regate', 'cap-reached', `re-gated ${REJUDGE_HEAD_CAP} heads already (cap ${REJUDGE_HEAD_CAP} · claim-time recheck) — no more rejudge; needs owner`, true);
+        step('regate', 'cap-reached', `${why ? `${why} · ` : ''}re-gated ${REJUDGE_HEAD_CAP} times already (cap ${REJUDGE_HEAD_CAP} · claim-time recheck) — no more rejudge; needs owner`, true);
         return outcomes;
       }
       if (claimed) {
         try {
           mkdirSync(dirname(resultPath), { recursive: true });
           await (deps.requestRegate ?? defaultRequestRegate)({ card: card.id, pr, head: toHead, repoRoot: cwd, resultPath });
-          step('regate', 'regate-requested', `host regate (noMerge) launched detached → ${resultPath}`, true);
+          step('regate', 'regate-requested', `${why ? `${why} · re-gate on a new base · ` : ''}host regate (noMerge) launched detached → ${resultPath}`, true);
         } catch (error) {
           const detail = `regate launch failed: ${(error instanceof Error ? error.message : String(error)).slice(-200)}`;
           updateTaskCard(statePath, card.id, (current) => current?.regates?.some((entry) => entry.pr === pr && entry.head === toHead && entry.at === at)
             ? { ...current, regates: current.regates.map((entry) => entry.pr === pr && entry.head === toHead && entry.at === at ? { ...entry, passed: false, status: 'unmeasured', detail } : entry) }
             : undefined);
-          step('regate', 'regate-failed', detail, true);
+          step('regate', 'regate-failed', `${why ? `${why} · ` : ''}${detail}`, true);
         }
       }
     }
+    // base-stale 재게이트는 그 결과가 나와야 land 한다 — 낡은 base 의 증거로 이번 틱에 다시 land 하지 않는다.
+    if (staleBase) return outcomes;
   } else if (regate.passed === undefined) {
     step('regate', 'awaiting-regate-result', 'host regate still running', false);
   }
@@ -254,6 +426,11 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
     step('land', 'not-landing', regate ? (regate.passed === false ? `host regate not passed: ${regate.detail ?? regate.status ?? 'unknown'}` : 'host regate still running') : 'no host regate for this head', regate?.passed === false);
     return outcomes;
   }
+  // REJUDGE base-stale — 새 base 위 재게이트가 «같은» base 로 돌아왔다 → origin/main 따라잡기(merge⊕push) 후 새 머리 재게이트.
+  if (regate.staleBase && regate.baseCommit && sameHead(regate.baseCommit, regate.staleBase)) {
+    await tryCatchUp(regate.staleBase, `base-stale-overlap — re-gate on head ${toHead.slice(0, 12)} returned the same base ${regate.staleBase.slice(0, 12)} (did not advance)`);
+    return outcomes;
+  }
   if (!deps.liveMoves.has('propose-land')) { step('land', 'would-land', 'propose-land not enabled in taskAgent.liveMoves — shadow', false); return outcomes; }
 
   // ③ land — 겹침 증거(#26023 꼴)를 «완전히» 쓴 뒤에만 executeLiveLand 를 그대로 부른다. 증거를 못 갖추면 land 하지 않는다(fail-closed).
@@ -263,21 +440,43 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
     return outcomes;
   }
   const overlapEvidence = overlapEvidencePath(statePath, card.id, pr, toHead);
+  // #26023 꼴 그대로 — 증거 «파일» 내용은 무변 · 아래 원장 조인이 같은 모양을 쓴다(cardId 는 메모리에서만 싣는다).
+  const overlapEvidenceContent = { pr, head: toHead, gate: { head: toHead, baseCommit: regate.baseCommit, passed: true }, reviewResult };
   try {
     mkdirSync(dirname(overlapEvidence), { recursive: true });
     // 임시 파일에 쓰고 바꿔 끼운다 — 겹친 틱이 같은 경로를 다시 써도 land 가 반쯤 쓴 JSON 을 읽지 않게.
     const tmp = `${overlapEvidence}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(tmp, JSON.stringify({ pr, head: toHead, gate: { head: toHead, baseCommit: regate.baseCommit, passed: true }, reviewResult }, null, 2));
+    writeFileSync(tmp, JSON.stringify(overlapEvidenceContent, null, 2));
     renameSync(tmp, overlapEvidence);
   } catch (error) {
     step('land', 'not-landing', `overlap evidence write failed: ${(error instanceof Error ? error.message : String(error)).slice(-200)}`, true);
     return outcomes;
   }
   const before = { reviewRequests: latest.reviewRequests, landAttempts: latest.landAttempts };
-  const landed = await executeLiveLand(latest, pr, { runId: card.runId ?? null, cycleId: `rejudge:${card.id}:${toHead}`, cwd, review, overlapEvidence },
+  // 주기 id — base-stale 재게이트 뒤의 land 는 새 base 를 붙여 앞 land 의 주기 표시(모듈 전역)와 갈린다 · gateAt 이 앞 base-stale 시도를 소비한다.
+  const cycleId = `rejudge:${card.id}:${toHead}${regate.staleBase ? `:${regate.baseCommit.slice(0, 12)}` : ''}`;
+  const landed = await executeLiveLand(latest, pr, { runId: card.runId ?? null, cycleId, cwd, review, overlapEvidence, gateAt: regate.at },
     { ...live, ...(deps.log ? { log: deps.log } : {}) });
+  // LAND-ORDER-LEDGER — executeLiveLand 직후 원장 한 줄(같은 pr+head 는 한 줄만). 쓰기가 실패해도 land 결과는 그대로(삼킨다).
+  const landOrderLog = (event: 'appended' | 'append-failed') => { try { log('task-agent.land-order', event, { pr, head: toHead }); } catch { /* fail-soft */ } };
+  try {
+    // review-results 파일을 못 읽으면 reviewVerdict 'missing' — 0 으로 쓰지 않는다(land 판정의 회수 결과와는 별개 파일).
+    let reviewForLedger: ParsedReviewResult | null = null;
+    try { reviewForLedger = parseReviewResultOutput(read(reviewResult)); } catch { reviewForLedger = null; }
+    appendLandOrderRow(statePath, joinLandOrderRow({
+      overlapEvidence: { ...overlapEvidenceContent, cardId: card.id },
+      reviewResult: reviewForLedger, landed, at: now().toISOString(),
+    }));
+    landOrderLog('appended');
+  } catch {
+    landOrderLog('append-failed');
+  }
   recordMove(statePath, card.id, card.runId, 'propose-land', landed, pr, before, now, deps.log);
-  step('land', landed.executed && landed.ok ? 'landed' : 'land-rejected', `${landed.detail} · overlap-evidence ${overlapEvidence}`, true);
+  // TA-LAND-RETRY-ON-INFRA — 실패한 시도는 갈래·사유·재시도 여부를 사유 줄에 싣는다(다음 틱이 왜 다시 하는지/안 하는지).
+  const attempt = landed.landAttempt?.class
+    ? ` · land-class ${landed.landAttempt.class} (${landed.landAttempt.reason}) · attempt ${landed.landAttempt.attempt} · ${landed.landAttempt.class === 'base-stale' ? 'base-stale → re-gate on a new base next tick (cap counts)' : landed.landAttempt.retryAllowed ? 'retry allowed on this head' : 'no retry on this head'}`
+    : '';
+  step('land', landed.executed && landed.ok ? 'landed' : 'land-rejected', `${landed.detail}${attempt} · overlap-evidence ${overlapEvidence}`, true);
   return outcomes;
 }
 

package/src/task-agent/review-prior-fix.ts

@@ -0,0 +1,146 @@
+/**
+ * REVIEW-CONVERGE-PRIOR-FIX — TA 가 같은 PR 에 «다시» 거는 리뷰가 직전 라운드를 보게 한다.
+ *
+ * - 왜: `liveReviewIntent` 의 «직전 반영분» 칸은 늘 «런 X 이 Y 로 멈춤 — 수확 가능» 고정 문면이었다 — 직전 리뷰의 must-fix 도,
+ *   그 뒤 바뀐 머리 범위도 없었다. 그래서 리뷰어가 head 마다 PR 전체를 처음부터 다시 보고 «새» must-fix 를 하나씩 냈고
+ *   (실측 10-11 PR #26030: ecd32f7c02 → c35d7be0cd 라운드마다 새 지적) REJUDGE 상한 3 에 걸려 TA 경로가 닫혔다.
+ * - 무엇을: 같은 PR 의 «두 번째 이후» 리뷰 요청에서만 intent 에 ① 직전 머리 → 지금 머리 diff 요약(파일·줄 수)
+ *   ② 직전 리뷰의 must-fix 목록(결과 파일 `review-results/<card>-<pr>-<head12>.json` — 못 읽으면 «직전 결과 미회수»)
+ *   ③ 스코프 경계 한 줄(바뀌지 않은 줄의 새 must-fix 는 근거 줄을 대라)을 싣는다. 첫 리뷰는 종전 문면 그대로다.
+ * - 하지 않는 것: 판정 로직(must-fix 0 규칙 · #25962 · #26036)은 손대지 않는다. 새 결함을 «금지»하지 않는다 — 근거 줄을 요구할 뿐이다.
+ * - 관측: `task-agent` · `review-prior-fix-filled {card, pr, fromHead, toHead, priorMustFix}`(호출부가 남긴다).
+ */
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import type { TaskCard } from './task-hand.js';
+
+const SHA40 = /^[0-9a-f]{40}$/i;
+const MAX_ITEMS = 10;
+const MAX_ITEM_CHARS = 600;
+const MAX_FILES = 20;
+
+export const PRIOR_RESULT_NOT_RECOVERED = '직전 결과 미회수';
+export const PRIOR_FIX_SCOPE_LINE = '이번 리뷰는 직전 must-fix 가 해결됐는지 ⊕ 그 사이 바뀐 줄에서 새 결함이 생겼는지를 본다 · 직전에 이미 본 바뀌지 않은 줄에서 새 must-fix 를 만들지 말 것(새 결함이 확실하면 근거 줄을 대라)';
+
+type ReviewRequest = NonNullable<TaskCard['reviewRequests']>[number];
+
+export interface PriorDiffFile { path: string; added: number | null; deleted: number | null }
+export interface PriorDiff { files: PriorDiffFile[]; added: number; deleted: number }
+/** 직전 머리 → 지금 머리 diff — 못 재면 null(«0 줄»이 아니라 «미측정»). */
+export type PriorDiffReader = (cwd: string | undefined, fromHead: string, toHead: string) => PriorDiff | null;
+
+export type PriorMustFix =
+  | { status: 'recovered'; items: string[] }
+  | { status: 'not-recovered'; reason: string };
+
+export interface PriorFixContext {
+  fromHead: string;
+  toHead: string;
+  diff: PriorDiff | null;
+  mustFix: PriorMustFix;
+}
+
+/** 같은 PR 의 직전 요청 — 지금 머리가 아닌 것 중 마지막(띄우기 오류가 난 요청은 리뷰가 안 돌았으니 건너뛴다). */
+export function priorReviewRequest(requests: readonly ReviewRequest[] | undefined, pr: number, head: string): ReviewRequest | undefined {
+  return (requests ?? []).filter((entry) => entry.pr === pr && entry.head !== head && !entry.error && SHA40.test(entry.head)).at(-1);
+}
+
+/**
+ * 결과 파일에서 must-fix «문면»을 읽는다 — `self review --json` 의 결과 줄(뒤에서부터 첫 결과 모양)만.
+ * 결과 모양 판정은 `parseReviewResultOutput` 과 같다(PR 번호 ⊕ (verdict ⊕ mustFix 배열 | error 문자열)).
+ */
+export function readPriorMustFix(path: string | undefined, pr: number, read: (path: string) => string = (p) => readFileSync(p, 'utf8')): PriorMustFix {
+  if (!path) return { status: 'not-recovered', reason: 'no result path' };
+  let text: string;
+  try { text = read(path); } catch (error) {
+    const code = (error as NodeJS.ErrnoException)?.code;
+    return { status: 'not-recovered', reason: code === 'ENOENT' ? 'result file not created' : `result file unreadable (${code ?? 'error'})` };
+  }
+  const lines = text.split('\n').map((line) => line.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const line = lines[i]!;
+    if (!line.startsWith('{')) continue;
+    let value: unknown;
+    try { value = JSON.parse(line); } catch { continue; }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) continue;
+    const v = value as Record<string, unknown>;
+    const isResult = v.pr !== undefined && (('verdict' in v && Array.isArray(v.mustFix)) || typeof v.error === 'string');
+    if (!isResult) continue;
+    const prRaw = typeof v.pr === 'number' ? v.pr : typeof v.pr === 'string' ? Number(String(v.pr).replace(/^#/, '')) : NaN;
+    if (prRaw !== pr) return { status: 'not-recovered', reason: `result PR ${Number.isFinite(prRaw) ? prRaw : 'unknown'} does not match #${pr}` };
+    if (typeof v.error === 'string') return { status: 'not-recovered', reason: `prior review error: ${v.error.slice(0, 200)}` };
+    if (v.reviewed === false) return { status: 'not-recovered', reason: 'prior review did not run (reviewed:false)' };
+    if (!Array.isArray(v.mustFix) || !v.mustFix.every((fix) => typeof fix === 'string')) return { status: 'not-recovered', reason: 'must-fix list unreadable' };
+    return { status: 'recovered', items: v.mustFix as string[] };
+  }
+  return { status: 'not-recovered', reason: text.trim() ? 'output has no JSON result line' : 'result file empty' };
+}
+
+/** 기본 diff — `git diff --numstat <from> <to>`(그 PR 의 저장소 cwd). 커밋이 없거나 git 이 실패하면 null. */
+export const defaultPriorDiff: PriorDiffReader = (cwd, fromHead, toHead) => {
+  if (!SHA40.test(fromHead) || !SHA40.test(toHead)) return null;
+  const out = spawnSync('git', ['diff', '--numstat', fromHead, toHead], { encoding: 'utf8', timeout: 20_000, ...(cwd ? { cwd } : {}) });
+  if (out.error || out.status !== 0 || typeof out.stdout !== 'string') return null;
+  return parseNumstat(out.stdout);
+};
+
+export function parseNumstat(text: string): PriorDiff {
+  const files: PriorDiffFile[] = [];
+  let added = 0;
+  let deleted = 0;
+  for (const line of text.split('\n')) {
+    const match = /^(\d+|-)\t(\d+|-)\t(.+)$/.exec(line);
+    if (!match) continue;
+    const a = match[1] === '-' ? null : Number(match[1]);
+    const d = match[2] === '-' ? null : Number(match[2]);
+    files.push({ path: match[3]!, added: a, deleted: d });
+    added += a ?? 0;
+    deleted += d ?? 0;
+  }
+  return { files, added, deleted };
+}
+
+/** 두 번째 이후 리뷰의 맥락 — 직전 요청이 없으면 null(첫 리뷰 · 종전 문면). */
+export function buildPriorFixContext(
+  card: TaskCard, pr: number, head: string,
+  opts: { cwd?: string; priorDiff?: PriorDiffReader; readFile?: (path: string) => string } = {},
+): PriorFixContext | null {
+  const prior = priorReviewRequest(card.reviewRequests, pr, head);
+  if (!prior) return null;
+  let diff: PriorDiff | null;
+  try { diff = (opts.priorDiff ?? defaultPriorDiff)(opts.cwd, prior.head, head); } catch { diff = null; }
+  return { fromHead: prior.head, toHead: head, diff, mustFix: readPriorMustFix(prior.resultPath, pr, opts.readFile) };
+}
+
+/** «직전 반영분» 블록 — 종전 런 줄 다음에 붙는다. */
+export function priorFixBlock(ctx: PriorFixContext): string {
+  const lines = [`직전 리뷰 머리 → 지금 머리: ${ctx.fromHead.slice(0, 12)} → ${ctx.toHead.slice(0, 12)}`];
+  if (ctx.diff) {
+    lines.push(`그 사이 바뀐 것: 파일 ${ctx.diff.files.length}개 · +${ctx.diff.added} −${ctx.diff.deleted}`);
+    for (const file of ctx.diff.files.slice(0, MAX_FILES)) lines.push(`  - ${file.path} (+${file.added ?? '?'} −${file.deleted ?? '?'})`);
+    if (ctx.diff.files.length > MAX_FILES) lines.push(`  - … 외 ${ctx.diff.files.length - MAX_FILES}개`);
+  } else {
+    lines.push('그 사이 바뀐 것: diff 미측정(이 저장소에서 두 머리를 비교하지 못했다)');
+  }
+  if (ctx.mustFix.status === 'recovered') {
+    if (ctx.mustFix.items.length === 0) lines.push('직전 리뷰 must-fix: 0건');
+    else {
+      lines.push(`직전 리뷰 must-fix ${ctx.mustFix.items.length}건:`);
+      ctx.mustFix.items.slice(0, MAX_ITEMS).forEach((item, index) => lines.push(`  ${index + 1}. ${item.replace(/\s+/g, ' ').trim().slice(0, MAX_ITEM_CHARS)}`));
+      if (ctx.mustFix.items.length > MAX_ITEMS) lines.push(`  … 외 ${ctx.mustFix.items.length - MAX_ITEMS}건`);
+    }
+  } else {
+    lines.push(`직전 리뷰 must-fix: ${PRIOR_RESULT_NOT_RECOVERED} (${ctx.mustFix.reason}) — 목록이 없다고 «0건»으로 읽지 말 것`);
+  }
+  return lines.join('\n');
+}
+
+/** 관측 칸 — must-fix 수(미회수면 null). */
+export function priorFixObservation(cardId: string, pr: number, ctx: PriorFixContext): Record<string, unknown> {
+  return {
+    card: cardId, pr, fromHead: ctx.fromHead, toHead: ctx.toHead,
+    priorMustFix: ctx.mustFix.status === 'recovered' ? ctx.mustFix.items.length : null,
+    ...(ctx.mustFix.status === 'not-recovered' ? { priorResult: 'not-recovered', priorResultReason: ctx.mustFix.reason } : {}),
+    diffFiles: ctx.diff ? ctx.diff.files.length : null,
+  };
+}

package/src/task-agent/review-result-capture.ts

@@ -12,6 +12,7 @@
  */
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import { isNoneSentinelFinding } from '../agent-substrate/pr-reviewer.js';
 import { debug } from '../debug/log.js';
 import { LIVE_MOVE_RESULT_EVENT, readTaskAgentState, updateTaskCard, type TaskCard, type TaskCardEvent } from './task-hand.js';
 
@@ -63,7 +64,8 @@ export function parseReviewResultOutput(text: string): ParsedReviewResult | null
       ...(Number.isSafeInteger(prRaw) && prRaw > 0 ? { pr: prRaw } : {}),
       verdict: typeof v.verdict === 'string' ? v.verdict : null,
       reviewed: typeof v.reviewed === 'boolean' ? v.reviewed : null,
-      mustFix: Array.isArray(v.mustFix) && v.mustFix.every((fix) => typeof fix === 'string') ? v.mustFix.length : null,
+      // PR-LAND-MUSTFIX-NONE — 저장된 결과(옛 판 리뷰 · 다른 경로)에 «(없음 — …)» 표지 줄이 남아 있어도 리뷰 출력과 «같은» 판정으로 0 으로 센다.
+      mustFix: Array.isArray(v.mustFix) && v.mustFix.every((fix) => typeof fix === 'string') ? v.mustFix.filter((fix) => !isNoneSentinelFinding(fix)).length : null,
       reviewRoute: typeof v.reviewRoute === 'string' ? v.reviewRoute : null,
       head: typeof v.headCommit === 'string' && SHA40.test(v.headCommit) ? v.headCommit : null,
       error: typeof v.error === 'string' ? v.error : null,