elanous 0.2.23 → 0.2.24

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

@@ -12,7 +12,13 @@
  *   ③ 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 …'}`.
  * - 대상: 카드에 묶인 PR(URL 로 저장소 확인) ⊕ 그 PR 로 TA 가 이미 리뷰를 요청한 카드(= 런이 멈춰 TA 판단이 시작됐다).
  * - 사람의 hold(draft PR)는 뒤집지 않는다 — 재게이트(`noMerge`)와 land 관문이 draft 를 거부한다.
  * - 허용: 설정 `taskAgent.liveMoves` 그대로 — 재게이트·land 는 `propose-land`, 리뷰 재요청은 `review` 가 있을 때만(없으면 «했을 수»).
@@ -24,9 +30,10 @@ 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 { 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';
@@ -50,8 +57,16 @@ export interface RejudgeDeps {
 }
 
 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`);
@@ -183,47 +198,60 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
   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);
+  //   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) {
+    step('regate', 'not-regating', `base-stale-overlap on head ${toHead.slice(0, 12)} but the stale regate has no baseCommit — needs owner`, true);
+    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 +282,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 로 돌아왔다 — 증거가 또 낡았다고 거절될 것이므로 land 하지 않는다(재게이트도 멱등 키로 0).
+  if (regate.staleBase && regate.baseCommit && sameHead(regate.baseCommit, regate.staleBase)) {
+    step('land', 'not-landing', `base-stale-overlap — re-gate on head ${toHead.slice(0, 12)} returned the same base ${regate.staleBase.slice(0, 12)} (did not advance) — no land, no further re-gate on this base; needs owner`, true);
+    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 +296,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/run-adopt.ts

@@ -0,0 +1,136 @@
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, resolve, sep } from 'node:path';
+import { debug } from '../debug/log.js';
+import { launchBindingRunIds, launchRegistryDir, readLaunchBinding } from '../harness/launch-registry.js';
+import { launchStampFromLedger } from '../harness/launch-stamp.js';
+import { normalizeRunId } from '../harness/harness-space.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { loadRunLedger, runLedgerDir } from '../self-implement/run-ledger.js';
+import { TASK_SEATS, updateTaskCard, type TaskCard, type TaskSeat } from './task-hand.js';
+
+export interface RunBirth {
+  runId: string;
+  goalPath?: string;
+  cwd: string;
+  runsDir?: string;
+  env: Readonly<Record<string, string | undefined>>;
+}
+
+export interface RunAdoptDeps {
+  /** 카드 상태 파일(시험 주입). 없으면 우주 뿌리(`instanceRoot`) 아래 `task-agent-actions.json` = `taskAgentStatePath()`. */
+  statePath?: string;
+  /** 우주 뿌리 해석 seam — 기본 `effectiveInstanceRoot()`(state·runsDir 를 만드는 같은 공용 해석). */
+  instanceRoot?: () => string;
+  registryDir?: string;
+  knownChecklistIds?: ReadonlySet<string>;
+  now?: () => Date;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+export type RunAdoptSkipReason = 'handed' | 'already-carded' | 'pod-child' | 'other-universe' | 'universe-mismatch';
+export type RunAdoptResult = { card: TaskCard; adopted: true } | { adopted: false; reason: RunAdoptSkipReason };
+
+function seatFromGoal(path: string | undefined): TaskSeat | undefined {
+  const seat = path?.replaceAll('\\', '/').match(/\/(?:seat-state|seats)\/(OP|TC|MK|UX)\//)?.[1];
+  return seat as TaskSeat | undefined;
+}
+
+function goalText(path: string | undefined, cwd: string): string {
+  if (!path) return '';
+  try {
+    const fullPath = isAbsolute(path) ? path : resolve(cwd, path);
+    return readFileSync(fullPath, 'utf8');
+  } catch { return ''; }
+}
+
+function checklistFromText(text: string, known: ReadonlySet<string>): string | undefined {
+  const explicit = /칸\s+([A-Za-z0-9][A-Za-z0-9_-]*)/.exec(text)?.[1];
+  if (explicit) return explicit;
+  const title = /(?:^|\n)제목:\s*([A-Za-z0-9][A-Za-z0-9_-]*?)-\d+\s+—/m.exec(text)?.[1];
+  return title && known.has(title) ? title : undefined;
+}
+
+/** 경로 정규화 — 심볼릭 링크(`/var`↔`/private/var` 등)·상대·후행 슬래시를 같은 값으로. 없는 꼬리는 있는 조상의 실경로에 붙인다. */
+function canonicalPath(path: string): string {
+  const absolute = resolve(path);
+  let head = absolute;
+  const tail: string[] = [];
+  while (!existsSync(head)) {
+    const parent = dirname(head);
+    if (parent === head) return absolute;
+    tail.unshift(basename(head));
+    head = parent;
+  }
+  try { return join(realpathSync(head), ...tail); } catch { return absolute; }
+}
+
+/** Adopt only a run belonging to this universe. The universe root is resolved once (`effectiveInstanceRoot()` unless a
+ *  state path is injected) and both the card state file and the run's `runsDir` are compared against it after canonical
+ *  path resolution. The runId check and write share updateTaskCard's lock.
+ *  A birth without `runsDir` cannot prove its universe and is skipped as `other-universe` (conservative); a `runsDir` that is
+ *  not `<root>/self-dev-runs` is skipped as `universe-mismatch` with both paths observed — never silently. */
+export function adoptRunCard(birth: RunBirth, deps: RunAdoptDeps = {}): RunAdoptResult {
+  const root = deps.statePath ? dirname(deps.statePath) : (deps.instanceRoot ?? effectiveInstanceRoot)();
+  const statePath = deps.statePath ?? join(root, 'task-agent-actions.json');
+  const log = deps.log ?? ((category: string, event: string, data: Record<string, unknown>) => debug.log(category, event, data));
+  const skip = (reason: RunAdoptSkipReason, extra: Record<string, unknown> = {}): RunAdoptResult => {
+    log('task-agent', 'run-adopt-skipped', { runId: birth.runId, reason, ...extra });
+    return { adopted: false, reason };
+  };
+  if (birth.env.ELANOUS_TASK_CARD_ID) return skip('handed');
+  if (birth.env.ELANOUS_POD_NAME) return skip('pod-child');
+  if (!birth.runsDir) return skip('other-universe', { statePath, runsDir: null });
+  const expectedRunsDir = canonicalPath(join(root, 'self-dev-runs'));
+  const runsDir = canonicalPath(birth.runsDir);
+  if (runsDir !== expectedRunsDir) return skip('universe-mismatch', { statePath, runsDir: birth.runsDir, expectedRunsDir, canonicalRunsDir: runsDir });
+  if (!birth.runId || birth.runId !== normalizeRunId(birth.runId) || birth.runId.includes(sep)) throw new Error(`invalid runId: ${birth.runId}`);
+  const text = goalText(birth.goalPath, birth.cwd);
+  const firstLine = text.split(/\r?\n/).find(line => line.trim())?.trim() ?? `harness run ${birth.runId}`;
+  let stamp = launchStampFromLedger(null);
+  try { stamp = launchStampFromLedger(loadRunLedger(birth.runId, runLedgerDir(root))); } catch { /* unreadable stamp is unknown */ }
+  const origin = stamp.entrance;
+  const actor = stamp.actor;
+  const seat = TASK_SEATS.find(candidate => candidate === actor) ?? seatFromGoal(birth.goalPath);
+  const checklistId = checklistFromText(text, deps.knownChecklistIds ?? new Set());
+  const id = `ta-${birth.runId}`;
+  let adopted = false;
+  const card = updateTaskCard(statePath, id, (current, tasks) => {
+    if (current || Object.values(tasks).some(candidate => candidate.runId === birth.runId)) return undefined;
+    adopted = true;
+    const at = (deps.now ?? (() => new Date()))().toISOString();
+    return {
+      id, text: firstLine, status: 'launched', runId: birth.runId,
+      ...(birth.goalPath ? { goal: birth.goalPath } : {}),
+      ...(seat ? { seat } : {}),
+      ...(checklistId ? { checklistId } : {}),
+      createdAt: at, history: [{ at, event: 'adopted', detail: origin }],
+    };
+  });
+  if (!adopted || !card) return skip('already-carded');
+  log('task-agent', 'run-adopted', { card: card.id, runId: birth.runId, origin, seat: seat ?? null, checklistId: checklistId ?? null });
+  return { card, adopted: true };
+}
+
+/** Explicit backfill for old launch bindings (`elanous tasks adopt-runs`); not part of the launch-time path.
+ *  The binding's launch-time `podName`/`taskCardId` stand in for the env, so Pod children and handed runs are skipped.
+ *  Bindings written before those fields existed carry no marker — the host registry is per-host `$TMPDIR`, and a Pod
+ *  child writes its binding inside its Pod, so such legacy rows are host-launched runs. */
+export function adoptUncardedRuns(deps: RunAdoptDeps = {}): { scanned: number; adopted: number; skipped: Partial<Record<RunAdoptSkipReason, number>> } {
+  const dir = deps.registryDir ?? launchRegistryDir();
+  const skipped: Partial<Record<RunAdoptSkipReason, number>> = {};
+  let scanned = 0;
+  let adopted = 0;
+  for (const runId of launchBindingRunIds(dir)) {
+    scanned++;
+    const binding = readLaunchBinding(runId, dir);
+    if (!binding?.runsDir) {
+      skipped['other-universe'] = (skipped['other-universe'] ?? 0) + 1;
+      (deps.log ?? ((category, event, data) => debug.log(category, event, data)))('task-agent', 'run-adopt-skipped', { runId, reason: 'other-universe' });
+      continue;
+    }
+    const result = adoptRunCard({ runId, cwd: binding.cwd, goalPath: binding.goalPath, runsDir: binding.runsDir, env: { ELANOUS_POD_NAME: binding.podName, ELANOUS_TASK_CARD_ID: binding.taskCardId } }, deps);
+    if (result.adopted) adopted++;
+    else skipped[result.reason] = (skipped[result.reason] ?? 0) + 1;
+  }
+  return { scanned, adopted, skipped };
+}

package/src/task-agent/shadow.ts

@@ -58,10 +58,28 @@ export interface TaskAgentShadowDeps {
   liveMoves?: ReadonlySet<TaskAgentLiveMove>;
   /** live 수의 부작용(리뷰 띄우기·PR 머리 조회·상태 파일) — 시험은 주입한다. */
   live?: LiveMoveDeps;
+  /** 카드 조회 상태 파일(시험 주입 · 운영 파일을 건드리지 않게). 기본 = `live.statePath` ⊕ `taskAgentStatePath()`. */
+  statePath?: string;
   /** Process env for the launched-run id (`ELANOUS_RUN_ID`) — test seam; default process.env. */
   env?: NodeJS.ProcessEnv;
 }
 
+/** 카드 조회 상태 파일 — 조회 경로 전부가 같은 파일을 본다. */
+function cardStatePath(deps: TaskAgentShadowDeps): string {
+  return deps.statePath ?? deps.live?.statePath ?? taskAgentStatePath();
+}
+
+/** 카드 «원장»(기록·회수 대상) — 카드를 읽은 파일과 같다. 주입한 카드 리더(`readCard`)만 있으면 `live.statePath` 가 없을 때 모른다. */
+function cardLedgerPath(deps: TaskAgentShadowDeps): string | undefined {
+  return deps.readCard ? deps.live?.statePath : cardStatePath(deps);
+}
+
+/** live 수의 의존 — 실행부가 적는 원장(리뷰 요청·착지 시도)도 카드를 읽은 파일과 같게 맞춘다. */
+function liveMoveDeps(deps: TaskAgentShadowDeps): LiveMoveDeps {
+  const ledger = cardLedgerPath(deps);
+  return { ...(deps.log ? { log: deps.log } : {}), ...deps.live, ...(ledger ? { statePath: ledger } : {}) };
+}
+
 /** 파일 산출물로 전달(elanous-out)하는 종결 종류 — 그 밖의 code-pr 밖 종류는 확인 증거를 판단부에서 기다린다. */
 const DELIVERY_KINDS: ReadonlySet<CompletionKind> = new Set<CompletionKind>(['research-report', 'artifact', 'content']);
 function isDeliveryKind(kind: CompletionKind | undefined): kind is DeliveryKind {
@@ -156,7 +174,7 @@ function shadowCompletion(card: TaskCard | undefined, lookupFailed: boolean): Co
 export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, deps: TaskAgentShadowDeps = {}): Promise<TaskAgentShadowMove> {
   // TA-REVIEW-RESULT-CAPTURE — 판단 «전»에 지난 live review 의 결과 파일을 회수한다(카드 원장을 아는 때만 · 던지지 않는다).
   //   대기 중인 요청이 없으면 아무것도 쓰지 않는다(결과 파일 없는 카드의 동작은 종전과 같다).
-  const reviewLedger = deps.live?.statePath ?? (deps.readCard ? undefined : taskAgentStatePath());
+  const reviewLedger = cardLedgerPath(deps);
   if (reviewLedger) {
     try { captureReviewResults(reviewLedger, { ...(deps.live?.now ? { now: deps.live.now } : {}), ...(deps.log ? { log: deps.log } : {}) }); } catch (error) {
       // fail-soft — 판단은 계속하되 원인은 남긴다.
@@ -167,12 +185,14 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
   let card: TaskCard | undefined;
   let cardLookupFailed = false;
   try {
-    card = successful ? (deps.readCard ?? readTaskCard)(successful.taskId) : undefined;
+    card = successful ? (deps.readCard ? deps.readCard(successful.taskId) : readTaskCard(successful.taskId, cardStatePath(deps))) : undefined;
     if (!card && successful && !deps.readCard) {
-      const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(taskAgentStatePath()).tasks ?? {};
+      const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(cardStatePath(deps)).tasks ?? {};
       const matches = Object.values(tasks).filter(candidate => candidate.status === 'launched' && candidate.text === successful.feature);
       if (matches.length === 1) card = matches[0];
     }
+    // TA-OWN-ALL-RUNS — 런 소유 카드: 입력 runId ⊕ 상속 ELANOUS_RUN_ID(Pod 자식의 부모 런) 중 카드 runId 와 «정확히» 같은 것만.
+    if (!card && !deps.readCard) card = runCardFor(input.runId, deps);
   } catch {
     // Card lookup is optional; preserve the original PR judgement when unavailable — but mark the completion kind as unmeasured.
     cardLookupFailed = true;
@@ -282,7 +302,7 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
             ...(prResult.branch ? { branch: prResult.branch } : {}),
             ...(prResult.prUrl ? { prUrl: prResult.prUrl } : {}),
           } } : {}),
-        }, { ...(deps.log ? { log: deps.log } : {}), ...deps.live });
+        }, liveMoveDeps(deps));
     } else if (liveKind === 'propose-land') {
       liveMove = await executeLiveLand(boundCard, prResult?.prNumber,
         { runId: input.runId, cycleId: input.cycleId, review: selfReview,
@@ -292,12 +312,12 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
             ...(prResult.branch ? { branch: prResult.branch } : {}),
             ...(prResult.prUrl ? { prUrl: prResult.prUrl } : {}),
           } } : {}),
-        }, { ...(deps.log ? { log: deps.log } : {}), ...deps.live });
+        }, liveMoveDeps(deps));
     } else {
       const evidence: Record<string, string> = {};
       if (boundCard && !delivery && judgeInput.prState === 'MERGED' && prResult) evidence[boundCard.id] = `#${prResult.prNumber}`;
       else if (boundCard && delivery && deps.mode === 'live' && executorResult === 'done') evidence[boundCard.id] = join(delivery.projectTarget, 'elanous-out', boundCard.id);
-      liveMove = executeLiveGreenProposal(boundCard, evidence, { ...(deps.log ? { log: deps.log } : {}), ...deps.live });
+      liveMove = executeLiveGreenProposal(boundCard, evidence, liveMoveDeps(deps));
     }
   }
   // 판단한 수마다 live/shadow 를 남긴다 — OP 가 «오판 건수»·«그림자 일치율»을 카드·수 종류로 잰다.
@@ -315,6 +335,29 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
   return liveMove ? { ...move, liveMove } : move;
 }
 
+/**
+ * 런 id 폴백 — 입력 runId(슈퍼바이저 · Pod 면 자식 런) → 상속 `ELANOUS_RUN_ID`(발사기가 넘긴 부모 런) 순으로,
+ * 카드 runId 와 정확히 같고 그 카드가 하나뿐일 때만 쓴다. 못 찾으면 추측하지 않고 이유 한 줄을 남긴다(조용한 미스 0).
+ */
+function runCardFor(runId: string | null | undefined, deps: TaskAgentShadowDeps): TaskCard | undefined {
+  const own = runId?.trim() || undefined;
+  const inherited = (deps.env ?? process.env)[HARNESS_RUN_ID_ENV]?.trim() || undefined;
+  if (!own && !inherited) return undefined;
+  const tasks = Object.values(readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(cardStatePath(deps)).tasks ?? {});
+  const tried: Array<{ source: 'run' | 'env'; id: string; bound: number }> = [];
+  for (const [source, id] of [['run', own], ['env', inherited]] as const) {
+    if (!id || tried.some((entry) => entry.id === id)) continue;
+    const bound = tasks.filter((candidate) => candidate.runId === id);
+    if (bound.length === 1) return bound[0];
+    tried.push({ source, id, bound: bound.length });
+  }
+  const reason = tried.map((entry) => `${entry.source === 'env' ? `env ${HARNESS_RUN_ID_ENV}` : 'runId'} ${entry.id}: ${entry.bound === 0 ? 'no card has this runId' : `${entry.bound} cards share this runId (ambiguous)`}`).join(' · ');
+  try {
+    (deps.log ?? ((c: string, e: string, d: Record<string, unknown>) => debug.log(c, e, d)))('task-agent', 'run-card-fallback-missed', { runId: own ?? null, inheritedRunId: inherited ?? null, tried, reason });
+  } catch { /* fail-soft */ }
+  return undefined;
+}
+
 /**
  * 카드 history 에 live-move 한 줄 — 상태 파일은 카드를 읽은 곳과 같아야 한다: 주입한 경로(`live.statePath`) 또는
  * 기본 리더를 썼을 때의 기본 경로. 주입한 카드 리더(`readCard`)만 있고 경로가 없으면 그 카드의 원장을 모른다 — 적지 않는다.
@@ -334,7 +377,7 @@ function recordLiveMoveOnCard(
   };
   try {
     if (!move.card) { fail('no task card bound to this move'); return; }
-    const statePath = deps.live?.statePath ?? (deps.readCard ? undefined : taskAgentStatePath());
+    const statePath = cardLedgerPath(deps);
     if (!statePath) { fail('card ledger unknown (injected readCard without live.statePath)'); return; }
     const card = move.card;
     // live 인데 실행부 결과가 없으면 «무엇이 일어났는지» 모른다 — 줄을 지어내지 않고 이유를 남긴다.
@@ -358,11 +401,11 @@ function recordLiveMoveOnCard(
 function liveCardFor(results: readonly SupervisorJobResult[], deps: TaskAgentShadowDeps, runId?: string | null): TaskCard | undefined {
   try {
     for (const result of results) {
-      const found = deps.readCard ? deps.readCard(result.taskId) : readTaskCard(result.taskId, deps.live?.statePath);
+      const found = deps.readCard ? deps.readCard(result.taskId) : readTaskCard(result.taskId, cardStatePath(deps));
       if (found) return found;
     }
     if (deps.readCard) return undefined;
-    const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(deps.live?.statePath ?? taskAgentStatePath()).tasks ?? {};
+    const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(cardStatePath(deps)).tasks ?? {};
     // TA-LIVE-LAND-2 — a Pod run's results carry the orchestrator task id, not the card id, and its feature may be the
     // authored goal rather than the handed sentence. `tasks hand --live` launched this process with ELANOUS_RUN_ID = the
     // card's runId (TA-CARD-RUN-LINK); the supervisor's runId may be the Pod child's. Either id bound to exactly one card is the match.
@@ -373,6 +416,7 @@ function liveCardFor(results: readonly SupervisorJobResult[], deps: TaskAgentSha
     }
     const features = new Set(results.map((result) => result.feature));
     const matches = Object.values(tasks).filter(candidate => candidate.status === 'launched' && features.has(candidate.text));
+    // runId ⊕ 상속 ELANOUS_RUN_ID 는 위에서 이미 봤다(판단부의 runCardFor 가 미스 이유를 남긴다).
     return matches.length === 1 ? matches[0] : undefined;
   } catch { return undefined; }
 }