donghyeon.kang/company-haness
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
main
company-haness/docs/superpowers/plans/2026-07-05-collaboration-efficiency-overlay.md
T

38 KiB
Raw Permalink Blame History

status, applies-to-version, superseded-by, exclude-from, note
status applies-to-version superseded-by exclude-from note
historical-snapshot registry 62 roles / 26 families / 11 lenses (이 계획 실행 시점) 현재 정본 registry 73 roles / 28 families / 12 lenses — org-os/00-role-registry/*
must-read
default-search
구현 완료된 과거 계획. 본문의 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:

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:

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:

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: 커밋
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:

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:

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: 커밋
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:

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:

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: 커밋
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:

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:

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: 커밋
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:

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:

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: 커밋
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:

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: 줄 아래에 다음을 같은 들여쓰기로 추가:

    mode: divergent / converge
    tier: light / standard / heavy
    assigned-lens:
    lens-coverage:
  • Step 3: scorecard hard-rules에 규칙 추가

같은 파일의 hard-rules: 리스트 끝에 다음 3개 항목 추가(기존 항목과 같은 - 들여쓰기):

    - 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: 위)에 다음을 같은 들여쓰기로 추가:

    mode: divergent / converge
    tier: light / standard / heavy
    assigned-lens:
    divergent-framing:

그리고 같은 파일의 required-fields: 리스트에 - mode, - tier 두 줄을 추가.

  • Step 5: 두 파일 파싱 + 검증 통과 확인

Run:

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: 커밋
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:

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칸)에 다음을 추가:

  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:

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: 커밋
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:

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줄 추가:

- `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 목록에 다음 한 줄 추가:

- `03-products` 표기는 이 README의 `{product-id}/` 구조를 정본으로 한다(Claude Code 구성 명세 문서의 `03-products/README.md` 표기는 후속 라운드에 이에 맞춘다).
  • Step 5: 최종 파싱 + 통합 게이트 재확인

Run:

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: 커밋
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.
Reference in New Issue View Git Blame Copy Permalink