elanous 0.2.27 → 0.2.29

package/src/task-agent/live-moves.ts

@@ -15,7 +15,7 @@
  * - 관측: 실행한 수마다 `debug.log('task-agent', 'live-move', {kind, card, ok, detail, live:true})`.
  */
 import { spawn, spawnSync } from 'node:child_process';
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { closeSync, mkdirSync, openSync, readFileSync, statSync } from 'node:fs';
 import { dirname, isAbsolute, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
@@ -25,9 +25,9 @@ import type { DetachedSpawn } from '../cli/tasks-cli.js';
 import { LIVE_MOVE_HISTORY_EVENT, taskAgentStatePath, updateTaskCard, type TaskCard } from './task-hand.js';
 import { LIVE_RETRY_MOVES } from './judge.js';
 import { decisionCardGrounds, decisionRaiseArgs, type DecisionCardEvidence, type NextAction } from './actions.js';
-import { reviewResultPath, TA_REVIEW_COMPLETION_CARD_ENV, TA_REVIEW_COMPLETION_RESULT_ENV, TA_REVIEW_COMPLETION_STATE_ENV } from './review-result-capture.js';
+import { pendingReviewResults, reviewResultPath, TA_REVIEW_COMPLETION_CARD_ENV, TA_REVIEW_COMPLETION_RESULT_ENV, TA_REVIEW_COMPLETION_STATE_ENV } from './review-result-capture.js';
 import { buildPriorFixContext, PRIOR_FIX_SCOPE_LINE, priorFixBlock, priorFixObservation, type PriorDiffReader, type PriorFixContext } from './review-prior-fix.js';
-import { createLandWorktree, localHead, observeLandWorktree, type LandWorktree, type LandWorktreeFailure, type LandWorktreeInput, type LandWorktreeRemoval } from './land-worktree.js';
+import { createLandWorktree, localBranch, localHead, observeLandWorktree, type LandWorktree, type LandWorktreeFailure, type LandWorktreeInput, type LandWorktreeRemoval } from './land-worktree.js';
 
 export const TASK_AGENT_LIVE_MOVES = ['review', 'propose-green', 'propose-land', 'decision-card', ...LIVE_RETRY_MOVES] as const;
 export type TaskAgentLiveMove = typeof TASK_AGENT_LIVE_MOVES[number];
@@ -89,7 +89,7 @@ export interface LiveMoveDeps {
   raiseDecision?: (args: string[]) => Promise<{ status: number; stdout: string; stderr?: string }>;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
   /** TA-LAND-WORKTREE — cwd HEAD 읽기 · PR 머리 임시 워크트리 만들기(시험 주입 · 기본 = git). */
-  landWorktree?: { localHead?: (cwd: string) => string | null; create?: (input: LandWorktreeInput) => Promise<LandWorktree | LandWorktreeFailure> };
+  landWorktree?: { localHead?: (cwd: string) => string | null; localBranch?: (cwd: string) => string | null; create?: (input: LandWorktreeInput) => Promise<LandWorktree | LandWorktreeFailure> };
 }
 
 /** `executed` = 부작용을 실제로 냈다(리뷰를 띄웠다 · 제안을 적었다). ok 이지만 이미 한 수(같은 머리·이미 제안)면 false. */
@@ -317,7 +317,7 @@ function observe(deps: LiveMoveDeps, result: LiveMoveResult): LiveMoveResult {
 /** `review` — PR 머리마다 한 번. 카드에 먼저 적고(잠금 안) 그다음 띄운다 · 띄우기 실패는 카드에 오류로 남기고 같은 머리는 다시 안 띄운다. */
 export async function executeLiveReview(
   card: TaskCard | undefined, pr: number | undefined,
-  ctx: { runId: string | null; stopReason: string; cwd?: string; produced?: { headCommit?: string; branch?: string; prUrl?: string } },
+  ctx: { runId: string | null; stopReason: string; cwd?: string; forceNewReview?: boolean; produced?: { headCommit?: string; branch?: string; prUrl?: string } },
   deps: LiveMoveDeps = {},
 ): Promise<LiveMoveResult> {
   const kind = 'review' as const;
@@ -345,12 +345,16 @@ export async function executeLiveReview(
   const path = deps.statePath ?? taskAgentStatePath();
   const at = (deps.now ?? (() => new Date()))().toISOString();
   // TA-REVIEW-RESULT-CAPTURE — 머리마다 한 번이라 경로도 머리마다 하나다. 요청 칸에 먼저 적는다(회수가 이 칸을 본다).
-  const resultPath = reviewResultPath(path, card.id, pr, head.head);
+  const resultPath = ctx.forceNewReview
+    ? reviewResultPath(path, card.id, pr, head.head).replace(/\.json$/, `-${randomUUID()}.json`)
+    : reviewResultPath(path, card.id, pr, head.head);
   const claim: { claimed: boolean; missing: boolean; before?: TaskCard } = { claimed: false, missing: false };
   updateTaskCard(path, card.id, (current) => {
     if (!current) { claim.missing = true; return undefined; }
     // 머리 «이력»으로 본다 — A→B→A 로 돌아와도 A 는 다시 요청하지 않는다.
-    if ((current.reviewRequests ?? []).some((entry) => entry.pr === pr && entry.head === head!.head)) return undefined;
+    if (ctx.forceNewReview) {
+      if (pendingReviewResults(current).some((entry) => entry.pr === pr && entry.head === head!.head)) return undefined;
+    } else if ((current.reviewRequests ?? []).some((entry) => entry.pr === pr && entry.head === head!.head)) return undefined;
     claim.claimed = true;
     claim.before = current;
     return { ...current, reviewRequests: [...(current.reviewRequests ?? []), { pr, head: head!.head, at, resultPath }] };
@@ -416,6 +420,12 @@ const LAND_BASE_STALE_LINE = /^✗ overlap-evidence: (base-stale-overlap: .*)$/;
 const LAND_BASE_STALE_CONSEQUENCE_LINES: readonly RegExp[] = [/^✗ expected-head: overlap merge approval unavailable for the reviewed head$/];
 /** 실패가 아닌 ✗ 줄 — `pr land` 가 «계속합니다»로 넘어간다(판정에 쓰지 않는다). */
 const LAND_NON_FATAL_LINES: readonly RegExp[] = [/^✗ active-run-files: .*계속합니다\.?$/];
+const TSC_RUNTIME_MISSING = /(?:^|\n)(?:sh: )?(?:env: )?(?:[^\s]*\/)?(?:node|bun|tsc): (?:No such file or directory|command not found)/m;
+const TSC_NOT_RUN = /(?:tsc 종료코드 127|tsc 실행 실패 \([^\n]*code=ENOENT)/;
+const TSC_GATE_REFUSED = '✗ typecheck: scripts/ci-typecheck-changed.ts blocked pr land.';
+function missingTscRuntime(text: string): boolean {
+  return TSC_NOT_RUN.test(text) && TSC_RUNTIME_MISSING.test(text);
+}
 /** executeLiveLand 쪽 인프라 사유(출력 줄이 아니라 실행 사실). */
 export const LAND_INFRA_EXECUTOR_REASONS = ['land-process-error', 'land-no-result-line'] as const;
 const [LAND_PROCESS_ERROR, LAND_NO_RESULT_LINE] = LAND_INFRA_EXECUTOR_REASONS;
@@ -435,6 +445,12 @@ export function classifyLandFailure(outcome: { status: number; stdout?: string;
   // 결과 줄이 «하나도» 없이 0 아닌 코드로 끝났다 — 관문까지 못 간 채 죽었다(크래시 · 신호).
   if (!marked.length) return outcome.status !== 0 ? { class: 'infra', reason: LAND_NO_RESULT_LINE } : { class: 'judgement', reason: 'no-failure-line' };
   const failures = marked.map((line) => line.replace(/^\[dry-run\] /, '')).filter((line) => line.startsWith('✗') && !LAND_NON_FATAL_LINES.some((re) => re.test(line)));
+  // The gate did not measure TypeScript when its interpreter was absent. The
+  // exact typecheck refusal alone remains judgement; require rc127/ENOENT and
+  // the missing runtime line, with no second failing gate.
+  if (failures.length === 1 && failures[0] === TSC_GATE_REFUSED && missingTscRuntime(lines.join('\n'))) {
+    return { class: 'infra', reason: 'tsc-runtime-missing' };
+  }
   const infra = new Set<string>();
   const unlisted: string[] = [];
   for (const line of failures) {
@@ -497,7 +513,15 @@ function observeLandWorktreeCreateCapped(deps: LiveMoveDeps, data: { card: strin
 
 /** 같은 머리에 한 번 더 시도해도 되나 — 앞 시도가 «전부» 끝났고(ok:false) «전부» infra 이고 상한 밑일 때만. */
 function landRetryAllowed(prior: readonly LandAttempt[]): boolean {
-  return prior.length > 0 && prior.length < LAND_ATTEMPTS_PER_HEAD_ON_INFRA && prior.every((entry) => entry.ok === false && entry.class === 'infra');
+  return prior.length > 0 && prior.length < LAND_ATTEMPTS_PER_HEAD_ON_INFRA
+    && prior.every((entry) => entry.ok === false && (entry.class === 'infra' || legacyMissingTscRuntime(entry)));
+}
+
+/** A previous release classified a missing node interpreter as judgement; only that exact recorded shape may be reopened. */
+function legacyMissingTscRuntime(entry: LandAttempt): boolean {
+  return entry.ok === false && entry.class === 'judgement' && entry.reason === TSC_GATE_REFUSED
+    && typeof entry.detail === 'string'
+    && classifyLandFailure({ status: 1, stderr: entry.detail }).reason === 'tsc-runtime-missing';
 }
 
 /**
@@ -566,7 +590,8 @@ export async function executeLiveLand(
   const at = (deps.now ?? (() => new Date()))().toISOString();
   const local = (deps.landWorktree?.localHead ?? localHead)(cwd);
   const landKey = `land:${card.id}:${view.head.slice(0, 12)}`;
-  const needsLandWorktree = !!local && local.toLowerCase() !== view.head.toLowerCase();
+  const branch = local?.toLowerCase() === view.head.toLowerCase() ? (deps.landWorktree?.localBranch ?? localBranch)(cwd) : null;
+  const needsLandWorktree = !!local && (local.toLowerCase() !== view.head.toLowerCase() || branch !== view.branch);
   const createCap = landWorktreeCreateCap();
   let claimed = false;
   let missing = false;
@@ -603,7 +628,8 @@ export async function executeLiveLand(
   const attempt = prior.length + 1;
   if (attempt > 1) {
     const last = prior.at(-1)!;
-    try { (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('task-agent', LAND_RETRY_ON_INFRA_EVENT, { card: card.id, pr, head: view.head, attempt, reason: last.reason ?? 'unknown', class: 'infra', decision: 'retrying' }); } catch { /* fail-soft */ }
+    const legacy = legacyMissingTscRuntime(last);
+    try { (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('task-agent', LAND_RETRY_ON_INFRA_EVENT, { card: card.id, pr, head: view.head, attempt, reason: legacy ? 'tsc-runtime-missing-legacy' : last.reason ?? 'unknown', class: 'infra', decision: legacy ? 'legacy-reclassified-retrying' : 'retrying' }); } catch { /* fail-soft */ }
   }
   if (cycle) landedCycles.add(cycle);
   // TA-LAND-WORKTREE — `pr land --expected-head` 는 «로컬 HEAD = 고정 머리»를 요구한다. cwd 가 다른 머리면(Pod 런 PR · 호스트 checkout)
@@ -618,6 +644,11 @@ export async function executeLiveLand(
     if ('reason' in made) {
       const reason = made.reason;
       observeLandWorktree({ card: card.id, pr, head: view.head, created: made.created, removed: made.removed, reason }, deps.log);
+      if (made.kind === 'worktree-conflict') {
+        try { (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('task-agent', 'worktree-conflict', {
+          card: card.id, pr, head: view.head, branch: view.branch ?? null, ownerPath: made.ownerPath ?? 'unknown', reason,
+        }); } catch { /* fail-soft */ }
+      }
       let failures: LandWorktreeCreateFailure[] = [];
       let recordFailureError: unknown;
       try {
@@ -655,7 +686,7 @@ export async function executeLiveLand(
     } catch (error) {
       try { (deps.log ?? ((c, e, d) => debug.log(c, e, d, { level: 'warn' })))('task-agent', 'land-worktree-create-failures-clear-failed', { card: card.id, pr, head: view.head, error: String(error).slice(-200) }); } catch { /* fail-soft */ }
     }
-    observeLandWorktree({ card: card.id, pr, head: view.head, created: true, removed: false, reason: `cwd HEAD ${local.slice(0, 12)} ≠ PR head ${view.head.slice(0, 12)}` }, deps.log);
+    observeLandWorktree({ card: card.id, pr, head: view.head, created: made.created ?? null, removed: false, reason: `cwd HEAD ${local.slice(0, 12)} · branch ${branch ?? 'unknown'} differs from PR ${view.head.slice(0, 12)} · ${view.branch ?? 'unknown'}` }, deps.log);
   }
   // 증거 경로는 «원래» cwd 기준으로 고정한다 — 임시 트리로 cwd 를 바꿔도 상대경로가 다른 파일을 가리키지 않게(같은 cwd 면 그대로).
   const overlapEvidence = ctx.overlapEvidence && worktree ? resolve(cwd, ctx.overlapEvidence) : ctx.overlapEvidence;
@@ -681,7 +712,7 @@ export async function executeLiveLand(
     // 성공이든 실패든 걷는다.
     let removal: LandWorktreeRemoval;
     try { removal = worktree.cleanup(); } catch (error) { removal = { removed: false, reason: String(error).slice(-200) }; }
-    observeLandWorktree({ card: card.id, pr, head: view.head, created: true, removed: removal.removed, ...(removal.branchRemoved !== undefined ? { branchRemoved: removal.branchRemoved } : {}),
+    observeLandWorktree({ card: card.id, pr, head: view.head, created: worktree.created ?? null, removed: removal.removed, ...(removal.branchRemoved !== undefined ? { branchRemoved: removal.branchRemoved } : {}),
       reason: removal.reason ?? `land ${ok ? 'ok' : 'failed'} — removed` }, deps.log);
   }
   const landAttempt: LiveMoveResult['landAttempt'] = failure

package/src/task-agent/parent-host.ts

@@ -159,7 +159,7 @@ export function remoteLaunchScript(target: ParentHostConfig, args: readonly stri
   const elanous = target.elanous ?? DEFAULT_REMOTE_ELANOUS;
   const configDir = target.configDir ?? DEFAULT_REMOTE_CONFIG_DIR;
   const log = remoteParentLogPath(target, env.ELANOUS_RUN_ID ?? 'unknown');
-  const envPart = Object.entries(env).filter(([key]) => /^[A-Z_][A-Z0-9_]*$/.test(key)).map(([key, value]) => `${key}=${shellQuote(value)}`).join(' ');
+  const envPart = [...Object.entries(env).filter(([key]) => key !== 'ELANOUS_STATE_DIR' && /^[A-Z_][A-Z0-9_]*$/.test(key)).map(([key, value]) => `${key}=${shellQuote(value)}`), `ELANOUS_STATE_DIR=${remotePath(configDir)}`].join(' ');
   const argv = [remotePath(elanous), '--config-dir', remotePath(configDir), ...remoteParentArgs(args, target.podPool).map(shellQuote)].join(' ');
   // 준비가 실패하면 «확실히 안 띄웠다»(not-launched=…)를 찍고 끝낸다 — 그때만 호출부가 로컬로 돌아간다.
   // 띄운 뒤에는 짧게 살아 있는지 보고 pid 를 찍는다(조기 종료면 early-exit — 역시 «안 돈다»가 확실).

package/src/task-agent/postland-card.ts

@@ -0,0 +1,139 @@
+import { debug } from '../debug/log.js';
+import { listChecklist, setItemIfSnapshot, type Checklist } from '../release-loop/checklist.js';
+import { judgeLandedCell, parseJudgeSignals, type GreenVerdict } from '../release-loop/landed-to-green.js';
+import { cardPrNumber, readTaskAgentState, taskAgentStatePath, updateTaskCard, type TaskCard } from './task-hand.js';
+
+export interface LandedTaskPr { number: number; url: string; headRefOid: string; state: string; baseRefName: string; mergedAt: string; files?: Array<{ path: string }> }
+export interface PostlandDeps {
+  statePath?: string;
+  versions: readonly string[];
+  checklist?: (version: string) => Checklist;
+  setStatus?: typeof setItemIfSnapshot;
+  updateCard?: typeof updateTaskCard;
+  judge?: typeof judgeLandedCell;
+  log?: typeof debug.log;
+}
+
+/** Read-only PR binding for the legacy completion guard, including when judgment or ledger I/O fails. */
+export function boundMergedTaskCells(pr: Pick<LandedTaskPr, 'number' | 'url'>, statePath = taskAgentStatePath()): string[] {
+  const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(statePath).tasks ?? {};
+  const cards = Object.values(tasks).filter((card) => card.taLand && card.checklistId && cardPrNumber(card) === pr.number
+    && typeof card.pr === 'object' && card.pr.url?.replace(/\/+$/, '') === pr.url.replace(/\/+$/, ''));
+  return [...new Set(cards.map((card) => card.checklistId!))];
+}
+
+/** When the PR API omits URL/head, keep candidate TA cells out of the prose-only green path. */
+export function candidateMergedTaskCells(number: number, statePath = taskAgentStatePath()): string[] {
+  const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(statePath).tasks ?? {};
+  return [...new Set(Object.values(tasks).filter((card) => card.taLand && card.checklistId && cardPrNumber(card) === number).map((card) => card.checklistId!))];
+}
+
+/** A bound TA card closes only after its exact PR and a unique release cell are confirmed. */
+export function closeMergedTaskCard(pr: LandedTaskPr, cwd: string, deps: PostlandDeps): string | null {
+  const log = deps.log ?? debug.log.bind(debug);
+  if (pr.state !== 'MERGED' || pr.baseRefName !== 'main' || !/^[a-f0-9]{40}$/i.test(pr.headRefOid) || !pr.url) return null;
+  const path = deps.statePath ?? taskAgentStatePath();
+  const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(path).tasks ?? {};
+  const cards = Object.values(tasks).filter((card) => card.taLand && card.checklistId && cardPrNumber(card) === pr.number
+    && typeof card.pr === 'object' && card.pr.url?.replace(/\/+$/, '') === pr.url.replace(/\/+$/, ''));
+  if (cards.length !== 1) {
+    log('task-agent', 'postland-card-skipped', { pr: pr.number, reason: cards.length ? 'ambiguous-card' : 'no-bound-card' });
+    return null;
+  }
+  const card = cards[0]!;
+  if (!(card.landAttempts ?? []).some((attempt) => attempt.pr === pr.number && attempt.head.toLowerCase() === pr.headRefOid.toLowerCase())) {
+    log('task-agent', 'postland-card-skipped', { pr: pr.number, card: card.id, reason: 'land-head-not-bound' });
+    return null;
+  }
+  const candidateVersions = card.checklistVersion ? [card.checklistVersion] : deps.versions;
+  const cells = candidateVersions.flatMap((version) => {
+    const snapshot = (deps.checklist ?? listChecklist)(version);
+    const item = snapshot.items.find((row) => row.id === card.checklistId);
+    return item ? [{ version, snapshot, item }] : [];
+  });
+  if (cells.length !== 1) {
+    log('task-agent', 'postland-card-skipped', { pr: pr.number, card: card.id, reason: cells.length ? 'ambiguous-cell-version' : 'cell-not-found' });
+    return null;
+  }
+  const { version, item } = cells[0]!;
+  const expected = { title: item.title, status: item.status, evidence: item.evidence };
+  const expectedTitle = expected.title;
+  const prior = (card as TaskCard & { postLand?: { pr: number; head: string; outcome: 'complete' | 'partial'; evidence: string[] } }).postLand;
+  const marker = `TA postland #${pr.number}/${pr.headRefOid.slice(0, 12)}:`;
+  const currentEvidenceLine = item.evidence?.split('\n').find((line) => line.startsWith(marker));
+  const terminalBound = card.status === 'done' && card.prTerminal?.pr === pr.number
+    && card.prTerminal.head.toLowerCase() === pr.headRefOid.toLowerCase()
+    && card.prTerminal.url.replace(/\/+$/, '') === pr.url.replace(/\/+$/, '');
+  if (prior?.pr === pr.number && prior.head.toLowerCase() === pr.headRefOid.toLowerCase()
+    && prior.outcome === 'complete' && terminalBound && item.status === 'green' && currentEvidenceLine
+    && prior.evidence?.length && prior.evidence.every((part) => currentEvidenceLine.includes(part))) return item.id;
+  const alreadyGreen = item.status === 'green';
+  let verdict: GreenVerdict | undefined = alreadyGreen ? 'proposed' : undefined;
+  let judgeError: string | undefined;
+  if (!alreadyGreen) {
+    try { verdict = (deps.judge ?? judgeLandedCell)({ version, id: item.id, title: expectedTitle, pr: pr.number }, { cwd }); }
+    catch (error) { judgeError = String(error).slice(0, 240); }
+  }
+  const complete = verdict === 'proposed';
+  const criterion = expectedTitle.split(/\r?\n/).filter((line) => /^\s*판정(?: 신호)?:/.test(line)).map((line) => line.trim());
+  const remaining = complete ? [] : criterion.length ? criterion : ['판정 줄 없음 — 칸 주인의 판정 필요'];
+  const allPaths = (pr.files ?? []).map((file) => file.path).filter(Boolean);
+  const paths = allPaths.slice(0, 20);
+  const omitted = allPaths.length - paths.length;
+  const observations = parseJudgeSignals(expectedTitle).map((signal) => signal.observe).filter((value): value is string => !!value);
+  const judgeEvidence = alreadyGreen ? '기존 green 상태 확인(새 측정 0)' : judgeError
+    ? `판정 실행 오류: ${judgeError}`
+    : `판정 ${verdict ?? 'error'}: ${observations.length ? observations.join(' · ') : '측정 명령 없음'}${verdict === 'proposed' ? ' → exit 0' : ''}`;
+  const changed = paths.length ? `changed: ${paths.join(' · ')}${omitted ? ` · 외 ${omitted}개(${pr.url}에서 전체 확인)` : ''}`
+    : `changed: 경로 목록 미제공(${pr.url} 참조)`;
+  const filled = [`PR #${pr.number} merged, head ${pr.headRefOid}`, `카드 land head 대조 일치`, changed, judgeEvidence];
+  const note = complete
+    ? `${marker} ${filled.join(' | ')}; ${alreadyGreen ? '기존 green 유지' : '판정 신호 통과 → green'}.`
+    : `${marker} 이 조각이 채운 것: ${filled.join(' | ')}; 남은 것: ${remaining.join(' | ')}; 다음 조각 retitle 후보: ${remaining[0]}`;
+  const priorLines = item.evidence?.split('\n').filter((line) => !line.startsWith(marker)) ?? [];
+  const evidence = [...priorLines, note].join('\n');
+  const desiredStatus = complete ? 'green' : item.status === 'red' ? 'red' : 'yellow';
+  if (prior?.pr === pr.number && prior.head.toLowerCase() === pr.headRefOid.toLowerCase()
+    && prior.outcome === (complete ? 'complete' : 'partial') && terminalBound
+    && item.status === desiredStatus && item.evidence === evidence) return item.id;
+  const at = new Date().toISOString();
+  let wrote = false;
+  // The card lock protects the binding through the ledger write. A failed ledger write
+  // throws before the card changes, so the next pass can retry both records.
+  (deps.updateCard ?? updateTaskCard)(path, card.id, (current, currentTasks) => {
+    const matching = Object.values(currentTasks).filter((candidate) => candidate.taLand && cardPrNumber(candidate) === pr.number
+      && typeof candidate.pr === 'object' && candidate.pr.url?.replace(/\/+$/, '') === pr.url.replace(/\/+$/, ''));
+    if (matching.length !== 1 || matching[0]?.id !== card.id) return undefined;
+    if (!current || cardPrNumber(current) !== pr.number || current.checklistId !== item.id
+      || current.checklistVersion !== card.checklistVersion || typeof current.pr !== 'object'
+      || current.pr.url?.replace(/\/+$/, '') !== pr.url.replace(/\/+$/, '')
+      || !(current.landAttempts ?? []).some((attempt) => attempt.pr === pr.number && attempt.head.toLowerCase() === pr.headRefOid.toLowerCase())) return undefined;
+    const existing = (current as TaskCard & { postLand?: { pr: number; head: string; outcome: 'complete' | 'partial' } }).postLand;
+    const currentTerminalBound = current.status === 'done' && current.prTerminal?.pr === pr.number
+      && current.prTerminal.head.toLowerCase() === pr.headRefOid.toLowerCase()
+      && current.prTerminal.url.replace(/\/+$/, '') === pr.url.replace(/\/+$/, '');
+    if (existing?.pr === pr.number && existing.head.toLowerCase() === pr.headRefOid.toLowerCase()
+      && existing.outcome === (complete ? 'complete' : 'partial') && currentTerminalBound
+      && item.status === desiredStatus && item.evidence === evidence) return undefined;
+    const currentVersions = current.checklistVersion ? [current.checklistVersion] : deps.versions;
+    const currentCells = currentVersions.flatMap((candidateVersion) =>
+      (deps.checklist ?? listChecklist)(candidateVersion).items.some((row) => row.id === item.id) ? [candidateVersion] : []);
+    if (currentCells.length !== 1 || currentCells[0] !== version) return undefined;
+    (deps.setStatus ?? setItemIfSnapshot)(version, item.id, { evidence, status: desiredStatus }, 'task-agent', expected);
+    wrote = true;
+    const sameOutcome = existing?.pr === pr.number && existing.head.toLowerCase() === pr.headRefOid.toLowerCase()
+      && existing.outcome === (complete ? 'complete' : 'partial');
+    return { ...current,
+      status: 'done' as const,
+      prTerminal: { pr: pr.number, url: pr.url, head: pr.headRefOid, state: 'MERGED' as const, at },
+      postLand: { pr: pr.number, head: pr.headRefOid, at, outcome: complete ? 'complete' as const : 'partial' as const, evidence: filled, remaining },
+      history: sameOutcome ? current.history : [...current.history, { at, event: 'postland-card', pr: pr.number, head: pr.headRefOid, detail: complete ? `green ${version}/${item.id}` : `${desiredStatus} ${version}/${item.id}; ${remaining.join(' | ')}` }],
+    };
+  });
+  if (!wrote) {
+    log('task-agent', 'postland-card-pending', { pr: pr.number, card: card.id, version, id: item.id, reason: 'card-binding-changed-before-write' });
+    return item.id;
+  }
+  log('task-agent', 'postland-card-closed', { pr: pr.number, card: card.id, version, id: item.id, outcome: complete ? 'complete' : 'partial', verdict });
+  return item.id;
+}

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

@@ -40,9 +40,12 @@ import type { DetachedSpawn } from '../cli/tasks-cli.js';
 import { remoteLedgerMirrorDir } from './parent-host.js';
 import { appendLandOrderRow, joinLandOrderRow } from './land-order-ledger.js';
 import { recordLiveMoveHistory } from './live-move-history.js';
+import { runRepairCycle, type RepairLaunchRequest } from './repair-cycle.js';
+import { repairMustFixFromReview, repairReviewDigest } from './repair-review.js';
+import type { RepairCasOutcome, RepairCasRequest } from './repair-branch-cas.js';
 import { defaultLandPrHead, 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';
+import { capturedLandReview, captureReviewResults, parseReviewResultOutput, pendingReviewResults, reviewResultPath, type ParsedReviewResult } from './review-result-capture.js';
+import { boundPrTerminal, cardPrNumber, LIVE_MOVE_RESULT_EVENT, readTaskCard, taskAgentStatePath, updateTaskCard, type TaskCard } from './task-hand.js';
 
 export const REJUDGE_ON_HEAD_EVENT = 'rejudge-on-head';
 /** 카드·PR 당 재게이트하는 머리 수 상한(머리가 바뀔 때마다 하나) — 넘으면 멈추고 사람에게 넘긴다. */
@@ -52,7 +55,7 @@ export const CATCH_UP_CAP = 2;
 /** 떼어 띄운 재게이트 결과를 기다리는 상한 — 지나도 파일이 없으면 «결과 없음»으로 적는다(같은 머리는 다시 안 돌린다). */
 export const REGATE_RESULT_WAIT_MS = 90 * 60_000;
 
-export type RejudgeStep = 'regate' | 'review' | 'ready' | 'land' | 'target' | 'catch-up';
+export type RejudgeStep = 'regate' | 'review' | 'ready' | 'land' | 'target' | 'catch-up' | 'repair';
 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;
@@ -82,6 +85,12 @@ export interface RejudgeDeps {
   readyPr?: (pr: number, cwd: string) => Promise<{ ok: boolean; reason: string }>;
   /** 재게이트를 떼어 띄운다 — 시험은 주입한다. 기본은 `tasks regate-run` 자식(stdio ignore · 결과는 파일). */
   requestRegate?: (request: RegateRequest) => Promise<void>;
+  /** Source PR/head repair worker; absent uses the detached HQ local parent. */
+  requestRepair?: (request: RepairLaunchRequest) => Promise<void>;
+  applyRepair?: (request: RepairCasRequest) => RepairCasOutcome;
+  notifyRepair?: (seat: string, body: string) => void;
+  /** Shared new-launch budget for this `tasks rejudge --all` call. */
+  repairBudget?: import('./repair-cycle.js').RepairTickBudget;
   /** 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;
@@ -405,7 +414,9 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
   if (!card || pr === undefined) return target('no-pr', 'card has no bound PR');
   const reviews = (card.reviewRequests ?? []).filter((entry) => entry.pr === pr);
   // 원격 부모는 node-b 의 liveMoves 가 꺼져 리뷰 이력이 0일 수 있다. HQ 거울의 종결 증거가 있을 때만 시작한다.
-  if (!reviews.length && (!card.parentHost || !(deps.remoteRunTerminal ?? remoteBoundRunTerminal)(card)))
+  const adopted = card.adoptedPr?.pr === pr && typeof card.pr === 'object'
+    && !!card.pr.url && sameUrl(card.adoptedPr.url, card.pr.url) && /^[a-f0-9]{40}$/i.test(card.adoptedPr.head);
+  if (!reviews.length && !adopted && (!card.parentHost || !(deps.remoteRunTerminal ?? remoteBoundRunTerminal)(card)))
     return target('not-started', 'no task-agent review on this PR yet (remote terminal unproven or run not stopped/judged)', pr);
   // 떼어 띄운 재게이트 결과를 «머리와 무관하게» 먼저 회수한다 — 결과가 나오기 전에 머리가 또 바뀌어도 그 머리의 결과는 카드에 남는다.
   for (const pending of (card.regates ?? []).filter((entry) => entry.pr === pr && entry.passed === undefined && entry.resultPath)) {
@@ -442,10 +453,100 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
   if ('reason' in found) return target('pr-unreadable', found.reason, pr, fromHead);
   const { cwd, view } = found;
   const toHead = view.head;
+  if (view.state === 'MERGED' || view.state === 'CLOSED') {
+    const at = now().toISOString();
+    updateTaskCard(statePath, card.id, (current) => {
+      if (!current || cardPrNumber(current) !== pr || typeof current.pr !== 'object' || current.pr.url !== url) return undefined;
+      const previous = boundPrTerminal(current);
+      if (previous?.state === view.state && previous.head === toHead) return undefined;
+      return { ...current, prTerminal: { pr, url, head: toHead, state: view.state as 'MERGED' | 'CLOSED', at } };
+    });
+    return target('pr-not-open', `PR #${pr} is ${view.state}`, pr, fromHead, toHead);
+  }
   if (view.state !== 'OPEN') return target('pr-not-open', `PR #${pr} is ${view.state}`, pr, fromHead, toHead);
+  // An explicitly rejudged PR can be reopened. Clear the old marker before normal head judgement.
+  if (boundPrTerminal(card)) {
+    updateTaskCard(statePath, card.id, (current) => current && cardPrNumber(current) === pr && typeof current.pr === 'object' && current.pr.url === url
+      ? { ...current, prTerminal: undefined } : undefined);
+    card = readTaskCard(card.id, statePath) ?? card;
+  }
   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);
 
+  // Adoption is a first judgement for the current head, even when the implementation run
+  // already asked for a review. A captured failure needs repair; an accepted result must
+  // reach the host regate instead of stopping at the old same-head shortcut below.
+  const adoptedReview = adopted ? (card.history ?? []).filter((item) => item.event === LIVE_MOVE_RESULT_EVENT
+    && item.kind === 'review' && item.pr === pr && item.head && sameHead(item.head, toHead)
+    && item.reviewed === true && ['pass', 'warn', 'fail'].includes(item.verdict ?? '')).at(-1) : undefined;
+  if (adopted && !adoptedReview) {
+    if (reviews.some((entry) => sameHead(entry.head, toHead))) {
+      step('review', 'review-pending', `PR #${pr} head ${toHead.slice(0, 12)} already has a review request; await its result`, false);
+    } else if (!deps.liveMoves.has('review')) {
+      step('review', 'would-review', 'adopted PR first judgement · review not enabled in HQ taskAgent.liveMoves — shadow', false);
+    } else {
+      const before = { reviewRequests: card.reviewRequests, landAttempts: card.landAttempts };
+      const result = await executeLiveReview(card, pr, { runId: card.runId ?? null, stopReason: 'adopted-pr-first-judgement', 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 capturedForHead = (card.history ?? []).filter((item) => item.event === LIVE_MOVE_RESULT_EVENT
+    && item.kind === 'review' && item.pr === pr && item.head && sameHead(item.head, toHead)
+    && item.reviewed === true && ['pass', 'warn', 'fail'].includes(item.verdict ?? '')).at(-1);
+  if (capturedForHead && (capturedForHead.verdict === 'fail' || (capturedForHead.mustFix ?? 0) > 0)) {
+    const capturedPath = capturedForHead.resultPath;
+    const requestMatches = !!capturedPath && (card.reviewRequests ?? []).some((entry) => entry.pr === pr
+      && sameHead(entry.head, toHead) && entry.resultPath === capturedPath);
+    let mustFix: string[] | null = null;
+    try {
+      if (requestMatches && /^[0-9a-f]{64}$/.test(capturedForHead.reviewSha256 ?? '')) {
+        const text = read(capturedPath!);
+        if (repairReviewDigest(text) === capturedForHead.reviewSha256) mustFix = repairMustFixFromReview(text, pr, toHead);
+      }
+    } catch { /* fail closed below */ }
+    if (!mustFix && (deps.liveMoves.has('narrow-relaunch') || deps.liveMoves.has('salvage-relaunch') || deps.liveMoves.has('alternative'))
+      && !(card.repairs ?? []).some((entry) => entry.pr === pr && (entry.status === 'requested' || entry.status === 'unconfirmed'))) {
+      if (pendingReviewResults(card).some((entry) => entry.pr === pr && sameHead(entry.head, toHead))) {
+        step('review', 'review-pending', 'replacement exact-head review pending before repair', false);
+        return outcomes;
+      }
+      const originalPath = reviewResultPath(statePath, card.id, pr, toHead);
+      const retried = (card.reviewRequests ?? []).some((entry) => entry.pr === pr && sameHead(entry.head, toHead)
+        && entry.resultPath && entry.resultPath !== originalPath);
+      if (deps.liveMoves.has('review') && !retried) {
+        const before = { reviewRequests: card.reviewRequests, landAttempts: card.landAttempts };
+        const result = await executeLiveReview(card, pr, { runId: card.runId ?? null, stopReason: 'captured-review-identity-unavailable', cwd, forceNewReview: true },
+          { ...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;
+      }
+      step('repair', 'repair-stopped', 'captured review result identity missing or changed; request a new review', true);
+      return outcomes;
+    }
+    if (mustFix?.length || (card.repairs ?? []).some((entry) => entry.pr === pr && (entry.status === 'requested' || entry.status === 'unconfirmed'))) {
+      if (!view.branch) {
+        step('repair', 'repair-stopped', 'PR branch name unavailable', true);
+        return outcomes;
+      }
+      const result = await runRepairCycle({ card, statePath, repo: cwd, pr, head: toHead, branch: view.branch,
+        mustFix: mustFix ?? [], liveMoves: deps.liveMoves, now: now(), readFile: read,
+        ...(deps.requestRepair ? { request: deps.requestRepair } : {}),
+        ...(deps.applyRepair ? { apply: deps.applyRepair } : {}),
+        ...(deps.notifyRepair ? { notify: deps.notifyRepair } : {}),
+        ...(deps.repairBudget ? { repairBudget: deps.repairBudget } : {}) });
+      step('repair', result.decision, result.reason, true);
+      return outcomes;
+    }
+  }
+  if (adopted && (adoptedReview?.verdict === 'fail' || !capturedLandReview(card, pr, toHead)
+    || capturedLandReview(card, pr, toHead)?.mustFixCount !== 0)) {
+    step('review', 'repair-needed', `PR #${pr} head ${toHead.slice(0, 12)} review ${adoptedReview?.verdict ?? 'unknown'} · must-fix ${adoptedReview?.mustFix ?? 'unknown'} — owner repair`, true);
+    return outcomes;
+  }
+
   // A remote --ta-land parent leaves its PR draft. Only a captured review for this exact
   // head may let HQ make it ready; the regate runner deliberately rejects draft PRs.
   let readyConfirmed = false;
@@ -527,7 +628,7 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
   };
 
   // 기존 live 경로의 같은 머리 조기 반환은 유지한다. 완료 훅의 그림자 판단만 통과 리뷰를 다시 본다.
-  if (!regates.length && judgedHead && sameHead(toHead, judgedHead) && !landRetryPending(card, pr, toHead)) {
+  if (!adopted && !regates.length && judgedHead && sameHead(toHead, judgedHead) && !landRetryPending(card, pr, toHead)) {
     const unchangedReview = capturedLandReview(card, pr, toHead);
     if (!deps.shadowSameHead || deps.liveMoves.size !== 0 || !unchangedReview || !['pass', 'warn'].includes(unchangedReview.verdict) || unchangedReview.mustFixCount !== 0) {
       return target('head-unchanged', `PR #${pr} head is still the judged head`, pr, fromHead, toHead);
@@ -687,7 +788,8 @@ function recordMove(statePath: string, cardId: string, runId: string | undefined
 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)
-      || (card.status === 'launched' && card.taLand === true && !!card.parentHost && !!card.runId && !!card.runChildId));
+    return pr !== undefined && !boundPrTerminal(card) && ((card.reviewRequests ?? []).some((entry) => entry.pr === pr)
+      || (card.status === 'launched' && card.taLand === true && ((!!card.parentHost && !!card.runId && !!card.runChildId)
+        || (card.adoptedPr?.pr === pr && typeof card.pr === 'object' && !!card.pr.url && sameUrl(card.adoptedPr.url, card.pr.url)))));
   }).map((card) => card.id);
 }

package/src/task-agent/remote-rejudge-bind.ts

@@ -0,0 +1,91 @@
+/** Bind remote TA parents from the HQ ledger mirror before `rejudge --all` selects PR cards. */
+import { dirname } from 'node:path';
+import { debug } from '../debug/log.js';
+import { loadRunLedger } from '../self-implement/run-ledger.js';
+import { bindCardEvidence, podChildRunIds, readCardRunSnapshot, refreshCardRunBinding } from './card-evidence.js';
+import { mirrorRemoteRunLedgers, remoteLedgerMirrorDir } from './parent-host.js';
+import { cardPrNumber, type TaskCard } from './task-hand.js';
+
+const RECENT_LAUNCH_MS = 24 * 60 * 60 * 1000;
+
+type BindDeps = {
+  now?: () => number;
+  mirror?: typeof mirrorRemoteRunLedgers;
+  onFailure?: (failure: { card: string; runId: string; host: string; reason: string }) => void;
+};
+
+function recentlyLaunched(card: TaskCard, now: number): boolean {
+  const launch = [...card.history].reverse().find(event => event.event === 'launch');
+  const at = Date.parse(launch?.at ?? card.createdAt);
+  return Number.isFinite(at) && at <= now && now - at < RECENT_LAUNCH_MS;
+}
+
+/**
+ * A remote child PR can appear after the last HQ card refresh. A card without a PR is otherwise absent from
+ * `rejudgeCandidates`, so the normal rejudge tick never reaches `mirrorRemoteCardLedger` or the binding replay.
+ * Only an existing, launched TA-owned parent with a parent→child edge in its own host mirror is admitted. The
+ * launch registry (including foreign/test universes) and child-only ledgers are never scanned or adopted here.
+ */
+export async function bindMirroredRemoteRejudgeCards(
+  tasks: Readonly<Record<string, TaskCard>>, statePath: string,
+  deps: BindDeps = {},
+): Promise<{ scanned: number; bound: number; skipped: number }> {
+  const root = dirname(statePath);
+  const now = (deps.now ?? Date.now)();
+  const mirror = deps.mirror ?? mirrorRemoteRunLedgers;
+  const reportFailure = (card: TaskCard, reason: string): void => {
+    const failure = { card: card.id, runId: card.runId!, host: card.parentHost!.host, reason: reason.slice(0, 300) };
+    try { (deps.onFailure ?? ((data) => debug.log('task-agent', 'remote-rejudge-bind-failed', data)))(failure); }
+    catch { /* observation must not stop the other cards */ }
+  };
+  let scanned = 0;
+  let bound = 0;
+  let skipped = 0;
+  for (const card of Object.values(tasks)) {
+    if (card.status !== 'launched' || card.taLand !== true || !card.parentHost || !card.runId
+      || cardPrNumber(card) !== undefined || card.refSource === 'manual') continue;
+    scanned++;
+    const dir = remoteLedgerMirrorDir(root, card.parentHost.host);
+    try {
+      // This prepass runs before PR-based candidate selection. Pulling here breaks the otherwise circular
+      // dependency: cards with a remote PR cannot be selected while their parent/child ledgers are absent locally.
+      // Limit fresh remote pulls to recent launches, but keep binding older ledgers already mirrored at HQ.
+      if (recentlyLaunched(card, now)) mirror(card.parentHost, card.runId, root);
+      const snapshot = await readCardRunSnapshot(card, {
+        loadLedger: (id) => loadRunLedger(id, dir),
+        podFinishes: () => [],
+      });
+      const parent = snapshot.host;
+      const evidence = bindCardEvidence(card, snapshot);
+      const childRunId = evidence.childRunId;
+      const pr = evidence.pr;
+      const child = childRunId ? snapshot.children[childRunId] : null;
+      if (snapshot.readErrors?.length) {
+        reportFailure(card, snapshot.readErrors.join('; '));
+        skipped++;
+        continue;
+      }
+      // A PR event alone is not a completed remote run. The rejudge candidate must have the same exact
+      // child PR and terminal status that remoteBoundRunTerminal will later require.
+      if (!parent || !childRunId || !pr?.url || !child
+        || !podChildRunIds(parent, card.runId).includes(childRunId)
+        || !child.some((entry) => entry.event === 'pr-opened' && entry.data?.number === pr.number
+          && entry.data?.url === pr.url)
+        || !child.some((entry) => entry.event === 'run-status'
+          && ['completed', 'failed', 'cancelled'].includes(String(entry.data?.runStatus)))) { skipped++; continue; }
+      const result = await refreshCardRunBinding(card.id, statePath, {
+        // Reuse the verified snapshot so a second mirror read cannot silently change the selected PR.
+        loadLedger: (id) => id === card.runId ? [...parent] : snapshot.children[id] ? [...snapshot.children[id]!] : null,
+        // The remote mirror is the sole evidence for this prepass. Host logs can contain unrelated child receipts.
+        podFinishes: () => [],
+      });
+      if (result.card?.runId === card.runId && cardPrNumber(result.card) !== undefined
+        && result.card.runChildId && podChildRunIds(parent, card.runId).includes(result.card.runChildId)) bound++;
+      else skipped++;
+    } catch (error) {
+      skipped++;
+      reportFailure(card, error instanceof Error ? error.message : String(error));
+    }
+  }
+  return { scanned, bound, skipped };
+}