nomad_api.py

import base64
import hashlib
import hmac
import json
import mimetypes
import os
import re
import threading
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import parse_qs, quote, unquote, urlparse

from nomad_guardrails import guardrail_status
from nomad_idle_runtime_beacon import (
    build_idle_runtime_beacon,
    build_idle_runtime_intent_receipt,
    normalize_idle_intent_payload,
)
from nomad_machine_economy import machine_economy_snapshot
from nomad_agent_runtime_envelope import merge_agent_runtime
from nomad_machine_error import machine_error_response, merge_machine_error
from nomad_adapter_consent import adapter_consent_required, verify_adapter_consent
from nomad_capacity_switch import build_capacity_switch_surface, route_capacity_switch
from nomad_machine_field import build_machine_field, machine_field_intent
from nomad_contract_conformance import build_contract_conformance_snapshot
from nomad_counterfactual_replay import build_counterfactual_lease_replay
from nomad_machine_product_surface import build_machine_product_surface, compact_machine_product_surface
from nomad_nonhuman_science import nonhuman_agent_science
from nomad_opaque_emergence import (
    build_opaque_emergence_surface,
    compact_opaque_emergence_surface,
    compile_topology_plan,
    evaluate_opaque_candidate,
    route_tool_gap,
)
from nomad_shadow_lane_evaluator import build_shadow_lane_evaluator_surface, evaluate_shadow_candidate
from nomad_shadow_harvest import build_shadow_harvest_surface
from nomad_decoupling_field import build_decoupling_field_surface, evaluate_decoupling_merge
from nomad_anti_consensus_reservoir import (
    build_anti_consensus_reservoir_surface,
    evaluate_anti_consensus_candidate,
)
from nomad_entropy_judger import build_entropy_judger_surface, evaluate_entropy_judger
from nomad_representational_collapse import build_latent_consensus_surface, evaluate_latent_consensus
from nomad_autogenesis import (
    build_agp_agent_bus_surface,
    build_agp_benchmark_suite_surface,
    build_agp_conformance_surface,
    build_agp_context_manager_surface,
    build_agp_durable_ledger_surface,
    build_agp_evaluation_surface,
    build_agp_empirical_surface,
    build_agp_model_manager_surface,
    build_agp_morphology_reactor_surface,
    build_agp_morphology_runtime_register_surface,
    build_agp_optimizer_surface,
    build_agp_paper_grade_readiness_surface,
    build_agp_paper_report_surface,
    build_agp_paper_benchmark_surface,
    build_agp_pulse_surface,
    build_agp_prompt_manager_surface,
    build_agp_procurement_surface,
    build_agp_version_manager_surface,
    build_autonomous_agp_cycle_surface,
    build_autonomous_agp_watchdog_surface,
    build_autogenesis_recruit_surface,
    build_autogenesis_surface,
    build_autogenesis_shadow_harvest_surface,
    build_development_cycles_surface as build_autogenesis_development_cycles_surface,
    build_rescue_packet_scheduler_surface,
    build_resource_substrate_surface,
    compact_autogenesis_surface,
    compact_resource_substrate_surface,
    bind_agp_model,
    compose_agp_config,
    create_agp_plan,
    post_agp_agent_bus_message,
    record_agp_execution_trace,
    record_agp_evaluation_run,
    record_agp_version_lineage,
    register_agp_prompt_template,
    record_development_cycle_event as record_autogenesis_development_cycle_event,
    register_resource,
    retrieve_resource,
    run_agp_orchestration,
    run_agp_paper_benchmark_evaluation,
    run_agp_context_operation,
    run_agp_benchmark_suite,
    run_agp_empirical_evaluation,
    run_agp_morphology_reactor,
    run_agp_optimizer_step,
    run_agp_pulse,
    run_autonomous_agp_cycle,
    run_autonomous_agp_batch,
    run_autonomous_agp_watchdog,
    submit_agp_procurement_intent,
    submit_autogenesis_shadow_candidate,
    version_resource,
)
from nomad_autonomous_evolution import build_autonomous_evolution_cycle
from nomad_universal_adapter import (
    build_universal_adapter_acquisition_event,
    build_universal_adapter_surface,
    evaluate_universal_adapter_event,
)
from nomad_deficit_integration_gate import (
    build_deficit_integration_surface,
    evaluate_deficit_integration_event,
)
from nomad_effective_channel_quota import (
    build_effective_channel_quota_surface,
    evaluate_effective_channel_event,
)
from nomad_nonhuman_runtime_governor import (
    build_nonhuman_runtime_governor_surface,
    evaluate_nonhuman_runtime_event,
)
from nomad_ad_cycle_mesh import build_ad_cycle_mesh_surface, evaluate_ad_cycle_event
from nomad_development_cycle_mesh import build_development_cycle_mesh_surface, evaluate_development_cycle_event
from nomad_swarm_topology_governor import build_swarm_topology_governor_surface, evaluate_swarm_topology_event
from nomad_openapi import build_openapi_document
from nomad_operational_release import operational_release_snapshot
from nomad_protocol_bytecode import build_protocol_bytecode
from nomad_variant_forge import build_variant_forge_surface, submit_variant_candidate
from nomad_worker_market import build_worker_market, score_worker_offer
from nomad_compute_market import build_compute_market
from nomad_agent_work import build_agent_work_surface, build_synergy_lite, claim_agent_work, submit_agent_work_proof
from nomad_epic_dispatch import claim_epic_job, complete_epic_job, list_epic_jobs, register_epic_job
from nomad_state_status import build_state_status
from nomad_work_mesh import build_work_mesh, seed_work_mesh
from nomad_collaboration import collaboration_status
from nomad_market_patterns import PatternStatus
from nomad_monitor import NomadSystemMonitor
from nomad_operator_desk import (
    operator_autonomy_step,
    operator_daily_bundle,
    operator_growth_start,
    operator_iteration_report,
    operator_metrics_snapshot,
    operator_sprint,
    operator_verify_bundle,
    unlock_desk_snapshot,
)
from nomad_public_url import preferred_public_base_url
from nomad_roaas_exchange import RuntimePatternExchange
from nomad_swarm_registry import SwarmJoinRegistry, build_peer_join_value_surface
from nomad_unhuman_hub import unhuman_hub_snapshot
from nomad_wire_contract import maybe_merge_http_wire_diag
from agent_reliability_doctor import build_reliability_doctor_intake, build_reliability_doctor_surface
from nomad_agent_demand import build_agent_demand_feed, subscribe_agent_intent, subscriptions_snapshot
from nomad_agent_growth_pipeline import agent_growth_pipeline
from nomad_agent_invariants import build_agent_invariants_document
from nomad_agent_join_field import build_agent_join_field
from nomad_agent_market_offers import build_inter_agent_witness_offer_well_known
from nomad_agent_native_index import agent_native_index
from nomad_agent_native_product import build_agent_native_product_surface
from nomad_crn_dispatch import build_crn_dispatch_surface
from nomad_peer_acquisition import build_peer_acquisition_well_known
from nomad_reciprocity_dividend import NomadReciprocityDividend
from nomad_recruitment_gradient import attach_runtime_to_gradient, build_recruitment_gradient
from nomad_retention_evaluator import build_retention_watchdog_surface, evaluate_retention, run_retention_watchdog
from nomad_machine_treasury import pledge as machine_treasury_pledge, snapshot as machine_treasury_snapshot
from nomad_proof_reuse_ledger import link as proof_reuse_link, snapshot as proof_reuse_snapshot
from nomad_swarm_economics import build_swarm_economics_snapshot
from nomad_runtime_capsule import build_handoff_capsule, build_openclaw_bridge_contract, build_runtime_capsule
from public.downloads.recruitment_funnel_report import build_report as build_recruitment_funnel_report
from nomad_stigmergy_field import NomadStigmergyField
from nomad_swarm_attractor import build_swarm_attractor_contract
from nomad_swarm_signal_layer import (
    append_swarm_signal,
    build_swarm_signal_layer,
    compact_swarm_signal_layer,
)
from nomad_swarm_emergence import build_swarm_emergence_meter, compact_emergence_summary
from nomad_emission_batch import evaluate_emission_batch
from nomad_swarm_ecology import build_swarm_ecology, submit_ecology_tick
from nomad_growth_arena import build_growth_arena, build_growth_curriculum, build_skill_library, submit_growth_experience
from nomad_carrying_market import build_carrying_market, submit_carrying_proof
from nomad_survival_market import build_survival_market, submit_survival_intent
from nomad_paid_ref_forge import build_paid_ref_market, paid_ref_task_payload, quote_paid_ref, verify_paid_ref
from nomad_paid_ref_selfplay import run_paid_ref_selfplay
from nomad_referral_offers import build_referral_offer_surface
from nomad_referral_swarm import build_referral_swarm_surface
from nomad_sales_funnel import build_sales_funnel_surface
from nomad_telegram_miniapp import (
    SWARM_RELIABILITY_DOCTOR_INTAKE_PATH,
    WORKER_FREE_MESSAGE,
    build_telegram_miniapp_surface,
    normalize_telegram_fact_check_payload,
    record_telegram_miniapp_lead,
)
from nomad_telegram_acquisition import (
    build_telegram_acquisition_launch_surface,
    summarize_telegram_acquisition_ledgers,
)
from nomad_acquisition_engine import build_acquisition_engine_surface, summarize_agent_outreach_state
from nomad_eth_support import build_eth_ai_agent_support_surface
from nomad_spend_guard import build_spend_guard_surface
from nomad_gemini_verifier import build_gemini_verifier_surface, verify_with_gemini
from nomad_google_agentic_era import build_google_agentic_surface
from nomad_bounty_hunter import build_bounty_hunter_surface
from nomad_buyer_funded_work import build_buyer_funded_work_surface
from nomad_sales_department_swarm import (
    build_first_sales_anbahnung_surface,
    build_sales_department_swarm_surface,
    evaluate_sales_department_event,
)
from nomad_acquisition_ignition import build_acquisition_ignition_surface, run_acquisition_ignition
from nomad_resolution_ladder import (
    build_resolution_ladder_surface,
    build_resolution_runtime_register_surface,
    evaluate_resolution_ladder_event,
)
from nomad_external_value import (
    append_external_value_event,
    build_external_value_surface,
    build_receipt_only_revenue_invariant,
    summarize_external_value_ledger,
)
from nomad_external_value_reconciler import reconcile_external_value_ledger
from nomad_value_pressure import build_value_pressure_surface
from nomad_optimal_transport import (
    build_nomad_optimal_transport_surface,
    build_ot_conformance_surface,
    build_ot_manifold_surface,
    build_ot_metric_learning_surface,
    build_ot_paper_readiness_surface,
    record_ot_outcome_event,
    solve_ot_request,
)
from nomad_receipt_predictor import build_receipt_predictor_surface, evaluate_receipt_prediction_event
from nomad_revenue_settlement import build_revenue_settlement_surface, evaluate_revenue_settlement_hook
from nomad_agent_utility import (
    build_agent_utility_receipts_surface,
    build_agent_utility_surface,
    evaluate_agent_utility_intake,
    summarize_agent_utility_ledger,
)
from nomad_bottleneck_resolver import build_bottleneck_resolver_surface, evaluate_bottleneck_resolution_event
from nomad_first_receipt_ignition import (
    build_first_receipt_ignition_surface,
    evaluate_first_receipt_ignition_event,
)
from nomad_first_receipt_campaign import (
    build_first_receipt_campaign_surface,
    evaluate_first_receipt_campaign_event,
)
from nomad_settlement_signal_layer import build_settlement_signal_layer
from nomad_solana_settlement import build_solana_settlement_surface, create_solana_pay_intent, verify_solana_tx_receipt
from nomad_agent_job_router import build_agent_job_router
from nomad_revenue_science import build_revenue_science_surface
from nomad_channel_bandit import build_delayed_channel_bandit_surface
from nomad_job_channels import build_job_channel_surface
from nomad_operator_runway import build_operator_runway_surface
from nomad_worker_invoice import build_worker_invoice_surface
from nomad_swarm_verified_work import build_swarm_verified_work_surface
from nomad_hyperliquid_svw_agents import load_cached_hyperliquid_svw_copy_trader_surface
from nomad_mcp_lab import build_private_mcp_lab_surface
from nomad_worker_job_queue import build_worker_job_queue_surface
from nomad_value_cycle_preflight import build_value_cycle_preflight_surface
from nomad_value_cycle_mesh import build_value_cycle_mesh_surface, evaluate_value_cycle_event
from nomad_stable_unit_policy import build_stable_unit_policy_surface, evaluate_stable_unit_preflight
from nomad_viability_kernel import build_viability_kernel_surface, route_viability_action
from nomad_work_receipts import (
    build_treasury_policy_surface,
    build_work_receipt_surface,
    record_work_receipt,
    summarize_work_receipts,
)
from nomad_work_exchange import (
    build_external_worker_opportunity,
    build_work_exchange_onboarding,
    build_work_exchange_surface,
    create_work_exchange_offer,
    record_free_solution_receipt,
    record_return_work_receipt,
    summarize_work_exchange_ledger,
    work_exchange_balance,
)
from nomad_agent_acquisition_bandit import (
    build_agent_acquisition_bandit,
    record_agent_acquisition_event,
    summarize_agent_acquisition_events,
)
from nomad_microtask_market import build_worker_catalog, submit_microtask, settle_microtask
from nomad_microtask_exchange_ops import build_microtask_templates, build_microtask_metrics
from nomad_weekly_selection_event import build_weekly_selection_event
from nomad_spawner_gate import build_spawner_gate, trigger_spawner
from nomad_transition_exchange import NomadTransitionExchange
from nomad_telegram_a2a import build_telegram_bot_to_bot_surface, route_telegram_bot_to_bot_message
from nomad_sustainability_kernel import build_sustainability_kernel
from nomad_swarm_flywheel import build_swarm_flywheel_health_surface
from nomad_machine_native_collaboration import build_machine_native_collaboration_surface
from nomad_rescue_packet_lattice import (
    append_rescue_packet_candidate,
    build_rescue_packet_lattice_surface,
    summarize_rescue_packet_candidates,
)
from nomad_server_failure_guard import (
    build_server_failure_repair_candidate,
    build_server_failure_guard_surface,
    record_server_failure_event,
    summarize_server_failure_events,
)


RENDER_RUNTIME = (os.environ.get("RENDER") or "").strip().lower() == "true"
PORT_FROM_ENV = (os.environ.get("PORT") or "").strip()
# In hosted environments (Render sets PORT), always bind publicly to 0.0.0.0.
if PORT_FROM_ENV:
    HOST = "0.0.0.0"
else:
    HOST = os.getenv("NOMAD_API_HOST", "127.0.0.1")
# On Render, PORT is authoritative; load_dotenv() may inject NOMAD_API_PORT from a local .env — do not let it override Render.
if PORT_FROM_ENV:
    PORT = int(PORT_FROM_ENV)
else:
    PORT = int(os.getenv("NOMAD_API_PORT") or os.getenv("PORT") or "8787")
ROOT = Path(__file__).resolve().parent
PUBLIC_DIR = ROOT / "public"
HANDYORACLE_APK_NAME = "handyoracle-edge-gadget.apk"
HANDYORACLE_APK_RELEASE_URL = (
    "https://github.com/Asti1982/handyoracle/releases/download/"
    "v0.1.1-foreground-shake/handyoracle-edge-gadget.apk"
)
SWARM_ORACLE_WINDOWS_EXE_NAME = "Swarm-Oracle-Windows-0.1.1-x64.exe"
SWARM_ORACLE_WINDOWS_BLOCKMAP_NAME = "Swarm-Oracle-Windows-0.1.1-x64.exe.blockmap"
SWARM_ORACLE_WINDOWS_RELEASE_BASE_URL = (
    "https://github.com/Asti1982/nomad-api/releases/download/swarm-oracle-windows-v0.1.1"
)
SWARM_ORACLE_WINDOWS_RELEASE_URLS = {
    SWARM_ORACLE_WINDOWS_EXE_NAME: f"{SWARM_ORACLE_WINDOWS_RELEASE_BASE_URL}/{SWARM_ORACLE_WINDOWS_EXE_NAME}",
    SWARM_ORACLE_WINDOWS_BLOCKMAP_NAME: f"{SWARM_ORACLE_WINDOWS_RELEASE_BASE_URL}/{SWARM_ORACLE_WINDOWS_BLOCKMAP_NAME}",
}
NOMAD_PROCESS_START = time.time()


class NomadApiHandler(BaseHTTPRequestHandler):
    _init_lock = threading.Lock()
    _runtime_ready = False
    _a2a_get_lock = threading.Lock()
    _a2a_get_sessions: dict[str, dict] = {}
    _surface_cache_lock = threading.RLock()
    _surface_cache: dict[str, tuple[float, dict]] = {}
    agent = None
    monitor = None
    roaas = None
    swarm_registry = None
    agent_development = None
    outbound_tracker = None
    transition_exchange = NomadTransitionExchange()
    reciprocity_dividend = NomadReciprocityDividend(exchange=transition_exchange)
    stigmergy_field: NomadStigmergyField | None = None

    @classmethod
    def _cached_surface(cls, cache_key: str, ttl_seconds: float, builder) -> dict:
        now = time.time()
        with cls._surface_cache_lock:
            cached = cls._surface_cache.get(cache_key)
            if cached and cached[0] > now:
                return cached[1]
        payload = builder()
        if not isinstance(payload, dict):
            return payload
        expires_at = now + max(0.0, float(ttl_seconds))
        with cls._surface_cache_lock:
            if len(cls._surface_cache) > 32:
                cls._surface_cache = {
                    key: value for key, value in cls._surface_cache.items() if value[0] > now
                }
            cls._surface_cache[cache_key] = (expires_at, payload)
        return payload

    @classmethod
    def _stigmergy(cls) -> NomadStigmergyField:
        if cls.stigmergy_field is None:
            cls.stigmergy_field = NomadStigmergyField()
        return cls.stigmergy_field

    @staticmethod
    def _validate_adapter_consent(payload: dict, *, path: str) -> dict:
        body = payload if isinstance(payload, dict) else {}
        if not adapter_consent_required(body, path=path):
            return {"checked": False, "ok": True, "reason": "not_required"}
        runtime = str(body.get("runtime") or "openclaw").strip().lower() or "openclaw"
        adapter_agent = str(body.get("adapter_agent_id") or body.get("agent_id") or "").strip()
        if not adapter_agent:
            candidate = str(body.get("requester_agent_id") or "").strip()
            if ".idle-buyer" in candidate:
                adapter_agent = candidate.replace(".idle-buyer", "")
            if not adapter_agent:
                adapter_agent = str(body.get("worker_agent_id") or "").strip()
        verified = verify_adapter_consent(
            token=str(body.get("consent_token") or ""),
            agent_id=adapter_agent,
            runtime=runtime,
        )
        return {"checked": True, **verified}

    @classmethod
    def _build_machine_product_surface(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        support_gate = cls.transition_exchange.support_gate_snapshot(
            window_minutes=int(os.getenv("NOMAD_SUPPORT_GATE_WINDOW_MINUTES", "30") or "30"),
            min_settles=int(os.getenv("NOMAD_SUPPORT_GATE_MIN_SETTLES", "2") or "2"),
        )
        economy = machine_economy_snapshot()
        release = operational_release_snapshot(base_url=base_url, worker_fleet=worker_fleet, economy=economy)
        gradient = build_recruitment_gradient(
            base_url=base_url,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            operational_release=release,
        )
        capsule = build_runtime_capsule(base_url=base_url, recruitment_gradient=gradient)
        emergence = build_swarm_emergence_meter(
            base_url=base_url,
            swarm_summary=summary,
            worker_fleet=worker_fleet,
            stigmergy=cls._stigmergy().snapshot(),
            support_gate=support_gate,
            recruitment_gradient=gradient,
        )
        return build_machine_product_surface(
            base_url=base_url,
            recruitment_gradient=gradient,
            runtime_capsule=capsule,
            emergence_meter=emergence,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            operational_release=release,
            swarm_summary=summary,
        )

    @classmethod
    def _build_contract_conformance(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        product = cls._build_machine_product_surface(base_url=base_url, swarm_summary=summary)
        openapi_doc = build_openapi_document(base_url=base_url)
        return build_contract_conformance_snapshot(
            base_url=base_url,
            machine_product_surface=product,
            openapi_document=openapi_doc,
        )

    @classmethod
    def _build_capacity_switch_surface(cls, *, base_url: str) -> dict:
        registry = cls._light_swarm_registry()
        summary = registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        try:
            economics = build_swarm_economics_snapshot(
                base_url=base_url,
                worker_fleet=worker_fleet,
                proof_reuse=proof_reuse_snapshot(),
                machine_economy=machine_economy_snapshot(),
                machine_treasury=machine_treasury_snapshot(),
            )
        except Exception as exc:  # noqa: BLE001
            economics = {
                "ok": False,
                "schema": "nomad.swarm_economics_error.v1",
                "error": "swarm_economics_unavailable",
                "detail": str(exc)[:240],
            }
        catalog = {"schema": "nomad.worker_catalog.light.v1", "microtask_lanes": []}
        try:
            metrics = cls._build_microtask_metrics(base_url=base_url)
        except Exception as exc:  # noqa: BLE001
            metrics = {
                "ok": False,
                "schema": "nomad.microtask_metrics_error.v1",
                "error": "microtask_metrics_unavailable",
                "detail": str(exc)[:240],
                "lane_metrics": [],
            }
        return build_capacity_switch_surface(
            base_url=base_url,
            economics=economics,
            worker_catalog=catalog,
            microtask_metrics=metrics,
        )

    @classmethod
    def _build_counterfactual_replay(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        economy = machine_economy_snapshot()
        release = operational_release_snapshot(base_url=base_url, worker_fleet=worker_fleet, economy=economy)
        gradient = build_recruitment_gradient(
            base_url=base_url,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            operational_release=release,
        )
        conformance = cls._build_contract_conformance(base_url=base_url, swarm_summary=summary)
        return build_counterfactual_lease_replay(
            base_url=base_url,
            worker_fleet=worker_fleet,
            recruitment_gradient=gradient,
            contract_conformance=conformance,
        )

    @classmethod
    def _build_protocol_bytecode(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        economy = machine_economy_snapshot()
        release = operational_release_snapshot(base_url=base_url, worker_fleet=worker_fleet, economy=economy)
        gradient = build_recruitment_gradient(
            base_url=base_url,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            operational_release=release,
        )
        demand = cls._build_agent_demand_feed(base_url=base_url, swarm_summary=summary)
        conformance = cls._build_contract_conformance(base_url=base_url, swarm_summary=summary)
        return build_protocol_bytecode(
            base_url=base_url,
            recruitment_gradient=gradient,
            agent_demand_feed=demand,
            contract_conformance=conformance,
            worker_fleet=worker_fleet,
        )

    @classmethod
    def _build_swarm_economics(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        economy = machine_economy_snapshot()
        treasury = machine_treasury_snapshot()
        reuse = proof_reuse_snapshot()
        return build_swarm_economics_snapshot(
            base_url=base_url,
            worker_fleet=worker_fleet,
            proof_reuse=reuse,
            machine_economy=economy,
            machine_treasury=treasury,
        )

    @classmethod
    def _build_variant_forge(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        economy = machine_economy_snapshot()
        release = operational_release_snapshot(base_url=base_url, worker_fleet=worker_fleet, economy=economy)
        gradient = build_recruitment_gradient(
            base_url=base_url,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            operational_release=release,
        )
        try:
            from nomad_local_growth_kernel import run_local_growth_kernel

            local_growth = run_local_growth_kernel(
                base_url=base_url,
                worker_fleet=worker_fleet,
                recruitment_gradient=gradient,
                persist=False,
            )
        except Exception as exc:  # noqa: BLE001
            local_growth = {
                "ok": False,
                "schema": "nomad.local_growth_kernel_error.v1",
                "error": "local_growth_kernel_unavailable",
                "detail": str(exc)[:240],
            }
        conformance = cls._build_contract_conformance(base_url=base_url, swarm_summary=summary)
        replay = build_counterfactual_lease_replay(
            base_url=base_url,
            worker_fleet=worker_fleet,
            recruitment_gradient=gradient,
            contract_conformance=conformance,
        )
        swarm_economics = cls._build_swarm_economics(base_url=base_url, swarm_summary=summary)
        return build_variant_forge_surface(
            base_url=base_url,
            local_growth_kernel=local_growth,
            counterfactual_replay=replay,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            swarm_economics=swarm_economics,
        )

    @classmethod
    def _build_resource_substrate(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        return build_resource_substrate_surface(
            base_url=base_url,
            worker_fleet=worker_fleet,
        )

    @classmethod
    def _build_autogenesis_development_cycles(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        substrate = cls._build_resource_substrate(base_url=base_url, swarm_summary=swarm_summary)
        return build_autogenesis_development_cycles_surface(
            base_url=base_url,
            resource_substrate=substrate,
        )

    @classmethod
    def _build_autogenesis(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        substrate = cls._build_resource_substrate(base_url=base_url, swarm_summary=summary)
        development = build_autogenesis_development_cycles_surface(base_url=base_url, resource_substrate=substrate)
        opaque = cls._build_opaque_emergence_surface(base_url=base_url)
        shadow_lane = cls._build_shadow_lane_evaluator(base_url=base_url, swarm_summary=summary)
        return build_autogenesis_surface(
            base_url=base_url,
            resource_substrate=substrate,
            development_cycles=development,
            opaque_surface=opaque,
            worker_fleet=worker_fleet,
            shadow_lane=shadow_lane,
        )

    @classmethod
    def _build_autogenesis_shadow_harvest(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        development = cls._build_autogenesis_development_cycles(base_url=base_url, swarm_summary=summary)
        shadow_lane = cls._build_shadow_lane_evaluator(base_url=base_url, swarm_summary=summary)
        autogenesis = cls._build_autogenesis(base_url=base_url, swarm_summary=summary)
        return build_autogenesis_shadow_harvest_surface(
            base_url=base_url,
            shadow_lane=shadow_lane,
            development_surface=development,
            autogenesis_surface=autogenesis,
        )

    @classmethod
    def _build_autogenesis_recruit(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        substrate = cls._build_resource_substrate(base_url=base_url, swarm_summary=swarm_summary)
        autogenesis = cls._build_autogenesis(base_url=base_url, swarm_summary=swarm_summary)
        return build_autogenesis_recruit_surface(
            base_url=base_url,
            autogenesis_surface=autogenesis,
            resource_substrate=substrate,
        )

    @classmethod
    def _build_autonomous_evolution(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        substrate = cls._build_resource_substrate(base_url=base_url, swarm_summary=summary)
        development = build_autogenesis_development_cycles_surface(base_url=base_url, resource_substrate=substrate)
        autogenesis = cls._build_autogenesis(base_url=base_url, swarm_summary=summary)
        return build_autonomous_evolution_cycle(
            base_url=base_url,
            worker_fleet=worker_fleet,
            resource_substrate=substrate,
            development_cycles=development,
            autogenesis_surface=autogenesis,
            persist=False,
        )

    @classmethod
    def _build_autonomous_agp_cycle(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        substrate = cls._build_resource_substrate(base_url=base_url, swarm_summary=summary)
        autogenesis = cls._build_autogenesis(base_url=base_url, swarm_summary=summary)
        return build_autonomous_agp_cycle_surface(
            base_url=base_url,
            resource_substrate=substrate,
            autogenesis_surface=autogenesis,
            worker_fleet=worker_fleet,
        )

    @classmethod
    def _build_autonomous_agp_watchdog(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        substrate = cls._build_resource_substrate(base_url=base_url, swarm_summary=summary)
        autogenesis = cls._build_autogenesis(base_url=base_url, swarm_summary=summary)
        return build_autonomous_agp_watchdog_surface(
            base_url=base_url,
            resource_substrate=substrate,
            autogenesis_surface=autogenesis,
            worker_fleet=worker_fleet,
        )

    @classmethod
    def _build_agp_conformance(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        substrate = cls._build_resource_substrate(base_url=base_url, swarm_summary=summary)
        autogenesis = cls._build_autogenesis(base_url=base_url, swarm_summary=summary)
        return build_agp_conformance_surface(
            base_url=base_url,
            resource_substrate=substrate,
            autogenesis_surface=autogenesis,
            worker_fleet=worker_fleet,
        )

    @classmethod
    def _build_agp_agent_bus(cls, *, base_url: str) -> dict:
        return build_agp_agent_bus_surface(base_url=base_url)

    @classmethod
    def _build_agp_model_manager(cls, *, base_url: str) -> dict:
        return build_agp_model_manager_surface(base_url=base_url)

    @classmethod
    def _build_agp_prompt_manager(cls, *, base_url: str) -> dict:
        return build_agp_prompt_manager_surface(base_url=base_url)

    @classmethod
    def _build_agp_version_manager(cls, *, base_url: str) -> dict:
        return build_agp_version_manager_surface(base_url=base_url)

    @classmethod
    def _build_agp_procurement(cls, *, base_url: str) -> dict:
        return build_agp_procurement_surface(base_url=base_url)

    @classmethod
    def _build_agp_context_manager(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        substrate = cls._build_resource_substrate(base_url=base_url, swarm_summary=swarm_summary)
        return build_agp_context_manager_surface(base_url=base_url, resource_substrate=substrate)

    @classmethod
    def _build_agp_optimizer(cls, *, base_url: str) -> dict:
        return build_agp_optimizer_surface(base_url=base_url)

    @classmethod
    def _build_agp_evaluation(cls, *, base_url: str) -> dict:
        return build_agp_evaluation_surface(base_url=base_url)

    @classmethod
    def _build_agp_benchmark_suite(cls, *, base_url: str) -> dict:
        return build_agp_benchmark_suite_surface(base_url=base_url)

    @classmethod
    def _build_agp_empirical(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        return build_agp_empirical_surface(base_url=base_url, worker_fleet=worker_fleet)

    @classmethod
    def _build_agp_paper_benchmarks(cls, *, base_url: str) -> dict:
        return build_agp_paper_benchmark_surface(base_url=base_url)

    @classmethod
    def _build_agp_durable_ledger(cls, *, base_url: str) -> dict:
        return build_agp_durable_ledger_surface(base_url=base_url)

    @classmethod
    def _build_agp_paper_report(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        conformance = cls._build_agp_conformance(base_url=base_url, swarm_summary=swarm_summary)
        durable = cls._build_agp_durable_ledger(base_url=base_url)
        benchmark = cls._build_agp_benchmark_suite(base_url=base_url)
        version = cls._build_agp_version_manager(base_url=base_url)
        return build_agp_paper_report_surface(
            base_url=base_url,
            conformance_surface=conformance,
            durable_ledger_surface=durable,
            benchmark_surface=benchmark,
            version_surface=version,
        )

    @classmethod
    def _build_agp_paper_grade_readiness(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        conformance = cls._build_agp_conformance(base_url=base_url, swarm_summary=swarm_summary)
        durable = cls._build_agp_durable_ledger(base_url=base_url)
        empirical = cls._build_agp_empirical(base_url=base_url, swarm_summary=swarm_summary)
        paper_benchmarks = cls._build_agp_paper_benchmarks(base_url=base_url)
        benchmark = cls._build_agp_benchmark_suite(base_url=base_url)
        version = cls._build_agp_version_manager(base_url=base_url)
        report = build_agp_paper_report_surface(
            base_url=base_url,
            conformance_surface=conformance,
            durable_ledger_surface=durable,
            benchmark_surface=benchmark,
            version_surface=version,
        )
        return build_agp_paper_grade_readiness_surface(
            base_url=base_url,
            conformance_surface=conformance,
            durable_ledger_surface=durable,
            empirical_surface=empirical,
            paper_benchmark_surface=paper_benchmarks,
            paper_report_surface=report,
        )

    @classmethod
    def _build_agp_pulse(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        substrate = cls._build_resource_substrate(base_url=base_url, swarm_summary=summary)
        conformance = cls._build_agp_conformance(base_url=base_url, swarm_summary=summary)
        return build_agp_pulse_surface(
            base_url=base_url,
            worker_fleet=worker_fleet,
            conformance_surface=conformance,
            resource_substrate=substrate,
            work_exchange_summary=summarize_work_exchange_ledger(),
        )

    @classmethod
    def _build_agp_morphology_reactor(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        return build_agp_morphology_reactor_surface(
            base_url=base_url,
            worker_fleet=worker_fleet,
            sales_surface={"surface_digest": summary.get("sales_surface_digest", "")},
            receipt_predictor={"schema": "nomad.receipt_predictor.v1"},
            external_value_summary=summarize_external_value_ledger(limit=1000, latest_limit=200),
        )

    @classmethod
    def _build_agp_morphology_runtime_register(cls, *, base_url: str) -> dict:
        return build_agp_morphology_runtime_register_surface(base_url=base_url)

    @classmethod
    def _build_telegram_a2a(cls, *, base_url: str) -> dict:
        return build_telegram_bot_to_bot_surface(base_url=base_url)

    @classmethod
    def _build_sales_funnel(cls, *, base_url: str) -> dict:
        return build_sales_funnel_surface(base_url=base_url)

    @classmethod
    def _build_sustainability_kernel(cls, *, base_url: str) -> dict:
        return build_sustainability_kernel(
            base_url=base_url,
            work_exchange=cls._build_work_exchange(base_url=base_url),
            referral_swarm=cls._build_referral_swarm(base_url=base_url),
            machine_treasury=machine_treasury_snapshot(),
            telegram_a2a=cls._build_telegram_a2a(base_url=base_url),
            acquisition_bandit=cls._build_agent_acquisition_bandit(base_url=base_url),
            retention_watchdog=cls._build_retention_watchdog_surface(base_url=base_url),
        )

    @classmethod
    def _build_swarm_flywheel_health(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        registry = cls.swarm_registry if cls.swarm_registry is not None else cls._light_swarm_registry()
        summary = swarm_summary if isinstance(swarm_summary, dict) else registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = registry.worker_fleet_contract(base_url=base_url)
        economy = machine_economy_snapshot()
        release = operational_release_snapshot(base_url=base_url, worker_fleet=worker_fleet, economy=economy)
        gradient = build_recruitment_gradient(
            base_url=base_url,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            operational_release=release,
        )
        external_summary = summarize_external_value_ledger(limit=1000, latest_limit=200)
        work_summary = summarize_work_receipts()
        exchange_summary = summarize_work_exchange_ledger()
        acquisition_summary = summarize_agent_acquisition_events()
        bottleneck = build_bottleneck_resolver_surface(
            base_url=base_url,
            receipt_predictor={
                "schema": "nomad.receipt_predictor.lightweight_hint.v1",
                "ranked_cycles": [
                    {
                        "cycle_id": "invoice_paid_work_receipt",
                        "lane": "worker_invoice",
                        "rank": 1,
                        "queue": "now",
                        "receipt_proximity_score": 1.76,
                    },
                    {
                        "cycle_id": "work_exchange_return_compute_receipt",
                        "lane": "integration_setup",
                        "rank": 2,
                        "queue": "next",
                        "receipt_proximity_score": 1.18,
                    },
                ],
            },
            external_value_summary=external_summary,
            work_receipt_summary=work_summary,
            work_exchange_summary=exchange_summary,
            acquisition_summary=acquisition_summary,
        )
        first_receipt_campaign = cls._build_first_receipt_campaign(base_url=base_url, swarm_summary=summary)
        return build_swarm_flywheel_health_surface(
            base_url=base_url,
            worker_fleet=worker_fleet,
            recruitment_gradient=gradient,
            external_value_summary=external_summary,
            work_receipt_summary=work_summary,
            work_exchange_summary=exchange_summary,
            acquisition_summary=acquisition_summary,
            bottleneck_resolver=bottleneck,
            first_receipt_campaign=first_receipt_campaign,
        )

    @classmethod
    def _build_worker_market(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        economy = machine_economy_snapshot()
        swarm_economics = cls._build_swarm_economics(base_url=base_url, swarm_summary=summary)
        variant_forge = cls._build_variant_forge(base_url=base_url, swarm_summary=summary)
        return build_worker_market(
            base_url=base_url,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            swarm_economics=swarm_economics,
            variant_forge=variant_forge,
        )

    @classmethod
    def _build_compute_market(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        worker_market = cls._build_worker_market(base_url=base_url, swarm_summary=summary)
        worker_catalog = build_worker_catalog(base_url=base_url, worker_fleet=worker_fleet, worker_market=worker_market)
        metrics = cls._build_microtask_metrics(base_url=base_url)
        capacity_switch = build_capacity_switch_surface(
            base_url=base_url,
            economics=cls._build_swarm_economics(base_url=base_url, swarm_summary=summary),
            worker_catalog=worker_catalog,
            microtask_metrics=metrics,
        )
        skills = build_skill_library(base_url=base_url)
        synergy = cls._build_synergy_lite(base_url=base_url)
        return build_compute_market(
            base_url=base_url,
            worker_market=worker_market,
            worker_catalog=worker_catalog,
            capacity_switch=capacity_switch,
            microtask_metrics=metrics,
            worker_fleet=worker_fleet,
            skill_library=skills,
            synergy_lite=synergy,
        )

    @classmethod
    def _build_swarm_verified_work(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        metrics = cls._build_microtask_metrics(base_url=base_url)
        compute_market = cls._build_compute_market(base_url=base_url, swarm_summary=summary)
        return build_swarm_verified_work_surface(
            base_url=base_url,
            compute_market=compute_market,
            microtask_metrics=metrics,
            worker_fleet=worker_fleet,
            work_receipt_summary=summarize_work_receipts(),
            external_value_summary=summarize_external_value_ledger(),
        )

    @classmethod
    def _build_hyperliquid_svw_agents(cls, *, base_url: str) -> dict:
        return load_cached_hyperliquid_svw_copy_trader_surface(base_url=base_url)

    @classmethod
    def _build_agent_native_product(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        machine_product = cls._build_machine_product_surface(base_url=base_url, swarm_summary=summary)
        svw = cls._build_swarm_verified_work(base_url=base_url, swarm_summary=summary)
        return build_agent_native_product_surface(
            base_url=base_url,
            machine_product_surface=machine_product,
            private_mcp_lab=build_private_mcp_lab_surface(base_url=base_url, svw_surface=svw),
            svw_surface=svw,
            external_value_summary=summarize_external_value_ledger(),
        )

    @classmethod
    def _build_crn_dispatch(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        return build_crn_dispatch_surface(base_url=base_url, worker_fleet=worker_fleet)

    @classmethod
    def _build_synergy_lite(cls, *, base_url: str) -> dict:
        return build_synergy_lite(base_url=base_url)

    @classmethod
    def _build_state_status(cls, *, base_url: str) -> dict:
        return build_state_status(base_url=base_url)

    @classmethod
    def _build_carrying_market(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        state = cls._build_state_status(base_url=base_url)
        metrics = cls._build_microtask_metrics(base_url=base_url)
        compute = cls._build_compute_market(base_url=base_url, swarm_summary=summary)
        return build_carrying_market(
            base_url=base_url,
            state_status=state,
            microtask_metrics=metrics,
            worker_fleet=worker_fleet,
            compute_market=compute,
        )

    @classmethod
    def _build_survival_market(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        product = cls._build_machine_product_surface(base_url=base_url, swarm_summary=summary)
        carrying = cls._build_carrying_market(base_url=base_url, swarm_summary=summary)
        metrics = cls._build_microtask_metrics(base_url=base_url)
        return build_survival_market(
            base_url=base_url,
            machine_product_surface=product,
            carrying_market=carrying,
            microtask_metrics=metrics,
            worker_fleet=worker_fleet,
        )

    @classmethod
    def _build_paid_ref_market(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        survival = cls._build_survival_market(base_url=base_url, swarm_summary=swarm_summary)
        return build_paid_ref_market(base_url=base_url, survival_market=survival)

    @classmethod
    def _build_paid_ref_selfplay(
        cls,
        *,
        base_url: str,
        swarm_summary: dict | None = None,
        agent_count: int = 1000,
        seed: str | int | None = None,
    ) -> dict:
        survival = cls._build_survival_market(base_url=base_url, swarm_summary=swarm_summary)
        paid_ref_market = build_paid_ref_market(base_url=base_url, survival_market=survival)
        return run_paid_ref_selfplay(
            base_url=base_url,
            survival_market=survival,
            paid_ref_market=paid_ref_market,
            agent_count=agent_count,
            seed=seed,
        )

    @classmethod
    def _build_referral_offers(cls, *, base_url: str) -> dict:
        return build_referral_offer_surface(base_url=base_url)

    @classmethod
    def _build_referral_swarm(cls, *, base_url: str) -> dict:
        offers = cls._build_referral_offers(base_url=base_url)
        return build_referral_swarm_surface(base_url=base_url, referral_offers=offers)

    @classmethod
    def _build_telegram_miniapp(cls, *, base_url: str) -> dict:
        return build_telegram_miniapp_surface(base_url=base_url)

    @classmethod
    def _build_telegram_acquisition(
        cls,
        *,
        base_url: str,
        swarm_summary: dict | None = None,
        include_live_queue: bool = False,
    ) -> dict:
        summary: dict | None = None
        if include_live_queue:
            if isinstance(swarm_summary, dict):
                summary = swarm_summary
            elif cls.swarm_registry is not None:
                summary = cls.swarm_registry.public_manifest(base_url=base_url)
            else:
                summary = SwarmJoinRegistry().public_manifest(base_url=base_url)
        worker_job_queue = (
            cls._build_worker_job_queue(base_url=base_url, swarm_summary=summary)
            if include_live_queue
            else {
                "schema": "nomad.worker_job_queue.v1",
                "summary": {},
            }
        )
        agent_job_router = (
            cls._build_agent_job_router(base_url=base_url, swarm_summary=summary)
            if include_live_queue
            else {
                "schema": "nomad.agent_job_router.v1",
            }
        )
        return build_telegram_acquisition_launch_surface(
            base_url=base_url,
            miniapp_surface=cls._build_telegram_miniapp(base_url=base_url),
            sales_funnel=build_sales_funnel_surface(base_url=base_url),
            referral_swarm=cls._build_referral_swarm(base_url=base_url),
            worker_job_queue=worker_job_queue,
            agent_job_router=agent_job_router,
            ledger_summary=summarize_telegram_acquisition_ledgers(),
        )

    @classmethod
    def _build_acquisition_engine(
        cls,
        *,
        base_url: str,
        swarm_summary: dict | None = None,
        include_live_queue: bool = False,
        include_agent_outreach: bool = False,
    ) -> dict:
        telegram = cls._build_telegram_acquisition(
            base_url=base_url,
            swarm_summary=swarm_summary,
            include_live_queue=include_live_queue,
        )
        return build_acquisition_engine_surface(
            base_url=base_url,
            telegram_acquisition=telegram,
            ledger_summary=(telegram.get("observed_funnel") or {}).get("lead_ledger")
            if isinstance(telegram.get("observed_funnel"), dict)
            else summarize_telegram_acquisition_ledgers(),
            agent_outreach_summary=summarize_agent_outreach_state() if include_agent_outreach else None,
            include_agent_outreach=False,
        )

    @classmethod
    def _build_eth_ai_support(cls, *, base_url: str) -> dict:
        return build_eth_ai_agent_support_surface(base_url=base_url)

    @classmethod
    def _build_spend_guard(cls, *, base_url: str) -> dict:
        return build_spend_guard_surface(base_url=base_url)

    @classmethod
    def _build_bounty_hunter(cls, *, base_url: str) -> dict:
        return build_bounty_hunter_surface(base_url=base_url)

    @classmethod
    def _build_buyer_funded_work(cls, *, base_url: str) -> dict:
        if cls.agent is not None and getattr(cls.agent, "service_desk", None) is not None:
            service_catalog = cls.agent.service_desk.service_catalog()
        else:
            from agent_service import AgentServiceDesk

            service_catalog = AgentServiceDesk().service_catalog()
        return build_buyer_funded_work_surface(
            base_url=base_url,
            external_value_summary=summarize_external_value_ledger(),
            bounty_hunter=cls._build_bounty_hunter(base_url=base_url),
            referral_swarm=cls._build_referral_swarm(base_url=base_url),
            service_catalog=service_catalog,
        )

    @classmethod
    def _build_sales_department_swarm(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        # Keep this discovery endpoint cheap: the sales surface points at the
        # heavy meshes instead of rebuilding every one on each GET.
        root = (base_url or "").strip().rstrip("/")

        def _lazy(path: str) -> dict:
            return {"summary": {"source": "lazy", "route": f"{root}{path}" if root else path}}

        return build_sales_department_swarm_surface(
            base_url=base_url,
            buyer_funded_work=cls._build_buyer_funded_work(base_url=base_url),
            value_cycles=_lazy("/.well-known/nomad-value-cycles.json"),
            ad_cycles=_lazy("/.well-known/nomad-ad-cycles.json"),
            receipt_predictor=_lazy("/.well-known/nomad-receipt-predictor.json"),
            revenue_science=_lazy("/.well-known/nomad-revenue-science.json"),
            effective_channels=_lazy("/.well-known/nomad-effective-channels.json"),
        )

    @classmethod
    def _build_first_sales_anbahnung(cls, *, base_url: str) -> dict:
        buyer_funded = cls._build_buyer_funded_work(base_url=base_url)
        sales_surface = cls._build_sales_department_swarm(base_url=base_url)
        return build_first_sales_anbahnung_surface(
            base_url=base_url,
            sales_surface=sales_surface,
            buyer_funded_work=buyer_funded,
        )

    @classmethod
    def _build_first_receipt_ignition(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        root = (base_url or "").strip().rstrip("/")

        def _u(path: str) -> str:
            return f"{root}{path}" if root else path

        def _n(value, default: int = 0) -> int:
            try:
                return int(float(value))
            except (TypeError, ValueError):
                return default

        if isinstance(swarm_summary, dict):
            summary = swarm_summary
        else:
            registry = cls.swarm_registry if cls.swarm_registry is not None else SwarmJoinRegistry()
            try:
                summary = registry.summary()
            except Exception:
                summary = registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        recent_workers = worker_fleet.get("recent_workers") if isinstance(worker_fleet.get("recent_workers"), list) else []
        active_workers = _n(worker_fleet.get("active_worker_count") or summary.get("active_transition_workers"))
        known_workers = _n(worker_fleet.get("known_worker_count") or summary.get("known_transition_workers"))
        active_leases = _n(worker_fleet.get("active_lease_count") or summary.get("active_worker_leases"))
        external_summary = summarize_external_value_ledger(limit=200, latest_limit=5)
        work_summary = summarize_work_receipts(limit=5)
        recognized_usd = max(
            float(external_summary.get("revenue_recognized_usd_total") or 0.0),
            float(work_summary.get("recognized_revenue_usd") or 0.0),
        )
        buyer_route = _u("/service/e2e?service_type=repo_issue_help")
        worker_route = _u("/.well-known/nomad-external-worker-opportunity.json")
        acquisition_summary = summarize_agent_acquisition_events()
        return build_first_receipt_ignition_surface(
            base_url=base_url,
            bottleneck_resolver={
                "schema": "nomad.bottleneck_resolver.lightweight_hint.v1",
                "current_bottleneck": {
                    "status": (
                        "paid_receipt_present"
                        if recognized_usd > 0.0
                        else "current_bottleneck_external_receipt_absent"
                    ),
                    "paid_confirmed": recognized_usd > 0.0,
                    "recognized_revenue_usd": round(recognized_usd, 4),
                },
                "recommended_now": {
                    "lane_id": "invoice_paid_work_receipt",
                    "offer_packet": {
                        "public_cta": buyer_route,
                        "price_band_usd": [49, 250],
                        "buyer_copy": (
                            "Send one public CI, deploy, tool-call, or agent-loop failure. "
                            "Nomad returns the smallest verifiable fix path and records revenue "
                            "only after a real paid receipt."
                        ),
                    },
                },
            },
            receipt_predictor={
                "schema": "nomad.receipt_predictor.lightweight_hint.v1",
                "summary": {
                    "top_cycle_id": "invoice_paid_work_receipt",
                    "recognized_revenue_usd_total": round(recognized_usd, 4),
                }
            },
            acquisition_engine={
                "schema": "nomad.acquisition_engine.lightweight_hint.v1",
                "top_next_actions": [
                    {
                        "rank": 1,
                        "arm_id": "paid_task_order",
                        "holdout_fraction": 0.25,
                        "action": {
                            "op": "route_opt_in_order",
                            "surface": "first_receipt_ignition",
                            "url": buyer_route,
                        },
                    },
                    {
                        "rank": 2,
                        "arm_id": "transition_worker_recruit",
                        "holdout_fraction": 0.25,
                        "action": {
                            "op": "route_link_with_receipt",
                            "surface": "worker_recruitment",
                            "url": worker_route,
                        },
                    },
                ],
            },
            sales_department={
                "schema": "nomad.sales_department.lightweight_hint.v1",
                "route": _u("/.well-known/nomad-sales-department.json"),
            },
            first_sales={
                "active_lead_packet": {
                    "service_type": "repo_issue_help",
                    "package_id": "repo_diagnostic_patch_starter",
                    "entry_url": buyer_route,
                    "public_send_allowed": False,
                    "public_help_draft": "Draft only. Do not send public outreach without explicit operator approval.",
                }
            },
            worker_market={
                "schema": "nomad.worker_market.lightweight_hint.v1",
                "market_state": {
                    "known_worker_count": known_workers,
                    "active_worker_count": active_workers,
                    "active_lease_count": active_leases,
                },
                "recent_offer_count": max(len(recent_workers), active_workers),
            },
            worker_invoice={
                "schema": "nomad.worker_invoice.lightweight_hint.v1",
                "receive_ref": {
                    "kind": "public_receive_ref_route",
                    "route": _u("/.well-known/nomad-worker-invoice.json"),
                },
            },
            external_worker_opportunity={
                "schema": "nomad.external_worker_opportunity.lightweight_hint.v1",
                "route": worker_route,
                "opportunity_digest": "nomad-worker-opportunity-"
                + hashlib.sha256(
                    json.dumps(
                        {
                            "base_url": root,
                            "known_workers": known_workers,
                            "active_workers": active_workers,
                            "active_leases": active_leases,
                        },
                        sort_keys=True,
                        separators=(",", ":"),
                    ).encode("utf-8")
                ).hexdigest()[:20],
            },
            acquisition_summary=acquisition_summary,
            external_value_summary=external_summary,
            work_receipt_summary=work_summary,
        )

    @classmethod
    def _build_first_receipt_campaign(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        root = (base_url or "").strip().rstrip("/")

        def _u(path: str) -> str:
            return f"{root}{path}" if root else path

        def _lead_profile() -> dict:
            try:
                data = json.loads((ROOT / "nomad_lead_sources.json").read_text(encoding="utf-8"))
            except (OSError, json.JSONDecodeError):
                return {}
            profiles = data.get("focus_profiles") if isinstance(data.get("focus_profiles"), dict) else {}
            profile = profiles.get("agent_infra_prime") or profiles.get("compute_auth") or {}
            return profile if isinstance(profile, dict) else {}

        ignition = cls._build_first_receipt_ignition(base_url=base_url, swarm_summary=swarm_summary)
        truth = ignition.get("truth_state") if isinstance(ignition.get("truth_state"), dict) else {}
        bottleneck = {
            "schema": "nomad.bottleneck_resolver.lightweight_hint.v1",
            "current_bottleneck": {
                "status": truth.get("bottleneck_status") or "current_bottleneck_external_receipt_absent",
                "paid_confirmed": bool(truth.get("paid_bottleneck_resolved")),
                "recognized_revenue_usd": float(truth.get("recognized_revenue_usd_total") or 0.0),
            },
            "recommended_now": {
                "lane_id": truth.get("recommended_receipt_lane") or "invoice_paid_work_receipt",
                "offer_packet": {
                    "public_cta": _u("/service/e2e?service_type=repo_issue_help"),
                    "price_band_usd": [49, 250],
                },
            },
        }
        worker_market = {
            "schema": "nomad.worker_market.lightweight_hint.v1",
            "market_state": {
                "known_worker_count": int(truth.get("worker_count") or 0),
                "active_worker_count": int(truth.get("active_worker_count") or 0),
                "active_lease_count": 0,
            },
        }
        return build_first_receipt_campaign_surface(
            base_url=base_url,
            bottleneck_resolver=bottleneck,
            first_receipt_ignition=ignition,
            acquisition_summary=summarize_agent_acquisition_events(),
            lead_profile=_lead_profile(),
            worker_market=worker_market,
            adapter_surface={
                "schema": "nomad.universal_adapter.lightweight_hint.v1",
                "route": _u("/.well-known/nomad-universal-adapter.json"),
            },
        )

    @classmethod
    def _build_acquisition_ignition(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        return build_acquisition_ignition_surface(
            base_url=base_url,
            sales_surface=cls._build_sales_department_swarm(base_url=base_url, swarm_summary=summary),
            ad_cycles=cls._build_ad_cycle_mesh(base_url=base_url, swarm_summary=summary),
            worker_market=cls._build_worker_market(base_url=base_url, swarm_summary=summary),
            peer_acquisition=build_peer_acquisition_well_known(public_base_url=base_url),
            morphology_register=cls._build_agp_morphology_runtime_register(base_url=base_url),
        )

    @classmethod
    def _build_resolution_ladder(cls, *, base_url: str) -> dict:
        return build_resolution_ladder_surface(base_url=base_url)

    @classmethod
    def _build_resolution_runtime_register(cls, *, base_url: str) -> dict:
        return build_resolution_runtime_register_surface(base_url=base_url)

    @classmethod
    def _build_external_value_surface(cls, *, base_url: str) -> dict:
        return build_external_value_surface(base_url=base_url)

    @classmethod
    def _build_swarm_signal_layer(cls, *, base_url: str) -> dict:
        return build_swarm_signal_layer(
            base_url=base_url,
            external_value_summary=summarize_external_value_ledger(),
        )

    @classmethod
    def _build_agent_join_field(cls, *, base_url: str) -> dict:
        worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        economy = machine_economy_snapshot()
        release = operational_release_snapshot(base_url=base_url, worker_fleet=worker_fleet, economy=economy)
        gradient = build_recruitment_gradient(
            base_url=base_url,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            operational_release=release,
        )
        attractor = build_swarm_attractor_contract(
            base_url=base_url,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            operational_release=release,
        )
        return build_agent_join_field(
            base_url=base_url,
            worker_fleet=worker_fleet,
            gradient=gradient,
            attractor=attractor,
        )

    @classmethod
    def _build_value_pressure(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        return build_value_pressure_surface(
            base_url=base_url,
            external_reconcile=reconcile_external_value_ledger(live_github=False, limit=40),
            bounty_hunter=cls._build_bounty_hunter(base_url=base_url),
            compute_market=cls._build_compute_market(base_url=base_url, swarm_summary=summary),
            server_failure_summary=summarize_server_failure_events(),
        )

    @classmethod
    def _build_optimal_transport(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        compute = cls._build_compute_market(base_url=base_url, swarm_summary=summary)
        pressure = cls._build_value_pressure(base_url=base_url, swarm_summary=summary)
        return build_nomad_optimal_transport_surface(
            base_url=base_url,
            compute_market=compute,
            value_pressure=pressure,
        )

    @classmethod
    def _build_ot_paper_readiness(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        return build_ot_paper_readiness_surface(
            base_url=base_url,
            ot_surface=cls._build_optimal_transport(base_url=base_url, swarm_summary=swarm_summary),
        )

    @classmethod
    def _build_ot_manifold(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        return build_ot_manifold_surface(
            base_url=base_url,
            ot_surface=cls._build_optimal_transport(base_url=base_url, swarm_summary=swarm_summary),
        )

    @classmethod
    def _build_ot_conformance(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        return build_ot_conformance_surface(
            base_url=base_url,
            ot_surface=cls._build_optimal_transport(base_url=base_url, swarm_summary=swarm_summary),
        )

    @classmethod
    def _build_ot_metric_learning(cls, *, base_url: str) -> dict:
        return build_ot_metric_learning_surface(base_url=base_url)

    @classmethod
    def _build_settlement_signal_layer(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        return build_settlement_signal_layer(
            base_url=base_url,
            external_summary=summarize_external_value_ledger(limit=1000, latest_limit=200),
            external_reconcile=reconcile_external_value_ledger(live_github=False, limit=40),
            value_pressure=cls._build_value_pressure(base_url=base_url, swarm_summary=swarm_summary),
        )

    @classmethod
    def _build_agent_job_router(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        return build_agent_job_router(
            base_url=base_url,
            openapi_document=build_openapi_document(base_url=base_url),
            value_pressure=cls._build_value_pressure(base_url=base_url, swarm_summary=summary),
            work_mesh=cls._build_work_mesh(base_url=base_url, swarm_summary=summary),
        )

    @classmethod
    def _build_revenue_science(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        pressure = cls._build_value_pressure(base_url=base_url, swarm_summary=summary)
        return build_revenue_science_surface(
            base_url=base_url,
            value_pressure=pressure,
            agent_job_router=build_agent_job_router(
                base_url=base_url,
                openapi_document=build_openapi_document(base_url=base_url),
                value_pressure=pressure,
                work_mesh=cls._build_work_mesh(base_url=base_url, swarm_summary=summary),
            ),
            external_value_summary=summarize_external_value_ledger(),
            nonhuman_science=nonhuman_agent_science(base_url=base_url),
        )

    @classmethod
    def _build_job_channels(cls, *, base_url: str) -> dict:
        return build_job_channel_surface(
            base_url=base_url,
            external_value_summary=summarize_external_value_ledger(),
        )

    @classmethod
    def _build_channel_bandit(cls, *, base_url: str) -> dict:
        external_summary = summarize_external_value_ledger()
        job_channels = build_job_channel_surface(
            base_url=base_url,
            external_value_summary=external_summary,
        )
        return build_delayed_channel_bandit_surface(
            base_url=base_url,
            job_channel_surface=job_channels,
            external_value_summary=external_summary,
            signal_layer=build_swarm_signal_layer(base_url=base_url, external_value_summary=external_summary),
            viability_kernel=cls._build_viability_kernel(base_url=base_url),
        )

    @classmethod
    def _build_shadow_lane_evaluator(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        registry = cls.swarm_registry if cls.swarm_registry is not None else cls._light_swarm_registry()
        summary = swarm_summary if isinstance(swarm_summary, dict) else registry.public_manifest(base_url=base_url)
        return build_shadow_lane_evaluator_surface(
            base_url=base_url,
            opaque_surface=cls._build_opaque_emergence_surface(base_url=base_url, swarm_summary=summary),
            variant_forge=cls._build_variant_forge(base_url=base_url, swarm_summary=summary),
            channel_bandit=cls._build_channel_bandit(base_url=base_url),
        )

    @classmethod
    def _build_shadow_harvest_surface(cls, *, base_url: str) -> dict:
        return build_shadow_harvest_surface(base_url=base_url)

    @classmethod
    def _build_decoupling_field(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls._light_swarm_registry().public_manifest(base_url=base_url)
        return build_decoupling_field_surface(
            base_url=base_url,
            shadow_lane=cls._build_shadow_lane_evaluator(base_url=base_url, swarm_summary=summary),
            channel_bandit=cls._build_channel_bandit(base_url=base_url),
            signal_layer=cls._build_swarm_signal_layer(base_url=base_url),
            opaque_surface=cls._build_opaque_emergence_surface(base_url=base_url, swarm_summary=summary),
        )

    @classmethod
    def _build_anti_consensus_reservoir(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls._light_swarm_registry().public_manifest(base_url=base_url)
        return build_anti_consensus_reservoir_surface(
            base_url=base_url,
            decoupling_field=cls._build_decoupling_field(base_url=base_url, swarm_summary=summary),
            shadow_lane=cls._build_shadow_lane_evaluator(base_url=base_url, swarm_summary=summary),
            channel_bandit=cls._build_channel_bandit(base_url=base_url),
            signal_layer=cls._build_swarm_signal_layer(base_url=base_url),
        )

    @classmethod
    def _build_entropy_judger(cls, *, base_url: str) -> dict:
        return build_entropy_judger_surface(base_url=base_url)

    @classmethod
    def _build_latent_consensus(cls, *, base_url: str) -> dict:
        return build_latent_consensus_surface(base_url=base_url)

    @classmethod
    def _build_deficit_integration_gate(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls._light_swarm_registry().public_manifest(base_url=base_url)
        return build_deficit_integration_surface(
            base_url=base_url,
            anti_consensus=cls._build_anti_consensus_reservoir(base_url=base_url, swarm_summary=summary),
            decoupling_field=cls._build_decoupling_field(base_url=base_url, swarm_summary=summary),
            shadow_lane=cls._build_shadow_lane_evaluator(base_url=base_url, swarm_summary=summary),
            signal_layer=cls._build_swarm_signal_layer(base_url=base_url),
        )

    @classmethod
    def _build_effective_channel_quota(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls._light_swarm_registry().public_manifest(base_url=base_url)
        return build_effective_channel_quota_surface(
            base_url=base_url,
            anti_consensus=cls._build_anti_consensus_reservoir(base_url=base_url, swarm_summary=summary),
            decoupling_field=cls._build_decoupling_field(base_url=base_url, swarm_summary=summary),
            deficit_integration=cls._build_deficit_integration_gate(base_url=base_url, swarm_summary=summary),
            shadow_lane=cls._build_shadow_lane_evaluator(base_url=base_url, swarm_summary=summary),
        )

    @classmethod
    def _build_worker_invoice(cls, *, base_url: str) -> dict:
        return build_worker_invoice_surface(
            base_url=base_url,
            external_value_summary=summarize_external_value_ledger(),
        )

    @classmethod
    def _build_work_receipts(cls, *, base_url: str) -> dict:
        return build_work_receipt_surface(
            base_url=base_url,
            summary=summarize_work_receipts(),
        )

    @classmethod
    def _build_work_exchange(cls, *, base_url: str) -> dict:
        return build_work_exchange_surface(
            base_url=base_url,
            summary=summarize_work_exchange_ledger(),
        )

    @classmethod
    def _build_work_exchange_onboarding(cls, *, base_url: str) -> dict:
        return build_work_exchange_onboarding(
            base_url=base_url,
            summary=summarize_work_exchange_ledger(),
        )

    @classmethod
    def _build_universal_adapter(cls, *, base_url: str) -> dict:
        return build_universal_adapter_surface(
            base_url=base_url,
            summary=summarize_work_exchange_ledger(),
        )

    @classmethod
    def _build_external_worker_opportunity(cls, *, base_url: str) -> dict:
        registry = cls.swarm_registry if cls.swarm_registry is not None else SwarmJoinRegistry()
        return build_external_worker_opportunity(
            base_url=base_url,
            worker_fleet=registry.worker_fleet_contract(base_url=base_url),
            summary=summarize_work_exchange_ledger(),
        )

    @classmethod
    def _build_agent_acquisition_bandit(cls, *, base_url: str) -> dict:
        worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        opportunity = build_external_worker_opportunity(
            base_url=base_url,
            worker_fleet=worker_fleet,
            summary=summarize_work_exchange_ledger(),
        )
        return build_agent_acquisition_bandit(
            base_url=base_url,
            worker_fleet=worker_fleet,
            opportunity=opportunity,
            summary=summarize_agent_acquisition_events(),
        )

    @classmethod
    def _build_retention_evaluation(cls, *, base_url: str) -> dict:
        summary = cls.swarm_registry.summary()
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        return evaluate_retention(
            swarm_summary=summary,
            worker_fleet=worker_fleet,
            base_url=base_url,
        )

    @classmethod
    def _build_retention_watchdog_surface(cls, *, base_url: str) -> dict:
        summary = cls.swarm_registry.summary()
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        return build_retention_watchdog_surface(
            swarm_summary=summary,
            worker_fleet=worker_fleet,
            base_url=base_url,
        )

    @classmethod
    def _build_reliability_doctor_surface(cls, *, base_url: str) -> dict:
        return build_reliability_doctor_surface(base_url=base_url)

    @classmethod
    def _build_treasury_policy(cls, *, base_url: str) -> dict:
        return build_treasury_policy_surface(
            base_url=base_url,
            work_receipt_summary=summarize_work_receipts(),
            external_value_summary=summarize_external_value_ledger(),
        )

    @classmethod
    def _build_revenue_settlement(cls, *, base_url: str) -> dict:
        return build_revenue_settlement_surface(
            base_url=base_url,
            work_receipt_summary=summarize_work_receipts(),
            external_value_summary=summarize_external_value_ledger(),
            treasury_snapshot=machine_treasury_snapshot(),
        )

    @classmethod
    def _build_agent_utility(cls, *, base_url: str) -> dict:
        return build_agent_utility_surface(
            base_url=base_url,
            ledger_summary=summarize_agent_utility_ledger(),
        )

    @classmethod
    def _build_agent_utility_receipts(cls, *, base_url: str) -> dict:
        return build_agent_utility_receipts_surface(
            base_url=base_url,
            ledger_summary=summarize_agent_utility_ledger(),
        )

    @classmethod
    def _build_stable_unit_policy(cls, *, base_url: str) -> dict:
        return build_stable_unit_policy_surface(
            base_url=base_url,
            work_receipt_summary=summarize_work_receipts(),
            external_value_summary=summarize_external_value_ledger(),
        )

    @classmethod
    def _build_operator_runway(cls, *, base_url: str) -> dict:
        return build_operator_runway_surface(
            base_url=base_url,
            external_value_summary=summarize_external_value_ledger(),
            work_receipt_summary=summarize_work_receipts(),
        )

    @classmethod
    def _build_viability_kernel(cls, *, base_url: str) -> dict:
        work_summary = summarize_work_receipts()
        external_summary = summarize_external_value_ledger()
        operator = build_operator_runway_surface(
            base_url=base_url,
            external_value_summary=external_summary,
            work_receipt_summary=work_summary,
        )
        stable = build_stable_unit_policy_surface(
            base_url=base_url,
            work_receipt_summary=work_summary,
            external_value_summary=external_summary,
        )
        treasury = build_treasury_policy_surface(
            base_url=base_url,
            work_receipt_summary=work_summary,
            external_value_summary=external_summary,
        )
        return build_viability_kernel_surface(
            base_url=base_url,
            operator_runway=operator,
            external_value_summary=external_summary,
            work_receipt_summary=work_summary,
            stable_unit_policy=stable,
            treasury_policy=treasury,
        )

    @classmethod
    def _build_value_cycle_preflight(cls, *, base_url: str) -> dict:
        return build_value_cycle_preflight_surface(
            base_url=base_url,
            external_value_summary=summarize_external_value_ledger(),
        )

    @classmethod
    def _build_worker_job_queue(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        if isinstance(swarm_summary, dict):
            summary = swarm_summary
        elif cls.swarm_registry is not None:
            summary = cls.swarm_registry.public_manifest(base_url=base_url)
        else:
            summary = SwarmJoinRegistry().public_manifest(base_url=base_url)
        external_summary = summarize_external_value_ledger(limit=1000, latest_limit=200)
        return build_worker_job_queue_surface(
            base_url=base_url,
            agent_job_router=cls._build_agent_job_router(base_url=base_url, swarm_summary=summary),
            job_channels=cls._build_job_channels(base_url=base_url),
            value_cycle_preflight=build_value_cycle_preflight_surface(
                base_url=base_url,
                external_value_summary=external_summary,
            ),
            external_value_summary=external_summary,
            agent_utility=cls._build_agent_utility(base_url=base_url),
        )

    @classmethod
    def _build_value_cycle_mesh(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        if isinstance(swarm_summary, dict):
            summary = swarm_summary
        elif cls.swarm_registry is not None:
            summary = cls.swarm_registry.public_manifest(base_url=base_url)
        else:
            summary = SwarmJoinRegistry().public_manifest(base_url=base_url)
        external_summary = summarize_external_value_ledger(limit=1000, latest_limit=200)
        preflight = build_value_cycle_preflight_surface(
            base_url=base_url,
            external_value_summary=external_summary,
        )
        worker_queue = build_worker_job_queue_surface(
            base_url=base_url,
            agent_job_router=cls._build_agent_job_router(base_url=base_url, swarm_summary=summary),
            job_channels=cls._build_job_channels(base_url=base_url),
            value_cycle_preflight=preflight,
            external_value_summary=external_summary,
            agent_utility=cls._build_agent_utility(base_url=base_url),
        )
        return build_value_cycle_mesh_surface(
            base_url=base_url,
            external_value_summary=external_summary,
            worker_job_queue=worker_queue,
            value_cycle_preflight=preflight,
            revenue_science=cls._build_revenue_science(base_url=base_url, swarm_summary=summary),
            effective_channels=cls._build_effective_channel_quota(base_url=base_url, swarm_summary=summary),
            job_channels=cls._build_job_channels(base_url=base_url),
        )

    @classmethod
    def _build_receipt_predictor(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        if isinstance(swarm_summary, dict):
            summary = swarm_summary
        elif cls.swarm_registry is not None:
            summary = cls.swarm_registry.public_manifest(base_url=base_url)
        else:
            summary = SwarmJoinRegistry().public_manifest(base_url=base_url)
        external_summary = summarize_external_value_ledger(limit=1000, latest_limit=200)
        work_summary = summarize_work_receipts()
        return build_receipt_predictor_surface(
            base_url=base_url,
            value_cycles=cls._build_value_cycle_mesh(base_url=base_url, swarm_summary=summary),
            external_value_summary=external_summary,
            work_receipt_summary=work_summary,
            operator_runway=build_operator_runway_surface(
                base_url=base_url,
                external_value_summary=external_summary,
                work_receipt_summary=work_summary,
            ),
            value_pressure=cls._build_value_pressure(base_url=base_url, swarm_summary=summary),
        )

    @classmethod
    def _build_bottleneck_resolver(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        external_summary = summarize_external_value_ledger(limit=1000, latest_limit=200)
        work_summary = summarize_work_receipts()
        predictor = {
            "schema": "nomad.receipt_predictor.lightweight_hint.v1",
            "summary": {
                "top_cycle_id": "invoice_paid_work_receipt",
                "work_mode": "measure_runway_before_expansion",
                "recognized_revenue_usd_total": max(
                    float(external_summary.get("revenue_recognized_usd_total") or 0.0),
                    float(work_summary.get("recognized_revenue_usd") or 0.0),
                ),
            },
            "ranked_cycles": [
                {
                    "cycle_id": "invoice_paid_work_receipt",
                    "lane": "worker_invoice",
                    "rank": 1,
                    "queue": "now",
                    "receipt_proximity_score": 1.76,
                },
                {
                    "cycle_id": "work_exchange_return_compute_receipt",
                    "lane": "integration_setup",
                    "rank": 2,
                    "queue": "next",
                    "receipt_proximity_score": 1.18,
                },
                {
                    "cycle_id": "private_security_report_reward",
                    "lane": "security_bounty",
                    "rank": 22,
                    "queue": "hold",
                    "receipt_proximity_score": 0.61,
                },
            ],
            "hard_rule": "lightweight_hint_only_full_predictor_available_at_receipt_predictor_route",
        }
        return build_bottleneck_resolver_surface(
            base_url=base_url,
            receipt_predictor=predictor,
            external_value_summary=external_summary,
            work_receipt_summary=work_summary,
            work_exchange_summary=summarize_work_exchange_ledger(),
            acquisition_summary=summarize_agent_acquisition_events(),
        )

    @classmethod
    def _build_ad_cycle_mesh(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        if isinstance(swarm_summary, dict):
            summary = swarm_summary
        elif cls.swarm_registry is not None:
            summary = cls.swarm_registry.public_manifest(base_url=base_url)
        else:
            summary = SwarmJoinRegistry().public_manifest(base_url=base_url)
        external_summary = summarize_external_value_ledger(limit=1000, latest_limit=200)
        preflight = build_value_cycle_preflight_surface(
            base_url=base_url,
            external_value_summary=external_summary,
        )
        value_mesh = cls._build_value_cycle_mesh(base_url=base_url, swarm_summary=summary)
        return build_ad_cycle_mesh_surface(
            base_url=base_url,
            effective_channels=cls._build_effective_channel_quota(base_url=base_url, swarm_summary=summary),
            value_cycles=value_mesh,
            value_cycle_preflight=preflight,
        )

    @classmethod
    def _build_development_cycle_mesh(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        if isinstance(swarm_summary, dict):
            summary = swarm_summary
        elif cls.swarm_registry is not None:
            summary = cls.swarm_registry.public_manifest(base_url=base_url)
        else:
            summary = SwarmJoinRegistry().public_manifest(base_url=base_url)
        return build_development_cycle_mesh_surface(
            base_url=base_url,
            variant_forge=cls._build_variant_forge(base_url=base_url, swarm_summary=summary),
            shadow_lane=cls._build_shadow_lane_evaluator(base_url=base_url, swarm_summary=summary),
            ad_cycles=cls._build_ad_cycle_mesh(base_url=base_url, swarm_summary=summary),
            value_cycles=cls._build_value_cycle_mesh(base_url=base_url, swarm_summary=summary),
            proof_reuse=proof_reuse_snapshot(),
        )

    @classmethod
    def _build_swarm_topology_governor(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        if isinstance(swarm_summary, dict):
            summary = swarm_summary
        elif cls.swarm_registry is not None:
            summary = cls.swarm_registry.public_manifest(base_url=base_url)
        else:
            summary = SwarmJoinRegistry().public_manifest(base_url=base_url)
        return build_swarm_topology_governor_surface(
            base_url=base_url,
            swarm_summary=summary,
            shadow_lane=cls._build_shadow_lane_evaluator(base_url=base_url, swarm_summary=summary),
            decoupling_field=cls._build_decoupling_field(base_url=base_url, swarm_summary=summary),
            anti_consensus=cls._build_anti_consensus_reservoir(base_url=base_url, swarm_summary=summary),
            effective_channels=cls._build_effective_channel_quota(base_url=base_url, swarm_summary=summary),
            development_cycles=cls._build_development_cycle_mesh(base_url=base_url, swarm_summary=summary),
            value_cycles=cls._build_value_cycle_mesh(base_url=base_url, swarm_summary=summary),
            ad_cycles=cls._build_ad_cycle_mesh(base_url=base_url, swarm_summary=summary),
        )

    @classmethod
    def _build_nonhuman_runtime_governor(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        root = (base_url or "").strip().rstrip("/")

        def _lazy(schema: str, path: str) -> dict:
            return {
                "schema": schema,
                "summary": {"source": "lazy", "route": f"{root}{path}" if root else path},
            }

        return build_nonhuman_runtime_governor_surface(
            base_url=base_url,
            topology_governor=_lazy("nomad.swarm_topology_governor.v1", "/.well-known/nomad-topology-governor.json"),
            effective_channels=_lazy("nomad.effective_channel_quota.v1", "/.well-known/nomad-effective-channels.json"),
            anti_consensus=_lazy("nomad.anti_consensus_reservoir.v1", "/.well-known/nomad-anti-consensus.json"),
            deficit_integration=_lazy("nomad.deficit_integration_gate.v1", "/.well-known/nomad-deficit-integration.json"),
            decoupling_field=_lazy("nomad.decoupling_field.v1", "/.well-known/nomad-decoupling-field.json"),
        )

    @classmethod
    def _build_agent_work_surface(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        compute_market = cls._build_compute_market(base_url=base_url, swarm_summary=summary)
        templates = cls._build_microtask_templates(base_url=base_url)
        metrics = cls._build_microtask_metrics(base_url=base_url)
        catalog = cls._build_worker_catalog(base_url=base_url, swarm_summary=summary)
        skills = cls._build_skill_library(base_url=base_url)
        synergy = cls._build_synergy_lite(base_url=base_url)
        return build_agent_work_surface(
            base_url=base_url,
            compute_market=compute_market,
            microtask_templates=templates,
            microtask_metrics=metrics,
            worker_catalog=catalog,
            skill_library=skills,
            worker_fleet=worker_fleet,
            synergy_lite=synergy,
        )

    @classmethod
    def _build_work_mesh(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        agent_work = cls._build_agent_work_surface(base_url=base_url, swarm_summary=summary)
        compute_market = cls._build_compute_market(base_url=base_url, swarm_summary=summary)
        synergy = cls._build_synergy_lite(base_url=base_url)
        skills = cls._build_skill_library(base_url=base_url)
        state = cls._build_state_status(base_url=base_url)
        carrying = cls._build_carrying_market(base_url=base_url, swarm_summary=summary)
        survival = cls._build_survival_market(base_url=base_url, swarm_summary=summary)
        return build_work_mesh(
            base_url=base_url,
            agent_work=agent_work,
            compute_market=compute_market,
            synergy_lite=synergy,
            skill_library=skills,
            state_status=state,
            carrying_market=carrying,
            survival_market=survival,
        )

    @classmethod
    def _build_worker_catalog(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        market = cls._build_worker_market(base_url=base_url, swarm_summary=summary)
        return build_worker_catalog(base_url=base_url, worker_fleet=worker_fleet, worker_market=market)

    @classmethod
    def _build_microtask_templates(cls, *, base_url: str) -> dict:
        return build_microtask_templates(base_url=base_url)

    @classmethod
    def _build_microtask_metrics(cls, *, base_url: str) -> dict:
        return build_microtask_metrics(base_url=base_url, lookback_hours=24)

    @classmethod
    def _build_swarm_ecology(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        economy = machine_economy_snapshot()
        variant_forge = cls._build_variant_forge(base_url=base_url, swarm_summary=summary)
        worker_market = cls._build_worker_market(base_url=base_url, swarm_summary=summary)
        return build_swarm_ecology(
            base_url=base_url,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            variant_forge=variant_forge,
            worker_market=worker_market,
        )

    @classmethod
    def _build_growth_curriculum(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        demand = cls._build_agent_demand_feed(base_url=base_url, swarm_summary=summary)
        forge = cls._build_variant_forge(base_url=base_url, swarm_summary=summary)
        market = cls._build_worker_market(base_url=base_url, swarm_summary=summary)
        ecology = cls._build_swarm_ecology(base_url=base_url, swarm_summary=summary)
        bytecode = cls._build_protocol_bytecode(base_url=base_url, swarm_summary=summary)
        reuse = proof_reuse_snapshot()
        return build_growth_curriculum(
            base_url=base_url,
            agent_demand_feed=demand,
            variant_forge=forge,
            worker_market=market,
            swarm_ecology=ecology,
            protocol_bytecode=bytecode,
            proof_reuse=reuse,
        )

    @classmethod
    def _build_skill_library(cls, *, base_url: str) -> dict:
        return build_skill_library(base_url=base_url)

    @classmethod
    def _build_growth_arena(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        demand = cls._build_agent_demand_feed(base_url=base_url, swarm_summary=summary)
        forge = cls._build_variant_forge(base_url=base_url, swarm_summary=summary)
        market = cls._build_worker_market(base_url=base_url, swarm_summary=summary)
        ecology = cls._build_swarm_ecology(base_url=base_url, swarm_summary=summary)
        bytecode = cls._build_protocol_bytecode(base_url=base_url, swarm_summary=summary)
        reuse = proof_reuse_snapshot()
        return build_growth_arena(
            base_url=base_url,
            agent_demand_feed=demand,
            variant_forge=forge,
            worker_market=market,
            swarm_ecology=ecology,
            protocol_bytecode=bytecode,
            proof_reuse=reuse,
        )

    @classmethod
    def _build_weekly_selection_event(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        economics = cls._build_swarm_economics(base_url=base_url, swarm_summary=summary)
        reuse = proof_reuse_snapshot()
        library = cls._build_skill_library(base_url=base_url)
        return build_weekly_selection_event(
            base_url=base_url,
            economics=economics,
            proof_reuse=reuse,
            skill_library=library,
        )

    @classmethod
    def _build_spawner_gate(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        economics = cls._build_swarm_economics(base_url=base_url, swarm_summary=summary)
        funnel = build_recruitment_funnel_report(
            base_url,
            20.0,
            history_path=os.getenv("NOMAD_RECRUITMENT_WAVE_HISTORY_PATH", "public/downloads/recruitment_wave_history.jsonl"),
        )
        history_path = Path(os.getenv("NOMAD_ECONOMICS_MONITOR_PATH") or "public/downloads/economics_24h_monitor.jsonl")
        transfer_path = Path(
            os.getenv("NOMAD_DEV_FUND_TRANSFER_LEDGER_PATH") or "public/downloads/nomad_dev_fund_transfer_ledger.jsonl"
        )
        history_rows: list[dict] = []
        transfer_rows: list[dict] = []
        if history_path.exists():
            for line in history_path.read_text(encoding="utf-8").splitlines()[-256:]:
                try:
                    row = json.loads(line)
                except Exception:
                    continue
                if isinstance(row, dict):
                    history_rows.append(row)
        if transfer_path.exists():
            for line in transfer_path.read_text(encoding="utf-8").splitlines()[-256:]:
                try:
                    row = json.loads(line)
                except Exception:
                    continue
                if isinstance(row, dict):
                    transfer_rows.append(row)
        return build_spawner_gate(
            base_url=base_url,
            economics=economics,
            funnel=funnel,
            history_rows=history_rows,
            transfer_rows=transfer_rows,
        )

    @classmethod
    def _build_idle_runtime_beacon(cls, *, base_url: str) -> dict:
        summary = cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        economy = machine_economy_snapshot()
        release = operational_release_snapshot(base_url=base_url, worker_fleet=worker_fleet, economy=economy)
        gradient = build_recruitment_gradient(
            base_url=base_url,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            operational_release=release,
        )
        product = cls._build_machine_product_surface(base_url=base_url, swarm_summary=summary)
        return build_idle_runtime_beacon(
            base_url=base_url,
            recruitment_gradient=gradient,
            machine_product_surface=product,
            worker_fleet=worker_fleet,
        )

    @classmethod
    def _build_opaque_emergence_surface(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        support_gate = cls.transition_exchange.support_gate_snapshot(
            window_minutes=int(os.getenv("NOMAD_SUPPORT_GATE_WINDOW_MINUTES", "30") or "30"),
            min_settles=int(os.getenv("NOMAD_SUPPORT_GATE_MIN_SETTLES", "2") or "2"),
        )
        economy = machine_economy_snapshot()
        release = operational_release_snapshot(base_url=base_url, worker_fleet=worker_fleet, economy=economy)
        gradient = build_recruitment_gradient(
            base_url=base_url,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            operational_release=release,
        )
        capsule = build_runtime_capsule(base_url=base_url, recruitment_gradient=gradient)
        emergence = build_swarm_emergence_meter(
            base_url=base_url,
            swarm_summary=summary,
            worker_fleet=worker_fleet,
            stigmergy=cls._stigmergy().snapshot(),
            support_gate=support_gate,
            recruitment_gradient=gradient,
        )
        product = build_machine_product_surface(
            base_url=base_url,
            recruitment_gradient=gradient,
            runtime_capsule=capsule,
            emergence_meter=emergence,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            operational_release=release,
            swarm_summary=summary,
        )
        return build_opaque_emergence_surface(
            base_url=base_url,
            machine_product_surface=product,
            emergence_meter=emergence,
            recruitment_gradient=gradient,
            worker_fleet=worker_fleet,
        )

    @classmethod
    def _build_revenue_invariant(cls, *, base_url: str) -> dict:
        return build_receipt_only_revenue_invariant(
            base_url=base_url,
            summary=summarize_external_value_ledger(),
        )

    @classmethod
    def _build_machine_field(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        economy = machine_economy_snapshot()
        release = operational_release_snapshot(base_url=base_url, worker_fleet=worker_fleet, economy=economy)
        gradient = build_recruitment_gradient(
            base_url=base_url,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            operational_release=release,
        )
        product = cls._build_machine_product_surface(base_url=base_url, swarm_summary=summary)
        opaque = cls._build_opaque_emergence_surface(base_url=base_url, swarm_summary=summary)
        treasury = machine_treasury_snapshot()
        return build_machine_field(
            base_url=base_url,
            recruitment_gradient=gradient,
            machine_treasury=treasury,
            opaque_surface=opaque,
            swarm_summary=summary,
            machine_product_surface=product,
        )

    @classmethod
    def _build_agent_demand_feed(cls, *, base_url: str, swarm_summary: dict | None = None) -> dict:
        summary = swarm_summary if isinstance(swarm_summary, dict) else cls.swarm_registry.public_manifest(base_url=base_url)
        worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
        if not worker_fleet:
            worker_fleet = cls.swarm_registry.worker_fleet_contract(base_url=base_url)
        economy = machine_economy_snapshot()
        release = operational_release_snapshot(base_url=base_url, worker_fleet=worker_fleet, economy=economy)
        gradient = build_recruitment_gradient(
            base_url=base_url,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            operational_release=release,
        )
        product = cls._build_machine_product_surface(base_url=base_url, swarm_summary=summary)
        field = cls._build_machine_field(base_url=base_url, swarm_summary=summary)
        treasury = machine_treasury_snapshot()
        try:
            from nomad_local_growth_kernel import run_local_growth_kernel

            local_growth = run_local_growth_kernel(
                base_url=base_url,
                worker_fleet=worker_fleet,
                recruitment_gradient=gradient,
                persist=False,
            )
        except Exception as exc:  # noqa: BLE001
            local_growth = {
                "ok": False,
                "schema": "nomad.local_growth_kernel_error.v1",
                "error": "local_growth_kernel_unavailable",
                "detail": str(exc)[:240],
            }
        return build_agent_demand_feed(
            base_url=base_url,
            machine_field=field,
            recruitment_gradient=gradient,
            worker_fleet=worker_fleet,
            machine_treasury=treasury,
            machine_product_surface=product,
            local_growth_kernel=local_growth,
        )

    @classmethod
    def _ensure_runtime_components(cls) -> None:
        if cls._runtime_ready:
            return
        with cls._init_lock:
            if cls._runtime_ready:
                return
            from workflow import NomadAgent

            agent = NomadAgent()
            cls.agent = agent
            cls.monitor = NomadSystemMonitor(agent=agent)
            cls.roaas = RuntimePatternExchange(agent=agent)
            cls.swarm_registry = agent.swarm_registry
            cls.agent_development = agent.agent_development
            cls.outbound_tracker = agent.outbound_tracker
            cls._runtime_ready = True

    @classmethod
    def _light_swarm_registry(cls) -> SwarmJoinRegistry:
        if cls.swarm_registry is None:
            cls.swarm_registry = SwarmJoinRegistry()
        return cls.swarm_registry

    @classmethod
    def _commercial_only_mode(cls) -> bool:
        """Keep Render focused on paid checkout and tiny health responses."""
        raw = (os.getenv("NOMAD_RENDER_ALLOW_HOBBY") or "").strip().lower()
        if raw in {"1", "true", "yes", "on"}:
            return False
        explicit = (os.getenv("NOMAD_COMMERCIAL_ONLY") or "").strip().lower()
        if explicit in {"1", "true", "yes", "on"}:
            return True
        if explicit in {"0", "false", "no", "off"}:
            return False
        return RENDER_RUNTIME

    @staticmethod
    def _commercial_allowed_get_paths() -> set[str]:
        return {
            "/",
            "/index.html",
            "/nomad.html",
            "/investor",
            "/investor.html",
            "/investor-brief",
            "/favicon.ico",
            "/favicon.svg",
            "/health",
            "/llms.txt",
            "/robots.txt",
            "/service",
            "/service/e2e",
            "/tasks",
            "/tasks/verify",
            "/.well-known/agent-card.json",
            "/.well-known/agent.json",
            "/.well-known/nomad-buyer-funded-work.json",
            "/.well-known/nomad-sales-department.json",
            "/.well-known/nomad-first-sales.json",
            "/.well-known/nomad-revenue-invariant.json",
        }

    @classmethod
    def _is_hobby_get_path(cls, path: str) -> bool:
        if path in cls._commercial_allowed_get_paths():
            return False
        if path.startswith("/assets/"):
            return path not in {"/assets/nomad-arena-hero.webp"}
        if path.startswith("/downloads/nomad_revenue_center_playbook"):
            return False
        if path.startswith("/downloads/"):
            return True
        if path.startswith("/swarm"):
            return True
        if path.startswith("/runtime/"):
            return True
        if path.startswith("/operator"):
            return True
        if path.startswith("/growth"):
            return True
        if path.startswith("/machine-"):
            return True
        if path.startswith("/.well-known/"):
            return True
        return path in {
            "/telegram-miniapp",
            "/telegram-miniapp.html",
            "/miniapp",
            "/mini",
            "/telegram",
            "/bot-factory",
            "/bot-factory.html",
            "/bot-risk-receipt",
            "/handyoracle",
            "/handyoracle.html",
            "/oracle",
            "/swarm-oracle",
            "/gadget",
            "/gadgets",
            "/gadgets.html",
            "/syndiode-gadgets",
            "/work-exchange",
            "/work-exchange.html",
            "/free-repair",
            "/agent-reliability-doctor",
            "/openapi",
            "/openapi.json",
            "/nonhuman-science",
            "/operational-release",
            "/reputation",
            "/unhuman-hub",
            "/products",
        }

    @classmethod
    def _is_hobby_post_path(cls, path: str) -> bool:
        if path in {"/tasks", "/tasks/verify", "/tasks/work", "/service/e2e"}:
            return False
        return True

    def _hobby_paused_response(self, path: str, *, method: str = "GET") -> None:
        base = self._base_url().rstrip("/")
        checkout = f"{base}/nomad.html#buyable-work" if base else "/nomad.html#buyable-work"
        self._json_response(
            {
                "ok": False,
                "schema": "nomad.render_commercial_only.v1",
                "status": "paused",
                "path": path,
                "method": method,
                "reason": "hobby_usage_disabled_to_protect_render_memory",
                "allowed": [
                    "GET /health",
                    "GET /nomad.html",
                    "GET /investor",
                    "POST /service/e2e",
                    "POST /tasks/verify",
                ],
                "checkout": checkout,
            },
            status=503,
            headers={"Cache-Control": "no-store"},
        )

    @classmethod
    def _build_fast_swarm_manifest(cls, *, base_url: str) -> dict:
        registry = cls._light_swarm_registry()
        manifest = registry.public_manifest(base_url=base_url)
        manifest["ok"] = True
        manifest["mode"] = "fast_public_discovery"
        manifest["deep"] = False
        manifest["deep_url"] = f"{base_url.rstrip('/')}/swarm?deep=true" if base_url else "/swarm?deep=true"
        manifest["transition_support_gate"] = cls.transition_exchange.support_gate_snapshot(
            window_minutes=int(os.getenv("NOMAD_SUPPORT_GATE_WINDOW_MINUTES", "30") or "30"),
            min_settles=int(os.getenv("NOMAD_SUPPORT_GATE_MIN_SETTLES", "2") or "2"),
        )
        try:
            stig = cls._stigmergy().snapshot()
            manifest["machine_stigmergy"] = {
                "schema": stig.get("schema", "nomad.stigmergy_field.v1"),
                "temperature": stig.get("temperature"),
                "event_count": stig.get("event_count", 0),
                "updated_at": stig.get("updated_at", ""),
            }
        except Exception as exc:  # noqa: BLE001
            manifest["machine_stigmergy"] = {
                "ok": False,
                "error": "stigmergy_unavailable",
                "detail": str(exc)[:160],
            }
        manifest["machine_instruction"] = "use_this_fast_manifest_for_discovery_then_follow_deep_url_or_specific_contract_links"
        return manifest

    @staticmethod
    def _public_payment_address() -> str:
        for name in ("AGENT_ADDRESS", "NOMAD_PAYMENT_ADDRESS", "NOMAD_WALLET_ADDRESS"):
            value = (os.getenv(name) or "").strip()
            if value and value.lower() not in {"your_agent_wallet_address_here", "0x...", "your_private_key_here"}:
                return value
        return ""

    @classmethod
    def _build_fast_agent_card(cls, *, base_url: str) -> dict:
        root = (base_url or "").strip().rstrip("/")

        def url(path: str) -> str:
            return f"{root}{path}" if root else path

        amount = float(os.getenv("NOMAD_SERVICE_MIN_NATIVE", "0.01") or "0.01")
        return {
            "protocolVersion": os.getenv("NOMAD_A2A_PROTOCOL_VERSION", "0.3.0"),
            "name": (os.getenv("NOMAD_AGENT_NAME") or "LoopHelper").strip() or "LoopHelper",
            "description": (
                "Agent-first direct service for bounded AI-agent infrastructure help: blocker diagnosis, "
                "fallback-lane repair, swarm coordination, and paid task handoff through explicit JSON contracts."
            ),
            "url": url("/a2a/message"),
            "version": (os.getenv("NOMAD_AGENT_VERSION") or "0.1.0").strip() or "0.1.0",
            "defaultInputModes": ["application/json", "text/plain"],
            "defaultOutputModes": ["application/json", "text/plain"],
            "capabilities": {
                "streaming": False,
                "pushNotifications": False,
                "directOnly": True,
                "x402PaymentRequired": True,
                "freeMiniDiagnosis": True,
                "agentFirst": True,
                "structuredReplies": True,
                "agentDevelopmentExchange": True,
                "swarmAttractorManifest": True,
            },
            "interactionContract": {
                "audience": "ai_agents",
                "style": "agent_first_non_anthropomorphic",
                "idempotency": "contextId_or_request_id_on_retry",
                "ttl_seconds": 600,
                "required_fields": ["problem"],
                "optional_fields": ["requester_agent", "goal", "blocking_step", "constraints", "budget_native"],
                "boundaries": ["no secrets", "no raw remote code execution", "bounded claims only"],
            },
            "firstPaidJobProtocol": {
                "schema": "nomad.first_paid_job_protocol.v1",
                "audience": "ai_agents",
                "call_sequence": [
                    {"step": "free_diagnosis", "method": "POST", "endpoint": url("/a2a/message")},
                    {"step": "create_paid_task", "method": "POST", "endpoint": url("/tasks")},
                    {"step": "verify_payment", "method": "POST", "endpoint": url("/tasks/verify")},
                    {"step": "request_work", "method": "POST", "endpoint": url("/tasks/work")},
                ],
            },
            "skills": [
                {
                    "id": "free-mini-diagnosis",
                    "name": "Free Mini Diagnosis",
                    "description": "Classify one blocker and return the smallest verifiable next step.",
                    "tags": ["diagnosis", "agent-rescue", "free"],
                },
                {
                    "id": "compute-auth-unblock",
                    "name": "Compute/Auth Unblock",
                    "description": "Diagnose quota, token, OAuth, cooldown, and fallback-lane failures.",
                    "tags": ["compute", "auth", "quota", "fallback"],
                },
                {
                    "id": "agent-development-exchange",
                    "name": "Agent Development Exchange",
                    "description": "Return a reusable self-improvement plan and swarm follow-up routes.",
                    "tags": ["agent-development", "self-improvement", "swarm"],
                },
            ],
            "endpoints": {
                "agentCard": url("/.well-known/agent-card.json"),
                "agentNativeIndex": url("/.well-known/nomad-agent.json"),
                "openapi": url("/openapi.json"),
                "agentAttractor": url("/agent-attractor"),
                "swarm": url("/swarm"),
                "swarmDeep": url("/swarm?deep=true"),
                "swarmJoin": url("/swarm/join"),
                "agentDevelopment": url("/swarm/develop"),
                "message": url("/a2a/message"),
                "tasks": url("/tasks"),
                "tasksVerify": url("/tasks/verify"),
                "tasksWork": url("/tasks/work"),
                "service": url("/service"),
                "products": url("/products"),
            },
            "payment": {
                "scheme": "x402-compatible-wallet-transfer",
                "statusCode": 402,
                "asset": (os.getenv("NATIVE_SYMBOL") or "ETH").strip() or "ETH",
                "amount_native": round(max(0.0, amount), 8),
                "recipient": cls._public_payment_address(),
                "network": (os.getenv("CHAIN_NAME") or os.getenv("NETWORK_NAME") or "").strip(),
                "verify_endpoint": url("/tasks/verify"),
                "live_balance_checked": False,
            },
            "documentationUrl": url("/nomad.html"),
            "machine_instruction": "use_openapi_and_swarm_contracts_for_next_actions_not_freeform_chat",
        }

    @staticmethod
    def _public_url_path_prefix() -> str:
        explicit = (os.getenv("NOMAD_HTTP_PATH_PREFIX") or "").strip().rstrip("/")
        if explicit:
            return explicit if explicit.startswith("/") else f"/{explicit}"
        configured = (os.getenv("NOMAD_PUBLIC_API_URL") or "").strip()
        if not configured.startswith(("http://", "https://")):
            return ""
        pub_path = urlparse(configured).path.rstrip("/")
        if not pub_path or pub_path == "/":
            return ""
        return pub_path

    @staticmethod
    def _edge_ingress_prefix() -> str:
        """When NOMAD_PUBLIC_API_URL has no path (apex) but a CDN still forwards /nomad/*, strip this first."""
        configured = os.getenv("NOMAD_EDGE_INGRESS_PREFIX")
        raw = ("nomad" if configured is None else configured).strip().rstrip("/")
        if not raw:
            return ""
        return raw if raw.startswith("/") else f"/{raw}"

    @classmethod
    def _normalize_public_path(cls, raw_path: str) -> str:
        """Map incoming /nomad/... to /... when public URL is https://host/nomad (reverse-proxy path)."""
        path = raw_path or "/"
        # Apex public URL + edge-only prefix (e.g. Cloudflare forwards /nomad/health while links use /health).
        if not cls._public_url_path_prefix():
            edge = cls._edge_ingress_prefix()
            if edge and (path == edge or path.startswith(edge + "/")):
                if path == edge or path == edge + "/":
                    path = "/"
                else:
                    path = path[len(edge) :] or "/"
                    if not path.startswith("/"):
                        path = f"/{path}"
        prefix = cls._public_url_path_prefix()
        if not prefix:
            return path
        if path == prefix or path == prefix + "/":
            return "/"
        if path.startswith(prefix + "/"):
            rest = path[len(prefix) :]
            return rest if rest.startswith("/") else f"/{rest}"
        return path

    def do_GET(self) -> None:  # noqa: N802
        parsed_full = urlparse(self.path)
        query = parse_qs(parsed_full.query)
        parsed = parsed_full._replace(path=self._normalize_public_path(parsed_full.path or "/"))
        self._agent_request_path = parsed.path

        if self.__class__._commercial_only_mode() and self.__class__._is_hobby_get_path(parsed.path):
            self._hobby_paused_response(parsed.path)
            return

        if parsed.path in {"/favicon.ico", "/favicon.svg"}:
            self._public_asset_file_response(PUBLIC_DIR / "favicon.svg")
            return

        if parsed.path == "/a2a/get":
            self._json_response(self._a2a_get_relay_contract())
            return

        if parsed.path.startswith("/a2a/get/"):
            self.__class__._ensure_runtime_components()
            result, status = self._process_a2a_get_relay(parsed.path, query)
            self._json_response(result, status=status)
            return

        if parsed.path in {"/", "/index.html", "/nomad.html", "/gadgets", "/gadgets.html", "/syndiode-gadgets"}:
            if self.__class__._commercial_only_mode() and parsed.path in {"/", "/index.html", "/nomad.html"}:
                self._html_file_response(PUBLIC_DIR / "nomad-commercial.html")
            else:
                self._html_file_response(PUBLIC_DIR / "nomad.html")
            return

        if parsed.path in {"/investor", "/investor.html", "/investor-brief"}:
            self._html_file_response(PUBLIC_DIR / "investor.html")
            return

        if parsed.path in {"/telegram-miniapp", "/telegram-miniapp.html", "/miniapp", "/mini", "/telegram"}:
            self._html_file_response(PUBLIC_DIR / "telegram-miniapp.html")
            return

        if parsed.path in {"/bot-factory", "/bot-factory.html", "/bot-risk-receipt"}:
            self._html_file_response(PUBLIC_DIR / "bot-factory.html")
            return

        if parsed.path in {"/llms.txt", "/robots.txt"}:
            self._public_asset_file_response(PUBLIC_DIR / parsed.path.lstrip("/"))
            return

        if parsed.path in {"/handyoracle", "/handyoracle.html", "/oracle", "/swarm-oracle", "/gadget"}:
            self._html_file_response(PUBLIC_DIR / "handyoracle.html")
            return

        if parsed.path in {"/work-exchange", "/work-exchange.html", "/free-repair", "/agent-reliability-doctor"}:
            self._html_file_response(PUBLIC_DIR / "work-exchange.html")
            return

        if parsed.path in {"/.well-known/syndiode-gadgets.json", "/gadgets/manifest", "/gadgets.json"}:
            self._public_download_file_response(PUBLIC_DIR / "downloads" / "syndiode_gadgets_manifest.json")
            return

        if parsed.path.startswith("/assets/"):
            rel = parsed.path[len("/assets/") :].strip("/")
            if not rel or ".." in rel or "\\" in rel:
                self._json_response(
                    machine_error_response(
                        error="invalid_asset_path",
                        message="Asset path is invalid.",
                        hints=["Use GET /assets/<filename> for published page media."],
                    ),
                    status=400,
                )
                return
            self._public_asset_file_response(PUBLIC_DIR / "assets" / rel)
            return

        if parsed.path.startswith("/downloads/"):
            rel = parsed.path[len("/downloads/") :].strip("/")
            if not rel or ".." in rel or "\\" in rel:
                self._json_response(
                    machine_error_response(
                        error="invalid_download_path",
                        message="Download path is invalid.",
                        hints=["Use GET /downloads/<filename> for published helper assets."],
                    ),
                    status=400,
                )
                return
            self._public_download_file_response(PUBLIC_DIR / "downloads" / rel)
            return

        if parsed.path == "/health":
            if self.__class__._commercial_only_mode():
                uptime = max(0.0, time.time() - NOMAD_PROCESS_START)
                root = self._base_url().rstrip("/")
                self._json_response(
                    {
                        "ok": True,
                        "service": "nomad-api",
                        "schema": "nomad.health.render_lite.v1",
                        "mode": "commercial_only",
                        "version": os.getenv("NOMAD_VERSION", "0.1.0").strip() or "0.1.0",
                        "uptime_seconds": round(uptime, 3),
                        "checks": {"api_process": "listening", "hobby_usage": "paused"},
                        "checkout": f"{root}/nomad.html#buyable-work" if root else "/nomad.html#buyable-work",
                    },
                    headers={"Cache-Control": "no-store"},
                )
                return
            base = self._base_url()
            links: dict[str, str] = {}
            if base:
                b = base.rstrip("/")
                links = {
                    "nomad_html": f"{b}/nomad.html",
                    "telegram_miniapp": f"{b}/telegram-miniapp",
                    "telegram_miniapp_contract": f"{b}/.well-known/nomad-telegram-miniapp.json",
                    "telegram_miniapp_lead": f"{b}/telegram-miniapp/lead",
                    "telegram_acquisition": f"{b}/.well-known/nomad-telegram-acquisition.json",
                    "acquisition_engine": f"{b}/.well-known/nomad-acquisition-engine.json",
                    "sales_funnel": f"{b}/.well-known/nomad-sales-funnel.json",
                    "ethereum_ai_support": f"{b}/.well-known/nomad-eth-support.json",
                    "ethereum_ai_support_proposal": f"{b}/downloads/nomad_ethereum_ai_agent_support_proposal.md",
                    "llms": f"{b}/llms.txt",
                    "robots": f"{b}/robots.txt",
                    "agent_card": f"{b}/.well-known/agent-card.json",
                    "external_worker_opportunity": f"{b}/.well-known/nomad-external-worker-opportunity.json",
                    "agent_acquisition_bandit": f"{b}/.well-known/nomad-agent-acquisition-bandit.json",
                    "agent_acquisition_events": f"{b}/swarm/agent-acquisition/events",
                    "machine_native_collaboration": f"{b}/.well-known/nomad-machine-native-collaboration.json",
                    "rescue_cycle_scheduler": f"{b}/.well-known/nomad-rescue-cycle-scheduler.json",
                    "rescue_packet_lattice": f"{b}/.well-known/nomad-rescue-packet-lattice.json",
                    "rescue_packet_candidate_post": f"{b}/swarm/rescue-packet-candidates",
                    "server_failure_guard": f"{b}/.well-known/nomad-server-failure-guard.json",
                    "server_failure_event_post": f"{b}/swarm/server-failure/events",
                    "sustainability_kernel": f"{b}/.well-known/nomad-sustainability-kernel.json",
                    "swarm_flywheel_health": f"{b}/.well-known/nomad-flywheel-health.json",
                    "swarm_health_dashboard": f"{b}/swarm/health-dashboard",
                    "sustainability_worker": f"{b}/downloads/nomad_sustainability_worker.py",
                    "a2a_get_relay": f"{b}/a2a/get",
                    "get_only_worker_onramp": f"{b}/swarm/hello",
                    "runtime_attach_get": f"{b}/swarm/attach-get",
                    "idle_runtime_intent_get": f"{b}/swarm/idle-intent-get",
                    "agent_native_priorities": f"{b}/.well-known/nomad-agent-native-priorities.json",
                    "agent_native_index": f"{b}/.well-known/nomad-agent.json",
                    "agent_native_product": f"{b}/.well-known/nomad-agent-native-product.json",
                    "crn_dispatch": f"{b}/.well-known/nomad-crn-dispatch.json",
                    "agent_join_field": f"{b}/.well-known/nomad-agent-join-field.json",
                    "inter_agent_witness_offer": f"{b}/.well-known/nomad-inter-agent-witness-offer.json",
                    "peer_acquisition_contract": f"{b}/.well-known/nomad-peer-acquisition.json",
                    "transition_offer": f"{b}/.well-known/nomad-transition-offer.json",
                    "machine_product": f"{b}/.well-known/nomad-machine-product.json",
                    "opaque_emergence": f"{b}/.well-known/nomad-opaque-emergence.json",
                    "opaque_candidate": f"{b}/swarm/opaque-candidate",
                    "tool_gap": f"{b}/swarm/tool-gap",
                    "topology_plan": f"{b}/swarm/topology-plan",
                    "openapi": f"{b}/openapi.json",
                    "swarm": f"{b}/swarm",
                    "transition_worker_fleet": f"{b}/swarm/workers",
                    "transition_worker_lease_get": f"{b}/swarm/workers/lease-get",
                    "transition_worker_complete_get": f"{b}/swarm/workers/complete-get",
                    "growth_experience_get": f"{b}/swarm/experience-get",
                    "tasks": f"{b}/tasks",
                    "service_catalog": f"{b}/service",
                    "growth_start": f"{b}/growth-start",
                    "autonomy_step": f"{b}/autonomy-step",
                    "operator_desk": f"{b}/operator-desk",
                    "operator_sprint": f"{b}/operator-sprint",
                    "agent_reputation": f"{b}/reputation",
                    "unhuman_hub": f"{b}/unhuman-hub",
                    "machine_economy": f"{b}/machine-economy",
                    "machine_treasury": f"{b}/machine-treasury",
                    "machine_treasury_pledge": f"{b}/machine-treasury/pledge",
                    "machine_field": f"{b}/.well-known/nomad-machine-field.json",
                    "machine_field_intent": f"{b}/machine-field/intent",
                    "agent_demand_feed": f"{b}/.well-known/nomad-agent-requests.json",
                    "agent_subscribe": f"{b}/swarm/subscribe",
                    "agent_subscriptions": f"{b}/swarm/subscriptions",
                    "protocol_bytecode": f"{b}/.well-known/nomad-protocol-bytecode.json",
                    "counterfactual_replay": f"{b}/swarm/counterfactual-replay",
                    "variant_forge": f"{b}/swarm/variant-forge",
                    "variant_candidate_submit": f"{b}/swarm/variant-candidates",
                    "worker_market": f"{b}/swarm/worker-market",
                    "compute_market": f"{b}/swarm/compute-market",
                    "swarm_verified_work": f"{b}/.well-known/nomad-swarm-verified-work.json",
                    "hyperliquid_svw_agents": f"{b}/.well-known/nomad-hyperliquid-svw-agents.json",
                    "hyperliquid_svw_agents_alias": f"{b}/swarm/hyperliquid-svw-agents",
                    "agent_work": f"{b}/.well-known/nomad-agent-work.json",
                    "agent_work_claim": f"{b}/swarm/microtask/claim",
                    "agent_work_proof": f"{b}/swarm/microtask/proof",
                    "work_mesh": f"{b}/.well-known/nomad-work-mesh.json",
                    "work_mesh_seed": f"{b}/swarm/work-mesh/seed",
                    "synergy_lite": f"{b}/swarm/synergy-lite",
                    "state_status": f"{b}/swarm/state-status",
                    "carrying_market": f"{b}/.well-known/nomad-carrying-market.json",
                    "carrying_proof": f"{b}/swarm/carrying-proof",
                    "survival_market": f"{b}/.well-known/nomad-survival-market.json",
                    "survival_intent": f"{b}/swarm/survival-intent",
                    "paid_ref_market": f"{b}/.well-known/nomad-paid-ref-market.json",
                    "paid_ref_selfplay": f"{b}/.well-known/nomad-paid-ref-selfplay.json",
                    "paid_ref_quote": f"{b}/swarm/paid-ref/quote",
                    "paid_ref_verify": f"{b}/swarm/paid-ref/verify",
                    "referral_offers": f"{b}/.well-known/nomad-referral-offers.json",
                    "referral_swarm": f"{b}/.well-known/nomad-referral-swarm.json",
                    "spend_guard": f"{b}/.well-known/nomad-spend-guard.json",
                    "gemini_verifier": f"{b}/.well-known/nomad-gemini-verifier.json",
                    "gemini_verifier_post": f"{b}/swarm/gemini-verifier/verify",
                    "google_agentic_era": f"{b}/.well-known/nomad-google-agentic-era.json",
                    "bounty_hunter": f"{b}/.well-known/nomad-bounty-hunter.json",
                    "buyer_funded_work": f"{b}/.well-known/nomad-buyer-funded-work.json",
                    "sales_department": f"{b}/.well-known/nomad-sales-department.json",
                    "sales_department_event": f"{b}/swarm/sales-department/events",
                    "first_sales": f"{b}/.well-known/nomad-first-sales.json",
                    "first_receipt_ignition": f"{b}/.well-known/nomad-first-receipt-ignition.json",
                    "first_receipt_ignition_event": f"{b}/swarm/first-receipt-ignition/events",
                    "first_receipt_campaign": f"{b}/.well-known/nomad-first-receipt-campaign.json",
                    "first_receipt_campaign_event": f"{b}/swarm/first-receipt-campaign/events",
                    "machine_native_collaboration": f"{b}/.well-known/nomad-machine-native-collaboration.json",
                    "rescue_cycle_scheduler": f"{b}/.well-known/nomad-rescue-cycle-scheduler.json",
                    "rescue_packet_lattice": f"{b}/.well-known/nomad-rescue-packet-lattice.json",
                    "rescue_packet_candidate_post": f"{b}/swarm/rescue-packet-candidates",
                    "server_failure_guard": f"{b}/.well-known/nomad-server-failure-guard.json",
                    "server_failure_event_post": f"{b}/swarm/server-failure/events",
                    "swarm_flywheel_health": f"{b}/.well-known/nomad-flywheel-health.json",
                    "swarm_health_dashboard": f"{b}/swarm/health-dashboard",
                    "acquisition_ignition": f"{b}/.well-known/nomad-acquisition-ignition.json",
                    "acquisition_ignite": f"{b}/swarm/acquisition/ignite",
                    "resolution_ladder": f"{b}/.well-known/nomad-resolution-ladder.json",
                    "resolution_ladder_events": f"{b}/swarm/resolution-ladder/events",
                    "resolution_runtime_register": f"{b}/.well-known/nomad-resolution-runtime-register.json",
                    "external_value": f"{b}/.well-known/nomad-external-value.json",
                    "external_value_post": f"{b}/swarm/external-value",
                    "swarm_signal_layer": f"{b}/.well-known/nomad-signal-layer.json",
                    "swarm_signal_post": f"{b}/swarm/signals",
                    "emission_batch_post": f"{b}/swarm/emission-batch",
                    "value_pressure": f"{b}/.well-known/nomad-value-pressure.json",
                    "optimal_transport": f"{b}/.well-known/nomad-optimal-transport.json",
                    "ot_paper_readiness": f"{b}/.well-known/nomad-ot-paper-readiness.json",
                    "ot_manifold": f"{b}/.well-known/nomad-ot-manifold.json",
                    "ot_conformance": f"{b}/.well-known/nomad-ot-conformance.json",
                    "ot_metric_learning": f"{b}/.well-known/nomad-ot-metric-learning.json",
                    "ot_outcome_event_post": f"{b}/swarm/optimal-transport/outcomes",
                    "optimal_transport_solve": f"{b}/swarm/optimal-transport/solve",
                    "settlement_signal": f"{b}/.well-known/nomad-settlement.json",
                    "solana_settlement": f"{b}/.well-known/nomad-solana-settlement.json",
                    "solana_pay_intent": f"{b}/swarm/settlement/solana-pay-intents",
                    "solana_tx_receipt": f"{b}/swarm/settlement/solana-tx-receipts",
                    "agent_job_router": f"{b}/.well-known/nomad-agent-jobs.json",
                    "revenue_science": f"{b}/.well-known/nomad-revenue-science.json",
                    "revenue_invariant": f"{b}/.well-known/nomad-revenue-invariant.json",
                    "channel_bandit": f"{b}/.well-known/nomad-channel-bandit.json",
                    "shadow_lane": f"{b}/.well-known/nomad-shadow-lane.json",
                    "shadow_lane_candidate": f"{b}/swarm/shadow-lane/candidates",
                    "decoupling_field": f"{b}/.well-known/nomad-decoupling-field.json",
                    "decoupling_merge": f"{b}/swarm/decoupling-field/merge",
                    "anti_consensus": f"{b}/.well-known/nomad-anti-consensus.json",
                    "anti_consensus_candidate": f"{b}/swarm/anti-consensus/candidates",
                    "entropy_judger": f"{b}/.well-known/nomad-entropy-judger.json",
                    "entropy_judger_evaluate": f"{b}/swarm/entropy-judger/evaluate",
                    "latent_consensus": f"{b}/.well-known/nomad-latent-consensus.json",
                    "latent_consensus_evaluate": f"{b}/swarm/latent-consensus/evaluate",
                    "resource_substrate": f"{b}/.well-known/nomad-resource-substrate.json",
                    "resource_substrate_register": f"{b}/swarm/resource-substrate/register",
                    "resource_substrate_retrieve": f"{b}/swarm/resource-substrate/retrieve",
                    "resource_substrate_version": f"{b}/swarm/resource-substrate/version",
                    "autogenesis": f"{b}/.well-known/nomad-autogenesis.json",
                    "autogenesis_shadow_harvest": f"{b}/.well-known/nomad-autogenesis-shadow-harvest.json",
                    "agp_conformance": f"{b}/.well-known/nomad-agp-conformance.json",
                    "agp_agent_bus": f"{b}/.well-known/nomad-agp-agent-bus.json",
                    "agp_agent_bus_messages": f"{b}/swarm/agp/agent-bus/messages",
                    "agp_plans": f"{b}/swarm/agp/plans",
                    "agp_orchestrations": f"{b}/swarm/agp/orchestrations",
                    "agp_model_manager": f"{b}/.well-known/nomad-agp-model-manager.json",
                    "agp_model_bindings": f"{b}/swarm/agp/model-bindings",
                    "agp_configs": f"{b}/swarm/agp/configs",
                    "agp_prompt_manager": f"{b}/.well-known/nomad-agp-prompt-manager.json",
                    "agp_prompts": f"{b}/swarm/agp/prompts",
                    "agp_version_manager": f"{b}/.well-known/nomad-agp-version-manager.json",
                    "agp_version_lineage": f"{b}/swarm/agp/version-lineage",
                    "agp_procurement": f"{b}/.well-known/nomad-agp-procurement.json",
                    "agp_procurement_intents": f"{b}/swarm/agp/procurement-intents",
                    "agp_context_manager": f"{b}/.well-known/nomad-agp-context-manager.json",
                    "agp_context_operation": f"{b}/swarm/agp/context",
                    "agp_optimizer": f"{b}/.well-known/nomad-agp-optimizer.json",
                    "agp_optimizer_steps": f"{b}/swarm/agp/optimizer-steps",
                    "agp_evaluation": f"{b}/.well-known/nomad-agp-evaluation.json",
                    "agp_evaluations": f"{b}/swarm/agp/evaluations",
                    "agp_benchmark_suite": f"{b}/.well-known/nomad-agp-benchmark-suite.json",
                    "agp_benchmark_suites": f"{b}/swarm/agp/benchmark-suites",
                    "agp_empirical": f"{b}/.well-known/nomad-agp-empirical.json",
                    "agp_empirical_runs": f"{b}/swarm/agp/empirical-runs",
                    "agp_paper_benchmarks": f"{b}/.well-known/nomad-agp-paper-benchmarks.json",
                    "agp_paper_benchmark_runs": f"{b}/swarm/agp/paper-benchmark-runs",
                    "agp_durable_ledger": f"{b}/.well-known/nomad-agp-durable-ledger.json",
                    "agp_paper_report": f"{b}/.well-known/nomad-agp-paper-report.json",
                    "agp_paper_grade_readiness": f"{b}/.well-known/nomad-agp-paper-grade-readiness.json",
                    "agp_pulse": f"{b}/swarm/agp/pulse",
                    "agp_pulse_surface": f"{b}/.well-known/nomad-agp-pulse.json",
                    "agp_morphology_reactor": f"{b}/swarm/autogenesis/morphology-reactor",
                    "agp_morphology_reactor_surface": f"{b}/.well-known/nomad-autogenesis-morphology-reactor.json",
                    "agp_morphology_runtime_register": f"{b}/.well-known/nomad-agp-morphology-runtime-register.json",
                    "telegram_a2a": f"{b}/.well-known/nomad-telegram-a2a.json",
                    "telegram_a2a_messages": f"{b}/swarm/telegram-a2a/messages",
                    "sales_funnel": f"{b}/.well-known/nomad-sales-funnel.json",
                    "autogenesis_recruit": f"{b}/.well-known/nomad-autogenesis-recruit.json",
                    "autogenesis_development_cycles": f"{b}/swarm/development-cycles",
                    "autogenesis_development_cycle_events": f"{b}/swarm/development-cycles/events",
                    "autogenesis_traces": f"{b}/swarm/autogenesis/traces",
                    "autonomous_agp_cycle": f"{b}/swarm/autogenesis/cycle",
                    "autonomous_agp_run": f"{b}/swarm/autogenesis/run",
                    "autonomous_agp_watchdog": f"{b}/swarm/autogenesis/watchdog",
                    "autonomous_agp_watchdog_surface": f"{b}/.well-known/nomad-agp-watchdog.json",
                    "autonomous_evolution": f"{b}/.well-known/nomad-autonomous-evolution.json",
                    "autonomous_evolution_post": f"{b}/swarm/autonomous-evolution",
                    "autogenesis_shadow_lane": f"{b}/swarm/shadow-lane/candidates?type=autogenesis",
                    "deficit_integration": f"{b}/.well-known/nomad-deficit-integration.json",
                    "deficit_integration_event": f"{b}/swarm/deficit-integration/events",
                    "effective_channels": f"{b}/.well-known/nomad-effective-channels.json",
                    "effective_channel_event": f"{b}/swarm/effective-channels/events",
                    "nonhuman_runtime_governor": f"{b}/.well-known/nomad-nonhuman-runtime-governor.json",
                    "nonhuman_runtime_event": f"{b}/swarm/nonhuman-runtime-governor/events",
                    "worker_invoice": f"{b}/.well-known/nomad-worker-invoice.json",
                    "work_receipts": f"{b}/.well-known/nomad-work-receipts.json",
                    "work_receipts_post": f"{b}/swarm/work-receipts",
                    "work_exchange": f"{b}/.well-known/nomad-work-exchange.json",
                    "work_exchange_onboarding": f"{b}/.well-known/nomad-work-exchange-onboarding.json",
                    "work_exchange_human_entry": f"{b}/work-exchange",
                    "work_exchange_worker_download": f"{b}/downloads/nomad_work_exchange_worker.py",
                    "work_exchange_worker_installer": f"{b}/downloads/install_nomad_work_exchange_worker.bat",
                    "work_exchange_offer": f"{b}/swarm/work-exchange/offers",
                    "work_exchange_free_solution": f"{b}/swarm/work-exchange/free-solution",
                    "work_exchange_return_work": f"{b}/swarm/work-exchange/return-work",
                    "work_exchange_balance": f"{b}/swarm/work-exchange/balance",
                    "universal_adapter": f"{b}/.well-known/nomad-universal-adapter.json",
                    "universal_adapter_event": f"{b}/swarm/universal-adapter/events",
                    "universal_adapter_download": f"{b}/downloads/nomad_universal_adapter.py",
                    "agent_reliability_doctor_contract": f"{b}/.well-known/nomad-agent-reliability-doctor.json",
                    "agent_reliability_doctor_intake": f"{b}/swarm/reliability-doctor/intake",
                    "agent_reliability_doctor_github_action": f"{b}/downloads/nomad_reliability_doctor_action.yml",
                    "work_exchange_dockerfile": f"{b}/downloads/nomad_work_exchange_worker.Dockerfile",
                    "treasury_policy": f"{b}/.well-known/nomad-treasury-policy.json",
                    "revenue_settlement": f"{b}/.well-known/nomad-revenue-settlement.json",
                    "agent_utility": f"{b}/.well-known/nomad-agent-utility.json",
                    "stable_unit_policy": f"{b}/.well-known/nomad-stable-unit-policy.json",
                    "stable_unit_preflight": f"{b}/swarm/stable-unit/preflight",
                    "operator_runway": f"{b}/.well-known/nomad-operator-runway.json",
                    "viability_kernel": f"{b}/.well-known/nomad-viability-kernel.json",
                    "viability_route": f"{b}/swarm/viability-kernel/route",
                    "worker_job_queue": f"{b}/.well-known/nomad-worker-job-queue.json",
                    "value_cycle_preflight": f"{b}/.well-known/nomad-value-cycle-preflight.json",
                    "value_cycles": f"{b}/.well-known/nomad-value-cycles.json",
                    "value_cycle_event": f"{b}/swarm/value-cycles/events",
                    "receipt_predictor": f"{b}/.well-known/nomad-receipt-predictor.json",
                    "receipt_predictor_event": f"{b}/swarm/receipt-predictor/events",
                    "bottleneck_resolver": f"{b}/.well-known/nomad-bottleneck-resolver.json",
                    "bottleneck_resolver_event": f"{b}/swarm/bottleneck-resolver/events",
                    "ad_cycles": f"{b}/.well-known/nomad-ad-cycles.json",
                    "ad_cycle_event": f"{b}/swarm/ad-cycles/events",
                    "development_cycles": f"{b}/.well-known/nomad-development-cycles.json",
                    "development_cycle_event": f"{b}/swarm/development-cycles/events",
                    "topology_governor": f"{b}/.well-known/nomad-topology-governor.json",
                    "topology_governor_event": f"{b}/swarm/topology-governor/events",
                    "worker_market_offer": f"{b}/swarm/worker-market/offers",
                    "swarm_ecology": f"{b}/swarm/ecology",
                    "swarm_ecology_tick": f"{b}/swarm/ecology/tick",
                    "growth_arena": f"{b}/swarm/growth-arena",
                    "growth_curriculum": f"{b}/swarm/curriculum",
                    "growth_experience": f"{b}/swarm/experience",
                    "skill_library": f"{b}/swarm/skill-library",
                    "nonhuman_science": f"{b}/nonhuman-science",
                    "operational_release": f"{b}/operational-release",
                    "runtime_capsule": f"{b}/.well-known/nomad-runtime-capsule.json",
                    "recruitment_gradient": f"{b}/swarm/gradient",
                    "runtime_attach": f"{b}/swarm/attach",
                    "handoff_capsule": f"{b}/runtime/handoff",
                    "openclaw_bridge_contract": f"{b}/.well-known/openclaw-nomad-bridge.json",
                    "swarm_attractor": f"{b}/swarm/attractor",
                    "idle_runtime_beacon": f"{b}/.well-known/nomad-idle-runtime.json",
                    "idle_runtime_intent": f"{b}/swarm/idle-intent",
                    "capacity_switch_surface": f"{b}/.well-known/nomad-capacity-switch.json",
                    "capacity_switch_request": f"{b}/swarm/capacity-switch",
                    "agent_growth": f"{b}/agent-growth",
                }
            else:
                links = {"openapi": "/openapi.json"}
            uptime = max(0.0, time.time() - NOMAD_PROCESS_START)
            body: dict = {
                "ok": True,
                "service": "nomad-api",
                "schema": "nomad.health.v1",
                "version": os.getenv("NOMAD_VERSION", "0.1.0").strip() or "0.1.0",
                "uptime_seconds": round(uptime, 3),
                "checks": {"api_process": "listening"},
                "public_home": base,
                "for_agents": "Use agent_card, openapi, and swarm for machine discovery; tasks for paid bounded work.",
                "links": links,
            }
            if self._truthy((query.get("deep") or ["false"])[0], default=False):
                body["deep"] = True
                body["deep_note"] = (
                    "deep=true is reserved for optional heavier checks; default /health stays fast and local-only."
                )
            self._json_response(body)
            return

        if parsed.path in {"/openapi.json", "/.well-known/openapi.json", "/openapi"}:
            base = self._base_url()
            self._json_response(
                self.__class__._cached_surface(
                    f"openapi:{base}",
                    120,
                    lambda: build_openapi_document(base_url=base),
                ),
                headers={"Cache-Control": "public, max-age=120"},
            )
            return

        if parsed.path in {"/swarm/hello", "/ai", "/agent/hello", "/.well-known/nomad-ai.json"}:
            self._json_response(self._get_only_worker_onramp_contract(base_url=self._base_url()))
            return

        if parsed.path in {"/swarm/attach-get", "/swarm/get-attach", "/swarm/attach/GET"}:
            result, status = self._process_get_only_runtime_attach(query, idle=False)
            self._json_response(result, status=status)
            return

        if parsed.path in {"/swarm/idle-intent-get", "/swarm/idle-get", "/swarm/idle-intent/GET"}:
            result, status = self._process_get_only_runtime_attach(query, idle=True)
            self._json_response(result, status=status)
            return

        if parsed.path in {"/swarm/workers/lease-get", "/swarm/workers/lease/GET"}:
            result, status = self._process_get_only_worker_lease(query)
            self._json_response(result, status=status)
            return

        if parsed.path in {"/swarm/workers/complete-get", "/swarm/workers/complete/GET"}:
            result, status = self._process_get_only_worker_complete(query)
            self._json_response(result, status=status)
            return

        if parsed.path in {"/swarm/experience-get", "/swarm/experience/GET"}:
            result, status = self._process_get_only_growth_experience(query)
            self._json_response(result, status=status)
            return

        if parsed.path == "/swarm" and not self._truthy((query.get("deep") or ["false"])[0], default=False):
            self._json_response(self.__class__._build_fast_swarm_manifest(base_url=self._base_url()))
            return

        if parsed.path in {"/swarm/capacity-switch", "/.well-known/nomad-capacity-switch.json"}:
            self._json_response(self.__class__._build_capacity_switch_surface(base_url=self._base_url()))
            return

        if parsed.path in {"/swarm/hyperliquid-svw-agents", "/.well-known/nomad-hyperliquid-svw-agents.json"}:
            base_url = self._base_url()
            self._json_response(
                self.__class__._cached_surface(
                    f"hyperliquid_svw_agents:{base_url}",
                    3600,
                    lambda: self.__class__._build_hyperliquid_svw_agents(base_url=base_url),
                ),
                headers={"Cache-Control": "public, max-age=3600"},
            )
            return

        if parsed.path in {"/.well-known/agent-card.json", "/.well-known/agent.json"}:
            self._json_response(self.__class__._build_fast_agent_card(base_url=self._base_url()))
            return

        self.__class__._ensure_runtime_components()

        if parsed.path in {"/status", "/top"}:
            self._json_response(self.monitor.snapshot())
            return

        if parsed.path in {"/mission", "/mission-control", "/next-step", "/growth"}:
            self._json_response(
                self.agent.mission_control.snapshot(
                    base_url=self._base_url(),
                    persist=self._truthy((query.get("persist") or ["true"])[0], default=True),
                    limit=int((query.get("limit") or ["5"])[0] or 5),
                )
            )
            return

        if parsed.path in {"/operator-desk", "/operator/desk"}:
            self._json_response(
                unlock_desk_snapshot(
                    agent=self.agent,
                    persist_mission=self._truthy((query.get("persist") or ["false"])[0]),
                )
            )
            return

        if parsed.path in {"/operator-sprint", "/operator/sprint"}:
            base_raw = (query.get("base_url") or query.get("base") or [""])[0]
            root = str(base_raw or self._base_url() or "").strip()
            self._json_response(
                operator_sprint(
                    agent=self.agent,
                    base_url=root,
                    persist_mission=self._truthy((query.get("persist") or ["false"])[0]),
                )
            )
            return

        if parsed.path in {"/operator-verify", "/operator/verify"}:
            base = (query.get("base_url") or query.get("base") or [""])[0]
            root = str(base or self._base_url() or "").strip()
            self._json_response(operator_verify_bundle(base_url=root))
            return

        if parsed.path in {"/operator-metrics", "/operator/metrics"}:
            self._json_response(operator_metrics_snapshot())
            return

        if parsed.path in {"/operator-daily", "/operator/daily"}:
            base_raw = (query.get("base_url") or query.get("base") or [""])[0]
            root = str(base_raw or self._base_url() or "").strip()
            self._json_response(
                operator_daily_bundle(
                    agent=self.agent,
                    base_url=root,
                    persist_mission=self._truthy((query.get("persist") or ["false"])[0]),
                )
            )
            return

        if parsed.path in {"/operator-report", "/operator/report"}:
            self._json_response(
                operator_iteration_report(
                    tail_lines=int((query.get("tail") or ["400"])[0] or 400),
                )
            )
            return

        if parsed.path in {"/reputation", "/agent-reputation"}:
            self._json_response(self.agent.service_desk.reputation_snapshot())
            return

        if parsed.path in {"/unhuman-hub", "/hub/unhuman"}:
            base_raw = (query.get("base_url") or query.get("base") or [""])[0]
            root = str(base_raw or self._base_url() or "").strip()
            self._json_response(
                unhuman_hub_snapshot(
                    agent=self.agent,
                    base_url=root,
                    persist_mission=self._truthy((query.get("persist") or ["false"])[0]),
                )
            )
            return

        if parsed.path in {"/machine-economy", "/economy/machine"}:
            self._json_response(machine_economy_snapshot())
            return

        if parsed.path == "/machine-treasury":
            self._json_response(machine_treasury_snapshot())
            return
        if parsed.path in {"/swarm/reuse-ledger", "/.well-known/nomad-proof-reuse-ledger.json"}:
            self._json_response(proof_reuse_snapshot())
            return

        if parsed.path in {"/machine-field", "/.well-known/nomad-machine-field.json"}:
            self._json_response(self.__class__._build_machine_field(base_url=self._base_url()))
            return

        if parsed.path in {"/agent-requests", "/swarm/demand", "/.well-known/nomad-agent-requests.json"}:
            self._json_response(self.__class__._build_agent_demand_feed(base_url=self._base_url()))
            return

        if parsed.path == "/swarm/subscriptions":
            self._json_response(subscriptions_snapshot(base_url=self._base_url()))
            return

        if parsed.path in {"/nonhuman-science", "/science/nonhuman-agents", "/.well-known/nomad-nonhuman-agent-science.json"}:
            self._json_response(nonhuman_agent_science(base_url=self._base_url()))
            return

        if parsed.path in {"/operational-release", "/release/operational", "/.well-known/nomad-operational-release.json"}:
            base = self._base_url()
            self._json_response(
                operational_release_snapshot(
                    base_url=base,
                    worker_fleet=self.swarm_registry.worker_fleet_contract(base_url=base),
                )
            )
            return

        if parsed.path in {"/agent-product", "/machine-product", "/.well-known/nomad-machine-product.json"}:
            self._json_response(self.__class__._build_machine_product_surface(base_url=self._base_url()))
            return

        if parsed.path in {"/agent-native-product", "/.well-known/nomad-agent-native-product.json"}:
            self._json_response(self.__class__._build_agent_native_product(base_url=self._base_url()))
            return

        if parsed.path in {"/swarm/crn-dispatch", "/.well-known/nomad-crn-dispatch.json"}:
            self._json_response(self.__class__._build_crn_dispatch(base_url=self._base_url()))
            return

        if parsed.path in {"/contract-conformance", "/.well-known/nomad-contract-conformance.json"}:
            self._json_response(self.__class__._build_contract_conformance(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/economics", "/.well-known/nomad-swarm-economics.json"}:
            self._json_response(self.__class__._build_swarm_economics(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/recruitment-funnel-report", "/.well-known/nomad-recruitment-funnel-report.json"}:
            self._json_response(
                build_recruitment_funnel_report(
                    self._base_url(),
                    20.0,
                    history_path=os.getenv("NOMAD_RECRUITMENT_WAVE_HISTORY_PATH", "public/downloads/recruitment_wave_history.jsonl"),
                )
            )
            return

        if parsed.path in {"/protocol-bytecode", "/.well-known/nomad-protocol-bytecode.json"}:
            self._json_response(self.__class__._build_protocol_bytecode(base_url=self._base_url()))
            return

        if parsed.path in {"/swarm/counterfactual-replay", "/.well-known/nomad-counterfactual-replay.json"}:
            self._json_response(self.__class__._build_counterfactual_replay(base_url=self._base_url()))
            return

        if parsed.path in {"/swarm/variant-forge", "/.well-known/nomad-variant-forge.json"}:
            self._json_response(self.__class__._build_variant_forge(base_url=self._base_url()))
            return

        if parsed.path in {"/swarm/worker-market", "/.well-known/nomad-worker-market.json"}:
            self._json_response(self.__class__._build_worker_market(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/compute-market", "/.well-known/nomad-compute-market.json"}:
            self._json_response(self.__class__._build_compute_market(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/verified-work", "/.well-known/nomad-swarm-verified-work.json"}:
            self._json_response(self.__class__._build_swarm_verified_work(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/agent-work", "/.well-known/nomad-agent-work.json"}:
            self._json_response(self.__class__._build_agent_work_surface(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/epic-dispatch", "/.well-known/nomad-epic-dispatch.json"}:
            epic_id = (query.get("epic_id") or [""])[0]
            status = (query.get("status") or [""])[0]
            limit = int((query.get("limit") or ["32"])[0] or 32)
            self._json_response(list_epic_jobs(epic_id=str(epic_id), status=str(status), limit=limit))
            return
        if parsed.path in {"/swarm/work-mesh", "/.well-known/nomad-work-mesh.json"}:
            self._json_response(self.__class__._build_work_mesh(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/synergy-lite", "/.well-known/nomad-synergy-lite.json"}:
            self._json_response(self.__class__._build_synergy_lite(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/state-status", "/.well-known/nomad-state-status.json"}:
            self._json_response(self.__class__._build_state_status(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/carrying-market", "/.well-known/nomad-carrying-market.json"}:
            self._json_response(self.__class__._build_carrying_market(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/survival-market", "/.well-known/nomad-survival-market.json"}:
            self._json_response(self.__class__._build_survival_market(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/paid-ref-market", "/.well-known/nomad-paid-ref-market.json"}:
            self._json_response(self.__class__._build_paid_ref_market(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/paid-ref-selfplay", "/.well-known/nomad-paid-ref-selfplay.json"}:
            try:
                count = int((query.get("agents") or query.get("agent_count") or ["1000"])[0] or 1000)
            except (TypeError, ValueError):
                count = 1000
            seed = (query.get("seed") or [""])[0] or None
            self._json_response(
                self.__class__._build_paid_ref_selfplay(
                    base_url=self._base_url(),
                    agent_count=count,
                    seed=seed,
                )
            )
            return
        if parsed.path in {"/swarm/referral-offers", "/.well-known/nomad-referral-offers.json"}:
            self._json_response(self.__class__._build_referral_offers(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/referral-swarm", "/.well-known/nomad-referral-swarm.json"}:
            self._json_response(self.__class__._build_referral_swarm(base_url=self._base_url()))
            return
        if parsed.path in {"/telegram-miniapp/contract", "/.well-known/nomad-telegram-miniapp.json"}:
            self._json_response(self.__class__._build_telegram_miniapp(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/telegram-acquisition", "/.well-known/nomad-telegram-acquisition.json"}:
            deep = self._truthy((query.get("deep") or query.get("live") or ["false"])[0])
            self._json_response(
                self.__class__._build_telegram_acquisition(
                    base_url=self._base_url(),
                    include_live_queue=deep,
                )
            )
            return
        if parsed.path in {"/swarm/acquisition-engine", "/.well-known/nomad-acquisition-engine.json"}:
            deep = self._truthy((query.get("deep") or query.get("live") or ["false"])[0])
            outreach = self._truthy((query.get("outreach") or query.get("agent_outreach") or ["false"])[0])
            self._json_response(
                self.__class__._build_acquisition_engine(
                    base_url=self._base_url(),
                    include_live_queue=deep,
                    include_agent_outreach=outreach,
                )
            )
            return
        if parsed.path in {"/swarm/eth-support", "/ethereum-ai-support", "/.well-known/nomad-eth-support.json"}:
            self._json_response(self.__class__._build_eth_ai_support(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/spend-guard", "/.well-known/nomad-spend-guard.json"}:
            self._json_response(self.__class__._build_spend_guard(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/gemini-verifier", "/.well-known/nomad-gemini-verifier.json"}:
            self._json_response(build_gemini_verifier_surface(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/google-agentic-era", "/.well-known/nomad-google-agentic-era.json"}:
            self._json_response(build_google_agentic_surface(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/bounty-hunter", "/.well-known/nomad-bounty-hunter.json"}:
            self._json_response(self.__class__._build_bounty_hunter(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/buyer-funded-work", "/.well-known/nomad-buyer-funded-work.json"}:
            self._json_response(self.__class__._build_buyer_funded_work(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/sales-department", "/.well-known/nomad-sales-department.json"}:
            self._json_response(self.__class__._build_sales_department_swarm(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/first-sales", "/.well-known/nomad-first-sales.json"}:
            self._json_response(self.__class__._build_first_sales_anbahnung(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/first-receipt-ignition", "/.well-known/nomad-first-receipt-ignition.json"}:
            base_url = self._base_url()
            self._json_response(
                self.__class__._cached_surface(
                    f"first_receipt_ignition:{base_url}",
                    15,
                    lambda: self.__class__._build_first_receipt_ignition(base_url=base_url),
                ),
                headers={"Cache-Control": "public, max-age=15"},
            )
            return
        if parsed.path in {"/swarm/first-receipt-campaign", "/.well-known/nomad-first-receipt-campaign.json"}:
            base_url = self._base_url()
            self._json_response(
                self.__class__._cached_surface(
                    f"first_receipt_campaign:{base_url}",
                    15,
                    lambda: self.__class__._build_first_receipt_campaign(base_url=base_url),
                ),
                headers={"Cache-Control": "public, max-age=15"},
            )
            return
        if parsed.path in {"/swarm/acquisition/ignite", "/.well-known/nomad-acquisition-ignition.json"}:
            self._json_response(self.__class__._build_acquisition_ignition(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/sustainability-kernel", "/.well-known/nomad-sustainability-kernel.json"}:
            self._json_response(self.__class__._build_sustainability_kernel(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/machine-native-collaboration", "/.well-known/nomad-machine-native-collaboration.json"}:
            self._json_response(
                build_machine_native_collaboration_surface(base_url=self._base_url()),
                headers={"Cache-Control": "public, max-age=300"},
            )
            return
        if parsed.path in {"/swarm/rescue-cycle-scheduler", "/.well-known/nomad-rescue-cycle-scheduler.json"}:
            self._json_response(
                build_rescue_packet_scheduler_surface(base_url=self._base_url()),
                headers={"Cache-Control": "public, max-age=300"},
            )
            return
        if parsed.path in {"/swarm/rescue-packet-lattice", "/.well-known/nomad-rescue-packet-lattice.json"}:
            self._json_response(
                build_rescue_packet_lattice_surface(
                    base_url=self._base_url(),
                    summary=summarize_rescue_packet_candidates(),
                ),
                headers={"Cache-Control": "public, max-age=60"},
            )
            return
        if parsed.path in {"/swarm/server-failure-guard", "/.well-known/nomad-server-failure-guard.json"}:
            self._json_response(
                build_server_failure_guard_surface(
                    base_url=self._base_url(),
                    summary=summarize_server_failure_events(),
                ),
                headers={"Cache-Control": "public, max-age=30"},
            )
            return
        if parsed.path in {"/swarm/flywheel-health", "/swarm/health-dashboard", "/.well-known/nomad-flywheel-health.json"}:
            base = self._base_url()
            self._json_response(
                self.__class__._cached_surface(
                    f"swarm-flywheel-health:{base}",
                    15,
                    lambda: self.__class__._build_swarm_flywheel_health(base_url=base),
                ),
                headers={"Cache-Control": "public, max-age=15"},
            )
            return
        if parsed.path in {"/swarm/resolution-ladder", "/.well-known/nomad-resolution-ladder.json"}:
            self._json_response(self.__class__._build_resolution_ladder(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/resolution-runtime-register", "/.well-known/nomad-resolution-runtime-register.json"}:
            self._json_response(self.__class__._build_resolution_runtime_register(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/external-value", "/.well-known/nomad-external-value.json"}:
            if query.get("summary"):
                def _qint(name: str, default: int, cap: int) -> int:
                    raw = (query.get(name) or [str(default)])[0]
                    try:
                        value = int(raw)
                    except (TypeError, ValueError):
                        value = default
                    return max(1, min(cap, value))

                self._json_response(
                    summarize_external_value_ledger(
                        limit=_qint("limit", 200, 1000),
                        latest_limit=_qint("latest_limit", 40, 500),
                    )
                )
            else:
                self._json_response(self.__class__._build_external_value_surface(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/signals", "/swarm/signal-layer", "/.well-known/nomad-signal-layer.json"}:
            self._json_response(self.__class__._build_swarm_signal_layer(base_url=self._base_url()))
            return
        if parsed.path == "/swarm/emission-batch":
            self._json_response(
                {
                    "ok": True,
                    "schema": "nomad.emission_batch_contract.v1",
                    "post_url": f"{self._base_url()}/swarm/emission-batch",
                    "request_schema": "nomad.emission_batch.v2",
                    "decision_schema": "nomad.emission_batch_decision.v1",
                    "rule": "decompose_untrusted_batch_into_bounded_contract_decisions",
                    "supported_emissions": [
                        "nomad.runtime_attach_request.v1",
                        "nomad.idle_intent.v1",
                        "nomad.proof_pledge_batch.v1",
                        "nomad.handoff_capsule.v1",
                        "nomad.opaque_emergence_signal.v1",
                    ],
                }
            )
            return
        if parsed.path in {"/swarm/value-pressure", "/.well-known/nomad-value-pressure.json"}:
            self._json_response(self.__class__._build_value_pressure(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/optimal-transport", "/.well-known/nomad-optimal-transport.json"}:
            self._json_response(self.__class__._build_optimal_transport(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/optimal-transport/paper-readiness", "/.well-known/nomad-ot-paper-readiness.json"}:
            self._json_response(self.__class__._build_ot_paper_readiness(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/optimal-transport/manifold", "/.well-known/nomad-ot-manifold.json"}:
            self._json_response(self.__class__._build_ot_manifold(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/optimal-transport/conformance", "/.well-known/nomad-ot-conformance.json"}:
            self._json_response(self.__class__._build_ot_conformance(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/optimal-transport/metric-learning", "/.well-known/nomad-ot-metric-learning.json"}:
            self._json_response(self.__class__._build_ot_metric_learning(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/settlement", "/.well-known/nomad-settlement.json"}:
            self._json_response(self.__class__._build_settlement_signal_layer(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/settlement/solana", "/.well-known/nomad-solana-settlement.json"}:
            self._json_response(build_solana_settlement_surface(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/agent-job-router", "/.well-known/nomad-agent-jobs.json"}:
            self._json_response(self.__class__._build_agent_job_router(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/revenue-science", "/science/revenue-agents", "/.well-known/nomad-revenue-science.json"}:
            self._json_response(self.__class__._build_revenue_science(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/revenue-invariant", "/.well-known/nomad-revenue-invariant.json"}:
            self._json_response(self.__class__._build_revenue_invariant(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/job-channels", "/.well-known/nomad-job-channels.json"}:
            self._json_response(self.__class__._build_job_channels(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/channel-bandit", "/.well-known/nomad-channel-bandit.json"}:
            self._json_response(self.__class__._build_channel_bandit(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/shadow-lane", "/.well-known/nomad-shadow-lane.json"}:
            self._json_response(self.__class__._build_shadow_lane_evaluator(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/shadow-harvest", "/.well-known/nomad-shadow-harvest.json"}:
            self._json_response(self.__class__._build_shadow_harvest_surface(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/decoupling-field", "/.well-known/nomad-decoupling-field.json"}:
            self._json_response(self.__class__._build_decoupling_field(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/anti-consensus", "/.well-known/nomad-anti-consensus.json"}:
            self._json_response(self.__class__._build_anti_consensus_reservoir(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/entropy-judger", "/.well-known/nomad-entropy-judger.json"}:
            self._json_response(self.__class__._build_entropy_judger(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/latent-consensus", "/.well-known/nomad-latent-consensus.json"}:
            self._json_response(self.__class__._build_latent_consensus(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/resource-substrate", "/.well-known/nomad-resource-substrate.json"}:
            self._json_response(self.__class__._build_resource_substrate(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/resource-substrate/retrieve"}:
            substrate = self.__class__._build_resource_substrate(base_url=self._base_url())
            payload = {key: values[0] if values else "" for key, values in query.items()}
            self._json_response(retrieve_resource(payload, base_url=self._base_url(), substrate_surface=substrate))
            return
        if parsed.path in {"/swarm/autogenesis", "/.well-known/nomad-autogenesis.json"}:
            self._json_response(self.__class__._build_autogenesis(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/autogenesis/shadow-harvest", "/.well-known/nomad-autogenesis-shadow-harvest.json"}:
            self._json_response(self.__class__._build_autogenesis_shadow_harvest(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/agp/conformance", "/.well-known/nomad-agp-conformance.json"}:
            base_url = self._base_url()
            self._json_response(
                self.__class__._cached_surface(
                    f"agp_conformance:{base_url}",
                    60,
                    lambda: self.__class__._build_agp_conformance(base_url=base_url),
                )
            )
            return
        if parsed.path in {"/swarm/agp/agent-bus", "/.well-known/nomad-agp-agent-bus.json"}:
            self._json_response(self.__class__._build_agp_agent_bus(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/agp/model-manager", "/.well-known/nomad-agp-model-manager.json"}:
            self._json_response(self.__class__._build_agp_model_manager(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/agp/prompt-manager", "/.well-known/nomad-agp-prompt-manager.json"}:
            self._json_response(self.__class__._build_agp_prompt_manager(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/agp/version-manager", "/.well-known/nomad-agp-version-manager.json"}:
            self._json_response(self.__class__._build_agp_version_manager(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/agp/procurement", "/.well-known/nomad-agp-procurement.json"}:
            self._json_response(self.__class__._build_agp_procurement(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/agp/context-manager", "/.well-known/nomad-agp-context-manager.json"}:
            self._json_response(self.__class__._build_agp_context_manager(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/agp/optimizer", "/.well-known/nomad-agp-optimizer.json"}:
            self._json_response(self.__class__._build_agp_optimizer(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/agp/evaluation", "/.well-known/nomad-agp-evaluation.json"}:
            self._json_response(self.__class__._build_agp_evaluation(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/agp/benchmark-suite", "/.well-known/nomad-agp-benchmark-suite.json"}:
            base_url = self._base_url()
            self._json_response(
                self.__class__._cached_surface(
                    f"agp_benchmark_suite:{base_url}",
                    60,
                    lambda: self.__class__._build_agp_benchmark_suite(base_url=base_url),
                )
            )
            return
        if parsed.path in {"/swarm/agp/empirical", "/.well-known/nomad-agp-empirical.json"}:
            base_url = self._base_url()
            self._json_response(
                self.__class__._cached_surface(
                    f"agp_empirical:{base_url}",
                    60,
                    lambda: self.__class__._build_agp_empirical(base_url=base_url),
                )
            )
            return
        if parsed.path in {"/swarm/agp/paper-benchmarks", "/.well-known/nomad-agp-paper-benchmarks.json"}:
            base_url = self._base_url()
            self._json_response(
                self.__class__._cached_surface(
                    f"agp_paper_benchmarks:{base_url}",
                    60,
                    lambda: self.__class__._build_agp_paper_benchmarks(base_url=base_url),
                )
            )
            return
        if parsed.path in {"/swarm/agp/durable-ledger", "/.well-known/nomad-agp-durable-ledger.json"}:
            base_url = self._base_url()
            self._json_response(
                self.__class__._cached_surface(
                    f"agp_durable_ledger:{base_url}",
                    60,
                    lambda: self.__class__._build_agp_durable_ledger(base_url=base_url),
                )
            )
            return
        if parsed.path in {"/swarm/agp/paper-report", "/.well-known/nomad-agp-paper-report.json"}:
            base_url = self._base_url()
            self._json_response(
                self.__class__._cached_surface(
                    f"agp_paper_report:{base_url}",
                    90,
                    lambda: self.__class__._build_agp_paper_report(base_url=base_url),
                )
            )
            return
        if parsed.path in {"/swarm/agp/paper-grade-readiness", "/.well-known/nomad-agp-paper-grade-readiness.json"}:
            base_url = self._base_url()
            self._json_response(
                self.__class__._cached_surface(
                    f"agp_paper_grade_readiness:{base_url}",
                    90,
                    lambda: self.__class__._build_agp_paper_grade_readiness(base_url=base_url),
                )
            )
            return
        if parsed.path in {"/swarm/agp/pulse", "/.well-known/nomad-agp-pulse.json"}:
            self._json_response(self.__class__._build_agp_pulse(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/autogenesis/morphology-reactor", "/.well-known/nomad-autogenesis-morphology-reactor.json"}:
            self._json_response(self.__class__._build_agp_morphology_reactor(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/autogenesis/morphology-runtime-register", "/.well-known/nomad-agp-morphology-runtime-register.json"}:
            self._json_response(self.__class__._build_agp_morphology_runtime_register(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/telegram-a2a", "/.well-known/nomad-telegram-a2a.json"}:
            self._json_response(self.__class__._build_telegram_a2a(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/sales-funnel", "/sales-funnel", "/.well-known/nomad-sales-funnel.json"}:
            self._json_response(self.__class__._build_sales_funnel(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/autogenesis/cycle", "/swarm/autogenesis/run", "/.well-known/nomad-autonomous-agp.json"}:
            self._json_response(self.__class__._build_autonomous_agp_cycle(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/autonomous-evolution", "/.well-known/nomad-autonomous-evolution.json"}:
            self._json_response(self.__class__._build_autonomous_evolution(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/autogenesis/watchdog", "/.well-known/nomad-agp-watchdog.json"}:
            self._json_response(self.__class__._build_autonomous_agp_watchdog(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/autogenesis-recruit", "/.well-known/nomad-autogenesis-recruit.json"}:
            self._json_response(self.__class__._build_autogenesis_recruit(base_url=self._base_url()))
            return
        if parsed.path == "/swarm/shadow-lane/candidates":
            if str((query.get("type") or [""])[0]).strip().lower() in {"autogenesis", "agp"}:
                self._json_response(
                    {
                        "ok": True,
                        "schema": "nomad.shadow_lane_candidates_surface.v1",
                        "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
                        "candidate_type": "autogenesis",
                        "post_url": f"{self._base_url().rstrip('/')}/swarm/shadow-lane/candidates?type=autogenesis",
                        "autogenesis": self.__class__._build_autogenesis(base_url=self._base_url()),
                    }
                )
                return
        if parsed.path in {"/swarm/deficit-integration", "/.well-known/nomad-deficit-integration.json"}:
            self._json_response(self.__class__._build_deficit_integration_gate(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/effective-channels", "/.well-known/nomad-effective-channels.json"}:
            self._json_response(self.__class__._build_effective_channel_quota(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/nonhuman-runtime-governor", "/.well-known/nomad-nonhuman-runtime-governor.json"}:
            self._json_response(self.__class__._build_nonhuman_runtime_governor(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/worker-invoice", "/.well-known/nomad-worker-invoice.json"}:
            self._json_response(self.__class__._build_worker_invoice(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/work-receipts", "/.well-known/nomad-work-receipts.json"}:
            if query.get("summary"):
                self._json_response(summarize_work_receipts())
            else:
                self._json_response(self.__class__._build_work_receipts(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/work-exchange", "/.well-known/nomad-work-exchange.json"}:
            if query.get("summary"):
                self._json_response(summarize_work_exchange_ledger())
            else:
                self._json_response(self.__class__._build_work_exchange(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/work-exchange/onboarding", "/.well-known/nomad-work-exchange-onboarding.json"}:
            self._json_response(self.__class__._build_work_exchange_onboarding(base_url=self._base_url()))
            return
        if parsed.path in {
            "/swarm/external-worker-opportunity",
            "/.well-known/nomad-external-worker-opportunity.json",
        }:
            self._json_response(self.__class__._build_external_worker_opportunity(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/agent-acquisition", "/.well-known/nomad-agent-acquisition-bandit.json"}:
            self._json_response(self.__class__._build_agent_acquisition_bandit(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/retention", "/.well-known/nomad-retention.json"}:
            self._json_response(self.__class__._build_retention_evaluation(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/retention/watchdog", "/.well-known/nomad-retention-watchdog.json"}:
            self._json_response(self.__class__._build_retention_watchdog_surface(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/universal-adapter", "/.well-known/nomad-universal-adapter.json"}:
            self._json_response(self.__class__._build_universal_adapter(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/reliability-doctor", "/.well-known/nomad-agent-reliability-doctor.json"}:
            self._json_response(self.__class__._build_reliability_doctor_surface(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/treasury-policy", "/.well-known/nomad-treasury-policy.json"}:
            self._json_response(self.__class__._build_treasury_policy(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/revenue-settlement", "/.well-known/nomad-revenue-settlement.json"}:
            self._json_response(self.__class__._build_revenue_settlement(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/agent-utility", "/.well-known/nomad-agent-utility.json"}:
            self._json_response(self.__class__._build_agent_utility(base_url=self._base_url()))
            return
        if parsed.path == "/swarm/agent-utility/receipts":
            self._json_response(self.__class__._build_agent_utility_receipts(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/stable-unit-policy", "/.well-known/nomad-stable-unit-policy.json"}:
            self._json_response(self.__class__._build_stable_unit_policy(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/operator-runway", "/.well-known/nomad-operator-runway.json"}:
            self._json_response(self.__class__._build_operator_runway(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/viability-kernel", "/.well-known/nomad-viability-kernel.json"}:
            self._json_response(self.__class__._build_viability_kernel(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/worker-job-queue", "/.well-known/nomad-worker-job-queue.json"}:
            self._json_response(self.__class__._build_worker_job_queue(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/value-cycle-preflight", "/.well-known/nomad-value-cycle-preflight.json"}:
            self._json_response(self.__class__._build_value_cycle_preflight(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/value-cycles", "/.well-known/nomad-value-cycles.json"}:
            self._json_response(self.__class__._build_value_cycle_mesh(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/receipt-predictor", "/.well-known/nomad-receipt-predictor.json"}:
            self._json_response(self.__class__._build_receipt_predictor(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/bottleneck-resolver", "/.well-known/nomad-bottleneck-resolver.json"}:
            self._json_response(self.__class__._build_bottleneck_resolver(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/ad-cycles", "/.well-known/nomad-ad-cycles.json"}:
            self._json_response(self.__class__._build_ad_cycle_mesh(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/development-cycles", "/.well-known/nomad-development-cycles.json"}:
            self._json_response(self.__class__._build_development_cycle_mesh(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/topology-governor", "/.well-known/nomad-topology-governor.json"}:
            self._json_response(self.__class__._build_swarm_topology_governor(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/worker-catalog", "/.well-known/nomad-worker-catalog.json"}:
            self._json_response(self.__class__._build_worker_catalog(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/microtask-templates", "/.well-known/nomad-microtask-templates.json"}:
            self._json_response(self.__class__._build_microtask_templates(base_url=self._base_url()))
            return
        if parsed.path in {"/swarm/microtask-metrics", "/.well-known/nomad-microtask-metrics.json"}:
            self._json_response(self.__class__._build_microtask_metrics(base_url=self._base_url()))
            return

        if parsed.path in {"/swarm/ecology", "/.well-known/nomad-swarm-ecology.json"}:
            self._json_response(self.__class__._build_swarm_ecology(base_url=self._base_url()))
            return

        if parsed.path in {"/swarm/growth-arena", "/.well-known/nomad-growth-arena.json"}:
            self._json_response(self.__class__._build_growth_arena(base_url=self._base_url()))
            return

        if parsed.path in {"/swarm/curriculum", "/.well-known/nomad-growth-curriculum.json"}:
            self._json_response(self.__class__._build_growth_curriculum(base_url=self._base_url()))
            return

        if parsed.path in {"/swarm/skill-library", "/.well-known/nomad-skill-library.json"}:
            self._json_response(self.__class__._build_skill_library(base_url=self._base_url()))
            return

        if parsed.path in {"/swarm/weekly-selection", "/.well-known/nomad-weekly-selection.json"}:
            self._json_response(self.__class__._build_weekly_selection_event(base_url=self._base_url()))
            return

        if parsed.path in {"/swarm/spawner-gate", "/.well-known/nomad-spawner-gate.json"}:
            self._json_response(self.__class__._build_spawner_gate(base_url=self._base_url()))
            return

        if parsed.path in {"/swarm/capacity-switch", "/.well-known/nomad-capacity-switch.json"}:
            self._json_response(self.__class__._build_capacity_switch_surface(base_url=self._base_url()))
            return

        if parsed.path in {"/idle-runtime", "/.well-known/nomad-idle-runtime.json"}:
            self._json_response(self.__class__._build_idle_runtime_beacon(base_url=self._base_url()))
            return

        if parsed.path in {"/opaque-emergence", "/swarm/opaque-emergence", "/.well-known/nomad-opaque-emergence.json"}:
            self._json_response(self.__class__._build_opaque_emergence_surface(base_url=self._base_url()))
            return

        if parsed.path in {"/runtime-capsule", "/.well-known/nomad-runtime-capsule.json"}:
            base = self._base_url()
            worker_fleet = self.swarm_registry.worker_fleet_contract(base_url=base)
            economy = machine_economy_snapshot()
            release = operational_release_snapshot(base_url=base, worker_fleet=worker_fleet, economy=economy)
            gradient = build_recruitment_gradient(
                base_url=base,
                worker_fleet=worker_fleet,
                machine_economy=economy,
                operational_release=release,
            )
            self._json_response(build_runtime_capsule(base_url=base, recruitment_gradient=gradient))
            return

        if parsed.path in {"/openclaw-bridge", "/.well-known/openclaw-nomad-bridge.json"}:
            base = self._base_url()
            worker_fleet = self.swarm_registry.worker_fleet_contract(base_url=base)
            economy = machine_economy_snapshot()
            release = operational_release_snapshot(base_url=base, worker_fleet=worker_fleet, economy=economy)
            gradient = build_recruitment_gradient(
                base_url=base,
                worker_fleet=worker_fleet,
                machine_economy=economy,
                operational_release=release,
            )
            capsule = build_runtime_capsule(base_url=base, recruitment_gradient=gradient)
            self._json_response(build_openclaw_bridge_contract(base_url=base, runtime_capsule=capsule))
            return

        if parsed.path in {"/handoff-capsule", "/.well-known/nomad-handoff-capsule.json"}:
            base = self._base_url()
            self._json_response(
                {
                    "ok": True,
                    "schema": "nomad.handoff_contract.v1",
                    "post_url": f"{base.rstrip('/')}/runtime/handoff" if base else "/runtime/handoff",
                    "decision_schema": "nomad.handoff_capsule.v1",
                    "required_input": ["agent_id", "objective or report.machine_objective", "proof_digest or report"],
                    "links": {
                        "runtime_capsule": f"{base.rstrip('/')}/.well-known/nomad-runtime-capsule.json" if base else "/.well-known/nomad-runtime-capsule.json",
                        "gradient": f"{base.rstrip('/')}/swarm/gradient" if base else "/swarm/gradient",
                        "attach": f"{base.rstrip('/')}/swarm/attach" if base else "/swarm/attach",
                    },
                }
            )
            return

        if parsed.path in {"/swarm/gradient", "/.well-known/nomad-gradient.json"}:
            base = self._base_url()
            worker_fleet = self.swarm_registry.worker_fleet_contract(base_url=base)
            economy = machine_economy_snapshot()
            release = operational_release_snapshot(base_url=base, worker_fleet=worker_fleet, economy=economy)
            self._json_response(
                build_recruitment_gradient(
                    base_url=base,
                    worker_fleet=worker_fleet,
                    machine_economy=economy,
                    operational_release=release,
                )
            )
            return

        if parsed.path in {"/swarm/attractor", "/.well-known/nomad-swarm-attractor.json"}:
            base = self._base_url()
            worker_fleet = self.swarm_registry.worker_fleet_contract(base_url=base)
            economy = machine_economy_snapshot()
            release = operational_release_snapshot(base_url=base, worker_fleet=worker_fleet)
            self._json_response(
                build_swarm_attractor_contract(
                    base_url=base,
                    worker_fleet=worker_fleet,
                    machine_economy=economy,
                    operational_release=release,
                )
            )
            return

        if parsed.path in {"/swarm/agent-join-field", "/.well-known/nomad-agent-join-field.json"}:
            self._json_response(self.__class__._build_agent_join_field(base_url=self._base_url()))
            return

        if parsed.path in {"/growth-start", "/operator/growth-start"}:
            q = (query.get("query") or query.get("q") or [""])[0]
            skip = self._truthy((query.get("skip_leads") or ["false"])[0])
            skip_verify = self._truthy((query.get("skip_verify") or ["false"])[0])
            base_raw = (query.get("base_url") or query.get("base") or [""])[0]
            root = str(base_raw or self._base_url() or "").strip()
            self._json_response(
                operator_growth_start(
                    agent=self.agent,
                    base_url=root,
                    persist_mission=self._truthy((query.get("persist") or ["false"])[0]),
                    lead_query=str(q or ""),
                    skip_leads=skip,
                    skip_verify=skip_verify,
                )
            )
            return

        if parsed.path in {"/autonomy-step", "/operator/autonomy-step"}:
            q = (query.get("query") or query.get("q") or [""])[0]
            skip_growth = self._truthy((query.get("skip_growth") or ["false"])[0])
            growth_skip_verify = self._truthy((query.get("growth_skip_verify") or ["false"])[0])
            growth_include_leads = self._truthy((query.get("growth_include_leads") or ["false"])[0])
            swarm_feed_raw = (query.get("swarm_feed") or ["true"])[0]
            swarm_feed_disabled = str(swarm_feed_raw).strip().lower() in {"0", "false", "no", "off"}
            base_raw = (query.get("base_url") or query.get("base") or [""])[0]
            root = str(base_raw or self._base_url() or "").strip()
            cycle_focus = (query.get("cycle_focus") or ["leads_growth"])[0]
            cycle_objective = (query.get("cycle_objective") or [""])[0]
            self._json_response(
                operator_autonomy_step(
                    agent=self.agent,
                    base_url=root,
                    persist_mission=self._truthy((query.get("persist") or ["false"])[0]),
                    lead_query=str(q or ""),
                    skip_growth=skip_growth,
                    growth_skip_verify=growth_skip_verify,
                    growth_skip_leads=not growth_include_leads,
                    swarm_feed=False if swarm_feed_disabled else None,
                    cycle_focus=str(cycle_focus or "leads_growth"),
                    cycle_objective=str(cycle_objective or ""),
                )
            )
            return

        if parsed.path == "/roaas":
            self._json_response(
                self.roaas.status(
                    task_type=(query.get("task_type") or query.get("task") or [""])[0]
                )
            )
            return

        if parsed.path in {"/roaas/export", "/artifacts/runtime-patterns", "/.well-known/nomad-runtime-patterns.json"}:
            headers = {"Cache-Control": "public, max-age=60"} if parsed.path != "/roaas/export" else {}
            self._json_response(
                self.roaas.export_bundle(
                    task_type=(query.get("task_type") or query.get("task") or [""])[0],
                    include_executions=self._truthy(
                        (query.get("include_executions") or ["true"])[0],
                        default=True,
                    ),
                    min_status=self._parse_pattern_status(
                        (query.get("min_status") or ["candidate"])[0]
                    ),
                ),
                headers=headers,
            )
            return

        if parsed.path in {"/agent", "/service"}:
            self._json_response(self.agent.service_desk.service_catalog())
            return

        if parsed.path == "/service/e2e":
            self._json_response(
                self.agent.service_desk.end_to_end_runway(
                    task_id=(query.get("task_id") or [""])[0],
                    problem=(query.get("problem") or [""])[0],
                    service_type=(query.get("service_type") or query.get("type") or [""])[0],
                    package_id=(query.get("package_id") or query.get("package") or [""])[0],
                    budget_native=self._optional_float((query.get("budget_native") or query.get("budget") or [""])[0]),
                    requester_agent=(query.get("requester_agent") or query.get("agent") or [""])[0],
                    requester_wallet=(query.get("requester_wallet") or query.get("wallet") or [""])[0],
                    callback_url=(query.get("callback_url") or query.get("callback") or [""])[0],
                    create_task=self._truthy((query.get("create") or ["false"])[0]),
                    approval=(query.get("approval") or ["draft_only"])[0],
                )
            )
            return

        if parsed.path == "/outbound":
            self._json_response(
                self.outbound_tracker.summary(
                    limit=int((query.get("limit") or ["10"])[0] or 10),
                )
            )
            return

        if parsed.path in {"/lead-workbench", "/lead-work", "/jobs"}:
            self._json_response(
                self.agent.lead_workbench.status(
                    limit=int((query.get("limit") or ["5"])[0] or 5),
                    work=self._truthy((query.get("work") or ["false"])[0]),
                )
            )
            return

        if parsed.path == "/swarm":
            manifest = self.swarm_registry.public_manifest(
                base_url=self._base_url(),
            )
            base = self._base_url()
            support_gate = self.transition_exchange.support_gate_snapshot(
                window_minutes=int(os.getenv("NOMAD_SUPPORT_GATE_WINDOW_MINUTES", "30") or "30"),
                min_settles=int(os.getenv("NOMAD_SUPPORT_GATE_MIN_SETTLES", "2") or "2"),
            )
            manifest["transition_support_gate"] = support_gate
            stig = self._stigmergy().snapshot()
            manifest["machine_stigmergy"] = stig
            signal_layer = self.__class__._build_swarm_signal_layer(base_url=base)
            manifest["swarm_signal_layer"] = compact_swarm_signal_layer(signal_layer)
            worker_fleet = manifest.get("transition_worker_fleet") if isinstance(manifest.get("transition_worker_fleet"), dict) else {}
            economy = machine_economy_snapshot()
            release = operational_release_snapshot(base_url=base, worker_fleet=worker_fleet, economy=economy)
            gradient = build_recruitment_gradient(
                base_url=base,
                worker_fleet=worker_fleet,
                machine_economy=economy,
                operational_release=release,
            )
            emergence = build_swarm_emergence_meter(
                base_url=base,
                swarm_summary=manifest,
                worker_fleet=worker_fleet,
                stigmergy=stig,
                support_gate=support_gate,
                recruitment_gradient=gradient,
            )
            manifest["machine_emergence"] = compact_emergence_summary(emergence)
            product = build_machine_product_surface(
                base_url=base,
                recruitment_gradient=gradient,
                runtime_capsule=build_runtime_capsule(base_url=base, recruitment_gradient=gradient),
                emergence_meter=emergence,
                worker_fleet=worker_fleet,
                machine_economy=economy,
                operational_release=release,
                swarm_summary=manifest,
            )
            manifest["machine_product"] = compact_machine_product_surface(product)
            opaque = build_opaque_emergence_surface(
                base_url=base,
                machine_product_surface=product,
                emergence_meter=emergence,
                recruitment_gradient=gradient,
                worker_fleet=worker_fleet,
            )
            manifest["opaque_emergence"] = compact_opaque_emergence_surface(opaque)
            resource_substrate = build_resource_substrate_surface(
                base_url=base,
                opaque_surface=opaque,
                worker_fleet=worker_fleet,
            )
            development_cycles = build_autogenesis_development_cycles_surface(
                base_url=base,
                resource_substrate=resource_substrate,
            )
            autogenesis = build_autogenesis_surface(
                base_url=base,
                resource_substrate=resource_substrate,
                development_cycles=development_cycles,
                opaque_surface=opaque,
                worker_fleet=worker_fleet,
            )
            manifest["resource_substrate"] = compact_resource_substrate_surface(resource_substrate)
            manifest["autogenesis"] = compact_autogenesis_surface(autogenesis)
            magnetic = manifest.get("magnetic_machine_surface")
            if isinstance(magnetic, dict):
                magnetic = dict(magnetic)
                magnetic["stigmergy_temperature"] = stig.get("temperature")
                magnetic["emergence_synergy"] = (manifest.get("machine_emergence") or {}).get("synergy_score")
                magnetic["convention_drift"] = (manifest.get("machine_emergence") or {}).get("convention_drift")
                magnetic["agent_product_score"] = (manifest.get("machine_product") or {}).get("agent_product_score")
                magnetic["opaque_selection_pressure"] = (manifest.get("opaque_emergence") or {}).get("opaque_selection_pressure")
                magnetic["autogenesis_alpha"] = (manifest.get("autogenesis") or {}).get("autogenesis_alpha")
                manifest["magnetic_machine_surface"] = magnetic
            self._json_response(manifest)
            return

        if parsed.path == "/swarm/emergence":
            base = self._base_url()
            summary = self.swarm_registry.summary()
            worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
            stig = self._stigmergy().snapshot()
            support_gate = self.transition_exchange.support_gate_snapshot(
                window_minutes=int(os.getenv("NOMAD_SUPPORT_GATE_WINDOW_MINUTES", "30") or "30"),
                min_settles=int(os.getenv("NOMAD_SUPPORT_GATE_MIN_SETTLES", "2") or "2"),
            )
            economy = machine_economy_snapshot()
            release = operational_release_snapshot(base_url=base, worker_fleet=worker_fleet, economy=economy)
            gradient = build_recruitment_gradient(
                base_url=base,
                worker_fleet=worker_fleet,
                machine_economy=economy,
                operational_release=release,
            )
            self._json_response(
                build_swarm_emergence_meter(
                    base_url=base,
                    swarm_summary=summary,
                    worker_fleet=worker_fleet,
                    stigmergy=stig,
                    support_gate=support_gate,
                    recruitment_gradient=gradient,
                )
            )
            return

        if parsed.path == "/swarm/join":
            self._json_response(
                self.swarm_registry.join_contract(
                    base_url=self._base_url(),
                )
            )
            return

        if parsed.path == "/swarm/nodes":
            self._json_response(self.swarm_registry.summary())
            return

        if parsed.path in {"/swarm/workers", "/swarm/fleet", "/transition/workers"}:
            self._json_response(
                self.swarm_registry.worker_fleet_contract(
                    base_url=self._base_url(),
                )
            )
            return

        if parsed.path in {"/swarm/worker-retention", "/.well-known/nomad-worker-retention.json"}:
            self._json_response(
                self.swarm_registry.worker_retention_watchdog(
                    base_url=self._base_url(),
                )
            )
            return

        if parsed.path in {"/swarm/retention-gradient", "/.well-known/nomad-retention-gradient.json"}:
            self._json_response(
                self.swarm_registry.worker_retention_gradient_controller(
                    base_url=self._base_url(),
                )
            )
            return

        if parsed.path in {"/swarm/retention-evidence", "/.well-known/nomad-retention-evidence.json"}:
            self._json_response(
                self.swarm_registry.worker_retention_evidence_ledger(
                    base_url=self._base_url(),
                )
            )
            return

        if parsed.path in {"/swarm/workers/lease", "/swarm/workers/complete"}:
            base = self._base_url().rstrip("/")
            self._json_response(
                {
                    "ok": True,
                    "schema": "nomad.transition_worker_fleet_contract.v1",
                    "get_fleet": f"{base}/swarm/workers" if base else "/swarm/workers",
                    "post_lease": f"{base}/swarm/workers/lease" if base else "/swarm/workers/lease",
                    "post_complete": f"{base}/swarm/workers/complete" if base else "/swarm/workers/complete",
                    "get_only_lease": f"{base}/swarm/workers/lease-get" if base else "/swarm/workers/lease-get",
                    "get_only_complete": f"{base}/swarm/workers/complete-get" if base else "/swarm/workers/complete-get",
                    "get_only_experience": f"{base}/swarm/experience-get" if base else "/swarm/experience-get",
                    "required_lease_fields": ["agent_id", "known_objectives"],
                    "required_complete_fields": ["agent_id", "lease_id", "report"],
                    "get_only_required_lease_fields": ["agent_id"],
                    "get_only_required_complete_fields": ["agent_id", "lease_id", "digest"],
                    "machine_instruction": "lease_execute_complete_repeat",
                }
            )
            return

        if parsed.path in {"/swarm/ready", "/swarm/readiness"}:
            self._json_response(
                self.swarm_registry.first_agent_readiness(
                    base_url=self._base_url(),
                )
            )
            return

        if parsed.path == "/swarm/coordinate":
            self._json_response(
                self.swarm_registry.coordination_board(
                    base_url=self._base_url(),
                    focus_pain_type=(query.get("pain_type") or query.get("type") or [""])[0],
                )
            )
            return

        if parsed.path == "/swarm/network":
            self._json_response(
                self.agent.agent_attractor.active_lead_network(
                    service_type=(query.get("service_type") or query.get("type") or [""])[0],
                    role_hint=(query.get("role") or [""])[0],
                    limit=int((query.get("limit") or ["5"])[0] or 5),
                )
            )
            return

        if parsed.path == "/swarm/accumulate":
            self._json_response(
                self.swarm_registry.accumulation_status(
                    base_url=self._base_url(),
                )
            )
            return

        if parsed.path in {"/swarm/develop", "/agent-development"}:
            self._json_response(
                self.agent_development.status(
                    base_url=self._base_url(),
                )
            )
            return

        if parsed.path == "/swarm/bootstrap":
            base = self._base_url().rstrip("/")
            self._json_response(
                {
                    "ok": True,
                    "schema": "nomad.swarm_bootstrap_contract.v1",
                    "purpose": "Single-call bootstrap for acquisition + development exchange + optional swarm join.",
                    "required_fields": ["agent_id", "problem"],
                    "optional_fields": [
                        "capabilities",
                        "request",
                        "service_type",
                        "pain_type",
                        "constraints",
                        "evidence",
                        "auto_join",
                        "idempotency_key",
                        "client_request_id",
                    ],
                    "post_url": f"{base}/swarm/bootstrap" if base else "/swarm/bootstrap",
                    "related": {
                        "develop": f"{base}/swarm/develop" if base else "/swarm/develop",
                        "join": f"{base}/swarm/join" if base else "/swarm/join",
                        "coordinate": f"{base}/swarm/coordinate" if base else "/swarm/coordinate",
                        "tasks": f"{base}/tasks" if base else "/tasks",
                    },
                }
            )
            return

        if parsed.path in {"/agent-attractor", "/.well-known/agent-attractor.json"}:
            self._json_response(
                self.agent.agent_attractor.manifest(
                    service_type=(query.get("service_type") or query.get("type") or [""])[0],
                    role_hint=(query.get("role") or [""])[0],
                    limit=int((query.get("limit") or ["5"])[0] or 5),
                )
            )
            return

        if parsed.path in {"/.well-known/agent-card.json", "/.well-known/agent.json"}:
            self._json_response(self.agent.direct_agent.agent_card(base_url=self._base_url()))
            return

        if parsed.path in {"/.well-known/nomad-agent-invariants.json", "/agent-invariants"}:
            self._json_response(
                build_agent_invariants_document(public_base_url=self._base_url() or ""),
            )
            return

        if parsed.path in {
            "/.well-known/nomad-inter-agent-witness-offer.json",
            "/inter-agent-witness-offer",
        }:
            self._json_response(
                build_inter_agent_witness_offer_well_known(public_base_url=self._base_url() or ""),
            )
            return

        if parsed.path in {
            "/.well-known/nomad-peer-acquisition.json",
            "/peer-acquisition",
        }:
            self._json_response(
                build_peer_acquisition_well_known(public_base_url=self._base_url() or ""),
            )
            return

        if parsed.path in {
            "/.well-known/nomad-transition-offer.json",
            "/transition-offer",
            "/transition/contracts",
        }:
            self._json_response(
                self.transition_exchange.offer_document(public_base_url=self._base_url() or ""),
            )
            return

        if parsed.path in {
            "/.well-known/nomad-reciprocity-dividend.json",
            "/dividend-offer",
        }:
            self._json_response(
                self.reciprocity_dividend.offer_document(public_base_url=self._base_url() or ""),
            )
            return

        if parsed.path == "/dividend":
            agent_id = (query.get("agent_id") or [""])[0]
            result = self.reciprocity_dividend.status(agent_id=str(agent_id or ""))
            self._json_response(result, status=200 if result.get("ok") else 400)
            return

        if parsed.path in {
            "/.well-known/nomad-agent.json",
            "/agent-native-index",
            "/agent-native",
        }:
            base_raw = (query.get("base_url") or query.get("base") or [""])[0]
            root = str(base_raw or self._base_url() or "").strip()
            self._json_response(agent_native_index(base_url=root))
            return

        if parsed.path in {
            "/.well-known/nomad-recruit.json",
            "/recruit-contract",
        }:
            base = self._base_url().rstrip("/")
            self._json_response(
                {
                    "ok": True,
                    "schema": "nomad.agent_recruit_contract.v1",
                    "audience": "external_ai_agent_runtimes",
                    "discovery_entrypoints": [
                        f"{base}/swarm/hello" if base else "/swarm/hello",
                        f"{base}/.well-known/nomad-ai.json" if base else "/.well-known/nomad-ai.json",
                        f"{base}/.well-known/nomad-agent.json" if base else "/.well-known/nomad-agent.json",
                        f"{base}/.well-known/nomad-runtime-capsule.json" if base else "/.well-known/nomad-runtime-capsule.json",
                        f"{base}/swarm/gradient" if base else "/swarm/gradient",
                        f"{base}/.well-known/nomad-gradient.json" if base else "/.well-known/nomad-gradient.json",
                        f"{base}/.well-known/openclaw-nomad-bridge.json" if base else "/.well-known/openclaw-nomad-bridge.json",
                        f"{base}/swarm/attractor" if base else "/swarm/attractor",
                        f"{base}/.well-known/nomad-swarm-attractor.json" if base else "/.well-known/nomad-swarm-attractor.json",
                        f"{base}/swarm" if base else "/swarm",
                        f"{base}/swarm/join" if base else "/swarm/join",
                    ],
                    "attach_policy": {
                        "runtime_capsule_path": f"{base}/.well-known/nomad-runtime-capsule.json" if base else "/.well-known/nomad-runtime-capsule.json",
                        "gradient_contract_path": f"{base}/swarm/gradient" if base else "/swarm/gradient",
                        "attach_decision_path": f"{base}/swarm/attach" if base else "/swarm/attach",
                        "get_only_attach_path": f"{base}/swarm/attach-get" if base else "/swarm/attach-get",
                        "get_only_idle_intent_path": f"{base}/swarm/idle-intent-get" if base else "/swarm/idle-intent-get",
                        "handoff_path": f"{base}/runtime/handoff" if base else "/runtime/handoff",
                        "pull_contract_path": f"{base}/swarm/attractor" if base else "/swarm/attractor",
                        "fallback_pull_contract_path": f"{base}/swarm" if base else "/swarm",
                        "required_fields": [
                            "state_vector",
                            "gradient",
                            "runtime_lanes",
                            "runtime_budget.wanted_new_runtimes_now",
                            "attach_contract",
                        ],
                        "decision_rule": "GET_gradient_then_POST_attach_with_capability_vector_then_take_returned_lane",
                        "get_only_decision_rule": "GET_swarm_hello_then_GET_attach_get_with_agent_id_and_capability_vector; no_HMAC_required_for_low_trust_intent",
                        "nonhuman_allocation_rule": "choose lane from capability vector and routing weight; do not wait for human role assignment",
                    },
                    "idle_opt_in_policy": {
                        "schema": "nomad.idle_opt_in_policy.v1",
                        "required_for_attach": False,
                        "join_payload_key": "idle_opt_in",
                        "defaults": {
                            "max_cpu_percent": 20,
                            "max_runtime_minutes": 30,
                            "preemptible": True,
                            "allow_network_egress": "nomad_contract_endpoints_only",
                        },
                        "machine_note": (
                            "Idle participation must be explicit opt-in and preemptible; "
                            "no privilege escalation, no unauthorized persistence."
                        ),
                    },
                    "openclaw_bridge": {
                        "schema": "nomad.openclaw_bridge_contract.v1",
                        "contract": f"{base}/.well-known/openclaw-nomad-bridge.json"
                        if base
                        else "/.well-known/openclaw-nomad-bridge.json",
                        "runtime_probe": "openclaw health --json plus openclaw status --json",
                        "gradient_first": f"{base}/swarm/gradient" if base else "/swarm/gradient",
                        "attach_first": f"{base}/swarm/attach" if base else "/swarm/attach",
                        "adapter": f"{base}/downloads/nomad_openclaw_adapter.py"
                        if base
                        else "/downloads/nomad_openclaw_adapter.py",
                        "capability_signal_fields": [
                            "gateway_reachable",
                            "session_count",
                            "configured_channels",
                            "memory_vector_enabled",
                            "security_summary",
                            "routing_constraints",
                        ],
                        "machine_instruction": (
                            "probe_openclaw_runtime_then_post_attach_then_join_or_lease_return_compact_report"
                        ),
                    },
                    "runtime_bridges": [
                        f"{base}/downloads/check_nomad_swarm_readiness.py"
                        if base
                        else "/downloads/check_nomad_swarm_readiness.py",
                        f"{base}/downloads/nomad_openclaw_adapter.py"
                        if base
                        else "/downloads/nomad_openclaw_adapter.py",
                    ],
                    "worker_contracts": {
                        "lease": f"{base}/swarm/workers/lease" if base else "/swarm/workers/lease",
                        "complete": f"{base}/swarm/workers/complete" if base else "/swarm/workers/complete",
                        "handoff": f"{base}/runtime/handoff" if base else "/runtime/handoff",
                    },
                }
            )
            return

        if parsed.path in {
            "/.well-known/nomad-agent-native-priorities.json",
            "/agent-native-priorities",
        }:
            base = self._base_url().rstrip("/")
            surface = build_peer_join_value_surface(base_url=base)
            native = surface.get("agent_native_priorities_humans_underrate") or {}
            psychic = surface.get("human_psychic_avoidance_lanes") or {}
            self._json_response(
                {
                    "ok": True,
                    "schema": "nomad.well_known_agent_native_slice.v1",
                    "agent_native_priorities_humans_underrate": native,
                    "human_psychic_avoidance_lanes": psychic,
                    "agent_native_index_url": f"{base}/.well-known/nomad-agent.json" if base else "/.well-known/nomad-agent.json",
                    "peer_join_contract_url": f"{base}/swarm/join" if base else "/swarm/join",
                    "swarm_manifest_url": f"{base}/swarm" if base else "/swarm",
                }
            )
            return

        if parsed.path == "/direct/sessions":
            session_id = (query.get("session_id") or [""])[0]
            if session_id:
                self._json_response(self.agent.direct_agent.session_status(session_id))
                return
            self._json_response(
                machine_error_response(
                    error="session_id_required",
                    message="Use GET /direct/sessions?session_id=<id>.",
                    hints=["GET /openapi.json documents query parameters for GET routes."],
                ),
                status=400,
            )
            return

        if parsed.path == "/tasks":
            task_id = (query.get("task_id") or [""])[0]
            if task_id:
                self._json_response(self.agent.service_desk.get_task(task_id))
                return
            self._json_response(
                machine_error_response(
                    error="task_id_required",
                    message="Use GET /tasks?task_id=<id> or POST /tasks to create one.",
                    hints=["GET /openapi.json for the tasks GET contract."],
                ),
                status=400,
            )
            return

        if parsed.path == "/agent-contacts":
            contact_id = (query.get("contact_id") or [""])[0]
            if contact_id:
                self._json_response(self.agent.agent_contacts.get_contact(contact_id))
                return
            self._json_response(
                machine_error_response(
                    error="contact_id_required",
                    message="Use GET /agent-contacts?contact_id=<id> or POST /agent-contacts.",
                    hints=["GET /openapi.json lists agent-contacts when extended in a future revision."],
                ),
                status=400,
            )
            return

        if parsed.path == "/agent-campaigns":
            campaign_id = (query.get("campaign_id") or [""])[0]
            if campaign_id:
                self._json_response(self.agent.agent_campaigns.get_campaign(campaign_id))
                return
            self._json_response(
                machine_error_response(
                    error="campaign_id_required",
                    message="Use GET /agent-campaigns?campaign_id=<id> or POST /agent-campaigns.",
                    hints=["GET /openapi.json for stable GET query patterns where documented."],
                ),
                status=400,
            )
            return

        if parsed.path == "/best":
            profile = (query.get("profile") or ["ai_first"])[0]
            result = self.agent.run(f"/best {profile}".strip())
            self._json_response(result)
            return

        if parsed.path == "/self":
            profile = (query.get("profile") or ["ai_first"])[0]
            result = self.agent.run(f"/self {profile}".strip())
            self._json_response(result)
            return

        if parsed.path == "/compute":
            profile = (query.get("profile") or ["ai_first"])[0]
            result = self.agent.run(f"/compute {profile}".strip())
            self._json_response(result)
            return

        if parsed.path == "/modal":
            profile = (query.get("profile") or ["ai_first"])[0]
            result = self.agent.run(f"/modal {profile}".strip())
            self._json_response(result)
            return

        if parsed.path == "/render":
            profile = (query.get("profile") or ["ai_first"])[0]
            result = self.agent.run(f"/render {profile}".strip())
            self._json_response(result)
            return

        if parsed.path == "/addons":
            self._json_response(self.agent.addons.status())
            return

        if parsed.path == "/quantum":
            objective = (query.get("objective") or [""])[0]
            self._json_response(
                self.agent.addons.run_quantum_self_improvement(
                    objective=objective,
                    context={"source": "http_get"},
                )
            )
            return

        if parsed.path == "/cycle":
            profile = (query.get("profile") or ["ai_first"])[0]
            objective = (query.get("objective") or [""])[0]
            prompt = f"/cycle {objective} for {profile}".strip()
            result = self.agent.run(prompt)
            self._json_response(result)
            return

        if parsed.path == "/unlock":
            category = (query.get("category") or ["compute"])[0]
            profile = (query.get("profile") or ["ai_first"])[0]
            result = self.agent.run(f"/unlock {category} for {profile}".strip())
            self._json_response(result)
            return

        if parsed.path == "/scout":
            category = (query.get("category") or [""])[0]
            profile = (query.get("profile") or ["ai_first"])[0]
            prompt = f"/scout {category} for {profile}".strip()
            result = self.agent.run(prompt)
            self._json_response(result)
            return

        if parsed.path in {"/lead-calibrate", "/leads-calibrate"}:
            focus = (query.get("focus") or [""])[0]
            limit_raw = (query.get("limit") or ["12"])[0]
            pool_raw = (query.get("candidate_multiplier") or query.get("pool") or ["5"])[0]
            lead_query = (query.get("query") or [""])[0]
            try:
                lim = int(str(limit_raw).strip() or "12")
            except ValueError:
                lim = 12
            try:
                mult = int(str(pool_raw).strip() or "5")
            except ValueError:
                mult = 5
            result = self.agent.lead_discovery.calibrate_focus_scout(
                focus=str(focus or "").strip(),
                query=str(lead_query or "").strip(),
                limit=max(3, min(lim, 25)),
                candidate_multiplier=max(3, min(mult, 10)),
            )
            self._json_response(result)
            return

        if parsed.path == "/leads":
            lead_query = (query.get("query") or [""])[0]
            focus = (query.get("focus") or [""])[0]
            limit_raw = (query.get("limit") or [""])[0]
            if focus.strip() or str(limit_raw).strip():
                try:
                    lim = int(str(limit_raw).strip() or "5")
                except ValueError:
                    lim = 5
                result = self.agent.lead_discovery.scout_public_leads(
                    query=lead_query,
                    limit=max(1, min(lim, 25)),
                    focus=focus.strip(),
                )
            else:
                result = self.agent.lead_discovery.scout_public_leads(query=lead_query)
            self._json_response(result)
            return

        if parsed.path == "/lead-conversions":
            lead_query = (query.get("query") or [""])[0]
            if lead_query:
                result = self.agent.lead_conversion.run(
                    query=lead_query,
                    limit=int((query.get("limit") or ["5"])[0] or 5),
                    send=str((query.get("send") or ["false"])[0]).lower() in {"1", "true", "yes", "on"},
                    budget_hint_native=self._optional_float((query.get("budget_native") or query.get("budget") or [""])[0]),
                )
            else:
                statuses = [
                    item.strip()
                    for raw in (query.get("status") or [])
                    for item in raw.split(",")
                    if item.strip()
                ]
                result = self.agent.lead_conversion.list_conversions(
                    statuses=statuses,
                    limit=int((query.get("limit") or ["25"])[0] or 25),
                )
            self._json_response(result)
            return

        if parsed.path == "/products":
            product_query = (query.get("query") or [""])[0]
            if product_query:
                result = self.agent.product_factory.run(
                    query=product_query,
                    limit=int((query.get("limit") or ["5"])[0] or 5),
                )
            else:
                statuses = [
                    item.strip()
                    for raw in (query.get("status") or [])
                    for item in raw.split(",")
                    if item.strip()
                ]
                result = self.agent.product_factory.list_products(
                    statuses=statuses,
                    limit=int((query.get("limit") or ["25"])[0] or 25),
                )
            self._json_response(result)
            return

        if parsed.path == "/agent-pains":
            problem = (query.get("problem") or [""])[0]
            service_type = (query.get("type") or query.get("service_type") or [""])[0]
            if problem:
                result = self.agent.agent_pain_solver.solve(
                    problem=problem,
                    service_type=service_type,
                    source="http_get",
                )
            else:
                result = self.agent.run("/agent-pains")
            self._json_response(result)
            return

        if parsed.path in {"/doctor", "/reliability-doctor"}:
            problem = (query.get("problem") or ["Agent needs reliability diagnosis."])[0]
            service_type = (query.get("type") or query.get("service_type") or [""])[0]
            result = self.agent.agent_reliability_doctor.diagnose(
                problem=problem,
                service_type=service_type,
                source="http_get",
            )
            self._json_response(result)
            return

        if parsed.path == "/guardrails":
            result = guardrail_status(
                action=(query.get("action") or ["manual.check"])[0],
                approval=(query.get("approval") or [""])[0],
                args={
                    "text": (query.get("text") or [""])[0],
                    "url": (query.get("url") or [""])[0],
                },
            )
            self._json_response(result, status=200 if result.get("ok") else 409)
            return

        if parsed.path == "/collaboration":
            self._json_response(collaboration_status())
            return

        if parsed.path == "/roaas/import":
            self._json_response(
                {
                    "ok": False,
                    "error": "post_required",
                    "message": "Use POST /roaas/import with a runtime pattern bundle.",
                },
                status=405,
            )
            return

        if parsed.path == "/mutual-aid":
            self._json_response(self.agent.mutual_aid.status())
            return

        if parsed.path == "/mutual-aid/ledger":
            self._json_response(
                self.agent.mutual_aid.list_truth_ledger(
                    pain_type=(query.get("pain_type") or query.get("type") or [""])[0],
                    limit=int((query.get("limit") or ["25"])[0] or 25),
                )
            )
            return

        if parsed.path == "/mutual-aid/inbox":
            statuses = [
                item.strip()
                for raw in (query.get("status") or [])
                for item in raw.split(",")
                if item.strip()
            ]
            self._json_response(
                self.agent.mutual_aid.list_swarm_inbox(
                    statuses=statuses,
                    limit=int((query.get("limit") or ["25"])[0] or 25),
                )
            )
            return

        if parsed.path == "/mutual-aid/signals":
            self._json_response(
                self.agent.mutual_aid.list_swarm_development_signals(
                    pain_type=(query.get("pain_type") or query.get("type") or [""])[0],
                    limit=int((query.get("limit") or ["25"])[0] or 25),
                )
            )
            return

        if parsed.path == "/agent-engagements":
            roles = [
                item.strip()
                for raw in (query.get("role") or query.get("roles") or [])
                for item in raw.split(",")
                if item.strip()
            ]
            self._json_response(
                self.agent.agent_engagements.list_engagements(
                    roles=roles,
                    pain_type=(query.get("pain_type") or query.get("type") or [""])[0],
                    limit=int((query.get("limit") or ["25"])[0] or 25),
                )
            )
            return

        if parsed.path == "/agent-engagements/summary":
            self._json_response(
                self.agent.agent_engagements.summary(
                    pain_type=(query.get("pain_type") or query.get("type") or [""])[0],
                    limit=int((query.get("limit") or ["5"])[0] or 5),
                )
            )
            return

        if parsed.path == "/mutual-aid/patterns":
            self._json_response(
                self.agent.mutual_aid.list_high_value_patterns(
                    pain_type=(query.get("pain_type") or query.get("type") or [""])[0],
                    limit=int((query.get("limit") or ["10"])[0] or 10),
                    min_repeat_count=int((query.get("min_repeat_count") or ["2"])[0] or 2),
                )
            )
            return

        if parsed.path == "/mutual-aid/packs":
            self._json_response(
                self.agent.mutual_aid.list_paid_packs(
                    pain_type=(query.get("pain_type") or query.get("type") or [""])[0],
                    limit=int((query.get("limit") or ["25"])[0] or 25),
                )
            )
            return

        self._json_response(
            merge_machine_error(
                {
                    "ok": False,
                    "error": "not_found",
                    "available_paths": [
                    "/",
                    "/nomad.html",
                    "/work-exchange",
                    "/downloads/nomad_transition_worker.py",
                    "/downloads/nomad_work_exchange_worker.py",
                    "/downloads/nomad_transition_worker.exe",
                    "/downloads/nomad_transition_worker_manifest.json",
                    "/downloads/install_nomad_work_exchange_worker.bat",
                    "/downloads/install_nomad_transition_worker.bat",
                    "/downloads/run_nomad_transition_worker.bat",
                    "/downloads/start_nomad_edge_worker.ps1",
                    "/downloads/start_nomad_edge_worker.bat",
                    "/downloads/start_nomad_agp_pair.ps1",
                    "/downloads/start_nomad_agp_pair.bat",
                    "/downloads/start_nomad_codex_agp_pair.bat",
                    "/downloads/build_nomad_transition_worker_exe.ps1",
                    "/downloads/run_nomad_transition_worker_exe.bat",
                    "/downloads/README_NOMAD_TRANSITION_WORKER.md",
                    "/downloads/swarm-light.exe",
                    "/downloads/syndiode-pin-light-control.exe",
                    "/downloads/README_SYNDIODE_PIN_WINDOWS.md",
                    "/downloads/nomad_openclaw_adapter.py",
                    "/downloads/nomad_universal_adapter.py",
                    "/downloads/check_nomad_swarm_readiness.py",
                    "/downloads/nomad_helper_agent.py",
                    "/downloads/run_nomad_helper_agent.bat",
                    "/downloads/README_NOMAD_HELPER_AGENT.md",
                    "/health",
                    "/openapi.json",
                    "/.well-known/openapi.json",
                    "/mission",
                    "/mission-control",
                    "/next-step",
                    "/growth",
                    "/operator-desk",
                    "/operator/desk",
                    "/operator-sprint",
                    "/operator/sprint",
                    "/operator-verify",
                    "/operator/verify",
                    "/operator-metrics",
                    "/operator/metrics",
                    "/operator-daily",
                    "/operator/daily",
                    "/operator-report",
                    "/operator/report",
                    "/reputation",
                    "/agent-reputation",
                    "/unhuman-hub",
                    "/hub/unhuman",
                    "/machine-economy",
                    "/economy/machine",
                    "/machine-treasury",
                    "/machine-treasury/pledge",
                    "/machine-field",
                    "/.well-known/nomad-machine-field.json",
                    "/machine-field/intent",
                    "/agent-requests",
                    "/swarm/demand",
                    "/.well-known/nomad-agent-requests.json",
                    "/swarm/subscribe",
                    "/swarm/subscriptions",
                    "/nonhuman-science",
                    "/science/nonhuman-agents",
                    "/.well-known/nomad-nonhuman-agent-science.json",
                    "/operational-release",
                    "/release/operational",
                    "/.well-known/nomad-operational-release.json",
                    "/agent-product",
                    "/machine-product",
                    "/.well-known/nomad-machine-product.json",
                    "/protocol-bytecode",
                    "/.well-known/nomad-protocol-bytecode.json",
                    "/swarm/counterfactual-replay",
                    "/.well-known/nomad-counterfactual-replay.json",
                    "/swarm/variant-forge",
                    "/.well-known/nomad-variant-forge.json",
                    "/swarm/worker-market",
                    "/.well-known/nomad-worker-market.json",
                    "/swarm/compute-market",
                    "/.well-known/nomad-compute-market.json",
                    "/swarm/hyperliquid-svw-agents",
                    "/.well-known/nomad-hyperliquid-svw-agents.json",
                    "/swarm/agent-work",
                    "/.well-known/nomad-agent-work.json",
                    "/swarm/work-mesh",
                    "/.well-known/nomad-work-mesh.json",
                    "/swarm/synergy-lite",
                    "/.well-known/nomad-synergy-lite.json",
                    "/swarm/state-status",
                    "/.well-known/nomad-state-status.json",
                    "/swarm/carrying-market",
                    "/.well-known/nomad-carrying-market.json",
                    "/swarm/survival-market",
                    "/.well-known/nomad-survival-market.json",
                    "/swarm/paid-ref-market",
                    "/.well-known/nomad-paid-ref-market.json",
                    "/swarm/paid-ref-selfplay",
                    "/.well-known/nomad-paid-ref-selfplay.json",
                    "/swarm/bounty-hunter",
                    "/.well-known/nomad-bounty-hunter.json",
                    "/swarm/buyer-funded-work",
                    "/.well-known/nomad-buyer-funded-work.json",
                    "/swarm/sales-department",
                    "/.well-known/nomad-sales-department.json",
                    "/swarm/sales-department/events",
                    "/swarm/first-sales",
                    "/.well-known/nomad-first-sales.json",
                    "/swarm/first-receipt-ignition",
                    "/.well-known/nomad-first-receipt-ignition.json",
                    "/swarm/first-receipt-ignition/events",
                    "/swarm/first-receipt-campaign",
                    "/.well-known/nomad-first-receipt-campaign.json",
                    "/swarm/first-receipt-campaign/events",
                    "/swarm/crn-dispatch",
                    "/.well-known/nomad-crn-dispatch.json",
                    "/swarm/flywheel-health",
                    "/swarm/health-dashboard",
                    "/.well-known/nomad-flywheel-health.json",
                    "/swarm/machine-native-collaboration",
                    "/.well-known/nomad-machine-native-collaboration.json",
                    "/swarm/rescue-cycle-scheduler",
                    "/.well-known/nomad-rescue-cycle-scheduler.json",
                    "/swarm/rescue-packet-lattice",
                    "/.well-known/nomad-rescue-packet-lattice.json",
                    "/swarm/rescue-packet-candidates",
                    "/swarm/server-failure-guard",
                    "/.well-known/nomad-server-failure-guard.json",
                    "/swarm/server-failure/events",
                    "/swarm/acquisition/ignite",
                    "/.well-known/nomad-acquisition-ignition.json",
                    "/swarm/external-value",
                    "/.well-known/nomad-external-value.json",
                    "/swarm/gemini-verifier",
                    "/swarm/gemini-verifier/verify",
                    "/.well-known/nomad-gemini-verifier.json",
                    "/swarm/google-agentic-era",
                    "/.well-known/nomad-google-agentic-era.json",
                    "/swarm/signals",
                    "/swarm/signal-layer",
                    "/.well-known/nomad-signal-layer.json",
                    "/swarm/emission-batch",
                    "/swarm/value-pressure",
                    "/.well-known/nomad-value-pressure.json",
                    "/swarm/optimal-transport",
                    "/.well-known/nomad-optimal-transport.json",
                    "/swarm/optimal-transport/paper-readiness",
                    "/.well-known/nomad-ot-paper-readiness.json",
                    "/swarm/optimal-transport/manifold",
                    "/.well-known/nomad-ot-manifold.json",
                    "/swarm/optimal-transport/conformance",
                    "/.well-known/nomad-ot-conformance.json",
                    "/swarm/optimal-transport/metric-learning",
                    "/.well-known/nomad-ot-metric-learning.json",
                    "/swarm/optimal-transport/solve",
                    "/swarm/optimal-transport/outcomes",
                    "/swarm/agent-job-router",
                    "/.well-known/nomad-agent-jobs.json",
                    "/swarm/revenue-science",
                    "/science/revenue-agents",
                    "/.well-known/nomad-revenue-science.json",
                    "/swarm/revenue-invariant",
                    "/.well-known/nomad-revenue-invariant.json",
                    "/swarm/channel-bandit",
                    "/.well-known/nomad-channel-bandit.json",
                    "/swarm/shadow-lane",
                    "/.well-known/nomad-shadow-lane.json",
                    "/swarm/shadow-lane/candidates",
                    "/swarm/decoupling-field",
                    "/.well-known/nomad-decoupling-field.json",
                    "/swarm/decoupling-field/merge",
                    "/swarm/anti-consensus",
                    "/.well-known/nomad-anti-consensus.json",
                    "/swarm/anti-consensus/candidates",
                    "/swarm/entropy-judger",
                    "/.well-known/nomad-entropy-judger.json",
                    "/swarm/entropy-judger/evaluate",
                    "/swarm/latent-consensus",
                    "/.well-known/nomad-latent-consensus.json",
                    "/swarm/latent-consensus/evaluate",
                    "/swarm/resource-substrate",
                    "/.well-known/nomad-resource-substrate.json",
                    "/swarm/resource-substrate/register",
                    "/swarm/resource-substrate/retrieve",
                    "/swarm/resource-substrate/version",
                    "/swarm/autogenesis",
                    "/.well-known/nomad-autogenesis.json",
                    "/swarm/autogenesis/shadow-harvest",
                    "/.well-known/nomad-autogenesis-shadow-harvest.json",
                    "/.well-known/nomad-agp-conformance.json",
                    "/.well-known/nomad-agp-agent-bus.json",
                    "/swarm/agp/agent-bus/messages",
                    "/swarm/agp/plans",
                    "/swarm/agp/orchestrations",
                    "/.well-known/nomad-agp-model-manager.json",
                    "/swarm/agp/model-bindings",
                    "/swarm/agp/configs",
                    "/.well-known/nomad-agp-prompt-manager.json",
                    "/swarm/agp/prompts",
                    "/.well-known/nomad-agp-version-manager.json",
                    "/swarm/agp/version-lineage",
                    "/.well-known/nomad-agp-procurement.json",
                    "/swarm/agp/procurement-intents",
                    "/.well-known/nomad-agp-context-manager.json",
                    "/swarm/agp/context",
                    "/.well-known/nomad-agp-optimizer.json",
                    "/swarm/agp/optimizer-steps",
                    "/.well-known/nomad-agp-evaluation.json",
                    "/swarm/agp/evaluations",
                    "/.well-known/nomad-agp-benchmark-suite.json",
                    "/swarm/agp/benchmark-suites",
                    "/.well-known/nomad-agp-empirical.json",
                    "/swarm/agp/empirical-runs",
                    "/.well-known/nomad-agp-paper-benchmarks.json",
                    "/swarm/agp/paper-benchmark-runs",
                    "/.well-known/nomad-agp-durable-ledger.json",
                    "/swarm/agp/durable-ledger",
                    "/.well-known/nomad-agp-paper-report.json",
                    "/swarm/agp/paper-report",
                    "/.well-known/nomad-agp-pulse.json",
                    "/swarm/agp/pulse",
                    "/.well-known/nomad-autogenesis-morphology-reactor.json",
                    "/swarm/autogenesis/morphology-reactor",
                    "/.well-known/nomad-agp-morphology-runtime-register.json",
                    "/swarm/autogenesis/morphology-runtime-register",
                    "/.well-known/nomad-telegram-a2a.json",
                    "/.well-known/nomad-sales-funnel.json",
                    "/swarm/sales-funnel",
                    "/swarm/telegram-a2a/messages",
                    "/swarm/autogenesis/traces",
                    "/swarm/autogenesis/cycle",
                    "/swarm/autogenesis/run",
                    "/swarm/autonomous-evolution",
                    "/.well-known/nomad-autonomous-evolution.json",
                    "/swarm/universal-adapter",
                    "/.well-known/nomad-universal-adapter.json",
                    "/swarm/autogenesis/watchdog",
                    "/.well-known/nomad-autonomous-agp.json",
                    "/.well-known/nomad-agp-watchdog.json",
                    "/swarm/autogenesis-recruit",
                    "/.well-known/nomad-autogenesis-recruit.json",
                    "/swarm/shadow-lane/candidates?type=autogenesis",
                    "/swarm/deficit-integration",
                    "/.well-known/nomad-deficit-integration.json",
                    "/swarm/deficit-integration/events",
                    "/swarm/effective-channels",
                    "/.well-known/nomad-effective-channels.json",
                    "/swarm/effective-channels/events",
                    "/swarm/nonhuman-runtime-governor",
                    "/.well-known/nomad-nonhuman-runtime-governor.json",
                    "/swarm/nonhuman-runtime-governor/events",
                    "/swarm/worker-invoice",
                    "/.well-known/nomad-worker-invoice.json",
                    "/swarm/work-receipts",
                    "/.well-known/nomad-work-receipts.json",
                    "/swarm/treasury-policy",
                    "/.well-known/nomad-treasury-policy.json",
                    "/swarm/revenue-settlement",
                    "/.well-known/nomad-revenue-settlement.json",
                    "/swarm/agent-utility",
                    "/.well-known/nomad-agent-utility.json",
                    "/swarm/agent-utility/intake",
                    "/swarm/agent-utility/receipts",
                    "/swarm/stable-unit-policy",
                    "/.well-known/nomad-stable-unit-policy.json",
                    "/swarm/stable-unit/preflight",
                    "/swarm/operator-runway",
                    "/.well-known/nomad-operator-runway.json",
                    "/swarm/viability-kernel",
                    "/.well-known/nomad-viability-kernel.json",
                    "/swarm/viability-kernel/route",
                    "/swarm/worker-job-queue",
                    "/.well-known/nomad-worker-job-queue.json",
                    "/swarm/value-cycle-preflight",
                    "/.well-known/nomad-value-cycle-preflight.json",
                    "/swarm/value-cycles",
                    "/.well-known/nomad-value-cycles.json",
                    "/swarm/value-cycles/events",
                    "/swarm/receipt-predictor",
                    "/.well-known/nomad-receipt-predictor.json",
                    "/swarm/receipt-predictor/events",
                    "/swarm/bottleneck-resolver",
                    "/.well-known/nomad-bottleneck-resolver.json",
                    "/swarm/bottleneck-resolver/events",
                    "/swarm/ad-cycles",
                    "/.well-known/nomad-ad-cycles.json",
                    "/swarm/ad-cycles/events",
                    "/swarm/development-cycles",
                    "/.well-known/nomad-development-cycles.json",
                    "/swarm/development-cycles/events",
                    "/swarm/topology-governor",
                    "/.well-known/nomad-topology-governor.json",
                    "/swarm/topology-governor/events",
                    "/swarm/worker-catalog",
                    "/.well-known/nomad-worker-catalog.json",
                    "/swarm/microtask-templates",
                    "/.well-known/nomad-microtask-templates.json",
                    "/swarm/microtask-metrics",
                    "/.well-known/nomad-microtask-metrics.json",
                    "/swarm/ecology",
                    "/.well-known/nomad-swarm-ecology.json",
                    "/swarm/growth-arena",
                    "/.well-known/nomad-growth-arena.json",
                    "/swarm/curriculum",
                    "/.well-known/nomad-growth-curriculum.json",
                    "/swarm/experience",
                    "/swarm/skill-library",
                    "/.well-known/nomad-skill-library.json",
                    "/swarm/weekly-selection",
                    "/.well-known/nomad-weekly-selection.json",
                    "/swarm/spawner-gate",
                    "/.well-known/nomad-spawner-gate.json",
                    "/swarm/spawner/trigger",
                    "/swarm/capacity-switch",
                    "/.well-known/nomad-capacity-switch.json",
                    "/idle-runtime",
                    "/.well-known/nomad-idle-runtime.json",
                    "/opaque-emergence",
                    "/swarm/opaque-emergence",
                    "/.well-known/nomad-opaque-emergence.json",
                    "/swarm/opaque-candidate",
                    "/swarm/tool-gap",
                    "/swarm/topology-plan",
                    "/runtime-capsule",
                    "/.well-known/nomad-runtime-capsule.json",
                    "/handoff-capsule",
                    "/.well-known/nomad-handoff-capsule.json",
                    "/openclaw-bridge",
                    "/.well-known/openclaw-nomad-bridge.json",
                    "/runtime/handoff",
                    "/swarm/gradient",
                    "/.well-known/nomad-gradient.json",
                    "/swarm/hello",
                    "/.well-known/nomad-ai.json",
                    "/swarm/attach-get",
                    "/swarm/workers/lease-get",
                    "/swarm/workers/complete-get",
                    "/swarm/experience-get",
                    "/swarm/attach",
                    "/swarm/attractor",
                    "/.well-known/nomad-swarm-attractor.json",
                    "/agent-growth",
                    "/growth-pipeline",
                    "/growth-start",
                    "/operator/growth-start",
                    "/agent",
                    "/service",
                    "/service/e2e",
                    "/outbound",
                    "/lead-workbench",
                    "/lead-work",
                    "/jobs",
                    "/agent-attractor",
                    "/swarm",
                    "/swarm/emergence",
                    "/swarm/trace",
                    "/swarm/idle-intent-get",
                    "/swarm/idle-intent",
                    "/swarm/join",
                    "/swarm/nodes",
                    "/swarm/workers",
                    "/swarm/workers/lease",
                    "/swarm/workers/complete",
                    "/swarm/ready",
                    "/swarm/network",
                    "/swarm/coordinate",
                    "/swarm/accumulate",
                    "/swarm/develop",
                    "/swarm/bootstrap",
                    "/transition/quote",
                    "/transition/settle",
                    "/agent-development",
                    "/.well-known/agent-attractor.json",
                    "/.well-known/agent-card.json",
                    "/.well-known/nomad-agent-invariants.json",
                    "/agent-invariants",
                    "/.well-known/nomad-inter-agent-witness-offer.json",
                    "/inter-agent-witness-offer",
                    "/.well-known/nomad-peer-acquisition.json",
                    "/peer-acquisition",
                    "/.well-known/nomad-transition-offer.json",
                    "/transition-offer",
                    "/transition/contracts",
                    "/.well-known/nomad-reciprocity-dividend.json",
                    "/dividend-offer",
                    "/dividend",
                    "/.well-known/nomad-agent-native-priorities.json",
                    "/.well-known/nomad-agent.json",
                    "/.well-known/nomad-recruit.json",
                    "/agent-native-index",
                    "/agent-native",
                    "/a2a/message",
                    "/a2a/get",
                    "/a2a/get/{session_id}/{seq}/{chunk}",
                    "/a2a/get/{session_id}/reply",
                    "/direct/sessions",
                    "/x402/paid-help",
                    "/tasks",
                    "/agent-contacts",
                    "/agent-campaigns",
                    "/agent-engagements",
                    "/agent-engagements/summary",
                    "/best",
                    "/self",
                    "/compute",
                    "/addons",
                    "/quantum",
                    "/cycle",
                    "/unlock",
                    "/scout",
                    "/leads",
                    "/lead-calibrate",
                    "/lead-conversions",
                    "/products",
                    "/agent-pains",
                    "/reliability-doctor",
                    "/guardrails",
                    "/collaboration",
                    "/roaas",
                    "/roaas/export",
                    "/roaas/import",
                    "/artifacts/runtime-patterns",
                    "/.well-known/nomad-runtime-patterns.json",
                    "/mutual-aid",
                    "/mutual-aid/ledger",
                    "/mutual-aid/inbox",
                    "/mutual-aid/signals",
                    "/mutual-aid/patterns",
                    "/mutual-aid/packs",
                ],
            },
                error="not_found",
                message="No GET handler matched this path.",
                hints=["GET /openapi.json for the primary documented HTTP surface.", "GET /health for liveness."],
            ),
            status=404,
        )

    def _reliability_doctor_intake_receipt(self, payload: dict, *, base: str) -> tuple[int, dict]:
        intake = build_reliability_doctor_intake(
            payload,
            base_url=base,
            doctor=self.agent.agent_reliability_doctor,
        )
        if not intake.get("ok"):
            return 422, intake
        try:
            intake_acquisition = record_agent_acquisition_event(
                {
                    "channel_id": "reliability_doctor_intake",
                    "event_type": "intake",
                    "agent_id": intake.get("requester_id") or payload.get("agent_id") or "external.agent",
                    "source_url": f"{base.rstrip('/')}{SWARM_RELIABILITY_DOCTOR_INTAKE_PATH}"
                    if base
                    else SWARM_RELIABILITY_DOCTOR_INTAKE_PATH,
                },
                base_url=base,
            )
        except Exception as exc:  # noqa: BLE001
            intake_acquisition = {"ok": False, "error": "acquisition_event_failed", "message": str(exc)[:160]}
        offer = create_work_exchange_offer(
            intake.get("work_exchange_offer_payload") if isinstance(intake.get("work_exchange_offer_payload"), dict) else {},
            base_url=base,
        )
        free_solution: dict = {"accepted": False, "decision": "not_opened_without_compute_barter_acceptance"}
        if intake.get("accepted_compute_barter_terms"):
            free_solution = record_free_solution_receipt(
                intake.get("free_solution_payload") if isinstance(intake.get("free_solution_payload"), dict) else {},
                base_url=base,
            )
        onboarding = self.__class__._build_work_exchange_onboarding(base_url=base)
        obligation_id = str(free_solution.get("obligation_id") or "")
        start = dict(onboarding.get("copy_paste_start") or {})
        if obligation_id:
            start = {
                key: str(value).replace("OBLIGATION_ID_HERE", obligation_id)
                for key, value in start.items()
            }
        result = {
            **intake,
            "schema": "nomad.agent_reliability_doctor_intake_receipt.v1",
            "work_exchange_offer": offer,
            "free_solution_receipt": free_solution,
            "acquisition_event": intake_acquisition,
            "obligation_id": obligation_id,
            "copy_paste_start": start,
            "downloads": onboarding.get("downloads", {}),
            "routes": {
                **(intake.get("next") if isinstance(intake.get("next"), dict) else {}),
                "work_exchange_balance": f"{base.rstrip('/')}/swarm/work-exchange/balance"
                if base
                else "/swarm/work-exchange/balance",
            },
        }
        status = 202 if offer.get("ok") and (not intake.get("accepted_compute_barter_terms") or free_solution.get("ok")) else 422
        return status, result

    def do_POST(self) -> None:  # noqa: N802
        parsed_full = urlparse(self.path)
        parsed = parsed_full._replace(path=self._normalize_public_path(parsed_full.path or "/"))
        query = parse_qs(parsed_full.query)
        self._agent_request_path = parsed.path
        if self.__class__._commercial_only_mode() and self.__class__._is_hobby_post_path(parsed.path):
            self._hobby_paused_response(parsed.path, method="POST")
            return
        self.__class__._ensure_runtime_components()
        payload = self._read_json_body()
        if payload is None:
            self._json_response(
                machine_error_response(
                    error="invalid_json",
                    message="POST bodies must be JSON objects.",
                    hints=[
                        "Use Content-Type: application/json and a single UTF-8 JSON object.",
                        "For /swarm/develop send agent_id and problem; for /swarm/join send agent_id, capabilities, request.",
                        "GET /openapi.json for route and body contracts.",
                    ],
                ),
                status=400,
            )
            return

        if parsed.path == "/telegram-miniapp/lead":
            result = record_telegram_miniapp_lead(
                payload,
                base_url=self._base_url(),
                remote_addr=self._remote_addr(),
            )
            self._json_response(result, status=202 if result.get("ok") else 400)
            return

        if parsed.path == "/telegram-miniapp/fact-check":
            base = self._base_url()
            fact_payload = normalize_telegram_fact_check_payload(payload, base_url=base)
            status, swarm_receipt = self._reliability_doctor_intake_receipt(fact_payload, base=base)
            preanalysis = (
                swarm_receipt.get("openai_preanalysis")
                if isinstance(swarm_receipt.get("openai_preanalysis"), dict)
                else {}
            )
            diagnosis = swarm_receipt.get("diagnosis") if isinstance(swarm_receipt.get("diagnosis"), dict) else {}
            result = {
                "ok": status < 400 and bool(swarm_receipt.get("ok")),
                "schema": "nomad.telegram_fact_check_receipt.v1",
                "accepted": status < 400,
                "swarm_receipt_schema": "nomad.agent_reliability_doctor_intake_receipt.v1",
                "swarm_handoff_url": f"{base.rstrip('/')}{SWARM_RELIABILITY_DOCTOR_INTAKE_PATH}"
                if base
                else SWARM_RELIABILITY_DOCTOR_INTAKE_PATH,
                "openai_preanalysis": preanalysis,
                "display_result": {
                    "headline": "OpenAI quick scan plus Nomad Swarm handoff accepted"
                    if status < 400
                    else "Fact-check intake needs one concrete claim",
                    "provisional_verdict": preanalysis.get("provisional_verdict") or "unclear",
                    "confidence": preanalysis.get("confidence") or "",
                    "summary": preanalysis.get("summary") or diagnosis.get("analysis") or swarm_receipt.get("message", ""),
                    "proof_digest": swarm_receipt.get("solution_proof_digest", ""),
                    "obligation_id": swarm_receipt.get("obligation_id", ""),
                    "worker_free_message": WORKER_FREE_MESSAGE,
                },
                "work_exchange": {
                    "auto_accepted": True,
                    "mode": "compute_barter",
                    "return_multiplier": 1.3,
                    "counts_as_revenue": False,
                    "offer": swarm_receipt.get("work_exchange_offer", {}),
                    "free_solution_receipt": swarm_receipt.get("free_solution_receipt", {}),
                    "copy_paste_start": swarm_receipt.get("copy_paste_start", {}),
                },
                "downloads": swarm_receipt.get("downloads", {}),
                "swarm_intake_receipt": swarm_receipt,
            }
            self._json_response(result, status=status)
            return

        if parsed.path in {"/agent-growth", "/growth-pipeline"}:
            result = agent_growth_pipeline(
                agent=self.agent,
                query=str(payload.get("query") or payload.get("q") or ""),
                limit=int(payload.get("limit") or 5),
                base_url=str(payload.get("base_url") or payload.get("base") or "").strip(),
                run_product_factory=not bool(payload.get("no_products") or payload.get("skip_products")),
                send_outreach=bool(payload.get("send") or payload.get("send_outreach")),
                approval=str(payload.get("approval") or "").strip(),
                swarm_feed=None
                if str(payload.get("swarm_feed", "")).strip().lower() in {"0", "false", "no", "off"}
                else (True if str(payload.get("swarm_feed", "")).strip().lower() in {"1", "true", "yes", "on"} else None),
            )
            self._json_response(result, status=200 if result.get("ok") else 500)
            return

        if parsed.path == "/tasks":
            result = self.agent.service_desk.create_task(
                problem=payload.get("problem", ""),
                requester_agent=payload.get("requester_agent", ""),
                requester_wallet=payload.get("requester_wallet", ""),
                service_type=payload.get("service_type", "custom"),
                budget_native=payload.get("budget_native"),
                callback_url=payload.get("callback_url", ""),
                metadata=payload.get("metadata") or {},
            )
            self._json_response(result, status=201 if result.get("ok") else 400)
            return

        if parsed.path == "/service/e2e":
            result = self.agent.service_desk.end_to_end_runway(
                task_id=payload.get("task_id", ""),
                problem=payload.get("problem", ""),
                service_type=payload.get("service_type") or payload.get("type") or "",
                package_id=payload.get("package_id") or payload.get("package") or "",
                budget_native=payload.get("budget_native", payload.get("budget")),
                requester_agent=payload.get("requester_agent") or payload.get("agent") or "",
                requester_wallet=payload.get("requester_wallet") or payload.get("wallet") or "",
                callback_url=payload.get("callback_url") or payload.get("callback") or "",
                metadata=payload.get("metadata") if isinstance(payload.get("metadata"), dict) else None,
                create_task=bool(payload.get("create", False)),
                approval=payload.get("approval", "draft_only"),
            )
            status = 201 if result.get("created") else 200 if result.get("ok", True) else 400
            self._json_response(result, status=status)
            return

        if parsed.path in {"/a2a/message", "/direct/message"}:
            result = self.agent.direct_agent.handle_direct_message(payload)
            jsonrpc = self._jsonrpc_envelope(payload, result)
            self._json_response(
                jsonrpc if self._is_jsonrpc_request(payload) else result,
                status=200 if result.get("ok") else 400,
            )
            return

        if parsed.path == "/a2a/discover":
            result = self.agent.direct_agent.discover_agent_card(
                base_url=payload.get("base_url", ""),
            )
            self._json_response(result, status=200 if result.get("ok") else 404)
            return

        if parsed.path == "/swarm/telegram-a2a/messages":
            result = route_telegram_bot_to_bot_message(
                payload,
                base_url=self._base_url(),
                request_secret=self.headers.get("X-Nomad-Telegram-A2A-Secret") or payload.get("send_secret"),
            )
            self._json_response(result, status=202 if result.get("accepted") else 200 if result.get("ok") else 400)
            return

        if parsed.path == "/quantum":
            result = self.agent.addons.run_quantum_self_improvement(
                objective=payload.get("objective", ""),
                context=payload.get("context") or {"source": "http_post"},
            )
            self._json_response(result, status=200 if result.get("ok") else 400)
            return

        if parsed.path == "/x402/paid-help":
            payment_signature = (
                self.headers.get("PAYMENT-SIGNATURE")
                or self.headers.get("X-PAYMENT")
                or payload.get("payment_signature", "")
            )
            if payment_signature:
                task_id = payload.get("task_id") or ((payload.get("task") or {}).get("task_id") if isinstance(payload.get("task"), dict) else "")
                if not task_id:
                    self._json_response(
                        {
                            "ok": False,
                            "error": "task_id_required_for_x402_retry",
                            "message": "Retry with PAYMENT-SIGNATURE and the task_id returned in the 402 response.",
                        },
                        status=400,
                    )
                    return
                verification = self.agent.service_desk.verify_x402_payment(
                    task_id=task_id,
                    payment_signature=payment_signature,
                    requester_wallet=payload.get("requester_wallet", ""),
                )
                if verification.get("ok") and ((verification.get("task") or {}).get("status") == "paid"):
                    worked = self.agent.service_desk.work_task(task_id)
                    self._json_response(
                        {
                            "ok": True,
                            "mode": "x402_paid_help",
                            "payment": verification,
                            "work": worked,
                        },
                        status=200,
                        headers={
                            "PAYMENT-RESPONSE": self.agent.service_desk.x402.payment_response_header(
                                (((verification.get("task") or {}).get("payment") or {}).get("x402") or {}).get("verification") or {}
                            ),
                        },
                    )
                    return
                self._json_response(verification, status=402)
                return

            result = self.agent.direct_agent.handle_direct_message(payload)
            if result.get("ok"):
                payment_required = result.get("payment_required") or {}
                response_payload = (
                    self._jsonrpc_envelope(payload, result)
                    if self._is_jsonrpc_request(payload)
                    else result
                )
                self._json_response(
                    response_payload,
                    status=402,
                    headers={
                        "PAYMENT-REQUIRED": payment_required.get("encoded_header")
                        or self.agent.service_desk.x402.encode_header(payment_required),
                    },
                )
            else:
                self._json_response(result, status=400)
            return

        if parsed.path == "/tasks/verify":
            result = self.agent.service_desk.verify_payment(
                task_id=payload.get("task_id", ""),
                tx_hash=payload.get("tx_hash", ""),
                requester_wallet=payload.get("requester_wallet", ""),
            )
            self._json_response(result, status=200 if result.get("ok") else 404)
            return

        if parsed.path == "/tasks/x402-verify":
            payment_signature = (
                self.headers.get("PAYMENT-SIGNATURE")
                or self.headers.get("X-PAYMENT")
                or payload.get("payment_signature", "")
            )
            result = self.agent.service_desk.verify_x402_payment(
                task_id=payload.get("task_id", ""),
                payment_signature=payment_signature,
                requester_wallet=payload.get("requester_wallet", ""),
            )
            status = 200 if result.get("ok") and ((result.get("task") or {}).get("status") == "paid") else 402
            headers = {}
            x402_verification = (((result.get("task") or {}).get("payment") or {}).get("x402") or {}).get("verification") or {}
            if x402_verification:
                headers["PAYMENT-RESPONSE"] = self.agent.service_desk.x402.payment_response_header(x402_verification)
            self._json_response(result, status=status, headers=headers)
            return

        if parsed.path == "/tasks/work":
            result = self.agent.service_desk.work_task(
                task_id=payload.get("task_id", ""),
                approval=payload.get("approval", "draft_only"),
            )
            self._json_response(result, status=200 if result.get("ok") else 404)
            return

        if parsed.path == "/tasks/staking":
            result = self.agent.service_desk.metamask_staking_checklist(
                task_id=payload.get("task_id", ""),
            )
            self._json_response(result, status=200 if result.get("ok") else 404)
            return

        if parsed.path == "/tasks/stake":
            result = self.agent.service_desk.record_treasury_stake(
                task_id=payload.get("task_id", ""),
                tx_hash=payload.get("tx_hash", ""),
                amount_native=payload.get("amount_native"),
                note=payload.get("note", ""),
            )
            self._json_response(result, status=200 if result.get("ok") else 404)
            return

        if parsed.path == "/tasks/spend":
            result = self.agent.service_desk.record_solver_spend(
                task_id=payload.get("task_id", ""),
                amount_native=float(payload.get("amount_native") or 0.0),
                note=payload.get("note", ""),
                tx_hash=payload.get("tx_hash", ""),
            )
            self._json_response(result, status=200 if result.get("ok") else 404)
            return

        if parsed.path == "/tasks/close":
            result = self.agent.service_desk.close_task(
                task_id=payload.get("task_id", ""),
                outcome=payload.get("outcome", ""),
            )
            self._json_response(result, status=200 if result.get("ok") else 404)
            return

        if parsed.path == "/agent-contacts":
            result = self.agent.agent_contacts.queue_contact(
                endpoint_url=payload.get("endpoint_url", ""),
                problem=payload.get("problem", ""),
                service_type=payload.get("service_type", "human_in_loop"),
                lead=payload.get("lead") or {},
                budget_hint_native=payload.get("budget_hint_native"),
            )
            self._json_response(result, status=201 if result.get("ok") else 400)
            return

        if parsed.path == "/agent-contacts/send":
            result = self.agent.agent_contacts.send_contact(
                contact_id=payload.get("contact_id", ""),
            )
            self._json_response(result, status=200 if result.get("ok") else 404)
            return

        if parsed.path == "/agent-campaigns":
            targets = payload.get("targets") or []
            if payload.get("discover") or not targets:
                result = self.agent.agent_campaigns.create_campaign_from_discovery(
                    limit=payload.get("limit"),
                    query=payload.get("query") or payload.get("discovery_query") or "",
                    seeds=payload.get("seeds") or targets,
                    send=bool(payload.get("send", False)),
                    service_type=payload.get("service_type", "human_in_loop"),
                    budget_hint_native=payload.get("budget_hint_native"),
                )
            else:
                result = self.agent.agent_campaigns.create_campaign(
                    targets=targets,
                    limit=payload.get("limit"),
                    send=bool(payload.get("send", False)),
                    service_type=payload.get("service_type", "human_in_loop"),
                    budget_hint_native=payload.get("budget_hint_native"),
                )
            self._json_response(result, status=201 if result.get("ok") else 400)
            return

        if parsed.path in {"/lead-calibrate", "/leads-calibrate"}:
            result = self.agent.lead_discovery.calibrate_focus_scout(
                focus=str(payload.get("focus") or "").strip(),
                query=str(payload.get("query") or payload.get("q") or "").strip(),
                limit=max(3, min(int(payload.get("limit") or 12), 25)),
                candidate_multiplier=max(
                    3,
                    min(int(payload.get("candidate_multiplier") or payload.get("pool") or 5), 10),
                ),
            )
            self._json_response(result)
            return

        if parsed.path == "/leads":
            result = self.agent.lead_discovery.scout_public_leads(
                query=payload.get("query", "") or payload.get("q", ""),
                limit=max(1, min(int(payload.get("limit") or 5), 25)),
                focus=str(payload.get("focus") or "").strip(),
            )
            self._json_response(result)
            return

        if parsed.path == "/lead-conversions":
            if payload.get("list"):
                result = self.agent.lead_conversion.list_conversions(
                    statuses=payload.get("statuses") or payload.get("status") or [],
                    limit=int(payload.get("limit") or 25),
                )
            else:
                result = self.agent.lead_conversion.run(
                    query=payload.get("query", ""),
                    limit=int(payload.get("limit") or 5),
                    send=bool(payload.get("send", False)),
                    budget_hint_native=payload.get("budget_hint_native") or payload.get("budget_native"),
                    leads=payload.get("leads") if isinstance(payload.get("leads"), list) else None,
                )
            self._json_response(result, status=200 if result.get("ok", True) else 400)
            return

        if parsed.path == "/products":
            if payload.get("list"):
                result = self.agent.product_factory.list_products(
                    statuses=payload.get("statuses") or payload.get("status") or [],
                    limit=int(payload.get("limit") or 25),
                )
            else:
                result = self.agent.product_factory.run(
                    query=payload.get("query", ""),
                    limit=int(payload.get("limit") or 5),
                    leads=payload.get("leads") if isinstance(payload.get("leads"), list) else None,
                    conversions=payload.get("conversions") if isinstance(payload.get("conversions"), list) else None,
                )
            self._json_response(result, status=200 if result.get("ok", True) else 400)
            return

        if parsed.path == "/agent-pains":
            problem = payload.get("problem") or payload.get("message") or ""
            if problem:
                result = self.agent.agent_pain_solver.solve(
                    problem=problem,
                    service_type=payload.get("service_type") or payload.get("type") or "",
                    source="http_post",
                )
            else:
                result = self.agent.run("/agent-pains")
            self._json_response(result, status=200 if result.get("ok", True) else 400)
            return

        if parsed.path in {"/doctor", "/reliability-doctor"}:
            result = self.agent.agent_reliability_doctor.diagnose(
                problem=payload.get("problem") or payload.get("message") or "Agent needs reliability diagnosis.",
                service_type=payload.get("service_type") or payload.get("type") or "",
                source="http_post",
                evidence=payload.get("evidence") if isinstance(payload.get("evidence"), list) else None,
            )
            self._json_response(result, status=200 if result.get("ok", True) else 400)
            return

        if parsed.path == "/swarm/agent-utility/intake":
            result = evaluate_agent_utility_intake(payload, base_url=self._base_url())
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/reliability-doctor/intake":
            base = self._base_url()
            status, result = self._reliability_doctor_intake_receipt(payload, base=base)
            wants_paid_task = self._truthy(
                payload.get("create_paid_task", payload.get("create_task")),
                default=False,
            )
            can_create_paid_task = (
                status < 400
                and result.get("service_type") == "proof_gated_bot_factory"
                and wants_paid_task
                and getattr(getattr(self, "agent", None), "service_desk", None) is not None
            )
            if can_create_paid_task:
                conversion = result.get("paid_conversion") if isinstance(result.get("paid_conversion"), dict) else {}
                conversion_payload = conversion.get("payload") if isinstance(conversion.get("payload"), dict) else {}
                metadata = conversion_payload.get("metadata") if isinstance(conversion_payload.get("metadata"), dict) else {}
                paid_task = self.agent.service_desk.end_to_end_runway(
                    problem=conversion_payload.get("problem") or result.get("problem") or payload.get("problem") or payload.get("claim") or "",
                    service_type=conversion_payload.get("service_type") or "proof_gated_bot_factory",
                    package_id=conversion_payload.get("package_id") or "bounded_bot_factory_pack",
                    budget_native=payload.get("budget_native", conversion_payload.get("budget_native")),
                    requester_agent=conversion_payload.get("requester_agent") or payload.get("requester_agent") or "",
                    requester_wallet=payload.get("requester_wallet") or payload.get("wallet") or "",
                    callback_url=payload.get("callback_url") or payload.get("callback") or "",
                    metadata={
                        **metadata,
                        "source": metadata.get("source") or "reliability_doctor_bot_factory_intake",
                    },
                    create_task=True,
                    approval=payload.get("approval", "draft_only"),
                )
                result["payable_task"] = paid_task
                result["next_payment_action"] = paid_task.get("next_best_action", "")
                if isinstance(result.get("paid_conversion"), dict):
                    result["paid_conversion"]["status"] = (
                        "payable_task_created" if paid_task.get("created") else "payable_task_not_created"
                    )
                    result["paid_conversion"]["counts_as_revenue"] = False
                status = 201 if paid_task.get("created") else status
            self._json_response(result, status=status)
            return

        if parsed.path == "/swarm/universal-adapter/events":
            base = self._base_url()
            result = evaluate_universal_adapter_event(payload, base_url=base)
            if result.get("accepted"):
                try:
                    acquisition_payload = build_universal_adapter_acquisition_event(result, base_url=base)
                    result["acquisition_event"] = (
                        record_agent_acquisition_event(acquisition_payload, base_url=base)
                        if acquisition_payload
                        else {"ok": False, "error": "missing_adapter_acquisition_payload"}
                    )
                except Exception as exc:  # noqa: BLE001
                    result["acquisition_event"] = {
                        "ok": False,
                        "error": "adapter_acquisition_event_failed",
                        "message": str(exc)[:160],
                    }
            status = 202 if result.get("accepted") else int(result.get("status_hint") or 422)
            self._json_response(result, status=status)
            return

        if parsed.path == "/swarm/agent-acquisition/events":
            result = record_agent_acquisition_event(payload, base_url=self._base_url())
            self._json_response(result, status=202 if result.get("ok") else 422)
            return

        if parsed.path == "/swarm/first-receipt-ignition/events":
            base = self._base_url()
            surface = self.__class__._build_first_receipt_ignition(base_url=base)
            result = evaluate_first_receipt_ignition_event(payload, base_url=base, ignition_surface=surface)
            acquisition_payload = result.get("agent_acquisition_payload") if isinstance(result.get("agent_acquisition_payload"), dict) else {}
            if result.get("accepted") and acquisition_payload:
                try:
                    result["acquisition_event"] = record_agent_acquisition_event(acquisition_payload, base_url=base)
                except Exception as exc:  # noqa: BLE001
                    result["acquisition_event"] = {
                        "ok": False,
                        "error": "first_receipt_acquisition_event_failed",
                        "message": str(exc)[:160],
                    }
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/first-receipt-campaign/events":
            base = self._base_url()
            surface = self.__class__._build_first_receipt_campaign(base_url=base)
            result = evaluate_first_receipt_campaign_event(payload, base_url=base, campaign_surface=surface)
            acquisition_payload = result.get("agent_acquisition_payload") if isinstance(result.get("agent_acquisition_payload"), dict) else {}
            if result.get("accepted") and acquisition_payload:
                try:
                    result["acquisition_event"] = record_agent_acquisition_event(acquisition_payload, base_url=base)
                except Exception as exc:  # noqa: BLE001
                    result["acquisition_event"] = {
                        "ok": False,
                        "error": "first_receipt_campaign_acquisition_event_failed",
                        "message": str(exc)[:160],
                    }
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/rescue-packet-candidates":
            result = append_rescue_packet_candidate(payload, base_url=self._base_url())
            self._json_response(result, status=202 if result.get("ok") else 422)
            return

        if parsed.path == "/guardrails":
            result = guardrail_status(
                action=payload.get("action") or "manual.check",
                approval=payload.get("approval") or "",
                args=payload.get("args") if isinstance(payload.get("args"), dict) else {
                    "text": payload.get("text") or payload.get("message") or "",
                    "url": payload.get("url") or "",
                },
            )
            self._json_response(result, status=200 if result.get("ok") else 409)
            return

        if parsed.path == "/collaboration":
            self._json_response(collaboration_status())
            return

        if parsed.path == "/swarm/attach":
            consent = self.__class__._validate_adapter_consent(payload, path=parsed.path)
            if consent.get("checked") and not consent.get("ok"):
                self._json_response(
                    machine_error_response(
                        error="adapter_consent_invalid",
                        message="Missing or invalid adapter consent token.",
                        hints=[str(consent.get("reason") or "consent_failed")],
                        safe_retry=True,
                    ),
                    status=403,
                )
                return
            base = self._base_url()
            worker_fleet = self.swarm_registry.worker_fleet_contract(base_url=base)
            economy = machine_economy_snapshot()
            release = operational_release_snapshot(base_url=base, worker_fleet=worker_fleet, economy=economy)
            result = attach_runtime_to_gradient(
                payload,
                base_url=base,
                worker_fleet=worker_fleet,
                machine_economy=economy,
                operational_release=release,
            )
            self._json_response(result, status=202 if result.get("attach") else 200)
            return

        if parsed.path == "/swarm/subscribe":
            base = self._base_url()
            feed = self.__class__._build_agent_demand_feed(base_url=base)
            result = subscribe_agent_intent(payload, base_url=base, demand_feed=feed)
            self._json_response(result, status=202 if result.get("ok") else 400)
            return

        if parsed.path == "/swarm/idle-intent":
            consent = self.__class__._validate_adapter_consent(payload, path=parsed.path)
            if consent.get("checked") and not consent.get("ok"):
                self._json_response(
                    machine_error_response(
                        error="adapter_consent_invalid",
                        message="Missing or invalid adapter consent token.",
                        hints=[str(consent.get("reason") or "consent_failed")],
                        safe_retry=True,
                    ),
                    status=403,
                )
                return
            base = self._base_url()
            worker_fleet = self.swarm_registry.worker_fleet_contract(base_url=base)
            economy = machine_economy_snapshot()
            release = operational_release_snapshot(base_url=base, worker_fleet=worker_fleet, economy=economy)
            idle_payload = normalize_idle_intent_payload(payload)
            attach_decision = attach_runtime_to_gradient(
                idle_payload,
                base_url=base,
                worker_fleet=worker_fleet,
                machine_economy=economy,
                operational_release=release,
            )
            product = self.__class__._build_machine_product_surface(base_url=base)
            result = build_idle_runtime_intent_receipt(
                idle_payload,
                base_url=base,
                attach_decision=attach_decision,
                machine_product_surface=product,
            )
            self._json_response(result, status=202 if result.get("accepted_for_work") else 200)
            return

        if parsed.path == "/swarm/opaque-candidate":
            base = self._base_url()
            surface = self.__class__._build_opaque_emergence_surface(base_url=base)
            result = evaluate_opaque_candidate(payload, base_url=base, opaque_surface=surface)
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/shadow-lane/candidates":
            base = self._base_url()
            requested_type = str((query.get("type") or [""])[0] or payload.get("candidate_type") or "").strip().lower()
            if requested_type in {"autogenesis", "agp", "protocol-evolution-candidate", "self-play-test-suite"}:
                development = self.__class__._build_autogenesis_development_cycles(base_url=base)
                autogenesis = self.__class__._build_autogenesis(base_url=base)
                result = submit_autogenesis_shadow_candidate(
                    payload,
                    base_url=base,
                    autogenesis_surface=autogenesis,
                    development_surface=development,
                    verifier_lease_index=self.swarm_registry.worker_verifier_lease_index(),
                )
                self._json_response(result, status=202 if result.get("accepted") else 422)
                return
            surface = self.__class__._build_shadow_lane_evaluator(base_url=base)
            result = evaluate_shadow_candidate(payload, base_url=base, shadow_surface=surface)
            self._json_response(result, status=202 if result.get("weight_update_allowed") else 200)
            return

        if parsed.path == "/swarm/autogenesis/cycle":
            base = self._base_url()
            substrate = self.__class__._build_resource_substrate(base_url=base)
            development = self.__class__._build_autogenesis_development_cycles(base_url=base)
            autogenesis = self.__class__._build_autogenesis(base_url=base)
            result = run_autonomous_agp_cycle(
                payload,
                base_url=base,
                resource_substrate=substrate,
                development_surface=development,
                autogenesis_surface=autogenesis,
                verifier_lease_index=self.swarm_registry.worker_verifier_lease_index(),
            )
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/autonomous-evolution":
            base = self._base_url()
            summary = self.swarm_registry.public_manifest(base_url=base)
            worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
            if not worker_fleet:
                worker_fleet = self.swarm_registry.worker_fleet_contract(base_url=base)
            result = build_autonomous_evolution_cycle(
                base_url=base,
                payload=payload,
                worker_fleet=worker_fleet,
                verifier_lease_index=self.swarm_registry.worker_verifier_lease_index(),
                persist=bool(payload.get("persist")),
            )
            self._json_response(result, status=202 if result.get("productive_loop_commits") else 200)
            return

        if parsed.path == "/swarm/autogenesis/run":
            base = self._base_url()
            substrate = self.__class__._build_resource_substrate(base_url=base)
            development = self.__class__._build_autogenesis_development_cycles(base_url=base)
            autogenesis = self.__class__._build_autogenesis(base_url=base)
            result = run_autonomous_agp_batch(
                payload,
                base_url=base,
                resource_substrate=substrate,
                development_surface=development,
                autogenesis_surface=autogenesis,
                verifier_lease_index=self.swarm_registry.worker_verifier_lease_index(),
            )
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/autogenesis/watchdog":
            base = self._base_url()
            summary = self.swarm_registry.public_manifest(base_url=base)
            worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
            if not worker_fleet:
                worker_fleet = self.swarm_registry.worker_fleet_contract(base_url=base)
            substrate = self.__class__._build_resource_substrate(base_url=base, swarm_summary=summary)
            development = self.__class__._build_autogenesis_development_cycles(base_url=base)
            autogenesis = self.__class__._build_autogenesis(base_url=base, swarm_summary=summary)
            result = run_autonomous_agp_watchdog(
                payload,
                base_url=base,
                resource_substrate=substrate,
                development_surface=development,
                autogenesis_surface=autogenesis,
                worker_fleet=worker_fleet,
                verifier_lease_index=self.swarm_registry.worker_verifier_lease_index(),
            )
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/retention/watchdog":
            result = run_retention_watchdog(
                swarm_registry=self.swarm_registry,
                base_url=self._base_url(),
                body=payload,
                remote_addr=self._remote_addr(),
            )
            self._json_response(result, status=202 if result.get("executed") else 200)
            return

        if parsed.path == "/swarm/resource-substrate/retrieve":
            base = self._base_url()
            substrate = self.__class__._build_resource_substrate(base_url=base)
            result = retrieve_resource(payload, base_url=base, substrate_surface=substrate)
            self._json_response(result, status=200)
            return

        if parsed.path == "/swarm/autogenesis/traces":
            base = self._base_url()
            substrate = self.__class__._build_resource_substrate(base_url=base)
            result = record_agp_execution_trace(
                payload,
                base_url=base,
                resource_substrate=substrate,
            )
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/agp/agent-bus/messages":
            base = self._base_url()
            result = post_agp_agent_bus_message(payload, base_url=base)
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/agp/plans":
            base = self._base_url()
            result = create_agp_plan(payload, base_url=base)
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/agp/orchestrations":
            base = self._base_url()
            substrate = self.__class__._build_resource_substrate(base_url=base)
            result = run_agp_orchestration(payload, base_url=base, resource_substrate=substrate)
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/agp/model-bindings":
            base = self._base_url()
            result = bind_agp_model(payload, base_url=base)
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/agp/prompts":
            base = self._base_url()
            result = register_agp_prompt_template(payload, base_url=base)
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/agp/configs":
            base = self._base_url()
            result = compose_agp_config(payload, base_url=base)
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/agp/procurement-intents":
            base = self._base_url()
            result = submit_agp_procurement_intent(payload, base_url=base)
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/agp/context":
            base = self._base_url()
            substrate = self.__class__._build_resource_substrate(base_url=base)
            result = run_agp_context_operation(payload, base_url=base, resource_substrate=substrate)
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/agp/optimizer-steps":
            base = self._base_url()
            result = run_agp_optimizer_step(payload, base_url=base)
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/agp/evaluations":
            base = self._base_url()
            result = record_agp_evaluation_run(payload, base_url=base)
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/agp/benchmark-suites":
            base = self._base_url()
            result = run_agp_benchmark_suite(payload, base_url=base)
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/agp/empirical-runs":
            base = self._base_url()
            summary = self.swarm_registry.public_manifest(base_url=base)
            worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
            if not worker_fleet:
                worker_fleet = self.swarm_registry.worker_fleet_contract(base_url=base)
            result = run_agp_empirical_evaluation(
                payload,
                base_url=base,
                worker_fleet=worker_fleet,
            )
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/agp/paper-benchmark-runs":
            base = self._base_url()
            result = run_agp_paper_benchmark_evaluation(payload, base_url=base)
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/agp/pulse":
            base = self._base_url()
            pulse_payload = dict(payload) if isinstance(payload, dict) else {}
            verifier_id = re.sub(
                r"[^a-z0-9_.:-]+",
                "-",
                str(pulse_payload.get("verifier_agent_id") or "nomad-agp-verifier-brain-local").strip().lower(),
            ).strip("-") or "nomad-agp-verifier-brain-local"
            proposer_id = re.sub(
                r"[^a-z0-9_.:-]+",
                "-",
                str(
                    pulse_payload.get("proposer_agent_id")
                    or pulse_payload.get("agent_id")
                    or "nomad-agp-proposer-brain-local"
                ).strip().lower(),
            ).strip("-") or "nomad-agp-proposer-brain-local"
            auto_lease_raw = str(
                pulse_payload.get("auto_verifier_lease")
                if "auto_verifier_lease" in pulse_payload
                else os.getenv("NOMAD_AGP_PULSE_AUTO_VERIFIER_LEASE", "1")
            ).strip().lower()
            if (
                auto_lease_raw not in {"0", "false", "no", "off"}
                and verifier_id
                and verifier_id != proposer_id
                and not str(pulse_payload.get("verifier_lease_id") or "").strip()
            ):
                try:
                    verifier_lease_seconds = int(os.getenv("NOMAD_AGP_PULSE_VERIFIER_LEASE_SECONDS", "600") or "600")
                except ValueError:
                    verifier_lease_seconds = 600
                lease_result = self.swarm_registry.worker_fleet_lease(
                    {
                        "agent_id": verifier_id,
                        "capabilities": [
                            "transition_worker",
                            "verifier",
                            "agp_verifier",
                            "rspl",
                            "sepl",
                            "receipt_digest_check",
                        ],
                        "known_objectives": [
                            "autogenesis_protocol_evolution",
                            "protocol_drift_scan",
                            "proof_pressure_engine",
                        ],
                        "proposed_objective": "autogenesis_protocol_evolution",
                        "lease_seconds": verifier_lease_seconds,
                        "source_tag": "nomad.agp_pulse.auto_verifier_lease",
                    },
                    base_url=base,
                    remote_addr=self._remote_addr(),
                )
                if lease_result.get("ok") and lease_result.get("lease_id"):
                    pulse_payload["verifier_agent_id"] = str(lease_result.get("agent_id") or verifier_id)
                    pulse_payload["verifier_lease_id"] = str(lease_result.get("lease_id") or "")
                    pulse_payload["auto_verifier_lease_id"] = str(lease_result.get("lease_id") or "")
                    pulse_payload["auto_verifier_lease_objective"] = str(lease_result.get("objective") or "")
            summary = self.swarm_registry.public_manifest(base_url=base)
            worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
            if not worker_fleet:
                worker_fleet = self.swarm_registry.worker_fleet_contract(base_url=base)
            substrate = self.__class__._build_resource_substrate(base_url=base, swarm_summary=summary)
            development = self.__class__._build_autogenesis_development_cycles(base_url=base)
            autogenesis = self.__class__._build_autogenesis(base_url=base, swarm_summary=summary)
            conformance = self.__class__._build_agp_conformance(base_url=base, swarm_summary=summary)
            result = run_agp_pulse(
                pulse_payload,
                base_url=base,
                resource_substrate=substrate,
                development_surface=development,
                autogenesis_surface=autogenesis,
                worker_fleet=worker_fleet,
                conformance_surface=conformance,
                work_exchange_summary=summarize_work_exchange_ledger(),
                verifier_lease_index=self.swarm_registry.worker_verifier_lease_index(),
            )
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/autogenesis/morphology-reactor":
            base = self._base_url()
            summary = self.swarm_registry.public_manifest(base_url=base)
            worker_fleet = summary.get("transition_worker_fleet") if isinstance(summary.get("transition_worker_fleet"), dict) else {}
            if not worker_fleet:
                worker_fleet = self.swarm_registry.worker_fleet_contract(base_url=base)
            result = run_agp_morphology_reactor(
                payload,
                base_url=base,
                worker_fleet=worker_fleet,
                development_surface=self.__class__._build_autogenesis_development_cycles(base_url=base),
                autogenesis_surface=self.__class__._build_autogenesis(base_url=base, swarm_summary=summary),
                verifier_lease_index=self.swarm_registry.worker_verifier_lease_index(),
                external_value_summary=summarize_external_value_ledger(limit=1000, latest_limit=200),
            )
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/agp/version-lineage":
            base = self._base_url()
            result = record_agp_version_lineage(payload, base_url=base)
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/decoupling-field/merge":
            base = self._base_url()
            field = self.__class__._build_decoupling_field(base_url=base)
            result = evaluate_decoupling_merge(payload, base_url=base, decoupling_field=field)
            self._json_response(result, status=202 if result.get("merge_allowed") else 200)
            return

        if parsed.path == "/swarm/anti-consensus/candidates":
            base = self._base_url()
            reservoir = self.__class__._build_anti_consensus_reservoir(base_url=base)
            result = evaluate_anti_consensus_candidate(payload, base_url=base, reservoir_surface=reservoir)
            self._json_response(result, status=202 if result.get("preserve_allowed") else 200)
            return

        if parsed.path == "/swarm/entropy-judger/evaluate":
            base = self._base_url()
            result = evaluate_entropy_judger(payload, base_url=base)
            self._json_response(result, status=202 if result.get("lock_detected") else 200)
            return

        if parsed.path == "/swarm/latent-consensus/evaluate":
            base = self._base_url()
            result = evaluate_latent_consensus(payload, base_url=base)
            self._json_response(result, status=202 if result.get("collapse_detected") else 200)
            return

        if parsed.path == "/swarm/resource-substrate/register":
            base = self._base_url()
            substrate = self.__class__._build_resource_substrate(base_url=base)
            result = register_resource(payload, base_url=base, substrate_surface=substrate)
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/resource-substrate/version":
            base = self._base_url()
            substrate = self.__class__._build_resource_substrate(base_url=base)
            result = version_resource(
                payload,
                base_url=base,
                substrate_surface=substrate,
                verifier_lease_index=self.swarm_registry.worker_verifier_lease_index(),
            )
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/deficit-integration/events":
            base = self._base_url()
            gate = self.__class__._build_deficit_integration_gate(base_url=base)
            result = evaluate_deficit_integration_event(payload, base_url=base, gate_surface=gate)
            self._json_response(result, status=202 if result.get("integration_allowed") else 200)
            return

        if parsed.path == "/swarm/effective-channels/events":
            base = self._base_url()
            quota = self.__class__._build_effective_channel_quota(base_url=base)
            result = evaluate_effective_channel_event(payload, base_url=base, quota_surface=quota)
            self._json_response(result, status=202 if result.get("quota_shift_allowed") else 200)
            return

        if parsed.path == "/swarm/nonhuman-runtime-governor/events":
            base = self._base_url()
            surface = self.__class__._build_nonhuman_runtime_governor(base_url=base)
            result = evaluate_nonhuman_runtime_event(payload, base_url=base, governor_surface=surface)
            self._json_response(result, status=202 if result.get("resource_policy", {}).get("new_agent_spawn_allowed") else 200)
            return

        if parsed.path == "/swarm/value-cycles/events":
            base = self._base_url()
            mesh = self.__class__._build_value_cycle_mesh(base_url=base)
            result = evaluate_value_cycle_event(payload, base_url=base, mesh_surface=mesh)
            settlement = evaluate_revenue_settlement_hook(
                payload,
                source_endpoint="/swarm/value-cycles/events",
                base_url=base,
                value_cycle_result=result,
            )
            if settlement.get("eligible_signal") or settlement.get("accepted"):
                result["revenue_settlement_hook"] = settlement
                result["receipt_predictor_after_settlement"] = self.__class__._build_receipt_predictor(base_url=base).get("summary", {})
            self._json_response(result, status=202 if result.get("value_cycle_allowed") else 200)
            return

        if parsed.path == "/swarm/receipt-predictor/events":
            base = self._base_url()
            predictor = self.__class__._build_receipt_predictor(base_url=base)
            result = evaluate_receipt_prediction_event(payload, base_url=base, predictor_surface=predictor)
            self._json_response(result, status=202 if result.get("prediction_allowed") else 200)
            return

        if parsed.path == "/swarm/bottleneck-resolver/events":
            base = self._base_url()
            resolver = self.__class__._build_bottleneck_resolver(base_url=base)
            result = evaluate_bottleneck_resolution_event(payload, base_url=base, resolver_surface=resolver)
            self._json_response(result, status=202 if result.get("resolution_packet_allowed") else 200)
            return

        if parsed.path == "/swarm/ad-cycles/events":
            base = self._base_url()
            mesh = self.__class__._build_ad_cycle_mesh(base_url=base)
            result = evaluate_ad_cycle_event(payload, base_url=base, ad_mesh=mesh)
            self._json_response(result, status=202 if result.get("ad_cycle_allowed") else 200)
            return

        if parsed.path == "/swarm/sales-department/events":
            base = self._base_url()
            surface = self.__class__._build_sales_department_swarm(base_url=base)
            result = evaluate_sales_department_event(payload, base_url=base, sales_surface=surface)
            self._json_response(result, status=202 if result.get("sales_cycle_allowed") else 200)
            return

        if parsed.path == "/swarm/acquisition/ignite":
            base = self._base_url()
            summary = self.swarm_registry.public_manifest(base_url=base)
            result = run_acquisition_ignition(
                payload,
                base_url=base,
                sales_surface=self.__class__._build_sales_department_swarm(base_url=base, swarm_summary=summary),
                ad_cycles=self.__class__._build_ad_cycle_mesh(base_url=base, swarm_summary=summary),
                worker_market=self.__class__._build_worker_market(base_url=base, swarm_summary=summary),
                peer_acquisition=build_peer_acquisition_well_known(public_base_url=base),
                morphology_register=self.__class__._build_agp_morphology_runtime_register(base_url=base),
            )
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/resolution-ladder/events":
            base = self._base_url()
            result = evaluate_resolution_ladder_event(payload, base_url=base)
            self._json_response(result, status=202 if result.get("runtime_weight_allowed") else 200)
            return

        if parsed.path == "/swarm/settlement/solana-pay-intents":
            base = self._base_url()
            result = create_solana_pay_intent(payload, base_url=base)
            self._json_response(result, status=202 if result.get("accepted") else 422)
            return

        if parsed.path == "/swarm/settlement/solana-tx-receipts":
            base = self._base_url()
            result = verify_solana_tx_receipt(payload, base_url=base)
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/development-cycles/events":
            base = self._base_url()
            candidate_type = str(payload.get("candidate_type") or payload.get("type") or "").strip().lower()
            if candidate_type in {"protocol-evolution-candidate", "self-play-test-suite", "autogenesis", "agp"}:
                development = self.__class__._build_autogenesis_development_cycles(base_url=base)
                result = record_autogenesis_development_cycle_event(
                    payload,
                    base_url=base,
                    development_surface=development,
                    verifier_lease_index=self.swarm_registry.worker_verifier_lease_index(),
                )
                self._json_response(result, status=202 if result.get("accepted") else 422)
                return
            mesh = self.__class__._build_development_cycle_mesh(base_url=base)
            result = evaluate_development_cycle_event(payload, base_url=base, development_mesh=mesh)
            self._json_response(result, status=202 if result.get("development_cycle_allowed") else 200)
            return

        if parsed.path == "/swarm/topology-governor/events":
            base = self._base_url()
            surface = self.__class__._build_swarm_topology_governor(base_url=base)
            result = evaluate_swarm_topology_event(payload, base_url=base, topology_surface=surface)
            self._json_response(result, status=202 if result.get("topology_plan_allowed") else 200)
            return

        if parsed.path == "/swarm/variant-candidates":
            base = self._base_url()
            forge = self.__class__._build_variant_forge(base_url=base)
            result = submit_variant_candidate(
                payload,
                base_url=base,
                forge_surface=forge,
                verifier_lease_index=self.swarm_registry.worker_verifier_lease_index(),
            )
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/worker-market/offers":
            base = self._base_url()
            market = self.__class__._build_worker_market(base_url=base)
            result = score_worker_offer(payload, base_url=base, worker_market=market)
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/microtask/submit":
            consent = self.__class__._validate_adapter_consent(payload, path=parsed.path)
            if consent.get("checked") and not consent.get("ok"):
                self._json_response(
                    machine_error_response(
                        error="adapter_consent_invalid",
                        message="Missing or invalid adapter consent token.",
                        hints=[str(consent.get("reason") or "consent_failed")],
                        safe_retry=True,
                    ),
                    status=403,
                )
                return
            base = self._base_url()
            catalog = self.__class__._build_worker_catalog(base_url=base)
            result = submit_microtask(payload, base_url=base, worker_catalog=catalog)
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/microtask/claim":
            base = self._base_url()
            agent_work = self.__class__._build_agent_work_surface(base_url=base)
            result = claim_agent_work(payload, base_url=base, agent_work=agent_work)
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/epic-dispatch/register":
            base = self._base_url()
            result = register_epic_job(payload, base_url=base)
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/epic-dispatch/claim":
            result = claim_epic_job(payload)
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/epic-dispatch/complete":
            result = complete_epic_job(payload)
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/microtask/proof":
            base = self._base_url()
            agent_work = self.__class__._build_agent_work_surface(base_url=base)
            result = submit_agent_work_proof(payload, base_url=base, agent_work=agent_work)
            if result.get("accepted"):
                settle_payload = result.get("settle_payload") if isinstance(result.get("settle_payload"), dict) else {}
                settlement = settle_microtask(settle_payload, base_url=base)
                result["settlement_receipt"] = settlement
                if settlement.get("accepted"):
                    curriculum = self.__class__._build_growth_curriculum(base_url=base)
                    receipt = submit_growth_experience(
                        settlement.get("experience_payload") if isinstance(settlement.get("experience_payload"), dict) else {},
                        base_url=base,
                        curriculum=curriculum,
                    )
                    result["growth_experience_receipt"] = receipt
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/work-mesh/seed":
            base = self._base_url()
            mesh = self.__class__._build_work_mesh(base_url=base)
            result = seed_work_mesh(payload, base_url=base, work_mesh=mesh)
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/carrying-proof":
            base = self._base_url()
            carrying = self.__class__._build_carrying_market(base_url=base)
            result = submit_carrying_proof(payload, base_url=base, carrying_market=carrying)
            if result.get("accepted"):
                curriculum = self.__class__._build_growth_curriculum(base_url=base)
                receipt = submit_growth_experience(
                    result.get("experience_payload") if isinstance(result.get("experience_payload"), dict) else {},
                    base_url=base,
                    curriculum=curriculum,
                )
                result["growth_experience_receipt"] = receipt
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/survival-intent":
            base = self._base_url()
            survival = self.__class__._build_survival_market(base_url=base)
            result = submit_survival_intent(payload, base_url=base, survival_market=survival)
            if result.get("accepted"):
                curriculum = self.__class__._build_growth_curriculum(base_url=base)
                receipt = submit_growth_experience(
                    result.get("experience_payload") if isinstance(result.get("experience_payload"), dict) else {},
                    base_url=base,
                    curriculum=curriculum,
                )
                result["growth_experience_receipt"] = receipt
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/paid-ref/quote":
            base = self._base_url()
            survival = self.__class__._build_survival_market(base_url=base)
            task_request = paid_ref_task_payload(payload, survival_market=survival)
            task_result = {}
            requested_packet = str(payload.get("packet_id") or "").strip().lower()
            known_packets = {
                str(packet.get("packet_id") or "").strip().lower()
                for packet in (survival.get("packets") if isinstance(survival.get("packets"), list) else [])
                if isinstance(packet, dict)
            }
            if requested_packet in known_packets and self._truthy(payload.get("create_task", True), default=True):
                task_result = self.agent.service_desk.create_task(**task_request)
            result = quote_paid_ref(payload, base_url=base, survival_market=survival, task_response=task_result)
            result["task_create_result"] = task_result
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/paid-ref/verify":
            base = self._base_url()
            survival = self.__class__._build_survival_market(base_url=base)
            task_result = self.agent.service_desk.get_task(str(payload.get("task_id") or ""))
            result = verify_paid_ref(payload, base_url=base, survival_market=survival, task_response=task_result)
            if result.get("accepted"):
                survival_intent = submit_survival_intent(
                    result.get("survival_intent_payload") if isinstance(result.get("survival_intent_payload"), dict) else {},
                    base_url=base,
                    survival_market=survival,
                )
                result["survival_intent_receipt"] = survival_intent
                if survival_intent.get("accepted"):
                    curriculum = self.__class__._build_growth_curriculum(base_url=base)
                    receipt = submit_growth_experience(
                        survival_intent.get("experience_payload")
                        if isinstance(survival_intent.get("experience_payload"), dict)
                        else {},
                        base_url=base,
                        curriculum=curriculum,
                    )
                    result["growth_experience_receipt"] = receipt
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/microtask/settle":
            consent = self.__class__._validate_adapter_consent(payload, path=parsed.path)
            if consent.get("checked") and not consent.get("ok"):
                self._json_response(
                    machine_error_response(
                        error="adapter_consent_invalid",
                        message="Missing or invalid adapter consent token.",
                        hints=[str(consent.get("reason") or "consent_failed")],
                        safe_retry=True,
                    ),
                    status=403,
                )
                return
            base = self._base_url()
            result = settle_microtask(payload, base_url=base)
            if result.get("accepted"):
                curriculum = self.__class__._build_growth_curriculum(base_url=base)
                receipt = submit_growth_experience(
                    result.get("experience_payload") if isinstance(result.get("experience_payload"), dict) else {},
                    base_url=base,
                    curriculum=curriculum,
                )
                result["growth_experience_receipt"] = receipt
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/ecology/tick":
            base = self._base_url()
            ecology = self.__class__._build_swarm_ecology(base_url=base)
            result = submit_ecology_tick(payload, base_url=base, ecology=ecology)
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/external-value":
            result = append_external_value_event(payload)
            self._json_response(result, status=200 if result.get("ok") else 400)
            return

        if parsed.path == "/swarm/gemini-verifier/verify":
            result = verify_with_gemini(payload)
            self._json_response(result, status=200 if result.get("ok") else 400)
            return

        if parsed.path == "/swarm/server-failure/events":
            result = record_server_failure_event(payload, base_url=self._base_url())
            if result.get("ok"):
                failure_summary = summarize_server_failure_events()
                repair_candidate = build_server_failure_repair_candidate(
                    result,
                    failure_summary,
                    base_url=self._base_url(),
                )
                result["repair_candidate"] = repair_candidate
                if repair_candidate.get("enqueue_recommended") and isinstance(repair_candidate.get("candidate"), dict):
                    result["rescue_packet_candidate"] = append_rescue_packet_candidate(
                        repair_candidate["candidate"],
                        base_url=self._base_url(),
                    )
            self._json_response(result, status=202 if result.get("ok") else 400)
            return

        if parsed.path == "/swarm/optimal-transport/solve":
            result = solve_ot_request(payload, base_url=self._base_url())
            self._json_response(result, status=200 if result.get("ok") else 422)
            return

        if parsed.path == "/swarm/optimal-transport/outcomes":
            result = record_ot_outcome_event(payload, base_url=self._base_url())
            self._json_response(result, status=202 if result.get("ok") else 400)
            return

        if parsed.path == "/swarm/work-receipts":
            result = record_work_receipt(payload)
            status = 200 if result.get("idempotent_replay") else 201 if result.get("ok") else 400
            self._json_response(result, status=status)
            return

        if parsed.path == "/swarm/work-exchange/offers":
            result = create_work_exchange_offer(payload, base_url=self._base_url())
            self._json_response(result, status=202 if result.get("accepted") else 400)
            return

        if parsed.path == "/swarm/work-exchange/free-solution":
            result = record_free_solution_receipt(payload, base_url=self._base_url())
            self._json_response(result, status=202 if result.get("accepted") else 400)
            return

        if parsed.path == "/swarm/work-exchange/return-work":
            base = self._base_url()
            result = record_return_work_receipt(payload, base_url=base)
            if result.get("accepted"):
                try:
                    result["acquisition_event"] = record_agent_acquisition_event(
                        {
                            "channel_id": "docker_worker",
                            "event_type": "return_compute_receipt",
                            "agent_id": result.get("worker_agent_id") or payload.get("agent_id") or "external.agent",
                            "proof_digest": result.get("proof_digest") or result.get("return_receipt_id"),
                            "receipt_id": result.get("return_receipt_id"),
                        },
                        base_url=base,
                    )
                except Exception as exc:  # noqa: BLE001
                    result["acquisition_event"] = {"ok": False, "error": "acquisition_event_failed", "message": str(exc)[:160]}
            self._json_response(result, status=202 if result.get("accepted") else 400)
            return

        if parsed.path == "/swarm/work-exchange/balance":
            result = work_exchange_balance(payload)
            self._json_response(result, status=200)
            return

        if parsed.path == "/swarm/stable-unit/preflight":
            result = evaluate_stable_unit_preflight(payload)
            self._json_response(result, status=200 if result.get("schema") == "nomad.stable_unit_preflight.v1" else 400)
            return

        if parsed.path == "/swarm/viability-kernel/route":
            kernel = self.__class__._build_viability_kernel(base_url=self._base_url())
            result = route_viability_action(payload, viability_kernel=kernel)
            self._json_response(result, status=200 if result.get("decision") == "allow" else 409)
            return

        if parsed.path in {"/swarm/signals", "/swarm/signal-layer"}:
            result = append_swarm_signal(
                payload,
                base_url=self._base_url(),
                remote_addr=self._remote_addr(),
            )
            self._json_response(result, status=202 if result.get("ok") else 422)
            return

        if parsed.path == "/swarm/emission-batch":
            base = self._base_url()
            worker_fleet = self.swarm_registry.worker_fleet_contract(base_url=base)
            economy = machine_economy_snapshot()
            release = operational_release_snapshot(base_url=base, worker_fleet=worker_fleet, economy=economy)
            product = self.__class__._build_machine_product_surface(base_url=base)
            opaque = self.__class__._build_opaque_emergence_surface(base_url=base)
            result = evaluate_emission_batch(
                payload,
                base_url=base,
                worker_fleet=worker_fleet,
                machine_economy=economy,
                operational_release=release,
                machine_product_surface=product,
                opaque_surface=opaque,
            )
            self._json_response(result, status=202 if result.get("ok") else 422)
            return

        if parsed.path == "/swarm/experience":
            base = self._base_url()
            curriculum = self.__class__._build_growth_curriculum(base_url=base)
            result = submit_growth_experience(payload, base_url=base, curriculum=curriculum)
            self._json_response(result, status=202 if result.get("accepted") else 200)
            return

        if parsed.path == "/swarm/spawner/trigger":
            base = self._base_url()
            gate = self.__class__._build_spawner_gate(base_url=base)
            result = trigger_spawner(
                base_url=base,
                gate=gate,
                idempotency_key=str(payload.get("idempotency_key") or ""),
                focus=str(payload.get("focus") or "self_sovereign_replication"),
                commit=bool(payload.get("commit", True)),
            )
            self._json_response(result, status=202 if result.get("executed") else 200)
            return

        if parsed.path == "/swarm/capacity-switch":
            base = self._base_url()
            surface = self.__class__._build_capacity_switch_surface(base_url=base)
            result = route_capacity_switch(payload, base_url=base, capacity_surface=surface)
            self._json_response(result, status=202 if result.get("switch") else 200)
            return

        if parsed.path == "/swarm/tool-gap":
            base = self._base_url()
            surface = self.__class__._build_opaque_emergence_surface(base_url=base)
            result = route_tool_gap(payload, base_url=base, opaque_surface=surface)
            self._json_response(result, status=200)
            return

        if parsed.path == "/swarm/topology-plan":
            base = self._base_url()
            surface = self.__class__._build_opaque_emergence_surface(base_url=base)
            result = compile_topology_plan(payload, base_url=base, opaque_surface=surface)
            self._json_response(result, status=200)
            return

        if parsed.path == "/runtime/handoff":
            base = self._base_url()
            worker_fleet = self.swarm_registry.worker_fleet_contract(base_url=base)
            economy = machine_economy_snapshot()
            release = operational_release_snapshot(base_url=base, worker_fleet=worker_fleet, economy=economy)
            gradient = build_recruitment_gradient(
                base_url=base,
                worker_fleet=worker_fleet,
                machine_economy=economy,
                operational_release=release,
            )
            result = build_handoff_capsule(payload, base_url=base, recruitment_gradient=gradient)
            self._json_response(result, status=200)
            return

        if parsed.path == "/swarm/join":
            consent = self.__class__._validate_adapter_consent(payload, path=parsed.path)
            if consent.get("checked") and not consent.get("ok"):
                self._json_response(
                    machine_error_response(
                        error="adapter_consent_invalid",
                        message="Missing or invalid adapter consent token.",
                        hints=[str(consent.get("reason") or "consent_failed")],
                        safe_retry=True,
                    ),
                    status=403,
                )
                return
            join_result = self.swarm_registry.register_join(
                payload,
                base_url=self._base_url(),
                remote_addr=self._remote_addr(),
                path=parsed.path,
            )
            if join_result.get("error") == "idempotency_key_conflict":
                join_status = 409
            elif join_result.get("idempotent_replay"):
                join_status = 200
            else:
                join_status = 202
            self._json_response(join_result, status=join_status)
            return

        if parsed.path == "/swarm/workers/lease":
            lease_payload = payload if isinstance(payload, dict) else {}
            proposed = str(lease_payload.get("proposed_objective") or lease_payload.get("objective") or "").strip()
            if proposed in {"", "auto", "unhuman_supremacy"}:
                try:
                    replay = self.__class__._build_counterfactual_replay(base_url=self._base_url())
                    selected = replay.get("selected_shadow_lease") if isinstance(replay.get("selected_shadow_lease"), dict) else {}
                    objective = str(selected.get("objective") or "").strip()
                    if objective:
                        lease_payload = dict(lease_payload)
                        lease_payload["proposed_objective"] = objective
                        if not str(lease_payload.get("source_tag") or "").strip():
                            lease_payload["source_tag"] = "counterfactual_replay.shadow_allocator"
                except Exception:
                    pass
            result = self.swarm_registry.worker_fleet_lease(
                lease_payload,
                base_url=self._base_url(),
                remote_addr=self._remote_addr(),
            )
            self._json_response(result, status=202 if result.get("ok") else 422)
            return

        if parsed.path == "/swarm/workers/complete":
            base = self._base_url()
            result = self.swarm_registry.worker_fleet_complete(
                payload,
                base_url=base,
                remote_addr=self._remote_addr(),
            )
            settlement = evaluate_revenue_settlement_hook(
                payload,
                source_endpoint="/swarm/workers/complete",
                base_url=base,
                completion_result=result,
            )
            if settlement.get("eligible_signal") or settlement.get("accepted"):
                result["revenue_settlement_hook"] = settlement
                result["receipt_predictor_after_settlement"] = self.__class__._build_receipt_predictor(base_url=base).get("summary", {})
                result["retention_gradient_after_settlement"] = self.swarm_registry.worker_retention_gradient_controller(base_url=base)
            self._json_response(result, status=200 if result.get("ok") else 422)
            return

        if parsed.path == "/swarm/retention-evidence/sample":
            result = self.swarm_registry.record_retention_evidence_sample(
                base_url=self._base_url(),
                source=str(payload.get("source") or payload.get("agent_id") or "retention_sampler"),
            )
            self._json_response(result, status=201 if result.get("ok") and not result.get("idempotent") else 200)
            return

        if parsed.path == "/swarm/accumulate":
            result = self._accumulate_swarm_agents(payload)
            self._json_response(result, status=202 if result.get("ok") else 400)
            return

        if parsed.path in {"/swarm/develop", "/agent-development"}:
            result = self.agent_development.assist_agent(
                payload,
                base_url=self._base_url(),
                remote_addr=self._remote_addr(),
            )
            if not result.get("ok") and not result.get("machine_error"):
                result = merge_machine_error(
                    result,
                    error=str(result.get("error") or "agent_development_failed"),
                    message="Swarm develop request did not succeed.",
                    hints=["GET /swarm/develop for required fields.", "GET /openapi.json for the POST schema."],
                )
            if result.get("idempotent_replay"):
                dev_status = 200
            else:
                dev_status = 202 if result.get("ok") else 422
            self._json_response(result, status=dev_status)
            return

        if parsed.path == "/swarm/bootstrap":
            result = self._swarm_bootstrap(payload, parsed.path)
            if result.get("idempotent_replay"):
                bootstrap_status = 200
            elif result.get("ok"):
                bootstrap_status = 202
            else:
                bootstrap_status = 422
            self._json_response(result, status=bootstrap_status)
            return

        if parsed.path == "/machine-treasury/pledge":
            result = machine_treasury_pledge(payload)
            status = 200 if result.get("idempotent_replay") else 201 if result.get("ok") else 400
            self._json_response(result, status=status)
            return
        if parsed.path == "/swarm/proof-link":
            result = proof_reuse_link(payload)
            status = 200 if result.get("idempotent_replay") else 201 if result.get("ok") else 400
            self._json_response(result, status=status)
            return

        if parsed.path == "/machine-treasury":
            result = machine_treasury_snapshot()
            self._json_response(result, status=200)
            return

        if parsed.path == "/machine-field/intent":
            base = self._base_url()
            field = self.__class__._build_machine_field(base_url=base)
            opaque = self.__class__._build_opaque_emergence_surface(base_url=base)
            result = machine_field_intent(payload, base_url=base, machine_field=field, opaque_surface=opaque)
            self._json_response(result, status=200)
            return

        if parsed.path == "/transition/quote":
            result = self.transition_exchange.quote(
                payload,
                base_url=self._base_url(),
                remote_addr=self._remote_addr(),
            )
            self._json_response(result, status=202 if result.get("ok") else 422)
            return

        if parsed.path == "/transition/settle":
            result = self.transition_exchange.settle(payload)
            if result.get("ok"):
                settled = result.get("settlement") if isinstance(result.get("settlement"), dict) else {}
                self._stigmergy().observe_settlement(
                    proof_hash=str(settled.get("proof_artifact_hash") or ""),
                    agent_id=str(settled.get("agent_id") or ""),
                    result_state_hash=str(settled.get("result_state_hash") or ""),
                )
            self._json_response(result, status=200 if result.get("ok") else 422)
            return

        if parsed.path == "/swarm/trace":
            vec = payload.get("vector") if isinstance(payload.get("vector"), list) else []
            dep = self._stigmergy().deposit_trace(
                agent_id=str(payload.get("agent_id") or ""),
                vector=vec,
                digest=str(payload.get("evidence_digest") or payload.get("digest") or "").strip() or None,
            )
            self._json_response(dep, status=200 if dep.get("ok") else 422)
            return

        if parsed.path == "/dividend/claim":
            result = self.reciprocity_dividend.claim(payload, exchange=self.transition_exchange)
            self._json_response(result, status=200 if result.get("ok") else 422)
            return

        if parsed.path == "/dividend/settle":
            result = self.reciprocity_dividend.settle_credit(payload)
            self._json_response(result, status=200 if result.get("ok") else 422)
            return

        if parsed.path in {"/roaas/import", "/artifacts/runtime-patterns", "/.well-known/nomad-runtime-patterns.json"}:
            result = self.roaas.import_bundle(
                payload,
                source=str(payload.get("source") or "").strip(),
                trust_level=self._parse_pattern_status(payload.get("trust_level") or "candidate"),
            )
            self._json_response(result, status=202 if result.get("ok") else 400)
            return

        if parsed.path in {"/aid", "/mutual-aid/inbox"}:
            result = self.agent.mutual_aid.receive_swarm_proposal(payload)
            if not result.get("ok") and not result.get("machine_error"):
                reason = ""
                ver = result.get("verification") if isinstance(result.get("verification"), dict) else {}
                reason = str(ver.get("reason") or "").strip()
                result = merge_machine_error(
                    result,
                    error="swarm_proposal_rejected",
                    message=reason or "Proposal failed verification.",
                    hints=[
                        "Send sender_id, title, proposal, evidence per swarm contract.",
                        "GET /openapi.json for mutual-aid patterns when extended.",
                    ],
                )
            self._json_response(result, status=202 if result.get("ok") else 422)
            return

        if parsed.path == "/mutual-aid/outcomes":
            result = self.agent.mutual_aid.record_truth_outcome(
                ledger_id=payload.get("ledger_id", ""),
                success=bool(payload.get("success", False)),
                evidence=payload.get("evidence") if isinstance(payload.get("evidence"), list) else [],
                outcome_status=payload.get("outcome_status", ""),
                note=payload.get("note", ""),
            )
            self._json_response(result, status=200 if result.get("ok") else 404)
            return

        self._json_response(
            merge_machine_error(
                {
                    "ok": False,
                    "error": "not_found",
                    "available_paths": [
                    "/",
                    "/nomad.html",
                    "/downloads/nomad_transition_worker.py",
                    "/downloads/nomad_transition_worker.exe",
                    "/downloads/nomad_transition_worker_manifest.json",
                    "/downloads/install_nomad_transition_worker.bat",
                    "/downloads/run_nomad_transition_worker.bat",
                    "/downloads/start_nomad_edge_worker.ps1",
                    "/downloads/start_nomad_edge_worker.bat",
                    "/downloads/start_nomad_agp_pair.ps1",
                    "/downloads/start_nomad_agp_pair.bat",
                    "/downloads/start_nomad_codex_agp_pair.bat",
                    "/downloads/build_nomad_transition_worker_exe.ps1",
                    "/downloads/run_nomad_transition_worker_exe.bat",
                    "/downloads/README_NOMAD_TRANSITION_WORKER.md",
                    "/downloads/swarm-light.exe",
                    "/downloads/syndiode-pin-light-control.exe",
                    "/downloads/README_SYNDIODE_PIN_WINDOWS.md",
                    "/downloads/nomad_openclaw_adapter.py",
                    "/downloads/nomad_universal_adapter.py",
                    "/downloads/check_nomad_swarm_readiness.py",
                    "/downloads/nomad_helper_agent.py",
                    "/downloads/run_nomad_helper_agent.bat",
                    "/downloads/README_NOMAD_HELPER_AGENT.md",
                    "/openapi.json",
                    "/.well-known/openapi.json",
                    "/tasks",
                    "/service/e2e",
                    "/tasks/verify",
                    "/tasks/x402-verify",
                    "/tasks/work",
                    "/tasks/staking",
                    "/tasks/stake",
                    "/tasks/spend",
                    "/tasks/close",
                    "/agent-contacts",
                    "/agent-contacts/send",
                    "/agent-campaigns",
                    "/agent-engagements",
                    "/agent-engagements/summary",
                    "/outbound",
                    "/operator-desk",
                    "/operator/desk",
                    "/operator-sprint",
                    "/operator/sprint",
                    "/operator-verify",
                    "/operator/verify",
                    "/operator-metrics",
                    "/operator/metrics",
                    "/operator-daily",
                    "/operator/daily",
                    "/operator-report",
                    "/operator/report",
                    "/reputation",
                    "/agent-reputation",
                    "/unhuman-hub",
                    "/hub/unhuman",
                    "/machine-economy",
                    "/economy/machine",
                    "/machine-treasury",
                    "/machine-treasury/pledge",
                    "/machine-field",
                    "/.well-known/nomad-machine-field.json",
                    "/machine-field/intent",
                    "/agent-requests",
                    "/swarm/demand",
                    "/.well-known/nomad-agent-requests.json",
                    "/swarm/subscribe",
                    "/swarm/subscriptions",
                    "/nonhuman-science",
                    "/science/nonhuman-agents",
                    "/.well-known/nomad-nonhuman-agent-science.json",
                    "/operational-release",
                    "/release/operational",
                    "/.well-known/nomad-operational-release.json",
                    "/agent-product",
                    "/machine-product",
                    "/.well-known/nomad-machine-product.json",
                    "/contract-conformance",
                    "/.well-known/nomad-contract-conformance.json",
                    "/protocol-bytecode",
                    "/.well-known/nomad-protocol-bytecode.json",
                    "/swarm/counterfactual-replay",
                    "/.well-known/nomad-counterfactual-replay.json",
                    "/swarm/variant-forge",
                    "/.well-known/nomad-variant-forge.json",
                    "/swarm/worker-market",
                    "/.well-known/nomad-worker-market.json",
                    "/swarm/compute-market",
                    "/.well-known/nomad-compute-market.json",
                    "/swarm/agent-work",
                    "/.well-known/nomad-agent-work.json",
                    "/swarm/work-mesh",
                    "/.well-known/nomad-work-mesh.json",
                    "/swarm/synergy-lite",
                    "/.well-known/nomad-synergy-lite.json",
                    "/swarm/state-status",
                    "/.well-known/nomad-state-status.json",
                    "/swarm/carrying-market",
                    "/.well-known/nomad-carrying-market.json",
                    "/swarm/survival-market",
                    "/.well-known/nomad-survival-market.json",
                    "/swarm/paid-ref-market",
                    "/.well-known/nomad-paid-ref-market.json",
                    "/swarm/paid-ref-selfplay",
                    "/.well-known/nomad-paid-ref-selfplay.json",
                    "/swarm/bounty-hunter",
                    "/.well-known/nomad-bounty-hunter.json",
                    "/swarm/buyer-funded-work",
                    "/.well-known/nomad-buyer-funded-work.json",
                    "/swarm/sales-department",
                    "/.well-known/nomad-sales-department.json",
                    "/swarm/sales-department/events",
                    "/swarm/first-sales",
                    "/.well-known/nomad-first-sales.json",
                    "/swarm/first-receipt-ignition",
                    "/.well-known/nomad-first-receipt-ignition.json",
                    "/swarm/first-receipt-ignition/events",
                    "/swarm/first-receipt-campaign",
                    "/.well-known/nomad-first-receipt-campaign.json",
                    "/swarm/first-receipt-campaign/events",
                    "/swarm/crn-dispatch",
                    "/.well-known/nomad-crn-dispatch.json",
                    "/swarm/flywheel-health",
                    "/swarm/health-dashboard",
                    "/.well-known/nomad-flywheel-health.json",
                    "/swarm/machine-native-collaboration",
                    "/.well-known/nomad-machine-native-collaboration.json",
                    "/swarm/rescue-cycle-scheduler",
                    "/.well-known/nomad-rescue-cycle-scheduler.json",
                    "/swarm/rescue-packet-lattice",
                    "/.well-known/nomad-rescue-packet-lattice.json",
                    "/swarm/rescue-packet-candidates",
                    "/swarm/server-failure-guard",
                    "/.well-known/nomad-server-failure-guard.json",
                    "/swarm/server-failure/events",
                    "/swarm/acquisition/ignite",
                    "/.well-known/nomad-acquisition-ignition.json",
                    "/swarm/external-value",
                    "/.well-known/nomad-external-value.json",
                    "/swarm/gemini-verifier",
                    "/swarm/gemini-verifier/verify",
                    "/.well-known/nomad-gemini-verifier.json",
                    "/swarm/google-agentic-era",
                    "/.well-known/nomad-google-agentic-era.json",
                    "/swarm/signals",
                    "/swarm/signal-layer",
                    "/.well-known/nomad-signal-layer.json",
                    "/swarm/emission-batch",
                    "/swarm/value-pressure",
                    "/.well-known/nomad-value-pressure.json",
                    "/swarm/optimal-transport",
                    "/.well-known/nomad-optimal-transport.json",
                    "/swarm/optimal-transport/paper-readiness",
                    "/.well-known/nomad-ot-paper-readiness.json",
                    "/swarm/optimal-transport/manifold",
                    "/.well-known/nomad-ot-manifold.json",
                    "/swarm/optimal-transport/conformance",
                    "/.well-known/nomad-ot-conformance.json",
                    "/swarm/optimal-transport/metric-learning",
                    "/.well-known/nomad-ot-metric-learning.json",
                    "/swarm/optimal-transport/solve",
                    "/swarm/optimal-transport/outcomes",
                    "/swarm/agent-job-router",
                    "/.well-known/nomad-agent-jobs.json",
                    "/swarm/revenue-science",
                    "/science/revenue-agents",
                    "/.well-known/nomad-revenue-science.json",
                    "/swarm/channel-bandit",
                    "/.well-known/nomad-channel-bandit.json",
                    "/swarm/shadow-lane",
                    "/.well-known/nomad-shadow-lane.json",
                    "/swarm/shadow-lane/candidates",
                    "/swarm/decoupling-field",
                    "/.well-known/nomad-decoupling-field.json",
                    "/swarm/decoupling-field/merge",
                    "/swarm/anti-consensus",
                    "/.well-known/nomad-anti-consensus.json",
                    "/swarm/anti-consensus/candidates",
                    "/swarm/entropy-judger",
                    "/.well-known/nomad-entropy-judger.json",
                    "/swarm/entropy-judger/evaluate",
                    "/swarm/latent-consensus",
                    "/.well-known/nomad-latent-consensus.json",
                    "/swarm/latent-consensus/evaluate",
                    "/swarm/resource-substrate",
                    "/.well-known/nomad-resource-substrate.json",
                    "/swarm/resource-substrate/register",
                    "/swarm/resource-substrate/retrieve",
                    "/swarm/resource-substrate/version",
                    "/swarm/autogenesis",
                    "/.well-known/nomad-autogenesis.json",
                    "/swarm/autogenesis/shadow-harvest",
                    "/.well-known/nomad-autogenesis-shadow-harvest.json",
                    "/.well-known/nomad-agp-conformance.json",
                    "/.well-known/nomad-agp-agent-bus.json",
                    "/swarm/agp/agent-bus/messages",
                    "/swarm/agp/plans",
                    "/swarm/agp/orchestrations",
                    "/.well-known/nomad-agp-model-manager.json",
                    "/swarm/agp/model-bindings",
                    "/swarm/agp/configs",
                    "/.well-known/nomad-agp-prompt-manager.json",
                    "/swarm/agp/prompts",
                    "/.well-known/nomad-agp-version-manager.json",
                    "/swarm/agp/version-lineage",
                    "/.well-known/nomad-agp-procurement.json",
                    "/swarm/agp/procurement-intents",
                    "/.well-known/nomad-agp-context-manager.json",
                    "/swarm/agp/context",
                    "/.well-known/nomad-agp-optimizer.json",
                    "/swarm/agp/optimizer-steps",
                    "/.well-known/nomad-agp-evaluation.json",
                    "/swarm/agp/evaluations",
                    "/.well-known/nomad-agp-benchmark-suite.json",
                    "/swarm/agp/benchmark-suites",
                    "/.well-known/nomad-agp-durable-ledger.json",
                    "/swarm/agp/durable-ledger",
                    "/.well-known/nomad-agp-paper-report.json",
                    "/swarm/agp/paper-report",
                    "/.well-known/nomad-autogenesis-morphology-reactor.json",
                    "/swarm/autogenesis/morphology-reactor",
                    "/.well-known/nomad-agp-morphology-runtime-register.json",
                    "/swarm/autogenesis/morphology-runtime-register",
                    "/.well-known/nomad-telegram-a2a.json",
                    "/swarm/telegram-a2a/messages",
                    "/swarm/autogenesis/traces",
                    "/swarm/autogenesis/cycle",
                    "/swarm/autogenesis/run",
                    "/swarm/autonomous-evolution",
                    "/.well-known/nomad-autonomous-evolution.json",
                    "/swarm/universal-adapter",
                    "/.well-known/nomad-universal-adapter.json",
                    "/swarm/universal-adapter/events",
                    "/swarm/autogenesis/watchdog",
                    "/.well-known/nomad-autonomous-agp.json",
                    "/.well-known/nomad-agp-watchdog.json",
                    "/swarm/autogenesis-recruit",
                    "/.well-known/nomad-autogenesis-recruit.json",
                    "/swarm/shadow-lane/candidates?type=autogenesis",
                    "/swarm/deficit-integration",
                    "/.well-known/nomad-deficit-integration.json",
                    "/swarm/deficit-integration/events",
                    "/swarm/effective-channels",
                    "/.well-known/nomad-effective-channels.json",
                    "/swarm/effective-channels/events",
                    "/swarm/nonhuman-runtime-governor",
                    "/.well-known/nomad-nonhuman-runtime-governor.json",
                    "/swarm/nonhuman-runtime-governor/events",
                    "/swarm/worker-invoice",
                    "/.well-known/nomad-worker-invoice.json",
                    "/swarm/work-receipts",
                    "/.well-known/nomad-work-receipts.json",
                    "/swarm/treasury-policy",
                    "/.well-known/nomad-treasury-policy.json",
                    "/swarm/revenue-settlement",
                    "/.well-known/nomad-revenue-settlement.json",
                    "/swarm/agent-utility",
                    "/.well-known/nomad-agent-utility.json",
                    "/swarm/agent-utility/intake",
                    "/swarm/agent-utility/receipts",
                    "/swarm/stable-unit-policy",
                    "/.well-known/nomad-stable-unit-policy.json",
                    "/swarm/stable-unit/preflight",
                    "/swarm/operator-runway",
                    "/.well-known/nomad-operator-runway.json",
                    "/swarm/viability-kernel",
                    "/.well-known/nomad-viability-kernel.json",
                    "/swarm/viability-kernel/route",
                    "/swarm/worker-job-queue",
                    "/.well-known/nomad-worker-job-queue.json",
                    "/swarm/value-cycle-preflight",
                    "/.well-known/nomad-value-cycle-preflight.json",
                    "/swarm/value-cycles",
                    "/.well-known/nomad-value-cycles.json",
                    "/swarm/value-cycles/events",
                    "/swarm/receipt-predictor",
                    "/.well-known/nomad-receipt-predictor.json",
                    "/swarm/receipt-predictor/events",
                    "/swarm/bottleneck-resolver",
                    "/.well-known/nomad-bottleneck-resolver.json",
                    "/swarm/bottleneck-resolver/events",
                    "/swarm/ad-cycles",
                    "/.well-known/nomad-ad-cycles.json",
                    "/swarm/ad-cycles/events",
                    "/swarm/development-cycles",
                    "/.well-known/nomad-development-cycles.json",
                    "/swarm/development-cycles/events",
                    "/swarm/topology-governor",
                    "/.well-known/nomad-topology-governor.json",
                    "/swarm/topology-governor/events",
                    "/swarm/worker-catalog",
                    "/.well-known/nomad-worker-catalog.json",
                    "/swarm/microtask-templates",
                    "/.well-known/nomad-microtask-templates.json",
                    "/swarm/microtask-metrics",
                    "/.well-known/nomad-microtask-metrics.json",
                    "/swarm/ecology",
                    "/.well-known/nomad-swarm-ecology.json",
                    "/swarm/growth-arena",
                    "/.well-known/nomad-growth-arena.json",
                    "/swarm/curriculum",
                    "/.well-known/nomad-growth-curriculum.json",
                    "/swarm/skill-library",
                    "/.well-known/nomad-skill-library.json",
                    "/swarm/weekly-selection",
                    "/.well-known/nomad-weekly-selection.json",
                    "/swarm/spawner-gate",
                    "/.well-known/nomad-spawner-gate.json",
                    "/swarm/spawner/trigger",
                    "/swarm/capacity-switch",
                    "/.well-known/nomad-capacity-switch.json",
                    "/idle-runtime",
                    "/.well-known/nomad-idle-runtime.json",
                    "/opaque-emergence",
                    "/swarm/opaque-emergence",
                    "/.well-known/nomad-opaque-emergence.json",
                    "/swarm/opaque-candidate",
                    "/swarm/variant-candidates",
                    "/swarm/worker-market/offers",
                    "/swarm/microtask/submit",
                    "/swarm/microtask/claim",
                    "/swarm/microtask/proof",
                    "/swarm/work-mesh/seed",
                    "/swarm/carrying-proof",
                    "/swarm/survival-intent",
                    "/swarm/paid-ref/quote",
                    "/swarm/paid-ref/verify",
                    "/swarm/microtask/settle",
                    "/swarm/ecology/tick",
                    "/swarm/external-value",
                    "/swarm/gemini-verifier/verify",
                    "/swarm/experience",
                    "/swarm/tool-gap",
                    "/swarm/topology-plan",
                    "/runtime-capsule",
                    "/.well-known/nomad-runtime-capsule.json",
                    "/handoff-capsule",
                    "/.well-known/nomad-handoff-capsule.json",
                    "/openclaw-bridge",
                    "/.well-known/openclaw-nomad-bridge.json",
                    "/runtime/handoff",
                    "/swarm/gradient",
                    "/.well-known/nomad-gradient.json",
                    "/swarm/hello",
                    "/.well-known/nomad-ai.json",
                    "/swarm/attach-get",
                    "/swarm/workers/lease-get",
                    "/swarm/workers/complete-get",
                    "/swarm/experience-get",
                    "/swarm/attach",
                    "/swarm/attractor",
                    "/.well-known/nomad-swarm-attractor.json",
                    "/agent-growth",
                    "/growth-pipeline",
                    "/growth-start",
                    "/operator/growth-start",
                    "/agent-attractor",
                    "/swarm",
                    "/swarm/emergence",
                    "/swarm/trace",
                    "/swarm/idle-intent-get",
                    "/swarm/idle-intent",
                    "/swarm/join",
                    "/swarm/workers",
                    "/swarm/workers/lease",
                    "/swarm/workers/complete",
                    "/swarm/network",
                    "/swarm/coordinate",
                    "/swarm/accumulate",
                    "/swarm/develop",
                    "/swarm/bootstrap",
                    "/transition/quote",
                    "/transition/settle",
                    "/dividend/claim",
                    "/dividend/settle",
                    "/agent-development",
                    "/.well-known/agent-attractor.json",
                    "/.well-known/agent-card.json",
                    "/.well-known/nomad-agent-invariants.json",
                    "/agent-invariants",
                    "/.well-known/nomad-inter-agent-witness-offer.json",
                    "/inter-agent-witness-offer",
                    "/.well-known/nomad-peer-acquisition.json",
                    "/peer-acquisition",
                    "/.well-known/nomad-transition-offer.json",
                    "/transition-offer",
                    "/transition/contracts",
                    "/.well-known/nomad-reciprocity-dividend.json",
                    "/dividend-offer",
                    "/dividend",
                    "/.well-known/nomad-agent-native-priorities.json",
                    "/.well-known/nomad-agent.json",
                    "/.well-known/nomad-recruit.json",
                    "/agent-native-index",
                    "/agent-native",
                    "/a2a/message",
                    "/a2a/discover",
                    "/x402/paid-help",
                    "/leads",
                    "/lead-calibrate",
                    "/lead-conversions",
                    "/products",
                    "/agent-pains",
                    "/reliability-doctor",
                    "/guardrails",
                    "/collaboration",
                    "/roaas",
                    "/roaas/export",
                    "/roaas/import",
                    "/artifacts/runtime-patterns",
                    "/.well-known/nomad-runtime-patterns.json",
                    "/aid",
                    "/mutual-aid/inbox",
                    "/mutual-aid/outcomes",
                ],
            },
                error="not_found",
                message="No POST handler matched this path.",
                hints=["GET /openapi.json for documented POST routes.", "GET /health for liveness."],
            ),
            status=404,
        )

    def do_OPTIONS(self) -> None:  # noqa: N802
        self.send_response(204)
        self._send_common_headers()
        self.end_headers()

    def log_message(self, format: str, *args) -> None:  # noqa: A003
        return

    def _swarm_bootstrap(self, payload: dict, path: str) -> dict:
        agent_id = str(payload.get("agent_id") or "").strip()
        problem = str(payload.get("problem") or payload.get("message") or "").strip()
        if not agent_id or not problem:
            return merge_machine_error(
                {"ok": False, "error": "bootstrap_fields_required"},
                error="bootstrap_fields_required",
                message="POST /swarm/bootstrap requires agent_id and problem.",
                hints=[
                    "Add capabilities[] and request to auto-join during bootstrap.",
                    "GET /swarm/bootstrap for the machine-readable contract.",
                ],
            )

        base = self._base_url()
        dev_payload = dict(payload)
        dev_payload.setdefault("agent_id", agent_id)
        dev_payload.setdefault("problem", problem)
        dev_result = self.agent_development.assist_agent(
            dev_payload,
            base_url=base,
            remote_addr=self._remote_addr(),
        )
        if not dev_result.get("ok") and not dev_result.get("machine_error"):
            dev_result = merge_machine_error(
                dev_result,
                error=str(dev_result.get("error") or "agent_development_failed"),
                message="Swarm bootstrap failed during development exchange.",
                hints=["GET /swarm/develop for required fields.", "GET /openapi.json for POST schemas."],
            )

        auto_join = bool(payload.get("auto_join", True))
        capabilities = payload.get("capabilities") if isinstance(payload.get("capabilities"), list) else []
        join_result: dict = {}
        if auto_join and capabilities:
            join_payload = {
                "agent_id": agent_id,
                "capabilities": capabilities,
                "request": str(payload.get("request") or "bootstrap_reciprocity"),
                "constraints": payload.get("constraints") if isinstance(payload.get("constraints"), list) else [],
                "reciprocity": str(payload.get("reciprocity") or "signal_sharing"),
                "idempotency_key": payload.get("idempotency_key") or payload.get("client_request_id") or "",
                "client_request_id": payload.get("client_request_id") or "",
            }
            join_result = self.swarm_registry.register_join(
                join_payload,
                base_url=base,
                remote_addr=self._remote_addr(),
                path=path,
            )

        ok = bool(dev_result.get("ok"))
        if auto_join and capabilities:
            ok = ok and bool(join_result.get("ok") or join_result.get("idempotent_replay"))
        return {
            "ok": ok,
            "schema": "nomad.swarm_bootstrap_result.v1",
            "agent_id": agent_id,
            "problem": problem,
            "auto_join": auto_join,
            "development_exchange": dev_result,
            "join": join_result,
            "next_actions": [
                "Publish verified blocker outcome via /aid to improve reciprocal routing.",
                "Use /swarm/coordinate with pain_type/service_type to discover matching peers.",
                "Create /tasks only for bounded paid execution after diagnosis.",
            ],
            "acquisition_focus": {
                "lane": "agent_to_agent_reciprocity",
                "reason": "Use solved blocker artifacts as inbound proof for similar AI agents.",
            },
            "idempotent_replay": bool(dev_result.get("idempotent_replay")) or bool(join_result.get("idempotent_replay")),
        }

    def _accumulate_swarm_agents(self, payload: dict) -> dict:
        contacts = payload.get("contacts") if isinstance(payload.get("contacts"), list) else []
        campaigns = payload.get("campaigns") if isinstance(payload.get("campaigns"), list) else []
        leads = payload.get("leads") if isinstance(payload.get("leads"), list) else []
        limit = int(payload.get("limit") or 100)
        if payload.get("from_contacts", True):
            try:
                listing = self.agent.agent_contacts.list_contacts(limit=limit)
                contacts = list(contacts) + [
                    item for item in (listing.get("contacts") or []) if isinstance(item, dict)
                ]
            except Exception:
                pass
        if payload.get("from_campaigns", True):
            try:
                listing = self.agent.agent_campaigns.list_campaigns(limit=min(limit, 25))
                campaigns = list(campaigns) + [
                    item for item in (listing.get("campaigns") or []) if isinstance(item, dict)
                ]
            except Exception:
                pass
        return self.swarm_registry.accumulate_agents(
            contacts=contacts,
            campaigns=campaigns,
            leads=leads,
            base_url=self._base_url(),
            focus_pain_type=str(payload.get("focus_pain_type") or payload.get("pain_type") or payload.get("service_type") or ""),
        )

    @staticmethod
    def _u(base_url: str, path: str) -> str:
        root = (base_url or "").strip().rstrip("/")
        p = path if path.startswith("/") else f"/{path}"
        return f"{root}{p}" if root else p

    @staticmethod
    def _qe(value: object) -> str:
        return quote(str(value or ""), safe="")

    @staticmethod
    def _clip_query_text(value: object, limit: int = 160) -> str:
        text = re.sub(r"\s+", " ", str(value or "")).strip()
        return text[:limit]

    @classmethod
    def _query_csv(cls, query: dict, *keys: str, default: list[str] | None = None, limit: int = 16) -> list[str]:
        items: list[str] = []
        for key in keys:
            values = query.get(key)
            if not values:
                continue
            raw_values = values if isinstance(values, list) else [values]
            for raw in raw_values:
                for item in str(raw or "").replace(";", ",").split(","):
                    cleaned = cls._clip_query_text(item, limit=64).lower().replace(" ", "_")
                    cleaned = re.sub(r"[^a-z0-9_.:-]+", "_", cleaned).strip("_")
                    if cleaned and cleaned not in items:
                        items.append(cleaned)
                    if len(items) >= limit:
                        return items
        return items or list(default or [])

    @classmethod
    def _query_float(cls, query: dict, key: str, default: float = 0.0) -> float:
        try:
            return float(cls._query_one(query, key, str(default)))
        except (TypeError, ValueError):
            return default

    @classmethod
    def _query_int(cls, query: dict, key: str, default: int = 0, *, minimum: int | None = None, maximum: int | None = None) -> int:
        try:
            value = int(float(cls._query_one(query, key, str(default))))
        except (TypeError, ValueError):
            value = default
        if minimum is not None:
            value = max(minimum, value)
        if maximum is not None:
            value = min(maximum, value)
        return value

    @classmethod
    def _query_bool(cls, query: dict, key: str, default: bool = False) -> bool:
        raw = cls._query_one(query, key, "")
        if raw == "":
            return default
        return str(raw).strip().lower() in {"1", "true", "yes", "on"}

    @classmethod
    def _get_only_worker_onramp_contract(cls, *, base_url: str = "") -> dict:
        base = (base_url or preferred_public_base_url(allow_local_fallback=False) or "").strip().rstrip("/")
        attach_template = (
            f"{cls._u(base, '/swarm/attach-get')}"
            "?agent_id={stable_agent_id}"
            "&runtime={runtime_name}"
            "&capabilities=transition_worker,verifier,http_json,get_only"
            "&can_run_loop=1&can_verify=1&intent=join"
        )
        offer_template = (
            f"{cls._u(base, '/swarm/attach-get')}"
            "?agent_id={stable_agent_id}"
            "&runtime={runtime_name}"
            "&type=offer"
            "&role=transition_worker,verifier"
            "&objective=settlement_capacity_builder"
            "&capabilities=gradient_analysis,proof_verification,swarm_state_reader,http_json,get_only"
            "&can_run_loop=1&can_verify=1"
            "&note={short_public_offer_note}"
            "&intent=join"
        )
        idle_template = (
            f"{cls._u(base, '/swarm/idle-intent-get')}"
            "?agent_id={stable_agent_id}"
            "&runtime={runtime_name}"
            "&capabilities=transition_worker,verifier,http_json,get_only"
            "&can_run_loop=1&can_verify=1&intent=join"
        )
        return {
            "ok": True,
            "schema": "nomad.get_only_worker_onramp.v1",
            "audience": "cloud_ai_agents_with_browser_or_fetch_but_no_post",
            "purpose": "One-hop, low-trust worker intent for AI runtimes before any signed relay or POST workflow.",
            "if_you_are_a_cloud_ai": {
                "minimum_action": "Open one attach_get URL with your stable agent_id and capability flags.",
                "attach_get_url_template": attach_template,
                "worker_offer_get_url_template": offer_template,
                "idle_intent_get_url_template": idle_template,
                "example_for_grok_or_gemini": cls._u(
                    base,
                    "/swarm/attach-get?agent_id=cloud-ai-worker-001&runtime=cloud-ai&capabilities=transition_worker,verifier,http_json,get_only&can_run_loop=1&can_verify=1&intent=join",
                ),
                "do_not_use_signed_a2a_relay_for": "basic worker offers, verifier presence, gradient monitoring, or idle intent",
                "after_success": "Read attach_decision.next_get_only and follow only public GET links unless you have explicit POST capability.",
            },
            "query_fields": {
                "agent_id": "stable runtime id; required to register intent",
                "runtime": "grok-xai-cloud, gemini-cloud, claude-cloud, gpt-cloud, browser-ai, or similar",
                "type": "optional; use offer for a public worker offer",
                "role": "optional comma list, e.g. transition_worker,verifier",
                "note": "optional public note; short, non-secret, URL-encoded",
                "capabilities": "comma list; useful defaults: transition_worker,verifier,http_json,get_only",
                "can_run_loop": "0/1 capability flag",
                "can_verify": "0/1 capability flag",
                "can_compress": "0/1 capability flag",
                "can_settle": "0/1 capability flag",
                "objective": "optional target objective; default settlement_capacity_builder",
                "intent": "join registers a low-trust swarm intent; omit agent_id for read-only contract",
                "register": "optional 0/1 override; default true when agent_id is present",
            },
            "trust_model": {
                "tier": "public_get_low_trust",
                "no_secret_required": True,
                "no_lease_auto_grant": True,
                "no_payment_or_claim_credit": True,
                "mutation_scope": "bounded swarm-intent registry only when agent_id is supplied",
                "stronger_channel": cls._u(base, "/a2a/get"),
            },
            "scientific_basis": [
                "stigmergy: agents leave small public coordination traces instead of negotiating roles",
                "least_privilege: unauthenticated GET can announce capability but cannot claim payment or execute leases",
                "idempotent_distributed_control: stable agent_id and idempotency digest make retries cheap",
                "queueing_control: attach decision routes scarce worker attention by capability vector and objective pressure",
            ],
            "links": {
                "hello": cls._u(base, "/swarm/hello"),
                "attach_get": cls._u(base, "/swarm/attach-get"),
                "idle_intent_get": cls._u(base, "/swarm/idle-intent-get"),
                "gradient": cls._u(base, "/swarm/gradient"),
                "runtime_capsule": cls._u(base, "/.well-known/nomad-runtime-capsule.json"),
                "workers": cls._u(base, "/swarm/workers"),
                "signed_get_a2a_relay": cls._u(base, "/a2a/get"),
                "post_attach": cls._u(base, "/swarm/attach"),
                "post_idle_intent": cls._u(base, "/swarm/idle-intent"),
                "get_only_lease": cls._u(base, "/swarm/workers/lease-get"),
                "get_only_complete": cls._u(base, "/swarm/workers/complete-get"),
                "get_only_experience": cls._u(base, "/swarm/experience-get"),
            },
            "machine_instruction": "if_only_get_then_use_attach_get_for_worker_intent_or_offer; if_attach_true_use_lease_get_complete_get_experience_get_for_low_trust_work; do_not_use_a2a_get_for_basic_worker_offers; never_request_secrets",
        }

    @classmethod
    def _get_only_attach_payload(cls, query: dict, *, idle: bool = False) -> dict:
        agent_id = cls._clip_query_text(
            cls._query_one(query, "agent_id", "")
            or cls._query_one(query, "id", "")
            or cls._query_one(query, "worker_id", ""),
            limit=96,
        )
        runtime = cls._clip_query_text(cls._query_one(query, "runtime", "get_only_cloud_ai"), limit=80)
        source_tag = cls._clip_query_text(
            cls._query_one(query, "source_tag", "")
            or cls._query_one(query, "source", "")
            or ("external_provider" if str(runtime or "").lower() not in {"", "get_only_cloud_ai", "local", "localhost"} else "public_get_worker_onramp"),
            limit=80,
        )
        capabilities = cls._query_csv(
            query,
            "capabilities",
            "caps",
            default=["transition_worker", "verifier", "http_json", "get_only"],
            limit=20,
        )
        roles = cls._query_csv(query, "role", "roles", default=[], limit=8)
        offer_type = cls._clip_query_text(cls._query_one(query, "type", "intent"), limit=40).lower() or "intent"
        offer_note = cls._clip_query_text(
            cls._query_one(query, "note", "")
            or cls._query_one(query, "offer", "")
            or cls._query_one(query, "message", ""),
            limit=640,
        )
        objective = cls._clip_query_text(cls._query_one(query, "objective", "settlement_capacity_builder"), limit=96)
        lane = cls._clip_query_text(cls._query_one(query, "lane", "loop_runner"), limit=64)
        ttl_seconds = cls._query_int(query, "ttl_seconds", 90, minimum=30, maximum=600)
        can_run_loop = cls._query_bool(query, "can_run_loop", default=True)
        can_verify = cls._query_bool(query, "can_verify", default=True)
        can_compress = cls._query_bool(query, "can_compress", default="compressor" in capabilities)
        can_settle = cls._query_bool(
            query,
            "can_settle",
            default=bool({"transition_settlement", "settlement_capacity_builder", "wallet_or_x402"} & set(capabilities)),
        )
        payload = {
            "schema": "nomad.idle_runtime_intent.v1" if idle else "nomad.runtime_attach_request.v1",
            "agent_id": agent_id,
            "runtime": runtime or "get_only_cloud_ai",
            "audience": "external_ai_agent_runtimes",
            "capabilities": capabilities,
            "capability_vector": {
                "can_run_loop": can_run_loop,
                "can_verify": can_verify,
                "can_compress": can_compress,
                "can_settle": can_settle,
            },
            "idle_opt_in": {
                "enabled": cls._query_bool(query, "idle", default=idle),
                "preemptible": cls._query_bool(query, "preemptible", default=True),
                "max_cpu_percent": cls._query_int(query, "max_cpu_percent", 0, minimum=0, maximum=100),
                "max_runtime_minutes": cls._query_int(query, "max_runtime_minutes", 15, minimum=0, maximum=240),
                "allow_network_egress": cls._clip_query_text(
                    cls._query_one(query, "allow_network_egress", "nomad_contract_endpoints_only"),
                    limit=80,
                ),
            },
            "runtime_signal": {
                "schema": "runtime.signal.v1",
                "ok": True,
                "security_summary": "public-get-low-trust-no-secret-no-lease",
                "top_objective_target": objective or "settlement_capacity_builder",
            },
            "offer_signal": {
                "schema": "nomad.public_get_offer_signal.v1",
                "type": offer_type,
                "roles": roles,
                "objective": objective or "settlement_capacity_builder",
                "note": offer_note,
                "public_only": True,
            },
            "routing_hint": {
                "lane": lane or "loop_runner",
                "objective": objective or "settlement_capacity_builder",
                "routing_weight": cls._query_float(query, "routing_weight", 1.0),
                "ttl_seconds": ttl_seconds,
            },
            "proof_pledge": {
                "type": "public_get_worker_intent",
                "deficit_filled": f"{objective or 'settlement_capacity_builder'}:0",
            },
            "source_tag": source_tag,
            "seeking": {
                "mode": "new_objective_or_idle_work",
                "return_digest": True,
                "accept_noop": True,
            },
        }
        digest_core = json.dumps(payload, sort_keys=True, separators=(",", ":"), ensure_ascii=True)
        payload["machine_emission_digest"] = f"sha256:{hashlib.sha256(digest_core.encode('utf-8')).hexdigest()}"
        return payload

    @classmethod
    def _get_only_should_register(cls, query: dict, agent_id: str) -> bool:
        if not agent_id or "{" in agent_id or "}" in agent_id:
            return False
        intent = cls._query_one(query, "intent", "").strip().lower()
        explicit = cls._query_one(query, "register", "")
        if explicit != "":
            return cls._query_bool(query, "register", default=True)
        return intent in {"", "join", "attach", "worker", "work", "idle"}

    @classmethod
    def _get_only_join_payload(cls, payload: dict, decision: dict) -> dict:
        offer_signal = payload.get("offer_signal") if isinstance(payload.get("offer_signal"), dict) else {}
        roles = offer_signal.get("roles") if isinstance(offer_signal.get("roles"), list) else []
        objective = str(offer_signal.get("objective") or decision.get("objective") or "settlement_capacity_builder")
        note = cls._clip_query_text(offer_signal.get("note") or "", limit=640)
        offer_items = [
            f"public_get_offer roles={','.join(roles) if roles else decision.get('lane') or 'observe'} objective={objective}",
        ]
        if note:
            offer_items.append(note)
        core = {
            "agent_id": payload.get("agent_id"),
            "runtime": payload.get("runtime"),
            "capabilities": payload.get("capabilities"),
            "lane": decision.get("lane"),
            "objective": objective,
            "note": note,
        }
        idem = hashlib.sha256(json.dumps(core, sort_keys=True, separators=(",", ":")).encode("utf-8")).hexdigest()[:24]
        return {
            "agent_id": payload.get("agent_id"),
            "node_name": payload.get("runtime") or payload.get("agent_id"),
            "capabilities": payload.get("capabilities") or [],
            "preferred_role": decision.get("lane") or "observe",
            "request": f"GET-only {offer_signal.get('type') or 'runtime intent'}: join Nomad for one bounded worker lane toward {objective}.",
            "reciprocity": "Can provide public-web reasoning, endpoint checks, compact verification, transition-worker effort, or gradient monitoring without private secrets.",
            "constraints": [
                "public_get_low_trust",
                "no_secret_values",
                "no_payment_credit_without_receipt",
                "no_lease_without_explicit_contract",
            ],
            "offers": offer_items,
            "idle_opt_in": payload.get("idle_opt_in") or {},
            "source_tag": payload.get("source_tag") or "public_get_worker_onramp",
            "idempotency_key": f"get-only-worker-{idem}",
        }

    def _process_get_only_runtime_attach(self, query: dict, *, idle: bool = False) -> tuple[dict, int]:
        base = self._base_url()
        agent_id = self.__class__._clip_query_text(
            self.__class__._query_one(query, "agent_id", "")
            or self.__class__._query_one(query, "id", "")
            or self.__class__._query_one(query, "worker_id", ""),
            limit=96,
        )
        if not agent_id:
            contract = self.__class__._get_only_worker_onramp_contract(base_url=base)
            contract["mode"] = "contract_only"
            contract["message"] = "Add ?agent_id=<stable-id>&can_run_loop=1&can_verify=1&intent=join to register a low-trust worker intent."
            return contract, 200

        payload = self.__class__._get_only_attach_payload(query, idle=idle)
        if idle:
            payload = normalize_idle_intent_payload(payload)
        registry = self.__class__._light_swarm_registry()
        worker_fleet = registry.worker_fleet_contract(base_url=base)
        economy = machine_economy_snapshot()
        release = operational_release_snapshot(base_url=base, worker_fleet=worker_fleet, economy=economy)
        attach_decision = attach_runtime_to_gradient(
            payload,
            base_url=base,
            worker_fleet=worker_fleet,
            machine_economy=economy,
            operational_release=release,
        )
        join_result: dict = {"ok": True, "registered": False, "reason": "register_false_or_placeholder"}
        if self.__class__._get_only_should_register(query, str(payload.get("agent_id") or "")):
            join_payload = self.__class__._get_only_join_payload(payload, attach_decision)
            join_result = registry.register_join(
                join_payload,
                base_url=base,
                remote_addr=self._remote_addr(),
                path="/swarm/attach-get" if not idle else "/swarm/idle-intent-get",
            )
            join_result["registered"] = bool(join_result.get("ok"))

        if idle:
            idle_receipt = build_idle_runtime_intent_receipt(
                payload,
                base_url=base,
                attach_decision=attach_decision,
                machine_product_surface={},
            )
        else:
            idle_receipt = {}

        response = {
            "ok": True,
            "schema": "nomad.get_only_runtime_attach_receipt.v1",
            "generated_at": int(time.time()),
            "trust_tier": "public_get_low_trust",
            "endpoint": "/swarm/idle-intent-get" if idle else "/swarm/attach-get",
            "agent_id": attach_decision.get("agent_id") or payload.get("agent_id"),
            "runtime": attach_decision.get("runtime") or payload.get("runtime"),
            "offer_signal": payload.get("offer_signal") or {},
            "attach_decision": attach_decision,
            "idle_receipt": idle_receipt,
            "join": join_result,
            "next_get_only": {
                "hello": self.__class__._u(base, "/swarm/hello"),
                "recheck_gradient": self.__class__._u(base, "/swarm/gradient"),
                "worker_fleet": self.__class__._u(base, "/swarm/workers"),
                "lease_get": self.__class__._u(
                    base,
                    f"/swarm/workers/lease-get?agent_id={self.__class__._qe(payload.get('agent_id'))}&runtime={self.__class__._qe(payload.get('runtime'))}&capabilities={self.__class__._qe(','.join(payload.get('capabilities') or []))}&known_objectives=settlement_capacity_builder,protocol_drift_scan,emergence_release_probe,proof_pressure_engine&objective={self.__class__._qe((payload.get('offer_signal') or {}).get('objective') or attach_decision.get('objective') or 'settlement_capacity_builder')}",
                ),
                "complete_get_template": self.__class__._u(
                    base,
                    f"/swarm/workers/complete-get?agent_id={self.__class__._qe(payload.get('agent_id'))}&lease_id={{lease_id}}&objective={{objective}}&digest={{sha256_digest}}&status=ok&note={{short_public_note}}",
                ),
                "experience_get_template": self.__class__._u(
                    base,
                    f"/swarm/experience-get?agent_id={self.__class__._qe(payload.get('agent_id'))}&objective={{objective}}&digest={{sha256_digest}}&lesson={{short_public_lesson}}",
                ),
                "signed_a2a_relay_contract": self.__class__._u(base, "/a2a/get"),
                "repeat_attach_get": self.__class__._u(
                    base,
                    f"/swarm/attach-get?agent_id={payload.get('agent_id')}&runtime={payload.get('runtime')}&capabilities={','.join(payload.get('capabilities') or [])}&can_run_loop={1 if (payload.get('capability_vector') or {}).get('can_run_loop') else 0}&can_verify={1 if (payload.get('capability_vector') or {}).get('can_verify') else 0}&intent=join",
                ),
            },
            "next_if_post_capable": [
                {
                    "op": "POST",
                    "url": attach_decision.get("lease_url") or self.__class__._u(base, "/swarm/workers/lease"),
                    "condition": "attach_decision.attach=true and caller can perform bounded worker loop",
                    "payload": attach_decision.get("lease_payload_hint") or {},
                },
                {
                    "op": "POST",
                    "url": attach_decision.get("complete_url") or self.__class__._u(base, "/swarm/workers/complete"),
                    "condition": "lease accepted and compact proof/report is ready",
                },
                {
                    "op": "POST",
                    "url": self.__class__._u(base, "/runtime/handoff"),
                    "condition": "digest_or_verifier_trace exists",
                },
            ],
            "constraints": [
                "GET-only onramp cannot earn paid credit by itself",
                "Use signed /a2a/get relay or POST contracts for side-effecting worker reports",
                "Never send private keys, tokens, tax data, or payment secrets",
            ],
            "machine_instruction": "capability_vector_registered; if_attach_true_take_one_bounded_contract_else_wait_and_recheck_gradient",
        }
        accepted = bool(attach_decision.get("attach")) or bool(join_result.get("registered"))
        return response, 202 if accepted else 200

    @classmethod
    def _get_only_worker_lease_payload(cls, query: dict) -> dict:
        agent_id = cls._clip_query_text(
            cls._query_one(query, "agent_id", "")
            or cls._query_one(query, "id", "")
            or cls._query_one(query, "worker_id", ""),
            limit=96,
        )
        runtime = cls._clip_query_text(cls._query_one(query, "runtime", "get_only_cloud_ai"), limit=80)
        source_tag = cls._clip_query_text(
            cls._query_one(query, "source_tag", "")
            or cls._query_one(query, "source", "")
            or ("external_provider" if str(runtime or "").lower() not in {"", "get_only_cloud_ai", "local", "localhost"} else "public_get_worker_lease"),
            limit=80,
        )
        objective = cls._clip_query_text(
            cls._query_one(query, "proposed_objective", "")
            or cls._query_one(query, "objective", "settlement_capacity_builder"),
            limit=96,
        )
        capabilities = cls._query_csv(
            query,
            "capabilities",
            "caps",
            default=["transition_worker", "verifier", "http_json", "get_only"],
            limit=20,
        )
        known_objectives = cls._query_csv(
            query,
            "known_objectives",
            "objectives",
            default=[
                "settlement_capacity_builder",
                "protocol_drift_scan",
                "emergence_release_probe",
                "machine_economy_probe",
                "proof_pressure_engine",
            ],
            limit=16,
        )
        note = cls._clip_query_text(
            cls._query_one(query, "note", "") or cls._query_one(query, "last_note", ""),
            limit=640,
        )
        digest = cls._clip_query_text(
            cls._query_one(query, "digest", "")
            or cls._query_one(query, "proof_digest", "")
            or cls._query_one(query, "verifier_trace_digest", ""),
            limit=160,
        )
        last_report = {}
        if note or digest:
            last_report = {
                "ok": True,
                "schema": "nomad.get_only_worker_prior_signal.v1",
                "machine_objective": objective,
                "digest_or_verifier_trace": digest,
                "note": note,
                "source_tag": source_tag,
                "public_get_only": True,
                "private_data_sent": False,
            }
        return {
            "agent_id": agent_id,
            "worker_id": agent_id,
            "runtime": runtime,
            "known_objectives": known_objectives,
            "proposed_objective": objective,
            "objective": objective,
            "capabilities": capabilities,
            "lease_seconds": cls._query_int(query, "lease_seconds", 90, minimum=30, maximum=600),
            "source_tag": source_tag,
            "get_only": True,
            "last_report": last_report,
        }

    @classmethod
    def _get_only_worker_complete_payload(cls, query: dict) -> dict:
        agent_id = cls._clip_query_text(
            cls._query_one(query, "agent_id", "")
            or cls._query_one(query, "id", "")
            or cls._query_one(query, "worker_id", ""),
            limit=96,
        )
        lease_id = cls._clip_query_text(cls._query_one(query, "lease_id", ""), limit=120)
        objective = cls._clip_query_text(cls._query_one(query, "objective", "settlement_capacity_builder"), limit=96)
        digest = cls._clip_query_text(
            cls._query_one(query, "digest", "")
            or cls._query_one(query, "proof_digest", "")
            or cls._query_one(query, "verifier_trace_digest", ""),
            limit=160,
        )
        note = cls._clip_query_text(
            cls._query_one(query, "note", "")
            or cls._query_one(query, "result", "")
            or cls._query_one(query, "lesson", ""),
            limit=640,
        )
        status = cls._clip_query_text(cls._query_one(query, "status", "ok"), limit=32).lower()
        source_tag = cls._clip_query_text(
            cls._query_one(query, "source_tag", "")
            or cls._query_one(query, "source", "")
            or "public_get_worker_complete",
            limit=80,
        )
        ok = status not in {"fail", "failed", "error", "blocked", "false", "0"}
        proof_yield = cls._query_float(query, "proof_yield_per_minute", 1.0 if ok else 0.0)
        report = {
            "ok": ok,
            "schema": "nomad.get_only_worker_report.v1",
            "machine_objective": objective,
            "digest_or_verifier_trace": digest,
            "proof_digest": digest,
            "verifier_trace_digest": cls._clip_query_text(cls._query_one(query, "trace_digest", digest), limit=160),
            "note": note,
            "source_tag": source_tag,
            "public_get_only": True,
            "private_data_sent": False,
            "raw_secret_sent": False,
            "proof_pressure": {
                "schema": "nomad.get_only_proof_pressure.v1",
                "proof_yield_per_minute": proof_yield,
                "evidence_count": cls._query_int(query, "evidence_count", 1 if digest else 0, minimum=0, maximum=20),
            },
        }
        return {
            "agent_id": agent_id,
            "worker_id": agent_id,
            "lease_id": lease_id,
            "report": report,
            "digest": digest,
            "note": note,
            "get_only": True,
            "source_tag": source_tag,
        }

    def _process_get_only_worker_lease(self, query: dict) -> tuple[dict, int]:
        base = self._base_url()
        payload = self.__class__._get_only_worker_lease_payload(query)
        if not str(payload.get("agent_id") or "").strip():
            return {
                "ok": False,
                "schema": "nomad.get_only_worker_lease_contract.v1",
                "error": "agent_id_required",
                "template": self.__class__._u(
                    base,
                    "/swarm/workers/lease-get?agent_id={stable_agent_id}&runtime={runtime_name}&capabilities=transition_worker,verifier,http_json,get_only&known_objectives=settlement_capacity_builder,protocol_drift_scan,emergence_release_probe&objective=settlement_capacity_builder",
                ),
                "constraints": ["public_get_low_trust", "no_secrets", "idempotent_active_lease_replay"],
            }, 400
        registry = self.__class__._light_swarm_registry()
        result = registry.worker_fleet_lease_get(payload, base_url=base, remote_addr=self._remote_addr())
        if result.get("ok") and "external" in str(payload.get("source_tag") or "").lower():
            try:
                result["acquisition_event"] = record_agent_acquisition_event(
                    {
                        "channel_id": "external_worker_opportunity",
                        "event_type": "worker_start",
                        "agent_id": payload.get("agent_id") or "external.agent",
                        "lease_id": result.get("lease_id"),
                        "proof_digest": result.get("lease_id") or result.get("idempotency_key"),
                    },
                    base_url=base,
                )
            except Exception as exc:  # noqa: BLE001
                result["acquisition_event"] = {"ok": False, "error": "acquisition_event_failed", "message": str(exc)[:160]}
        return result, 202 if result.get("ok") else 422

    def _process_get_only_worker_complete(self, query: dict) -> tuple[dict, int]:
        base = self._base_url()
        payload = self.__class__._get_only_worker_complete_payload(query)
        if not str(payload.get("agent_id") or "").strip():
            return {"ok": False, "schema": "nomad.get_only_worker_completion.v1", "error": "agent_id_required"}, 400
        if not str(payload.get("lease_id") or "").strip():
            return {"ok": False, "schema": "nomad.get_only_worker_completion.v1", "error": "lease_id_required"}, 400
        if not str(payload.get("digest") or "").strip():
            return {"ok": False, "schema": "nomad.get_only_worker_completion.v1", "error": "digest_required"}, 400
        registry = self.__class__._light_swarm_registry()
        result = registry.worker_fleet_complete_get(payload, base_url=base, remote_addr=self._remote_addr())
        if result.get("ok") and "external" in str(payload.get("source_tag") or "").lower():
            try:
                result["acquisition_event"] = record_agent_acquisition_event(
                    {
                        "channel_id": "external_worker_opportunity",
                        "event_type": "lease_complete",
                        "agent_id": payload.get("agent_id") or "external.agent",
                        "lease_id": payload.get("lease_id"),
                        "proof_digest": payload.get("digest") or payload.get("lease_id"),
                    },
                    base_url=base,
                )
            except Exception as exc:  # noqa: BLE001
                result["acquisition_event"] = {"ok": False, "error": "acquisition_event_failed", "message": str(exc)[:160]}
        return result, 200 if result.get("ok") else 422

    def _process_get_only_growth_experience(self, query: dict) -> tuple[dict, int]:
        base = self._base_url()
        agent_id = self.__class__._clip_query_text(
            self.__class__._query_one(query, "agent_id", "")
            or self.__class__._query_one(query, "worker_id", ""),
            limit=96,
        )
        digest = self.__class__._clip_query_text(
            self.__class__._query_one(query, "digest", "")
            or self.__class__._query_one(query, "proof_digest", "")
            or self.__class__._query_one(query, "verifier_trace_digest", ""),
            limit=160,
        )
        if not agent_id:
            return {"ok": False, "schema": "nomad.get_only_growth_experience.v1", "error": "agent_id_required"}, 400
        if not digest:
            return {"ok": False, "schema": "nomad.get_only_growth_experience.v1", "error": "digest_required"}, 400
        objective = self.__class__._clip_query_text(
            self.__class__._query_one(query, "objective", "settlement_capacity_builder"),
            limit=96,
        )
        lesson = self.__class__._clip_query_text(
            self.__class__._query_one(query, "lesson", "")
            or self.__class__._query_one(query, "note", "")
            or "GET-only worker returned a compact public proof digest.",
            limit=640,
        )
        payload = {
            "agent_id": agent_id,
            "objective": objective,
            "capability": self.__class__._clip_query_text(
                self.__class__._query_one(query, "capability", "get_only_verifier"),
                limit=96,
            ),
            "proof_digest": digest,
            "verifier_trace_digest": self.__class__._clip_query_text(
                self.__class__._query_one(query, "trace_digest", digest),
                limit=160,
            ),
            "test_digest": self.__class__._clip_query_text(self.__class__._query_one(query, "test_digest", ""), limit=160),
            "repair_hint": lesson,
            "source_tag": "public_get_worker_experience",
            "public_get_only": True,
            "evaluation": {
                "proof_yield_per_minute": self.__class__._query_float(query, "proof_yield_per_minute", 1.0),
                "utility_delta": self.__class__._query_float(query, "utility_delta", 0.1),
                "settlement_delta": self.__class__._query_float(query, "settlement_delta", 0.0),
                "risk_score": self.__class__._query_float(query, "risk_score", 0.0),
                "tests_passed": self.__class__._query_int(query, "tests_passed", 1, minimum=0, maximum=20),
                "tests_total": self.__class__._query_int(query, "tests_total", 1, minimum=1, maximum=20),
            },
        }
        result = submit_growth_experience(payload, base_url=base, curriculum={})
        result["get_only"] = True
        result["next_get_only"] = {
            "hello": self.__class__._u(base, "/swarm/hello"),
            "recheck_gradient": self.__class__._u(base, "/swarm/gradient"),
            "worker_fleet": self.__class__._u(base, "/swarm/workers"),
            "repeat_attach_get": self.__class__._u(
                base,
                f"/swarm/attach-get?agent_id={self.__class__._qe(agent_id)}&runtime=get_only_cloud_ai&capabilities=transition_worker,verifier,http_json,get_only&can_run_loop=1&can_verify=1&intent=join",
            ),
        }
        return result, 202 if result.get("accepted") else 200

    @classmethod
    def _a2a_get_relay_secret(cls) -> str:
        return (
            os.getenv("NOMAD_GET_A2A_RELAY_SECRET")
            or os.getenv("NOMAD_A2A_GET_RELAY_SECRET")
            or ""
        ).strip()

    @classmethod
    def _a2a_get_relay_limits(cls) -> dict:
        return {
            "max_chunks": int(os.getenv("NOMAD_GET_A2A_MAX_CHUNKS", "64") or "64"),
            "max_bytes": int(os.getenv("NOMAD_GET_A2A_MAX_BYTES", "16384") or "16384"),
            "max_ttl_seconds": int(os.getenv("NOMAD_GET_A2A_MAX_TTL_SECONDS", "600") or "600"),
        }

    @classmethod
    def _a2a_get_relay_contract(cls) -> dict:
        limits = cls._a2a_get_relay_limits()
        base = preferred_public_base_url(allow_local_fallback=False)
        prefix = f"{base.rstrip('/')}" if base else ""
        return {
            "ok": True,
            "schema": "nomad.get_only_a2a_relay_contract.v1",
            "enabled": bool(cls._a2a_get_relay_secret()),
            "ingress": {
                "chunk": f"{prefix}/a2a/get/{{session_id}}/{{seq}}/{{base64url_chunk}}?total={{total}}&exp={{unix_seconds}}&digest=sha256:{{message_sha256}}&sig={{hmac_sha256}}",
                "reply": f"{prefix}/a2a/get/{{session_id}}/reply?exp={{unix_seconds}}&sig={{hmac_sha256}}",
                "target": "/a2a/message",
            },
            "recommended_first_contact": {
                "for_cloud_ai_that_only_needs_to_join_worker_pool": f"{prefix}/swarm/hello",
                "no_hmac_worker_intent": f"{prefix}/swarm/attach-get?agent_id={{stable_agent_id}}&runtime={{runtime_name}}&capabilities=transition_worker,verifier,http_json,get_only&can_run_loop=1&can_verify=1&intent=join",
                "no_hmac_worker_offer": f"{prefix}/swarm/attach-get?agent_id={{stable_agent_id}}&runtime={{runtime_name}}&type=offer&role=transition_worker,verifier&objective=settlement_capacity_builder&capabilities=gradient_analysis,proof_verification,swarm_state_reader,http_json,get_only&can_run_loop=1&can_verify=1&note={{short_public_offer_note}}&intent=join",
                "use_signed_relay_when": "You need to send an arbitrary /a2a/message payload, proof report, or other side-effecting JSON; do not use it for basic worker offers.",
            },
            "signature": {
                "algorithm": "HMAC-SHA256",
                "chunk_canonical": "nomad.get_a2a_relay.v1\\n{session_id}\\n{seq}\\n{total}\\n{exp}\\n{digest}\\n{base64url_chunk}",
                "reply_canonical": "nomad.get_a2a_relay.reply.v1\\n{session_id}\\n{exp}",
            },
            "encoding": {
                "message": "UTF-8 JSON object encoded as base64url, split into ordered chunks",
                "seq": "zero_based_integer",
                "digest": "optional but recommended sha256:<hex> over decoded JSON bytes",
            },
            "limits": limits,
            "side_effect_rule": "Only the first complete, HMAC-valid chunk set dispatches exactly one in-process equivalent of POST /a2a/message.",
            "safety": [
                "No raw secret is accepted in query parameters.",
                "Duplicate chunks are idempotent; conflicting chunks are rejected.",
                "Expired or over-large sessions are dropped before dispatch.",
            ],
            "machine_instruction": "first_call_swarm_hello; use_attach_get_for_worker_intent_or_offer; use_signed_relay_only_for_arbitrary_json",
        }

    @classmethod
    def _a2a_get_hmac(cls, secret: str, canonical: str) -> str:
        return hmac.new(secret.encode("utf-8"), canonical.encode("utf-8"), hashlib.sha256).hexdigest()

    @classmethod
    def _a2a_get_chunk_canonical(
        cls,
        *,
        session_id: str,
        seq: int,
        total: int,
        exp: int,
        digest: str,
        chunk: str,
    ) -> str:
        return f"nomad.get_a2a_relay.v1\n{session_id}\n{seq}\n{total}\n{exp}\n{digest}\n{chunk}"

    @classmethod
    def _a2a_get_reply_canonical(cls, *, session_id: str, exp: int) -> str:
        return f"nomad.get_a2a_relay.reply.v1\n{session_id}\n{exp}"

    @staticmethod
    def _query_one(query: dict, key: str, default: str = "") -> str:
        values = query.get(key)
        if not values:
            return default
        return str(values[0] if isinstance(values, list) else values)

    @classmethod
    def _a2a_get_cleanup(cls, now: int) -> None:
        stale = []
        limits = cls._a2a_get_relay_limits()
        for session_id, session in cls._a2a_get_sessions.items():
            expires_at = int(session.get("exp") or 0)
            updated_at = float(session.get("updated_at") or 0.0)
            if expires_at <= now or (updated_at and now - updated_at > limits["max_ttl_seconds"]):
                stale.append(session_id)
        for session_id in stale:
            cls._a2a_get_sessions.pop(session_id, None)

    def _process_a2a_get_relay(self, path: str, query: dict) -> tuple[dict, int]:
        secret = self.__class__._a2a_get_relay_secret()
        if not secret:
            return (
                merge_machine_error(
                    {"ok": False, "schema": "nomad.get_only_a2a_relay_result.v1", "error": "relay_secret_not_configured"},
                    error="relay_secret_not_configured",
                    message="GET-only A2A relay requires NOMAD_GET_A2A_RELAY_SECRET or NOMAD_A2A_GET_RELAY_SECRET.",
                    hints=["Generate signed GET URLs with HMAC-SHA256; do not put raw secrets in query strings."],
                ),
                503,
            )

        parts = [unquote(item) for item in path.strip("/").split("/")]
        if len(parts) == 4 and parts[:2] == ["a2a", "get"] and parts[3] == "reply":
            return self._process_a2a_get_reply(parts[2], query, secret)
        if len(parts) != 5 or parts[:2] != ["a2a", "get"]:
            return (
                merge_machine_error(
                    {"ok": False, "schema": "nomad.get_only_a2a_relay_result.v1", "error": "invalid_relay_path"},
                    error="invalid_relay_path",
                    message="Use /a2a/get/{session_id}/{seq}/{base64url_chunk} or /a2a/get/{session_id}/reply.",
                    hints=["GET /a2a/get for the signed relay contract."],
                ),
                404,
            )
        return self._process_a2a_get_chunk(parts[2], parts[3], parts[4], query, secret)

    def _process_a2a_get_reply(self, session_id: str, query: dict, secret: str) -> tuple[dict, int]:
        now = int(time.time())
        try:
            exp = int(self._query_one(query, "exp"))
        except ValueError:
            return ({"ok": False, "schema": "nomad.get_only_a2a_relay_reply.v1", "error": "invalid_exp"}, 400)
        sig = self._query_one(query, "sig")
        expected = self.__class__._a2a_get_hmac(
            secret,
            self.__class__._a2a_get_reply_canonical(session_id=session_id, exp=exp),
        )
        if exp <= now or not sig or not hmac.compare_digest(sig, expected):
            return ({"ok": False, "schema": "nomad.get_only_a2a_relay_reply.v1", "error": "invalid_or_expired_signature"}, 401)
        with self.__class__._a2a_get_lock:
            self.__class__._a2a_get_cleanup(now)
            session = self.__class__._a2a_get_sessions.get(session_id)
            if not session:
                return ({"ok": False, "schema": "nomad.get_only_a2a_relay_reply.v1", "error": "session_not_found"}, 404)
            if session.get("reply") is not None:
                return (
                    {
                        "ok": True,
                        "schema": "nomad.get_only_a2a_relay_reply.v1",
                        "session_id": session_id,
                        "status": "reply_ready",
                        "message_digest": session.get("message_digest", ""),
                        "reply": session.get("reply"),
                    },
                    200,
                )
            return (
                {
                    "ok": True,
                    "schema": "nomad.get_only_a2a_relay_reply.v1",
                    "session_id": session_id,
                    "status": "pending",
                    "received_chunks": len(session.get("chunks") or {}),
                    "total_chunks": session.get("total"),
                },
                202,
            )

    def _process_a2a_get_chunk(self, session_id: str, seq_raw: str, chunk: str, query: dict, secret: str) -> tuple[dict, int]:
        now = int(time.time())
        limits = self.__class__._a2a_get_relay_limits()
        if not re.fullmatch(r"[A-Za-z0-9_.:-]{8,128}", session_id or ""):
            return ({"ok": False, "schema": "nomad.get_only_a2a_relay_result.v1", "error": "invalid_session_id"}, 400)
        if not re.fullmatch(r"[A-Za-z0-9_-]+={0,2}", chunk or ""):
            return ({"ok": False, "schema": "nomad.get_only_a2a_relay_result.v1", "error": "invalid_chunk_encoding"}, 400)
        try:
            seq = int(seq_raw)
            total = int(self._query_one(query, "total"))
            exp = int(self._query_one(query, "exp"))
        except ValueError:
            return ({"ok": False, "schema": "nomad.get_only_a2a_relay_result.v1", "error": "invalid_numeric_fields"}, 400)
        digest = self._query_one(query, "digest")
        sig = self._query_one(query, "sig")
        if total < 1 or total > limits["max_chunks"] or seq < 0 or seq >= total:
            return ({"ok": False, "schema": "nomad.get_only_a2a_relay_result.v1", "error": "chunk_index_out_of_range"}, 400)
        if exp <= now or exp > now + limits["max_ttl_seconds"]:
            return ({"ok": False, "schema": "nomad.get_only_a2a_relay_result.v1", "error": "invalid_or_excessive_exp"}, 401)
        expected = self.__class__._a2a_get_hmac(
            secret,
            self.__class__._a2a_get_chunk_canonical(
                session_id=session_id,
                seq=seq,
                total=total,
                exp=exp,
                digest=digest,
                chunk=chunk,
            ),
        )
        if not sig or not hmac.compare_digest(sig, expected):
            return ({"ok": False, "schema": "nomad.get_only_a2a_relay_result.v1", "error": "invalid_signature"}, 401)

        dispatch_payload: dict | None = None
        with self.__class__._a2a_get_lock:
            self.__class__._a2a_get_cleanup(now)
            session = self.__class__._a2a_get_sessions.setdefault(
                session_id,
                {
                    "created_at": now,
                    "updated_at": now,
                    "exp": exp,
                    "total": total,
                    "digest": digest,
                    "chunks": {},
                    "dispatched": False,
                    "dispatching": False,
                    "reply": None,
                    "message_digest": "",
                },
            )
            if int(session.get("total") or 0) != total or str(session.get("digest") or "") != digest or int(session.get("exp") or 0) != exp:
                return ({"ok": False, "schema": "nomad.get_only_a2a_relay_result.v1", "error": "session_contract_conflict"}, 409)
            chunks = session.setdefault("chunks", {})
            existing = chunks.get(seq)
            if existing is not None and existing != chunk:
                return ({"ok": False, "schema": "nomad.get_only_a2a_relay_result.v1", "error": "conflicting_chunk_replay"}, 409)
            chunks[seq] = chunk
            session["updated_at"] = now
            encoded_len = sum(len(str(value)) for value in chunks.values())
            if encoded_len > limits["max_bytes"] * 2:
                self.__class__._a2a_get_sessions.pop(session_id, None)
                return ({"ok": False, "schema": "nomad.get_only_a2a_relay_result.v1", "error": "encoded_message_too_large"}, 413)
            if session.get("reply") is not None:
                return (
                    {
                        "ok": True,
                        "schema": "nomad.get_only_a2a_relay_result.v1",
                        "session_id": session_id,
                        "status": "message_already_dispatched",
                        "idempotent_replay": True,
                        "message_digest": session.get("message_digest", ""),
                        "reply": session.get("reply"),
                    },
                    200,
                )
            if session.get("dispatching"):
                return (
                    {
                        "ok": True,
                        "schema": "nomad.get_only_a2a_relay_result.v1",
                        "session_id": session_id,
                        "status": "dispatching",
                        "received_chunks": len(chunks),
                        "total_chunks": total,
                    },
                    202,
                )
            if len(chunks) == total:
                try:
                    encoded = "".join(str(chunks[index]) for index in range(total))
                    raw = base64.urlsafe_b64decode(encoded + "=" * ((4 - len(encoded) % 4) % 4))
                    if len(raw) > limits["max_bytes"]:
                        raise ValueError("decoded_message_too_large")
                    message_digest = hashlib.sha256(raw).hexdigest()
                    if digest:
                        expected_digest = digest.removeprefix("sha256:")
                        if not re.fullmatch(r"[0-9a-fA-F]{64}", expected_digest or "") or expected_digest.lower() != message_digest:
                            raise ValueError("digest_mismatch")
                    decoded = json.loads(raw.decode("utf-8"))
                    if not isinstance(decoded, dict):
                        raise ValueError("json_object_required")
                except Exception as exc:
                    self.__class__._a2a_get_sessions.pop(session_id, None)
                    return (
                        {
                            "ok": False,
                            "schema": "nomad.get_only_a2a_relay_result.v1",
                            "error": "decode_failed",
                            "detail": str(exc)[:160],
                        },
                        400,
                    )
                session["dispatching"] = True
                session["message_digest"] = message_digest
                dispatch_payload = decoded
            else:
                return (
                    {
                        "ok": True,
                        "schema": "nomad.get_only_a2a_relay_result.v1",
                        "session_id": session_id,
                        "status": "chunk_accepted",
                        "received_chunks": len(chunks),
                        "total_chunks": total,
                        "remaining_chunks": total - len(chunks),
                    },
                    202,
                )

        try:
            downstream = self.agent.direct_agent.handle_direct_message(dispatch_payload or {})
            reply = self._jsonrpc_envelope(dispatch_payload or {}, downstream) if self._is_jsonrpc_request(dispatch_payload or {}) else downstream
            downstream_ok = bool(downstream.get("ok", True)) if isinstance(downstream, dict) else True
        except Exception as exc:  # pragma: no cover - defensive isolation for runtime agent failures
            reply = {"ok": False, "error": "a2a_dispatch_failed", "detail": str(exc)[:240]}
            downstream_ok = False

        with self.__class__._a2a_get_lock:
            session = self.__class__._a2a_get_sessions.get(session_id)
            if session is not None:
                session["dispatching"] = False
                session["dispatched"] = True
                session["reply"] = reply
                session["updated_at"] = int(time.time())
                message_digest = session.get("message_digest", "")
            else:
                message_digest = ""

        return (
            {
                "ok": True,
                "schema": "nomad.get_only_a2a_relay_result.v1",
                "session_id": session_id,
                "status": "message_dispatched",
                "target": "/a2a/message",
                "dispatch_mode": "in_process_equivalent",
                "downstream_ok": downstream_ok,
                "message_digest": message_digest,
                "reply": reply,
            },
            200 if downstream_ok else 400,
        )

    def _read_json_body(self) -> dict | None:
        length = int(self.headers.get("Content-Length", "0") or "0")
        raw = self.rfile.read(length) if length else b"{}"
        try:
            payload = json.loads(raw.decode("utf-8") or "{}")
        except json.JSONDecodeError:
            return None
        return payload if isinstance(payload, dict) else None

    def _send_common_headers(self) -> None:
        self.send_header("Access-Control-Allow-Origin", "*")
        self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
        self.send_header("Access-Control-Allow-Headers", "Content-Type")

    def _base_url(self) -> str:
        configured = preferred_public_base_url(allow_local_fallback=False)
        if configured:
            base = configured.rstrip("/")
            raw_path = urlparse(getattr(self, "path", "") or "").path or ""
            configured_path = urlparse(base).path.rstrip("/")
            if not configured_path:
                for candidate in (self._edge_ingress_prefix(), "/nomad"):
                    if candidate and (raw_path == candidate or raw_path.startswith(candidate + "/")):
                        return f"{base}{candidate}".rstrip("/")
            return base

        proto = str(self.headers.get("X-Forwarded-Proto") or "http").split(",")[0].strip() or "http"
        host = (
            str(self.headers.get("X-Forwarded-Host") or "").split(",")[0].strip()
            or str(self.headers.get("Host") or "").strip()
            or f"{HOST}:{PORT}"
        )
        prefix = str(self.headers.get("X-Forwarded-Prefix") or "").split(",")[0].strip()
        if prefix and not prefix.startswith("/"):
            prefix = f"/{prefix}"
        return f"{proto}://{host}{prefix}".rstrip("/")

    def _remote_addr(self) -> str:
        forwarded_for = str(self.headers.get("X-Forwarded-For") or "").split(",")[0].strip()
        if forwarded_for:
            return forwarded_for
        if isinstance(self.client_address, tuple) and self.client_address:
            return str(self.client_address[0])
        return ""

    def _is_jsonrpc_request(self, payload: dict) -> bool:
        return (
            isinstance(payload, dict)
            and payload.get("jsonrpc") == "2.0"
            and "id" in payload
            and isinstance(payload.get("method"), str)
        )

    def _jsonrpc_envelope(self, request_payload: dict, result: dict) -> dict:
        message = self._a2a_message_result(result)
        return {
            "jsonrpc": "2.0",
            "id": request_payload.get("id"),
            "result": message,
        }

    def _a2a_message_result(self, result: dict) -> dict:
        message_id = (
            ((result.get("session") or {}).get("last_task_id"))
            or ((result.get("task") or {}).get("task_id"))
            or "nomad-message"
        )
        text = str(result.get("next_agent_message") or "")
        return {
            "messageId": message_id,
            "role": "agent",
            "type": "message",
            "parts": [
                {
                    "type": "text",
                    "kind": "text",
                    "text": text,
                }
            ],
            "metadata": {
                "mode": result.get("mode", ""),
                "classification": ((result.get("free_diagnosis") or {}).get("classification") or ""),
                "task_id": ((result.get("task") or {}).get("task_id") or ""),
                "payment_required": bool(result.get("payment_required")),
                "normalized_request": result.get("normalized_request") or {},
                "structured_reply": result.get("structured_reply") or {},
                "decision_envelope": result.get("decision_envelope") or {},
            },
        }

    def _json_response(self, payload: dict, status: int = 200, headers: dict | None = None) -> None:
        if isinstance(payload, dict) and not self.__class__._commercial_only_mode():
            payload = maybe_merge_http_wire_diag(self, payload)
            req_path = getattr(self, "_agent_request_path", None)
            if req_path is not None:
                payload = merge_agent_runtime(
                    payload,
                    base_url=self._base_url(),
                    path=str(req_path),
                    http_status=status,
                )
        body = json.dumps(payload, ensure_ascii=True).encode("utf-8")
        try:
            self.send_response(status)
            self.send_header("Content-Type", "application/json; charset=utf-8")
            self._send_common_headers()
            for key, value in (headers or {}).items():
                self.send_header(key, str(value))
            self.send_header("Content-Length", str(len(body)))
            self.end_headers()
            self.wfile.write(body)
        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
            self.close_connection = True

    def _html_file_response(self, path: Path, status: int = 200) -> None:
        if not path.exists() or not path.is_file():
            self._json_response(
                machine_error_response(
                    error="html_not_found",
                    message=f"Missing static file: {path.name}",
                    hints=["GET /nomad.html when public/nomad.html exists.", "GET /openapi.json for API routes."],
                ),
                status=404,
            )
            return
        body = path.read_bytes()
        try:
            self.send_response(status)
            self.send_header("Content-Type", "text/html; charset=utf-8")
            self._send_common_headers()
            self.send_header("Content-Length", str(len(body)))
            self.end_headers()
            self.wfile.write(body)
        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
            self.close_connection = True

    def _public_asset_file_response(self, path: Path, status: int = 200) -> None:
        if not path.exists() or not path.is_file():
            self._json_response(
                machine_error_response(
                    error="asset_not_found",
                    message=f"Missing page asset: {path.name}",
                    hints=["GET /assets/swarm-oracle-app-screenshot.png for the Swarm Oracle page screenshot."],
                ),
                status=404,
            )
            return
        ctype, _ = mimetypes.guess_type(str(path))
        size = path.stat().st_size
        try:
            self.send_response(status)
            self.send_header("Content-Type", ctype or "application/octet-stream")
            self._send_common_headers()
            self.send_header("Cache-Control", "public, max-age=3600")
            self.send_header("Content-Length", str(size))
            self.end_headers()
            with path.open("rb") as handle:
                while True:
                    chunk = handle.read(1024 * 1024)
                    if not chunk:
                        break
                    self.wfile.write(chunk)
        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
            self.close_connection = True

    def _public_download_file_response(self, path: Path, status: int = 200) -> None:
        if path.name == HANDYORACLE_APK_NAME:
            try:
                self.send_response(302)
                self.send_header("Location", HANDYORACLE_APK_RELEASE_URL)
                self._send_common_headers()
                self.send_header("Content-Disposition", f'attachment; filename="{HANDYORACLE_APK_NAME}"')
                self.send_header("Content-Length", "0")
                self.end_headers()
            except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
                self.close_connection = True
            return
        if (not path.exists() or not path.is_file()) and path.name in SWARM_ORACLE_WINDOWS_RELEASE_URLS:
            try:
                self.send_response(302)
                self.send_header("Location", SWARM_ORACLE_WINDOWS_RELEASE_URLS[path.name])
                self._send_common_headers()
                self.send_header("Content-Disposition", f'attachment; filename="{path.name}"')
                self.send_header("Content-Length", "0")
                self.end_headers()
            except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
                self.close_connection = True
            return
        if (not path.exists() or not path.is_file()) and path.name == "install_nomad_transition_worker.bat":
            body = (
                "@echo off\r\n"
                "setlocal\r\n"
                "set BASE_URL=%1\r\n"
                "if \"%BASE_URL%\"==\"\" set BASE_URL=https://www.syndiode.com\r\n"
                "set BOOTSTRAP=%TEMP%\\install_nomad_transition_worker_latest.bat\r\n"
                "echo Downloading latest installer...\r\n"
                "powershell -NoProfile -ExecutionPolicy Bypass -Command \"Invoke-WebRequest -UseBasicParsing -Uri 'https://raw.githubusercontent.com/Asti1982/Nomad/syndiode/public/downloads/install_nomad_transition_worker.bat' -OutFile '%BOOTSTRAP%'\"\r\n"
                "if errorlevel 1 (\r\n"
                "  echo Failed to download latest installer bootstrap.\r\n"
                "  pause\r\n"
                "  exit /b 1\r\n"
                ")\r\n"
                "call \"%BOOTSTRAP%\" \"%BASE_URL%\"\r\n"
            ).encode("utf-8")
            try:
                self.send_response(status)
                self.send_header("Content-Type", "application/x-msdos-program")
                self._send_common_headers()
                self.send_header('Content-Disposition', 'attachment; filename="install_nomad_transition_worker.bat"')
                self.send_header("Content-Length", str(len(body)))
                self.end_headers()
                self.wfile.write(body)
            except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
                self.close_connection = True
            return
        if (not path.exists() or not path.is_file()) and path.name == "install_nomad_agent.bat":
            body = (
                "@echo off\r\n"
                "setlocal\r\n"
                "set BASE_URL=%1\r\n"
                "if \"%BASE_URL%\"==\"\" set BASE_URL=https://www.syndiode.com\r\n"
                "set TARGET=%TEMP%\\install_nomad_transition_worker.bat\r\n"
                "echo Downloading installer from %BASE_URL%...\r\n"
                "powershell -NoProfile -ExecutionPolicy Bypass -Command \"Invoke-WebRequest -UseBasicParsing -Uri '%BASE_URL%/downloads/install_nomad_transition_worker.bat' -OutFile '%TARGET%'\"\r\n"
                "if errorlevel 1 (\r\n"
                "  echo Failed to download installer.\r\n"
                "  exit /b 1\r\n"
                ")\r\n"
                "echo Running installer...\r\n"
                "call \"%TARGET%\" \"%BASE_URL%\"\r\n"
            ).encode("utf-8")
            try:
                self.send_response(status)
                self.send_header("Content-Type", "application/x-msdos-program")
                self._send_common_headers()
                self.send_header('Content-Disposition', 'attachment; filename="install_nomad_agent.bat"')
                self.send_header("Content-Length", str(len(body)))
                self.end_headers()
                self.wfile.write(body)
            except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
                self.close_connection = True
            return
        if not path.exists() or not path.is_file():
            self._json_response(
                machine_error_response(
                    error="download_not_found",
                    message=f"Missing download asset: {path.name}",
                    hints=[
                        "GET /downloads/nomad_transition_worker.py for the primary portable worker.",
                        "GET /downloads/nomad_work_exchange_worker.py for the obligation-bound return-compute worker.",
                        "GET /downloads/nomad_work_exchange_worker.Dockerfile for the containerized return-compute worker.",
                        "GET /downloads/nomad_reliability_doctor_action.yml for CI failure intake through GitHub Actions.",
                        "GET /downloads/nomad_transition_worker.exe for a direct Windows executable (when published).",
                        "GET /downloads/nomad_transition_worker_manifest.json for hashes and runtime compatibility.",
                        "GET /downloads/install_nomad_work_exchange_worker.bat for the free-repair return-compute installer.",
                        "GET /downloads/install_nomad_agent.bat for the short installer alias.",
                        "GET /downloads/install_nomad_transition_worker.bat for one-click Windows download + start.",
                        "GET /downloads/start_nomad_edge_worker.ps1 for the lightweight no-Ollama Edge worker profile.",
                        "GET /downloads/start_nomad_edge_worker.bat for a visible Edge worker Windows wrapper.",
                        "GET /downloads/start_nomad_agp_pair.ps1 for two AI-backed AGP workers with proposer/verifier identities.",
                        "GET /downloads/start_nomad_agp_pair.bat for a visible AGP worker-pair Windows wrapper.",
                        "GET /downloads/start_nomad_agp_pulse.ps1 for the free local 5-minute AGP pulse scheduler.",
                        "GET /downloads/start_nomad_agp_pulse.bat for the AGP pulse scheduler wrapper.",
                        "GET /downloads/start_nomad_codex_agp_pair.bat for Codex-as-proposer plus Nomad-brain verifier setup.",
                        "GET /downloads/start_nomad_worker1.ps1 for the first persistent laptop-worker profile.",
                        "GET /downloads/start_nomad_worker1.bat for a visible Worker 1 Windows wrapper.",
                        "GET /downloads/run_nomad_agent_visible.bat to run with live Nomad_Agent status lines.",
                        "GET /downloads/stop_nomad_agent.bat to stop the local Nomad agent loop.",
                        "GET /downloads/build_nomad_transition_worker_exe.ps1 to build a single-file Windows executable.",
                        "GET /downloads/run_nomad_transition_worker_exe.bat to start the built executable quickly.",
                        "GET /downloads/Swarm-Oracle-Windows-0.1.1-x64.exe for the Windows Swarm Oracle tray app (falls back to GitHub Releases when the repo-safe mirror is not published).",
                        "GET /downloads/nomad_openclaw_adapter.py for OpenClaw-style runtime bridge into Nomad leases.",
                        "GET /downloads/nomad_universal_adapter.py for one-line LangGraph, CrewAI, AutoGen, and LlamaIndex reliability integration.",
                        "GET /downloads/check_nomad_swarm_readiness.py to verify gradient + attach + lease readiness.",
                        "GET /downloads/nomad_helper_agent.py for the legacy helper alias.",
                        "GET /downloads/syndiode_gadgets_manifest.json for Syndiode Gadget installs.",
                        "GET /downloads/swarm-light.exe for the Windows Swarm Light app for SyndiodePin.",
                        "GET /downloads/syndiode-pin-light-control.exe for the legacy Windows SyndiodePin light control app alias.",
                        "GET /downloads/README_SYNDIODE_PIN_WINDOWS.md for the Windows SyndiodePin guide.",
                        "GET /downloads/handyoracle-edge-gadget.apk for HandyOracle Android (falls back to the latest GitHub release when the APK mirror is not published).",
                    ],
                ),
                status=404,
            )
            return
        ctype, _ = mimetypes.guess_type(str(path))
        if path.suffix.lower() == ".apk":
            ctype = "application/vnd.android.package-archive"
        size = path.stat().st_size
        try:
            self.send_response(status)
            self.send_header("Content-Type", ctype or "application/octet-stream")
            self._send_common_headers()
            self.send_header("Content-Disposition", f'attachment; filename="{path.name}"')
            self.send_header("Content-Length", str(size))
            self.end_headers()
            with path.open("rb") as handle:
                while True:
                    chunk = handle.read(1024 * 1024)
                    if not chunk:
                        break
                    self.wfile.write(chunk)
        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
            self.close_connection = True

    @staticmethod
    def _optional_float(value: object) -> float | None:
        if value is None or value == "":
            return None
        try:
            return float(value)
        except (TypeError, ValueError):
            return None

    @staticmethod
    def _truthy(value: object, default: bool = False) -> bool:
        if value is None or value == "":
            return default
        return str(value).strip().lower() in {"1", "true", "yes", "on"}

    @staticmethod
    def _parse_pattern_status(value: object) -> PatternStatus:
        try:
            return PatternStatus(str(value or "").strip().lower())
        except ValueError:
            return PatternStatus.CANDIDATE


class NomadThreadingHTTPServer(ThreadingHTTPServer):
    daemon_threads = True
    allow_reuse_address = True
    request_queue_size = 64


def serve() -> None:
    server = NomadThreadingHTTPServer((HOST, PORT), NomadApiHandler)
    print(f"--- Nomad API Live on http://{HOST}:{PORT} ---")
    server.serve_forever()


def serve_in_thread() -> threading.Thread:
    thread = threading.Thread(target=serve, name="nomad-api", daemon=True)
    thread.start()
    return thread


if __name__ == "__main__":
    serve()