elanous 0.2.25 → 0.2.28

package/src/task-agent/green-sweep.ts

@@ -0,0 +1,170 @@
+/**
+ * GREEN-FROM-LEDGER, first slice: decide from a bound card or an explicit
+ * checklist evidence line.  This module never writes a checklist or card.
+ */
+import type { ChecklistItem } from '../release-loop/checklist.js';
+import { debug } from '../debug/log.js';
+import { cardPrNumber, type TaskCard } from './task-hand.js';
+
+export type GreenSweepVerdict = 'green' | 'record-only' | 'skip';
+export interface GreenSweepCandidate {
+  cell: string;
+  pr: number;
+  source: 'card' | 'evidence';
+  card?: TaskCard;
+  ambiguousAcrossCards?: boolean;
+}
+export interface GreenSweepPr {
+  number: number;
+  state: string;
+  mergeSha?: string;
+  url?: string;
+}
+export interface GreenSweepDecision {
+  cell: string;
+  pr: number;
+  mergeSha: string | null;
+  source: GreenSweepCandidate['source'];
+  verdict: GreenSweepVerdict;
+  reason: string;
+  evidence: string;
+  existingEvidence: string;
+  /** Preview only; a later live operation may persist this complete value. */
+  plannedEvidence: string;
+}
+
+/** PR-body mentions are intentionally absent from this parser. */
+export function explicitEvidencePrs(evidence: string | undefined): number[] {
+  const numbers = new Set<number>();
+  for (const line of (evidence ?? '').split(/\r?\n/)) {
+    // A previous refusal is diagnostic text, never new landing evidence.
+    if (/^GREEN-FROM-LEDGER:/i.test(line) && !/· green ·/.test(line)) continue;
+    // A negated landing claim cannot establish this cell's PR ownership.
+    if (/미착지|미병합|예정|계획|아님|않음|안\s*함|보류|대기|실패|불가|아직|미완료|누락|못\s*함|(?:착지|병합)\s*전|\b(?:not\s+(?:yet\s+)?(?:merged|landed)|unmerged|pending|planned)\b/i.test(line)) continue;
+    // A PR number only counts when this cell's own evidence calls it landed.
+    for (const match of line.matchAll(/(?:착지|병합|merged|landed)\s*(?:PR\s*)?#(\d+)\b|(?:PR\s*)?#(\d+)\s*(?:착지|병합|merged|landed)(?=$|[^A-Za-z가-힣])/gi)) {
+      const number = Number(match[1] ?? match[2]);
+      if (Number.isSafeInteger(number) && number > 0) numbers.add(number);
+    }
+    for (const match of line.matchAll(/https?:\/\/github\.com\/[^/\s]+\/[^/\s]+\/pull\/(\d+)\b\s*(?:착지|병합|merged|landed)|(?:착지|병합|merged|landed)\s*https?:\/\/github\.com\/[^/\s]+\/[^/\s]+\/pull\/(\d+)\b/gi)) {
+      const number = Number(match[1] ?? match[2]);
+      if (Number.isSafeInteger(number) && number > 0) numbers.add(number);
+    }
+  }
+  return [...numbers];
+}
+
+export function greenSweepCandidates(item: ChecklistItem, version: string, cards: readonly TaskCard[]): GreenSweepCandidate[] {
+  if (item.status !== 'yellow' && item.status !== 'red') return [];
+  const candidates = new Map<number, GreenSweepCandidate>();
+  for (const number of explicitEvidencePrs(item.evidence)) candidates.set(number, { cell: item.id, pr: number, source: 'evidence' });
+  for (const card of cards) {
+    if (card.checklistId !== item.id || (card.checklistVersion && card.checklistVersion !== version)
+      || (card.completion ?? 'code-pr') !== 'code-pr') continue;
+    const pr = cardPrNumber(card);
+    if (!pr) continue;
+    // Multiple cards claiming one PR are ambiguous, even if one has a complete marker.
+    if (candidates.get(pr)?.source === 'card') candidates.set(pr, { cell: item.id, pr, source: 'card' });
+    else candidates.set(pr, { cell: item.id, pr, source: 'card', card });
+  }
+  return [...candidates.values()].map((candidate) => ({ ...candidate,
+    ambiguousAcrossCards: cards.filter((card) => cardPrNumber(card) === candidate.pr).length > 1,
+  })).sort((a, b) => a.pr - b.pr);
+}
+
+export function ambiguousGreenSweepPrs(items: readonly ChecklistItem[], version: string, cards: readonly TaskCard[]): Set<number> {
+  const claims = new Map<number, Set<string>>();
+  for (const item of items) {
+    const numbers = new Set(explicitEvidencePrs(item.evidence));
+    for (const card of cards) {
+      if (card.checklistId === item.id && (!card.checklistVersion || card.checklistVersion === version)
+        && (card.completion ?? 'code-pr') === 'code-pr') {
+        const pr = cardPrNumber(card);
+        if (pr) numbers.add(pr);
+      }
+    }
+    for (const pr of numbers) {
+      const cells = claims.get(pr) ?? new Set<string>();
+      cells.add(item.id);
+      claims.set(pr, cells);
+    }
+  }
+  return new Set([...claims].filter(([, cells]) => cells.size > 1).map(([pr]) => pr));
+}
+
+export function appendGreenSweepEvidence(existing: string | undefined, line: string): string {
+  const before = existing ?? '';
+  if (before.split(/\r?\n/).includes(line)) return before;
+  return `${before}${before && !before.endsWith('\n') ? '\n' : ''}${line}`;
+}
+
+/** A merge establishes ownership of a PR, not completion of a whole cell. */
+export function decideGreenSweep(input: {
+  item: ChecklistItem;
+  candidate: GreenSweepCandidate;
+  candidateCount: number;
+  pr: GreenSweepPr | null;
+  ancestor: boolean | null;
+  hold: boolean | null;
+  repositoryMatches?: boolean | null;
+  ambiguousAcrossCells?: boolean;
+}): GreenSweepDecision {
+  const { item, candidate, pr } = input;
+  const mergeSha = pr?.mergeSha && /^[a-f0-9]{40}$/i.test(pr.mergeSha) ? pr.mergeSha : null;
+  const result = (verdict: GreenSweepVerdict, reason: string): GreenSweepDecision => {
+    const evidence = `GREEN-FROM-LEDGER: PR #${candidate.pr}${mergeSha ? ` merged ${mergeSha}` : ''} · ${verdict} · ${reason}`;
+    return { cell: item.id, pr: candidate.pr, mergeSha, source: candidate.source, verdict, reason,
+      evidence, existingEvidence: item.evidence ?? '', plannedEvidence: appendGreenSweepEvidence(item.evidence, evidence) };
+  };
+  if (item.status !== 'yellow' && item.status !== 'red') return result('skip', 'cell-not-yellow');
+  if (item.status === 'red') return result('skip', 'red-cell-requires-owner');
+  if (!pr || pr.number !== candidate.pr) return result('skip', 'pr-unreadable');
+  if (input.repositoryMatches === false) return result('skip', 'repository-mismatch');
+  if (input.repositoryMatches !== true) return result('record-only', 'repository-unreadable');
+  if (pr.state !== 'MERGED') return result('skip', `pr-${pr.state.toLowerCase()}`);
+  if (!mergeSha) return result('skip', 'merge-sha-unreadable');
+  if (input.ancestor === null) return result('record-only', 'origin-main-ref-unverified');
+  if (!input.ancestor) return result('skip', 'merge-sha-not-on-origin-main');
+  const explicitUrls = [...(item.evidence ?? '').matchAll(/https?:\/\/github\.com\/[^/\s]+\/[^/\s]+\/pull\/\d+\b/gi)]
+    .map((match) => match[0]);
+  if (explicitUrls.some((url) => /\/pull\/(\d+)\b/.exec(url)?.[1] === String(candidate.pr)
+    && url.replace(/\/+$/, '').toLowerCase() !== (pr.url ?? '').replace(/\/+$/, '').toLowerCase()))
+    return result('skip', 'evidence-pr-url-mismatch');
+  if (/보류|중단|정지|\bhold\b/i.test(`${item.title}\n${item.evidence ?? ''}`))
+    return result('skip', 'cell-stop-evidence');
+  if (input.hold === null) return result('record-only', 'hold-state-unreadable');
+  if (input.hold) return result('skip', 'traffic-hold');
+  if (input.candidateCount !== 1) return result('record-only', 'multiple-piece-prs');
+  if (input.ambiguousAcrossCells) return result('record-only', 'ambiguous-pr-across-cells');
+  if (candidate.ambiguousAcrossCards) return result('record-only', 'ambiguous-pr-across-cards');
+  if (/남은|나머지|후속|조각|분할|미착지|미병합|예정|계획|(?:착지|병합)\s*(?:실패|불가|아직|미완료|누락|못\s*함)|PR\s*#\d+\s*누락|추가\s*(?:작업|실물|검증|배선|조각|PR|필요)|(?:착지|실물|판정|검증|승인|운영)\s*대기|대기\s*(?:중|필요)|[1-9]차|(?:작업|검증|확인|운영|수리|배선)\s*필요|(?:일부|부분)(?:\s*범위(?:만)?)?\s*완료|잔여|미충족|미달|미완료|대체\s*후보/i.test(`${item.title}\n${item.evidence ?? ''}`))
+    return result('record-only', 'remaining-or-multiple-piece-evidence');
+  const verdictLines = [...(item.evidence ?? '').matchAll(/(?:^|\n)\s*(?:판정|결론|상태)\s*:\s*([^\n]+)/gi)];
+  if (verdictLines.some((match) => !/^(?:green|완료|충족)(?:$|[\s·,.;])/i.test(match[1] ?? '')))
+    return result('record-only', 'conflicting-cell-verdict-evidence');
+  if (candidate.source === 'evidence') {
+    const fullCellProof = /(?:^|\n)\s*(?:판정|결론|상태)\s*:\s*(?:green|완료|충족)(?:$|[\s·,.;])/i;
+    return fullCellProof.test(item.evidence ?? '')
+      ? result('green', 'explicit-cell-completion-evidence')
+      : result('record-only', 'cell-completion-not-explicit');
+  }
+  const card = candidate.card;
+  if (!card) return result('record-only', 'ambiguous-card-binding');
+  if (!card.checklistVersion) return result('record-only', 'card-version-unbound');
+  if (card.status !== 'done') return result('record-only', 'card-not-done');
+  if (card.postLand && (card.postLand.outcome !== 'complete' || card.postLand.remaining.length > 0))
+    return result('record-only', 'card-post-land-incomplete');
+  if (card.history.some((event) => event.event === 'closed-by-hand'))
+    return result('record-only', 'card-stop-evidence');
+  if (typeof card.pr === 'object' && pr.url && card.pr.url
+    && card.pr.url.replace(/\/+$/, '') !== pr.url.replace(/\/+$/, ''))
+    return result('record-only', 'card-pr-url-mismatch');
+  if (card.prTerminal?.state === 'CLOSED') return result('record-only', 'card-terminal-conflict');
+  return result('green', card.postLand?.outcome === 'complete' ? 'bound-card-complete' : 'bound-card-merged');
+}
+
+/** Every candidate emits one structured decision, including refusals. */
+export function observeGreenSweep(decision: GreenSweepDecision, log: typeof debug.log = debug.log.bind(debug)): void {
+  log('task-agent.green-sweep', decision.verdict,
+    { cell: decision.cell, pr: decision.pr, mergeSha: decision.mergeSha, reason: decision.reason });
+}

package/src/task-agent/land-worktree.ts

@@ -24,7 +24,7 @@ const defaultGit: GitRun = (cwd, args) => {
 
 export interface LandWorktreeInput { card: string; pr: number; head: string; branch: string | undefined; repoCwd: string; statePath: string }
 export type LandWorktreeRemoval = { removed: boolean; reason?: string; /** 이 호출이 만든 가지를 지웠나 — 만든 가지가 없으면 null. */ branchRemoved?: boolean | null };
-export interface LandWorktree { cwd: string; cleanup: () => LandWorktreeRemoval }
+export interface LandWorktree { cwd: string; cleanup: () => LandWorktreeRemoval; /** false means an existing owner's tree is borrowed, never removed. */ created?: boolean }
 
 export interface LandWorktreeDeps {
   git?: GitRun;
@@ -46,6 +46,14 @@ export function localHead(cwd: string, git: GitRun = defaultGit): string | null
   } catch { return null; }
 }
 
+/** cwd 의 현재 가지 — detached·조회 실패는 null. */
+export function localBranch(cwd: string, git: GitRun = defaultGit): string | null {
+  try {
+    const r = git(cwd, ['branch', '--show-current']);
+    return r.status === 0 && r.stdout.trim() ? r.stdout.trim() : null;
+  } catch { return null; }
+}
+
 async function defaultProvideDeps(worktree: string, sourceRoot: string): Promise<void> {
   const { spawnSync } = await import('node:child_process');
   const { provideCheckoutDependencies } = await import('../self-implement/host-regate.js');
@@ -71,6 +79,24 @@ function registered(git: GitRun, repoCwd: string, path: string): boolean | null
   return list.stdout.split('\n').some((line) => line.startsWith('worktree ') && real(line.slice('worktree '.length).trim()) === want);
 }
 
+/** A registered checkout of the exact PR branch. An unreadable/malformed registry is never treated as vacant. */
+function branchOwner(git: GitRun, repoCwd: string, branch: string): { path: string | null; reason?: string } {
+  let list: ReturnType<GitRun>;
+  try { list = git(repoCwd, ['worktree', 'list', '--porcelain']); }
+  catch { return { path: null, reason: 'git worktree registry unreadable (owner unknown)' }; }
+  if (list.status !== 0 || !list.stdout.trim()) return { path: null, reason: 'git worktree registry unreadable (owner unknown)' };
+  const entries = list.stdout.trim().split(/\n\s*\n/);
+  const owners: string[] = [];
+  for (const entry of entries) {
+    const lines = entry.split('\n');
+    const pathLine = lines.find(line => line.startsWith('worktree '));
+    if (!pathLine?.slice(9).trim()) return { path: null, reason: 'git worktree registry malformed (owner unknown)' };
+    if (lines.some(line => line === `branch refs/heads/${branch}`)) owners.push(pathLine.slice(9).trim());
+  }
+  if (owners.length > 1) return { path: null, reason: `PR branch ${branch} has multiple registered owners (owner unknown)` };
+  return { path: owners[0] ?? null };
+}
+
 /** 이 저장소의 git 공통 디렉터리(실경로) — 못 읽으면 null. */
 function commonDir(git: GitRun, repoCwd: string): string | null {
   const r = git(repoCwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
@@ -110,7 +136,7 @@ function removeWorktree(git: GitRun, repoCwd: string, path: string): { removed:
 }
 
 /** `created` — 트리를 만들었었나(모르면 null) · `removed` — 만들었다면 걷었나(만든 적 없거나 모르면 null). */
-export type LandWorktreeFailure = { reason: string; created: boolean | null; removed: boolean | null };
+export type LandWorktreeFailure = { reason: string; created: boolean | null; removed: boolean | null; kind?: 'worktree-conflict'; ownerPath?: string };
 
 /** PR 머리 트리를 만든다 — 못 만들면 이유 ⊕ 만들었다 걷었는지(관측용). 던지지 않는다. */
 export async function createLandWorktree(input: LandWorktreeInput, deps: LandWorktreeDeps = {}): Promise<LandWorktree | LandWorktreeFailure> {
@@ -119,10 +145,15 @@ export async function createLandWorktree(input: LandWorktreeInput, deps: LandWor
   const head = input.head.toLowerCase();
   const branch = input.branch;
   const fail = (reason: string, created: boolean | null = false, removed: boolean | null = null): LandWorktreeFailure => ({ reason, created, removed });
+  const conflict = (reason: string, ownerPath?: string): LandWorktreeFailure => ({ reason: `worktree-conflict: ${reason}`, created: false, removed: null, kind: 'worktree-conflict', ...(ownerPath ? { ownerPath } : {}) });
   if (!branch) return fail('PR head branch name unknown');
   if (!/^[0-9a-f]{40}$/.test(head)) return fail('PR head is not a full sha');
   // 지난 시도가 남긴 같은 자리는 먼저 걷는다(같은 PR·머리 · 재사용하지 않는다 — 상태를 모르는 트리에서 착지하지 않게).
-  if (existsSync(path) || registered(git, input.repoCwd, path) !== false) {
+  let atLandPath: boolean | null;
+  try { atLandPath = registered(git, input.repoCwd, path); }
+  catch { atLandPath = null; }
+  if (atLandPath === null) return conflict('git worktree list unreadable (owner unknown)');
+  if (existsSync(path) || atLandPath) {
     const stale = removeWorktree(git, input.repoCwd, path);
     if (!stale.removed) return fail(`stale land worktree could not be removed: ${stale.reason}`);
   }
@@ -135,9 +166,25 @@ export async function createLandWorktree(input: LandWorktreeInput, deps: LandWor
     return r.status === 0 ? r.stdout.trim().toLowerCase() : null;
   };
   const existingHead = branchHead();
-  if (existingHead && existingHead !== head) return fail(`local branch ${branch} exists at ${existingHead.slice(0, 12)} (not the PR head) — not overwriting it`);
   const mine = commonDir(git, input.repoCwd);
   if (!mine) return fail('git common directory unreadable');
+  const owner = branchOwner(git, input.repoCwd, branch);
+  if (owner.reason) return conflict(owner.reason);
+  if (owner.path) {
+    const path = owner.path;
+    // The registry is only a lead: validate the checkout itself immediately before handing it to pr land.
+    try {
+      if (commonDir(git, path) !== mine) return conflict(`owner ${path} repository identity unreadable or different`, path);
+      const current = git(path, ['branch', '--show-current']);
+      if (current.status !== 0 || current.stdout.trim() !== branch) return conflict(`owner ${path} branch is ${current.stdout.trim() || 'unknown'} (expected ${branch})`, path);
+      const actualHead = localHead(path, git);
+      if (actualHead?.toLowerCase() !== head) return conflict(`owner ${path} HEAD ${actualHead?.slice(0, 12) ?? 'unknown'} ≠ reviewed ${head.slice(0, 12)}`, path);
+      const status = git(path, ['status', '--porcelain']);
+      if (status.status !== 0 || status.stdout.trim()) return conflict(`owner ${path} is ${status.status !== 0 ? 'status unreadable' : `dirty: ${status.stdout.trim().split('\n').slice(0, 3).join(' · ').slice(0, 160)}`}`, path);
+    } catch { return conflict(`owner ${path} verification failed`, path); }
+    return { cwd: path, created: false, cleanup: () => ({ removed: false, reason: `borrowed owner ${path} — left untouched` }) };
+  }
+  if (existingHead && existingHead !== head) return fail(`local branch ${branch} exists at ${existingHead.slice(0, 12)} (not the PR head) — not overwriting it`);
   try {
     mkdirSync(dirname(path), { recursive: true });
     // 표지를 먼저 — 등록 전에 죽어도 다음 시도가 «우리 잔여»임을 확인하고 걷을 수 있게.
@@ -192,7 +239,7 @@ export async function createLandWorktree(input: LandWorktreeInput, deps: LandWor
   } catch (error) {
     return abort(`land worktree check threw: ${(error instanceof Error ? error.message : String(error)).slice(-200)}`);
   }
-  return { cwd: path, cleanup };
+  return { cwd: path, cleanup, created: true };
 }
 
 export function observeLandWorktree(data: { card: string; pr: number; head: string; created: boolean | null; removed: boolean | null; branchRemoved?: boolean | null; reason: string },

package/src/task-agent/live-move-history.ts

@@ -50,6 +50,7 @@ export function liveMoveEffect(input: Pick<LiveMoveHistoryInput, 'executorResult
   const result = input.result;
   if (!result) return LIVE_MOVE_EFFECT_UNKNOWN;
   if (!result.executed) return 'none — not executed';
+  if (result.kind === 'decision-card') return result.ok ? 'decision card raised' : 'raise failed';
   if (result.kind === 'review' && result.ok) return result.resultPath ? LIVE_REVIEW_EFFECT_PENDING : LIVE_REVIEW_EFFECT_REQUESTED;
   if (result.kind === 'land' && result.ok) return 'land reported ok by the executor (merge state not re-checked here) · merge sha not reported';
   if (result.kind === 'propose-green' && result.ok) return `green proposed · checklist ${checklistId ?? '-'} (checklist untouched)`;

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

@@ -3,7 +3,7 @@
  *
  * - `review`: 수확 가능 런의 PR 에 elanous 리뷰를 «한 번» 요청한다 — PR 머리(sha)마다 한 번(카드 `reviewRequests` 이력).
  *   요청만 한다: 결과로 착지·재발사로 잇지 않는다(실행부 `executeNextAction` 의 review→land 사슬을 타지 않는다).
- *   TA-REVIEW-RESULT-CAPTURE — 자식 stdout(`--json`)은 결과 파일로 받고, 회수(`review-result-capture.ts`)는 «다음» 판단 틱이 한다 —
+ *   TA-REVIEW-RESULT-CAPTURE — 자식 stdout(`--json`)은 결과 파일로 받고, 자식 완료 뒤 해당 카드만 회수·재판정한다.
  *   회수한 pass 는 그 틱의 판단부·land 관문 입력(`selfReview`)이 될 뿐 land 판정 로직은 그대로다.
  * - `propose-green`: 카드에 green «제안»(`greenProposal`)만 적는다 — 체크리스트는 손대지 않는다.
  * - `propose-land`: 카드·현재 머리의 self review 통과(pass «또는» warn ⊕ must-fix 0 · TA-LAND-WARN-MUSTFIX0)·non-draft 를 확인하고 기존 `pr land` 를 머리 고정으로 한 번 부른다.
@@ -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 } 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. */
@@ -208,13 +208,18 @@ export function liveReviewArgs(entry: string, configDir: string, pr: number, int
  * 파이프가 아니라 파일 — 부모가 먼저 끝나도 자식이 EPIPE 로 죽지 않는다). 없으면 종전과 같다(stdio ignore).
  * `opts` 는 시험 몫(spawn·진입점·우주) — 기본은 실물.
  */
-export async function defaultRequestReview(pr: number, intent: string, cwd?: string, opts: { spawn?: DetachedSpawn; entry?: string; configDir?: string; resultPath?: string } = {}): Promise<void> {
+export async function defaultRequestReview(pr: number, intent: string, cwd?: string, opts: { spawn?: DetachedSpawn; entry?: string; configDir?: string; resultPath?: string; cardId?: string; statePath?: 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();
   const base = opts.spawn ?? (spawn as unknown as DetachedSpawn);
   const args = liveReviewArgs(opts.entry ?? ELANOUS_CLI_ENTRY, configDir, pr, intent);
+  const completionEnv = opts.resultPath && opts.cardId && opts.statePath ? {
+    [TA_REVIEW_COMPLETION_CARD_ENV]: opts.cardId,
+    [TA_REVIEW_COMPLETION_STATE_ENV]: opts.statePath,
+    [TA_REVIEW_COMPLETION_RESULT_ENV]: opts.resultPath,
+  } : undefined;
   if (!opts.resultPath) { await spawnDetachedConfirmed(base, process.execPath, args, undefined, cwd); return; }
   let fd: number;
   try {
@@ -229,7 +234,7 @@ export async function defaultRequestReview(pr: number, intent: string, cwd?: str
   const toFile: DetachedSpawn = (command, spawnArgs, options) =>
     (base as unknown as (c: string, a: string[], o: unknown) => ReturnType<DetachedSpawn>)(command, spawnArgs, { ...options, stdio: ['ignore', fd, 'ignore'] });
   try {
-    await spawnDetachedConfirmed(toFile, process.execPath, args, undefined, cwd);
+    await spawnDetachedConfirmed(toFile, process.execPath, args, undefined, cwd, completionEnv);
   } finally {
     try { closeSync(fd); } catch { /* the child keeps its own copy */ }
   }
@@ -312,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;
@@ -340,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 }] };
@@ -360,7 +369,7 @@ export async function executeLiveReview(
       try { (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('task-agent', 'review-prior-fix-filled', priorFixObservation(card.id, pr, prior)); } catch { /* fail-soft */ }
     }
     const intent = liveReviewIntent(card, ctx.runId, ctx.stopReason, prior);
-    await (deps.requestReview ? deps.requestReview(pr, intent, cwd, { resultPath }) : defaultRequestReview(pr, intent, cwd, { resultPath }));
+    await (deps.requestReview ? deps.requestReview(pr, intent, cwd, { resultPath }) : defaultRequestReview(pr, intent, cwd, { resultPath, cardId: card.id, statePath: path }));
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     updateTaskCard(path, card.id, (current) => current?.reviewRequests?.some((entry) => entry.pr === pr && entry.head === head!.head && entry.at === at)
@@ -411,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;
@@ -430,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) {
@@ -492,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';
 }
 
 /**
@@ -560,11 +589,15 @@ export async function executeLiveLand(
   const path = deps.statePath ?? taskAgentStatePath();
   const at = (deps.now ?? (() => new Date()))().toISOString();
   const local = (deps.landWorktree?.localHead ?? localHead)(cwd);
-  const needsLandWorktree = !!local && local.toLowerCase() !== view.head.toLowerCase();
+  const landKey = `land:${card.id}:${view.head.slice(0, 12)}`;
+  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;
   let cappedReason: string | undefined;
+  // This state-file lock is the cross-process card/head land claim. Both completion workers
+  // must pass it; an unfinished or successful attempt makes the second worker skip.
   // TA-LAND-RETRY-ON-INFRA — 같은 머리의 앞 시도들(잠금 안에서 읽은 «지금» 카드) · 재시도면 그 근거.
   let prior: LandAttempt[] = [];
   try {
@@ -590,12 +623,13 @@ export async function executeLiveLand(
   if (!claimed) {
     const last = prior.at(-1);
     const why = last ? ` (attempts ${prior.length} · last ${last.ok === false ? `class ${last.class ?? 'unclassified'}${last.reason ? ` ${last.reason}` : ''}` : last.ok === true ? 'ok' : 'unfinished'})` : '';
-    return observe(deps, withRepo({ kind, card: card.id, ok: true, executed: false, detail: `already attempted land for #${pr} head ${view.head.slice(0, 12)}${why}` }));
+    return observe(deps, withRepo({ kind, card: card.id, ok: true, executed: false, detail: `already attempted land for #${pr} head ${view.head.slice(0, 12)} · ${landKey} claimed — skip${why}` }));
   }
   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)
@@ -610,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 {
@@ -647,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;
@@ -673,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 — 역시 «안 돈다»가 확실).