@uzysjung/agent-harness 26.141.1 → 26.143.0

package/dist/trust-tier-drift.js

@@ -15,7 +15,7 @@ import {
   init_esm_shims,
   residentCost,
   resolveBundleRoot
-} from "./chunk-5RWSZT2J.js";
+} from "./chunk-7KAPL2PZ.js";
 
 // src/trust-tier-drift.ts
 init_esm_shims();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uzysjung/agent-harness",
-  "version": "26.141.1",
+  "version": "26.143.0",
   "description": "Curate vetted AI-coding skills & plugins by your tech stack — install only what you need, across Claude Code, Codex, OpenCode & Antigravity",
   "type": "module",
   "publishConfig": {

package/templates/rules/doc-governance.md

@@ -41,4 +41,10 @@
 
 현행 SSOT 만 루트/`docs/` 에 둔다. 히스토리(옛 버전·폐기 sub-spec·완료된 audit 산출물)는 `docs/archive/` 로 격리하고 지도 파일(`archive/README.md`) 하나로 찾게 한다. 현행 문서에 히스토리가 쌓이면 "지금 무엇이 맞는지" 읽는 비용이 히스토리에 비례해 커진다.
 
-**why 중심으로 쓴다** — what 은 코드와 diff 가 보여준다. SPEC 이 800줄을 넘으면 기능별로 분리한다(`spec-scaling` 스킬). **본 규약을 무는 게이트는 기본 제공되지 않는다** — 같은 drift 가 반복되면 프로즈를 늘리지 말고 게이트를 만들어라.
+**why 중심으로 쓴다** — what 은 코드와 diff 가 보여준다. SPEC 이 800줄을 넘으면 기능별로 분리한다(`spec-scaling` 스킬).
+
+## 검증 게이트
+
+`.uzys-agent-harness/spec-drift-check.sh`(전 트랙 설치)가 SPEC/TODO 의 미완 잔존·Status 불일치를 검출한다 — **훅이 아니라 명시 호출**이다: 인자 없이 부르면 경고(exit 1), `ship` 인자면 차단(exit 2). 백로그는 `ship-gate:ignore` 구간만 면제된다(기본값은 검사 · 표식 짝이 깨지면 면제를 통째로 무시).
+
+**한계를 알고 써라**: 탐지 경로(`docs/SPEC.md`·`docs/todo.md` 등) 밖의 문서 레이아웃은 게이트가 못 본다. 그 경우 본 규약은 프로즈로만 작동한다 — 안 지켜져도 아무도 안 막는다. 그게 확인되면 **게이트를 넓혀라, 프로즈를 늘리지 말고.**

package/templates/rules/ship-checklist.md

@@ -8,7 +8,7 @@ ship 단계 실행 시 아래 모든 항목을 통과해야 배포 가능.
 - [ ] **커버리지 기준 충족**: `test-policy.md` 의 Track 별 threshold 확인. **전체 실행(full)을 요구하는 지점은 여기다** — 커밋에는 테스트가 없고 머지에는 영향 범위만 돈다(시점별 정책은 `test-policy.md` 가 SSOT)
 - [ ] **CI green 이 배포의 전제로 배선됐는지**: 릴리스가 CI job 에 `needs:` 로 묶여 **CI red 면 게시가 안 일어나야** 한다. 게시가 CI 와 별개 워크플로면 red 를 통과해 나간다
 - [ ] **Security Scan · 의존성 감사**: `npx ecc-agentshield scan` 결과 CRITICAL/HIGH 없음 · `npm audit`(Node.js) 또는 `pip-audit`(Python) critical/high 취약점 없음
-- [ ] **SPEC/PRD 정합성**: 이번 사이클에 하기로 한 항목이 미완으로 남아 있지 않은가 (`doc-governance.md` "작업 완료 처리")
+- [ ] **SPEC/PRD 정합성**: 이번 사이클에 하기로 한 항목이 미완으로 남아 있지 않은가 (`doc-governance.md` "작업 완료 처리"). 실행 확인 = `bash .uzys-agent-harness/spec-drift-check.sh ship` — **exit 2 면 차단**(동기화 후 재시도), exit 1 은 경고, 0 이 통과. 백로그는 `ship-gate:ignore` 구간으로 감싸 면제한다(표식이 안 닫히면 면제를 통째로 무시)
 - [ ] **Review 게이트 통과**: review 단계에서 CRITICAL 이슈 없음 확인
 
 ## Post-Ship

package/templates/scripts/spec-drift-check.sh

@@ -0,0 +1,131 @@
+#!/bin/bash
+# spec-drift-check.sh
+# SPEC/TODO 문서의 drift를 검출한다. Verify 또는 Ship 단계에서 호출 가능.
+#
+# 훅이 아니라 **명시 호출** 스크립트다 — 자동 발화 경로는 없다.
+#   bash .uzys-agent-harness/spec-drift-check.sh        # 경고 수준 (verify)
+#   bash .uzys-agent-harness/spec-drift-check.sh ship   # 차단 수준 (ship)
+# 호출자 = `ship-checklist.md` SPEC/PRD 정합성 항목 · `doc-governance.md` 검증 게이트 절.
+#
+# 검출 항목:
+#  1. SPEC 문서에 unchecked 항목 존재 (docs/SPEC.md → SPEC.md 중 첫 존재 파일)
+#  2. TODO 문서에 unchecked 항목 존재 (docs/todo.md → docs/TODO.md → todo.md → TODO.md
+#     → tasks/todo.md 중 첫 존재 파일 — first-match 라 대소문자 무시 FS 에서도 이중 카운트 없음)
+#  3. SPEC Status가 "Define"인데 build/verify gate가 완료된 경우 (gate-status.json 존재 시)
+#  4. Ship 단계에서는 모든 unchecked가 차단
+#
+# Exit codes:
+#  0: drift 없음
+#  1: drift 발견 (경고 출력)
+#  2: 차단 수준 drift (Ship 게이트에서 차단)
+set -e
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+DOCS_DIR="$PROJECT_DIR/docs"
+[ ! -d "$DOCS_DIR" ] && DOCS_DIR="$PROJECT_DIR/Docs"
+
+DRIFT=0
+BLOCK=0
+
+# unchecked 항목을 센다. 단 `ship-gate:ignore` 구간은 제외한다 — 게이트가 잡으려는 것은 "이번
+# 사이클에 하기로 해놓고 안 한 것"이지 "언젠가 할 일(백로그)"이 아니다. 백로그는 정상적으로 항상
+# 존재하므로 구분 없이 세면 게이트가 상시 차단이 되고, 그러면 사람들은 체크박스를 안 쓰는 쪽으로
+# 우회한다 → 셀 게 없어 게이트가 죽는다.
+#
+# 기본값은 검사다. 면제는 표식이 있는 쪽이어야 한다. 표식이 짝이 안 맞으면 면제를 통째로
+# 무시한다(fail-closed) — 표식 하나 잘못 써서 게이트가 통째로 꺼지는 경로를 만들지 않는다.
+#
+# 표식은 **단독 줄**일 때만 인정한다(앞뒤 공백만 허용). 그래야 이 기능을 설명하는 산문이
+# — 예: 백틱으로 인용한 사용법 — 파서에 진짜 표식으로 잡히지 않는다. 기능을 그 기능이
+# 적용되는 파일 안에서 문서화할 수 없으면 안 된다. (실제로 그 함정을 밟고 추가한 규칙이다.)
+count_unchecked() {
+  local file="$1"
+  awk '
+    /^[ \t]*<!--[ ]*ship-gate:ignore-start[ ]*-->[ \t]*$/ { skip = 1; opened++; next }
+    /^[ \t]*<!--[ ]*ship-gate:ignore-end[ ]*-->[ \t]*$/   { skip = 0; closed++; next }
+    /^- \[ \]|^  - \[ \]/                                 { total++; if (!skip) counted++ }
+    END {
+      if (opened != closed) {
+        printf "spec-drift-check: ship-gate:ignore 표식 불일치 (start %d / end %d) — 면제를 무시한다\n", opened, closed > "/dev/stderr"
+        print total + 0
+      } else {
+        print counted + 0
+      }
+    }
+  ' "$file"
+}
+
+# 후보 목록 중 첫 존재 파일 (없으면 빈 문자열). docs/ 고정이 아니라 실제 워크플로
+# 산출 레이아웃(root SPEC.md·tasks/todo.md 등)까지 훑는다.
+first_existing() {
+  local f
+  for f in "$@"; do
+    if [ -f "$f" ]; then
+      echo "$f"
+      return 0
+    fi
+  done
+  echo ""
+}
+
+SPEC_FILE=$(first_existing "$DOCS_DIR/SPEC.md" "$PROJECT_DIR/SPEC.md")
+TODO_FILE=$(first_existing "$DOCS_DIR/todo.md" "$DOCS_DIR/TODO.md" "$PROJECT_DIR/todo.md" \
+  "$PROJECT_DIR/TODO.md" "$PROJECT_DIR/tasks/todo.md")
+
+# 1. SPEC unchecked 검사
+if [ -n "$SPEC_FILE" ]; then
+  UNCHECKED=$(count_unchecked "$SPEC_FILE")
+  UNCHECKED=${UNCHECKED:-0}
+  if [ "$UNCHECKED" -gt 0 ] 2>/dev/null; then
+    echo "DRIFT: ${SPEC_FILE#"$PROJECT_DIR"/}에 unchecked 항목 ${UNCHECKED}건" >&2
+    DRIFT=$((DRIFT + 1))
+  fi
+fi
+
+# 2. TODO unchecked 검사
+if [ -n "$TODO_FILE" ]; then
+  UNCHECKED=$(count_unchecked "$TODO_FILE")
+  UNCHECKED=${UNCHECKED:-0}
+  if [ "$UNCHECKED" -gt 0 ] 2>/dev/null; then
+    echo "DRIFT: ${TODO_FILE#"$PROJECT_DIR"/}에 unchecked 항목 ${UNCHECKED}건" >&2
+    DRIFT=$((DRIFT + 1))
+  fi
+fi
+
+# 3. SPEC Status 일관성 — gate-status.json과 대조 (6-gate 워크플로 사용 프로젝트만; 파일 없으면 skip)
+GATE_FILE="$PROJECT_DIR/.claude/gate-status.json"
+if [ -f "$GATE_FILE" ] && [ -n "$SPEC_FILE" ] && command -v jq &> /dev/null; then
+  BUILD_DONE=$(jq -r '.build.completed // false' "$GATE_FILE")
+  VERIFY_DONE=$(jq -r '.verify.completed // false' "$GATE_FILE")
+
+  # SPEC Status가 "Define"인지 확인 (frontmatter 형식만, 본문 파이프라인 설명 제외)
+  if grep -qE "^> \*\*Status\*\*:.*Define" "$SPEC_FILE"; then
+    if [ "$BUILD_DONE" = "true" ] || [ "$VERIFY_DONE" = "true" ]; then
+      echo "DRIFT: SPEC Status='Define'인데 Build/Verify gate가 완료됨" >&2
+      DRIFT=$((DRIFT + 1))
+      # Ship 게이트에서는 차단 (Build 이후에도 SPEC이 Define이면 안 됨)
+      [ "$1" = "ship" ] && BLOCK=1
+    fi
+  fi
+fi
+
+# 4. Ship 단계에서는 모든 unchecked가 차단
+if [ "$1" = "ship" ] && [ "$DRIFT" -gt 0 ]; then
+  BLOCK=1
+fi
+
+# Summary
+if [ "$DRIFT" -eq 0 ]; then
+  echo "OK: SPEC/TODO 동기화 상태 정상"
+  exit 0
+fi
+
+if [ "$BLOCK" -eq 1 ]; then
+  echo "" >&2
+  echo "BLOCKED (ship gate): SPEC/TODO drift 발견 — 동기화 후 재시도" >&2
+  exit 2
+fi
+
+echo "" >&2
+echo "WARNING: SPEC drift ${DRIFT}건. 동기화 권장." >&2
+exit 1

package/templates/skills/audit-harness-fit/SKILL.md

@@ -0,0 +1,278 @@
+---
+name: audit-harness-fit
+description: >-
+  Audits whether a project's resident steering layer still earns the context it costs — the
+  CLAUDE.md/AGENTS.md anchor and its `@import` chain, `.claude/rules/`, hooks, permission rules,
+  and the skill descriptors preloaded every session. INVENTORY measures what actually loads;
+  EVIDENCE gathers block logs and correction history; VERDICT rules each section keep / rewrite /
+  relocate / delete against published authoring guidance instead of taste; RELOCATE moves
+  procedures into skills, must-hold guarantees into hooks and permission rules, and derivable
+  facts back into code or tests; APPLY proposes the edit and waits for approval. Use when the
+  user says any of "하네스 정리", "룰·훅이 밥값을 하는지", "CLAUDE.md 다이어트", "상주 컨텍스트
+  정리", "룰이 너무 많아", "훅이 실제로 뭘 막고 있는지" — or the English equivalents "harness
+  audit", "trim my CLAUDE.md", "are my rules earning their keep", "prune the steering layer",
+  "why does Claude ignore my rules". Fires for both Korean and English phrasing. Do NOT use it to
+  escalate a countermeasure after a defect came back (that is recurrence-prevention), and not for
+  drift between the product's own docs and its code (that is audit-service-gaps DRIFT).
+---
+
+# Audit Harness Fit (상주 조종층 감사)
+
+The steering layer around an agent has a documented growth loop and no documented shrink loop.
+The published guidance is explicit about when to add — *"Claude makes the same mistake a second
+time"*, *"a code review catches something Claude should have known"* — and the natural response is
+another line in CLAUDE.md, another rule file, another hook. Nothing in that loop ever fires in
+reverse. So the layer grows monotonically until it hits the failure the same guidance names:
+*"If your CLAUDE.md is too long, Claude ignores half of it because important rules get lost in the
+noise."*
+
+This skill is the reverse pass. It takes the resident layer as it is today, measures it, and rules
+on each part with **three kinds of evidence only**:
+
+1. **Published criteria** — what the vendor documentation says belongs resident, what belongs
+   on-demand, and what is not an enforcement layer at all. Quotes and sources:
+   [references/official-criteria.md](references/official-criteria.md).
+2. **Block and correction logs** — what the enforcement layer actually stopped, and what the
+   human actually had to correct.
+3. **Measurement** — item counts and token estimates per surface, taken the same way twice so
+   before and after are comparable.
+
+**Opinion is not one of the three.** "This rule feels important" and "this rule feels like bloat"
+are the same evidence class, and a verdict that pits one against the other is a coin flip wearing
+a report's clothes. If none of the three applies to a section, the verdict is `unjudged`, and it
+stays exactly as it is.
+
+## When to use
+
+- The resident layer has grown across many sessions and nobody has ever removed anything.
+- Claude keeps violating a rule that is plainly written down — the diagnostic the docs give for
+  that symptom is *file length*, not rule wording.
+- You are about to add another rule and want to know what the existing ones are doing first.
+- A model upgrade landed and some instructions may now be scaffolding for a weakness that is gone.
+
+Not for: a defect that just recurred — `recurrence-prevention` owns that, and it moves *one*
+countermeasure up a ladder rather than re-judging the whole layer. Not for mismatch between the
+product's documentation and the product's code — that is `audit-service-gaps` in DRIFT mode.
+
+---
+
+## Stage 1 — INVENTORY (what actually loads every session)
+
+Enumerate the resident surfaces before judging any of them. Resident means loaded at session
+start whether or not it gets used:
+
+| Surface | Where it lives | Resident? |
+|---|---|---|
+| Project anchor | `CLAUDE.md` / `AGENTS.md` at the repo root (and parent directories) | Full text, every session |
+| Project anchor 2 | `.claude/CLAUDE.md` — a second file, not an alias of the first | Full text, every session |
+| User anchor | the same filenames under the home config dir (`$HOME/.claude/`) | Full text — a separate scope, not a parent directory |
+| Imports | every `@path` reachable from any of those anchors, up to four hops | Full text — imports organize, they do not reduce |
+| Auto-memory | `MEMORY.md`, written by the agent to itself | Full text; often the single largest item |
+| Rules | `.claude/rules/*.md` | Full text if no `paths:` frontmatter; on match if scoped |
+| Skills | `.claude/skills/*/SKILL.md` | **Name + description only**; the body loads on trigger |
+| Subagents | `.claude/agents/*.md` | Description preloaded, same as skills |
+| Hooks | `settings.json` hook entries + their scripts | **Zero**, unless the hook writes to stdout |
+| Permissions | `permissions.allow` / `ask` / `deny` | Enforcement, not context |
+
+Then measure. Use whatever the project already provides; if it provides nothing, plain shell is
+enough and portable. Measure every row in the same unit — **bytes** — or the rows cannot be added
+up, and "half the layer is rules" becomes a guess:
+
+```bash
+have() { for f in "$@"; do [ -f "$f" ] && printf '%s\n' "$f"; done; }
+
+# ⓐ every anchor that exists, plus one hop of @imports resolved next to the file that declared them
+anchors=$(have CLAUDE.md .claude/CLAUDE.md AGENTS.md "$HOME/.claude/CLAUDE.md")
+imports=$(for a in $anchors; do
+  grep -o '@[^[:space:])]*' "$a" |
+    sed -e "s|^@~|$HOME|" -e "s|^@/|/|" -e "s|^@|$(dirname "$a")/|"
+done)
+have $anchors $imports | xargs wc -c        # ÷ 4 ≈ tokens
+
+# ⓑ rules — count them, then size only the ones without `paths:` frontmatter
+find .claude/rules -name '*.md' | wc -l
+grep -L '^paths:' .claude/rules/*.md | xargs wc -c
+
+# ⓒ auto-memory — one home dir holds every project's, so keep the ones naming this project
+find . "$HOME/.claude" -name 'MEMORY.md' 2>/dev/null |
+  grep -e '^\./' -e "$(basename "$PWD")" | xargs wc -c
+
+# ⓓ for skills and subagents the descriptor is the resident part — size the frontmatter, not the file
+awk 'FNR==1{n=0} /^---$/{n++;next} n==1' .claude/skills/*/SKILL.md | wc -c
+awk 'FNR==1{n=0} /^---$/{n++;next} n==1' .claude/agents/*.md | wc -c
+```
+
+Three traps that make an inventory wrong rather than incomplete:
+
+- **Two copies of the same name.** A repo that *ships* a harness has a development copy and a
+  distributed copy of the same filenames. Measure the one the session actually loads, and say
+  which one you measured.
+- **`paths:` frontmatter changes the answer.** A rule with a `paths:` list is not resident; a rule
+  without one is. Read the frontmatter, do not assume.
+- **Imports are not free.** Splitting a long anchor into `@imports` improves organization and
+  changes the resident total by nothing.
+
+Record the numbers as bytes per surface plus one total. Every later claim about "smaller" has to
+point back at them, and a total that quietly drops a surface makes every percentage after it wrong.
+
+## Stage 2 — EVIDENCE (what the layer actually did)
+
+For each resident item, look for a trace that it did work:
+
+- **Block logs.** Blocking hooks that append one line per block (`.uzys-agent-harness/hook-blocks.log`
+  where this harness is installed) give the only direct data on what enforcement actually caught.
+- **Correction history.** `git log` on the steering files themselves, plus the commits that
+  *followed* a rule's introduction: was the mistake it targets absent afterward, or does it recur?
+- **The maintainer's own record.** Issue threads, postmortems, memory files — a rule created after
+  a real incident has a citation; a rule created out of caution does not.
+
+**A log with zero lines is not an acquittal.** It has two readings that data alone cannot separate:
+nothing needed blocking, or the log was born last week / the hook never fired / the hook never wired
+up. Report `no sample` and go find a second signal — when the hook was added, whether its matcher can
+ever match, whether the file exists at all. A hook whose matcher cannot match anything is not
+"quietly effective", it is dead wiring, and that is a finding in its own right.
+
+The same asymmetry runs the other way: a log line proves the hook fired, not that the block was
+*correct*. Read the blocked targets. A block on a path the maintainer intended to edit is a false
+positive, and false positives are the cost side of the enforcement ledger.
+
+## Stage 3 — VERDICT (rule on each section, one at a time)
+
+The unit is the **section**, not the file. Files are usually mixed — one paragraph carrying a real
+project fact, three carrying things any competent model already does.
+
+The primary question comes straight from the published guidance: **"Would removing this cause
+Claude to make mistakes?"** If not, cut it. Two corollaries decide most sections without argument:
+
+- Anything derivable from the codebase (directory layouts, dependency lists, file-by-file
+  descriptions, API documentation) is derivable *by the model, on demand*. It does not need to be
+  resident.
+- Anything the model does correctly without the instruction is a no-op that still costs adherence
+  from the rules around it.
+
+Then run the **generation lint**. Recent guidance names prompt patterns that were useful for older
+models and now actively cost tokens or quality — they survive in steering layers as legacy
+scaffolding, so look for them by name:
+
+| Pattern to flag | Why it is now a cost |
+|---|---|
+| Explicit verification instructions ("add a final verification step", "use a subagent to verify") | The model verifies its own work unprompted; the instruction causes over-verification |
+| Re-check instructions ("double-check your answer", "re-verify before responding") | Compounds with behavior the model already has — cost without quality |
+| Severity suppression in review prompts ("only report high-severity issues", "be conservative") | Followed literally: the review reports less. Ask for everything, filter in a separate pass |
+| Rules telling the model not to think or not to reason, especially naming thinking tags | Increases tag leakage — the documented effect is the opposite of the intent |
+| Long stacks of prohibitions | Positive examples of the wanted style outperform instructions about what not to do |
+| Aspirational rules nobody follows | Documented as "not worth including"; also teaches that rules are optional |
+
+A flag is a candidate, not a verdict. Confirm it against the section's evidence before ruling.
+
+Assign exactly one verdict per section:
+
+- **keep** — evidence of a real mistake it prevents, and it belongs resident.
+- **rewrite** — right content, wrong form: vague where it should be concrete ("format properly" →
+  "use 2-space indentation"), or contradicting another section (conflicting instructions get picked
+  between arbitrarily).
+- **relocate** — right content, wrong layer. Stage 4 decides where.
+- **delete** — no evidence, derivable, already-known, or dead wiring.
+- **unjudged** — none of the three evidence kinds applies. Leave it alone and say so.
+
+Conflicts deserve their own sweep: two sections that contradict each other are worse than either
+alone, because the model may follow either one on any given session.
+
+## Stage 4 — RELOCATE (right content, wrong layer)
+
+Most of what a bloated steering layer holds is not wrong — it is filed in the layer that cannot
+enforce it and charges rent for trying.
+
+| What it is | Where it belongs | Why |
+|---|---|---|
+| Multi-step procedure, playbook, checklist | **Skill** | Loads on demand; the descriptor is the only resident cost |
+| Instruction that only matters for part of the tree | **Path-scoped rule** (`paths:` frontmatter) | Loads when matching files are touched, not every session |
+| Must happen every time, no exceptions (format on save, block a path) | **Hook** | Prose is advisory; hooks are deterministic and fire regardless of what the model decides |
+| Hard allow/deny boundary on tools, commands, paths | **Permission rule** | Documented as the enforcement layer for boundaries; a hook filter is best-effort and fails open on unparseable input |
+| A fact the code already states, or should | **Code, test, or generated doc** | Derived facts do not drift; copied facts do |
+| Dynamic per-session context (recent commits, open issues) | **SessionStart hook** | Static context belongs in the anchor; only scripted, changing context justifies a hook |
+| A system Claude keeps re-reading or cannot see at all; a setup a second repo needs too | **MCP server** or **plugin** | Connect or package the capability instead of narrating it in prose that loads every session |
+| A side task whose output would flood the main conversation | **Subagent** | Runs in its own context; only the result comes back |
+| Nothing depends on it | **Delete** | |
+
+Two directions that look symmetric and are not: hooks can tighten what permission rules allow but
+never loosen it, and a prompt instruction is not on the enforcement list at all — it shapes what
+the model attempts, so pair it with one of the two real mechanisms rather than shipping it alone.
+
+Relocation is not free either. A hook adds a shell dependency and an administrative surface; a
+skill adds a descriptor to every session. Say what the move costs, not only what it saves.
+
+## Stage 5 — APPLY (propose; the human decides)
+
+Default output is a **proposal**, not an edit. Present it as one table — section, verdict,
+evidence, destination — with before/after measurements from Stage 1, then stop.
+
+Apply only what was approved, and keep the applied change checkable:
+
+- One coherent commit, so the removal can be reverted as a unit.
+- **Deletions are reversible in version control and nowhere else.** Before deleting a rule, check
+  whether a test, gate, or script reads that file by path — a gate that greps for a removed file
+  turns green by finding nothing.
+- After applying, the honest verification is behavioral: the guidance's own instruction is to
+  *"test changes by observing whether Claude's behavior actually shifts."* Say plainly that the
+  effect is unverified until that observation exists. A smaller token count is not evidence that
+  the layer got better.
+
+Never widen the audit into a rewrite of the project's conventions. This skill decides what loads,
+not what the team believes.
+
+---
+
+## Worked example (abridged run)
+
+**Input:** "룰이랑 훅이 밥값 하는지 좀 봐줘 — CLAUDE.md도 너무 길어진 것 같고."
+
+**INVENTORY** — anchor 210 lines + 9 rule files, no `paths:` frontmatter on any of them, 1,100
+lines resident in total across both copies of the layer; 4 hooks registered in `settings.json`;
+`permissions` has `defaultMode: bypassPermissions` with zero `deny` and zero `ask` entries.
+
+**EVIDENCE** — block log holds 6 lines over 3 weeks: 4 from the protected-file hook (all on
+`.env` writes), 2 from an MCP allowlist hook, of which **1 blocked a lookup the maintainer had
+explicitly asked for** — a false positive, not a save. Two of the 4 registered hooks appear zero
+times; one turns out to have a matcher that cannot match any event name the CLI emits (**dead
+wiring**), the other has genuinely never been triggered (**no sample** — reported as unknown, not
+as safe).
+
+**VERDICT** — 9 rules → 8 (one file restated the anchor's own principles: `delete`). Within the
+survivors, section-level cuts land on: a verification-step instruction and two "double-check
+before responding" clauses (generation lint), a directory-layout listing (derivable), and a
+"report only blocking issues" clause in the review rule (severity suppression). Resident prose
+1,100 → 535 lines. The four rules with incident citations: `keep`, untouched.
+
+**RELOCATE** — the release checklist (11 steps, invoked a few times per month) → skill. The
+"never edit `.env`" line stays as prose *and* keeps its hook, since prose alone is not a boundary.
+The dead-wired hook is deleted; the never-fired one is left in place with its status recorded as
+unknown, because deleting on absence of evidence is the mistake this stage exists to avoid.
+
+**APPLY** — proposal table presented; maintainer approves the deletions, defers the skill
+extraction. Reported as: −565 resident lines, 1 dead hook removed, 1 false-positive block
+identified; **behavioral effect unverified** until the next few sessions are observed.
+
+## Output, side effects, and stop conditions
+
+- **Output** — the inventory with its measurement method, the evidence table (including `no
+  sample` entries), one verdict per section with its evidence kind, the relocation plan with
+  costs, and the before/after numbers.
+- **Side effects** — this skill proposes; it edits only what was approved. Never touch
+  `permissions` or hook configuration without explicit approval: those change what the agent is
+  allowed to do, not merely what it reads.
+- **Stop** when the project's steering layer is spread across copies you cannot tell apart, or
+  when the only available judgment is preference. An audit that ranks sections by taste produces a
+  confident list of changes that no one can defend later.
+
+## Cross-references (don't duplicate)
+
+- **`recurrence-prevention`** — opposite direction: it escalates one countermeasure after a
+  specific defect returned. This skill audits the layer at rest; it does not decide whether a
+  given incident deserves a new rule.
+- **`audit-service-gaps`** — audits the product against its target state; DRIFT mode covers
+  doc-vs-code mismatch in the product. This skill audits the agent's own steering layer.
+- **`north-star`** — where a project's stated direction lives; a rule that no longer serves it is
+  a candidate for deletion, but the direction itself is set there, not here.
+- **[references/official-criteria.md](references/official-criteria.md)** — the published quotes
+  behind every criterion above, with sources. Read it before ruling on a contested section.