npm - @walwal-harness/cli - Versions diffs - 4.0.0-alpha.13 → 4.0.0-alpha.15 - Mend

@walwal-harness/cli 4.0.0-alpha.13 → 4.0.0-alpha.15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/README.md +226 -273
package/bin/init.js +1 -0
package/package.json +1 -1
package/scripts/harness-dashboard-v4.sh +27 -115
package/scripts/harness-prompts-v4.sh +106 -0
package/scripts/harness-studio-v4.sh +61 -37

package/README.md CHANGED Viewed

@@ -1,4 +1,4 @@
-# walwal-harness
+# @walwal-harness/cli
 **AI 에이전트를 위한 프로덕션 하네스 엔지니어링 프레임워크**
@@ -9,332 +9,333 @@
 ---
+## 두 가지 모드
+| 모드 | 설명 | 실행 방법 |
+|------|------|----------|
+| **Classic (v3)** | 순차 실행 — Planner → Generator → Evaluator 1세션씩 | `하네스 엔지니어링 시작` |
+| **Agent Teams (v4)** | 병렬 실행 — 3 Team이 Feature 단위 Gen→Eval 루프 동시 실행 | `/harness-team` 또는 `npx walwal-harness v4` |
+---
 ## 설치
+### 첫 설치
 ```bash
+cd your-project
 npm install @walwal-harness/cli
 ```
-`postinstall`이 자동으로 프로젝트 루트에 설치합니다:
-1. `.harness/` 디렉토리 스캐폴딩 (actions, archive, gotchas, config)
-2. `.claude/skills/` 에 에이전트 스킬 설치 (9개)
-3. `scripts/` 에 오케스트레이션 헬퍼 스크립트 설치
-4. `SessionStart` 훅 등록 (세션 시작 시 진행 상태 표시)
-5. `UserPromptSubmit` 훅 등록 (모든 프롬프트를 Dispatcher 경유 자동 라우팅)
-6. `AGENTS.md` 생성 + `CLAUDE.md` 심볼릭 링크
-7. 기존 프로젝트면 구조 스캔 → IA-MAP 자동 생성
+`postinstall`이 자동으로:
+1. `.harness/` 디렉토리 스캐폴딩
+2. `.claude/skills/` 에 에이전트 스킬 설치 (8개)
+3. `scripts/` 에 오케스트레이션 스크립트 설치
+4. SessionStart / UserPromptSubmit 훅 등록
+5. `AGENTS.md` + `CLAUDE.md` 심볼릭 링크 생성
 > **중요:** 설치 후 Claude Code 세션을 **재시작**해야 skills가 인식됩니다.
-> `/exit` → 디렉터리 재진입이 필요합니다.
-### CLI 명령
+### 기존 설치자 업데이트
 ```bash
-npx walwal-harness           # 초기화 (postinstall과 동일)
-npx walwal-harness --force   # 강제 재초기화 (기존 파일 덮어쓰기)
-npx walwal-harness --help    # 도움말
-```
+# latest (v3 안정판)
+npm update @walwal-harness/cli
-### 초기화에서 일어나는 일
+# v4 alpha (Agent Teams)
+npm install @walwal-harness/cli@next
+# 스크립트 동기화 (코어 스크립트 자동 덮어쓰기)
+npx walwal-harness
 ```
-your-project/
-├── AGENTS.md                       # 에이전트 공통 컨텍스트 (Planner 관리)
-├── CLAUDE.md → AGENTS.md           # 심볼릭 링크
-├── scripts/
-│   ├── harness-next.sh             # 세션 오케스트레이터
-│   ├── harness-session-start.sh    # SessionStart 훅
-│   ├── harness-user-prompt-submit.sh  # UserPromptSubmit 훅 (auto-routing)
-│   ├── scan-project.sh             # 프로젝트 구조 스캔
-│   ├── init-agents-md.sh           # AGENTS.md 생성/리빌드
-│   └── lib/
-│       └── harness-render-progress.sh  # 프로그레스 바 렌더러
-├── .harness/
-│   ├── config.json                 # 하네스 설정
-│   ├── HARNESS.md                  # 하네스 상세 가이드
-│   ├── progress.json               # 세션 간 상태 (기계 판독)
-│   ├── gotchas/                    # 에이전트별 실수 기록
-│   ├── actions/                    # 활성 스프린트 문서
-│   └── archive/                    # 완료 스프린트 보관 (불변)
-└── .claude/
-    ├── settings.json               # 훅 등록 (SessionStart + UserPromptSubmit)
-    └── skills/                     # Claude Code 스킬 (9개)
-        ├── harness-dispatcher/
-        ├── harness-brainstorming/
-        ├── harness-planner/
-        ├── harness-generator-backend/
-        ├── harness-generator-frontend/
-        ├── harness-generator-frontend-flutter/
-        ├── harness-evaluator-functional/
-        ├── harness-evaluator-functional-flutter/
-        └── harness-evaluator-visual/
+### CLI 명령어
+```bash
+npx walwal-harness            # 초기화 / 스크립트 업데이트
+npx walwal-harness --force    # 강제 재초기화
+npx walwal-harness studio     # Harness Studio v3 (tmux 5-pane)
+npx walwal-harness v4         # Harness Studio v4 (Agent Teams, tmux 6-pane)
+npx walwal-harness --help     # 도움말
 ```
 ---
-## Quick Start
+## Quick Start — Classic Mode (v3)
 ### 1. 설치 + 재시작
 ```bash
 cd your-project
 npm install @walwal-harness/cli
-# Claude Code 세션 재시작 (/exit → 재진입)
+# Claude Code 재시작 (/exit → 재진입)
 ```
 ### 2. 하네스 시작
-Claude Code에서 아무 요청이나 입력하면 **UserPromptSubmit 훅이 자동으로 Dispatcher를 호출**합니다. 또는 명시적으로:
 ```
-> 하네스 엔지니어링 시작
+❯ 하네스 엔지니어링 시작
 ```
-### 3. Dispatcher가 분류
+또는 Claude Code에서 아무 요청 → UserPromptSubmit 훅이 자동으로 Dispatcher를 호출합니다.
+### 3. 파이프라인 자동 선택
+Dispatcher가 요청을 분석하여 파이프라인을 결정합니다:
 ```
-사용자 입력
-    │
-    ├─ 신규 기능/제품 요청 → 파이프라인 선택 (FULLSTACK / FE-ONLY / BE-ONLY)
-    │   └─ "브레인스토밍 필요합니까?" → Y: Brainstormer → Planner
-    │                                  → N: Planner 직행
-    ├─ 실수 지적 → Gotcha 기록 → 해당 에이전트 재작업
-    ├─ 특정 에이전트 명령 → 해당 에이전트 직접 라우팅
-    └─ 메타/인사 → 일반 응답
+FULLSTACK  : Planner → Gen-BE → Gen-FE → Eval-Func → Eval-Visual
+FE-ONLY    : Planner(light) → Gen-FE → Eval-Func → Eval-Visual
+BE-ONLY    : Planner → Gen-BE → Eval-Func(API-only)
 ```
-### 4. 에이전트 순차 실행
+### 4. 순차 실행
-각 에이전트가 완료되면 다음 프롬프트를 제안합니다:
+각 에이전트가 독립 Claude Code 세션에서 실행됩니다:
 ```
-✓ Dispatcher 완료. bash scripts/harness-next.sh 실행하여 다음 단계 확인.
+❯ /harness-planner           # Plan 작성
+❯ /harness-generator-frontend  # 코드 생성
+❯ /harness-evaluator-functional  # E2E 테스트
 ```
-`bash scripts/harness-next.sh` 를 실행하면 프로그레스 바 + 다음 에이전트 안내:
+에이전트가 완료되면 **새 세션**을 시작하면 자동으로 다음 에이전트를 안내합니다.
-```
-═══ Sprint 1 / FULLSTACK ═══════════════════
+### 5. Eval FAIL → 자동 재작업
-Agents: planner✓ → generator-backend✓ → [generator-frontend] → evaluator-functional → evaluator-visual
+Evaluator FAIL 시 → 실패 원인 + 피드백과 함께 Generator로 자동 리라우팅 (최대 10회).
-/harness-generator-frontend 를 실행하세요.
-```
+---
-### 5. 반복
+## Quick Start — Agent Teams (v4)
-FAIL이 발생하면 Evaluator가 원인을 분석하고 해당 Generator로 자동 재작업 라우팅 (최대 10회). PASS하면 다음 Evaluator로 진행. 모든 Evaluator를 통과하면 스프린트 완료 → 아카이브.
+> **v4는 alpha 단계입니다.** `npm install @walwal-harness/cli@next`로 설치하세요.
----
+### 개요
+3개 Agent Team이 **Feature 단위**로 Gen→Eval 루프를 **병렬 실행**합니다.
+```
+기존 (v3): Planner → Gen(F-001~028 전부) → Eval(전부)
+v4:        Planner → 3 Teams 병렬, 각 Team이 Feature 1개씩 Gen→Eval
+```
-## 파이프라인
+### 1. 설치
-Dispatcher가 사용자 요청을 분석하여 3가지 파이프라인 중 하나를 자동 선택합니다:
+```bash
+npm install @walwal-harness/cli@next
+npx walwal-harness    # 스크립트 동기화
+```
-### FULLSTACK (신규 프로젝트)
+### 2. Planner 실행 (Classic으로)
+v4에서도 Planner는 먼저 실행해야 합니다:
 ```
-Brainstormer? → Planner → Generator-BE → Generator-FE → Evaluator-Func → Evaluator-Visual
-                                                              │ FAIL
-                                                              └──→ 재작업 (max 10회)
+❯ 하네스 엔지니어링 시작
+# Dispatcher → Planner → feature-list.json 생성
 ```
-### FE-ONLY (기존 API에 프론트엔드 연동)
+### 3. Agent Teams 실행
 ```
-Brainstormer? → Planner(light) → Generator-FE → Evaluator-Func → Evaluator-Visual
-                    └─ OpenAPI → api-contract.json 자동 변환
+❯ /harness-team
 ```
-### BE-ONLY (기존 서버에 백엔드 기능 추가)
+또는:
+```bash
+npx walwal-harness v4
 ```
-Brainstormer? → Planner → Generator-BE → Evaluator-Func(API-only)
+### 4. tmux 레이아웃
+```
+┌──────────────┬──────────────┬──────────────┐
+│              │  Progress    │  Team 1      │
+│              │  (Queue,     │  Gen→Eval    │
+│  Main        │   Teams,     ├──────────────┤
+│  (Claude)    │   Features)  │  Team 2      │
+│              ├──────────────┤  Gen→Eval    │
+│              │  Prompts     ├──────────────┤
+│              │  (History)   │  Team 3      │
+│              │              │  Gen→Eval    │
+└──────────────┴──────────────┴──────────────┘
 ```
-> `Brainstormer?` = Dispatcher가 사용자에게 확인 후 조건부 실행. 명확한 PRD/OpenAPI가 있으면 생략 가능.
+| 패널 | 역할 |
+|------|------|
+| **Main** | 사용자 대화형 Claude — 오케스트레이터 역할 |
+| **Progress** | Feature Queue + Team 상태 + Feature 목록 (자동 갱신) |
+| **Prompts** | 사용자 매뉴얼 프롬프트 + Team 활동 로그 (newest first) |
+| **Team 1~3** | `claude -p --dangerously-skip-permissions` headless worker |
-### Flutter 프로젝트 자동 감지 (Web / Mobile / Desktop)
+### 5. 작동 원리
-`pubspec.yaml` + `flutter:` 키가 감지되면 FE 에이전트가 **자동 치환**됩니다. **Flutter Web** 은 컴파일 결과가 HTML+JS+CSS 이므로 React 와 동일하게 Playwright 기반 evaluator 를 그대로 사용하고, **Mobile/Desktop** 만 정적 분석 evaluator 로 교체됩니다.
+```
+Feature Queue (dependency-aware topological sort)
+  Ready:   [F-002, F-003, F-007]  ← depends_on 충족된 것만
+  Blocked: [F-004, F-005, ...]    ← 선행 Feature 미완료
-| fe_stack | fe_target | Generator | Eval-Functional | Eval-Visual |
-|----------|-----------|-----------|----------------|-------------|
-| react | (n/a) | `generator-frontend` | `evaluator-functional` (Playwright) | `evaluator-visual` |
-| **flutter** | **web** | `generator-frontend-flutter` | **`evaluator-functional`** (Playwright!) | **`evaluator-visual`** (Playwright!) |
-| **flutter** | mobile | `generator-frontend-flutter` | `evaluator-functional-flutter` (flutter analyze/test) | **SKIP** |
-| **flutter** | desktop | `generator-frontend-flutter` | `evaluator-functional-flutter` (flutter analyze/test) | **SKIP** |
+Team 1: dequeue F-002 → worktree 생성 → Gen → Gate → Eval
+  PASS → merge to main → worktree 정리 → unblock dependents → dequeue next
+  FAIL → retry (max 3) → 3회 실패 시 failed 처리
+```
-**감지 방식**: `scan-project.sh` 가 Flutter 프로젝트의 `web/index.html`, `android/`, `ios/`, `macos/`, `windows/`, `linux/` 디렉터리 존재 여부로 `fe_target` 을 자동 판정. 멀티 타겟 또는 모호한 경우 Planner 가 사용자에게 확인합니다. 치환은 `pipeline.json.fe_stack + fe_target` 조합에 의해 `harness-next.sh` 가 자동 처리합니다.
+- 각 Team은 **git worktree**로 격리 실행 (파일 충돌 없음)
+- Feature PASS 시 main으로 **auto-merge** + worktree 즉시 삭제
+- Merge conflict 시 auto-rebase 시도
----
+### 6. Main에서 할 수 있는 것
-## 에이전트
+Main Claude는 **오케스트레이터**입니다:
+- 대시보드 상태 확인 요청
+- 실패한 Feature 분석/피드백
+- 코드 리뷰, 아키텍처 판단
+- Gotcha 등록 (실수 지적 → 이후 Team에 반영)
-### 9개 에이전트 (조건부 포함)
+Main에서는 `/harness-generator-*`, `/harness-evaluator-*` 를 **직접 호출하지 않습니다** — Team이 처리합니다.
-| 에이전트 | 역할 | 호출 조건 |
-|----------|------|----------|
-| **Dispatcher** | 파이프라인 선택 + Gotcha 관리 + 라우팅 | 항상 (auto-routing 훅) |
-| **Brainstormer** | 러프한 요구사항을 대화형으로 구체화 | Dispatcher가 사용자에게 확인 후 |
-| **Planner** | 제품 사양 + API 계약서 + 서비스 분할 | 파이프라인 시작 시 |
-| **Generator-Backend** | NestJS MSA 구현 (Gateway + Microservices) | FULLSTACK, BE-ONLY |
-| **Generator-Frontend** | React/Next.js UI + API 연동 | FULLSTACK, FE-ONLY (React) |
-| **Generator-Frontend-Flutter** | Flutter (Riverpod + Retrofit + ARB i18n) | FULLSTACK, FE-ONLY (Flutter) |
-| **Evaluator-Functional** | Playwright E2E 기능 검증 | FULLSTACK, FE-ONLY (React) |
-| **Evaluator-Functional-Flutter** | flutter analyze/test + 정적 anti-pattern 검증 | FULLSTACK, FE-ONLY (Flutter) |
-| **Evaluator-Visual** | 디자인 일관성, 반응형, 접근성, AI슬롭 감지 | FULLSTACK, FE-ONLY (React만) |
+---
-### Brainstormer (조건부)
+## 에이전트
-[obra/superpowers](https://github.com/obra/superpowers) (MIT License)의 brainstorming 방법론을 이식.
-바이브코딩 수준의 러프한 요구사항을 **대화형 Q&A로 구체화**하여 Planner가 바로 소비할 수 있는 `brainstorm-spec.md`로 만듭니다.
+| 에이전트 | 역할 | 모델 |
+|----------|------|------|
+| **Dispatcher** | 파이프라인 선택 + Gotcha 관리 | opus |
+| **Brainstormer** | 러프한 요구사항 대화형 구체화 | opus |
+| **Planner** | 제품 사양 + API 계약 + Feature 설계 | opus/ultraplan |
+| **Generator-Backend** | NestJS MSA 구현 | sonnet |
+| **Generator-Frontend** | React/Next.js UI 구현 | sonnet |
+| **Evaluator-Functional** | Playwright E2E 기능 검증 | opus/ultrathink |
+| **Evaluator-Visual** | 디자인, 반응형, 접근성 검증 | opus/ultrathink |
-**핵심 원칙:**
-- HARD-GATE: 사용자 승인 없이 구현 단계로 넘어갈 수 없음
-- 한 번에 한 질문, 객관식 우선
-- 2-3개 접근법 제시 후 사용자가 선택
-- Spec self-review + User Review Gate
+### Brainstormer (조건부)
-**실행 조건:** Dispatcher가 "브레인스토밍 과정이 필요합니까? (Y/N)" 라고 묻고 사용자가 Y 응답한 경우에만. 피드백/이터레이션/직접 명령에서는 자동 스킵.
+[obra/superpowers](https://github.com/obra/superpowers) (MIT License) 기반. 바이브코딩 수준의 러프한 요구사항을 대화형 Q&A로 구체화합니다.
 ---
 ## 핵심 메커니즘
-### Auto-Routing (UserPromptSubmit Hook)
+### Auto-Routing
-설치 시 `.claude/settings.json`에 `UserPromptSubmit` 훅이 자동 등록됩니다. 모든 사용자 프롬프트가 Dispatcher를 경유하도록 컨텍스트를 주입합니다.
+모든 사용자 프롬프트가 Dispatcher를 자동 경유합니다.
-**per-message opt-out:**
-```
-> harness skip 그냥 이것만 답해줘
-> harness 없이 질문 하나만
-> without harness ...
 ```
+# per-message opt-out
+❯ harness skip 그냥 답해줘
-**전역 비활성:**
-```json
-// .harness/config.json
-{ "behavior": { "auto_route_dispatcher": false } }
+# 전역 비활성
+.harness/config.json → behavior.auto_route_dispatcher = false
 ```
 ### API Contract — 진실의 원천
-`api-contract.json`이 Frontend ↔ Gateway ↔ Microservices 간 유일한 계약서입니다. Planner만 수정 가능하며, Generator-BE는 이를 구현하고, Generator-FE는 이를 소비합니다.
-### AGENTS.md — 에이전트 불문 범용 컨텍스트
+`api-contract.json`이 FE ↔ Gateway ↔ Services 간 유일한 계약서입니다.
-모든 AI 에이전트(Claude, Cursor, Copilot, Windsurf)가 읽을 수 있는 공통 진입점입니다. 1차원 IA-MAP으로 폴더별 책임과 소유 에이전트를 명시합니다.
+### Gotcha 시스템
-```
-├── apps/gateway/     # [BE] API Gateway       → Generator-Backend
-├── apps/service-a/   # [BE] Microservice      → Generator-Backend
-├── apps/web/         # [FE] Frontend App      → Generator-Frontend
-└── .harness/         # [HARNESS] 하네스 시스템  → Planner
-```
+사용자가 실수를 지적하면 Dispatcher가 자동 기록 → 이후 세션에서 반복 방지.
-### Gotcha 시스템 — 실수를 반복하지 않는 에이전트
+### Pre-Eval Gate
-사용자가 에이전트의 실수를 지적하면 Dispatcher가 자동으로 감지하여 해당 에이전트의 gotchas 파일에 기록합니다. 이후 세션에서 에이전트는 시작 시 자신의 gotchas를 읽고 같은 실수를 반복하지 않습니다.
+Generator → Evaluator 전환 전 결정론적 검증 (tsc, eslint, test). 실패 시 Evaluator 세션을 열지 않고 Generator로 자동 리라우팅.
+```json
+// .harness/config.json
+"pre_eval_gate": {
+  "frontend_checks": ["npx tsc --noEmit", "npx eslint src/", "npx vitest run --bail 1"],
+  "frontend_cwd": "path/to/frontend"  // 프로젝트 루트와 다른 경우
+}
 ```
-사용자: "API 응답에 created_at은 ISO 8601로 반환해야 해"
-  → Dispatcher: generator-backend.md에 [G-001] 기록
-  → Generator-BE 다음 세션: gotchas 읽기 → 같은 실수 방지
-```
-### IA Structure Compliance — Step 0 Gate
-Evaluator는 기능 테스트 전에 AGENTS.md의 IA-MAP과 실제 폴더 구조를 대조합니다. 경로 누락이나 소유권 침범이 발견되면 **기능 테스트 없이 즉시 FAIL**합니다.
+### Evaluation System
-### 브라운필드 지원
-기존 프로젝트에 설치하면:
-- `scan-project.sh`가 Tech Stack, 폴더 구조, 기존 CLAUDE.md를 자동 스캔
-- 기존 CLAUDE.md 규칙을 "Preserved Rules" 섹션으로 이관
-- 원본은 `.harness/archive/pre-harness-backup/`에 백업
-- Flutter 프로젝트 자동 감지 (`pubspec.yaml` + `flutter:`)
+| 설정 | 값 |
+|------|------|
+| PASS 기준 | 2.80 / 3.00 이상 |
+| FAIL 기준 | 2.79 이하 (예외 없음) |
+| Evidence 없는 Score | 0점 강제 |
+| Regression 실패 | 1건이라도 → 전체 FAIL |
 ---
-## FE 스택별 지원
+## Harness Studio (tmux)
-### React / Next.js (기본)
+### Studio v3 (Classic)
-| 항목 | 상세 |
-|------|------|
-| Generator | `harness-generator-frontend` — RSC, App Router, Tailwind CSS, Cache Components |
-| Evaluator-Func | `harness-evaluator-functional` — Playwright MCP (`browser_*`) E2E 테스트 |
-| Evaluator-Visual | `harness-evaluator-visual` — 스크린샷 기반 디자인/접근성/반응형 검증 |
-| 레퍼런스 | Vercel Best Practices, Design System Rules, AI Forbidden Patterns, Component Patterns |
-### Flutter (Dart) — Web / Mobile / Desktop
-| 항목 | Web (`fe_target=web`) | Mobile/Desktop (`fe_target=mobile`/`desktop`) |
-|------|----------------------|---------------------------------------------|
-| Generator | `harness-generator-frontend-flutter` (Web 가이드 활성) | `harness-generator-frontend-flutter` (Mobile/Desktop 가이드) |
-| Eval-Func | **`harness-evaluator-functional`** (Playwright MCP) | `harness-evaluator-functional-flutter` (`flutter analyze` + `flutter test` + build_runner drift + FL-01~FL-08 정적 검증) |
-| Eval-Visual | **`harness-evaluator-visual`** (Playwright 스크린샷/반응형/접근성) | **SKIP** (브라우저 없음) |
-| 레퍼런스 공통 | API Layer Pattern, Riverpod Pattern, i18n Pattern, Anti-Patterns | 동일 |
-| 레퍼런스 추가 | **Flutter Web Pattern** (`dart:html`/`package:web` 허용, go_router, CORS, PWA, 빌드/호스팅) | — |
-| dart:html / package:web | **허용** (가능하면 conditional import 권장) | **금지** (모바일/데스크톱 빌드 실패 유발) |
-| 빌드 명령 | `flutter build web --release` / `flutter run -d chrome` | `flutter build apk` / `flutter build ios` / `flutter build macos` 등 |
-### FE 스택 + 타겟 감지
-1. `scan-project.sh`가 `pubspec.yaml` + `flutter:` 키를 탐지하여 `fe_stack = "flutter"` 설정
-2. 같은 스캔이 `web/index.html`, `android/`, `ios/`, `macos/`/`windows/`/`linux/` 존재 여부로 `fe_target` 자동 판정 (`web` / `mobile` / `desktop`)
-3. Planner 가 모호한 경우(멀티 타겟, unknown) 사용자에게 단 한 번 확인하고 `pipeline.json.fe_target` 확정
-4. `harness-next.sh`가 `fe_stack + fe_target` 조합에 따라 FE 에이전트를 자동 치환 (Agent Bar에도 반영)
----
-## 스크립트 레퍼런스
+```bash
+npx walwal-harness studio
+```
-| 스크립트 | 설명 | 실행 방법 |
-|----------|------|----------|
-| `harness-next.sh` | 세션 오케스트레이터 — progress.json 읽고 다음 에이전트 결정, 프로그레스 바 출력 | `bash scripts/harness-next.sh` |
-| `scan-project.sh` | 프로젝트 구조 스캔 → `.harness/actions/scan-result.json` 출력 | `bash scripts/scan-project.sh .` |
-| `init-agents-md.sh` | scan-result.json 기반 AGENTS.md 생성/리빌드 | `bash scripts/init-agents-md.sh .` |
-| `harness-session-start.sh` | SessionStart 훅 — 세션 시작 시 progress 요약 출력 | (자동 — .claude/settings.json 훅) |
-| `harness-user-prompt-submit.sh` | UserPromptSubmit 훅 — 모든 프롬프트를 Dispatcher 경유 라우팅 | (자동 — .claude/settings.json 훅) |
+```
+┌──────────────┬──────────────┐
+│  Dashboard    │ Monitor      │
+│  (Progress)   ├──────────────┤
+├──────────────┤ Agent Session │
+│  Control      ├──────────────┤
+│  (harness>)   │ Eval Review  │
+└──────────────┴──────────────┘
+```
----
+### Studio v4 (Agent Teams)
-## Tech Stack
+```bash
+npx walwal-harness v4
+```
-| 영역 | 기술 |
-|------|------|
-| Backend | NestJS (TypeScript) + MSA |
-| Frontend (React) | React 또는 Next.js (TypeScript) + Tailwind CSS |
-| Frontend (Flutter) | Flutter (Dart) + Riverpod + Retrofit + ARB i18n |
-| E2E Testing (React) | Playwright MCP |
-| E2E Testing (Flutter) | flutter analyze + flutter test + 정적 검증 |
-| Unit Testing | Jest (BE) + Vitest (FE-React) + flutter test (FE-Flutter) |
-| Database | PostgreSQL / SQLite |
+```
+┌──────────────┬──────────────┬──────────────┐
+│              │  Progress    │  Team 1      │
+│  Main        ├──────────────┤  Team 2      │
+│  (Claude)    │  Prompts     │  Team 3      │
+└──────────────┴──────────────┴──────────────┘
+```
 ---
-## 권장 외부 스킬
-하네스는 자체 reference 파일로 기본 가이드를 제공하지만, 아래 외부 스킬을 설치하면 품질이 향상됩니다. 초기화 시 자동으로 설치 여부를 체크하고 안내합니다.
+## 프로젝트 구조
-| 스킬 | 설명 | 사용 에이전트 |
-|------|------|-------------|
-| **vercel** | Vercel/Next.js 배포, 성능 최적화, AI SDK | Generator-FE |
-| **web-design-guidelines** | UI/UX 접근성, Web Interface Guidelines | Evaluator-Visual, Generator-FE |
-| **taste-skill** | AI 생성 UI 디자인 품질, AI슬롭 감지 | Evaluator-Visual, Generator-FE |
-| **supanova-design-skill** | 디자인 시스템 규칙, 시각적 일관성 | Evaluator-Visual, Generator-FE |
+```
+your-project/
+├── AGENTS.md                           # 에이전트 공통 컨텍스트
+├── CLAUDE.md → AGENTS.md               # 심볼릭 링크
+├── scripts/
+│   ├── harness-next.sh                 # 세션 오케스트레이터
+│   ├── harness-session-start.sh        # SessionStart 훅
+│   ├── harness-user-prompt-submit.sh   # UserPromptSubmit 훅
+│   ├── harness-queue-manager.sh        # v4: Feature Queue 관리
+│   ├── harness-team-worker.sh          # v4: Team Worker (Gen→Eval 루프)
+│   ├── harness-studio-v4.sh            # v4: tmux 레이아웃
+│   ├── harness-dashboard-v4.sh         # v4: Progress 패널
+│   ├── harness-prompts-v4.sh           # v4: Prompts 패널
+│   └── lib/
+├── .harness/
+│   ├── config.json                     # 하네스 설정
+│   ├── HARNESS.md                      # 상세 가이드
+│   ├── progress.json                   # 세션 간 상태
+│   ├── progress.log                    # append-only 히스토리
+│   ├── gotchas/                        # 에이전트별 실수 기록
+│   ├── actions/
+│   │   ├── feature-list.json           # 기능 목록 + AC
+│   │   ├── feature-queue.json          # v4: Feature Queue 상태
+│   │   ├── api-contract.json           # API 계약서
+│   │   └── plan.md                     # 제품 사양
+│   └── archive/                        # 완료 스프린트 보관
+└── .claude/
+    ├── settings.json                   # 훅 등록
+    └── skills/                         # Claude Code 스킬 (8개)
+```
 ---
-## Playwright MCP 설정 (React 프로젝트)
+## Playwright MCP 설정
-Evaluator-Functional / Evaluator-Visual이 브라우저 테스트를 수행하려면 Playwright MCP가 필요합니다. `~/.mcp.json`에 추가:
+Evaluator가 브라우저 테스트를 수행하려면 Playwright MCP가 필요합니다:
 ```json
+// ~/.mcp.json
 {
   "mcpServers": {
     "playwright": {
@@ -345,8 +346,6 @@ Evaluator-Functional / Evaluator-Visual이 브라우저 테스트를 수행하
 }
 ```
-> **Flutter Web (`fe_target=web`) 프로젝트도 Playwright 가 필요합니다** — 컴파일 결과가 일반 웹앱과 동일하므로 React 와 같은 evaluator 를 재사용합니다. **Flutter Mobile/Desktop (`fe_target=mobile`/`desktop`) 프로젝트만** Playwright 없이 `flutter analyze` + `flutter test` 기반으로 동작합니다.
 ---
 ## 트러블슈팅
@@ -354,76 +353,30 @@ Evaluator-Functional / Evaluator-Visual이 브라우저 테스트를 수행하
 ### Skills가 로드되지 않아요
 ```bash
-# Claude Code 세션을 완전히 종료하고 다시 시작
-/exit
-# 프로젝트 디렉토리에서 재진입 후 확인
-```
-Claude Code는 세션 시작 시 `.claude/skills/`를 스캔합니다. `npm install` 이후 반드시 세션 재시작이 필요합니다.
-### Dispatcher가 자동 호출되지 않아요
-`UserPromptSubmit` 훅이 정상적으로 등록되었는지 확인:
-```bash
-cat .claude/settings.json
-# hooks.UserPromptSubmit 배열에 harness-user-prompt-submit.sh가 있어야 함
+/exit  # Claude Code 세션 종료
+# 프로젝트 디렉토리에서 재진입
 ```
-등록이 안 되었다면:
+### 스크립트가 구버전이에요
 ```bash
-npx walwal-harness --force
-# 재시작
+npx walwal-harness  # 코어 스크립트 자동 덮어쓰기
 ```
-### 브레인스토밍이 매번 실행돼서 피로해요
-Brainstormer는 Dispatcher가 "브레인스토밍 필요합니까?" 물을 때만 실행됩니다. **N**으로 답하면 Planner로 직행합니다. 피드백/이터레이션/특정 에이전트 명령에서는 질문 자체가 나오지 않습니다.
-### Flutter 프로젝트인데 React 에이전트가 실행돼요
+### v4 Team이 "No features ready" 반복
 ```bash
-# 프로젝트 루트에 pubspec.yaml이 있고 flutter: 키가 존재하는지 확인
-grep "flutter:" pubspec.yaml
-# 재스캔
-bash scripts/scan-project.sh .
-# pipeline.json의 fe_stack + fe_target 값 확인
-cat .harness/actions/pipeline.json | jq '.fe_stack, .fe_target'
+# Studio를 재시작하면 자동으로 stale in_progress 복구
+npx walwal-harness v4
 ```
-### Flutter Web 프로젝트인데 evaluator-functional-flutter (정적 분석) 가 실행돼요
-`fe_target` 이 `web` 으로 감지되지 않아서 발생합니다. 다음 두 가지를 확인:
-```bash
-# 1) Flutter 프로젝트 루트에 web/index.html 이 존재하는가?
-ls -la web/index.html
-# 없으면 Flutter Web 활성화:
-flutter config --enable-web
-flutter create --platforms=web .
+### Auto-routing 끄기
-# 2) pipeline.json 의 fe_target 값 확인
-jq '.fe_target' .harness/actions/pipeline.json
-# "mobile" 또는 "unknown" 이면 수동 수정 또는 재스캔
-bash scripts/scan-project.sh .
 ```
-`fe_target = web` 으로 확정되면 Playwright 기반 `evaluator-functional` + `evaluator-visual` 이 자동 사용됩니다.
-### Auto-routing을 끄고 싶어요
-```json
-// .harness/config.json
-{ "behavior": { "auto_route_dispatcher": false } }
+❯ harness skip 답만 해줘
 ```
-또는 개별 메시지에서:
-```
-> harness skip 그냥 이것만 답해줘
-```
+또는 `.harness/config.json`에서 `behavior.auto_route_dispatcher = false`
 ---
@@ -432,7 +385,7 @@ bash scripts/scan-project.sh .
 - [Anthropic: Effective Harnesses for Long-Running Agents](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents)
 - [Anthropic: Harness Design for Long-Running Application Development](https://www.anthropic.com/engineering/harness-design-long-running-apps)
 - [Claude Code Skills Documentation](https://code.claude.com/docs/en/skills)
-- [obra/superpowers](https://github.com/obra/superpowers) — Brainstorming skill 원본 (MIT License)
+- [obra/superpowers](https://github.com/obra/superpowers) — Brainstorming skill (MIT License)
 ## License

package/bin/init.js CHANGED Viewed

@@ -231,6 +231,7 @@ function installScripts() {
     'harness-control-v4.sh',
     'harness-queue-manager.sh',
     'harness-team-worker.sh',
+    'harness-prompts-v4.sh',
   ]);
   if (fs.existsSync(scriptsSrc)) {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@walwal-harness/cli",
-  "version": "4.0.0-alpha.13",
+  "version": "4.0.0-alpha.15",
   "description": "Production harness for AI agent engineering — Planner, Generator(BE/FE), Evaluator(Func/Visual), optional Brainstormer (requirements refinement). Supports React and Flutter FE stacks.",
   "bin": {
     "walwal-harness": "bin/init.js"

package/scripts/harness-dashboard-v4.sh CHANGED Viewed

@@ -1,6 +1,6 @@
 #!/bin/bash
-# harness-dashboard-v4.sh — v4 Dashboard: Feature Queue + Team Status
-# Auto-refresh 3초 간격. feature-queue.json + feature-list.json 시각화.
+# harness-dashboard-v4.sh — v4 Dashboard 상단: Planner Progress
+# Queue + Teams + Features 를 auto-refresh. 고정 영역, 스크롤 없음.
 set -uo pipefail
@@ -30,42 +30,34 @@ render_header() {
   now=$(date +"%H:%M:%S")
   project_name=$(jq -r '.project_name // "Unknown"' "$PROGRESS" 2>/dev/null)
-  echo -e "${BOLD}╔════════════════════════════════════════════════╗${RESET}"
-  echo -e "${BOLD}║  HARNESS v4 — Parallel Agent Teams             ║${RESET}"
-  echo -e "${BOLD}╚════════════════════════════════════════════════╝${RESET}"
-  echo -e "  ${DIM}${project_name}  |  ${now}${RESET}"
-  echo ""
+  echo -e "${BOLD}HARNESS v4${RESET} ${DIM}${project_name} | ${now}${RESET}"
 }
 render_queue_summary() {
   if [ ! -f "$QUEUE" ]; then
-    echo -e "  ${DIM}(queue not initialized — run 'init' in Control)${RESET}"
+    echo -e "  ${DIM}(queue not initialized)${RESET}"
     return
   fi
-  local ready blocked in_prog passed failed total concurrency
+  local ready blocked in_prog passed failed total
   ready=$(jq '.queue.ready | length' "$QUEUE" 2>/dev/null || echo 0)
   blocked=$(jq '.queue.blocked | length' "$QUEUE" 2>/dev/null || echo 0)
   in_prog=$(jq '.queue.in_progress | length' "$QUEUE" 2>/dev/null || echo 0)
   passed=$(jq '.queue.passed | length' "$QUEUE" 2>/dev/null || echo 0)
   failed=$(jq '.queue.failed | length' "$QUEUE" 2>/dev/null || echo 0)
-  concurrency=$(jq '.concurrency // 3' "$QUEUE" 2>/dev/null || echo 3)
   ready=${ready:-0}; blocked=${blocked:-0}; in_prog=${in_prog:-0}; passed=${passed:-0}; failed=${failed:-0}
   total=$((ready + blocked + in_prog + passed + failed))
-  # Progress bar
   local pct=0
   if [ "$total" -gt 0 ]; then pct=$(( passed * 100 / total )); fi
-  local bar_w=20
+  local bar_w=16
   local filled=$(( pct * bar_w / 100 ))
   local empty=$(( bar_w - filled ))
   local bar=""
   for ((i=0; i<filled; i++)); do bar+="█"; done
   for ((i=0; i<empty; i++)); do bar+="░"; done
-  echo -e "  ${BOLD}Queue${RESET}  ${bar}  ${passed}/${total} (${pct}%)  ${DIM}concurrency=${concurrency}${RESET}"
-  echo -e "  Ready:${GREEN}${ready}${RESET}  Blocked:${YELLOW}${blocked}${RESET}  Progress:${CYAN}${in_prog}${RESET}  Pass:${GREEN}${passed}${RESET}  Fail:${RED}${failed}${RESET}"
-  echo ""
+  echo -e "  ${bar} ${passed}/${total} (${pct}%)  R:${GREEN}${ready}${RESET} B:${YELLOW}${blocked}${RESET} P:${CYAN}${in_prog}${RESET} ${GREEN}✓${passed}${RESET} ${RED}✗${failed}${RESET}"
 }
 render_teams() {
@@ -75,49 +67,44 @@ render_teams() {
   team_count=$(jq '.teams | length' "$QUEUE" 2>/dev/null)
   if [ "${team_count:-0}" -eq 0 ]; then return; fi
-  echo -e "  ${BOLD}Teams${RESET}"
   for i in $(seq 1 "$team_count"); do
     local t_status t_feature t_phase t_attempt
     t_status=$(jq -r ".teams[\"$i\"].status // \"idle\"" "$QUEUE" 2>/dev/null)
     t_feature=$(jq -r ".teams[\"$i\"].feature // \"—\"" "$QUEUE" 2>/dev/null)
-    # Get phase from in_progress
     if [ "$t_feature" != "—" ] && [ "$t_feature" != "null" ]; then
       t_phase=$(jq -r --arg f "$t_feature" '.queue.in_progress[$f].phase // "?"' "$QUEUE" 2>/dev/null)
       t_attempt=$(jq -r --arg f "$t_feature" '.queue.in_progress[$f].attempt // 1' "$QUEUE" 2>/dev/null)
     else
-      t_phase="—"
-      t_attempt="—"
+      t_phase="—"; t_attempt=""
     fi
     local icon color
     case "$t_status" in
-      busy)   icon="▶" ; color="$GREEN" ;;
-      idle)   icon="○" ; color="$DIM" ;;
-      paused) icon="⏸" ; color="$YELLOW" ;;
-      *)      icon="?" ; color="$RESET" ;;
+      busy)   icon="▶"; color="$GREEN" ;;
+      idle)   icon="○"; color="$DIM" ;;
+      *)      icon="?"; color="$RESET" ;;
     esac
-    local phase_display=""
+    local phase_short=""
     case "$t_phase" in
-      gen)  phase_display="${CYAN}GEN${RESET}" ;;
-      gate) phase_display="${YELLOW}GATE${RESET}" ;;
-      eval) phase_display="${MAGENTA}EVAL${RESET}" ;;
-      *)    phase_display="${DIM}${t_phase}${RESET}" ;;
+      gen)  phase_short="${CYAN}G${RESET}" ;;
+      gate) phase_short="${YELLOW}K${RESET}" ;;
+      eval) phase_short="${MAGENTA}E${RESET}" ;;
+      *)    phase_short="${DIM}-${RESET}" ;;
     esac
-    printf "  %b %b Team %d  %-8s %b  attempt %s\n" "$color" "$icon" "$i" "$t_feature" "$phase_display" "$t_attempt"
+    printf "  %b%b T%d %-7s %b" "$color" "$icon" "$i" "$t_feature" "$phase_short"
+    if [ -n "$t_attempt" ] && [ "$t_attempt" != "—" ]; then
+      printf " #%s" "$t_attempt"
+    fi
+    echo ""
   done
-  echo ""
 }
-render_feature_list() {
+render_features() {
   if [ ! -f "$QUEUE" ] || [ ! -f "$FEATURES" ]; then return; fi
-  echo -e "  ${BOLD}Features${RESET}"
-  # Single jq call: merge feature-list + queue state → pre-formatted lines
   jq -r --slurpfile q "$QUEUE" '
     ($q[0].queue.passed // []) as $passed |
     ($q[0].queue.failed // []) as $failed |
@@ -125,7 +112,7 @@ render_feature_list() {
     ($q[0].queue.in_progress // {}) as $prog |
     .features[] |
     .id as $fid |
-    (.name // .description // "?" | if length > 22 then .[0:20] + ".." else . end) as $fname |
+    (.name // .description // "?" | if length > 18 then .[0:16] + ".." else . end) as $fname |
     (if ($fid | IN($passed[])) then "P"
      elif $prog[$fid] then "I|\($prog[$fid].team)|\($prog[$fid].phase)"
      elif ($fid | IN($failed[])) then "F"
@@ -138,100 +125,25 @@ render_feature_list() {
       F)    printf "  ${RED}✗${RESET} %-6s %s\n" "$fid" "$fname" ;;
       R)    printf "  ${YELLOW}○${RESET} %-6s %s\n" "$fid" "$fname" ;;
       B)    printf "  ${DIM}◌${RESET} %-6s %s\n" "$fid" "$fname" ;;
-      I\|*) # in_progress: extract team and phase
-            team=$(echo "$st" | cut -d'|' -f2)
+      I\|*) team=$(echo "$st" | cut -d'|' -f2)
             phase=$(echo "$st" | cut -d'|' -f3)
-            printf "  ${CYAN}◐${RESET} %-6s %-18s T%s:%s\n" "$fid" "$fname" "$team" "$phase" ;;
+            printf "  ${CYAN}◐${RESET} %-6s %-14s T%s:%s\n" "$fid" "$fname" "$team" "$phase" ;;
       *)    printf "  ? %-6s %s\n" "$fid" "$fname" ;;
     esac
   done
-  echo ""
-}
-render_user_prompts() {
-  local log_file="$PROJECT_ROOT/.harness/progress.log"
-  if [ ! -f "$log_file" ]; then return; fi
-  # Extract user-prompt entries (newest first, max 5)
-  local user_lines
-  user_lines=$(grep 'user-prompt' "$log_file" 2>/dev/null | tail -r 2>/dev/null | head -5)
-  if [ -z "$user_lines" ]; then return; fi
-  echo -e "  ${BOLD}Manual Prompts${RESET} ${DIM}(newest first)${RESET}"
-  echo "$user_lines" | while IFS= read -r line; do
-    local ts detail
-    ts=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$1); print $1}')
-    detail=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$4); print $4}')
-    # Short timestamp (HH:MM or MM-DD HH:MM)
-    local short_ts
-    short_ts=$(echo "$ts" | sed 's/^[0-9]*-//')
-    if [ ${#detail} -gt 55 ]; then detail="${detail:0:53}.."; fi
-    echo -e "  ${BOLD}★${RESET} ${DIM}${short_ts}${RESET} ${detail}"
-  done
-  echo ""
-}
-render_team_activity() {
-  local log_file="$PROJECT_ROOT/.harness/progress.log"
-  if [ ! -f "$log_file" ]; then return; fi
-  local max_lines=8
-  echo -e "  ${BOLD}Activity${RESET} ${DIM}(newest first)${RESET}"
-  # All non-user-prompt entries, newest first
-  grep -v '^#' "$log_file" 2>/dev/null | grep -v '^$' | grep -v 'user-prompt' | \
-  tail -r 2>/dev/null | head -"$max_lines" | \
-  while IFS= read -r line; do
-    local ts agent action detail
-    ts=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$1); print $1}')
-    agent=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$2); print $2}')
-    action=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$3); print $3}')
-    detail=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$4); print $4}')
-    local short_ts icon color
-    short_ts=$(echo "$ts" | sed 's/^[0-9]*-//')
-    case "$agent" in
-      dispatcher*) icon="▸"; color="$MAGENTA" ;;
-      team-*)      icon="⚡"; color="$CYAN" ;;
-      manual)      icon="★"; color="$BOLD" ;;
-      planner*)    icon="□"; color="$YELLOW" ;;
-      gen*)        icon="▶"; color="$GREEN" ;;
-      eval*)       icon="✦"; color="$RED" ;;
-      system)      icon="⚙"; color="$DIM" ;;
-      *)           icon="·"; color="$DIM" ;;
-    esac
-    if [ ${#detail} -gt 45 ]; then detail="${detail:0:43}.."; fi
-    echo -e "  ${color}${icon}${RESET} ${DIM}${short_ts}${RESET} ${agent} ${DIM}${action}${RESET} ${detail}"
-  done
-  echo ""
 }
 render_all() {
   render_header
   render_queue_summary
   render_teams
-  render_user_prompts
-  render_team_activity
-  render_feature_list
-  echo -e "  ${DIM}Refreshing every 3s${RESET}"
+  echo ""
+  render_features
 }
 # ── Main loop ──
 tput civis 2>/dev/null
 trap 'tput cnorm 2>/dev/null; exit 0' EXIT INT TERM
 clear
 while true; do

package/scripts/harness-prompts-v4.sh ADDED Viewed

@@ -0,0 +1,106 @@
+#!/bin/bash
+# harness-prompts-v4.sh — v4 Dashboard 하단: Manual Prompts + Activity
+# progress.log에서 user-prompt와 team 활동을 newest-first로 표시.
+# 스크롤 가능 영역 — 프롬프트가 많아져도 상단 Progress를 가리지 않음.
+set -uo pipefail
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_ROOT="${1:-}"
+if [ -z "$PROJECT_ROOT" ]; then
+  source "$SCRIPT_DIR/lib/harness-render-progress.sh"
+  PROJECT_ROOT="$(resolve_harness_root ".")" || { echo "[prompts] .harness/ not found."; exit 1; }
+fi
+LOG_FILE="$PROJECT_ROOT/.harness/progress.log"
+BOLD="\033[1m"
+DIM="\033[2m"
+GREEN="\033[32m"
+YELLOW="\033[33m"
+RED="\033[31m"
+CYAN="\033[36m"
+MAGENTA="\033[35m"
+RESET="\033[0m"
+LAST_LINE_COUNT=0
+render_prompts() {
+  if [ ! -f "$LOG_FILE" ]; then
+    echo -e "  ${DIM}(progress.log not found)${RESET}"
+    return
+  fi
+  local term_h
+  term_h=$(tput lines 2>/dev/null || echo 20)
+  local max_lines=$((term_h - 3))  # Leave room for header
+  if [ "$max_lines" -lt 5 ]; then max_lines=5; fi
+  echo -e "${BOLD}Prompts & Activity${RESET} ${DIM}(newest first)${RESET}"
+  echo ""
+  # Read all entries, reverse, limit to terminal height
+  grep -v '^#' "$LOG_FILE" 2>/dev/null | grep -v '^$' | \
+  tail -r 2>/dev/null | head -"$max_lines" | \
+  while IFS= read -r line; do
+    local ts agent action detail
+    ts=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$1); print $1}')
+    agent=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$2); print $2}')
+    action=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$3); print $3}')
+    detail=$(echo "$line" | awk -F'|' '{gsub(/^ +| +$/,"",$4); print $4}')
+    local short_ts icon color
+    short_ts=$(echo "$ts" | sed 's/^[0-9]*-//')
+    case "$agent" in
+      user-prompt)
+        icon="★"; color="$BOLD"
+        # User prompts get full width, highlighted
+        if [ ${#detail} -gt 60 ]; then detail="${detail:0:58}.."; fi
+        echo -e "  ${color}${icon} ${short_ts}${RESET} ${detail}"
+        ;;
+      dispatcher*)
+        icon="▸"; color="$MAGENTA"
+        if [ ${#detail} -gt 50 ]; then detail="${detail:0:48}.."; fi
+        echo -e "  ${color}${icon}${RESET} ${DIM}${short_ts}${RESET} ${agent} ${DIM}${action}${RESET} ${detail}"
+        ;;
+      team-*)
+        icon="⚡"; color="$CYAN"
+        if [ ${#detail} -gt 50 ]; then detail="${detail:0:48}.."; fi
+        # Color by action type
+        case "$action" in
+          *pass*)  color="$GREEN"; icon="✓" ;;
+          *fail*)  color="$RED";   icon="✗" ;;
+          *eval*)  color="$MAGENTA"; icon="✦" ;;
+          *gen*)   color="$CYAN";  icon="▶" ;;
+          *merge*) color="$GREEN"; icon="⊕" ;;
+        esac
+        echo -e "  ${color}${icon}${RESET} ${DIM}${short_ts}${RESET} ${agent} ${DIM}${action}${RESET} ${detail}"
+        ;;
+      manual)
+        icon="★"; color="$YELLOW"
+        if [ ${#detail} -gt 50 ]; then detail="${detail:0:48}.."; fi
+        echo -e "  ${color}${icon}${RESET} ${DIM}${short_ts}${RESET} ${detail}"
+        ;;
+      *)
+        icon="·"; color="$DIM"
+        if [ ${#detail} -gt 50 ]; then detail="${detail:0:48}.."; fi
+        echo -e "  ${color}${icon}${RESET} ${DIM}${short_ts}${RESET} ${agent} ${DIM}${action}${RESET} ${detail}"
+        ;;
+    esac
+  done
+}
+# ── Main loop ──
+tput civis 2>/dev/null
+trap 'tput cnorm 2>/dev/null; exit 0' EXIT INT TERM
+clear
+while true; do
+  buf=$(render_prompts 2>&1)
+  tput cup 0 0 2>/dev/null
+  echo "$buf"
+  tput ed 2>/dev/null
+  sleep 3
+done

package/scripts/harness-studio-v4.sh CHANGED Viewed

@@ -1,21 +1,13 @@
 #!/bin/bash
-# harness-studio-v4.sh — Harness Studio v4: 3-Column Layout
+# harness-studio-v4.sh — Harness Studio v4: 3-Column + Dashboard Split
 #
 # ┌──────────────┬──────────────┬──────────────┐
-# │              │              │  Team 1      │
-# │              │              ├──────────────┤
-# │  Main        │  Dashboard   │  Team 2      │
-# │  (Claude)    │  (read-only) ├──────────────┤
-# │              │              │  Team 3      │
+# │              │  Progress    │  Team 1      │
+# │              │  (fixed)     ├──────────────┤
+# │  Main        ├──────────────┤  Team 2      │
+# │  (claude)    │  Prompts     ├──────────────┤
+# │              │  (scroll)    │  Team 3      │
 # └──────────────┴──────────────┴──────────────┘
-#
-# Main: 사용자가 직접 Claude Code를 실행하는 대화형 세션
-# Dashboard: feature-queue + team status 자동 갱신 (입력 불가)
-# Team 1~3: claude -p headless worker (입력 불가, 로그만 표시)
-#
-# Usage:
-#   bash scripts/harness-studio-v4.sh [project-root]
-#   bash scripts/harness-studio-v4.sh --kill
 set -euo pipefail
@@ -54,7 +46,7 @@ echo "Session: $SESSION_NAME"
 tmux kill-session -t "$SESSION_NAME" 2>/dev/null || true
-# ── Initialize or recover queue ──
+# ── Init/recover queue ──
 QUEUE="$PROJECT_ROOT/.harness/actions/feature-queue.json"
 if [ ! -f "$QUEUE" ]; then
   echo "Initializing feature queue..."
@@ -65,47 +57,78 @@ else
 fi
 # ══════════════════════════════════════════
-# 3-Column Layout (Main | Dashboard | Teams)
+# Layout: 3 columns first, then split middle column
+#
+# Step 1: [Main]
+# Step 2: [Main | Right]          — h split 66%
+# Step 3: [Main | Mid | Right]    — h split Mid from Right at 50%
+# Step 4: [Main | Progress / Prompts | Right]  — v split Mid
+# Step 5: [Main | Progress / Prompts | T1 / T2 / T3]  — v split Right
 # ══════════════════════════════════════════
-# Column 1: Main (interactive shell — user runs claude here)
+# 1. Main
 PANE_MAIN=$(tmux new-session -d -s "$SESSION_NAME" -c "$PROJECT_ROOT" -x 220 -y 55 \
   -P -F '#{pane_id}')
-# Column 2: Dashboard (split right from Main, 66% remaining → 33% each of 3 cols)
-PANE_DASH=$(tmux split-window -h -p 66 -t "$PANE_MAIN" -c "$PROJECT_ROOT" \
-  -P -F '#{pane_id}' \
-  "bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-dashboard-v4.sh\" \"${PROJECT_ROOT}\"'")
+# 2. Right column (will become Team area)
+PANE_RIGHT=$(tmux split-window -h -p 66 -t "$PANE_MAIN" -c "$PROJECT_ROOT" \
+  -P -F '#{pane_id}')
-# Column 3: Team 1 (split right from Dashboard, 50% of remaining = 33% total)
-PANE_T1=$(tmux split-window -h -p 50 -t "$PANE_DASH" -c "$PROJECT_ROOT" \
+# 3. Middle column (split from Right, 50% = Mid gets left half, Right keeps right half)
+PANE_MID=$(tmux split-window -h -p 50 -t "$PANE_RIGHT" -c "$PROJECT_ROOT" \
+  -P -F '#{pane_id}')
+# Now: PANE_MID is the NEW pane (right side of split), PANE_RIGHT stays left
+# Wait — tmux split-window -h on PANE_RIGHT creates new pane to the RIGHT of PANE_RIGHT
+# So PANE_MID ends up on the right, and PANE_RIGHT is in the middle
+# We need to swap: split PANE_MAIN's right, then the rightmost becomes teams
+# Actually let me reconsider. After step 2:
+#   [Main 33%] [Right 66%]
+# After step 3 (split Right horizontally at 50%):
+#   [Main 33%] [Right_left 33%] [Right_right 33%]
+# Right_left = PANE_RIGHT (original), Right_right = PANE_MID (new)
+# We want: Right_left = Dashboard area, Right_right = Team area
+# So PANE_RIGHT becomes Dashboard, PANE_MID becomes Teams. But pane IDs...
+# Actually: split-window creates the NEW pane. -h splits horizontally.
+# The new pane goes to the right. So:
+#   PANE_RIGHT (original) = middle column (Dashboard)
+#   PANE_MID (new) = right column (Teams)
+# Perfect!
+# 4. Split middle column (PANE_RIGHT = Dashboard area) into Progress + Prompts
+#    Kill the shell in PANE_RIGHT first, replace with Progress
+tmux send-keys -t "$PANE_RIGHT" "exec bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-dashboard-v4.sh\" \"${PROJECT_ROOT}\"'" Enter
+PANE_PROMPTS=$(tmux split-window -v -p 40 -t "$PANE_RIGHT" -c "$PROJECT_ROOT" \
   -P -F '#{pane_id}' \
-  "bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-team-worker.sh\" 1 \"${PROJECT_ROOT}\"'")
+  "bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-prompts-v4.sh\" \"${PROJECT_ROOT}\"'")
+# 5. Split right column (PANE_MID = Team area) into Team 1/2/3
+tmux send-keys -t "$PANE_MID" "exec bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-team-worker.sh\" 1 \"${PROJECT_ROOT}\"'" Enter
-# Team 2 (split below Team 1)
-PANE_T2=$(tmux split-window -v -p 66 -t "$PANE_T1" -c "$PROJECT_ROOT" \
+PANE_T2=$(tmux split-window -v -p 66 -t "$PANE_MID" -c "$PROJECT_ROOT" \
   -P -F '#{pane_id}' \
   "bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-team-worker.sh\" 2 \"${PROJECT_ROOT}\"'")
-# Team 3 (split below Team 2)
 PANE_T3=$(tmux split-window -v -p 50 -t "$PANE_T2" -c "$PROJECT_ROOT" \
   -P -F '#{pane_id}' \
   "bash --norc --noprofile -c 'exec bash \"${SCRIPT_DIR}/harness-team-worker.sh\" 3 \"${PROJECT_ROOT}\"'")
-# ── Launch Claude in Main pane ──
+# ── Launch Claude in Main ──
 tmux send-keys -t "$PANE_MAIN" "unset npm_config_prefix 2>/dev/null; clear && claude --dangerously-skip-permissions" Enter
 # ── Pane titles ──
-tmux select-pane -t "$PANE_MAIN" -T "Main"
-tmux select-pane -t "$PANE_DASH" -T "Dashboard"
-tmux select-pane -t "$PANE_T1"   -T "Team 1"
-tmux select-pane -t "$PANE_T2"   -T "Team 2"
-tmux select-pane -t "$PANE_T3"   -T "Team 3"
+tmux select-pane -t "$PANE_MAIN"    -T "Main"
+tmux select-pane -t "$PANE_RIGHT"   -T "Progress"
+tmux select-pane -t "$PANE_PROMPTS" -T "Prompts"
+tmux select-pane -t "$PANE_MID"     -T "Team 1"
+tmux select-pane -t "$PANE_T2"      -T "Team 2"
+tmux select-pane -t "$PANE_T3"      -T "Team 3"
 tmux set-option -t "$SESSION_NAME" pane-border-status top 2>/dev/null || true
 tmux set-option -t "$SESSION_NAME" pane-border-format " #{pane_title} " 2>/dev/null || true
-# ── Focus Main pane ──
+# ── Focus Main ──
 tmux select-pane -t "$PANE_MAIN"
 # ── Attach ──
@@ -114,9 +137,10 @@ if [ -n "${TMUX:-}" ]; then
 else
   echo ""
   echo "Launching Harness Studio v4..."
-  echo "  Main (left)      : Interactive — run 'claude' here"
-  echo "  Dashboard (mid)  : Feature Queue + Team status (auto-refresh)"
-  echo "  Team 1-3 (right) : Parallel workers (headless, log only)"
+  echo "  Main (left)       : Claude interactive"
+  echo "  Progress (mid↑)   : Queue + Teams + Features"
+  echo "  Prompts (mid↓)    : Manual prompts + activity"
+  echo "  Team 1-3 (right)  : Parallel workers"
   echo ""
   tmux attach -t "$SESSION_NAME"
 fi