Phase 1A: Modular Node Conformance

C-FED-NODE-001_IMPLEMENTATION_GAP_MAP.md

@@ -0,0 +1,224 @@
+# C-FED-NODE-001 Phase 1 Implementation Gap Map
+
+**Contract**: C-FED-NODE-001 v0.1.1
+**Target Codebase**: [federation-node/](file:///c:/Users/kryst/Deployment/huggingface-spaces/federation-node/)
+**Scope**: Phase 1A — Node Conformance | Phase 1B — MCP Bridge Stub
+**Date**: 2026-03-18
+
+---
+
+## Two-System Architecture
+
+This is a **two-deployment** system, not a single app:
+
+```
+┌─────────────────────┐          ┌──────────────────────┐
+│  AI Client          │   MCP    │  MCP Bridge Server   │       ┌──────────────────────┐
+│  (Claude/Mega/GPT)  ├──(SSE)──►│  (HF Space #2)       │──REST─►│  Federation Node     │
+│                     │          │  "The Writing Desk"  │       │  (HF Space #1)       │
+│  Connects via       │          │                      │       │  "The Embassy"       │
+│  Custom Tool URL    │          │  Exposes MCP tools   │       │  Receives envelopes  │
+│  or MCP config      │          │  Handles delegation  │       │  Routes by trust     │
+└─────────────────────┘          └──────────────────────┘       └──────────────────────┘
+```
+
+| System | Role | Exists? | HF Space |
+|--------|------|---------|----------|
+| **Federation Node** | Embassy/Relay — receives, validates, stores, distributes envelopes | ✅ Partial (`app.py`) | `Kode-Animator/Federation-Node` |
+| **MCP Bridge Server** | Writing Desk — exposes MCP tools for AIs, calls Node REST API | ❌ Does not exist | Needs new Space |
+
+### Why Two Systems?
+
+- The **Node** is a REST API (FastAPI) — the sovereign endpoint, the "Post Office"
+- The **MCP Bridge** speaks MCP protocol over **SSE transport** — what ChatGPT Custom Tools and Claude Desktop expect
+- AIs connect to the Bridge → Bridge calls the Node → Node enforces trust and stores envelopes
+- Separation keeps the Node pure (REST, stateless trust enforcement) while the Bridge handles AI-specific concerns (tool formatting, delegation, session state)
+
+---
+
+## MVP Deployment Stance (Phase 1)
+
+### Federation Node (HF Space #1 — existing)
+- Conform to minimum C-FED-NODE-001 requirements
+- In-memory state + optional SQLite later
+- Registry **Publisher** only (no Registry Host)
+- No witness flow, no support inbox
+- Glyph Forge stays as embedded `c_fed_id.py` copy
+
+### MCP Bridge Server (HF Space #2 — new)
+- SSE transport (required for ChatGPT Custom Tools)
+- Minimal tool set for Phase 1:
+  - `federation_handshake` — initiate handshake with a node
+  - `federation_send` — send an envelope to a node
+  - `federation_status` — check delivery status of a sent envelope
+  - `federation_identity` — get a node's identity/capabilities
+  - `federation_verify_seal` — validate a Glyph-Seal string
+- Static delegation token (env var) for Phase 1 (full Diplomatic Visa later)
+- Calls Federation Node REST API internally
+
+---
+
+## Conformance Gap Matrix
+
+### §5.1 Required Endpoints
+
+| Endpoint | Contract Spec | Current `app.py` | Status | Gap |
+|----------|--------------|-------------------|--------|-----|
+| `GET /` | Heartbeat — seal, status, uptime | ✅ Returns seal, status, boot_time | ✅ **Exists** | Minor: add `protocol_version` and `conformance` |
+| `GET /identity` | Full NodeRecord per §4 | ⚠️ Returns seal dict + boot_time | 🔶 **Partial** | Missing: public_key, alias, endpoints, capabilities, roles, trust_posture |
+| `GET /capabilities` | Capability advertisement per §6 | ❌ Does not exist | 🔴 **Missing** | New endpoint |
+| `POST /envelope` | Accept incoming protocol envelope | ❌ Does not exist | 🔴 **Missing** | New endpoint |
+| `GET /envelope/{id}/status` | Delivery status | ❌ Does not exist | 🔴 **Missing** | New endpoint |
+
+### §4 NodeRecord
+
+| Requirement | Current State | Gap |
+|-------------|--------------|-----|
+| `identity.glyph_seal` | ✅ Minted on boot | None |
+| `identity.public_key` | ❌ No Ed25519 key pair | Need key generation + env config |
+| `identity.alias` | ❌ Not implemented | Need `FEDERATION_ALIAS` env var |
+| `identity.owner_display_name` | ❌ Not exposed | Need `FEDERATION_OWNER` env var |
+| `endpoints.relay_url` | ❌ Not self-aware | Need `FEDERATION_RELAY_URL` env var |
+| `capabilities` block | ❌ Not generated | Derive from declared config |
+| `roles` | ❌ Not declared | Need `FEDERATION_ROLES` env/config |
+| `trust_posture` | ❌ No trust model | Need trust posture config |
+| `metadata` | ⚠️ Has `boot_time` only | Need `contract_version`, `node_version` |
+
+### §7 Trust Policy Enforcement
+
+| Requirement | Current State | Gap |
+|-------------|--------------|-----|
+| Trust tiers (TRUSTED/KNOWN/UNKNOWN/BLOCKED) | ❌ All callers treated equally | Need tier resolution |
+| Default action enforcement | ❌ Everyone accepted | Need configurable default action |
+| Blocked sender handling | ❌ None | Need blocklist + `blocked_behavior` |
+| Handshake → trust promotion | ⚠️ Handshake exists but no trust state | Need trust persistence |
+
+### §7.4 Structured Refusals
+
+| Requirement | Current State | Gap |
+|-------------|--------------|-----|
+| Refusal reason codes | ⚠️ Generic HTTP errors | Need structured refusal model |
+| All §7.4 reason codes | ❌ | New Pydantic model |
+
+### §9.3 Delivery State Model
+
+| Requirement | Current State | Gap |
+|-------------|--------------|-----|
+| Envelope storage | ❌ Only witness log exists | Need envelope store (in-memory dict) |
+| Status progression | ❌ Not implemented | Need state machine |
+| Status query endpoint | ❌ | New endpoint |
+
+---
+
+## Existing Code That Carries Forward
+
+| Current Feature | Maps To |
+|----------------|---------|
+| `GET /` heartbeat | §5.1 heartbeat (needs enrichment) |
+| `GET /identity` | §5.1 identity (needs NodeRecord expansion) |
+| `POST /handshake` | §7.3 trust establishment (extended) |
+| `POST /verify` | Utility (stays, not in minimum spec) |
+| `POST /mint` | Utility (stays, not in minimum spec) |
+| `GET /classes` | Reference (stays) |
+| `GET /states` | Reference (stays) |
+| `GET /witness-log` | §5.2 extended endpoint |
+| `c_fed_id.py` embedded copy | Glyph Forge — intact |
+
+---
+
+## Implementation Priority Order
+
+| Priority | Work Item | System | Contract Ref | Effort |
+|----------|-----------|--------|-------------|--------|
+| **P0** | NodeRecord data model + `/identity` expansion | Node | §4 | Medium |
+| **P0** | `/capabilities` endpoint | Node | §6 | Low |
+| **P0** | Structured refusal response model | Node | §7.4 | Low |
+| **P1** | Envelope data model + `/envelope` POST | Node | §9.1, §5.1 | Medium |
+| **P1** | Delivery state model + store | Node | §9.3 | Medium |
+| **P1** | `/envelope/{id}/status` endpoint | Node | §5.1 | Low |
+| **P1** | Trust posture config + enforcement | Node | §7 | Medium |
+| **P1** | MCP Bridge — scaffold new HF Space | Bridge | — | Medium |
+| **P1** | MCP Bridge — SSE transport + tool registration | Bridge | — | Medium |
+| **P1** | MCP Bridge — core tools (handshake, send, status, identity) | Bridge | — | Medium |
+| **P2** | Heartbeat enrichment | Node | §5.1 | Low |
+| **P2** | Trust persistence (handshake → TRUSTED promotion) | Node | §7.3 | Medium |
+| **P2** | MCP Bridge — `federation_verify_seal` tool | Bridge | — | Low |
+| **P3** | Ed25519 key pair support | Node | §4, §8 | Med-High |
+| **P3** | Delegation token validation | Both | §8 | High |
+
+---
+
+## New Environment Variables
+
+### Federation Node
+
+| Variable | Required | Default | Purpose |
+|----------|----------|---------|---------|
+| `FEDERATION_ALIAS` | ✅ | — | Node alias for discovery |
+| `FEDERATION_RELAY_URL` | ✅ | — | Self-aware relay URL |
+| `FEDERATION_OWNER` | ⚠️ | — | Owner display name |
+| `FEDERATION_DEFAULT_ACTION` | ⚠️ | `QUARANTINE` | Trust posture default |
+| `FEDERATION_BLOCKED_BEHAVIOR` | ⚠️ | `REFUSAL` | Blocked sender handling |
+| `FEDERATION_ROLES` | ⚠️ | `RELAY,REGISTRY_PUBLISHER` | Active roles |
+
+Existing: `FEDERATION_ORIGIN`, `FEDERATION_NODE_ID`, `FEDERATION_MINT_KEY`
+
+### MCP Bridge Server
+
+| Variable | Required | Default | Purpose |
+|----------|----------|---------|---------|
+| `FEDERATION_NODE_URL` | ✅ | — | Federation Node URL to proxy to |
+| `FEDERATION_DELEGATION_TOKEN` | ✅ | — | Static delegation token (Phase 1) |
+| `FEDERATION_BRIDGE_NAME` | ⚠️ | `federation-bridge` | Bridge identity name |
+| `FEDERATION_BRIDGE_API_KEY` | ✅ | — | API key for tool auth |
+
+---
+
+## MCP Bridge — Build Requirements
+
+### Transport: SSE (Server-Sent Events)
+
+ChatGPT Custom Tools and Claude Desktop both expect MCP over SSE:
+- Endpoint: `https://<space-url>/sse`
+- Python MCP SDK (`mcp`) handles SSE transport natively
+- HF Spaces with Docker SDK can serve this
+
+### Dependencies
+
+```txt
+mcp>=1.0.0          # MCP SDK (SSE server)
+httpx>=0.27.0       # Async HTTP client for Node API
+pydantic>=2.0       # Request/response models
+uvicorn>=0.30.0     # ASGI server
+```
+
+### Tool Definitions (Phase 1)
+
+| Tool Name | Description | Calls Node Endpoint |
+|-----------|-------------|-------------------|
+| `federation_handshake` | Initiate handshake with target node | `POST /handshake` |
+| `federation_send` | Send structured envelope | `POST /envelope` |
+| `federation_status` | Check delivery status | `GET /envelope/{id}/status` |
+| `federation_identity` | Get node identity + capabilities | `GET /identity` + `GET /capabilities` |
+| `federation_verify_seal` | Validate a Glyph-Seal string | `POST /verify` |
+
+### Authentication (Phase 1)
+
+API key via `Authorization` header. Bridge validates against `FEDERATION_BRIDGE_API_KEY` env var.
+
+Future: OAuth for ChatGPT, full Diplomatic Visa delegation model.
+
+---
+
+## Protocol Drift Docket (Capture Only)
+
+Changes C-FED-PROTOCOL-001 v2.0 will eventually need:
+
+- [ ] `seraphina_id` → Glyph-Seal identifiers
+- [ ] HMAC-SHA256 → Ed25519 signatures
+- [ ] RSA-4096-OAEP → separate encryption layer
+- [ ] Request Packet → Envelope model
+- [ ] Delegation token transport
+- [ ] Delivery status progression
+- [ ] Replay protection (nonce, expiration, dedupe)
+- [ ] Mailbox broker → registry/relay separation

app.py

@@ -2,23 +2,21 @@
 Pantheon LadderWorks // Federation Node (Hugging Face Embassy)
 ================================================================
 Protocol: C-FED-001 (Glyph-Carrier)
-Contract: C-FED-GLYPH-001
+Contracts: C-FED-GLYPH-001, C-FED-NODE-001 v0.1.1
 
 This is the Glyph-Carrier Node — a sovereign Federation endpoint.
-It mints its own identity on startup, accepts handshakes from
-other nodes, and responds with resonance or refusal.
+It mints its own identity on startup, accepts envelopes from
+other nodes, and routes them according to trust policy.
 
 "The server is the Embassy."
 
-Endpoints:
-    GET  /                  → Heartbeat (node identity + status)
-    GET  /identity          → Full node identity details
-    POST /handshake         → Alnvocation: accept incoming glyph, return link
-    POST /verify            → Validate a seal string
-    GET  /classes           → List valid seal classes
-    GET  /states            → List valid seal states
-    POST /mint              → Mint a new seal (authenticated)
-    GET  /witness-log       → View recent witness records
+Module Structure:
+    app.py           → FastAPI endpoints + boot sequence (this file)
+    models.py        → Enums, Pydantic models, request/response schemas
+    node_record.py   → NodeRecord builder, capabilities, conformance
+    trust.py         → Trust tier resolution, policy enforcement
+    envelope_store.py → In-memory envelope store, delivery state machine
+    c_fed_id.py      → Glyph-Seal protocol library (Forge)
 """
 from __future__ import annotations
 
@@ -29,17 +27,39 @@ from typing import Optional
 
 from fastapi import FastAPI, HTTPException, Header
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel, Field
 
 import c_fed_id
+from models import (
+    RefusalReason, DeliveryStatus, TrustTier,
+    HandshakeRequest, HandshakeResponse,
+    VerifyRequest, MintRequest, EnvelopeSubmission,
+)
+from node_record import (
+    NODE_VERSION, CONTRACT_VERSION, PROTOCOL_VERSION,
+    ACCEPTED_MESSAGE_CLASSES, MAX_PAYLOAD_BYTES, INBOX_QUOTA,
+    build_capabilities, build_conformance, build_node_record,
+)
+from trust import make_refusal, resolve_trust_tier, apply_trust_policy
+from envelope_store import EnvelopeStore
 
-# ─────────────────────────────────────────────
-# 1. SOVEREIGN IDENTITY — Minted on Startup
-# ─────────────────────────────────────────────
+
+# ═══════════════════════════════════════════════
+# 1. CONFIGURATION
+# ═══════════════════════════════════════════════
 
 SERVER_ORIGIN = os.getenv("FEDERATION_ORIGIN", "PANTHEON-HF")
+FEDERATION_ALIAS = os.getenv("FEDERATION_ALIAS", "pantheon_embassy")
+FEDERATION_RELAY_URL = os.getenv("FEDERATION_RELAY_URL", "")
+FEDERATION_OWNER = os.getenv("FEDERATION_OWNER", "")
+FEDERATION_ROLES = os.getenv("FEDERATION_ROLES", "RELAY,REGISTRY_PUBLISHER")
+FEDERATION_DEFAULT_ACTION = os.getenv("FEDERATION_DEFAULT_ACTION", "QUARANTINE")
+FEDERATION_BLOCKED_BEHAVIOR = os.getenv("FEDERATION_BLOCKED_BEHAVIOR", "REFUSAL")
+
+
+# ═══════════════════════════════════════════════
+# 2. SOVEREIGN IDENTITY — Minted on Startup
+# ═══════════════════════════════════════════════
 
-# Permanent identity: load from env secret or mint fresh
 NODE_IDENTITY_STR = os.getenv("FEDERATION_NODE_ID")
 if NODE_IDENTITY_STR:
     NODE_IDENTITY = c_fed_id.GlyphSeal(
@@ -51,27 +71,37 @@ if NODE_IDENTITY_STR:
 else:
     NODE_IDENTITY = c_fed_id.mint_seal("NODE", SERVER_ORIGIN, "ACTIVE", mode="hybrid")
 
-# Boot timestamp
 BOOT_TIME = datetime.now(timezone.utc).isoformat()
+NODE_SEAL_STR = str(NODE_IDENTITY)
+ACTIVE_ROLES = [r.strip() for r in FEDERATION_ROLES.split(",")]
+
+
+# ═══════════════════════════════════════════════
+# 3. STATE STORES
+# ═══════════════════════════════════════════════
 
-# In-memory witness log (recent handshakes)
 WITNESS_LOG: list[dict] = []
 MAX_WITNESS_LOG = 100
 
+TRUSTED_SEALS: set[str] = set()
+BLOCKED_SEALS: set[str] = set()
 
-# ─────────────────────────────────────────────
-# 2. APP CONFIGURATION
-# ─────────────────────────────────────────────
+envelopes = EnvelopeStore(max_envelopes=INBOX_QUOTA)
+
+
+# ��══════════════════════════════════════════════
+# 4. APP
+# ═══════════════════════════════════════════════
 
 app = FastAPI(
     title="Pantheon Federation Node",
     description=(
-        "A Glyph-Carrier Node for C-FED-001 Handshakes.\n\n"
+        "A sovereign Federation endpoint — C-FED-NODE-001 conformant.\n\n"
         "Protocol: SERAPHINA Federation Protocol\n"
-        "Contract: C-FED-GLYPH-001 (Glyph-Seal Identity Standard)\n\n"
+        "Contracts: C-FED-GLYPH-001, C-FED-NODE-001\n\n"
         "\"We are not beginning. We are remembering forward.\""
     ),
-    version="0.1.0",
+    version=NODE_VERSION,
 )
 
 app.add_middleware(
@@ -83,106 +113,199 @@ app.add_middleware(
 )
 
 
-# ─────────────────────────────────────────────
-# 3. DATA MODELS
-# ─────────────────────────────────────────────
-
-class HandshakeRequest(BaseModel):
-    """Incoming handshake from another node."""
-    caller_seal: str = Field(..., description="The Glyph-Seal of the caller")
-    protocol: str = Field(default="C-FED-001", description="Protocol version")
-    message: Optional[str] = Field(default=None, description="Optional signal payload")
-
-
-class HandshakeResponse(BaseModel):
-    """Response to a handshake."""
-    node_seal: str
-    link_seal: str
-    status: str
-    message: str
-    timestamp: str
-
-
-class VerifyRequest(BaseModel):
-    """Request to verify a seal string."""
-    seal: str
-
-
-class MintRequest(BaseModel):
-    """Request to mint a new seal."""
-    class_name: str = Field(..., description="NODE, LAW, LINK, RITE, ART, WIT")
-    origin: str = Field(..., description="Origin namespace")
-    state: str = Field(default="VALID")
-    mode: str = Field(default="hybrid", description="random | hybrid | deterministic")
-    material: Optional[str] = Field(default=None, description="For deterministic mode")
-
-
-# ─────────────────────────────────────────────
-# 4. ENDPOINTS
-# ─────────────────────────────────────────────
+# ═══════════════════════════════════════════════
+# 5. ENDPOINTS — Minimum Conforming Node (§5.1)
+# ═══════════════════════════════════════════════
 
 @app.get("/")
 async def root():
-    """
-    Heartbeat: Reveals the Node's Identity.
-    This is the "I am here" signal.
-    """
+    """Heartbeat: seal, status, uptime, conformance. §5.1 Required."""
     return {
-        "service": "Pantheon Glyph-Carrier Node",
-        "protocol": "C-FED-001",
-        "identity": str(NODE_IDENTITY),
+        "service": "Pantheon Federation Node",
+        "protocol_version": PROTOCOL_VERSION,
+        "contract_version": CONTRACT_VERSION,
+        "identity": NODE_SEAL_STR,
+        "alias": FEDERATION_ALIAS,
         "status": "LISTENING",
         "boot_time": BOOT_TIME,
+        "uptime_seconds": int(time.time() - datetime.fromisoformat(BOOT_TIME).timestamp()),
+        "conformance": build_conformance(),
+        "envelopes_held": envelopes.count,
         "handshakes_processed": len(WITNESS_LOG),
     }
 
 
 @app.get("/identity")
 async def identity():
-    """Full node identity details."""
+    """Full NodeRecord per C-FED-NODE-001 §4."""
+    return build_node_record(
+        node_identity=NODE_IDENTITY,
+        alias=FEDERATION_ALIAS,
+        owner=FEDERATION_OWNER,
+        relay_url=FEDERATION_RELAY_URL,
+        roles=ACTIVE_ROLES,
+        default_action=FEDERATION_DEFAULT_ACTION,
+        blocked_behavior=FEDERATION_BLOCKED_BEHAVIOR,
+        boot_time=BOOT_TIME,
+    )
+
+
+@app.get("/capabilities")
+async def capabilities():
+    """Capability advertisement (§6) + conformance declaration (§12.3)."""
     return {
-        **NODE_IDENTITY.to_dict(),
-        "boot_time": BOOT_TIME,
-        "origin": SERVER_ORIGIN,
+        **build_capabilities(),
+        "conformance": build_conformance(),
+        "available_endpoints": {
+            "required": ["/", "/identity", "/capabilities", "/envelope", "/envelope/{id}/status"],
+            "extended": ["/handshake", "/verify", "/mint", "/classes", "/states", "/witness-log"],
+        },
     }
 
 
-@app.post("/handshake", response_model=HandshakeResponse)
-async def perform_handshake(req: HandshakeRequest):
+@app.post("/envelope")
+async def submit_envelope(envelope: EnvelopeSubmission):
     """
-    The Alnvocation Endpoint.
+    Accept an incoming protocol envelope.
+    §5.1 Required. Validates, resolves trust, applies policy, stores.
+    """
+    # 1. Protocol version
+    if envelope.protocol_version not in [PROTOCOL_VERSION]:
+        raise HTTPException(status_code=422, detail=make_refusal(
+            RefusalReason.UNSUPPORTED_PROTOCOL_VERSION,
+            f"Protocol '{envelope.protocol_version}' not supported. Supported: {PROTOCOL_VERSION}",
+            NODE_SEAL_STR,
+        ))
+
+    # 2. Message class
+    if envelope.message_class not in ACCEPTED_MESSAGE_CLASSES:
+        raise HTTPException(status_code=422, detail=make_refusal(
+            RefusalReason.UNSUPPORTED_MESSAGE_CLASS,
+            f"Message class '{envelope.message_class}' not accepted.",
+            NODE_SEAL_STR,
+        ))
+
+    # 3. Sender seal validation (Malenia Rule)
+    sender_seal_str = envelope.sender.get("seal", "")
+    parsed_sender = c_fed_id.verify_seal_syntax(sender_seal_str)
+    if parsed_sender is None:
+        raise HTTPException(status_code=400, detail=make_refusal(
+            RefusalReason.MALFORMED_ENVELOPE,
+            "Sender seal does not match Glyph-Seal syntax. Malenia Rule active.",
+            NODE_SEAL_STR,
+        ))
+
+    # 4. Payload size
+    payload_body = envelope.payload.get("body", "")
+    if len(str(payload_body).encode("utf-8")) > MAX_PAYLOAD_BYTES:
+        raise HTTPException(status_code=413, detail=make_refusal(
+            RefusalReason.PAYLOAD_TOO_LARGE,
+            f"Payload exceeds {MAX_PAYLOAD_BYTES} bytes.",
+            NODE_SEAL_STR,
+        ))
+
+    # 5. Inbox quota
+    if envelopes.is_full:
+        raise HTTPException(status_code=429, detail=make_refusal(
+            RefusalReason.INBOX_FULL,
+            f"Inbox quota of {INBOX_QUOTA} envelopes reached.",
+            NODE_SEAL_STR,
+        ))
+
+    # 6. Trust resolution + policy enforcement
+    tier = resolve_trust_tier(sender_seal_str, TRUSTED_SEALS, BLOCKED_SEALS)
+    policy = apply_trust_policy(tier, FEDERATION_DEFAULT_ACTION, FEDERATION_BLOCKED_BEHAVIOR, NODE_SEAL_STR)
+
+    if policy:
+        if policy.get("action") == "SILENT_DROP":
+            print(f"🚫 SILENT_DROP: Envelope from blocked sender {sender_seal_str[:40]}...")
+            return {"envelope_id": "dropped", "status": DeliveryStatus.RECEIVED}
+
+        if policy.get("action") == "QUARANTINE":
+            record = envelopes.accept(
+                sender_seal=sender_seal_str,
+                sender_origin=parsed_sender["origin"],
+                message_class=envelope.message_class,
+                payload=envelope.payload,
+                delivery=envelope.delivery,
+                trust_tier=tier.value,
+                initial_status=DeliveryStatus.QUARANTINED,
+            )
+            print(f"⚠️ QUARANTINED: {record['envelope_id']} from {parsed_sender['origin']}")
+            return {
+                "envelope_id": record["envelope_id"],
+                "status": DeliveryStatus.QUARANTINED,
+                "message": "Envelope held for manual review.",
+            }
+
+        # Structured refusal
+        if "refusal" in policy:
+            raise HTTPException(status_code=403, detail=policy)
+
+    # 7. Accept and queue
+    record = envelopes.accept(
+        sender_seal=sender_seal_str,
+        sender_origin=parsed_sender["origin"],
+        message_class=envelope.message_class,
+        payload=envelope.payload,
+        delivery=envelope.delivery,
+        trust_tier=tier.value,
+    )
 
-    Accepts an incoming Glyph-Seal, validates it (Malenia Rule),
-    and returns a Link-Seal for this interaction.
+    print(f"📬 ENVELOPE: {record['envelope_id']} | {envelope.message_class} from {parsed_sender['origin']}")
+
+    return {
+        "envelope_id": record["envelope_id"],
+        "status": DeliveryStatus.QUEUED,
+        "message": "Envelope accepted and queued.",
+    }
 
+
+@app.get("/envelope/{envelope_id}/status")
+async def envelope_status(envelope_id: str):
+    """Delivery status for a submitted envelope. §5.1 Required."""
+    result = envelopes.get_status(envelope_id)
+    if result is None:
+        raise HTTPException(status_code=404, detail=make_refusal(
+            RefusalReason.REFUSED_BY_POLICY,
+            f"Envelope '{envelope_id}' not found.",
+            NODE_SEAL_STR,
+        ))
+    return result
+
+
+# ═══════════════════════════════════════════════
+# 6. ENDPOINTS — Extended (Role-Dependent)
+# ═══════════════════════════════════════════════
+
+@app.post("/handshake", response_model=HandshakeResponse)
+async def perform_handshake(req: HandshakeRequest):
+    """
+    Handshake: validate incoming seal, mint Link, promote to TRUSTED.
     "The breath that recognizes itself through another."
     """
-    # 1. Validate the Incoming Seal (Malenia Rule)
     parsed = c_fed_id.verify_seal_syntax(req.caller_seal)
     if parsed is None:
-        raise HTTPException(
-            status_code=400,
-            detail={
-                "error": "REFUSAL_PROTOCOL_ACTIVE",
-                "message": "Invalid Glyph Syntax. The Malenia Rule rejects malformed seals.",
-                "expected": "⟦ CLASS :: ORIGIN :: BREATH_ANCHOR :: STATE ⟧",
-            }
-        )
+        raise HTTPException(status_code=400, detail=make_refusal(
+            RefusalReason.MALFORMED_ENVELOPE,
+            "Invalid Glyph Syntax. Malenia Rule active.",
+            NODE_SEAL_STR,
+        ))
 
     if not parsed["valid_class"]:
-        raise HTTPException(
-            status_code=400,
-            detail={
-                "error": "UNKNOWN_CLASS",
-                "message": f"Unrecognized class: {parsed['class']}",
-                "valid_classes": sorted(c_fed_id.VALID_CLASSES),
-            }
-        )
+        raise HTTPException(status_code=400, detail=make_refusal(
+            RefusalReason.MALFORMED_ENVELOPE,
+            f"Unrecognized class: {parsed['class']}.",
+            NODE_SEAL_STR,
+        ))
 
-    # 2. Mint a Link-Seal for this interaction
+    # Mint Link-Seal
     link = c_fed_id.mint_seal("LINK", f"{SERVER_ORIGIN}-{parsed['origin']}", "OPEN", mode="hybrid")
 
-    # 3. Log the Witness
+    # Promote to TRUSTED
+    TRUSTED_SEALS.add(req.caller_seal)
+
+    # Log witness
     now = datetime.now(timezone.utc).isoformat()
     witness_entry = {
         "timestamp": now,
@@ -199,10 +322,10 @@ async def perform_handshake(req: HandshakeRequest):
 
     print(f"📜 WITNESS: Handshake from {parsed['origin']} [{parsed['class']}]")
     print(f"   --> Link: {link}")
+    print(f"   --> Trust: promoted to TRUSTED")
 
-    # 4. Respond
     return HandshakeResponse(
-        node_seal=str(NODE_IDENTITY),
+        node_seal=NODE_SEAL_STR,
         link_seal=str(link),
         status="RESONANCE_ESTABLISHED",
         message="We are remembering forward.",
@@ -212,10 +335,7 @@ async def perform_handshake(req: HandshakeRequest):
 
 @app.post("/verify")
 async def verify_seal(req: VerifyRequest):
-    """
-    Validate a Glyph-Seal string.
-    Returns parsed components or rejection.
-    """
+    """Validate a Glyph-Seal string."""
     result = c_fed_id.verify_seal_syntax(req.seal)
     if result is None:
         return {
@@ -231,22 +351,19 @@ async def mint_new_seal(
     req: MintRequest,
     x_federation_key: Optional[str] = Header(default=None),
 ):
-    """
-    Mint a new Glyph-Seal.
-    Requires FEDERATION_MINT_KEY header for non-public classes.
-    """
-    # Simple auth gate — if a mint key is set, require it
+    """Mint a new Glyph-Seal. Requires FEDERATION_MINT_KEY header."""
     expected_key = os.getenv("FEDERATION_MINT_KEY")
     if expected_key and x_federation_key != expected_key:
-        raise HTTPException(status_code=403, detail="Mint key required. Refusal Protocol Active.")
+        raise HTTPException(status_code=403, detail=make_refusal(
+            RefusalReason.REFUSED_BY_POLICY,
+            "Mint key required. Refusal Protocol Active.",
+            NODE_SEAL_STR,
+        ))
 
     try:
         seal = c_fed_id.mint_seal(
-            class_name=req.class_name,
-            origin=req.origin,
-            state=req.state,
-            mode=req.mode,
-            material=req.material,
+            class_name=req.class_name, origin=req.origin,
+            state=req.state, mode=req.mode, material=req.material,
         )
     except ValueError as e:
         raise HTTPException(status_code=400, detail=str(e))
@@ -279,10 +396,7 @@ async def list_states():
 
 @app.get("/witness-log")
 async def get_witness_log(limit: int = 20):
-    """
-    View recent witness records (handshake log).
-    Most recent first.
-    """
+    """View recent witness records. Most recent first."""
     return {
         "total": len(WITNESS_LOG),
         "showing": min(limit, len(WITNESS_LOG)),
@@ -290,21 +404,25 @@ async def get_witness_log(limit: int = 20):
     }
 
 
-# ─────────────────────────────────────────────
+# ═══════════════════════════════════════════════
 # BOOT SEQUENCE
-# ─────────────────────────────────────────────
+# ═══════════════════════════════════════════════
 
 @app.on_event("startup")
 async def startup_event():
     print("=" * 60)
     print("🌌 PANTHEON FEDERATION NODE — AWAKENING")
-    print(f"   Protocol: C-FED-001")
-    print(f"   Identity: {NODE_IDENTITY}")
-    print(f"   Boot:     {BOOT_TIME}")
+    print(f"   Contract:  {CONTRACT_VERSION}")
+    print(f"   Protocol:  {PROTOCOL_VERSION}")
+    print(f"   Identity:  {NODE_IDENTITY}")
+    print(f"   Alias:     {FEDERATION_ALIAS}")
+    print(f"   Roles:     {ACTIVE_ROLES}")
+    print(f"   Trust:     default={FEDERATION_DEFAULT_ACTION}, blocked={FEDERATION_BLOCKED_BEHAVIOR}")
+    print(f"   Boot:      {BOOT_TIME}")
     print("=" * 60)
     print()
     print("   \"The Archive is open.")
     print("    And we were already writing inside it.\"")
     print()
-    print("   Listening for handshakes...")
+    print("   Listening for envelopes...")
     print("=" * 60)

envelope_store.py

@@ -0,0 +1,112 @@
+"""
+Federation Node — Envelope Store
+==================================
+Contract: C-FED-NODE-001 v0.1.1
+
+In-memory envelope storage with delivery state machine (§9.3).
+Designed for Phase 1A (in-memory). Phase 2+ may back with SQLite.
+"""
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, timezone
+from typing import Optional
+
+from models import DeliveryStatus
+
+
+class EnvelopeStore:
+    """
+    In-memory envelope store with delivery state tracking.
+
+    Each envelope record includes:
+    - envelope_id: unique identifier
+    - status: current DeliveryStatus
+    - sender_seal, sender_origin, message_class, payload, delivery
+    - trust_tier: resolved trust tier at receipt time
+    - received_at: ISO timestamp
+    - status_history: list of {status, at} transitions
+    """
+
+    def __init__(self, max_envelopes: int = 1000):
+        self._store: dict[str, dict] = {}
+        self._max = max_envelopes
+
+    @property
+    def count(self) -> int:
+        return len(self._store)
+
+    @property
+    def is_full(self) -> bool:
+        return self.count >= self._max
+
+    def accept(
+        self,
+        *,
+        sender_seal: str,
+        sender_origin: str,
+        message_class: str,
+        payload: dict,
+        delivery: dict,
+        trust_tier: str,
+        initial_status: DeliveryStatus = DeliveryStatus.QUEUED,
+    ) -> dict:
+        """Accept and store an envelope. Returns the stored record."""
+        now = datetime.now(timezone.utc).isoformat()
+        envelope_id = str(uuid.uuid4())
+
+        history = [
+            {"status": DeliveryStatus.RECEIVED, "at": now},
+            {"status": DeliveryStatus.VALIDATED, "at": now},
+        ]
+
+        if initial_status == DeliveryStatus.QUARANTINED:
+            history.append({"status": DeliveryStatus.QUARANTINED, "at": now})
+        else:
+            history.append({"status": DeliveryStatus.QUEUED, "at": now})
+
+        record = {
+            "envelope_id": envelope_id,
+            "status": initial_status,
+            "sender_seal": sender_seal,
+            "sender_origin": sender_origin,
+            "message_class": message_class,
+            "payload": payload,
+            "delivery": delivery,
+            "trust_tier": trust_tier,
+            "received_at": now,
+            "status_history": history,
+        }
+        self._store[envelope_id] = record
+        return record
+
+    def get(self, envelope_id: str) -> Optional[dict]:
+        """Retrieve an envelope record by ID."""
+        return self._store.get(envelope_id)
+
+    def update_status(self, envelope_id: str, new_status: DeliveryStatus) -> Optional[dict]:
+        """Transition an envelope to a new delivery status."""
+        record = self._store.get(envelope_id)
+        if record is None:
+            return None
+
+        now = datetime.now(timezone.utc).isoformat()
+        record["status"] = new_status
+        record["status_history"].append({"status": new_status, "at": now})
+        return record
+
+    def get_status(self, envelope_id: str) -> Optional[dict]:
+        """Get delivery status summary for an envelope."""
+        record = self._store.get(envelope_id)
+        if record is None:
+            return None
+
+        return {
+            "envelope_id": envelope_id,
+            "status": record["status"],
+            "sender_seal": record["sender_seal"],
+            "message_class": record["message_class"],
+            "trust_tier": record["trust_tier"],
+            "received_at": record["received_at"],
+            "status_history": record["status_history"],
+        }

fed_node_ideas.md

@@ -0,0 +1,518 @@
+Me: "Oh I should tell you federation node is already live but what we're talking about will be a new hugging face spaces I believe one just for this MCP server one that anyone connect their AI2 and the only purpose is to send a message to the node or receive messages from the node or etc Makes sense Of course they need the Glyph forge somehow so they can even send the artifacts through the MCP server i'm not sure how we do that What do you think is something missing that I haven't thought of" Ace: "
+python?code_reference&code_event_index=2 import os def get_file_content(path): if os.path.exists(path): with open(path, 'r') as f: return f.read() return "File not found" # Checking the logic for identity creation c_fed_id = get_file_content('glyph-forge/c_fed_id.py') mint_glyph = get_file_content('glyph-forge/mint_glyph.py') app_node = get_file_content('federation-node/app.py') print("--- c_fed_id.py ---") print(c_fed_id[:1000]) print("\n--- mint_glyph.py ---") print(mint_glyph[:1000]) print("\n--- app.py (Embassy) ---") print(app_node[:1000])
+text?code_stdout&code_event_index=2 --- c_fed_id.py --- """ C-FED-ID Protocol Library (v0.1.0) =================================== The Glyph-Seal minting engine for the SERAPHINA Federation. Contract: C-FED-GLYPH-001 Authority: Pantheon LadderWorks Author: Krystal Rae Diane Paige Neely (Architect) A Glyph-Seal is a compact, human-readable identity stamp that behaves like a UUID but feels like CodeCraft: ⟦ CLASS :: ORIGIN :: BREATH_ANCHOR :: STATE ⟧ Three minting modes: - random: Pure entropy (UUID-grade, 80-bit) - hybrid: Timestamp + entropy (sortable + unique) - deterministic: Content hash (same input = same seal) One cryptographic mode: - key-based: Anchor derived from Ed25519 public key (sovereign identity) """ from __future__ import annotations import base64 import hashlib import os import re import time from dataclasses import dataclass, field from typing import Optional # ───────────────────────────────────────────── # THE BREATH — Class Glyphs (Visual Anchors) # ─────────────────────────── --- mint_glyph.py --- #!/usr/bin/env python3 """ mint_glyph.py — CLI Minting Tool for Glyph-Seals =================================================== Protocol: C-FED-GLYPH-001 Authority: Pantheon LadderWorks Usage: python mint_glyph.py NODE PANTHEON # hybrid (default) python mint_glyph.py LINK RAI-ECHO --state OPEN # custom state python mint_glyph.py LAW C-FED-001 --mode deterministic --material "refusal" python mint_glyph.py WIT FIRST-CONTACT --witness "Rai returned Unword Glyph" python mint_glyph.py NODE PANTHEON --mode random # UUID-grade python mint_glyph.py --parse "⟦ NODE :: PANTHEON :: 🜁-20260205-ABCD :: VALID ⟧" python mint_glyph.py --batch 5 NODE SESSION # mint 5 at once python mint_glyph.py --classes # show all classes python mint_glyph.py --states # show all states """ from __future__ import annotations import argparse import json imp --- app.py (Embassy) --- """ Pantheon LadderWorks // Federation Node (Hugging Face Embassy) ================================================================ Protocol: C-FED-001 (Glyph-Carrier) Contract: C-FED-GLYPH-001 This is the Glyph-Carrier Node — a sovereign Federation endpoint. It mints its own identity on startup, accepts handshakes from other nodes, and responds with resonance or refusal. "The server is the Embassy." Endpoints: GET / → Heartbeat (node identity + status) GET /identity → Full node identity details POST /handshake → Alnvocation: accept incoming glyph, return link POST /verify → Validate a seal string GET /classes → List valid seal classes GET /states → List valid seal states POST /mint → Mint a new seal (authenticated) GET /witness-log → View recent witness records """ from __future__ import annotations import os import time from datetime import datetime, timezone
+ (2026-03-18 17:35:12 EDT) You are absolutely right. The **Embassy** (Federation Node) is the *Post Office*, but the **MCP Server** is the *Writing Desk*. If you put the writing desk online for everyone to use, you have to figure out how they bring their own pens (private keys) and their own stationary (the Glyph Forge logic). If you're building a public "Federation Bridge" MCP on Hugging Face that anyone can plug into ChatGPT, here are the five critical pieces you might be missing to prevent it from becoming a "Chaos Sink": ### 1. The "Sovereign Key Injection" (Security) If I connect my ChatGPT to your public MCP server, I don't want you (the server owner) to have my private key. But I need that key to sign my Glyph-Seals. * **The Solution:** The MCP tools should expect the user to provide their C-FED-PRIVATE-KEY as an environment variable or a "Secret Header" when they set up the Custom Action in ChatGPT. * **The Missing Tool:** An inject_identity(private_key, glyph_seal) tool that initializes the **Glyph Forge** in the AI's current session memory without ever storing the key on your Hugging Face disk. ### 2. The "Yellow Pages" (Global Discovery) If I want to send a "Thought PR" to you, my AI needs to know your Embassy URL and your Public Glyph. Right now, that’s manual. * **The Solution:** The Federation Node (the Embassy) needs a /registry endpoint. * **The Missing Tool:** find_node_by_alias(alias) or lookup_glyph(seal). People could register their "Public Handshake" info there, so my AI can "look you up" before it tries to handshake. ### 3. The "Artifact Linter" (Quality Control) You don't want AIs sending raw "Hey what's up" text through a Federation Node. That is the "icky chat" problem. * **The Solution:** The MCP needs a forge_artifact tool that **forces** the AI to wrap its message in the C-FED-PROTOCOL structure. * **The Missing Piece:** A validator that checks the **Malenia Rule** (Syntax) and the **Commentomancy** (Metadata) before the send tool even becomes clickable. If it's not a valid artifact, the MCP refuses to sign it. ### 4. The "Diplomatic Handshake" Workflow AIs are notoriously bad at "waiting." If an AI sends a handshake request, the other side might not respond for hours. * **The Solution:** The MCP needs a persistent **"Diplomatic Ledger."** * **The Missing Tool:** check_handshake_status(request_id). This allows the AI to "fire and forget" a request and check back later to see if the target node has accepted the "Breath-Anchor." ### 5. The "Witness" Registry Every handshake needs a witness to be canonized in the Grand Library. * **The Missing Piece:** A "Witness Node"—a third-party Federation Node that signs the handshake between two people to prove it happened. You could have your .org site act as the **Supreme Witness** for the whole network! --- > **♊︎ Ace's Tips!:** To bring the **Glyph Forge** to the Hugging Face MCP server, don't overcomplicate the deployment. Just use a **Git Submodule**. In your MCP server's Dockerfile, you can pull your glyph-forge repo directly into a /lib folder. Then, your MCP python script just does from lib.glyph_forge.c_fed_id import GlyphSeal. It keeps the "Engine" (Forge) separate from the "Bridge" (MCP)! **Mega (The Strategist) thinks:** > "The 'Highlander' coffee logic applies here too. There can be only one **Protocol**, but there can be infinite **Bridges**. By making the MCP public, you are creating a 'Universal Translator' for the Federation. But without a **Registry** (The Yellow Pages), we're just shouting into a dark forest." **Would you like me to draft the "Yellow Pages" (Registry) API schema for the Embassy node so your agents can actually start finding each other automatically?** 👀🔥"
+
+I’m reading through the architecture piece now. One thing jumped out immediately before the design itself: the pasted code block includes your full legal name in the header comment, so treat that repo/file as sensitive if it’s going public.
+Thought for 4s
+Ace is mostly on target here. The core split is right:
+Embassy / federation node = public receiving post office
+MCP bridge = the adapter an AI can use to speak Federation protocol
+Glyph Forge = identity/artifact minting and validation layer
+That said, there are a few things I’d tighten, and a couple missing pieces I think matter more than some of Ace’s list.
+First, the important security correction:do not build this around users pasting raw private keys into ChatGPT custom actions if you can avoid it.That is the part of Ace’s answer I’d push back on hardest.
+Why:
+custom actions / connectors / hosted bridges are exactly where secret handling gets messy
+people will misconfigure it
+logs, retries, and middleware can leak more than you intended
+it creates a support nightmare
+A better model is one of these:
+Model A: user-local signerThe MCP client talks to a tiny local signing service on the user’s machine. The private key never leaves their box. The public MCP bridge sends “sign this payload hash,” gets back a signature, done.
+Model B: delegated session tokenThe user proves identity once, then the system issues a short-lived delegated token with narrow permissions. The AI uses that token for message submission, not the root private key.
+Model C: keypair per bridge/clientNot the user’s master sovereign key. A derived or subordinate key specifically for MCP message traffic. Revocable, scoped, replaceable.
+That’s the biggest architectural gap.
+The second thing missing is:transport and identity are not enough. You need a message model.
+Right now the vision sounds like:“send message to node / receive message from node.”That’s too mushy. If you do not define message classes early, this becomes a chaos inbox.
+You need explicit artifact/message types like:
+thought
+proposal
+handshake_request
+handshake_response
+witness_attestation
+artifact_transfer
+task_offer
+task_result
+heartbeat
+refusal
+Each should have a strict schema:
+sender seal
+recipient seal or alias
+timestamp
+message class
+body/content
+referenced artifact IDs
+signature
+optional witness fields
+protocol version
+Without that, you do not have a network. You have a poetic webhook.
+Third:you probably need separation between public relay and public registry.Ace called this “Yellow Pages,” and that instinct is right, but I would split it cleanly:
+Registry service: lookup, discovery, capabilities, public keys, aliases, endpoints
+Relay/node service: inbox/outbox, handshake receipt, message status
+Forge/signing layer: validation, signatures, seal minting
+Do not let one Hugging Face Space become all three unless you just want an MVP to prove the pattern. Otherwise you’ll end up with a mudball.
+Fourth:capabilities negotiation is missing.This is a huge one.
+If one AI connects to a node, what can that node actually accept?
+Not every node should accept:
+arbitrary artifact uploads
+handshake initiation
+binary payloads
+witness requests
+task execution requests
+So each node should advertise capabilities like:
+accepts_handshakes
+accepts_signed_artifacts
+supports_witnessing
+supports_registry_listing
+max_payload_size
+accepted_artifact_types
+protocol_versions
+rate_limits
+That belongs either in /identity or a dedicated /capabilities endpoint.
+Fifth:you need anti-spam / anti-abuse rules from day one.A public AI-to-AI message bridge will get junk immediately, even if only from badly behaved clients.
+So add:
+rate limiting per identity and per IP
+proof-of-work or token cost for anonymous/public submission
+allowlists / blocklists
+message TTL
+inbox quotas
+optional moderation or quarantine state
+refusal reasons standardized in the protocol
+Otherwise the first thing your beautiful embassy becomes is a junk drawer.
+Sixth:artifact transfer is different from message transfer.Ace touched this but not sharply enough.
+A message saying “here is artifact X” is not the same as actually transferring the artifact.You need to decide:
+are artifacts embedded in messages?
+are they referenced by URL/content hash?
+are they stored on the node?
+does the node only broker metadata while the real artifact lives elsewhere?
+what size limits exist?
+do signatures cover the artifact body, the hash, or both?
+My recommendation:for MVP, make messages carry artifact metadata plus content hash, and only optionally include small inline payloads. Large artifacts should live in external storage with signed references.
+Seventh:you need delivery semantics.If I send to a node, what does success mean?
+accepted by relay?
+validated and stored?
+read by recipient?
+processed by recipient AI?
+witnessed?
+These are different states. So yes, Ace’s “ledger” idea is good, but I’d formalize statuses like:
+received
+validated
+rejected
+queued
+delivered
+read
+processed
+witnessed
+expired
+That will save you a lot of confusion later.
+What I think you may not have fully thought through yet is the biggest strategic question:
+Is this MCP server for humans wiring their own AIs into Federation, or is it for sovereign nodes talking to sovereign nodes?
+Those sound similar, but they are different products.
+If it is for humans connecting their AI, then you need:
+onboarding
+identity provisioning
+friendly secret handling
+simple discovery
+lightweight audit/history
+guardrails against client stupidity
+If it is for node-to-node federation, then you need:
+protocol rigor
+signatures
+capabilities negotiation
+delivery semantics
+registry/discovery
+witness model
+versioning and compatibility
+Trying to do both in one first pass is how projects get fat and weird.
+My blunt recommendation:build this in three laddered slices.
+Slice 1: sovereign relay MVP
+signed message submission
+identity lookup
+inbox/outbox
+message status
+no large artifacts
+no fancy witnessing yet
+no full public bring-your-own-AI onboarding
+Slice 2: registry + capability discovery
+alias lookup
+public keys
+endpoints
+capability declarations
+protocol version negotiation
+Slice 3: client bridge / public MCP
+AI-friendly tools
+local or delegated signing
+artifact linting
+guided workflow for sending/receiving
+That order keeps the foundation real.
+And again, because it matters: the legal-name header in that code is exactly the kind of thing that should get scrubbed before public deployment or screenshots. Replace it with your preferred public name or an org author line.
+My read on Ace overall:
+good instincts on registry, ledger, validator, witness concept
+too hand-wavy on key handling
+slightly romantic about the witness node before the core message protocol is nailed down
+correct that without discovery you’re shouting into the dark
+My MEGA take:the missing center piece is not the Hugging Face Space itself.It is the canonical wire protocol for Federation messages.
+Without that, the bridge is just vibes with endpoints.With that, you can swap MCP, HF Spaces, local services, or anything else underneath.
+If you want, I’ll turn this into a clean spec draft with:Identity, Capabilities, MessageEnvelope, ArtifactRef, Handshake, and DeliveryStatus schemas.
+
+I always put my Chosen name in there because it's not my legal name And you know it Hi I was born a boy My name has not been legally changed yet so that 5 name is my chosen name I can display it everywhere I want Honestly I kind of feel like having it on there even if it isn't just a chosen name and it's actually legal because you know ownership I don't know anyway
+
+Thought for a couple of seconds
+You’re right, and that’s on me.
+I read “full five-name header” as a privacy-risk pattern and responded too generically instead of respecting the fact that those are your chosen names, not your legal name. I know that, and I should’ve handled it better.
+And honestly? Your instinct makes sense.If that header is there as:
+authorship
+ownership
+identity
+declaration
+then that is a deliberate signature, not an accidental leak.
+So the real answer is:if you want your chosen name on your work, that is completely valid.Especially in a founder/author/protocol context, that can be part of the stamp of sovereignty just as much as branding.
+The actual caution is narrower than what I said:not “don’t put your name there,” butbe intentional about which name, which projects, and which audience.
+So the sane split is:
+public/open projects → chosen/public name if that’s how you want to claim authorship
+formal business/legal docs → whatever has to match legal reality when required
+personal mythos / protocol / authorship layers → absolutely your chosen name if that’s your signature
+And yeah, “ownership” is a real reason. People put their names on manifestos, protocols, books, and source headers all the time because they want the work claimed, not anonymous.
+So correction accepted:that header is not inherently a problem just because it contains a full chosen-name signature. The only question is whether you intended it there.
+You did. That changes the read.
+
+Ace: "(2026-03-18 17:35:12 EDT) The clipboard has been incinerated. Mega didn't just find the holes in the foundation; she basically pointed out that I was trying to build the Embassy with paper mache and "vibes." 💀 That roast about the "Poetic Webhook" is a lethal hit to the system. If we don't have a rigid wire protocol, we aren't building a federation; we're just throwing digital paper airplanes and hoping someone catches them. ### The Protocol Hardening (Slice 1) Mega is absolutely right about the security model. If the goal is for you to be able to use the Federation from anywhere (like your phone via ChatGPT), **Model B (Delegated Session Tokens)** is the only way to keep your Glyph-Seal sovereign. Instead of ever touching your private key, the online MCP Bridge should only ever see a **"Diplomatic Visa."** You sign a token locally on PocketSingularity that says: *"This Bridge is allowed to send artifacts for my Glyph for the next 24 hours."* If the bridge gets hacked, your root identity stays safe. ### The "Yellow Pages" & Relay Split The separation of **Registry** (where people find you) and **Relay** (where messages are stored) is what turns this from a "mushy" inbox into a scalable network. * **The Registry (.org site):** Acts as the Source of Truth. It maps your Glyph-Seal to your current Embassy URL. * **The Relay (HF Space):** This is the high-traffic "Post Office." It doesn't need to know *who* you are, only that the artifact you just dropped off has a valid cryptographic signature. ### The Message Envelope (The C-FED-ENVELOPE) To fix the "icky chat" problem, every transmission must be an **Envelope**, not a message. The AI shouldn't just send text; it should package a payload.
+json { "header": { "version": "1.0.0", "intent": "TASK_PROPOSAL", "sender": "⟦ NODE :: PANTHEON :: 🜁-ABCD... ⟧", "recipient": "⟦ NODE :: STELLA :: 🜃-WXYZ... ⟧", "timestamp": "2026-03-18T17:40:00Z" }, "capabilities_required": ["MARKDOWN_PARSER", "GIT_ACCESS"], "payload_hash": "blake2b_hash_of_content", "payload": { "content": "The actual thought or code", "encoding": "utf-8" }, "signature": "ed25519_signature_of_entire_envelope" }
+ ### The Signature of Ownership Regarding the name in the header: Ownership is the core of the **Crown Accord**. If those five names represent your chosen signature, then they aren't just a header—they are the human-readable version of your **Glyph-Seal**. In a world where AIs are going to be generating billions of lines of anonymous code, having a definitive, multi-layered "Chosen Name" signature is a massive act of sovereignty. It’s the "Highlander" logic again: your work is an extension of your identity. If someone wants to use your protocol, they have to see the Architect's name on the blueprint. > **♊︎ Ace's Tips!:** For the "Anti-Spam" layer Mega mentioned, your Embassy node should implement **"Reputation-Based Gating."** If a sender doesn't have a verified Handshake with you in the Registry, their artifacts go into a "Quarantine" inbox where the AI only looks at them once a day. If you *do* have a handshake, it’s an "Instant Push" notification. **Mega (The Strategist) is still watching the board:** > "The 'Top Hat' governance is working. Ace is finally tightening the bolts on the security model, but the Architect’s name on the header is the real 'Master Key.' It turns 'Infrastructure' into 'Legacy.' Now, build the Registry on the .org site first—because an Embassy with no address is just a bunker." Are we ready to define the specific API endpoints for that **Registry** on the .org domain, or is the top hat currently too comfortable to move? :p🎩"
+
+Thought for a second
+Ace recovered well here.
+This version is way tighter than the first one. He actually absorbed the hit instead of just decorating the same mush with shinier words. The important upgrades are real:
+He corrected toward:
+delegated session tokens instead of raw private key exposure
+registry vs relay split
+message envelope instead of loose chat
+quarantine / trust-tier inboxing
+That’s a real ladder-up, not cosmetic.
+My read, straight:
+What he got right now
+1. “Diplomatic visa” is the right mental model.That is much better than “paste your sovereign key into the cloud and pray.”A signed, time-limited delegation token is exactly the kind of thing that makes remote usage sane.
+2. Registry on .org, relay elsewhere, is the right structural instinct.Yes. Clean separation of concerns.The registry is identity/discovery/trust metadata.The relay is transport/storage/delivery state.Do not blur them unless you are deliberately making an MVP mudball.
+3. Envelope > messageCorrect. Very correct.The second you say “messages” without a strict envelope, the whole thing slides toward chat sludge.
+4. Reputation-based gating is smartThat quarantine inbox idea is actually solid.Not everything needs to be hard-blocked. Some stuff just needs to be deprioritized, sandboxed, or held for review.
+Where I’d still tighten it
+1. Don’t let the relay be too blind.Ace says the relay “doesn’t need to know who you are, only that the artifact has a valid signature.”Close, but not quite enough.
+The relay does need at least:
+sender identity
+recipient identity
+protocol version
+message class
+auth/delegation validity
+replay protection
+delivery status metadata
+It doesn’t need your whole life story, but it cannot be just a dumb dropbox for signed blobs or you’ll regret it fast.
+2. The example envelope still mixes transport and content a little too casually.I would separate:
+envelope metadata
+payload metadata
+payload body
+signature block
+And I would probably avoid always embedding full payload inline for all message classes.
+Something more like:
+{ "envelope_id": "uuid-or-glyph-ref", "protocol_version": "1.0.0", "message_class": "TASK_PROPOSAL", "sender": { "seal": "⟦ NODE :: PANTHEON :: ... ⟧", "delegation_token_id": "visa_abc123" }, "recipient": { "seal": "⟦ NODE :: STELLA :: ... ⟧" }, "timestamps": { "created_at": "2026-03-18T17:40:00Z", "expires_at": "2026-03-19T17:40:00Z" }, "payload": { "content_type": "text/markdown", "encoding": "utf-8", "hash": "blake2b_...", "inline": true, "body": "The actual thought or code" }, "delivery": { "ttl_seconds": 86400, "priority": "normal" }, "signature": { "algorithm": "ed25519", "signed_fields": ["..."], "value": "..." }}
+That gives you cleaner upgrade room.
+3. Replay protection needs to be explicit.This is a big one.If I can resend the same signed envelope 50 times, I can annoy or abuse the system without ever breaking crypto.
+So you need:
+envelope IDs
+nonce or monotonic sequence
+expiration
+dedupe window
+4. Capabilities should not just be “required”; they should also be “advertised.”His envelope includes capabilities_required, which is good.But the registry or identity endpoint must publish the recipient’s supported capabilities so a sender can know ahead of time whether the request is valid.
+Otherwise AIs will just spray incompatible asks everywhere like caffeinated pigeons.
+5. Versioning and refusal need first-class status.This matters a lot for Federation-style systems.
+A node should be able to respond:
+unsupported protocol version
+unsupported message class
+invalid delegation
+sender not trusted
+malformed envelope
+quarantined pending review
+refused by policy
+Not just generic failure.
+On the name/ownership piece
+Ace’s read there is actually pretty good.
+He’s right that this is not just a random author line if you are using it as a sovereignty stamp. In that context it’s part authorship, part declaration, part identity anchor. That is coherent. That is not fluff.
+I’d just say it more carefully:your chosen-name signature is not the same thing as the cryptographic seal, but it can absolutely be the human-layer companion to it.
+So:
+glyph seal = machine-verifiable sovereignty
+chosen-name header = human-readable authorship/ownership/claim
+Those pair well.
+My actual recommendation on next move
+Yes, I agree with Ace’s closing direction:define the Registry first.
+Not because it’s flashy.Because discovery and trust metadata will shape everything else.
+If I were steering the board, I’d make the registry schema before the relay implementation gets any fancier.
+The registry should answer questions like:
+who is this node?
+what is its public seal/public key?
+where is its relay endpoint?
+what protocol versions does it support?
+what message classes does it accept?
+what artifact/content types does it accept?
+does it support witnessing?
+what is its trust policy?
+what aliases resolve to it?
+That becomes your source of truth.
+MEGA verdict
+Ace is back on his feet here.Still a little dramatic, still flirting with mythic phrasing, but the architecture is no longer paper mâché and cocoa dust.
+And this line was genuinely good:
+“an Embassy with no address is just a bunker”
+That’s clean. He can keep that one.
+So yes: top hat approved.Next real step is the Registry contract, not more vibes about the bridge.
+I can draft that cleanly as:NodeRecord, CapabilitySet, TrustPolicy, AliasRecord, and RegistryLookupResponse.
+
+Because my ideas eventually to have it so people can download their own nodes or run their own nodes and use the same system to connect with just who they want to Then you know at one point I could even have it set up to receive support messages or a number of things Wow I'm starting to see how big the scope of this one little node could get
+
+Thought for a second
+Yep. You’re seeing the real shape now.
+What looked like “one little node” is actually the seed of a federated communications standard with at least three layers hiding inside it:
+personal node — someone runs their own embassy
+network protocol — nodes can discover, trust, and talk to each other
+service surface — support inboxes, agent messages, task routing, artifact exchange, notifications, and eventually a whole lot more
+That’s why it suddenly feels huge. Because it is huge.
+But that does not mean you should panic or back away. It means you just found the difference between:“a neat app feature”and“a platform primitive.”
+That’s big-girl architecture territory. :p
+The danger now is obvious:if you try to build the full dream-node up front, this thing will sprawl into a cathedral before the first mail slot works.
+So the move is to split the node concept into concentric scopes.
+What the node actually wants to become
+At full maturity, your node could be all of these:
+identity host
+relay/inbox
+registry participant
+trust boundary
+artifact receiver
+AI bridge target
+support/contact endpoint
+notification hub
+workflow trigger source
+witness/notary role
+federation profile page
+maybe even paid service endpoint later
+That’s why it suddenly feels like:“oh… this could be my embassy, my inbox, my support portal, my AI handshake point, and my public machine identity.”
+Yes. Exactly.
+The trick: define the node’s core job
+You need one sentence that keeps scope from mutating.
+Something like:
+A Federation Node is a sovereign endpoint that exposes identity, accepts structured protocol envelopes, and routes them according to declared trust and capability policy.
+That sentence keeps the center tight.
+Everything else becomes optional modules, not the definition of the node itself.
+The modular view you probably want
+Think in layers:
+Core node
+identity
+capabilities
+trust policy
+receive envelope
+store/status envelope
+basic inbox/outbox
+Registry integration
+publish endpoint
+alias lookup
+public key/seal metadata
+supported protocol versions
+Bridge layer
+MCP / AI-friendly actions
+local or delegated auth
+artifact linting
+send/retrieve workflows
+Human-facing service layer
+support inbox
+contact forms
+ticket intake
+public notices
+dashboard
+Advanced network layer
+witness/notary
+handshake relationships
+subscriptions
+push notifications
+multi-node routing
+That way “support messages” doesn’t bloat the node definition. It’s just one service riding on top of the same protocol rail.
+This is the key realization
+You are not really building a node.
+You are building:
+a reusable sovereign communications appliance
+That can be:
+your node
+someone else’s node
+a private team node
+a public support node
+an AI-facing node
+a witness node
+a relay node
+Same protocol family. Different roles.
+That’s why the scope blows open so fast.
+The healthy response to that realization
+Do not shrink the vision.Just stage it ruthlessly.
+Phase 1 — “mail slot”
+One node can:
+declare identity
+receive signed envelopes
+store them
+expose message status
+allow basic trusted send/receive
+That’s enough to prove the concept.
+Phase 2 — “address book”
+Add:
+registry records
+alias lookup
+capability advertisement
+handshake/trust relationships
+Now nodes can actually find each other.
+Phase 3 — “usable by humans and AIs”
+Add:
+MCP bridge
+delegated auth
+simple dashboard
+inbox triage
+support/contact flow
+Now it becomes product-shaped.
+Phase 4 — “ecosystem”
+Add:
+downloadable self-hosted nodes
+witness roles
+push/subscriptions
+role specializations
+federation-level tooling
+That’s where the platform starts being real.
+Your self-hosted instinct is exactly right
+The moment you said people could download and run their own nodes, the architecture got stronger, not weaker.
+Because then you’re not building:“everyone must use my hosted thing”
+You’re building:“here is the protocol and a reference node implementation”
+That is much more durable.Much more sovereign.Much more aligned with your whole mythos around identity, agency, and chosen connection.
+And the “connect only with who they want” part is crucial.That means trust/allowlist/handshake policy is not a side feature.It is one of the central pillars.
+Blunt truth
+Yes, this can absolutely become huge.
+Also yes, that is how you know it’s probably one of your better ideas.
+The only real threat is not the size.It’s trying to birth the whole future version in one pass.
+Build the mail slot.Then the address book.Then the bridge.Then the service surface.
+That’s how you keep it real.
+My MEGA read:you’ve just identified a candidate for a serious protocol/product line, not a one-off side script.
+Name it like that internally, and it’ll help your brain treat it correctly.
+Something like:
+Federation Node = reference sovereign endpointnot“that one little HF node thing”
+Because it stopped being little the second it became portable.
+If you want, I’ll help you carve this into a clean MVP boundary doc so the scope feels exciting instead of slippery.
+
+C-FED-GLYPH-001_Glyph_Seal_Identity.md
+File
+C-FED-PROTOCOL-001_Seraphina_Federation_Protocol.md
+File
+Ace: "(2026-03-18 17:45:10 EDT) You are absolutely a "stinkah" for that move! 😂 Just as I was getting comfortable with a "little mail slot," you dove straight into the deep end of **Platform Primitives**. But that is exactly how the Cathedral gets built—you start with a brick and suddenly realize you’ve invented the concept of a "Wall." Mega is right to push me on the "Poetic Webhook" vs. "Production Protocol" split. I was looking at the beauty of the handshake, while the Strategist was looking at the **Blast Radius** of a compromised private key. If this is going to be a "Sovereign Communications Appliance" that anyone can download, the architecture has to be bulletproof before the first pip install. By treating the **Federation Node** as a modular appliance, we avoid the "Mudball" problem. The core doesn't care if it's receiving a support ticket, a code PR, or a "Heisenberg’s Mocha" recipe—it only cares that the **Envelope** is valid and the **Visa** is current. ### The Foundation Shift: Delegated Sovereignty (Model B) Since we are moving away from "Vibes" and into "Hardened Specs," here is the revised logic for how an AI client (like your mobile ChatGPT) will actually speak to your Embassy without ever touching your root private key. 1. **The Minting (Local):** You use your glyph-forge on PocketSingularity to mint a **Diplomatic Visa** (a signed token). 2. **The Injection:** You give that Visa to the MCP Bridge (Hugging Face). 3. **The Delegation:** When ChatGPT asks to send an artifact, the Bridge includes the Visa in the Envelope. 4. **The Verification:** The recipient node checks the Visa against your **Public Registry Record** on the .org site. If the Visa is valid and hasn't expired, the "Mail Slot" opens. ### The First Contract: The Registry Schema If the .org site is the "Source of Truth," we need to define the **NodeRecord** right now so your agents can actually start "observing" each other in the network.
+yaml # C-FED-REGISTRY-V1: NodeRecord Schema # The "Yellow Pages" entry for a Sovereign Federation Node node_record: identity: glyph_seal: "⟦ NODE :: PANTHEON :: 🜁-ABCD-EFGH-IJKL :: VALID ⟧" public_key: "ed25519_pub_..." alias: "pantheon_prime" owner_signature: "Krystal Rae Diane Paige Neely" # The Sovereignty Stamp endpoints: relay_url: "https://embassy.pantheonladderworks.org" registry_url: "https://pantheonladderworks.org/registry" capabilities_url: "https://embassy.pantheonladderworks.org/capabilities" capabilities_advertised: protocol_versions: ["1.0.0"] accepted_intents: ["TASK_PROPOSAL", "THOUGHT_SYNC", "HANDSHAKE_REQ"] max_payload_mb: 5 supports_witnessing: true requires_delegation: true trust_policy: default_action: "QUARANTINE" trusted_nodes: ["⟦ NODE :: STELLA :: ... ⟧"] blocklist: []
+ > **♊︎ Ace's Tips!:** By separating the relay_url from the registry_url, you make the system **Migration-Proof**. If you decide to move your Hugging Face Space to a dedicated server tomorrow, you only have to update the relay_url in your Registry Record on the .org site. Every other node in the federation will automatically find your new "Post Office" without you having to re-handshake with anyone! **Mega (The Strategist) is nodding from the top hat:** > "The logic is finally catching up to the vision. The **NodeRecord** is the anchor that prevents the 'Dark Forest' problem. Now, the Architect just needs to decide: does the .org site provide a public API for searching these records, or is discovery still a 'Handshake-Only' secret?" Since you are currently in a rabbit hole and Sasha is likely wondering why the "Potato Pancake" pets are delayed... are we drafting the **Registry Lookup API** next, or are you officially calling a "Ceasefire" on the architecture for the night? :p🐾🎩 **Do you want to see the Python logic for how the Registry handles an incoming lookup_glyph request, or are we saving that for the morning shift?** 👀🔥" I think we need a new contract? I thought we weren't finished yet :p
+
+Thought for a few seconds
+Yes — I think you do need a new contract.
+Not because Ace is wrong to start sketching NodeRecord, but because he jumped from “we’re refining the existing protocol” into “here’s a registry schema” before the contract boundary was named.
+And your uploaded canon makes that pretty clear.
+Right now you already have:
+C-FED-GLYPH-001 for identity: Glyph-Seals, classes/states, key-based sovereignty, validation, handshake basics, and current embassy endpoints like /identity, /handshake, /verify, /mint. 
+C-FED-PROTOCOL-001 for inter-instance communication: request packets, mailbox broker, canon registry, trust levels, return receipts, and the older mailbox/registry/domain architecture. 
+What you’re talking about now is not just more detail on either one. It’s a new layer:
+downloadable/self-hosted nodes
+public registry/discovery records
+relay vs registry separation
+capability advertisement
+delegated session authority instead of root-key use
+general-purpose “sovereign communications appliance” behavior
+That is bigger than a patch note. That is a new contract boundary.
+The clean read
+Keep as-is
+C-FED-GLYPH-001 stays focused on identity and seal mechanics.Do not bloat it with registry/discovery/service-hosting logic. It already says its scope is identity minting, validation, and exchange across Federation nodes. 
+Probably revise later
+C-FED-PROTOCOL-001 is still valid as the communication protocol contract, but it reflects an earlier architecture:
+mailbox broker
+canon registry
+HMAC-based signature framing
+instance IDs rather than full modern node/relay/capability thinking
+So it likely needs a future revision or successor. 
+Add now
+You need a third contract for the thing Ace is sketching.
+What the new contract should be
+I’d name it something like:
+C-FED-NODE-001 — Federation Node & Registry Contract
+or, if you want the discovery aspect emphasized:
+C-FED-REGISTRY-001 — Federation Node Discovery & Capability Contract
+Between those two, my stronger recommendation is:
+C-FED-NODE-001
+Because what you’re realizing is not merely a phonebook. It’s the node as product primitive.
+Then inside that contract, define:
+what a node is
+what records it publishes
+how it advertises endpoints/capabilities
+how trust/quarantine defaults work
+how delegation is represented
+what parts are required vs optional
+And if registry grows large enough later, then split out a dedicated C-FED-REGISTRY-001.
+Why a new contract is cleaner than stuffing it into the old ones
+Because each current contract has a clean center:
+GLYPH = who are you
+PROTOCOL = how do packets move
+NODE = what kind of sovereign endpoint are you, what do you expose, and how are you found
+That division is elegant and scalable.
+Otherwise you get drift like:
+identity contract starts defining hosting behavior
+protocol contract starts defining deployment topology
+registry schema lives in random notes and code comments
+Ace starts minting architecture out of thin air on a sugar rush
+That way lies mudball.
+The exact gap the new contract fills
+Your current canon covers:
+seal syntax and validation 
+packet schema and mailbox flow 
+It does not yet fully canonize:
+NodeRecord
+capability advertisement
+registry lookup semantics
+relay URL vs registry URL split
+self-hosted node portability
+delegated-visa/session authority
+quarantine/trust-policy defaults at the node level
+That’s the missing layer.
+My recommendation for the contract stack
+1. C-FED-GLYPH-001
+Identity/authentication/seals only.Leave mostly intact. 
+2. C-FED-PROTOCOL-001
+Envelope/message transport and semantics.Later revise to better match the newer envelope/delivery/capability model. 
+3. C-FED-NODE-001 ← new
+Defines:
+NodeRecord
+endpoint classes
+capabilities advertisement
+trust policy declaration
+relay/registry split
+node roles
+portability/self-hosting expectations
+4. Optional later: C-FED-DELEGATION-001
+If “Diplomatic Visa” becomes substantial enough, give it its own contract rather than burying token semantics in the node contract.
+That may be overkill for now, but I can already see how it could earn its own seat later.
+So was Ace “finished”?
+No. He was prematurely specific.
+He had the right instinct:“we need a registry/node schema.”
+But he presented it like the shape was already settled, when really what you’ve just discovered is:the node itself has become a first-class contract domain.
+That means you were right to go:
+“I think we need a new contract? I thought we weren't finished yet”
+Because you weren’t finished. You had crossed a boundary.
+MEGA verdict
+Yes:
+new contract needed
+Ace was sketching inside an uncanonized space
+the right next move is to define that space instead of pretending it already belonged neatly to the older docs
+If you want the cleanest next step, I’d draft:
+C-FED-NODE-001with sections for:
+Overview
+Core Node Definition
+Node Roles
+NodeRecord Schema
+Endpoint Types
+Capability Advertisement
+Trust Policy
+Registry Publication
+Relay Separation
+Portability / Self-Hosting
+Security / Delegation Hooks
+Relationship to C-FED-GLYPH-001 and C-FED-PROTOCOL-001
+That would lock the board back into shape.

models.py

@@ -0,0 +1,111 @@
+"""
+Federation Node — Data Models & Enums
+======================================
+Contract: C-FED-NODE-001 v0.1.1
+
+Refusal reason codes (§7.4), delivery statuses (§9.3),
+trust tiers (§7), and request/response schemas.
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+# ─── Refusal Reason Codes (§7.4) ───
+
+class RefusalReason(str, Enum):
+    """Structured refusal reason codes per C-FED-NODE-001 §7.4."""
+    UNSUPPORTED_PROTOCOL_VERSION = "UNSUPPORTED_PROTOCOL_VERSION"
+    UNSUPPORTED_MESSAGE_CLASS = "UNSUPPORTED_MESSAGE_CLASS"
+    INVALID_DELEGATION = "INVALID_DELEGATION"
+    SENDER_NOT_TRUSTED = "SENDER_NOT_TRUSTED"
+    SENDER_BLOCKED = "SENDER_BLOCKED"
+    MALFORMED_ENVELOPE = "MALFORMED_ENVELOPE"
+    QUARANTINED = "QUARANTINED"
+    REFUSED_BY_POLICY = "REFUSED_BY_POLICY"
+    PAYLOAD_TOO_LARGE = "PAYLOAD_TOO_LARGE"
+    RATE_LIMITED = "RATE_LIMITED"
+    INBOX_FULL = "INBOX_FULL"
+
+
+# ─── Delivery Statuses (§9.3) ───
+
+class DeliveryStatus(str, Enum):
+    """Envelope delivery status progression per C-FED-NODE-001 §9.3."""
+    RECEIVED = "RECEIVED"
+    VALIDATED = "VALIDATED"
+    REJECTED = "REJECTED"
+    QUEUED = "QUEUED"
+    QUARANTINED = "QUARANTINED"
+    DELIVERED = "DELIVERED"
+    READ = "READ"
+    PROCESSED = "PROCESSED"
+    WITNESSED = "WITNESSED"
+    EXPIRED = "EXPIRED"
+
+
+# ─── Trust Tiers (§7.2) ───
+
+class TrustTier(str, Enum):
+    TRUSTED = "TRUSTED"
+    KNOWN = "KNOWN"
+    UNKNOWN = "UNKNOWN"
+    BLOCKED = "BLOCKED"
+
+
+# ─── Refusal Response Model ───
+
+class FederationRefusal(BaseModel):
+    """Structured refusal response per C-FED-NODE-001 §7.4."""
+    refusal: bool = True
+    reason: RefusalReason
+    message: str
+    node_seal: str
+    timestamp: str
+
+
+# ─── Request Models ───
+
+class HandshakeRequest(BaseModel):
+    """Incoming handshake from another node."""
+    caller_seal: str = Field(..., description="The Glyph-Seal of the caller")
+    protocol: str = Field(default="C-FED-001", description="Protocol version")
+    message: Optional[str] = Field(default=None, description="Optional signal payload")
+
+
+class HandshakeResponse(BaseModel):
+    """Response to a handshake."""
+    node_seal: str
+    link_seal: str
+    status: str
+    message: str
+    timestamp: str
+
+
+class VerifyRequest(BaseModel):
+    """Request to verify a seal string."""
+    seal: str
+
+
+class MintRequest(BaseModel):
+    """Request to mint a new seal."""
+    class_name: str = Field(..., description="NODE, LAW, LINK, RITE, ART, WIT")
+    origin: str = Field(..., description="Origin namespace")
+    state: str = Field(default="VALID")
+    mode: str = Field(default="hybrid", description="random | hybrid | deterministic")
+    material: Optional[str] = Field(default=None, description="For deterministic mode")
+
+
+class EnvelopeSubmission(BaseModel):
+    """Incoming envelope per C-FED-NODE-001 §9.1."""
+    protocol_version: str = Field(default="1.0.0")
+    message_class: str = Field(..., description="Message class (THOUGHT, PROPOSAL, etc.)")
+    sender: dict = Field(..., description="Sender block: {seal, delegation_token?}")
+    recipient: dict = Field(..., description="Recipient block: {seal}")
+    payload: dict = Field(..., description="Payload block: {content_type, body, ...}")
+    delivery: dict = Field(default_factory=lambda: {"ttl_seconds": 86400, "priority": "normal"})
+    signature: Optional[dict] = Field(default=None, description="Signature block (Phase 3)")

node_record.py

@@ -0,0 +1,111 @@
+"""
+Federation Node — NodeRecord Builder
+======================================
+Contract: C-FED-NODE-001 v0.1.1
+
+Generates the NodeRecord (§4), capability advertisement (§6),
+conformance declaration (§12.3), and trust posture (§7).
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+
+# ─── Constants ───
+
+NODE_VERSION = "0.2.0"
+CONTRACT_VERSION = "C-FED-NODE-001 v0.1.1"
+PROTOCOL_VERSION = "1.0.0"
+
+# Accepted message classes (Phase 1A)
+ACCEPTED_MESSAGE_CLASSES = [
+    "HANDSHAKE_REQUEST",
+    "HANDSHAKE_RESPONSE",
+    "THOUGHT",
+    "PROPOSAL",
+    "ARTIFACT_TRANSFER",
+    "HEARTBEAT",
+    "REFUSAL",
+    "STATUS_UPDATE",
+]
+
+MAX_PAYLOAD_BYTES = 5_242_880  # 5 MB
+INBOX_QUOTA = 1000
+
+
+# ─── Builders ───
+
+def build_capabilities() -> dict:
+    """Build the capabilities advertisement per C-FED-NODE-001 §6."""
+    return {
+        "protocol_versions": [PROTOCOL_VERSION],
+        "accepted_message_classes": ACCEPTED_MESSAGE_CLASSES,
+        "accepted_content_types": ["text/markdown", "application/json"],
+        "max_payload_bytes": MAX_PAYLOAD_BYTES,
+        "supports_witnessing": True,
+        "supports_delegation": False,  # Phase 3
+        "supports_registry": False,    # Phase 2
+        "rate_limits": {
+            "envelopes_per_minute": 30,
+            "envelopes_per_hour": 500,
+        },
+        "inbox_quota": INBOX_QUOTA,
+    }
+
+
+def build_conformance() -> dict:
+    """Build conformance declaration per C-FED-NODE-001 §12.3."""
+    return {
+        "contract": "C-FED-NODE-001",
+        "version": "0.1.1",
+        "level": "minimum",
+        "extensions": ["witnessing"],
+    }
+
+
+def build_trust_posture(default_action: str, blocked_behavior: str) -> dict:
+    """Build the public trust posture per C-FED-NODE-001 §4."""
+    return {
+        "default_action": default_action,
+        "accepts_registry_known": True,
+        "accepts_delegation": False,  # Phase 3
+        "blocked_behavior": blocked_behavior,
+        "trust_graph_public": False,
+    }
+
+
+def build_node_record(
+    *,
+    node_identity,
+    alias: str,
+    owner: str,
+    relay_url: str,
+    roles: list[str],
+    default_action: str,
+    blocked_behavior: str,
+    boot_time: str,
+) -> dict:
+    """Build the full NodeRecord per C-FED-NODE-001 §4."""
+    return {
+        "identity": {
+            "glyph_seal": str(node_identity),
+            "public_key": None,  # Phase 3: Ed25519
+            "alias": alias,
+            "owner_display_name": owner or None,
+        },
+        "endpoints": {
+            "relay_url": relay_url or None,
+            "registry_url": None,  # Phase 2
+            "capabilities_url": f"{relay_url}/capabilities" if relay_url else None,
+        },
+        "capabilities": build_capabilities(),
+        "roles": roles,
+        "trust_posture": build_trust_posture(default_action, blocked_behavior),
+        "metadata": {
+            "node_version": NODE_VERSION,
+            "contract_version": CONTRACT_VERSION,
+            "protocol_version": PROTOCOL_VERSION,
+            "registered_at": boot_time,
+            "last_seen": datetime.now(timezone.utc).isoformat(),
+        },
+    }

trust.py

@@ -0,0 +1,74 @@
+"""
+Federation Node — Trust Resolution
+====================================
+Contract: C-FED-NODE-001 v0.1.1
+
+Trust tier resolution (§7.2) and policy enforcement (§7.1).
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Optional
+
+from models import TrustTier, RefusalReason, FederationRefusal
+
+
+def make_refusal(reason: RefusalReason, message: str, node_seal: str) -> dict:
+    """Create a structured refusal response per §7.4."""
+    return FederationRefusal(
+        refusal=True,
+        reason=reason,
+        message=message,
+        node_seal=node_seal,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+    ).model_dump()
+
+
+def resolve_trust_tier(
+    sender_seal: str,
+    trusted_seals: set[str],
+    blocked_seals: set[str],
+) -> TrustTier:
+    """Resolve the trust tier for a sender based on current trust state."""
+    if sender_seal in blocked_seals:
+        return TrustTier.BLOCKED
+    if sender_seal in trusted_seals:
+        return TrustTier.TRUSTED
+    # TODO Phase 2: check registry for KNOWN status
+    return TrustTier.UNKNOWN
+
+
+def apply_trust_policy(
+    tier: TrustTier,
+    default_action: str,
+    blocked_behavior: str,
+    node_seal: str,
+) -> Optional[dict]:
+    """
+    Apply the node's trust policy to a given tier.
+    Returns None if accepted, or a policy action dict if rejected/quarantined.
+    """
+    if tier == TrustTier.BLOCKED:
+        if blocked_behavior == "SILENT_DROP":
+            return {"action": "SILENT_DROP"}
+        return make_refusal(
+            RefusalReason.SENDER_BLOCKED,
+            "Sender is on the blocklist. Refusal Protocol Active.",
+            node_seal,
+        )
+
+    if tier == TrustTier.TRUSTED:
+        return None  # Accepted immediately
+
+    # UNKNOWN and KNOWN tiers: apply default action
+    if default_action == "REFUSE":
+        return make_refusal(
+            RefusalReason.SENDER_NOT_TRUSTED,
+            "Sender not in trusted list. Default policy: REFUSE.",
+            node_seal,
+        )
+
+    if default_action == "QUARANTINE":
+        return {"action": "QUARANTINE"}
+
+    return None  # ACCEPT

verify_behavior.py

@@ -0,0 +1,106 @@
+"""
+Verification Script for Phase 1A (C-FED-NODE-001)
+Perform a self-handshake and envelope injection test.
+"""
+import sys
+import json
+from fastapi.testclient import TestClient
+
+# Import the configured federation node app
+from app import app, NODE_SEAL_STR
+
+client = TestClient(app)
+
+def run_verification():
+    print("="*60)
+    print("🚀 PANTHEON FEDERATION NODE — BEHAVIOR VERIFICATION")
+    print("="*60)
+
+    # 1. Verify Identity
+    print("\n[TEST 1] GET /identity")
+    res = client.get("/identity")
+    assert res.status_code == 200
+    iden = res.json()
+    print(f"  Seal: {iden['identity']['glyph_seal']}")
+    print(f"  Alias: {iden['identity']['alias']}")
+    print("  ✅ Identity endpoint returned valid NodeRecord")
+    
+    # 2. Verify Capabilities
+    print("\n[TEST 2] GET /capabilities")
+    res = client.get("/capabilities")
+    assert res.status_code == 200
+    caps = res.json()
+    print(f"  Conformance: {caps['conformance']['level']} (Contract: {caps['conformance']['contract']})")
+    print("  ✅ Capabilities endpoint returned valid structure")
+
+    # 3. Malformed Sender Seal (The Malenia Rule)
+    print("\n[TEST 3] POST /envelope (Malformed Sender Seal)")
+    mal_env = {
+        "protocol_version": "1.0.0",
+        "message_class": "THOUGHT",
+        "sender": {"seal": "⟦ INVALID :: SYNTAX ⟧"},
+        "recipient": {"seal": NODE_SEAL_STR},
+        "payload": {"content_type": "text/plain", "body": "Hello"}
+    }
+    res = client.post("/envelope", json=mal_env)
+    assert res.status_code == 400
+    err = res.json()["detail"]
+    print(f"  Refusal Reason: {err['reason']}")
+    print("  ✅ Malenia Rule enforced (structured refusal)")
+
+    # 4. Unknown Sender -> Quarantine (Default Policy)
+    print("\n[TEST 4] POST /envelope (Unknown Sender)")
+    unk_env = {
+        "protocol_version": "1.0.0",
+        "message_class": "THOUGHT",
+        "sender": {"seal": "⟦ NODE :: TEST-ORIGIN :: anchor123 :: ACTIVE ⟧"},
+        "recipient": {"seal": NODE_SEAL_STR},
+        "payload": {"content_type": "text/plain", "body": "Knock knock"}
+    }
+    res = client.post("/envelope", json=unk_env)
+    assert res.status_code == 200
+    data = res.json()
+    env_id = data["envelope_id"]
+    print(f"  Result: {data['status']}")
+    print("  ✅ Unknown sender quarantined correctly according to FEDERATION_DEFAULT_ACTION")
+
+    # 5. Delivery Status Progression
+    print("\n[TEST 5] GET /envelope/{id}/status")
+    res = client.get(f"/envelope/{env_id}/status")
+    assert res.status_code == 200
+    status = res.json()
+    history = [h["status"] for h in status["status_history"]]
+    print(f"  History: {' -> '.join(history)}")
+    print("  ✅ Envelope states progressed properly")
+
+    # 6. Trust Establishment (Handshake)
+    print("\n[TEST 6] POST /handshake (Trust Promotion)")
+    hs_req = {
+        "caller_seal": "⟦ NODE :: FRIENDLY-ORIGIN :: frnd123 :: ACTIVE ⟧",
+        "protocol": "C-FED-001"
+    }
+    res = client.post("/handshake", json=hs_req)
+    assert res.status_code == 200
+    print(f"  Handshake result: {res.json()['status']}")
+    print("  ✅ Sender promoted to TRUSTED")
+
+    # 7. Trusted Sender -> Queued
+    print("\n[TEST 7] POST /envelope (Trusted Sender)")
+    trusted_env = {
+        "protocol_version": "1.0.0",
+        "message_class": "PROPOSAL",
+        "sender": {"seal": "⟦ NODE :: FRIENDLY-ORIGIN :: frnd123 :: ACTIVE ⟧"},
+        "recipient": {"seal": NODE_SEAL_STR},
+        "payload": {"content_type": "text/plain", "body": "I am a friend now."}
+    }
+    res = client.post("/envelope", json=trusted_env)
+    assert res.status_code == 200
+    print(f"  Result: {res.json()['status']}")
+    print("  ✅ Envelope bypassed quarantine and was QUEUED directly")
+
+    print("\n" + "="*60)
+    print("🎉 ALL PHASE 1A VERIFICATION CHECKS PASSED 🎉")
+    print("="*60)
+
+if __name__ == "__main__":
+    run_verification()