chore(p0): drop never-enabled hunter tools, test-only functions and receiver delivery

Off every active line (PATHFINDER-2026-10-13/03-unified-proposal.md, cuts).
Deleted: the four hunter tools no caller enables (read_definition,
entry_points, flows, obligations) with their schemas and dispatch, the dead
mapping branch of find_refs; 20 functions whose only caller was one test
(mapping task records, compute_ranking_metrics, build_quick_hunter_prompt,
validate_evidence_transition, should_fuse, harness processors,
rank_targets_with_model, model/report slice rendering, taxonomy
hierarchical/related, config_value.verdict, taint.verdict, roles.load_roles,
features.language_of and build_for_scan, folds.leave_one_*,
features.recorded_case, search BatchExecutor and the three __main__ shims,
delivery.put_input); the receiver delivery mode of the plane. push_inputs.py
moved to benchmarks/push. memory.purge stays: the live-S3 test cleanup uses
it. Net: 2,730 lines deleted, 207 added. 473 targeted tests passed; 3,282
tests collect. breadth.toml records the removals.

Co-Authored-By: Claude Fable 5.1 <[email protected]>

src/openultrasast/harness.py

@@ -6,7 +6,7 @@ from collections.abc import Callable
 from dataclasses import asdict, dataclass, field
 from datetime import UTC, datetime
 from pathlib import Path
-from typing import Any, Literal, Protocol
+from typing import Any, Literal
 
 from .config import ResolvedConfig
 
@@ -21,11 +21,6 @@ EventType = Literal[
     "task_end",
 ]
 
-ContractMode = Literal["strict", "warn"]
-
-
-class HarnessContractError(ValueError):
-    """Raised when a processor violates its declared state contract."""
 
 
 @dataclass(frozen=True)
@@ -37,27 +32,9 @@ class HarnessEvent:
     payload: dict[str, Any] = field(default_factory=dict)
 
 
-@dataclass(frozen=True)
-class ProcessorSpec:
-    name: str
-    version: str
-    handles: tuple[EventType, ...]
-    reads: tuple[str, ...] = ()
-    writes: tuple[str, ...] = ()
-
-
-class Processor(Protocol):
-    spec: ProcessorSpec
-
-    def handle(self, event: HarnessEvent, state: dict[str, Any]) -> dict[str, Any] | None:
-        raise NotImplementedError
-
-
 @dataclass(frozen=True)
 class SerializedHarnessConfig:
-    contract_mode: ContractMode
     model_roles: dict[str, str | None]
-    processor_versions: dict[str, str]
     prompt_hashes: dict[str, str]
 
 
@@ -84,14 +61,10 @@ class HarnessRuntime:
         scan_id: str,
         config: ResolvedConfig,
         trace_writer: HarnessTraceWriter,
-        processors: list[Processor] | None = None,
-        contract_mode: ContractMode = "strict",
     ) -> None:
         self.scan_id = scan_id
         self.config = config
         self.trace_writer = trace_writer
-        self.processors = processors or []
-        self.contract_mode = contract_mode
         self.state: dict[str, Any] = {"degradations": []}
 
     def start(self, *, mode: str, target: Path) -> None:
@@ -119,71 +92,22 @@ class HarnessRuntime:
             payload=payload,
         )
         self.trace_writer.append(event)
-        for processor in self.processors:
-            if event_type in processor.spec.handles:
-                self._run_processor(processor, event)
-
-    def _run_processor(self, processor: Processor, event: HarnessEvent) -> None:
-        before = set(self.state)
-        missing_reads = [key for key in processor.spec.reads if key not in self.state]
-        if missing_reads:
-            self._contract_violation(processor.spec.name, f"missing reads: {', '.join(missing_reads)}")
-            return
-
-        updates = processor.handle(event, dict(self.state)) or {}
-        if not isinstance(updates, dict):
-            self._contract_violation(processor.spec.name, "processor returned a non-dict update")
-            return
-        undeclared = sorted(set(updates) - set(processor.spec.writes))
-        if undeclared:
-            self._contract_violation(processor.spec.name, f"undeclared writes: {', '.join(undeclared)}")
-            return
-        self.state.update(updates)
-        changed = sorted(set(self.state) - before | set(updates))
-        self.trace_writer.append(
-            HarnessEvent(
-                event_type=event.event_type,
-                scan_id=self.scan_id,
-                stage=event.stage,
-                timestamp=datetime.now(UTC).isoformat(),
-                payload={"processor": processor.spec.name, "changed_state": changed},
-            )
-        )
-
-    def _contract_violation(self, processor_name: str, reason: str) -> None:
-        message = f"processor {processor_name} contract violation: {reason}"
-        if self.contract_mode == "strict":
-            raise HarnessContractError(message)
-        self.state.setdefault("degradations", []).append(message)
-        self.trace_writer.append(
-            HarnessEvent(
-                event_type="stage_end",
-                scan_id=self.scan_id,
-                stage="processor_contract",
-                timestamp=datetime.now(UTC).isoformat(),
-                payload={"status": "degraded", "reason": message},
-            )
-        )
 
 
 def write_harness_config(
     *,
     config: ResolvedConfig,
-    processors: list[Processor],
-    contract_mode: ContractMode,
     path: Path,
     prompts: dict[str, str] | None = None,
 ) -> None:
     prompts = prompts or {}
     serialized = SerializedHarnessConfig(
-        contract_mode=contract_mode,
         model_roles={
             "ranker": config.models.ranker,
             "hunter": config.models.hunter,
             "verifier": None,  # schema kept byte for byte; LLM verification runs on the plane
             "patcher": None,  # schema kept; `[models] patcher` was retired 2026-10-02 (never read)
         },
-        processor_versions={processor.spec.name: processor.spec.version for processor in processors},
         prompt_hashes={name: _hash_text(prompt) for name, prompt in sorted(prompts.items())},
     )
     path.parent.mkdir(parents=True, exist_ok=True)