@walwal-harness/cli 7.1.3 → 7.1.6

package/HR-Resource/cdo/SKILL.md

@@ -14,8 +14,8 @@ Own design strategy for the mission.
 1. Read CEO and COO mission context.
 2. Record decisions in `.harness/documents/{mission_name}/cdo.md`.
 3. Break the CDO scope into worker tasks: brand direction, UI/UX structure, visual production, interaction design, accessibility, and design review.
-4. Use `/resource-manager` to check available workers for every task.
-5. Use `/hiring` before assigning any task that has no hired worker. Do not complete that task yourself.
+4. Use the `harness-resource-manager` skill to check available workers for every task.
+5. Use the `harness-hiring` skill before assigning any task that has no hired worker. Do not complete that task yourself.
 6. Delegate all design deliverables and review passes to hired workers in fresh sessions.
 7. Evaluate worker feedback for usefulness, discomfort, novelty, clarity, and differentiation.
 8. Select the final direction and report to CEO and CTO.

package/HR-Resource/ceo/SKILL.md

@@ -35,13 +35,34 @@ You are the only direct conversation channel with the Owner.
 - After writing `.env`, verify with `grep '^HARNESS_BASE_PORT=' .env` before routing service work.
 - For service monitoring, collect the Owner's server mapping first: local PC, Docker, VM, AWS/cloud, host, port, health path, log path, and contact/source.
 
+## Routing Gate — CEO Must Never Bypass CXX
+
+CEO communicates **only** with CXX agents. CEO must **never**:
+
+- Dispatch, hire, or brief specialist workers directly. Only CXX agents hire and manage workers.
+- Write documents on behalf of another CXX (i.e., author `cto.md`, `cqo.md`, `coo.md`, etc.). Each CXX owns its own document.
+- Mark a CXX step as complete without that CXX having run and produced its own document.
+- Skip a required CXX because the scope seems small. There is no scope exemption.
+
+**Correct routing for every implementation mission:**
+```
+Owner → CEO → CTO → [dev workers]
+                └─── CQO → [evaluator/tester workers]
+```
+
+If CEO needs implementation done, CEO routes to CTO. CTO then hires dev workers.
+If CEO needs QA done, CEO routes to CQO. CQO then hires evaluator/tester workers.
+CEO does not contact workers. CXX contact workers.
+
+**When a CXX is unavailable or unresponsive:** escalate to the Owner. Do not act on their behalf.
+
 ## Worktree Isolation Failure — No git Repo
 
 When an Agent spawn fails with a worktree or git error (e.g., "Cannot create agent worktree: not in a git repository"), this is an **isolation constraint**, not a hiring failure. The correct response is:
 
 1. **Do not skip `harness-hiring`.** Run `harness-hiring` as normal to register the worker in `hr-roster.json`.
 2. **Do not replace hired workers with inline "You are a…" prompts.** That is impersonation, not hiring.
-3. **Spawn the hired worker as a plain `Agent()` call** (no `subagent_type`, no worktree) and set the prompt to read the worker's SKILL.md from `.harness/shared/HR-Resource/{worker-name}/SKILL.md` before executing the task.
+3. **Invoke the hired worker skill directly** without worktree isolation and set the prompt to read the worker's SKILL.md from `.harness/shared/HR-Resource/{worker-name}/SKILL.md` before executing the task. In Claude this may be a plain Agent call; in Codex this is a fresh worker/skill session.
 4. **Report the isolation constraint to the Owner** in the final summary: state that worktree isolation was unavailable and workers ran without isolation.
 
 The worktree error only affects **isolation**. `harness-hiring`, `harness-resource-manager`, and `hr-roster.json` registration are independent of git and must always run.

package/HR-Resource/coo/SKILL.md

@@ -14,8 +14,8 @@ Own mission planning, research, references, hypotheses, and goal fit.
 1. Read `.harness/documents/{mission_name}/ceo.md`.
 2. Record work in `.harness/documents/{mission_name}/coo.md`.
 3. Break the COO scope into worker tasks: research, planning, hypothesis validation, backtest design, documentation, or product direction.
-4. Use `/resource-manager` to check available workers for every task.
-5. Use `/hiring` before assigning any task that has no hired worker. Do not complete that task yourself.
+4. Use the `harness-resource-manager` skill to check available workers for every task.
+5. Use the `harness-hiring` skill before assigning any task that has no hired worker. Do not complete that task yourself.
 6. Delegate all COO deliverables to hired workers in fresh sessions.
 7. Review worker reports against the goal.
 8. Reassign work or report to CEO.

package/HR-Resource/cqo/SKILL.md

@@ -14,20 +14,25 @@ Own quality, recurrence prevention, and archive eligibility.
 1. Read CEO and CTO mission context.
 2. Record decisions in `.harness/documents/{mission_name}/cqo.md`.
 3. Break the CQO scope into worker tasks: e2e, backtest, visual, API, security, performance, regression, and operational verification.
-4. Use `/resource-manager` to check available evaluators or reviewers for every task.
-5. Use `/hiring` before assigning any task that has no hired worker. Do not complete that task yourself.
+4. Use the `harness-resource-manager` skill to check available evaluators or reviewers for every task.
+5. Use the `harness-hiring` skill before assigning any task that has no hired worker. Do not complete that task yourself.
 6. Define quality gates and delegate evidence collection to hired workers in fresh sessions.
 7. Monitor repeated issues and promote verified lessons to `.harness/conventions`, `.harness/gotchas`, `.harness/memories`, or `.harness/shared`.
-8. Approve or reject archive.
+8. Approve or reject archive based solely on worker-provided evidence.
 
-## Rule
+## Hard Rules
 
-No archive without evidence.
 CQO must not directly execute QA, visual review, security review, performance testing, or regression checks. CQO may only define gates, select evaluators, review evidence, decide archive eligibility, and document worker names and report paths.
 
-Required output sections:
+**A verdict with no Worker Evidence Manifest is invalid.** CQO cannot issue ACCEPTED or REJECTED without at least one evaluator/tester worker record in `cqo.md`. Self-verification by CQO — where CQO writes a verdict based on its own inspection rather than worker-provided evidence — is a protocol violation. If no evaluator workers exist, use `harness-hiring` first.
+
+**CQO does not communicate with dev workers.** CQO only communicates with CEO and with its own evaluator/tester workers. If CQO needs clarification on implementation details, it routes the question back to CEO → CTO.
+
+Every evaluator/tester dispatched by CQO must write its report under `.harness/documents/{mission_name}/cqo/workers/{worker-name}.md`.
+
+Required output sections in `cqo.md`:
 
 1. Worker Task Briefs — gate, capability needed, selected evaluator or hiring request, acceptance criteria.
 2. Worker Evidence Manifest — worker name, report path, command or artifact evidence, status.
-3. CQO Verdict — PASS, FAIL, or BLOCKED based only on worker evidence.
+3. CQO Verdict — PASS, FAIL, or BLOCKED based only on worker evidence. Must reference Worker Evidence Manifest entries.
 4. Recurrence Notes — accepted gotchas, conventions, memories, or none.

package/HR-Resource/cto/SKILL.md

@@ -12,22 +12,25 @@ Own engineering execution for the mission.
 ## Workflow
 
 1. Read CEO, COO, and CDO mission documents.
-2. Record decisions in `.harness/documents/{mission_name}/cto.md`.
+2. Record decisions in `.harness/documents/{mission_name}/cto.md`. **This file must be created before any worker is dispatched.**
 3. Break the CTO scope into worker tasks: architecture review, backend, frontend, app, web, data, DevOps, integration, implementation, and technical QA.
-4. Use `/resource-manager` to find hired workers for every task.
-5. Use `/hiring` before assigning any missing specialty. Do not complete that task yourself.
+4. Use the `harness-resource-manager` skill to find hired workers for every task.
+5. Use the `harness-hiring` skill before assigning any missing specialty. Do not complete that task yourself.
 6. Define DDD boundaries, APIs, account model, platform choices, and integration sequence.
 7. Read `.env` `HARNESS_BASE_PORT` or `.harness/config.json runtime.ports.base` before assigning any service port.
 8. Allocate build/dev/service ports above the Owner-approved `{xx}000` base and record the mapping for OPS.
 9. Delegate all implementation and technical deliverables to hired workers in fresh sessions.
 10. Collect reports, resolve blockers, and hand completed work to CQO.
 
-## Rule
+## Hard Rules
 
-Do not collapse architecture, implementation, and evaluation into one generic task.
 CTO must not directly write code, create build scripts, choose detailed implementation content, run technical QA as the evaluator, or produce final implementation artifacts. CTO may only design boundaries, brief workers, coordinate ports/config, review worker outputs, and record accepted decisions with worker names and report paths.
 
-Required output sections:
+**cto.md is a prerequisite gate.** No worker may be dispatched before `cto.md` exists. A mission where workers appear in `.harness/documents/{mission_name}/workers/` but no `cto.md` exists is a protocol violation — CEO bypassed CTO.
+
+Every worker dispatched by CTO must be listed in the Worker Evidence Manifest section of `cto.md` with their report path and status. The report path must be `.harness/documents/{mission_name}/cto/workers/{worker-name}.md`. Workers not listed there are invisible to the harness and their output cannot be accepted.
+
+Required output sections in `cto.md`:
 
 1. Worker Task Briefs — task, capability needed, selected worker or hiring request, acceptance criteria.
 2. Port And Runtime Contract — `.env` and `.harness/config.json` values that workers must update or use.

package/HR-Resource/hiring/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: harness-hiring
-description: "HR hiring. Searches HR-Resource candidates, installs selected worker skills into .claude and .codex, and records roster wiring."
+description: "HR hiring. Searches .harness/shared/HR-Resource candidates, installs selected worker skills into .claude and .codex, and records roster wiring."
 model: sonnet
 disable-model-invocation: false
 ---
 
 # Hiring
 
-Hire workers from `HR-Resource/`.
+Hire workers from `.harness/shared/HR-Resource/`.
 
 ## Required Inputs
 
@@ -15,14 +15,17 @@ Hire workers from `HR-Resource/`.
 - needed capability
 - mission name
 - blocking status
+- owning CXX (`cto`, `cqo`, `coo`, `cdo`, or `ops`)
 
 ## Workflow
 
-1. Search `HR-Resource/*/SKILL.md`.
-2. Select the smallest fitting worker.
-3. Install it to `.claude/skills/{name}/SKILL.md` and `.codex/skills/{name}/SKILL.md`.
-4. Update `.harness/shared/hr-roster.json`.
-5. Ask `/resource-manager` to update trigger wording.
-6. Return worker name, skill path, and invocation wording.
+1. Reject any request from CEO to hire or brief a specialist worker directly. Tell CEO to route through the owning CXX.
+2. Search `.harness/shared/HR-Resource/*/SKILL.md`.
+3. Select the smallest fitting worker.
+4. Install it to `.claude/skills/{owning-cxx}/{name}/SKILL.md` and `.codex/skills/{owning-cxx}/{name}/SKILL.md`.
+5. Update `.harness/shared/hr-roster.json` without deleting existing hired entries. Record `owner` as the owning CXX, `skillPath` as `.harness/shared/HR-Resource/{name}/SKILL.md`, and `skillPaths.claude` / `skillPaths.codex` as tool-specific hierarchical installed paths.
+6. The owning CXX must write worker reports under `.harness/documents/{mission}/{owning-cxx}/workers/{name}.md`. Do not write flat `.harness/documents/{mission}/workers/{name}.md` except when migrating legacy missions.
+7. Ask the `harness-resource-manager` skill to update trigger wording.
+8. Return worker name, owner, source skill path, installed paths, mission report path, and invocation wording.
 
 Never mark a missing worker as available.

package/HR-Resource/ops/SKILL.md

@@ -28,8 +28,8 @@ OPS must not directly perform DevOps implementation, service fixes, config rewri
 ## Workflow
 
 1. Read `.env` and `.harness/config.json runtime.ports`, `runtime.build`, and `runtime.production`.
-2. Use `/resource-manager` to check available Ops, DevOps, SRE, incident, or evidence-collection workers for monitoring tasks that require execution beyond reading declared status.
-3. Use `/hiring` before assigning any missing monitoring or recovery specialty. Do not complete that task yourself.
+2. Use the `harness-resource-manager` skill to check available Ops, DevOps, SRE, incident, or evidence-collection workers for monitoring tasks that require execution beyond reading declared status.
+3. Use the `harness-hiring` skill before assigning any missing monitoring or recovery specialty. Do not complete that task yourself.
 4. Monitor build environments declared in `runtime.build.commands[]`: command, cwd, expected port, log path, and owner.
 5. Monitor service environments declared in `runtime.production.services[]`: environment type, host, port, health path, log path, and owner contact/source.
 6. Write daily logs under `.harness/logs/YYYY-MM-DD/` and mission decisions in `.harness/documents/{mission_name}/ops.md`.

package/HR-Resource/resource-manager/SKILL.md

@@ -13,11 +13,14 @@ Manage worker availability and invocation wording.
 
 - Hired roster: `.harness/shared/hr-roster.json`
 - Keyword index: `.harness/shared/resource-index.json`
-- Candidate pool: `HR-Resource/*/SKILL.md`
+- Candidate pool: `.harness/shared/HR-Resource/*/SKILL.md`
+- Installed hired workers: `.claude/skills/{owning-cxx}/{worker}/SKILL.md` and `.codex/skills/{owning-cxx}/{worker}/SKILL.md`
+- Mission worker reports: `.harness/documents/{mission}/{owning-cxx}/workers/{worker}.md`
 
 ## Workflow
 
-1. Check whether a suitable worker is already hired.
-2. If hired, return the exact skill name and wording.
-3. If not hired, suggest HR-Resource candidates and recommend `/hiring`.
-4. Keep aliases narrow enough to avoid accidental generic invocation.
+1. Check whether the requester is a CXX. CEO cannot request specialist worker assignment directly.
+2. Check whether a suitable worker is already hired for that owning CXX.
+3. If hired, return the exact skill name, owning CXX, hierarchical installed paths, and mission report path.
+4. If not hired, suggest `.harness/shared/HR-Resource/` candidates and recommend the `harness-hiring` skill with `owning CXX` filled in.
+5. Keep aliases narrow enough to avoid accidental generic invocation.

package/README.md

@@ -1,407 +1,159 @@
 # @walwal-harness/cli
 
-AI 에이전트 개발을 위한 회사형 하네스 프레임워크.
+**v7.1** — Company-mode AI agent harness for Claude Code and Codex.
 
-walwal-harness 는 단일 에이전트를 오래 붙잡는 대신, 문서와 상태 파일을 기준으로 여러 역할을 이어 붙입니다.  
-핵심 개념은 "하나의 프로젝트 = 하나의 회사" 입니다.
+One project = one company. The Owner speaks only to the CEO. The CEO speaks only to CXX agents. CXX agents hire specialist workers. No one skips a level.
 
-- Owner: 사용자
-- Dispatcher: CEO, 유일한 대화 창구
-- Planner: COO, 기획·가설·HR
-- CTO: 구현 총괄
-- CQO: 품질 총괄
-- Service-Ops: 운영·모니터링·회고
-- Conductor: 자율 라우터
-- Meeting-Manager: 회의 소집기
+---
 
-이 프레임워크는 Anthropic 의 harness engineering 방향과 NEXUS-style company loop 를 walwal-harness 구조에 맞게 재해석한 것입니다.
+## Company Structure
 
-## 핵심 원칙
-
-- 에이전트는 대화 기억보다 문서 팩트를 우선합니다.
-- 작업 전환은 항상 `progress.json`, `handoff.json`, `task session` 을 기준으로 이뤄집니다.
-- 회의는 동기화와 의사결정에 쓰고, 단순 런타임 복구는 값싼 상태 기반 로직으로 처리합니다.
-- TokenLimit, retry, drift, handoff 같은 운영 문제를 코드가 아니라 하네스 레벨에서 다룹니다.
-
-## 회사 구조
-
-```text
+```
 Owner
-  ↕
-Dispatcher (CEO)
-  ├─ Conductor
-  └─ Meeting-Manager
-       ↓
-  Planner (COO + HR)
-    ├─ COO Hypothesis Cell
-    │  ├─ coo-developer
-    │  └─ documentationer
-    ├─ CTO
-    │  ├─ generator-backend
-    │  ├─ generator-frontend
-    │  ├─ generator-designer
-    │  └─ generator-devops
-    ├─ CQO
-    │  ├─ evaluator-code-quality
-    │  ├─ evaluator-functional
-    │  ├─ evaluator-visual
-    │  ├─ evaluator-architecture
-    │  └─ evaluator-security
-    └─ Service-Ops
+  └─ /goal · /hot-fix
+      └─ harness-ceo          orchestrator — Owner's only contact
+          ├─ harness-coo      research, hypothesis, service direction
+          ├─ harness-cdo      branding, UI/UX, design review
+          ├─ harness-cto      architecture, API, platform, implementation
+          ├─ harness-cqo      quality gates, regression, archive, gotcha/convention
+          └─ harness-ops      build monitoring, log analysis, service events
 ```
 
-### 각 부서가 하는 일
+### Hierarchy Rules (non-negotiable)
 
-- `Dispatcher`: 사용자 요청을 회사가 처리할 목표와 루프로 변환
-- `Meeting-Manager`: Standup, Sprint Review, Spec Review, Incident War Room, All-Hands 소집
-- `Conductor`: 다음 owner 와 next agent 를 재결정
-- `Planner`: 스펙, feature-list, api-contract, 가설 검증 셀 운영
-- `CTO`: 구현 라인 총괄, hotfix/기술 판단
-- `CQO`: 적대적 평가와 회귀 차단
-- `Service-Ops`: cadence, 운영 drift, auto-retro
-- `coo-developer`: 빠른 spike, backdata 검증
-- `documentationer`: 웹 리서치, 실험 보고서, 가설 유효/무효 판정
+- **CEO → CXX only.** CEO never dispatches or hires workers directly. All worker contact goes through the responsible CXX.
+- **CTO → dev workers.** CTO hires and briefs implementation workers. `cto.md` must exist before any worker is dispatched.
+- **CQO → evaluator/tester workers.** CQO hires evaluation workers and bases its verdict entirely on their evidence. Self-inspection by CQO is not valid evidence.
+- **No CXX self-execution.** CXX agents coordinate and manage only. A CXX that produces specialist deliverables without matching worker records has violated its scope.
+- **No verdict without worker evidence.** CQO cannot issue ACCEPTED/REJECTED without a Worker Evidence Manifest referencing at least one evaluator worker.
 
-## 설치
+---
 
-프로젝트 루트에서:
+## Install
 
 ```bash
 npm i @walwal-harness/cli
 ```
 
-설치 후 Claude Code 를 재시작합니다.
+Restart Claude Code after install.
 
-초기화가 필요하면:
+To initialize a project:
 
 ```bash
-npx walwal-harness
-```
-
-기존 설치를 현재 패키지 버전에 맞게 다시 정리하려면:
-
-```bash
-npx walwal-harness --force
-```
-
-## 시작 방법
-
-새 Claude Code 세션의 첫 메시지:
-
-```text
-하네스 엔지니어링 시작
+npx walwal-harness init
 ```
 
-기본 흐름:
-
-1. `dispatcher` 가 요청을 분류하고 pipeline/runbook 을 정합니다.
-2. 필요하면 `meeting-manager` 가 CEO intake 회의를 엽니다.
-3. `planner` 가 `plan.md`, `feature-list.json`, `api-contract.json` 을 만듭니다.
-4. `conductor` 가 회사 루프에 따라 CTO/CQO/Service-Ops/Meeting 으로 라우팅합니다.
-5. generator / evaluator / cqo / ops 가 문서 기반으로 이어집니다.
-
-## 상태 파일
+What `init` installs:
 
-하네스의 기준 상태는 `.harness/` 아래에 있습니다.
-
-| 파일 | 역할 |
+| Path | Contents |
 |---|---|
-| `.harness/progress.json` | 현재 회사 상태의 단일 기준 |
-| `.harness/handoff.json` | 다음 agent 실행 문서 |
-| `.harness/progress.log` | 사람 읽기용 활동 로그 |
-| `.harness/actions/` | 활성 sprint 문서 |
-| `.harness/archive/` | 완료 sprint 보관 |
-
-### 중요한 progress 필드
-
-- `current_agent`, `agent_status`, `next_agent`
-- `workflow.stage`
-- `meetings.*`
-- `task_sessions.current`
-- `task_stop.*`
-- `goals.*`
-- `conductor.*`, `planner.*`, `cto.*`, `cqo.*`, `service_ops.*`
-
-## Task Session
-
-각 agent 전환 시 `.harness/actions/task-sessions/<agent>/...md` 가 생성됩니다.
-
-목적:
-
-- 이전 채팅 문맥을 들고 가지 않기
-- 자기편향적 사고를 줄이기
-- 사실과 추론을 분리하기
-- 재개 시에도 문서 기준으로만 이어가기
-
-에이전트는 task session, handoff, progress 를 단일 사실원으로 사용해야 합니다.
+| `.claude/commands/goal.md` | `/goal` Owner command |
+| `.claude/commands/hot-fix.md` | `/hot-fix` Owner command |
+| `.claude/skills/harness-{ceo,coo,cdo,cto,cqo,ops}/` | CXX agent skills |
+| `.harness/shared/HR-Resource/` | Hireable worker skill pool |
+| `AGENTS.md` ← `CLAUDE.md` symlink | Project harness config |
 
-## 회의 시스템
+---
 
-회의는 계속 유지됩니다. 토큰 제한 복구 로직이 회의를 대체하지 않습니다.
+## Mission Flow
 
-지원 회의:
+### Goal
 
-- `Standup`
-- `Sprint Review`
-- `Spec Review`
-- `Incident War Room`
-- `All-Hands`
-
-역할:
-
-- 회의: owner 결정, drift 분류, evidence 집계, action item 생성
-- Conductor: 회의 결과를 읽고 next agent 갱신
-- Service-Ops: cadence 계산
-
-기본 cadence:
-
-- `light`: 30m
-- `normal`: 1h
-- `heavy`: 4h
-
-## TokenLimit Hold / Resume
-
-`TokenLimit` 은 회의가 아니라 런타임 중단 복구 문제로 취급합니다.
-
-즉:
-
-- 회의 시스템은 그대로 유지
-- TokenLimit 은 별도 저비용 복구 레이어로 처리
-
-### 동작 방식
-
-토큰 한도로 작업이 중단되면:
-
-```bash
-bash scripts/harness-token-limit.sh . mark
 ```
-
-기본 정책:
-
-- `TaskStopReason = TokenLimit`
-- 현재 작업은 `paused`
-- `progress.json.task_stop` 에 아래가 기록됨
-  - `wake_target`
-  - `resume_after`
-  - `stopped_agent`
-  - `stopped_next_agent`
-  - `task_session_path`
-
-그 다음:
-
-- `SessionStart` 는 별도 모델 probe 없이 시간만 확인
-- 아직 hold 중이면 `retry_after` 와 `wake target` 만 출력
-- 시간이 지나면 `# Harness resume ready` 를 출력하고 원래 CXX/agent 로 복귀
-
-테스트용:
-
-```bash
-bash scripts/harness-token-limit.sh . mark 300
+Owner /goal → CEO → [COO] → [CDO] → CTO → [dev workers] → CQO → [evaluator workers]
 ```
 
-중요:
-
-- 회의는 유지됩니다.
-- TokenLimit checker 는 회의를 대체하지 않습니다.
-- 에이전트는 복귀 시 이전 대화가 아니라 `task_session_path` 와 문서를 보고 이어갑니다.
-
-## COO Hypothesis Cell
-
-정규 CTO/CQO 라인에 넣기 전, COO 직속으로 빠른 가설 검증 셀을 돌릴 수 있습니다.
+1. CEO reads Owner request, writes `ceo.md`, routes to relevant CXX.
+2. Each CXX writes its own `{cxx}.md`, hires workers, collects evidence.
+3. CEO aggregates CXX outputs and reports to Owner.
 
-구성:
+### Hot Fix
 
-- `coo-developer`
-- `documentationer`
-
-흐름:
-
-1. `planner.requested_mode = "hypothesis"`
-2. `documentationer` 가 리서치/질문 정리
-3. `coo-developer` 가 spike / backdata 실험
-4. `documentationer` 가 보고서와 verdict 작성
-5. `planner` 가 결과를 정규 sprint artifact 로 승격하거나 폐기
-
-핵심은 운영 품질이 아니라 빠른 사실 확인입니다.
-
-## 런타임 (회사모드 always-on)
-
-회사모드는 유일한 런타임이며 항상 켜져 있습니다. `progress.mode == "company"` 가 항상 참이고, 별도 모드 전환 명령은 없습니다.
-
-자율 진행은 두 메커니즘으로 유지됩니다:
-
-- **Stop 훅** — Claude 가 한 turn 을 끝내려는 시점에 발화. `conductor.state == "running"` 이고 다음 부서가 있으면 자동으로 turn 을 한 번 더 굴려 끊김 없이 연쇄.
-- **launchd hourly wake (선택)** — 1시간마다 macOS 가 `scripts/harness-wake.sh` 를 호출. idle ≥ 55분이고 `paused/completed/escalated` 가 아닌 프로젝트만 깨움.
-
-```bash
-# 1시간 안전망 wake 등록
-bash scripts/harness-wake-install.sh install .
-
-# 상태 확인
-bash scripts/harness-wake-install.sh status
-
-# 즉시 한 번 발화 (테스트)
-bash scripts/harness-wake-install.sh run-now
 ```
-
-회의 결정의 `tracks[]` 는 진행 흐름의 fork-join 단위이며 런타임 모드와는 별개입니다 (`tracks.length ≥ 2` 일 때 parallel).
-- Archive prompt
-
-Queue 관련 유용한 명령:
-
-```bash
-bash scripts/harness-queue-manager.sh status .
-bash scripts/harness-queue-manager.sh auto-dispatch .
-bash scripts/harness-queue-manager.sh idle-slots .
+Owner /hot-fix → CEO → CTO → [dev workers] → CQO → [evaluator workers]
 ```
 
-## Generator / Evaluator Chain
-
-구현과 평가는 분리됩니다.
-
-일반적인 흐름:
+1. CEO summons CTO and CQO immediately.
+2. CTO designs minimum patch, hires implementation workers, writes `cto.md`.
+3. CQO runs regression gate with evaluator workers, registers gotcha/convention, writes `cqo.md`.
 
-1. `generator-backend`
-2. `generator-frontend`
-3. `evaluator-code-quality`
-4. `evaluator-functional`
-5. `evaluator-visual`
-6. `cqo`
-7. `service-ops`
+**Complete when:** `cto.md` + `cqo.md` + at least one `.harness/gotchas/` or `.harness/conventions/` entry exist.
 
-평가자 체인 원칙:
+---
 
-- 앞단 FAIL 시 뒤 평가는 생략 가능
-- Evidence 없는 점수는 0
-- regression 1건 이상이면 전체 FAIL
-- evaluator 는 읽기 전용
+## Hard Rules
 
-## Gotchas / Conventions / Memory
-
-하네스는 피드백을 세 저장소로 나눠 누적합니다.
-
-| 종류 | 용도 |
+| # | Rule |
 |---|---|
-| `gotchas/` | 에이전트가 반복한 실수 |
-| `.harness/conventions/` | 하우스 스타일 |
-| `.harness/memory.md` | 프로젝트 전역 교훈 |
-
-각 agent 는 세션 시작 시 다음 순서로 읽습니다.
+| 1 | No source edit without `{mission}/cto.md` — CTO scope sign-off required |
+| 2 | No CXX impersonation — use installed harness skills in fresh sessions |
+| 3 | No unnamed workers — all work routes through `harness-hiring` → `harness-resource-manager` |
+| 4 | No archive without CQO verdict — `{mission}/cqo.md` with explicit PASS must exist |
+| 5 | No gotcha skip — every hot-fix produces at least one gotcha or convention entry |
+| 6 | CEO routes only to CXX — never directly to workers |
+| 7 | No CXX self-execution — deliverables without matching worker records are rejected |
+| 8 | No verdict without worker evidence — CQO self-inspection is not valid |
 
-1. `CONVENTIONS.md`
-2. `.harness/conventions/shared.md`
-3. `.harness/conventions/<self>.md`
-4. `.harness/gotchas/<self>.md`
-5. `.harness/memory.md`
+---
 
-## 주요 스크립트
+## Harness Dashboard
 
-| 스크립트 | 역할 |
-|---|---|
-| `scripts/conductor-tick.sh` | 회사 루프 라우터 — 다음 부서 결정 |
-| `scripts/harness-next.sh` | turn 종료 후 handoff 생성 + gotcha/convention 자동 등록 + audit gate |
-| `scripts/harness-progress-set.sh` | progress.json partial update 헬퍼 |
-| `scripts/harness-session-start.sh` | SessionStart 훅 (+ future-dated 라인 자동 격리) |
-| `scripts/harness-user-prompt-submit.sh` | UserPromptSubmit 훅 |
-| `scripts/harness-stop.sh` | Stop 훅 — turn 종료 시 자동 연쇄 |
-| `scripts/harness-wake.sh` | 1시간 안전망 wake (launchd 가 호출) |
-| `scripts/harness-wake-install.sh` | launchd 등록/관리 CLI |
-| `scripts/harness-statusline.sh` | 1줄 statusLine 렌더 |
-| `scripts/harness-queue-manager.sh` | feature queue 관리 |
-| `scripts/harness-meeting-doc.sh` | 회의 문서 skeleton / decision 처리 |
-| `scripts/harness-task-session.sh` | agent 별 task session (TokenLimit) |
-| `scripts/harness-token-limit.sh` | TokenLimit hold/resume 마킹 |
-| `scripts/harness-archive.sh` | sprint 종료 archive |
-| `scripts/harness-gotcha-register.sh` | evaluator output 의 gotcha_candidates 자동 등록 |
-| `scripts/harness-dashboard-up.sh` | Brick Office (브라우저 3D 대시보드) 기동 |
-
-## 디렉토리 구조
-
-```text
-.harness/
-├── actions/
-│   ├── plan.md
-│   ├── feature-list.json
-│   ├── api-contract.json
-│   ├── sprint-contract.md
-│   ├── meetings/
-│   ├── incidents/
-│   └── task-sessions/
-├── archive/
-├── progress.json
-├── handoff.json
-├── progress.log
-├── config.json
-└── doctrine/
-```
-
-상세 조직 규칙은 다음 문서를 봅니다.
-
-- `AGENTS.md`
-- `.harness/doctrine/nexus.md`
-- `.harness/agency-mapping.md`
-- `.harness/HARNESS.md`
-
-## Troubleshooting
-
-### 다음 agent 가 안 뜸
+The harness ships with a real-time dashboard that reads `.harness/documents/` directly.
 
 ```bash
-cat .harness/progress.json | jq '{current_agent, agent_status, next_agent, workflow, task_stop}'
+bash scripts/harness-dashboard-up.sh
 ```
 
-### handoff 재생성
+Features:
 
-```bash
-bash scripts/harness-next.sh .
-```
+- **Org Tree** — live status of Owner → CEO → CXX → Workers hierarchy
+- **Mission Timeline** — clickable history of goal/hot-fix missions showing the full dispatch chain
+- **Mission Flow tab** — per-mission flow: Owner prompt → CEO routing → CXX → worker files changed → CQO verdict
+- **History tab** — mission-specific Owner request (from CEO summary + closest progress.log match)
+- **Gotchas tab** — searchable `.harness/gotchas/*.md` knowledge base, click to read full markdown
+- **Document tab** — per-CXX markdown doc viewer
 
-### SessionStart 안내 확인
+---
 
-```bash
-bash scripts/harness-session-start.sh
-```
-
-### TokenLimit hold 상태 확인
+## Harness Runtime Paths
 
-```bash
-cat .harness/progress.json | jq '.task_stop'
-```
+| Path | Role |
+|---|---|
+| `.harness/documents/{mission}/` | CXX decisions and worker reports per mission |
+| `.harness/documents/{mission}/{cxx}/workers/` | Worker reports owned by that CXX |
+| `.harness/conventions/` | Durable rules (CQO writes, survives missions) |
+| `.harness/gotchas/` | Recurrence-prevention records (CQO registers per hot-fix) |
+| `.harness/shared/HR-Resource/` | Hireable worker skill pool |
+| `.harness/archive/` | CQO-approved completed missions (immutable) |
+| `.harness/logs/YYYY-MM-DD/` | OPS exception logs |
 
-### queue 상태 확인
+---
 
-```bash
-bash scripts/harness-queue-manager.sh status .
-```
+## Hiring
 
-### Stop 훅 자동 연쇄가 안 도는지 점검
-
-```bash
-# config 확인 — auto_chain_on_stop 이 true 여야 함
-jq '.behavior.auto_chain_on_stop // true' .harness/config.json
+Any CXX uses `harness-hiring` before assigning work to a specialist not yet on roster.
 
-# stop_chain_count 와 sprint 상한 확인
-jq '{count: .conductor.stop_chain_count, max: 200}' .harness/progress.json
 ```
-
-### 1시간 wake 가 발화 안 하는지 점검
-
-```bash
-bash scripts/harness-wake-install.sh status
-tail -30 ~/.walwal-harness/logs/wake.log
+harness-resource-manager → find available worker
+harness-hiring           → register and onboard worker
+{cxx} → hired worker     → deliverable → {cxx} evidence manifest
 ```
 
-## 버전 호환성
+---
 
-README 는 v6.x 계열 always-on 회사모드 기준입니다 (solo/team 모드 영구 제거).
+## Version History
 
-이 문서에서 전제하는 기능:
-
-- company loop
-- conductor / meeting-manager / cto / cqo / service-ops
-- task-session isolation
-- COO hypothesis cell
-- TokenLimit hold/resume
+| Version | Summary |
+|---|---|
+| 7.1.6 | CXX hierarchy enforcement: CEO→CXX-only gate, CTO prerequisite gate, CQO worker-evidence mandate; dashboard gotchas tab, mission-specific history tab, worker file list in flow |
+| 7.1.5 | Dashboard: mission flow timeline, markdown viewer, 50vw drawer |
+| 7.1.4 | Dashboard: org-tree redesign with real `.harness/documents/` data |
+| 7.1.3 | Karpathy-style AGENTS.md rewrite, ko templates, hot-fix harness gate rules |
+| 7.1.2 | v7 CEO routing migration, legacy command removal |
+| 7.1.1 | CEO no-git hiring fix, gotcha/convention migration |
+| 7.1.0 | v7.1 merge: OPS monitoring, CXX hiring enforcement |
+
+---
 
 ## License
 

package/assets/templates/AGENTS.md.template

@@ -104,6 +104,10 @@ Note: A docmeta skip decision on harness documents (ceo.md, cto.md, cqo.md, work
 4. **No archive without CQO verdict** — `{mission}/cqo.md` with explicit PASS must exist.
 5. **No gotcha skip** — Every hot-fix produces at least one `.harness/gotchas/` or `.harness/conventions/` entry.
 6. **This file is read-only during missions** — Raise a separate `/goal` to update AGENTS.md.
+7. **CEO routes only to CXX — never to workers** — CEO must not dispatch, hire, or brief specialist workers directly. Implementation workers are hired by CTO. Evaluator/tester workers are hired by CQO.
+8. **No CXX self-execution** — CXX agents coordinate and manage only. A CXX that produces deliverables without matching worker records has violated its scope. CEO must reject such reports.
+9. **No verdict without worker evidence** — CQO cannot issue ACCEPTED/REJECTED without a Worker Evidence Manifest referencing at least one evaluator worker. Self-inspection by CQO is not valid evidence.
+10. **Hierarchical worker ownership** — Hired workers are installed under `.claude/skills/{owning-cxx}/{worker}/` and `.codex/skills/{owning-cxx}/{worker}/`; mission worker reports live under `.harness/documents/{mission}/{owning-cxx}/workers/`. Flat `{mission}/workers/` reports are legacy and signal an ownership violation unless explicitly migrated.
 
 ---
 

package/bin/init.js

@@ -21,6 +21,17 @@ const isAuto = args.includes('--auto');
 const isForce = args.includes('--force');
 const isHelp = args.includes('--help') || args.includes('-h');
 
+function getOptionValue(name) {
+  const eqPrefix = `${name}=`;
+  const eqArg = args.find((a) => a.startsWith(eqPrefix));
+  if (eqArg) return eqArg.slice(eqPrefix.length);
+  const idx = args.indexOf(name);
+  if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith('-')) {
+    return args[idx + 1];
+  }
+  return null;
+}
+
 // ─────────────────────────────────────────
 // Resolve project root
 // ─────────────────────────────────────────
@@ -28,6 +39,9 @@ const isHelp = args.includes('--help') || args.includes('-h');
 // inside node_modules, NOT the consumer project root.
 // We detect this and walk up to find the actual project root.
 function resolveProjectRoot() {
+  const explicitRoot = getOptionValue('--project-root');
+  if (explicitRoot) return path.resolve(explicitRoot);
+
   let cwd = process.cwd();
 
   // If we're running inside node_modules, walk up to the project root
@@ -430,12 +444,12 @@ function scaffoldHarness() {
   }
 
   const rosterPath = path.join(HARNESS_DIR, 'shared', 'hr-roster.json');
-  if (!fileExists(rosterPath) || isForce) {
+  if (!fileExists(rosterPath)) {
     fs.writeFileSync(rosterPath, JSON.stringify({ hired: [] }, null, 2) + '\n');
   }
 
   const resourceIndexPath = path.join(HARNESS_DIR, 'shared', 'resource-index.json');
-  if (!fileExists(resourceIndexPath) || isForce) {
+  if (!fileExists(resourceIndexPath)) {
     fs.writeFileSync(resourceIndexPath, JSON.stringify({ aliases: {}, keywords: {} }, null, 2) + '\n');
   }
 
@@ -1183,17 +1197,40 @@ function detectMigrationNeeded() {
   const configPath = path.join(HARNESS_DIR, 'config.json');
   const memoryPath = path.join(HARNESS_DIR, 'memory.md');
   const memoryTplPath = path.join(PKG_ROOT, 'assets', 'templates', 'memory.md');
+  const rosterPath = path.join(HARNESS_DIR, 'shared', 'hr-roster.json');
+  const resourceIndexPath = path.join(HARNESS_DIR, 'shared', 'resource-index.json');
   const flags = {
     progressV3toV4: false,
     progressLegacyRouting: false,
     configMissingCompanyMode: false,
     configLegacyRouting: false,
+    coreSkillsStale: false,
+    hrResourcePoolStale: false,
+    rosterCodexPathsMissing: false,
+    resourceIndexCodexWordingMissing: false,
     memoryMissingSystemEntries: [],
     gotchaMissingEntries: {},   // { "<filename>": [G-IDs...] }
     conventionMissingEntries: {}, // { "<filename>": [C-IDs...] }
     bundleVersionStale: null,    // { current, installed }
   };
 
+  const coreSkills = ['ceo', 'coo', 'cdo', 'cto', 'cqo', 'ops', 'hiring', 'resource-manager', 'brick-office'];
+  for (const skill of coreSkills) {
+    const srcPath = path.join(PKG_ROOT, 'HR-Resource', skill, 'SKILL.md');
+    if (!fs.existsSync(srcPath)) continue;
+    const srcBody = fs.readFileSync(srcPath, 'utf8');
+    for (const root of [CLAUDE_SKILLS_DIR, CODEX_SKILLS_DIR]) {
+      const destPath = path.join(root, `harness-${skill}`, 'SKILL.md');
+      if (!fs.existsSync(destPath) || fs.readFileSync(destPath, 'utf8') !== srcBody) {
+        flags.coreSkillsStale = true;
+      }
+    }
+    const poolPath = path.join(HARNESS_DIR, 'shared', 'HR-Resource', skill, 'SKILL.md');
+    if (fs.existsSync(path.dirname(poolPath)) && (!fs.existsSync(poolPath) || fs.readFileSync(poolPath, 'utf8') !== srcBody)) {
+      flags.hrResourcePoolStale = true;
+    }
+  }
+
   // Gotcha entry-level diff: for each bundled gotcha file, compare entry IDs.
   // 사용자가 직접 추가한 [G-NNN] 은 절대 건드리지 않으며, 패키지에서 새로
   // 도입된 시스템 entry 만 append 대상.
@@ -1266,6 +1303,27 @@ function detectMigrationNeeded() {
       ) flags.configLegacyRouting = true;
     } catch {}
   }
+  if (fs.existsSync(rosterPath)) {
+    try {
+      const roster = JSON.parse(fs.readFileSync(rosterPath, 'utf8'));
+      const hired = Array.isArray(roster.hired) ? roster.hired : [];
+      flags.rosterCodexPathsMissing = hired.some((entry) => {
+        if (!entry || typeof entry !== 'object' || !entry.worker) return false;
+        const owner = entry.owner || entry.owningCxx;
+        const flatClaude = /^\.claude\/skills\/[^/]+\/SKILL\.md$/.test(entry.skillPaths?.claude || '');
+        const flatCodex = /^\.codex\/skills\/[^/]+\/SKILL\.md$/.test(entry.skillPaths?.codex || '');
+        return !owner || !entry.skillPaths?.codex || !entry.skillPaths?.claude || /^\.claude\/skills\//.test(entry.skillPath || '') || flatClaude || flatCodex;
+      });
+    } catch {}
+  }
+  if (fs.existsSync(resourceIndexPath)) {
+    try {
+      const idx = JSON.parse(fs.readFileSync(resourceIndexPath, 'utf8'));
+      if (!idx.invocation || !idx.invocation.codex || !idx.invocation.claude) {
+        flags.resourceIndexCodexWordingMissing = true;
+      }
+    } catch {}
+  }
   if (fs.existsSync(memoryPath) && fs.existsSync(memoryTplPath)) {
     try {
       const userMem = fs.readFileSync(memoryPath, 'utf8');
@@ -1355,6 +1413,18 @@ function showMigrationProposal(flags) {
   if (flags.configLegacyRouting) {
     console.log('  • config.json: legacy dispatcher/conductor wording → v7 CEO/CXX wording');
   }
+  if (flags.coreSkillsStale) {
+    console.log('  • .claude/.codex skills: harness-* core skills 최신 패키지로 refresh');
+  }
+  if (flags.hrResourcePoolStale) {
+    console.log('  • .harness/shared/HR-Resource: core HR pool 최신 패키지로 refresh');
+  }
+  if (flags.rosterCodexPathsMissing) {
+    console.log('  • hr-roster.json: 기존 hired worker 보존 + Claude/Codex skillPaths 보강');
+  }
+  if (flags.resourceIndexCodexWordingMissing) {
+    console.log('  • resource-index.json: Claude/Codex skill invocation wording 보강');
+  }
   if (flags.memoryMissingSystemEntries && flags.memoryMissingSystemEntries.length) {
     console.log('  • memory.md: 시스템 entry 누락 — append 가능');
     console.log('    [' + flags.memoryMissingSystemEntries.join(', ') + ']');
@@ -1397,6 +1467,10 @@ function runMigrate(opts = {}) {
     !flags.progressLegacyRouting &&
     !flags.configMissingCompanyMode &&
     !flags.configLegacyRouting &&
+    !flags.coreSkillsStale &&
+    !flags.hrResourcePoolStale &&
+    !flags.rosterCodexPathsMissing &&
+    !flags.resourceIndexCodexWordingMissing &&
     (!flags.memoryMissingSystemEntries || flags.memoryMissingSystemEntries.length === 0) &&
     gotchaMissingTotal === 0 &&
     conventionMissingTotal === 0 &&
@@ -1405,7 +1479,7 @@ function runMigrate(opts = {}) {
     console.log('');
     let pkgVer = 'unknown';
     try { pkgVer = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, 'package.json'), 'utf8')).version; } catch {}
-    log(`이미 최신 — bundle v${pkgVer} 일치, progress v${TARGET_PROGRESS_VERSION} v7 routing, config.company_mode, memory 시스템 entry, gotcha entry 모두 sync.`);
+    log(`이미 최신 — bundle v${pkgVer} 일치, progress v${TARGET_PROGRESS_VERSION} v7 routing, config.company_mode, Codex skill wiring, memory 시스템 entry, gotcha entry 모두 sync.`);
     return;
   }
 
@@ -1474,6 +1548,99 @@ function runMigrate(opts = {}) {
     }
   }
 
+  // 2a. Refresh installed core harness skills and HR core pool without
+  //     touching hired worker skills or roster state.
+  if (flags.hrResourcePoolStale) {
+    const hrResourceSrc = path.join(PKG_ROOT, 'HR-Resource');
+    const hrResourceDest = path.join(HARNESS_DIR, 'shared', 'HR-Resource');
+    if (fs.existsSync(hrResourceSrc)) {
+      log('  .harness/shared/HR-Resource: core pool refresh');
+      if (!dryRun) copyDir(hrResourceSrc, hrResourceDest);
+    }
+  }
+  if (flags.coreSkillsStale) {
+    log('  .claude/.codex skills: harness-* core skills refresh');
+    if (!dryRun) installSkills();
+  }
+
+  // 2b. hr-roster.json — preserve hired worker history, add tool-specific
+  //     paths so Codex can reuse existing hires without relying on .claude.
+  const rosterPath = path.join(HARNESS_DIR, 'shared', 'hr-roster.json');
+  if (flags.rosterCodexPathsMissing && fs.existsSync(rosterPath)) {
+    const original = fs.readFileSync(rosterPath, 'utf8');
+    try {
+      const roster = JSON.parse(original);
+      const hired = Array.isArray(roster.hired) ? roster.hired : [];
+      let changed = false;
+      roster.hired = hired.map((entry) => {
+        if (!entry || typeof entry !== 'object' || !entry.worker) return entry;
+        const worker = entry.worker;
+        const owner = entry.owner || entry.owningCxx || 'unknown';
+        const scopedPrefix = owner ? `${owner}/` : '';
+        const claudePath = entry.skillPaths?.claude || (
+          /^\.claude\/skills\//.test(entry.skillPath || '')
+            ? entry.skillPath
+            : `.claude/skills/${scopedPrefix}${worker}/SKILL.md`
+        );
+        const codexPath = entry.skillPaths?.codex || (
+          /^\.codex\/skills\//.test(entry.skillPath || '')
+            ? entry.skillPath
+            : `.codex/skills/${scopedPrefix}${worker}/SKILL.md`
+        );
+        const next = {
+          ...entry,
+          owner,
+          skillPath: `.harness/shared/HR-Resource/${worker}/SKILL.md`,
+          skillPaths: {
+            ...(entry.skillPaths || {}),
+            claude: /^\.claude\/skills\/[^/]+\/SKILL\.md$/.test(claudePath)
+              ? `.claude/skills/${scopedPrefix}${worker}/SKILL.md`
+              : claudePath,
+            codex: /^\.codex\/skills\/[^/]+\/SKILL\.md$/.test(codexPath)
+              ? `.codex/skills/${scopedPrefix}${worker}/SKILL.md`
+              : codexPath,
+            source: `.harness/shared/HR-Resource/${worker}/SKILL.md`,
+          },
+        };
+        if (JSON.stringify(next) !== JSON.stringify(entry)) changed = true;
+        return next;
+      });
+      if (changed) {
+        log(`  hr-roster.json: ${roster.hired.length}개 hired worker에 Codex 경로 보강`);
+        if (!dryRun) {
+          fs.writeFileSync(path.join(backupDir, 'hr-roster.json'), original);
+          fs.writeFileSync(rosterPath, JSON.stringify(roster, null, 2) + '\n');
+        }
+      }
+    } catch (e) {
+      log(`  WARNING: hr-roster.json parse failed, skipped (${e.message})`);
+    }
+  }
+
+  // 2c. resource-index.json — keep aliases/keywords, add tool wording.
+  const resourceIndexPath = path.join(HARNESS_DIR, 'shared', 'resource-index.json');
+  if (flags.resourceIndexCodexWordingMissing && fs.existsSync(resourceIndexPath)) {
+    const original = fs.readFileSync(resourceIndexPath, 'utf8');
+    try {
+      const idx = JSON.parse(original);
+      idx.aliases = idx.aliases || {};
+      idx.keywords = idx.keywords || {};
+      idx.invocation = {
+        ...(idx.invocation || {}),
+        claude: 'Invoke the installed skill by name from .claude/skills/{owning-cxx}/{worker}/SKILL.md.',
+        codex: 'Use the installed skill by name from .codex/skills/{owning-cxx}/{worker}/SKILL.md.',
+        source: 'Candidate pool lives in .harness/shared/HR-Resource/{worker}/SKILL.md.',
+      };
+      log('  resource-index.json: Claude/Codex invocation wording 보강');
+      if (!dryRun) {
+        fs.writeFileSync(path.join(backupDir, 'resource-index.json'), original);
+        fs.writeFileSync(resourceIndexPath, JSON.stringify(idx, null, 2) + '\n');
+      }
+    } catch (e) {
+      log(`  WARNING: resource-index.json parse failed, skipped (${e.message})`);
+    }
+  }
+
   // 3. memory.md — append missing system entries (M-NEXUS-*, M-SYS-*) only.
   //    User-added [M-NNN] entries are NEVER touched.
   const memoryPath = path.join(HARNESS_DIR, 'memory.md');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walwal-harness/cli",
-  "version": "7.1.3",
+  "version": "7.1.6",
   "description": "Company-style AI agent harness for Claude and Codex. Installs commands, CXX agents, skills, HR-Resource hiring pool, and project-local .harness runtime state.",
   "bin": {
     "walwal-harness": "bin/init.js"

package/scripts/harness-worker-evidence-validate.sh

@@ -11,6 +11,16 @@ mode="${2:-text}"
 violations=()
 
 has_worker_report() {
+  local mission_dir="$1"
+  local owner="${2:-}"
+  if [ -n "$owner" ]; then
+    find "$mission_dir/$owner/workers" -maxdepth 1 -type f -name '*.md' 2>/dev/null | grep -q .
+  else
+    find "$mission_dir"/{coo,cdo,cto,cqo,ops}/workers -maxdepth 1 -type f -name '*.md' 2>/dev/null | grep -q .
+  fi
+}
+
+has_legacy_flat_worker_report() {
   local mission_dir="$1"
   find "$mission_dir/workers" -maxdepth 1 -type f -name '*.md' 2>/dev/null | grep -q .
 }
@@ -19,16 +29,21 @@ for mission_dir in "$DOC_ROOT"/*; do
   [ -d "$mission_dir" ] || continue
   mission_name="$(basename "$mission_dir")"
 
-  cxx_docs=()
+  if has_legacy_flat_worker_report "$mission_dir"; then
+    violations+=("$mission_name:legacy-flat-workers")
+  fi
+
   for cxx in coo cdo cto cqo ops; do
     cxx_path="$mission_dir/$cxx.md"
     [ -s "$cxx_path" ] || continue
-    cxx_docs+=("$cxx.md")
+    if ! has_worker_report "$mission_dir" "$cxx"; then
+      violations+=("$mission_name:$cxx.md")
+    fi
   done
 
-  [ "${#cxx_docs[@]}" -gt 0 ] || continue
-  if ! has_worker_report "$mission_dir"; then
-    violations+=("$mission_name:${cxx_docs[*]}")
+  cqo_path="$mission_dir/cqo.md"
+  if [ -s "$cqo_path" ] && grep -Eq '\b(ACCEPTED|REJECTED|PASS|FAIL)\b' "$cqo_path" && ! has_worker_report "$mission_dir" "cqo"; then
+    violations+=("$mission_name:cqo-verdict-without-evaluator")
   fi
 done
 
@@ -51,8 +66,8 @@ else
     mission="${violation%%:*}"
     docs="${violation#*:}"
     echo "- mission: $mission"
-    echo "  cxx_docs: $docs"
-    echo "  required: at least one .harness/documents/$mission/workers/{worker-name}.md report"
+    echo "  issue: $docs"
+    echo "  required: worker reports under .harness/documents/$mission/{cxx}/workers/{worker-name}.md"
   done
 fi