elanous 0.2.35 → 0.2.37

package/src/agent/terminal-surface.ts

@@ -25,6 +25,7 @@ import type { LLMOpts, LLMToolSpec } from '../llm.js';
 import type { FileSink } from '../channel/file-sink.js';
 import { PTY_SHELL_TOOL_NAMES } from '../boot/daemon-tools/pty-shell.js';
 import { killNonDetached as killNonDetachedPty } from '../pty-shell/registry.js';
+import { getCurrentPtyId } from './pty-identity.js';
 
 /** ① Conditional tool-budget grant for driving a headless terminal /
  *  coding agent. Keeps the tight per-family cap for ordinary turns
@@ -184,3 +185,219 @@ export function buildTerminalCapableTurn(base: TerminalCapableBase): TerminalCap
     [TERMINAL_CAPABLE_TURN_BRAND]: true,
   };
 }
+
+// ---------------------------------------------------------------------------
+// ⑤ TUI self-nest guard (TUI-NO-SELF-NEST · #27)
+//
+// A TUI turn already runs INSIDE a PTY owned by the outer TUI (the seat
+// shell). Spawning `eln` / `elanous` again from there nests a second TUI in
+// the same terminal: the two alt-screens and input loops overwrite each other
+// and the operator loses the seat ("screens fighting"). The guard refuses
+// exactly that one command shape and answers with guidance; every other
+// command (bash, `eln pty list`, `eln msg post`, …) keeps its current
+// behaviour, and the existing harness-write-boundary ledger path is
+// untouched — the reject is returned in the same `{ output }` envelope the
+// PtyShell dispatch already uses (precedent: skills/tools/pty.ts
+// dispatchPtyShellSend's reject-with-guidance).
+// ---------------------------------------------------------------------------
+
+/** Stable marker the reject message starts with — tests and the operator
+ *  read this; changing it is a behaviour change, not a wording tweak. */
+export const TUI_SELF_NEST_REJECT_MARKER = '[TUI 자기중첩 거부]';
+
+/** Binaries that ARE the elanous TUI (or its launcher). */
+const ELANOUS_TUI_BINARIES = new Set(['eln', 'elanous']);
+
+/** Subcommands that open an interactive TUI surface. A bare invocation
+ *  (`eln`) is the default TUI. Anything else keeps running as-is. */
+const ELANOUS_TUI_SUBCOMMANDS = new Set(['', 'tui', 'chat', 'dashboard', 'nexus']);
+
+/** Interpreter wrappers that can launch the TUI entry file. */
+const ELANOUS_LAUNCHER_BINARIES = new Set(['bun', 'node', 'bunx']);
+
+const ELANOUS_ENTRY_FILES = new Set(['elanous', 'elanous.mjs', 'elanous.cjs']);
+
+/** Global flags that consume the NEXT token as their value — without this
+ *  list `eln --config-dir /tmp/x dashboard` would read `/tmp/x` as the
+ *  subcommand. */
+const VALUE_TAKING_FLAGS = new Set([
+  '--config-dir',
+  '--state-dir',
+  '--cwd',
+  '--role-llm',
+  '--child-llm-provider',
+  '--child-llm-model',
+  '--model',
+  '--provider',
+  '--seat',
+  '--name',
+  '--session',
+  '--since',
+  '--grep',
+]);
+
+/** Flags that only ask for information (version / help). A call carrying one
+ *  of these never opens an interactive surface, so it is NOT a TUI launch:
+ *  refusing `eln --version` or `eln chat --help` inside a TUI would break a
+ *  non-interactive command — a false positive is an accident, not a guard. */
+const INFORMATIONAL_FLAGS = new Set(['--help', '-h', '--version', '-V']);
+
+function basenameOf(token: string): string {
+  const parts = token.split(/[\\/]/);
+  return (parts[parts.length - 1] ?? '').toLowerCase();
+}
+
+export type TuiCommandKind = 'elanous-tui-launch' | 'other';
+
+export interface TuiLaunchLook {
+  kind: TuiCommandKind;
+  /** Subcommand that opened the TUI ('' for a bare `eln`). */
+  subcommand: string | null;
+}
+
+/** Pure classifier: is this argv an elanous/eln TUI launch?
+ *
+ *  Accepts the direct form (`eln`, `/usr/local/bin/eln chat`) and the
+ *  interpreter form (`bun bin/elanous.mjs dashboard`). Leading flags are
+ *  skipped, but a flag's VALUE is never mistaken for the subcommand — an
+ *  unknown shape simply classifies as `other` (a false negative is safe;
+ *  a false positive would break unrelated commands). A call carrying an
+ *  informational flag (`--version` / `--help` / `-h` / `-V`) is `other` too,
+ *  whether the flag sits alone (`eln --version`) or after a TUI subcommand
+ *  (`eln chat --help`): it prints and exits, it never opens the surface. */
+export function classifyTuiLaunch(argv: readonly string[]): TuiLaunchLook {
+  if (argv.length === 0) return { kind: 'other', subcommand: null };
+  const head = basenameOf(argv[0] ?? '');
+
+  let rest: string[];
+  if (ELANOUS_TUI_BINARIES.has(head)) {
+    rest = argv.slice(1);
+  } else if (ELANOUS_LAUNCHER_BINARIES.has(head)) {
+    const entryIdx = argv.findIndex((tok, i) => i > 0 && ELANOUS_ENTRY_FILES.has(basenameOf(tok)));
+    if (entryIdx === -1) return { kind: 'other', subcommand: null };
+    rest = argv.slice(entryIdx + 1);
+  } else {
+    return { kind: 'other', subcommand: null };
+  }
+
+  const sub = firstPositional(rest);
+  if (!ELANOUS_TUI_SUBCOMMANDS.has(sub)) return { kind: 'other', subcommand: sub };
+  // 정보성 플래그가 붙은 호출(`eln --version`·`eln --help`·`eln chat --help`)은
+  // 기동이 아니라 출력 요청이다 — 대화형 표면을 열지 않으므로 `other` 로 보낸다.
+  if (asksForInformation(rest)) return { kind: 'other', subcommand: sub === '' ? null : sub };
+  return { kind: 'elanous-tui-launch', subcommand: sub };
+}
+
+/** True when the tokens ask for version/help output. The value of a
+ *  value-taking flag is skipped so `--grep --help` stays a value. */
+function asksForInformation(tokens: readonly string[]): boolean {
+  for (let i = 0; i < tokens.length; i += 1) {
+    const token = tokens[i] ?? '';
+    if (VALUE_TAKING_FLAGS.has(token)) {
+      i += 1;
+      continue;
+    }
+    if (INFORMATIONAL_FLAGS.has(token)) return true;
+  }
+  return false;
+}
+
+/** First non-flag token, skipping the value of a value-taking flag. */
+function firstPositional(tokens: readonly string[]): string {
+  for (let i = 0; i < tokens.length; i += 1) {
+    const token = tokens[i] ?? '';
+    if (token.startsWith('-')) {
+      if (VALUE_TAKING_FLAGS.has(token)) i += 1;
+      continue;
+    }
+    return token;
+  }
+  return '';
+}
+
+export interface TuiNestEnv {
+  parentPtyId: string | null;
+  nestDepth: number;
+}
+
+/** Read "am I already a TUI PTY child?" material from the same sources
+ *  src/pty-shell/registry.ts uses for a child's identity:
+ *  `ELANOUS_PARENT_PTY_ID` ?? `getCurrentPtyId()`, and `ELANOUS_NEST_DEPTH`. */
+export function readTuiNestEnv(env: NodeJS.ProcessEnv = process.env): TuiNestEnv {
+  let parentPtyId = env.ELANOUS_PARENT_PTY_ID?.trim() || null;
+  if (!parentPtyId) {
+    try {
+      parentPtyId = getCurrentPtyId() ?? null;
+    } catch {
+      parentPtyId = null;
+    }
+  }
+  const rawDepth = env.ELANOUS_NEST_DEPTH?.trim();
+  const parsedDepth = rawDepth === undefined || rawDepth === '' ? 0 : Number.parseInt(rawDepth, 10);
+  const nestDepth = Number.isFinite(parsedDepth) && parsedDepth > 0 ? parsedDepth : 0;
+  return { parentPtyId, nestDepth };
+}
+
+export type TuiSelfNestReason = 'already-inside-tui';
+
+export interface TuiSelfNestDecision {
+  reject: boolean;
+  reason: TuiSelfNestReason | null;
+  command: TuiCommandKind;
+  subcommand: string | null;
+  parentPtyId: string | null;
+  nestDepth: number;
+  /** Reject + guidance text; null when the command is allowed through. */
+  output: string | null;
+}
+
+function buildTuiSelfNestGuidance(input: {
+  argv: readonly string[];
+  parentPtyId: string | null;
+  nestDepth: number;
+}): string {
+  const shown = input.argv.join(' ');
+  const identity = [
+    input.parentPtyId ? `parent pty ${input.parentPtyId}` : 'parent pty 없음',
+    `nest depth ${input.nestDepth}`,
+  ].join(' · ');
+  return [
+    `${TUI_SELF_NEST_REJECT_MARKER} 이미 TUI PTY 안입니다 (${identity}).`,
+    `여기서 '${shown}' 를 다시 띄우면 두 TUI 화면·입력 루프가 서로를 덮어써 조작이 불가능해집니다.`,
+    '- 이미 열린 TUI 세션에서 계속하세요: elanous pty list → elanous pty snapshot <id> / elanous pty send <id> ...',
+    '- 새 TUI 가 정말 필요하면 이 PTY 밖(운영 터미널)에서 기동하세요.',
+    '- 도구 세션에서 셸이 필요하면 TUI 가 아니라 일반 셸을 여세요: PtyShellStart { cmd: "bash" }.',
+  ].join('\n');
+}
+
+/** Pure decision function: reject `eln`/`elanous` TUI launches when this
+ *  process already lives inside a TUI PTY (parent pty id or nest depth ≥ 1).
+ *  Everything else is allowed through with `reject: false`. */
+export function decideTuiSelfNest(
+  argv: readonly string[],
+  env: NodeJS.ProcessEnv = process.env,
+): TuiSelfNestDecision {
+  const look = classifyTuiLaunch(argv);
+  const nest = readTuiNestEnv(env);
+  const insideTui = Boolean(nest.parentPtyId) || nest.nestDepth >= 1;
+  if (look.kind !== 'elanous-tui-launch' || !insideTui) {
+    return {
+      reject: false,
+      reason: null,
+      command: look.kind,
+      subcommand: look.subcommand,
+      parentPtyId: nest.parentPtyId,
+      nestDepth: nest.nestDepth,
+      output: null,
+    };
+  }
+  return {
+    reject: true,
+    reason: 'already-inside-tui',
+    command: look.kind,
+    subcommand: look.subcommand,
+    parentPtyId: nest.parentPtyId,
+    nestDepth: nest.nestDepth,
+    output: buildTuiSelfNestGuidance({ argv, parentPtyId: nest.parentPtyId, nestDepth: nest.nestDepth }),
+  };
+}

package/src/agent/types.ts

@@ -91,6 +91,10 @@ export interface AgentTask {
   /** Full message history as the runner built it — starts with a
    *  system message + user prompt and grows with tool rounds. */
   messages: LLMMessage[];
+  /** Tool calls the child has made so far, counted live as each call starts.
+   *  `messages` only grows when a tool loop completes (and never on abort/error),
+   *  so a roster that counted messages alone showed «0 tools» for a working child. */
+  toolCallCount?: number;
   /** Final assistant text once the run completes. */
   result?: string;
   /** Error message when state === 'error'. */

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

@@ -36,10 +36,25 @@ export function isScopeRevertMustFix(mustFix: string): boolean {
   return scopeSignal && revertSignal;
 }
 
+/**
+ * SCOPE-ESCAPE-AS-REFINE (대표 10-22 «범위 밖 허용도 로직으로») — 범위-되돌림 must-fix 중 강등하지 «않는» 것:
+ * 삭제·보호 경로(규칙·자격증명·운영 config)를 되돌리라는 지적. 오케스트레이터 자동 정지 사유(scope-adjacency
+ * `ScopeStopReason`)와 같은 선이다 — 상한은 리뷰 문면으로 잴 수 없으니 여기서 다루지 않는다.
+ */
+// ⚠️ 영어 `remove` 는 «되돌려라» 동사로도 흔하다(«unrelated change, remove it») — 삭제 신호는 `delet` 만 본다.
+const SCOPE_REVERT_KEEP_BLOCKER = /삭제|지웠|지운|delet|\.rules\b|credential|secret|auth\.json|\.env\b|config\.json|보호\s*경로|protected/i;
+
+/** 범위-되돌림 must-fix 를 shouldFix 로 강등할 대상인가(결정론 · 문자열만). */
+export function isDemotableScopeRevertMustFix(mustFix: string): boolean {
+  return isScopeRevertMustFix(mustFix) && !SCOPE_REVERT_KEEP_BLOCKER.test(mustFix);
+}
+
 export interface ReviewResult {
   verdict: ReviewVerdict;
   mustFix: string[];
   shouldFix: string[];
+  /** SCOPE-ESCAPE-AS-REFINE — 리뷰어가 must-fix 로 냈지만 «범위 밖이니 되돌려라» 라서 shouldFix 로 내린 원문(관측용). */
+  scopeRevertDemoted?: string[];
   /** 리뷰어가 판정에 앞서 더 보아야 한다고 관측한 저장소 맥락. 소비·판정에는 아직 쓰지 않는다. */
   requirements?: string[];
   /** 실제 리뷰가 돌았나(LLM 응답 파싱 성공). 미주입/예외로 verdict='pass' 된 경우와 진짜 PASS 구분. */
@@ -302,7 +317,7 @@ export function planReviewChunks(
  */
 export function foldReviewResults(
   results: readonly ReviewResult[],
-): Pick<ReviewResult, 'verdict' | 'mustFix' | 'shouldFix' | 'requirements' | 'reviewed' | 'failureReason' | 'reviewerFallback'> {
+): Pick<ReviewResult, 'verdict' | 'mustFix' | 'shouldFix' | 'scopeRevertDemoted' | '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) ?? [])]));
@@ -312,12 +327,14 @@ export function foldReviewResults(
   const mustFix = collect((r) => r.mustFix).slice(0, 6);
   const shouldFix = collect((r) => r.shouldFix).slice(0, 6);
   const requirements = collect((r) => r.requirements);
+  const scopeRevertDemoted = collect((r) => r.scopeRevertDemoted);
   const failed = results.find((r) => r.reviewed !== true);
   const reviewerFallback = results.find((r) => r.reviewerFallback)?.reviewerFallback;
   return {
     verdict,
     mustFix,
     shouldFix,
+    ...(scopeRevertDemoted.length ? { scopeRevertDemoted } : {}),
     ...(requirements.length ? { requirements } : {}),
     reviewed: results.length > 0 && failed === undefined,
     ...(failed?.failureReason ? { failureReason: failed.failureReason } : {}),
@@ -638,6 +655,7 @@ export function buildReviewPrompt(
     '  - WARN = ships but has non-blocking concerns.',
     '  - PASS = correct and sound (a watch item is still fine).',
     'Then optionally a line "MUST-FIX:" followed by blocker findings (one per line, "- " prefix),',
+    'If there are no blockers, leave MUST-FIX empty; do not put “없음”, “결함 없음”, “none”, or any explanatory no-finding sentence in that list.',
     'then optionally a line "SHOULD-FIX:" followed by non-blocker findings ("- " prefix). Keep each finding one concise line.',
     'Then optionally a line "REQUIREMENTS:" followed by repository context you need to inspect before making a determination ("- " prefix). This is observational only and does not change the verdict.',
   ].join('\n');
@@ -672,12 +690,17 @@ const NO_FINDING_REMARK = new RegExp([
   String.raw`^(?:(?:블로커|차단)\s*)?(?:수준의?\s*)?(?:결함|문제|이슈|지적|블로커)(?:은|는|이|가)?\s*(?:발견되지\s*않(?:음|았(?:다|습니다)?)|없(?:음|다|습니다))[.。]?$`,
   // REVIEW-MUSTFIX-NONE-PARSE — `(없음 — 이 조각 범위에서는 차단 결함 없음)` 꼬리.
   String.raw`^(?:이\s*)?(?:조각\s*)?범위(?:에서는|에서|엔)?\s*(?:블로커|차단)(?:\s*(?:수준의?\s*)?(?:결함|문제|이슈|지적))?\s*없(?:음|다|습니다)[.。]?$`,
-  String.raw`^(?:no|zero)\s+(?:blocking\s+)?(?:blockers?|issues?|problems?|findings?|must-?fix(?:es)?)(?:\s+found)?\.?$`,
+  String.raw`^이\s*조각에서\s*확인된\s*코어\s*결함\s*없음\s*[—–-]\s*명시\s*intent\s*기준\s*mustFix\s*는\s*비움$`,
+  String.raw`^이\s*조각에서\s*검증된\s*(?:차단\s*)?결함은\s*발견되지\s*않음(?:\s*\(mustFix\s*\[\]\))?$`,
+  String.raw`^코드\s*경로\s*자체는\s*결함\s*없음[.。]?$`,
+  String.raw`^(?:no|zero)\s+(?:blocking\s+)?(?:blockers?|defects?|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');
+// Whole-item no-finding statements are safe to fold. Any additional clause is kept fail-closed.
+const UNBRACKETED_NO_FINDING_REMARK = /^(?:(?:블로커|차단|코어|실제)\s*)?(?:수준의?\s*)?(?:결함|문제|이슈|지적|블로커|findings?|defects?|issues?|problems?|blockers?)(?:은|는|이|가)?\s*(?:발견되지\s*않(?:음|았(?:다|습니다)?)|없(?:음|다|습니다)|not\s+found|none\s+found)[.。]?$/i;
 // OP #3173 — 설명은 의미 추정하지 않는다. 실측으로 무소견임을 확인한 문장만 등록한다.
 // 문법 밖 `없음 — 설명`은 실제 결함일 수 있으므로 mustFix에 남긴다.
 const LONG_BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*(?:[-—–]+\s*)?${NONE_WORD}\s*[—–\-:·]\s*([\s\S]+?)\s*[)\]）】]$`, 'i');
@@ -695,6 +718,20 @@ const KNOWN_POSITIVE_FINDINGS = new Set([
   'retro 사실과 tasks cover 집계는 분모 줄이 있든 없든 같다. 시험(`retro-cli.test.ts`)이 이를 고정하고, 임시 폴더는 `finally` 의 `rmSync` 로 지운다.',
   // 이 후속 PR 자체의 ACP r2: 닫힌 무소견 문장.
   '없음 — 막는 결함은 찾지 못했다.',
+  // REVIEW-MUSTFIX-NONE-NORMALIZE · 2026-10-22 ACP 저장 결과 #30199/#30188/#30183.
+  // 설명을 의미 추정으로 삭제하지 않는다. 원문 전체 일치만 무결함으로 접는다.
+  '(없음) #30188(UX)과 #30189(MK)는 서로 다른 파일만 고쳐서 글자 단위로 겹치는 곳이 없습니다. 합친 뒤에 새로 생긴 회귀도 찾지 못했습니다.',
+  '없음. 네 고침 모두 지금 저장소 계약과 맞는다. 하나씩 대조했다.',
+  '`catalog.yaml:24` kinds 끝에 `classify`가 있다.',
+  '`research-loop.yaml`은 노드 26개이고 `entry_node: intake`다.',
+  '`self-implement.ts:247`이 `cwd-repository`를 돌려준다.',
+  '기본 확장 판정(`scope-adjacency.ts:121`)은 삭제를 `deletion` 정지 사유로 본다.',
+  "`tier-split.ts`의 `planTierSplit`은 두 경우를 `kind:'blocked'`로 돌려보냅니다.",
+  'device-test 조각 없이 feature 조각만 있는 경우: `device-first-stage-missing`',
+  'device-test 조각이 2개 이상이거나, 첫 조각이 아니거나, 그 뒤에 feature가 아닌 조각이 섞인 경우: `device-first-order-invalid`',
+  '이 반환은 `tier-split.ts:114`에서 `handTask({ ...hand, tierSplitBlocked: plan.reason })` 한 곳으로만 이어집니다. decomposer의 timeout이나 throw도 같은 blocked 경로를 탑니다.',
+  '`task-hand.ts`는 다음 세 줄에서 이 경우를 처리합니다.',
+  "`:1066`: 카드 status를 `'failed'`로 정하고, history에 `tier-split-failed: <reason>`을 남깁니다.",
 ]);
 function isPositiveNoFinding(text: string): boolean {
   return KNOWN_POSITIVE_FINDINGS.has(text);
@@ -712,12 +749,19 @@ function isLongNoFindingBracket(text: string): boolean {
  *  ⭐ export — `parseReviewResultOutput` 가 «같은» 판정으로 저장된 결과의 표지 줄을 다시 접는다(PR-LAND-MUSTFIX-NONE · 복제 금지). */
 export function isNoneSentinelFinding(finding: string): boolean {
   const text = finding.trim();
-  if (!text || isBracketedPlaceholder(text)) return true;
+  if (!text || text === '[]' || isBracketedPlaceholder(text)) return true;
   if (isPositiveNoFinding(text)) return true;
+  if (text === '(없음 — 막는 결함은 찾지 못했다.)') return true;
   if (/^[-—–]+$/.test(text)) return true;
   const markerText = text.replace(/^[—–-]+\s*|\s*[—–-]+$/g, '').trim();
+  const unbracketedNone = new RegExp(String.raw`^${NONE_WORD}\s*[—–\-:·]\s*(.+)$`, 'i').exec(markerText);
+  if (unbracketedNone && UNBRACKETED_NO_FINDING_REMARK.test(unbracketedNone[1]!.trim())) return true;
+  if (UNBRACKETED_NO_FINDING_REMARK.test(markerText)) return true;
   const leadingNone = /^[（(]\s*(?:없음|none)\s*[）)]\s+(.+)$/i.exec(markerText);
   if (leadingNone && KNOWN_NO_FINDING_REMARKS.has(leadingNone[1]!.trim())) return true;
+  if (NO_FINDING_REMARK.test(markerText)) return true;
+  const bracketedRemark = BRACKETED_PLACEHOLDER.exec(markerText);
+  if (bracketedRemark && NO_FINDING_REMARK.test(bracketedRemark[1]!.trim())) return true;
   if (markerText && (BARE_SENTINEL.test(markerText) || DASH_ONLY_SENTINEL.test(markerText) || DASH_WRAPPED_BRACKETED_SENTINEL.test(markerText))) return true;
   const bracketed = BRACKETED_SENTINEL.exec(markerText);
   if (bracketed) {
@@ -767,11 +811,27 @@ export function parseReviewResult(text: string): ReviewResult {
     const first = shouldFix.shift() ?? fallbackFinding;
     mustFix.push(first ?? 'PR 리뷰 FAIL — 재작업 필요(구체 지적 미파싱).');
   }
+  // SCOPE-ESCAPE-AS-REFINE — 골의 대상 경로는 출발점이다: «범위 밖이니 되돌려라/분리하라» 는 블로커가 아니라 비블로커.
+  //   삭제·보호 경로 지적은 블로커로 남긴다. 남은 블로커가 없으면 FAIL → WARN(위 «FAIL 인데 must-fix 없음» 승격을 다시 타지 않는다).
+  const scopeRevertDemoted = mustFix.filter(isDemotableScopeRevertMustFix);
+  let finalVerdict = verdict;
+  if (scopeRevertDemoted.length > 0) {
+    const kept = mustFix.filter((finding) => !isDemotableScopeRevertMustFix(finding));
+    mustFix.splice(0, mustFix.length, ...kept);
+    // 리뷰어가 원래 낸 should-fix 를 앞에 둔다 — 아래 상한(6)이 원래 지적을 밀어내지 않게(강등 원문은 scopeRevertDemoted 에 전부 남는다).
+    shouldFix.push(...scopeRevertDemoted);
+    if (verdict === 'fail' && kept.length === 0) finalVerdict = 'warn';
+    try {
+      debug.log('review.parse', 'scope-revert-demoted', { count: scopeRevertDemoted.length, verdictBefore: verdict, verdictAfter: finalVerdict,
+        remainingMustFix: kept.length, heads: scopeRevertDemoted.map((finding) => safeLogText(finding, 120)) });
+    } catch { /* observation must not change parsed review data */ }
+  }
   const fallback = text.match(/\n\[reviewer fallback: ([^\r\n]+)\]$/);
   return {
-    verdict,
+    verdict: finalVerdict,
     mustFix: mustFix.slice(0, 6),
     shouldFix: shouldFix.slice(0, 6),
+    ...(scopeRevertDemoted.length ? { scopeRevertDemoted } : {}),
     ...(fallback ? { reviewerFallback: fallback[1] } : {}),
     ...(requirements.length ? { requirements } : {}),
   };

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

@@ -13,6 +13,7 @@ import remarkParse from 'remark-parse';
 import { unified } from 'unified';
 
 import { parseGoalType, type GoalType } from '../self-implement/goal-author.js';
+import { DEVICE_FIRST_STEP } from '../self-implement/device-first.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';
@@ -525,6 +526,30 @@ function goalFileBlock(goalFile: string | undefined): Block | undefined {
     : undefined;
 }
 
+/** tier-split 이 골 본문에 남긴 조각 표지를 리뷰의 책임 경계로 옮긴다. */
+function sliceReviewScopeBlock(goal: string): Block | undefined {
+  const fencedLines = topLevelCodeLines(goal);
+  const lines = goal.split('\n').filter((_, index) => !fencedLines.has(index));
+  const match = lines.map((line) => /^\s*조각\s+(\d+)\/(\d+)\s*—/.exec(line)).find(Boolean);
+  if (!match) return undefined;
+  const index = Number(match[1]);
+  const total = Number(match[2]);
+  if (!Number.isSafeInteger(index) || !Number.isSafeInteger(total) || index < 1 || total < 2 || index > total) return undefined;
+
+  const deviceStep = `동작: ${DEVICE_FIRST_STEP}`;
+  const device = lines.some((line) => line.split('·').some((part) => {
+    const stage = part.trimStart();
+    return stage === deviceStep || stage.startsWith(`${deviceStep} `);
+  }));
+  const title = '조각 계약 — 리뷰 범위';
+  const scopeLines = [
+    `${title}\n조각 ${index}/${total} — 현재 조각의 동작·변경 파일·자기 완료 경계로 이 PR을 판정한다.`,
+    ...(index < total ? ['다음 조각 몫과 부모 전체 완료 경계의 미완료만으로 이 조각의 must-fix를 만들지 말 것.'] : []),
+    ...(device ? ['장치 조각: 호출부 없는 export의 소비자는 다음 피처 조각이다. 이 조각에서 호출부 부재만으로 must-fix를 만들지 말고 장치 시험과 사용 가능한 인터페이스를 판정한다.'] : []),
+  ];
+  return { title, text: scopeLines.join('\n') };
+}
+
 function isLightweightGoal(goal: string): boolean {
   try {
     const tree = unified().use(remarkParse).use(remarkGfm).parse(goal) as MarkdownNode;
@@ -599,6 +624,7 @@ export function buildReviewIntent(i: Readonly<ReviewIntentInput>): string {
   const boundaries = i.scopeBoundaries ?? mined.scopeBoundaries;
   const unverifiedBoundaryCandidates = mined.unverifiedBoundaryCandidates;
   const goalType = goalTypeBlock(i.goal);
+  const sliceScope = sliceReviewScopeBlock(i.goal);
   // ⚠️ 목표 블록에는 **추출된 절을 뺀 나머지**를 넣는다(리뷰 should-fix) — 골 원문을 통째로 넣고
   //   그 안의 수용기준을 다시 목록으로 붙이면 **같은 내용이 두 번** 들어가 4000자 예산을 먹고,
   //   후순위 블록(스코프 경계)이 불필요하게 잘린다.
@@ -631,7 +657,7 @@ export function buildReviewIntent(i: Readonly<ReviewIntentInput>): string {
     const context = lightweightGoalContext(i.goal, i.goalFile!.trim());
     const boundaryBlock = listBlock('의도적 스코프 경계', boundaries);
     const liteBlocks = [
-      acceptanceBlock, context, boundaryBlock, shardBoundary, priorFindings, applied,
+      acceptanceBlock, context, boundaryBlock, sliceScope, shardBoundary, priorFindings, applied,
       runFacts, goalType, preexisting, importerTestsNotRun,
       gateEvidence, designCheck, designGate, shardSiblings, coverage, claims,
       listBlock('검증 못 한 경계 후보 (결정 아님 — 이것만으로 must-fix 를 면제하지도, 만들지도 말 것)', unverifiedBoundaryCandidates),
@@ -648,6 +674,7 @@ export function buildReviewIntent(i: Readonly<ReviewIntentInput>): string {
   //   ⚠️ 이것은 «렌더 순서»만 바꾼다 — 예산 배분 순서(`order`)와 보호 블록은 아래에서 따로 정한다.
   const blocks: Block[] = [
     runFacts,
+    sliceScope,
     priorFindings,
     goalFile,
     goalType,
@@ -667,7 +694,7 @@ export function buildReviewIntent(i: Readonly<ReviewIntentInput>): string {
     listBlock('검증 못 한 경계 후보 (결정 아님 — 이것만으로 must-fix 를 면제하지도, 만들지도 말 것)', unverifiedBoundaryCandidates),
   ].filter((b): b is Block => Boolean(b));
 
-  const protectedBlocks = blocks.filter((block) => block.title === '수용기준' || block.title === '의도적 스코프 경계');
+  const protectedBlocks = blocks.filter((block) => block.title === '수용기준' || block.title === '의도적 스코프 경계' || block === sliceScope);
   // ⛔⭐ **증거가 목표보다 먼저다**(실측 수리). 종전 순서는 `[보호블록, 목표, 나머지]` 였고, 골이
   //   15,383자면 `목표` 가 남은 예산을 통째로 먹어 자식의 `EVIDENCE/RESULT` 가 **제목만 남고
   //   `…[N개 생략됨]`** 이 됐다. 그러면 리뷰는 *"실행하지 않았다 · 증거가 없다"* 를 적고 — 그것이

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

@@ -100,6 +100,8 @@ interface ReviewObservation {
   readonly mustFix: number;
   /** 목표 범위를 이유로 되돌리거나 분리하라는 MUST-FIX의 관측용 빈도. */
   readonly scopeRevertMustFix: number;
+  /** SCOPE-ESCAPE-AS-REFINE — must-fix 에서 shouldFix 로 강등된 범위-되돌림 지적 수. */
+  readonly scopeRevertDemoted: number;
   readonly shouldFix: number;
   /** ⭐ 지적 **식별용** 앞부분. 이게 있어야 "같은 지적이 반복되나"를 로그만으로 볼 수 있다. */
   readonly mustFixItems: readonly string[];
@@ -197,6 +199,7 @@ export function buildReviewObservation(input: ReviewObservationInput): ReviewObs
     ...(review?.failureReason ? { failureReason: safeLogText(review.failureReason) } : {}),
     mustFix: mustFix.length,
     scopeRevertMustFix: mustFix.filter(isScopeRevertMustFix).length,
+    scopeRevertDemoted: review?.scopeRevertDemoted?.length ?? 0,
     shouldFix: shouldFix.length,
     mustFixItems: clip(mustFix),
     shouldFixItems: clip(shouldFix),