elanous 0.2.22 → 0.2.23

package/src/agent-mission/acp-judge.ts

@@ -17,7 +17,12 @@ type AcpAgentManagerPort = {
 };
 
 export type JudgeVerdict = 'merge' | 'rework' | 'reject' | 'ambiguous';
-export interface AcpJudgeResult { verdict: JudgeVerdict; asks: string[]; reason: string; raw: string; }
+export interface AcpJudgeResult {
+  verdict: JudgeVerdict; asks: string[]; reason: string; raw: string;
+  /** TA-LAND-MUSTFIX-ZERO — 심판 JSON 의 asks 가 없거나 배열이 아니거나 문자열 아닌 원소가 섞였다(`asks` 는 소비처 호환으로 `[]`·걸러진 값).
+   *  ⛔ 이때 `asks: []` 는 «남은 지적 0» 이 아니라 «모름» — 자동 병합 관문이 `review-must-fix-unknown` 으로 막는다. */
+  asksUnreadable?: true;
+}
 
 /** ACP 최종심판에 전달하는 PR diff의 기본 문자 상한. */
 export const DEFAULT_JUDGE_DIFF_CHAR_LIMIT = 24_000;
@@ -94,7 +99,8 @@ export function parseJudge(raw: string): AcpJudgeResult {
     const d = JSON.parse(json) as { verdict?: string; asks?: unknown; reason?: string };
     const verdict = (['merge', 'rework', 'reject', 'ambiguous'] as const).includes(d.verdict as JudgeVerdict) ? (d.verdict as JudgeVerdict) : '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 : '', raw };
+    const asksUnreadable = !Array.isArray(d.asks) || asks.length !== d.asks.length;
+    return { verdict, asks, reason: typeof d.reason === 'string' ? d.reason : '', raw, ...(asksUnreadable ? { asksUnreadable: true as const } : {}) };
   } catch { return { verdict: 'ambiguous', asks: [], reason: 'json-parse-fail', raw }; }
 }
 

package/src/agent-mission/capabilities-cli.ts

@@ -2,10 +2,12 @@ import type { Command } from 'commander';
 import { buildCapabilityMatrix, pickBackend } from './capability-matrix.js';
 import { createCapabilityReaders, type CapabilityRun } from './capability-readers.js';
 import { normalizeServiceName, type CapabilityEntry } from './capability-types.js';
+import { buildCapabilityIndex, type CapabilityIndexReaders } from '../smart-wizard/capability-index.js';
 
 export interface CapabilitiesCliDeps {
   run?: CapabilityRun;
   write?: (text: string) => void;
+  indexReaders?: CapabilityIndexReaders;
 }
 
 /** Register the read-only capability inventory under agent-mission (and its codex alias). */
@@ -14,7 +16,20 @@ export function registerCapabilitiesCommand(parent: Command, deps: CapabilitiesC
     .description('List codex, claude and grok service capabilities (read only)')
     .option('--service <name>', 'Show observations and selected backend for a service')
     .option('--json', 'Output JSON')
-    .action((opts: { service?: string; json?: boolean }) => {
+    .option('--index', 'Show provenance and authentication index (read only)')
+    .action(async (opts: { service?: string; json?: boolean; index?: boolean }) => {
+      if (opts.index) {
+        const index = await buildCapabilityIndex(deps.indexReaders);
+        const write = deps.write ?? (text => { process.stdout.write(text); });
+        if (opts.json) write(JSON.stringify(index) + '\n');
+        else {
+          write('SOURCE\tSTATUS\n');
+          for (const [source, status] of Object.entries(index.sources)) write(`${source}\t${status}\n`);
+          write('SOURCE\tID\tKIND\tSTATE\tAUTH\tPROVENANCE\n');
+          for (const entry of index.entries) write(`${entry.source}\t${entry.id}\t${entry.kind}\t${entry.state}\t${entry.auth}\t${entry.provenance}\n`);
+        }
+        return;
+      }
       const readers = createCapabilityReaders(deps.run);
       const matrix = buildCapabilityMatrix(readers);
       const entries: CapabilityEntry[] = opts.service

package/src/agent-mission/driver.ts

@@ -352,7 +352,7 @@ export function resolveBackendSpawn(
   //   ⚠️ 과금 스크럽 키만 — 중첩 표지는 정체성 allowlist 가 다시 싣는 키가 있어 이 PR 의 범위 밖이다.
   const unsetEnv = [...new Set(backend.scrubEnv ?? [])].filter((k) => !(k in env));
   // Codex drops parent env under shell_environment_policy inherit=core, so the nested-depth
-  // marker rides on argv (`-c shell_environment_policy.set.ELANOUS_NESTED_DEPTH=<child>`).
+  // marker rides on argv (`-c shell_environment_policy.set.ELANOUS_NESTED_DEPTH="<child>"` — TOML 문자열).
   // Backends that cannot carry it are refused only when a nested elanous launch was requested.
   const args = [...backend.args, ...nestedDepthCodexArgs(backend.name, getNestDepth() + 1)];
   return { cmd: backend.cmd, args, env, unsetEnv, nestedEnvRemovedCount, forcedEnv };

package/src/agent-mission/pr-review-watch.ts

@@ -25,10 +25,14 @@ import { AUTO_REVIEW_LABEL } from '../self-implement/context-capsule.js';
 import { resolveReworkBackendChoice, runReviewLoop, type ReviewLoopOpts, type ReviewLoopResult, type ReviewVerdict } from './review-loop.js';
 import type { ReviewResult } from '../agent-substrate/pr-reviewer.js';
 
-/** 1차 리뷰 결과(ReviewResult) → review-loop injectedReview. fail→reinforce(mustFix)·pass/warn→ok(clean). 순수. */
+/** 1차 리뷰 결과(ReviewResult) → review-loop injectedReview. fail→reinforce(mustFix)·pass/warn→ok. 순수.
+ *  TA-LAND-MUSTFIX-ZERO — pass/warn 의 must-fix 를 «지우지 않고» asks 로 싣는다: 지우면 review-loop 의
+ *  자동 병합 관문이 «must-fix 0» 으로 읽는다. must-fix 0 이면 종전과 같은 `asks: []`. */
 export function mapReviewToInjected(r: ReviewResult): { verdict: ReviewVerdict; asks: string[] } {
   if (r.verdict === 'fail') return { verdict: 'reinforce', asks: r.mustFix };
-  return { verdict: 'ok', asks: [] };
+  // must-fix 목록을 못 읽으면 «0» 이 아니라 «모름» — ok 로 보내지 않는다(ambiguous = 명확화 요청 · 병합 없음).
+  if (!Array.isArray(r.mustFix)) return { verdict: 'ambiguous', asks: [] };
+  return { verdict: 'ok', asks: [...r.mustFix] };
 }
 
 /** [ISO] ELANOUS_STATE_DIR 존중(lazy) — 테스트격리 시 .elanous-test 로 스코프. */

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

@@ -31,6 +31,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 +117,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 +266,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 +297,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 {
@@ -429,7 +447,8 @@ JSON 만: {"verdict":"...","asks":["..."],"reason":"..."}`;
     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 +516,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-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,38 @@ 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)\.?$`,
+].join('|'), 'i');
+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);
+}
+
 /** 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 +690,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 +710,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 +765,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 +825,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 +856,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 +879,7 @@ export async function reviewPullRequest(
         const passInput: ReviewInput = {
           ...input,
           prDiff: passDiff,
+          reviewerContext: passContext[index]?.indices.map((itemIndex) => contextItems[itemIndex]!),
           // ⭐ 리뷰어에게 «자기가 몇 분의 몇을 보는지» 알린다 — 이것 없이는 조각 리뷰어가
           //   "다른 파일이 안 보인다"를 SCOPE/미배선 결함으로 오판한다(규칙 (7) 오작동).
           evidenceNote: [
@@ -749,13 +889,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 +917,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));