claude plugin marketplace add Mineru98/mstack
claude plugin install mstack@ax

/plugin marketplace add Mineru98/mstack
/plugin install mstack@ax

codex plugin marketplace add Mineru98/mstack

/mineru-mode 이 PR에 버그가 있어요. 가만히 두어도 750ms마다 스크롤이 밀립니다. 먼저
재현하고, 고친 다음 검증해 주세요.

/mineru-mode 저는 자러 갑니다. CI가 불안정해도 스택을 머지해 주세요. 아침까지 전부
머지되어 있으면 좋겠습니다.

/how 실행 취소는 어떻게 동작해? 취소할 run을 하나씩 조회하면서 n+1 문제가 생기지는 않아?

/interrogate 이 PR을 리뷰해 줘.

bug fix:           /mineru-mode 이 PR에 버그가 있어요. 가만히 두어도 750ms마다 스크롤이
                   밀립니다. 먼저 재현하고, 고친 다음 검증해 주세요.
perf:              /mineru-mode 가상화(virtualize)를 했는데도 큰 목록이 뜨는 데 1~2초가
                   걸려요. CPU trace를 떠서 이유를 알려 주세요.
feature:           /mineru-mode 기능 플래그 뒤에 작은 기능을 만들어 주세요. 정말 동작하는지
                   검증도 해 주세요.
prototype:         /mineru-mode 비교할 수 있게 markdown renderer 프로토타입을 두 개
                   만들어 주세요. 에이전트를 하나씩 띄워서요.
multi-phase:       /mineru-mode 이 스킬들을 플러그인으로 오픈소스화해 주세요. 내부 정보가
                   새면 안 되고, 임시 디렉터리에서 작업하고, 의존성 그래프부터 보여 주세요.
overnight run:     /mineru-mode 저는 자러 갑니다. CI가 불안정해도 스택을 머지해 주세요.
                   아침까지 전부 머지되어 있으면 좋겠습니다.
babysit:           /mineru-mode PR 123 상태 좀 봐 주세요. 남은 게 있나요?
visual parity:     /mineru-mode 이 플래그를 켜면 행 간격이 너무 넓어요. 두 번째 이미지가
                   정답입니다. 똑같아질 때까지 재현하고 고쳐 주세요.
figure it out:     /mineru-mode 자리를 비웁니다. 동기 store를 쓰는 모든 호출부를 새 비동기
                   store로 옮겨 주세요. 동작은 똑같이 유지해야 합니다. 돌아왔을 때 제대로
                   끝났다고 믿을 수 있었으면 합니다.
how:               /how 실행 취소는 어떻게 동작해? 취소할 run을 하나씩 조회하면서 n+1 문제가
                   생기지는 않아?
why:               /why 이 기능 플래그는 왜 아직 안 켜졌어?
architect:         이 계측은 신호가 뚜렷하고 오탐이 없게 설계해 줘. 먼저 /architect 로
                   진행해 줘.
arena:             /arena 내 프롬프트를 그대로 arena에 가져가 줘. 그쪽 제안과 네 제안을
                   비교해 보고 싶어.
swarm:             /swarm packages/ 아래 모든 패키지를 각자의 check.sh로 검사해 줘. 패키지
                   하나당 워커 하나. 보고서는 하나로.
interrogate:       /interrogate 이 PR을 리뷰해 줘.
tdd:               /tdd implement
unslop:            새로 바뀐 부분에서 슬롭을 걷어내고 더 간결하게 다듬어 줄래?
reflect:           /reflect 너무 오래 걸렸어. 다음번에는 같은 일을 반복하지 않도록 배운
                   점을 정리해 줘.
correct:           /correct
show-me-your-work: /show-me-your-work 돌아와서 검토할 수 있게 결정 기록을 남겨 줘.
automate-me:       /automate-me
help:              /mineru-help 이 브랜치를 리뷰하려면 어떤 스킬을 쓰면 좋아?

flowchart TD
    U["사용자가 /mineru-mode와 작업을 입력"] --> M["mineru-mode가 요청을 분류"]
    M --> PB{"맞는 플레이북이 있는가"}
    PB -->|"있음"| TODO["플레이북 단계를 todo 목록에 그대로 복사<br/>건너뛰는 단계는 skip 사유와 함께 남김"]
    PB -->|"없음 또는 크고 가로지르는 작업"| FIO["figure-it-out<br/>맞춤 플레이북 설계"]
    PB -->|"며칠짜리 상시 프로젝트"| ORCH["Orchestrate 플레이북"]
    FIO --> TODO
    ORCH --> TODO
    TODO --> STEP["단계 실행<br/>필요한 스킬과 원칙을 호출"]
    STEP --> SUB["서브에이전트에 위임<br/>mineru-agent / Explore / general-purpose"]
    SUB --> REV["결과를 직접 검토<br/>diff를 읽고 요약은 내가 작성"]
    REV --> NEXT{"남은 단계가 있는가"}
    NEXT -->|"있음"| STEP
    NEXT -->|"없음"| PR["Opening a PR<br/>모든 플레이북의 마지막 단계"]
    PR --> REPLY["unslop을 거친 답변<br/>적용한 원칙과 바뀐 결정을 명시"]

flowchart LR
    T["작업 입력"] --> P["원칙 색인을 읽음<br/>적용한 원칙을 답변에 명시"]
    P --> R{"트리거"}
    R -->|"간단하지 않은 변경, 아키텍처 결정"| HOW["how"]
    R -->|"함수 경계를 넘는 코드"| ARC["architect"]
    R -->|"병렬 커버리지, 경쟁"| SW["swarm"]
    R -->|"설계나 코드 베이크오프"| AR["arena"]
    R -->|"논쟁적인 설계"| INT["interrogate"]
    R -->|"모든 글과 답변"| UN["unslop"]
    R -->|"문서, RFC, PR 설명, 커밋 메시지"| TW["technical-writing"]
    R -->|"커밋 전, 리뷰 전"| NC["no-comments"]
    R -->|"벤치마크 수치를 보고하기 전"| BC["benchmark-checklist"]
    R -->|"PR 상태 확인"| BB["Babysit 플레이북"]
    R -->|"초록불 스택을 머지"| SH["Shipping 플레이북"]
    R -->|"리뷰 봇 코멘트"| BT["bugbot-triage 기준으로<br/>fix, dismiss, ask 분류"]
    R -->|"길거나 자리를 비우는 작업"| SMW["show-me-your-work"]
    R -->|"사용자에게 질문하기 직전"| Q{"실행해서 관찰할 수 있는 사실인가"}
    Q -->|"예"| PRO["Prototype 플레이북으로 실험"]
    Q -->|"아니오, 제품이나 취향 판단"| ASK["사용자에게 질문"]

flowchart TD
    Q["/mineru-help 질문"] --> W{"작업을 요청하는 문장인가"}
    W -->|"예"| DO["mineru-mode를 읽고 그 아래에서 작업 수행<br/>sticky mode가 없다고 한 번만 안내"]
    W -->|"아니오"| N{"필요가 분명한가"}
    N -->|"아니오"| ASK["객관식 질문 하나<br/>설정 / 작업 시작 / 스킬 고르기 / 문제 해결 / 나에게 맞추기"]
    N -->|"예"| ST
    ASK --> ST["상태 확인<br/>mstack-models 규칙, verify 스킬, 형식 검증 스킬 유무"]
    ST --> SEC["선택된 섹션만 답변"]
    SEC --> OUT["답 + 보낼 프롬프트 예시 하나 + 근거 파일의 공개 링크"]

flowchart TD
    A["/setup-mstack"] --> B["서브에이전트 도구가 받는 모델 목록 감지"]
    B --> C["기존 mstack-models 규칙 읽기<br/>없으면 기본값에서 시작"]
    C --> D["예산 선택<br/>unlimited / large / medium / small"]
    D --> E["예산에 맞춰 모든 실제 슬러그의 effort 조정<br/>inherit-parent와 auto는 그대로"]
    E --> F["역할별 모델 표시 후 수정 여부 확인"]
    F --> G{"선택한 모델이 감지된 목록에 있는가"}
    G -->|"아니오"| F
    G -->|"예"| H["규칙 전체를 덮어써서 저장<br/>Claude Code는 파일, Codex는 표시된 블록"]
    H --> I["새 세션부터 적용된다고 안내"]
    I --> J{"프로젝트에 verify 스킬이 있는가"}
    J -->|"없음"| K["create-verification-skill을 한 번 제안"]
    J -->|"있음"| L
    K --> L{"형식 검증 스킬이 있는가"}
    L -->|"없음"| M["create-formal-verification-skill을 한 번 제안"]
    L -->|"있음"| Z["종료"]
    M --> Z

flowchart LR
    A["/in-your-own-words"] --> B["사용자의 목표와 풀려는 문제를<br/>에이전트가 자기 말로 재진술"]
    B --> C["사용자가 오해를 바로잡음"]
    C --> D["작업 시작"]

flowchart TD
    A["/sharpen과 프롬프트"] --> B["1. 최고 전문가가 요청 밖에서 할 일"]
    B --> C["2. 이미 가공된 자료가 아닌 가장 원재료"]
    C --> D["3. 쓸 방법과 도구"]
    D --> E["4. 나와 에이전트 말고 결과가 맞다고 보여 줄 외부 검증"]
    E --> F["위 네 가지를 요청하도록 프롬프트 재작성<br/>사용자가 정할 선택은 열어 둠"]
    F --> G["다시 쓴 프롬프트만 반환<br/>작업 자체는 하지 않음"]

flowchart LR
    A["/bro"] --> B["직전 메시지를 다시 읽음"]
    B --> C["전문 용어 없이<br/>사람이 사람에게 말하듯 더 짧게 재진술"]

flowchart TD
    A["/ketchup"] --> B["읽기 전용으로 수집<br/>내 작업, 서브에이전트 보고, 다른 사람의 메시지"]
    B --> C["PR, CI, 에이전트의 현재 상태 확인<br/>보여 줄 숫자는 원본과 대조"]
    C --> D["첫 문장<br/>결정을 기다리는 항목 또는 없다는 말"]
    D --> E{"사용자에게 의미 있게 바뀐 것이 있는가"}
    E -->|"없음"| Z["그대로 종료"]
    E -->|"있음"| F["그림 먼저<br/>스크린샷, 영상, 작은 다이어그램"]
    F --> G["요청별 결과 한 줄씩<br/>완료 / 진행 중 / 실패 / 미확인"]
    G --> H{"사용자만 내릴 수 있는 결정이 남았는가"}
    H -->|"있음"| I["결정 항목 전부 나열<br/>링크, 바뀌는 점, 근거, 위험, 내 추천"]
    H -->|"없음"| J["내가 직접 할 수 있는 남은 일 한 줄"]

flowchart TD
    A["/recall"] --> B{"무엇을 원하는가"}
    B -->|"특정 채팅 하나를 이어받기"| SP["Session pickup 플레이북"]
    B -->|"습관을 스킬로 남기기"| AM["automate-me"]
    B -->|"이미 상태 캡슐을 줌"| USE["캡슐을 쓰고 채굴 생략"]
    B -->|"작업 맥락 복원"| C["범위 고정<br/>기간 기본 7일, 주제, 현재 워크스페이스"]
    C --> D["내 채팅 기록 채굴<br/>빠른 모델 서브에이전트가 조각을 나눠 병렬"]
    C --> E{"주제에 기능, 파일, 버그가 있는가"}
    E -->|"있음"| F["why의 조사관으로 공유 기록 탐색<br/>이슈, 채팅, 문서, 에러 추적"]
    E -->|"없음, 활동 회상"| G["공유 기록 생략"]
    D --> H["git과 gh로 PR, 브랜치, 티켓의 현재 상태 확인"]
    F --> H
    G --> H
    H --> I["브리핑<br/>Capsule / Threads / Problems / Next move"]

flowchart TD
    A["어떻게 동작하는가 질문"] --> B{"복잡도"}
    B -->|"단순, 모듈 하나"| C["explainer 하나가<br/>탐색과 설명을 한 번에"]
    B -->|"복잡, 여러 파일이나 서비스"| D["질문을 2~4개 관점으로 분해"]
    D --> E["explorer 여러 명을 한 메시지로 동시에 실행<br/>읽기 전용 Explore"]
    E --> F["explainer 하나가 모든 탐색 결과를 종합"]
    C --> G["결과 제시<br/>Overview / Key Concepts / How It Works / Where Things Live / Gotchas"]
    F --> G

sequenceDiagram
    actor U as 사용자
    participant L as 리드
    participant I as 조사관 (범주당 1명)
    participant S as 종합 에이전트

    U->>L: 이 코드는 왜 이렇게 만들어졌나
    L->>L: 대상과 질문 정리 (모호하면 해석을 밝히고 진행)
    L->>L: 코드 앵커 구축 (git blame, git log, PR 본문과 토론)
    L->>L: 사용 가능한 MCP를 증거 범주 7개에 매핑
    Note over L,I: 소스 관리 / 이슈 / 장문 문서 / 실시간 채팅 / 인프라 관측 / 에러 추적 / 분석 웨어하우스
    L->>I: 범주마다 조사관 1명을 한 메시지로 동시에 실행
    I-->>L: 발견 내용 (결과 없음도 보고)
    L->>S: 조사 결과, 코드 앵커, 질문, epistemics 틀
    S-->>L: 확신도를 분리한 종합 보고
    L-->>U: 인용된 답과 Sources Consulted<br/>코드를 바꿀 계획이면 Preserve / Change / Avoid / Risk

flowchart TD
    A["/teach"] --> B["사용자가 가져갈 것 몇 가지를 결정<br/>대화에서 읽은 배경과 목적 기준"]
    B --> C["how와 why를 동시에 실행<br/>작은 변경이면 하나만"]
    C --> D["쉬운 정의로 시작<br/>일반적인 말로 이름을 붙이고 지금 사례에 연결"]
    D --> E["메커니즘 설명<br/>부분마다 해결하는 문제와 동작 원리"]
    E --> F{"움직이는 부분이 3개 이상인가"}
    F -->|"예"| G["다이어그램을 한 부분씩 더하며 여러 장 그림"]
    F -->|"아니오"| H["필요할 때만 그림 한 장"]
    G --> I["대화로 이어감<br/>더 깊이 갈지는 사용자가 정함"]
    H --> I

flowchart TD
    A["/blast-radius"] --> B["변경 읽기<br/>diff가 말하지 않는 동작 변화까지"]
    B --> C["이 변경이 안전한 이유가 되는<br/>사실 하나를 찾음"]
    C --> D["grep이 멈추는 곳을 봄<br/>라이브러리 소스, 실행 시점, JSON, DB 컬럼, 플래그"]
    D --> E["위험마다 확률, 비용, file:line 기록<br/>확인한 위험과 해소한 위험을 분리"]
    E --> F["핵심 사실을 실제 코드를 실행하는 스크립트나 테스트로 증명"]
    F --> G{"변경이 크고 넓은가"}
    G -->|"예"| H["arena로 여러 모델에 같은 질문 후 병합"]
    G -->|"아니오"| I
    H --> I["결과 반환<br/>What it does / 안전한 이유와 증명 단계 / Risks / Cleared / Before you merge"]

flowchart TD
    A["/architect"] --> B["A. Ground<br/>관련 서브시스템에 how 실행<br/>소유권을 바꾸면 why도 실행"]
    B --> C["B. Sketch<br/>arena로 구조가 다른 후보 2개 이상<br/>design-red-flags로 거름"]
    C --> D{"사용자가 체크포인트를 요청했는가"}
    D -->|"예"| E["C. 종합 설계를 보여 주고 승인 대기"]
    D -->|"아니오, 기본"| F
    E --> F["D. 스케치에 맞춰 구현<br/>벗어나는 곳은 조용히 흡수하지 않고 드러냄"]
    F --> G{"같은 모양의 우회가 반복되는가"}
    G -->|"아니오"| H["산출물<br/>사용 예 먼저, 타입 스케치, rationale"]
    G -->|"예"| I["E. 스케치 폐기<br/>how 재실행, 처음부터 설계했다고 가정하고 재설계, 먼저 빼기"]
    I --> C
    E -.->|"사용자가 형태에 반대"| B

flowchart TD
    A["/arena"] --> B["A. Frame<br/>산출물, 루브릭 3~6개, 러너 모델, 후보별 출력 위치"]
    B --> C["B. Fan out<br/>N개를 한 메시지로 동시에 실행<br/>후보 하나가 비면 N-1로 진행"]
    C --> D["C. Cross-judge<br/>후보가 모두 끝난 뒤 다른 모델 계열의 읽기 전용 심사 하나"]
    C --> E["D. Pick<br/>모든 후보를 끝까지 읽고 루브릭 항목별로 채점"]
    D --> E
    E --> F{"후보들이 수렴했는가"}
    F -->|"한 모양으로 수렴"| G["합의된 모양을 그대로 채택<br/>이식 불필요"]
    F -->|"크게 갈라짐"| H["Frame이 부족했음<br/>다시 정의하고 재실행"]
    H --> B
    F -->|"기본"| I["E. Graft<br/>패자에서 쓸 만한 부분을 손으로 이식"]
    G --> J["F. Verify"]
    I --> J
    J --> K{"문제가 드러났는가"}
    K -->|"Frame이 틀림"| B
    K -->|"이식을 놓침"| I
    K -->|"없음"| L["하나의 산출물 + 종합 노트"]

flowchart TD
    A["/swarm"] --> B["A. Frame<br/>완료 조건, 산출물, 분할 / 경쟁 / 혼합 선택<br/>경쟁이면 first pass / rank all / best-of 미리 선언"]
    B --> C["B. Fan out<br/>워커 N명을 worktree에서 동시에 실행<br/>보고는 PASS / ISSUES / BLOCKED"]
    C --> D["C. Aggregate<br/>결과가 SHA와 측정 방법을 기록했는지 확인"]
    D --> E{"기록이 빠졌는가"}
    E -->|"예, 첫 번째"| F["그 워커를 한 번 재실행"]
    F --> D
    E -->|"두 번째도 빠짐"| G["gap으로 기록<br/>gap은 통과가 아님"]
    E -->|"아니오"| H["D. Report<br/>표, 이슈 한 줄씩, gap과 이탈자, 경쟁 규칙"]
    G --> H

sequenceDiagram
    actor U as 사용자
    participant L as 리드 리뷰어
    participant A as Reviewer A
    participant B as Reviewer B

    U->>L: 리뷰 요청
    L->>L: 범위 확정 (지정한 파일 또는 git diff main...HEAD)
    L->>L: 의도를 한 문단으로 진술 (불확실하면 사용자에게 질문)
    Note over A,B: 모델 목록 길이만큼 리뷰어가 생기고 기본은 opus xhigh와 inherit-parent
    L->>A: 의도, diff, 루브릭, 코드 품질 관점 (파일 수정 금지)
    L->>B: 같은 템플릿, 다른 모델
    A-->>L: 발견 목록
    B-->>L: 발견 목록
    L->>L: 같은 이슈를 병합하고 둘 이상이 독립적으로 지적한 항목에 가중
    L->>L: Act on / Consider / Noted / Dismissed 네 칸으로 판정
    L-->>U: Intent, Reviewers, 네 칸, Agreement Map (자동 적용 없음)

flowchart TD
    A["/figure-it-out"] --> B["A. Frame<br/>반증 가능한 완료 조건, 정량화한 규모, 높게 잡은 엄격도"]
    B --> C["장시간 실행이면 틀과 장단점을 보여 주고 체크포인트 한 번"]
    C --> D["B. 워크플로 설계<br/>독립 착륙 단위로 분해, 가장 위험한 미지수 먼저<br/>검증 하네스와 기준선을 작업 전에 구축"]
    D --> E{"되돌릴 수 없는 설계 결정이 있는가"}
    E -->|"예"| F["architect 실행"]
    E -->|"아니오"| G
    F --> G["설계한 단계 목록을 기록<br/>사람이 검토하는 대상"]
    G --> H["C. 단위마다 가설, 최소 변경, 실제 산출물 측정"]
    H --> I{"완료 조건이 앞으로 나아갔는가"}
    I -->|"예"| J["유지"]
    I -->|"아니오"| K["되돌림<br/>VERIFIED / NOT VERIFIED / INCONCLUSIVE"]
    J --> L["D. show-me-your-work로 결정 기록"]
    K --> L
    L --> M{"남은 단위가 있는가"}
    M -->|"있음"| H
    M -->|"없음"| N["E. 실제 제품에서 A의 조건을 확인<br/>반복된 교정은 린트나 스크립트로 구조화"]

flowchart TD
    A["/tdd"] --> B["버그 이해<br/>의도한 동작, 현재 동작, 가장 작은 재현"]
    B --> C{"싸고 분명한 테스트 경로가 있는가"}
    C -->|"없음"| D["가장 가까운 실행 가능한 검증<br/>스크립트, 재현 명령, 브라우저 자동화, 스냅샷"]
    C -->|"있음"| E["가장 좁은 테스트를 먼저 작성<br/>구현을 흉내 내지 않고 의도한 동작을 표현"]
    E --> F["고치기 전에 실행"]
    F --> G{"의도한 이유로 실패하는가"}
    G -->|"아니오"| E
    G -->|"예"| H["최소 수정으로 고침"]
    H --> I["회귀 테스트 재실행"]
    D --> J
    I --> J["보고<br/>고치기 전 실패 증거, 고친 뒤 통과 증거<br/>없으면 이유와 대체 검증"]

flowchart TD
    A["성능 수치를 얻음"] --> B["실행 전<br/>보고할 문장을 미리 적고 측정 스크립트를 읽고 uptime과 nproc 확인"]
    B --> Q1["1. 왜 두 배가 아닌가: 제한 요인 찾기"]
    Q1 --> Q2["2. 튜닝했는가: 양쪽을 프로덕션 방식으로"]
    Q2 --> Q3["3. 한계를 넘었는가: 대역폭과 코어로 산수"]
    Q3 --> Q4["4. 오류가 났는가: 실패 수와 출력 정확성"]
    Q4 --> Q5["5. 재현되는가: 번갈아 5회 이상, 중앙값과 범위"]
    Q5 --> Q6["6. 중요한가: 전체 경로 대비 비중"]
    Q6 --> Q7["7. 실제로 일어났는가: 측정 구간 안에서 일이 실행됨"]
    Q7 --> V{"제한 요인을 말할 수 있고<br/>4번과 7번을 확인했고 양쪽이 튜닝됐는가"}
    V -->|"아니오"| X["inconclusive<br/>빠진 부분을 명시"]
    V -->|"예"| Y["faster / slower / no measurable difference<br/>수치, 단위, 실행 횟수, 범위, 제한 요인"]

flowchart TD
    A["/no-comments"] --> B["범위 결정<br/>호출자가 준 파일이나 main 대비 현재 diff"]
    B --> C["comment-sicko 서브에이전트 실행"]
    C --> D["보고와 diff 검사<br/>애플리케이션 코드 수정, 범위 이탈, 예외 보호 삭제는 거부"]
    D --> E{"거부할 것이 있는가"}
    E -->|"첫 번째"| F["되돌리고 실패 사유를 적어 한 번 재실행"]
    F --> D
    E -->|"두 번째도 거부"| FAIL["미해결로 보고하고 no-comments 실패"]
    E -->|"없음"| G{"수정에 구조 결정이 필요한가"}
    G -->|"예"| H["architect를 한 번 실행하고 스케치까지만"]
    G -->|"아니오"| I
    H --> I["범위 안에서 가장 작은 근본 원인 수정<br/>우회 코드는 모두 제거"]
    I --> J{"제약을 주장하는 주석인가<br/>do not remove 같은 것"}
    J -->|"예"| K["가장 싼 타입, 런타임, 테스트, CI 린트로 인코딩 제안"]
    K --> L{"승인되었는가"}
    L -->|"예"| M["인코딩하고 주석 삭제"]
    L -->|"아니오"| N["주석 삭제 후 제약을 미해결로 보고"]
    J -->|"아니오"| O
    M --> O["보고<br/>삭제 수, 복원, 재실행, 수정, 인코딩, 미해결 항목"]
    N --> O

flowchart TD
    A["/correct"] --> B["최근 커밋, 되돌림, 리뷰 코멘트, 우회 주석에서 실수 수집"]
    B --> C["유형으로 묶기<br/>두 번 일어나면 한 유형"]
    C --> D["유형마다 가장 높은 층위에서 해결"]
    D --> L1["1. 아키텍처로 없애기<br/>상태의 소유자 하나, 잘못된 import 차단, 옛 방식 삭제"]
    L1 --> L2["2. 타입으로 막기<br/>그래도 컴파일되면 대체할 대상을 에러에 적은 린트나 CI"]
    L2 --> L3["3. 동작을 테스트<br/>무의미한 테스트는 고치거나 삭제"]
    L3 --> L4["4. 문서와 규칙은 마지막<br/>판단이 필요한 부분만"]
    L4 --> E["가장 잦은 유형부터 커밋 하나씩 수정"]
    E --> F["새 검사가 실제 과거 실수에서 실패하는지 증명<br/>로컬과 CI에서 같은 명령"]
    F --> G["에이전트 지침 파일의 규칙-강제 수단 표 갱신<br/>실수가 불가능해진 규칙은 삭제"]

flowchart TD
    A[".ts / .tsx를 읽거나 수정"] --> B["type-system-discipline 원칙을 먼저 적용"]
    B --> C["타입 설계<br/>kind 판별자 유니온, 브랜드 타입, 구성적 모델링, 가장 단순한 total 타입"]
    C --> D["경계에서 검증<br/>외부 데이터는 unknown, 스키마로 파싱, 안쪽은 타입 신뢰"]
    D --> E["좁히기 우선순위<br/>판별자 switch, in, typeof와 instanceof, 타입 가드, as"]
    E --> F["default에서 never로 exhaustiveness 확인<br/>as 대신 satisfies"]
    F --> G["테스트와 로깅<br/>실제 테스트 우선, 구조화된 로그, console.log 금지"]

flowchart TD
    A["/create-verification-skill"] --> B["1. 사용자가 아닌 저장소에 질문<br/>표면, 실행 방법, 구동 방법, 관찰 증거, 격리 가능성"]
    B --> C{"체크아웃이 빌드되고 실행되는가"}
    C -->|"아니오"| D["먼저 고치거나 정확히 보고"]
    D --> C
    C -->|"예"| E["2. verify-앱이름/SKILL.md 생성<br/>Launch / Doctor / Drive / Evidence / Cleanup / Helpers"]
    E --> F["3. 기능 맵 시드<br/>features/README.md와 기능별 파일 3~5개"]
    F --> G["4. 생성한 스킬을 끝까지 한 번 실행<br/>실행, doctor, 기능 하나 구동, 증거 수집, 정리"]
    G --> H{"정리 뒤에도 증거가 남아 있는가"}
    H -->|"아니오 또는 실패"| I["고치고 실패한 시도도 정리"]
    I --> G
    H -->|"예"| J["5. maintain-verification-skill 안내"]

flowchart TD
    S0["0. 대상 verify 스킬 찾기<br/>여러 개면 질문, 없으면 create로 안내"] --> S1["1. 기능 맵 색인 정리"]
    S1 --> S2["2. Source wave<br/>기능 파일마다 읽기 전용 서브에이전트가 동시에 소스 조사<br/>드리프트 의심과 구동 레시피 하나 반환"]
    S2 --> S3["3. Reconcile<br/>겹치는 레시피 병합, 맵에 없는 최근 표면 확인"]
    S3 --> S4["4. Live pass<br/>코디네이터 한 명이 모든 기능을 실제로 구동<br/>doctor 선행, 증거 보존, 잔여물 정리"]
    S4 --> S5{"5. Triage"}
    S5 -->|"설명이 틀림"| DD["문서 드리프트: 맵 수정"]
    S5 -->|"하네스가 못 다룸"| HG["하네스 갭: 하네스 수정 후 다시 구동"]
    S5 -->|"앱이 실제로 고장"| PG["제품 갭: 사용자에게 기록만"]
    DD --> S6
    HG --> S6
    PG --> S6{"6. 결과"}
    S6 -->|"수정할 것 없음"| CL["clean: 브랜치와 PR 없음"]
    S6 -->|"증명된 수정 있음"| CH["changed: 증명된 수정만 담아 PR 한 개"]
    S6 -->|"끝내지 못함"| BL["blocked: 막힌 이유를 정확히 보고"]

flowchart TD
    A["/create-formal-verification-skill"] --> B["코드에서 목표 선택<br/>깨지면 비용이 크고 테스트가 거의 닿지 않는 약속"]
    B --> C["질문에 맞는 도구 선택<br/>순서 문제는 TLA+ 모델 검사, 코드 속성은 코드 검증기, 크기 무관은 증명"]
    C --> D["속성 하나를 검증<br/>모델의 모든 부분이 열어 볼 수 있는 코드를 가리킴"]
    D --> E["깨진 변형에서 실패하는지 확인<br/>실패한 적 없는 검사는 증명이 아님"]
    E --> F["프로젝트 전용 verify 스킬 생성<br/>커버 범위와 마지막 동기화 커밋 기록"]
    F --> G["속성을 깨는 임시 변경에 스킬을 따라 적용"]
    G --> H{"스킬이 깨짐을 잡는가"}
    H -->|"아니오"| I["스킬이나 검증을 고침<br/>임시 변경은 건드리지 않음"]
    I --> G
    H -->|"예"| J["임시 변경 제거, 검사가 원래 상태인지 확인"]
    J --> K["인계<br/>검증한 것, 도구와 이유, 한계, 발견, 실행법, 커버하지 못하는 것"]

flowchart TD
    S1["1. 검사 찾기<br/>모델 검사기나 증명기를 돌리는 프로젝트 스킬<br/>속성, 대상 코드, 한계, 명령, 마지막 동기화 커밋 수집"] --> S2["2. 바꾸기 전에 그대로 실행하고 결과 기록"]
    S2 --> S3["3. 동기화 커밋 이후 커버 코드의 변경을 모두 읽음<br/>이동, 분리, 같은 상태를 쓰는 새 코드도 확인"]
    S3 --> C{"변경 유형"}
    C -->|"영향 없음"| NE["그대로 둠"]
    C -->|"검증이 코드를 더는 설명하지 못함"| UD["모델이나 하네스 수정"]
    C -->|"약속이 의도적으로 바뀜"| UP["근거를 인용하고 속성 수정"]
    C -->|"약속이 깨졌을 수 있음"| BC["실패하면 버그 후보"]
    UD --> S4
    UP --> S4["4. 결과가 아닌 코드에서 업데이트<br/>한계는 유지, 줄이면 보고"]
    BC --> S4
    NE --> S5
    S4 --> S5["5. 다시 실행"]
    S5 --> R{"결과"}
    R -->|"통과"| P1["새 코드를 일부러 깨뜨려 검사가 여전히 실패하는지 확인"]
    R -->|"실패"| F1["반례를 실제 코드에서 한 단계씩 재현"]
    F1 --> F2{"모든 단계가 일어날 수 있는가"}
    F2 -->|"아니오"| DR["검증의 드리프트: 검증을 고침"]
    F2 -->|"예"| BUG["bug: 도입한 커밋, 반례, 피해를 보고"]
    P1 --> S6
    DR --> S6
    BUG --> S6["6. verify 스킬의 범위, 명령, 한계, 동기화 커밋 갱신"]
    S6 --> OUT["in sync / updated / bug / blocked 중 하나로 보고<br/>검증 수정은 제품 수정과 별도 변경"]

flowchart TD
    A["길거나 자리를 비우는 작업"] --> B["decisions.tsv 시작<br/>헤더는 템플릿에서 복사"]
    B --> C["결정 지점마다 한 줄 추가<br/>ts / phase / decision / why / evidence / result"]
    C --> D{"작업이 끝났는가"}
    D -->|"아니오"| C
    D -->|"예"| E["기록을 대화 기록과 대조해 감사<br/>모든 행이 실제 결정인지, 증거가 풀리는지, 빠진 갈림길은 없는지"]
    E --> F{"틀린 행이나 빠진 결정이 있는가"}
    F -->|"있음"| G["행을 고치지 않고 덮어쓰는 새 행을 추가"]
    F -->|"없음"| H
    G --> H["다른 모델 계열의 서브에이전트가 기록을 교차 검토"]
    H --> I["답변 끝에 Attention 섹션<br/>reviewed by 모델명, 플래그 또는 No flags"]
    I --> J{"검토자가 신뢰를 요구하는 큰 작업인가"}
    J -->|"예"| K["기록을 커밋"]
    J -->|"아니오"| L["로컬에만 유지"]

sequenceDiagram
    actor U as 사용자
    participant P as 부모
    participant J as Judgment 리뷰어
    participant T as Tooling 리뷰어
    participant D as Divergent 리뷰어
    participant S as 종합 에이전트

    U->>P: /reflect
    P->>P: 현재 워크스페이스의 대화 기록을 찾음 (없으면 요약본 사용)
    P->>J: 대화 기록 경로 (general-purpose, MCP 접근 포함)
    P->>T: 대화 기록 경로
    P->>D: 대화 기록 경로
    J-->>P: 발견 목록
    T-->>P: 발견 목록
    D-->>P: 발견 목록
    P->>S: 세 리뷰어의 전체 출력
    S-->>P: Accepted / Rejected / Backlog
    P->>P: 린트나 스크립트로 강제할 수 있는 Accepted는 Backlog로 이동
    P-->>U: 전체 목록을 보여 주고 승인 대기
    P->>P: Backlog는 승인을 기다리지 않고 트래커에 등록
    U->>P: 적용할 부분 선택
    P->>P: 사소한 수정은 직접, 큰 수정과 새 스킬은 skill-creator로
    P-->>U: 적용한 수정, 새 스킬, Backlog 등록, 버린 항목

flowchart TD
    A["/automate-me"] --> B{"내 -mode 스킬이 이미 있는가"}
    B -->|"있음"| C["업데이트(기본) 또는 새로 시작 확인<br/>업데이트는 마지막 수정 이후 기록만 채굴"]
    B -->|"없음"| D
    C --> D["1. 현재 워크스페이스의 대화 기록만 채굴<br/>2~4주를 3조각으로 나눠 병렬 서브에이전트"]
    D --> E["둘 이상의 조각에서 보인 패턴만 높은 신뢰로 채택"]
    E --> F["2. AskUserQuestion으로 직접 질문<br/>선택지 4~6개 한두 번, 자유 입력 한 번"]
    F --> G["3. 신호를 섹션으로 묶음<br/>응답 스타일, 자율성, 서브에이전트, 검증, 프로세스 등"]
    G --> H["4. skill-creator로 초안<br/>description은 이름과 /핸들-mode 중심"]
    H --> I["5. unslop을 적용하고 사용자 피드백으로 반복<br/>과감히 줄임"]
    I --> J{"사용자가 만족하는가"}
    J -->|"아니오"| I
    J -->|"예"| K["6. main에서 딴 worktree에서 커밋하고 PR<br/>main에 직접 푸시하지 않음"]

flowchart LR
    A["글"] --> B["패턴 탐지<br/>내용 / 어휘 / 문체 / 챗봇 문구 / 군더더기 / 추상 은유 / 평이한 말"]
    B --> C["다시 쓰기<br/>의미와 의도한 어조는 유지"]
    C --> D["능동태, 한 문장에 한 생각, 구체적인 사실이나 수치"]

flowchart TD
    A["문서, RFC, readme, PR 설명, 커밋 메시지"] --> B{"Diátaxis 모드 선택<br/>행동인가 이해인가, 학습인가 업무인가"}
    B -->|"행동 + 학습"| T1["tutorial"]
    B -->|"행동 + 업무"| T2["how-to"]
    B -->|"이해 + 업무"| T3["reference"]
    B -->|"이해 + 학습"| T4["explanation"]
    T1 --> C
    T2 --> C
    T3 --> C
    T4 --> C["문서 하나에 모드 하나"]
    C --> D["Google developer style<br/>독자에게 you, 능동태, 명령형, 조건을 앞에"]
    D --> E["STE<br/>한 문장에 지시 하나, 20~25단어 이내, 경고를 단계 앞에"]
    E --> F["Global English<br/>모호한 대명사와 명사 연쇄 제거, 같은 것은 한 이름으로"]
    F --> G["리듬 변주<br/>문장 길이를 섞고 구체적으로 쓰고 관점을 가짐"]
    G --> H["unslop 적용"]

sequenceDiagram
    actor U as 사용자
    participant A as 에이전트
    participant S as 이 컴퓨터의 서버
    participant W as 웹훅 자동화

    A->>W: 웹훅 트리거 자동화 생성 (사용자가 생성 확인)
    U->>U: 자동화 화면에서 URL과 sender key 복사
    U->>A: URL만 채팅에 전달
    U->>U: 키는 채팅에 붙이지 않고 로컬 파일(권한 600)이나 환경 변수에 저장
    A->>S: 키를 서버 설정에 복사 (출력과 로그 금지)
    A->>S: 0.0.0.0 주소의 지정한 포트에서 페이지 호스팅
    A->>S: 무해한 payload로 한 번 probe
    S->>W: POST (Bearer 키, 8초 제한, 재시도 없음)
    W-->>S: HTTP 200 (자동화가 깨어남)
    A->>A: tailscale 상태 확인, 호스트명과 100.x 주소 두 URL을 사용자에게 제공
    U->>S: 버튼 클릭
    S->>W: JSON을 POST
    W->>A: 헤더, body 문자열, 타임스탬프와 함께 실행
    A->>A: body를 파싱하고 외부 데이터로 취급 (지시가 아닌 입력)

flowchart LR
    A["읽기 전용 질문"] --> B["how"]
    B --> C{"동기를 묻는가"}
    C -->|"예"| D["why도 실행"]
    C -->|"아니오"| E
    D --> E["how 형식의 출력<br/>대안 중 선택이면 장단점 표"]
    E --> F["unslop 적용"]
    F --> G["답변<br/>PR도 babysit도 없음"]

flowchart TD
    A["메모리 누수, 유휴 CPU 폭주, 화면 깨짐"] --> B["제어 스킬로 살아 있는 신호 캡처<br/>CPU 프로파일, 힙 스냅샷, CDP 트레이스"]
    B --> C["산출물을 결정적 단서로 축소<br/>큰 파일은 서브에이전트가 파싱"]
    C --> D["메커니즘을 증명<br/>실행 중인 프로세스에 CDP로 계측을 주입"]
    D --> E["소스로 되돌려 매핑<br/>파일, 심볼, 할당이나 예약하는 줄"]
    E --> F["진단만 전달<br/>고치려면 Bug fix나 Perf issue로 이관"]

flowchart TD
    A["cpuprofile, trace, spindump, heap snapshot"] --> B["형식 식별 후 알맞은 도구로 로드<br/>큰 파일은 서브에이전트가 파싱"]
    B --> C["sqlite로 변환해 조회 가능한 형태로"]
    C --> D["가장 시간이 많은 프레임, 보유 체인, 막힌 스레드로 좁힘"]
    D --> E["산출물의 심볼로 파일, 심볼, 줄에 귀속"]
    E --> F{"전후 쌍의 캡처가 있는가"}
    F -->|"있음"| G["전후를 비교해 원인 확정"]
    F -->|"없음"| H["산출물이 지지하는 가장 강한 가설로 표시"]
    G --> I["인용된 진단 전달"]
    H --> I

flowchart TD
    A["결함 보고"] --> B["같은 표면에서 직접 재현<br/>제어 스킬 사용, 사용자에게 재현을 떠넘기지 않음"]
    B --> C{"재현되는가"}
    C -->|"아니오"| C2["트리거 합성, 조건 좁히기, 계측"]
    C2 --> B
    C -->|"예"| D["이진 탐색으로 원인 후보를 제거<br/>how와 why로 후보 생성, 런타임 증거로 제거"]
    D --> E["살아남은 메커니즘을 런타임 증거로 확인"]
    E --> F{"함수 경계를 넘는 수정인가"}
    F -->|"예"| G["architect"]
    F -->|"아니오"| H
    G --> H["서브에이전트가 증거가 정당화하는 최소 수정을 구현"]
    H --> I["같은 표면에서 원래 재현이 통과하는지 검증"]
    I --> J{"통과했는가"}
    J -->|"아니오 또는 inconclusive"| D
    J -->|"예"| K["실패하는 재현이 수정보다 먼저 커밋되도록 정리<br/>싼 테스트 경로가 있으면 tdd"]
    K --> L["Opening a PR"]

flowchart TD
    A["측정된 느려짐"] --> B["기준선 트레이스 캡처<br/>benchmark-checklist로 수치 검증"]
    B --> C["how로 가설 수립<br/>실행해 보기 전에 성능 한계를 단정하지 않음"]
    C --> D["성능 만트라를 싼 순서로 시도<br/>하지 않기, 반복하지 않기, 덜 하기, 나중에, 안 보일 때, 동시에, 더 싸게"]
    D --> E["트레이스에서 수정을 계획<br/>함수 경계를 넘으면 architect"]
    E --> F["서브에이전트가 구현, diff 검토, 수정 후 트레이스 캡처"]
    F --> G["산출물을 파싱해 비교<br/>inconclusive나 잘못된 표면은 통과가 아님"]
    G --> H{"목표를 달성했는가"}
    H -->|"아니오"| D
    H -->|"예, 앞 단계 만트라에서 충족"| I["더 비싼 만트라는 시도하지 않고 멈춤"]
    I --> J["PR에 측정값 인용 후 Opening a PR"]

flowchart TD
    S1["1. how로 워크로드와 구조를 파악<br/>지표, 방향, 목표와 최소 반복 횟수를 쌍으로 묶은 종료 조건"] --> S2["2. 측정 하네스 구축, 민감도 증명, 동결<br/>benchmark-checklist로 검증, 기준선과 회귀 게이트 기록"]
    S2 --> S3["3. 결정 로그 decision.tsv 시작"]
    S3 --> S4["4. 구조 모델에 근거한 가설<br/>성능 지표면 만트라 순서"]
    S4 --> S5["5. 서브에이전트가 변경 하나를 구현"]
    S5 --> M["동결한 하네스로 전후 측정 + 회귀 게이트"]
    M --> J{"노이즈를 넘어 개선되었고 게이트가 초록인가"}
    J -->|"예"| K["채택: 커밋 하나, 로그에 kept"]
    J -->|"아니오"| R["전부 되돌림, 로그에 reverted"]
    K --> ST
    R --> ST{"6~7. 종료 조건을 만족했는가"}
    ST -->|"예, 또는 남은 아이디어가 한계 이득"| S8["8. 채택한 커밋을 쌓아 Opening a PR"]
    ST -->|"아니오"| PL{"연속으로 기각되며 정체했는가"}
    PL -->|"예"| PV["범주 전환, 근접한 시도 결합, 소스 재독, 더 급진적인 시도"]
    PL -->|"아니오"| S4
    PV --> S4

flowchart TD
    A["새 동작이나 바뀐 동작"] --> B["1. 영향 받는 서브시스템에 how"]
    B --> C["2. architect로 병렬 설계 탐색"]
    C --> D["3. 처리량 체크포인트 네 항목<br/>선행 차단 단계 / 독립 작업 흐름 / 공유 가변 상태 / 가장 작은 안전한 분해"]
    D --> E{"구현 형태가 여러 개 유효한가"}
    E -->|"예"| F["arena로 위임"]
    E -->|"아니오"| G["서브에이전트에 위임<br/>파일, 데이터 형태, 성공 기준을 명시"]
    F --> H
    G --> H["5. 맞는 표면에서 검증<br/>inconclusive는 통과가 아님"]
    H --> I["6. 작고 순서 있는 커밋으로 rebase"]
    I --> J{"설계가 논쟁적인가"}
    J -->|"예"| K["7. interrogate"]
    J -->|"아니오"| L
    K --> L["8. Opening a PR"]

flowchart TD
    A["구조나 형태 변경"] --> B["1. 동작 계약을 고정<br/>how로 계약 파악, 특성화 테스트나 스냅샷, 타입 검사는 고정이 아님"]
    B --> C["2. 코드에 빠진 구조에 이름을 붙임"]
    C --> D["3. 목표 형태 정의<br/>함수 경계를 넘으면 architect"]
    D --> E["4. 먼저 뺌: 죽은 코드, 호출처 하나인 래퍼, 중복 검증"]
    E --> F["5. 고정이 초록인 작은 단계로 이동<br/>호출부 이전과 옛 API 삭제를 같은 묶음에서"]
    F --> G["6. 실제 산출물로 동작 불변 증명<br/>옛 출력과 새 출력의 diff, 기록한 기준선 재생"]
    G --> H{"독자 부담이 줄었는가"}
    H -->|"아니오"| I["되돌림"]
    H -->|"예"| J["8. 뺄셈, 재구성, 후속 정리 순서로 커밋하고 Opening a PR"]
    D -.->|"정리 중 진짜 버그나 빠진 기능 발견"| K["분리해서 Feature나 Bug fix로 이관<br/>구조 변경을 먼저 출고"]

flowchart TD
    A["프로토타입 요청"] --> B["1. 내려야 할 결정을 한 문장으로"]
    B --> C{"결정이 있는가"}
    C -->|"없음"| F0["Feature로 이관"]
    C -->|"있음"| D["2. 설계 공간이 열려 있으면 레퍼런스 수집<br/>선행 사례, 무드보드, 사용자가 방향 선택"]
    D --> E["3. 격리된 스크래치 디렉터리에 버릴 코드<br/>속도 우선, 프로덕션 프레임워크와 테스트 없음"]
    E --> F["4. 대안은 전환 버튼 하나 뒤에 라벨을 붙여 비교"]
    F --> G["5. 맞는 표면에서 관찰<br/>시각은 스크린샷, 동작과 타이밍은 로그나 출력"]
    G --> H["6. 대안, 장단점, 추천을 제시<br/>산출물은 결정과 버릴 스케치"]
    H --> I["선택한 방향을 Feature나 architect로 넘김"]

flowchart TD
    A["픽셀 동일성 요구"] --> B["1. 기준선 먼저<br/>현재 컴포넌트의 상태별 스크린샷 하네스, 기준선 없이는 일치 주장 불가"]
    B --> C["2. 우회 금지<br/>하네스 수정, 기준선 변조, 컴포넌트 구조 변경 금지"]
    C --> D["3. 공유 기본 요소를 먼저 이전"]
    D --> E["컴포넌트 하나씩 이전<br/>worktree마다 담당자 한 명"]
    E --> F["4. 기준선과 이미지 diff"]
    F --> G{"diff가 0인가"}
    G -->|"아니오"| H["픽셀 차이를 조사하고 수정, loop로 반복"]
    H --> F
    G -->|"예"| I["5. 컴포넌트별 또는 안전한 묶음별 Opening a PR"]

flowchart LR
    A["SKILL.md 작성 또는 수정"] --> B["skill-creator 사용"]
    B --> C["검증<br/>frontmatter의 name과 description, 참조 파일 존재, 스킬 간 링크"]
    C --> D{"구조적 스킬인가"}
    D -->|"예"| E["테스트 케이스 작성"]
    D -->|"아니오, 주관적"| F
    E --> F["Opening a PR"]

flowchart TD
    A["변경 후보"] --> B["1. Frame<br/>시험할 변형과 성공 동작, 심판 전용 루브릭 3~6개"]
    B --> C["2. 후보별 정제된 환경<br/>eval, test 같은 단어를 디렉터리와 프롬프트에서 제거"]
    C --> D["3. 실제 사용자가 칠 법한 프롬프트 하나<br/>측정 대상은 드러내지 않음"]
    D --> E["4. 서로 다른 모델의 후보 N개를 병렬 실행"]
    E --> F["5. 다른 모델 계열의 블라인드 심판 하나<br/>모델명 대신 정제된 라벨로만 봄"]
    F --> G["6. 자기 보고가 아니라 대화 기록에서 실제로 연 파일을 확인"]
    E --> H["7. 모든 후보 출력을 직접 끝까지 읽음"]
    G --> I
    H --> I["심판의 판정과 비교"]
    I --> J{"판정과 내 판단이 갈리는가"}
    J -->|"예"| K["모델 편향 또는 모호한 루브릭<br/>종합해서 정리"]
    J -->|"아니오"| L
    K --> L["변형을 승격할지 추천"]

flowchart TD
    A["플레이북의 마지막"] --> B["main에서 딴 git worktree에서 작업"]
    B --> C["작고 순서 있는 커밋으로 rebase<br/>각 커밋은 따로 착륙 가능"]
    C --> D["커밋 전 plain-words 패스와 unslop<br/>리뷰 전 no-comments"]
    D --> E["제목은 Conventional Commits<br/>본문은 technical-writing과 unslop"]
    E --> F["본문 섹션<br/>Why / What changed / Scope / Tradeoffs / Blast Radius / Verification"]
    F --> G["forge 결정: gh 기본, Origin이 가능하면 origin pr"]
    G --> H{"실행 환경에 내장 PR 도구가 있는가"}
    H -->|"있음"| I["내장 도구로 생성하고 draft: false"]
    H -->|"없음"| J["origin pr create --status open 또는 gh pr create"]
    I --> K
    J --> K["항상 ready 상태로 열기<br/>큰 변경은 좁은 PR 여러 개로 쌓음"]
    K --> L["URL을 올리고 계속 작업<br/>babysit은 시작하지 않음"]

flowchart TD
    A["PR 상태 요청"] --> B["1. 모드 선언과 forge 결정<br/>drive / background / threads-only / check"]
    B --> C["2. 가장 낮은 머지되지 않은 PR이 프런티어<br/>위쪽 PR은 읽고 모아 두기만"]
    C --> D["3. 스택당 babysitter 하나, 스택 토폴로지는 변경하지 않음"]
    D --> E{"5. 차단 요소"}
    E -->|"충돌"| F["해결하지 않고 어느 브랜치가 rebase해야 하는지 보고하고 중단"]
    E -->|"리뷰 스레드"| G["8. 봇 코멘트는 코드로 검증<br/>실제 문제는 먼저 실패하는 증명과 함께 수정, 노이즈는 근거와 함께 반려"]
    E -->|"CI 실패"| H["7. 분류<br/>flake는 새 빌드 한 번, 같은 실패가 반복되면 재분류, stale base는 rebase 필요로 보고"]
    G --> I["수정은 한 번의 push 묶음으로"]
    H --> I
    I --> J["6. forge의 판정을 신뢰<br/>GitHub는 watch-pr, Origin은 origin pr view"]
    J --> K{"머지 가능 상태인가"}
    K -->|"아니오"| E
    K -->|"예"| L["merge-ready로 보고하고 중단"]
    L --> M["9. 머지 권한은 사용자에게<br/>머지, 착륙, 출고를 명시적으로 요청하면 Shipping으로"]

flowchart TD
    A["초록불 스택을 착륙해 달라는 요청"] --> B["1. forge 결정, PR마다 독립 검증자 한 명<br/>각자 worktree에서 사용자처럼 실행, 코드를 쓴 에이전트의 판정은 무효"]
    B --> C["각 PR에 PASS / PASS+NOTES / FAIL 게시"]
    C --> D["2. 바닥부터 연속으로 검증된 구간만 착륙 대상<br/>검증 안 된 PR 위의 PR은 대기"]
    D --> E["3. 판정이 현재 코드를 설명하는지 확인<br/>git patch-id 비교, 달라졌으면 새로 검사하고 새 판정"]
    E --> F["4. 가장 낮은 PR을 머지<br/>머지 대기열에만 올라갔는지 PR을 다시 읽어 확인"]
    F --> G["다음 PR의 base를 trunk로 바꾸고 --force-with-lease로 push"]
    G --> H["5. 착륙 중에는 스택을 건드리지 않음<br/>watch-pr --queued-stack 또는 origin pr checks --watch"]
    H --> I{"천장 PR까지 머지되었는가"}
    I -->|"아니오"| F
    I -->|"예"| J["6. 천장에서 멈춤<br/>구간을 늘리려면 1단계부터 새로"]

flowchart TD
    A["오래 걸리는 작업"] --> B["1. 확인 가능한 종료 조건을 먼저 선언<br/>테스트 초록, 재현 해결, PR N개 머지, 픽셀 diff 0"]
    B --> C["2. 깨우는 방법 선택<br/>이벤트가 있으면 감시 서브에이전트와 긴 하트비트, 없으면 고정 간격"]
    C --> D["3. 증거가 정당화하는 최소 변경"]
    D --> E["종료 조건에 비춰 검증"]
    E --> F{"앞으로 나아갔는가"}
    F -->|"예"| G["커밋"]
    F -->|"아니오"| H["변경을 버림"]
    G --> I["5. show-me-your-work에 행 기록"]
    H --> I
    I --> J{"종료 조건을 만족했는가"}
    J -->|"아니오, 정체는 중단 사유가 아님"| K["접근을 바꿔 계속<br/>진짜 막다른 길이면 드러냄"]
    K --> D
    J -->|"예"| L["종료"]
    D -.->|"중간에 발견한 별개 문제"| M["직접 해결, 별도 PR<br/>되돌릴 수 없는 일만 사용자에게"]
    M --> D

flowchart TD
    S1["1. Frame<br/>셀 수 있는 완료 조건, 규모, 예산<br/>에이전트 하나로 끝나면 Autonomous run으로"] --> S2["2. 런타임 설치<br/>orch init, 상시 지침 preferences.md, frontier.json 시드"]
    S2 --> S3["3. 파일럿<br/>단위 하나로 브리프, 워커, 검증, 스택, 머지까지 전체 경로를 통과"]
    S3 --> S4["4. Scale<br/>동시 실행 상한까지 롤링 윈도로 워커 생성"]
    subgraph LOOP["프로그램 루프"]
        S4 --> S5["5. Drain<br/>inbox를 비우고 완료 항목을 landed / needs-verify / failed / zombie / noise로 분류"]
        S5 --> S6["6. Land<br/>검증된 단위부터 지속적으로 착륙<br/>스태커 한 명만 토폴로지 변경"]
        S6 --> SV["검증 원장 갱신<br/>PR 번호와 head SHA 단위"]
        SV --> RD{"준비된 일이 남았는가"}
        RD -->|"예"| S4
    end
    RD -->|"아니오"| S7["7. Close<br/>모든 에이전트를 종료 상태로 정리, 실제 산출물에서 조건 확인, 기록 감사"]
    S5 -.->|"사람이 필요한 결정"| GT["gates.md에 보류하고 나머지 작업은 우회해 진행"]

sequenceDiagram
    actor Op as 운영자
    participant R as 루트
    participant O as PR 담당자 (PR마다 1명)
    participant W as 스웜 검증자

    Op->>R: 큐와 머지 권한을 부여 (운영자 몫의 항목은 merge-ready에서 중단)
    R->>O: PR마다 담당자 생성 (worktree, trunk에서 병렬 분기)
    O->>O: 빌드, PR 열기, slop 제거(no-comments, unslop), trunk에 rebase
    O-->>R: code-ready head 보고
    O->>O: 실제 산출물로 자기 증명, babysit
    R->>W: code-ready SHA에서 독립 검증자를 병렬 실행 (gates, 라이브 구동, diff 감사)
    W-->>R: 레인별 PASS 또는 발견
    R->>O: 증명된 발견을 한 번의 fix-forward로 전달 (루트는 직접 푸시하지 않음)
    O-->>R: 새 head 보고, merge-ready
    R->>R: 영수증 감사, 게이트를 느슨하게 하는 변경은 새 countersign
    R->>O: 검증된 head를 확인
    O->>O: 머지 직전 trunk 변화 확인, 필요하면 rebase와 CI
    O-->>R: 머지 완료
    R-->>Op: ketchup 방식의 보고, 1시간 /loop 감사가 멈춘 에이전트를 교체
    Op->>R: 중단 지시가 오면 모든 담당자가 쓰기 없이 위치만 보고

flowchart TD
    A["운영자가 착륙 전에 리뷰하길 원함<br/>작업이 순서가 있거나 맞물림"] --> B["1. Autopilot-full의 담당자 실행<br/>merge-ready 대신 STACK-READY 보고<br/>rebase, retarget, 머지, auto-merge 금지"]
    B --> C["2. 토폴로지의 작성자는 루트 하나<br/>의존 순서대로 PR을 붙이고 base를 부모 브랜치로"]
    C --> D["3. 착륙 전까지 루트가 drift를 흡수<br/>링크마다 필요하면 아래부터 rebase, patch-id 규칙 적용"]
    D --> E["4. 체인을 운영자에게 전달<br/>링크마다 판정을 PR에 담음"]
    E --> F["착륙이 시작되면 아무도 체인에 쓰지 않음<br/>착륙 후 retarget만 허용"]
    F --> G["운영자가 아래부터 착륙"]

flowchart TD
    A["여러 단계 또는 여러 PR에 걸친 작업"] --> B{"파일 한두 개이고 접근이 뻔한가"}
    B -->|"예"| Z["계획을 생략하고 그렇게 말함"]
    B -->|"아니오"| C["2. 열린 질문을 프로토타입으로 해결<br/>제품 취향만 운영자에게"]
    C --> D["3. mineru-agent 서브에이전트로 탐색<br/>파일 포인터, 관례, 테스트 명령, 진입점만 반환"]
    D --> E["4. 스켈레톤을 복사해 모든 자리를 채움<br/>PR마다 한 섹션, 단위 / 라이브 / 성능 검증 상자"]
    E --> F["5. technical-writing 후 unslop"]
    F --> G["6. check-plan.mjs 실행, 출력 줄을 모두 수정"]
    G --> H["7. 계획 경로와 스크립트 출력을 전달하고 중단"]
    H --> I["운영자의 명시적 승인 뒤에<br/>계획이 이름 붙인 실행 플레이북으로 시작"]

flowchart TD
    A["이전 작업을 이어받기"] --> B["1. 이전 기록 찾기<br/>대화 기록, 백그라운드 에이전트 URL, 푸시된 브랜치<br/>긴 기록은 서브에이전트가 파싱"]
    B --> C["2. 운영 상태 재구성<br/>브랜치, worktree, 착륙한 것, todo, 결정"]
    C --> D["3. 계획 대비 완료와 남은 일을 비교<br/>재개 지점을 명명, 처음부터 다시 검증하지 않음"]
    D --> E{"4. 판정"}
    E -->|"이어서 실행"| F1["남은 일을 맞는 플레이북으로 라우팅"]
    E -->|"끝난 권고를 출고"| F2["권고 전달"]
    E -->|"이전 결론을 추인하거나 뒤집음"| F3["근거와 함께 판정"]
    E -->|"실패한 실행의 부검"| F4["postmortem"]
    F1 --> G["5. 물려받은 주장을 원래 목표 기준으로 실제 산출물에서 검증"]
    F2 --> G
    F3 --> G
    F4 --> G

flowchart TD
    A["명시적 중단 요청<br/>계속하라는 말에는 중단하지 않음"] --> B["1. 안전한 경계에서 멈춤<br/>현재 원자적 단계를 마치거나 되돌리고 중첩 서브에이전트 취소"]
    B --> C["2. 되돌릴 수 없는 행동은 하지 않음<br/>이미 나가 있던 것이 아니면 PR과 push 없음"]
    C --> D["3. 작업을 영속화<br/>커밋 하나로 wip 저장, 깨진 상태면 본문에 한 줄"]
    D --> E["4. 컨텍스트 밖에 재개 메모 작성<br/>의도, 진행, 검증된 것, 상태, 다음 단계, 핵심 파일, 함정"]
    E --> F["보고<br/>디스크에 있는 것과 머릿속에만 있는 것, 재개 후 첫 행동"]

flowchart TD
    A["디스크 확보 요청"] --> B["1. df -h 기록, worktree-audit.sh 실행<br/>크기, 나이, 병합 상태, 미커밋 작업, PR 상태, 마지막 채팅 기준으로 분류"]
    B --> C["2. 분류는 조언일 뿐<br/>고정한 채팅과 진행 중인 채팅이 기준, 사용자나 사이드바에서 확인"]
    C --> D["3. 애매한 행은 서브에이전트가 대화 기록을 읽고 사용 여부 보고"]
    D --> E{"4. 되돌릴 수 없는 손실이 있는가"}
    E -->|"wip: 추적되는 미커밋 수정"| F["diff를 보여 주고 결정을 받음"]
    E -->|"scratch: 추적되지 않는 임시 파일"| G["파일을 명명하고 삭제"]
    E -->|"깨끗하고 병합됐고 사용 중이 아님"| H["진행"]
    F --> I
    G --> I
    H --> I["5. 확정된 목록만 삭제<br/>git worktree remove --force 후 git worktree prune"]
    I --> J["6. 시뮬레이터와 캐시<br/>simctl 정리, DerivedData, 패키지 캐시, 사용자가 보존하라 한 것 제외"]
    J --> K["보고<br/>전후 용량, 정리한 worktree, 남긴 것과 이유"]

flowchart LR
    W["작업"] --> D1{"어떤 순간인가"}

    D1 -->|"설계 전, 변경 크기 정하기"| CORE["core<br/>laziness-protocol, foundational-thinking, redesign-from-first-principles, attack-the-premise, subtract-before-you-add, minimize-reader-load, outcome-oriented-execution, experience-first, exhaust-the-design-space, build-the-lever"]
    D1 -->|"구조와 타입 설계, 동시성, API 교체"| ARCH["architecture<br/>model-the-domain, boundary-discipline, type-system-discipline, make-operations-idempotent, migrate-callers-then-delete-legacy-apis, separate-before-serializing-shared-state"]
    D1 -->|"완료 선언 전, 디버깅, 테스트, 측정"| VER["verification<br/>prove-it-works, fix-root-causes, sequence-verifiable-units, test-behavior-not-implementation, explain-the-number"]
    D1 -->|"컨텍스트가 차는 큰 작업, 되돌릴 수 있는 일에 질문하고 싶을 때"| DEL["delegation<br/>guard-the-context-window, never-block-on-the-human"]
    D1 -->|"같은 지시를 두 번째로 쓰는 순간"| META["meta<br/>encode-lessons-in-structure"]