okstra 0.207.0 → 0.208.0

package/runtime/python/okstra_ctl/business_flow/store.py

@@ -0,0 +1,388 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any, cast
+
+from ..json_boundary import JsonBoundaryError
+from ..run_context import dir_flock
+from .contracts import (
+    BusinessFact,
+    BusinessFlowError,
+    BusinessKnowledge,
+    BusinessResolution,
+    ClaimProducer,
+    FlowExecution,
+    FlowRequest,
+    SourceSnapshot,
+    StoredClaim,
+    TaskLink,
+    TaskLinkRow,
+    artifact_path,
+    fingerprint,
+    now_iso,
+    read_artifact,
+    write_artifact,
+)
+from .source import candidate_projects, capture_project
+
+CONFIRMED_LEVELS = frozenset({"static", "execution-verified"})
+
+
+def task_link_path(project_root: Path, task_key: str) -> Path:
+    return artifact_path(
+        project_root, "task-links", fingerprint(task_key), "links.json"
+    )
+
+
+def read_task_links(project_root: Path, task_key: str) -> TaskLink:
+    path = task_link_path(project_root, task_key)
+    return (
+        cast(TaskLink, read_artifact(path, "taskLink"))
+        if path.exists()
+        else {"schemaVersion": 1, "taskKey": task_key, "executions": []}
+    )
+
+
+def record_task_execution(
+    request: FlowRequest, execution: FlowExecution, input_digest: str
+) -> TaskLinkRow:
+    path = task_link_path(request.project_root, request.task_key)
+    row: TaskLinkRow = {
+        "id": execution["id"],
+        "mode": request.mode,
+        "status": execution["status"],
+        "inputDigest": input_digest,
+        "reports": execution.get("reports", {}),
+        "summary": execution.get("result", {}).get("summary", ""),
+        "error": execution.get("error", ""),
+    }
+    with dir_flock(path.parent, ".links.lock"):
+        links = read_task_links(request.project_root, request.task_key)
+        if not any(item["id"] == row["id"] for item in links["executions"]):
+            links["executions"].append(row)
+        write_artifact(path, links, "taskLink")
+    return row
+
+
+def read_knowledge(project_root: Path) -> BusinessKnowledge:
+    path = artifact_path(project_root, "knowledge.json")
+    if not path.exists():
+        return {"schemaVersion": 1, "claims": [], "resolutions": []}
+    return cast(BusinessKnowledge, read_artifact(path, "knowledge"))
+
+
+def contribute_knowledge(
+    project_root: Path,
+    facts: list[BusinessFact],
+    projects: list[SourceSnapshot],
+    producer: ClaimProducer,
+) -> dict[str, Any]:
+    path = artifact_path(project_root, "knowledge.json")
+    with dir_flock(path.parent, ".knowledge.lock"):
+        data = read_knowledge(project_root)
+        claims = [_claim(fact, projects, producer) for fact in facts]
+        by_id = {row["id"]: row for row in data["claims"]}
+        added = []
+        for claim in claims:
+            if claim["id"] in by_id:
+                existing = by_id[claim["id"]]
+                if producer not in existing["producers"]:
+                    existing["producers"].append(producer)
+                for key in ("aliases", "relatedKeys", "executionEvidence"):
+                    if key in claim:
+                        existing[key] = list(
+                            dict.fromkeys(existing.get(key, []) + claim[key])
+                        )
+                continue
+            data["claims"].append(claim)
+            by_id[claim["id"]] = claim
+            added.append(claim["id"])
+        _mark_conflicts(data["claims"])
+        write_artifact(path, data, "knowledge")
+    return {
+        "added": added,
+        "conflicts": [
+            row["id"] for row in data["claims"] if row["status"] == "conflict"
+        ],
+    }
+
+
+def _claim(
+    fact: BusinessFact, projects: list[SourceSnapshot], producer: ClaimProducer
+) -> StoredClaim:
+    ids = {evidence["projectId"] for evidence in fact["evidence"]}
+    states = {
+        row["projectId"]: {
+            "root": row["root"],
+            "digest": row["digest"],
+            "head": row["head"],
+        }
+        for row in projects
+        if row["projectId"] in ids
+    }
+    identity = {
+        "key": fact["key"],
+        "value": fact["value"],
+        "level": fact["level"],
+        "sourceStates": {key: row["digest"] for key, row in states.items()},
+    }
+    return {
+        **fact,
+        "id": fingerprint(identity),
+        "sourceStates": states,
+        "producer": producer,
+        "producers": [producer],
+        "createdAt": now_iso(),
+        "status": "accepted",
+    }
+
+
+def _mark_conflicts(claims: list[StoredClaim]) -> None:
+    groups: dict[str, list[StoredClaim]] = {}
+    for claim in claims:
+        if claim["level"] not in CONFIRMED_LEVELS or claim["status"] == "superseded":
+            continue
+        if not claim["sourceStates"] or any(
+            not row["digest"] for row in claim["sourceStates"].values()
+        ):
+            continue
+        state = {key: row["digest"] for key, row in claim["sourceStates"].items()}
+        groups.setdefault(
+            fingerprint({"key": claim["key"], "states": state}), []
+        ).append(claim)
+    for rows in groups.values():
+        if len({row["value"] for row in rows}) > 1:
+            for row in rows:
+                row["status"] = "conflict"
+
+
+def resolve_conflicts(
+    project_root: Path, resolutions: list[BusinessResolution], producer: ClaimProducer
+) -> None:
+    path = artifact_path(project_root, "knowledge.json")
+    with dir_flock(path.parent, ".knowledge.lock"):
+        data = read_knowledge(project_root)
+        validate_resolutions(read_shared_knowledge(project_root), resolutions)
+        by_id = {row["id"]: row for row in data["claims"]}
+        for resolution in resolutions:
+            ids = resolution["claimIds"]
+            rows = [by_id[key] for key in ids if key in by_id]
+            for row in rows:
+                row["status"] = (
+                    "accepted"
+                    if row["id"] == resolution["acceptedClaimId"]
+                    else "superseded"
+                )
+            data["resolutions"].append(
+                {**resolution, "producer": producer, "createdAt": now_iso()}
+            )
+        write_artifact(path, data, "knowledge")
+
+
+def validate_resolutions(
+    data: BusinessKnowledge, resolutions: list[BusinessResolution]
+) -> None:
+    by_id = {row["id"]: row for row in data["claims"]}
+    visited = set()
+    for resolution in resolutions:
+        ids = set(resolution["claimIds"])
+        if (
+            not ids.issubset(by_id)
+            or resolution["acceptedClaimId"] not in ids
+            or ids & visited
+        ):
+            raise BusinessFlowError(
+                "conflict resolution references unknown or repeated claims"
+            )
+        rows = _resolution_rows(data["claims"], resolution)
+        state = fingerprint(
+            {key: source["digest"] for key, source in rows[0]["sourceStates"].items()}
+        )
+        group = {
+            row["id"]
+            for row in data["claims"]
+            if row["key"] == rows[0]["key"]
+            and row["status"] == "conflict"
+            and fingerprint(
+                {key: source["digest"] for key, source in row["sourceStates"].items()}
+            )
+            == state
+        }
+        if ids != group:
+            raise BusinessFlowError(
+                "conflict resolution must cover the complete active conflict"
+            )
+        visited.update(ids)
+
+
+def _resolution_rows(
+    claims: list[StoredClaim],
+    resolution: BusinessResolution,
+) -> list[StoredClaim]:
+    by_id = {row["id"]: row for row in claims}
+    ids = set(resolution["claimIds"])
+    if not ids.issubset(by_id) or resolution["acceptedClaimId"] not in ids:
+        raise BusinessFlowError("conflict resolution references unknown claims")
+    rows = [by_id[key] for key in ids]
+    states = {
+        fingerprint(
+            {key: state["digest"] for key, state in row["sourceStates"].items()}
+        )
+        for row in rows
+    }
+    if len({row["key"] for row in rows}) != 1 or len(states) != 1:
+        raise BusinessFlowError("conflict resolution mixes subjects or source versions")
+    return rows
+
+
+def read_shared_knowledge(project_root: Path) -> dict[str, Any]:
+    claims, resolutions, errors = [], [], []
+    candidates = candidate_projects(FlowRequest(project_root, "business"))
+    for candidate in candidates:
+        root = Path(candidate["root"])
+        try:
+            data = read_knowledge(root)
+            claims.extend({**claim, "ownerRoot": str(root)} for claim in data["claims"])
+            resolutions.extend(data["resolutions"])
+        except (OSError, BusinessFlowError, JsonBoundaryError) as exc:
+            errors.append(f"{candidate['projectId']}: {exc}")
+    _apply_shared_resolutions(claims, resolutions, errors)
+    _mark_conflicts(claims)
+    return {"claims": claims, "errors": errors}
+
+
+def _apply_shared_resolutions(
+    claims: list[StoredClaim],
+    resolutions: list[BusinessResolution],
+    errors: list[str],
+) -> None:
+    decisions: dict[frozenset[str], set[str]] = {}
+    for resolution in resolutions:
+        group = frozenset(resolution["claimIds"])
+        decisions.setdefault(group, set()).add(resolution["acceptedClaimId"])
+    disputed = {group for group, accepted in decisions.items() if len(accepted) > 1}
+    for resolution in resolutions:
+        try:
+            _resolution_rows(claims, resolution)
+        except BusinessFlowError as exc:
+            errors.append(f"Stored conflict resolution unavailable: {exc}")
+            continue
+        group = frozenset(resolution["claimIds"])
+        if group in disputed:
+            errors.append(
+                "Contradictory shared conflict resolutions: " + ", ".join(sorted(group))
+            )
+            continue
+        for row in claims:
+            if row["id"] in group:
+                row["status"] = (
+                    "accepted"
+                    if row["id"] == resolution["acceptedClaimId"]
+                    else "superseded"
+                )
+    for row in claims:
+        if any(row["id"] in group for group in disputed):
+            row["status"] = "conflict"
+
+
+def query_knowledge(
+    project_root: Path, query: str, source_root: Path | None = None
+) -> dict[str, Any]:
+    sources = {
+        row["projectId"]: row["root"]
+        for row in candidate_projects(
+            FlowRequest(project_root, query or "business", source_root=source_root)
+        )
+    }
+    tokens = set(re.findall(r"[\w-]{2,}", query.casefold()))
+    shared = read_shared_knowledge(project_root)
+    claims, errors = shared["claims"], shared["errors"]
+    selected = [
+        row
+        for row in claims
+        if any(
+            token
+            in (
+                row["business"]
+                + " "
+                + row["key"]
+                + " "
+                + row["value"]
+                + " "
+                + " ".join(row.get("aliases", []))
+            ).casefold()
+            for token in tokens
+        )
+    ]
+    keys = {row["key"] for row in selected}
+    while True:
+        related = keys | {key for row in selected for key in row.get("relatedKeys", [])}
+        expanded = [row for row in claims if row["key"] in related]
+        if {(row["ownerRoot"], row["id"]) for row in expanded} == {
+            (row["ownerRoot"], row["id"]) for row in selected
+        }:
+            break
+        selected, keys = expanded, {row["key"] for row in expanded}
+    states: dict[str, dict[str, Any]] = {}
+    for row in selected:
+        row["freshness"] = _freshness(row, states, sources)
+        row["selectionReason"] = "business terms or a connected claim key"
+    return {"claims": selected, "errors": errors, "query": query}
+
+
+def _freshness(
+    claim: dict[str, Any], cache: dict[str, dict[str, Any]], sources: dict[str, str]
+) -> str:
+    for project_id, expected in claim["sourceStates"].items():
+        root = sources.get(project_id)
+        if root is None:
+            return "unverified"
+        if root not in cache:
+            cache[root] = capture_project({"projectId": project_id, "root": root})
+        current = cache[root]
+        if current["gaps"] or not current["digest"]:
+            return "unverified"
+        if current["digest"] != expected["digest"]:
+            return "historical"
+    return "current" if claim["sourceStates"] else "unverified"
+
+
+def knowledge_packet(
+    project_root: Path, question: str, source_root: Path | None = None
+) -> str:
+    try:
+        result = query_knowledge(project_root, question, source_root)
+    except (OSError, BusinessFlowError, JsonBoundaryError) as exc:
+        return f"## Shared Business Knowledge\n\nKnowledge unavailable: {exc}\n"
+    lines = [
+        "## Shared Business Knowledge",
+        "",
+        "Preserve level, freshness, conflict and provenance. Recheck historical facts before relying on them.",
+        "",
+    ]
+    if not result["claims"]:
+        lines.append(
+            "No related stored claims were selected. Inspect source and use additional lookup when new business terms emerge."
+        )
+    for row in result["claims"]:
+        lines.extend(
+            [
+                f"- `{row['id']}`: {row['value']}",
+                f"  - Level: {row['level']}; freshness: {row['freshness']}; status: {row['status']}",
+                f"  - Owner: `{row['ownerRoot']}`; key: `{row['key']}`",
+            ]
+        )
+        lines.extend(
+            f"  - Evidence: `{item['projectId']}:{item['path']}:{item['line']}`"
+            for item in row["evidence"]
+        )
+    lines.extend(f"- Knowledge read error: {error}" for error in result["errors"])
+    lines.extend(
+        [
+            "",
+            "Additional lookup: `okstra explain-flow knowledge --query <business question>`",
+            "",
+        ]
+    )
+    return "\n".join(lines)

package/runtime/python/okstra_ctl/convergence.py

@@ -60,6 +60,14 @@ from .convergence_store import (
     write_final_state_atomic,
     write_json_atomic,
 )
+from .coverage_census import (
+    CensusError,
+    audit_census,
+    audit_filename,
+    census_filename,
+    gapfill_prompt_body,
+)
+from .path_resolve import relative_to_project_root
 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
@@ -323,6 +331,10 @@ _CLI_EPILOG = r"""Usage:
   okstra convergence reverify-prompt --run-manifest <path> --plan <path> \
     --worker <worker-id>
   okstra convergence apply-critic-gaps --work-state <path> --results <path>
+  okstra convergence census-audit --run-manifest <path> \
+    --result <worker>=<path>... [--gapfill <worker>=<path>...]
+  okstra convergence census-gapfill-prompt --run-manifest <path> \
+    --worker <worker-id>
   okstra convergence apply-acceptance-critic --work-state <path> \
     --results <path>
   okstra convergence finalize --work-state <path> --output <path>
@@ -475,6 +487,51 @@ def _parser() -> argparse.ArgumentParser:
     )
     critic_verify_prompt.add_argument("--worker", required=True)
 
+    census_audit = subparsers.add_parser(
+        "census-audit",
+        help="audit each analyser's coverage-census verdicts",
+        description=(
+            "Read every analysis worker's `Coverage Verdicts` against this run's "
+            "coverage census and write state/coverage-census-audit-<task-type>-"
+            "<seq>.json: per worker the cells still without a usable verdict, "
+            "the cell x worker matrix, the cells one worker judged `finding` and "
+            "another `clean`, and per-cell grouping suggestions. Run it after the "
+            "initial batch, and again with `--gapfill` after the one gap-fill "
+            "dispatch. Cells left unjudged are recorded as warnings; they never "
+            "change the exit code. A run whose profile has no census writes "
+            "nothing and exits 0."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    census_audit.add_argument("--run-manifest", type=Path, required=True)
+    census_audit.add_argument(
+        "--result", action="append", default=[], required=True,
+        metavar="<worker>=<path>",
+        help="one analysis worker's initial result file (repeatable); a path "
+             "that does not exist counts as a missing result",
+    )
+    census_audit.add_argument(
+        "--gapfill", action="append", default=[], metavar="<worker>=<path>",
+        help="that worker's census-gapfill result file (repeatable); a path that "
+             "does not exist records a failed gap-fill",
+    )
+
+    census_gapfill_prompt = subparsers.add_parser(
+        "census-gapfill-prompt",
+        help="render one analyser's census gap-fill instructions to stdout",
+        description=(
+            "Print the census gap-fill instruction body for one analysis worker "
+            "from the latest `census-audit`: only the cells that worker left "
+            "without a usable verdict, grouped by why. The lead writes it "
+            "verbatim to the file the prompt materializer's `--instruction` "
+            "takes, with `--dispatch-kind census-gapfill`. Refused for a worker "
+            "with no unjudged cell or one that already had its single gap-fill."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    census_gapfill_prompt.add_argument("--run-manifest", type=Path, required=True)
+    census_gapfill_prompt.add_argument("--worker", required=True)
+
     apply_critic = subparsers.add_parser(
         "apply-critic-gaps",
         help="apply one coverage-critic verification batch",
@@ -1325,7 +1382,7 @@ def _group_from_fields(
     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 {
+    group = {
         "findingId": finding_id, "summary": scalar.get("summary", ""),
         "category": scalar.get("category", ""),
         "ticketIds": [item.strip() for item in scalar.get("tickets", "").split(",") if item.strip()],
@@ -1334,6 +1391,10 @@ def _group_from_fields(
         "discoveredBy": discovered,
         "sourceItems": source_items,
     }
+    cells = [cell.strip() for cell in scalar.get("cells", "").split(",") if cell.strip()]
+    if cells:
+        group["cellRefs"] = list(dict.fromkeys(cells))
+    return group
 
 
 def _group_source_provenance(
@@ -1579,6 +1640,7 @@ def _critic_verify_prompt(args: argparse.Namespace) -> str:
     result_path, audit_path = critic_result_paths(
         groups, critic_provider=provider,
         project_root=authority.project_root, run_dir=authority.run_dir,
+        recorded_result=_settled_critic_result(authority.payload),
     )
     return critic_verify_prompt_body(
         task_key=task_key,
@@ -1589,6 +1651,109 @@ def _critic_verify_prompt(args: argparse.Namespace) -> str:
     )
 
 
+def _worker_paths(raw_pairs: list[str], label: str) -> dict[str, Path]:
+    paths: dict[str, Path] = {}
+    for raw in raw_pairs:
+        worker, value = _split_pair(raw, label)
+        if worker in paths:
+            raise ConvergenceContractError(f"{label} names `{worker}` twice")
+        paths[worker] = Path(value)
+    return paths
+
+
+def _read_if_present(path: Path) -> str | None:
+    return path.read_text(encoding="utf-8") if path.is_file() else None
+
+
+def _census_audit(args: argparse.Namespace) -> dict[str, Any]:
+    """Audit the census verdicts. Unjudged cells are data, never an error."""
+    authority = validated_run_authority(args.run_manifest)
+    state_dir = authority.run_dir / "state"
+    census_path = state_dir / census_filename(
+        authority.task_type, authority.state_sequence
+    )
+    summary: dict[str, Any] = {"ok": True, "operation": "census-audit"}
+    if not census_path.is_file():
+        return {**summary, "census": "absent"}
+    census = load_owned_json_object(census_path)
+    result_paths = _worker_paths(args.result, "--result")
+    gapfill_paths = _worker_paths(args.gapfill, "--gapfill")
+    unrostered = sorted(set(gapfill_paths) - set(result_paths))
+    if unrostered:
+        raise ConvergenceContractError(
+            f"--gapfill names {unrostered}, which no --result names"
+        )
+    audit = audit_census(
+        census,
+        {worker: _read_if_present(path) for worker, path in result_paths.items()},
+        {worker: _read_if_present(path) for worker, path in gapfill_paths.items()},
+    )
+    for row in audit["workers"]:
+        row["resultPath"] = relative_to_project_root(
+            result_paths[row["workerId"]], authority.project_root
+        )
+        if row["workerId"] in gapfill_paths:
+            row["gapfillPath"] = relative_to_project_root(
+                gapfill_paths[row["workerId"]], authority.project_root
+            )
+    output = state_dir / audit_filename(authority.task_type, authority.state_sequence)
+    write_json_atomic(output, audit)
+    return {
+        **summary,
+        "census": "present",
+        "path": str(output),
+        "crossCheck": audit["crossCheck"],
+        "gapfillNeeded": audit["gapfillNeeded"],
+        "unverdicted": {
+            row["workerId"]: len(row["unverdicted"]) for row in audit["workers"]
+        },
+        "disagreements": len(audit["disagreements"]),
+    }
+
+
+def _census_gapfill_prompt(args: argparse.Namespace) -> str:
+    authority = validated_run_authority(args.run_manifest)
+    state_dir = authority.run_dir / "state"
+    audit_path = state_dir / audit_filename(authority.task_type, authority.state_sequence)
+    if not audit_path.is_file():
+        raise ConvergenceContractError(
+            "the gap-fill prompt reads the census audit; run "
+            f"`okstra convergence census-audit` first: {audit_path}"
+        )
+    census_path = state_dir / census_filename(authority.task_type, authority.state_sequence)
+    return gapfill_prompt_body(
+        load_owned_json_object(audit_path),
+        args.worker,
+        task_key=authority.task_key,
+        analysis_packet_path=_manifest_authority_string(
+            authority.payload, "analysisPacketPath"
+        ),
+        census_path=relative_to_project_root(census_path, authority.project_root),
+    )
+
+
+def _settled_critic_result(manifest: Mapping[str, Any]) -> str:
+    """critic dispatch 의 가장 최근 `ok` attempt 가 기록한 resultPath. 없으면 ''."""
+    invocations = manifest.get("invocations")
+    attempts = manifest.get("attempts")
+    if not isinstance(invocations, list) or not isinstance(attempts, list):
+        return ""
+    critic_refs = {
+        row.get("invocationRef") for row in invocations
+        if isinstance(row, Mapping) and row.get("dispatchKind") == "critic"
+    }
+    settled = [
+        row for row in attempts
+        if isinstance(row, Mapping) and row.get("invocationRef") in critic_refs
+        and row.get("status") == "ok"
+        and isinstance(row.get("resultPath"), str) and row["resultPath"]
+    ]
+    if not settled:
+        return ""
+    latest = max(settled, key=lambda row: (str(row.get("finishedAt") or ""), row.get("attempt") or 0))
+    return latest["resultPath"]
+
+
 def _execute(args: argparse.Namespace) -> tuple[str, Path]:
     operations: dict[str, Any] = {
         "prepare-groups": _prepare_groups,
@@ -1626,9 +1791,15 @@ def main(argv: list[str] | None = None) -> int:
         if args.operation == "critic-verify-prompt":
             print(_critic_verify_prompt(args), end="")
             return 0
+        if args.operation == "census-audit":
+            print(json.dumps(_census_audit(args), ensure_ascii=False))
+            return 0
+        if args.operation == "census-gapfill-prompt":
+            print(_census_gapfill_prompt(args), end="")
+            return 0
         action, path = _execute(args)
     except (ConvergenceContractError, VerdictBlockError, ReverifyPromptError,
-            CriticVerifyPromptError,
+            CriticVerifyPromptError, CensusError,
             json.JSONDecodeError, ValueError) as exc:
         print(f"error: {exc}", file=sys.stderr)
         return 2

package/runtime/python/okstra_ctl/convergence_critic_verify_prompt.py

@@ -77,6 +77,7 @@ def critic_result_paths(
     critic_provider: str,
     project_root: Path,
     run_dir: Path,
+    recorded_result: str = "",
 ) -> tuple[str, str]:
     """critic 결과 파일과 그 감사 사이드카의 프로젝트 상대 경로.
 
@@ -85,7 +86,24 @@ def critic_result_paths(
     §"Coverage critic pass"). 접미사는 분석자 결과와 같은 규칙으로 그룹의
     `runManifestPath` 에서 읽는다. 파일이 없으면 critic 결과가 아직 수집되지
     않은 것이라 거절한다 — gap 검증은 critic 결과 뒤에만 온다.
+
+    `recorded_result` 는 매니페스트 attempt 원장이 critic 의 마지막 `ok` attempt
+    에 적은 경로다. 있으면 이름 규칙보다 먼저 쓴다 — 리드가 run seq 로 이름을
+    붙여도(실측 2026-10-03, fontsninja-v3-site dev-11118 requirements-discovery
+    002: prompts 002, workerResults 001) 실제로 수집된 파일을 가리킨다.
     """
+    if recorded_result:
+        recorded = Path(recorded_result)
+        result = recorded if recorded.is_absolute() else Path(project_root) / recorded
+        if not result.is_file():
+            raise CriticVerifyPromptError(
+                f"the critic attempt recorded {result} but the file is missing"
+            )
+        result_rel = _project_relative(project_root, result)
+        try:
+            return result_rel, audit_sidecar_rel(result_rel)
+        except WorkerArtifactPathError as exc:
+            raise CriticVerifyPromptError(str(exc)) from exc
     if not _nonempty_string(critic_provider):
         raise CriticVerifyPromptError("run manifest has no critic assignment provider")
     suffix = worker_result_suffix(Path(run_dir), groups)

package/runtime/python/okstra_ctl/convergence_provenance.py

@@ -26,6 +26,7 @@ from okstra_ctl.execution_manifest import read_execution_manifest_view
 from okstra_ctl.json_boundary import (
     load_owned_object,
 )
+from okstra_ctl.worker_prompt_policy import CENSUS_GAPFILL_DISPATCH_KIND
 
 GROUPS_BASENAME_RE = re.compile(
     r"^convergence-groups-(?P<suffix>[a-z][a-z-]*?-\d{3})\.json$"
@@ -223,6 +224,13 @@ def provenance_errors(
         text = contents[worker]
         if text is None or id_occurs_wordbounded(text, item_id):
             continue
+        gapfill = read_canonical_worker_result(
+            worker_results_dir, worker, f"{CENSUS_GAPFILL_DISPATCH_KIND}-{suffix}"
+        )
+        # A finding the census gap-fill raised lives in that worker's gap-fill
+        # result, not in its first one.
+        if gapfill is not None and id_occurs_wordbounded(gapfill, item_id):
+            continue
         errors.append(
             f"convergence groups `{groups_label}` group {finding_id} "
             f"cites source item `{worker}:{item_id}`, but that ID does not "