elanous 0.2.22 → 0.2.24

package/src/agent-mission/review-loop.ts

@@ -11,6 +11,7 @@ import { runGitCommand } from '../git-fs/runner.js';
 import * as llm from '../llm.js';
 import type { LLMMessage } from '../llm.js';
 import { debug } from '../debug/log.js';
+import { resolveRoleLlm } from '../user-config.js';
 import { releasePathHold, releasePathHoldShouldPost, releasePathHoldComment, releasePathHoldCommentsArgs, releasePrFilePaths, RELEASE_PATH_LABEL } from '../self-dev/release-path-guard.js';
 import { runAgentMission, resolveBackend, type AgentMissionResult, type EvidenceMode } from './driver.js';
 import { judgeWithAcp, prepareJudgeDiff } from './acp-judge.js';
@@ -31,6 +32,8 @@ export interface ReviewClassification {
   asks: string[];
   reason: string;
   classificationSource: ReviewClassificationSource;
+  /** TA-LAND-MUSTFIX-ZERO — 분류 JSON 의 asks 가 없거나 배열이 아니거나 문자열 아닌 원소가 섞였다. `asks: []` 는 그때 «0» 이 아니라 «모름». */
+  asksUnreadable?: true;
 }
 
 export interface ReviewLoopOpts {
@@ -115,6 +118,16 @@ function gh(args: string[]): string {
   return execFileSync('gh', args, { encoding: 'utf8', timeout: 60000, maxBuffer: 20 * 1024 * 1024, env: process.env });
 }
 
+/** TA-LAND-MUSTFIX-ZERO — 자동 병합 «직전» must-fix 관문(#25941 `canAuto` 와 같은 축).
+ *  남은 지적(asks)이 있으면 `review-warn-with-must-fix` · 목록 자체가 배열이 아니면 «0» 이 아니라
+ *  «모름» = `review-must-fix-unknown`(fail-closed). 막을 때 `review-loop` 범주에 `auto-merge-blocked` 를 남긴다. */
+function reviewMergeMustFixBlock(pr: string, stage: 'initial-ok' | 'final-judge', asks: unknown, unreadable: boolean, round?: number): 'review-warn-with-must-fix' | 'review-must-fix-unknown' | null {
+  const known = Array.isArray(asks) && !unreadable;
+  const reason = !known ? 'review-must-fix-unknown' : (asks as unknown[]).length > 0 ? 'review-warn-with-must-fix' : null;
+  if (reason) debug.log('review-loop', 'auto-merge-blocked', { pr, stage, reason, mustFixCount: known ? (asks as unknown[]).length : null, ...(round !== undefined ? { round } : {}) });
+  return reason;
+}
+
 /** Check every page of the PR file list immediately before an unattended review-loop merge. */
 function holdReleasePathBeforeReviewMerge(pr: string, runGh: (args: string[]) => string): boolean {
   let paths: string[];
@@ -254,10 +267,16 @@ export async function judgeAndFinalize(
   debug.log('review-loop', 'judge-start', { pr, round, diffChars: preparedDiff.totalChars, judgeBackend: judgeBackendResolution.backend, judgeBackendSource: judgeBackendResolution.source });
   const judge = opts.judge ?? judgeWithAcp;
   const j = await judge({ diff, context: `반영한 지적:\n${asks.join('\n')}${reviewerContext}`, gatePassed: true, cwd, backend: judgeBackendResolution.backend, ...(opts.judgeModel ? { model: opts.judgeModel } : {}) });
-  debug.log('review-loop', 'judge-verdict', { pr, round, verdict: j.verdict, asks: j.asks.length });
+  debug.log('review-loop', 'judge-verdict', { pr, round, verdict: j.verdict, asks: Array.isArray(j.asks) ? j.asks.length : null });
   const diffScope = `심판 diff 범위: 본 ${preparedDiff.judgeChars}자 / 전체 ${preparedDiff.totalChars}자`;
 
   if (j.verdict === 'merge') {
+    // TA-LAND-MUSTFIX-ZERO — 심판이 «merge» 라도 남긴 asks(미해결 지적)가 있으면 자동 병합하지 않는다 → HITL.
+    const mustFixBlock = opts.autoMerge ? reviewMergeMustFixBlock(pr, 'final-judge', j.asks, j.asksUnreadable === true, round) : null;
+    if (mustFixBlock) {
+      try { runGh(['pr', 'comment', pr, '--body', `🛑 ACP Claude Code 2차 최종심판: **MERGE** 이나 미해결 지적이 남아 자동 병합하지 않음(${mustFixBlock} · 라운드 ${round}) → 대표 결정 필요.\n${diffScope}\n사유: ${j.reason}`]); } catch { /* noop */ }
+      return { pr, branch, verdict: 'reinforce', asks: Array.isArray(j.asks) ? j.asks : asks, action: 'parked', reworkOk: true, pushed: lastPushed, rounds: round, detail: `2차 심판 MERGE ⊕ ${mustFixBlock} → HITL: ${j.reason}` };
+    }
     if (opts.autoMerge) {
       if (holdReleasePathBeforeReviewMerge(pr, runGh)) return { pr, branch, verdict: 'reinforce', asks, action: 'parked', reworkOk: true, pushed: lastPushed, rounds: round, detail: 'OP approval required: release-path hold or PR file inspection unavailable' };
       const approve = opts.approve ?? approvePr;
@@ -279,7 +298,7 @@ export async function judgeAndFinalize(
     try { runGh(['pr', 'comment', pr, '--body', `🛑 ACP Claude Code 2차 최종심판: **${j.verdict.toUpperCase()}** (라운드 ${round}) → 대표 결정 필요.\n${diffScope}\n사유: ${j.reason}`]); } catch { /* noop */ }
     return { pr, branch, verdict: 'reinforce', asks, action: 'parked', reworkOk: true, pushed: lastPushed, rounds: round, detail: `2차 심판 ${j.verdict} → HITL: ${j.reason}` };
   }
-  return { rework: j.asks.length > 0 ? j.asks : asks };
+  return { rework: Array.isArray(j.asks) && j.asks.length > 0 ? j.asks : asks };
 }
 
 export interface LatestReviewSource {
@@ -421,15 +440,21 @@ asks: reinforce 일 때 codex 가 반영할 **구체 지적 목록**(각 한 줄
 JSON 만: {"verdict":"...","asks":["..."],"reason":"..."}`;
   const messages: LLMMessage[] = [{ role: 'system', content: sys }, { role: 'user', content: body.slice(0, 6000) }];
   let raw = '';
-  try { raw = await llm.streamLLM(messages, () => {}, { maxTokens: 700, temperature: 0.1 }); }
-  catch (e) { return { verdict: 'ambiguous', asks: [], reason: `분류 오류: ${describeThrownValue(e)}`, classificationSource: 'llm-call-failure' }; }
+  try {
+    const resolved = resolveRoleLlm('classify');
+    const provider = llm.PROVIDERS[resolved.provider];
+    if (!provider) throw new Error(`Unknown classify provider: ${resolved.provider}`);
+    debug.log('llm.role-pin', 'resolved', { site: 'classify-review', role: 'classify', model: resolved.model, provider: resolved.provider, source: resolved.source });
+    raw = await llm.streamLLM(messages, () => {}, { model: resolved.model, provider, usageRole: 'classify', maxTokens: 700, temperature: 0.1 });
+  } catch (e) { return { verdict: 'ambiguous', asks: [], reason: `분류 오류: ${describeThrownValue(e)}`, classificationSource: 'llm-call-failure' }; }
   const jm = raw.match(/\{[\s\S]*\}/);
   if (!jm) return { verdict: 'ambiguous', asks: [], reason: 'JSON 파싱 실패', classificationSource: 'llm' };
   try {
     const d = JSON.parse(jm[0]) as { verdict?: string; asks?: unknown; reason?: string };
     const verdict = (['ok', 'reinforce', 'reject', 'ambiguous'] as const).includes(d.verdict as ReviewVerdict) ? (d.verdict as ReviewVerdict) : 'ambiguous';
     const asks = Array.isArray(d.asks) ? d.asks.filter((x): x is string => typeof x === 'string') : [];
-    return { verdict, asks, reason: typeof d.reason === 'string' ? d.reason : '', classificationSource: 'llm' };
+    const asksUnreadable = !Array.isArray(d.asks) || asks.length !== d.asks.length;
+    return { verdict, asks, reason: typeof d.reason === 'string' ? d.reason : '', classificationSource: 'llm', ...(asksUnreadable ? { asksUnreadable: true as const } : {}) };
   } catch { return { verdict: 'ambiguous', asks: [], reason: 'JSON 파싱 실패', classificationSource: 'llm' }; }
 }
 
@@ -497,15 +522,24 @@ export async function runReviewLoop(pr: string, opts: ReviewLoopOpts = {}): Prom
   debug.log('review-loop', 'classified', {
     pr,
     verdict: cls.verdict,
-    asks: cls.asks.length,
+    asks: Array.isArray(cls.asks) ? cls.asks.length : null, // 목록 없음 = null(«0» 아님) — 아래 must-fix 관문이 막는다
     source: opts.injectedReview ? 'injected' : 'gh',
     reason: cls.reason,
     classificationSource: cls.classificationSource,
   });
 
-  let asks = cls.asks;
+  let asks = Array.isArray(cls.asks) ? cls.asks : []; // 목록 없음·못 읽음은 아래 자동 병합 관문이 cls 로 막는다 · rework/명확화 소비처만 `[]` 로 읽는다
 
   if (cls.verdict === 'ok') {
+    // TA-LAND-MUSTFIX-ZERO — 1차 «ok» 에 지적(asks)이 남았거나 목록을 못 읽으면 자동 병합 경로로 가지 않는다(승인도 안 함) → HITL.
+    //   light·heavy 둘 다 — heavy 는 심판에 asks 를 안 넘기므로(`[]`) 여기서 막지 않으면 심판 merge 가 1차 must-fix 를 덮는다.
+    //   관문은 «이 경로가 실제로 자동 병합할 때»만 — light 는 autoMergeOnOk||autoMerge, heavy 는 심판 merge 의 autoMerge 뿐(autoMergeOnOk 만이면 종전대로 심판 → ready-to-merge).
+    const autoMergesHere = effectiveFinalJudge ? opts.autoMerge === true : (opts.autoMergeOnOk || opts.autoMerge);
+    const mustFixBlock = autoMergesHere ? reviewMergeMustFixBlock(pr, 'initial-ok', cls.asks, cls.asksUnreadable === true) : null;
+    if (mustFixBlock) {
+      try { runGh(['pr', 'comment', pr, '--body', `🛑 1차 리뷰 ok 이나 미해결 지적이 남아 자동 병합하지 않음(${mustFixBlock}) → 대표 결정 필요.`]); } catch { /* noop */ }
+      return { pr, branch, verdict: 'ok', asks: Array.isArray(cls.asks) ? cls.asks : [], action: 'parked', detail: `${depth}·1차 ok ⊕ ${mustFixBlock} → HITL(자동 병합 안 함)` };
+    }
     // light: 1차 clean 으로 충분 → approve + 머지. heavy: 1차 ok 여도 2차 심판 머스트.
     if (!effectiveFinalJudge) {
       if ((opts.autoMergeOnOk || opts.autoMerge) && holdReleasePathBeforeReviewMerge(pr, runGh)) {

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

@@ -0,0 +1,139 @@
+// ── ACP Claude Code 를 «구현» 실행기로 (CLAUDE-IMPL-LANE · `--child-llm-provider claude-acp`) ──
+//
+// acp-reviewer.ts 의 짝이다. 리뷰어는 read-only 라 읽기 툴만 허가하지만, 구현 실행기는 런 워크트리 안에서
+// 쓰기·실행을 허가해야 한다. 그래서 approver 가 «워크트리 밖 경로 쓰기»를 구조적으로 거부한다.
+// 자식은 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;
+  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)은 모든 경로가 워크트리 안일 때만 허가하고,
+ *  실행(execute)은 cwd 가 워크트리라 허가한다. 읽기 계열은 허가, 그 외는 경로가 있고 전부 안쪽일 때만 허가(보수적). */
+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 verdict = (allow: boolean): ImplementerPermissionDecision => ({ tool, path: shown, decision: allow ? 'allow' : 'deny' });
+  if (req.kind && WRITE_TOOL_KINDS.has(req.kind)) return verdict(paths.length > 0 && outside === undefined);
+  if (req.kind === 'execute') return verdict(true);
+  if (isReadOnlyReviewTool(req.kind, req.title)) return verdict(true);
+  return verdict(paths.length > 0 && outside === undefined);
+}
+
+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', { ...verdict });
+        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/acp-reviewer.ts

@@ -33,6 +33,8 @@ export interface AcpReviewerOpts {
   model?: string;
   /** 리뷰 1턴 최대 대기(ms). 초과 시 cancel→throw(부분 리뷰로 오판 pass 방지). 기본 300000. */
   timeoutMs?: number;
+  /** One deadline for spawn → initialize → session/new → model select (ms). A child that never answers ACP must not hang the review. Default min(timeoutMs, 60000). */
+  handshakeTimeoutMs?: number;
 }
 
 /**
@@ -152,13 +154,20 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     let text = '';
     let timedOut = false;
     let timer: ReturnType<typeof setTimeout> | undefined;
+    const handshakeTimeoutMs = opts.handshakeTimeoutMs ?? Math.min(timeoutMs, 60_000);
+    const handshakeDeadline = Date.now() + handshakeTimeoutMs;
+    let handshakeTimer: ReturnType<typeof setTimeout> | undefined;
+    const withinHandshake = <T>(step: Promise<T>): Promise<T> => Promise.race([step, new Promise<never>((_, reject) => {
+      handshakeTimer = setTimeout(() => {
+        debug.log('acp-review', 'handshake-timeout', { backend, handshakeTimeoutMs }, { level: 'error' });
+        reject(new Error(`ACP handshake timeout (${handshakeTimeoutMs}ms)`));
+      }, Math.max(0, handshakeDeadline - Date.now()));
+    })]).finally(() => { if (handshakeTimer) clearTimeout(handshakeTimer); });
     try {
-      agent = opts.createAgent
-        ? opts.createAgent({ backendId: requestedBackend, ...agentOpts })
-        : opts.backendSpec
-          ? new AcpAgent({ backendId: requestedBackend, ...agentOpts })
-          : await reviewManager!.getAgent(requestedBackend, agentOpts);
-      if (injected || opts.backendSpec) await agent.start();
+      if (opts.createAgent) agent = opts.createAgent({ backendId: requestedBackend, ...agentOpts });
+      else if (opts.backendSpec) agent = new AcpAgent({ backendId: requestedBackend, ...agentOpts });
+      else agent = await withinHandshake(reviewManager!.getAgent(requestedBackend, agentOpts));
+      if (injected || opts.backendSpec) await withinHandshake(agent.start());
       if (!capabilitiesObserved) {
         try {
           debug.log('acp-review', 'capabilities', {
@@ -172,9 +181,9 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
           // Observability must not interrupt a review.
         }
       }
-      const sid = await agent.newSession();
+      const sid = await withinHandshake(agent.newSession());
       if (opts.model) {
-        const picked = await agent.selectSessionModel(sid, opts.model);
+        const picked = await withinHandshake(agent.selectSessionModel(sid, opts.model));
         debug.log('acp-review', 'model', { requested: opts.model, picked: picked?.name ?? null, backend });
       }
       timer = setTimeout(() => { timedOut = true; agent!.cancel(sid).catch(() => { /* noop */ }); }, timeoutMs);

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

@@ -430,14 +430,38 @@ function referencedRepositoryPaths(prDiff: string): string[] {
 
 const REVIEWER_CONTEXT_MAX_CHARS = 12_000;
 
+/** Decode the a-side of a diff header, including Git's quoted UTF-8 octal paths. */
+function reviewerContextDiffPath(chunk: string): string | undefined {
+  const header = /^diff --git ("(?:\\.|[^"\\])*"|a\/[^ \n]+) (?:"(?:\\.|[^"\\])*"|b\/[^ \n]+)(?:\r?\n|$)/.exec(chunk);
+  if (!header) return undefined;
+  const token = header[1]!;
+  if (!token.startsWith('"')) return token.slice(2);
+  const bytes: number[] = [];
+  const escapes: Record<string, number> = { a: 7, b: 8, t: 9, n: 10, v: 11, f: 12, r: 13, '"': 34, '\\': 92 };
+  const body = token.slice(1, -1);
+  for (let i = 0; i < body.length; i += 1) {
+    // Decode by code point so astral characters (emoji) keep both surrogate halves.
+    const codePoint = body.codePointAt(i)!;
+    const char = String.fromCodePoint(codePoint);
+    if (char !== '\\') { bytes.push(...Buffer.from(char, 'utf8')); if (codePoint > 0xffff) i += 1; continue; }
+    const octal = body.slice(i + 1, i + 4);
+    if (/^[0-7]{3}$/.test(octal)) { bytes.push(parseInt(octal, 8)); i += 3; continue; }
+    const next = body[++i]!;
+    if (escapes[next] !== undefined) bytes.push(escapes[next]);
+    else bytes.push(...Buffer.from(next, 'utf8'));
+  }
+  const path = Buffer.from(bytes).toString('utf8');
+  return path.startsWith('a/') ? path.slice(2) : undefined;
+}
+
 /** Bound each ordered human-supplied item independently so an early large item cannot evict later context. */
-export function budgetReviewerContext(
-  items: readonly ReviewerContextItem[] = [],
-  maxChars = REVIEWER_CONTEXT_MAX_CHARS,
-): ReviewerContextBudget {
+function budgetReviewerContextWithParts(
+  items: readonly ReviewerContextItem[],
+  maxChars: number,
+): { budget: ReviewerContextBudget; partsByItem: (string | undefined)[] } {
   const fullText = items.map((item) => `### ${item.label}\n${item.body}`).join('\n\n');
   if (items.length === 0) {
-    return { text: '', itemCount: 0, shownChars: 0, totalChars: 0, truncated: false, fullyIncludedItems: 0, truncatedItems: 0, omittedItems: 0 };
+    return { budget: { text: '', itemCount: 0, shownChars: 0, totalChars: 0, truncated: false, fullyIncludedItems: 0, truncatedItems: 0, omittedItems: 0 }, partsByItem: [] };
   }
   const separatorChars = (items.length - 1) * 2;
   const itemBudget = Math.max(0, Math.floor((maxChars - separatorChars) / items.length));
@@ -489,17 +513,27 @@ export function budgetReviewerContext(
   const omittedItems = items.length - parts.length;
   const text = parts.join('\n\n');
   return {
-    text,
-    itemCount: items.length,
-    shownChars: text.length,
-    totalChars: fullText.length,
-    truncated: text.length < fullText.length,
-    fullyIncludedItems,
-    truncatedItems,
-    omittedItems,
+    budget: {
+      text,
+      itemCount: items.length,
+      shownChars: text.length,
+      totalChars: fullText.length,
+      truncated: text.length < fullText.length,
+      fullyIncludedItems,
+      truncatedItems,
+      omittedItems,
+    },
+    partsByItem,
   };
 }
 
+export function budgetReviewerContext(
+  items: readonly ReviewerContextItem[] = [],
+  maxChars = REVIEWER_CONTEXT_MAX_CHARS,
+): ReviewerContextBudget {
+  return budgetReviewerContextWithParts(items, maxChars).budget;
+}
+
 function reviewerContextSection(
   items: readonly ReviewerContextItem[] | undefined,
   budget = items?.length ? budgetReviewerContext(items) : undefined,
@@ -609,10 +643,65 @@ export function buildReviewPrompt(
   ].join('\n');
 }
 
+/** «지적 없음» 표지 — 일부 모델(GLM-5.3 실측)이 빈 섹션 대신 `- (없음 — …)` / `- none` 을 항목으로 쓴다.
+ *  ⭐ 표지 «만»인 항목을 0건으로 접는다. 두 모양뿐이다:
+ *   ① 낱말 하나(`none`·`없음`·`N/A`·`해당 없음` · 끝 마침표 허용)
+ *   ② 항목 «전체»가 괄호에 싸인 표지 — 설명이 붙으면 그 설명이 «지적이 없다»는 말일 때만
+ *      (`(없음 — 블로커 수준의 결함은 발견되지 않음)` · `(none — no blockers)`).
+ *  ⛔ 그 밖은 «지적»으로 남긴다 — `없음 — 인증 검사가 없어 …` · `(none: the new export is never called)` ·
+ *  `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');
+// ⭐ 설명 «전체»가 「지적 없음」 한 문장일 때만 — 일부만 맞아도 접으면 `(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');
+// 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`). */
+function isNoneSentinelFinding(finding: string): boolean {
+  const text = finding.trim();
+  if (BARE_SENTINEL.test(text)) return true;
+  const bracketed = BRACKETED_SENTINEL.exec(text);
+  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 섹션 분해.
  *  verdict=FAIL 인데 must-fix 미기재면 첫 finding 을 must 로 승격(블로커 근거 보존). */
+/** ⭐ `VERDICT: PASS|WARN|FAIL` 판정 줄 — `parseReviewResult` 와 `reviewedResultFromRaw` 가 «같은» 정규식을 쓴다(존재 판정이 갈리면 안 된다). */
+const VERDICT_LINE = /VERDICT:\s*(PASS|WARN|FAIL)/i;
+
 export function parseReviewResult(text: string): ReviewResult {
-  const vm = /VERDICT:\s*(PASS|WARN|FAIL)/i.exec(text);
+  const vm = VERDICT_LINE.exec(text);
   const verdict = (vm ? vm[1]!.toLowerCase() : 'pass') as ReviewVerdict;
   const lines = text.split('\n').map((l) => l.trim());
   const mustFix: string[] = [];
@@ -628,7 +717,7 @@ export function parseReviewResult(text: string): ReviewResult {
     if (l.startsWith('- ')) {
       const f = l.slice(2).trim();
       if (!f) continue;
-      if (section === 'must') mustFix.push(f);
+      if (section === 'must') { if (!isNoneSentinelFinding(f)) mustFix.push(f); }
       else if (section === 'should') shouldFix.push(f);
       else if (section === 'requirements') requirements.push(f);
       else fallbackFinding ??= f;
@@ -648,6 +737,34 @@ export function parseReviewResult(text: string): ReviewResult {
   };
 }
 
+/** 판정 줄 없는 응답의 사유 값 — 기존 «리뷰 못 함» 경로(`reviewed:false` ⊕ `failureReason`)를 그대로 탄다. */
+export const NO_VERDICT_LINE_REASON = 'no-verdict-line';
+
+/**
+ * ⛔⭐⭐ REVIEW-NO-VERDICT-FAILCLOSED(2026-10-10) — 리뷰어 응답 «하나»를 결과로 접는다.
+ *   `parseReviewResult` 는 `VERDICT:` 줄이 없으면 `pass` 로 기본값을 둔다. 종전 호출부는 거기에
+ *   `reviewed: true` 를 붙여서, 자격 없는 리뷰어의 219자 오류 문구가 «지적 0 인 PASS» 로 접혔다
+ *   (실물: run-dbe7b7df · PR #25906 · codex-app-server 17초).
+ *   ⇒ 판정 줄이 없으면 «리뷰 못 함»(`reviewed:false` · `failureReason=no-verdict-line`)이다 —
+ *   catch 경로와 «같은 모양»이라 소비처(orchestrator·seams·renderReview·fold)가 이미 «통과 판정 아님»으로 다룬다.
+ *   ⭐ 판정 줄이 «있는» 응답은 `parseReviewResult(raw)` ⊕ `reviewed:true` 그대로 — 바이트 동일.
+ *   ⛔ 계약: `reviewed:false` 일 때 `verdict` 는 «의미 없는 자리값»(`pass`)이다 — catch·미주입 경로와 같다.
+ *      소비처는 `reviewed` 를 «먼저» 본다(`renderReview`·`self-review-cli`·`review-adapter`·orchestrator).
+ */
+function reviewedResultFromRaw(raw: string, runId: string | undefined, pass?: { index: number; of: number }): ReviewResult {
+  if (VERDICT_LINE.test(raw)) return { ...parseReviewResult(raw), reviewed: true };
+  try {
+    debug.log('review.verdict', NO_VERDICT_LINE_REASON, {
+      chars: raw.length,
+      head: safeLogText(raw, 80),
+      ...(pass ? { pass: pass.index + 1, passes: pass.of } : {}),
+      // ⛔ backend 는 안 남긴다 — 이 함수는 어느 백엔드로 불렸는지 «모른다»(catch 주석 `#7495` 와 같은 이유).
+      ...(runId !== undefined ? { runId } : {}),
+    });
+  } catch { /* Observation must not prevent the review. */ }
+  return { verdict: 'pass', mustFix: [], shouldFix: [], reviewed: false, failureReason: NO_VERDICT_LINE_REASON };
+}
+
 function failureReasonText(error: unknown): string {
   if (error instanceof Error) return safeLogText(error.message, 400);
   if (typeof error === 'string') return safeLogText(error, 400);
@@ -675,7 +792,56 @@ export async function reviewPullRequest(
   if (!llmReview) return { verdict: 'pass', mustFix: [], shouldFix: [], reviewed: false }; // 리뷰어 미주입=미검토.
   try {
     const diffBudget = budgetedDiff(input.prDiff);
-    const reviewerContextBudget = input.reviewerContext?.length ? budgetReviewerContext(input.reviewerContext) : undefined;
+    // Existing caller: self-review-cli.ts runSelfReviewCliCommand → deps.reviewPullRequest(reviewInput, llmReview).
+    const plan = planReviewChunks(input.prDiff);
+    const chunked = plan.passes.length > 1;
+    const contextItems = input.reviewerContext ?? [];
+    const passPaths = chunked ? plan.passes.map((pass) => new Set(
+      splitDiffByFile(pass).flatMap((chunk) => {
+        // self-review-cli.ts runSelfReviewCliCommand → deps.reviewPullRequest(reviewInput, llmReview) → this pass.
+        const path = reviewerContextDiffPath(chunk);
+        return path === undefined ? [] : [path];
+      }),
+    )) : [];
+    const matchedLabels = new Set(passPaths.flatMap((paths) => [...paths]));
+    const passContext = chunked && contextItems.length ? passPaths.map((paths, passIndex) => {
+      const indices = contextItems.flatMap((item, index) =>
+        item.image ? (passIndex === 0 ? [index] : [])
+          : !matchedLabels.has(item.label) || paths.has(item.label) ? [index] : []);
+      const { budget, partsByItem } = budgetReviewerContextWithParts(indices.map((index) => contextItems[index]!), REVIEWER_CONTEXT_MAX_CHARS);
+      return { indices, budget, partsByItem };
+    }) : [];
+    const chunkContextBudget = passContext.length ? (() => {
+      const shownByItem: Array<number | undefined> = contextItems.map(() => undefined);
+      const status: Array<'omitted' | 'truncated' | 'full' | undefined> = contextItems.map(() => undefined);
+      for (const { indices, partsByItem } of passContext) {
+        indices.forEach((itemIndex, position) => {
+          const part = partsByItem[position];
+          // Count each item once at its narrowest pass: a loss in any pass must show in shownChars.
+          const shown = part?.length ?? 0;
+          shownByItem[itemIndex] = Math.min(shownByItem[itemIndex] ?? shown, shown);
+          const full = `### ${contextItems[itemIndex]!.label}\n${contextItems[itemIndex]!.body}`;
+          if (part !== full) status[itemIndex] = part === undefined && status[itemIndex] !== 'truncated' ? 'omitted' : 'truncated';
+          else if (status[itemIndex] === undefined) status[itemIndex] = 'full';
+        });
+      }
+      const shownCount = shownByItem.filter((length) => (length ?? 0) > 0).length;
+      const fullyIncludedItems = status.filter((value) => value === 'full').length;
+      const truncatedItems = status.filter((value) => value === 'truncated').length;
+      const omittedItems = contextItems.length - fullyIncludedItems - truncatedItems;
+      return {
+        itemCount: contextItems.length,
+        // Same scale as totalChars (items joined by "\n\n"): each item counts once at its narrowest
+        // shown part, so shownChars === totalChars exactly when no item lost anything in any pass.
+        // perPassShownChars in the budget log keeps the raw per-pass sizes.
+        shownChars: shownByItem.reduce<number>((sum, length) => sum + (length ?? 0), 0) + Math.max(0, shownCount - 1) * 2,
+        totalChars: contextItems.map((item) => `### ${item.label}\n${item.body}`).join('\n\n').length,
+        truncated: truncatedItems > 0 || omittedItems > 0,
+        fullyIncludedItems, truncatedItems, omittedItems,
+      };
+    })() : undefined;
+    const singleContextBudget = !chunked && contextItems.length ? budgetReviewerContext(contextItems) : undefined;
+    const reviewerContextBudget = chunkContextBudget ?? singleContextBudget;
     if (reviewerContextBudget) {
       try {
         debug.log('review.images', 'reviewer-context-budget', {
@@ -686,6 +852,7 @@ export async function reviewPullRequest(
           fullyIncludedItems: reviewerContextBudget.fullyIncludedItems,
           truncatedItems: reviewerContextBudget.truncatedItems,
           omittedItems: reviewerContextBudget.omittedItems,
+          ...(chunked ? { passes: plan.passes.length, perPassShownChars: passContext.map(({ budget }) => budget.shownChars) } : {}),
           ...(input.reviewContext?.runId !== undefined ? { runId: input.reviewContext.runId } : {}),
           ...(input.reviewContext?.round !== undefined ? { round: input.reviewContext.round } : {}),
         });
@@ -716,8 +883,7 @@ export async function reviewPullRequest(
     //     *"64,000자는 **분할 리뷰 도입을 전제로 한 조각별 고정 예산**"*. 부품(`splitDiffByFile`)도
     //     서 있었다. 없던 것은 「조각들을 리뷰하고 결과를 «접는» 자」 하나였다.
     //   ⛔ 상한을 «올리는» 것이 아니다 — 조각마다 상한을 «지킨다».
-    const plan = planReviewChunks(input.prDiff);
-    if (plan.passes.length > 1) {
+    if (chunked) {
       try {
         debug.log('review.diff-plan', 'chunked', {
           passes: plan.passes.length, files: plan.files, coversAll: plan.coversAll,
@@ -740,6 +906,7 @@ export async function reviewPullRequest(
         const passInput: ReviewInput = {
           ...input,
           prDiff: passDiff,
+          reviewerContext: passContext[index]?.indices.map((itemIndex) => contextItems[itemIndex]!),
           // ⭐ 리뷰어에게 «자기가 몇 분의 몇을 보는지» 알린다 — 이것 없이는 조각 리뷰어가
           //   "다른 파일이 안 보인다"를 SCOPE/미배선 결함으로 오판한다(규칙 (7) 오작동).
           evidenceNote: [
@@ -749,13 +916,10 @@ export async function reviewPullRequest(
             + ' 「여기 안 보인다」를 결함으로 판정하지 마십시오.',
           ].filter(Boolean).join('\n'),
         };
-        passResults.push({
-          ...parseReviewResult(await llmReview(
-            buildReviewPrompt(passInput, passBudget, '', reviewerContextBudget),
-            reviewImages.length > 0 && index === 0 ? reviewImages : undefined,
-          )),
-          reviewed: true,
-        });
+        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 }));
       }
       return {
         ...foldReviewResults(passResults),
@@ -780,12 +944,11 @@ export async function reviewPullRequest(
       };
     }
     const raw = await llmReview(
-      buildReviewPrompt(input, diffBudget, referencedContext.text, reviewerContextBudget),
+      buildReviewPrompt(input, diffBudget, referencedContext.text, singleContextBudget),
       reviewImages.length > 0 ? reviewImages : undefined,
     );
     return {
-      ...parseReviewResult(raw),
-      reviewed: true,
+      ...reviewedResultFromRaw(raw, input.reviewContext?.runId),
       diffBudget: {
         truncated: diffBudget.truncated,
         shownChars: diffBudget.shownChars,

package/src/agent-substrate/review-intent.ts

@@ -16,7 +16,7 @@ import { parseGoalType, type GoalType } from '../self-implement/goal-author.js';
 import type { DesignCheckOutcome } from '../design/design-check.js';
 import type { DesignGateResult } from '../design/design-gate.js';
 import type { PriorDraftFinding } from '../self-implement/prior-draft-findings.js';
-import { parseShardIdentity, shardBoundaryBlock, withoutShardIdentity } from './shard-boundary-intent.js';
+import { parseShardIdentity, shardReviewContractBlock, withoutShardIdentity } from './shard-boundary-intent.js';
 
 export interface ReviewIntentInput {
   /** 무엇을 왜 — 골 원문. */
@@ -603,7 +603,9 @@ export function buildReviewIntent(i: Readonly<ReviewIntentInput>): string {
   //   그 안의 수용기준을 다시 목록으로 붙이면 **같은 내용이 두 번** 들어가 4000자 예산을 먹고,
   //   후순위 블록(스코프 경계)이 불필요하게 잘린다.
   const identity = parseShardIdentity(i.goal);
-  const shardBoundary = identity ? { title: '조각 경계', text: `조각 경계\n${shardBoundaryBlock(identity)}` } : undefined;
+  // This is the phaseIntent consumed by defaultSeams.reviewDiff → reviewPullRequest;
+  // the same block is retained by the orchestrator's PR-body review-intent section.
+  const shardBoundary = identity ? { title: '샤드 계약 — 리뷰 범위', text: shardReviewContractBlock(i.goal, identity, boundaries, i.changedFiles) } : undefined;
   const authoredLiteGoal = isLightweightGoal(i.goal);
   const liteGoal = authoredLiteGoal && Boolean(i.goalFile?.trim());
   const goalBody = liteGoal ? '' : stripExtractedSections(identity ? withoutShardIdentity(i.goal) : i.goal).trim();
@@ -629,8 +631,8 @@ export function buildReviewIntent(i: Readonly<ReviewIntentInput>): string {
     const context = lightweightGoalContext(i.goal, i.goalFile!.trim());
     const boundaryBlock = listBlock('의도적 스코프 경계', boundaries);
     const liteBlocks = [
-      acceptanceBlock, context, boundaryBlock, priorFindings, applied,
-      runFacts, goalType, shardBoundary, preexisting, importerTestsNotRun,
+      acceptanceBlock, context, boundaryBlock, shardBoundary, priorFindings, applied,
+      runFacts, goalType, preexisting, importerTestsNotRun,
       gateEvidence, designCheck, designGate, shardSiblings, coverage, claims,
       listBlock('검증 못 한 경계 후보 (결정 아님 — 이것만으로 must-fix 를 면제하지도, 만들지도 말 것)', unverifiedBoundaryCandidates),
     ].filter((block): block is Block => Boolean(block));