elanous 0.2.24 → 0.2.27

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

@@ -12,15 +12,23 @@
  */
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import { isNoneSentinelFinding } from '../agent-substrate/pr-reviewer.js';
 import { debug } from '../debug/log.js';
-import { LIVE_MOVE_RESULT_EVENT, readTaskAgentState, updateTaskCard, type TaskCard, type TaskCardEvent } from './task-hand.js';
+import { LIVE_MOVE_RESULT_EVENT, cardPrNumber, readTaskAgentState, readTaskCard, updateTaskCard, type TaskCard, type TaskCardEvent } from './task-hand.js';
+import type { RejudgeDeps } from './rejudge-on-head.js';
 
 export const REVIEW_RESULT_MISSING_EFFECT = 'review process produced no result';
 /** 결과 파일은 있는데 읽지 못했다(EACCES 등) — «결과 없음»과 가른다(결과가 있었을 수 있다). */
 export const REVIEW_RESULT_UNREADABLE_EFFECT = 'review result file unreadable';
+/** Detached self review child: only this card and exact result file may trigger a completion tick. */
+export const TA_REVIEW_COMPLETION_CARD_ENV = 'ELANOUS_TA_REVIEW_COMPLETION_CARD';
+export const TA_REVIEW_COMPLETION_STATE_ENV = 'ELANOUS_TA_REVIEW_COMPLETION_STATE';
+export const TA_REVIEW_COMPLETION_RESULT_ENV = 'ELANOUS_TA_REVIEW_COMPLETION_RESULT';
 /** 리뷰 한 판(1차 ⊕ 폴백 · ACP 300s 상한 여러 번)을 넉넉히 덮는 대기 상한 — 이 안에는 «아직»으로 본다. */
 export const REVIEW_RESULT_WAIT_MS = 90 * 60_000;
 
+const reviewRejudgeInFlight = new Set<string>();
+
 const SHA40 = /^[0-9a-f]{40}$/i;
 
 /** 결과 파일 경로 — 카드 상태 파일 옆 `review-results/` · 카드 id 는 파일 이름에 안전한 글자만. */
@@ -63,7 +71,8 @@ export function parseReviewResultOutput(text: string): ParsedReviewResult | null
       ...(Number.isSafeInteger(prRaw) && prRaw > 0 ? { pr: prRaw } : {}),
       verdict: typeof v.verdict === 'string' ? v.verdict : null,
       reviewed: typeof v.reviewed === 'boolean' ? v.reviewed : null,
-      mustFix: Array.isArray(v.mustFix) && v.mustFix.every((fix) => typeof fix === 'string') ? v.mustFix.length : null,
+      // PR-LAND-MUSTFIX-NONE — 저장된 결과(옛 판 리뷰 · 다른 경로)에 «(없음 — …)» 표지 줄이 남아 있어도 리뷰 출력과 «같은» 판정으로 0 으로 센다.
+      mustFix: Array.isArray(v.mustFix) && v.mustFix.every((fix) => typeof fix === 'string') ? v.mustFix.filter((fix) => !isNoneSentinelFinding(fix)).length : null,
       reviewRoute: typeof v.reviewRoute === 'string' ? v.reviewRoute : null,
       head: typeof v.headCommit === 'string' && SHA40.test(v.headCommit) ? v.headCommit : null,
       error: typeof v.error === 'string' ? v.error : null,
@@ -86,6 +95,8 @@ export function pendingReviewResults(card: TaskCard): ReviewRequest[] {
 export interface CaptureReviewResultsOptions {
   /** 이 카드들만 본다 — 없으면 상태 파일의 모든 카드. */
   cardIds?: readonly string[];
+  /** A detached completion callback may only harvest its own result file. */
+  resultPaths?: readonly string[];
   now?: () => Date;
   /** 시험 seam — 결과 파일 읽기(없으면 ENOENT 를 던진다). */
   readFile?: (path: string) => string;
@@ -121,6 +132,7 @@ export function captureReviewResults(statePath: string, opts: CaptureReviewResul
     if (!card) continue;
     for (const request of pendingReviewResults(card)) {
       const resultPath = request.resultPath!;
+      if (opts.resultPaths && !opts.resultPaths.includes(resultPath)) continue;
       let text: string | null = null;
       let readError: string | null = null;
       let unreadable = false;
@@ -182,6 +194,59 @@ export function captureReviewResults(statePath: string, opts: CaptureReviewResul
   return out;
 }
 
+/** Run after the detached review child has fully written its JSON stdout. Never infer a card from PR alone. */
+export async function rejudgeCompletedTaskReview(
+  env: Record<string, string | undefined> = process.env,
+  rejudge?: (cardId: string, statePath: string) => Promise<unknown>,
+  rejudgeDeps?: RejudgeDeps,
+): Promise<boolean> {
+  const cardId = env[TA_REVIEW_COMPLETION_CARD_ENV];
+  const statePath = env[TA_REVIEW_COMPLETION_STATE_ENV];
+  const resultPath = env[TA_REVIEW_COMPLETION_RESULT_ENV];
+  if (!cardId || !statePath || !resultPath) return false;
+  const before = readTaskCard(cardId, statePath);
+  const bound = before?.reviewRequests?.find((item) => item.resultPath === resultPath);
+  if (before?.status !== 'launched' || before.taLand !== true || !bound || cardPrNumber(before) !== bound.pr
+    || !SHA40.test(bound.head) || (before.history ?? []).some((item) => item.event === 'async-result-rejudge' && item.resultPath === resultPath)) return false;
+  captureReviewResults(statePath, { cardIds: [cardId], resultPaths: [resultPath] });
+  const key = `${statePath}\0${cardId}\0${resultPath}`;
+  if (reviewRejudgeInFlight.has(key)) return false;
+  const card = readTaskCard(cardId, statePath);
+  const request = card?.reviewRequests?.find((item) => item.resultPath === resultPath);
+  if (card?.status !== 'launched' || card.taLand !== true || !request || cardPrNumber(card) !== request.pr
+    || !(card.history ?? []).some((item) => item.event === LIVE_MOVE_RESULT_EVENT && item.resultPath === resultPath && item.kind === 'review'
+      && item.pr === request.pr && SHA40.test(request.head) && SHA40.test(item.head ?? '')
+      && item.effect?.startsWith('review result captured') && item.reviewed === true && item.head?.toLowerCase() === request.head.toLowerCase())
+    || (card.history ?? []).some((item) => item.event === 'async-result-rejudge' && item.resultPath === resultPath)) return false;
+  reviewRejudgeInFlight.add(key);
+  try {
+    const run = async (): Promise<unknown> => {
+      if (rejudgeDeps) {
+        const { rejudgeShadowCard } = await import('./rejudge-on-head.js');
+        return rejudgeShadowCard(cardId, statePath, rejudgeDeps, { pr: request.pr, head: request.head, kind: 'review', resultPath });
+      } else if (rejudge) return rejudge(cardId, statePath);
+      else {
+        const { rejudgeAsyncResultCard } = await import('./rejudge-on-head.js');
+        return rejudgeAsyncResultCard(cardId, statePath, {}, { pr: request.pr, head: request.head, kind: 'review', resultPath });
+      }
+    };
+    const { requireCompletedHeadRejudge } = await import('./rejudge-on-head.js');
+    try { requireCompletedHeadRejudge(await run(), request.pr, request.head); }
+    catch { requireCompletedHeadRejudge(await run(), request.pr, request.head); } // Bounded retry; no marker on failed outcomes.
+    updateTaskCard(statePath, cardId, (current) => current?.status === 'launched' && current.taLand === true && cardPrNumber(current) === request.pr
+      && (current.reviewRequests ?? []).some((item) => item.pr === request.pr && SHA40.test(item.head) && item.head.toLowerCase() === request.head.toLowerCase() && item.resultPath === resultPath)
+      && (current.history ?? []).some((item) => item.event === LIVE_MOVE_RESULT_EVENT && item.resultPath === resultPath && item.kind === 'review'
+        && item.pr === request.pr && SHA40.test(item.head ?? '') && item.head?.toLowerCase() === request.head.toLowerCase()
+        && item.reviewed === true && item.effect?.startsWith('review result captured'))
+      && !(current.history ?? []).some((item) => item.event === 'async-result-rejudge' && item.resultPath === resultPath)
+      ? { ...current, history: [...(current.history ?? []), { at: new Date().toISOString(), event: 'async-result-rejudge', kind: 'review', pr: request.pr, head: request.head, resultPath, effect: 'completion callback succeeded' }] }
+      : undefined);
+  } finally {
+    reviewRejudgeInFlight.delete(key);
+  }
+  return true;
+}
+
 /**
  * 다음 수 판단의 입력 — 카드에 회수된 리뷰 결과 중 «그 머리(`head`)»의 «가장 최근» 결과가 실제로 돈(reviewed) pass 이고
  * 리뷰한 머리가 40자 sha 일 때만 `selfReview` 모양으로 돌려준다(슈퍼바이저가 나르는 `self-implement-cli` 의 규칙과 같다 ·

package/src/task-agent/shadow.ts

@@ -10,16 +10,22 @@
  * - 관측: `debug.log('task-agent', 'shadow-move', …)` → `elanous logs --category task-agent`.
  */
 import { lstatSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { extname, join, relative, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
-import { readTaskAgentState, readTaskCard, taskAgentStatePath, type CompletionKind, type TaskCard } from './task-hand.js';
+import { readTaskAgentState, readTaskCard, taskAgentStatePath, TASK_CARD_PREFIX, type CompletionKind, type TaskCard } from './task-hand.js';
 import type { SupervisorJobResult, SupervisorStopReason } from '../self-dev/run-supervisor.js';
 import { executeNextAction, type DeliveryKind, type NextAction } from './actions.js';
 import { judgeNextMove, type TaskJudgeInput, type TaskJudgement } from './judge.js';
 import { HARNESS_RUN_ID_ENV } from '../harness/harness-space.js';
-import { recordLiveMoveHistory } from './live-move-history.js';
+import { appendRunLedgerEntry, loadRunLedger } from '../self-implement/run-ledger.js';
+import { collectWiringEvidence, readCardRunSnapshot, type WiringEvidenceDeps, type CardRunEvidenceDeps } from './card-evidence.js';
+import { remoteLedgerMirrorDir } from './parent-host.js';
+import { prodInstanceRoot } from '../instance/resolve.js';
+import { liveMoveHistoryEntry, recordLiveMoveHistory } from './live-move-history.js';
+import { updateTaskCard } from './task-hand.js';
 import { capturedSelfReview, captureReviewResults, hasCapturedPass } from './review-result-capture.js';
-import { configuredTaskAgentLiveMoves, defaultPrHead, executeLiveGreenProposal, executeLiveLand, executeLiveReview, type LiveMoveDeps, type LiveMoveResult, type TaskAgentLiveMove } from './live-moves.js';
+import { configuredTaskAgentLiveMoves, defaultPrHead, executeLiveDecisionCard, executeLiveGreenProposal, executeLiveLand, executeLiveReview, type LiveMoveDeps, type LiveMoveResult, type TaskAgentLiveMove } from './live-moves.js';
 
 export interface TaskAgentShadowInput {
   runId: string | null;
@@ -45,6 +51,8 @@ export interface TaskAgentShadowMove {
   pr: number | null;
   /** TA-JUDGE-LIVE-SAFE — `taskAgent.liveMoves` 가 이 수를 실제로 했을 때만 실린다(없으면 종전 그대로 그림자). */
   liveMove?: LiveMoveResult;
+  /** 원격 카드 결선이 미결일 때 런 원장 대기열 보존 결과. */
+  cardBinding?: 'pending' | 'queue-failed';
 }
 
 export interface TaskAgentShadowDeps {
@@ -60,10 +68,16 @@ export interface TaskAgentShadowDeps {
   live?: LiveMoveDeps;
   /** 카드 조회 상태 파일(시험 주입 · 운영 파일을 건드리지 않게). 기본 = `live.statePath` ⊕ `taskAgentStatePath()`. */
   statePath?: string;
+  /** TA-WIRING-CHECK — 배선 근거 수집 의존(시험 주입 · 기본 = gh pr diff 한 번 ⊕ 카드 런 원장). */
+  wiring?: Omit<WiringEvidenceDeps, 'card'>;
   /** Process env for the launched-run id (`ELANOUS_RUN_ID`) — test seam; default process.env. */
   env?: NodeJS.ProcessEnv;
+  /** Remote pending-move ledger seam; defaults to the run ledger. */
+  queueMove?: typeof appendRunLedgerEntry;
 }
 
+export const REMOTE_CARD_MOVE_PENDING = 'task-agent-card-move-pending';
+
 /** 카드 조회 상태 파일 — 조회 경로 전부가 같은 파일을 본다. */
 function cardStatePath(deps: TaskAgentShadowDeps): string {
   return deps.statePath ?? deps.live?.statePath ?? taskAgentStatePath();
@@ -172,6 +186,13 @@ function shadowCompletion(card: TaskCard | undefined, lookupFailed: boolean): Co
 }
 
 export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, deps: TaskAgentShadowDeps = {}): Promise<TaskAgentShadowMove> {
+  const env = deps.env ?? process.env;
+  const remoteChild = !!env.ELANOUS_POD_NAME;
+  const hintedCard = env.ELANOUS_TASK_CARD_ID?.trim();
+  const pendingCardId = hintedCard?.startsWith(TASK_CARD_PREFIX) && hintedCard.length <= 63 && /^[A-Za-z0-9._-]+$/.test(hintedCard) ? hintedCard : null;
+  const parentRunId = env.ELANOUS_PARENT_RUN_ID?.trim() || null;
+  const matchesLaunchCard = (candidate: TaskCard | undefined): boolean => !!candidate && !!parentRunId
+    && candidate.id === pendingCardId && candidate.runId === parentRunId;
   // TA-REVIEW-RESULT-CAPTURE — 판단 «전»에 지난 live review 의 결과 파일을 회수한다(카드 원장을 아는 때만 · 던지지 않는다).
   //   대기 중인 요청이 없으면 아무것도 쓰지 않는다(결과 파일 없는 카드의 동작은 종전과 같다).
   const reviewLedger = cardLedgerPath(deps);
@@ -185,14 +206,22 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
   let card: TaskCard | undefined;
   let cardLookupFailed = false;
   try {
-    card = successful ? (deps.readCard ? deps.readCard(successful.taskId) : readTaskCard(successful.taskId, cardStatePath(deps))) : undefined;
-    if (!card && successful && !deps.readCard) {
+    // Pod 에 발사 카드 id 가 있으면 그 id 만 믿는다. 같은 문장을 가진 다른 카드가 있어도 묶지 않는다.
+    if (remoteChild) {
+      if (pendingCardId) {
+        const found = deps.readCard ? deps.readCard(pendingCardId) : readTaskCard(pendingCardId, cardStatePath(deps));
+        if (matchesLaunchCard(found)) card = found;
+      }
+    } else if (successful) {
+      card = deps.readCard ? deps.readCard(successful.taskId) : readTaskCard(successful.taskId, cardStatePath(deps));
+    }
+    if (!card && successful && !deps.readCard && !remoteChild) {
       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);
+    if (!card && !deps.readCard && !remoteChild) 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;
@@ -206,7 +235,7 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
     try {
       const reviewedPr = judgeInput.pr;
       const prRun = input.results.find((result) => result.prNumber === reviewedPr);
-      const prCard = prRun ? (card && successful?.taskId === prRun.taskId ? card : liveCardFor([prRun], deps, input.runId)) : undefined;
+      const prCard = prRun ? (remoteChild ? card : card && successful?.taskId === prRun.taskId ? card : liveCardFor([prRun], deps, input.runId)) : undefined;
       // 회수한 판정은 «리뷰한 머리»의 것이다 — 지금 PR 머리의 결과만 입력으로 쓴다(A 의 pass 로 B 를 land 쪽으로 보내지 않게 ·
       //   여러 머리 결과가 역순으로 회수돼도 지금 머리 것을 고른다). 지금 머리 = 그 런 작업 트리에서 PR 머리 조회 ·
       //   작업 트리가 없으면(Pod) 런이 낸 머리. 못 정하면 쓰지 않는다(종전처럼 review 수 → 새 머리면 새 리뷰).
@@ -275,20 +304,23 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
     move.reason = wouldDo ?? judgement.reason;
     move.wouldDo = null;
   }
-  const liveKind: TaskAgentLiveMove | null = move.move === 'review' || move.move === 'propose-green' || move.move === 'propose-land' ? move.move : null;
+  const liveKind: TaskAgentLiveMove | null = move.move === 'review' || move.move === 'propose-green' || move.move === 'propose-land' || move.move === 'decision-card' ? move.move : null;
   // 판단마다 해석한다 — 허용되지 않은 수를 판단할 때도 모르는 항목 경고가 남게.
   const liveMoves = deps.liveMoves ?? await configuredTaskAgentLiveMoves();
-  const live = liveKind !== null && liveMoves.has(liveKind);
   // 카드 id 는 모든 판단 관측에 싣는다(그림자 일치율을 카드로 잇는다) — 읽기 전용 조회.
   // live 수는 «근거 결과»에 묶는다 — PR 수는 그 PR 을 낸 결과의 카드·작업 트리, 전달은 전달한 카드(다중 결과에서 남의 카드에 쓰지 않게).
   const prResult = typeof judgeInput.pr === 'number' ? input.results.find((result) => result.prNumber === judgeInput.pr) : undefined;
-  const boundCard = delivery
+  const candidateBoundCard = delivery
     ? card
     : prResult
-      ? (card && successful?.taskId === prResult.taskId ? card : liveCardFor([prResult], deps, input.runId))
-      : undefined;
+      ? (card && (successful?.taskId === prResult.taskId || (remoteChild && pendingCardId === card.id)) ? card : liveCardFor([prResult], deps, input.runId))
+      : liveKind === 'decision-card' ? card ?? liveCardFor(input.results, deps, input.runId) : undefined;
+  const boundCard = remoteChild && !matchesLaunchCard(candidateBoundCard) ? undefined : candidateBoundCard;
   // PR 에 묶인 수는 그 PR 의 카드만 관측에 싣는다(못 찾으면 null — 다른 결과의 카드로 대체하지 않는다).
-  const liveCard = prResult || delivery ? boundCard : card ?? (cardLookupFailed ? undefined : liveCardFor(input.results, deps, input.runId));
+  const candidateLiveCard = prResult || delivery ? boundCard : card ?? (cardLookupFailed ? undefined : liveCardFor(input.results, deps, input.runId));
+  const liveCard = remoteChild && !matchesLaunchCard(candidateLiveCard) ? undefined : candidateLiveCard;
+  // 원격 Pod 는 HQ 카드 파일을 갖지 않는다. id 를 전달받아도 현지 원장이 없으면 실행 수는 보류한다.
+  const live = liveKind !== null && liveMoves.has(liveKind) && (!remoteChild || boundCard !== undefined);
   let liveMove: LiveMoveResult | undefined;
   if (live) {
     if (liveKind === 'review') {
@@ -313,6 +345,17 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
             ...(prResult.prUrl ? { prUrl: prResult.prUrl } : {}),
           } } : {}),
         }, liveMoveDeps(deps));
+    } else if (liveKind === 'decision-card') {
+      // Supervisor results carry failure text and reviewer must-fix items, but no screen tail.
+      // A stop reason alone is not evidence: the executor correctly raises no card when both are absent.
+      const evidenceResults = prResult ? [prResult] : input.results;
+      const signature = evidenceResults.find((result) => result.error?.message?.trim())?.error?.message;
+      const mustFix = evidenceResults.flatMap((result) => result.reviewMustFix ?? []);
+      liveMove = await executeLiveDecisionCard(boundCard, {
+        runId: input.runId, stopReason: input.stopReason, reason: move.reason,
+        ...(prResult ? { pr: prResult.prNumber } : {}),
+        evidence: { ...(signature ? { signature } : {}), mustFix },
+      }, liveMoveDeps(deps));
     } else {
       const evidence: Record<string, string> = {};
       if (boundCard && !delivery && judgeInput.prState === 'MERGED' && prResult) evidence[boundCard.id] = `#${prResult.prNumber}`;
@@ -320,26 +363,62 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
       liveMove = executeLiveGreenProposal(boundCard, evidence, liveMoveDeps(deps));
     }
   }
-  // 판단한 수마다 live/shadow 를 남긴다 — OP 가 «오판 건수»·«그림자 일치율»을 카드·수 종류로 잰다.
-  (deps.log ?? ((category, event, data) => debug.log(category, event, data)))('task-agent', 'shadow-move', {
-    ...move, completion: shadowCompletion(card, cardLookupFailed), card: liveCard?.id ?? null, live, liveExecuted: liveMove?.executed ?? false, ...(liveMove ? { liveOk: liveMove.ok } : {}),
-    ...(reviewFromCapture ? { reviewSource: 'captured-review-result' } : {}),
-  });
+  // TA-WIRING-CHECK — 병합 PR 은 판단한 «뒤» 배선 근거를 관측만 한다(move 불변 · 실패는 unknown 으로 남기고 던지지 않는다).
+  if (judgeInput.prState === 'MERGED' && typeof judgeInput.pr === 'number' && !delivery && liveCard) {
+    try {
+      const wiring = await collectWiringEvidence(judgeInput.pr, { ...deps.wiring, card: liveCard });
+      (deps.log ?? ((category, event, data) => debug.log(category, event, data)))('task-agent', 'wiring-shadow', {
+        card: liveCard.id, pr: judgeInput.pr, required: wiring.required, liveRunRecorded: wiring.liveRunRecorded, unknown: wiring.unknown,
+      });
+    } catch { /* fail-soft — 관측일 뿐 판단을 막지 않는다 */ }
+  }
   // TA-LIVE-MOVE-CARD-HISTORY — live-move 수(review·propose-green·propose-land)는 실행이든 그림자든 그 카드 history 에 한 줄.
   // 결정·실행이 끝난 «뒤»에 덧붙이기만 한다(반환값·관측 무변경) · 실패는 관측만(live-move 를 막지 않는다).
-  if (liveKind !== null) recordLiveMoveOnCard({
+  if (liveKind !== null && (liveKind !== 'decision-card' || live) && (!remoteChild || liveCard)) recordLiveMoveOnCard({
     liveKind, live, liveMove, card: live ? boundCard : liveCard, runId: input.runId,
     pr: prResult?.prNumber ?? (typeof judgeInput.pr === 'number' ? judgeInput.pr : undefined),
     shadowDetail: move.wouldDo ?? move.reason,
   }, deps);
-  return liveMove ? { ...move, liveMove } : move;
+  let cardBinding: TaskAgentShadowMove['cardBinding'];
+  if (liveKind !== null && !liveCard && remoteChild) {
+    const inheritedRunId = parentRunId || env[HARNESS_RUN_ID_ENV]?.trim() || null;
+    const reason = !parentRunId ? 'parent run id absent; HQ binding required'
+      : pendingCardId ? 'card id carried but ledger unavailable' : 'card id absent; parent run lookup required';
+    try {
+      if (!input.runId) throw new Error('runId absent');
+      (deps.queueMove ?? appendRunLedgerEntry)({
+        timestamp: new Date().toISOString(), runId: input.runId, event: REMOTE_CARD_MOVE_PENDING,
+        data: { id: randomUUID(), card: pendingCardId, parentRunId: inheritedRunId, kind: liveKind, pr: move.pr,
+          detail: move.wouldDo ?? move.reason, reason, executorResult: 'shadow' },
+      });
+      cardBinding = 'pending';
+    } catch (error) {
+      cardBinding = 'queue-failed';
+      try {
+        (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('task-agent', 'card-binding-queue-failed',
+          { card: pendingCardId, runId: input.runId, parentRunId: inheritedRunId, kind: liveKind, reason: error instanceof Error ? error.message : String(error) });
+      } catch { /* queue failure remains visible in the return value */ }
+    }
+    if (cardBinding === 'pending') try {
+      (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('task-agent', 'card-binding-pending',
+        { card: pendingCardId, runId: input.runId, parentRunId: inheritedRunId, kind: liveKind, reason });
+    } catch { /* queued evidence remains authoritative */ }
+  }
+  // 판단 관측은 원격 미결 수를 실제 원장에 기록한 결과까지 확정한 뒤 남긴다.
+  (deps.log ?? ((category, event, data) => debug.log(category, event, data)))('task-agent', 'shadow-move', {
+    ...move, completion: shadowCompletion(card, cardLookupFailed), card: liveCard?.id ?? pendingCardId,
+    live, liveExecuted: liveMove?.executed ?? false, ...(liveMove ? { liveOk: liveMove.ok } : {}),
+    ...(cardBinding ? { cardBinding } : {}),
+    ...(reviewFromCapture ? { reviewSource: 'captured-review-result' } : {}),
+  });
+  return { ...move, ...(liveMove ? { liveMove } : {}), ...(cardBinding ? { cardBinding } : {}) };
 }
 
 /**
  * 런 id 폴백 — 입력 runId(슈퍼바이저 · Pod 면 자식 런) → 상속 `ELANOUS_RUN_ID`(발사기가 넘긴 부모 런) 순으로,
  * 카드 runId 와 정확히 같고 그 카드가 하나뿐일 때만 쓴다. 못 찾으면 추측하지 않고 이유 한 줄을 남긴다(조용한 미스 0).
  */
-function runCardFor(runId: string | null | undefined, deps: TaskAgentShadowDeps): TaskCard | undefined {
+export 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;
@@ -358,6 +437,54 @@ function runCardFor(runId: string | null | undefined, deps: TaskAgentShadowDeps)
   return undefined;
 }
 
+/** HQ `tasks show` 가 원격 원장 거울의 미결 수를 카드에 회수한다. 부모→자식 원장 간선과 카드 id 를 함께 확인한다. */
+export async function replayRemoteCardMoves(cardId: string, statePath: string, evidenceDeps: CardRunEvidenceDeps = {},
+  log: (category: string, event: string, data: Record<string, unknown>) => void = (c, e, d) => debug.log(c, e, d)): Promise<number> {
+  const card = readTaskCard(cardId, statePath);
+  if (!card?.runId || !card.parentHost) return 0;
+  // 원격 부모와 동일 runId 의 HQ 국소 원장은 발사 영수증만 있을 수 있다. 이 회수는 원격 거울을 우선한다.
+  const loadLedger = evidenceDeps.loadLedger ?? ((runId: string) =>
+    loadRunLedger(runId, remoteLedgerMirrorDir(prodInstanceRoot(), card.parentHost!.host)));
+  const snapshot = await readCardRunSnapshot(card, { ...evidenceDeps, loadLedger });
+  if (snapshot.readErrors?.length) {
+    log('task-agent', 'card-binding-replay-failed', { card: cardId, runId: card.runId, reason: snapshot.readErrors.join(' · ') });
+    return 0;
+  }
+  // 카드 id 가 빠진 옛 원격 줄은 부모 runId 의 유일 카드일 때만 역조회한다.
+  const matches = Object.values(readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(statePath).tasks ?? {})
+    .filter((candidate) => candidate.runId === card.runId);
+  let written = 0;
+  for (const [childRunId, entries] of Object.entries(snapshot.children)) {
+    for (const entry of entries ?? []) {
+      if (entry.event !== REMOTE_CARD_MOVE_PENDING) continue;
+      const data = entry.data;
+      const id = data.id;
+      const kind = data.kind;
+      const linked = data.card === cardId || (data.card == null && matches.length === 1 && matches[0]?.id === cardId);
+      const parentMatches = data.parentRunId == null || data.parentRunId === card.runId;
+      if (!linked || !parentMatches || typeof id !== 'string' || !/^[a-f0-9-]{36}$/i.test(id)
+        || !['review', 'propose-green', 'propose-land', 'decision-card'].includes(String(kind))) {
+        log('task-agent', 'card-binding-replay-skipped', { card: cardId, childRunId, pendingId: typeof id === 'string' ? id : null,
+          reason: !linked ? 'card mismatch or ambiguous runId' : !parentMatches ? 'parent run mismatch' : 'invalid pending move' });
+        continue;
+      }
+      const at = entry.timestamp ?? '';
+      if (!Number.isFinite(Date.parse(at))) continue;
+      const pr = Number.isSafeInteger(data.pr) && (data.pr as number) > 0 ? data.pr as number : undefined;
+      updateTaskCard(statePath, cardId, (current) => {
+        if (!current || current.runId !== card.runId || current.history.some((item) => item.sourceId === id)) return undefined;
+        const item = liveMoveHistoryEntry(current, { at, kind: kind as TaskAgentLiveMove, executorResult: 'shadow',
+          shadowDetail: typeof data.detail === 'string' ? data.detail : 'remote card binding pending', runId: childRunId,
+          ...(pr ? { pr } : {}) });
+        written++;
+        return { ...current, history: [...current.history, { ...item, sourceId: id }] };
+      });
+    }
+  }
+  if (written) log('task-agent', 'card-binding-replayed', { card: cardId, parentRunId: card.runId, written });
+  return written;
+}
+
 /**
  * 카드 history 에 live-move 한 줄 — 상태 파일은 카드를 읽은 곳과 같아야 한다: 주입한 경로(`live.statePath`) 또는
  * 기본 리더를 썼을 때의 기본 경로. 주입한 카드 리더(`readCard`)만 있고 경로가 없으면 그 카드의 원장을 모른다 — 적지 않는다.

package/src/task-agent/task-hand.ts

@@ -18,6 +18,7 @@ import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { withFileLockSync } from '../storage/file-lock.js';
 import { checkCompletionEvidence, deliverableReceiptEvidence } from './completion-evidence.js';
 import { judgeNextMove } from './judge.js';
+import { loadRunLedger, runLedgerDir } from '../self-implement/run-ledger.js';
 
 export interface ResolveHandTextDeps {
   cwd: string;
@@ -94,6 +95,8 @@ export type CompletionKind = typeof COMPLETION_KINDS[number];
  */
 export interface TaskCardEvent {
   at: string; event: string; detail?: string; runId?: string; pr?: number;
+  /** 원격 미결 수를 HQ 에 한 번만 회수하기 위한 원장 사건 id. */
+  sourceId?: string;
   /** `closed-by-hand` 줄만 — 닫은 사유 · 닫은 자리(`closeTaskCard`). */
   reason?: string; by?: string;
   kind?: string; executed?: boolean; ok?: boolean; executorResult?: 'shadow' | 'live'; head?: string; effect?: string;
@@ -167,7 +170,9 @@ export interface TaskCard {
    */
   regates?: Array<{ pr: number; head: string; at: string; resultPath?: string; passed?: boolean; status?: string; baseCommit?: string; detail?: string;
     /** REJUDGE base-stale — 같은 머리를 새 base 위에서 다시 잰 재게이트면, land 가 낡았다고 거절한 앞 재게이트의 base(멱등 키 = 머리 ⊕ 이 base). */
-    staleBase?: string }>;
+    staleBase?: string;
+    /** TA-READY-BEFORE-REGATE — draft 때문에 실패한 같은 머리를 ready 뒤 딱 한 번 다시 잰다. */
+    readyRetry?: true }>;
   /**
    * Live land attempts, claimed before invocation, once per PR head even if the command fails.
    * TA-LAND-RETRY-ON-INFRA — a failed attempt carries `class`/`reason`: `infra` (TA-side, allow-listed) leaves one more attempt on
@@ -316,7 +321,8 @@ export function launchArgs(card: Pick<TaskCard, 'text' | 'seat' | 'childLlm'>):
  * 이유에 «착지 미확인»을 단다(착지했다/안 했다를 단정하지 않는다).
  * 미션 카드는 스스로 발사하지 않는다 · 아직 안 뜬 조각의 선행이 덜 착지했으면 `wait after <id>`.
  */
-export function nextMoveFor(card: TaskCard, landed?: ReadonlySet<string>): TaskCardMove {
+export function nextMoveFor(card: TaskCard, landed?: ReadonlySet<string>, deps: { ledgerDir?: string } = {}): TaskCardMove {
+  // Completion callbacks record a shadow decision; do not suggest the live CLI here.
   if (card.pieces) return { kind: 'wait', reason: `미션 — 조각 ${card.pieces.length}장이 선후대로 발사된다` };
   const unmet = (card.after ?? []).filter((id) => !landed?.has(id));
   if (card.status !== 'launched' && unmet.length > 0) return { kind: 'wait', reason: `after ${unmet.join(', ')}${landed ? '' : ' · 착지 미확인'}` };
@@ -324,6 +330,16 @@ export function nextMoveFor(card: TaskCard, landed?: ReadonlySet<string>): TaskC
   if (card.status === 'launch-failed') return { kind: 'launch', command: launchArgs(card), reason: '직전 발사 실패 — 다시 발사' };
   // live-move·hand-move 줄(관측 기록)은 실패 사유가 아니다 — 그 줄을 뺀 마지막 칸이 사유다(live-move 줄 없는 카드는 종전과 같다).
   if (card.status === 'failed') return { kind: 'wait', reason: card.history.filter((item) => item.event !== LIVE_MOVE_HISTORY_EVENT && item.event !== LIVE_MOVE_RESULT_EVENT && item.event !== HAND_MOVE_HISTORY_EVENT).at(-1)?.detail ?? '런 실패 — PR·수확 가지 없음' };
+  if (card.status === 'launched' && card.runId) {
+    try {
+      const ledger = loadRunLedger(card.runId, deps.ledgerDir ?? runLedgerDir());
+      const terminal = ledger?.filter((entry) => entry.event === 'run-status').at(-1);
+      if (terminal && ['succeeded', 'failed', 'cancelled', 'abandoned'].includes(String(terminal.data.runStatus))) {
+        if (cardPrNumber(card) === undefined) return { kind: 'wait', reason: `런 원장 종료 — ${terminal.data.runStatus} · PR 없음` };
+        return { kind: 'wait', reason: `런 원장 종료 — ${terminal.data.runStatus} · 그림자 재판정은 완료 훅이 기록` };
+      }
+    } catch { /* 원장 결손·손상은 종료로 단정하지 않는다. */ }
+  }
   return { kind: 'wait', reason: '발사됨 — 런 멈춤을 슈퍼바이저 그림자 판단(task-agent.shadow-move)이 받는다' };
 }
 
@@ -487,7 +503,10 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   if (!opts.launcher) throw new Error('--live 인데 launcher 가 없다');
   const runId = mintRunId();
   const launchId = `tl-${randomBytes(6).toString('hex')}`;
-  const context: TaskLaunchContext = { runId, launchId, env: { [HARNESS_RUN_ID_ENV]: runId, ELANOUS_TASK_CARD_ID: card.id, ...(card.taLand ? { [TA_LAND_ENV]: '1' } : {}) }, cardLabelContext: taskCardLabelContext(card) };
+  const context: TaskLaunchContext = { runId, launchId, env: { [HARNESS_RUN_ID_ENV]: runId, ELANOUS_TASK_CARD_ID: card.id,
+    ...(card.checklistId ? { ELANOUS_POD_SLOT_ID: card.checklistId } : {}),
+    ...(card.seat ? { ELANOUS_POD_OWNER_KIND: 'seat', ELANOUS_POD_OWNER_ID: card.seat } : {}),
+    ...(card.taLand ? { [TA_LAND_ENV]: '1' } : {}) }, cardLabelContext: taskCardLabelContext(card) };
   let receipt: void | TaskLaunchReceipt;
   try {
     receipt = await opts.launcher(move.command!, project?.target, context);

package/src/task-orchestrator/surfaces/pod-command-job.ts

@@ -371,6 +371,12 @@ export interface RunPodCommandOptions {
   runId?: string;
   name?: string;
   pollMs?: number;
+  /**
+   * GATE-MULTI-HOST — throw once the Job's status has been unreadable (`kubectl get job` failing) this long, instead of
+   * polling forever: a pool member that died mid-Job (host off · tailnet drop) then frees its caller to place the work
+   * elsewhere. Omitted = poll without a bound (unchanged for every caller but the release gate).
+   */
+  statusUnreadableMs?: number;
   kubectl?: Kubectl;
   /** A caller-owned scheduler is self-capped: acquires count only its own Jobs, never cluster occupancy (POOLGLOBAL-REG). */
   poolScheduler?: PodPoolScheduler;
@@ -536,10 +542,18 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       throw new Error(applied.stderr.trim() || 'pod command: Job 적용 실패');
     }
     let state: 'complete' | 'failed' = 'failed';
+    let unreadableSince: number | null = null;
     for (;;) {
       const got = kubectl(['-n', namespace, 'get', 'job', name, '-o', 'jsonpath={.status.conditions[*].type}']);
       const finished = jobFinished(got.stdout);
       if (finished) { state = finished; break; }
+      if (got.status !== 0 && options.statusUnreadableMs !== undefined) {
+        unreadableSince ??= Date.now();
+        if (Date.now() - unreadableSince >= options.statusUnreadableMs) {
+          log('pod.command', 'job-status-unreadable', { job: name, context, unreadableMs: Date.now() - unreadableSince, error: (got.stderr ?? '').trim().slice(0, 300) });
+          throw new Error(`pod command: Job 상태를 ${Math.round(options.statusUnreadableMs / 1000)}초 동안 못 읽었다(${context}) — ${(got.stderr ?? '').trim().split('\n').pop()?.slice(0, 200) ?? ''}`);
+        }
+      } else unreadableSince = null;
       await sleep(options.pollMs ?? 15_000);
     }
     const logsResult = kubectl(['-n', namespace, 'logs', `job/${name}`, '-c', 'child']);

package/src/task-orchestrator/surfaces/pod-host-acp-review.ts

@@ -0,0 +1,122 @@
+// REVIEW-ACP-POD (0.2.25 · REVIEW-ACP-DEFAULT ② 조각) — Pod 런이 낸 merge-ready PR 을 «호스트»가 Claude ACP(구독)로 다시 본다.
+//
+// S  Pod 안 하니스 리뷰는 api 리뷰어(codex 기본 gpt-6-sol · OR Pod 는 glm 고정)로 돈다 — Pod 엔 Claude 구독도 정책 파일도 없어
+//    `roleLlm.reviewer = claude-acp`(운영에 이미 켜져 있다)가 Pod 안에선 «안 닿는다». 호스트 레인 런만 ACP 로 리뷰받는다.
+// C  Pod 가 호스트로 돌려보내는 유일한 문은 merge-ready → 호스트 재게이트 → 병합이다. 여기에 리뷰가 없다.
+// Q  Pod 런의 리뷰를 구독(ACP)으로 옮기려면 어디서 하나?
+// A  호스트 병합 직전 한 자리에서, 하니스 레인과 «같은» 정책 행(`resolveSubscriptionReviewer`)·같은 가용성 검사
+//    (`subscriptionReviewerAvailability` — 구독 확인 · 상한 · 프록시)·같은 ACP 리뷰어(`makeAcpReviewLLM`)로 PR 을 본다.
+//    ⛔ 못 쓰면(설정 없음·구독 확인 실패·상한·프록시 없음·리뷰 미완) «refused» 로 돌려주고 호출자는 종전 길(Pod 리뷰 결과로 재게이트)을 그대로 간다.
+//       조용히 다른 공급자로 새지 않는다 — 이 함수 안엔 api 폴백이 «없다».
+//    ⛔ 기본 꺼짐(opt-in): 옵션 → env `ELANOUS_POD_HOST_ACP_REVIEW` → config `llm.podHostAcpReview` 순.
+//    📌 남은 조각(②-b): 이 문이 켜진 런에서 Pod 안 api 리뷰를 «끄는» 것은 Pod 이미지 쪽 변경이라 따로 간다.
+import { spawnSync } from 'node:child_process';
+import { debug } from '../../debug/log.js';
+import type { ReviewResult } from '../../agent-substrate/pr-reviewer.js';
+import type { SubscriptionReviewerSpec } from '../../user-config.js';
+import type { SubscriptionReviewerDeps, subscriptionReviewerSpawn } from '../../self-dev/review-provider-fallback.js';
+
+export const POD_HOST_ACP_REVIEW_ENV = 'ELANOUS_POD_HOST_ACP_REVIEW';
+
+export type PodHostAcpReviewEnable = { enabled: boolean; source: 'option' | 'env' | 'config' | 'default' };
+
+/** 켜는 순서: 옵션 → env(`1`/`true` 켬 · `0`/`false` 끔) → config `llm.podHostAcpReview === true` → 꺼짐. 읽기 실패는 꺼짐(종전). */
+export function resolvePodHostAcpReview(
+  option: boolean | undefined,
+  env: NodeJS.ProcessEnv,
+  readConfig: () => unknown,
+): PodHostAcpReviewEnable {
+  if (typeof option === 'boolean') return { enabled: option, source: 'option' };
+  const raw = env[POD_HOST_ACP_REVIEW_ENV]?.trim().toLowerCase();
+  if (raw === '1' || raw === 'true') return { enabled: true, source: 'env' };
+  if (raw === '0' || raw === 'false') return { enabled: false, source: 'env' };
+  try {
+    const cfg = readConfig() as { llm?: { podHostAcpReview?: unknown } } | undefined;
+    if (cfg?.llm?.podHostAcpReview === true) return { enabled: true, source: 'config' };
+  } catch { /* 읽기 실패 = 꺼짐(종전 길) */ }
+  return { enabled: false, source: 'default' };
+}
+
+export type PodHostAcpReviewOutcome =
+  | { status: 'clean'; mustFix: 0; shouldFix: number }
+  | { status: 'must-fix'; mustFix: number; findings: string[]; verdict: ReviewResult['verdict'] }
+  | { status: 'refused'; reason: string };
+
+export interface PodHostAcpReviewDeps {
+  /** `{ spec, cap }` — 기본은 하니스 레인과 같은 정책 행(`resolveSubscriptionReviewer`). */
+  resolveReviewer?: () => { spec: SubscriptionReviewerSpec; cap: number } | undefined;
+  /** 구독·상한·프록시 확인 — 기본은 `subscriptionReviewerAvailability`. */
+  availability?: (spec: SubscriptionReviewerSpec, cap: number) => { spawn?: ReturnType<typeof subscriptionReviewerSpawn>; reason?: string };
+  subscriptionReviewerDeps?: SubscriptionReviewerDeps;
+  /** PR 머리 sha·제목·본문·diff. 기본은 `gh`. */
+  readPr?: (prNumber: number, repoRoot: string) => { headRefOid: string; title: string; body: string; diff: string } | undefined;
+  /** ACP 리뷰어(prompt→text). 기본은 `makeAcpReviewLLM({ backend: 'claude', backendSpec, env })`. */
+  makeAcpReviewLLM?: (spawn: ReturnType<typeof subscriptionReviewerSpawn>, repoRoot: string) => (prompt: string) => Promise<string>;
+  reviewPullRequest?: (input: { prDiff: string; phaseIntent: string }, llm: (prompt: string) => Promise<string>) => Promise<ReviewResult>;
+  env?: NodeJS.ProcessEnv;
+}
+
+function defaultReadPr(prNumber: number, repoRoot: string): { headRefOid: string; title: string; body: string; diff: string } | undefined {
+  const view = spawnSync('gh', ['pr', 'view', String(prNumber), '--json', 'headRefOid,title,body'], { cwd: repoRoot, encoding: 'utf8', timeout: 60_000 });
+  if (view.status !== 0) return undefined;
+  const diff = spawnSync('gh', ['pr', 'diff', String(prNumber)], { cwd: repoRoot, encoding: 'utf8', timeout: 120_000, maxBuffer: 64 * 1024 * 1024 });
+  if (diff.status !== 0) return undefined;
+  try {
+    const parsed = JSON.parse(view.stdout) as { headRefOid?: unknown; title?: unknown; body?: unknown };
+    if (typeof parsed.headRefOid !== 'string') return undefined;
+    return { headRefOid: parsed.headRefOid, title: typeof parsed.title === 'string' ? parsed.title : '', body: typeof parsed.body === 'string' ? parsed.body : '', diff: diff.stdout };
+  } catch { return undefined; }
+}
+
+function refused(reason: string, data: Record<string, unknown>): PodHostAcpReviewOutcome {
+  try { debug.log('self-implement.pod', 'acp-review-refused', { ...data, reason }, { level: 'warn' }); } catch { /* 관측은 결과를 안 바꾼다 */ }
+  return { status: 'refused', reason };
+}
+
+/** Pod merge-ready PR 을 호스트 Claude ACP 로 리뷰한다. ⛔ 던지지 않는다 — 모든 실패는 `refused`(호출자는 종전 길). */
+export async function runPodHostAcpReview(
+  input: { prNumber: number; headCommit: string; repoRoot: string; job?: string },
+  deps: PodHostAcpReviewDeps = {},
+): Promise<PodHostAcpReviewOutcome> {
+  const obs = { job: input.job ?? null, pr: input.prNumber, head: input.headCommit };
+  try {
+    const env = deps.env ?? process.env;
+    // 지연 import — 이 문이 꺼진 런은 정책·설정을 안 읽는다.
+    const picked = deps.resolveReviewer ? deps.resolveReviewer() : await (async () => {
+      const { loadLlmPolicy, resolveSubscriptionReviewer } = await import('../../policy/llm-policy.js');
+      const { getUserConfig } = await import('../../user-config.js');
+      return resolveSubscriptionReviewer(loadLlmPolicy(), getUserConfig().roleLlm);
+    })();
+    if (!picked) return refused('no-subscription-reviewer', obs);
+    const avail = deps.availability
+      ? deps.availability(picked.spec, picked.cap)
+      : (await import('../../self-dev/review-provider-fallback.js')).subscriptionReviewerAvailability(picked.spec, picked.cap, env, deps.subscriptionReviewerDeps);
+    if (!avail.spawn) return refused(`unavailable: ${avail.reason ?? 'unknown'}`, { ...obs, cap: picked.cap });
+    const pr = (deps.readPr ?? defaultReadPr)(input.prNumber, input.repoRoot);
+    if (!pr) return refused('pr-unreadable', obs);
+    if (pr.headRefOid.toLowerCase() !== input.headCommit.toLowerCase()) return refused('head-moved', { ...obs, prHead: pr.headRefOid });
+    if (!pr.diff.trim()) return refused('empty-diff', obs);
+    const llm = deps.makeAcpReviewLLM
+      ? deps.makeAcpReviewLLM(avail.spawn, input.repoRoot)
+      : await (async () => {
+        const { makeAcpReviewLLM } = await import('../../agent-substrate/acp-reviewer.js');
+        const spawn = avail.spawn!;
+        return makeAcpReviewLLM({ cwd: input.repoRoot, backend: 'claude', backendSpec: spawn.backendSpec, env: spawn.env });
+      })();
+    const review = deps.reviewPullRequest ?? (await import('../../agent-substrate/pr-reviewer.js')).reviewPullRequest;
+    const phaseIntent = [`Pod 런 PR #${input.prNumber} 의 호스트 Claude ACP 리뷰(병합 전 관문).`, pr.title, pr.body.slice(0, 4000)].filter((s) => s.trim()).join('\n\n');
+    const rr = await review({ prDiff: pr.diff, phaseIntent }, llm);
+    // ⛔ reviewed=false(파싱 실패·ACP 오류를 리뷰어가 흡수) 는 «리뷰 완료»가 아니다 — 통과로 읽지 않는다.
+    if (!rr.reviewed) return refused('acp-review-not-completed', obs);
+    const mustFix = rr.mustFix.length;
+    if (rr.verdict === 'fail' || mustFix > 0) {
+      debug.log('self-implement.pod', 'host-acp-review', { ...obs, status: 'must-fix', verdict: rr.verdict, mustFix, shouldFix: rr.shouldFix.length });
+      return { status: 'must-fix', mustFix, findings: rr.mustFix.slice(0, 10), verdict: rr.verdict };
+    }
+    debug.log('self-implement.pod', 'host-acp-review', { ...obs, status: 'clean', verdict: rr.verdict, mustFix: 0, shouldFix: rr.shouldFix.length });
+    return { status: 'clean', mustFix: 0, shouldFix: rr.shouldFix.length };
+  } catch (error) {
+    // 원문은 싣지 않는다 — 계정·프록시 문면이 섞일 수 있다(하니스 레인과 같은 규율).
+    return refused(/handshake timeout/i.test(error instanceof Error ? error.message : String(error)) ? 'acp-handshake-timeout' : 'acp-error', obs);
+  }
+}