elanous 0.2.23 → 0.2.25

package/src/agent-substrate/acp-implementer.ts

@@ -0,0 +1,146 @@
+// ── ACP Claude Code 를 «구현» 실행기로 (CLAUDE-IMPL-LANE · `--child-llm-provider claude-acp`) ──
+//
+// acp-reviewer.ts 의 짝이다. 리뷰어는 read-only 라 읽기 툴만 허가하지만, 구현 실행기는 런 워크트리 안에서
+// 쓰기·실행을 허가해야 한다. 대표 대표 결정(10-12): ACP 세션 권한 모드는 호스트 설정(auto)을 그대로 두고
+// 바꾸지 않으며, approver 가 불려도 «워크트리 밖 경로 쓰기»를 거부하지 않고 허가하되 insideWorktree 로 관측한다.
+// 자식은 claude 구독 ACP 어댑터(`claude-agent-acp`)이며 env 는 subscriptionReviewerSpawn 의 과금 스크럽
+// (ANTHROPIC_API_KEY 등 제거)을 그대로 쓴다 — 지우지 않으면 구독이 아니라 API 로 과금된다.
+import { isAbsolute, relative, resolve } from 'node:path';
+import { AcpAgent, type AcpAgentOpts } from '../acp/client.js';
+import { debug } from '../debug/log.js';
+import { subscriptionReviewerSpawn } from '../self-dev/review-provider-fallback.js';
+import type { SubscriptionReviewerSpec } from '../user-config.js';
+import { isReadOnlyReviewTool } from './acp-reviewer.js';
+
+const WRITE_TOOL_KINDS = new Set(['edit', 'delete', 'move']);
+const PATH_INPUT_KEYS = ['file_path', 'filePath', 'path', 'notebook_path', 'destination', 'source'] as const;
+
+export interface ImplementerPermissionRequest {
+  title: string;
+  kind?: string;
+  rawInput?: unknown;
+}
+
+export interface ImplementerPermissionDecision {
+  tool: string;
+  path: string | null;
+  /** 판정에 쓴 경로가 워크트리 안인가 — 경로가 없으면 null. 밖이어도 허가한다(대표 10-12); 이 칸이 그 관측이다. */
+  insideWorktree: boolean | null;
+  decision: 'allow' | 'deny';
+}
+
+function requestedPaths(rawInput: unknown): string[] {
+  if (!rawInput || typeof rawInput !== 'object') return [];
+  const input = rawInput as Record<string, unknown>;
+  return PATH_INPUT_KEYS.flatMap((key) => (typeof input[key] === 'string' && input[key] ? [input[key] as string] : []));
+}
+
+function insideWorktree(worktree: string, target: string): boolean {
+  const rel = relative(resolve(worktree), resolve(worktree, target));
+  return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+
+/** 허가 판정(순수 함수). 쓰기 계열(edit·delete·move)은 경로가 있으면 워크트리 안팎을 가리지 않고 허가한다
+ *  (대표 10-12 — 밖 쓰기 거부를 걷었다 · insideWorktree 로 관측만 한다). 실행(execute)·읽기 계열은 허가,
+ *  그 외(모르는 kind)는 경로가 있을 때만 허가 — 경로 없는 쓰기·모르는 요청은 여전히 거부. */
+export function decideImplementerPermission(req: ImplementerPermissionRequest, worktree: string): ImplementerPermissionDecision {
+  const paths = requestedPaths(req.rawInput);
+  const outside = paths.find((p) => !insideWorktree(worktree, p));
+  const tool = req.title.slice(0, 80);
+  const shown = outside ?? paths[0] ?? null;
+  const inside = paths.length === 0 ? null : outside === undefined;
+  const verdict = (allow: boolean): ImplementerPermissionDecision => ({ tool, path: shown, insideWorktree: inside, decision: allow ? 'allow' : 'deny' });
+  if (req.kind && WRITE_TOOL_KINDS.has(req.kind)) return verdict(paths.length > 0);
+  if (req.kind === 'execute') return verdict(true);
+  if (isReadOnlyReviewTool(req.kind, req.title)) return verdict(true);
+  return verdict(paths.length > 0);
+}
+
+export interface AcpImplementerOpts {
+  /** 런 워크트리 — ACP 자식의 cwd 이자 쓰기 허용 경계. */
+  worktree: string;
+  /** 자식 env 의 원천(기본 process.env). 과금 키는 subscriptionReviewerSpawn 이 제거한다. */
+  env?: NodeJS.ProcessEnv;
+  /** cct 실행기가 `teamclaude env --no-mitm` 에서 읽은 프록시 주소. */
+  proxyBaseUrl?: string;
+  spec?: SubscriptionReviewerSpec;
+  /** 모델 별칭 — 지정 시 session/set_model 로 고정. */
+  model?: string;
+  /** 이어갈 ACP 세션 id — 주면 newSession 대신 loadSession 으로 이어간다. */
+  resumeSessionId?: string;
+  /** 구현 1턴 최대 대기(ms). 초과 시 cancel → throw. 기본 1_800_000. */
+  timeoutMs?: number;
+  /** spawn → initialize → session 준비까지의 단일 기한(ms). 기본 60_000. */
+  handshakeTimeoutMs?: number;
+  /** 테스트용 ACP 에이전트 생성기. */
+  createAgent?: (opts: AcpAgentOpts) => AcpAgent;
+}
+
+export interface AcpImplementerResult {
+  text: string;
+  sessionId: string;
+  allowed: number;
+  denied: number;
+}
+
+const OBS = 'agent-substrate.acp-implementer';
+
+export function makeAcpImplementer(opts: AcpImplementerOpts): (prompt: string) => Promise<AcpImplementerResult> {
+  return async (prompt) => {
+    const spawn = subscriptionReviewerSpawn(opts.spec ?? { provider: 'claude-acp' }, opts.env ?? process.env, opts.proxyBaseUrl);
+    const timeoutMs = opts.timeoutMs ?? 1_800_000;
+    const handshakeTimeoutMs = opts.handshakeTimeoutMs ?? 60_000;
+    let allowed = 0;
+    let denied = 0;
+    const agentOpts: AcpAgentOpts = {
+      backendId: 'claude',
+      backendSpec: spawn.backendSpec,
+      env: spawn.env,
+      cwd: opts.worktree,
+      log: (message) => debug.log(OBS, 'agent-log', { message }),
+      permissionApprover: async (req) => {
+        const verdict = decideImplementerPermission(req, opts.worktree);
+        if (verdict.decision === 'allow') allowed++; else denied++;
+        debug.log(OBS, 'permission', {
+          tool: verdict.tool, path: verdict.path, insideWorktree: verdict.insideWorktree, allowed: verdict.decision === 'allow',
+        });
+        return verdict.decision === 'allow';
+      },
+    };
+    const agent = opts.createAgent ? opts.createAgent(agentOpts) : new AcpAgent(agentOpts);
+    let handshakeTimer: ReturnType<typeof setTimeout> | undefined;
+    const withinHandshake = <T>(step: Promise<T>): Promise<T> => Promise.race([step, new Promise<never>((_, reject) => {
+      handshakeTimer = setTimeout(() => reject(new Error(`ACP handshake timeout (${handshakeTimeoutMs}ms)`)), handshakeTimeoutMs);
+    })]).finally(() => { if (handshakeTimer) clearTimeout(handshakeTimer); });
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    let timedOut = false;
+    let text = '';
+    try {
+      await withinHandshake(agent.start());
+      let sid: string;
+      if (opts.resumeSessionId) {
+        await withinHandshake(agent.loadSession({ sessionId: opts.resumeSessionId, cwd: opts.worktree }));
+        sid = opts.resumeSessionId;
+      } else {
+        sid = await withinHandshake(agent.newSession());
+      }
+      if (opts.model) await withinHandshake(agent.selectSessionModel(sid, opts.model));
+      debug.log(OBS, 'start', { cwd: opts.worktree, model: opts.model ?? '(default)', resumed: Boolean(opts.resumeSessionId) });
+      timer = setTimeout(() => { timedOut = true; agent.cancel(sid).catch(() => { /* noop */ }); }, timeoutMs);
+      await agent.prompt(sid, [{ type: 'text', text: prompt }], (u) => {
+        if (u.sessionUpdate === 'agent_message_chunk' && u.content.type === 'text' && u.content.text) text += u.content.text;
+      });
+      if (timedOut) throw new Error(`ACP 구현 타임아웃(${timeoutMs}ms)`);
+      debug.log(OBS, 'done', { chars: text.length, allowed, denied });
+      return { text, sessionId: sid, allowed, denied };
+    } catch (e) {
+      debug.log(OBS, 'error', { message: (e as Error).message, allowed, denied }, { level: 'error' });
+      throw e;
+    } finally {
+      if (timer) clearTimeout(timer);
+      try { await agent.stop(); } catch (e) {
+        debug.log(OBS, 'stop-fail', { message: (e as Error).message }, { level: 'error' });
+      }
+    }
+  };
+}

package/src/agent-substrate/pr-reviewer.ts

@@ -652,20 +652,48 @@ export function buildReviewPrompt(
  *  `none of the tests …`. 표지 낱말로 시작하는 실제 블로커를 지우면 PASS/WARN 리뷰에서 블로커가 사라진다. */
 const NONE_WORD = String.raw`(?:없음|해당\s*없음|n\/a|none|nothing)`;
 const BARE_SENTINEL = new RegExp(String.raw`^${NONE_WORD}\s*[.。]?$`, 'i');
-const BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*${NONE_WORD}(?:\s*[—–\-:.,;]\s*([^)\]）】]*))?\s*[)\]）】]$`, 'i');
+const BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*${NONE_WORD}(?:\s*[—–\-:.,;·]\s*([^)\]）】]*))?\s*[)\]）】]$`, 'i');
 // ⭐ 설명 «전체»가 「지적 없음」 한 문장일 때만 — 일부만 맞아도 접으면 `(none: no blockers are checked because …)` 같은 지적이 사라진다.
 const NO_FINDING_REMARK = new RegExp([
   String.raw`^(?:(?:블로커|차단)\s*)?(?:수준의?\s*)?(?:결함|문제|이슈|지적|블로커)(?:은|는|이|가)?\s*(?:발견되지\s*않(?:음|았(?:다|습니다)?)|없(?:음|다|습니다))[.。]?$`,
   String.raw`^(?:no|zero)\s+(?:blocking\s+)?(?:blockers?|issues?|problems?|findings?|must-?fix(?:es)?)(?:\s+found)?\.?$`,
   String.raw`^nothing\s+(?:blocking|to\s+fix)\.?$`,
+  // REVIEW-MUSTFIX-NONE-SENTINEL — `(없음 — 수용기준 충족)` · `(none — acceptance criteria met)` (GLM 실측 6건). «미충족» 은 ^ 앵커로 안 맞는다.
+  String.raw`^수용\s*기준(?:을|이)?\s*(?:(?:모두|전부)\s*)?충족(?:함|됨|했다|합니다)?[.。]?$`,
+  String.raw`^(?:all\s+)?acceptance\s+criteria\s+(?:are\s+)?(?:all\s+)?met\.?$`,
 ].join('|'), 'i');
-function isNoneSentinelFinding(finding: string): boolean {
+// REVIEW-MUSTFIX-NONE-SENTINEL 후속 — GLM 이 괄호 안에 «무소견 머리 + 긴 근거»를 쓴다(10-11 TC `pr land` 가 `review-must-fix-1` 로 거부):
+//   `(없음 — 수용기준 충족: 머리말에 … 반영됨 …)` · `(없음 — 수용기준 3항 모두 충족: … (\`'failed'\` 반환) · …)`(근거 안에 괄호가 또 있다).
+//   ⭐ 길이 무관 0 은 «머리»가 무소견 서술이고 바로 구분자가 올 때만 — 머리가 결함 서술이면(`(없음 — 하지만 X 가 깨진다)`) 지적으로 남긴다.
+//   ⛔ 근거에 역접·미충족(`하지만`·`다만`·`미충족`·`but`·`except`·`not met` …)이 있으면 보수적으로 지적으로 남긴다.
+const LONG_BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*${NONE_WORD}\s*[—–\-:·]\s*([\s\S]+?)\s*[)\]）】]$`, 'i');
+const NO_FINDING_HEAD = new RegExp('^(?:' + [
+  String.raw`수용\s*기준(?:\s*\d+\s*(?:항|개|건)(?:목)?)?(?:을|이)?\s*(?:(?:모두|전부)\s*)?충족(?:함|됨|했다|합니다)?`,
+  String.raw`(?:all\s+)?acceptance\s+criteria\s+(?:are\s+)?(?:all\s+)?met`,
+  String.raw`must-?fix\s*(?:항목)?(?:은|는|이|가)?\s*(?:없(?:음|다|습니다)|0\s*건)`,
+  String.raw`(?:no|zero)\s+(?:blocking\s+)?(?:blockers?|must-?fix(?:es)?)(?:\s+found)?`,
+  String.raw`(?:(?:블로커|차단)\s*)?(?:수준의?\s*)?(?:결함|블로커)(?:은|는|이|가)?\s*(?:발견되지\s*않(?:음|았(?:다|습니다)?)|없(?:음|다|습니다))`,
+].join('|') + String.raw`)\s*(?:[:：—–\-·,;.。(]|$)`, 'i');
+const LONG_REMARK_DISSENT = /하지만|그러나|다만|(?<![가-힣])단(?:,|\s)|미\s*충족|불\s*충족|충족하지|충족되지|\bbut\b|\bhowever\b|\bexcept\b|\balthough\b|\bnot\s+(?:yet\s+)?met\b|\bunmet\b/i;
+/** 괄호 안이 «없음 + 구분자 + 무소견 머리 …» 인가 — 길이 무관(근거 안 괄호도 허용). `isNoneSentinelFinding` 의 갈래. */
+function isLongNoFindingBracket(text: string): boolean {
+  const m = LONG_BRACKETED_SENTINEL.exec(text.trim());
+  if (!m) return false;
+  const remark = m[1]!.trim();
+  return NO_FINDING_HEAD.test(remark) && !LONG_REMARK_DISSENT.test(remark);
+}
+/** must-fix 항목이 «지적 없음» 표지인가 — must-fix 를 세는 자리는 전부 `parseReviewResult` 를 거친다
+ *  (`self review --json` 의 `mustFix` → TA `parseReviewResultOutput` → `pr land --overlap-evidence` 의 `review-must-fix-N`).
+ *  ⭐ export — `parseReviewResultOutput` 가 «같은» 판정으로 저장된 결과의 표지 줄을 다시 접는다(PR-LAND-MUSTFIX-NONE · 복제 금지). */
+export function isNoneSentinelFinding(finding: string): boolean {
   const text = finding.trim();
   if (BARE_SENTINEL.test(text)) return true;
   const bracketed = BRACKETED_SENTINEL.exec(text);
-  if (!bracketed) return false;
-  const remark = bracketed[1]?.trim();
-  return !remark || NO_FINDING_REMARK.test(remark);
+  if (bracketed) {
+    const remark = bracketed[1]?.trim();
+    if (!remark || NO_FINDING_REMARK.test(remark)) return true;
+  }
+  return isLongNoFindingBracket(text);
 }
 
 /** critic 응답 파싱 → ReviewResult. 순수함수. VERDICT + MUST-FIX/SHOULD-FIX/REQUIREMENTS 섹션 분해.
@@ -738,6 +766,25 @@ function reviewedResultFromRaw(raw: string, runId: string | undefined, pass?: {
   return { verdict: 'pass', mustFix: [], shouldFix: [], reviewed: false, failureReason: NO_VERDICT_LINE_REASON };
 }
 
+/** REVIEW-PROMPT-SIZE — llmReview 호출 하나(단일·청크 패스)마다 프롬프트·응답 크기를 남긴다.
+ *  관측이 리뷰를 막지 않는다(다른 review.* 관측과 같은 계약). */
+function logReviewPromptSize(
+  prompt: string,
+  response: string,
+  pass: { pass: number; chunked: boolean },
+  runId: string | undefined,
+): void {
+  try {
+    debug.log('review.prompt-size', 'call', {
+      pass: pass.pass,
+      promptChars: prompt.length,
+      responseChars: response.length,
+      chunked: pass.chunked,
+      ...(runId !== undefined ? { runId } : {}),
+    });
+  } catch { /* Observation must not prevent the review. */ }
+}
+
 function failureReasonText(error: unknown): string {
   if (error instanceof Error) return safeLogText(error.message, 400);
   if (typeof error === 'string') return safeLogText(error, 400);
@@ -889,10 +936,11 @@ export async function reviewPullRequest(
             + ' 「여기 안 보인다」를 결함으로 판정하지 마십시오.',
           ].filter(Boolean).join('\n'),
         };
-        passResults.push(reviewedResultFromRaw(await llmReview(
-          buildReviewPrompt(passInput, passBudget, '', passContext[index]?.budget),
-          reviewImages.length > 0 && index === 0 ? reviewImages : undefined,
-        ), input.reviewContext?.runId, { index, of: plan.passes.length }));
+        const passPrompt = buildReviewPrompt(passInput, passBudget, '', passContext[index]?.budget);
+        const passImages = reviewImages.length > 0 && index === 0 ? reviewImages : undefined;
+        const passRaw = await llmReview(passPrompt, passImages);
+        logReviewPromptSize(passPrompt, passRaw, { pass: index + 1, chunked: true }, input.reviewContext?.runId);
+        passResults.push(reviewedResultFromRaw(passRaw, input.reviewContext?.runId, { index, of: plan.passes.length }));
       }
       return {
         ...foldReviewResults(passResults),
@@ -916,10 +964,9 @@ export async function reviewPullRequest(
         } : {}),
       };
     }
-    const raw = await llmReview(
-      buildReviewPrompt(input, diffBudget, referencedContext.text, singleContextBudget),
-      reviewImages.length > 0 ? reviewImages : undefined,
-    );
+    const prompt = buildReviewPrompt(input, diffBudget, referencedContext.text, singleContextBudget);
+    const raw = await llmReview(prompt, reviewImages.length > 0 ? reviewImages : undefined);
+    logReviewPromptSize(prompt, raw, { pass: 1, chunked: false }, input.reviewContext?.runId);
     return {
       ...reviewedResultFromRaw(raw, input.reviewContext?.runId),
       diffBudget: {

package/src/agent-substrate/self-review-cli.ts

@@ -14,6 +14,9 @@
 //
 // index.ts 의 액션은 옵션 파싱과 실제 의존 배선만 남는다(얇은 껍데기).
 
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { tierModel } from '../llm/model-defaults.js';
 import { buildReviewObservation, safeLogText } from './review-observation.js';
 import { DEFAULT_REVIEW_BACKEND } from './acp-reviewer.js';
@@ -24,6 +27,9 @@ import type { ReferencedFileReader } from '../self-implement/goal-file-reader.js
 import type { SubscriptionReviewerSpec } from '../user-config.js';
 import { listRunLedgers, lookupPrGoalAcceptance, lookupRunLedger, type PrGoalAcceptanceLookup, type RunLedgerEntry, type RunLedgerLookup } from '../self-implement/run-ledger.js';
 
+/** SUBSCRIPTION-EXHAUST-REROUTE — API reviewer when the configured `roleLlm.reviewer` lane is unavailable (off codex). */
+export const ROLE_REVIEWER_FALLBACK_MODEL = 'openrouter/z-ai/glm-5.3';
+
 export interface SelfReviewCliOpts {
   intent?: string | undefined;
   model?: string | undefined;
@@ -54,8 +60,13 @@ export interface SelfReviewCliDeps {
    *  (`#7486` 리뷰 must-fix · 실제로 `index.ts` 래퍼가 그렇게 한 번 떨어뜨렸다). */
   reviewPullRequest(input: ReviewInput, llm: (prompt: string, images?: readonly ReviewImage[]) => Promise<string>): Promise<ReviewResult>;
   renderReview(review: ReviewResult): string;
-  /** 기본 경로 리뷰어 LLM(API). */
-  makeApiLlm(model: string): (prompt: string) => Promise<string>;
+  /**
+   * 기본 경로 리뷰어 LLM(API).
+   * `o.pinProvider` — 명시 `--model` 일 때 true: 구현은 streamLLM 의 provider 를 그 모델의 provider 로 고정해
+   * 라우터 폴백(grok 등)으로 조용히 넘어가지 않고 실패를 오류로 낸다.
+   * `o.onResolved` — streamLLM 이 «실제로 응답한» provider·model 을 알린다.
+   */
+  makeApiLlm(model: string, o?: { pinProvider?: boolean; onResolved?: (provider: string, model: string) => void }): (prompt: string) => Promise<string>;
   /** `--acp` 경로 리뷰어 LLM(독립 프로세스). */
   /**
    * ⭐ `P4b` — 두 번째 인자가 **멀티미디어 통로**다.
@@ -67,15 +78,20 @@ export interface SelfReviewCliDeps {
    *
    * ⚠️ API 백엔드(`makeApiLlm`)는 이 인자를 안 받는다 — ACP 경로만 이미지를 나른다.
    */
-  makeAcpLlm(o: { backend: string; model?: string; timeoutMs: number }): (prompt: string, images?: readonly ReviewImage[]) => Promise<string>;
+  makeAcpLlm(o: { backend: string; model?: string; timeoutMs: number; cwd?: string }): (prompt: string, images?: readonly ReviewImage[]) => Promise<string>;
   /**
    * Reviewer ACP lane selected by `roleLlm.reviewer` (no explicit flag). Returns the LLM when the
    * subscription is usable, or a reason code when it is not — the caller then reviews on the API
    * exactly as before. Absent seam = the lane is unavailable (`role-reviewer-seam-missing`).
    */
-  makeRoleReviewerLlm?(spec: SubscriptionReviewerSpec, o: { timeoutMs: number }):
+  makeRoleReviewerLlm?(spec: SubscriptionReviewerSpec, o: { timeoutMs: number; cwd?: string }):
     | { llm: (prompt: string, images?: readonly ReviewImage[]) => Promise<string>; backend: string }
     | { reason: string };
+  /**
+   * SUBSCRIPTION-EXHAUST-REROUTE — API model used when `roleLlm.reviewer` is configured (no explicit flag) but its
+   * lane is unavailable or fails. Absent seam or empty answer = the codex-ladder default as before.
+   */
+  roleFallbackModel?(): string | undefined;
   /** 관측 sink 등록 — ⭐ 이 호출이 분기 밖에 있는지가 이 트랙의 계약이다. */
   registerSink(surface: string): Promise<void>;
   /** `data` 는 payload 객체 — 순수 헬퍼가 만든 관측 타입도 그대로 받는다(인덱스 시그니처 강요 금지). */
@@ -95,6 +111,8 @@ export interface SelfReviewCliDeps {
 
 export interface SelfReviewCliOutcome {
   results: Array<Record<string, unknown>>;
+  /** 리뷰하지 못한 PR 수(`gh pr diff` 실패 · ACP 리뷰 reviewed=false) — json·비json 둘 다 센다. index.ts 가 1 이상이면 rc=1. */
+  failed: number;
 }
 
 interface GhResult {
@@ -1149,6 +1167,65 @@ export function renderReviewerContextStatus(loaded: LoadedReviewerContext, decom
   return `Reviewer context: ${loaded.items.length} loaded, ${loaded.failed.length} not loaded.${source}${truncation}${decompositionStatus}${labels ? `\n${labels}` : ''}${failures ? `\n${failures}` : ''}`;
 }
 
+/**
+ * 머지된 PR 의 사후 리뷰 격리 — 리뷰어 cwd 가 main 최신이면 그 뒤 수리를 인용한다.
+ * `merged` 는 그 PR 의 머지 커밋, `open` 은 종전(cwd 불변), `unpinnable` 은 MERGED 인데 머지 커밋을 못 구한 경우다.
+ */
+type PrMergeState =
+  | { kind: 'open' }
+  | { kind: 'merged'; commit: string }
+  | { kind: 'unpinnable'; reason: 'merge-commit-unknown' };
+
+function readPrMergeState(pr: string, deps: SelfReviewCliDeps): PrMergeState {
+  const view = deps.gh(['pr', 'view', pr, '--json', 'state,mergeCommit'], 15_000);
+  if (view.status !== 0) return { kind: 'open' };
+  try {
+    const parsed = JSON.parse(view.stdout) as { state?: unknown; mergeCommit?: { oid?: unknown } | null };
+    if (parsed?.state !== 'MERGED') return { kind: 'open' };
+    const oid = parsed.mergeCommit?.oid;
+    return typeof oid === 'string' && COMMIT_OID.test(oid)
+      ? { kind: 'merged', commit: oid }
+      : { kind: 'unpinnable', reason: 'merge-commit-unknown' };
+  } catch {
+    return { kind: 'open' };
+  }
+}
+
+interface ReviewWorktree {
+  cwd: string;
+  commit: string;
+  /** 멱등 — 두 번 불러도 안전하다. */
+  remove(): void;
+}
+
+type ReviewWorktreeResult = ReviewWorktree | { reason: 'no-git-seam' | 'worktree-add-failed' };
+
+function createDetachedReviewWorktree(commit: string, deps: SelfReviewCliDeps): ReviewWorktreeResult {
+  const git = deps.git;
+  if (!git) return { reason: 'no-git-seam' };
+  const parent = mkdtempSync(join(tmpdir(), 'elanous-review-pin-'));
+  const cwd = join(parent, 'wt');
+  const add = () => git(['worktree', 'add', '--detach', cwd, commit], 120_000);
+  let added = add();
+  if (added.status !== 0) {
+    git(['fetch', 'origin', commit], 120_000);
+    added = add();
+  }
+  let removed = false;
+  const remove = (): void => {
+    if (removed) return;
+    removed = true;
+    git(['worktree', 'remove', '--force', cwd], 60_000);
+    rmSync(parent, { recursive: true, force: true });
+    // ⛔ `git worktree prune` 은 부르지 않는다 — 저장소 «전체»의 stale 메타데이터를 지워 남의 worktree 까지 건드린다.
+  };
+  if (added.status !== 0) {
+    remove();
+    return { reason: 'worktree-add-failed' };
+  }
+  return { cwd, commit, remove };
+}
+
 /** `elanous self review <pr...>` 본문. read-only — 머지하지 않는다. */
 /**
  * `self review --json` stdout 한 줄 — 결과가 하나면 객체, 여럿이면 배열. index.ts 액션이 이것을 그대로 쓴다.
@@ -1162,6 +1239,20 @@ export async function runSelfReviewCliCommand(
   prArgs: string[],
   opts: SelfReviewCliOpts,
   deps: SelfReviewCliDeps,
+): Promise<SelfReviewCliOutcome> {
+  const pins: ReviewWorktree[] = [];
+  try {
+    return await runSelfReviewCliCommandPinned(prArgs, opts, deps, pins);
+  } finally {
+    for (const pin of pins) pin.remove();
+  }
+}
+
+async function runSelfReviewCliCommandPinned(
+  prArgs: string[],
+  opts: SelfReviewCliOpts,
+  deps: SelfReviewCliDeps,
+  pins: ReviewWorktree[],
 ): Promise<SelfReviewCliOutcome> {
   // 관측 sink는 모든 종료 경로보다 먼저 등록해 거부도 운영 로그에 남긴다.
   await deps.registerSink('self-review');
@@ -1175,7 +1266,7 @@ export async function runSelfReviewCliCommand(
       invalidPrArgs: safeInvalidPrArgs,
     }, { level: 'warn' });
     deps.error(`PR 인자가 올바르지 않습니다: ${safeInvalidPrArgs.join(', ')}. PR 번호는 숫자 형식이어야 합니다 (예: elanous self review 5502).`);
-    return { results: [] };
+    return { results: [], failed: 0 };
   }
 
   const useAcp = opts.acp === true;
@@ -1197,11 +1288,19 @@ export async function runSelfReviewCliCommand(
   if (useAcp) {
     acpReviewLLM = deps.makeAcpLlm({ backend: acpBackend, ...(acpModel ? { model: acpModel } : {}), timeoutMs: acpTimeoutSec * 1000 });
   }
-  const model = useAcp ? `acp:${acpBackend}${acpModel ? `/${acpModel}` : ''}` : (opts.model || deps.envModel() || tierModel('better'));
   // ⭐ Reviewer selection source. An explicit flag always wins byte-for-byte; only without one does
   //    `roleLlm.reviewer` (the harness's reviewer row) pick the ACP lane. Worst case = today's API review.
   const explicitReviewerFlag = opts.acp === true || Boolean(opts.acpBackend) || Boolean(opts.acpModel?.trim()) || Boolean(opts.model?.trim());
   const reviewerSource: 'cli' | 'role-config' | 'default' = explicitReviewerFlag ? 'cli' : opts.roleReviewer ? 'role-config' : 'default';
+  // SUBSCRIPTION-EXHAUST-REROUTE (0.2.24): when `roleLlm.reviewer` is configured but its lane is unavailable
+  //   (10-11 prod: «Claude subscription usage unavailable or at harness cap (60%)»), the API fallback was the codex
+  //   ladder default (`tierModel('better')` = gpt-6-sol) — the CLI read roleLlm.reviewer, then spent codex anyway.
+  //   ⇒ the role-config lane falls back to `roleFallbackModel()` (off codex) when the seam gives one. Explicit flag
+  //   and ELANOUS_PR_REVIEW_MODEL still win; no seam / no answer = today's default byte-for-byte.
+  const envModel = deps.envModel();
+  const roleFallbackModel = !useAcp && !opts.model && !envModel && reviewerSource === 'role-config'
+    ? deps.roleFallbackModel?.()?.trim() || undefined : undefined;
+  const model = useAcp ? `acp:${acpBackend}${acpModel ? `/${acpModel}` : ''}` : (opts.model || envModel || roleFallbackModel || tierModel('better'));
   let roleReviewer: { llm: (prompt: string, images?: readonly ReviewImage[]) => Promise<string>; model: string } | undefined;
   let roleReviewerUnavailableReason: string | undefined;
   let roleReviewerAvailabilityMs: number | undefined;
@@ -1223,6 +1322,7 @@ export async function runSelfReviewCliCommand(
       deps.log('role-reviewer-fallback', {
         reviewerSource, roleReviewerProvider: opts.roleReviewer.provider, roleReviewerAvailabilityMs,
         stage: 'availability', reason: roleReviewerUnavailableReason, fallbackModel: safeLogText(model),
+        fallbackModelSource: roleFallbackModel ? 'role-fallback' : 'default',
       }, { level: 'warn' });
     }
   }
@@ -1234,6 +1334,7 @@ export async function runSelfReviewCliCommand(
     ...(roleReviewerUnavailableReason ? { roleReviewerFallbackReason: roleReviewerUnavailableReason } : {}),
   });
   const results: Array<Record<string, unknown>> = [];
+  let failed = 0;
   const providedReviewerContext = loadReviewerContext(opts, deps.readReferencedFile);
   const hasProvidedReviewerContext = (opts.contextOrder?.length ?? 0) > 0 || (opts.context?.length ?? 0) > 0 || (opts.contextText?.length ?? 0) > 0;
   for (const pr of prArgs) {
@@ -1247,6 +1348,7 @@ export async function runSelfReviewCliCommand(
     // ⛔ `relation-unknown` 도 경고한다(위 주석 · 리뷰가 두 라운드 반복 지적) — 그 밖 unavailable 은 조용하다.
     //    ⭐ 경고 여부 판정은 `localHeadWarningDetails` 한 곳에 있다(호출부에서 같은 함수를 두 번 부르지 않는다).
     const mismatchWarning = localHeadWarningDetails(localHeadComparison);
+    const mergeState = readPrMergeState(pr, deps);
     const view = deps.gh(['pr', 'view', pr, '--json', 'title,body'], 15_000);
     let prView: { title?: string; body?: string } | undefined;
     if (view.status === 0) {
@@ -1311,6 +1413,7 @@ export async function runSelfReviewCliCommand(
       const contextOutput = reviewerContextOutput(reviewerContext, decompositionContext);
       if (opts.json) results.push({ pr, error: err, ...contextOutput, ...comparisonData, ...(mismatchWarning ?? {}) });
       else deps.error(`PR ${pr}: ${err}\n${reviewerContextStatus}`);
+      failed += 1;
       continue;
     }
     // ⭐ S2(2026-07-30) — 리뷰 증거를 **이 PR 이 저작한 변경**으로 좁힌다. 실측 7건에서 1건만
@@ -1373,9 +1476,44 @@ export async function runSelfReviewCliCommand(
       else deps.print(`\n━━ PR ${pr} (${primaryModel}) ━━\n${renderStaleRefusal(diffRead)}\n${reviewerContextStatus}`);
       continue;
     }
+    // ⭐ 머지된 PR 만 머지 커밋 detached worktree 에서 리뷰한다 — main 최신이 아니라 그 PR 이 머지된 시점의 코드를 본다.
+    //    열린 PR 은 종전 그대로(cwd = process.cwd() · 리뷰어 심이 cwd 를 받지 않는다).
+    let reviewPin: ReviewWorktree | undefined;
+    let reviewCwdPinFallbackReason: string | undefined;
+    // cwd 를 받는 레인(ACP · role 리뷰어)일 때만 worktree 를 뜬다 — API 리뷰어는 cwd 를 안 받으므로 떠도 그 위에서 돌지 않는다.
+    const pinLane = useAcp || Boolean(roleReviewer && opts.roleReviewer && deps.makeRoleReviewerLlm);
+    let rolePinned = false;
+    if (!pinLane) {
+      // 비-ACP 레인 — 격리하지 않는다(종전 그대로 · reviewCwdCommit 없음).
+    } else if (mergeState.kind === 'merged') {
+      const made = createDetachedReviewWorktree(mergeState.commit, deps);
+      if ('cwd' in made) {
+        reviewPin = made;
+        pins.push(made);
+      } else reviewCwdPinFallbackReason = made.reason;
+    } else if (mergeState.kind === 'unpinnable') reviewCwdPinFallbackReason = mergeState.reason;
+    const reviewCwd = reviewPin?.cwd;
+    const prAcpReviewLLM = reviewCwd && useAcp
+      ? deps.makeAcpLlm({ backend: acpBackend, ...(acpModel ? { model: acpModel } : {}), timeoutMs: acpTimeoutSec * 1000, cwd: reviewCwd })
+      : acpReviewLLM;
+    let prRoleReviewer = roleReviewer;
+    if (reviewCwd && roleReviewer && opts.roleReviewer && deps.makeRoleReviewerLlm) {
+      try {
+        const pinned = deps.makeRoleReviewerLlm(opts.roleReviewer, { timeoutMs: acpTimeoutSec * 1000, cwd: reviewCwd });
+        if ('llm' in pinned) { prRoleReviewer = { llm: pinned.llm, model: `acp:${pinned.backend}` }; rolePinned = true; }
+        else reviewCwdPinFallbackReason = 'role-reviewer-cwd-unavailable';
+      } catch {
+        reviewCwdPinFallbackReason = 'role-reviewer-cwd-unavailable';
+      }
+    }
     const startedAt = deps.now();
     // Role-config lane builds the API reviewer only when it falls back (`made().api` stays 0 on ACP success).
-    const llmReview = roleReviewer ? undefined : (acpReviewLLM ?? deps.makeApiLlm(model));
+    const responded: { provider?: string; model?: string } = {};
+    const makeApi = () => deps.makeApiLlm(model, {
+      pinProvider: Boolean(opts.model?.trim()),
+      onResolved: (provider, respondedModel) => { responded.provider = provider; responded.model = respondedModel; },
+    });
+    const llmReview = prRoleReviewer ? undefined : (prAcpReviewLLM ?? makeApi());
     // ⛔ evidenceNote 는 **별도 채널**이다 — phaseIntent 에 섞으면 의도 채널이 오염된다(실측: 그렇게
     //   했다가 intent 배선 테스트 3개가 즉시 깨졌다).
     // ⛔ 사람 `--intent`(phaseIntent) 와 골 acceptance 는 다른 인자 — 충돌하지 않고, 충돌해도 intent 가 이긴다.
@@ -1395,10 +1533,10 @@ export async function runSelfReviewCliCommand(
     let roleReview: ReviewResult | undefined;
     let roleReviewerFallbackReason = roleReviewerUnavailableReason;
     let roleReviewMs: number | undefined;
-    if (roleReviewer) {
+    if (prRoleReviewer) {
       const roleStartedAt = deps.now();
       try {
-        const attempt = await deps.reviewPullRequest(reviewInput, roleReviewer.llm);
+        const attempt = await deps.reviewPullRequest(reviewInput, prRoleReviewer.llm);
         if (attempt.reviewed === true) roleReview = attempt;
         // Code, not the reviewer's raw failure text (same rule as the throw path above).
         else roleReviewerFallbackReason = 'acp-review-not-completed';
@@ -1414,8 +1552,8 @@ export async function runSelfReviewCliCommand(
         }, { level: 'warn' });
       }
     }
-    let review = roleReview ?? await deps.reviewPullRequest(reviewInput, llmReview ?? acpReviewLLM ?? deps.makeApiLlm(model));
-    let selectedModel = roleReview && roleReviewer ? roleReviewer.model : model;
+    let review = roleReview ?? await deps.reviewPullRequest(reviewInput, llmReview ?? prAcpReviewLLM ?? makeApi());
+    let selectedModel = roleReview && prRoleReviewer ? prRoleReviewer.model : model;
     let reviewRoute: 'api' | 'acp' | 'acp-fallback' = useAcp || roleReview ? 'acp' : 'api';
     let fallbackAttempted = false;
     let fallbackBackend: string | undefined;
@@ -1435,7 +1573,7 @@ export async function runSelfReviewCliCommand(
         try {
           const fallbackReview = await deps.reviewPullRequest(
             reviewInput,
-            deps.makeAcpLlm({ backend, timeoutMs: acpTimeoutSec * 1000 }),
+            deps.makeAcpLlm({ backend, timeoutMs: acpTimeoutSec * 1000, ...(reviewCwd ? { cwd: reviewCwd } : {}) }),
           );
           if (fallbackReview.reviewed === true) {
             review = fallbackReview;
@@ -1451,6 +1589,14 @@ export async function runSelfReviewCliCommand(
         }
       }
     }
+    reviewPin?.remove();
+    // reviewCwdCommit 은 «최종 판정을 낸 LLM 이 실제로 그 cwd 를 받았을 때만» 싣는다(role 실패 → API 폴백이면 안 싣는다).
+    const reviewedOnPin = Boolean(reviewPin) && (roleReview ? rolePinned : reviewRoute === 'acp-fallback' ? true : reviewRoute === 'acp' && useAcp);
+    if (reviewPin && !reviewedOnPin) reviewCwdPinFallbackReason ??= 'final-reviewer-not-pinned';
+    const reviewCwdOutput = {
+      ...(reviewPin && reviewedOnPin ? { reviewCwdCommit: reviewPin.commit } : {}),
+      ...(reviewCwdPinFallbackReason ? { reviewCwdPinFallbackReason } : {}),
+    };
     if (!fallbackAttempted) {
       fallbackNotAttemptedReason = useAcp ? 'explicit-acp' : 'primary-review-succeeded';
     }
@@ -1463,6 +1609,11 @@ export async function runSelfReviewCliCommand(
       ...(fallbackFailures.length ? { fallbackFailures } : {}),
       ...(skippedAcpFallbackBackends.length ? { skippedAcpFallbackBackends } : {}),
     };
+    // API 경로로 «성공한» 리뷰만 응답 provider·model 을 싣는다(요청 model 과 다르면 둘 다 보인다).
+    //   ⚠️ streamLLM 의 onResolvedProvider 는 시도 «전»에 불린다 — 실패한 리뷰에 실으면 응답 안 한 provider 를 «응답했다»로 적는다.
+    const respondedOutput = reviewRoute === 'api' && review.reviewed === true && responded.provider
+      ? { respondedProvider: responded.provider, respondedModel: responded.model }
+      : {};
     // ⚠️ `buildReviewObservation` drops unknown keys — the selection rides next to it, not inside it.
     const reviewerSelection = {
       ...reviewerSourceObservation(),
@@ -1486,20 +1637,24 @@ export async function runSelfReviewCliCommand(
         goalLoaded: goalAcceptance.goalLoaded,
         acceptanceChars: goalAcceptance.acceptanceChars,
         ...reviewerSelection,
+        ...reviewCwdOutput,
       },
       { level: review.reviewed === false ? 'warn' : 'info' });
     // --acp 는 대표가 명시 요청한 리뷰 — fail-soft(reviewed=false)면 조용히 pass 하지 말고 표면화(관측=acp-review).
     if (useAcp && review.reviewed === false) {
       const err = 'ACP 리뷰 실행 실패(reviewed=false) — 관측: elanous logs --category acp-review';
       const contextOutput = reviewerContextOutput(reviewerContext, decompositionContext);
-      if (opts.json) results.push({ pr, error: err, ...review, verdict: null, ...reviewProvenance, ...reviewerSelection, ...provenance, ...contextOutput });
+      if (opts.json) results.push({ pr, error: err, ...review, verdict: null, ...reviewProvenance, ...respondedOutput, ...reviewerSelection, ...reviewCwdOutput, ...provenance, ...contextOutput });
       else deps.error(`PR ${pr}: ${err}\n${renderProvenance(diffRead)}\n${reviewerContextStatus}`);
+      failed += 1;
       continue;
     }
     const contextOutput = reviewerContextOutput(reviewerContext, decompositionContext);
     const jsonReview = review.reviewed === true ? review : { ...review, verdict: null };
-    if (opts.json) results.push({ pr, model: selectedModel, ...jsonReview, ...reviewProvenance, ...reviewerSelection, ...provenance, ...contextOutput, evidence: evidence.evidence, prDiffFiles: evidence.prDiffFiles, ...(evidence.authoredFiles !== undefined ? { authoredFiles: evidence.authoredFiles } : {}) });
+    if (opts.json) results.push({ pr, model: selectedModel, ...jsonReview, ...reviewProvenance, ...respondedOutput, ...reviewerSelection, ...reviewCwdOutput, ...provenance, ...contextOutput, evidence: evidence.evidence, prDiffFiles: evidence.prDiffFiles, ...(evidence.authoredFiles !== undefined ? { authoredFiles: evidence.authoredFiles } : {}) });
     else deps.print(`\n━━ PR ${pr} (${selectedModel}) ━━\n${renderProvenance(diffRead)}\n${evidenceLine}\n${reviewerContextStatus}\n${deps.renderReview(review)}`);
+    // REVIEW-ERROR-RC — 기본(API)·role 경로가 1차·폴백 모두 실패해 reviewed≠true 로 끝나도 «못 리뷰한 PR» 이다(verdict:null).
+    if (review.reviewed !== true) failed += 1;
   }
-  return { results };
+  return { results, failed };
 }

package/src/autopilot/mission-critique.ts

@@ -106,12 +106,25 @@ export function buildCritiquePrompt(input: { planBody: string; changedFiles: str
   ].join('\n');
 }
 
-/** LLM 응답 파싱 → verdict + findings. 순수함수(LLM node 규칙). */
+/** 판정 줄 — «줄 머리» VERDICT 만 판정으로 읽는다(본문 중간 인용·설명 속 «VERDICT:» 오인 방지).
+ *  들여쓰기는 허용(mission-engine 의 미션 판정 파서와 같은 앵커). */
+const CRITIQUE_VERDICT_LINE = /^[ \t]*VERDICT:\s*(PASS|WARN|FAIL)/im;
+/** 판정 줄이 없을 때 findings 에 남기는 fail-closed 사유(REVIEW-NO-VERDICT-FAILCLOSED #25937). */
+const NO_VERDICT_FINDING = '비평 판정 줄(VERDICT) 없음 — 판정 없음은 통과가 아니다(fail-closed · REVIEW-NO-VERDICT-FAILCLOSED #25937)';
+const MAX_CRITIQUE_FINDINGS = 4;
+
+/** LLM 응답 파싱 → verdict + findings. 순수함수(LLM node 규칙).
+ *  ⛔ 판정 줄이 «없으면» pass 로 기본하지 않는다(칸 MISSION-CRITIQUE-FAILCLOSED · #25937):
+ *  «판정 없음 = 통과 아님» ⇒ verdict 'warn' + 사유 finding.
+ *  'fail' 이 아니라 'warn' 인 이유 — 소비측(nocturnal-runner)은 critique verdict==='fail' 에
+ *  gate-failed(재구현 요구)를 건다. «비평가 응답의 형식 결함»을 «구현 훼손」으로
+ *  오귀속시키는 것이다. 'warn' 은 PR 본문(renderCritique)·자율 원장에 그대로 표시되어 사람(HITL)이 판단한다.
+ *  (post-PR 리뷰 축 parseReviewResult 는 substrate 가 `reviewed:false` 로 같은 fail-closed 를 이미 한다.) */
 export function parseLLMCritique(text: string): { verdict: CritiqueResult['verdict']; findings: string[] } {
-  const vm = /VERDICT:\s*(PASS|WARN|FAIL)/i.exec(text);
-  const verdict = (vm ? vm[1]!.toLowerCase() : 'pass') as CritiqueResult['verdict'];
-  const findings = text.split('\n').map((l) => l.trim()).filter((l) => l.startsWith('- ')).map((l) => l.slice(2).trim()).slice(0, 4);
-  return { verdict, findings };
+  const bullets = text.split('\n').map((l) => l.trim()).filter((l) => l.startsWith('- ')).map((l) => l.slice(2).trim());
+  const vm = CRITIQUE_VERDICT_LINE.exec(text);
+  if (!vm) return { verdict: 'warn', findings: [NO_VERDICT_FINDING, ...bullets].slice(0, MAX_CRITIQUE_FINDINGS) };
+  return { verdict: vm[1]!.toLowerCase() as CritiqueResult['verdict'], findings: bullets.slice(0, MAX_CRITIQUE_FINDINGS) };
 }
 
 /** ★ R1 결정론 + LLM 비평(대표 2026-07-12) — 결정론(R0) 먼저, llmReview 주입 시 LLM 심층 비평