elanous 0.2.21 → 0.2.23

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

@@ -59,6 +59,8 @@ export interface ReviewResult {
    * ⚠️ 미주입(`llmReview` 없음)은 «실패가 아니라 미검토»라 이 칸을 안 채운다 — 둘을 구분한다.
    */
   failureReason?: string;
+  /** Subscription reviewer unavailable: the default reviewer produced this verdict. */
+  reviewerFallback?: string;
 }
 
 /** 모든 리뷰 관측 생산자가 공유하는 diff 예산 필드 계약. 예산 부재는 빈 객체로 보존한다.
@@ -300,7 +302,7 @@ export function planReviewChunks(
  */
 export function foldReviewResults(
   results: readonly ReviewResult[],
-): Pick<ReviewResult, 'verdict' | 'mustFix' | 'shouldFix' | 'requirements' | 'reviewed' | 'failureReason'> {
+): Pick<ReviewResult, 'verdict' | 'mustFix' | 'shouldFix' | 'requirements' | 'reviewed' | 'failureReason' | 'reviewerFallback'> {
   const dedupe = (values: readonly string[]): string[] => [...new Set(values)];
   const collect = (pick: (r: ReviewResult) => readonly string[] | undefined): string[] =>
     dedupe(results.flatMap((r) => [...(pick(r) ?? [])]));
@@ -311,6 +313,7 @@ export function foldReviewResults(
   const shouldFix = collect((r) => r.shouldFix).slice(0, 6);
   const requirements = collect((r) => r.requirements);
   const failed = results.find((r) => r.reviewed !== true);
+  const reviewerFallback = results.find((r) => r.reviewerFallback)?.reviewerFallback;
   return {
     verdict,
     mustFix,
@@ -318,6 +321,7 @@ export function foldReviewResults(
     ...(requirements.length ? { requirements } : {}),
     reviewed: results.length > 0 && failed === undefined,
     ...(failed?.failureReason ? { failureReason: failed.failureReason } : {}),
+    ...(reviewerFallback ? { reviewerFallback } : {}),
   };
 }
 
@@ -426,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));
@@ -485,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,
@@ -560,6 +598,9 @@ export function buildReviewPrompt(
 
   return [
     'You are a strict staff-engineer reviewing an ALREADY-OPENED pull request from an autonomous coding agent.',
+    // ⚠️ 무표식 절단 금지(리뷰 must-fix) — 잘렸으면 **어느 절부터**인지 리뷰어가 알아야 한다.
+    phaseIntentHeading, phaseIntent,
+    ...(input.acceptance ? ['## Acceptance criteria', input.acceptance.slice(0, 1000)] : []),
     'This is a POST-PR review of the produced artifact. Judge whether the PR actually',
     'delivers the phase intent CORRECTLY and soundly: (1) correctness/latent bugs, (2) does it meet the stated',
     'acceptance criteria, (3) design/regression risk, (4) missing wiring (new code never called), (5) tests present',
@@ -584,9 +625,6 @@ export function buildReviewPrompt(
     '    and check that the error names that site; use values the real caller produces instead of synthetic input.',
     'Do NOT rubber-stamp; an empty review is a failed review — always surface at least a watch item.',
     '',
-    // ⚠️ 무표식 절단 금지(리뷰 must-fix) — 잘렸으면 **어느 절부터**인지 리뷰어가 알아야 한다.
-    phaseIntentHeading, phaseIntent,
-    ...(input.acceptance ? ['## Acceptance criteria', input.acceptance.slice(0, 1000)] : []),
     ...(input.workingMemory ? ['## Prior decisions / reuse boundaries (working memory)', input.workingMemory.slice(0, 1200)] : []),
     // ⭐ 증거가 무엇인지 먼저 말한다 — 규칙 (7) 이 "의도를 넘어선 변경" 을 판정하려면
     //   diff 에 담긴 것이 **이 PR 이 저작한 것인지**를 알아야 한다.
@@ -605,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[] = [];
@@ -624,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;
@@ -634,14 +700,44 @@ export function parseReviewResult(text: string): ReviewResult {
     const first = shouldFix.shift() ?? fallbackFinding;
     mustFix.push(first ?? 'PR 리뷰 FAIL — 재작업 필요(구체 지적 미파싱).');
   }
+  const fallback = text.match(/\n\[reviewer fallback: ([^\r\n]+)\]$/);
   return {
     verdict,
     mustFix: mustFix.slice(0, 6),
     shouldFix: shouldFix.slice(0, 6),
+    ...(fallback ? { reviewerFallback: fallback[1] } : {}),
     ...(requirements.length ? { requirements } : {}),
   };
 }
 
+/** 판정 줄 없는 응답의 사유 값 — 기존 «리뷰 못 함» 경로(`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);
@@ -669,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', {
@@ -680,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 } : {}),
         });
@@ -710,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,
@@ -734,6 +879,7 @@ export async function reviewPullRequest(
         const passInput: ReviewInput = {
           ...input,
           prDiff: passDiff,
+          reviewerContext: passContext[index]?.indices.map((itemIndex) => contextItems[itemIndex]!),
           // ⭐ 리뷰어에게 «자기가 몇 분의 몇을 보는지» 알린다 — 이것 없이는 조각 리뷰어가
           //   "다른 파일이 안 보인다"를 SCOPE/미배선 결함으로 오판한다(규칙 (7) 오작동).
           evidenceNote: [
@@ -743,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),
@@ -774,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,
@@ -830,6 +972,7 @@ export function renderReview(r: ReviewResult): string {
   const icon = r.verdict === 'pass' ? '✅' : r.verdict === 'warn' ? '⚠️' : '⛔';
   const head = `${icon} 자율 PR 리뷰: ${r.verdict.toUpperCase()}`;
   const parts = [head];
+  if (r.reviewerFallback) parts.push(`[reviewer fallback: ${r.reviewerFallback}]`);
   if (r.mustFix.length) parts.push('**Must-fix (blockers)**', ...r.mustFix.map((f) => `- ${f}`));
   if (r.shouldFix.length) parts.push('**Should-fix**', ...r.shouldFix.map((f) => `- ${f}`));
   if (r.mustFix.length === 0 && r.shouldFix.length === 0) parts.push('— 리뷰 통과(블로커·비블로커 지적 없음).');

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 {
   /** 무엇을 왜 — 골 원문. */
@@ -525,6 +525,73 @@ function goalFileBlock(goalFile: string | undefined): Block | undefined {
     : undefined;
 }
 
+function isLightweightGoal(goal: string): boolean {
+  try {
+    const tree = unified().use(remarkParse).use(remarkGfm).parse(goal) as MarkdownNode;
+    const nodes = tree.children ?? [];
+    const headings = new Set<string>();
+    const declarations = new Set<string>();
+    for (let index = 0; index < nodes.length; index += 1) {
+      const node = nodes[index]!;
+      if (node.type !== 'heading' || node.depth !== 2) continue;
+      const start = node.position?.start.offset;
+      const end = node.position?.end.offset;
+      if (start === undefined || end === undefined) return false;
+      const heading = goal.slice(start, end).trim();
+      headings.add(heading);
+      if (heading !== '## 답하지 못하는 것' && heading !== '## 불변식') continue;
+      const next = nodes[index + 1];
+      if (next?.type !== 'list' || next.children?.length !== 1) continue;
+      const item = next.children[0];
+      const itemStart = item?.position?.start.offset;
+      const itemEnd = item?.position?.end.offset;
+      if (itemStart === undefined || itemEnd === undefined) continue;
+      if (goal.slice(itemStart, itemEnd).trim() === '- No persistent grounding was performed in lite authoring.') {
+        declarations.add(heading);
+      }
+    }
+    return headings.has('## WHAT TO BUILD') && headings.has('## ACCEPTANCE CRITERIA')
+      && declarations.has('## 답하지 못하는 것') && declarations.has('## 불변식');
+  } catch {
+    return false;
+  }
+}
+
+function lightweightGoalContext(goal: string, goalFile: string): Block {
+  const nodes = (unified().use(remarkParse).use(remarkGfm).parse(goal) as MarkdownNode).children ?? [];
+  const firstLine = (title: string): string | undefined => {
+    const headingIndex = nodes.findIndex((node) => {
+      if (node.type !== 'heading' || node.depth !== 2) return false;
+      const start = node.position?.start.offset;
+      const end = node.position?.end.offset;
+      return start !== undefined && end !== undefined && goal.slice(start, end).trim() === `## ${title}`;
+    });
+    if (headingIndex < 0) return undefined;
+    for (const node of nodes.slice(headingIndex + 1)) {
+      if (node.type === 'heading' && (node.depth ?? 0) <= 2) break;
+      if (node.type === 'code') continue;
+      const start = node.position?.start.offset;
+      const end = node.position?.end.offset;
+      if (start === undefined || end === undefined) continue;
+      const line = goal.slice(start, end).split('\n').find((item) => item.trim());
+      if (line) return line.replace(/^[-*]\s*/, '').replace(/^(?:무엇|왜):\s*/, '').trim();
+    }
+    return undefined;
+  };
+  const brief = (text: string): string => text.length > 350 ? `${text.slice(0, 350)}…[골 원문 참조]` : text;
+  const what = firstLine('WHAT TO BUILD');
+  const why = firstLine('PROBLEM');
+  return {
+    title: '무엇을 왜',
+    text: [
+      '무엇을 왜',
+      ...(what ? [`무엇: ${brief(what)}`] : []),
+      ...(why ? [`왜: ${brief(why)}`] : []),
+      `골 원문·긴 참조: ${goalFile}`,
+    ].join('\n'),
+  };
+}
+
 export function buildReviewIntent(i: Readonly<ReviewIntentInput>): string {
   // ① 조망 — 명시값이 없으면 **골 텍스트에서 추출**한다(생산자는 골 자체다·LLM 없음).
   const mined = extractIntentBlocks(i.goal);
@@ -536,8 +603,12 @@ export function buildReviewIntent(i: Readonly<ReviewIntentInput>): string {
   //   그 안의 수용기준을 다시 목록으로 붙이면 **같은 내용이 두 번** 들어가 4000자 예산을 먹고,
   //   후순위 블록(스코프 경계)이 불필요하게 잘린다.
   const identity = parseShardIdentity(i.goal);
-  const shardBoundary = identity ? { title: '조각 경계', text: `조각 경계\n${shardBoundaryBlock(identity)}` } : undefined;
-  const goalBody = stripExtractedSections(identity ? withoutShardIdentity(i.goal) : i.goal).trim();
+  // 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();
   const goal = goalBody ? { title: '목표', text: `목표\n${goalBody}` } : undefined;
   // ⭐ **자식이 낸 증거**(diff 밖 이행 · base 적색 · 직전 반영분)를 한 묶음으로 잡아 둔다 — 아래 예산
   //   배분에서 **목표 본문보다 먼저** 채우기 위해서다. 제목 문자열이 아니라 **동일성**으로 가른다.
@@ -553,6 +624,20 @@ export function buildReviewIntent(i: Readonly<ReviewIntentInput>): string {
   const coverage = evidenceCoverageBlock(i.evidenceCoverage);
   const goalFile = goalFileBlock(i.goalFile);
   const runFacts = runFactsBlock(i);
+  // Lite authoring keeps its original ask in a fenced block under WHAT TO BUILD.
+  // Review the authored criteria and short context; the goal document is the pointer to the long source.
+  if (liteGoal) {
+    const acceptanceBlock = listBlock('수용기준', acceptance);
+    const context = lightweightGoalContext(i.goal, i.goalFile!.trim());
+    const boundaryBlock = listBlock('의도적 스코프 경계', boundaries);
+    const liteBlocks = [
+      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));
+    return fitReviewIntentBlocks(liteBlocks, liteBlocks, liteBlocks);
+  }
   // ⛔⭐⭐⭐ **런 사실이 «맨 앞»이다 — 라이브 실측으로 옮겼다**(2026-08-07).
   //   📏 `#7556`(실물 하니스 PR · 본문 37,354자)을 프로덕션 `intentFromPr` 에 태우니
   //     ***`runId` 도 커밋도 변경 파일도 «하나도» 안 남았다***(4,000자 상한 · 살아남은 것은 `목표`·`수용기준`).
@@ -645,7 +730,7 @@ function sectionPriority(title: string): 0 | 1 | 2 {
 const PREAMBLE_TITLE = '(머리말)';
 
 type MarkdownPosition = { readonly start: { readonly offset?: number }; readonly end: { readonly offset?: number } };
-type MarkdownNode = { readonly type: string; readonly position?: MarkdownPosition; readonly children?: readonly MarkdownNode[] };
+type MarkdownNode = { readonly type: string; readonly depth?: number; readonly position?: MarkdownPosition; readonly children?: readonly MarkdownNode[] };
 type MarkdownUnit = { readonly text: string; readonly start: number; readonly end: number };
 
 /** 비교 가능한 CommonMark 단위와 그 원문 범위. 코드 펜스는 원문에 남기되 비교 후보에서는 제외한다. */
@@ -829,6 +914,18 @@ function isTableHeader(line: string, next: string | undefined): boolean {
   return /^\s*\|(\s*:?-{2,}:?\s*\|)+\s*$/.test(next ?? '');
 }
 
+function topLevelCodeLines(goal: string): ReadonlySet<number> {
+  const lines = new Set<number>();
+  try {
+    const tree = unified().use(remarkParse).use(remarkGfm).parse(goal);
+    for (const node of tree.children) {
+      if (node.type !== 'code' || !node.position) continue;
+      for (let index = node.position.start.line - 1; index < node.position.end.line; index += 1) lines.add(index);
+    }
+  } catch { /* unknown syntax: keep existing extraction behavior */ }
+  return lines;
+}
+
 /** 골에서 **추출된 것만** 걷어낸 나머지(목표 서술). 추출 내용이 목표 블록에 중복되지 않게 한다.
  *
  *  ⚠️ **산문은 남긴다**(리뷰 must-fix) — 초판은 인식된 절을 만나면 다음 헤더까지 **통째로** 버려,
@@ -839,7 +936,9 @@ export function stripExtractedSections(goal: string): string {
   const mined = extractIntentBlocks(goal);
   const out: string[] = [];
   let extractedSection: 'acceptance' | 'boundary' | null = null;
-  for (const line of goal.split('\n')) {
+  const fencedLines = topLevelCodeLines(goal);
+  for (const [index, line] of goal.split('\n').entries()) {
+    if (fencedLines.has(index)) { out.push(line); continue; }
     const kind = headKind(line);
     if (kind === 'acceptance' || kind === 'boundary') { extractedSection = kind; continue; }   // 헤더만 제거
     if (kind === 'other') extractedSection = null;
@@ -921,6 +1020,7 @@ function isUnverifiedBoundaryCandidate(item: string): boolean {
 }
 
 export function extractIntentBlocks(goal: string, includeSections = false): ExtractedIntentBlocks {
+  const fencedLines = topLevelCodeLines(goal);
   const acceptanceItems: string[] = [];
   const scopeBoundaryItems: string[] = [];
   const unverifiedBoundaryCandidateItems: string[] = [];
@@ -945,6 +1045,7 @@ export function extractIntentBlocks(goal: string, includeSections = false): Extr
     push();
   }
   for (const [idx, line] of lines.entries()) {
+    if (fencedLines.has(idx)) continue;
     const kind = headKind(line);
     if (kind === 'acceptance') { cur = 'acceptance'; continue; }
     if (kind === 'boundary') { cur = 'boundary'; continue; }