okstra 0.214.1 → 0.216.0

package/runtime/python/okstra_ctl/convergence_engine.py

@@ -13,7 +13,8 @@ WORKING_SCHEMA_VERSION = "1.0"
 V2_WORKING_SCHEMA_VERSION = "2.0"
 EXECUTION_IDENTITY_VERSION = 2
 FINAL_SCHEMA_VERSION = "1.4"
-_AUDIENCES = {"analysis", "lead", "report-writer"}
+# `critic` 은 발견을 내지 않고, 분석 워커 표가 원저자 표와 동률일 때만 투표한다.
+_AUDIENCES = {"analysis", "lead", "report-writer", "critic"}
 # 발견을 낼 수 있는 audience. 리드는 계약상 Phase 6 자체 리뷰를 수행하므로
 # 출처가 될 수 있지만, 교차검증 표는 아니다 — 합의 수는 아래에서 분석 워커만
 # 센다. 리드를 분석 워커로 위장 선언하는 것을 계약이 금지하는 이상, 리드의
@@ -23,6 +24,7 @@ _AUDIENCE_SOURCE_ROLES = {
     "analysis": frozenset({"analyser", "designer", "planner", "verifier"}),
     "lead": frozenset({"leader"}),
     "report-writer": frozenset({"report-writer"}),
+    "critic": frozenset({"critic"}),
 }
 _VERIFICATION_MODES = {"lightweight", "full-reanalysis"}
 # `unverified` 가 없던 시절의 산출물. `reuse-final` 이 그대로 읽으므로 그
@@ -73,6 +75,16 @@ FINALIZE_PLAN_NOTE = (
 )
 
 
+# 원저자 표를 더한 다수결이 갈리지 않은 라운드. 분류 값이 아니라 크리틱에게
+# 넘길지 정하는 내부 표지다.
+TIE = "tie"
+
+_COLLABORATIVE_REMOVED = (
+    "config.adversarial is false: collaborative convergence was removed and every "
+    "phase verifies adversarially; regroup with `okstra convergence prepare-groups`"
+)
+
+
 class ConvergenceContractError(ValueError):
     """Raised when convergence input violates the persisted-state contract."""
 
@@ -112,6 +124,12 @@ def seed_working_state(
         for worker in workers
         if worker["audience"] in _FINDING_SOURCE_AUDIENCES
     ]
+    critics = [worker["workerId"] for worker in workers if worker["audience"] == "critic"]
+    if len(critics) > 1:
+        raise ConvergenceContractError(
+            f"at most one critic worker may break ties: {', '.join(critics)}"
+        )
+    config["tieBreaker"] = critics[0] if critics else None
     state = {
         "schemaVersion": source["schemaVersion"],
         "taskKey": task_key,
@@ -201,6 +219,12 @@ def plan_next_round(state: Mapping[str, Any]) -> dict[str, Any]:
     workers = current.get("workers")
     if not isinstance(workers, list):
         raise ConvergenceContractError("working state.workers must be an array")
+    tie_breaker = config.get("tieBreaker")
+    awaiting_tie_break = [
+        finding_id
+        for finding_id in queue
+        if _finding_outcome(findings[finding_id].get("rounds") or [], tie_breaker)[1]
+    ]
     dispatches: list[dict[str, Any]] = []
     skipped: list[dict[str, str]] = []
     for worker in workers:
@@ -210,7 +234,8 @@ def plan_next_round(state: Mapping[str, Any]) -> dict[str, Any]:
         eligible = [
             finding_id
             for finding_id in queue
-            if _worker_is_independent_from_finding(
+            if finding_id not in awaiting_tie_break
+            and _worker_is_independent_from_finding(
                 worker, findings[finding_id], workers
             )
         ]
@@ -228,6 +253,17 @@ def plan_next_round(state: Mapping[str, Any]) -> dict[str, Any]:
                     "reason": "no items to verify",
                 }
             )
+    if awaiting_tie_break:
+        critic = next(
+            worker
+            for worker in workers
+            if isinstance(worker, Mapping) and worker.get("workerId") == tie_breaker
+        )
+        dispatches.append({
+            **_worker_execution_refs(critic),
+            "worker": tie_breaker,
+            "findingIds": awaiting_tie_break,
+        })
     return {
         "schemaVersion": WORKING_SCHEMA_VERSION,
         "action": "dispatch",
@@ -292,25 +328,6 @@ def _worker_execution_refs(worker: Mapping[str, Any]) -> dict[str, str]:
     }
 
 
-def classify_collaborative_round(
-    votes: Mapping[str, Mapping[str, Any]],
-) -> str | None:
-    """Classify one collaborative round using non-error votes only."""
-    parsed = _parsed_votes(votes, adversarial=False)
-    usable = [vote for vote in parsed.values() if vote["verdict"] != "verification-error"]
-    if not usable:
-        return None
-    agreeing = sum(vote["verdict"] in {"agree", "supplement"} for vote in usable)
-    disagreeing = sum(vote["verdict"] == "disagree" for vote in usable)
-    if agreeing == len(usable):
-        return "full-consensus"
-    if disagreeing == len(usable):
-        return "worker-unique"
-    if agreeing > len(usable) / 2:
-        return "partial-consensus"
-    return None
-
-
 def classify_adversarial_round(
     votes: Mapping[str, Mapping[str, Any]],
 ) -> str | None:
@@ -343,6 +360,65 @@ def classify_adversarial_round(
     return "partial-consensus"
 
 
+def classify_finding_round(
+    votes: Mapping[str, Mapping[str, Any]],
+) -> str | None:
+    """원저자를 SURVIVES 1표로 세어 finding 의 한 라운드를 분류한다.
+
+    검증자 표만 세면 검증자 둘이 1:1 로 갈릴 때 과반이 없다. 원저자는 자기 발견을
+    유지하는 쪽이므로 그 표를 더해 다수결을 낸다. 동률은 `TIE` 다.
+    """
+    parsed = _parsed_votes(votes, adversarial=True)
+    usable = [vote for vote in parsed.values() if vote["verdict"] != "verification-error"]
+    if not usable:
+        return None
+    disagrees = [vote for vote in usable if vote["verdict"] == "disagree"]
+    if any(vote["disagreeBasis"] == "counter-evidence" for vote in disagrees):
+        return "contested"
+    survives = 1 + len(usable) - len(disagrees)
+    if survives > len(disagrees):
+        if disagrees:
+            return "partial-consensus"
+        caveats = sum(vote["verdict"] == "supplement" for vote in usable)
+        return "partial-consensus" if caveats > len(usable) / 2 else "full-consensus"
+    if len(disagrees) > survives:
+        return "worker-unique"
+    return TIE
+
+
+def _finding_outcome(
+    rounds: list[Any],
+    tie_breaker: str | None,
+) -> tuple[str | None, bool]:
+    """finding 의 라운드 기록이 확정한 분류와, 크리틱의 동률 판정을 기다리는지.
+
+    동률 라운드의 표는 다음 라운드(크리틱 한 표)와 합쳐 다시 센다. 크리틱이
+    로스터에 없으면 동률은 그 라운드에서 `contested` 로 끝난다 — 같은 분석
+    워커에게 다시 물어도 새 정보가 없다.
+    """
+    rows = [
+        row
+        for row in rounds
+        if isinstance(row, Mapping) and isinstance(row.get("votes"), Mapping)
+    ]
+    pending: dict[str, Any] = {}
+    for index, row in enumerate(rows):
+        votes = {**pending, **row["votes"]}
+        classification = classify_finding_round(votes)
+        if classification is None:
+            continue
+        if classification == TIE:
+            if tie_breaker is None:
+                classification = "contested"
+            else:
+                pending = votes
+                continue
+        if classification == "contested" and index < len(rows) - 1:
+            return _legacy_adversarial_history(rows), False
+        return classification, False
+    return None, bool(pending)
+
+
 def _round_has_counter_evidence(
     votes: Mapping[str, Mapping[str, Any]],
 ) -> bool:
@@ -356,12 +432,12 @@ def _round_has_counter_evidence(
 
 def _classify_adversarial_history(
     rounds: list[Mapping[str, Any]],
+    tie_breaker: str | None = None,
 ) -> str | None:
     """적대적 라운드 기록을 읽어 확정된 분류를 돌려준다.
 
-    분류를 낸 첫 라운드에서 멈춘다. `counter-evidence` 반증이 만드는
-    `contested` 도 그 라운드에서 종결이다 — 반증이 영구적이므로 다음 라운드는
-    같은 표를 다시 받을 뿐이다.
+    분류를 낸 첫 라운드에서 멈춘다. `counter-evidence` 반증이 만드는 `contested`
+    도 그 라운드에서 종결이다 — 같은 검증자에게 다시 물어도 새 정보가 없다.
 
     예외는 구 엔진이 남긴 상태 하나다. 구 엔진은 counter-evidence 를 마지막
     라운드까지 끌고 갔고, 그 뒤로는 만장일치 반대(`worker-unique`)만 인정했다.
@@ -369,19 +445,7 @@ def _classify_adversarial_history(
     지문이다 — 현 엔진에서는 거기서 큐를 떠나므로 뒤 라운드가 생기지 않는다.
     그때만 구 규칙으로 이어 읽어, 이미 기록된 세션을 소급해 실패시키지 않는다.
     """
-    rows = [
-        row
-        for row in rounds
-        if isinstance(row, Mapping) and isinstance(row.get("votes"), Mapping)
-    ]
-    for index, row in enumerate(rows):
-        classification = classify_adversarial_round(row["votes"])
-        if classification is None:
-            continue
-        if classification == "contested" and index < len(rows) - 1:
-            return _legacy_adversarial_history(rows)
-        return classification
-    return None
+    return _finding_outcome(rounds, tie_breaker)[0]
 
 
 def _legacy_adversarial_history(
@@ -449,7 +513,6 @@ def apply_round_results(
     updated = deepcopy(dict(current))
     queue = list(updated["queueFindingIds"])
     findings = {row["findingId"]: row for row in updated["findings"]}
-    adversarial = bool(updated["config"].get("adversarial"))
     resolved: list[str] = []
     for finding_id in queue:
         finding = findings[finding_id]
@@ -458,15 +521,13 @@ def apply_round_results(
             planned_by_finding,
             statuses,
             votes_by_finding,
-            adversarial,
+            True,
         )
         finding["rounds"].append(
             {"round": expected_plan["round"], "votes": round_votes}
         )
-        classification = (
-            _classify_adversarial_history(finding["rounds"])
-            if adversarial
-            else classify_collaborative_round(round_votes)
+        classification = _classify_adversarial_history(
+            finding["rounds"], updated["config"].get("tieBreaker")
         )
         if classification is not None:
             finding["classification"] = classification
@@ -659,17 +720,11 @@ def finalize_working_state(state: Mapping[str, Any]) -> dict[str, Any]:
     config = deepcopy(current["config"])
     findings = deepcopy(current["findings"])
     queue = set(current["queueFindingIds"])
-    adversarial = bool(config.get("adversarial"))
     for finding in findings:
         if finding["findingId"] not in queue:
             continue
-        if _received_no_verdict(finding):
-            finding["classification"] = "unverified"
-            continue
         finding["classification"] = (
-            "contested"
-            if adversarial
-            else _final_collaborative_classification(finding)
+            "unverified" if _received_no_verdict(finding) else "contested"
         )
     stop_reason = current.get("stopReason")
     history = deepcopy(current["roundHistory"])
@@ -923,6 +978,12 @@ def validate_final_state(state: Mapping[str, Any]) -> list[str]:
         history = []
     errors.extend(_validate_round_history(history))
     adversarial = bool(config.get("adversarial"))
+    if not adversarial and history:
+        errors.append(_COLLABORATIVE_REMOVED)
+    tie_breaker = config.get("tieBreaker")
+    if tie_breaker is not None and not _nonempty_string(tie_breaker):
+        errors.append("config.tieBreaker must be a worker ID or null")
+        tie_breaker = None
     historical = version in _HISTORICAL_FINAL_VERSIONS
     allowed_classifications = set(_CLASSIFICATION_COUNT_KEYS)
     if historical:
@@ -949,23 +1010,25 @@ def validate_final_state(state: Mapping[str, Any]) -> list[str]:
         # 라운드 안에서 확정된 `contested`(증거 기반 반증)는 다르다 — 그때 큐를
         # 떠나므로 뒤 라운드 기록이 없는 것이 정상이다.
         settled_in_round = (
-            adversarial and _round_settled_classification(rounds) is not None
+            _round_settled_classification(rounds, tie_breaker) is not None
         )
         unresolved = classification in {"contested", "unverified"}
         if unresolved and rounds and not settled_in_round:
             if rounds[-1].get("round") != len(history):
                 errors.append(f"finding {finding_id} contested before the final round")
         if not unresolved:
-            errors.extend(_validate_no_reappearance_after_resolution(finding, adversarial))
+            errors.extend(
+                _validate_no_reappearance_after_resolution(finding, tie_breaker)
+            )
         expected = _expected_final_classification(
-            finding, adversarial, historical=historical
+            finding, tie_breaker, historical=historical
         )
         if expected is not None and classification != expected:
             errors.append(
                 f"finding {finding_id} classification {classification} "
                 f"does not match replayed classification {expected}"
             )
-    errors.extend(_validate_round_ledger_counts(findings, history, adversarial))
+    errors.extend(_validate_round_ledger_counts(findings, history, tie_breaker))
     total_rounds = state.get("totalRounds")
     if total_rounds != len(history):
         errors.append("totalRounds does not match roundHistory length")
@@ -1852,22 +1915,15 @@ def _received_no_verdict(finding: Mapping[str, Any]) -> bool:
     return seen
 
 
-def _final_collaborative_classification(finding: Mapping[str, Any]) -> str:
-    usable: list[Mapping[str, Any]] = []
-    for round_row in finding.get("rounds", []):
-        for vote in round_row.get("votes", {}).values():
-            if vote.get("verdict") != "verification-error":
-                usable.append(vote)
-    agreeing = sum(vote.get("verdict") in {"agree", "supplement"} for vote in usable)
-    return "partial-consensus" if usable and agreeing > len(usable) / 2 else "contested"
-
-
-def _round_settled_classification(rounds: list[Any]) -> str | None:
+def _round_settled_classification(
+    rounds: list[Any],
+    tie_breaker: str | None,
+) -> str | None:
     """라운드 기록만으로 확정된 적대적 분류. finalize 가 찍은 값과 구별한다."""
     if not isinstance(rounds, list) or not rounds:
         return None
     try:
-        return _classify_adversarial_history(rounds)
+        return _classify_adversarial_history(rounds, tie_breaker)
     except ConvergenceContractError:
         # 표 자체가 계약 위반이면 그 사실은 `_validate_finding_ledger` 가 이미
         # 별도 오류로 낸다. 여기서는 "라운드 안에서 확정되지 않았다"로만 읽는다.
@@ -1876,7 +1932,7 @@ def _round_settled_classification(rounds: list[Any]) -> str | None:
 
 def _expected_final_classification(
     finding: Mapping[str, Any],
-    adversarial: bool,
+    tie_breaker: str | None,
     *,
     historical: bool = False,
 ) -> str | None:
@@ -1885,27 +1941,16 @@ def _expected_final_classification(
         return "unverified"
     if not isinstance(rounds, list) or not rounds:
         return None
-    if adversarial:
-        try:
-            return _classify_adversarial_history(rounds) or "contested"
-        except ConvergenceContractError:
-            return "contested"
-    for row in rounds:
-        if not isinstance(row, Mapping) or not isinstance(row.get("votes"), Mapping):
-            continue
-        try:
-            resolved = classify_collaborative_round(row["votes"])
-        except ConvergenceContractError:
-            continue
-        if resolved is not None:
-            return resolved
-    return _final_collaborative_classification(finding)
+    try:
+        return _classify_adversarial_history(rounds, tie_breaker) or "contested"
+    except ConvergenceContractError:
+        return "contested"
 
 
 def _validate_round_ledger_counts(
     findings: list[Any],
     history: list[Any],
-    adversarial: bool,
+    tie_breaker: str | None,
 ) -> list[str]:
     errors: list[str] = []
     for round_number, history_row in enumerate(history, start=1):
@@ -1919,9 +1964,9 @@ def _validate_round_ledger_counts(
         accepted = {
             (len(ledgers), resolved, len(ledgers) - resolved)
             for resolved in {
-                _resolved_ledger_count(findings, round_number, adversarial),
+                _resolved_ledger_count(findings, round_number, tie_breaker),
                 _resolved_ledger_count(
-                    findings, round_number, adversarial, legacy=True
+                    findings, round_number, tie_breaker, legacy=True
                 ),
             }
         }
@@ -1960,7 +2005,7 @@ def _round_ledgers(
 def _resolved_ledger_count(
     findings: list[Any],
     round_number: int,
-    adversarial: bool,
+    tie_breaker: str | None,
     *,
     legacy: bool = False,
 ) -> int:
@@ -1985,12 +2030,12 @@ def _resolved_ledger_count(
         if not isinstance(votes, Mapping):
             continue
         try:
-            if not adversarial:
-                classification = classify_collaborative_round(votes)
-            elif legacy:
+            if legacy:
                 classification = _legacy_adversarial_history(current_rounds)
             else:
-                classification = _classify_adversarial_history(current_rounds)
+                classification = _classify_adversarial_history(
+                    current_rounds, tie_breaker
+                )
         except ConvergenceContractError:
             continue
         resolved += classification is not None
@@ -2071,7 +2116,7 @@ def _validate_finding_ledger(
 
 def _validate_no_reappearance_after_resolution(
     finding: Mapping[str, Any],
-    adversarial: bool,
+    tie_breaker: str | None,
 ) -> list[str]:
     rounds = finding.get("rounds")
     if not isinstance(rounds, list):
@@ -2081,10 +2126,8 @@ def _validate_no_reappearance_after_resolution(
         if not isinstance(votes, Mapping):
             continue
         try:
-            classification = (
-                _classify_adversarial_history(rounds[: index + 1])
-                if adversarial
-                else classify_collaborative_round(votes)
+            classification = _classify_adversarial_history(
+                rounds[: index + 1], tie_breaker
             )
         except ConvergenceContractError:
             continue
@@ -2438,6 +2481,8 @@ def _parse_config(value: Any) -> dict[str, Any]:
     mode = _required_string(config, "verificationMode", "config")
     if mode not in _VERIFICATION_MODES:
         raise ConvergenceContractError("config.verificationMode is unsupported")
+    if enabled and not adversarial:
+        raise ConvergenceContractError(_COLLABORATIVE_REMOVED)
     if adversarial and mode != "full-reanalysis":
         raise ConvergenceContractError(
             "adversarial convergence requires full-reanalysis verificationMode"

package/runtime/python/okstra_ctl/convergence_reverify_prompt.py

@@ -78,21 +78,6 @@ uncertain, your verdict is REFUTED with basis = burden-not-met.
 Inspect ONLY the evidence each finding cites and its immediate surroundings. Do NOT
 re-read the task brief, instruction-set, or report template."""
 
-_COLLABORATIVE_MANDATE = """Review the following findings discovered by other workers.
-For EACH finding, respond with exactly one verdict:
-
-- **AGREE**: The finding is valid based on the evidence presented
-- **DISAGREE**: The finding is incorrect or unsupported (explain briefly why)
-- **SUPPLEMENT**: The finding is valid AND you have additional supporting evidence or context
-- **UNVERIFIABLE**: Capability, credential, network, or service state prevents you
-  from checking this finding. Explain the unavailable capability; do not substitute DISAGREE.
-
-Every verdict carries an `**Explanation**`, AGREE included — name the evidence you
-checked. A block with a verdict and no explanation is not collected and the whole
-response is refused.
-
-Do NOT re-analyze the original source materials. Judge based on the evidence provided."""
-
 # 근거 접근 규칙. `**Cited evidence**` 는 리드의 요약이고, 완전한 인용은 원 워커의
 # 결과 항목이다. 검증자가 요약만 열고 "이 근거로는 입증되지 않는다" 고 답하던
 # 자리를 막는다.
@@ -111,11 +96,6 @@ ADVERSARIAL_RESPONSE = """### <finding-id>
 SURVIVES say what you attacked and why the attack failed; for counter-evidence include
 the file:line you found>"""
 
-_COLLABORATIVE_RESPONSE = """### <finding-id>
-**Verdict**: AGREE | DISAGREE | SUPPLEMENT | UNVERIFIABLE
-**Explanation** (required for every verdict, AGREE included): <2-3 sentences>"""
-
-
 def _nonempty_string(value: Any) -> str:
     return value if isinstance(value, str) and value.strip() else ""
 
@@ -208,7 +188,6 @@ def reverify_prompt_body(
     *,
     task_key: str,
     round_number: int,
-    adversarial: bool,
     findings: Sequence[ReverifyFinding],
 ) -> str:
     """reverify 지시문 파일 본문. 같은 입력이면 같은 바이트를 낸다."""
@@ -216,14 +195,11 @@ def reverify_prompt_body(
         raise ReverifyPromptError("convergence groups carry no taskKey")
     if not findings:
         raise ReverifyPromptError("no findings to verify")
-    mode = "ADVERSARIAL re-verification" if adversarial else "re-verification"
-    mandate = ADVERSARIAL_MANDATE if adversarial else _COLLABORATIVE_MANDATE
-    response = ADVERSARIAL_RESPONSE if adversarial else _COLLABORATIVE_RESPONSE
     rows = [
         "## Instructions\n\n",
         f"{RENDERED_BY_LINE}\n\n",
-        f"Perform {mode} for {task_key} (round {round_number}).\n\n",
-        mandate, "\n\n",
+        f"Perform ADVERSARIAL re-verification for {task_key} (round {round_number}).\n\n",
+        ADVERSARIAL_MANDATE, "\n\n",
         _EVIDENCE_ACCESS, "\n\n",
         "## Findings to verify\n",
     ]
@@ -242,7 +218,7 @@ def reverify_prompt_body(
         "Field labels are bold with the colon outside (`**Verdict**: …`); the "
         "collector also reads `**Verdict:** …` and `- Verdict: …` as the same field.\n\n"
     )
-    rows.append(response.replace("<finding-id>", findings[0].finding_id))
+    rows.append(ADVERSARIAL_RESPONSE.replace("<finding-id>", findings[0].finding_id))
     rows.append("\n")
     if len(findings) > 1:
         rows.append(f"\n### {findings[1].finding_id}\n**Verdict**: ...\n")

package/runtime/python/okstra_ctl/convergence_store.py

@@ -68,6 +68,9 @@ _ACCEPTANCE_BATCH_SCHEMA = {
                     "candidateId": {"type": "string", "pattern": "\\S"},
                     "verdict": {"enum": ["confirmed", "downgraded"]},
                     "statement": {"type": "string"},
+                    "severity": {"enum": ["critical", "major"]},
+                    "originEvidence": {"type": "string"},
+                    "votes": {"type": "object"},
                 },
             },
         },
@@ -226,7 +229,10 @@ def _validate_dynamic_verifier_request(
     task_type: str,
     dispatch_kind: str,
 ) -> None:
-    from .worker_prompt_policy import is_plan_verify_dispatch_kind
+    from .worker_prompt_policy import (
+        is_plan_verify_dispatch_kind,
+        is_reverify_dispatch_kind,
+    )
 
     try:
         duty_role = role_for_duty(duty_id)
@@ -247,11 +253,12 @@ def _validate_dynamic_verifier_request(
             f"dynamic verifier source role is not eligible: {source.role}"
         )
     if source is not None and source.role == "critic" and not (
-        task_type == "implementation-planning"
-        and is_plan_verify_dispatch_kind(dispatch_kind)
+        (task_type == "implementation-planning" and is_plan_verify_dispatch_kind(dispatch_kind))
+        or is_reverify_dispatch_kind(dispatch_kind)
     ):
         raise ExecutionManifestError(
-            "critic source role is eligible only for planning verification"
+            "critic source role is eligible only for a plan-body or finding "
+            "re-verification round"
         )
 
 

package/runtime/python/okstra_ctl/dispatch_core.py

@@ -144,6 +144,9 @@ from .write_policy import (
 
 
 MAX_WORKER_ATTEMPTS = 2
+# 배치 시작 실패가 그 배치의 모든 디스패치 행에 남기는 사유의 머리. 토론 단계가 이
+# 값으로 시작 실패와 재시도 루프 뒤 실패를 가른다.
+CLI_BATCH_LAUNCH_FAILURE = "concurrent CLI batch launch failed"
 TERMINAL_DISPATCH_STATUSES = {"completed", "timeout", "error", "not-run"}
 # What the error log records for a wrapper the dispatcher timed out, matching
 # the value `team-contract` prescribes for a polling-cap termination.
@@ -770,7 +773,7 @@ def _abort_cli_batch_start(
 ) -> None:
     from .adapters.runtime.assembly import port_for
 
-    reason = f"concurrent CLI batch launch failed: {error}"
+    reason = f"{CLI_BATCH_LAUNCH_FAILURE}: {error}"
     for handle, _attempt in active:
         runtime = handle.runtime_handle
         if runtime is None:

package/runtime/python/okstra_ctl/domain/role.py

@@ -48,6 +48,7 @@ DUTY_ROLE_IDS = {
     "discovery-worker": "analyser",
     "diagnosis-worker": "analyser",
     "technical-verification-worker": "analyser",
+    "discussion-worker": "analyser",
     "scope-critic": "critic",
     "acceptance-critic": "critic",
     "direction-selection-worker": "designer",

package/runtime/python/okstra_ctl/manager_cli.py

@@ -146,7 +146,7 @@ def _render_manager_status(payload: dict) -> list[str]:
                        ("Task ID", "taskId"), ("Progress mode", "progressMode")):
         rows.append(line(label, manifest.get(key)))
     summary = payload.get("summary") if isinstance(payload.get("summary"), dict) else {}
-    for key in ("planned", "missing", "running", "done", "blocked"):
+    for key in ("planned", "missing", "running", "done", "blocked", "discussion"):
         rows.append(line(f"Summary {key}", summary.get(key)))
     children = payload.get("children") if isinstance(payload.get("children"), list) else []
     for index, child in enumerate(children, 1):
@@ -160,6 +160,32 @@ def _render_manager_status(payload: dict) -> list[str]:
             if key in child:
                 value = child.get(key)
                 rows.append(line(f"Child {index} {label}", ("yes" if value else "no") if isinstance(value, bool) else value))
+        if isinstance(child.get("discussion"), dict):
+            rows.extend(_render_discussion(index, child["discussion"]))
+    return rows
+
+
+def _render_discussion(index: int, discussion: dict) -> list[str]:
+    prefix = f"Child {index} discussion"
+    rows = [line(f"{prefix} state", discussion.get("state"))]
+    if discussion.get("state") == "unknown":
+        return rows + [line(f"{prefix} reason", discussion.get("reason"))]
+    rows += [line(f"{prefix} phase", discussion.get("phase")),
+             line(f"{prefix} completed revision", discussion.get("completedRevision") or "none")]
+    questions = discussion.get("pendingQuestions") or {}
+    for audience, key in (("user", "forUser"), ("participant", "forParticipants")):
+        for number, row in enumerate(questions.get(key) or [], 1):
+            rows.append(line(f"{prefix} pending {audience} question {number}",
+                             f"{row.get('recordId')}: {row.get('text')}"))
+    for number, row in enumerate(discussion.get("revisions") or [], 1):
+        rows.append(line(f"{prefix} revision {number}",
+                         f"{row.get('revisionId')} — {row.get('changeReason') or row.get('reason') or 'first revision'}"))
+    follow_ups = discussion.get("followUps") or {}
+    for number, row in enumerate(follow_ups.get("items") or [], 1):
+        rows.append(line(f"{prefix} follow-up {number}",
+                         f"{row.get('targetTaskKey')} {row.get('state')} uses {row.get('pinnedRevision') or '-'}"))
+    if follow_ups.get("state") == "unknown":
+        rows.append(line(f"{prefix} follow-ups", f"unknown — {follow_ups.get('reason')}"))
     return rows