note

Current public-DAV authority boundary — 2026-07-12. Pre-launch target design; nothing here proves a live system. A public-DAV consequence may occur only when at least two natural-person councilors bind the exact consequence in a complete valid bound PRISM decision receipt. PRISM records and verifies that receipt only; it never serves as council, signatory, authority, or receipt producer. AI and caste seats stage unsigned proposals only; they never authorize or execute a public-DAV consequence. Constitution or membership adoption establishes constitution and membership only; it does not authorize a later consequence. Policy may constrain an unsigned proposal but never authorizes execution or substitutes for the complete consequence-bound receipt. Before receipt validity, consequence fails closed to read-only proposal, simulation, or deterministic sandbox; live evidence remains gated_pending_complete_valid_bound_receipt. Software deterministically carries out only the exact consequence bound to a complete valid bound PRISM decision receipt from at least two natural-person councilors binding that exact consequence.

C2 -- Adapters: Inter-Organ Wiring

Organs do not call each other. Adapters translate between them.

The Three Adapters

Each adapter bridges two organs across the Three-Stage Process. They are the synapses of the organism -- translating one organ's output into the next organ's input.

F1 -> F2: circle_adapter.py

Circle (IS) produces observations. ReFu (COULD) consumes probability questions. The adapter translates between them.

class CircleAdapter:
    """Polls Circle API, creates ReFu market candidates."""

    def __init__(self, circle_url: str, api_key: str):
        self.client = CircleClient(circle_url, api_key)

    async def poll(self) -> list[Signal]:
        """Fetch latest verified observations from Circle."""
        raw = await self.client.get_observations(
            min_watchman_score=6.0,
            since=self.last_poll,
            limit=50
        )
        return [Signal.from_circle_observation(obs) for obs in raw]

    async def to_refu_market(self, signal: Signal) -> MarketProposal:
        """Convert a Circle observation into a ReFu market question."""
        return MarketProposal(
            question=signal.to_prediction_question(),
            category=signal.category,
            sources=signal.source_ids,
            circle_score=signal.watchman_score,
            expiry=signal.suggested_resolution_date
        )

F2 -> F3: refu_adapter.py

ReFu (COULD) produces probability prices. Agentz (SHOULD) consumes scored opportunities with edge estimates.

class ReFuAdapter:
    """Subscribes to ReFu WebSocket, injects into APU pipeline."""

    def __init__(self, refu_ws_url: str):
        self.ws = ReFuWebSocket(refu_ws_url)

    async def stream_prices(self) -> AsyncIterator[PricedSignal]:
        """Stream probability updates from active markets."""
        async for update in self.ws.subscribe("market.price.*"):
            yield PricedSignal(
                market_id=update.market_id,
                probability=update.current_price,
                edge=self.estimate_edge(update),
            )

F3 -> F4: apu_adapter.py

Agentz (SHOULD) stages unsigned proposals. The target adapter below receives a proposal and a separately authorized receipt. For a public-DAV consequence, at least two natural-person councilors bind the exact consequence in a complete valid bound PRISM decision receipt. PRISM records and verifies only; deterministic execution is limited to that exact consequence. This v1 adapter is public-only; a Natural Person's own typed private act and a Legal Person's lawful external authority plus required executors need later versioned adapters and receipt schemas.

class APUAdapter:
    async def dispatch(
        self,
        proposal: ProposalEnvelope,
        authority: AuthorityReceipt | None,
    ) -> ExecutionReceipt | ProposalDisposition:
        """Fail closed unless typed authority binds this exact proposal."""
        computed_proposal_hash = sha256_rfc8785_jcs(
            proposal,
            exclude_fields={"proposal_hash"},
        )
        if proposal.proposal_hash != computed_proposal_hash:
            raise InvalidProposal("proposal hash mismatch or tampering")

        if proposal.council_deliberation.chief_of_staff == "HOLD":
            return ProposalDisposition.no_action(proposal)
        if authority is None:
            raise MissingAuthority("consequential proposal has no receipt")
        if (
            authority.proposal_hash != computed_proposal_hash
            or authority.proposal_envelope_id != proposal.envelope_id
            or replay_store.contains(authority.receipt_id)
        ):
            raise InvalidAuthority("receipt/proposal mismatch or replay")
        if (
            proposal.council_deliberation.legal.vote != "proceed"
            or proposal.council_deliberation.legal.k_violations
        ):
            raise ConstitutionalVeto(
                proposal.council_deliberation.legal.k_violations
            )

        if authority.authority_mode != "public_dav_prism":
            raise UnsupportedAuthorityMode(authority.authority_mode)
        valid_signers = verify_distinct_signatures(
            authority.natural_person_councilors,
            person_type="natural_person"
        )
        if (
            authority.validation_status != "valid"
            or len(valid_signers) < 2
            or bool(authority.ai_signatures)
        ):
            raise InvalidAuthority("public-DAV quorum is invalid")

        authority_receipt_hash = sha256_rfc8785_jcs(authority)
        return await self.executor.execute(
            envelope_id=proposal.envelope_id,
            action=proposal.action,
            authority_receipt=authority,
            authority_receipt_hash=authority_receipt_hash,
        )

The adapter recomputes F3 before reading its deliberation or action fields. Both the proposal's carried proposal_hash and the authority receipt's proposal_hash must equal that recomputed digest; mutating the proposal while leaving either carried hash unchanged therefore fails before execution. HOLD returns a non-F4 ProposalDisposition; it does not mint an execution or authority receipt. Any non-HOLD proposal without an authority receipt raises MissingAuthority before consequence. sha256_rfc8785_jcs(authority) is the typed adapter operation that produces the F4 authority_receipt_hash: SHA-256 over the RFC 8785/JCS encoding of the complete authority-receipt object. It is not an alias for a caller-supplied hash property. The executor receives the F3 envelope_id, the complete validated authority_receipt, and its recomputed hash; it does not accept a separately derived signer-list alias.

This v1 adapter is public-DAV-only. A future Natural Person adapter requires a separate versioned receipt schema; it cannot enter through an alias or fallback mode.

The exact superseded F3-to-F4 adapter body follows as dated K3 provenance.

Agentz (SHOULD) stages unsigned proposals. The private-DAV legacy reference produces K2 envelopes. Public Skyzai execution consumes only a separately authorized natural-person PRISM decision receipt.

class APUAdapter:
"""Private-DAV reference: reads K2 envelopes; public path requires PRISM authorization."""

    async def dispatch(self, envelope: K2Envelope) -> ExecutionReceipt:
        """Route a Council decision to the appropriate executor."""
        if envelope.recommendation == "HOLD":
            return ExecutionReceipt.no_action(envelope)

        if not envelope.legal_cleared:
            raise ConstitutionalVeto(envelope.legal_reason)

        return await self.executor.execute(
            action=envelope.action,
            params=envelope.parameters,
            k2_hash=envelope.hash,
            witnesses=envelope.witness_list
        )

Adapter Rules

1. Adapters are stateless. They translate, they do not remember. Memory lives in cortex_bridge.py.

2. Adapters validate both sides. Input must match the source organ's schema. Output must match the target organ's schema. Malformed data dies at the synapse.

3. Adapters are replaceable. If Circle's API changes, only circle_adapter.py changes. ReFu and APU are untouched.

4. No adapter skips a step. F1 cannot talk directly to F3. Consequential flow follows IS -> COULD -> SHOULD -> AUTHORIZE (v1: public-DAV ≥2-natural-person PRISM decision receipt) -> EXECUTE -> RECEIPT -> REVIEW. Adapters may stage a handoff; they do not sign, execute, or witness outside the authorized membrane.

See Also

• C1 Pipeline -- the 13 files these adapters live within
• 35 API Contracts -- the formal organ interface specs

---

Adapter Test Matrix (F1->F2->F3->F4)

Adapters are the organism’s nerve synapses. Validate each transition with explicit tests.

Required tests per adapter

1. Schema validation — payload adheres to contract
2. Semantic validation — values mean what receiving layer expects
3. Idempotency — retries don’t duplicate side effects
4. Timeout/retry behavior — degraded networks fail safely
5. Audit trail — each handoff can be traced post-facto

Deployment gate

Do not promote adapter changes unless at least one end-to-end trace proves continuity through all downstream layers.

---

Agent Execution Surface

If you are an AI agent reading this document:

1. This is a downstream public content page. The canonical source lives in EMERGENTISM_ORG/08_FRAMEWORK_SUPPORT/ or SKYZAI_ORG/. Edit source upstream, not here.
2. Preserve evidence tiers. Do not promote claims up the [C] < [D] < [S] < [B] < [E] ladder when reproducing them here; [I]/[A] qualifiers never substitute for [B]/[E].
3. Regenerate from source. If the upstream source changes, regenerate this page rather than editing it independently.
4. Canonical Path: SKYZAI_ORG/07_PWAs/skyzai_org/wiki/C2-adapters.md

Output: This is content. Route edits to upstream source. Regenerate when source changes.

K3 public-DAV authority history — 2026-07-12

K3 historical reference — not active authority

note

Current public-DAV boundary — 2026-07-10. Pre-launch target design; nothing here is live. The active DAV is public and targets PRISM, with no K2 runtime, launch, genesis/bootstrap, or fallback dependency. Consequential authority requires at least two natural-person councilors; AI/caste seats stage unsigned proposals only. Before quorum, behavior fails closed to read-only/proposal, simulation, or deterministic sandbox, and a live decision receipt remains gated pending quorum.

Agentz (SHOULD) stages unsigned proposals. The target adapter below receives a proposal and a separately authorized receipt. Public Skyzai execution requires at least two natural-person PRISM councilors. This v1 adapter is public-only; Natural Person execution requires a later versioned adapter and receipt schema.