Build a cognition marketplace

        let seller_input = json!({"issue":input["issue"],"mode":if mode=="model" {"model"}else{"deterministic"},"exercise_denials":true});
        let seller_run = Run::create(&root.join("seller-runs"), Factory.name(), &seller_input)?;
        let repair = Factory.execute(seller_input, seller_run.clone()).await;
        seller_run.finish(&repair)?;
        let repair = repair?;
        anyhow::ensure!(
            repair["tests"]["passed"] == true,
            "Seller has no passing candidate to offer"
        );
        run.emit(
            "market.seller",
            "seller",
            "Produced and tested the candidate using the factory",
            seller_run.snapshot()?,
        )?;

    if config["action"] in {"offer", "nonfix"}:
        async with CognitionMarketSeller(venue / "seller-client.json") as seller:
            try:
                package = await seller.package_verified_fix(
                    repository=config["repository"], base=config["base"], candidate=config["candidate"],
                    tests=["python3 -m unittest -v test_analysis"], topic="coding/sliding-window-analysis", price=config["price"],
                )
                admitted = await seller.admit(package)
            except CognitionMarketError as error:
                if config["action"] == "nonfix":
                    return {"refused": True, "reason": str(error)}
                raise
            if config["action"] == "nonfix":
                raise RuntimeError("A non-fixing candidate was admitted")
        return {"offer": admitted}

    async with CognitionMarketBuyer(venue / "buyer-client.json", chio_binary=Path(config["chio"])) as buyer:
        proof = await buyer.verified_proof(config["finding_id"])
        if config["action"] == "tamper":
            altered = json.loads(proof.proof)
            # Alter signed evidence, preserving JSON readability.
            altered["bundle"]["finding"]["payload_sha256"] = "0" * 64
            try:
                await buyer.verify_proof(json.dumps(altered).encode())
            except CognitionMarketError as error:
                return {"refused": True, "reason": str(error)}
            raise RuntimeError("Changed proof was accepted")
        before = purchase_state(venue)
        try:
            purchased = await buyer.purchase_verified_fix(proof, max_price_units=config["max_price"])
        except CognitionMarketError as error:
            after = purchase_state(venue)
            if before != after:
                raise RuntimeError("Refused purchase advanced venue purchase state") from error
            return {"status": "refused", "reason": str(error), "purchase_state_unchanged": True, "purchase_state": after}
        repeated = await buyer.purchase_verified_fix(proof, max_price_units=config["max_price"])
        if repeated.request != purchased.request or repeated.purchase != purchased.purchase:
            raise RuntimeError("Repeated purchase did not recover the same terminal result")
        Path(config["patch"]).write_text(purchased.patch, encoding="utf-8")
        return {"status": "delivered", "finding_id": purchased.finding_id,
                "base_revision": purchased.base_revision, "candidate_revision": purchased.candidate_revision,
                "patch": purchased.patch, "request": purchased.request, "purchase": purchased.purchase,
                "repeated_purchase": "same request and retained terminal; no second purchase"}

        let customer = Repository::create(&root.join("customer"))?;
        git(&customer.directory, &["init", "--initial-branch=customer"]).await?;
        let before = customer.test(true).await?;
        anyhow::ensure!(
            before["passed"] == false,
            "Customer copy did not reproduce the defect"
        );
        let patch = root.join("purchased.patch");
        git(
            &customer.directory,
            &[
                "apply",
                "--check",
                patch.to_str().context("Invalid patch path")?,
            ],
        )
        .await?;
        git(
            &customer.directory,
            &["apply", patch.to_str().context("Invalid patch path")?],
        )
        .await?;
        let after = customer.test(false).await?;
        run.emit(
            "market.customer-tested",
            "customer",
            "Test the purchased delivery in the customer repository",
            json!({"before":before,"after":after}),
        )?;
        anyhow::ensure!(
            after["passed"] == true,
            "Delivered patch did not repair the separate customer project"
        );
        run.emit(
            "market.repaired",
            "customer",
            "The purchased patch repairs a separate customer copy",
            json!({"before":before,"after":after,"finding_id":finding}),
        )?;