749 lines
38 KiB
Markdown
749 lines
38 KiB
Markdown
---
|
||
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.
|