---
status: historical-snapshot
applies-to-version: "registry 62 roles / 26 families / 11 lenses (이 계획 실행 시점)"
superseded-by: "현재 정본 registry 73 roles / 28 families / 12 lenses — org-os/00-role-registry/*"
exclude-from: [must-read, default-search]
note: "구현 완료된 과거 계획. 본문의 62/26/11 수치는 당시 스냅샷이며 현재 정본은 org-os 레지스트리다(finding #20)."
---

# 협업 효율화 + 다양성 보존 오버레이 Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Org OS에 발산/수렴 모드 × 경량/표준/중대 티어 × 11개 불가침 렌즈로 이뤄진 협업 오버레이를 명세 파일로 추가해, 협업 handoff 비용을 낮추면서 관점 다양성을 구조적으로 보존한다.

**Architecture:** 가산적 오버레이 — `org-os` 아래 5개 신규 YAML을 추가하고 기존 4개 파일에는 참조 필드/규칙만 덧붙인다. 코드·실행체(.claude)는 만들지 않는다. 각 파일은 단일 관심사만 담고 id/참조로만 연결된다.

**Tech Stack:** YAML 명세, 검증은 python3 + pyyaml(설치 확인됨 6.0.1)로 임시(비커밋) 스크립트를 scratchpad에서 실행. Markdown 문서.

## Global Constraints

- 기준 스펙: `docs/superpowers/specs/2026-07-05-collaboration-efficiency-design.md` (모든 값의 단일 원천).
- 범위: **명세만.** `.claude/*`, MCP, hook, 영구 validator 스크립트 생성 금지(후속 라운드).
- 기존 62개 role을 삭제/추가하지 않는다. `roles.yaml`은 참조 분류체계로 보존한다.
- 기존 파일 변경은 **참조 추가뿐** — 기존 rigor(특히 High/Critical→인간, Approved 조건)의 의미를 제거하지 않는다. **TIER-HEAVY == 오늘 동작.**
- 신규/수정 YAML은 모두 `python3 -c "import yaml,sys; yaml.safe_load(open(f))"`로 파싱되어야 한다.
- 모든 참조 id(role-id/family-id/lens-id)는 실제 정의에 존재해야 한다(orphan 0).
- 고정 id 집합(대소문자·하이픈 정확히 준수):
  - 렌즈 11개: `LENS-VALUE, LENS-TECH, LENS-PRODUCT, LENS-FINANCE, LENS-OPS, LENS-INTEGRATION, LENS-SECURITY, LENS-LEGAL, LENS-CUSTOMER, LENS-REVENUE, LENS-CONTRARIAN`
  - 패밀리 26개: `FAM-CEO, FAM-ORCH, FAM-CTO, FAM-CPO, FAM-CFO, FAM-COO, FAM-CPTO, FAM-VPENG, FAM-PRODUCT-MGMT, FAM-UX-RESEARCH, FAM-DESIGN, FAM-STRATEGY, FAM-ENG-FRONTEND, FAM-ENG-BACKEND, FAM-ENG-SPECIAL, FAM-PLATFORM-INFRA, FAM-ARCHITECTURE-TECH, FAM-ARCHITECTURE-BIZ, FAM-DATA, FAM-QA, FAM-SECURITY, FAM-OPS-DELIVERY, FAM-GTM-GROWTH, FAM-GTM-SALES, FAM-REVOPS, FAM-LEGAL`
  - 티어 3개: `light, standard, heavy` / 모드 2개: `divergent, converge`

---

## File Structure

| 파일 | 책임 | 신규/수정 |
|---|---|---|
| `org-os/00-role-registry/capability-families.yaml` | 62 role → 26 패밀리 매핑 | 신규 (Task 1) |
| `org-os/00-role-registry/lens-registry.yaml` | 11 렌즈 정의 + 렌즈↔패밀리 | 신규 (Task 2) |
| `org-os/06-agent-work/governance-tiers.yaml` | 위험→티어 파생 + 티어별 요구 | 신규 (Task 3) |
| `org-os/06-agent-work/execution-policy.yaml` | 파이프라인·병렬감사·재적재 제어 | 신규 (Task 4) |
| `org-os/06-agent-work/collaboration-modes.yaml` | 발산/수렴 실행형태 | 신규 (Task 5) |
| `org-os/00-role-registry/role-selection-scorecard.yaml` | mode/tier/lens 필드·규칙 | 수정 (Task 6) |
| `org-os/06-agent-work/context-package-spec.yaml` | mode/tier/lens 필드 | 수정 (Task 6) |
| `org-os/00-role-registry/state-transition-rules.yaml` | 상태어휘 정합 + tier-modifiers | 수정 (Task 7) |
| `org-os/README.md` | 신규 파일 등재 + 03-products 정리 | 수정 (Task 8) |

의존 순서: Task 1(families) → Task 2(lenses, families 참조) → Task 3,4(독립) → Task 5(lenses·execution 참조) → Task 6,7(기존 파일) → Task 8(README + 통합 게이트).

---

## Task 0: 리포지토리 준비

**Files:** 없음 (환경 초기화)

- [ ] **Step 1: git 저장소 초기화**

Run:
```bash
cd /home/donghyeon/dev/company-haness
git init && git add -A && git commit -m "chore: baseline org-os spec before collaboration overlay"
```
Expected: `Initialized empty Git repository ...` 후 baseline 커밋 생성. (이미 repo면 `git init`은 무해.)

- [ ] **Step 2: pyyaml 확인**

Run: `python3 -c "import yaml; print(yaml.__version__)"`
Expected: `6.0.1` (또는 임의 버전 출력). 실패 시 `pip install pyyaml`.

- [ ] **Step 3: 검증 헬퍼 위치 확인 (scratchpad, 비커밋)**

Run: `mkdir -p /tmp/orgos-verify && echo ok`
Expected: `ok`. 이후 모든 검증 python은 이 경로에 임시 저장하며 **repo에 커밋하지 않는다**.

---

## Task 1: capability-families.yaml (62 → 26 패밀리)

**Files:**
- Create: `org-os/00-role-registry/capability-families.yaml`
- Verify(temp): `/tmp/orgos-verify/check_families.py`

**Interfaces:**
- Consumes: `org-os/00-role-registry/roles.yaml` (role-id 집합)
- Produces: `family-id` 26개 + 각 패밀리의 `member-role-ids`, `carries-lenses`, `audit-capable` — Task 2/5/6에서 참조.

- [ ] **Step 1: 실패하는 검증 작성**

Create `/tmp/orgos-verify/check_families.py`:
```python
import yaml, sys
ROOT = "/home/donghyeon/dev/company-haness/org-os/00-role-registry"
roles = yaml.safe_load(open(f"{ROOT}/roles.yaml"))
role_ids = {r["role-id"] for r in roles["role-registry"]["roles"]}
fam = yaml.safe_load(open(f"{ROOT}/capability-families.yaml"))
families = fam["capability-families"]["families"]
mapped = [rid for f in families for rid in f["member-role-ids"]]
assert len(families) == 26, f"expected 26 families, got {len(families)}"
assert len(mapped) == len(set(mapped)), "duplicate role in families"
assert set(mapped) == role_ids, f"mismatch: missing={role_ids-set(mapped)} extra={set(mapped)-role_ids}"
print("OK families:", len(families), "roles:", len(mapped))
```
Run: `python3 /tmp/orgos-verify/check_families.py`
Expected: FAIL — `FileNotFoundError: capability-families.yaml`.

- [ ] **Step 2: 파일 작성**

Create `org-os/00-role-registry/capability-families.yaml`:
```yaml
capability-families:
  version: 1
  purpose: >
    62개 참조 role(roles.yaml)을 실제 인스턴스화·라우팅 단위인 26개 패밀리로 묶는다.
    같은 렌즈/역량을 공유하는 role만 한 패밀리로 묶으며, 서로 다른 렌즈는 병합하지 않는다.
  source-of-roles: org-os/00-role-registry/roles.yaml
  reference-taxonomy-preserved: true
  family-count: 26
  role-count-covered: 62
  rules:
    - 모든 role-id는 정확히 하나의 패밀리에 속한다(중복·누락 금지).
    - 서로 다른 lens를 carry하는 role은 같은 패밀리로 병합하지 않는다(lens-registry R1).
    - audit-capable=true 패밀리만 감사/검증 역할로 배정할 수 있다.
    - 임원 8개 패밀리는 각자 distinct 렌즈라 통합하지 않는다(다양성 보존).
  families:
    - { family-id: FAM-CEO, member-role-ids: [EXEC-CEO], carries-lenses: [LENS-VALUE], audit-capable: false, default-team-types: [Leadership], instantiation-priority: mvp }
    - { family-id: FAM-ORCH, member-role-ids: [OPS-ORCH], carries-lenses: [], audit-capable: false, default-team-types: [Operations], instantiation-priority: mvp }
    - { family-id: FAM-CTO, member-role-ids: [EXEC-CTO], carries-lenses: [LENS-TECH], audit-capable: false, default-team-types: [Leadership, Platform], instantiation-priority: mvp }
    - { family-id: FAM-CPO, member-role-ids: [EXEC-CPO], carries-lenses: [LENS-PRODUCT], audit-capable: false, default-team-types: [Leadership, Stream-aligned], instantiation-priority: mvp }
    - { family-id: FAM-CFO, member-role-ids: [EXEC-CFO], carries-lenses: [LENS-FINANCE], audit-capable: false, default-team-types: [Leadership, Enabling], instantiation-priority: mvp }
    - { family-id: FAM-COO, member-role-ids: [EXEC-COO], carries-lenses: [LENS-OPS], audit-capable: false, default-team-types: [Leadership, Enabling], instantiation-priority: standard }
    - { family-id: FAM-CPTO, member-role-ids: [EXEC-CPTO], carries-lenses: [LENS-INTEGRATION], audit-capable: false, default-team-types: [Leadership], instantiation-priority: standard }
    - { family-id: FAM-VPENG, member-role-ids: [EXEC-VPENG], carries-lenses: [LENS-TECH], audit-capable: true, default-team-types: [Leadership, Enabling], instantiation-priority: mvp }
    - { family-id: FAM-PRODUCT-MGMT, member-role-ids: [PROD-PM, PROD-PO, PROD-TPO, PROD-PPO], carries-lenses: [LENS-PRODUCT], audit-capable: false, default-team-types: [Stream-aligned, Complicated Subsystem, Platform], instantiation-priority: mvp }
    - { family-id: FAM-UX-RESEARCH, member-role-ids: [UX-RESEARCHER, DATA-ANALYST], carries-lenses: [LENS-CUSTOMER], audit-capable: false, default-team-types: [Enabling, Stream-aligned], instantiation-priority: standard }
    - { family-id: FAM-DESIGN, member-role-ids: [DES-PROD, DES-PLATFORM, DES-INTERNAL], carries-lenses: [LENS-CUSTOMER], audit-capable: false, default-team-types: [Stream-aligned, Platform], instantiation-priority: standard }
    - { family-id: FAM-STRATEGY, member-role-ids: [STR-ANALYST], carries-lenses: [LENS-VALUE, LENS-FINANCE], audit-capable: false, default-team-types: [Enabling], instantiation-priority: standard }
    - { family-id: FAM-ENG-FRONTEND, member-role-ids: [ENG-FE, ENG-FEPLAT, ENG-FEUX], carries-lenses: [LENS-TECH], audit-capable: false, default-team-types: [Stream-aligned, Platform], instantiation-priority: mvp }
    - { family-id: FAM-ENG-BACKEND, member-role-ids: [ENG-BE, ENG-BEGEN, ENG-PRODSERVER, ENG-PLATSERVER, ENG-PRODUCTMINDED, ENG-SW], carries-lenses: [LENS-TECH], audit-capable: false, default-team-types: [Stream-aligned, Platform], instantiation-priority: mvp }
    - { family-id: FAM-ENG-SPECIAL, member-role-ids: [ENG-DESKTOP, ENG-PRODCHAPTER], carries-lenses: [LENS-TECH], audit-capable: false, default-team-types: [Complicated Subsystem, Platform], instantiation-priority: later }
    - { family-id: FAM-PLATFORM-INFRA, member-role-ids: [INFRA-DEV, INFRA-PLATFORM, INFRA-DEVOPS, SRE, SEC-DEVSECOPS], carries-lenses: [LENS-TECH, LENS-SECURITY], audit-capable: true, default-team-types: [Platform], instantiation-priority: standard }
    - { family-id: FAM-ARCHITECTURE-TECH, member-role-ids: [ARCH-EA, ARCH-SOLUTION, ARCH-APP, ARCH-TECH, ARCH-IT, ARCH-SYSANALYST, ARCH-SWAT], carries-lenses: [LENS-TECH], audit-capable: true, default-team-types: [Complicated Subsystem, Enabling, Platform], instantiation-priority: standard }
    - { family-id: FAM-ARCHITECTURE-BIZ, member-role-ids: [ARCH-BA, ARCH-BIZANALYST], carries-lenses: [LENS-OPS, LENS-VALUE], audit-capable: false, default-team-types: [Enabling], instantiation-priority: later }
    - { family-id: FAM-DATA, member-role-ids: [ARCH-DATA, DATA-ENGINEER, DATA-BIGDATA], carries-lenses: [LENS-TECH], audit-capable: false, default-team-types: [Platform, Complicated Subsystem], instantiation-priority: standard }
    - { family-id: FAM-QA, member-role-ids: [QA], carries-lenses: [], audit-capable: true, default-team-types: [Enabling, Stream-aligned], instantiation-priority: mvp }
    - { family-id: FAM-SECURITY, member-role-ids: [SEC-ENGINEER, SEC-APPSEC, SEC-CHAMPION], carries-lenses: [LENS-SECURITY], audit-capable: true, default-team-types: [Enabling, Complicated Subsystem, Stream-aligned], instantiation-priority: standard }
    - { family-id: FAM-OPS-DELIVERY, member-role-ids: [OPS-CH, OPS-CREW], carries-lenses: [LENS-OPS, LENS-CUSTOMER], audit-capable: false, default-team-types: [Stream-aligned], instantiation-priority: later }
    - { family-id: FAM-GTM-GROWTH, member-role-ids: [GTM-GROWTHPM, GTM-DEMANDGEN, GTM-PMM, GTM-CI], carries-lenses: [LENS-REVENUE], audit-capable: false, default-team-types: [GTM Revenue, Stream-aligned, Enabling], instantiation-priority: standard }
    - { family-id: FAM-GTM-SALES, member-role-ids: [GTM-SALES, GTM-CS, GTM-PARTNER], carries-lenses: [LENS-REVENUE, LENS-CUSTOMER], audit-capable: false, default-team-types: [GTM Revenue, Stream-aligned], instantiation-priority: standard }
    - { family-id: FAM-REVOPS, member-role-ids: [GTM-REVOPS, GTM-PRICING], carries-lenses: [LENS-REVENUE, LENS-FINANCE], audit-capable: false, default-team-types: [GTM Revenue, Platform, Enabling], instantiation-priority: mvp }
    - { family-id: FAM-LEGAL, member-role-ids: [GTM-LEGAL], carries-lenses: [LENS-LEGAL], audit-capable: true, default-team-types: [GTM Revenue, Enabling], instantiation-priority: standard }
```

- [ ] **Step 3: 검증 통과 확인**

Run: `python3 /tmp/orgos-verify/check_families.py`
Expected: PASS — `OK families: 26 roles: 62`

- [ ] **Step 4: 커밋**

```bash
git add org-os/00-role-registry/capability-families.yaml
git commit -m "feat(org-os): add capability-families overlay (62 roles -> 26 families)"
```

---

## Task 2: lens-registry.yaml (11 불가침 렌즈)

**Files:**
- Create: `org-os/00-role-registry/lens-registry.yaml`
- Verify(temp): `/tmp/orgos-verify/check_lenses.py`

**Interfaces:**
- Consumes: Task 1의 `capability-families.yaml` (`carries-lenses` 역방향)
- Produces: `lens-id` 11개 + 각 렌즈 `carrier-families` — Task 5/6에서 참조.

- [ ] **Step 1: 실패하는 검증 작성**

Create `/tmp/orgos-verify/check_lenses.py`:
```python
import yaml
ROOT = "/home/donghyeon/dev/company-haness/org-os/00-role-registry"
fam = yaml.safe_load(open(f"{ROOT}/capability-families.yaml"))["capability-families"]["families"]
lens = yaml.safe_load(open(f"{ROOT}/lens-registry.yaml"))["lens-registry"]
lenses = {l["lens-id"]: l for l in lens["lenses"]}
fam_ids = {f["family-id"] for f in fam}
# invert families -> lens -> carriers
inv = {}
for f in fam:
    for L in f["carries-lenses"]:
        inv.setdefault(L, set()).add(f["family-id"])
assert len(lenses) == 11, f"expected 11 lenses, got {len(lenses)}"
for lid, l in lenses.items():
    carriers = set(l.get("carrier-families", []))
    # LENS-CONTRARIAN is rotation-based: allowed to be empty/special
    if lid == "LENS-CONTRARIAN":
        continue
    assert carriers, f"{lid} has no carrier"
    assert carriers <= fam_ids, f"{lid} carriers not in families: {carriers-fam_ids}"
    assert carriers == inv.get(lid, set()), f"{lid} carrier mismatch: registry={carriers} families={inv.get(lid)}"
print("OK lenses:", len(lenses))
```
Run: `python3 /tmp/orgos-verify/check_lenses.py`
Expected: FAIL — `FileNotFoundError: lens-registry.yaml`.

- [ ] **Step 2: 파일 작성**

Create `org-os/00-role-registry/lens-registry.yaml`:
```yaml
lens-registry:
  version: 1
  purpose: >
    서로 구별되는 11개 평가 렌즈를 다양성의 바닥으로 고정한다.
    다양성은 렌즈 수에서 나오며 role headcount가 아니다. 효율화(패밀리 통합)는 이 바닥을 줄이지 않는다.
  source-document: org-os/00-role-registry/team-topology-map.yaml (executive-balance)
  rules:
    - R1. 패밀리 통합 시 서로 다른 lens는 절대 병합 금지. 같은 lens의 중복 role만 합친다.
    - R2. divergent 모드는 tier별 최소 렌즈 수 이상을 병렬로 커버해야 한다.
    - R3. converge 모드(특히 heavy)는 렌즈 의견을 하나로 뭉치지 말고 트레이드오프째 노출한다.
    - R4. LENS-CONTRARIAN 담당 패밀리는 해당 옵션을 작성한 패밀리와 달라야 한다(이해상충 방지).
  lenses:
    - { lens-id: LENS-VALUE, name: 장기가치, question: 장기 회사가치·포트폴리오 적합성?, carrier-families: [FAM-CEO, FAM-STRATEGY, FAM-ARCHITECTURE-BIZ], primary: FAM-CEO }
    - { lens-id: LENS-TECH, name: 기술, question: 아키텍처·안정성·확장성·기술부채?, carrier-families: [FAM-CTO, FAM-VPENG, FAM-ENG-FRONTEND, FAM-ENG-BACKEND, FAM-ENG-SPECIAL, FAM-PLATFORM-INFRA, FAM-ARCHITECTURE-TECH, FAM-DATA], primary: FAM-CTO }
    - { lens-id: LENS-PRODUCT, name: 제품, question: 고객문제·제품가치·로드맵·P/L?, carrier-families: [FAM-CPO, FAM-PRODUCT-MGMT], primary: FAM-CPO }
    - { lens-id: LENS-FINANCE, name: 재무, question: 비용·ROI·자본효율·기회비용?, carrier-families: [FAM-CFO, FAM-STRATEGY, FAM-REVOPS], primary: FAM-CFO }
    - { lens-id: LENS-OPS, name: 운영, question: 운영타당성·프로세스·지원부담?, carrier-families: [FAM-COO, FAM-OPS-DELIVERY, FAM-ARCHITECTURE-BIZ], primary: FAM-COO }
    - { lens-id: LENS-INTEGRATION, name: 제품기술통합, question: 제품-기술 통합·충돌 감소?, carrier-families: [FAM-CPTO], primary: FAM-CPTO }
    - { lens-id: LENS-SECURITY, name: 보안, question: 위협·shift-left·데이터 무결성?, carrier-families: [FAM-SECURITY, FAM-PLATFORM-INFRA], primary: FAM-SECURITY }
    - { lens-id: LENS-LEGAL, name: 법무, question: 계약·컴플라이언스·프라이버시?, carrier-families: [FAM-LEGAL], primary: FAM-LEGAL }
    - { lens-id: LENS-CUSTOMER, name: 고객, question: 사용자 리서치·고객의 소리·경험?, carrier-families: [FAM-UX-RESEARCH, FAM-DESIGN, FAM-GTM-SALES, FAM-OPS-DELIVERY], primary: FAM-UX-RESEARCH }
    - { lens-id: LENS-REVENUE, name: 매출, question: 매출영향·GTM motion·lead-to-cash?, carrier-families: [FAM-REVOPS, FAM-GTM-GROWTH, FAM-GTM-SALES], primary: FAM-REVOPS }
    - { lens-id: LENS-CONTRARIAN, name: 역발상, question: 이걸 하지 말아야 할 이유·무엇이 깨지나?, carrier-families: [], carrier-policy: rotation-any-audit-capable-non-authoring-family, primary: null }
```

- [ ] **Step 3: 검증 통과 확인**

Run: `python3 /tmp/orgos-verify/check_lenses.py`
Expected: PASS — `OK lenses: 11`

- [ ] **Step 4: 커밋**

```bash
git add org-os/00-role-registry/lens-registry.yaml
git commit -m "feat(org-os): add lens-registry overlay (11 inviolable lenses)"
```

---

## Task 3: governance-tiers.yaml (경량/표준/중대 티어)

**Files:**
- Create: `org-os/06-agent-work/governance-tiers.yaml`
- Verify(temp): `/tmp/orgos-verify/check_tiers.py`

**Interfaces:**
- Produces: `tiers.{light,standard,heavy}` + `derivation` — Task 5/7에서 참조.

- [ ] **Step 1: 실패하는 검증 작성**

Create `/tmp/orgos-verify/check_tiers.py`:
```python
import yaml
P = "/home/donghyeon/dev/company-haness/org-os/06-agent-work/governance-tiers.yaml"
g = yaml.safe_load(open(P))["governance-tiers"]
tiers = g["tiers"]
assert set(tiers) == {"light", "standard", "heavy"}, f"tiers={set(tiers)}"
for t in tiers.values():
    assert "converge" in t and "divergent" in t, "tier missing converge/divergent"
assert g["derivation"]["rule"]["base"]["High"] == "heavy"
assert g["derivation"]["rule"]["base"]["Critical"] == "heavy"
hg = tiers["heavy"]["converge"]["human-gate"]["human-decider-when"]
assert "risk-High-or-Critical" in hg and "blast-production-customer-revenue" in hg
print("OK tiers:", list(tiers))
```
Run: `python3 /tmp/orgos-verify/check_tiers.py`
Expected: FAIL — `FileNotFoundError`.

- [ ] **Step 2: 파일 작성**

Create `org-os/06-agent-work/governance-tiers.yaml`:
```yaml
governance-tiers:
  version: 1
  purpose: 위험도에 비례해 협업 의식의 무게를 조절한다. HEAVY는 기존 DRAI 동작과 동일.
  backward-compatibility: >
    TIER-HEAVY == 기존 drai-matrix + state-transition Approved 조건. 기존 High/Critical 경로는 자동으로 HEAVY.
  derivation:
    inputs:
      risk-level: [Low, Med, High, Critical]
      reversibility: [two-way-door, one-way-door]
      blast-radius: [single-role, cross-team, production-customer-revenue]
    rule:
      base: { Low: light, Med: standard, High: heavy, Critical: heavy }
      modifiers:
        - { if: reversibility-is-one-way-door, effect: bump-up-one-level }
        - { if: blast-radius-is-cross-team, effect: bump-up-one-level }
      hard-floor:
        - { if: blast-radius-is-production-customer-revenue, effect: min-tier-heavy }
      cap: heavy
      no-auto-downgrade-below: base
      human-can-escalate-up: true
    examples:
      - { risk: Low, reversibility: one-way-door, blast: single-role, result: standard }
      - { risk: Med, reversibility: one-way-door, blast: cross-team, result: heavy }
      - { risk: Low, reversibility: two-way-door, blast: single-role, result: light }
  tiers:
    light:
      converge:
        deciders: [owner-role-agent]
        reviewers: 1
        auditors: 0
        auditor-added-when: [security, legal, privacy]
        evidence-grade-min: E2
        human: not-required
      divergent: { min-distinct-lenses: 3, contrarian-required: false, synthesis: 1 }
      wave-execution: pipeline
    standard:
      converge:
        deciders: [decider-role-agent]
        recommenders: parallel
        auditors: 1
        evidence-grade-min: E3
        human: informed-non-blocking
      divergent: { min-distinct-lenses: 5, contrarian-required: true, synthesis: 1 }
      wave-execution: pipeline
    heavy:
      converge:
        drai: full-per-drai-matrix
        audit-fanout: { min-independent-verifiers: 3, kill-on: majority-refute }
        evidence-grade-min: E3
        unresolved-critical-risks: false
        human-gate:
          human-decider-when: [risk-High-or-Critical, blast-production-customer-revenue]
          else: { decider: EXEC-CEO, human: informed-non-blocking }
      divergent: { min-distinct-lenses: all-relevant, contrarian-required: true, synthesis: tradeoff-matrix }
      wave-execution: pipeline-with-barrier-at-synthesis
```

- [ ] **Step 3: 검증 통과 확인**

Run: `python3 /tmp/orgos-verify/check_tiers.py`
Expected: PASS — `OK tiers: ['light', 'standard', 'heavy']`

- [ ] **Step 4: 커밋**

```bash
git add org-os/06-agent-work/governance-tiers.yaml
git commit -m "feat(org-os): add governance-tiers overlay (light/standard/heavy)"
```

---

## Task 4: execution-policy.yaml (파이프라인·병렬감사)

**Files:**
- Create: `org-os/06-agent-work/execution-policy.yaml`
- Verify(temp): `/tmp/orgos-verify/check_exec.py`

**Interfaces:**
- Produces: `pipeline-default`, `parallel-audit-fanout`, `re-hydration-control` — Task 5에서 참조.

- [ ] **Step 1: 실패하는 검증 작성**

Create `/tmp/orgos-verify/check_exec.py`:
```python
import yaml
P = "/home/donghyeon/dev/company-haness/org-os/06-agent-work/execution-policy.yaml"
e = yaml.safe_load(open(P))["execution-policy"]
assert e["pipeline-default"] is True
assert e["parallel-audit-fanout"]["min-independent-verifiers"] >= 3
assert e["wave"]["semantics"] == "concurrency-cap-not-barrier"
assert "divergent-synthesis" in e["barrier-allowed-only-when"]
print("OK execution-policy")
```
Run: `python3 /tmp/orgos-verify/check_exec.py`
Expected: FAIL — `FileNotFoundError`.

- [ ] **Step 2: 파일 작성**

Create `org-os/06-agent-work/execution-policy.yaml`:
```yaml
execution-policy:
  version: 1
  purpose: wave를 배리어가 아닌 파이프라인으로 실행하고, 감사를 병렬화하며, 재적재 비용을 통제한다.
  pipeline-default: true
  barrier-allowed-only-when:
    - divergent-synthesis
    - dedup-across-all-findings
    - early-exit-on-zero
    - cross-item-comparison-required
  wave:
    max-concurrent-role-agents: 5
    semantics: concurrency-cap-not-barrier
    note: scorecard의 wave-size 5는 동시성 상한이며 wave 완료를 기다리는 배리어가 아니다.
  parallel-audit-fanout:
    applies-to-tier: heavy
    min-independent-verifiers: 3
    verifier-prompt-stance: refute
    verifier-lens-diversity: required
    kill-on: majority-refute
    on-kill: set-state-Blocked
  verifier-independence:
    rule: 검증자 패밀리는 자기 패밀리가 작성한 산출물을 검증할 수 없다
    source: roles.yaml independent-audit-policy 이해상충 규칙과 정합
  re-hydration-control:
    pass-forward: structured-summary-and-evidence-links-only
    forbid: raw-logs
    enforce: org-os/06-agent-work/context-package-spec.yaml compression-policy
```

- [ ] **Step 3: 검증 통과 확인**

Run: `python3 /tmp/orgos-verify/check_exec.py`
Expected: PASS — `OK execution-policy`

- [ ] **Step 4: 커밋**

```bash
git add org-os/06-agent-work/execution-policy.yaml
git commit -m "feat(org-os): add execution-policy overlay (pipeline + parallel audit)"
```

---

## Task 5: collaboration-modes.yaml (발산/수렴)

**Files:**
- Create: `org-os/06-agent-work/collaboration-modes.yaml`
- Verify(temp): `/tmp/orgos-verify/check_modes.py`

**Interfaces:**
- Consumes: Task 2(lens-registry), Task 3(governance-tiers), Task 4(execution-policy)
- Produces: `modes.{divergent,converge}` — Task 6에서 scorecard가 참조.

- [ ] **Step 1: 실패하는 검증 작성**

Create `/tmp/orgos-verify/check_modes.py`:
```python
import yaml
P = "/home/donghyeon/dev/company-haness/org-os/06-agent-work/collaboration-modes.yaml"
m = yaml.safe_load(open(P))["collaboration-modes"]
assert set(m["modes"]) == {"divergent", "converge"}, f"modes={set(m['modes'])}"
assert m["mode-selection"]["declared-at"] == "intake"
d = m["modes"]["divergent"]
assert d["synthesis"]["must-not"], "divergent synthesis must forbid merging/deciding"
assert d["barrier"] == "allowed"
print("OK modes:", list(m["modes"]))
```
Run: `python3 /tmp/orgos-verify/check_modes.py`
Expected: FAIL — `FileNotFoundError`.

- [ ] **Step 2: 파일 작성**

Create `org-os/06-agent-work/collaboration-modes.yaml`:
```yaml
collaboration-modes:
  version: 1
  purpose: 발산(아이디어 생성)과 수렴(결정·승인)을 분리해 각각 최적 실행형태로 돌린다.
  mode-selection:
    declared-at: intake
    declared-by: EXEC-CEO
    values: [divergent, converge]
    default: converge
  modes:
    divergent:
      goal: 다양한 옵션·아이디어 생성
      mechanism: per-lens-parallel-fanout
      fanout:
        assign: 각 에이전트에 서로 다른 lens와 divergent-framing 부여
        source-of-lenses: org-os/00-role-registry/lens-registry.yaml
        min-distinct-lenses: from-governance-tiers
        contrarian: LENS-CONTRARIAN 포함(티어 규칙에 따름), 옵션 작성 패밀리와 다른 패밀리가 담당
      synthesis:
        role: 합성 에이전트 1명
        must: 옵션 수집·정리, 렌즈별 트레이드오프 노출
        must-not: 단일 추천으로 병합하거나 결정하기
      barrier: allowed
      output: option-set (옵션별 lens 트레이드오프)
    converge:
      goal: 책임소재 있는 결정·승인
      mechanism: tier-weighted-DRAI
      execution: { recommenders: parallel, auditors: parallel-when-heavy, decider: consumes }
      output: decision-record (선택 옵션 + 인정된 트레이드오프 + dissent 기록)
      rule: High/Critical → 인간 decider (governance-tiers human-gate 준수)
  two-phase:
    divergent-then-converge:
      when: 사용자가 아이디어 후 결정을 함께 원할 때
      execution: pipeline (발산 option-set → 수렴 입력)
```

- [ ] **Step 3: 검증 통과 확인**

Run: `python3 /tmp/orgos-verify/check_modes.py`
Expected: PASS — `OK modes: ['divergent', 'converge']`

- [ ] **Step 4: 커밋**

```bash
git add org-os/06-agent-work/collaboration-modes.yaml
git commit -m "feat(org-os): add collaboration-modes overlay (divergent/converge)"
```

---

## Task 6: scorecard + context-package 참조 배선

**Files:**
- Modify: `org-os/00-role-registry/role-selection-scorecard.yaml`
- Modify: `org-os/06-agent-work/context-package-spec.yaml`
- Verify(temp): `/tmp/orgos-verify/check_wiring.py`

**Interfaces:**
- Consumes: Task 3(tier), Task 5(mode), Task 2(lens)
- Produces: scorecard output-template의 `mode/tier/assigned-lens/lens-coverage`, context-package의 동일 필드.

- [ ] **Step 1: 실패하는 검증 작성**

Create `/tmp/orgos-verify/check_wiring.py`:
```python
import yaml
R = "/home/donghyeon/dev/company-haness/org-os"
sc = yaml.safe_load(open(f"{R}/00-role-registry/role-selection-scorecard.yaml"))["role-selection-scorecard"]
ot = sc["output-template"]
for k in ["mode", "tier", "assigned-lens", "lens-coverage"]:
    assert k in ot, f"scorecard output-template missing {k}"
hr = "\n".join(sc["hard-rules"])
assert "mode" in hr and "tier" in hr and "lens" in hr, "scorecard hard-rules missing mode/tier/lens rule"
cp = yaml.safe_load(open(f"{R}/06-agent-work/context-package-spec.yaml"))["context-package-spec"]
for k in ["mode", "tier", "assigned-lens", "divergent-framing"]:
    assert k in cp["schema"], f"context-package schema missing {k}"
print("OK wiring")
```
Run: `python3 /tmp/orgos-verify/check_wiring.py`
Expected: FAIL — `AssertionError: scorecard output-template missing mode`.

- [ ] **Step 2: scorecard output-template에 필드 추가**

`org-os/00-role-registry/role-selection-scorecard.yaml`의 `output-template:` 블록에서 마지막 `reason:` 줄 아래에 다음을 같은 들여쓰기로 추가:
```yaml
    mode: divergent / converge
    tier: light / standard / heavy
    assigned-lens:
    lens-coverage:
```

- [ ] **Step 3: scorecard hard-rules에 규칙 추가**

같은 파일의 `hard-rules:` 리스트 끝에 다음 3개 항목 추가(기존 항목과 같은 `- ` 들여쓰기):
```yaml
    - A workflow must declare mode and tier before the first execution wave.
    - Divergent mode must cover at least the tier's min-distinct-lenses in parallel (governance-tiers).
    - Converge heavy must expose lens tradeoffs and must not merge distinct lenses into one recommendation.
```

- [ ] **Step 4: context-package-spec schema에 필드 추가**

`org-os/06-agent-work/context-package-spec.yaml`의 `schema:` 블록에서 `task-id:` 아래(또는 `objective:` 위)에 다음을 같은 들여쓰기로 추가:
```yaml
    mode: divergent / converge
    tier: light / standard / heavy
    assigned-lens:
    divergent-framing:
```
그리고 같은 파일의 `required-fields:` 리스트에 `- mode`, `- tier` 두 줄을 추가.

- [ ] **Step 5: 두 파일 파싱 + 검증 통과 확인**

Run:
```bash
python3 -c "import yaml; yaml.safe_load(open('org-os/00-role-registry/role-selection-scorecard.yaml')); yaml.safe_load(open('org-os/06-agent-work/context-package-spec.yaml')); print('parse ok')"
python3 /tmp/orgos-verify/check_wiring.py
```
Expected: `parse ok` 다음 `OK wiring`

- [ ] **Step 6: 커밋**

```bash
git add org-os/00-role-registry/role-selection-scorecard.yaml org-os/06-agent-work/context-package-spec.yaml
git commit -m "feat(org-os): wire mode/tier/lens into scorecard and context-package"
```

---

## Task 7: state-transition-rules 정합 배선

**Files:**
- Modify: `org-os/00-role-registry/state-transition-rules.yaml`
- Verify(temp): `/tmp/orgos-verify/check_states.py`

**Interfaces:**
- Consumes: Task 3(governance-tiers, tier-modifiers 단일 원천)
- Produces: `state-vocabulary-map`, `tier-modifiers` — hook 구현(후속 라운드)이 참조.

- [ ] **Step 1: 실패하는 검증 작성**

Create `/tmp/orgos-verify/check_states.py`:
```python
import yaml
P = "/home/donghyeon/dev/company-haness/org-os/00-role-registry/state-transition-rules.yaml"
s = yaml.safe_load(open(P))["state-transition-rules"]
svm = s["state-vocabulary-map"]
assert svm["source-of-truth"] == "workflow-stage"
for k in ["workflow-stage", "document-state", "review-state"]:
    assert k in svm, f"missing {k}"
assert "light" in s["tier-modifiers"] and "heavy" in s["tier-modifiers"]
print("OK states")
```
Run: `python3 /tmp/orgos-verify/check_states.py`
Expected: FAIL — `KeyError: 'state-vocabulary-map'`.

- [ ] **Step 2: state-vocabulary-map + tier-modifiers 블록 추가**

`org-os/00-role-registry/state-transition-rules.yaml`의 최상위(`transitions:` 블록 아래, 같은 `state-transition-rules:` 자식 들여쓰기 2칸)에 다음을 추가:
```yaml
  state-vocabulary-map:
    source-of-truth: workflow-stage
    workflow-stage: [intake, discovery, design, review, implementation, verification, release, blocked, closed]
    document-state: [Draft, Review, Approved, Closed]
    review-state: [Submitted-for-Review, Accepted, Changes-Requested, Blocked]
    mapping:
      - workflow-stage가 워크플로우의 단일 원천이다.
      - 각 stage 내부에서 개별 산출물은 document-state를, 부모-자식 수용 1건은 review-state를 가진다.
      - hook은 document-state와 review-state를 전이시킨다.
      - 해당 stage의 게이팅 문서가 Approved 또는 Accepted에 도달하면 workflow-stage가 전진한다.
  tier-modifiers:
    source-of-truth: org-os/06-agent-work/governance-tiers.yaml
    light: { evidence-grade-min: E2, auditor-required: only-when-security-legal-privacy, human: not-required }
    standard: { evidence-grade-min: E3, auditor-required: true, human: informed-non-blocking }
    heavy: { evidence-grade-min: E3, auditor-required: parallel-fanout, human: gate-per-governance-tiers }
    note: 실제 값의 단일 원천은 governance-tiers.yaml이며 여기는 상태전이 관점의 참조다. HEAVY는 기존 Approved 조건과 동일.
```

- [ ] **Step 3: 파싱 + 검증 통과 확인**

Run:
```bash
python3 -c "import yaml; yaml.safe_load(open('org-os/00-role-registry/state-transition-rules.yaml')); print('parse ok')"
python3 /tmp/orgos-verify/check_states.py
```
Expected: `parse ok` 다음 `OK states`

- [ ] **Step 4: 커밋**

```bash
git add org-os/00-role-registry/state-transition-rules.yaml
git commit -m "feat(org-os): reconcile state vocabularies and reference tier-modifiers"
```

---

## Task 8: README 등재 + 전체 통합 게이트

**Files:**
- Modify: `org-os/README.md`
- Verify(temp): `/tmp/orgos-verify/check_all.py`

**Interfaces:**
- Consumes: Task 1–7 모든 산출물. 최종 성공기준(스펙 §7) 게이트.

- [ ] **Step 1: 통합 검증 작성 (성공기준 1–6)**

Create `/tmp/orgos-verify/check_all.py`:
```python
import yaml, glob
R = "/home/donghyeon/dev/company-haness/org-os"
# parse all org-os yaml
for f in glob.glob(f"{R}/**/*.yaml", recursive=True):
    yaml.safe_load(open(f))
roles = yaml.safe_load(open(f"{R}/00-role-registry/roles.yaml"))["role-registry"]["roles"]
role_ids = {r["role-id"] for r in roles}
fams = yaml.safe_load(open(f"{R}/00-role-registry/capability-families.yaml"))["capability-families"]["families"]
fam_ids = {f["family-id"] for f in fams}
lenses = yaml.safe_load(open(f"{R}/00-role-registry/lens-registry.yaml"))["lens-registry"]["lenses"]
lens_ids = {l["lens-id"] for l in lenses}
# 1: 62 roles mapped exactly once
mapped = [rid for f in fams for rid in f["member-role-ids"]]
assert set(mapped) == role_ids and len(mapped) == len(set(mapped)) == 62
# 2: family carries-lenses reference real lenses
for f in fams:
    assert set(f["carries-lenses"]) <= lens_ids, f"{f['family-id']} orphan lens"
# 3+5: every lens has >=1 carrier (except contrarian rotation) + carriers are real families
for l in lenses:
    cf = set(l.get("carrier-families", []))
    assert cf <= fam_ids, f"{l['lens-id']} orphan family {cf-fam_ids}"
    if l["lens-id"] != "LENS-CONTRARIAN":
        assert cf, f"{l['lens-id']} no carrier"
# 4: tier x mode all defined
g = yaml.safe_load(open(f"{R}/06-agent-work/governance-tiers.yaml"))["governance-tiers"]["tiers"]
assert set(g) == {"light","standard","heavy"}
for t in g.values(): assert "converge" in t and "divergent" in t
m = yaml.safe_load(open(f"{R}/06-agent-work/collaboration-modes.yaml"))["collaboration-modes"]["modes"]
assert set(m) == {"divergent","converge"}
# 6: heavy preserves human gate on High/Critical
hg = g["heavy"]["converge"]["human-gate"]["human-decider-when"]
assert "risk-High-or-Critical" in hg
print("OK ALL: 62 roles, 26 families,", len(lens_ids), "lenses, tiers", set(g), "modes", set(m))
```
Run: `python3 /tmp/orgos-verify/check_all.py`
Expected: 이 시점엔 README 미갱신이어도 통과해야 함(README는 검증 대상 아님). PASS — `OK ALL: 62 roles, 26 families, 11 lenses ...`. 실패 시 이전 Task로 돌아가 수정.

- [ ] **Step 2: README Directory Map 갱신**

`org-os/README.md`의 ` ```text ... ``` ` 디렉토리 맵에서:
- `00-role-registry/` 항목 목록에 `lens-registry.yaml`, `capability-families.yaml` 두 줄 추가.
- `06-agent-work/` 항목 목록에 `collaboration-modes.yaml`, `governance-tiers.yaml`, `execution-policy.yaml` 세 줄 추가.

- [ ] **Step 3: README Rules 추가**

`## Rules` 목록 끝에 다음 3줄 추가:
```markdown
- `lens-registry.yaml`는 11개 불가침 평가 렌즈의 단일 원천이며, 다양성 바닥을 정의한다.
- 실제 인스턴스화·라우팅 단위는 `capability-families.yaml`의 26개 패밀리이고, `roles.yaml`의 62개 role은 참조 분류체계로 보존한다.
- 협업 실행은 `collaboration-modes.yaml`(발산/수렴) × `governance-tiers.yaml`(light/standard/heavy)로 결정하며, TIER-HEAVY는 기존 DRAI 동작과 동일하다.
```

- [ ] **Step 4: 03-products 드리프트 정리**

`## Directory Map`의 `03-products/` 항목이 정본(`{product-id}/pr-faq.md·roadmap.md·metrics.md`)임을 유지하고, Rules 목록에 다음 한 줄 추가:
```markdown
- `03-products` 표기는 이 README의 `{product-id}/` 구조를 정본으로 한다(Claude Code 구성 명세 문서의 `03-products/README.md` 표기는 후속 라운드에 이에 맞춘다).
```

- [ ] **Step 5: 최종 파싱 + 통합 게이트 재확인**

Run:
```bash
python3 /tmp/orgos-verify/check_all.py
```
Expected: PASS — `OK ALL: 62 roles, 26 families, 11 lenses, tiers {'light','standard','heavy'} modes {'divergent','converge'}`

- [ ] **Step 6: 커밋**

```bash
git add org-os/README.md
git commit -m "docs(org-os): register overlay files and reconcile 03-products in README"
```

---

## Self-Review 결과 (작성자 점검)

- **Spec coverage:** 스펙 §3.1→Task2, §3.2→Task1, §3.3→Task5, §3.4→Task3, §3.5→Task4, §4.1→Task6, §4.2→Task6, §4.3→Task7, §4.4→Task8, §7 성공기준→Task8 게이트. 갭 없음.
- **Placeholder scan:** 각 신규 파일 전체 내용과 각 수정의 정확한 삽입 블록 포함. "TBD/적절히 처리" 없음.
- **Type consistency:** family-id 26개·lens-id 11개·tier 3개·mode 2개를 Global Constraints에 고정하고 전 Task가 동일 문자열 사용. check_all.py가 상호참조를 최종 검증.

## Notes
- 검증 python은 모두 `/tmp/orgos-verify/`의 임시 파일로 **repo에 커밋하지 않는다**(범위: 명세만). 영구 validator는 후속 라운드.
- 이 계획 완료 후 다음 라운드 입력: 스펙 §5의 흐름을 `.claude`(에이전트·command·hook)로 구현하는 thin vertical slice.