commitgate 0.7.0 → 0.8.0

package/scripts/req/review-codex.ts

@@ -17,12 +17,21 @@
  *   req:review-codex --ticket <dir>    # 임의 티켓 디렉터리
  *   옵션: --handoff <path>  (미지정 시 req.config.json의 handoffPath. 둘 다 없으면 handoff 블록 생략 — 코어 기본은 비활성)
  */
-import { readFileSync, existsSync, writeFileSync, mkdirSync, readdirSync, realpathSync, statSync } from 'node:fs'
-import { resolve, join, relative, sep } from 'node:path'
+import {
+  readFileSync,
+  existsSync,
+  writeFileSync,
+  appendFileSync,
+  mkdirSync,
+  readdirSync,
+  realpathSync,
+  statSync,
+} from 'node:fs'
+import { resolve, join, relative, sep, dirname } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { createHash } from 'node:crypto'
 import Ajv from 'ajv'
-import { loadConfig, packageRoot, buildScriptInvocation, DEFAULTS, type ResolvedConfig, type PackageManager } from './lib/config'
+import { loadConfig, packageRoot, buildScriptInvocation, DEFAULTS, type ResolvedConfig, type PackageManager, type ReviewBudget } from './lib/config'
 import {
   createGitAdapter,
   createCodexReviewerAdapter,
@@ -39,8 +48,15 @@ export { isArchiveFileName, isAllowedResponsesScratch } from './lib/scratch'
 
 // git·codex(reviewer) 경계 = 어댑터(Phase 3, D-017-3/4). main()이 loadConfig 후 config.root로 재생성(기본 = packageRoot — config 부재 시 현재 동작 보존).
 let gitAdapter: GitAdapter = createGitAdapter(packageRoot())
-// reviewer는 main에서 재할당 없음(기본 codex). 테스트 주입 이음새는 callReviewer 파라미터.
-const reviewer: ReviewerAdapter = createCodexReviewerAdapter()
+// REQ-2026-027 D3: reviewer 주입 seam. gitAdapter와 같은 패턴(let + main 재할당)으로 near-e2e 테스트가
+// main() 전체 경로를 fake reviewer로 돌려 (1) legacy에서 외부 호출 0회, (2) attempt 보존 배선을 검증한다.
+// 기본값은 codex — 인자 없는 main(argv)·runCli은 프로덕션 동작 불변.
+let reviewer: ReviewerAdapter = createCodexReviewerAdapter()
+
+/** 테스트 전용: 현재 모듈 reviewer를 관측(복원 검증용). 프로덕션 경로는 이 함수를 쓰지 않는다. */
+export function __getReviewerForTest(): ReviewerAdapter {
+  return reviewer
+}
 
 /** 구조화 응답 스키마 버전 (machine.schema.json과 동기). */
 export const MACHINE_SCHEMA_VERSION = '1.1'
@@ -84,6 +100,9 @@ export interface ReviewPromptInput {
   reviewKind?: ReviewKind
   stagedDiff?: string
   designDocs?: DesignDocs | null
+  // REQ-2026-033 B-2a: delta 표시(design kind 전용). 있으면 authority 블록을 문서별 [변경됨]/[승인 baseline]
+  // 태그로 렌더. 없으면(full 모드·phase) 기존 플레인 블록 그대로(바이트 무변경). persona는 안 바꾼다.
+  designDelta?: { changed: DesignDocKey[]; unchanged: DesignDocKey[] } | null
 }
 
 /**
@@ -96,7 +115,7 @@ export interface ReviewPromptInput {
  * ⚠️ 이 함수는 파일을 읽지 않는다 — persona는 이미 읽힌 **본문**이다. 읽기·부재 판정은 `loadReviewPersona`가 한다.
  */
 export function assembleReviewPrompt(input: ReviewPromptInput): string {
-  const { persona, handoff, reviewContext, reviewBaseSha, requestBody, stagedDiff, designDocs } = input
+  const { persona, handoff, reviewContext, reviewBaseSha, requestBody, stagedDiff, designDocs, designDelta } = input
   const kind: ReviewKind = input.reviewKind ?? 'phase'
   if (!reviewBaseSha) throw new Error('reviewBaseSha 필요')
   if (!requestBody || !requestBody.trim()) throw new Error('codex-request.md 본문이 비어 있음')
@@ -121,17 +140,38 @@ export function assembleReviewPrompt(input: ReviewPromptInput): string {
   blocks.push(`---\n${requestBody.trim()}`)
   if (kind === 'design') {
     if (!designDocs) throw new Error('design 리뷰 권위 아티팩트(00/01/02 designDocs) 필요')
-    blocks.push(
-      [
-        '---\n# 권위 아티팩트 = 설계 문서 00/01/02 (리뷰 대상 = 바인딩 대상)',
-        '## 00-requirement.md',
-        designDocs.requirement,
-        '## 01-design.md',
-        designDocs.design,
-        '## 02-plan.md',
-        designDocs.plan,
-      ].join('\n'),
-    )
+    if (designDelta) {
+      // REQ-2026-033 B-2a: delta 모드 — 문서별 태그. REQ-2026-036 B-3b: 변경 문서는 full 본문, 미변경(baseline)은
+      // DELTA_OMITTED_BODY로 생략(토큰 절감). 생략 문맥이 필요하면 리뷰어가 full_review_requested=yes(B-3a) 요청.
+      const tag = (k: DesignDocKey): string =>
+        designDelta.changed.includes(k) ? DELTA_CHANGED_TAG : DELTA_BASELINE_TAG
+      const body = (k: DesignDocKey, content: string): string =>
+        designDelta.changed.includes(k) ? content : DELTA_OMITTED_BODY
+      blocks.push(
+        [
+          '---\n# 권위 아티팩트 = 설계 문서 00/01/02 (delta review — 변경분 심사)',
+          `## 00-requirement.md ${tag('requirement')}`,
+          body('requirement', designDocs.requirement),
+          `## 01-design.md ${tag('design')}`,
+          body('design', designDocs.design),
+          `## 02-plan.md ${tag('plan')}`,
+          body('plan', designDocs.plan),
+        ].join('\n'),
+      )
+    } else {
+      // full 모드(baseline 없음·첫/legacy) — B-1 이전과 바이트 동일 블록(R6).
+      blocks.push(
+        [
+          '---\n# 권위 아티팩트 = 설계 문서 00/01/02 (리뷰 대상 = 바인딩 대상)',
+          '## 00-requirement.md',
+          designDocs.requirement,
+          '## 01-design.md',
+          designDocs.design,
+          '## 02-plan.md',
+          designDocs.plan,
+        ].join('\n'),
+      )
+    }
   } else {
     blocks.push(`---\n# 권위 아티팩트 = staged diff (리뷰 대상 = 바인딩 대상)\n${stagedDiff ?? ''}`)
   }
@@ -238,6 +278,118 @@ export function captureDesignBinding(
   return { designHash, paths }
 }
 
+/** design 문서 3종의 문서별 blob OID(REQ-2026-031 B-1). delta review(B-2)의 승인 baseline. */
+export interface DesignDocBlobs {
+  requirement: string
+  design: string
+  plan: string
+}
+
+/**
+ * design 문서 3종의 **문서별 blob OID**를 git 인덱스에서 뽑는다(REQ-2026-031 B-1, R1).
+ * `git ls-files -s -- <3경로>` 출력의 각 줄 `<mode> <oid> <stage>\t<path>`에서 **mode·stage는 무시하고
+ * `path`로 문서 키를 매핑**한다 — 커스텀 designDocs면 ls-files가 경로 알파벳순으로 나와 위치가 문서 순서와
+ * 달라지므로, 위치가 아니라 path로 매핑해야 baseline이 오염되지 않는다(design-r01 P1).
+ * `captureDesignBinding`의 designHash와 **독립**(그것을 바꾸지 않는다, R6). 3개 중 하나라도 없으면 fail-closed.
+ */
+export function captureDesignDocBlobs(
+  ticketRelDir: string,
+  gitFn: GitFn = git,
+  designDocs: DesignDocs = DEFAULTS.designDocs,
+): DesignDocBlobs {
+  const [reqP, designP, planP] = designDocPaths(ticketRelDir, designDocs)
+  const byPath = new Map<string, string>()
+  const out = gitFn(['ls-files', '-s', '--', reqP, designP, planP])
+  for (const line of out.split('\n').map((l) => l.trim()).filter(Boolean)) {
+    const tab = line.indexOf('\t')
+    if (tab < 0) continue
+    const path = line.slice(tab + 1)
+    const oid = line.slice(0, tab).split(/\s+/)[1] // [mode, oid, stage] — stage·mode 무시
+    if (oid) byPath.set(path, oid)
+  }
+  const pick = (p: string): string => {
+    const oid = byPath.get(p)
+    if (!oid) throw new Error(`design baseline 실패: ${p} 의 blob OID 없음(git 미추적, fail-closed).`)
+    return oid
+  }
+  return { requirement: pick(reqP), design: pick(designP), plan: pick(planP) }
+}
+
+/**
+ * state에 유효한 design baseline(3 blob OID)이 있는지 판별(REQ-2026-031 B-1, R4·R5). 순수.
+ * B-1은 이 함수를 **제공만** 하고 아무 데서도 호출하지 않는다(R5) — B-2가 delta/full 분기에 쓴다.
+ * 부재(legacy·B-1 이전 승인) = false → B-2가 그런 티켓을 full review로 fallback한다.
+ */
+export function hasDesignBaseline(state: WorkflowState): boolean {
+  const b = (state as { design_baseline?: unknown }).design_baseline
+  if (!b || typeof b !== 'object') return false
+  const o = b as Record<string, unknown>
+  return (
+    typeof o.requirement === 'string' && o.requirement.length > 0 &&
+    typeof o.design === 'string' && o.design.length > 0 &&
+    typeof o.plan === 'string' && o.plan.length > 0
+  )
+}
+
+/** 설계 문서 키(REQ-2026-033 B-2a). `DesignDocBlobs`·delta 표시의 문서 식별. */
+export type DesignDocKey = 'requirement' | 'design' | 'plan'
+
+/**
+ * delta review 문서 태그(REQ-2026-033 B-2a, R3). 변경/미변경 표시 — 코드 상수(오라클이 정확히 고정).
+ * 정보성 태그일 뿐이다: 리뷰 계약(재litigate 금지 지시)은 B-2b의 persona 몫. B-2a는 "무엇이 바뀌었나"만 표시.
+ */
+export const DELTA_CHANGED_TAG = '[변경됨 — 심사 대상]'
+export const DELTA_BASELINE_TAG = '[승인 baseline — 변경 없음, 참조]'
+
+/**
+ * delta 리뷰에서 **미변경 문서 본문 자리**의 생략 placeholder(REQ-2026-036 B-3b). 변경 문서는 full 본문,
+ * 미변경은 이 문자열로 대체해 토큰을 절감한다. 생략된 문맥이 필요하면 리뷰어는 `full_review_requested=yes`
+ * (B-3a)로 full review를 요청한다 — 그 안전판을 안내한다.
+ */
+export const DELTA_OMITTED_BODY =
+  '(본문 생략 — 승인 baseline·변경 없음. 전체가 필요하면 `full_review_requested: "yes"`로 full review를 요청하라.)'
+
+/**
+ * baseline(승인 시점 문서별 blob OID)과 현재 인덱스 OID를 **키별** 비교(REQ-2026-033 B-2a, R1). 순수.
+ * 다르면 changed, 같으면 unchanged — 위치·순서가 아니라 키(requirement/design/plan)로 비교. 결정적 키 순서로
+ * 반환. delta 프롬프트가 어느 문서를 [변경됨]/[승인 baseline]으로 표시할지의 근거. baseline·current는 DesignDocBlobs.
+ */
+export function computeDesignDelta(
+  baseline: DesignDocBlobs,
+  current: DesignDocBlobs,
+): { changed: DesignDocKey[]; unchanged: DesignDocKey[] } {
+  const keys: DesignDocKey[] = ['requirement', 'design', 'plan']
+  const changed: DesignDocKey[] = []
+  const unchanged: DesignDocKey[] = []
+  for (const k of keys) (baseline[k] === current[k] ? unchanged : changed).push(k)
+  return { changed, unchanged }
+}
+
+/**
+ * design delta 리뷰의 **행동 계약**(REQ-2026-034 B-2b, R1). delta 모드 persona에 얹혀 "표시된 변경분·직접
+ * 영향만 심사, 승인 영역 재litigate 금지"를 건다. 태그 문구는 `DELTA_*_TAG` **상수 참조**(하드코딩 금지 —
+ * 태그가 바뀌면 계약도 자동 반영). B-2a 태그를 리뷰어가 어떻게 쓸지의 계약이다.
+ */
+export const DESIGN_DELTA_CONTRACT = [
+  '# Delta Review 계약',
+  `- ${DELTA_CHANGED_TAG} 표시 문서·섹션과 그 직접 영향 범위만 심사한다.`,
+  `- ${DELTA_BASELINE_TAG}은 직전 라운드에 승인되었다. 재심사·재litigate 금지 — 참조 문맥으로만 쓴다.`,
+  '- 단, 이번 변경이 승인 영역의 재고를 강제하면(모순·전제 붕괴) finding으로 명확히 밝혀라.',
+  // REQ-2026-035 B-3a: escalation 사용법. 신호(full_review_requested)만으론 언제 쓸지 모르므로 계약에 명시.
+  '- 변경이 너무 근본적이어서 delta(변경분만)로 판단할 수 없으면 `full_review_requested: "yes"`로 응답해 전체 설계 재리뷰를 요청하라(그때 `commit_approved: "no"`).',
+].join('\n')
+
+/**
+ * delta 모드 effective persona 계산(REQ-2026-034 B-2b, R2·R4). 순수. `deltaActive`(= main의 `designDelta`가
+ * 설정됨 = design + baseline)면 계약을 얹는다 — base 있으면 `base + '\n' + 계약`, **base null(reviewPersonaPath:null,
+ * 지원 설정)이면 계약 단독**. `deltaActive` 아니면 base 그대로(null이면 null — full·phase 무회귀).
+ * main은 이 결과 **하나**를 프롬프트와 review-call 로그 policy_version 양쪽에 흘린다(단일 배선, 032 r02·r03).
+ */
+export function applyDeltaPersona(base: string | null, deltaActive: boolean): string | null {
+  if (!deltaActive) return base
+  return base ? `${base}\n${DESIGN_DELTA_CONTRACT}` : DESIGN_DELTA_CONTRACT
+}
+
 /**
  * 설계 문서 3종 본문을 git **인덱스**에서 읽는다(`git show :<path>`) — Codex P2.
  * 프롬프트 본문(리뷰 대상)과 design 바인딩 해시(`captureDesignBinding`, 인덱스 기반)가 **동일 대상**을 가리키게 하여
@@ -292,6 +444,9 @@ export interface Verdict {
   next_action?: string
   // REQ-2026-005: optional 비차단 코멘트. classifyReview는 이 필드를 보지 않는다(findings 존재만으로 분류).
   observations?: Observation[]
+  // REQ-2026-035 B-3a: design delta 리뷰에서 리뷰어가 full review를 요청하는 신호(yes/no, optional). yes면
+  // processResponse가 baseline을 비워 다음 리뷰를 full로 되돌린다. yes는 commit_approved=no·review_kind=design 필수.
+  full_review_requested?: string
 }
 
 const STATUS_VALUES = ['NEEDS_FIX', 'STEP_COMPLETE', 'COMPLETE']
@@ -343,6 +498,12 @@ export function validateVerdict(
   if (v.commit_approved === 'yes' && Array.isArray(v.findings) && v.findings.length > 0)
     errors.push('모순: commit_approved=yes 인데 findings가 비어있지 않음 (승인은 findings 0건 — 지적이 있으면 미승인)')
 
+  // REQ-2026-035 B-3a: full review 요청은 미승인·design 전용(교차필드). enum(yes/no)은 AJV가 강제.
+  if (v.full_review_requested === 'yes' && v.commit_approved !== 'no')
+    errors.push('모순: full_review_requested=yes 인데 commit_approved≠no (full review 요청은 미승인이어야 함)')
+  if (v.full_review_requested === 'yes' && v.review_kind !== 'design')
+    errors.push('모순: full_review_requested=yes 인데 review_kind≠design (delta/baseline은 design 전용)')
+
   return { ok: errors.length === 0, errors }
 }
 
@@ -382,6 +543,84 @@ export const REVIEW_EXIT_CODES: Record<ReviewOutcome, number> = {
   'needs-fix': 3,
 }
 
+// ──────────────────────────────────── review-call 측정 로그 (REQ-2026-025) ──
+
+/** 로그 경로(repo 루트 기준). `.gitignore`에 등재 — **커밋 대상이 아니다**(D3·R7). */
+export const REVIEW_CALL_LOG_REL = 'workflow/.review-calls.jsonl'
+
+/**
+ * persona 본문 → 로그 세그먼트 키(D2). `sha256(본문)` 앞 12자. persona 비활성(null)이면 `'none'`.
+ *
+ * 수동 상수 bump를 쓰지 않는 이유: persona를 고치고 상수 올리기를 잊으면 세그먼트가 **조용히 거짓**이 된다.
+ * 이 프로젝트는 사람이 손으로 적은 값이 실제와 어긋나 REQ 하나를 폐기한 이력이 있다(REQ-2026-019).
+ * 자동 파생은 잊을 수 없고, 사용자가 `reviewPersonaPath`로 바꾼 custom persona도 자동으로 구분한다.
+ */
+export function reviewPolicyVersion(persona: string | null): string {
+  if (persona === null) return 'none'
+  return createHash('sha256').update(persona, 'utf8').digest('hex').slice(0, 12)
+}
+
+/** review-call 로그 1행(R6 최소 필드). REQ-A가 series/attempt/lineage를, REQ-B가 review_mode/full_review를 **확장**한다(R9·D6). */
+export interface ReviewCallLogRow {
+  ticket_id: string
+  review_kind: ReviewKind
+  phase_id: string | null
+  /** 아카이브 round. 무효 응답은 아카이브를 남기지 않으므로 `null`(D4). */
+  archive_round: number | null
+  outcome: ReviewOutcome
+  findings_count: number
+  observations_count: number
+  timestamp: string
+  policy_version: string
+}
+
+/**
+ * verdict → 로그 행(순수). **내용 배제 경계가 여기다**(R7).
+ *
+ * verdict를 받지만 **개수만 꺼낸다** — `findings[].detail`·`observations[].detail`·`next_action`·`file`은
+ * 절대 행에 담지 않는다. 리뷰 프롬프트는 `git diff --cached` 전문을 담을 수 있고(AGENTS 계약 §6),
+ * 그 파생물을 gitignore된 로컬 파일에 복제하면 마스킹 없는 사본이 하나 더 생긴다. 개수만 세면 목적
+ * ("배칭이 라운드당 P1 수를 바꾸는가")이 달성된다.
+ */
+export function buildReviewCallLogRow(args: {
+  ticketId: string
+  kind: ReviewKind
+  phaseId: string | null
+  archiveRound: number | null
+  outcome: ReviewOutcome
+  verdict: Verdict
+  timestamp: string
+  policyVersion: string
+}): ReviewCallLogRow {
+  return {
+    ticket_id: args.ticketId,
+    review_kind: args.kind,
+    phase_id: args.phaseId,
+    archive_round: args.archiveRound,
+    outcome: args.outcome,
+    findings_count: args.verdict.findings?.length ?? 0,
+    observations_count: args.verdict.observations?.length ?? 0,
+    timestamp: args.timestamp,
+    policy_version: args.policyVersion,
+  }
+}
+
+/**
+ * 로그 append(측정 전용). **실패를 삼킨다**(R8).
+ *
+ * fail-closed 원칙의 예외가 아니다 — 이 로그는 **승인 근거가 아니므로 게이트가 아니다.** 측정 실패가
+ * 리뷰 판정·exit code·state를 바꾸면 그것이 오히려 계약 위반이다. 아카이브 기록도 같은 패턴을 쓴다.
+ */
+export function appendReviewCallLog(rootAbs: string, row: ReviewCallLogRow): void {
+  try {
+    const abs = join(rootAbs, ...REVIEW_CALL_LOG_REL.split('/'))
+    mkdirSync(dirname(abs), { recursive: true })
+    appendFileSync(abs, `${JSON.stringify(row)}\n`, 'utf8')
+  } catch {
+    // 측정은 게이트가 아니다(R8). 리뷰 판정 경로는 로그 유무와 무관하게 동일하다.
+  }
+}
+
 export interface ProcessResponseResult {
   ok: boolean
   errors: string[]
@@ -588,11 +827,319 @@ export interface WorkflowState {
   // REQ-016 A1: 승인 증거 핀(kind 격리) + grandfathering 트리거. 반대 kind 증거는 미오염.
   approval_evidence?: ApprovalEvidence
   design_approval_evidence?: ApprovalEvidence
+  // REQ-2026-031 B-1: 마지막 design 승인 시점의 문서별 blob OID(delta review baseline). top-level이라
+  // design 재리뷰의 evidence stale 제거(:1184)에 안 걸리고 NEEDS_FIX 사이클 내내 보존된다. 승인 시에만 갱신.
+  design_baseline?: DesignDocBlobs
   blocked_review?: BlockedReviewMarker
   approval_evidence_required?: boolean
+  // REQ-2026-027 D1·D2: review series 모델 버전 + series 레코드. 필드 부재 = legacy(무침습).
+  review_series_model_version?: number
+  review_series?: SeriesRecord[]
+  // REQ-2026-028 D2: 사람 예외 손기록(6~8회차). 소비되면 null(무이월).
+  review_exception_confirmed?: ReviewExceptionConfirmed | null
+  // REQ-2026-029 D3: 대체 REQ의 부모 lineage(--successor-of로만 채워짐).
+  successor_of?: SuccessorOf
   [k: string]: unknown
 }
 
+/**
+ * review series 레코드(REQ-2026-027 D2). 키 `(review_kind, phase_id)`. 배열이라 이력을 지우지 않는다(R7).
+ * A-1의 `closed_reason`은 `'approved' | null`뿐 — A-2가 `'human-resolution'`을 추가한다(열린 확장).
+ */
+export interface SeriesRecord {
+  series_id: string
+  review_kind: ReviewKind
+  phase_id: string | null
+  attempts: number
+  // REQ-2026-029 A-2b: 'human-resolution' 추가(A-2a가 열린 확장으로 남긴 타입). approved와 재개방 규칙 정반대.
+  closed_reason: 'approved' | 'human-resolution' | null
+  // closed_reason='human-resolution'일 때만. 사람이 escalate된 series를 종료·대체로 결정한 손기록.
+  human_resolution?: HumanResolution
+}
+
+/** 사람의 series 종결 결정(REQ-2026-029 A-2b D1). accept-risk 없음(배분표 ④ — decision은 둘뿐). */
+export interface HumanResolution {
+  decision: 'terminate' | 'replace'
+  method: string        // 받은 승인 문장 그대로
+  decided_at: string    // 실제 시계(REQ-019 날조 폐기 이력)
+  note?: string
+}
+
+/**
+ * legacy ticket 판정(REQ-2026-027 D1, 순수). 생성 시 stamp되는 `review_series_model_version` **부재** = legacy.
+ * "series 레코드 유무"로 판정하지 않는다 — 새 ticket도 첫 리뷰 전엔 레코드가 없어 오분류된다.
+ * `state.phase`를 쓰지 않는다(죽은 필드 — 티켓 전부 INTAKE). legacy면 자동 초기화 대신 사람에게 넘긴다.
+ */
+export function isLegacyTicket(state: WorkflowState): boolean {
+  return typeof state.review_series_model_version !== 'number'
+}
+
+/** `state.review_series`를 안전하게 읽는다(부재/비배열 → []). */
+function readSeries(state: WorkflowState): SeriesRecord[] {
+  const raw = (state as { review_series?: unknown }).review_series
+  return Array.isArray(raw) ? (raw as SeriesRecord[]) : []
+}
+
+/**
+ * attempt 기록(REQ-2026-027 D2·D3, 순수). 같은 `(kind, phase_id)`에 **열린** series가 있으면 그 `attempts`를
+ * +1, 없으면 새 series를 연다(seq = 같은 키의 기존 레코드 수 + 1, attempts=1).
+ *
+ * **hash를 입력으로 받지 않는다**(R5) — design series는 hash가 바뀌어도 같은 series다. 이것이 REQ-020의
+ * 14라운드 병리(라운드마다 hash가 달라 계수가 초기화됨)를 막는 핵심이다. **아무것도 막지 않는다**(R11):
+ * attempts가 아무리 커도 여기서 거부하지 않는다 — 예산·상한은 A-2다.
+ */
+export function recordAttempt(state: WorkflowState, kind: ReviewKind, phaseId: string | null): WorkflowState {
+  const series = readSeries(state)
+  const openIdx = series.findIndex(
+    (r) => r.review_kind === kind && (r.phase_id ?? null) === phaseId && r.closed_reason === null,
+  )
+  if (openIdx >= 0) {
+    const next = series.map((r, i) => (i === openIdx ? { ...r, attempts: r.attempts + 1 } : r))
+    return { ...state, review_series: next }
+  }
+  const seq = series.filter((r) => r.review_kind === kind && (r.phase_id ?? null) === phaseId).length + 1
+  const rec: SeriesRecord = {
+    series_id: `${kind}:${phaseId ?? '-'}#${seq}`,
+    review_kind: kind,
+    phase_id: phaseId,
+    attempts: 1,
+    closed_reason: null,
+  }
+  return { ...state, review_series: [...series, rec] }
+}
+
+/**
+ * 승인으로 series 종료(REQ-2026-027 D2, 순수). 같은 `(kind, phase_id)`의 **열린** 레코드를 `'approved'`로 닫는다.
+ * 열린 게 없으면 no-op(방어). **`approved`만이 A-1의 자동 종료 계기다**(R6) — needs-fix·blocked·invalid는
+ * 여기를 타지 않아 열린 채로 남고, 그래야 A-2가 얹을 상한이 의미를 갖는다.
+ */
+export function closeSeriesApproved(state: WorkflowState, kind: ReviewKind, phaseId: string | null): WorkflowState {
+  const series = readSeries(state)
+  const openIdx = series.findIndex(
+    (r) => r.review_kind === kind && (r.phase_id ?? null) === phaseId && r.closed_reason === null,
+  )
+  if (openIdx < 0) return state
+  const next = series.map((r, i) => (i === openIdx ? { ...r, closed_reason: 'approved' as const } : r))
+  return { ...state, review_series: next }
+}
+
+// ──────────────────────────────── review lineage — human-resolution (REQ-2026-029 A-2b) ──
+
+/**
+ * 사람 종결 손기록 형식 검증(REQ-2026-029 D1, 순수, R3·배분표 ⑪). `decision ∈ {terminate,replace}` +
+ * 비어있지 않은 `method` + 유효 ISO `decided_at`(A-2a `isValidIsoInstant` 재사용 — 형식+달력).
+ * 검증 없으면 `{decision:'',decided_at:'x'}`도 통과해 날조 종결(REQ-019 부류).
+ */
+export function isValidHumanResolution(r: unknown): r is HumanResolution {
+  if (!r || typeof r !== 'object') return false
+  const h = r as Partial<HumanResolution>
+  if (h.decision !== 'terminate' && h.decision !== 'replace') return false
+  if (typeof h.method !== 'string' || h.method.trim().length === 0) return false
+  if (!isValidIsoInstant(h.decided_at)) return false
+  return true
+}
+
+/**
+ * 사람 종결로 series 닫기(REQ-2026-029 D1, 순수). 같은 `(kind,phase_id)`의 **열린** 레코드를
+ * `closed_reason='human-resolution'`+`human_resolution`으로 닫는다. 열린 게 없으면 throw(종결 대상이 없음).
+ * resolution 형식이 무효면 throw(fail-closed).
+ */
+export function closeSeriesHumanResolution(
+  state: WorkflowState,
+  kind: ReviewKind,
+  phaseId: string | null,
+  resolution: HumanResolution,
+): WorkflowState {
+  if (!isValidHumanResolution(resolution)) throw new Error('human_resolution 형식 무효(decision·method·decided_at)')
+  const series = readSeries(state)
+  const openIdx = series.findIndex(
+    (r) => r.review_kind === kind && (r.phase_id ?? null) === phaseId && r.closed_reason === null,
+  )
+  if (openIdx < 0) throw new Error('human-resolution 종결 대상(열린 series)이 없다')
+  const next = series.map((r, i) =>
+    i === openIdx ? { ...r, closed_reason: 'human-resolution' as const, human_resolution: resolution } : r,
+  )
+  return { ...state, review_series: next }
+}
+
+/**
+ * series 키 terminal 판정(REQ-2026-029 D2, 순수, R4·배분표 ③). `(kind,phase_id)`에 `closed_reason=
+ * 'human-resolution'` 레코드가 **하나라도 있으면** true. `approved`만/null인 키는 false(재개방 정상).
+ *
+ * **approved와 재개방 규칙이 정반대다**: approved=문제 해결 → 새 series 정당. human-resolution=미해결·사람
+ * 개입 → 같은 키에서 계속하면 개입 무효화 → 자동으로 안 연다.
+ */
+export function isSeriesKeyTerminal(state: WorkflowState, kind: ReviewKind, phaseId: string | null): boolean {
+  return readSeries(state).some(
+    (r) => r.review_kind === kind && (r.phase_id ?? null) === phaseId && r.closed_reason === 'human-resolution',
+  )
+}
+
+/**
+ * 대체 REQ의 부모 lineage(REQ-2026-029 D3). **`recorded_at`만 자식 생성 시각**이고 나머지는 부모에서 읽는다
+ * (design-r01 observation — provenance 명확화).
+ */
+export interface SuccessorOf {
+  req_id: string                              // 부모 REQ id
+  parent_attempts_total: number               // 부모 **모든** series attempts 합
+  parent_replace_resolution: HumanResolution  // 부모의 replace 종결 손기록 그대로
+  recorded_at: string                          // 자식 생성 시각(부모 값 아님)
+}
+
+/**
+ * 부모에서 lineage를 읽어 채운다(REQ-2026-029 D3, 순수, R6·R7·배분표 ⑩). 부모에 `decision='replace'` +
+ * 유효 형식(`isValidHumanResolution`)인 human-resolution series가 **없으면 throw**(fail-closed — 티켓 미생성).
+ *
+ * **lineage 근거 세 필드(`req_id`·`parent_attempts_total`·`parent_replace_resolution`)는 부모 state에서 온다**
+ * — CLI로 받지 않는다(전사 오류·날조 통로 차단). `recorded_at`만 자식 생성 시각(부모 값 아님, 호출자가 넘김).
+ */
+export function resolveSuccessorLineage(parentState: WorkflowState, parentReqId: string, recordedAt: string): SuccessorOf {
+  const replace = readSeries(parentState).find(
+    (r) => r.closed_reason === 'human-resolution' && r.human_resolution?.decision === 'replace' && isValidHumanResolution(r.human_resolution),
+  )
+  if (!replace || !replace.human_resolution)
+    throw new Error(`--successor-of ${parentReqId}: 부모에 대체(replace)를 허용한 유효한 사람 결정 기록이 없다`)
+  const parentAttemptsTotal = readSeries(parentState).reduce((sum, r) => sum + (typeof r.attempts === 'number' ? r.attempts : 0), 0)
+  return {
+    req_id: parentReqId,
+    parent_attempts_total: parentAttemptsTotal,
+    parent_replace_resolution: replace.human_resolution,
+    recorded_at: recordedAt,
+  }
+}
+
+// ──────────────────────────────── review 예산 게이트 (REQ-2026-028 A-2a) ──
+
+/** 예산 판정(REQ-2026-028 D1). `attempt`는 **이 다음 호출의 회차**(= openAttempts + 1). */
+export type BudgetDecision =
+  | { kind: 'allow' }
+  | { kind: 'needs-exception'; attempt: number }
+  | { kind: 'hard-blocked'; attempt: number }
+
+/**
+ * 같은 `(kind, phase_id)`의 **열린** series의 attempts(없으면 0). 게이트 입력.
+ * `escalated`나 직전 outcome을 보지 않는다 — 계수만이 기준이다(R2, 배분표 ⑤).
+ */
+export function openSeriesAttempts(state: WorkflowState, kind: ReviewKind, phaseId: string | null): number {
+  const rec = openSeriesRecord(state, kind, phaseId)
+  return rec ? rec.attempts : 0
+}
+
+/**
+ * 예산 게이트 판정(REQ-2026-028 D1, 순수). **기준은 `openAttempts`뿐**(R2).
+ * - `openAttempts < autoBudget` → allow(자동)
+ * - `autoBudget <= openAttempts < hardCap` → needs-exception(6~8회차, 사람 예외 필요)
+ * - `openAttempts >= hardCap` → hard-blocked(9회차, 예외로도 차단)
+ */
+export function checkReviewBudget(openAttempts: number, budget: ReviewBudget): BudgetDecision {
+  const attempt = openAttempts + 1 // 이 다음 호출의 회차
+  if (openAttempts < budget.autoBudget) return { kind: 'allow' }
+  if (openAttempts < budget.hardCap) return { kind: 'needs-exception', attempt }
+  return { kind: 'hard-blocked', attempt }
+}
+
+/** ISO instant 형식(밀리초 선택). req-commit.ts의 ISO_RE와 같은 패턴(손기록 계약 통일). */
+const REVIEW_ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/
+
+/**
+ * ISO instant 유효성(REQ-2026-028 D2). **형식 + 달력 유효성 둘 다**(design-r02·r03).
+ * `ISO_RE`만으론 `2026-99-99T99:99:99Z`가 통과하므로, 재파싱해 성분(연·월·일·시·분·초)이 보존되는지 확인.
+ * 밀리초 표기 차(`08Z` vs `08.000Z`)는 비교에서 무시 — 성분이 맞으면 유효.
+ */
+export function isValidIsoInstant(s: unknown): boolean {
+  if (typeof s !== 'string' || !REVIEW_ISO_RE.test(s)) return false
+  const d = new Date(s)
+  if (Number.isNaN(d.getTime())) return false
+  // 재직렬화 후 초까지 성분 비교(밀리초 절단). `2026-99-99...`는 여기서 불일치로 걸린다.
+  const canon = (x: string): string => x.replace(/\.\d+Z$/, 'Z').replace(/Z$/, '')
+  return canon(d.toISOString()) === canon(s)
+}
+
+/** 사람 예외 손기록(REQ-2026-028 D2). `user_commit_confirmed`와 같은 모양. */
+export interface ReviewExceptionConfirmed {
+  confirmed: boolean
+  method: string
+  confirmed_at: string
+  for_series_id: string
+  for_attempt: number
+  note?: string
+}
+
+/**
+ * 사람 예외 소비(REQ-2026-028 D2, 순수). 유효하면 소비된 state(`review_exception_confirmed=null`) 반환,
+ * 무효면 throw(fail-closed). **series는 닫지 않는다**(R10, 배분표 ①) — `closed_reason` 미변경.
+ *
+ * 유효 조건: (1) 형식 — `confirmed===true` + 비어있지 않은 `method` + 유효 ISO `confirmed_at`(R8, 배분표 ⑪).
+ * (2) 바인딩 — `for_series_id === seriesId` && `for_attempt === nextAttempt`(R9).
+ */
+export function consumeReviewException(
+  state: WorkflowState,
+  seriesId: string,
+  nextAttempt: number,
+): WorkflowState {
+  const raw = (state as { review_exception_confirmed?: unknown }).review_exception_confirmed
+  if (!raw || typeof raw !== 'object') throw new Error(`review 예외 승인 없음 — ${nextAttempt}회차는 사람 승인이 필요하다`)
+  const ex = raw as Partial<ReviewExceptionConfirmed>
+  if (ex.confirmed !== true) throw new Error('review 예외: confirmed!==true (무효 손기록)')
+  if (typeof ex.method !== 'string' || ex.method.trim().length === 0)
+    throw new Error('review 예외: method 비어 있음 (무효 손기록)')
+  if (!isValidIsoInstant(ex.confirmed_at)) throw new Error(`review 예외: confirmed_at 비-ISO (${String(ex.confirmed_at)})`)
+  if (ex.for_series_id !== seriesId)
+    throw new Error(`review 예외: for_series_id 불일치(${String(ex.for_series_id)} ≠ ${seriesId}) — 다른 series 예외 재사용 불가`)
+  if (ex.for_attempt !== nextAttempt)
+    throw new Error(`review 예외: for_attempt 불일치(${String(ex.for_attempt)} ≠ ${nextAttempt}) — 다른 회차 예외 재사용 불가`)
+  const { review_exception_confirmed: _consumed, ...rest } = state // 1회 소비(무이월)
+  return { ...rest, review_exception_confirmed: null }
+}
+
+/**
+ * attempt를 **외부 호출 직전**에 기록·`writeState`하고 `call()`을 부른다(REQ-2026-027 D3 + REQ-2026-028 D1).
+ *
+ * **순서가 계약이다**(R8): 예산 게이트 → (예외 소비) → 기록·writeState → `call()`. `call()`이 throw해도
+ * 기록은 이미 디스크에 있어 되돌아가지 않는다 — 외부 호출은 이미 일어났고 비용도 발생했다.
+ *
+ * **예산 게이트가 `recordAttempt` 전이다**(REQ-2026-028 R5): 막을 거면 호출도 기록도 하기 전에 막는다.
+ * throw 시 state는 바뀌지 않는다(예외 소비 성공 시에만 쓰기). **반환 `state`가 후처리의 유일한 base다**(R9).
+ */
+export function withAttemptRecorded<T>(
+  ctx: { ticketDir: string; state: WorkflowState; kind: ReviewKind; phaseId: string | null; budget: ReviewBudget },
+  call: () => T,
+): { result: T; state: WorkflowState } {
+  // REQ-2026-029 D2: terminal 가드 — 예산 게이트보다 **앞**. human-resolution으로 종결된 키는 예산을 볼
+  // 필요도 없이 막는다(배분표 ③). 가드 없으면 recordAttempt가 새 series(0회)를 열어 예산이 리셋된다.
+  if (isSeriesKeyTerminal(ctx.state, ctx.kind, ctx.phaseId))
+    throw new Error(
+      '이 series는 human-resolution으로 종결됐다 — 같은 키에서 자동으로 재개하지 않는다. 대체가 필요하면 `req:new --successor-of <이 REQ>`로 만든다.',
+    )
+  // REQ-2026-028 D1: recordAttempt **전**에 예산 검사. 초과면 호출·기록 전에 throw.
+  const openAttempts = openSeriesAttempts(ctx.state, ctx.kind, ctx.phaseId)
+  const decision = checkReviewBudget(openAttempts, ctx.budget)
+  let gated = ctx.state
+  if (decision.kind === 'hard-blocked')
+    throw new Error(
+      `review 예산 소진 — ${decision.attempt}회차는 어떤 경로로도 실행하지 않는다(hardCap=${ctx.budget.hardCap}). 종료하거나 정합한 대체 REQ를 작성한다.`,
+    )
+  if (decision.kind === 'needs-exception') {
+    // 🔴 열린 record의 series_id를 **직접** 쓴다(design-r01 P1). 재구성(`split('#')`)은 phase id에 `#`가
+    // 들어가면 깨진다(`phase#alpha` → `NaN`). needs-exception이면 openAttempts>=autoBudget≥1이라 열린
+    // record가 반드시 존재한다(attempts>=1).
+    const open = openSeriesRecord(ctx.state, ctx.kind, ctx.phaseId)
+    if (!open) throw new Error('review 예외: 열린 series를 찾을 수 없다(불변 위반)') // 방어(도달 불가)
+    gated = consumeReviewException(ctx.state, open.series_id, decision.attempt) // 무효면 throw
+  }
+  const state = recordAttempt(gated, ctx.kind, ctx.phaseId)
+  writeState(ctx.ticketDir, state) // 호출 **전** 영속 — throw해도 남는다
+  const result = call() // throw면 그대로 전파(기록은 이미 선행)
+  return { result, state }
+}
+
+/** 같은 `(kind, phase_id)`의 열린 series record(없으면 undefined). series_id를 재구성하지 않고 직접 얻는다. */
+export function openSeriesRecord(state: WorkflowState, kind: ReviewKind, phaseId: string | null): SeriesRecord | undefined {
+  return readSeries(state).find(
+    (r) => r.review_kind === kind && (r.phase_id ?? null) === phaseId && r.closed_reason === null,
+  )
+}
+
 /** state.phases를 안전하게 PhaseEntry[]로 읽음(부재/비배열→[], id 문자열 항목만). */
 export function readPhases(state: WorkflowState): PhaseEntry[] {
   const raw = (state as { phases?: unknown }).phases
@@ -750,6 +1297,8 @@ export function processResponse(args: {
   // REQ-016 A1: 승인 시 증거 핀 정본(아카이브 경로+sha). 미제공 시 evidence 미부착(하위호환).
   archive?: { path: string; sha256: string }
   approvedAt?: string
+  // REQ-2026-031 B-1: design 승인 시 저장할 문서별 blob OID. 승인+archive 분기에서만 state.design_baseline에 설정.
+  designDocBlobs?: DesignDocBlobs
 }): ProcessResponseResult {
   const { ticketDir, state, binding, threadId, designHash, schemaPath } = args
   const kind: ReviewKind = args.kind ?? 'phase'
@@ -787,6 +1336,13 @@ export function processResponse(args: {
     const nextState = ok
       ? applyVerdict({ base, binding, verdict, kind, designHash })
       : { ...base, design_approved: false, design_approved_hash: null }
+    // REQ-2026-031 B-1: baseline은 **유효 design 승인마다** 갱신("마지막 승인된 설계 스냅샷") — archive(evidence
+    // 핀)와 독립. archive 쓰기 실패로 evidence 없이 승인이 영속되는 경우(design_approved=true는 applyVerdict가
+    // archive와 무관하게 설정)에도 baseline은 저장돼야 B-2가 정상 승인을 legacy로 오판하지 않는다(R2·R3, phase-r01 P1).
+    // NEEDS_FIX·미승인은 이 분기를 안 타므로 stateRest(:1184)의 기존 design_baseline이 그대로 보존된다(NEEDS_FIX 생존).
+    if (ok && nextState.design_approved === true && args.designDocBlobs) {
+      nextState.design_baseline = args.designDocBlobs
+    }
     // A1(D-016-2): design 승인 + archive 제공 시에만 design_approval_evidence 재부착(fresh). 그 외엔 위 omit으로 미부착.
     if (ok && nextState.design_approved === true && args.archive) {
       nextState.design_approval_evidence = buildApprovalEvidence({
@@ -800,6 +1356,12 @@ export function processResponse(args: {
         approvedAt: args.approvedAt ?? new Date().toISOString(),
       })
     }
+    // REQ-2026-035 B-3a: 리뷰어가 full review를 요청하면 baseline을 비워 다음 design 리뷰를 full로 되돌린다
+    // (hasDesignBaseline 게이트 재사용 — main·게이트 무변경). full_review_requested=yes는 commit_approved=no
+    // (validateVerdict R2)라 위 승인-baseline 분기를 안 타고, stateRest에서 온 기존 baseline만 지운다. ordinary
+    // NEEDS_FIX(full_review_requested≠yes)는 baseline을 보존한다(B-1 NEEDS_FIX 생존 무회귀).
+    // `ok` 가드: 무효 응답(예: yes인데 commit_approved=yes 모순)은 baseline을 안 건드린다(응답 거부).
+    if (ok && verdict.full_review_requested === 'yes') delete nextState.design_baseline
     return { ok, errors, nextState, verdict }
   }
 
@@ -1203,12 +1765,32 @@ export function callReviewer(
   return { threadId }
 }
 
-export function main(argv: string[] = process.argv.slice(2)): void {
+export function main(argv: string[] = process.argv.slice(2), opts2?: { reviewer?: ReviewerAdapter }): void {
+  // REQ-2026-027 D3: 주입한 reviewer는 이 호출에만 유효해야 한다 — 모듈 전역에 잔존하면 이후 인자 없는
+  // main()도 그것을 쓴다(리뷰어 observation). CLI는 프로세스당 1회라 무해하나, programmatic 다중 호출
+  // (near-e2e 테스트 등)에선 오염된다. finally로 기본값을 복원한다.
+  const defaultReviewer = reviewer
+  try {
+    mainImpl(argv, opts2)
+  } finally {
+    reviewer = defaultReviewer
+  }
+}
+
+function mainImpl(argv: string[], opts2?: { reviewer?: ReviewerAdapter }): void {
   const opts = parseArgs(argv)
   const cfg = loadConfig({ root: opts.root })
   gitAdapter = createGitAdapter(cfg.root) // 모든 git 호출 cwd = config.root
+  // REQ-2026-027 D3: 테스트 주입 seam(gitAdapter 선례). 미주입이면 기본 codex(프로덕션 불변).
+  if (opts2?.reviewer) reviewer = opts2.reviewer
   const ticketDir = resolveTicketDir(opts, cfg)
   let state = loadState(ticketDir) // 부재 시 명확한 에러
+  // REQ-2026-027 D1: legacy ticket(모델 버전 부재)은 외부 호출 **전에** fail-closed. AWAIT_HUMAN 안내는
+  // req:next가, 강제 throw는 여기가 담당한다. 어떤 state 변경도·codex 호출도 하지 않는다(R2).
+  if (isLegacyTicket(state))
+    throw new Error(
+      'legacy ticket(review_series_model_version 부재) — 자동 리뷰 불가. 사람이 이 티켓을 새 모델로 채택할지 결정해야 한다(req:next가 AWAIT_HUMAN으로 안내).',
+    )
   // --fresh-thread: blocked 회로차단기 명시적 회복 — 마커 제거(단락 해제) + resume 대신 새 스레드(고착 resume 끊기).
   if (opts.freshThread) state = clearBlockedReview(state)
 
@@ -1249,13 +1831,25 @@ export function main(argv: string[] = process.argv.slice(2)): void {
   let stagedDiff: string | undefined
   let designDocs: DesignDocs | undefined
   let designHash: string | undefined
+  let designDocBlobs: DesignDocBlobs | undefined
+  let designDelta: { changed: DesignDocKey[]; unchanged: DesignDocKey[] } | undefined
   if (opts.kind === 'design') {
     // 리뷰 본문·바인딩 해시 모두 git 인덱스에서 — "리뷰 대상 = 바인딩 대상"(결정#3, Codex P2). 누락 문서는 각 함수가 fail-closed.
     designDocs = readDesignDocsFromIndex(ticketRel, git, cfg.designDocs)
     designHash = captureDesignBinding(ticketRel, git, cfg.designDocs).designHash
+    // REQ-2026-031 B-1: 같은 인덱스에서 문서별 blob OID도 뽑아 둔다(승인 시 processResponse가 baseline에 저장).
+    designDocBlobs = captureDesignDocBlobs(ticketRel, git, cfg.designDocs)
+    // REQ-2026-033 B-2a: design **재리뷰**(baseline 있음)면 delta 표시. 이 분기 안이라 phase는 구조적으로 delta 불가(kind 격리).
+    // 게이트는 hasDesignBaseline이지 changed 수가 아니다 — 변경 0(baseline==current)이어도 delta 모드. persona는 안 바꾼다.
+    const baseline = state.design_baseline
+    if (hasDesignBaseline(state) && baseline) designDelta = computeDesignDelta(baseline, designDocBlobs)
   } else {
     stagedDiff = git(['diff', '--cached'])
   }
+  // REQ-2026-034 B-2b: delta 모드(designDelta 설정 = design + baseline)면 persona에 delta 계약을 얹는다.
+  // 이 effectivePersona **하나**를 프롬프트와 review-call 로그 policy_version 양쪽에 흘린다(단일 배선, 032 r02·r03).
+  // designDelta는 B-2a에서 design 전용이므로 phase·full은 base 그대로(kind 격리 구조적 재사용, 032 r06-2).
+  const effectivePersona = applyDeltaPersona(persona, designDelta !== undefined)
   const blockedTarget = buildBlockedReviewTarget({
     kind: opts.kind,
     phaseId,
@@ -1272,7 +1866,7 @@ export function main(argv: string[] = process.argv.slice(2)): void {
     previousFindingsToClose: buildPreviousFindingsBlock(state, opts.kind, phaseId),
   }
   const prompt = assembleReviewPrompt({
-    persona,
+    persona: effectivePersona, // REQ-2026-034 B-2b: delta면 base+계약(null이면 계약 단독), 아니면 base 그대로.
     handoff,
     reviewContext,
     reviewBaseSha,
@@ -1280,6 +1874,7 @@ export function main(argv: string[] = process.argv.slice(2)): void {
     reviewKind: opts.kind,
     stagedDiff,
     designDocs,
+    designDelta, // REQ-2026-033 B-2a: design 재리뷰(baseline 有)일 때만 값. 없으면 full 플레인 블록(무회귀).
   })
   const previewPath = join(ticketDir, '.review-preview.txt')
   writeFileSync(previewPath, prompt, 'utf8')
@@ -1332,16 +1927,24 @@ export function main(argv: string[] = process.argv.slice(2)): void {
 
   // ReviewerAdapter 경유(Phase 3). exec/resume 분기·--output-last-message·thread 파싱은 어댑터가 담당.
   // resumeThreadId 있으면 resume(thread 상속), 없으면 exec(--sandbox read-only) → thread.started 파싱.
-  const { threadId } = callReviewer(reviewer, {
-    prompt,
-    schemaPath: cfg.schemaPathAbs,
-    resumeThreadId: isResume ? (state.codex_thread_id as string) : null,
-    cwd: cfg.root,
-    respPath,
-    // REQ-2026-013 P1: 리뷰 모델·추론강도 override를 config에서 채워 어댑터로 전달(null이면 어댑터가 `-c` 생략).
-    model: cfg.reviewModel,
-    reasoningEffort: cfg.reviewReasoningEffort,
-  })
+  // REQ-2026-027 D3: attempt를 **호출 직전**에 기록·writeState(withAttemptRecorded). 반환 state(afterAttempt)가
+  // 이후 모든 처리의 base다 — 호출 전 `state`를 다시 쓰면 최종 writeState가 attempt를 되돌린다(R9).
+  const { result: callRes, state: afterAttempt } = withAttemptRecorded(
+    { ticketDir, state, kind: opts.kind, phaseId, budget: cfg.reviewBudget },
+    () =>
+      callReviewer(reviewer, {
+        prompt,
+        schemaPath: cfg.schemaPathAbs,
+        resumeThreadId: isResume ? (state.codex_thread_id as string) : null,
+        cwd: cfg.root,
+        respPath,
+        // REQ-2026-013 P1: 리뷰 모델·추론강도 override를 config에서 채워 어댑터로 전달(null이면 어댑터가 `-c` 생략).
+        model: cfg.reviewModel,
+        reasoningEffort: cfg.reviewReasoningEffort,
+      }),
+  )
+  const { threadId } = callRes
+  state = afterAttempt // 이후 baseArgs·finalState의 base
 
   // 사후 리뷰어 무수정 검증: worktree 절대검사 + index(staged tree OID) 불변 (content 기반)
   const postDirty = findUnstagedOrUntracked(gitStatusEntries(), SCRATCH, ticketRel)
@@ -1364,10 +1967,13 @@ export function main(argv: string[] = process.argv.slice(2)): void {
     phaseId,
     designValid,
     schemaPath: cfg.schemaPathAbs,
+    designDocBlobs, // REQ-2026-031 B-1: design kind일 때만 값 있음. 승인+archive 분기에서만 baseline에 저장.
   }
   const probe = processResponse(baseArgs) // 아카이브 없이 검증(진짜 승인 여부·유효성)
   const decision = archiveDecision(probe, opts.kind) // null=아카이브 안 함(무효), 'approved'|'needs-fix'
   let archiveDesc: { path: string; sha256: string } | undefined
+  // REQ-2026-025 D4: 측정 로그의 archive_round. 무효 응답은 아카이브를 남기지 않으므로 null로 남는다.
+  let archiveRound: number | null = null
   if (decision) {
     try {
       const respBytes = readFileSync(respPath)
@@ -1375,9 +1981,11 @@ export function main(argv: string[] = process.argv.slice(2)): void {
       const responsesDir = join(ticketDir, 'responses')
       mkdirSync(responsesDir, { recursive: true })
       const existing = readdirSync(responsesDir).filter((n) => isArchiveFileName(n))
-      const archiveAbs = join(responsesDir, archiveFileName(base, nextArchiveRound(existing, base), decision))
+      const round = nextArchiveRound(existing, base)
+      const archiveAbs = join(responsesDir, archiveFileName(base, round, decision))
       writeFileSync(archiveAbs, respBytes)
       archiveDesc = { path: repoRel(archiveAbs), sha256: createHash('sha256').update(respBytes).digest('hex') }
+      archiveRound = round
     } catch {
       // 아카이브 기록 실패 — evidence 미부착(probe 결과 사용)
     }
@@ -1400,7 +2008,26 @@ export function main(argv: string[] = process.argv.slice(2)): void {
     blockedAt: approvedAt,
     compareHash,
   })
-  writeState(ticketDir, finalState)
+  // REQ-2026-027 D2·R6: approved만이 series 자동 종료 계기. needs-fix·blocked·invalid는 열린 채 둔다
+  // (그래야 A-2 상한이 의미를 갖는다). finalState는 afterAttempt 계보라 attempts 증가가 보존돼 있다.
+  const persistedState = outcome === 'approved' ? closeSeriesApproved(finalState, opts.kind, phaseId) : finalState
+  writeState(ticketDir, persistedState)
+
+  // REQ-2026-025 D4: 완료된 review call 1행 기록(측정 전용). `approvedAt`을 재사용해 같은 call의 다른
+  // 기록과 시각이 어긋나지 않게 한다 — 새 시계를 읽지 않는다. 실패는 삼켜진다(R8).
+  appendReviewCallLog(
+    cfg.root,
+    buildReviewCallLogRow({
+      ticketId: String(state.id ?? ''),
+      kind: opts.kind,
+      phaseId,
+      archiveRound,
+      outcome,
+      verdict: result.verdict,
+      timestamp: approvedAt,
+      policyVersion: reviewPolicyVersion(effectivePersona), // REQ-2026-034 B-2b: 전송 persona와 동일(단일 배선).
+    }),
+  )
 
   console.log(`[req:review-codex] ${outcomeLabel(outcome)}  thread=${threadId}`)
   console.log(