Partner Probe Guide — integrating with FCC's live services¶

This is the one document you need to integrate against a running FCC (Find → Create → Critique Agent Team Framework) instance. The audience is an ecosystem partner OR a Claude CLI agent working in another project: you want to discover FCC's surfaces, call them, and know exactly what shapes come back.

This guide is also the prose half of a machine-verified contract. Every promise made here is asserted against a running FCC stack by scripts/uat_probe_pass.py — the guide makes the promise, the script proves it. If the two ever disagree, the script wins and this document is the bug. Run the contract with make uat-probe (advisory) or make uat-probe-strict (CI gate).

The version axis¶

FCC has one version (fcc.__version__) and every surface reports it. A probe result therefore reflects the running version, not whatever a doc claims. The single source of truth is the health endpoint:

curl -s http://127.0.0.1:8901/ux/health | python -m json.tool
# → "version": "1.10.0"   (whatever the running build is)

The version-coherence tripwire (T1, below) asserts that every version-bearing surface reports the same string, and that the string equals fcc.__version__. If the UX gateway, the ws-bridge /health, the A2A card, and the MCP info payload ever drift apart, the contract fails.

Loopback port map¶

FCC binds everything to 127.0.0.1 by default. These are the ports the probe script reads (overridable via env — see Ports + env):

Service	Port	Purpose	Probeable surface
UX gateway (Sky Parlour)	8901	REST + SSE + discovery	`/ux/health`, `/ux/openapi`, `/.well-known/agent-card.json`, `/api/v1/mcp/info`, `/api/v1/personas[/{id}\\|/search]`, `POST /api/v1/ask`, `/ux/events/live`, `/ux/command`, `/ux/session/{id}`
ws-bridge	8765	WebSocket event stream	`ws://127.0.0.1:8765/` + `GET /health`
admin API	8900	Read-only admin REST	`/api/v1/admin/*`, `/api/v1/federation/health`
frontend (React)	8080	SPA	(not probed)
streamlit	8501	apps	(not probed)
jupyter	8888	notebooks	(not probed)

FCC's ports sit in the FREE range (8700–8999 / 8900) of the vendored port_allocation.yaml (RC ADR-020 authority) and collide with no ecosystem peer.

⚡ Quickstart¶

Copy-paste this block against a running stack (make uat-up first):

# 1. Liveness + version
curl -s http://127.0.0.1:8901/ux/health

# 2. A2A service card (who am I, what can I do)
curl -s http://127.0.0.1:8901/.well-known/agent-card.json

# 3. Web MCP discovery (the 16-tool catalog)
curl -s http://127.0.0.1:8901/api/v1/mcp/info

What to tell a Claude CLI agent in another project¶

FCC runs a UX gateway on http://127.0.0.1:8901. Discover it with GET /.well-known/agent-card.json (A2A 0.3.0, six skills: fcc.scaffold/refactor/debug/test/compare/document) and GET /api/v1/mcp/info (Web MCP profile web-mcp-rest-v1, 16 tools). Liveness + version is GET /ux/health. The read-only admin API is on :8900 (/api/v1/admin/health, /inventory, /ports, /plugins, /audit/full). FCC's MCP server itself is stdio JSON-RPC (fcc protocol mcp-server), not a network port — the /api/v1/mcp/info REST endpoint is discovery-only. FCC serves no GraphQL. Every surface returns JSON; documented-but-absent paths return 404, never 5xx.

Confirm FCC is up (run first)¶

Three independent liveness checks, one per server. All three report the same version:

# UX gateway (the INERT gate the probe script keys off)
curl -s http://127.0.0.1:8901/ux/health
# → {"status":"ok","service":"fcc-ux-gateway","port":8901,"version":"1.10.0","server":"FccUxGateway/1.4.2"}

# ws-bridge health (same port as the WebSocket stream)
curl -s http://127.0.0.1:8765/health
# → {"status":"ok","service":"fcc-ws-bridge","version":"1.10.0"}

# admin API health
curl -s http://127.0.0.1:8900/api/v1/admin/health
# → {"status":"ok", ...}   (HealthReader().check())

If the UX gateway /ux/health is unreachable, the probe script prints [uat-probe] INERT and exits 0 — the contract is inert when the stack is down, so the CI gate stays green without a running stack.

Surfaces¶

One subsection per surface, each with a real curl and the expected JSON shape.

Health & version coherence¶

Both health surfaces report version == fcc.__version__. This is the load-bearing invariant: the probe's _health_has_version validator fails unless version is present and equals the installed package version.

curl -s http://127.0.0.1:8901/ux/health
# {"status":"ok","service":"fcc-ux-gateway","port":8901,
#  "version":"1.10.0","server":"FccUxGateway/1.4.2"}

curl -s http://127.0.0.1:8765/health
# {"status":"ok","service":"fcc-ws-bridge","version":"1.10.0"}

The cross-surface version-coherence tripwire (T1) then asserts the UX gateway, ws-bridge, A2A card, and MCP info payload all carry one identical version string.

REST (UX gateway + admin API)¶

UX gateway (:8901) serves the live-view contract vendored at ux_rest_openapi.yaml:

# Serve the vendored OpenAPI spec (YAML, not JSON)
curl -s http://127.0.0.1:8901/ux/openapi | head -5
# → openapi: 3.x ... (application/yaml)

# Read-only session view (404 until a session is wired in)
curl -s -o /dev/null -w "%{http_code}\n" http://127.0.0.1:8901/ux/session/nope
# → 404   {"error":"session not found: nope"}

It also serves the Agent Catalog read API + "Ask FCC Agent" (Phase 6 P2) — the live data behind the portal's agent browser and deep spec-search:

curl -s http://127.0.0.1:8901/api/v1/personas                 # all 176 summary rows {count, personas[]}
curl -s http://127.0.0.1:8901/api/v1/personas/AMK             # one full enriched R.I.S.C.E.A.R. record
curl -s "http://127.0.0.1:8901/api/v1/personas/search?q=accessibility&k=5"  # keyword|semantic ranked hits
curl -s http://127.0.0.1:8901/api/v1/personas/AMK/adopt        # agents-as-a-service binding bundle
# Ask FCC Agent — sourced, extractive answer over every spec (no LLM required)
curl -s -X POST http://127.0.0.1:8901/api/v1/ask \
  -H 'Content-Type: application/json' \
  -d '{"question":"who handles compliance and risk?","k":3}'
# → {"answer": "...", "sources": [{"id","name","section","snippet","url"}...], "confidence": 0.58}

Adopt ("FCC Agents as a Service", Phase 6 P3). GET /api/v1/personas/{id}/adopt returns the four truthful ways to bind an FCC agent: a copy-ready R.I.S.C.E.A.R. prompt, the per-persona A2A Agent Card (null for vertical-pack personas), the PAOM-8 binding (canonical archetype → PAOM-8 enum + constitution — what PAOM consumes to run the persona live), and an MCP service-level reference (FCC's MCP surface is per-service, not per-persona). 404 if the id is unknown.

search and ask accept mode=keyword (default, dependency-free) or mode=semantic (wraps PersonaSearchIndex; degrades to keyword with a note if unavailable). Every hit cites its persona + R.I.S.C.E.A.R. section and a /personas/<id> deep-link.

Admin API (:8900) is read-only (GET + OPTIONS only). All routes return JSON:

curl -s http://127.0.0.1:8900/api/v1/admin/health
curl -s http://127.0.0.1:8900/api/v1/admin/inventory                 # full ecosystem inventory
curl -s "http://127.0.0.1:8900/api/v1/admin/inventory?tier=ecosystem" # filter by tier
curl -s http://127.0.0.1:8900/api/v1/admin/inventory/summary         # counts rollup
curl -s http://127.0.0.1:8900/api/v1/admin/ports                     # full port registry
curl -s "http://127.0.0.1:8900/api/v1/admin/ports?codename=NEXUS"    # one project (404 if unknown)
curl -s http://127.0.0.1:8900/api/v1/admin/ports/conflicts           # port-conflict report
curl -s http://127.0.0.1:8900/api/v1/admin/plugins                   # plugin inventory
curl -s "http://127.0.0.1:8900/api/v1/admin/plugins?health=true"     # plugin health snapshot
curl -s http://127.0.0.1:8900/api/v1/admin/audit/full                # serialized AuditReport
curl -s http://127.0.0.1:8900/api/v1/admin/compliance/summary        # {"tier1_gaps":3, ...}
curl -s http://127.0.0.1:8900/api/v1/federation/health               # bidirectional-sync dashboard

Web MCP (`/api/v1/mcp/info`, `web-mcp-rest-v1`)¶

FCC mirrors the ecosystem Web MCP REST profile web-mcp-rest-v1 (spec revision draft-2026-05-09 — authority lives upstream; FCC mirrors, never imports). The discovery payload is built from the same MCPToolRegistry.create_default() catalog the MCP server dispatches against, so tools_count cannot drift from what is actually callable:

curl -s http://127.0.0.1:8901/api/v1/mcp/info

{
  "profile": "web-mcp-rest-v1",
  "spec_revision": "draft-2026-05-09",
  "service": "fcc-mcp",
  "version": "1.10.0",
  "transport": "stdio-jsonrpc",
  "tools_count": 16,
  "tools": [
    {"name": "fcc_simulate", "description": "..."},
    {"name": "fcc_action_run", "description": "..."}
    /* ... 16 total ... */
  ]
}

The 16-tool catalog: fcc_simulate, fcc_action_run, fcc_action_list, fcc_generate_docs, fcc_validate, fcc_validate_docs, fcc_plugins_list, fcc_plugins_validate, fcc_collab_start, fcc_collab_turn, fcc_collab_score, fcc_collab_complete, fcc_dashboard_personas, fcc_dashboard_quality, fcc_ecosystem_validate, fcc_ecosystem_health.

Note — the stdio MCP server. This REST endpoint is discovery metadata only. FCC's actual MCP server speaks stdio JSON-RPC, not a network port — launch it with fcc protocol mcp-server. The /api/v1/mcp/info payload advertises the catalog so a partner or Claude CLI agent can learn the tool surface without a stdio handshake. The transport field (stdio-jsonrpc) says so explicitly.

A2A (agent-card 0.3.0)¶

FCC serves a service-level A2A Agent Card (one card for the whole FCC service, not per-persona) at the well-known path:

curl -s http://127.0.0.1:8901/.well-known/agent-card.json

{
  "protocolVersion": "0.3.0",
  "name": "FCC Agent Team",
  "description": "Find → Create → Critique agent-team framework ...",
  "url": "http://127.0.0.1:8901",
  "version": "1.10.0",
  "provider": {"organization": "INFORMATION COLLECTIVE, LLC", "url": "..."},
  "capabilities": {"streaming": false, "pushNotifications": false,
                   "stateTransitionHistory": false, "personaCount": 149},
  "defaultInputModes": ["application/json"],
  "defaultOutputModes": ["application/json"],
  "skills": [
    {"id": "fcc.scaffold", "name": "Scaffold", "tags": ["fcc","workflow","scaffold"]},
    {"id": "fcc.refactor", "name": "Refactor", "...": "..."},
    {"id": "fcc.debug",    "...": "..."},
    {"id": "fcc.test",     "...": "..."},
    {"id": "fcc.compare",  "...": "..."},
    {"id": "fcc.document", "...": "..."}
  ]
}

The six skills map 1:1 to FCC's six workflow action types (scaffold, refactor, debug, test, compare, document). protocolVersion is 0.3.0 and version equals fcc.__version__.

A2A HTTP skill-invocation server is a STUB. FCC publishes the discovery card above, but it does not serve an A2A HTTP task-invocation endpoint (no JSON-RPC tasks/send server). The card advertises the skill surface; to actually run a skill today you use the Web MCP tools (e.g. fcc_action_run) or the FCC CLI. Honest status: card served, invocation server not served.

WebSocket (ws-bridge)¶

The ws-bridge fans FCC EventBus events out to browser clients over a WebSocket on :8765, and exposes an HTTP /health on the same port (handled before the WebSocket upgrade — handy for container probes):

# HTTP health on the same port as the socket
curl -s http://127.0.0.1:8765/health
# → {"status":"ok","service":"fcc-ws-bridge","version":"1.10.0"}

# Connect to the live event stream (any WS client)
#   ws://127.0.0.1:8765/
# Each frame is one JSON-serialized Event (event.to_dict()).

import asyncio, websockets
async def tap():
    async with websockets.connect("ws://127.0.0.1:8765/") as ws:
        async for msg in ws:
            print(msg)   # one JSON Event per frame
asyncio.run(tap())

The bridge is broadcast-only for browser clients: inbound messages are logged but not acted upon.

SSE (`/ux/events/live`)¶

The UX gateway streams EventBus events as Server-Sent Events. Two optional query params:

# Default lane (ux), all event types
curl -N http://127.0.0.1:8901/ux/events/live

# PAOM lane only
curl -N "http://127.0.0.1:8901/ux/events/live?lane=paom"

# Filter to a single event type (dotted value OR member name)
curl -N "http://127.0.0.1:8901/ux/events/live?event_type=viz.data.updated"
curl -N "http://127.0.0.1:8901/ux/events/live?event_type=VIZ_DATA_UPDATED"

Each frame is a standard SSE record:

event: viz.data.updated
data: {"event_type":"viz.data.updated","source":"...","payload":{...}, ...}
id: <event_id>

A : heartbeat comment is emitted every 15s to keep proxies from closing the connection. lane accepts only ux (default) or paom — anything else is a 400. An unrecognised event_type is also a 400.

GraphQL stance¶

FCC serves no GraphQL. There is no /graphql endpoint, no schema, no introspection. Classification GraphQL lives in CONSTEL (PRISM) and persona/R.I.S.C.E.A.R. GraphQL lives in PAOM (SENTINEL) per ADR-034. FCC's surfaces are REST + SSE + WebSocket + (discovery-only) Web MCP + the stdio MCP server. If you need GraphQL over the FCC persona catalog, consume PAOM.

Collector (OTLP / event plane, `:8902`)¶

The v2.0.0 OTLP/event collector persists the lane-routed event + span stream and exposes a read API. Its /health carries version (joins the version-coherence tripwire); the query side is GET /api/v1/events[/stats|/sessions] and GET /api/v1/traces/{trace_id}; ingest is POST /api/v1/otlp and POST /api/v1/events.

curl -s http://127.0.0.1:8902/health
# → {"status":"ok","service":"fcc-collector","version":"2.0.1","events":N}
curl -s http://127.0.0.1:8902/api/v1/events/stats
# → {"total":N,"by_type":{...},"by_source":{...},"by_lane":{...}}

Contribution dossier (`contribution-dossier-v1`)¶

Served at /.well-known/contribution-dossier.json (UX gateway). A summary of the RC-mirrored contribution-dossier-v1 schema. Rule-8 holds on the wire: summary.active_authors is an integer COUNT — never names.

curl -s http://127.0.0.1:8901/.well-known/contribution-dossier.json
# → {"spec":"contribution-dossier-v1","publisher":"fcc",
#    "summary":{"commit_count":N,"active_authors":N,"persona_count":176,...}, ...}

Portal panes (`/embed/<id>`)¶

Real server-rendered, CORS-free, tokens-v1-themed HTML panes a host can mount in an iframe (advertised by the portal-components manifest above): /embed/personas, /embed/ecosystem, /embed/compliance. Each returns <!doctype html> and is process-cached after first render.

curl -s http://127.0.0.1:8901/embed/personas | head -c 40
# → <!doctype html><html><head>...

Journey streams (Agent AX / Human UX / Persona)¶

Mirroring the ecosystem journey-stream convention (AOME is the gold standard), FCC partitions its UAT surfaces into three journey streams. Each is driven through a make uat-stream-* target and exercises a distinct interaction surface:

Stream	Make target	What it covers
Agent AX	`make uat-stream-agent-ax`	The surfaces a machine agent (Claude CLI, Copilot, a partner service) exercises: Web MCP tool dispatch (`/api/v1/mcp/info` + the 16-tool catalog via stdio), the admin REST reads, A2A card discovery, and the SSE/WebSocket event taps.
Human UX	`make uat-stream-human-ux`	The surfaces a human operator exercises: the Sky Parlour UX gateway live view (`/ux/events/live`, `/ux/command`, `/ux/session/{id}`), the React frontend on `:8080`, and the Streamlit apps on `:8501`.
Persona	`make uat-stream-persona`	Per-persona boundaries projected through the surfaces: the A2A card's `personaCount`, the persona dashboard reader (`fcc_dashboard_personas`), and the persona catalog that backs the six workflow skills.
(all three)	`make uat-streams`	Runs the full journey set.

The executable probe contract (make uat-probe) is the cross-stream liveness floor under all three — it touches health, REST, Web MCP, A2A, and the never-5xx tripwire that every stream depends on.

Parameter-variation catalog¶

The exact query params / body shapes each endpoint accepts:

Endpoint	Param / body	Accepted values	On bad input
`GET /ux/events/live`	`lane`	`ux` (default), `paom`	400 `{"error":"bad request","detail":"invalid lane: ..."}`
`GET /ux/events/live`	`event_type`	any `EventType` dotted value (`viz.data.updated`) or member name (`VIZ_DATA_UPDATED`)	400 `unknown event_type: ...`
`GET /api/v1/admin/inventory`	`tier`	`ecosystem`, `jv_partner`, `vocabulary`, `tier2_conforming`	unknown tier → empty filtered result
`GET /api/v1/admin/ports`	`codename`	any project codename (`NEXUS`, `CRUCIBLE`, `OPHIUCHUS`, ...)	404 `{"error":"codename not found: ..."}`
`GET /api/v1/admin/plugins`	`health`	`1`/`true`/`yes` → health snapshot; else inventory	(no error path)
`POST /ux/command`	body	JSON object with required string `command`; optional `args` (obj), `session_id`, `correlation_id`	400 on empty body / non-JSON / non-object / missing `command`

POST /ux/command body shape:

{
  "command": "run_simulation",
  "args": {"scenario": "demo"},
  "session_id": "abc123",
  "correlation_id": "trace-001"
}

It emits a PAOM-lane collaboration.turn.taken event and returns 202:

{"status":"accepted","event_id":"<uuid>","lane":"paom","subscribers_notified":2}

Multi-step workflow simulations¶

Replayable recipes that chain surfaces together.

WF-01 — Observe a command round-trip (SSE → POST → event)¶

Open an SSE tap on the PAOM lane, then post a command and watch the event arrive:

# Terminal 1 — tap the PAOM lane
curl -N "http://127.0.0.1:8901/ux/events/live?lane=paom"

# Terminal 2 — post a command
curl -s -X POST http://127.0.0.1:8901/ux/command \
  -H "Content-Type: application/json" \
  -d '{"command":"ping","args":{}}'
# → 202 {"status":"accepted","event_id":"...","lane":"paom","subscribers_notified":1}

Terminal 1 then receives a collaboration.turn.taken SSE frame carrying the command payload. This proves the command → event-bus → SSE seam end-to-end.

WF-02 — Discover, then call (agent-card → mcp/info → tool)¶

The canonical agent on-ramp: discover the service, learn the tool catalog, then dispatch a tool:

# 1. Who is this service? (A2A 0.3.0, six fcc.* skills)
curl -s http://127.0.0.1:8901/.well-known/agent-card.json | python -c \
  "import sys,json; c=json.load(sys.stdin); print(c['name'], c['version'], [s['id'] for s in c['skills']])"

# 2. What tools can I call? (16-tool Web MCP catalog)
curl -s http://127.0.0.1:8901/api/v1/mcp/info | python -c \
  "import sys,json; d=json.load(sys.stdin); print(d['profile'], d['tools_count'])"

# 3. Dispatch a tool over the stdio MCP server (transport: stdio-jsonrpc)
fcc protocol mcp-server   # then speak JSON-RPC over stdin/stdout, e.g. tools/call fcc_ecosystem_health

WF-03 — Admin inventory + port reconciliation¶

Read the ecosystem inventory and confirm a partner's port assignment:

curl -s http://127.0.0.1:8900/api/v1/admin/inventory/summary
curl -s "http://127.0.0.1:8900/api/v1/admin/ports?codename=NEXUS"   # → RC's 2430/2440/2450 v3 block
curl -s http://127.0.0.1:8900/api/v1/admin/ports/conflicts          # → should report no conflicts

Cross-surface tripwires¶

Invariants that span more than one surface. ★ = auto-asserted by scripts/uat_probe_pass.py.

#	Tripwire	What it guarantees	Auto-asserted
T1	Version coherence ★	UX gateway `/ux/health`, ws-bridge `/health`, the A2A card, and `/api/v1/mcp/info` all report one identical `version`, equal to `fcc.__version__`.	✅ `_coherence_result` + `_health_has_version`
T2	MCP catalog parity ★	`tools_count` in `/api/v1/mcp/info` equals the length of the listed `tools[]` array, is > 0, and the profile/spec are `web-mcp-rest-v1` / `draft-2026-05-09`. Built from the same registry the MCP server dispatches, so it cannot drift.	✅ `_mcp_info_catalog`
T3	A2A card served + 0.3.0 ★	`/.well-known/agent-card.json` is served, `protocolVersion == "0.3.0"`, `version == fcc.__version__`, and ≥ 1 skill is present.	✅ `_agent_card_0_3_0`
T4	Never 5xx ★	A documented-but-absent path (e.g. `/nope`) returns 404, never a 5xx. The gateway only 500s on a genuine internal error.	✅ `_never_5xx`

The probe catalogue also includes the ws-bridge + UX-gateway health probes (required) and the admin-API health probe (advisory) — see build_probes().

Error-shape reference + never-5xx contract¶

Every FCC HTTP surface returns a JSON error envelope. The never-5xx contract: client-caused conditions are 4xx; a 5xx means a genuine internal fault (and the probe's T4 tripwire treats any 5xx on a known-absent path as a failure).

Status	When	Body shape
400	Bad request — invalid `lane`, unknown `event_type`, empty/non-JSON/non-object command body, missing `command`	`{"error":"bad request","detail":"<reason>"}` (UX gateway)
404	Unknown path, unknown `?codename=`, missing session	`{"error":"not found"}` / `{"error":"codename not found: X"}` / `{"error":"session not found: X"}`
202	`POST /ux/command` accepted	`{"status":"accepted","event_id":"...","lane":"...","subscribers_notified":N}`
500	Genuine internal error only	`{"error":"internal server error","detail":"<ExcType>: <msg>"}`

All responses carry permissive CORS headers (Access-Control-Allow-Origin: *) and OPTIONS preflight returns 204.

Ports + env vars¶

The probe script reads these env vars (defaults shown); override for non-default deployments:

Env var	Default	Controls
`FCC_UAT_UX_URL`	`http://127.0.0.1:8901`	UX gateway base (health, openapi, agent-card, mcp/info, SSE, command)
`FCC_UAT_WS_URL`	`http://127.0.0.1:8765`	ws-bridge base (`/health`)
`FCC_UAT_ADMIN_URL`	`http://127.0.0.1:8900`	admin API base
`FCC_UAT_TIMEOUT`	`8`	per-request timeout (seconds)

Bring the whole stack up and probe it:

make uat-up            # docker-up the full probeable stack
make uat-probe         # run the contract (advisory; INERT exit-0 if down)
make uat-probe-strict  # CI gate — non-zero on a required-surface failure
make uat-down          # tear it down

Reports land under docs/uat/v<version>/probe_pass/ (report.json + report.md), version-derived so they never collide with a stale dir.

Ecosystem partner quick-reference¶

FCC is the framework root of the Ideate ecosystem; codenames are issued under NEXUS authority (see codename-decoder.md for the canonical table). FCC's relationship to each partner:

Codename	Project / role	FCC relationship
FCC	Find → Create → Critique framework (this repo)	Owns the persona catalog, R.I.S.C.E.A.R. spec, workflow graphs. Lineage root.
NEXUS	Research Center — authoritative registries	FCC vendors RC's `port_allocation.yaml` + `ecosystem_projects.yaml`; RC is the sole R-CPV authority. Live on :2430.
PHOENIX	AI-COE-Docs — quality gates + patent IP + open-science	FCC vendors PHOENIX's 61-gate registry (SHA256 drift sentinel) + OPEN-SCI templates.
AOME (CRUCIBLE)	React admin UI + forensic auditor	Ecosystem UAT gold standard; consumes FCC persona events over the ws-bridge. Live on :3100.
CONSTEL (PRISM)	Classification GraphQL + constellation registry	Issues constellation codenames when FCC scaffolds a vertical; owns classification GraphQL. Live on :8100.
PAOM (SENTINEL)	LLM router + budget manager	Most mature FCC consumer — runs FCC personas as live agents via a pull-adapter; owns persona/R.I.S.C.E.A.R. GraphQL. Live on :3201.
AURORA	Sky Parlour — live trace viewer + UX	Subscribes to FCC's WebSocket event bus; mirrors FCC's 37 archetypes. Live on :2000/:2010.
DISTILLER (FORNAX)	Vocabulary distillation engine	Consumed via `fcc.protocols.distiller_bridge` (sentinel pattern).
CTO	Canonical Tabular Ontology	Optional object-model bridge (`cto` extra); `cto_available()` sentinel. Live on :2810.
POLARIS / ice_ext (BOREAS)	Long-term model archive	Consumed via `fcc.archive.polaris_bridge`; mock fallback when ice_ext absent.
LYRA	Graph-of-thought + harmonic vocab	Consumed via `fcc.knowledge.lyra_bridge`; mock fallback.
ATHENIUM / MNEMOSYNE	JV L2 libraries (analytics / memory)	`fcc.vocabulary_providers` entry-point plugins; `library_only`.
Ophiuchus … Caelum	10 constellation verticals	1:1 `plugins/fcc-<codename>-plugin/` vocabulary providers; 39xx port block (ADR-020).

Eleven ecosystem namespaces are registered in FCC's NamespaceRegistry; the full codename → repo → port map is the codename decoder.