okstra 0.214.1 → 0.216.0

package/runtime/python/okstra_ctl/convergence.py

@@ -24,9 +24,11 @@ from .convergence_engine import (
     validate_final_state,
     validate_working_state,
 )
-from .worker_prompt_policy import critic_assignment_ref
+from .worker_prompt_policy import critic_assignment_ref, critic_duty_for_task_type
 from .convergence_critic_verify_prompt import (
     CriticVerifyPromptError,
+    acceptance_candidates,
+    acceptance_verify_prompt_body,
     critic_result_paths,
     critic_verify_gaps,
     critic_verify_prompt_body,
@@ -37,7 +39,9 @@ from .convergence_reverify_prompt import (
     reverify_prompt_body,
 )
 from .convergence_critic_prompt import (
+    acceptance_critic_prompt_body,
     analyser_results,
+    analysis_roster,
     covered_index,
     critic_prompt_body,
 )
@@ -73,6 +77,7 @@ from .execution_identity import ExecutionManifest
 from .execution_manifest import read_execution_manifest_view
 from .final_report_schema import load_named_schema, validate as validate_schema
 from .paths import RunRef
+from .plan_items import CRITIC_WORKER_ID
 from .report_finalize import task_manifest_path
 from .verdict_blocks import FindingVote, VerdictBlockError, parse_finding_votes
 from .fixed_text import line
@@ -181,10 +186,10 @@ _EXAMPLES: dict[str, dict[str, Any]] = {
         "taskKey": "example/group/task",
         "config": {
             "enabled": True,
-            "adversarial": False,
+            "adversarial": True,
             "maxRounds": 2,
             "effectiveMaxRounds": 2,
-            "verificationMode": "lightweight",
+            "verificationMode": "full-reanalysis",
         },
         "workers": [
             {"workerId": "claude-worker", "audience": "analysis"},
@@ -412,10 +417,6 @@ def _parser() -> argparse.ArgumentParser:
         help="read one round's worker responses into the apply-round input",
     )
     collect.add_argument("--plan", type=Path, required=True)
-    collect.add_argument("--mode", choices=("adversarial", "collaborative"),
-                         required=True,
-                         help="which reverify prompt this round used; the two "
-                              "carry different verdict vocabularies")
     collect.add_argument("--result", action="append", default=[],
                          metavar="<worker>=<path>",
                          help="one worker's reverify result file (repeatable)")
@@ -452,9 +453,8 @@ def _parser() -> argparse.ArgumentParser:
         description=(
             "Print the reverify instruction body for one `dispatches[]` row of "
             "a round plan. The lead writes it verbatim to the file the prompt "
-            "materializer's `--instruction` takes. It carries the round's "
-            "mandate (adversarial or collaborative, from the grouping's "
-            "config), every planned finding with its summary, origin worker, "
+            "materializer's `--instruction` takes. It carries the adversarial "
+            "mandate, every planned finding with its summary, origin worker, "
             "cited-evidence line, the origin worker's result file and item id, "
             "and the origin audit sidecar the verifier may open, plus the "
             "response format the collector parses. Nothing here is hand-written."
@@ -485,7 +485,9 @@ def _parser() -> argparse.ArgumentParser:
     critic_verify_prompt.add_argument("--run-manifest", type=Path, required=True)
     critic_verify_prompt.add_argument(
         "--gaps", type=Path, required=True,
-        help="coverage batch JSON (schemaVersion 1.0, mode coverage, gaps[])",
+        help="critic batch JSON: mode coverage with gaps[], or mode "
+             "acceptance-devils-advocate with candidates[] (every analyser "
+             "verifies every candidate)",
     )
     critic_verify_prompt.add_argument("--worker", required=True)
 
@@ -556,6 +558,28 @@ def _parser() -> argparse.ArgumentParser:
     apply_acceptance.add_argument("--work-state", type=Path, required=True)
     apply_acceptance.add_argument("--results", type=Path, required=True)
 
+    collect_acceptance = subparsers.add_parser(
+        "collect-acceptance-votes",
+        help="derive confirmed/downgraded from the analysers' acceptance verdicts",
+        description=(
+            "Read every analyser's `critic-verify` response to the acceptance "
+            "candidates and write the `apply-acceptance-critic --results` batch: "
+            "a candidate any analyser answers SURVIVES or SURVIVES-WITH-CAVEAT is "
+            "confirmed, every other candidate is downgraded to a Residual Risk. "
+            "Each analyser must answer every candidate."
+        ),
+    )
+    collect_acceptance.add_argument("--run-manifest", type=Path, required=True)
+    collect_acceptance.add_argument(
+        "--candidates", type=Path, required=True,
+        help="the acceptance batch given to critic-verify-prompt (no verdicts yet)",
+    )
+    collect_acceptance.add_argument(
+        "--result", action="append", default=[], metavar="<worker>=<path>",
+        help="one analyser's critic-verify result file (repeatable)",
+    )
+    collect_acceptance.add_argument("--output", type=Path, required=True)
+
     finalize = subparsers.add_parser("finalize", help="write the public final state")
     finalize.add_argument("--work-state", type=Path, required=True)
     finalize.add_argument("--output", type=Path, required=True)
@@ -1371,7 +1395,7 @@ def _planned_finding_ids(plan: dict[str, Any]) -> dict[str, list[str]]:
 
 
 def _worker_votes(
-    raw_results: list[str], planned: dict[str, list[str]], adversarial: bool
+    raw_results: list[str], planned: dict[str, list[str]]
 ) -> dict[str, dict[str, FindingVote]]:
     votes: dict[str, dict[str, FindingVote]] = {}
     for raw in raw_results:
@@ -1380,9 +1404,7 @@ def _worker_votes(
             raise ConvergenceContractError(
                 f"`{worker}` returned a result but the round plan did not dispatch it"
             )
-        parsed = parse_finding_votes(
-            Path(path).read_text(encoding="utf-8"), adversarial=adversarial
-        )
+        parsed = parse_finding_votes(Path(path).read_text(encoding="utf-8"))
         assigned = set(planned[worker])
         missing = sorted(assigned - set(parsed))
         if missing:
@@ -1411,7 +1433,7 @@ def _collect_results(args: argparse.Namespace) -> tuple[str, Path]:
             "a legacy v1 roster has no attempt ledger to read"
         )
     dispatches = _dispatch_rows_from_manifest(plan, manifest, args.run_manifest)
-    votes = _worker_votes(args.result, planned, args.mode == "adversarial")
+    votes = _worker_votes(args.result, planned)
     returned_without_completion = sorted(
         worker for worker in votes
         if next((row["status"] for row in dispatches if row["worker"] == worker), None)
@@ -1606,15 +1628,26 @@ def _group_worker(manifest: Mapping[str, Any], worker_id: str) -> dict[str, str]
             "sourceRoleExecutionRef": str(execution["roleExecutionRef"])}
 
 
+def _critic_tie_breaker(manifest: Mapping[str, Any]) -> list[dict[str, str]]:
+    """로스터에 크리틱이 있으면 동률 finding 을 판정할 `critic` 워커 행 하나."""
+    executions = manifest.get("roleExecutions") if isinstance(manifest.get("roleExecutions"), list) else []
+    critics = [row for row in executions
+               if isinstance(row, Mapping) and row.get("role") == "critic"]
+    if not critics:
+        return []
+    if len(critics) != 1 or not critics[0].get("participantRef") or not critics[0].get("roleExecutionRef"):
+        raise ConvergenceContractError("no single canonical critic role execution")
+    return [{"workerId": CRITIC_WORKER_ID, "audience": "critic",
+             "participantRef": str(critics[0]["participantRef"]),
+             "sourceRoleExecutionRef": str(critics[0]["roleExecutionRef"])}]
+
+
 def _convergence_config(authority: RunArtifactAuthority) -> Mapping[str, Any]:
     """convergence 설정의 정본은 task-manifest.json 이다.
 
     `render.render_task_manifest` 가 `_build_convergence_block` 결과를 거기에만
-    쓴다. run manifest 에는 `convergenceStatePath` 뿐이라, 예전처럼 run manifest 를
-    읽으면 키가 없어 `adversarial=False` / `verificationMode="lightweight"` 기본값으로
-    조용히 떨어졌다. 그 강등은 무증상이다 — `convergence_engine._parse_groups` 가
-    적대 모드가 꺼진 다중 출처 그룹을 큐에 넣지 않고 즉시 `full-consensus` 로
-    확정하므로, 세 워커의 처방이 서로 달라도 합의로 기록된다.
+    쓴다. run manifest 에는 `convergenceStatePath` 뿐이라 거기서는 라운드 상한을
+    읽을 수 없다.
 
     설정이 없으면 기본값으로 떨어지지 않고 실패한다. 여기서 조용히 넘어가면
     검증 자체가 사라지고 산출물은 정상으로 읽힌다.
@@ -1641,6 +1674,18 @@ def _critic_prompt(args: argparse.Namespace) -> str:
             f"`okstra convergence prepare-groups` first: {groups_path}"
         )
     groups = load_owned_json_object(groups_path)
+    if critic_duty_for_task_type(authority.task_type) == "acceptance-critic":
+        return acceptance_critic_prompt_body(
+            groups,
+            analysis_packet_path=_manifest_authority_string(
+                authority.payload, "analysisPacketPath"
+            ),
+            results=analyser_results(
+                groups,
+                project_root=authority.project_root,
+                run_dir=authority.run_dir,
+            ),
+        )
     return critic_prompt_body(
         groups,
         analysis_packet_path=_manifest_authority_string(
@@ -1667,16 +1712,17 @@ def _prepare_groups(args: argparse.Namespace) -> tuple[str, Path]:
     )
     config = _convergence_config(authority)
     workers = [_group_worker(manifest, worker) for worker in worker_ids]
+    workers.extend(_critic_tie_breaker(manifest))
     source_refs = [worker["sourceRoleExecutionRef"] for worker in workers]
     if len(source_refs) != len(set(source_refs)):
         raise ConvergenceContractError("duplicate sourceRoleExecutionRef")
     payload = {"schemaVersion": "2.0", "executionIdentityVersion": 2,
                "taskKey": manifest.get("taskKey"), "runManifestPath": manifest.get("runManifestPath"),
                "config": {"enabled": bool(config.get("enabled", True)),
-                          "adversarial": bool(config.get("adversarial", False)),
+                          "adversarial": True,
                           "maxRounds": int(config.get("maxRounds", 2)),
                           "effectiveMaxRounds": int(config.get("effectiveMaxRounds", config.get("maxRounds", 2))),
-                          "verificationMode": str(config.get("verificationMode", "lightweight"))},
+                          "verificationMode": "full-reanalysis"},
                "workers": workers, "groups": groups}
     schema_errors = validate_schema(
         payload, load_named_schema("convergence-groups-v2.0.schema.json")
@@ -1705,7 +1751,6 @@ def _reverify_prompt(args: argparse.Namespace) -> str:
         )
     groups = load_owned_json_object(groups_path)
     plan = load_owned_json_object(args.plan)
-    config = groups.get("config") if isinstance(groups.get("config"), Mapping) else {}
     round_number = plan.get("round")
     if not isinstance(round_number, int) or round_number < 1:
         raise ConvergenceContractError("round plan has no positive `round`")
@@ -1717,7 +1762,6 @@ def _reverify_prompt(args: argparse.Namespace) -> str:
     return reverify_prompt_body(
         task_key=_manifest_authority_string(authority.payload, "taskKey"),
         round_number=round_number,
-        adversarial=bool(config.get("adversarial", False)),
         findings=reverify_findings(
             groups, plan, args.worker,
             project_root=authority.project_root, run_dir=authority.run_dir,
@@ -1740,11 +1784,11 @@ def _critic_verify_prompt(args: argparse.Namespace) -> str:
     batch = load_owned_json_object(args.gaps)
     task_key = _manifest_authority_string(authority.payload, "taskKey")
     if batch.get("taskKey") != task_key:
-        raise ConvergenceContractError("coverage batch taskKey does not match the run manifest")
-    if batch.get("mode") != "coverage":
+        raise ConvergenceContractError("critic batch taskKey does not match the run manifest")
+    mode = batch.get("mode")
+    if mode not in {"coverage", "acceptance-devils-advocate"}:
         raise ConvergenceContractError(
-            "critic-verify-prompt accepts coverage mode only; acceptance candidates "
-            "use confirm-or-downgrade"
+            f"critic batch mode must be coverage or acceptance-devils-advocate, got {mode!r}"
         )
     critic_ref = critic_assignment_ref(authority.task_type)
     assignments = authority.payload.get("invocationAssignments")
@@ -1759,6 +1803,14 @@ def _critic_verify_prompt(args: argparse.Namespace) -> str:
         project_root=authority.project_root, run_dir=authority.run_dir,
         recorded_result=_settled_critic_result(authority.payload),
     )
+    if mode == "acceptance-devils-advocate":
+        return acceptance_verify_prompt_body(
+            task_key=task_key,
+            critic_worker=f"{provider}-critic",
+            critic_result_path=result_path,
+            critic_audit_path=audit_path,
+            candidates=acceptance_candidates(batch, groups, args.worker),
+        )
     return critic_verify_prompt_body(
         task_key=task_key,
         critic_worker=f"{provider}-critic",
@@ -1768,6 +1820,67 @@ def _critic_verify_prompt(args: argparse.Namespace) -> str:
     )
 
 
+def _collect_acceptance_votes(args: argparse.Namespace) -> tuple[str, Path]:
+    """분석자 응답에서 후보마다 confirmed / downgraded 를 정해 반영 배치를 쓴다.
+
+    한 분석자라도 SURVIVES(또는 SURVIVES-WITH-CAVEAT)면 확인된 blocker 다
+    (convergence.md §"Verification — confirm-or-downgrade"). 아무도 살리지
+    않으면 Residual Risk 로 내린다 — 후보는 사라지지 않는다.
+    """
+    authority = validated_run_authority(args.run_manifest)
+    groups_path = authority.run_dir / "state" / _canonical_run_artifact_name(
+        "convergence-groups", authority.task_type, authority.state_sequence
+    )
+    groups = load_owned_json_object(groups_path)
+    batch = load_owned_json_object(args.candidates)
+    if batch.get("taskKey") != _manifest_authority_string(authority.payload, "taskKey"):
+        raise ConvergenceContractError("acceptance batch taskKey does not match the run manifest")
+    if batch.get("mode") != "acceptance-devils-advocate":
+        raise ConvergenceContractError("acceptance batch mode must be acceptance-devils-advocate")
+    if not args.result:
+        raise ConvergenceContractError("pass at least one analyser --result")
+    roster = analysis_roster(groups)
+    votes: dict[str, dict[str, FindingVote]] = {}
+    for raw in args.result:
+        worker, path = _split_pair(raw, "--result")
+        if worker.removesuffix("-worker") in roster and worker not in roster:
+            worker = worker.removesuffix("-worker")
+        if worker not in roster:
+            raise ConvergenceContractError(
+                f"`{worker}` is not an analysis worker of this run; roster: {', '.join(roster)}"
+            )
+        votes[worker] = parse_finding_votes(Path(path).read_text(encoding="utf-8"))
+    candidates: list[dict[str, Any]] = []
+    for candidate in acceptance_candidates(batch, groups, next(iter(votes))):
+        row: dict[str, Any] = {}
+        for worker, parsed in votes.items():
+            vote = parsed.get(candidate.candidate_id)
+            if vote is None:
+                raise ConvergenceContractError(
+                    f"`{worker}` returned no verdict for {candidate.candidate_id}"
+                )
+            row[worker] = {"verdict": vote.verdict, "explanation": vote.explanation}
+        confirmed = any(v["verdict"] in {"agree", "supplement"} for v in row.values())
+        candidates.append({
+            "candidateId": candidate.candidate_id,
+            "statement": candidate.statement,
+            **({"severity": candidate.severity} if candidate.severity else {}),
+            "originEvidence": candidate.origin_evidence,
+            "verdict": "confirmed" if confirmed else "downgraded",
+            "votes": row,
+        })
+    write_json_atomic(args.output, {
+        "schemaVersion": "1.0",
+        "taskKey": batch["taskKey"],
+        "mode": "acceptance-devils-advocate",
+        "provider": batch.get("provider"),
+        "modelExecutionValue": batch.get("modelExecutionValue"),
+        "candidates": candidates,
+    })
+    load_acceptance_critic_batch(args.output)
+    return "collected", args.output
+
+
 def _worker_paths(raw_pairs: list[str], label: str) -> dict[str, Path]:
     paths: dict[str, Path] = {}
     for raw in raw_pairs:
@@ -1880,6 +1993,7 @@ def _execute(args: argparse.Namespace) -> tuple[Any, ...]:
         "apply-round": _apply_round,
         "apply-critic-gaps": _apply_critic_gaps,
         "apply-acceptance-critic": _apply_acceptance_critic,
+        "collect-acceptance-votes": _collect_acceptance_votes,
         "finalize": _finalize,
         "skip": _skip,
         "validate": _validate,

package/runtime/python/okstra_ctl/convergence_critic_prompt.py

@@ -288,6 +288,63 @@ def critic_prompt_body(
     return "".join(rows)
 
 
+_ACCEPTANCE_MANDATE = """
+The delivered work is about to be judged for acceptance. Your ONLY job is to find
+reasons it should NOT be accepted — surface candidate acceptance BLOCKERS the
+verifiers may have missed:
+- requirements / acceptance points with no covering evidence,
+- DB / IO / SQL changes lacking real-execution evidence,
+- regressions or broken error paths,
+- scope / contract violations.
+A finding that would not stop the release is not a blocker — say so, and it is
+recorded as a conditional-acceptance condition instead. Do NOT restate an existing
+Acceptance Blocker. If you find none, write `No candidate blockers.`
+
+Write each candidate as its own section, numbered from AC-001:
+
+### [AC-001] <one-line statement>
+**Severity**: critical | major
+**Evidence**: <file:line / log / test output you executed or read>
+""".strip()
+
+
+def acceptance_critic_prompt_body(
+    groups: Mapping[str, Any],
+    *,
+    analysis_packet_path: str,
+    results: Sequence[AnalyserResult],
+) -> str:
+    """final-verification acceptance critic 지시문 본문. 같은 입력이면 같은 바이트.
+
+    final-verification 프롬프트 본문은 96줄 상한을 받으므로 Round 0 finding 목록은
+    싣지 않는다 — 분석자 결과 파일 경로가 그 자리를 대신한다.
+    """
+    task_key = _nonempty_string(groups.get("taskKey"))
+    if not task_key:
+        raise CriticPromptError("convergence groups carry no taskKey")
+    packet = _nonempty_string(analysis_packet_path)
+    if not packet.endswith("analysis-packet.md"):
+        raise CriticPromptError(
+            "run manifest analysisPacketPath must name analysis-packet.md; "
+            f"found `{analysis_packet_path}`"
+        )
+    rows: list[str] = [
+        f"**Prompt Delivery Mode:** {PROMPT_DELIVERY_MODE}\n",
+        "\n",
+        f"# Acceptance critic — {task_key}\n",
+        "\n",
+        "## Inputs\n",
+        f"- Primary analysis packet: `{packet}`\n",
+        "\n",
+        "## Mandate\n",
+        "\n",
+        _ACCEPTANCE_MANDATE,
+        "\n\n",
+    ]
+    rows.extend(_analyser_rows(results))
+    return "".join(rows)
+
+
 def _round0_rows(groups: Mapping[str, Any]) -> list[str]:
     findings = [
         group for group in groups.get("groups") or [] if isinstance(group, Mapping)

package/runtime/python/okstra_ctl/convergence_critic_verify_prompt.py

@@ -237,3 +237,109 @@ def critic_verify_prompt_body(
     if len(gaps) > 1:
         rows.append(f"\n### {gaps[1].gap_id}\n**Verdict**: ...\n")
     return "".join(rows)
+
+
+@dataclass(frozen=True)
+class AcceptanceCandidate:
+    """acceptance critic 이 낸 후보 blocker 하나."""
+
+    candidate_id: str
+    statement: str
+    severity: str
+    origin_evidence: str
+
+
+def acceptance_candidates(
+    batch: Mapping[str, Any],
+    groups: Mapping[str, Any],
+    worker_id: str,
+) -> list[AcceptanceCandidate]:
+    """분석자 한 명이 검증할 후보 — 계약상 모든 분석자가 모든 후보를 본다."""
+    roster = analysis_roster(groups)
+    if worker_id not in roster and worker_id.removesuffix("-worker") in roster:
+        worker_id = worker_id.removesuffix("-worker")
+    if worker_id not in roster:
+        raise CriticVerifyPromptError(
+            f"`{worker_id}` is not an analysis worker of this run; roster: "
+            f"{', '.join(roster) or 'none'}"
+        )
+    raw = batch.get("candidates")
+    if not isinstance(raw, list) or not raw:
+        raise CriticVerifyPromptError("acceptance batch has no candidates array")
+    candidates: list[AcceptanceCandidate] = []
+    seen: set[str] = set()
+    for row in raw:
+        if not isinstance(row, Mapping):
+            raise CriticVerifyPromptError("acceptance candidate must be an object")
+        candidate_id = _nonempty_string(row.get("candidateId"))
+        if not candidate_id:
+            raise CriticVerifyPromptError("acceptance candidate has no candidateId")
+        if candidate_id in seen:
+            raise CriticVerifyPromptError(f"duplicate candidateId: {candidate_id}")
+        seen.add(candidate_id)
+        candidates.append(AcceptanceCandidate(
+            candidate_id=candidate_id,
+            statement=_nonempty_string(row.get("statement")),
+            severity=_nonempty_string(row.get("severity")),
+            origin_evidence=_nonempty_string(row.get("originEvidence")),
+        ))
+    return candidates
+
+
+_ACCEPTANCE_EVIDENCE_ACCESS = """Each candidate claims the delivered work should NOT be accepted. The complete
+claim is the critic's own item: before judging, open the `**Origin item**` file at
+the section whose heading names the candidate id, and the `**Origin audit sidecar**`, and
+re-run or re-read what they cite. SURVIVES means you reproduced the problem or
+found evidence that supports it; the candidate then becomes an Acceptance Blocker.
+A candidate no analyser lets survive is downgraded to a Residual Risk, never
+dropped."""
+
+
+def acceptance_verify_prompt_body(
+    *,
+    task_key: str,
+    critic_worker: str,
+    critic_result_path: str,
+    critic_audit_path: str,
+    candidates: Sequence[AcceptanceCandidate],
+) -> str:
+    """acceptance 후보 확인·강등 지시문 본문. 같은 입력이면 같은 바이트를 낸다."""
+    if not _nonempty_string(task_key):
+        raise CriticVerifyPromptError("run manifest carries no taskKey")
+    if not candidates:
+        raise CriticVerifyPromptError("no acceptance candidates to verify")
+    rows = [
+        "## Instructions\n\n",
+        f"{RENDERED_BY_LINE}\n\n",
+        f"Perform ADVERSARIAL acceptance-candidate verification for {task_key} "
+        f"(dispatch kind `{CRITIC_VERIFY_DISPATCH_KIND}`, one round).\n\n",
+        ADVERSARIAL_MANDATE, "\n\n",
+        _ACCEPTANCE_EVIDENCE_ACCESS, "\n\n",
+        "## Findings to verify\n",
+    ]
+    for candidate in candidates:
+        rows.append(
+            f"\n### {candidate.candidate_id}: {candidate.statement or '(no statement)'}\n"
+        )
+        rows.append(f"**Origin**: {critic_worker}\n")
+        rows.append(f"**Severity**: {candidate.severity or '(none recorded)'}\n")
+        rows.append(
+            f"**Cited evidence**: {candidate.origin_evidence or '(none recorded)'}\n"
+        )
+        # 헤딩 모양은 critic 이 정한다(`### [AC-001]`, `### AC-001 — …`); id 만 가리킨다.
+        rows.append(
+            f"**Origin item**: `{critic_result_path}` — the section headed "
+            f"`{candidate.candidate_id}`\n"
+        )
+        rows.append(f"**Origin audit sidecar**: `{critic_audit_path}`\n")
+    rows.append("\n## Response format\n\n")
+    rows.append(
+        "One block per candidate, headed by the candidate id at exactly three hashes. "
+        "Field labels are bold with the colon outside (`**Verdict**: …`); the "
+        "collector also reads `**Verdict:** …` and `- Verdict: …` as the same field.\n\n"
+    )
+    rows.append(ADVERSARIAL_RESPONSE.replace("<finding-id>", candidates[0].candidate_id))
+    rows.append("\n")
+    if len(candidates) > 1:
+        rows.append(f"\n### {candidates[1].candidate_id}\n**Verdict**: ...\n")
+    return "".join(rows)