@walwal-harness/cli 6.1.2 → 6.1.4

package/gotchas/generator-designer.md

@@ -0,0 +1,22 @@
+---
+docmeta:
+  id: gotchas-generator-designer
+  title: Gotchas — ugenerator-udesigner
+  type: input
+  createdAt: 2026-05-08T00:00:00Z
+  updatedAt: 2026-05-08T00:00:00Z
+  source:
+    producer: user
+    skillId: harness-dispatcher
+  inputs: []
+  tags: [gotchas, generator-designer]
+---
+
+# Gotchas — ugenerator-udesigner
+
+> Dispatcher 가 관리. ugenerator-udesigner 는 세션 시작 시 이 파일을 읽고 같은 실수를 반복하지 않습니다.
+> 
+> 항목 형식은 `gotchas/README.md` 참조. Dispatcher 가 사용자의 실수 지적을 감지하면 자동으로
+> `### [G-NNN]` 항목을 append 합니다. 사용자가 직접 편집해도 무방합니다.
+
+<!-- 항목이 추가되면 아래에 기록됩니다 -->

package/gotchas/generator-devops.md

@@ -0,0 +1,22 @@
+---
+docmeta:
+  id: gotchas-generator-devops
+  title: Gotchas — ugenerator-udevops
+  type: input
+  createdAt: 2026-05-08T00:00:00Z
+  updatedAt: 2026-05-08T00:00:00Z
+  source:
+    producer: user
+    skillId: harness-dispatcher
+  inputs: []
+  tags: [gotchas, generator-devops]
+---
+
+# Gotchas — ugenerator-udevops
+
+> Dispatcher 가 관리. ugenerator-udevops 는 세션 시작 시 이 파일을 읽고 같은 실수를 반복하지 않습니다.
+> 
+> 항목 형식은 `gotchas/README.md` 참조. Dispatcher 가 사용자의 실수 지적을 감지하면 자동으로
+> `### [G-NNN]` 항목을 append 합니다. 사용자가 직접 편집해도 무방합니다.
+
+<!-- 항목이 추가되면 아래에 기록됩니다 -->

package/gotchas/generator-frontend.md

@@ -1,31 +1,22 @@
 ---
 docmeta:
-  id: generator-frontend
-  title: Gotchas — Generator-Frontend
-  type: intermediate
-  createdAt: 2026-05-07T00:00:00Z
-  updatedAt: 2026-05-07T00:00:00Z
+  id: gotchas-generator-frontend
+  title: Gotchas — ugenerator-ufrontend
+  type: input
+  createdAt: 2026-05-08T00:00:00Z
+  updatedAt: 2026-05-08T00:00:00Z
   source:
-    producer: agent
+    producer: user
     skillId: harness-dispatcher
   inputs: []
-  tags: [gotcha, generator-frontend, sub-skill, agency-agents]
+  tags: [gotchas, generator-frontend]
 ---
 
-# Gotchas — Generator-Frontend
+# Gotchas — ugenerator-ufrontend
 
-> Dispatcher가 관리. Generator-Frontend는 세션 시작 시 이 파일을 읽고 같은 실수를 반복하지 않습니다.
+> Dispatcher 가 관리. ugenerator-ufrontend 는 세션 시작 시 이 파일을 읽고 같은 실수를 반복하지 않습니다.
+> 
+> 항목 형식은 `gotchas/README.md` 참조. Dispatcher 가 사용자의 실수 지적을 감지하면 자동으로
+> `### [G-NNN]` 항목을 append 합니다. 사용자가 직접 편집해도 무방합니다.
 
-## [G-001] CTO-Frontend 단독 작업 금지 — 흡수된 agency-agents sub-skill 명시 호출 (status: verified)
-
-- **Why**: walwal-harness v6 는 agency-agents (MIT) 의 design/UX/A11y/perf 패턴을 부서별로 흡수했지만, generator-frontend SKILL 에는 sub-skill 호출 의무가 누락되어 CTO-Frontend 가 단독으로 컴포넌트를 찍어내고 끝나는 회귀가 있었다 (moon_web 2026-05-07).
-- **How to apply**:
-  - **Sprint Workflow Step 2 (구현)** 진입 시, 다음 sub-skill 결과를 **순차 호출 후 본 구현에 반영**한다 — 결과 미반영은 PASS 금지:
-    1. **engineering-react-developer** (또는 -flutter-developer) — 컴포넌트 골격 패턴 결정
-    2. **design/ux-strategy** (CTO-Designer 흡수) — 사용자 흐름 / 정보 구조 검증
-    3. **design/ui-component-spec** — 토큰 / variant / state 매핑
-    4. **engineering-accessibility-reviewer** — WCAG AA + 키보드 네비
-    5. **engineering-performance-engineer** — RSC 우선 / hydration 비용 / IntersectionObserver
-  - 호출 결과는 sprint-contract.md FE 섹션의 `## Sub-skill Findings` 블록에 요약 반영. 빈 블록 = FAIL.
-  - tmux/3D 대시보드에 visibility 보장: 각 sub-skill 호출 직전 `progress.json.meetings.active = ["generator-frontend", "<sub-skill>"]` partial update 후 1.5s, 호출 후 `[]` 로 복귀.
-- **References**: skills/cto/SKILL.md "agency-agents (MIT) 흡수" 섹션, skills/generator-designer/SKILL.md.
+<!-- 항목이 추가되면 아래에 기록됩니다 -->

package/gotchas/meeting-manager.md

@@ -0,0 +1,22 @@
+---
+docmeta:
+  id: gotchas-meeting-manager
+  title: Gotchas — umeeting-umanager
+  type: input
+  createdAt: 2026-05-08T00:00:00Z
+  updatedAt: 2026-05-08T00:00:00Z
+  source:
+    producer: user
+    skillId: harness-dispatcher
+  inputs: []
+  tags: [gotchas, meeting-manager]
+---
+
+# Gotchas — umeeting-umanager
+
+> Dispatcher 가 관리. umeeting-umanager 는 세션 시작 시 이 파일을 읽고 같은 실수를 반복하지 않습니다.
+> 
+> 항목 형식은 `gotchas/README.md` 참조. Dispatcher 가 사용자의 실수 지적을 감지하면 자동으로
+> `### [G-NNN]` 항목을 append 합니다. 사용자가 직접 편집해도 무방합니다.
+
+<!-- 항목이 추가되면 아래에 기록됩니다 -->

package/gotchas/planner.md

@@ -1,5 +1,22 @@
-# Gotchas — Planner
+---
+docmeta:
+  id: gotchas-planner
+  title: Gotchas — uplanner
+  type: input
+  createdAt: 2026-05-08T00:00:00Z
+  updatedAt: 2026-05-08T00:00:00Z
+  source:
+    producer: user
+    skillId: harness-dispatcher
+  inputs: []
+  tags: [gotchas, planner]
+---
 
-> Dispatcher가 관리. Planner는 세션 시작 시 이 파일을 읽고 같은 실수를 반복하지 않습니다.
+# Gotchas — uplanner
+
+> Dispatcher 가 관리. uplanner 는 세션 시작 시 이 파일을 읽고 같은 실수를 반복하지 않습니다.
+> 
+> 항목 형식은 `gotchas/README.md` 참조. Dispatcher 가 사용자의 실수 지적을 감지하면 자동으로
+> `### [G-NNN]` 항목을 append 합니다. 사용자가 직접 편집해도 무방합니다.
 
 <!-- 항목이 추가되면 아래에 기록됩니다 -->

package/gotchas/service-ops.md

@@ -1,27 +1,22 @@
 ---
 docmeta:
-  id: service-ops
-  title: Gotchas — Service-Ops
-  type: intermediate
-  createdAt: 2026-05-07T00:00:00Z
-  updatedAt: 2026-05-07T00:00:00Z
+  id: gotchas-service-ops
+  title: Gotchas — uservice-uops
+  type: input
+  createdAt: 2026-05-08T00:00:00Z
+  updatedAt: 2026-05-08T00:00:00Z
   source:
-    producer: agent
+    producer: user
     skillId: harness-dispatcher
   inputs: []
-  tags: [gotcha, service-ops, monitor, presence]
+  tags: [gotchas, service-ops]
 ---
 
-# Gotchas — Service-Ops
+# Gotchas — uservice-uops
 
-> Dispatcher가 관리. Service-Ops 는 세션 시작 시 이 파일을 읽고 같은 실수를 반복하지 않습니다.
+> Dispatcher 가 관리. uservice-uops 는 세션 시작 시 이 파일을 읽고 같은 실수를 반복하지 않습니다.
+> 
+> 항목 형식은 `gotchas/README.md` 참조. Dispatcher 가 사용자의 실수 지적을 감지하면 자동으로
+> `### [G-NNN]` 항목을 append 합니다. 사용자가 직접 편집해도 무방합니다.
 
-## [G-001] Build/Deploy 진행 중 자리 비움 금지 — monitor 모듈 활성 의무 (status: verified)
-
-- **Why**: Service-Ops 의 monitor 는 cron + red-alert 이벤트로만 spawn 되도록 설계됐으나, generator/evaluator 가 build·flutter test·deploy 를 실행하는 동안에는 cron 주기 사이 공백이 길어 대시보드에서 "SERVICE-OPS 룸 빈 채" 가 관찰됨 (moon_web 2026-05-07). 빌드 stderr 의 WebSocketChannelException, 컴파일 에러, dart analyze warning 을 실시간으로 캐치하지 못하면 이후 evaluator-functional 단계에서야 발견 → 비용 증가.
-- **How to apply**:
-  - Conductor 가 generator-* 또는 evaluator-functional 을 spawn 하기 **직전**, 동일 tick 에 service-ops/monitor 를 **stream-mode 로 함께 spawn** (handoff-bridge). progress.json.service_ops.monitor.stream_active = true.
-  - Stream-mode monitor 의 책임: 자식 프로세스 stdout/stderr 를 tail → 정규식 (`error:|exception|TestFailure|Cannot find|Failed to compile`) 매칭 시 즉시 conductor 에 red-alert 발행.
-  - 자식 프로세스 종료 시 stream_active = false + ops-report 짧은 요약 append.
-  - Visibility: monitor 활성 동안 progress.json.agents 에 service-ops minifig 가 service-ops 룸 (또는 모니터링 대상 룸 인접) 에 위치하도록 partial update.
-- **References**: skills/service-ops/SKILL.md service_ops.monitor 섹션.
+<!-- 항목이 추가되면 아래에 기록됩니다 -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walwal-harness/cli",
-  "version": "6.1.2",
+  "version": "6.1.4",
   "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"
@@ -53,6 +53,7 @@
     "commands/",
     "assets/",
     "gotchas/",
+    "conventions/",
     "CHANGELOG.md"
   ]
 }

package/scripts/conductor-tick.sh

@@ -23,6 +23,10 @@ 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")
+# v6.2 — parallel tracks (fork-join) state
+parallel_tracks=$(jq -c '.conductor.tracks // []' "$PROGRESS")
+parallel_rendezvous=$(jq -c '.conductor.rendezvous // null' "$PROGRESS")
+parallel_pending_count=$(jq -r '[ .conductor.tracks // [] | .[] | select(.status == "pending" or .status == "running") ] | length' "$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")
@@ -191,6 +195,80 @@ elif [ "$meetings_active_count" -gt 0 ] && [ "$current_agent" != "meeting-manage
   next="meeting-manager"
   action="spawn:meeting-manager:${meeting_type}"
   new_conductor_state="waiting_meeting"
+  if [ "$meeting_type" = "followup-review" ]; then
+    new_workflow_stage="followup-review"
+    if [ "$current_agent" = "planner" ] && [ "$planner_requested_mode" = "hypothesis-verdict" ]; then
+      planner_filter='.planner.requested_mode = null'
+    fi
+  fi
+
+# v6.2 — Parallel tracks advance: if a track owner just completed, mark its track done
+# and dispatch the next pending track. When all tracks completed, convene followup-review.
+#
+# Exclusion: for planner running a hypothesis chain (action_type=hypothesis-*), the track is
+# only terminal when the chain ends with planner.last_brief="hypothesis:done". Intermediate
+# planner ticks (research, verdict-prep, etc.) must defer to the dedicated planner-completed
+# branch which routes the chain.
+elif [ "$parallel_pending_count" -gt 0 ] && [ "$agent_status" = "completed" ] && \
+     [ "$(jq --arg a "$current_agent" '[.[] | select(.owner == $a and (.status == "running" or .status == "pending"))] | length' <<<"$parallel_tracks")" -gt 0 ] && \
+     ! { [ "$current_agent" = "planner" ] && \
+         [ "$(jq --arg a "$current_agent" '[.[] | select(.owner == $a and (.status == "running" or .status == "pending")) | .action_type // ""] | first | startswith("hypothesis")' <<<"$parallel_tracks")" = "true" ] && \
+         [ "$planner_last_brief" != "hypothesis:done" ]; }; then
+  # mark the matching running/pending track as completed
+  updated_tracks=$(jq -c --arg a "$current_agent" '
+    [ .[] |
+      if .owner == $a and (.status == "running" or .status == "pending") then
+        . + { status: "completed", completed_at: (now | todate) }
+      else . end
+    ]
+  ' <<<"$parallel_tracks")
+  remaining=$(jq -r '[ .[] | select(.status == "pending" or .status == "running") ] | length' <<<"$updated_tracks")
+  if [ "$remaining" -gt 0 ]; then
+    # dispatch the next pending track
+    next_owner=$(jq -r '[ .[] | select(.status == "pending") ] | .[0].owner // empty' <<<"$updated_tracks")
+    next_action=$(jq -r '[ .[] | select(.status == "pending") ] | .[0].action_type // "triage"' <<<"$updated_tracks")
+    next_track_id=$(jq -r '[ .[] | select(.status == "pending") ] | .[0].id // "track-?"' <<<"$updated_tracks")
+    if [ -n "$next_owner" ]; then
+      updated_tracks=$(jq -c --arg id "$next_track_id" '
+        [ .[] |
+          if .id == $id then . + { status: "running", started_at: (now | todate) } else . end
+        ]
+      ' <<<"$updated_tracks")
+      next="$next_owner"
+      action="dispatch:parallel:${next_track_id}:${next_owner}/${next_action}"
+      new_workflow_stage="$(meeting_stage_for_owner "$next_owner")"
+      if [ "$next_owner" = "planner" ]; then
+        planner_filter=".planner.requested_mode = \"$next_action\""
+      fi
+      meeting_filter=".conductor.tracks = $updated_tracks | .meetings.decision.tracks = $updated_tracks"
+    fi
+  else
+    # All tracks completed → rendezvous (followup-review)
+    rdv_type=$(jq -r '.type // "followup-review"' <<<"$parallel_rendezvous")
+    fork_meeting_id=$(jq -r '.conductor.fork_meeting_id // ""' "$PROGRESS")
+    next="meeting-manager"
+    action="convene:${rdv_type}:rendezvous"
+    new_conductor_state="waiting_meeting"
+    new_workflow_stage="followup-review"
+    meeting_prepare=true
+    # Save prior_tracks + fork_meeting_id to a stable namespace (.meetings.fork_context)
+    # because meeting-doc.sh prepare overwrites .meetings.decision with a new skeleton.
+    meeting_filter="
+      .meetings.active = [\"meeting-manager\"] |
+      .meetings.requested_type = \"$rdv_type\" |
+      .meetings.requested_reason = \"rendezvous\" |
+      .meetings.requested_tracks = [] |
+      .meetings.requested_rendezvous = null |
+      .meetings.fork_meeting_id = $(escape_json_string "$fork_meeting_id") |
+      .meetings.fork_context = {
+        \"fork_meeting_id\": $(escape_json_string "$fork_meeting_id"),
+        \"prior_tracks\": $updated_tracks,
+        \"sealed_at\": (now | todate)
+      } |
+      .planner.requested_mode = null |
+      .conductor.tracks = $updated_tracks |
+      .conductor.rendezvous = null"
+  fi
 
 elif [ "$requested_mode" != "null" ] && [ -n "$requested_mode" ] && [ "$current_agent" != "service-ops" ]; then
   next="service-ops"
@@ -224,6 +302,9 @@ elif [ "$current_agent" = "meeting-manager" ] && [ "$agent_status" = "completed"
   evidence=$(jq -c '.evidence // []' <<<"$meeting_decision")
   decision_drift=$(jq -r '.drift_classification // "unknown"' <<<"$meeting_decision")
   source_path=$(jq -r '.source_path // "null"' <<<"$meeting_decision")
+  # v6.2 — tracks length >= 2 → fork-join, else single. mode 필드 없음.
+  decision_tracks=$(jq -c '.tracks // []' <<<"$meeting_decision")
+  decision_rendezvous=$(jq -c '.rendezvous // null' <<<"$meeting_decision")
 
   if [ "$owner" = "null" ] || [ -z "$owner" ]; then
     case "$decision_drift" in
@@ -237,30 +318,95 @@ elif [ "$current_agent" = "meeting-manager" ] && [ "$agent_status" = "completed"
     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\""
+  # v6.2 — Parallel fork: if 2+ tracks, materialize conductor.tracks[] and dispatch
+  # the first pending track owner. Subsequent ticks advance remaining tracks.
+  if [ "$(jq 'length' <<<"$decision_tracks")" -gt 1 ]; then
+    first_track_owner=$(jq -r '.[0].owner' <<<"$decision_tracks")
+    first_track_action=$(jq -r '.[0].action_type // "triage"' <<<"$decision_tracks")
+    first_track_id=$(jq -r '.[0].id // "track-1"' <<<"$decision_tracks")
+    # mark first track as running, rest as pending
+    materialized_tracks=$(jq -c --arg first "$first_track_id" '
+      [ .[] | . + {
+          status: (if .id == $first then "running" else (.status // "pending") end),
+          deliverable_path: (.deliverable_path // null)
+        }
+      ]
+    ' <<<"$decision_tracks")
+    next="$first_track_owner"
+    action="dispatch:parallel:${first_track_id}:${first_track_owner}/${first_track_action}"
+    new_workflow_stage="$(meeting_stage_for_owner "$first_track_owner")"
+    if [ "$first_track_owner" = "planner" ]; then
+      planner_filter=".planner.requested_mode = \"$first_track_action\""
+    fi
+    meeting_filter="
+      .meetings.active = [] |
+      .meetings.last_type = .meetings.requested_type |
+      .meetings.last_reason = .meetings.requested_reason |
+      .meetings.last_decision = \"fork:${first_track_owner}:${first_track_action}\" |
+      .meetings.requested_type = null |
+      .meetings.requested_reason = null |
+      .meetings.requested_tracks = [] |
+      .meetings.requested_rendezvous = 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"),
+        \"tracks\": $materialized_tracks,
+        \"rendezvous\": $decision_rendezvous
+      } |
+      .conductor.tracks = $materialized_tracks |
+      .conductor.rendezvous = $decision_rendezvous |
+      .conductor.fork_meeting_id = (.meetings.current_id // null)"
+  else
+    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.requested_tracks = [] |
+      .meetings.requested_rendezvous = 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"),
+        \"tracks\": [],
+        \"rendezvous\": null
+      } |
+      .conductor.tracks = [] |
+      .conductor.rendezvous = null |
+      .conductor.fork_meeting_id = null"
   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
+  # v6.2 — hypothesis-verdict is terminal for the cell; return to meeting-manager.
+  if [ "$planner_requested_mode" = "hypothesis-verdict" ]; then
+    next="meeting-manager"
+    action="convene:followup-review:hypothesis-verdict"
+    new_workflow_stage="followup-review"
+    meeting_prepare=true
+    planner_filter='.planner.requested_mode = null'
+    meeting_filter="
+      .meetings.active = [\"meeting-manager\"] |
+      .meetings.requested_type = \"followup-review\" |
+      .meetings.requested_reason = \"rendezvous\" |
+      .meetings.requested_tracks = [] |
+      .meetings.requested_rendezvous = null"
+  # v6.2 — Accept hypothesis* (e.g. "hypothesis", "hypothesis-validation") as Hypothesis Cell trigger
+  elif [[ "$planner_requested_mode" == hypothesis* ]]; then
     next="documentationer"
     action="dispatch:hypothesis:documentationer"
     new_workflow_stage="coo-hypothesis-research"

package/scripts/harness-meeting-doc.sh

@@ -21,6 +21,13 @@ ops_report=$(jq -r '.service_ops.auto_retro.last_report // empty' "$PROGRESS")
 cqo_audit=$(jq -r '.cqo.audit_path // empty' "$PROGRESS")
 cto_review=$(jq -r '.cto.review_path // empty' "$PROGRESS")
 current_path=$(jq -r '.meetings.current_record_path // empty' "$PROGRESS")
+# v6.2 — parallel tracks hints (set by conductor before convene). length >= 2 = fork.
+requested_tracks=$(jq -c '.meetings.requested_tracks // []' "$PROGRESS")
+requested_rendezvous=$(jq -c '.meetings.requested_rendezvous // null' "$PROGRESS")
+fork_context=$(jq -c '.meetings.fork_context // null' "$PROGRESS")
+fallback_fork_meeting_id=$(jq -r '.meetings.fork_meeting_id // .conductor.fork_meeting_id // ""' "$PROGRESS")
+fallback_conductor_tracks=$(jq -c '.conductor.tracks // []' "$PROGRESS")
+fallback_decision_tracks=$(jq -c '.meetings.decision.tracks // []' "$PROGRESS")
 
 default_decision_json() {
   local owner="planner"
@@ -35,6 +42,33 @@ default_decision_json() {
     owner="planner"
     action_type="goal-alignment"
   fi
+
+  # v6.2 — Tracks 가 단일 진실: length >= 2 → fork-join, length == 1 → single.
+  # legacy {owner, action_type} 만 들어와도 1-element tracks[] 로 합성.
+  local tracks_json="[]"
+  local rendezvous_json="null"
+  if [ "$(jq 'length' <<<"$requested_tracks")" -gt 1 ]; then
+    tracks_json=$(jq -c '
+      [ to_entries[] | (.value + {
+          id: ((.value.id // null) // ("track-" + ((.key + 1) | tostring))),
+          deliverable: (.value.deliverable // "report"),
+          deliverable_path: (.value.deliverable_path // null),
+          status: (.value.status // "pending")
+        })
+      ]
+    ' <<<"$requested_tracks")
+    rendezvous_json=$(jq -c '. // {type:"followup-review", when:"next_cadence"}' <<<"$requested_rendezvous")
+    # primary owner = first track owner (편의 미러)
+    owner=$(jq -r '.[0].owner // "planner"' <<<"$tracks_json")
+    action_type=$(jq -r '.[0].action_type // "triage"' <<<"$tracks_json")
+  else
+    # single — derive a 1-element tracks[] (backward compat 도 동시에 처리)
+    tracks_json=$(jq -c -n \
+      --arg owner "$owner" \
+      --arg action_type "$action_type" \
+      '[ {id:"track-1", owner:$owner, action_type:$action_type, deliverable:"report", deliverable_path:null, status:"pending"} ]')
+  fi
+
   jq -n \
     --arg owner "$owner" \
     --arg action_type "$action_type" \
@@ -42,7 +76,9 @@ default_decision_json() {
     --arg drift_classification "$1" \
     --arg ops_report "$ops_report" \
     --arg cqo_audit "$cqo_audit" \
-    --arg cto_review "$cto_review" '
+    --arg cto_review "$cto_review" \
+    --argjson tracks "$tracks_json" \
+    --argjson rendezvous "$rendezvous_json" '
     {
       owner: $owner,
       action_type: $action_type,
@@ -54,26 +90,70 @@ default_decision_json() {
           (if $cto_review != "" then {source:$cto_review, kind:"cto-review"} else empty end)
         ]
       ),
-      drift_classification: $drift_classification
+      drift_classification: $drift_classification,
+      tracks: $tracks,
+      rendezvous: $rendezvous
     }'
 }
 
+resolve_followup_fork_context() {
+  local resolved="$fork_context"
+  if [ "$requested_type" != "followup-review" ]; then
+    echo "$resolved"
+    return
+  fi
+
+  if [ "$resolved" != "null" ] && [ -n "$resolved" ]; then
+    echo "$resolved"
+    return
+  fi
+
+  local fallback_tracks="$fallback_conductor_tracks"
+  if [ "$(jq 'length' <<<"$fallback_tracks")" -eq 0 ] && [ "$(jq 'length' <<<"$fallback_decision_tracks")" -gt 0 ]; then
+    fallback_tracks="$fallback_decision_tracks"
+  fi
+
+  if [ "$(jq 'length' <<<"$fallback_tracks")" -eq 0 ]; then
+    echo "null"
+    return
+  fi
+
+  jq -c -n \
+    --arg fork_meeting_id "$fallback_fork_meeting_id" \
+    --argjson prior_tracks "$fallback_tracks" \
+    '{fork_meeting_id:$fork_meeting_id, prior_tracks:$prior_tracks, sealed_at:(now | todate)}'
+}
+
 if [ "$MODE" = "prepare" ]; then
   meeting_id="M-$(date -u +%Y%m%dT%H%M%SZ)"
   meeting_dir="$MEETINGS_ROOT/$meeting_id"
   mkdir -p "$meeting_dir"
   record="$meeting_dir/meeting-$meeting_id.md"
 
+  # v6.2 — Notice surfaces tracks/rendezvous for visibility (length >= 2 = fork)
+  tracks_summary="(single owner)"
+  rendezvous_summary="-"
+  is_fork="false"
+  if [ "$(jq 'length' <<<"$requested_tracks")" -gt 1 ]; then
+    is_fork="true"
+    tracks_summary=$(jq -r '[.[] | "\(.id // "?"):\(.owner)/\(.action_type)→\(.deliverable // "report")"] | join(", ")' <<<"$requested_tracks")
+    rendezvous_summary=$(jq -r '"\(.type // "followup-review")@\(.when // "next_cadence")"' <<<"$requested_rendezvous")
+  fi
   cat > "$meeting_dir/notice.md" <<EOF
 # Notice — $meeting_id
 
 - type: $requested_type
 - reason: $requested_reason
 - goal_adherence: $goal_adherence
+- fork: $is_fork
+- tracks: $tracks_summary
+- rendezvous: $rendezvous_summary
 
 ## Request
 "$requested_reason" 요청이 접수되었습니다. 참석자들은 각자의 전문 시각에서 사실·증거를 제출하고,
 다음 owner와 action_type을 evidence 중심으로 결정하십시오.
+
+> **Parallel tracks (v6.2)**: \`tracks[]\` 의 길이 ≥ 2 면 fork-join. \`rendezvous\` 시점에 followup-review 로 합쳐집니다. 단일 트랙 회의는 기존과 동일하게 동작합니다.
 EOF
 
   cat > "$meeting_dir/prep-dispatcher.md" <<'EOF'
@@ -108,6 +188,26 @@ EOF
 EOF
 
   decision_json="$(default_decision_json "$drift")"
+
+  # v6.2 — followup-review: surface prior_tracks + fork_meeting_id from fork_context
+  resolved_fork_context="$(resolve_followup_fork_context)"
+
+  fork_section=""
+  if [ "$requested_type" = "followup-review" ] && [ "$resolved_fork_context" != "null" ] && [ -n "$resolved_fork_context" ]; then
+    fork_id=$(jq -r '.fork_meeting_id // ""' <<<"$resolved_fork_context")
+    fork_section="
+
+## Fork Context (v6.2)
+- fork_meeting_id: $fork_id
+- prior_tracks (rendezvous 입력):
+
+\`\`\`json
+$(jq '.prior_tracks' <<<"$resolved_fork_context")
+\`\`\`
+
+> 결정자(기본 CTO) 는 위 트랙별 deliverable 을 통합 검토 후 \`apply-now / backlog / more-validation\` 중 하나를 선택해 아래 Decision JSON 의 \`tracks\` 를 비우고 \`owner / action_type\` 만 채운다 (followup 에서 또 fork 금지)."
+  fi
+
   cat > "$record" <<EOF
 # Meeting Record — $meeting_id
 
@@ -115,6 +215,7 @@ EOF
 - type: $requested_type
 - reason: $requested_reason
 - goal_adherence: $goal_adherence
+$fork_section
 
 ## Decision JSON
 \`\`\`json
@@ -135,6 +236,10 @@ EOF
        jq -n --arg meeting_id "$meeting_id" --arg type "$requested_type" --arg reason "$requested_reason" --arg source_path "${record#$PROJECT_ROOT/}" --argjson decision "$decision_json" '{meeting_id:$meeting_id,type:$type,reason:$reason,decision:($decision + {source_path:$source_path})}'
      )"))" >/dev/null
 
+  if [ "$requested_type" = "followup-review" ] && [ "$resolved_fork_context" != "null" ] && [ -n "$resolved_fork_context" ]; then
+    bash "$SCRIPT_DIR/harness-progress-set.sh" "$PROJECT_ROOT" ".meetings.fork_context = $resolved_fork_context" >/dev/null
+  fi
+
   echo "${record#$PROJECT_ROOT/}"
   exit 0
 fi
@@ -150,4 +255,43 @@ if [ "$MODE" = "read-decision" ]; then
   exit 0
 fi
 
+# v6.2 — read-tracks: emit normalized tracks[] (length>=2 = fork, length==1 = single).
+# Legacy decisions without tracks → synthesize 1-element tracks[] from {owner, action_type}.
+if [ "$MODE" = "read-tracks" ]; then
+  jq -c '
+    if ((.meetings.decision.tracks // []) | length) > 0 then
+      .meetings.decision.tracks
+    elif ((.meetings.fork_context.prior_tracks // []) | length) > 0 then
+      .meetings.fork_context.prior_tracks
+    elif ((.conductor.tracks // []) | length) > 0 then
+      .conductor.tracks
+    else
+      [ {
+          id: "track-1",
+          owner: (.meetings.decision.owner // "planner"),
+          action_type: (.meetings.decision.action_type // "triage"),
+          deliverable: "report",
+          deliverable_path: null,
+          status: "pending"
+        }
+      ]
+    end
+  ' "$PROGRESS"
+  exit 0
+fi
+
+# v6.2 — read-rendezvous: emit rendezvous{} or null
+if [ "$MODE" = "read-rendezvous" ]; then
+  jq -c '.meetings.decision.rendezvous // .conductor.rendezvous // null' "$PROGRESS"
+  exit 0
+fi
+
+# v6.2 — read-fork: "true" if tracks.length >= 2, else "false"
+if [ "$MODE" = "read-fork" ]; then
+  decision="$(bash "$0" "$PROJECT_ROOT" read-decision 2>/dev/null || true)"
+  if [ -z "$decision" ]; then decision='{}'; fi
+  jq -r '((.tracks // []) | length) > 1' <<<"$decision"
+  exit 0
+fi
+
 exit 2

package/scripts/harness-session-start.sh

@@ -8,10 +8,12 @@
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 LIB="$SCRIPT_DIR/lib/harness-render-progress.sh"
 AUDIT_LIB="$SCRIPT_DIR/lib/harness-audit.sh"
+MIGRATE_LIB="$SCRIPT_DIR/lib/harness-progress-migrate.sh"
 
 if [ ! -f "$LIB" ]; then exit 0; fi
 source "$LIB"
 [ -f "$AUDIT_LIB" ] && source "$AUDIT_LIB"
+[ -f "$MIGRATE_LIB" ] && source "$MIGRATE_LIB"
 command -v jq &>/dev/null || exit 0
 
 PROJECT_ROOT="$(resolve_harness_root "." 2>/dev/null)" || exit 0
@@ -20,6 +22,11 @@ CONFIG="$PROJECT_ROOT/.harness/config.json"
 HANDOFF="$PROJECT_ROOT/.harness/handoff.json"
 [ -f "$PROGRESS" ] || exit 0
 
+# v6.2 — idempotent schema migration (parallel tracks fields, etc.)
+if declare -f migrate_progress_schema >/dev/null 2>&1; then
+  migrate_progress_schema "$PROGRESS" || true
+fi
+
 sprint_status=$(jq -r '.sprint.status // "init"' "$PROGRESS" 2>/dev/null)
 sprint_num=$(jq -r '.sprint.number // 0' "$PROGRESS" 2>/dev/null)
 current_agent=$(jq -r '.current_agent // "none"' "$PROGRESS" 2>/dev/null)