okstra 0.214.1 → 0.216.0

package/runtime/python/okstra_ctl/stage_reopen.py

@@ -0,0 +1,151 @@
+"""`okstra stage-reopen` — done 으로 닫힌 stage 를 사유와 함께 다시 연다.
+
+stage 를 다시 여는 수단은 `done` 뒤에 `failed` 행을 붙이는 것이고
+(`_implementation-deliverable.md` §"Reopening a settled stage"), 위저드는 마지막
+행이 `failed` 인 stage 를 fix run 대상으로 받는다. 그 행을 쓰는 명령이 없어
+리드가 `append_consumer` 를 직접 불러야 했다 — 실측(2026-10-07,
+fontsninja-v3-site dev-11118): final-verification 이 `blocked` 로 끝나
+`implementation` 을 가리켰는데 stage 1 이 `done` 이라 위저드가 거절했고,
+consumers.jsonl 을 손으로 고치지 않는 한 fix run 을 시작할 길이 없었다.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from okstra_project import (
+    ResolverError,
+    StateError,
+    resolve_project_root,
+    resolve_task_identity,
+)
+
+from .consumers import (
+    append_consumer,
+    last_lifecycle_status_by_stage,
+    latest_done_by_stage,
+    read_consumers,
+)
+from .paths import RunRef
+from .stage_map import StageMapError, load_latest_plan_stage_map
+
+
+def reopen_stage(
+    project_root: Path, task_key: str, stage: int, reason: str, evidence: str = "",
+) -> dict:
+    """마지막 행이 `done` 인 stage 에 `failed` 행을 붙이고 그 근거를 돌려준다."""
+    if not reason.strip():
+        raise StateError("--reason is required: say why the stage is reopened",
+                         stage="reason")
+    identity = resolve_task_identity(project_root, task_key)
+    task_root = Path(identity["taskRoot"])
+    plan_run_root = RunRef.from_task_root(task_root, "implementation-planning").run_dir
+    try:
+        stage_map = load_latest_plan_stage_map(task_root)
+    except StageMapError as exc:
+        raise StateError(str(exc), stage=exc.code) from exc
+    rows = [row for row in stage_map.stages if isinstance(row, dict)]
+    if not any(row.get("stage_number") == stage for row in rows):
+        raise StateError(f"stage {stage} is not in this task's Stage Map", stage="stage-map")
+    if any(row.get("stage_number") == stage and row.get("cancelled") for row in rows):
+        raise StateError(f"stage {stage} is cancelled in the latest plan", stage="stage-map")
+
+    consumers = read_consumers(plan_run_root)
+    recorded = last_lifecycle_status_by_stage(consumers).get(stage)
+    if recorded != "done":
+        raise StateError(
+            f"stage {stage} is recorded {recorded!r}, not 'done' — only a settled "
+            "stage is reopened; a 'failed' stage is already selectable for a fix run",
+            stage="consumers",
+        )
+    evidence_rel = ""
+    if evidence:
+        evidence_path = Path(evidence)
+        if not evidence_path.is_absolute():
+            evidence_path = project_root / evidence_path
+        if not evidence_path.is_file():
+            raise StateError(f"--evidence names no file: {evidence_path}", stage="evidence")
+        evidence_rel = evidence_path.resolve().relative_to(project_root.resolve()).as_posix()
+    done_row = latest_done_by_stage(
+        [row for row in consumers if row.get("status") == "done"]
+    )[stage]
+    head = str(done_row.get("head_commit") or "")
+    append_consumer(
+        plan_run_root,
+        impl_task_key=identity["taskKey"],
+        stage=stage,
+        status="failed",
+        head_commit=head,
+        reason=reason.strip(),
+        reopened_by="stage-reopen",
+        **({"evidence_path": evidence_rel} if evidence_rel else {}),
+    )
+    return {
+        "taskKey": identity["taskKey"],
+        "stage": stage,
+        "headCommit": head,
+        "reason": reason.strip(),
+        "evidencePath": evidence_rel,
+        "consumersPath": str(plan_run_root / "consumers.jsonl"),
+    }
+
+
+_CLI_EPILOG = r"""Usage:
+  okstra stage-reopen <task-key> --stage <N> --reason "<why>" [--evidence <path>]
+
+Appends a `failed` row after the stage's `done` row, so `/okstra-run` offers the
+stage again for a fix run and its dependents stop branching from the withdrawn
+head. Use it when a later verification found a defect in a done stage — for
+example a final-verification that ended `blocked` and points at
+`implementation`; pass that report as --evidence. Refuses a stage that is not in
+the latest Stage Map, is cancelled, or whose last row is not `done`.
+
+Output: JSON { ok, taskKey, stage, headCommit, reason, evidencePath,
+consumersPath }. Exit 1 on a refusal, 2 when PROJECT_ROOT cannot be resolved.
+"""
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Reopen a done implementation stage for a fix run.",
+        epilog=_CLI_EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        prog="okstra stage-reopen")
+    parser.add_argument("task_key", metavar="task-key",
+                        help="project-id:task-group:task-id")
+    parser.add_argument("--stage", type=int, required=True,
+                        help="the Stage Map number to reopen")
+    parser.add_argument("--reason", required=True,
+                        help="why the stage is reopened; recorded on the row")
+    parser.add_argument("--evidence", default="",
+                        help="the report that found the defect (recorded as a "
+                             "project-relative path)")
+    parser.add_argument("--project-root", "--project", default="",
+                        help="use this directory as PROJECT_ROOT")
+    parser.add_argument("--cwd", default=".",
+                        help="resolve PROJECT_ROOT starting from here")
+    args = parser.parse_args(argv)
+
+    def emit(payload: dict) -> None:
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
+
+    try:
+        resolved = resolve_project_root(explicit_root=args.project_root, cwd=args.cwd)
+    except ResolverError as exc:
+        emit({"ok": False, "stage": "resolve", "reason": str(exc)})
+        return 2
+    try:
+        reopened = reopen_stage(
+            Path(resolved), args.task_key, args.stage, args.reason, args.evidence,
+        )
+    except StateError as exc:
+        emit({"ok": False, "stage": getattr(exc, "stage", None) or "stage-reopen",
+              "reason": str(exc)})
+        return 1
+    emit({"ok": True, **reopened})
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/runtime/python/okstra_ctl/verdict_blocks.py

@@ -24,18 +24,9 @@ VERDICT_TOKENS = frozenset({
 })
 FIXABILITY_VALUES = frozenset({"planner-fixable", "needs-user-input"})
 
-# The convergence reverify prompts use their own vocabularies. Collaborative and
-# full-reanalysis rounds speak the schema's own words; the adversarial round asks
-# the verifier to break the finding, so it answers in break/survive terms that
-# have to be translated back (`prompts/lead/convergence.md`
-# §"Adversarial Re-verification Prompt").
-COLLABORATIVE_VERDICTS = {
-    "AGREE": "agree",
-    "DISAGREE": "disagree",
-    "SUPPLEMENT": "supplement",
-    "UNVERIFIABLE": "unverifiable",
-    "VERIFICATION-ERROR": "verification-error",
-}
+# The convergence reverify prompt asks the verifier to break the finding, so it
+# answers in break/survive terms that have to be translated back to the schema's
+# words (`prompts/lead/convergence.md` §"Adversarial Re-verification Prompt").
 ADVERSARIAL_VERDICTS = {
     "SURVIVES": "agree",
     "SURVIVES-WITH-CAVEAT": "supplement",
@@ -156,16 +147,11 @@ def _scan_blocks(text: str) -> dict[str, dict[str, str]]:
     }
 
 
-def parse_finding_votes(text: str, *, adversarial: bool) -> dict[str, FindingVote]:
-    """Convergence reverify votes in *text*, keyed by finding id.
-
-    *adversarial* selects the vocabulary; guessing it from the content would make
-    an unfamiliar token silently read as a different verdict.
-    """
-    vocabulary = ADVERSARIAL_VERDICTS if adversarial else COLLABORATIVE_VERDICTS
+def parse_finding_votes(text: str) -> dict[str, FindingVote]:
+    """Convergence reverify votes in *text*, keyed by finding id."""
     return _collect_blocks(
         _scan_blocks(text),
-        lambda item_id, fields: _finding_vote(item_id, fields, vocabulary),
+        lambda item_id, fields: _finding_vote(item_id, fields, ADVERSARIAL_VERDICTS),
     )
 
 
@@ -178,22 +164,12 @@ def finding_vote_defect(text: str) -> str | None:
     (`okstra_ctl.dispatch_state.unusable_result_defect`). 그러지 않으면 원장은
     `ok`, 수집기는 거절이 되어 리드가 손으로 재띄우거나 run 을 닫는 수밖에 없다
     (2026-09-10 실측, fontsninja-v3-site dev-10631 implementation-option-selection).
-
-    라운드가 adversarial 인지 collaborative 인지는 결과 파일에 적혀 있지 않다. 한쪽
-    어휘로만 읽으면 반대쪽 라운드의 정상 결과를 결함으로 신고하므로, 어느 한쪽으로
-    읽히면 결함이 아니다. 둘 다 실패했을 때만 adversarial 쪽 메시지를 낸다 — 실측된
-    결함(설명 누락)은 두 어휘에서 같은 문장을 낸다.
     """
-    adversarial_error: str | None = None
-    for adversarial in (True, False):
-        try:
-            parse_finding_votes(text, adversarial=adversarial)
-        except VerdictBlockError as exc:
-            if adversarial:
-                adversarial_error = str(exc)
-            continue
-        return None
-    return adversarial_error
+    try:
+        parse_finding_votes(text)
+    except VerdictBlockError as exc:
+        return str(exc)
+    return None
 
 
 def _collect_blocks(blocks: dict[str, dict[str, str]], parse) -> dict:

package/runtime/python/okstra_ctl/wizard/cli.py

@@ -7,6 +7,7 @@ from pathlib import Path
 
 from okstra_ctl.registry.host_registry import default_host_registry
 
+from .ids import REQUESTABLE_TASK_TYPES
 from .state import WizardError
 from .statefile import load_state_file, save_state_file
 from .confirmation import confirmation_block
@@ -43,6 +44,12 @@ def main(argv: list[str]) -> int:
     p_init.add_argument("--project-root", required=True)
     p_init.add_argument("--project-id", required=True)
     p_init.add_argument("--preferred-task-key", default="")
+    p_init.add_argument(
+        "--task-type",
+        default="",
+        choices=("", *REQUESTABLE_TASK_TYPES),
+        help="ask the task type before the brief and recommend this type",
+    )
     p_init.add_argument(
         "--host-runtime",
         default="claude-code",
@@ -82,6 +89,7 @@ def main(argv: list[str]) -> int:
             project_root=args.project_root,
             project_id=args.project_id,
             preferred_task_key=args.preferred_task_key,
+            requested_task_type=args.task_type,
             host_runtime=args.host_runtime,
             host_entry_mode=args.entry_mode,
             available_functions=args.available_function,

package/runtime/python/okstra_ctl/wizard/confirmation.py

@@ -221,7 +221,10 @@ def confirmation_block(state: WizardState) -> str:
     lines: list[str] = [header]
     lines.append(f"  task-type     : {state.task_type}")
     lines.append(f"  task-key      : {state.task_group}/{state.task_id}")
-    lines.append(f"  brief         : {state.brief_path or '(none)'}")
+    if state.task_type == "discussion":
+        lines.append(f"  discussion-start: {state.discussion_start}")
+    else:
+        lines.append(f"  brief         : {state.brief_path or '(none)'}")
     if state.analysis_target:
         lines.append(f"  analysis-target: {state.analysis_target}")
     if state.feature_evidence_path or state.project_evidence_path:

package/runtime/python/okstra_ctl/wizard/engine.py

@@ -20,6 +20,7 @@ from .ids import (
     GROUP_LABELS,
     GROUP_MAX_TABS,
     PROMPT_GROUPS,
+    REQUESTABLE_TASK_TYPES,
     S_ABORTED,
     S_CONFIRM,
     S_DESIGN_PREP_CONFIRM,
@@ -50,13 +51,20 @@ def init_state(
     host_entry_mode: str = "current-session",
     available_functions: Optional[list[str]] = None,
     preferred_task_key: str = "",
+    requested_task_type: str = "",
 ) -> WizardState:
     """Bootstrap a new wizard state."""
+    if requested_task_type and requested_task_type not in REQUESTABLE_TASK_TYPES:
+        raise WizardError(
+            f"--task-type accepts only {', '.join(REQUESTABLE_TASK_TYPES)}; "
+            f"got {requested_task_type!r}"
+        )
     return WizardState(
         workspace_root=workspace_root,
         project_root=project_root,
         project_id=project_id,
         preferred_task_key=preferred_task_key,
+        requested_task_type=requested_task_type,
         host_runtime=host_runtime,
         host_entry_mode=host_entry_mode,
         available_functions=list(available_functions or []),

package/runtime/python/okstra_ctl/wizard/ids.py

@@ -26,6 +26,7 @@ TASK_TYPES: list[tuple[str, str]] = [
     ("implementation", "Execute approved plan (requires approved final-report)"),
     ("final-verification", "Acceptance + residual-risk review"),
     ("release-handoff", "Drive commit/push/PR — reuse the implementation task-key (new keys fail the empty-commits gate)"),
+    ("discussion", "Settle requirements and direction with the user and several agents (no code changes)"),
 ]
 
 
@@ -50,6 +51,11 @@ _BRIEF_ENTRY_TASK_TYPES = (
 )
 
 
+# `okstra wizard init --task-type` 로 미리 고를 수 있는 유형. brief 없이 시작하는
+# 유형만 둔다 — 새 task 에서 brief 질문보다 유형 질문이 먼저 와야 하기 때문이다.
+REQUESTABLE_TASK_TYPES = ("discussion",)
+
+
 CANONICAL_BASE_REFS = ["main", "dev", "staging", "preprod", "prod"]
 
 
@@ -136,6 +142,12 @@ S_BRIEF_PATH = "brief_path"
 S_BRIEF_CARRY = "brief_carry"
 
 
+S_DISCUSSION_START_PICK = "discussion_start_pick"
+
+
+S_DISCUSSION_START = "discussion_start"
+
+
 S_FEATURE_EVIDENCE_PICK = "feature_evidence_pick"
 
 

package/runtime/python/okstra_ctl/wizard/registry.py

@@ -8,6 +8,13 @@ from okstra_ctl.phases.change_impact_analysis.entry import (
     _submit_feature_evidence_pick,
 )
 
+from okstra_ctl.phases.discussion.wizard import (
+    build_discussion_start,
+    build_discussion_start_pick,
+    submit_discussion_start,
+    submit_discussion_start_pick,
+)
+
 from okstra_ctl.phases.implementation_planning.wizard import (
     _selected_direction_options,
     _planning_rerun_selected,
@@ -40,6 +47,8 @@ from .ids import (
     S_DESIGN_PREP_OVERRIDES,
     S_DIRECTIVE,
     S_DIRECTIVE_PICK,
+    S_DISCUSSION_START,
+    S_DISCUSSION_START_PICK,
     S_EDIT_TARGET,
     S_FEATURE_EVIDENCE,
     S_FEATURE_EVIDENCE_PICK,
@@ -286,7 +295,12 @@ STEPS: list[Step] = [
              and not s.brief_path_pending_text
              and S_BRIEF_PATH_PICK not in s.answered
              and (
-                 (s.is_new_task is True and bool(s.task_group))
+                 # `--task-type` 로 미리 고른 새 task 는 유형을 먼저 묻고, 그 유형이
+                 # brief 를 받는 경우에만 brief 를 묻는다.
+                 (s.is_new_task is True and bool(s.task_group)
+                  and (not s.requested_task_type
+                       or (S_TASK_TYPE in s.answered
+                           and s.task_type not in ("", "discussion"))))
                  or (s.is_new_task is False
                      and S_TASK_TYPE in s.answered
                      and s.task_type in _BRIEF_ENTRY_TASK_TYPES
@@ -304,7 +318,9 @@ STEPS: list[Step] = [
     Step(S_TASK_TYPE,
          applies=lambda s: (s.is_new_task is not None
                             and (s.is_new_task is False
-                                 or (bool(s.task_group) and bool(s.brief_path)))
+                                 or (bool(s.task_group)
+                                     and (bool(s.brief_path)
+                                          or bool(s.requested_task_type))))
                             and S_TASK_TYPE not in s.answered),
          build=_build_task_type, submit=_submit_task_type,
          owns=("task_type", "reuse_worktree")),
@@ -320,7 +336,7 @@ STEPS: list[Step] = [
          applies=lambda s: (S_TASK_TYPE in s.answered
                             and bool(s.task_type)
                             and s.task_type not in _BRIEF_ENTRY_TASK_TYPES
-                            and s.task_type != "release-handoff"
+                            and s.task_type not in ("release-handoff", "discussion")
                             and not s.brief_path
                             and not s.brief_path_pending_text),
          build=_build_brief_carry, submit=_submit_brief_carry,
@@ -341,6 +357,22 @@ STEPS: list[Step] = [
                             and s.task_id_pending_text),
          build=_build_task_id_text, submit=_submit_task_id_text,
          owns=("task_id", "task_id_pending_text")),
+    # discussion 은 brief 대신 시작 입력을 받는다. task key 가 정해진 뒤에 물어야
+    # "이 task 의 토론 이어가기" 를 판정할 수 있어 task-id 다음에 선다.
+    Step(S_DISCUSSION_START_PICK,
+         applies=lambda s: (s.task_type == "discussion"
+                            and bool(s.task_id)
+                            and not s.discussion_start
+                            and not s.discussion_start_pending_text
+                            and S_DISCUSSION_START_PICK not in s.answered),
+         build=build_discussion_start_pick, submit=submit_discussion_start_pick,
+         owns=("discussion_start", "discussion_start_pending_text")),
+    Step(S_DISCUSSION_START,
+         applies=lambda s: (s.task_type == "discussion"
+                            and s.discussion_start_pending_text
+                            and S_DISCUSSION_START not in s.answered),
+         build=build_discussion_start, submit=submit_discussion_start,
+         owns=("discussion_start", "discussion_start_pending_text")),
     Step(S_REUSE_PREVIOUS,
          applies=lambda s: (_identity_ready(s)
                             and s.reuse_previous is None

package/runtime/python/okstra_ctl/wizard/render.py

@@ -99,7 +99,8 @@ def render_args(state: WizardState) -> dict[str, Any]:
         "task-id": state.task_id,
         "task-type": state.task_type,
         "task-brief": (
-            "" if state.task_type == "release-handoff" else state.brief_path
+            "" if state.task_type in ("release-handoff", "discussion")
+            else state.brief_path
         ),
         "analysis-target": state.analysis_target,
         "evidence-inputs": ",".join(evidence_paths),
@@ -121,6 +122,8 @@ def render_args(state: WizardState) -> dict[str, Any]:
             _host_session_context(state)
         ),
     }
+    if state.task_type == "discussion":
+        rendered["discussion-start"] = state.discussion_start
     role_argv = render_role_args(state)
     rendered["role-count"] = [
         role_argv[index + 1]

package/runtime/python/okstra_ctl/wizard/sources.py

@@ -198,8 +198,8 @@ def _resolve_reuse_worktree(state: WizardState) -> bool:
 
 
 def _brief_resolved(state: WizardState) -> bool:
-    """brief 입력이 끝났는가. release-handoff 는 brief 가 없는 phase 라 항상 True."""
-    return bool(state.brief_path) or state.task_type == "release-handoff"
+    """brief 입력이 끝났는가. release-handoff·discussion 은 brief 를 받지 않아 항상 True."""
+    return bool(state.brief_path) or state.task_type in ("release-handoff", "discussion")
 
 
 def _parse_stage_objects(state: WizardState) -> list:

package/runtime/python/okstra_ctl/wizard/state.py

@@ -40,6 +40,7 @@ class WizardState:
     project_root: str = ""
     project_id: str = ""
     preferred_task_key: str = ""
+    requested_task_type: str = ""
     host_runtime: str = "claude-code"
     host_entry_mode: str = "current-session"
     available_functions: list[str] = field(default_factory=list)
@@ -66,6 +67,10 @@ class WizardState:
     brief_path: str = ""
     brief_path_pending_text: bool = False
 
+    # discussion: brief 대신 받는 시작 입력(링크·짧은 설명·이 task 의 key)
+    discussion_start: str = ""
+    discussion_start_pending_text: bool = False
+
     # analysis evidence and target
     project_evidence_path: str = ""
     project_evidence_pending_text: bool = False
@@ -566,7 +571,11 @@ def _identity_ready(s: WizardState) -> bool:
     if not s.task_type:
         return False
     # release-handoff 는 brief 가 없다 — prepare 가 검증 보고서 인용 input 을 생성한다.
-    if not s.brief_path and s.task_type != "release-handoff":
+    # discussion 은 brief 대신 시작 입력으로 prepare 가 input 문서를 만든다.
+    if s.task_type == "discussion":
+        if not s.discussion_start:
+            return False
+    elif not s.brief_path and s.task_type != "release-handoff":
         return False
     if _base_ref_required(s) and S_BASE_REF_PICK not in s.answered:
         return False
@@ -588,6 +597,7 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "task_group_pending_text": False, "task_id_pending_text": False,
     "keep_existing_brief": None,
     "brief_path": "", "brief_path_pending_text": False,
+    "discussion_start": "", "discussion_start_pending_text": False,
     "project_evidence_path": "", "project_evidence_pending_text": False,
     "feature_evidence_path": "", "feature_evidence_pending_text": False,
     "analysis_target": "", "analysis_target_pending_text": False,

package/runtime/python/okstra_ctl/wizard/steps_identity.py

@@ -223,7 +223,7 @@ def _submit_task_pick(state: WizardState, value: str) -> Optional[str]:
     # task_type seeded from manifest's nextRecommendedPhase as the recommended default
     root = find_task_root(Path(state.project_root), value)
     manifest = (read_task_manifest(root) or {}) if root else {}
-    state.task_type = _recommended_task_type(state, manifest)
+    state.task_type = state.requested_task_type or _recommended_task_type(state, manifest)
     return f"task: {value}"
 
 
@@ -606,7 +606,7 @@ def _build_task_type(state: WizardState) -> Prompt:
     recommended = (revision_requested or state.task_type
                    or _recommended_task_type(state, manifest))
     if not recommended and not workflow:
-        recommended = brief_phase or TASK_TYPE_VALUES[0]
+        recommended = state.requested_task_type or brief_phase or TASK_TYPE_VALUES[0]
     if brief_phase and recommended == brief_phase:
         recommended_suffix = t["options"].get("_BRIEF_SUFFIX", recommended_suffix)
     pointer = next_phase.promote(workflow.get("nextRecommendedPhase"))
@@ -645,8 +645,8 @@ def _carry_in_existing_brief(state: WizardState) -> str:
     """downstream task-type 이 등록된 brief 를 자동 carry-in 한다. 주입한 경로(또는 '')."""
     if state.task_type in _BRIEF_ENTRY_TASK_TYPES:
         return ""
-    if state.task_type == "release-handoff":
-        return ""  # prepare 가 검증 보고서 인용 input 문서를 자동 생성한다
+    if state.task_type in ("release-handoff", "discussion"):
+        return ""  # prepare 가 brief 자리의 input 문서를 직접 생성한다
     if state.brief_path or not state.existing_brief_path:
         return ""
     p = Path(state.existing_brief_path)

package/runtime/python/okstra_ctl/worker_prompt_policy.py

@@ -54,6 +54,7 @@ FINAL_VERIFICATION_HEADERS = (
 )
 SUPPORTED_TASK_TYPES = frozenset({
     "technical-verification",
+    "discussion",
     "requirements-discovery",
     "error-analysis",
     "implementation-option-selection",
@@ -71,6 +72,7 @@ SUPPORTED_TASK_TYPES = frozenset({
 # observational default below: describe the area, do not design for it.
 ANALYSIS_DUTY_BY_TASK_TYPE: dict[str, AgentAudience] = {
     "technical-verification": "technical-verification-worker",
+    "discussion": "discussion-worker",
     "requirements-discovery": "discovery-worker",
     "improvement-discovery": "discovery-worker",
     "error-analysis": "diagnosis-worker",
@@ -103,6 +105,9 @@ PLAN_VERIFY_DISPATCH_KIND_PREFIX = "plan-verify-r"
 # The one coverage-census retry: the same analyser, only the cells its first
 # result left unjudged. Unnumbered because the retry count is fixed at one.
 CENSUS_GAPFILL_DISPATCH_KIND = "census-gapfill"
+# 토론에서 사용자가 한 참여자에게 직접 한 질문. 질문마다 그 참여자 한 명에게만 새로
+# 디스패치하므로 본문이 최초 분석 프롬프트와 다르다.
+DISCUSSION_QUESTION_DISPATCH_KIND = "discussion-question"
 
 
 def _numbered_round(dispatch_kind: str, prefix: str) -> int | None:
@@ -125,19 +130,29 @@ def is_verification_dispatch_kind(dispatch_kind: str) -> bool:
     )
 
 
+def is_reverify_dispatch_kind(dispatch_kind: str) -> bool:
+    """finding 수렴의 번호 reverify 라운드인가."""
+    return _numbered_round(dispatch_kind, REVERIFY_DISPATCH_KIND_PREFIX) is not None
+
+
 def is_plan_verify_dispatch_kind(dispatch_kind: str) -> bool:
     """계획 본문 검증 라운드인가. 검증 계약이 요구하는 렌더러 서명이 번호
     reverify 와 다르므로 계약 검사가 이 둘을 갈라야 한다."""
     return _numbered_round(dispatch_kind, PLAN_VERIFY_DISPATCH_KIND_PREFIX) is not None
 
 
-def is_plan_critic_verification(
+def is_critic_verification(
     *, task_type: str, assignment_ref: str, dispatch_kind: str,
 ) -> bool:
+    """크리틱이 검증자로 투표하는 디스패치인가 — 계획 본문 라운드의 1:1 판정과
+    finding 수렴 라운드의 동률 판정."""
+    if task_type == "implementation-planning" and assignment_ref == "critic/scope" and (
+        is_plan_verify_dispatch_kind(dispatch_kind)
+    ):
+        return True
     return (
-        task_type == "implementation-planning"
-        and assignment_ref == "critic/scope"
-        and is_plan_verify_dispatch_kind(dispatch_kind)
+        assignment_ref == critic_assignment_ref(task_type)
+        and is_reverify_dispatch_kind(dispatch_kind)
     )
 
 
@@ -209,9 +224,12 @@ def resolve_prompt_plan(
     # and unrequested work, not findings), so grouping it with the initial
     # analysis prompts makes `validate_analysis_prompt_set` compare two prompts
     # that are *supposed* to differ and fail every critic-enabled run. A census
-    # gap-fill body lists one worker's missing cells, so it differs the same way.
+    # gap-fill body lists one worker's missing cells, and a discussion question
+    # carries one participant's question, so both differ the same way.
     analysis_equality_group = (
-        None if dispatch_kind in ("critic", CENSUS_GAPFILL_DISPATCH_KIND)
+        None if dispatch_kind in (
+            "critic", CENSUS_GAPFILL_DISPATCH_KIND, DISCUSSION_QUESTION_DISPATCH_KIND,
+        )
         else "analysis-core"
     )
     analysis_duty: AgentAudience = (

package/runtime/python/okstra_token_usage/pricing.py

@@ -72,6 +72,8 @@ CLAUDE_PRICING = {
     "opus-4-6":   (5.0, 6.25, 0.50, 25.0),     # Opus 4.6 (legacy; pricing matches 4.7 per Anthropic)
     "sonnet-4-6": (3.0, 3.75, 0.30, 15.0),     # Sonnet 4.6 (cache prices derived from ratios)
     "haiku-4-5":  (1.0, 1.25, 0.10, 5.0),      # Haiku 4.5  (cache prices derived from ratios)
+    # Haiku 5.5 bills prompts over 100K tokens at 5x; this row is the <=100K rate.
+    "haiku-5-5":  (0.10, 0.125, 0.01, 0.50),   # Haiku 5.5 (platform.claude.com pricing, read 2026-10-15)
 
     # Claude 4 family fallbacks (Opus 4 / Sonnet 4 / Haiku 4 base).
     "opus-4":     (15.0, 18.75, 1.50, 75.0),

package/runtime/schemas/convergence-groups-v1.0.schema.json

@@ -38,7 +38,7 @@
       "additionalProperties": false,
       "properties": {
         "workerId": { "type": "string", "pattern": "\\S" },
-        "audience": { "enum": ["analysis", "lead", "report-writer"] }
+        "audience": { "enum": ["analysis", "lead", "report-writer", "critic"] }
       }
     },
     "Group": {

package/runtime/schemas/convergence-groups-v2.0.schema.json

@@ -56,7 +56,7 @@
       "additionalProperties": false,
       "properties": {
         "workerId": { "type": "string", "pattern": "\\S" },
-        "audience": { "enum": ["analysis", "lead", "report-writer"] },
+        "audience": { "enum": ["analysis", "lead", "report-writer", "critic"] },
         "participantRef": { "type": "string", "pattern": "\\S" },
         "sourceRoleExecutionRef": { "type": "string", "pattern": "\\S" }
       }