@walwal-harness/cli 6.1.5 → 7.1.0

package/scripts/conductor-tick.sh

@@ -33,6 +33,7 @@ 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")
+pending_required_execution=$(jq -r 'if (.meetings.decision.required_execution // null) != null then "true" else "false" end' "$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")
@@ -120,6 +121,10 @@ ensure_team_queue() {
 
 load_meeting_decision() {
   local decision
+  if jq -e '(.meetings.decision.required_execution // null) != null' "$PROGRESS" >/dev/null 2>&1; then
+    jq -c '.meetings.decision' "$PROGRESS"
+    return 0
+  fi
   decision=$(bash "$SCRIPT_DIR/harness-meeting-doc.sh" "$PROJECT_ROOT" read-decision 2>/dev/null || true)
   if [ -n "$decision" ]; then
     echo "$decision"
@@ -135,6 +140,47 @@ dispatch_company_workers() {
   bash "$SCRIPT_DIR/harness-worker-dispatch.sh" "$PROJECT_ROOT" 2>/dev/null || echo "[]"
 }
 
+ensure_strategy_work_package() {
+  local required_json="$1"
+  local deliverable_path="$2"
+  local target_path="$PROJECT_ROOT/$deliverable_path"
+  local stamp
+  stamp="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+
+  [ -n "$deliverable_path" ] && [ "$deliverable_path" != "null" ] || return 0
+  mkdir -p "$(dirname "$target_path")"
+  if [ ! -f "$target_path" ]; then
+    {
+      echo "# Strategy Cadence Recovery Work Package"
+      echo ""
+      echo "- created_at: $stamp"
+      echo "- owner: Planner/COO"
+      echo "- source_decision: $(jq -r '.source_path // "unknown"' <<<"$required_json")"
+      echo "- required_execution_id: $(jq -r '.id // "unknown"' <<<"$required_json")"
+      echo "- status: opened"
+      echo ""
+      echo "## Candidate Idea"
+      echo ""
+      echo "Planner/COO must define one concrete strategy candidate for this hour. A restatement of the goal is not sufficient."
+      echo ""
+      echo "## Data Source"
+      echo ""
+      echo "Name the market data source, lookback window, and any filters used by the candidate."
+      echo ""
+      echo "## Backtest Command"
+      echo ""
+      echo '```bash'
+      echo "# Fill with the exact command that produces a backtest result artifact."
+      echo '```'
+      echo ""
+      echo "## CQO Acceptance"
+      echo ""
+      echo "- PASS requires a generated candidate artifact and a backtest/evaluation artifact."
+      echo "- If no candidate is generated before the next hourly review, classify the cycle as paperwork_only_failure."
+    } > "$target_path"
+  fi
+}
+
 effective_mode="$(normalize_company_mode)"
 ensure_team_queue
 drift_classification="$(infer_drift_classification)"
@@ -260,7 +306,7 @@ elif [ "$parallel_pending_count" -gt 0 ] && [ "$agent_status" = "completed" ] &&
       .conductor.rendezvous = null"
   fi
 
-elif [ "$requested_mode" != "null" ] && [ -n "$requested_mode" ] && [ "$current_agent" != "service-ops" ]; then
+elif [ "$pending_required_execution" != "true" ] && [ "$requested_mode" != "null" ] && [ -n "$requested_mode" ] && [ "$current_agent" != "service-ops" ]; then
   next="service-ops"
   action="spawn:service-ops:${requested_mode}"
 
@@ -292,6 +338,8 @@ 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")
+  required_execution=$(jq -c '.required_execution // null' <<<"$meeting_decision")
+  required_deliverable=$(jq -r '.required_execution.deliverable_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")
@@ -308,10 +356,34 @@ elif [ "$current_agent" = "meeting-manager" ] && [ "$agent_status" = "completed"
     esac
   fi
 
+  if [ "$required_execution" = "null" ]; then
+    case "$owner:$action_type" in
+      planner:continue-current-handoff|planner:execution-plan|cto:continue-current-handoff|cqo:continue-current-handoff|generator-*:continue-current-handoff|evaluator-*:continue-current-handoff)
+        next="meeting-manager"
+        action="convene:followup-review:execution-contract-missing"
+        new_conductor_state="waiting_meeting"
+        new_workflow_stage="followup-review"
+        meeting_prepare=true
+        meeting_filter="
+          .meetings.active = [\"meeting-manager\"] |
+          .meetings.requested_type = \"followup-review\" |
+          .meetings.requested_reason = \"execution-contract-missing\" |
+          .meetings.contract_missing = {
+            \"owner\": \"$owner\",
+            \"action_type\": \"$action_type\",
+            \"source_path\": $(escape_json_string "$source_path"),
+            \"detected_at\": (now | todate)
+          }"
+        ;;
+    esac
+  fi
+
   # v6.2 — Parallel fork: if 2+ tracks, materialize all tracks as running.
   # `next_agent` keeps the first owner only for backward-compatible handoff display;
   # the fork state itself must expose every track as active in the same tick.
-  if [ "$(jq 'length' <<<"$decision_tracks")" -gt 1 ]; then
+  if [ "$action" = "convene:followup-review:execution-contract-missing" ]; then
+    :
+  elif [ "$(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")
@@ -355,6 +427,10 @@ elif [ "$current_agent" = "meeting-manager" ] && [ "$agent_status" = "completed"
       .conductor.rendezvous = $decision_rendezvous |
       .conductor.fork_meeting_id = (.meetings.current_id // null)"
   else
+    if [ "$action_type" = "strategy-cadence-recovery" ]; then
+      ensure_strategy_work_package "$required_execution" "$required_deliverable"
+      owner="planner"
+    fi
     next="$owner"
     action="dispatch:${owner}:${action_type}"
     new_workflow_stage="$(meeting_stage_for_owner "$owner")"
@@ -377,6 +453,7 @@ elif [ "$current_agent" = "meeting-manager" ] && [ "$agent_status" = "completed"
         \"evidence\": $evidence,
         \"drift_classification\": $(escape_json_string "$decision_drift"),
         \"source_path\": $(escape_json_string "$source_path"),
+        \"required_execution\": $required_execution,
         \"tracks\": [],
         \"rendezvous\": null
       } |
@@ -440,7 +517,17 @@ elif [ "$current_agent" = "coo-developer" ] && [ "$agent_status" = "completed" ]
   fi
 
 elif [ "$current_agent" = "cto" ]; then
-  if [ "${cto_hotfixes:-0}" -gt 0 ] || [ "${ops_recommendations:-0}" -gt 0 ]; then
+  cto_step_b_status=$(jq -r '.cto.step_b_status // ""' "$PROGRESS")
+  if [ "$agent_status" = "step-B-code-edited" ] || [[ "$cto_step_b_status" == *deferred* ]]; then
+    next="cqo"
+    action="spawn:cqo:gateway-typecheck-verify"
+    new_workflow_stage="quality-review"
+    meeting_filter='
+      .cqo.requested_mode = "gateway-typecheck-verify" |
+      .meetings.active = ["cqo"] |
+      .meetings.requested_type = null |
+      .meetings.requested_reason = null'
+  elif [ "${cto_hotfixes:-0}" -gt 0 ] || [ "${ops_recommendations:-0}" -gt 0 ]; then
     next="planner"
     action="dispatch:planner:execution-plan"
     new_workflow_stage="coo-replan"
@@ -548,7 +635,13 @@ if [ "$next" = "meeting-manager" ] && [ "$workflow_stage" = "ops-review" ]; then
 fi
 
 worker_dispatches="[]"
-if [ "$new_conductor_state" = "running" ] && [ "$next" != "meeting-manager" ] && [ "$next" != "service-ops" ] && [ "$next" != "archive" ]; then
+if [ "$new_conductor_state" = "running" ] &&
+  [ "$next" != "meeting-manager" ] &&
+  [ "$next" != "service-ops" ] &&
+  [ "$next" != "planner" ] &&
+  [ "$next" != "cto" ] &&
+  [ "$next" != "cqo" ] &&
+  [ "$next" != "archive" ]; then
   worker_dispatches="$(dispatch_company_workers)"
   if jq -e 'type == "array" and length > 0' >/dev/null 2>&1 <<<"$worker_dispatches"; then
     dispatch_count="$(jq 'length' <<<"$worker_dispatches")"

package/scripts/harness-hourly-review.sh

@@ -34,6 +34,7 @@ fi
 
 ts="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 id="M-$(date -u +%Y%m%dT%H%M%SZ)-hourly"
+stamp="$(date -u +%Y%m%dT%H%M%SZ)"
 meeting_dir="$PROJECT_ROOT/.harness/actions/meetings/$id"
 meeting_rel=".harness/actions/meetings/$id/meeting-$id.md"
 meeting_path="$PROJECT_ROOT/$meeting_rel"
@@ -52,6 +53,7 @@ current_agent="$(jq -r '.current_agent // "none"' "$PROGRESS" 2>/dev/null || ech
 next_agent="$(jq -r '.next_agent // "none"' "$PROGRESS" 2>/dev/null || echo none)"
 agent_status="$(jq -r '.agent_status // "unknown"' "$PROGRESS" 2>/dev/null || echo unknown)"
 conductor_state="$(jq -r '.conductor.state // "idle"' "$PROGRESS" 2>/dev/null || echo idle)"
+conductor_action="$(jq -r '.conductor.current_action // "none"' "$PROGRESS" 2>/dev/null || echo none)"
 tick_count="$(jq -r '.conductor.tick_count // 0' "$PROGRESS" 2>/dev/null || echo 0)"
 health_count="$(jq -r '(.service_ops.health // []) | length' "$PROGRESS" 2>/dev/null || echo 0)"
 alert_count="$(jq -r '[.service_ops.health[]? | select(.status == "down" or .status == "degraded")] | length' "$PROGRESS" 2>/dev/null || echo 0)"
@@ -66,11 +68,63 @@ last_meeting="$(jq -r '.meetings.last_review_path // .meetings.current_record_pa
 cqo_audit="$(jq -r '.cqo.audit_path // empty' "$PROGRESS" 2>/dev/null || true)"
 cto_review="$(jq -r '.cto.review_path // empty' "$PROGRESS" 2>/dev/null || true)"
 open_incidents="$(jq -r '(.service_ops.incident.open // []) | length' "$PROGRESS" 2>/dev/null || echo 0)"
+incident_repeat_count="$(jq -r '.service_ops.incident.repeat_count // 0' "$PROGRESS" 2>/dev/null || echo 0)"
+incident_recovery_required="$(jq -r '.service_ops.incident.recovery_required // false' "$PROGRESS" 2>/dev/null || echo false)"
+prev_required_json="$(jq -c '.meetings.decision.required_execution // .meetings.required_execution // null' "$PROGRESS" 2>/dev/null || echo null)"
+prev_required_action="$(jq -r '(.meetings.decision.required_execution // .meetings.required_execution // {}).action // "none"' "$PROGRESS" 2>/dev/null || echo none)"
+prev_required_owner="$(jq -r '(.meetings.decision.required_execution // .meetings.required_execution // {}).owner // "none"' "$PROGRESS" 2>/dev/null || echo none)"
+prev_required_deliverable="$(jq -r '(.meetings.decision.required_execution // .meetings.required_execution // {}).deliverable_path // ""' "$PROGRESS" 2>/dev/null || true)"
+prev_execution_result="none"
+prev_execution_detail="no prior required_execution"
+if [ "$prev_required_json" != "null" ]; then
+  if [ -n "$prev_required_deliverable" ] && [ -f "$PROJECT_ROOT/$prev_required_deliverable" ]; then
+    prev_execution_result="executed_unverified"
+    prev_execution_detail="deliverable exists: $prev_required_deliverable"
+    if [ "$prev_required_action" = "runtime-recovery-runbook" ] && [ "${open_incidents:-0}" -eq 0 ] && [ "$alert_count" -eq 0 ]; then
+      prev_execution_result="executed_and_verified"
+      prev_execution_detail="deliverable exists and Service-Ops has no open incident"
+    fi
+  elif [ "$prev_required_action" = "runtime-recovery-runbook" ] && [ "$(jq -r '.cto.step_b_status // .cto.step_a_status // ""' "$PROGRESS" 2>/dev/null || true)" != "" ]; then
+    prev_execution_result="attempted_blocked"
+    prev_execution_detail="CTO recovery state advanced but required deliverable missing: ${prev_required_deliverable:-unset}"
+  else
+    prev_execution_result="paperwork_only_failure"
+    prev_execution_detail="required deliverable missing: ${prev_required_deliverable:-unset}"
+  fi
+fi
 owner_escalation="false"
+strategy_total_signals=0
+strategy_previous_signals="$(jq -r '.goals.strategy_cadence.total_signals // 0' "$PROGRESS" 2>/dev/null || echo 0)"
+strategy_delta=0
+strategy_status="not_applicable"
+strategy_target_per_hour=0
+strategy_target_per_day=0
+strategy_last_signal="none"
+strategy_required=false
+
+if grep -Eiq 'strategy|algo|backtest|신규.?전략|시간당.?1|일.?6|daily.?6|hourly.?1' "$log_path" "$PROJECT_ROOT/.harness/actions/goals.md" 2>/dev/null; then
+  strategy_required=true
+  strategy_target_per_hour=1
+  strategy_target_per_day=6
+  strategy_total_signals="$(grep -Eic '(^|[|[:space:]])(new-strategy|strategy-generated|algos?_candidate|backtest-jobs?|backtest_enqueue|신규.?전략|전략.?생성)([|[:space:]]|$)' "$log_path" 2>/dev/null || echo 0)"
+  strategy_last_signal="$(grep -Ei '(^|[|[:space:]])(new-strategy|strategy-generated|algos?_candidate|backtest-jobs?|backtest_enqueue|신규.?전략|전략.?생성)([|[:space:]]|$)' "$log_path" 2>/dev/null | tail -1 || true)"
+  [ -n "$strategy_last_signal" ] || strategy_last_signal="none"
+  if [ "$strategy_total_signals" -lt "$strategy_previous_signals" ]; then
+    strategy_previous_signals="$strategy_total_signals"
+  fi
+  strategy_delta=$((strategy_total_signals - strategy_previous_signals))
+  if [ "$strategy_delta" -ge "$strategy_target_per_hour" ]; then
+    strategy_status="on_track"
+  else
+    strategy_status="behind_goal"
+  fi
+fi
 
 verdict="working"
 if [ "$alert_count" -gt 0 ]; then
   verdict="incident"
+elif [ "$strategy_required" = "true" ] && [ "$strategy_status" = "behind_goal" ]; then
+  verdict="goal_drift"
 elif [ "$conductor_state" = "escalated" ]; then
   verdict="owner_needed"
 elif [ "$conductor_state" = "waiting_owner" ]; then
@@ -83,6 +137,25 @@ meeting_type="standup"
 decision_owner="planner"
 decision_action="execution-plan"
 decision_rationale="정기 회의에서 active GOAL 대비 현재 작업과 운영 신호를 재정렬하고 다음 work package를 명확히 한다."
+progress_meaningful_json='[]'
+required_execution_json='null'
+handoff_requires_execution=false
+handoff_feature="$(printf "%s" "$conductor_action" | awk -F: '{print $NF}')"
+case "$handoff_feature" in
+  ""|none|null|pass-through|monitor|completed|running|ready|execution-plan|continue-current-handoff|goal-alignment)
+    handoff_feature="$stamp"
+    ;;
+esac
+safe_handoff_feature="$(printf "%s" "$handoff_feature" | tr -cs 'A-Za-z0-9._-' '-' | sed 's/^-//; s/-$//')"
+[ -n "$safe_handoff_feature" ] || safe_handoff_feature="$stamp"
+
+case "$next_agent" in
+  planner|cto|cqo|generator-*|evaluator-*|documentationer|coo-developer)
+    if [ "$next_agent" != "$current_agent" ] || [[ "$conductor_action" == *handoff* ]] || [[ "$conductor_action" == advance:* ]] || [[ "$conductor_action" == spawn:* ]] || [[ "$conductor_action" == dispatch:* ]]; then
+      handoff_requires_execution=true
+    fi
+    ;;
+esac
 case "$next_agent" in
   planner|cto|cqo|service-ops|dispatcher)
     decision_owner="$next_agent"
@@ -93,13 +166,56 @@ esac
 if [ "$verdict" = "incident" ]; then
   meeting_type="incident-war-room"
   decision_owner="cto"
-  decision_action="runtime-recovery"
-  decision_rationale="Service-Ops가 down/degraded 신호를 발견했으므로 CTO가 복구 경로를 정하고 CQO가 복구 evidence를 검증한다."
+  if [ "$incident_recovery_required" = "true" ] || [ "${incident_repeat_count:-0}" -ge 2 ]; then
+    decision_action="runtime-recovery-runbook"
+    decision_rationale="동일 운영 장애가 ${incident_repeat_count}회 연속 감지됐다. 반복 회의가 아니라 CTO가 복구 runbook을 실행하고 CQO가 evidence를 검증한다."
+    progress_meaningful_json='["runtime-recovery-runbook required"]'
+    required_execution_json="$(jq -n --arg id "RE-$stamp-runtime-recovery" --arg source "$meeting_rel" '{
+      id:$id,
+      owner:"cto",
+      action:"runtime-recovery-runbook",
+      deliverable_path:".harness/actions/cto-runbook-runtime-recovery-current.md",
+      verifier:"cqo+service-ops",
+      due:"next_tick",
+      source_path:$source,
+      success_condition:"Service-Ops verifies every configured production service as ok; partial recovery remains incident."
+    }')"
+  else
+    decision_action="runtime-recovery"
+    decision_rationale="Service-Ops가 down/degraded 신호를 발견했으므로 CTO가 복구 경로를 정하고 CQO가 복구 evidence를 검증한다."
+    progress_meaningful_json='["runtime-recovery decision"]'
+    required_execution_json="$(jq -n --arg id "RE-$stamp-runtime-recovery" --arg source "$meeting_rel" '{
+      id:$id,
+      owner:"cto",
+      action:"runtime-recovery",
+      deliverable_path:".harness/actions/cto-action-runtime-recovery-current.md",
+      verifier:"service-ops",
+      due:"next_tick",
+      source_path:$source,
+      success_condition:"Service-Ops health improves or records a concrete blocker."
+    }')"
+  fi
 elif [ "$verdict" = "idle" ] || [ "$verdict" = "autonomous_review" ]; then
   meeting_type="followup-review"
   decision_owner="planner"
   decision_action="goal-alignment"
   decision_rationale="Owner 대기 없이 CEO/COO/CTO/CQO/Service-Ops가 GOAL 대비 다음 work package를 재정렬한다."
+elif [ "$verdict" = "goal_drift" ]; then
+  meeting_type="spec-review"
+  decision_owner="planner"
+  decision_action="strategy-cadence-recovery"
+  decision_rationale="전략 생성 cadence가 목표보다 뒤처졌다. COO가 다음 시간의 전략 후보 생성/백테스트 work package를 즉시 재배정한다."
+  progress_meaningful_json='["strategy cadence recovery decision"]'
+  required_execution_json="$(jq -n --arg id "RE-$stamp-strategy-cadence" --arg source "$meeting_rel" --arg deliverable ".harness/actions/strategy-work-package-${stamp}.md" '{
+    id:$id,
+    owner:"planner",
+    action:"create-strategy-work-package",
+    deliverable_path:$deliverable,
+    verifier:"cqo",
+    due:"next_tick",
+    source_path:$source,
+    success_condition:"A strategy work package exists with candidate idea, data source, backtest command, and CQO acceptance criteria."
+  }')"
 elif [ "$verdict" = "owner_needed" ]; then
   meeting_type="all-hands"
   decision_owner="dispatcher"
@@ -108,6 +224,82 @@ elif [ "$verdict" = "owner_needed" ]; then
   owner_escalation="true"
 fi
 
+if [ "$verdict" = "working" ] && [ "$handoff_requires_execution" = "true" ]; then
+  decision_owner="$next_agent"
+  case "$next_agent" in
+    planner)
+      decision_action="execution-plan"
+      deliverable_path=".harness/actions/planner-execution-plan-${safe_handoff_feature}.md"
+      verifier="cto+cqo"
+      success_condition="Planner creates a concrete execution plan that reconciles the current handoff with GOAL, queue priority, non-goals, owner, and verifier."
+      ;;
+    cto)
+      decision_action="technical-handoff"
+      deliverable_path=".harness/actions/cto-action-${safe_handoff_feature}.md"
+      verifier="cqo"
+      success_condition="CTO records implementation scope, affected files, validation commands, blocker status, and the next execution owner."
+      ;;
+    cqo)
+      decision_action="quality-verification"
+      deliverable_path=".harness/actions/cqo-audit-${safe_handoff_feature}.md"
+      verifier="meeting-manager"
+      success_condition="CQO records PASS/FAIL with evidence, regressions, and the next routing decision."
+      ;;
+    generator-*)
+      decision_action="implement-${safe_handoff_feature}"
+      deliverable_path=".harness/actions/gen-report-${safe_handoff_feature}.md"
+      verifier="cqo+evaluator-code-quality"
+      success_condition="Generator produces the named implementation report, changed-file list, validation output, and handoff to CQO/evaluator."
+      ;;
+    evaluator-*)
+      decision_action="verify-${safe_handoff_feature}"
+      deliverable_path=".harness/actions/evaluation-${safe_handoff_feature}.md"
+      verifier="cqo"
+      success_condition="Evaluator writes an evidence-backed PASS/FAIL report and does not rubber-stamp missing evidence."
+      ;;
+    documentationer)
+      decision_action="document-${safe_handoff_feature}"
+      deliverable_path=".harness/actions/documentation-${safe_handoff_feature}.md"
+      verifier="planner"
+      success_condition="Documentationer writes the requested brief/report with source paths and decision impact."
+      ;;
+    coo-developer)
+      decision_action="spike-${safe_handoff_feature}"
+      deliverable_path=".harness/actions/hypothesis/${safe_handoff_feature}/spike/report.md"
+      verifier="planner+cqo"
+      success_condition="COO developer records spike result, repro/evidence, and verdict input for Planner."
+      ;;
+    *)
+      decision_action="execute-${safe_handoff_feature}"
+      deliverable_path=".harness/actions/execution-${safe_handoff_feature}.md"
+      verifier="meeting-manager"
+      success_condition="The owner writes a concrete deliverable and next-step evidence before the following hourly review."
+      ;;
+  esac
+  decision_rationale="working 상태라도 현재 handoff는 산출물 없는 '계속 진행'으로 통과할 수 없다. 다음 tick까지 owner가 deliverable을 남기고 verifier가 검증한다."
+  progress_meaningful_json="$(jq -n --arg item "execution contract required: $next_agent/$decision_action" '[$item]')"
+  required_execution_json="$(jq -n \
+    --arg id "RE-$stamp-handoff" \
+    --arg owner "$decision_owner" \
+    --arg action "$decision_action" \
+    --arg deliverable "$deliverable_path" \
+    --arg verifier "$verifier" \
+    --arg source "$meeting_rel" \
+    --arg success "$success_condition" \
+    --arg conductor_action "$conductor_action" \
+    '{
+      id:$id,
+      owner:$owner,
+      action:$action,
+      deliverable_path:$deliverable,
+      verifier:$verifier,
+      due:"next_tick",
+      source_path:$source,
+      source_conductor_action:$conductor_action,
+      success_condition:$success
+    }')"
+fi
+
 decision_json="$(jq -n \
   --arg owner "$decision_owner" \
   --arg action_type "$decision_action" \
@@ -117,6 +309,8 @@ decision_json="$(jq -n \
   --arg ops_report "$ops_report" \
   --arg cqo_audit "$cqo_audit" \
   --arg cto_review "$cto_review" \
+  --argjson progress_meaningful "$progress_meaningful_json" \
+  --argjson required_execution "$required_execution_json" \
   --argjson owner_escalation "$owner_escalation" '
   {
     owner: $owner,
@@ -132,6 +326,11 @@ decision_json="$(jq -n \
     drift_classification: $drift,
     source_path: $source,
     owner_escalation: $owner_escalation,
+    progress_classification: {
+      meaningful_actions: $progress_meaningful,
+      paperwork_only: ["hourly-review", "service-ops-monitor"]
+    },
+    required_execution: $required_execution,
     tracks: [],
     rendezvous: null
   }')"
@@ -165,6 +364,9 @@ meeting_json="$(jq -n \
   echo "- drift_classification: $drift"
   echo "- previous_decision: $last_decision"
   echo "- previous_meeting: $last_meeting"
+  echo "- previous_required_execution: $prev_required_owner/$prev_required_action"
+  echo "- previous_execution_result: $prev_execution_result"
+  echo "- previous_execution_detail: $prev_execution_detail"
   if [ -n "$ops_report" ]; then
     echo "- service_ops_report: $ops_report"
   fi
@@ -175,6 +377,21 @@ meeting_json="$(jq -n \
     echo "- cqo_audit: $cqo_audit"
   fi
   echo ""
+  echo "## Progress Classification"
+  echo ""
+  echo "- previous_required_execution_result: $prev_execution_result"
+  echo "- previous_required_execution_detail: $prev_execution_detail"
+  if [ "$verdict" = "incident" ] && { [ "$incident_recovery_required" = "true" ] || [ "${incident_repeat_count:-0}" -ge 2 ]; }; then
+    echo "- meaningful_actions: runtime-recovery-runbook required"
+    echo "- paperwork_only: hourly meeting minutes, Service-Ops monitor report"
+  elif [ "$verdict" = "goal_drift" ]; then
+    echo "- meaningful_actions: strategy cadence recovery decision"
+    echo "- paperwork_only: hourly meeting minutes, Service-Ops monitor report"
+  else
+    echo "- meaningful_actions: none detected in this deterministic batch until conductor/agent tick records execution"
+    echo "- paperwork_only: hourly meeting minutes, Service-Ops monitor report"
+  fi
+  echo ""
   echo "## Role Briefs"
   echo ""
   echo "### Dispatcher/CEO"
@@ -214,6 +431,12 @@ meeting_json="$(jq -n \
   echo "- warnings: $warn_count"
   echo "- alerts: $alert_count"
   echo "- open_incidents: $open_incidents"
+  echo "- incident_repeat_count: $incident_repeat_count"
+  echo "- incident_recovery_required: $incident_recovery_required"
+  if [ "$strategy_required" = "true" ]; then
+    echo "- strategy_cadence: $strategy_status (delta=$strategy_delta, total_signals=$strategy_total_signals, target_per_hour=$strategy_target_per_hour, target_per_day=$strategy_target_per_day)"
+    echo "- last_strategy_signal: $strategy_last_signal"
+  fi
   echo "- 판단: 운영 신호를 회의에 제출하고, 장애 시 incident-war-room을 요구한다."
   echo ""
   if [ "$health_count" -gt 0 ]; then
@@ -234,11 +457,22 @@ meeting_json="$(jq -n \
   case "$verdict" in
     incident)
       echo "- Service-Ops: down/degraded 서비스가 있으므로 feature work보다 장애 triage가 우선이다."
-      echo "- CTO: 복구 절차, 재시작, 설정 누락, 포트 충돌 중 원인을 좁히고 runtime-recovery work item을 받는다."
+      if [ "$incident_recovery_required" = "true" ] || [ "${incident_repeat_count:-0}" -ge 2 ]; then
+        echo "- CTO: 같은 장애가 반복됐으므로 추가 회의가 아니라 runtime-recovery-runbook 실행으로 전환한다."
+      else
+        echo "- CTO: 복구 절차, 재시작, 설정 누락, 포트 충돌 중 원인을 좁히고 runtime-recovery work item을 받는다."
+      fi
       echo "- CQO: 복구 완료 주장은 health check와 재현 가능한 evidence 없이는 PASS로 보지 않는다."
       echo "- COO: 장애 복구가 GOAL 진행을 막는 범위를 queue에 반영한다."
       echo "- CEO: Owner에게 묻지 않고 내부 복구 루프를 진행한다. 단 GOAL 변경이 필요하면 별도 escalation한다."
       ;;
+    goal_drift)
+      echo "- CEO: Owner가 없어도 최초 GOAL의 KPI를 기준으로 회사 루프를 평가한다."
+      echo "- COO: 전략 생성/백테스트 cadence가 목표보다 낮으므로 다음 work package를 전략 후보 생성으로 고정한다."
+      echo "- CTO: 필요한 데이터/실행 경로가 막혔는지 점검한다."
+      echo "- CQO: 후보 전략은 backtest evidence 없이는 유의미 진척으로 인정하지 않는다."
+      echo "- Service-Ops: 운영 장애가 cadence 저하 원인인지 계속 감시한다."
+      ;;
     owner_needed)
       echo "- CEO: conductor escalation의 원인이 내부 해결 가능한지 우선 판정한다."
       echo "- COO/CTO/CQO/Service-Ops: 각자 해결 가능한 내부 action을 제시하고, 불가능할 때만 Owner escalation을 유지한다."
@@ -272,6 +506,11 @@ meeting_json="$(jq -n \
       echo "- Service-Ops: 복구 후 monitor를 다시 돌려 last_check와 health evidence를 갱신한다."
       echo "- CQO: 복구 evidence를 검증하고 regression risk를 기록한다."
       ;;
+    goal_drift)
+      echo "- Planner/COO: 다음 autonomous tick에서 전략 후보 생성/백테스트 work package를 발급한다."
+      echo "- CTO: 전략 실행 경로와 데이터 의존성 차단 여부를 점검한다."
+      echo "- CQO: backtest 결과가 없는 후보를 유의미 진척으로 집계하지 않는다."
+      ;;
     idle|autonomous_review)
       echo "- Planner/COO: Owner 대기 없이 active GOAL 기준 다음 work package를 정의한다."
       echo "- Conductor: meeting decision을 읽고 다음 부서를 자동 배정한다."
@@ -280,9 +519,34 @@ meeting_json="$(jq -n \
       echo "- Conductor: 다음 autonomous tick에서 decision.owner/action_type 기준으로 handoff한다."
       ;;
   esac
+  echo ""
+  echo "## Required Execution"
+  echo ""
+  if [ "$required_execution_json" = "null" ]; then
+    echo "- none"
+  else
+    jq -r '"- owner: \(.owner)\n- action: \(.action)\n- deliverable_path: \(.deliverable_path)\n- verifier: \(.verifier)\n- due: \(.due)\n- success_condition: \(.success_condition)"' <<<"$required_execution_json"
+  fi
 } > "$meeting_path"
 
-jq --arg ts "$ts" --arg id "$id" --arg rel "$meeting_rel" --arg verdict "$verdict" --arg type "$meeting_type" --argjson decision "$decision_json" '
+jq \
+  --arg ts "$ts" \
+  --arg id "$id" \
+  --arg rel "$meeting_rel" \
+  --arg verdict "$verdict" \
+  --arg type "$meeting_type" \
+  --arg strategy_status "$strategy_status" \
+  --arg strategy_last_signal "$strategy_last_signal" \
+  --arg prev_execution_result "$prev_execution_result" \
+  --arg prev_execution_detail "$prev_execution_detail" \
+  --argjson strategy_required "$strategy_required" \
+  --argjson strategy_target_per_hour "$strategy_target_per_hour" \
+  --argjson strategy_target_per_day "$strategy_target_per_day" \
+  --argjson strategy_total_signals "$strategy_total_signals" \
+  --argjson strategy_previous_signals "$strategy_previous_signals" \
+  --argjson strategy_delta "$strategy_delta" \
+  --argjson incident_recovery_required "$incident_recovery_required" \
+  --argjson decision "$decision_json" '
 	  .meetings.last_type = "hourly-review" |
 	  .meetings.last_reason = $verdict |
 	  .meetings.last_review_at = $ts |
@@ -291,7 +555,22 @@ jq --arg ts "$ts" --arg id "$id" --arg rel "$meeting_rel" --arg verdict "$verdic
 	  .meetings.current_record_path = $rel |
 	  .meetings.last_attendees = ["dispatcher","planner","cto","cqo","service-ops","meeting-manager"] |
 	  .meetings.decision = $decision |
-	  if $verdict == "incident" or $verdict == "autonomous_review" or $verdict == "idle"
+	  .meetings.previous_required_execution_result = $prev_execution_result |
+	  .meetings.previous_required_execution_detail = $prev_execution_detail |
+	  .meetings.required_execution = $decision.required_execution |
+	  .goals.strategy_cadence = {
+	    "required": $strategy_required,
+	    "status": $strategy_status,
+	    "target_per_hour": $strategy_target_per_hour,
+	    "target_per_day": $strategy_target_per_day,
+	    "total_signals": $strategy_total_signals,
+	    "previous_total_signals": $strategy_previous_signals,
+	    "delta_since_last_review": $strategy_delta,
+	    "last_signal": $strategy_last_signal,
+	    "last_check": $ts
+	  } |
+	  .service_ops.incident.recovery_required = $incident_recovery_required |
+	  if $verdict == "incident" or $verdict == "autonomous_review" or $verdict == "idle" or $verdict == "goal_drift"
 	  then .meetings.active = ((.meetings.active // []) + ["meeting-manager","dispatcher","planner","cto","cqo","service-ops"] | unique) |
 	       .meetings.requested_type = (.meetings.requested_type // $type) |
 	       .meetings.requested_reason = (.meetings.requested_reason // $verdict)