commitgate 0.9.6 → 0.9.9

package/scripts/req/review-codex.ts

@@ -32,12 +32,27 @@ import { pathToFileURL } from 'node:url'
 import { createHash } from 'node:crypto'
 import Ajv from 'ajv'
 import { loadConfig, packageRoot, buildScriptInvocation, DEFAULTS, type ResolvedConfig, type PackageManager, type ReviewBudget } from './lib/config'
+// REQ-2026-048 phase-1: 증거/매니페스트 공통 술어는 leaf `lib/evidence.ts`가 정본. 여기서 **재수출**해
+// 기존 import 경로(`from './review-codex'`)를 쓰던 호출부·테스트를 그대로 둔다.
+import { archiveBaseName, durableDesignEvidence, isValidIsoInstant } from './lib/evidence'
+export { archiveBaseName, isValidIsoInstant } from './lib/evidence'
+import { createEvidencePorts } from './lib/evidence-ports'
 import {
   createGitAdapter,
   createCodexReviewerAdapter,
+  ReviewCallError,
   type GitAdapter,
   type ReviewerAdapter,
 } from './lib/adapters'
+import {
+  ledgerPath,
+  appendLedgerRow,
+  serializeLedgerRow,
+  type LedgerRow,
+} from './lib/review-ledger'
+import { computeReviewSemanticIdentity } from './lib/review-target'
+import { closeProofPath, appendCloseProofRow, type CloseProofRow } from './lib/close-proof'
+import { summarizeLockfileDiff } from './lib/lockfile-diff'
 import { parseStatusZ, entryPaths, formatStatusEntry, STATUS_Z_ARGS, type StatusEntry } from './lib/porcelain'
 import { isArchiveFileName, isAllowedResponsesScratch, reviewScratchPaths } from './lib/scratch'
 
@@ -527,6 +542,12 @@ export interface ApprovalEvidence {
   review_base_sha: string
   approved_tree?: string
   design_hash?: string | null
+  /**
+   * 🔴 REQ-2026-052 DEC-B5(phase-3a2): **phase 전용** — 이 phase 승인 시점의 committed design 결속
+   *   (= `designValid` 통과값 `currentHash`). evidence-finalize가 manifest phase 행 `phase_design_ref`로 기록한다.
+   *   design kind·레거시(phaseId 없음)면 null.
+   */
+  phase_design_ref?: string | null
   codex_thread_id: string
   machine_schema_version: string
   status: string
@@ -579,6 +600,16 @@ export interface ReviewCallLogRow {
    */
   review_model: string | null
   review_reasoning_effort: string | null
+  /**
+   * REQ-2026-045(phase-2-observability): 재리뷰 장기화 원인분석용 관측성 지원 필드.
+   * 전부 **개수/해시만**(내용배제 유지). 진단·재구성 보조이며 **승인 증거가 아니다**(로그는 측정 전용·gitignore·fail-closed).
+   */
+  prompt_bytes: number
+  review_duration_ms: number
+  previous_findings_count: number
+  assembled_prompt_sha256: string
+  review_base_sha: string | null
+  review_tree: string | null
 }
 
 /**
@@ -600,6 +631,13 @@ export function buildReviewCallLogRow(args: {
   policyVersion: string
   reviewModel: string | null
   reviewReasoningEffort: string | null
+  // REQ-2026-045: 관측성 지원 필드(개수/해시). 값은 호출부가 계산해 주입(순수성 유지).
+  promptBytes: number
+  reviewDurationMs: number
+  previousFindingsCount: number
+  assembledPromptSha256: string
+  reviewBaseSha: string | null
+  reviewTree: string | null
 }): ReviewCallLogRow {
   return {
     ticket_id: args.ticketId,
@@ -613,9 +651,23 @@ export function buildReviewCallLogRow(args: {
     policy_version: args.policyVersion,
     review_model: args.reviewModel,
     review_reasoning_effort: args.reviewReasoningEffort,
+    prompt_bytes: args.promptBytes,
+    review_duration_ms: args.reviewDurationMs,
+    previous_findings_count: args.previousFindingsCount,
+    assembled_prompt_sha256: args.assembledPromptSha256,
+    review_base_sha: args.reviewBaseSha,
+    review_tree: args.reviewTree,
   }
 }
 
+/**
+ * REQ-2026-045: 조립 프롬프트의 **UTF-8 바이트** 수(내용 아님). JS `.length`(UTF-16 code unit)는 비-ASCII에서
+ * 바이트 수와 다르므로(`'가'.length===1`이지만 3바이트) `Buffer.byteLength(…,'utf8')`로 계산한다.
+ */
+export function assembledPromptBytes(prompt: string): number {
+  return Buffer.byteLength(prompt, 'utf8')
+}
+
 /**
  * 로그 append(측정 전용). **실패를 삼킨다**(R8).
  *
@@ -642,8 +694,12 @@ export interface ProcessResponseResult {
 export interface BlockedReviewTarget {
   review_kind: ReviewKind
   phase_id: string | null
-  review_base_sha: string
-  review_binding: string
+  /**
+   * 🔴 REQ-2026-052: **semantic identity**로 키잉한다(review-target.ts). 예전엔 `review_base_sha`+`review_binding`
+   *    (reviewTree/designHash)이었으나, pre-call 원장 커밋이 매 라운드 그 값을 흔들어 무한 재리뷰 차단이 깨졌다.
+   *    semantic identity는 `responses/` audit 변화에 불변이라 "같은 블록 리뷰 반복"을 정확히 감지한다.
+   */
+  semantic_identity: string
 }
 
 export interface BlockedReviewMarker extends BlockedReviewTarget {
@@ -783,6 +839,19 @@ export function buildPreviousFindingsBlock(state: WorkflowState, kind: ReviewKin
   ].join('\n')
 }
 
+/**
+ * REQ-2026-045: previousFindingsToClose로 전달되는 직전 same-target NEEDS_FIX finding 총수(측정 지원, 개수만).
+ * buildPreviousFindingsBlock과 동일 가드(교차-대상·승인 후 리셋)를 써서 프롬프트 블록과 정합한다. 값 = 스냅샷 shown + elided.
+ */
+export function previousFindingsCount(state: WorkflowState, kind: ReviewKind, phaseId: string | null): number {
+  const lr = state.last_review as LastReviewMarker | undefined
+  if (!lr || lr.outcome !== 'needs-fix') return 0
+  if (lr.review_kind !== kind || lr.phase_id !== phaseId) return 0
+  const snap = validatePersistedSnapshot(lr.findings, lr.elided_count)
+  if (!snap) return 0
+  return snap.findings.length + snap.elided_count
+}
+
 function sameLastReviewTarget(a: LastReviewMarker | undefined, kind: ReviewKind, phaseId: string | null, compareHash: string | null): boolean {
   return !!a && a.review_kind === kind && a.phase_id === phaseId && a.compare_hash === compareHash
 }
@@ -866,6 +935,21 @@ export interface SeriesRecord {
   closed_reason: 'approved' | 'human-resolution' | null
   // closed_reason='human-resolution'일 때만. 사람이 escalate된 series를 종료·대체로 결정한 손기록.
   human_resolution?: HumanResolution
+  // 🔴 REQ-2026-054(DEC-C3): pre-dispatch 실패로 **환불된** 회차 수(additive·기본 0). 예산 게이트가 보는 유효
+  //    회차 = attempts - refunded_attempts. attempts는 단조 유지(원장 자연키 충돌 회피)하고 여기서만 환불한다.
+  refunded_attempts?: number
+}
+
+/**
+ * 리뷰 호출 실패의 lifecycle 분류(REQ-2026-054·DEC-C2, 순수). 도달한 가장 먼 단계로 분류한다.
+ * 🔴 **오직 타입된 pre-dispatch만 환불 대상**(pre_dispatch_failed). 일반 오류·확인 전 dispatched는
+ *    dispatched_unknown으로 **차감**(fail-closed — "명백한 pre-dispatch만 무차감").
+ */
+export type DispatchFailureLifecycle = 'pre_dispatch_failed' | 'dispatched_unknown' | 'dispatch_confirmed'
+export function classifyDispatchFailure(err: unknown, dispatchConfirmed: boolean): DispatchFailureLifecycle {
+  if (err instanceof ReviewCallError && err.dispatchPhase === 'pre-dispatch') return 'pre_dispatch_failed'
+  if (dispatchConfirmed) return 'dispatch_confirmed' // thread_id 확보 후 실패 = dispatched 확실.
+  return 'dispatched_unknown' // 확인 전 dispatched·타입 없는 일반 오류(fail-closed 차감).
 }
 
 /** 사람의 series 종결 결정(REQ-2026-029 A-2b D1). accept-risk 없음(배분표 ④ — decision은 둘뿐). */
@@ -995,6 +1079,13 @@ export interface SuccessorOf {
   parent_attempts_total: number               // 부모 **모든** series attempts 합
   parent_replace_resolution: HumanResolution  // 부모의 replace 종결 손기록 그대로
   recorded_at: string                          // 자식 생성 시각(부모 값 아님)
+  /**
+   * 🔴 REQ-2026-052 phase-4(DEC-D2): 부모의 **replace 종결된 series_id**. 이 committed 값이 부모 티켓의
+   *    `series-terminal` close-proof 행을 **완전히 결정**하게 해 `req:reconstruct`가 소비할 수 있게 한다
+   *    (없으면 series_id 미결정 → 복원 불가). 구식 successor_of(이 필드 없음)는 backward-compat로 허용하되
+   *    reconstruct 대상이 아니다. **선택 필드**(기존 successor 티켓 무회귀).
+   */
+  parent_series_id?: string
 }
 
 /**
@@ -1016,6 +1107,8 @@ export function resolveSuccessorLineage(parentState: WorkflowState, parentReqId:
     parent_attempts_total: parentAttemptsTotal,
     parent_replace_resolution: replace.human_resolution,
     recorded_at: recordedAt,
+    // 🔴 phase-4(DEC-D2): replace 종결된 series_id를 lineage에 박아, 부모 series-terminal 행을 reconstruct가 완전 결정하게 한다.
+    parent_series_id: replace.series_id,
   }
 }
 
@@ -1033,7 +1126,24 @@ export type BudgetDecision =
  */
 export function openSeriesAttempts(state: WorkflowState, kind: ReviewKind, phaseId: string | null): number {
   const rec = openSeriesRecord(state, kind, phaseId)
-  return rec ? rec.attempts : 0
+  // 🔴 REQ-2026-054(DEC-C3): 유효 회차 = attempts - refunded_attempts. pre-dispatch 실패로 환불된 회차는
+  //    예산에서 뺀다. refunded_attempts 부재(옛 state)면 attempts 그대로(하위호환).
+  return rec ? Math.max(0, rec.attempts - (rec.refunded_attempts ?? 0)) : 0
+}
+
+/**
+ * pre-dispatch 실패 회차 환불(REQ-2026-054·DEC-C3, 순수). 열린 series의 `refunded_attempts +1`.
+ * 🔴 `attempts`는 건드리지 않는다 — 감소하면 재시도가 같은 `(series_id, attempt)`를 만들어 원장 자연키가
+ *    충돌(conflict)한다. 유효 회차는 `openSeriesAttempts`가 차감으로 낸다. 열린 series 없으면 no-op(방어).
+ */
+export function refundAttempt(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, refunded_attempts: (r.refunded_attempts ?? 0) + 1 } : r))
+  return { ...state, review_series: next }
 }
 
 /**
@@ -1049,22 +1159,8 @@ export function checkReviewBudget(openAttempts: number, budget: ReviewBudget): B
   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)
-}
+// `isValidIsoInstant`는 REQ-2026-048 phase-1에서 `lib/evidence.ts`로 이동했다(매니페스트 검증과 공유하는
+// 술어라 leaf에 있어야 review-codex↔req-commit 순환이 생기지 않는다). 기존 import 경로 보존을 위해 re-export한다.
 
 /** 사람 예외 손기록(REQ-2026-028 D2). `user_commit_confirmed`와 같은 모양. */
 export interface ReviewExceptionConfirmed {
@@ -1112,10 +1208,156 @@ export function consumeReviewException(
  * **예산 게이트가 `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 } {
+/**
+ * 원장 1행 append(REQ-2026-051 D5·D6). 티켓 `responses/review-ledger.jsonl`에 쓴다.
+ *
+ * 🔴 **두 실패를 분리한다**(phase-2 리뷰 P1 — D5와 D6이 뭉개지면 안 된다):
+ *
+ *   1. **기존 원장 읽기·파싱·검증 실패 = 전파(fail-closed, D5).** 기존 본문이 파싱 불가(잘린 JSONL)이거나
+ *      같은 자연키에 다른 내용이 오면 `appendLedgerRow`가 `conflict`를 낸다. `readFileSync` 자체의 오류도
+ *      마찬가지다. 이것들은 **감사 원장의 무결성 손상**이므로 조용히 진행하면 D5 위반이다 — throw한다.
+ *      호출자(attempt-opened)가 외부 호출 **전**에 이걸 부르므로, 손상된 원장은 리뷰를 시작조차 못 한다
+ *      (D10 pre-review clean-tree 게이트와 같은 자리·같은 태도).
+ *
+ *   2. **새 행 쓰기 실패 = 삼킴(D6).** 읽기·검증이 통과했는데 mkdir/write가 실패하는 것은 순수한 I/O
+ *      문제다. 이것이 승인·차단 판정이나 exit code를 뒤집으면 계약 위반이다(측정 로그 R8과 같은 취지).
+ *      경고만 내고 판정은 그대로 둔다.
+ *
+ * 정상 경로에서 attempt-opened가 무결성을 확인하고 우리가 유효한 행 하나만 append하므로, attempt-closed
+ * 시점의 재검증은 (협조적 단일 worktree 전제에서) 통과한다 — closed에서 전파가 실제로 발화하는 것은
+ * "일어나선 안 될" 손상뿐이고, 그때는 크게 실패하는 편이 옳다.
+ */
+export function appendLedgerRowToDisk(root: string, ticketRel: string, row: LedgerRow): void {
+  const abs = join(root, ledgerPath(ticketRel))
+  // ── 읽기·검증 단계(D5 — 전파) ──
+  const existing = existsSync(abs) ? readFileSync(abs, 'utf8') : '' // readFileSync 오류는 전파(무결성 신호)
+  const r = appendLedgerRow(existing, row)
+  if (r.outcome === 'conflict')
+    throw new Error(`리뷰 원장 무결성 실패(fail-closed): ${r.problems.join('; ')}`)
+  if (r.outcome === 'duplicate') return // 재실행 멱등(no-op)
+  // ── 쓰기 단계(D6 — 삼킴) ──
+  try {
+    mkdirSync(dirname(abs), { recursive: true })
+    writeFileSync(abs, r.content, 'utf8')
+  } catch (err) {
+    console.warn(`[req:review-codex] ⚠️ 리뷰 원장 쓰기 실패(판정에는 영향 없음): ${err instanceof Error ? err.message : String(err)}`)
+  }
+}
+
+/**
+ * 🔴 **pre-call ledger-only 커밋**(REQ-2026-052 DEC-A4·A6 step 4). `attempt-opened`를 외부 호출 **전에**
+ *    HEAD에 durable하게 만든다 — process가 죽어도 "예산 사용·미확정 호출"이 HEAD에서 관측된다(요구 #1).
+ *
+ * 🔴 **pathspec 커밋 — 원장 경로만**: `git commit -- <ledger>`는 워킹트리의 원장만 커밋하고, 인덱스에
+ *    staged된 design 문서·phase 코드는 **건드리지 않는다**(그대로 staged 유지). 그래서 리뷰 대상 binding
+ *    (reviewTree)이 커밋 후에도 보존된다. `git add -- <ledger>`로 먼저 스테이징(1라운드 untracked 대응).
+ *
+ * 🔴 **fail-closed**: 커밋 실패(훅 등)면 throw — opened가 durable하지 않은 채 외부 호출하면 요구 위반이다.
+ *    실패는 **외부 호출 전**에 전파된다(호출은 아직 안 일어났다).
+ */
+/**
+ * close proof 1행 append(REQ-2026-052). 원장의 `appendLedgerRowToDisk`와 같은 규칙:
+ * 읽기·검증 손상은 **전파**(fail-closed·D5), 쓰기 실패는 **삼킴**(D6). 멱등(duplicate=no-op).
+ */
+export function appendCloseProofRowToDisk(root: string, ticketRel: string, row: CloseProofRow): void {
+  const abs = join(root, closeProofPath(ticketRel))
+  const existing = existsSync(abs) ? readFileSync(abs, 'utf8') : ''
+  const r = appendCloseProofRow(existing, row)
+  if (r.outcome === 'conflict') throw new Error(`close proof 무결성 실패(fail-closed): ${r.problems.join('; ')}`)
+  if (r.outcome === 'duplicate') return
+  try {
+    mkdirSync(dirname(abs), { recursive: true })
+    writeFileSync(abs, r.content, 'utf8')
+  } catch (err) {
+    console.warn(`[req] ⚠️ close proof 쓰기 실패(판정에는 영향 없음): ${err instanceof Error ? err.message : String(err)}`)
+  }
+}
+
+/**
+ * 🔴 REQ-2026-052: 부모 티켓의 replace/human-resolution 종결을 **durable화**한다(요구 #3·test #3).
+ *
+ * `req:new --successor-of`가 부모의 replace 종결을 확인한 직후 호출된다. 부모 state(scratch)의
+ * `human-resolution` closed series들에 대해 `series-terminal` close proof를 append하고, close proof·ledger를
+ * **pathspec 커밋**한다(다른 staged 항목 미접촉). 멱등이라 재실행에 중복 없음.
+ *
+ * decision 매핑: `replace`→resolution `replace`, `terminate`→resolution `human-resolution`.
+ * @returns 커밋했으면 true(방출·커밋 발생), 이미 durable/대상 없음이면 false.
+ */
+export function durableParentSeriesTerminal(args: {
+  root: string
+  gitFn: GitFn
+  parentTicketRel: string
+  parentState: WorkflowState
+  parentId: string
+  nowIso: string
+}): boolean {
+  const terminals = readSeries(args.parentState).filter((s) => s.closed_reason === 'human-resolution')
+  if (terminals.length === 0) return false
+  let anyNew = false
+  for (const s of terminals) {
+    const resolution = s.human_resolution?.decision === 'replace' ? 'replace' : 'human-resolution'
+    const abs = join(args.root, closeProofPath(args.parentTicketRel))
+    const before = existsSync(abs) ? readFileSync(abs, 'utf8') : ''
+    appendCloseProofRowToDisk(args.root, args.parentTicketRel, {
+      ticket_id: args.parentId,
+      event: 'series-terminal',
+      series_id: s.series_id,
+      resolution,
+      phase_inventory: null,
+      design_ref: null,
+      at: args.nowIso,
+      reconstructed: false,
+      evidence_basis: null,
+    })
+    const after = existsSync(abs) ? readFileSync(abs, 'utf8') : ''
+    if (after !== before) anyNew = true
+  }
+  if (!anyNew) return false // 전부 이미 있음(멱등)
+  // close proof + ledger를 pathspec 커밋(부모 responses/ audit — 다른 staged 미접촉).
+  const cpRel = closeProofPath(args.parentTicketRel)
+  const ledgerRel = ledgerPath(args.parentTicketRel)
+  const paths = existsSync(join(args.root, ledgerRel)) ? [cpRel, ledgerRel] : [cpRel]
+  args.gitFn(['add', '--', ...paths])
+  args.gitFn(['commit', '-m', `chore(${args.parentId}): series-terminal close proof (replace/human-resolution)`, '--', ...paths])
+  return true
+}
+
+export function precallCommitLedgerRow(gitFn: GitFn, ticketRel: string, ticketId: string, attempt: AttemptInfo): void {
+  const ledgerRel = ledgerPath(ticketRel)
+  gitFn(['add', '--', ledgerRel]) // untracked/modified 원장을 스테이징(오직 이 경로).
+  gitFn([
+    'commit',
+    '-m',
+    `chore(${ticketId}): ledger attempt-opened ${attempt.series_id} #${attempt.attempt}`,
+    '--', // 🔴 pathspec 커밋 — 이 경로만. staged design/code는 인덱스에 그대로 남는다.
+    ledgerRel,
+  ])
+}
+
+export interface AttemptInfo {
+  /** 열린 series의 id. 원장 자연키의 일부다. */
+  series_id: string
+  /** 이 호출이 몇 번째 attempt인가(recordAttempt 이후 값). */
+  attempt: number
+  /** autoBudget 초과라 사람 예외를 소비했는지 — scratch에서 지워지는 유일한 사실(REQ-2026-051). */
+  exception_consumed: boolean
+}
+
+/**
+ * attempt 게이트+기록의 **앞부분만**(REQ-2026-052 phase-2에서 분리): terminal 가드 → 예산 → 예외 소비 →
+ * recordAttempt → writeState. 반환 `{state, attempt}`. **외부 호출도 원장 쓰기도 하지 않는다.**
+ *
+ * 왜 분리했나: B2는 attempt 기록 **후, 외부 호출 전**에 원장 opened를 커밋하고 **그 다음에** approval binding을
+ * 캡처해야 한다(DEC-A6). 그러려면 "기록"과 "호출" 사이에 커밋·캡처 단계가 들어간다. `withAttemptRecorded`는
+ * 이 함수 + onAttemptOpened + call로 그대로 재조립돼 기존 계약·테스트를 보존한다.
+ */
+export function gateAndRecordAttempt(ctx: {
+  ticketDir: string
+  state: WorkflowState
+  kind: ReviewKind
+  phaseId: string | null
+  budget: ReviewBudget
+}): { state: WorkflowState; attempt: AttemptInfo } {
   // REQ-2026-029 D2: terminal 가드 — 예산 게이트보다 **앞**. human-resolution으로 종결된 키는 예산을 볼
   // 필요도 없이 막는다(배분표 ③). 가드 없으면 recordAttempt가 새 series(0회)를 열어 예산이 리셋된다.
   if (isSeriesKeyTerminal(ctx.state, ctx.kind, ctx.phaseId))
@@ -1140,8 +1382,41 @@ export function withAttemptRecorded<T>(
   }
   const state = recordAttempt(gated, ctx.kind, ctx.phaseId)
   writeState(ctx.ticketDir, state) // 호출 **전** 영속 — throw해도 남는다
+  const opened = openSeriesRecord(state, ctx.kind, ctx.phaseId)
+  const info: AttemptInfo = {
+    series_id: opened?.series_id ?? '',
+    attempt: opened?.attempts ?? 0,
+    exception_consumed: decision.kind === 'needs-exception',
+  }
+  return { state, attempt: info }
+}
+
+export function withAttemptRecorded<T>(
+  ctx: {
+    ticketDir: string
+    state: WorkflowState
+    kind: ReviewKind
+    phaseId: string | null
+    budget: ReviewBudget
+    /**
+     * attempt 확정·영속 **직후, 외부 호출 직전**에 불린다(REQ-2026-051 D2 — `attempt-opened`).
+     * 🔴 **여기서 던진 예외는 전파된다**(외부 호출 전에). `appendLedgerRowToDisk`가 쓰기 실패는 이미
+     *    삼키므로, 여기까지 올라오는 예외는 **원장 무결성 손상**뿐이다 — 손상된 감사 원장 위에서 리뷰를
+     *    시작하지 않는다(D5 fail-closed, D10 pre-review 게이트와 같은 자리).
+     */
+    onAttemptOpened?: (info: AttemptInfo) => void
+  },
+  call: () => T,
+): { result: T; state: WorkflowState; attempt: AttemptInfo } {
+  const { state, attempt: info } = gateAndRecordAttempt(ctx)
+  // 🔴 원장 `attempt-opened`도 **호출 전**에 남는다 — 그래야 호출이 실패해 완료 기록이 없는 attempt가
+  //    "예산은 깎였는데 완료되지 않은 호출"로 관측된다(REQ-2026-051 요구사항 #1).
+  //    🔴 **여기서 삼키지 않는다**(phase-2 리뷰 P1). `appendLedgerRowToDisk`가 이미 쓰기 실패는 삼키고
+  //    읽기·검증 손상만 throw한다(D5/D6 분리). 그 throw는 **외부 호출 전에 전파**되어야 손상된 원장이
+  //    리뷰를 시작조차 못 한다(D10 pre-review 게이트와 같은 자리). 여기서 catch하면 그 fail-closed가 죽는다.
+  ctx.onAttemptOpened?.(info)
   const result = call() // throw면 그대로 전파(기록은 이미 선행)
-  return { result, state }
+  return { result, state, attempt: info }
 }
 
 /** 같은 `(kind, phase_id)`의 열린 series record(없으면 undefined). series_id를 재구성하지 않고 직접 얻는다. */
@@ -1302,6 +1577,8 @@ export function processResponse(args: {
   threadId: string
   kind?: ReviewKind
   designHash?: string | null
+  /** 🔴 REQ-2026-052 DEC-B5: phase 승인 시점의 committed design 결속(designValid 통과값). phase evidence에 핀. */
+  phaseDesignRef?: string | null
   phaseId?: string | null
   designValid?: boolean
   schemaPath?: string
@@ -1396,6 +1673,7 @@ export function processResponse(args: {
       binding,
       phaseId: args.phaseId ?? null,
       designHash: null,
+      phaseDesignRef: args.phaseDesignRef ?? null, // REQ-2026-052 DEC-B5: 승인 시점 design 결속 핀
       threadId,
       archive: args.archive,
       approvedAt: args.approvedAt ?? new Date().toISOString(),
@@ -1479,24 +1757,28 @@ export function resolveReviewOutcome(args: {
 export function buildBlockedReviewTarget(args: {
   kind: ReviewKind
   phaseId: string | null
-  binding: Binding
-  designHash?: string | null
+  /** REQ-2026-052: semantic identity(review-target.ts). 원장 커밋에 불변인 리뷰 대상 정체성. */
+  semanticIdentity: string
 }): BlockedReviewTarget {
   return {
     review_kind: args.kind,
     phase_id: args.kind === 'phase' ? args.phaseId ?? null : null,
-    review_base_sha: args.binding.reviewBaseSha,
-    review_binding: args.kind === 'design' ? args.designHash ?? args.binding.reviewTree : args.binding.reviewTree,
+    semantic_identity: args.semanticIdentity,
   }
 }
 
+/**
+ * 🔴 REQ-2026-052: `semantic_identity`로 비교한다. 구형 marker(이 필드가 없음 — pre-052)는 `a.semantic_identity`가
+ *    `undefined`라 어떤 identity와도 불일치 → **재판정**(short-circuit 안 함 → 한 번 신선 리뷰 → 새 marker 기록).
+ *    구형 marker를 새 identity와 같다고 **추정하지 않는다**(사용자 constraint 3).
+ */
 function sameBlockedReviewTarget(a: BlockedReviewMarker | undefined, b: BlockedReviewTarget): boolean {
   return (
     !!a &&
+    typeof a.semantic_identity === 'string' && // 구형 marker(undefined) → false → 재판정
     a.review_kind === b.review_kind &&
     a.phase_id === b.phase_id &&
-    a.review_base_sha === b.review_base_sha &&
-    a.review_binding === b.review_binding
+    a.semantic_identity === b.semantic_identity
   )
 }
 
@@ -1573,10 +1855,8 @@ function escapeRegExp(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
 
-/** 아카이브 base(round namespace): design은 'design'(phaseId 무시), phase는 phaseId(없으면 'phase'=레거시). */
-export function archiveBaseName(kind: ReviewKind, phaseId: string | null): string {
-  return kind === 'design' ? 'design' : phaseId && phaseId.length > 0 ? phaseId : 'phase'
-}
+// `archiveBaseName`도 같은 이유로 `lib/evidence.ts`로 이동(아래 re-export). 아카이브 이름 규칙은
+// 매니페스트 검증(`validateManifest`)과 stage 목록(`expectedArchivePaths`)이 공유하는 계약이다.
 
 /** 아카이브 파일명 — r 2자리 zero-pad. */
 export function archiveFileName(base: string, round: number, status: 'approved' | 'needs-fix'): string {
@@ -1607,11 +1887,13 @@ export function buildApprovalEvidence(args: {
   binding: Binding
   phaseId: string | null
   designHash: string | null
+  /** 🔴 REQ-2026-052 DEC-B5: phase 승인의 design 결속(승인 시점 committed design 참조). design kind면 무시. */
+  phaseDesignRef?: string | null
   threadId: string
   archive: { path: string; sha256: string }
   approvedAt: string
 }): ApprovalEvidence {
-  const { kind, verdict, binding, phaseId, designHash, threadId, archive, approvedAt } = args
+  const { kind, verdict, binding, phaseId, designHash, phaseDesignRef, threadId, archive, approvedAt } = args
   const ev: ApprovalEvidence = {
     response_path: archive.path,
     response_sha256: archive.sha256,
@@ -1624,7 +1906,10 @@ export function buildApprovalEvidence(args: {
     commit_approved: verdict.commit_approved ?? '',
     approved_at: approvedAt,
   }
-  return kind === 'design' ? { ...ev, design_hash: designHash ?? null } : { ...ev, approved_tree: binding.reviewTree }
+  // REQ-2026-052 DEC-B5: phase 승인엔 design 결속(phase_design_ref)을 함께 핀한다. design 행엔 넣지 않는다(kind 격리).
+  return kind === 'design'
+    ? { ...ev, design_hash: designHash ?? null }
+    : { ...ev, approved_tree: binding.reviewTree, phase_design_ref: phaseDesignRef ?? null }
 }
 
 /**
@@ -1761,6 +2046,12 @@ export function callReviewer(
     respPath: string
     model: string | null
     reasoningEffort: string | null
+    /**
+     * 🔴 REQ-2026-054(DEC-C1): thread_id **파싱 성공 즉시**(respPath 기록 前) 호출된다 — 호출자가 dispatch
+     *    확인 시점을 정확히 안다. 그래야 thread_id 확보 **후** respPath I/O 실패도 dispatch_confirmed로 분류된다
+     *    (반환 후에만 알면 이 경로가 dispatched_unknown으로 오분류됨).
+     */
+    onDispatchConfirmed?: (threadId: string) => void
   },
 ): { threadId: string } {
   const { lastMessage, threadId } = rv.review({
@@ -1771,7 +2062,9 @@ export function callReviewer(
     model: opts.model,
     reasoningEffort: opts.reasoningEffort,
   })
-  if (!threadId) throw new Error('thread_id 파싱 실패 (codex exec --json에 thread.started 없음)')
+  // thread_id 없음 = codex는 실행됐으나(exit 0) 출력이 무효 = dispatched(차감), pre-dispatch 아님.
+  if (!threadId) throw new ReviewCallError('dispatched', 'thread_id 파싱 실패 (codex exec --json에 thread.started 없음)')
+  opts.onDispatchConfirmed?.(threadId) // 🔴 respPath 기록 前 — 이후 I/O 실패도 dispatch_confirmed.
   writeFileSync(opts.respPath, lastMessage, 'utf8')
   return { threadId }
 }
@@ -1816,7 +2109,8 @@ function mainImpl(argv: string[], opts2?: { reviewer?: ReviewerAdapter }): void
   const handoffPath = opts.handoff ? resolve(opts.handoff) : cfg.handoffPathAbs
   const handoff = handoffPath && existsSync(handoffPath) ? readFileSync(handoffPath, 'utf8') : null
 
-  const { reviewBaseSha, reviewTree } = captureGitBinding()
+  // 🔴 REQ-2026-052 DEC-A6: approval binding(captureGitBinding)은 여기서 캡처하지 않는다 — pre-call 원장
+  //    커밋 **후**에 캡처해야 reviewBaseSha/reviewTree가 실제 post-commit 값이 된다(DRY-RUN·LIVE 각 분기에서).
   const branch = git(['rev-parse', '--abbrev-ref', 'HEAD'])
   const ticketRel = relative(cfg.root, ticketDir).replace(/\\/g, '/')
 
@@ -1827,6 +2121,10 @@ function mainImpl(argv: string[], opts2?: { reviewer?: ReviewerAdapter }): void
 
   // 추적 phase(phaseId)는 유효 design 승인(D13 동일: design_approved + freshness) 전제.
   let designValid = false
+  // 🔴 REQ-2026-052 DEC-B5: designValid가 참일 때의 currentHash = 이 phase가 결속된 committed design 참조.
+  //    승인 시 phase evidence(phase_design_ref)에 핀한다. designValid=false면 아래(step 2a)에서 fail-closed라
+  //    finalize에 도달하지 않으므로 null로 남아도 안전.
+  let phaseDesignRef: string | null = null
   if (phaseId) {
     const approvedHash = typeof state.design_approved_hash === 'string' ? state.design_approved_hash : null
     let currentHash: string | null = null
@@ -1836,6 +2134,7 @@ function mainImpl(argv: string[], opts2?: { reviewer?: ReviewerAdapter }): void
       currentHash = null
     }
     designValid = state.design_approved === true && approvedHash !== null && approvedHash === currentHash
+    if (designValid) phaseDesignRef = currentHash
   }
 
   // kind별 권위 아티팩트: phase=staged diff, design=설계 문서 00/01/02 + design 바인딩 해시(결정#3·#4).
@@ -1855,42 +2154,56 @@ function mainImpl(argv: string[], opts2?: { reviewer?: ReviewerAdapter }): void
     const baseline = state.design_baseline
     if (hasDesignBaseline(state) && baseline) designDelta = computeDesignDelta(baseline, designDocBlobs)
   } else {
-    stagedDiff = git(['diff', '--cached'])
+    // REQ-2026-056: lockfile diff는 프롬프트에서 요약(전문 opt-in = cfg.lockfilePromptFull). 🔴 프롬프트 문자열만
+    // 바꾼다 — 바인딩(reviewTree = git write-tree)은 전체 index라 무영향(승인은 여전히 전체 lockfile 결속).
+    stagedDiff = summarizeLockfileDiff(git(['diff', '--cached']), { full: cfg.lockfilePromptFull })
   }
   // 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,
-    binding: { reviewBaseSha, reviewTree },
-    designHash,
-  })
 
-  const reviewContext: ReviewContext = {
-    branch,
-    reviewBaseSha,
-    reviewTree,
-    phase: state.phase,
-    // REQ-2026-013 P4: 직전 same-target NEEDS_FIX findings만 주입(교차-대상이면 null). 옛 무조건 previous_codex_result 제거.
-    previousFindingsToClose: buildPreviousFindingsBlock(state, opts.kind, phaseId),
-  }
-  const prompt = assembleReviewPrompt({
-    persona: effectivePersona, // REQ-2026-034 B-2b: delta면 base+계약(null이면 계약 단독), 아니면 base 그대로.
-    handoff,
-    reviewContext,
-    reviewBaseSha,
-    requestBody,
-    reviewKind: opts.kind,
-    stagedDiff,
-    designDocs,
-    designDelta, // REQ-2026-033 B-2a: design 재리뷰(baseline 有)일 때만 값. 없으면 full 플레인 블록(무회귀).
-  })
+  // ── REQ-2026-052 DEC-A6 step 1: semantic identity 후보(원장 커밋 **전**, binding 무관) ──
+  const semanticIdentity = computeReviewSemanticIdentity(ticketRel, git)
+  const isDurable = !isLegacyTicket(state) // pre-call 커밋은 durable 티켓만 — legacy는 기존 경로 그대로.
+
+  // blocked target = semantic identity 키잉(DEC-A5). base_sha/reviewTree가 아니라 원장-불변 정체성.
+  const blockedTarget = buildBlockedReviewTarget({ kind: opts.kind, phaseId, semanticIdentity })
+
+  // 프롬프트 블록 원천 — state 재할당(attempt 기록) **전** 원본에서 계산.
+  const previousFindingsBlock = buildPreviousFindingsBlock(state, opts.kind, phaseId)
+  const previousFindingsCountVal = previousFindingsCount(state, opts.kind, phaseId)
+  const originalPhase = state.phase
   const previewPath = join(ticketDir, '.review-preview.txt')
-  writeFileSync(previewPath, prompt, 'utf8')
+
+  // 실제 approval binding으로 프롬프트를 짓는 helper(DRY-RUN·LIVE 공유). reviewBaseSha/reviewTree는 호출 시점 실제값.
+  const buildPromptFor = (rbSha: string, rTree: string): string => {
+    const reviewContext: ReviewContext = {
+      branch,
+      reviewBaseSha: rbSha,
+      reviewTree: rTree,
+      phase: originalPhase,
+      // REQ-2026-013 P4: 직전 same-target NEEDS_FIX findings만 주입(교차-대상이면 null).
+      previousFindingsToClose: previousFindingsBlock,
+    }
+    return assembleReviewPrompt({
+      persona: effectivePersona, // REQ-2026-034 B-2b: delta면 base+계약(null이면 계약 단독), 아니면 base 그대로.
+      handoff,
+      reviewContext,
+      reviewBaseSha: rbSha,
+      requestBody,
+      reviewKind: opts.kind,
+      stagedDiff,
+      designDocs,
+      designDelta, // REQ-2026-033 B-2a: design 재리뷰(baseline 有)일 때만 값. 없으면 full 플레인 블록(무회귀).
+    })
+  }
 
   if (!opts.run) {
+    // ── DRY-RUN: binding 캡처(커밋 없음) → 프롬프트 → 출력 → return ──
+    const { reviewBaseSha, reviewTree } = captureGitBinding()
+    const prompt = buildPromptFor(reviewBaseSha, reviewTree)
+    writeFileSync(previewPath, prompt, 'utf8')
     console.log('[req:review-codex] DRY-RUN (--run 지정 시 라이브 호출)')
     console.log(
       `  ticket=${ticketDir}  REQ=${state.id} phase=${state.phase} branch=${branch} kind=${opts.kind} phaseId=${phaseId ?? '(none)'}`,
@@ -1902,48 +2215,93 @@ function mainImpl(argv: string[], opts2?: { reviewer?: ReviewerAdapter }): void
     return
   }
 
-  // ── LIVE (단계 3B) ──
+  // ── LIVE (단계 3B) — DEC-A6 순서 고정 ──
   const respPath = join(ticketDir, 'codex-response.json')
   const repoRel = (abs: string) => relative(cfg.root, abs).replace(/\\/g, '/')
-  // 워크플로 도구가 쓰는 메타데이터(응답·프리뷰·state)는 리뷰 대상 아님 → exact 경로로 허용(precondition/무수정검증 제외).
-  // 특히 state.json은 직전 라운드 writeState로 unstaged가 되므로 resume(2회차) precondition 통과에 필수(4C e2e 발견).
   const SCRATCH = reviewScratchPaths(ticketRel)
-  // --fresh-thread면 codex_thread_id가 있어도 resume하지 않고 새 exec으로 시작(고착 스레드 회복).
-  // REQ-2026-013 P4: 재리뷰는 **항상 stateless**(새 스레드). resume 누적이 토큰·goalpost drift의 원인이었다(D5).
-  // `codex_thread_id`는 계속 저장하되(후속 resume opt-in REQ용) resume에 쓰지 않는다. 연속성은 previous_findings_to_close로.
-  // `--fresh-thread`는 여전히 blocked 회로차단기 마커를 초기화한다(위 clearBlockedReview) — 그 회복 의미는 보존된다.
-  const isResume = false
+  const isResume = false // REQ-2026-013 P4: 재리뷰는 항상 stateless. codex_thread_id는 저장만.
 
-  // Phase 4: 추적 phase는 유효 design 승인 전제(D13 동일) — 미충족 시 호출 전 fail-closed(불필요 codex 호출 방지).
+  // DEC-A6 step 2a: phase는 유효 design 승인 전제(D13 동일) — 미충족 시 호출·커밋·기록 전 fail-closed.
   if (phaseId && !designValid)
     throw new Error(
       'phase 리뷰 전 유효 design 승인 필요(design_approved=true + 현재 00/01/02 해시 일치) — 설계 재승인 후 진행하세요.',
     )
 
-  // D10 precondition: 리뷰 전 워킹트리는 staged + 스크래치만 (사후 무수정 검증의 전제 — Codex P1).
-  // A2: ticketRel 전달 → 직전 라운드 untracked 아카이브(responses/)는 스크래치 허용, tracked 변조·approvals.jsonl은 flag.
+  // DEC-A6 step 2b: D10 pre-review 가드(사후 무수정 검증의 전제).
   const preDirty = findUnstagedOrUntracked(gitStatusEntries(), SCRATCH, ticketRel)
   if (preDirty.length)
     throw new Error(
       `리뷰 전 워킹트리에 unstaged/untracked 존재(D10) — 의도 변경은 git add, 그 외 정리 필요:\n  ${preDirty.map(formatStatusEntry).join('\n  ')}`,
     )
 
+  // 🔴 DEC-A6 step 2c: blocked short-circuit — **커밋·attempt 기록·예산 소비·외부 호출보다 먼저**.
+  //    같은 semantic target이 이미 blocked면 그 넷 중 어느 것도 일어나지 않는다(사용자 불변식).
   if (shouldShortCircuitBlockedReview(state, blockedTarget)) {
-    console.error('[req:review-codex] BLOCKED  repeated blocked result for the same review binding')
-    console.error('  Codex will not be called again for this unchanged target. Change the staged binding or escalate.')
+    console.error('[req:review-codex] BLOCKED  repeated blocked result for the same review target (semantic identity)')
+    console.error('  Codex will not be called again for this unchanged target. Change the staged review target or escalate.')
     process.exit(reviewOutcomeExitCode('blocked'))
   }
 
-  console.warn(`⚠️  codex 실제 호출 (${isResume ? 'resume' : 'exec'}) — 호출 1회 발생 (DEC-WF-026: 호출 직전 확인)`)
+  // DEC-A6 step 3: 예산/예외 gate + attempt-opened 기록(state.json scratch). 반환 state가 이후 base(R9).
+  const { state: afterAttempt, attempt: attemptInfo } = gateAndRecordAttempt({
+    ticketDir,
+    state,
+    kind: opts.kind,
+    phaseId,
+    budget: cfg.reviewBudget,
+  })
+  state = afterAttempt
+
+  // DEC-A6 step 4: 원장 attempt-opened append + pre-call ledger-only commit(durable 티켓만·fail-closed).
+  //   opened 행의 prompt_sha256은 **null** — 프롬프트는 아직 안 지었다(binding이 이 커밋 뒤라야 확정).
+  //   순환의존을 끊는다: prompt_sha256은 나중에 attempt-closed 행에만 채운다.
+  appendLedgerRowToDisk(cfg.root, ticketRel, {
+    ticket_id: String(state.id ?? ''),
+    review_kind: opts.kind,
+    phase_id: phaseId,
+    series_id: attemptInfo.series_id,
+    attempt: attemptInfo.attempt,
+    event: 'attempt-opened',
+    lifecycle: null,
+    outcome: null,
+    exception_consumed: attemptInfo.exception_consumed,
+    prompt_sha256: null,
+    at: new Date().toISOString(),
+    reconstructed: false,
+  })
+  if (isDurable) precallCommitLedgerRow(git, ticketRel, String(state.id ?? ''), attemptInfo)
+
+  // DEC-A6 step 5: 실제 approval binding 캡처(pre-call 커밋 **후** — 실제 HEAD/전체 index tree).
+  const { reviewBaseSha, reviewTree } = captureGitBinding()
+
+  // DEC-A6 step 6: semantic identity 재계산 + pre-commit 값과 동일 assert(원장 커밋이 audit-only임을 검증).
+  const semanticIdentityAfter = computeReviewSemanticIdentity(ticketRel, git)
+  if (semanticIdentityAfter !== semanticIdentity)
+    throw new Error(
+      `pre-call 원장 커밋이 semantic identity를 바꿨다(audit-only 위반 — responses/ 밖 변경이 커밋에 딸림): ${semanticIdentity} → ${semanticIdentityAfter}`,
+    )
 
-  // ReviewerAdapter 경유(Phase 3). exec/resume 분기·--output-last-message·thread 파싱은 어댑터가 담당.
-  // resumeThreadId 있으면 resume(thread 상속), 없으면 exec(--sandbox read-only) → thread.started 파싱.
-  // 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, {
+  // DEC-A6 step 7: 프롬프트 조립(실제 binding) + 외부 호출.
+  const prompt = buildPromptFor(reviewBaseSha, reviewTree)
+  writeFileSync(previewPath, prompt, 'utf8')
+  const promptSha256 = createHash('sha256').update(prompt, 'utf8').digest('hex')
+  console.warn(`⚠️  codex 실제 호출 (${isResume ? 'resume' : 'exec'}) — 호출 1회 발생 (DEC-WF-026: 호출 직전 확인)`)
+  let reviewDurationMs = 0 // REQ-2026-045: callReviewer 소요(측정 전용).
+  // 🔴 REQ-2026-054(DEC-C4): dispatch 구간(callReviewer → 사후 tamper 검증 → 응답 파싱)을 try/catch로 감싼다.
+  //    실패 시 lifecycle을 분류해 **보상 attempt-closed**를 남기고(durable이면 pathspec 커밋), **명백한
+  //    pre-dispatch면 회차를 환불**한 뒤 **원본 오류를 re-throw**(fail-closed). `dispatchConfirmed`는 thread_id
+  //    확보 즉시(onDispatchConfirmed) true — 그 후 실패(respPath I/O·tamper·응답 파싱)는 dispatch_confirmed.
+  //    이 try는 outcome이 정해지기 **전**(probe)에서 끝난다 → 정상 경로의 attempt-closed(completed)와 상호배타.
+  let dispatchConfirmed = false
+  let threadId!: string
+  let approvedAt!: string
+  let baseArgs!: Parameters<typeof processResponse>[0]
+  let probe!: ReturnType<typeof processResponse>
+  try {
+    const callStartMs = Date.now()
+    let callRes: ReturnType<typeof callReviewer>
+    try {
+      callRes = callReviewer(reviewer, {
         prompt,
         schemaPath: cfg.schemaPathAbs,
         resumeThreadId: isResume ? (state.codex_thread_id as string) : null,
@@ -1952,35 +2310,76 @@ function mainImpl(argv: string[], opts2?: { reviewer?: ReviewerAdapter }): void
         // 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)
-  if (postDirty.length)
-    throw new Error(`리뷰 호출 후 워킹트리 변경(리뷰어 수정?):\n  ${postDirty.map(formatStatusEntry).join('\n  ')}`)
-  const afterTree = git(['write-tree'])
-  if (afterTree !== reviewTree)
-    throw new Error(`리뷰 호출 후 staged tree 변경(리뷰어 index 수정?): ${reviewTree} → ${afterTree}`)
-
-  // A2(D-016-1 · A2-P2-2): reviewer 무수정 검증 이후, **검증 먼저(아카이브 없이)** → archiveDecision으로 suffix/생략 결정 → 기록.
-  // 무효(kind 불일치·모순 등)면 아카이브를 남기지 않는다(round/finalize 오염 방지). 유효 NEEDS_FIX는 보존, 승인은 evidence 핀 부착.
-  const approvedAt = new Date().toISOString()
-  const baseArgs = {
-    ticketDir,
-    state,
-    binding: { reviewBaseSha, reviewTree },
-    threadId,
-    kind: opts.kind,
-    designHash,
-    phaseId,
-    designValid,
-    schemaPath: cfg.schemaPathAbs,
-    designDocBlobs, // REQ-2026-031 B-1: design kind일 때만 값 있음. 승인+archive 분기에서만 baseline에 저장.
+        onDispatchConfirmed: () => {
+          dispatchConfirmed = true
+        },
+      })
+    } finally {
+      reviewDurationMs = Date.now() - callStartMs
+    }
+    threadId = callRes.threadId
+
+    // 사후 리뷰어 무수정 검증: worktree 절대검사 + index(staged tree OID) 불변 (content 기반)
+    const postDirty = findUnstagedOrUntracked(gitStatusEntries(), SCRATCH, ticketRel)
+    if (postDirty.length)
+      throw new Error(`리뷰 호출 후 워킹트리 변경(리뷰어 수정?):\n  ${postDirty.map(formatStatusEntry).join('\n  ')}`)
+    const afterTree = git(['write-tree'])
+    if (afterTree !== reviewTree)
+      throw new Error(`리뷰 호출 후 staged tree 변경(리뷰어 index 수정?): ${reviewTree} → ${afterTree}`)
+
+    // A2(D-016-1 · A2-P2-2): reviewer 무수정 검증 이후, **검증 먼저(아카이브 없이)** → archiveDecision으로 suffix/생략 결정 → 기록.
+    // 무효(kind 불일치·모순 등)면 아카이브를 남기지 않는다(round/finalize 오염 방지). 유효 NEEDS_FIX는 보존, 승인은 evidence 핀 부착.
+    approvedAt = new Date().toISOString()
+    baseArgs = {
+      ticketDir,
+      state,
+      binding: { reviewBaseSha, reviewTree },
+      threadId,
+      kind: opts.kind,
+      designHash,
+      phaseDesignRef, // REQ-2026-052 DEC-B5: phase 승인 시점 design 결속(designValid 통과값)
+      phaseId,
+      designValid,
+      schemaPath: cfg.schemaPathAbs,
+      designDocBlobs, // REQ-2026-031 B-1: design kind일 때만 값 있음. 승인+archive 분기에서만 baseline에 저장.
+    }
+    probe = processResponse(baseArgs) // 아카이브 없이 검증(진짜 승인 여부·유효성)
+  } catch (err) {
+    // 🔴 DEC-C4 보상 경로. classifyDispatchFailure로 lifecycle 판정 → attempt-closed(invalid) 기록 → durable이면
+    //    원장 pathspec 커밋(best-effort) → pre-dispatch면 환불 → 원본 오류 re-throw.
+    const lifecycle = classifyDispatchFailure(err, dispatchConfirmed)
+    try {
+      appendLedgerRowToDisk(cfg.root, ticketRel, {
+        ticket_id: String(state.id ?? ''),
+        review_kind: opts.kind,
+        phase_id: phaseId,
+        series_id: attemptInfo.series_id,
+        attempt: attemptInfo.attempt,
+        event: 'attempt-closed',
+        lifecycle, // pre_dispatch_failed | dispatched_unknown | dispatch_confirmed
+        outcome: 'invalid', // 실패한 호출 — 유효 판정 없음.
+        exception_consumed: attemptInfo.exception_consumed,
+        prompt_sha256: null, // 실패 경로는 프롬프트 해시를 담지 않는다(opened와 동일).
+        at: new Date().toISOString(),
+        reconstructed: false,
+      })
+      if (isDurable) {
+        // 원장 modified가 남으면 다음 리뷰 D10이 막힌다 → attempt-opened와 동일 조건·기법으로 pathspec 커밋.
+        const ledgerRel = ledgerPath(ticketRel)
+        git(['add', '--', ledgerRel])
+        git(['commit', '-m', `chore(${String(state.id ?? '')}): ledger attempt-closed ${attemptInfo.series_id} #${attemptInfo.attempt} (${lifecycle})`, '--', ledgerRel])
+      }
+    } catch (compErr) {
+      // 보상 기록/커밋 실패는 삼킨다 — 원본 dispatch 오류가 전파돼야 한다(판정을 가리지 않는다).
+      console.warn(`[req:review-codex] ⚠️ 보상 attempt-closed 기록/커밋 실패(원본 오류 전파): ${compErr instanceof Error ? compErr.message : String(compErr)}`)
+    }
+    if (lifecycle === 'pre_dispatch_failed') {
+      // 🔴 명백한 pre-dispatch만 환불(유효 회차 -1 효과). attempts는 단조 유지 → 재시도가 원장 자연키 충돌 없음.
+      state = refundAttempt(state, opts.kind, phaseId)
+      writeState(ticketDir, state)
+    }
+    throw err // fail-closed — 실패는 실패(exit 비-0).
   }
-  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로 남는다.
@@ -2009,8 +2408,10 @@ function mainImpl(argv: string[], opts2?: { reviewer?: ReviewerAdapter }): void
   const responseSha256 = existsSync(respPath)
     ? createHash('sha256').update(readFileSync(respPath)).digest('hex')
     : null
-  // D6-2: req:next가 write-tree 없이 재계산할 수 있는 바인딩 해시. design=designHash, phase=인덱스 전체 해시.
-  const compareHash = opts.kind === 'design' ? designHash ?? null : captureIndexHash()
+  // 🔴 REQ-2026-052: compare_hash = **semantic identity**(design·phase 통일). pre-call 원장 커밋·evidence-finalize
+  //    양쪽 audit 변화에 불변이라, 방금 승인·내구화한 리뷰를 req:next G2가 stale로 오판하지 않는다.
+  //    read-only(ls-files) — req:next가 write-tree 없이 재계산 가능. semanticIdentity(step 6 assert 통과값)를 재사용.
+  const compareHash = semanticIdentity
   const { outcome, exitCode, finalState } = resolveReviewOutcome({
     result,
     kind: opts.kind,
@@ -2024,6 +2425,59 @@ function mainImpl(argv: string[], opts2?: { reviewer?: ReviewerAdapter }): void
   const persistedState = outcome === 'approved' ? closeSeriesApproved(finalState, opts.kind, phaseId) : finalState
   writeState(ticketDir, persistedState)
 
+  // REQ-2026-051 D2: 원장 `attempt-closed`. 🔴 **durableDesignEvidence 커밋보다 먼저** 써야 한다 —
+  // 아니면 design 승인 리뷰의 closed 행(outcome=approved, 가장 중요한 행)이 그 커밋에 실리지 못하고
+  // 미커밋으로 남는다(phase-3 e2e가 이 순서를 고정). 대응하는 `attempt-opened`가 이미 있고, 이 행이
+  // 없으면 그 attempt는 "완료되지 않은 호출"로 남는다(요구사항 #1). `approvedAt` 재사용(새 시계 안 읽음).
+  appendLedgerRowToDisk(cfg.root, ticketRel, {
+    ticket_id: String(state.id ?? ''),
+    review_kind: opts.kind,
+    phase_id: phaseId,
+    series_id: attemptInfo.series_id,
+    attempt: attemptInfo.attempt,
+    event: 'attempt-closed',
+    lifecycle: 'completed', // 이 REQ는 completed만 쓴다. 실패 분류는 후속 REQ 소관(D3).
+    outcome, // ReviewOutcome === LedgerOutcome. 캐스트하지 않는다 — 갈라지면 빌드가 깨져야 한다.
+    exception_consumed: attemptInfo.exception_consumed,
+    // 🔴 prompt_sha256은 opened가 아니라 closed에만 담는다(REQ-2026-052: opened는 프롬프트 확정 전에 커밋되므로).
+    prompt_sha256: promptSha256,
+    // 🔴 archive path·sha는 담지 않는다 — approvals.jsonl의 archive_inventory가 단일 출처다(phase-2 리뷰 P1).
+    at: approvedAt,
+    reconstructed: false,
+  })
+
+  // ── REQ-2026-048 phase-3: design 승인 evidence **자동 내구화**(DEC-3) ──
+  // 정상 승인 경로가 여기서 아카이브·매니페스트를 커밋한다 → 운영자가 `--finalize-design`을 따로 기억할
+  // 필요가 없다. 그 수동 단계가 잊히면 design 감사 증거가 커밋 이력에 **전혀 남지 않던** 것이 이 REQ의 원인이다.
+  //
+  // 🔴 **실패를 삼킨다 — 승인 판정·exit code를 바꾸지 않는다.** 기록 실패가 게이트 결정을 뒤집으면 그것이
+  //    계약 위반이다(측정 로그 R8과 같은 취지). 대신 복구 명령을 안내하고, 그 "승인됨·미커밋" 창은
+  //    `req:next`의 DONE 게이트(phase-4)가 잡는다. 멱등이라 재실행도 안전하다.
+  if (opts.kind === 'design' && outcome === 'approved') {
+    const dev = (persistedState.design_approval_evidence as ApprovalEvidence | undefined) ?? null
+    if (dev) {
+      const ticketRelForEvidence = repoRel(ticketDir)
+      try {
+        const r = durableDesignEvidence({
+          ticketId: String(persistedState.id ?? ''),
+          ticketRel: ticketRelForEvidence,
+          evidence: dev,
+          validPhaseIds: readPhases(persistedState).map((ph) => ph.id),
+          nowIso: approvedAt,
+          ports: createEvidencePorts(cfg.root, `${ticketRelForEvidence}/responses`),
+        })
+        if (r.outcome !== 'already-durable')
+          console.log('[req:review-codex] design 승인 증거를 커밋했습니다(아카이브·approvals.jsonl).')
+      } catch (err) {
+        console.warn(
+          `[req:review-codex] ⚠️ design 승인 증거 커밋 실패(승인 자체는 유효): ${err instanceof Error ? err.message : String(err)}
+` +
+            `   복구: ${buildScriptInvocation(cfg.packageManager, 'req:commit', [String(persistedState.id ?? ''), '--finalize-design', '--run']).join(' ')}`,
+        )
+      }
+    }
+  }
+
   // REQ-2026-025 D4: 완료된 review call 1행 기록(측정 전용). `approvedAt`을 재사용해 같은 call의 다른
   // 기록과 시각이 어긋나지 않게 한다 — 새 시계를 읽지 않는다. 실패는 삼켜진다(R8).
   appendReviewCallLog(
@@ -2040,6 +2494,13 @@ function mainImpl(argv: string[], opts2?: { reviewer?: ReviewerAdapter }): void
       // REQ-2026-043: codex에 흘러간 값(1942-1943)과 동일 원천. null=미핀(전역 상속).
       reviewModel: cfg.reviewModel,
       reviewReasoningEffort: cfg.reviewReasoningEffort,
+      // REQ-2026-045: 관측성 지원 필드(개수/해시 — 내용배제 유지, 승인 증거 아님).
+      promptBytes: assembledPromptBytes(prompt),
+      reviewDurationMs,
+      previousFindingsCount: previousFindingsCountVal,
+      assembledPromptSha256: createHash('sha256').update(prompt, 'utf8').digest('hex'),
+      reviewBaseSha,
+      reviewTree,
     }),
   )