elanous 0.2.22 → 0.2.23

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

@@ -0,0 +1,297 @@
+/**
+ * TA-REJUDGE-ON-HEAD — 런이 멈춘 «뒤» PR 머리가 바뀌면 task agent 가 재게이트 · 리뷰 · land 를 다시 판단한다.
+ *
+ * - 왜: live 판단은 «런 멈춤 순간» 한 번뿐이다(run-supervisor → `recordTaskAgentShadowMove`). 그 뒤 사람이(또는 다른 런이)
+ *   must-fix 를 고쳐 push 해도 카드의 다음 수는 `wait` 로 남고, 새 머리를 재게이트·리뷰·착지하는 길이 없었다(2026-10-11 #26030:
+ *   호스트 재게이트 기록은 Pod 산출 머리 것뿐이고 손으로 고친 새 머리엔 없었다).
+ * - 한 틱(카드 하나 · `tasks rejudge`) — land 는 셋이 «모두» 지금 머리에 대해 참일 때만:
+ *   ① 재게이트: 지금 머리의 재게이트 기록(`card.regates[]`)이 없으면 기존 호스트 재게이트(`runHostRegate` · `noMerge` — 병합 없음 ·
+ *      ta-land-owner 와 같은 함수)를 «떼어 띄운» 자식(`tasks regate-run`)으로 한 번 돌린다 — 판단 틱을 막지 않는다. 결과
+ *      (`<state>/regate-results/<card>-<pr>-<head12>.json` · head · baseCommit · passed)는 다음 틱이 회수해 카드에 적는다.
+ *   ② 리뷰: 지금 머리로 리뷰를 요청한 적이 없으면 다시 요청한다(#25980 `executeLiveReview` 그대로 · 결과 회수도 그대로).
+ *   ③ 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` 개까지 — 넘으면 사유 줄을 남기고 멈춘다.
+ * - 대상: 카드에 묶인 PR(URL 로 저장소 확인) ⊕ 그 PR 로 TA 가 이미 리뷰를 요청한 카드(= 런이 멈춰 TA 판단이 시작됐다).
+ * - 사람의 hold(draft PR)는 뒤집지 않는다 — 재게이트(`noMerge`)와 land 관문이 draft 를 거부한다.
+ * - 허용: 설정 `taskAgent.liveMoves` 그대로 — 재게이트·land 는 `propose-land`, 리뷰 재요청은 `review` 가 있을 때만(없으면 «했을 수»).
+ * - 관측: `task-agent` · `rejudge-on-head {card, pr, fromHead, toHead, step, decision, reason}` — 수가 난 판단은 카드 history 에도
+ *   한 줄(`event:'rejudge-on-head'` · 같은 머리·같은 단계·같은 판단은 한 번).
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { debug } from '../debug/log.js';
+import type { DetachedSpawn } from '../cli/tasks-cli.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 { 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;
+/** 떼어 띄운 재게이트 결과를 기다리는 상한 — 지나도 파일이 없으면 «결과 없음»으로 적는다(같은 머리는 다시 안 돌린다). */
+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 interface RegateRequest { card: string; pr: number; head: string; repoRoot: string; resultPath: string }
+export interface RejudgeDeps {
+  live?: LiveMoveDeps;
+  liveMoves: ReadonlySet<TaskAgentLiveMove>;
+  /** 재게이트를 떼어 띄운다 — 시험은 주입한다. 기본은 `tasks regate-run` 자식(stdio ignore · 결과는 파일). */
+  requestRegate?: (request: RegateRequest) => Promise<void>;
+  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 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`);
+}
+
+/** `tasks regate-run` 자식 argv — 같은 우주 · 같은 진입점. */
+export function regateRunArgs(entry: string, configDir: string, request: RegateRequest): string[] {
+  return [entry, '--config-dir', configDir, 'tasks', 'regate-run', '--card', request.card, '--pr', String(request.pr), '--head', request.head, '--repo', request.repoRoot, '--out', request.resultPath];
+}
+
+export async function defaultRequestRegate(request: RegateRequest, opts: { spawn?: DetachedSpawn; entry?: string; configDir?: string } = {}): Promise<void> {
+  const { spawnDetachedConfirmed, ELANOUS_CLI_ENTRY } = await import('../cli/tasks-cli.js');
+  const { getElanousConfigDirOverride } = await import('../elanous-config-dir.js');
+  const { effectiveInstanceRoot } = await import('../instance/resolve.js');
+  const configDir = opts.configDir ?? getElanousConfigDirOverride() ?? effectiveInstanceRoot();
+  await spawnDetachedConfirmed(opts.spawn ?? (spawn as unknown as DetachedSpawn), process.execPath, regateRunArgs(opts.entry ?? ELANOUS_CLI_ENTRY, configDir, request), undefined, request.repoRoot);
+}
+
+/** 재게이트 결과 파일 — `tasks regate-run` 이 쓴다. */
+export interface RegateResultFile { pr: number; head: string; passed: boolean; status?: string; baseCommit?: string; failures?: Array<{ step: string; detail: string }> }
+
+export function parseRegateResult(text: string, pr: number, head: string): RegateResultFile | null {
+  let value: unknown;
+  try { value = JSON.parse(text); } catch { return null; }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const v = value as Partial<RegateResultFile>;
+  if (v.pr !== pr || typeof v.head !== 'string' || v.head.toLowerCase() !== head.toLowerCase() || typeof v.passed !== 'boolean') return null;
+  // 모양이 틀린 칸은 결과로 받지 않는다(회수 중 예외로 다른 카드 판단까지 멈추지 않게) — 상한 뒤 «결과 없음»으로 적힌다.
+  if (v.baseCommit !== undefined && (typeof v.baseCommit !== 'string' || !/^[0-9a-f]{40}$/i.test(v.baseCommit))) return null;
+  if (v.status !== undefined && typeof v.status !== 'string') return null;
+  if (v.failures !== undefined && (!Array.isArray(v.failures) || !v.failures.every((f) => f && typeof f.step === 'string' && typeof f.detail === 'string'))) return null;
+  return v as RegateResultFile;
+}
+
+const sameUrl = (a: string, b: string) => a.trim().replace(/\/+$/, '').toLowerCase() === b.trim().replace(/\/+$/, '').toLowerCase();
+const sameHead = (a: string, b: string) => a.toLowerCase() === b.toLowerCase();
+
+/** 카드의 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[];
+  try { candidates = (deps.repoCandidates ?? defaultReviewRepoCandidates)(card); } catch { candidates = []; }
+  const misses: string[] = [];
+  for (const candidate of candidates) {
+    let view: PrHeadView | null;
+    try { view = await (deps.prHead ?? defaultPrHead)(pr, candidate.cwd); } catch { view = null; }
+    if (!view) { misses.push(`${candidate.source}: unreadable`); continue; }
+    if (!view.url || !sameUrl(view.url, url)) { misses.push(`${candidate.source}: url ${view.url ?? 'none'}`); continue; }
+    return { cwd: candidate.cwd, view };
+  }
+  return { reason: candidates.length ? misses.join(' · ') : 'no target repository (card project · harness.defaultRepo · host checkout)' };
+}
+
+/** 카드 하나를 다시 판단한다 — 던지지 않는다. 돌려주는 것은 이번 틱에 난 판단들(단계 순). */
+export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Promise<RejudgeOutcome[]> {
+  const live = deps.live ?? {};
+  const statePath = live.statePath ?? taskAgentStatePath();
+  const now = () => (live.now ?? (() => new Date()))();
+  const log = deps.log ?? ((c: string, e: string, d: Record<string, unknown>) => debug.log(c, e, d));
+  const read = deps.readFile ?? ((path: string) => readFileSync(path, 'utf8'));
+  const outcomes: RejudgeOutcome[] = [];
+  const emit = (o: RejudgeOutcome, record: boolean): void => {
+    outcomes.push(o);
+    try { log('task-agent', REJUDGE_ON_HEAD_EVENT, { ...o }); } catch { /* fail-soft */ }
+    if (!record || o.pr === null) return;
+    try {
+      updateTaskCard(statePath, o.card, (current) => {
+        if (!current) return undefined;
+        const detail = `${o.fromHead ? o.fromHead.slice(0, 12) : '-'} → ${o.toHead ? o.toHead.slice(0, 12) : '-'} · ${o.reason}`;
+        // 같은 머리·같은 단계·같은 판단·같은 사유는 한 줄만 — 틱마다 쌓지 않되, 사유가 바뀌면 새 줄로 남긴다.
+        if ((current.history ?? []).some((item) => item.event === REJUDGE_ON_HEAD_EVENT && item.pr === o.pr && item.head === (o.toHead ?? undefined) && item.kind === o.step && item.effect === o.decision && item.detail === detail)) return undefined;
+        return { ...current, history: [...(current.history ?? []), {
+          at: now().toISOString(), event: REJUDGE_ON_HEAD_EVENT, kind: o.step, pr: o.pr!, ...(o.toHead ? { head: o.toHead } : {}), effect: o.decision, detail,
+        }] };
+      });
+    } catch (error) {
+      try { log('task-agent', 'rejudge-on-head-history-failed', { card: o.card, reason: (error instanceof Error ? error.message : String(error)).slice(-300) }); } catch { /* fail-soft */ }
+    }
+  };
+  const target = (decision: string, reason: string, pr: number | null = null, fromHead: string | null = null, toHead: string | null = null, record = false) => {
+    emit({ card: cardId, pr, fromHead, toHead, step: 'target', decision, reason }, record);
+    return outcomes;
+  };
+
+  // 지난 리뷰 결과부터 회수한다 — 같은 틱의 판단이 그 결과를 본다.
+  try { captureReviewResults(statePath, { cardIds: [cardId], ...(live.now ? { now: live.now } : {}), log }); } catch { /* 회수는 스스로 관측한다 */ }
+  let card: TaskCard | undefined;
+  try { card = readTaskCard(cardId, statePath); } catch (error) { return target('card-unreadable', String(error).slice(-200)); }
+  const pr = card ? cardPrNumber(card) : undefined;
+  if (!card || pr === undefined) return target('no-pr', 'card has no bound PR');
+  const reviews = (card.reviewRequests ?? []).filter((entry) => entry.pr === pr);
+  // 런이 멈춰 TA 가 이 PR 을 리뷰한 적이 있어야 재판정한다 — 도는 런의 PR 에 끼어들지 않는다.
+  if (!reviews.length) return target('not-started', 'no task-agent review on this PR yet (run not stopped/judged)', pr);
+  // 떼어 띄운 재게이트 결과를 «머리와 무관하게» 먼저 회수한다 — 결과가 나오기 전에 머리가 또 바뀌어도 그 머리의 결과는 카드에 남는다.
+  for (const pending of (card.regates ?? []).filter((entry) => entry.pr === pr && entry.passed === undefined && entry.resultPath)) {
+    let text: string | null = null;
+    try { text = read(pending.resultPath!); } catch { text = null; }
+    const result = text !== null ? parseRegateResult(text, pr, pending.head) : null;
+    const waited = now().getTime() - Date.parse(pending.at);
+    if (!result && !(waited >= REGATE_RESULT_WAIT_MS)) continue;
+    const patch = result
+      ? { passed: result.passed, ...(result.status ? { status: result.status } : {}), ...(result.baseCommit ? { baseCommit: result.baseCommit } : {}),
+        detail: result.passed ? 'passed' : `${result.failures?.[0]?.step ?? 'unknown'}: ${(result.failures?.[0]?.detail ?? '').replace(/\s+/g, ' ').slice(0, 200)}` }
+      : { passed: false, status: 'no-result', detail: `regate process produced no result after ${Math.round(waited / 60_000)}m` };
+    let wrote = false;
+    updateTaskCard(statePath, card.id, (current) => {
+      if (!current?.regates?.some((entry) => entry.pr === pr && entry.head === pending.head && entry.at === pending.at && entry.passed === undefined)) return undefined;
+      wrote = true;
+      return { ...current, regates: current.regates.map((entry) => entry.pr === pr && entry.head === pending.head && entry.at === pending.at ? { ...entry, ...patch } : entry) };
+    });
+    if (wrote) emit({ card: card.id, pr, fromHead: null, toHead: pending.head, step: 'regate', decision: patch.passed ? 'regate-passed' : 'regate-failed',
+      reason: `head ${pending.head.slice(0, 12)} · base ${(patch as { baseCommit?: string }).baseCommit?.slice(0, 12) ?? '-'} · ${patch.detail}` }, true);
+  }
+  card = readTaskCard(card.id, statePath) ?? card;
+  const regates = (card.regates ?? []).filter((entry) => entry.pr === pr);
+  // 런 멈춤 때 판단한 머리 — 리뷰 요청 중 «재판정이 낸 것»(history `rejudge-on-head` review-requested)을 뺀 마지막(Pod 재게이트가 잰 머리).
+  //   재판정이 낸 리뷰만 있는 머리는 아직 재게이트하지 않은 «새» 머리다(허용이 나중에 켜져도 재게이트·land 로 간다).
+  const rejudgeReviewed = new Set((card.history ?? []).filter((item) => item.event === REJUDGE_ON_HEAD_EVENT && item.kind === 'review' && item.effect === 'review-requested' && item.pr === pr && item.head)
+    .map((item) => item.head!.toLowerCase()));
+  const judgedHead = reviews.filter((entry) => !rejudgeReviewed.has(entry.head.toLowerCase())).at(-1)?.head ?? null;
+  // «마지막으로 재게이트한 머리» — 카드에 재게이트 기록이 없으면 런 멈춤 때 판단한 머리.
+  const fromHead = regates.at(-1)?.head ?? judgedHead;
+  const url = typeof card.pr === 'object' ? card.pr.url : undefined;
+  if (!url) return target('pr-url-unknown', 'card PR has no URL — repository unconfirmed, no gh/regate/review/land', pr, fromHead, null, true);
+  const found = await resolveCardPr(card, pr, url, live);
+  if ('reason' in found) return target('pr-unreadable', found.reason, pr, fromHead);
+  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);
+
+  // 머리가 런 멈춤 때 그대로면 재판정하지 않는다 — 그 머리의 재게이트·리뷰·land 판단은 멈춤 때의 판단(슈퍼바이저 틱)이 이미 했다.
+  if (!regates.length && judgedHead && sameHead(toHead, judgedHead)) 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) {
+    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);
+      return outcomes;
+    }
+    if (!deps.liveMoves.has('propose-land')) step('regate', 'would-regate', 'propose-land not enabled in taskAgent.liveMoves — shadow', false);
+    else {
+      const at = now().toISOString();
+      const resultPath = regateResultPath(statePath, card.id, pr, toHead);
+      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;
+        // 상한은 잠금 안의 «지금» 카드로 다시 잰다 — 다른 머리를 본 두 틱이 겹쳐도 상한을 넘지 않게.
+        if (held.length >= REJUDGE_HEAD_CAP) { capped = true; return undefined; }
+        claimed = true;
+        return { ...current, regates: [...(current.regates ?? []), { pr, head: toHead, at, resultPath }] };
+      });
+      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);
+        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);
+        } 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);
+        }
+      }
+    }
+  } else if (regate.passed === undefined) {
+    step('regate', 'awaiting-regate-result', 'host regate still running', false);
+  }
+
+  // ② 리뷰 — 지금 머리로 요청한 적이 없으면 다시(같은 머리는 한 번 · 상한은 ① 의 머리 수가 이미 막았다).
+  if (!reviews.some((entry) => sameHead(entry.head, toHead))) {
+    if (!deps.liveMoves.has('review')) step('review', 'would-review', 'review not enabled in taskAgent.liveMoves — shadow', false);
+    else {
+      const before = { reviewRequests: card.reviewRequests, landAttempts: card.landAttempts };
+      const result = await executeLiveReview(card, pr, { runId: card.runId ?? null, stopReason: 'rejudge-on-head', cwd }, { ...live, ...(deps.log ? { log: deps.log } : {}) });
+      recordMove(statePath, card.id, card.runId, 'review', result, pr, before, now, deps.log);
+      step('review', result.executed ? 'review-requested' : 'review-request-failed', result.detail, true);
+    }
+    return outcomes;
+  }
+  const latest = readTaskCard(card.id, statePath) ?? card;
+  if (pendingReviewResults(latest).some((entry) => entry.pr === pr && sameHead(entry.head, toHead))) {
+    step('review', 'awaiting-review-result', 'review result not captured yet', false);
+    return outcomes;
+  }
+  // TA-LAND-WARN-MUSTFIX0 — 정본 규칙: verdict ∈ {pass, warn} ⊕ reviewed ⊕ must-fix 가 «숫자 0» ⊕ 그 머리(모르면 통과 아님).
+  const review = capturedLandReview(latest, pr, toHead);
+  if (!review || review.mustFixCount !== 0) {
+    step('land', 'not-landing', review ? `review ${review.verdict} carries must-fix ${review.mustFixCount ?? 'unknown'}` : 'no captured review pass/warn for this head', true);
+    return outcomes;
+  }
+  if (!regate || regate.passed !== true) {
+    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;
+  }
+  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).
+  const reviewResult = latest.reviewRequests?.find((entry) => entry.pr === pr && sameHead(entry.head, toHead))?.resultPath;
+  if (!reviewResult || !regate.baseCommit || !/^[0-9a-f]{40}$/i.test(regate.baseCommit)) {
+    step('land', 'not-landing', `overlap evidence incomplete — ${!reviewResult ? 'review result path missing' : 'regate baseCommit missing'}`, true);
+    return outcomes;
+  }
+  const overlapEvidence = overlapEvidencePath(statePath, card.id, pr, toHead);
+  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));
+    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 },
+    { ...live, ...(deps.log ? { log: deps.log } : {}) });
+  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);
+  return outcomes;
+}
+
+function recordMove(statePath: string, cardId: string, runId: string | undefined, kind: TaskAgentLiveMove, result: LiveMoveResult, pr: number, before: Pick<TaskCard, 'reviewRequests' | 'landAttempts'>, now: () => Date, log?: RejudgeDeps['log']): void {
+  try {
+    recordLiveMoveHistory(statePath, cardId, { at: now().toISOString(), kind, executorResult: 'live', result, runId: runId ?? null, pr, before },
+      log ? (c, e, d) => log(c, e, d) : undefined);
+  } catch { /* recordLiveMoveHistory 는 스스로 관측한다 */ }
+}
+
+/** 재판정 대상 카드 — 묶인 PR ⊕ 그 PR 로 TA 리뷰를 요청한 적이 있는 카드. */
+export function rejudgeCandidates(tasks: Readonly<Record<string, TaskCard>>): string[] {
+  return Object.values(tasks).filter((card) => {
+    const pr = cardPrNumber(card);
+    return pr !== undefined && (card.reviewRequests ?? []).some((entry) => entry.pr === pr);
+  }).map((card) => card.id);
+}

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

@@ -0,0 +1,218 @@
+/**
+ * TA-REVIEW-RESULT-CAPTURE — live `review` 수가 떼어 띄운 `self review --json` 의 결과를 «파일로» 받아 카드에 되돌린다.
+ *
+ * - 왜: `defaultRequestReview` 는 리뷰를 떼어 띄우고(stdio ignore) spawn 만 확인했다 — `self review` 는 PR 코멘트를 안 달고
+ *   결과를 `--json` stdout ⊕ logs 에만 낸다. stdout 을 버리니 TA 는 판정을 영영 못 받았다(카드 줄 «result not received»).
+ * - 무엇을: 띄울 때 자식 stdout 을 `<상태 파일 디렉터리>/review-results/<card>-<pr>-<head12>.json` 로 받는다(떼어 띄움 유지 ·
+ *   TA 루프는 안 막는다). 경로는 `reviewRequests[]` 항목 ⊕ live-move 줄에 `resultPath` 로 싣는다.
+ * - 회수: 다음 TA 판단 틱(`recordTaskAgentShadowMove`) · `tasks show <card>` 가 그 파일을 읽어 같은 카드 history 에
+ *   `live-move-result` 줄을 «한 번» 덧붙인다. 파일이 «대기 상한» 지나도 결과가 없으면 `review process produced no result` 줄.
+ *   지어내지 않는다 — 읽은 JSON 의 칸만 옮긴다.
+ * - 관측: `task-agent` · `review-result-captured` / `review-result-missing`.
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { LIVE_MOVE_RESULT_EVENT, readTaskAgentState, updateTaskCard, type TaskCard, type TaskCardEvent } from './task-hand.js';
+
+export const REVIEW_RESULT_MISSING_EFFECT = 'review process produced no result';
+/** 결과 파일은 있는데 읽지 못했다(EACCES 등) — «결과 없음»과 가른다(결과가 있었을 수 있다). */
+export const REVIEW_RESULT_UNREADABLE_EFFECT = 'review result file unreadable';
+/** 리뷰 한 판(1차 ⊕ 폴백 · ACP 300s 상한 여러 번)을 넉넉히 덮는 대기 상한 — 이 안에는 «아직»으로 본다. */
+export const REVIEW_RESULT_WAIT_MS = 90 * 60_000;
+
+const SHA40 = /^[0-9a-f]{40}$/i;
+
+/** 결과 파일 경로 — 카드 상태 파일 옆 `review-results/` · 카드 id 는 파일 이름에 안전한 글자만. */
+export function reviewResultPath(statePath: string, cardId: string, pr: number, head: string): string {
+  const safe = (value: string) => value.replace(/[^A-Za-z0-9._-]/g, '_');
+  return join(dirname(statePath), 'review-results', `${safe(cardId)}-${pr}-${safe(head.slice(0, 12))}.json`);
+}
+
+export interface ParsedReviewResult {
+  pr?: number;
+  verdict: string | null;
+  reviewed: boolean | null;
+  /** must-fix 목록이 문자열 배열일 때만 수 — 아니면 null(«0» 이 아니라 «모름»). */
+  mustFix: number | null;
+  reviewRoute: string | null;
+  /** 리뷰가 읽은 머리(`headCommit`) — 40자 sha 일 때만. */
+  head: string | null;
+  error: string | null;
+}
+
+/**
+ * `self review --json` stdout 을 해석한다 — 그 stdout 에는 다른 줄이 섞일 수 있어 «뒤에서부터» 첫 JSON 객체 줄을 쓴다.
+ * 못 읽으면 null(쓰는 중이거나 자식이 죽었다 — 판단은 호출자가 시각으로 한다).
+ */
+export function parseReviewResultOutput(text: string): ParsedReviewResult | null {
+  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>;
+    // 결과 «모양»일 때만 확정한다 — `self review --json` 의 결과는 PR 번호 ⊕ (판정 칸 ⊕ must-fix 목록 | 오류 문자열)이다.
+    //   다른 JSON 줄(중간 로그)을 결과로 확정하면 뒤에 나온 진짜 판정을 중복 방지가 영영 막는다.
+    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;
+    return {
+      ...(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,
+      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,
+    };
+  }
+  return null;
+}
+
+type ReviewRequest = NonNullable<TaskCard['reviewRequests']>[number];
+
+function alreadyCaptured(card: TaskCard, resultPath: string): boolean {
+  return (card.history ?? []).some((item) => item.event === LIVE_MOVE_RESULT_EVENT && item.resultPath === resultPath);
+}
+
+/** 회수 대기 중인 요청 — 결과 경로가 있고 · 띄우기 오류가 없고 · 아직 결과 줄이 없는 것. */
+export function pendingReviewResults(card: TaskCard): ReviewRequest[] {
+  return (card.reviewRequests ?? []).filter((entry) => typeof entry.resultPath === 'string' && entry.resultPath && !entry.error && !alreadyCaptured(card, entry.resultPath));
+}
+
+export interface CaptureReviewResultsOptions {
+  /** 이 카드들만 본다 — 없으면 상태 파일의 모든 카드. */
+  cardIds?: readonly string[];
+  now?: () => Date;
+  /** 시험 seam — 결과 파일 읽기(없으면 ENOENT 를 던진다). */
+  readFile?: (path: string) => string;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+export type ReviewResultCapture =
+  | { card: string; pr: number; resultPath: string; status: 'captured'; entry: TaskCardEvent }
+  | { card: string; pr: number; resultPath: string; status: 'missing'; entry: TaskCardEvent }
+  | { card: string; pr: number; resultPath: string; status: 'pending' };
+
+/**
+ * 대기 중인 리뷰 결과를 회수한다 — 던지지 않는다(상태 파일 읽기 실패는 빈 결과 · 관측만).
+ * 결과 줄은 카드 잠금 안에서 «아직 없을 때만» 덧붙인다(두 틱이 겹쳐도 한 줄).
+ */
+export function captureReviewResults(statePath: string, opts: CaptureReviewResultsOptions = {}): ReviewResultCapture[] {
+  const log = opts.log ?? ((c: string, e: string, d: Record<string, unknown>) => debug.log(c, e, d));
+  const emit = (event: string, data: Record<string, unknown>) => { try { log('task-agent', event, data); } catch { /* fail-soft */ } };
+  let tasks: Record<string, TaskCard>;
+  try { tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(statePath).tasks ?? {}; } catch (error) {
+    emit('review-result-capture-failed', { statePath, reason: (error instanceof Error ? error.message : String(error)).slice(-300) });
+    return [];
+  }
+  const ids = opts.cardIds ?? Object.keys(tasks);
+  // 시각은 대기 중인 요청을 «처음 볼 때»만 읽는다 — 회수할 것이 없으면 시계도 안 건드린다(종전 틱과 같다).
+  let nowValue: Date | undefined;
+  const nowOf = () => (nowValue ??= (opts.now ?? (() => new Date()))());
+  const waitMs = REVIEW_RESULT_WAIT_MS;
+  const read = opts.readFile ?? ((path: string) => readFileSync(path, 'utf8'));
+  const out: ReviewResultCapture[] = [];
+  for (const id of ids) {
+    const card = tasks[id];
+    if (!card) continue;
+    for (const request of pendingReviewResults(card)) {
+      const resultPath = request.resultPath!;
+      let text: string | null = null;
+      let readError: string | null = null;
+      let unreadable = false;
+      try { text = read(resultPath); } catch (error) {
+        unreadable = (error as NodeJS.ErrnoException)?.code !== 'ENOENT';
+        readError = unreadable ? (error instanceof Error ? error.message : String(error)).slice(-200) : 'result file not created';
+      }
+      const output = text !== null ? parseReviewResultOutput(text) : null;
+      // 요청한 PR 의 결과만 확정한다 — 다른 PR 번호(또는 번호 없음)의 결과는 이 카드 결과로 옮기지 않는다.
+      const parsed = output && output.pr === request.pr ? output : null;
+      const mismatch = output && !parsed ? `result PR ${output.pr ?? 'unknown'} does not match requested #${request.pr}` : null;
+      const now = nowOf();
+      const requestedAt = Date.parse(request.at);
+      const waitedMs = Number.isFinite(requestedAt) ? now.getTime() - requestedAt : null;
+      let entry: TaskCardEvent;
+      let status: 'captured' | 'missing';
+      if (parsed) {
+        status = 'captured';
+        entry = {
+          at: now.toISOString(), event: LIVE_MOVE_RESULT_EVENT, kind: 'review', pr: request.pr,
+          ...(parsed.head ? { head: parsed.head } : {}),
+          verdict: parsed.verdict, reviewed: parsed.reviewed, mustFix: parsed.mustFix, reviewRoute: parsed.reviewRoute,
+          resultPath,
+          effect: `review result captured · verdict ${parsed.verdict ?? 'none'} · reviewed ${parsed.reviewed ?? 'unknown'} · must-fix ${parsed.mustFix ?? 'unknown'}`,
+          ...(parsed.error ? { detail: parsed.error.slice(0, 300) } : {}),
+        };
+      } else if (waitedMs !== null && waitedMs >= waitMs) {
+        status = 'missing';
+        const reason = readError ?? mismatch ?? (text !== null && text.trim() ? 'output has no JSON result line' : 'result file empty');
+        entry = {
+          at: now.toISOString(), event: LIVE_MOVE_RESULT_EVENT, kind: 'review', pr: request.pr, head: request.head,
+          resultPath, effect: unreadable ? REVIEW_RESULT_UNREADABLE_EFFECT : REVIEW_RESULT_MISSING_EFFECT, detail: `${reason} after ${Math.round(waitedMs / 60_000)}m (requested ${request.at})`,
+        };
+      } else {
+        out.push({ card: id, pr: request.pr, resultPath, status: 'pending' });
+        continue;
+      }
+      let wrote = false;
+      try {
+        updateTaskCard(statePath, id, (current) => {
+          // 잠금 안에서 다시 본다 — 그 사이 요청이 오류로 바뀌었거나 없어졌거나 이미 회수됐으면 쓰지 않는다.
+          if (!current || !pendingReviewResults(current).some((entry) => entry.resultPath === resultPath && entry.pr === request.pr)) return undefined;
+          wrote = true;
+          return { ...current, history: [...(current.history ?? []), entry] };
+        });
+      } catch (error) {
+        emit('review-result-capture-failed', { card: id, pr: request.pr, resultPath, reason: (error instanceof Error ? error.message : String(error)).slice(-300) });
+        continue;
+      }
+      if (!wrote) continue;
+      if (status === 'captured') {
+        emit('review-result-captured', { card: id, pr: request.pr, requestedHead: request.head, head: entry.head ?? null, verdict: entry.verdict, reviewed: entry.reviewed, mustFix: entry.mustFix, reviewRoute: entry.reviewRoute, resultPath });
+      } else {
+        emit('review-result-missing', { card: id, pr: request.pr, head: request.head, resultPath, waitedMs, reason: entry.detail });
+      }
+      out.push({ card: id, pr: request.pr, resultPath, status, entry });
+    }
+  }
+  return out;
+}
+
+/**
+ * 다음 수 판단의 입력 — 카드에 회수된 리뷰 결과 중 «그 머리(`head`)»의 «가장 최근» 결과가 실제로 돈(reviewed) pass 이고
+ * 리뷰한 머리가 40자 sha 일 때만 `selfReview` 모양으로 돌려준다(슈퍼바이저가 나르는 `self-implement-cli` 의 규칙과 같다 ·
+ * must-fix 수는 읽었을 때만). 머리마다 고르므로 여러 머리의 결과가 어떤 순서로 회수돼도 지금 머리의 판정만 본다.
+ * 그 밖(fail·warn·미실행·없음·다른 머리)은 undefined — 판단부 입력을 비워 둔다(«통과»로 읽지 않는다).
+ */
+export function capturedSelfReview(card: TaskCard | undefined, pr: number, head: string): { verdict: 'pass'; head: string; mustFixCount?: number } | undefined {
+  if (!SHA40.test(head)) return undefined;
+  const latest = (card?.history ?? []).filter((item) => item.event === LIVE_MOVE_RESULT_EVENT && item.kind === 'review' && item.pr === pr
+    && item.effect !== REVIEW_RESULT_MISSING_EFFECT && item.effect !== REVIEW_RESULT_UNREADABLE_EFFECT && typeof item.head === 'string' && item.head.toLowerCase() === head.toLowerCase()).at(-1);
+  // 결과 줄의 detail 은 리뷰 오류(`error`)일 때만 실린다 — 오류가 섞인 결과는 pass 후보가 아니다.
+  if (!latest || latest.detail || latest.reviewed !== true || latest.verdict !== 'pass' || !latest.head || !SHA40.test(latest.head)) return undefined;
+  return { verdict: 'pass', head: latest.head, ...(typeof latest.mustFix === 'number' ? { mustFixCount: latest.mustFix } : {}) };
+}
+
+/**
+ * TA-LAND-WARN-MUSTFIX0 — land 입력용: 그 머리의 «가장 최근» 회수 결과가 실제로 돈(reviewed) 리뷰이고 오류가 없으며
+ * verdict 가 pass «또는» warn 이면 돌려준다(정본 규칙 «warn ⊕ must-fix 0 = 통과» · #25941 canAuto · #25962).
+ * must-fix 수는 읽었을 때만 싣는다 — 0 인지는 호출부·land 관문이 본다(모르면 거부 · fail-closed).
+ * `capturedSelfReview`(판단부 입력 · pass 만)는 그대로 둔다 — 멈춤 시점 판단부의 정합은 이 함수의 몫이 아니다.
+ */
+export function capturedLandReview(card: TaskCard | undefined, pr: number, head: string): { verdict: 'pass' | 'warn'; head: string; reviewed: true; mustFixCount?: number } | undefined {
+  if (!SHA40.test(head)) return undefined;
+  const latest = (card?.history ?? []).filter((item) => item.event === LIVE_MOVE_RESULT_EVENT && item.kind === 'review' && item.pr === pr
+    && item.effect !== REVIEW_RESULT_MISSING_EFFECT && item.effect !== REVIEW_RESULT_UNREADABLE_EFFECT && typeof item.head === 'string' && item.head.toLowerCase() === head.toLowerCase()).at(-1);
+  if (!latest || latest.detail || latest.reviewed !== true || (latest.verdict !== 'pass' && latest.verdict !== 'warn') || !latest.head || !SHA40.test(latest.head)) return undefined;
+  return { verdict: latest.verdict, head: latest.head, reviewed: true, ...(typeof latest.mustFix === 'number' ? { mustFixCount: latest.mustFix } : {}) };
+}
+
+/** 그 PR 에 회수된 «돈 pass» 결과가 하나라도 있나 — 지금 머리를 조회(gh)할지 정하는 싼 검사. */
+export function hasCapturedPass(card: TaskCard | undefined, pr: number): boolean {
+  return (card?.history ?? []).some((item) => item.event === LIVE_MOVE_RESULT_EVENT && item.kind === 'review' && item.pr === pr
+    && !item.detail && item.reviewed === true && item.verdict === 'pass' && typeof item.head === 'string' && SHA40.test(item.head));
+}