commitgate 0.9.8 → 0.9.9

package/scripts/req/lib/evidence.ts

@@ -91,6 +91,16 @@ export interface ManifestEntry {
   review_base_sha: string
   approved_tree?: string
   design_hash?: string
+  /**
+   * 🔴 REQ-2026-052 DEC-B5(phase-3a2): **phase 전용** — 이 phase가 승인 시점에 결속된 committed design 참조
+   *   (= `captureDesignBinding().designHash`, design 행 `design_hash`와 동일 계산·값). dev-complete 완전성이
+   *   이 값 == 현재 committed design_ref인 phase 행만 산입한다(design-blind면 D1 검토분이 D2 완료에 샌다).
+   *
+   * **선택 필드**다: 부재(레거시·이 보정 이전 커밋분)해도 매니페스트 검증은 통과한다(무회귀). 단 durable 완료
+   *   판정에서는 부재를 **불산입(fail-closed)** — 검증의 관대함과 완료의 엄격함을 분리(`archive_inventory`와 동형).
+   *   design 행에는 **금지**(kind 격리). 미지정 시 키 자체를 넣지 않아 기존 phase 행과 바이트 동일.
+   */
+  phase_design_ref?: string
   approved_at: string
   consumed_at: string
   consumed_by_commit_sha: string
@@ -118,6 +128,7 @@ const MANIFEST_KEYS = new Set([
   'review_base_sha',
   'approved_tree',
   'design_hash',
+  'phase_design_ref', // REQ-2026-052 DEC-B5(선택 — phase 전용·부재해도 유효)
   'approved_at',
   'consumed_at',
   'consumed_by_commit_sha',
@@ -165,12 +176,20 @@ export function designEvidenceStagePaths(
   inventory: readonly ArchiveInventoryItem[],
   responsePath: string,
   ticketRel: string,
+  /**
+   * 리뷰 원장이 디스크에 **존재하는가**(REQ-2026-051 D7). 존재할 때만 pathspec에 합류시킨다 —
+   * 없는 경로를 넣으면 `commitPaths`가 실패해 승인 증거 커밋 **전체**가 무산된다(원장 때문에 승인
+   * 증거를 잃는 것은 본말전도다).
+   * 생략 가능: 기존 3-arg 호출부를 깨지 않는다.
+   */
+  ledgerExists = false,
 ): string[] {
   const dir = `${ticketRel.replace(/\\/g, '/').replace(/\/+$/, '')}/responses`
   const archives = [...inventory.map((i) => i.response_path), responsePath].filter(
     (p) => typeof p === 'string' && p.length > 0 && isConfinedArchivePath(p, ticketRel),
   )
-  return [...new Set([...archives, `${dir}/approvals.jsonl`])]
+  const tail = ledgerExists ? [`${dir}/approvals.jsonl`, `${dir}/review-ledger.jsonl`] : [`${dir}/approvals.jsonl`]
+  return [...new Set([...archives, ...tail])]
 }
 
 /** 인벤토리 항목의 형식 문제 목록(순수). 빈 배열 = 정상. `line N: ` 접두는 호출부가 붙인다. */
@@ -248,7 +267,11 @@ export function buildManifestEntry(
   const approvedTree = ev.approved_tree
   if (typeof approvedTree !== 'string' || !approvedTree)
     throw new Error('buildManifestEntry: phase evidence에 approved_tree 누락(fail-fast)')
-  return { ...base, approved_tree: approvedTree, ...inv }
+  // REQ-2026-052 DEC-B5: phase_design_ref(승인 시점 design 결속)가 있으면 phase 행에 포함. 미지정이면
+  // 키 자체를 넣지 않는다 — 레거시 phase 행과 바이트 동일(무회귀). durable 티켓은 designValid 게이트가
+  // 승인 전제라 정상 경로에서 항상 채워지고, 완료 판정이 이 값으로 design-bound 필터한다.
+  const pdr = typeof ev.phase_design_ref === 'string' && ev.phase_design_ref ? { phase_design_ref: ev.phase_design_ref } : {}
+  return { ...base, approved_tree: approvedTree, ...pdr, ...inv }
 }
 
 /** 매니페스트 한 줄 직렬화(JSONL): JSON + 끝 개행. 고정 키 순서라 deterministic. */
@@ -305,10 +328,15 @@ export function validateManifest(content: string, opts: { ticketRel: string; val
         problems.push(`line ${ln}: phase_id 비유효: ${String(e.phase_id)}`)
       if (typeof e.approved_tree !== 'string' || !GIT_OID_RE.test(e.approved_tree)) problems.push(`line ${ln}: approved_tree 비-OID`)
       if ('design_hash' in e) problems.push(`line ${ln}: phase entry에 design_hash 금지`)
+      // REQ-2026-052 DEC-B5: phase_design_ref는 **선택**(부재=레거시 무회귀). 있으면 64hex(design_hash와 동형).
+      if ('phase_design_ref' in e && (typeof e.phase_design_ref !== 'string' || !SHA256_RE.test(e.phase_design_ref)))
+        problems.push(`line ${ln}: phase_design_ref 비-64hex`)
     } else if (kind === 'design') {
       if (e.phase_id !== null) problems.push(`line ${ln}: design entry는 phase_id=null이어야`)
       if (typeof e.design_hash !== 'string' || !SHA256_RE.test(e.design_hash)) problems.push(`line ${ln}: design_hash 비-64hex`)
       if ('approved_tree' in e) problems.push(`line ${ln}: design entry에 approved_tree 금지`)
+      // REQ-2026-052 DEC-B5: kind 격리 — design 행에는 phase_design_ref 금지.
+      if ('phase_design_ref' in e) problems.push(`line ${ln}: design entry에 phase_design_ref 금지`)
     }
     // archive_inventory(REQ-2026-048 DEC-2): **선택** — 부재는 정상(기존 행 무회귀). 있으면 형식 검증.
     if ('archive_inventory' in e) {
@@ -371,6 +399,89 @@ export function findEvidenceRow(
   return null
 }
 
+// ─────────────────── 매니페스트 순수 파서 (REQ-2026-052 phase-3b: req-commit에서 이동) ──
+// req-commit(command)과 intake 스캔(leaf)이 같은 파서를 공유하도록 매니페스트 모델의 정본인 여기로 옮겼다.
+// req-commit이 기존 경로로 re-export한다(호출부 호환).
+
+/** 매니페스트(JSONL) 본문에서 안전하게 엔트리 배열을 뽑는다(파싱 불가 행은 건너뛴다 — 검증은 별도). */
+export function parseManifestEntries(content: string): Array<Record<string, unknown>> {
+  const out: Array<Record<string, unknown>> = []
+  for (const line of content.split('\n')) {
+    if (line.trim() === '') continue
+    try {
+      const o = JSON.parse(line)
+      if (o && typeof o === 'object' && !Array.isArray(o)) out.push(o as Record<string, unknown>)
+    } catch {
+      /* skip */
+    }
+  }
+  return out
+}
+
+/**
+ * 매니페스트에서 커밋된 **phase 증거**가 있는 phase id 집합(consumed phase 엔트리).
+ *
+ * 🔴 REQ-2026-052 DEC-B5(phase-3a2): `designRef`를 주면 **design-bound** — 그 phase 행의 `phase_design_ref`가
+ *   `designRef`와 **일치**하는 것만 산입한다. dev-complete 완전성이 이 필터를 써야 D1에서 검토된 phase가 D2
+ *   재승인 후 D2 완료 증명에 새어들지 않는다. `phase_design_ref` 부재 행(레거시·보정 이전)은 **불산입**(fail-closed).
+ *   `designRef` 미지정(하위호환)이면 결속 무관 전량(옛 동작) — 신규 완료 경로는 항상 designRef를 준다.
+ */
+export function evidencedPhaseIdsFromManifest(content: string, designRef?: string | null): string[] {
+  return parseManifestEntries(content)
+    .filter((e) => e.kind === 'phase' && typeof e.phase_id === 'string')
+    .filter((e) => (designRef == null ? true : e.phase_design_ref === designRef))
+    .map((e) => e.phase_id as string)
+}
+
+/** 매니페스트에서 커밋된 design 승인의 design_hash(가장 마지막 design 엔트리). 없으면 null. */
+export function designHashFromManifest(content: string): string | null {
+  const designs = parseManifestEntries(content).filter((e) => e.kind === 'design' && typeof e.design_hash === 'string')
+  return designs.length ? (designs[designs.length - 1]!.design_hash as string) : null
+}
+
+// ───────── phase 승인 archive 무결성 (REQ-2026-052 DEC-B6·phase-3b2) — 공유 leaf 모듈 ──
+
+export interface PhaseArchiveProblem {
+  phaseId: string
+  responsePath: string
+  reason: 'missing' | 'sha-mismatch'
+}
+
+/**
+ * 🔴 phase 승인 **archive blob 무결성** 검증(순수 + `headBlobSha256` 포트, DEC-B6). intake(`scanTicketIntake`)와
+ *    req:commit 발행 후 verifier(`verifyDevCompleteAtHead`)가 **이 한 모듈을 공유**한다 → 두 경로의 phase archive
+ *    규칙이 갈라질 수 없다(요구 #3).
+ *
+ * 각 phase manifest 행에 대해: `response_path` blob이 **HEAD에 존재**하고(`headBlobSha256` non-null) 그
+ * sha256이 `response_sha256`과 **일치**하는지 확인한다. archive를 삭제하면 `missing`, 바이트를 바꾸면
+ * `sha-mismatch` — 둘 다 archive 손상(corrupt)이다. manifest 행 형식(`response_path`/`response_sha256`)은 여기서
+ * 재검증하지 않는다(그건 `validateManifest` 몫) — 형식이 이미 통과한 행의 **blob 정합**만 본다.
+ *
+ * 🔴 **강한 정책(요구 #1 우선안)**: `onlyDesignRef`를 주지 않으면 **모든** phase 행을 검증한다(inventory 한정 아님).
+ *    감사 내구성상 재승인 이전 라운드 행의 archive까지 온전해야 한다. `onlyDesignRef` 지정 시 그 design_ref에
+ *    결속된 phase 행만(부분 검증 — 필요 시).
+ *
+ * 🔴 on-disk·워킹트리를 절대 읽지 않는다 — `headBlobSha256`(HEAD blob 바이트 sha)만. leaf라 git을 직접 모른다.
+ */
+export function verifyPhaseArchives(
+  content: string,
+  headBlobSha256: (repoRel: string) => string | null,
+  onlyDesignRef?: string | null,
+): PhaseArchiveProblem[] {
+  const problems: PhaseArchiveProblem[] = []
+  for (const e of parseManifestEntries(content)) {
+    if (e.kind !== 'phase' || typeof e.phase_id !== 'string' || e.phase_id === '') continue
+    if (onlyDesignRef != null && e.phase_design_ref !== onlyDesignRef) continue
+    const responsePath = typeof e.response_path === 'string' ? e.response_path : ''
+    const expectedSha = typeof e.response_sha256 === 'string' ? e.response_sha256 : ''
+    if (!responsePath || !expectedSha) continue // 형식 문제는 validateManifest가 corrupt로 잡는다(중복 판정 안 함).
+    const actual = headBlobSha256(responsePath)
+    if (actual === null) problems.push({ phaseId: e.phase_id, responsePath, reason: 'missing' })
+    else if (actual !== expectedSha) problems.push({ phaseId: e.phase_id, responsePath, reason: 'sha-mismatch' })
+  }
+  return problems
+}
+
 // ─────────────────────────── design evidence 내구화 (REQ-2026-048 DEC-3) ──
 
 /**
@@ -483,7 +594,11 @@ export function durableDesignEvidence(args: {
     ports.writeText(manifestRel, candidate)
   }
 
-  const stagePaths = designEvidenceStagePaths(inventory, ev.response_path, ticketRel)
+  // REQ-2026-051 D7: 원장이 있으면 같은 커밋에 싣는다. `readText`로 존재를 확인한다 — 포트 경계를
+  // 넘지 않고(fs 직접 접근 금지), 없으면 pathspec에 넣지 않아 커밋이 실패하지 않는다.
+  const ledgerRel = `${ticketRel.replace(/\\/g, '/').replace(/\/+$/, '')}/responses/review-ledger.jsonl`
+  const ledgerExists = ports.readText(ledgerRel) !== null
+  const stagePaths = designEvidenceStagePaths(inventory, ev.response_path, ticketRel, ledgerExists)
   // 🔴 가드는 **우리가 커밋할 경로**에만 건다 — index 전체가 아니다(phase-3 리뷰 P1).
   //    index 전체를 보면 설계 문서를 stage한 정상 승인 경로에서 항상 실패한다. pathspec 범위 커밋이라
   //    무관한 staged 변경은 애초에 이 커밋에 들어갈 수 없고, 커밋 후에도 index에 그대로 남는다.
@@ -628,6 +743,46 @@ export function verifyCommittedDesignEvidence(args: {
   return { durable: true, reason: 'design 승인 증거가 HEAD에 완비됨' }
 }
 
+// ───────── committed 증거 무결성 종합(design+phase) (REQ-2026-052 DEC-B7·phase-3b3) — 공유 deep 모듈 ──
+
+/**
+ * 🔴 durable 티켓의 **committed 증거 무결성 종합 판정**(design + phase, DEC-B7). intake(`scanTicketIntake`)와
+ *    req:commit 발행 후 verifier(`verifyDevCompleteAtHead`)가 **이 한 함수를 공유**한다(요구 #3) — 두 경로의
+ *    증거 무결성 규칙이 갈라질 수 없다. 호출자는 design·phase 검증 순서·세부 조건을 몰라도 된다(얕은 인터페이스 금지).
+ *
+ * 내부는 **기존 함수 재사용**(중복 규칙 없음):
+ *   - **design**: manifest에 design 행이 있으면 **`verifyCommittedDesignEvidence`**(REQ-2026-048 DONE 게이트)로
+ *     최신 design 승인 archive 존재·SHA + `archive_inventory` 전체(과거 needs-fix 포함) 존재·SHA + HEAD 집합 정합을
+ *     검증. `durable=false`면 무결성/완전성 실패.
+ *   - **phase**: **`verifyPhaseArchives`**(DEC-B6)로 모든 phase 행 archive 존재·SHA.
+ *
+ * 🔴 **불완전(incomplete) ≠ 손상(tampered)**: manifest에 **design 행이 없으면** design 무결성 검사 대상이 아니다
+ *    (대체된 미완 티켓·design 미승인은 손상이 아니라 미완 — 통과 가능, series-terminal). `designEvidenceComplete`은
+ *    needs-recovery 판정 입력(design 행 없으면 false = 미완).
+ *
+ * 🔴 **HEAD blob만** — on-disk·워킹트리·state.json을 판정 근거로 쓰지 않는다(포트 경유).
+ */
+export function verifyCommittedEvidenceIntegrity(args: {
+  ticketRel: string
+  manifestText: string | null
+  ports: Pick<EvidencePorts, 'headText' | 'headBlobSha256' | 'headArchivePaths'>
+}): { problems: string[]; designEvidenceComplete: boolean } {
+  const { ticketRel, manifestText, ports } = args
+  const problems: string[] = []
+  let designEvidenceComplete = false
+  if (manifestText === null) return { problems, designEvidenceComplete }
+  // design: design 행이 있을 때만 검사(없으면 손상 아님 — 불완전≠손상).
+  if (designHashFromManifest(manifestText) !== null) {
+    const d = verifyCommittedDesignEvidence({ ticketRel, ports })
+    designEvidenceComplete = d.durable
+    if (!d.durable) problems.push(`design 증거 무결성/완전성 실패: ${d.reason}`)
+  }
+  // phase: 모든 phase 행 archive 무결성.
+  for (const p of verifyPhaseArchives(manifestText, ports.headBlobSha256))
+    problems.push(`phase archive ${p.reason}: ${p.phaseId} (${p.responsePath})`)
+  return { problems, designEvidenceComplete }
+}
+
 /**
  * approvals.jsonl에 **이 evidence가** 이미 finalize된 엔트리가 있는지(순수, 멱등 finalize용).
  * ⚠️ B3-R2: consumed_by_commit_sha만으로는 부족 — 같은 source SHA를 쓰는 design-finalize row 등에 오인될 수 있음.

package/scripts/req/lib/intake.ts

@@ -0,0 +1,175 @@
+/**
+ * req:new intake gate (REQ-2026-052 phase-3b, DEC-C) — 새 REQ 생성 전, **HEAD-committed durable 증거만으로**
+ * 각 기존 티켓의 기본 상태를 파생해 미종결(developing/needs-recovery) durable 티켓이 있으면 fail-closed로 막는다.
+ *
+ * 🔴 판정 입력은 **오직 HEAD blob**: scaffold marker(`state.json`)·`approvals.jsonl`·`ticket-close.jsonl`·
+ *    `review-ledger.jsonl`. 워킹 `state.json`·워킹트리·미커밋 원장은 절대 보지 않는다(DEC-B4). 스캔은 git
+ *    **조회만**(read-only) — write-tree·commit·state 수정 없음.
+ * 🔴 **corrupt/부분 HEAD 증거**(매니페스트·close-proof 손상)는 pass 조건(dev-complete/series-terminal)이 읽는
+ *    아티팩트이므로, 손상 시 통과시키지 않고 **block**한다(fail-closed). 손상된 신호로 완료를 위장할 수 없다.
+ * 🔴 오버레이(`integrated`·`reconstructed`)는 기본 상태 판정을 바꾸지 않는다 — 게이트는 `baseStateBlocksIntake`
+ *    (기본 상태만) 으로 결정한다. legacy(durability marker 없음)는 차단하지 않고 표시만 한다.
+ *
+ * 순수 판정(`classifyIntake`)과 IO 수집(`scanTicketIntake`·`scanIntake`)을 분리한다.
+ */
+import {
+  deriveBaseState,
+  baseStateBlocksIntake,
+  isReconstructed,
+  parseCloseProof,
+  type CloseBaseState,
+  type CloseProofRow,
+} from './close-proof'
+import {
+  isDurabilityRequired,
+  verifyCommittedEvidenceIntegrity,
+  validateManifest,
+  evidencedPhaseIdsFromManifest,
+  designHashFromManifest,
+} from './evidence'
+import { parseLedger } from './review-ledger'
+import { createEvidencePorts } from './evidence-ports'
+
+export type IntakeVerdict = 'pass' | 'block' | 'legacy'
+
+export interface IntakeTicketResult {
+  ticketId: string
+  ticketRel: string
+  /** 파생 기본 상태. 매니페스트/close-proof 손상은 5-상태 밖의 `corrupt`(항상 block). */
+  baseState: CloseBaseState | 'corrupt'
+  verdict: IntakeVerdict
+  reason: string
+  /** `reconstructed` 오버레이(표시용 — 게이트 판정엔 영향 없음). */
+  reconstructed: boolean
+}
+
+export interface IntakeFacts {
+  ticketId: string
+  ticketRel: string
+  /** HEAD scaffold marker(`isDurabilityRequired`). false면 legacy. */
+  durabilityRequired: boolean
+  /** HEAD approvals.jsonl 본문(없으면 null). */
+  manifestText: string | null
+  /** `validateManifest` 결과(빈 배열=정상). 비어있지 않으면 corrupt block. */
+  manifestProblems: string[]
+  /** HEAD ticket-close.jsonl 파싱 결과. problems 비어있지 않으면 corrupt block. */
+  closeParsed: { rows: CloseProofRow[]; problems: string[] }
+  /** 🔴 committed 증거(design+phase) 무결성 문제(DEC-B6·B7). 비어있지 않으면 corrupt block(삭제/변조). */
+  evidenceIntegrityProblems: string[]
+  ledgerHasApprovedClose: boolean
+  committedEvidenceComplete: boolean
+  committedDesignRef: string | null
+  /** **design-bound**(현재 committed design_ref에 결속된) phase evidence의 phase id. */
+  evidencedPhaseIds: string[]
+}
+
+/**
+ * HEAD 사실 → intake 판정(순수). corrupt(매니페스트/close-proof 손상)는 기본 상태 밖의 별도 block 사유다.
+ */
+export function classifyIntake(facts: IntakeFacts): IntakeTicketResult {
+  const head = { ticketId: facts.ticketId, ticketRel: facts.ticketRel }
+  // legacy(durability marker 없음)는 차단하지 않고 표시만(DEC-C·요구).
+  if (!facts.durabilityRequired)
+    return { ...head, baseState: 'legacy', verdict: 'legacy', reason: 'legacy 티켓(durability marker 없음) — 표시만, 차단 안 함', reconstructed: false }
+  // 🔴 pass 조건(dev-complete/series-terminal)이 읽는 아티팩트가 손상됐으면 통과 금지(fail-closed).
+  if (facts.manifestText !== null && facts.manifestProblems.length)
+    return { ...head, baseState: 'corrupt', verdict: 'block', reason: `HEAD approvals.jsonl 손상 — 통과 불가(fail-closed): ${facts.manifestProblems.slice(0, 3).join('; ')}`, reconstructed: false }
+  if (facts.closeParsed.problems.length)
+    return { ...head, baseState: 'corrupt', verdict: 'block', reason: `HEAD ticket-close.jsonl 손상 — 통과 불가(fail-closed): ${facts.closeParsed.problems.slice(0, 3).join('; ')}`, reconstructed: false }
+  // 🔴 DEC-B6·B7: committed 증거(design·phase archive) blob 부재/변조도 통과 조건이 읽는 증거의 손상 →
+  //    corrupt block(dev-complete·series-terminal 위장 차단). design 행이 없는 미완 티켓은 손상 대상 아님(불완전≠손상).
+  if (facts.evidenceIntegrityProblems.length)
+    return { ...head, baseState: 'corrupt', verdict: 'block', reason: `committed 증거 손상 — 통과 불가(fail-closed): ${facts.evidenceIntegrityProblems.slice(0, 3).join('; ')}`, reconstructed: false }
+  const state = deriveBaseState({
+    durabilityRequired: true,
+    closeProofRows: facts.closeParsed.rows,
+    ledgerHasApprovedClose: facts.ledgerHasApprovedClose,
+    committedEvidenceComplete: facts.committedEvidenceComplete,
+    evidencedPhaseIds: facts.evidencedPhaseIds,
+    committedDesignRef: facts.committedDesignRef,
+  })
+  const blocked = baseStateBlocksIntake(state) // 기본 상태만 본다 — 오버레이 무관(요구).
+  const reason = blocked
+    ? state === 'developing'
+      ? '미종결 durable 티켓(developing) — 모든 phase 완료·커밋 또는 종결 후 재시도'
+      : 'HEAD 증거 불일치(needs-recovery) — 승인 흔적은 있으나 커밋된 증거 불완전, 복구 필요'
+    : state === 'dev-complete'
+      ? '개발 완료(dev-complete)'
+      : state === 'series-terminal'
+        ? 'series 종결(replace/human-resolution)'
+        : // 🔴 REQ-2026-053: migrated-complete는 **phase-1(커밋 3ed1b95 close-proof.ts)**에서 event·base-state·
+          //    파서·deriveBaseState(dev-complete 아래·needs-recovery 위 비차단)로 이미 확장됐다. 이 phase-2 diff는
+          //    명령(req:close)과 이 reason 케이스만 추가한다. 종결→pass 전 파이프라인은 req-close.test.ts ⑮가 실증.
+          state === 'migrated-complete'
+          ? '개발 완료(마이그레이션 종결·migrated-complete)'
+          : String(state)
+  return { ...head, baseState: state, verdict: blocked ? 'block' : 'pass', reason, reconstructed: isReconstructed(facts.closeParsed.rows) }
+}
+
+/**
+ * 한 티켓의 HEAD 사실을 모아 판정(IO — git 조회만, read-only). `ports`가 HEAD blob 접근 정본.
+ */
+export function scanTicketIntake(root: string, ticketRel: string, ticketId: string): IntakeTicketResult {
+  const ports = createEvidencePorts(root, `${ticketRel}/responses`)
+  const durabilityRequired = isDurabilityRequired(ports.headText(`${ticketRel}/state.json`))
+  if (!durabilityRequired)
+    return classifyIntake({ ticketId, ticketRel, durabilityRequired: false, manifestText: null, manifestProblems: [], closeParsed: { rows: [], problems: [] }, evidenceIntegrityProblems: [], ledgerHasApprovedClose: false, committedEvidenceComplete: false, committedDesignRef: null, evidencedPhaseIds: [] })
+  const manifestText = ports.headText(`${ticketRel}/responses/approvals.jsonl`)
+  const closeText = ports.headText(`${ticketRel}/responses/ticket-close.jsonl`)
+  const ledgerText = ports.headText(`${ticketRel}/responses/review-ledger.jsonl`)
+  // validPhaseIds는 매니페스트 자신의 phase 행 id로 만든다(HEAD state.phases는 설계상 []이므로 멤버십 검사만 무효화 —
+  // verifyCommittedDesignEvidence와 동일 기법). 나머지 구조·경로·sha·주입·kind 격리·phase_design_ref 형식은 강제된다.
+  const manifestPhaseIds = manifestText ? evidencedPhaseIdsFromManifest(manifestText) : []
+  const manifestProblems = manifestText ? validateManifest(manifestText, { ticketRel, validPhaseIds: manifestPhaseIds }) : []
+  const closeParsed = closeText ? parseCloseProof(closeText) : { rows: [], problems: [] }
+  const ledgerParsed = ledgerText ? parseLedger(ledgerText) : { rows: [], problems: [] }
+  const ledgerHasApprovedClose = ledgerParsed.rows.some((r) => r.event === 'attempt-closed' && r.outcome === 'approved')
+  const committedDesignRef = manifestText ? designHashFromManifest(manifestText) : null
+  const evidencedPhaseIds = manifestText ? evidencedPhaseIdsFromManifest(manifestText, committedDesignRef) : []
+  // 🔴 DEC-B7: committed 증거(design+phase) 무결성 종합 — intake·req:commit 공유 모듈. designEvidenceComplete로
+  //    needs-recovery 판정 입력(committedEvidenceComplete)을 같은 조회에서 얻는다(중복 조회 없음).
+  const integrity = verifyCommittedEvidenceIntegrity({ ticketRel, manifestText, ports })
+  return classifyIntake({ ticketId, ticketRel, durabilityRequired: true, manifestText, manifestProblems, closeParsed, evidenceIntegrityProblems: integrity.problems, ledgerHasApprovedClose, committedEvidenceComplete: integrity.designEvidenceComplete, committedDesignRef, evidencedPhaseIds })
+}
+
+/**
+ * HEAD tree의 `workflow/REQ-*` 디렉터리 이름(정렬). 🔴 **워킹 디렉터리를 읽지 않는다**(HEAD only).
+ *
+ * 🔴 **후행 슬래시가 load-bearing이다**: `git ls-tree -d --name-only HEAD workflow/`(슬래시 有)는 `workflow/`의
+ *    **직계 자식 tree**(= `workflow/REQ-*`)를 열거한다. 슬래시가 **없으면**(`workflow`) ls-tree는 그 항목 자신
+ *    (`workflow`) 한 줄만 낸다 → 자식을 못 보고 스캔이 통째로 비어 **게이트가 우회된다**. 그래서 아래에서 항상
+ *    `${dir}/`로 슬래시를 붙인다. 이 정상 경로는 `req-new-intake.test.ts`의 실 git 열거·생성 전 차단 e2e가 고정한다
+ *    (열거가 비면 developing 티켓이 차단되지 않아 그 테스트가 실패한다).
+ */
+export function listHeadTicketIds(workflowDirRel: string, gitFn: (a: string[]) => string): string[] {
+  const dir = workflowDirRel.replace(/\\/g, '/').replace(/\/+$/, '')
+  let out: string
+  try {
+    out = gitFn(['ls-tree', '-d', '--name-only', 'HEAD', `${dir}/`]) // 🔴 후행 슬래시 필수(직계 자식 열거).
+  } catch {
+    return [] // workflow/ 가 HEAD에 없음(첫 REQ 등) → 스캔 대상 없음.
+  }
+  return out
+    .split('\n')
+    .map((l) => l.trim())
+    .filter(Boolean)
+    .map((p) => p.split('/').pop() ?? '')
+    .filter((n) => /^REQ-\d{4}-\d+$/.test(n))
+    .sort()
+}
+
+/**
+ * HEAD의 `workflow/REQ-*` 티켓 전부를 스캔(read-only). `excludeTicketId`(대체될 부모 등)는 스캔에서 제외한다 —
+ * 그 티켓은 지금 정규 replace 흐름으로 종결되므로 후속 생성을 막아선 안 된다(제외는 부모의 replace 검증이 이미 끝난 뒤에만 쓴다).
+ */
+export function scanIntake(
+  root: string,
+  workflowDirRel: string,
+  gitFn: (a: string[]) => string,
+  excludeTicketId?: string | null,
+): { tickets: IntakeTicketResult[]; blocked: IntakeTicketResult[] } {
+  const ticketIds = listHeadTicketIds(workflowDirRel, gitFn).filter((id) => id !== excludeTicketId)
+  const dir = workflowDirRel.replace(/\\/g, '/').replace(/\/+$/, '')
+  const tickets = ticketIds.map((id) => scanTicketIntake(root, `${dir}/${id}`, id))
+  return { tickets, blocked: tickets.filter((t) => t.verdict === 'block') }
+}

package/scripts/req/lib/lockfile-diff.ts

@@ -0,0 +1,127 @@
+/**
+ * lockfile diff **요약** (REQ-2026-056·DEC-E1).
+ *
+ * `git diff --cached` 전문이 리뷰 프롬프트에 들어가는데, lockfile(`package-lock.json`·`pnpm-lock.yaml` 등)은
+ * 수천 줄 기계생성이라 토큰을 낭비하고 사람/리뷰어 신호를 묻는다. lockfile 구획의 hunk를 **요약**(경로·헤더
+ * 보존 + ±N/M + 생략분 sha256)으로 대체한다.
+ *
+ * 🔴 **프롬프트만 바꾼다** — 승인 바인딩(reviewTree = git write-tree)은 전체 index라 이 문자열 변형과 무관하다.
+ *    승인은 여전히 전체 lockfile을 결속한다(이 모듈은 그 사실을 강제하지 않지만, 호출부가 stagedDiff 문자열에만
+ *    이 변형을 적용한다).
+ *
+ * 순수 모듈 — fs·git을 모른다(deterministic·`createHash`만).
+ */
+import { createHash } from 'node:crypto'
+
+/** lockfile로 인식할 basename(정확 일치만 — 경로 부분문자열 오탐 방지). */
+export const LOCKFILE_NAMES: ReadonlySet<string> = new Set([
+  'package-lock.json',
+  'npm-shrinkwrap.json',
+  'pnpm-lock.yaml',
+  'yarn.lock',
+  'bun.lockb',
+])
+
+/** 경로 접두(`a/`·`b/`)·git C-quote(따옴표)를 벗겨 정규화한다. */
+function stripPathDecoration(raw: string): string {
+  let t = raw.trim()
+  if (t.length >= 2 && t.startsWith('"') && t.endsWith('"')) t = t.slice(1, -1) // git quoted path
+  if (t.startsWith('a/') || t.startsWith('b/')) t = t.slice(2)
+  return t
+}
+
+/**
+ * 한 구획의 **모든 후보 경로**를 헤더 줄에서 모은다(r01 P1). `diff --git`의 양쪽 경로는 공백에서 모호하므로
+ * `---`/`+++`/`rename from|to`/`copy from|to`/`Binary files … differ`의 명시 경로도 함께 본다 —
+ * rename(한쪽만 lockfile)·공백/따옴표 경로에서도 인식되게.
+ */
+function sectionPaths(section: string[]): string[] {
+  const paths: string[] = []
+  const add = (p: string | undefined): void => {
+    if (p === undefined) return
+    const s = stripPathDecoration(p)
+    if (s && s !== '/dev/null') paths.push(s)
+  }
+  for (const line of section) {
+    if (line.startsWith('--- ')) add(line.slice(4))
+    else if (line.startsWith('+++ ')) add(line.slice(4))
+    else if (line.startsWith('rename from ')) add(line.slice(12))
+    else if (line.startsWith('rename to ')) add(line.slice(10))
+    else if (line.startsWith('copy from ')) add(line.slice(10))
+    else if (line.startsWith('copy to ')) add(line.slice(8))
+    else if (line.startsWith('Binary files ')) {
+      const m = /^Binary files (.+) and (.+) differ$/.exec(line)
+      if (m) { add(m[1]); add(m[2]) }
+    } else if (line.startsWith('diff --git ')) {
+      const m = /^diff --git (.+) (.+)$/.exec(line) // best-effort(공백 경로면 ---/+++가 보완)
+      if (m) { add(m[1]); add(m[2]) }
+    }
+  }
+  return paths
+}
+
+/** 경로 basename이 lockfile인가(정확 일치). */
+export function isLockfilePath(path: string): boolean {
+  const base = path.replace(/\\/g, '/').split('/').pop() ?? ''
+  return LOCKFILE_NAMES.has(base)
+}
+
+/** 구획이 lockfile을 다루는가(양쪽 경로·rename·binary 헤더 모두 검사). */
+function sectionIsLockfile(section: string[]): { yes: boolean; display: string } {
+  const paths = sectionPaths(section)
+  const lock = paths.find(isLockfilePath)
+  return { yes: lock !== undefined, display: lock ?? paths[paths.length - 1] ?? '(lockfile)' }
+}
+
+/** 한 파일 구획(`diff --git`으로 시작하는 줄 배열)을 요약(lockfile일 때만). 비-lockfile은 그대로. */
+function summarizeSection(section: string[]): string[] {
+  const { yes, display: path } = sectionIsLockfile(section)
+  if (!yes) return section
+
+  const hunkIdx = section.findIndex((l) => l.startsWith('@@ '))
+  if (hunkIdx >= 0) {
+    const header = section.slice(0, hunkIdx)
+    const hunks = section.slice(hunkIdx)
+    // `+++`/`---`는 파일 헤더라 hunkIdx 이후엔 없지만 방어적으로 제외한다.
+    const plus = hunks.filter((l) => l.startsWith('+') && !l.startsWith('+++')).length
+    const minus = hunks.filter((l) => l.startsWith('-') && !l.startsWith('---')).length
+    const sha = createHash('sha256').update(hunks.join('\n'), 'utf8').digest('hex').slice(0, 12)
+    return [
+      ...header,
+      `# [lockfile 전문 생략 — 요약 모드] ${path}: +${plus}/-${minus} lines · sha256(생략분)=${sha} · 전문은 config lockfilePromptFull:true`,
+    ]
+  }
+  const binaryIdx = section.findIndex((l) => l.startsWith('Binary files ') && l.includes(' differ'))
+  if (binaryIdx >= 0) {
+    return [...section.slice(0, binaryIdx), `# [lockfile binary 변경 — 요약 모드] ${path} · 전문은 config lockfilePromptFull:true`]
+  }
+  // hunk도 binary도 없음(순수 rename/mode 변경 등) — 헤더만 작으니 그대로 둔다.
+  return section
+}
+
+/**
+ * staged diff의 lockfile 구획을 요약한다(순수). `opts.full`이면 원문 그대로.
+ * 🔴 lockfile 구획이 하나도 없으면 **완전 no-op**(입력===출력) — 기존 byte-identical near-e2e 무회귀.
+ */
+export function summarizeLockfileDiff(stagedDiff: string, opts: { full: boolean }): string {
+  if (opts.full || stagedDiff === '') return stagedDiff
+  const lines = stagedDiff.split('\n')
+  const starts: number[] = []
+  for (let i = 0; i < lines.length; i++) if (lines[i]!.startsWith('diff --git ')) starts.push(i)
+  if (starts.length === 0) return stagedDiff // 표준 파일 구획 없음 → 손대지 않는다.
+
+  // 구획별로 요약(비-lockfile은 그대로). 요약이 하나도 일어나지 않으면 원문 반환(no-op 보장).
+  const result: string[] = []
+  if (starts[0]! > 0) result.push(...lines.slice(0, starts[0]!)) // 첫 구획 前 preamble(있으면) 보존.
+  let changed = false
+  for (let s = 0; s < starts.length; s++) {
+    const from = starts[s]!
+    const to = s + 1 < starts.length ? starts[s + 1]! : lines.length
+    const section = lines.slice(from, to)
+    const summarized = summarizeSection(section)
+    if (summarized !== section) changed = true // summarizeSection은 요약 시에만 새 배열을 반환한다.
+    result.push(...summarized)
+  }
+  if (!changed) return stagedDiff // lockfile 구획 없음(또는 요약 대상 없음) → 원문 그대로.
+  return result.join('\n')
+}

package/scripts/req/lib/reconstruct.ts

@@ -0,0 +1,118 @@
+/**
+ * req:reconstruct 복원 가능성 매트릭스 (REQ-2026-052 phase-4·DEC-D2) — **순수** 산출.
+ *
+ * 🔴 close-proof lifecycle event는 `dev-complete`·`series-terminal` 둘뿐이다. 이 모듈은 **HEAD-committed
+ *    immutable evidence가 행의 모든 필드를 명확·모호없이 결정할 때만** 복원 후보를 낸다:
+ *   - **dev-complete**: 🔴 **절대 산출하지 않는다.** `phase_inventory`를 approvals.jsonl의 phase_id 집합으로
+ *     합성하면 계획됐으나 미커밋인 phase를 조용히 빼는 DEC-B5 P1이 재발한다. inventory 독립 기록이 없으므로
+ *     self-verifying 행이 없으면 복원 근거가 없다 → 재검토·재내구화가 유일 경로.
+ *   - **series-terminal(replace)**: 커밋된 **successor** 티켓의 `successor_of`(parent_series_id 포함)가
+ *     이 티켓 replace 종결을 완전히 증명할 때만.
+ *   - **series-terminal(terminate)**: successor를 만들지 않아 증거가 없다 → 불가.
+ *
+ * fs·git·review-codex를 모르는 leaf(부작용·evidence 추출은 CLI가 한다).
+ */
+import { type CloseProofRow, closeProofRowKey } from './close-proof'
+
+/** 이 티켓을 replace 부모로 지목하는 committed successor의 추출 증거(CLI가 HEAD blob에서 뽑아 넣는다). */
+export interface SuccessorEvidence {
+  /** successor 티켓 id(진단용). */
+  successorTicketId: string
+  /** successor `state.json`의 repo-상대 경로 — evidence_basis. */
+  successorStatePath: string
+  /** `successor_of.parent_series_id` — 부모의 replace 종결 series_id. */
+  parentSeriesId: string
+  /** 종결 사유. successor는 항상 `replace`(collect가 그렇게 거른다) — material field로 명시 검사한다. */
+  resolution: 'replace'
+  /** `successor_of.parent_replace_resolution.decided_at` — 종결 시점(부모 값). */
+  at: string
+}
+
+export interface ReconstructCandidate {
+  row: CloseProofRow
+  evidenceBasis: string[]
+}
+
+export interface ReconstructPlan {
+  /** 복원 예정(신규) 행. */
+  candidates: ReconstructCandidate[]
+  /** 복원 불가·불필요·모호 사유(진단 표시용 — write는 안 하지만 명령은 계속). */
+  refusals: string[]
+  /** 🔴 fail-closed conflict(HEAD 모순) — 하나라도 있으면 CLI는 **전체를 write 0으로 중단**한다. */
+  conflicts: string[]
+}
+
+/**
+ * 이 티켓의 복원 가능한 close-proof 행을 매트릭스(DEC-D2 multi-witness)대로 산출(순수). dev-complete는 절대 산출 안 함.
+ *
+ * 🔴 **parent_series_id별 그룹화**: 같은 series를 가리키는 복수 witness의 material field(resolution·at)가 **전부 일치**할
+ *    때만 후보 1개(evidence_basis=모든 successor state 경로 정렬·중복제거). 불일치=ambiguity refusal(그 series write 0).
+ * 🔴 **HEAD 정합**: 같은 자연키 행이 HEAD에 있으면 material 일치=멱등 no-op, 모순=**conflict**(숨기지 않고 fail-closed).
+ *
+ * @param existingRows 이 티켓 HEAD close-proof를 파싱한 행들. 손상 티켓은 CLI가 이 함수 **전에** 거른다.
+ * @param successors 이 티켓을 부모로 지목하는 committed successor 증거들.
+ */
+export function planReconstruction(args: {
+  ticketId: string
+  existingRows: readonly CloseProofRow[]
+  successors: readonly SuccessorEvidence[]
+}): ReconstructPlan {
+  const candidates: ReconstructCandidate[] = []
+  const refusals: string[] = []
+  const conflicts: string[] = []
+
+  // ① parent_series_id별 그룹화(빈 필드는 미결정으로 개별 refusal).
+  const groups = new Map<string, SuccessorEvidence[]>()
+  for (const s of args.successors) {
+    if (!s.parentSeriesId || !s.at || !s.resolution) {
+      refusals.push(`successor ${s.successorTicketId}: parent_series_id·resolution·at 중 미결정 → 복원 불가(모호)`)
+      continue
+    }
+    const g = groups.get(s.parentSeriesId)
+    if (g) g.push(s)
+    else groups.set(s.parentSeriesId, [s])
+  }
+
+  for (const seriesId of [...groups.keys()].sort()) {
+    const witnesses = groups.get(seriesId)!
+    // ② material field(resolution·at) 전부 일치해야 후보. 불일치=ambiguity(그 series 후보 없음).
+    const ats = new Set(witnesses.map((w) => w.at))
+    const resolutions = new Set(witnesses.map((w) => w.resolution))
+    if (ats.size > 1 || resolutions.size > 1) {
+      refusals.push(
+        `series ${seriesId}: 복수 successor의 material field 불일치(at=[${[...ats].sort().join(', ')}] resolution=[${[...resolutions].sort().join(', ')}]) → ambiguity 복원 불가(write 0)`,
+      )
+      continue
+    }
+    const at = witnesses[0]!.at
+    const resolution = witnesses[0]!.resolution
+    // 완전 일치하는 복수 witness → evidence_basis에 모든 경로 정렬·중복제거.
+    const evidenceBasis = [...new Set(witnesses.map((w) => w.successorStatePath))].sort()
+    const row: CloseProofRow = {
+      ticket_id: args.ticketId,
+      event: 'series-terminal',
+      series_id: seriesId,
+      resolution,
+      phase_inventory: null,
+      design_ref: null,
+      at,
+      reconstructed: true,
+      evidence_basis: evidenceBasis,
+    }
+    // ③ HEAD 정합: 같은 자연키 행이 있으면 material 일치=멱등 no-op, 모순=conflict(fail-closed).
+    const key = closeProofRowKey(row)
+    const prior = args.existingRows.find((r) => closeProofRowKey(r) === key)
+    if (prior) {
+      if (prior.resolution === resolution && prior.at === at) {
+        refusals.push(`series ${seriesId}: 동일 series-terminal 행이 HEAD에 존재 → 복원 불필요(멱등 no-op)`)
+      } else {
+        conflicts.push(
+          `series ${seriesId}: HEAD 행과 모순(HEAD at=${prior.at} resolution=${prior.resolution} ≠ 후보 at=${at} resolution=${resolution}) → fail-closed(숨기지 않음)`,
+        )
+      }
+      continue
+    }
+    candidates.push({ row, evidenceBasis })
+  }
+  return { candidates, refusals, conflicts }
+}