okstra 0.179.2 → 0.183.2

package/runtime/python/okstra_ctl/contract_graph_cli.py

@@ -0,0 +1,62 @@
+"""런타임 계약 그래프 검증 명령 진입점."""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+from .contract_graph import (
+    ContractFile,
+    ContractGraphError,
+    ContractGraphRoot,
+    ContractGraphValidator,
+    ContractSelection,
+)
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="okstra contract-check",
+        description="Validate runtime contract documents and dependencies.",
+    )
+    parser.add_argument("--root", required=True, type=Path)
+    selection = parser.add_mutually_exclusive_group()
+    selection.add_argument("--profile")
+    selection.add_argument("--operation")
+    return parser
+
+
+def _record(row: ContractFile) -> dict[str, str]:
+    return {
+        "path": row.relative_path,
+        "schemaVersion": row.schema_version,
+        "sha256": row.sha256,
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    selected = None
+    if args.profile is not None or args.operation is not None:
+        selected = ContractSelection(args.profile, args.operation)
+    try:
+        graph = ContractGraphValidator().validate(
+            ContractGraphRoot.from_base(args.root), selected=selected
+        )
+        if args.profile is not None:
+            rows = graph.dependencies_for_profile(args.profile)
+        elif args.operation is not None:
+            rows = graph.dependencies_for_operation(args.operation)
+        else:
+            rows = graph.files
+    except ContractGraphError as exc:
+        for error in exc.errors:
+            print(error, file=sys.stderr)
+        return 1
+    print(json.dumps([_record(row) for row in rows], indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/runtime/python/okstra_ctl/convergence.py

@@ -3,11 +3,14 @@ from __future__ import annotations
 
 import argparse
 from collections.abc import Mapping
+from dataclasses import dataclass
 import json
 from pathlib import Path, PurePosixPath
 import sys
 from typing import Any
 
+from okstra_project.state import StateError, parse_task_key, slugify
+
 from .convergence_engine import (
     ConvergenceContractError,
     apply_critic_gap_results,
@@ -27,16 +30,107 @@ from .convergence_migration import (
 from .convergence_provenance import (
     GROUPS_BASENAME_RE,
     provenance_errors,
+    worker_result_suffix,
 )
 from .convergence_store import (
-    load_json_object,
+    load_convergence_critic_batch,
+    load_convergence_round_results,
+    load_owned_json_object,
     write_final_state_atomic,
     write_json_atomic,
 )
 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 .report_finalize import task_manifest_path
 from .verdict_blocks import FindingVote, VerdictBlockError, parse_finding_votes
+from .fixed_text import line
+
+
+@dataclass(frozen=True)
+class RunArtifactAuthority:
+    manifest_path: Path
+    project_root: Path
+    run_dir: Path
+    task_type: str
+    task_key: str
+    manifest_ref: str
+    state_sequence: str
+    execution_manifest: ExecutionManifest | None
+    payload: Mapping[str, Any]
+
+
+def validated_run_authority(manifest_path: Path) -> RunArtifactAuthority:
+    supplied = Path(manifest_path)
+    if not supplied.is_absolute() or supplied.absolute() != supplied.resolve():
+        raise ConvergenceContractError("run manifest path is not canonical")
+    payload = load_owned_json_object(supplied)
+    execution_manifest = None
+    if payload.get("executionIdentityVersion") == 2:
+        execution_manifest, view = read_execution_manifest_view(supplied)
+        payload = dict(view)
+    project_root = _manifest_project_root(payload)
+    manifest_ref = _manifest_run_ref(payload, project_root, supplied)
+    run_dir, task_type, state_sequence = _validated_run_artifact_authority(
+        payload, project_root, supplied, manifest_ref
+    )
+    task_key = _manifest_authority_string(payload, "taskKey")
+    try:
+        _project_id, task_group, task_id = parse_task_key(task_key)
+    except StateError as exc:
+        raise ConvergenceContractError(str(exc)) from exc
+    recovered = RunRef.from_run_dir(run_dir)
+    if (slugify(task_group), slugify(task_id)) != (
+        recovered.task_group, recovered.task_id
+    ):
+        raise ConvergenceContractError(
+            "run manifest taskKey does not match run directory"
+        )
+    return RunArtifactAuthority(
+        supplied, project_root, run_dir, task_type, task_key, manifest_ref,
+        state_sequence, execution_manifest, payload,
+    )
+
+
+def canonical_run_state_artifact(
+    authority: RunArtifactAuthority,
+    *,
+    manifest_field: str,
+    prefix: str,
+    label: str,
+) -> Path:
+    value = _manifest_authority_string(authority.payload, manifest_field)
+    supplied = _canonical_project_artifact_path(
+        authority.project_root, value, label
+    )
+    expected = authority.run_dir / "state" / _canonical_run_artifact_name(
+        prefix, authority.task_type, authority.state_sequence
+    )
+    if supplied != expected:
+        raise ConvergenceContractError(f"{label} does not match run authority")
+    return expected
+
+
+def canonical_run_report_artifact(authority: RunArtifactAuthority) -> Path:
+    report_sequence = _manifest_sequence(authority.payload, "reports")
+    try:
+        expected = RunRef.from_run_dir(
+            authority.run_dir, seq=int(report_sequence)
+        ).report
+    except ValueError as exc:
+        raise ConvergenceContractError(
+            "run manifest report sequence is not canonical"
+        ) from exc
+    value = _manifest_authority_string(
+        authority.payload, "expectedReportRecordPath"
+    )
+    supplied = _canonical_project_artifact_path(
+        authority.project_root, value, "report path"
+    )
+    if supplied != expected:
+        raise ConvergenceContractError("report path does not match run authority")
+    return expected
 
 
 _EVIDENCE_ARTIFACT = {
@@ -197,6 +291,11 @@ def _parser() -> argparse.ArgumentParser:
     seed.add_argument("--final-state", type=Path, required=True)
     seed.add_argument("--migration-dir", type=Path, required=True)
     seed.add_argument("--restart-from-round0", action="store_true")
+    prepare = subparsers.add_parser(
+        "prepare-groups", help="publish grouped findings from fixed Markdown"
+    )
+    prepare.add_argument("--run-manifest", type=Path, required=True)
+    prepare.add_argument("--input", type=Path, required=True)
 
     plan = subparsers.add_parser("plan-round", help="write the next dispatch plan")
     plan.add_argument("--work-state", type=Path, required=True)
@@ -292,7 +391,7 @@ def _resume_after_legacy_final(
         source_path=final_state_path,
         migration_dir=migration_dir,
     )
-    state = load_json_object(work_state_path)
+    state = load_owned_json_object(work_state_path)
     state["migration"] = migration_record(final_state_path, archive_path, digest)
     write_json_atomic(work_state_path, state)
 
@@ -305,16 +404,21 @@ def _seeded_groups_provenance_errors(groups_path: Path, document: dict) -> list[
     file, and the same claims are re-checked at Phase 7 by `validate-run`,
     where a bad `itemId` surfaces hours later as a blocked approval.
     """
-    match = GROUPS_BASENAME_RE.match(groups_path.name)
-    if match is None:
+    if GROUPS_BASENAME_RE.match(groups_path.name) is None:
         return []
-    worker_results_dir = groups_path.parent.parent / "worker-results"
+    run_dir = groups_path.parent.parent
+    worker_results_dir = run_dir / "worker-results"
     if not worker_results_dir.is_dir():
         return []
+    # 그룹 파일명이 지닌 것은 state 시퀀스다. 워커 결과는 workerResults 시퀀스로
+    # 이름 붙으므로 그룹 문서가 기록한 run manifest 를 거쳐 해소한다.
+    suffix = worker_result_suffix(run_dir, document)
+    if suffix is None:
+        return []
     return provenance_errors(
         document,
         worker_results_dir=worker_results_dir,
-        suffix=match.group("suffix"),
+        suffix=suffix,
         groups_label=groups_path.name,
     )
 
@@ -698,7 +802,7 @@ def _canonical_project_artifact_path(
 
 
 def _seed(args: argparse.Namespace) -> tuple[str, Path]:
-    grouped_input = load_json_object(args.groups)
+    grouped_input = load_owned_json_object(args.groups)
     execution_manifest = _seed_execution_manifest(
         args.groups,
         grouped_input,
@@ -746,7 +850,7 @@ def _seed(args: argparse.Namespace) -> tuple[str, Path]:
 
 
 def _plan_round(args: argparse.Namespace) -> tuple[str, Path]:
-    state = load_json_object(args.work_state)
+    state = load_owned_json_object(args.work_state)
     errors = validate_working_state(state)
     if errors:
         raise ConvergenceContractError("invalid working state: " + "; ".join(errors))
@@ -756,10 +860,10 @@ def _plan_round(args: argparse.Namespace) -> tuple[str, Path]:
 
 
 def _apply_round(args: argparse.Namespace) -> tuple[str, Path]:
-    state = load_json_object(args.work_state)
+    state = load_owned_json_object(args.work_state)
     _validated_v2_work_authority(args.work_state, state)
-    plan = load_json_object(args.plan)
-    results = load_json_object(args.results)
+    plan = load_owned_json_object(args.plan)
+    results = load_convergence_round_results(args.results)
     updated = apply_round_results(state, plan, results)
     errors = validate_working_state(updated)
     if errors:
@@ -769,16 +873,16 @@ def _apply_round(args: argparse.Namespace) -> tuple[str, Path]:
 
 
 def _apply_critic_gaps(args: argparse.Namespace) -> tuple[str, Path]:
-    state = load_json_object(args.work_state)
+    state = load_owned_json_object(args.work_state)
     _validated_v2_work_authority(args.work_state, state)
-    results = load_json_object(args.results)
+    results = load_convergence_critic_batch(args.results)
     updated = apply_critic_gap_results(state, results)
     write_json_atomic(args.work_state, updated)
     return "applied", args.work_state
 
 
 def _finalize(args: argparse.Namespace) -> tuple[str, Path]:
-    state = load_json_object(args.work_state)
+    state = load_owned_json_object(args.work_state)
     authority = _validated_v2_work_authority(args.work_state, state)
     if authority is not None:
         _manifest, run_dir, task_type, state_sequence = authority
@@ -797,7 +901,7 @@ def _finalize(args: argparse.Namespace) -> tuple[str, Path]:
 
 
 def _validate(args: argparse.Namespace) -> tuple[str, Path]:
-    state = load_json_object(args.state)
+    state = load_owned_json_object(args.state)
     errors = (
         validate_working_state(state)
         if args.kind == "working"
@@ -881,7 +985,7 @@ def _worker_votes(
 
 
 def _collect_results(args: argparse.Namespace) -> tuple[str, Path]:
-    plan = load_json_object(args.plan)
+    plan = load_owned_json_object(args.plan)
     planned = _planned_finding_ids(plan)
     dispatches = _dispatch_rows(args.dispatch)
     undispatched = sorted(set(planned) - {row["worker"] for row in dispatches})
@@ -909,8 +1013,222 @@ def _collect_results(args: argparse.Namespace) -> tuple[str, Path]:
     return "collected", args.output
 
 
+def _parse_grouping_markdown(path: Path) -> list[dict[str, Any]]:
+    groups: list[dict[str, Any]] = []
+    fields: dict[str, list[str]] = {}
+    finding_id = ""
+    for raw in [*path.read_text(encoding="utf-8").splitlines(), "## END"]:
+        if raw.startswith("## "):
+            if finding_id:
+                groups.append(_group_from_fields(finding_id, fields))
+            finding_id = raw[3:].strip()
+            fields = {}
+        elif ":" in raw and finding_id:
+            key, value = raw.split(":", 1)
+            fields.setdefault(key.strip().lower(), []).append(value.strip())
+    return groups
+
+
+def _parse_group_source(spec: str) -> tuple[str, str, str]:
+    identity, separator, evidence = spec.partition("|")
+    worker, colon, item_id = identity.strip().partition(":")
+    if not separator or not colon or not all((worker, item_id, evidence.strip())):
+        raise ConvergenceContractError(
+            "Source must use worker:item-id | evidence"
+        )
+    return worker, item_id, evidence.strip()
+
+
+def _group_from_fields(
+    finding_id: str, fields: Mapping[str, list[str]]
+) -> dict[str, Any]:
+    scalar = {
+        key: values[0] if len(values) == 1 else ""
+        for key, values in fields.items() if key != "source"
+    }
+    source_rows = fields.get("source", [])
+    if source_rows:
+        parsed = [_parse_group_source(spec) for spec in source_rows]
+    else:
+        specs = [part.strip() for part in scalar.get("sources", "").split(",") if part.strip()]
+        if len(specs) != 1 or not scalar.get("evidence"):
+            raise ConvergenceContractError(
+                "multi-worker groups require one Source per worker"
+            )
+        worker, colon, item_id = specs[0].partition(":")
+        if not colon or not worker or not item_id:
+            raise ConvergenceContractError("Sources must use worker:item-id entries")
+        parsed = [(worker, item_id, scalar["evidence"])]
+    discovered, source_items = _group_source_provenance(parsed)
+    origin_worker, separator, origin_item = scalar.get("origin", "").partition(":")
+    if not separator or discovered.get(origin_worker, {}).get("itemId") != origin_item:
+        raise ConvergenceContractError("Origin must identify one Source item")
+    return {
+        "findingId": finding_id, "summary": scalar.get("summary", ""),
+        "category": scalar.get("category", ""),
+        "ticketIds": [item.strip() for item in scalar.get("tickets", "").split(",") if item.strip()],
+        "originWorker": origin_worker,
+        "originEvidence": discovered[origin_worker]["evidence"],
+        "discoveredBy": discovered,
+        "sourceItems": source_items,
+    }
+
+
+def _group_source_provenance(
+    parsed: list[tuple[str, str, str]],
+) -> tuple[dict[str, dict[str, str]], list[dict[str, str]]]:
+    workers = [worker for worker, _item, _evidence in parsed]
+    if len(workers) != len(set(workers)):
+        raise ConvergenceContractError("duplicate Source worker in one finding")
+    discovered = {
+        worker: {"itemId": item, "evidence": evidence}
+        for worker, item, evidence in parsed
+    }
+    sources = [
+        {"worker": worker, "itemId": item}
+        for worker, item, _evidence in parsed
+    ]
+    if any(discovered[row["worker"]]["itemId"] != row["itemId"] for row in sources):
+        raise ConvergenceContractError("discoveredBy and sourceItems do not match")
+    return discovered, sources
+
+
+def _assignment_identity(row: Mapping[str, Any]) -> tuple[str, str, str]:
+    role = str(row.get("role") or "")
+    provider = str(row.get("provider") or "")
+    model = str(row.get("modelExecutionValue") or row.get("model") or "")
+    if not all((role, provider, model)):
+        raise ConvergenceContractError(
+            "worker assignment requires role, provider, and model"
+        )
+    return role, provider, model
+
+
+def _execution_model(row: Mapping[str, Any]) -> str:
+    binding = row.get("binding")
+    if isinstance(binding, Mapping) and binding.get("resolvedExecutionValue"):
+        return str(binding["resolvedExecutionValue"])
+    return str(row.get("modelId") or "")
+
+
+def _group_assignment_identity(
+    manifest: Mapping[str, Any], worker_id: str,
+) -> tuple[str, str, str, int]:
+    assignments = manifest.get("workerAssignments") if isinstance(manifest.get("workerAssignments"), list) else []
+    normalized = worker_id.removesuffix("-worker")
+    if normalized == "lead":
+        duplicate = any(
+            isinstance(row, Mapping)
+            and str(row.get("workerId", "")).removesuffix("-worker") == "lead"
+            for row in assignments
+        )
+        if duplicate:
+            raise ConvergenceContractError("ambiguous lead assignment identity")
+        lead = manifest.get("leadAssignment")
+        if not isinstance(lead, Mapping):
+            raise ConvergenceContractError("lead assignment identity is missing")
+        role, provider, model = _assignment_identity(lead)
+        if role != "lead":
+            raise ConvergenceContractError("leadAssignment role must be lead")
+        return "leader", provider, model, 1
+    matches = [(index, row) for index, row in enumerate(assignments)
+               if isinstance(row, Mapping)
+               and str(row.get("workerId", "")).removesuffix("-worker") == normalized]
+    if len(matches) != 1:
+        raise ConvergenceContractError(
+            f"worker assignment identity is missing or duplicate for {worker_id}"
+        )
+    index, assignment = matches[0]
+    role, provider, model = _assignment_identity(assignment)
+    ordinal = sum(
+        1 for row in assignments[:index + 1]
+        if isinstance(row, Mapping) and str(row.get("role") or "") == role
+    )
+    return role, provider, model, ordinal
+
+
+def _group_worker(manifest: Mapping[str, Any], worker_id: str) -> dict[str, str]:
+    role, provider, model, ordinal = _group_assignment_identity(
+        manifest, worker_id
+    )
+    executions = manifest.get("roleExecutions") if isinstance(manifest.get("roleExecutions"), list) else []
+    candidates = [row for row in executions if isinstance(row, Mapping)
+                  and row.get("role") == role and row.get("provider") == provider
+                  and _execution_model(row) == model and row.get("ordinal") == ordinal]
+    if len(candidates) != 1:
+        raise ConvergenceContractError(f"no canonical role execution for {worker_id}")
+    execution = candidates[0]
+    if not execution.get("participantRef") or not execution.get("roleExecutionRef"):
+        raise ConvergenceContractError(f"no canonical role execution for {worker_id}")
+    audience = "report-writer" if role == "report-writer" else "lead" if role in {"lead", "leader"} else "analysis"
+    return {"workerId": worker_id, "audience": audience,
+            "participantRef": str(execution["participantRef"]),
+            "sourceRoleExecutionRef": str(execution["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` 로
+    확정하므로, 세 워커의 처방이 서로 달라도 합의로 기록된다.
+
+    설정이 없으면 기본값으로 떨어지지 않고 실패한다. 여기서 조용히 넘어가면
+    검증 자체가 사라지고 산출물은 정상으로 읽힌다.
+    """
+    path = task_manifest_path(authority.project_root, authority.payload)
+    payload = load_owned_json_object(path)
+    config = payload.get("convergence")
+    if not isinstance(config, Mapping):
+        raise ConvergenceContractError(
+            f"task manifest carries no convergence config: {path}"
+        )
+    return config
+
+
+def _prepare_groups(args: argparse.Namespace) -> tuple[str, Path]:
+    authority = validated_run_authority(args.run_manifest)
+    manifest = authority.payload
+    groups = _parse_grouping_markdown(args.input)
+    worker_ids = list(dict.fromkeys(
+        source["worker"] for group in groups for source in group["sourceItems"]
+    ))
+    output = authority.run_dir / "state" / _canonical_run_artifact_name(
+        "convergence-groups", authority.task_type, authority.state_sequence
+    )
+    config = _convergence_config(authority)
+    workers = [_group_worker(manifest, worker) for worker in worker_ids]
+    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)),
+                          "maxRounds": int(config.get("maxRounds", 2)),
+                          "effectiveMaxRounds": int(config.get("effectiveMaxRounds", 2)),
+                          "verificationMode": str(config.get("verificationMode", "lightweight"))},
+               "workers": workers, "groups": groups}
+    schema_errors = validate_schema(
+        payload, load_named_schema("convergence-groups-v2.0.schema.json")
+    )
+    if schema_errors:
+        raise ConvergenceContractError(
+            "invalid convergence groups: " + "; ".join(schema_errors)
+        )
+    seed_working_state(
+        payload, execution_manifest=authority.execution_manifest
+    )
+    write_json_atomic(output, payload)
+    return "prepared", output
+
+
 def _execute(args: argparse.Namespace) -> tuple[str, Path]:
     operations: dict[str, Any] = {
+        "prepare-groups": _prepare_groups,
         "seed": _seed,
         "plan-round": _plan_round,
         "collect-results": _collect_results,
@@ -943,7 +1261,10 @@ def main(argv: list[str] | None = None) -> int:
     except OSError as exc:
         print(f"error: {exc}", file=sys.stderr)
         return 1
-    _emit(args.operation, action, path)
+    if args.operation == "prepare-groups":
+        print("Convergence groups\n" + line("Status", "ready") + line("Action", action), end="")
+    else:
+        _emit(args.operation, action, path)
     return 0
 
 

package/runtime/python/okstra_ctl/convergence_engine.py

@@ -21,6 +21,7 @@ _AUDIENCES = {"analysis", "lead", "report-writer"}
 _FINDING_SOURCE_AUDIENCES = {"analysis", "lead"}
 _AUDIENCE_SOURCE_ROLES = {
     "analysis": frozenset({"analyser", "designer", "planner", "verifier"}),
+    "lead": frozenset({"leader"}),
     "report-writer": frozenset({"report-writer"}),
 }
 _VERIFICATION_MODES = {"lightweight", "full-reanalysis"}
@@ -809,7 +810,7 @@ def _parse_critic_dispatches(
         worker = _required_string(row, "worker", f"critic dispatches[{index}]")
         if worker in seen:
             raise ConvergenceContractError(f"duplicate critic voter dispatch: {worker}")
-        if worker not in roster or _is_critic_worker(worker, provider):
+        if worker not in roster:
             raise ConvergenceContractError(
                 f"critic voter must be a non-critic analyser: {worker}"
             )
@@ -823,9 +824,7 @@ def _parse_critic_dispatches(
             )
         seen.add(worker)
         dispatches.append({"worker": worker, "status": status, "durationMs": duration})
-    expected = {
-        worker for worker in roster if not _is_critic_worker(worker, provider)
-    }
+    expected = set(roster)
     if seen != expected:
         missing = sorted(expected - seen)
         raise ConvergenceContractError(
@@ -869,7 +868,7 @@ def _parse_critic_gap(
     votes_value = _object(gap.get("votes"), f"{label}.votes")
     votes: dict[str, dict[str, Any]] = {}
     for worker, raw_vote in votes_value.items():
-        if worker not in roster or _is_critic_worker(worker, provider):
+        if worker not in roster:
             raise ConvergenceContractError(
                 f"critic voter must be a non-critic analyser: {worker}"
             )
@@ -1435,15 +1434,9 @@ def _validate_critic_roster(
             errors.append("criticVerification.analyserRoster does not match workers")
     for row in dispatches if isinstance(dispatches, list) else []:
         worker = row.get("worker") if isinstance(row, Mapping) else None
-        if (
-            not _nonempty_string(worker)
-            or worker not in roster
-            or _is_critic_worker(worker, provider)
-        ):
+        if not _nonempty_string(worker) or worker not in roster:
             errors.append(f"critic voter must be a non-critic analyser: {worker}")
-    expected_dispatches = {
-        worker for worker in roster if not _is_critic_worker(worker, provider)
-    }
+    expected_dispatches = set(roster)
     actual_dispatches = {
         row.get("worker")
         for row in dispatches
@@ -1467,17 +1460,13 @@ def _validate_critic_roster(
     for gap in gaps if isinstance(gaps, list) else []:
         votes = gap.get("votes") if isinstance(gap, Mapping) else None
         for voter in votes if isinstance(votes, Mapping) else {}:
-            if voter not in roster or _is_critic_worker(voter, provider):
+            if voter not in roster:
                 errors.append(f"critic voter must be a non-critic analyser: {voter}")
             elif voter not in completed:
                 errors.append(f"critic voter has no completed dispatch: {voter}")
     return errors
 
 
-def _is_critic_worker(worker: Any, provider: Any) -> bool:
-    return isinstance(provider, str) and worker in {provider, f"{provider}-worker"}
-
-
 def _final_collaborative_classification(finding: Mapping[str, Any]) -> str:
     usable: list[Mapping[str, Any]] = []
     for round_row in finding.get("rounds", []):
@@ -2135,6 +2124,9 @@ def _validate_worker_execution_identity(
                 f"{worker['audience']} audience source role is not allowed: "
                 f"{source.role}"
             )
+    source_refs = [worker["sourceRoleExecutionRef"] for worker in workers]
+    if len(source_refs) != len(set(source_refs)):
+        raise ConvergenceContractError("duplicate sourceRoleExecutionRef")
 
 
 def _parse_groups(