@walwal-harness/cli 6.0.5 → 6.1.1

package/CHANGELOG.md

@@ -29,6 +29,71 @@ docmeta:
 
 # Changelog
 
+## 6.1.1 — COO hypothesis routing activation (2026-05-08)
+
+### Why
+v6.1.0 에서 COO 직속 `coo-developer` / `documentationer` 역할과 hypothesis cell 문서는 추가됐지만, 실제 Conductor 라우팅은 여전히 `planner -> cto` 직행이었다. 그래서 "COO가 가설을 세우면 빠르게 리서치·실험·판정한다" 는 운용 모델이 문서상으로만 존재했다.
+
+### Changes
+- **runtime routing for hypothesis mode**
+  - `planner.requested_mode = "hypothesis"` 이면 `documentationer` 로 우선 라우팅
+  - 이후 `documentationer -> coo-developer -> documentationer -> planner` 순서로 가설 검증 루프 진행
+  - 단계 추적용 상태를 `planner.last_brief` 에 `hypothesis:research`, `hypothesis:experiment`, `hypothesis:report`, `hypothesis:done` 으로 기록
+- **agent registry update**
+  - `.harness/config.json` 의 `agents` 카탈로그에 `coo-developer`, `documentationer` 등록
+  - handoff/statusline/session-start 가 두 agent 를 정상 인식하도록 연결
+
+### Validation
+- `bash -n scripts/conductor-tick.sh`
+- `jq empty .harness/config.json`
+- `/private/tmp` 샌드박스에서 hypothesis flow 시뮬레이션:
+  - `planner(completed, requested_mode=hypothesis) -> documentationer`
+  - `documentationer -> coo-developer`
+  - `coo-developer -> documentationer`
+  - `documentationer -> planner(requested_mode=hypothesis-verdict)`
+
+## 6.1.0 — document-driven company loop + task-session isolation (2026-05-08)
+
+### Why
+v6.0.x 는 회사형 조직 비유와 Cxx 라우팅을 문서로는 설명했지만, 실제 런타임은 여전히 얕았다. 특히 다음 두 결함이 컸다.
+
+- 회의 결과가 `누가 다음 owner 인가` 를 구조적으로 기록하지 않음
+- `goal_adherence` 하락 시 원인 분류 없이 Planner로 보내는 경향이 있음
+
+또한 agent 간 자기강화 편향을 줄이기 위한 문서 중심 task session 분리도 충분히 강제되지 않았다.
+
+### Changes
+- **document-driven meeting decision**
+  - `meeting-manager` 가 `notice.md`, `prep-*.md`, `meeting-<id>.md` skeleton 을 자동 생성
+  - 회의 기록에 `decision.owner`, `action_type`, `rationale`, `evidence`, `drift_classification` JSON 블록 추가
+  - `conductor-tick` 은 더 이상 `meeting_reason` 문자열만 보지 않고 회의 decision 문서를 우선 읽어 다음 owner 를 결정
+- **goal drift classification**
+  - `implementation_drift | planning_drift | ops_drift | goal_drift` 분류 추가
+  - 분류별 기본 라우팅:
+    - `implementation_drift -> cto`
+    - `planning_drift -> planner`
+    - `ops_drift -> service-ops`
+    - `goal_drift -> dispatcher`
+- **task-session isolation**
+  - `harness-next` 가 다음 agent 마다 `.harness/actions/task-sessions/<agent>/<id>.md` 생성
+  - `handoff.json` 에 `task_session_path` 추가
+  - `UserPromptSubmit` 가 running agent 와 다른 `/harness-*` 호출을 경고가 아니라 **hard block**
+- **direct invocation policy**
+  - 모든 harness skill 의 `disable-model-invocation` 을 `false` 로 통일
+  - orchestration/control-plane 과 worker/evaluator 모두 직접 호출 가능 상태로 정리
+- **archive reset hardening**
+  - archive 시 `workflow`, `meetings.decision`, `service_ops.drift_classification`, `task_sessions.current` 초기화
+
+### Validation
+- `bash -n` 으로 주요 스크립트 문법 검증
+- `jq empty` 로 `config.json`, `progress.json` 검증
+- `/private/tmp` 샌드박스에서:
+  - `dispatcher -> meeting-manager` 시 회의 문서 자동 생성 확인
+  - 회의 decision 편집 후 `dispatcher / planner / cto` 로 문서 기반 재라우팅 확인
+  - `goal_adherence` 하락 시 drift classification 반영 확인
+  - context isolation hard block 확인
+  - `task_session_path` 생성 확인
+
 ## 6.0.5 — migrate 가 gotcha entry / bundle version 까지 sync (2026-05-07)
 
 ### Why

package/commands/harness-solo.md

@@ -1,7 +1,7 @@
 ---
 docmeta:
   id: harness-solo
-  title: /harness-solo — Solo Mode 시작/전환
+  title: /harness-solo — 비상용 Single-Agent Fallback
   type: input
   createdAt: 2026-04-20T00:00:00Z
   updatedAt: 2026-05-07T00:00:00Z
@@ -24,14 +24,14 @@ docmeta:
   tags: [harness, solo-mode, command, override, v6]
 ---
 
-# /harness-solo — Solo Mode 사용자 Override (v6.0+)
+# /harness-solo — 비상용 Single-Agent Fallback (v6.0+)
 
-> v6.0 부터 모드 결정은 **Conductor 가 자동**으로 합니다 (config.json `mode_selection.rules`). 본 명령은 Conductor 의 자동 결정을 사용자가 강제로 덮어쓰는 **override** 입니다.
+> v6.0 의 정상 경로는 회사형 자동 루프입니다. 본 명령은 그 루프를 일시적으로 벗어나는 **비상용 override** 입니다.
 >
 > **효과**: `progress.json.mode = "solo"` 강제 + `mode_decision.user_override = "solo"` 기록. 현재 sprint 끝까지 유지. 다음 sprint 진입 시 Conductor 가 재자동결정. **Auto 복귀**: 사용자 발화 "auto 로 돌려" 또는 "Conductor 결정으로".
 
-프롬프트 기반으로 하네스 파이프라인을 순차 진행합니다.
-Team 모드에서 전환 시, 진행 중이던 피처의 상태를 보존하고 Solo로 이어갑니다.
+디버깅, 스크립트 장애, 수동 hotfix 같은 예외 상황에서만 사용합니다.
+회사 루프에서 전환 시, 진행 중이던 피처의 상태를 보존하고 단일 에이전트 fallback 으로 이어갑니다.
 
 ## 실행 절차
 
@@ -49,12 +49,12 @@ echo "현재 모드: $MODE"
 bash scripts/harness-queue-manager.sh recover .
 
 # mode를 solo로 설정
-jq '.mode = "solo" | .team_state.active_teams = 0 | .team_state.paused_at = (now | todate)' .harness/progress.json > /tmp/progress_tmp.json && mv /tmp/progress_tmp.json .harness/progress.json
+jq '.mode = "solo" | .mode_decision.user_override = "solo" | .team_state.active_teams = 0 | .team_state.paused_at = (now | todate)' .harness/progress.json > /tmp/progress_tmp.json && mv /tmp/progress_tmp.json .harness/progress.json
 ```
 
 **paused → solo 전환 시:**
 ```bash
-jq '.mode = "solo"' .harness/progress.json > /tmp/progress_tmp.json && mv /tmp/progress_tmp.json .harness/progress.json
+jq '.mode = "solo" | .mode_decision.user_override = "solo"' .harness/progress.json > /tmp/progress_tmp.json && mv /tmp/progress_tmp.json .harness/progress.json
 ```
 
 ### Step 2: 현재 진행 상태 표시
@@ -75,29 +75,29 @@ fi
 progress.json의 `next_agent` 필드를 확인하여 다음 단계를 안내합니다:
 
 - **next_agent = "dispatcher"** → "프롬프트로 요구사항을 입력하면 자동으로 dispatcher가 분석합니다."
-- **next_agent = "planner"** → "/harness-planner 를 호출하거나, 계획을 요청하세요."
-- **next_agent = "generator-backend"** → "/harness-generator-backend 를 호출하세요."
-- **next_agent = "generator-frontend"** → "/harness-generator-frontend 를 호출하세요."
-- **next_agent = "evaluator-functional"** → "/harness-evaluator-functional 를 호출하세요."
-- **next_agent = "evaluator-visual"** → "/harness-evaluator-visual 를 호출하세요."
+- **next_agent = "planner"** → Planner 단계가 다음입니다. SessionStart / 내부 handoff가 연결돼 있으면 자동 진입, 아니면 해당 스킬을 수동 호출합니다.
+- **next_agent = "generator-backend"** → Backend generator 단계가 다음입니다.
+- **next_agent = "generator-frontend"** → Frontend generator 단계가 다음입니다.
+- **next_agent = "evaluator-functional"** → Functional evaluator 단계가 다음입니다.
+- **next_agent = "evaluator-visual"** → Visual evaluator 단계가 다음입니다.
 
 ### Step 4: Solo 모드 진행
 
-각 에이전트는 완료 즉시 **`/harness-next` 슬래시 명령을 자동 호출** 하여 다음 에이전트로 핸드오프합니다 (사용자가 매번 bash 명령을 칠 필요 없음).
+각 에이전트는 완료 즉시 **내부 handoff(`harness-next.sh` 또는 SessionStart hook)** 로 다음 에이전트에 넘겨집니다. Owner가 `/harness-next` 를 직접 다룬다는 전제는 6.0 회사 모델과 맞지 않습니다.
 
 **예외 — 사용자 승인 게이트가 있는 단계:**
-- **Brainstorming**: brainstorm-spec.md 완성 후 사용자 승인 대기 → 승인 시 자동 `/harness-next`
-- **Planner**: plan.md / api-contract.json 완성 후 사용자 승인 대기 → 승인 시 자동 `/harness-next`
+- **Brainstorming**: brainstorm-spec.md 완성 후 사용자 승인 대기 → 승인 시 내부 handoff
+- **Planner**: plan.md / api-contract.json 완성 후 사용자 승인 대기 → 승인 시 내부 handoff
 
-흐름이 멈췄거나 수동으로 다음 단계를 트리거하고 싶으면 사용자가 직접 `/harness-next` 입력 가능.
+흐름이 멈췄다면 원인은 보통 내부 handoff 스크립트/훅 미설치 또는 `next_agent` 불일치입니다. 이 경우 상태 파일과 hook 설치 상태를 먼저 점검합니다.
 
 feature-queue.json이 존재하는 경우:
 - 피처 완료(evaluator PASS) 시 `bash scripts/harness-queue-manager.sh pass {FEATURE_ID} .`를 호출하여 공유 상태 업데이트
 - Team 모드로 전환해도 이미 완료된 피처는 skip됨
 
-## Solo 모드에서 가능한 작업
+## 사용 권장 상황
 
 - 프롬프트로 각 에이전트 순차 실행
-- 코드 직접 수정 및 디버깅
-- 피처 단위 작업 선택
-- Team 모드로 언제든 전환: `/harness-team`
+- 내부 handoff 스크립트 장애 시 응급 복구
+- 아주 짧은 수동 hotfix / 상태 수선
+- 정상 회사 루프로 복귀: `/harness-team`

package/commands/harness-team.md

@@ -54,7 +54,7 @@ Planner가 완료한 feature-list.json의 피처들을 최대 3개 팀이 병렬
 
 ```bash
 # progress.json에 mode=team 설정
-jq '.mode = "team" | .team_state.active_teams = 3 | .team_state.paused_at = null' .harness/progress.json > /tmp/progress_tmp.json && mv /tmp/progress_tmp.json .harness/progress.json
+jq '.mode = "team" | .mode_decision.user_override = "team" | .team_state.active_teams = 3 | .team_state.paused_at = null' .harness/progress.json > /tmp/progress_tmp.json && mv /tmp/progress_tmp.json .harness/progress.json
 
 # Queue 초기화 또는 복구
 if [ ! -f .harness/actions/feature-queue.json ]; then

package/gotchas/coo-developer.md

@@ -0,0 +1,13 @@
+# Gotchas — COO Developer
+
+### [G-001] 운영코드와 실험코드 혼동  <!-- rule_id: coo-developer-experiment-vs-production -->
+- **Status**: unverified
+- **Date**: 2026-05-08
+- **Source**: planner:manual
+- **Trigger**: COO 직속 가설검증 셀 신설
+- **Wrong**: spike 코드를 운영 경로의 정본처럼 다룸
+- **Right**: 실험 코드는 실험으로 남기고, 정규화가 필요하면 Planner가 다시 Sprint artifact로 승격
+- **Why**: 이 셀의 목적은 빠른 사실 확인이지 운영 품질 보장이 아니다
+- **Scope**: `coo-developer`의 모든 실험 작업
+- **Occurrences**: 1
+- **Last-Seen**: 2026-05-08

package/gotchas/documentationer.md

@@ -0,0 +1,13 @@
+# Gotchas — Documentationer
+
+### [G-001] 보고서가 근거를 앞서감  <!-- rule_id: documentationer-claim-without-evidence -->
+- **Status**: unverified
+- **Date**: 2026-05-08
+- **Source**: planner:manual
+- **Trigger**: COO 직속 가설검증 셀 신설
+- **Wrong**: 리서치나 실험 근거보다 해석을 먼저 확정함
+- **Right**: evidence를 명시하고, 판정은 유효/무효/보류 중 하나로 제한
+- **Why**: Documentationer의 산출물은 COO 의사결정의 입력이며, 환상적 확신을 만들면 안 된다
+- **Scope**: `documentationer`의 모든 보고서와 브리프
+- **Occurrences**: 1
+- **Last-Seen**: 2026-05-08

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walwal-harness/cli",
-  "version": "6.0.5",
+  "version": "6.1.1",
   "description": "Production harness for AI agent engineering — NEXUS-adapted company metaphor (Dispatcher/CEO + Conductor + Meeting-Manager + COO/Planner + CTO + CQO + Service-Ops). Solo/Team mode, Brainstormer, Planner, Generator(BE/FE/Designer/DevOps), Evaluator chain (Code-Quality → Functional → Visual + Architecture/Security). Supports React, Next.js, and Flutter FE stacks.",
   "bin": {
     "walwal-harness": "bin/init.js"

package/scripts/conductor-tick.sh

@@ -0,0 +1,416 @@
+#!/bin/bash
+# conductor-tick.sh — document-driven company-loop router
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPT_DIR/lib/harness-render-progress.sh"
+
+PROJECT_ROOT="$(resolve_harness_root "${1:-.}")" || exit 0
+PROGRESS="$PROJECT_ROOT/.harness/progress.json"
+CONFIG="$PROJECT_ROOT/.harness/config.json"
+FEATURES="$PROJECT_ROOT/.harness/actions/feature-list.json"
+
+[ -f "$PROGRESS" ] || exit 0
+[ -f "$CONFIG" ] || exit 0
+command -v jq >/dev/null 2>&1 || exit 0
+
+candidate="${HARNESS_CONDUCTOR_CANDIDATE:-}"
+if [ -z "$candidate" ]; then
+  candidate=$(jq -r '.next_agent // "null"' "$PROGRESS" 2>/dev/null || echo "null")
+fi
+
+current_agent=$(jq -r '.current_agent // "null"' "$PROGRESS")
+agent_status=$(jq -r '.agent_status // "pending"' "$PROGRESS")
+pipeline=$(jq -r '.pipeline // "null"' "$PROGRESS")
+mode=$(jq -r '.mode // "auto"' "$PROGRESS")
+user_override=$(jq -r '.mode_decision.user_override // "null"' "$PROGRESS")
+requested_mode=$(jq -r '.service_ops.requested_mode // "null"' "$PROGRESS")
+planner_requested_mode=$(jq -r '.planner.requested_mode // "null"' "$PROGRESS")
+planner_last_brief=$(jq -r '.planner.last_brief // "null"' "$PROGRESS")
+goal_adherence=$(jq -r '.goals.current_adherence // "null"' "$PROGRESS")
+meetings_active_count=$(jq -r '(.meetings.active | length) // 0' "$PROGRESS")
+cqo_verdict=$(jq -r '.cqo.sprint_verdict // "pending"' "$PROGRESS")
+ops_report=$(jq -r '.service_ops.auto_retro.last_report // "null"' "$PROGRESS")
+cto_hotfixes=$(jq -r '.cto.open_hotfixes // 0' "$PROGRESS")
+ops_recommendations=$(jq -r '.service_ops.auto_retro.open_recommendations // 0' "$PROGRESS")
+ops_alerts=$(jq -r '.service_ops.monitor.alerts_this_sprint // 0' "$PROGRESS")
+open_incidents=$(jq -r '(.service_ops.incident.open | length) // 0' "$PROGRESS")
+workflow_stage=$(jq -r '.workflow.stage // "goal-intake"' "$PROGRESS")
+meeting_type=$(jq -r '.meetings.requested_type // "null"' "$PROGRESS")
+meeting_reason=$(jq -r '.meetings.requested_reason // "null"' "$PROGRESS")
+cqo_regressions=$(jq -r '.cqo.open_regressions // 0' "$PROGRESS")
+cqo_axes_below=$(jq -r '(.cqo.axes_below_threshold | length) // 0' "$PROGRESS")
+plan_status=$(jq -r '.artifacts["plan.md"].status // "pending"' "$PROGRESS")
+feature_status=$(jq -r '.artifacts["feature-list.json"].status // "pending"' "$PROGRESS")
+api_status=$(jq -r '.artifacts["api-contract.json"].status // "pending"' "$PROGRESS")
+service_ops_drift=$(jq -r '.service_ops.drift_classification // "null"' "$PROGRESS")
+
+set_progress() {
+  bash "$SCRIPT_DIR/harness-progress-set.sh" "$PROJECT_ROOT" "$1" >/dev/null
+}
+
+escape_json_string() {
+  jq -Rn --arg v "$1" '$v'
+}
+
+maybe_select_mode() {
+  local effective="$mode"
+  if [ "$user_override" != "null" ] && [ -n "$user_override" ]; then
+    effective="$user_override"
+    set_progress ".mode = \"$effective\" |
+      .mode_decision.owner = \"conductor\" |
+      .mode_decision.user_override = \"$effective\" |
+      .mode_decision.decided_at = (now | todate) |
+      .mode_decision.rationale = \"user override: $effective\""
+    echo "$effective"
+    return
+  fi
+  if [ "$mode" != "auto" ] || [ ! -f "$FEATURES" ]; then
+    echo "$mode"
+    return
+  fi
+
+  local feature_count ready_at_start critical_depth
+  feature_count=$(jq '.features | length // 0' "$FEATURES" 2>/dev/null || echo 0)
+  ready_at_start=$(jq '[.features[]? | select(((.depends_on // []) | length) == 0)] | length' "$FEATURES" 2>/dev/null || echo 0)
+  critical_depth=$(jq '
+    def feature($id): .features[]? | select(.id == $id);
+    def depth($id):
+      (feature($id) | .depends_on // []) as $deps
+      | if ($deps | length) == 0 then 1 else ([ $deps[] | depth(.) ] | max + 1) end;
+    ([.features[]?.id | depth(.)] | max) // 0
+  ' "$FEATURES" 2>/dev/null || echo 0)
+
+  local team_ready team_features team_depth selected rationale
+  team_ready=$(jq -r '.mode_selection.rules.force_team_when.ready_at_start_gte // 3' "$CONFIG")
+  team_features=$(jq -r '.mode_selection.rules.force_team_when.feature_count_gte // 6' "$CONFIG")
+  team_depth=$(jq -r '.mode_selection.rules.force_team_when.critical_path_depth_lte // 2' "$CONFIG")
+
+  if [ "$ready_at_start" -ge "$team_ready" ] && [ "$feature_count" -ge "$team_features" ] && [ "$critical_depth" -le "$team_depth" ]; then
+    selected="team"
+  else
+    selected=$(jq -r '.mode_selection.rules.tie_breaker // "team"' "$CONFIG")
+  fi
+  rationale="company-default: ready=${ready_at_start}, features=${feature_count}, depth=${critical_depth} -> ${selected}"
+  set_progress ".mode = \"$selected\" |
+    .mode_decision.owner = \"conductor\" |
+    .mode_decision.decided_at = (now | todate) |
+    .mode_decision.rationale = \"$rationale\""
+  echo "$selected"
+}
+
+infer_drift_classification() {
+  if [ "$service_ops_drift" != "null" ] && [ -n "$service_ops_drift" ]; then
+    echo "$service_ops_drift"
+    return
+  fi
+  if [ "$cqo_verdict" = "FAIL" ] || [ "${cqo_regressions:-0}" -gt 0 ] || [ "${cqo_axes_below:-0}" -gt 0 ]; then
+    echo "implementation_drift"
+    return
+  fi
+  if [ "$requested_mode" = "incident" ] || [ "${open_incidents:-0}" -gt 0 ] || [ "${ops_alerts:-0}" -gt 0 ]; then
+    echo "ops_drift"
+    return
+  fi
+  if [ "$goal_adherence" != "null" ] && awk "BEGIN {exit !($goal_adherence < 0.7)}"; then
+    if [ "$cqo_verdict" = "PASS" ] && [ "${open_incidents:-0}" -eq 0 ] && [ "${ops_alerts:-0}" -eq 0 ]; then
+      echo "planning_drift"
+    elif [ "$(jq -r '.goals.active_id // "null"' "$PROGRESS")" = "null" ]; then
+      echo "goal_drift"
+    else
+      echo "goal_drift"
+    fi
+    return
+  fi
+  echo "unknown"
+}
+
+meeting_stage_for_owner() {
+  case "$1" in
+    planner) echo "coo-planning" ;;
+    cto) echo "cto-review" ;;
+    cqo) echo "quality-review" ;;
+    service-ops) echo "ops-review" ;;
+    dispatcher) echo "goal-intake" ;;
+    *) echo "goal-intake" ;;
+  esac
+}
+
+load_meeting_decision() {
+  local decision
+  decision=$(bash "$SCRIPT_DIR/harness-meeting-doc.sh" "$PROJECT_ROOT" read-decision 2>/dev/null || true)
+  if [ -n "$decision" ]; then
+    echo "$decision"
+  else
+    jq -c '.meetings.decision // {}' "$PROGRESS"
+  fi
+}
+
+effective_mode="$(maybe_select_mode)"
+drift_classification="$(infer_drift_classification)"
+
+next="$candidate"
+action="pass-through"
+new_conductor_state="running"
+new_workflow_stage="$workflow_stage"
+meeting_filter=""
+planner_filter=""
+ops_filter=""
+meeting_prepare=false
+
+plan_artifacts_ready=false
+if [ "$plan_status" != "pending" ] || [ "$feature_status" != "pending" ] || [ "$api_status" != "pending" ]; then
+  plan_artifacts_ready=true
+fi
+
+first_generator="generator-backend"
+if [ "$pipeline" = "FE-ONLY" ]; then
+  first_generator="generator-frontend"
+fi
+
+if [ "$current_agent" = "dispatcher" ] && [ "$agent_status" = "completed" ]; then
+  next="meeting-manager"
+  action="convene:all-hands:goal-intake"
+  new_conductor_state="waiting_meeting"
+  new_workflow_stage="ceo-meeting"
+  meeting_prepare=true
+  meeting_filter="
+    .meetings.active = [\"meeting-manager\"] |
+    .meetings.requested_type = \"all-hands\" |
+    .meetings.requested_reason = \"goal-intake\" |
+    .meetings.decision = {
+      \"owner\": \"planner\",
+      \"action_type\": \"goal-alignment\",
+      \"rationale\": \"CEO intake always starts with COO alignment.\",
+      \"evidence\": [],
+      \"drift_classification\": null,
+      \"source_path\": null
+    }"
+
+elif [ "$meetings_active_count" -gt 0 ] && [ "$current_agent" != "meeting-manager" ]; then
+  next="meeting-manager"
+  action="spawn:meeting-manager:${meeting_type}"
+  new_conductor_state="waiting_meeting"
+
+elif [ "$requested_mode" != "null" ] && [ -n "$requested_mode" ] && [ "$current_agent" != "service-ops" ]; then
+  next="service-ops"
+  action="spawn:service-ops:${requested_mode}"
+
+elif [ "$goal_adherence" != "null" ] && awk "BEGIN {exit !($goal_adherence < 0.7)}"; then
+  next="meeting-manager"
+  action="convene:spec-review:${drift_classification}"
+  new_conductor_state="waiting_meeting"
+  new_workflow_stage="goal-drift-review"
+  meeting_prepare=true
+  meeting_filter="
+    .meetings.active = [\"meeting-manager\"] |
+    .meetings.requested_type = \"spec-review\" |
+    .meetings.requested_reason = \"goal-drift\" |
+    .service_ops.drift_classification = \"$drift_classification\" |
+    .meetings.decision = {
+      \"owner\": null,
+      \"action_type\": null,
+      \"rationale\": null,
+      \"evidence\": [],
+      \"drift_classification\": \"$drift_classification\",
+      \"source_path\": null
+    }"
+
+elif [ "$current_agent" = "meeting-manager" ] && [ "$agent_status" = "completed" ]; then
+  meeting_decision="$(load_meeting_decision)"
+  owner=$(jq -r '.owner // "null"' <<<"$meeting_decision")
+  action_type=$(jq -r '.action_type // "triage"' <<<"$meeting_decision")
+  rationale=$(jq -r '.rationale // ""' <<<"$meeting_decision")
+  evidence=$(jq -c '.evidence // []' <<<"$meeting_decision")
+  decision_drift=$(jq -r '.drift_classification // "unknown"' <<<"$meeting_decision")
+  source_path=$(jq -r '.source_path // "null"' <<<"$meeting_decision")
+
+  if [ "$owner" = "null" ] || [ -z "$owner" ]; then
+    case "$decision_drift" in
+      implementation_drift) owner="cto" ;;
+      planning_drift) owner="planner" ;;
+      ops_drift) owner="service-ops" ;;
+      goal_drift) owner="dispatcher" ;;
+      *)
+        if [ "$plan_artifacts_ready" = false ]; then owner="planner"; else owner="cto"; fi
+        ;;
+    esac
+  fi
+
+  next="$owner"
+  action="dispatch:${owner}:${action_type}"
+  new_workflow_stage="$(meeting_stage_for_owner "$owner")"
+  if [ "$owner" = "planner" ]; then
+    planner_filter=".planner.requested_mode = \"$action_type\""
+  fi
+  meeting_filter="
+    .meetings.active = [] |
+    .meetings.last_type = .meetings.requested_type |
+    .meetings.last_reason = .meetings.requested_reason |
+    .meetings.last_decision = \"$owner:$action_type\" |
+    .meetings.requested_type = null |
+    .meetings.requested_reason = null |
+    .meetings.decision = {
+      \"owner\": \"$owner\",
+      \"action_type\": \"$action_type\",
+      \"rationale\": $(escape_json_string "$rationale"),
+      \"evidence\": $evidence,
+      \"drift_classification\": $(escape_json_string "$decision_drift"),
+      \"source_path\": $(escape_json_string "$source_path")
+    }"
+
+elif [ "$current_agent" = "planner" ] && [ "$agent_status" = "completed" ]; then
+  if [ "$planner_requested_mode" = "hypothesis" ]; then
+    next="documentationer"
+    action="dispatch:hypothesis:documentationer"
+    new_workflow_stage="coo-hypothesis-research"
+    planner_filter='
+      .planner.last_brief = "hypothesis:research" |
+      .planner.requested_mode = null'
+  else
+    next="cto"
+    action="handoff:cto:plan-ready"
+    new_workflow_stage="cto-review"
+    planner_filter='
+      .planner.last_brief = (.planner.requested_mode // "goal-alignment") |
+      .planner.requested_mode = null'
+  fi
+
+elif [ "$current_agent" = "documentationer" ] && [ "$agent_status" = "completed" ]; then
+  if [ "$planner_last_brief" = "hypothesis:research" ]; then
+    next="coo-developer"
+    action="dispatch:hypothesis:experiment"
+    new_workflow_stage="coo-hypothesis-experiment"
+    planner_filter='.planner.last_brief = "hypothesis:experiment"'
+  elif [ "$planner_last_brief" = "hypothesis:report" ]; then
+    next="planner"
+    action="dispatch:planner:hypothesis-verdict"
+    new_workflow_stage="coo-hypothesis-verdict"
+    planner_filter='
+      .planner.last_brief = "hypothesis:done" |
+      .planner.requested_mode = "hypothesis-verdict"'
+  fi
+
+elif [ "$current_agent" = "coo-developer" ] && [ "$agent_status" = "completed" ]; then
+  if [ "$planner_last_brief" = "hypothesis:experiment" ]; then
+    next="documentationer"
+    action="dispatch:hypothesis:report"
+    new_workflow_stage="coo-hypothesis-report"
+    planner_filter='.planner.last_brief = "hypothesis:report"'
+  fi
+
+elif [ "$current_agent" = "cto" ]; then
+  if [ "${cto_hotfixes:-0}" -gt 0 ] || [ "${ops_recommendations:-0}" -gt 0 ]; then
+    next="planner"
+    action="dispatch:planner:execution-plan"
+    new_workflow_stage="coo-replan"
+    planner_filter='.planner.requested_mode = "execution-plan"'
+  elif [ "$candidate" = "archive" ] && [ "$workflow_stage" = "ops-review" ]; then
+    next="archive"
+    action="archive"
+    new_conductor_state="completed"
+    new_workflow_stage="ops-monitoring"
+  else
+    next="$first_generator"
+    action="dispatch:workers:${first_generator}"
+    new_workflow_stage="implementation"
+  fi
+
+elif [ "$candidate" = "archive" ]; then
+  if [[ "$current_agent" == evaluator-* ]] && [ "$cqo_verdict" = "pending" ]; then
+    next="cqo"
+    action="spawn:cqo"
+    new_workflow_stage="quality-review"
+  elif [ "$current_agent" = "cqo" ]; then
+    if [ "$cqo_verdict" = "FAIL" ] || [ "${cqo_regressions:-0}" -gt 0 ] || [ "${cqo_axes_below:-0}" -gt 0 ]; then
+      next="meeting-manager"
+      action="convene:spec-review:implementation_drift"
+      new_conductor_state="waiting_meeting"
+      new_workflow_stage="quality-review"
+      meeting_prepare=true
+      meeting_filter='
+        .meetings.active = ["meeting-manager"] |
+        .meetings.requested_type = "spec-review" |
+        .meetings.requested_reason = "quality-fail" |
+        .service_ops.drift_classification = "implementation_drift" |
+        .meetings.decision = {
+          "owner": null,
+          "action_type": null,
+          "rationale": null,
+          "evidence": [],
+          "drift_classification": "implementation_drift",
+          "source_path": null
+        }'
+    else
+      next="service-ops"
+      action="spawn:service-ops:auto-retro"
+      new_workflow_stage="ops-review"
+      ops_filter='.service_ops.requested_mode = "auto-retro"'
+    fi
+  elif [ "$cqo_verdict" != "pending" ] && [ "$ops_report" = "null" ]; then
+    next="service-ops"
+    action="spawn:service-ops:auto-retro"
+    new_workflow_stage="ops-review"
+    ops_filter='.service_ops.requested_mode = "auto-retro"'
+  elif [ "$current_agent" = "service-ops" ]; then
+    local_drift="$drift_classification"
+    if [ "$requested_mode" = "auto-retro" ] || [ "${open_incidents:-0}" -gt 0 ] || [ "${ops_alerts:-0}" -gt 0 ] || { [ "$goal_adherence" != "null" ] && awk "BEGIN {exit !($goal_adherence < 0.7)}"; }; then
+      next="meeting-manager"
+      action="convene:sprint-review:${local_drift}"
+      new_conductor_state="waiting_meeting"
+      new_workflow_stage="ops-review"
+      meeting_prepare=true
+      meeting_filter="
+        .meetings.active = [\"meeting-manager\"] |
+        .meetings.requested_type = \"sprint-review\" |
+        .meetings.requested_reason = \"ops-batch\" |
+        .service_ops.drift_classification = \"$local_drift\" |
+        .meetings.decision = {
+          \"owner\": null,
+          \"action_type\": null,
+          \"rationale\": null,
+          \"evidence\": [],
+          \"drift_classification\": \"$local_drift\",
+          \"source_path\": null
+        }"
+    else
+      next="archive"
+      action="archive"
+      new_conductor_state="completed"
+      new_workflow_stage="ops-monitoring"
+      ops_filter='.service_ops.requested_mode = null'
+    fi
+  fi
+fi
+
+filter=".conductor.state = \"$new_conductor_state\" |
+  .conductor.current_action = \"$action\" |
+  .conductor.last_tick = (now | todate) |
+  .conductor.tick_count = ((.conductor.tick_count // 0) + 1) |
+  .next_agent = \"$next\" |
+  .workflow.stage = \"$new_workflow_stage\" |
+  .workflow.last_transition = (now | todate) |
+  .workflow.last_reason = \"$action\""
+
+if [ -n "$meeting_filter" ]; then
+  filter="$filter | $meeting_filter"
+fi
+if [ -n "$planner_filter" ]; then
+  filter="$filter | $planner_filter"
+fi
+if [ -n "$ops_filter" ]; then
+  filter="$filter | $ops_filter"
+elif [ "$current_agent" = "service-ops" ] && [ "$next" != "service-ops" ]; then
+  filter="$filter | .service_ops.requested_mode = null"
+fi
+if [ "$next" = "meeting-manager" ] && [ "$workflow_stage" = "ops-review" ]; then
+  filter="$filter | .workflow.loop_count = ((.workflow.loop_count // 0) + 1)"
+fi
+
+set_progress "$filter"
+
+if [ "$meeting_prepare" = true ] && [ "$next" = "meeting-manager" ]; then
+  bash "$SCRIPT_DIR/harness-meeting-doc.sh" "$PROJECT_ROOT" prepare >/dev/null 2>&1 || true
+fi
+
+echo "$next"