@cavi-ai/api-client 0.1.0

package/src/extensions/cavi/fallbacks/snapshots/operator-control/snapshot-section-status.ts

@@ -0,0 +1,41 @@
+import type { OperatorControlSnapshot } from "../../../domain/index.js";
+
+export const fallbackOperatorControlSectionStatus: OperatorControlSnapshot["sectionStatus"] =
+  {
+    status: {
+      available: true,
+      authoritative: true,
+      error: null,
+      sampleLimit: null,
+    },
+    registryDetail: {
+      available: true,
+      authoritative: true,
+      error: null,
+      sampleLimit: null,
+    },
+    tasks: {
+      available: true,
+      authoritative: false,
+      error: null,
+      sampleLimit: 20,
+    },
+    memory: {
+      available: true,
+      authoritative: false,
+      error: null,
+      sampleLimit: 20,
+    },
+    workerReady: {
+      available: true,
+      authoritative: true,
+      error: null,
+      sampleLimit: null,
+    },
+    workerTasks: {
+      available: true,
+      authoritative: false,
+      error: null,
+      sampleLimit: 20,
+    },
+  };

package/src/extensions/cavi/fallbacks/snapshots/operator-control/snapshot-status.ts

@@ -0,0 +1,87 @@
+import type { OperatorControlSnapshot } from "../../../domain/index.js";
+import { fallbackSnapshotNow as now } from "../shared.js";
+import { OPERATOR_DISPATCH_ENDPOINTS } from "../../../contracts/paths.js";
+import { fallbackDelegatedTransport, fallbackLegacyWorkerFleet } from "./transports.js";
+
+export const fallbackOperatorControlStatus: OperatorControlSnapshot["status"] = {
+  primaryOperator: "operator-a",
+  fallbackOperator: "primary-operator",
+  authorityMode: "authoritative-failover",
+  taskStorePath: "/state/cavi-control/operator-control-tasks.json",
+  registry: {
+    agentCount: 22,
+    teamCount: 5,
+    sourcePath:
+      "/workspace/projects/openclaw/src/caviclaw/operator-control/agents.yaml",
+    sourceHash: "mock-registry-hash",
+    generatedAt: now - 8 * 60_000,
+  },
+  taskSummary: {
+    primaryOperator: "operator-a",
+    fallbackOperator: "primary-operator",
+    tasks: {
+      accepted: 1,
+      queued: 2,
+      started: 1,
+      retrying: 0,
+      blocked: 1,
+      completed: 8,
+      "dead-letter": 1,
+    },
+    totals: {
+      total: 14,
+      terminal: 9,
+      active: 5,
+    },
+  },
+  runtimes: {
+    acpBackendId: "acpx",
+    acpBackendHealthy: true,
+    sharedMemoryAuthority: "vector-memory",
+  },
+  sharedMemory: {
+    storePath: "/state/cavi-control/operator-shared-memory.json",
+    collections: {
+      "service-context": {
+        count: 4,
+        lastVerifiedAt: now - 4 * 60_000,
+        writeMode: "upsert",
+      },
+      "task-outcomes": {
+        count: 17,
+        lastVerifiedAt: now - 2 * 60_000,
+        writeMode: "append-only",
+      },
+      "contract-registry": {
+        count: 11,
+        lastVerifiedAt: now - 19 * 60_000,
+        writeMode: "upsert",
+      },
+      "channel-events": {
+        count: 23,
+        lastVerifiedAt: now - 1 * 60_000,
+        writeMode: "append-only",
+      },
+    },
+  },
+  legacyWorkerFleet: fallbackLegacyWorkerFleet,
+  delegatedFirstClassAgents: fallbackDelegatedTransport,
+  worker: fallbackLegacyWorkerFleet,
+  mesh: {
+    legacyExecutionFleet: fallbackLegacyWorkerFleet,
+    delegatedFirstClassAgents: fallbackDelegatedTransport,
+    executionFleet: fallbackLegacyWorkerFleet,
+    projectOps: {
+      mode: "task-lifecycle",
+      configured: true,
+      baseUrl: "http://project-board.internal:3010",
+      eventEndpoint: `http://project-board.internal:3010${OPERATOR_DISPATCH_ENDPOINTS.operatorEvents}`,
+      authScheme: "bearer",
+      authEnv: "CAVI_CONTROL_PROJECT_BOARD_SHARED_SECRET",
+      authConfigured: true,
+    },
+    domainOrchestrators: fallbackDelegatedTransport,
+    marketing: fallbackDelegatedTransport,
+    research: fallbackDelegatedTransport,
+  },
+};

package/src/extensions/cavi/fallbacks/snapshots/operator-control/snapshot-tasks.ts

@@ -0,0 +1,113 @@
+import type { OperatorControlSnapshot } from "../../../domain/index.js";
+import { fallbackSnapshotNow as now } from "../shared.js";
+
+export const fallbackOperatorControlTasks: OperatorControlSnapshot["tasks"] = {
+  summary: {
+    accepted: 1,
+    queued: 2,
+    started: 1,
+    retrying: 0,
+    blocked: 1,
+    completed: 8,
+    "dead-letter": 1,
+  },
+  tasks: [
+    {
+      envelope: {
+        task_id: "task-operator-1",
+        requester: { id: "operator-a", kind: "operator" },
+        target: { capability: "backend", alias: "backend-operator" },
+        objective: "Verify operator task lifecycle",
+        tier: "STANDARD",
+        acceptance_criteria: ["task store contains completed task"],
+        timeout_s: 900,
+      },
+      receipt: {
+        task_id: "task-operator-1",
+        run_id: "task-run-1",
+        state: "completed",
+        owner: "primary-operator-2",
+        attempt: 0,
+        created_at: now - 30 * 60_000,
+        updated_at: now - 5 * 60_000,
+        queue_latency_ms: 2400,
+        artifacts: ["task://task-operator-1"],
+        failure_code: null,
+      },
+      events: [],
+      validation: {
+        validation_id: "val-operator-1",
+        validator: "verification-operator",
+        result: "passed",
+      },
+      outcome: {
+        outcome: "success",
+        verification_status: "passed",
+        rework_needed: false,
+        recorded_at: now - 5 * 60_000,
+      },
+    },
+    {
+      envelope: {
+        task_id: "task-rollout-2",
+        parent_task_id: "task-operator-1",
+        requester: { id: "operator-a", kind: "operator" },
+        target: {
+          capability: "infra",
+          alias: "infra-operator",
+          team_id: "execution-fleet",
+        },
+        objective: "Reconcile AKS operator deploy drift",
+        tier: "HEAVY",
+        acceptance_criteria: ["pods healthy", "receipts emitted"],
+        timeout_s: 1800,
+      },
+      receipt: {
+        task_id: "task-rollout-2",
+        run_id: "task-run-2",
+        state: "blocked",
+        owner: "primary-operator-2",
+        attempt: 1,
+        created_at: now - 55 * 60_000,
+        updated_at: now - 9 * 60_000,
+        queue_latency_ms: 6200,
+        artifacts: [],
+        failure_code: "approval-pending",
+      },
+      events: [],
+      validation: null,
+      outcome: null,
+    },
+    {
+      envelope: {
+        task_id: "task-memory-3",
+        parent_task_id: "task-rollout-2",
+        requester: { id: "operator-a", kind: "operator" },
+        target: {
+          capability: "analysis",
+          alias: "analysis-operator",
+          team_id: "execution-fleet",
+        },
+        objective: "Promote verified task outcomes into shared memory",
+        tier: "LITE",
+        acceptance_criteria: ["fresh memory collections visible"],
+        timeout_s: 300,
+      },
+      receipt: {
+        task_id: "task-memory-3",
+        run_id: "task-run-3",
+        state: "queued",
+        owner: "operator-a",
+        attempt: 0,
+        created_at: now - 8 * 60_000,
+        updated_at: now - 2 * 60_000,
+        queue_latency_ms: 180,
+        artifacts: [],
+        failure_code: null,
+      },
+      events: [],
+      validation: null,
+      outcome: null,
+    },
+  ],
+};

package/src/extensions/cavi/fallbacks/snapshots/operator-control/snapshot-worker-ready.ts

@@ -0,0 +1,19 @@
+import type { OperatorControlSnapshot } from "../../../domain/index.js";
+
+export const fallbackOperatorControlWorkerReady: OperatorControlSnapshot["workerReady"] =
+  {
+    status: "ok",
+    pending: 2,
+    active: 1,
+    shuttingDown: false,
+    auth: {
+      enabled: true,
+      scheme: "bearer",
+    },
+    backend: {
+      mode: "filesystem",
+      persistenceEnabled: true,
+      stateFile: "/var/lib/agents/primary-operator-2/queue-state.json",
+      recoveredTasks: 3,
+    },
+  };

package/src/extensions/cavi/fallbacks/snapshots/operator-control/snapshot-worker-tasks.ts

@@ -0,0 +1,46 @@
+import type { OperatorControlSnapshot } from "../../../domain/index.js";
+import { fallbackSnapshotNow as now } from "../shared.js";
+
+export const fallbackOperatorControlWorkerTasks: OperatorControlSnapshot["workerTasks"] =
+  {
+    stats: {
+      pending: 2,
+      active: 1,
+      shuttingDown: false,
+    },
+    tasks: [
+      {
+        taskId: "worker-task-1",
+        runId: "worker-run-1",
+        type: "backend",
+        priority: "normal",
+        state: "queued",
+        attempt: 0,
+        createdAt: now - 12 * 60_000,
+        updatedAt: now - 3 * 60_000,
+        summary: "Awaiting worker slot",
+      },
+      {
+        taskId: "worker-task-2",
+        runId: "worker-run-2",
+        type: "infra",
+        priority: "high",
+        state: "started",
+        attempt: 1,
+        createdAt: now - 22 * 60_000,
+        updatedAt: now - 2 * 60_000,
+        summary: "Running rollout verification",
+      },
+      {
+        taskId: "worker-task-3",
+        runId: "worker-run-3",
+        type: "analysis",
+        priority: "low",
+        state: "completed",
+        attempt: 0,
+        createdAt: now - 42 * 60_000,
+        updatedAt: now - 18 * 60_000,
+        summary: "Completed evidence packet build",
+      },
+    ],
+  };

package/src/extensions/cavi/fallbacks/snapshots/operator-control/snapshot.ts

@@ -0,0 +1,18 @@
+import type { OperatorControlSnapshot } from "../../../domain/index.js";
+import { fallbackOperatorControlMemory } from "./snapshot-memory.js";
+import { fallbackOperatorControlRegistryDetail } from "./snapshot-registry-detail.js";
+import { fallbackOperatorControlSectionStatus } from "./snapshot-section-status.js";
+import { fallbackOperatorControlStatus } from "./snapshot-status.js";
+import { fallbackOperatorControlTasks } from "./snapshot-tasks.js";
+import { fallbackOperatorControlWorkerReady } from "./snapshot-worker-ready.js";
+import { fallbackOperatorControlWorkerTasks } from "./snapshot-worker-tasks.js";
+
+export const fallbackOperatorControl: OperatorControlSnapshot = {
+  status: fallbackOperatorControlStatus,
+  registryDetail: fallbackOperatorControlRegistryDetail,
+  tasks: fallbackOperatorControlTasks,
+  memory: fallbackOperatorControlMemory,
+  workerReady: fallbackOperatorControlWorkerReady,
+  workerTasks: fallbackOperatorControlWorkerTasks,
+  sectionStatus: fallbackOperatorControlSectionStatus,
+};

package/src/extensions/cavi/fallbacks/snapshots/operator-control/transports.ts

@@ -0,0 +1,81 @@
+import type { OperatorControlSnapshot } from "../../../domain/index.js";
+import { OPERATOR_DISPATCH_ENDPOINTS } from "../../../contracts/paths.js";
+
+const SECONDARY_OPERATOR_INTERNAL_BASE_URL = "http://primary-operator-2.internal:3009";
+const SERVICE_OPERATOR_INTERNAL_BASE_URL = "http://service-operator.internal:18789";
+const GATEWAY_INTERNAL_BASE_URL = "http://gateway.internal";
+
+function fallbackEndpoint(baseUrl: string, path: string): string {
+  return `${baseUrl}${path}`;
+}
+
+export const fallbackLegacyWorkerFleet: OperatorControlSnapshot["status"]["legacyWorkerFleet"] =
+  {
+    dispatchTransport: "primary-operator-2-http",
+    role: "legacy-worker-fleet",
+    configured: true,
+    baseUrl: SECONDARY_OPERATOR_INTERNAL_BASE_URL,
+    receiptTemplate: fallbackEndpoint(
+      GATEWAY_INTERNAL_BASE_URL,
+      OPERATOR_DISPATCH_ENDPOINTS.taskReceiptsTemplate,
+    ),
+    authScheme: "bearer",
+    authEnv: "CAVI_CONTROL_SECONDARY_OPERATOR_SHARED_SECRET",
+    authConfigured: true,
+  };
+
+export const fallbackDelegatedTransport: OperatorControlSnapshot["status"]["delegatedFirstClassAgents"] =
+  {
+    dispatchTransport: "delegated-http",
+    transportAliases: ["service-operator-http", "research-operator-http"],
+    role: "delegated-first-class-agent-boundary",
+    configured: true,
+    baseUrl: SERVICE_OPERATOR_INTERNAL_BASE_URL,
+    authScheme: "bearer",
+    authEnv: "CAVI_CONTROL_SERVICE_OPERATOR_SHARED_SECRET",
+    authConfigured: true,
+    globalDefaultAlias: "operator-team",
+    servedTeams: ["marketing", "research"],
+    leadAliases: ["operator-team", "research-operator"],
+    defaultAliasByTeam: {
+      marketing: "operator-team",
+      research: "research-operator",
+    },
+    teamTopology: [
+      {
+        teamId: "marketing",
+        declaredTransport: "service-operator-http",
+        resolvedTransport: "delegated-http",
+        leadAlias: "operator-team",
+        defaultAlias: "operator-team",
+        dispatchEndpointEnv: "CAVI_CONTROL_SERVICE_OPERATOR_URL",
+        dispatchPath: OPERATOR_DISPATCH_ENDPOINTS.message,
+        dispatchAuthEnv: "CAVI_CONTROL_SERVICE_OPERATOR_SHARED_SECRET",
+        resolvedBaseUrl: SERVICE_OPERATOR_INTERNAL_BASE_URL,
+        resolvedEndpoint: fallbackEndpoint(
+          SERVICE_OPERATOR_INTERNAL_BASE_URL,
+          OPERATOR_DISPATCH_ENDPOINTS.message,
+        ),
+        authConfigured: true,
+        urlResolutionHint: null,
+      },
+      {
+        teamId: "research",
+        declaredTransport: "delegated-http",
+        resolvedTransport: "delegated-http",
+        leadAlias: "research-operator",
+        defaultAlias: "research-operator",
+        dispatchEndpointEnv: "CAVI_CONTROL_INTERNAL_CONTROL_URL",
+        dispatchPath: OPERATOR_DISPATCH_ENDPOINTS.message,
+        dispatchAuthEnv: "CAVI_CONTROL_INTERNAL_CONTROL_SHARED_SECRET",
+        resolvedBaseUrl: GATEWAY_INTERNAL_BASE_URL,
+        resolvedEndpoint: fallbackEndpoint(
+          GATEWAY_INTERNAL_BASE_URL,
+          OPERATOR_DISPATCH_ENDPOINTS.message,
+        ),
+        authConfigured: true,
+        urlResolutionHint: null,
+      },
+    ],
+    legacyTeams: ["execution-fleet"],
+  };

package/src/extensions/cavi/fallbacks/snapshots/overview.ts

@@ -0,0 +1,42 @@
+import type { OverviewSnapshot } from "../../../../core/gateway/snapshots/contracts.js";
+import { GATEWAY_PROBE_ENDPOINTS } from "../../../../contracts/paths.js";
+import { fallbackSnapshotNow as now } from "./shared.js";
+
+export const fallbackOverview: OverviewSnapshot = {
+  health: {
+    live: true,
+    ready: true,
+    checkedAt: now,
+    probes: {
+      healthz: {
+        path: GATEWAY_PROBE_ENDPOINTS.healthz,
+        ok: true,
+        statusCode: 200,
+      },
+      readyz: {
+        path: GATEWAY_PROBE_ENDPOINTS.readyz,
+        ok: true,
+        statusCode: 200,
+        failing: [],
+        uptimeMs: 900_000,
+      },
+    },
+  },
+  kpis: {
+    activeSessions: 7,
+    totalSessions: 44,
+    totalMessages: 5_812,
+    totalToolCalls: 1_129,
+    totalErrors: 16,
+    estimatedCostUsd: 13.41,
+  },
+  providerBreakdown: [
+    { provider: "openai", tokens: 482_331, cost: 10.84 },
+    { provider: "anthropic", tokens: 114_220, cost: 2.57 },
+  ],
+  topAgents: [
+    { agentId: "primary-operator", messages: 1_028, cost: 4.12 },
+    { agentId: "qa-operator", messages: 807, cost: 2.73 },
+    { agentId: "ui-operator", messages: 739, cost: 2.06 },
+  ],
+};

package/src/extensions/cavi/fallbacks/snapshots/routing.ts

@@ -0,0 +1,38 @@
+import type { RoutingMatrixSnapshot } from "../../../../core/gateway/snapshots/contracts.js";
+
+export const fallbackRoutingMatrix: RoutingMatrixSnapshot = {
+  rows: [
+    {
+      channel: "discord",
+      handler: "primary-operator",
+      totalRuns: 42,
+      successRuns: 39,
+      failedRuns: 3,
+      successRate: 39 / 42,
+      messages: 544,
+    },
+    {
+      channel: "discord",
+      handler: "qa-operator",
+      totalRuns: 17,
+      successRuns: 12,
+      failedRuns: 5,
+      successRate: 12 / 17,
+      messages: 198,
+    },
+    {
+      channel: "webchat",
+      handler: "ui-operator",
+      totalRuns: 11,
+      successRuns: 11,
+      failedRuns: 0,
+      successRate: 1,
+      messages: 149,
+    },
+  ],
+  totals: {
+    totalRuns: 70,
+    successRuns: 62,
+    failedRuns: 8,
+  },
+};

package/src/extensions/cavi/fallbacks/snapshots/runs.ts

@@ -0,0 +1,141 @@
+import type { AgentRun } from "../../../../core/gateway/run/contracts.js";
+import type {
+  GatewaySessionRunDetailSnapshot,
+  GatewaySessionRunsSnapshot,
+} from "../../../../core/gateway/snapshots/contracts.js";
+import { fallbackSnapshotNow as now } from "./shared.js";
+
+const fallbackRuns: AgentRun[] = [
+  {
+    key: "agent:primary-operator:main",
+    title: "Primary Operator Orchestrator",
+    agentId: "primary-operator",
+    channel: "discord",
+    updatedAt: now - 2 * 60_000,
+    status: "active",
+    totalTokens: 138_203,
+    errors: 0,
+    model: "anthropic/claude-sonnet-4",
+    totalCostUsd: 1.24,
+  },
+  {
+    key: "agent:qa-operator:subagent:20260309-1",
+    title: "Inspectah CI Recovery",
+    agentId: "qa-operator",
+    channel: "discord",
+    updatedAt: now - 31 * 60_000,
+    status: "stalled",
+    totalTokens: 42_918,
+    errors: 3,
+    model: "openai/gpt-4o",
+    totalCostUsd: 0.89,
+  },
+  {
+    key: "agent:ui-operator:subagent:20260309-7",
+    title: "Cavi Control UI MVP",
+    agentId: "ui-operator",
+    channel: "webchat",
+    updatedAt: now - 11 * 60_000,
+    status: "idle",
+    totalTokens: 56_477,
+    errors: 0,
+    model: "anthropic/claude-sonnet-4",
+    totalCostUsd: 0.72,
+  },
+  {
+    key: "agent:backend-operator:backend:20260310-1",
+    title: "Backend validation",
+    agentId: "backend-operator",
+    channel: "discord",
+    updatedAt: now - 25 * 60_000,
+    status: "idle",
+    totalTokens: 22_100,
+    errors: 0,
+    model: "openai/gpt-4o-mini",
+    totalCostUsd: 0.31,
+  },
+  {
+    key: "agent:infra-operator:infra:20260310-2",
+    title: "AKS reconcile",
+    agentId: "infra-operator",
+    channel: "discord",
+    updatedAt: now - 55 * 60_000,
+    status: "stalled",
+    totalTokens: 18_400,
+    errors: 2,
+    model: "anthropic/claude-sonnet-4",
+    totalCostUsd: 0.28,
+  },
+];
+export const fallbackAgentRuns: GatewaySessionRunsSnapshot = {
+  live: fallbackRuns.filter((run) => run.status === "active" || run.status === "idle"),
+  history: fallbackRuns,
+  summary: {
+    active: fallbackRuns.filter((run) => run.status === "active").length,
+    idle: fallbackRuns.filter((run) => run.status === "idle").length,
+    stalled: fallbackRuns.filter((run) => run.status === "stalled").length,
+    error: fallbackRuns.filter((run) => run.status === "error").length,
+  },
+};
+
+export function fallbackRunDetailForKey(key: string): GatewaySessionRunDetailSnapshot {
+  const run = fallbackRuns.find((entry) => entry.key === key) ?? fallbackRuns[0] ?? null;
+
+  return {
+    run,
+    preview: {
+      status: run ? "ok" : "missing",
+      items: run
+        ? [
+            {
+              role: "system",
+              text: "Session booted and routing context attached.",
+              at: now - 18 * 60_000,
+              eventType: "system",
+            },
+            {
+              role: "user",
+              text: "Please harden Cavi Control run detail and health UX.",
+              at: now - 15 * 60_000,
+              eventType: "user",
+            },
+            {
+              role: "assistant",
+              text: "Acknowledged. I will scan cavi-control scope and execute a focused patch.",
+              at: now - 14 * 60_000,
+              eventType: "assistant",
+            },
+            {
+              role: "tool",
+              text: "read: cavi-control-ui/src/pages/AgentRunDetailPage.tsx",
+              at: now - 13 * 60_000,
+              eventType: "tool",
+              toolName: "read",
+              durationMs: 620,
+            },
+            {
+              role: "tool",
+              text: "edit: cavi-control-ui/src/pages/OverviewPage.tsx",
+              at: now - 8 * 60_000,
+              eventType: "tool",
+              toolName: "edit",
+              durationMs: 1_120,
+            },
+            {
+              role: "assistant",
+              text: "Build succeeded. Final validation checklist updated.",
+              at: now - 5 * 60_000,
+              eventType: "assistant",
+            },
+          ]
+        : [],
+    },
+    usage: {
+      totalTokens: run?.totalTokens ?? 0,
+      totalCostUsd: run ? 1.74 : 0,
+      messages: run ? 36 : 0,
+      toolCalls: run ? 14 : 0,
+      errors: run?.errors ?? 0,
+    },
+  };
+}

package/src/extensions/cavi/fallbacks/snapshots/shared.ts

@@ -0,0 +1 @@
+export const fallbackSnapshotNow = Date.now();

package/src/extensions/cavi/index.ts

@@ -0,0 +1,52 @@
+export * from "./client.js";
+export * from "./contracts/index.js";
+export * from "./runtime/paths.js";
+export * from "./runtime/env-config.js";
+export * from "./library/client.js";
+export * from "./library/clip.js";
+export * from "./portal/client.js";
+export * from "./portal/tts.js";
+export * from "./adapters/create-cavi-control-adapters.js";
+export * from "./fallbacks/provider.js";
+export * from "./project-board/constants.js";
+export * from "./project-board/fallback.js";
+export * from "./project-board/live.js";
+export * from "./project-board/mutations.js";
+export * from "./project-board/normalize.js";
+export * from "./operator-control/constants.js";
+export * from "./operator-control/defaults.js";
+export * from "./operator-control/load-section.js";
+export {
+  backfillCanonicalTeam,
+  buildAgentMainSessionKey,
+  configureCanonicalOperatorRegistry,
+  configureCanonicalTeamRegistry,
+  getOperatorTeamLookupKeys,
+  getPortalTeamCode,
+  getPortalTeamIdentity,
+  getPortalTeamSectorSlug,
+  getPortalTeamSlug,
+  listCaviTeamPortalIds,
+  listCompiledCanonicalTeams,
+  matchesOperatorTeamIdentifier,
+  matchesTaskTargetToTeam,
+  normalizeSessionAgentId,
+  normalizeSessionKey,
+  normalizeTeamLookupValue,
+  parseAgentSessionKey,
+  resetCanonicalOperatorRegistry,
+  resolveCompiledCanonicalTeam,
+  resolvePortalPrimarySessionKey,
+  resolveTeamSessionAgentId,
+  resolveTeamSessionKey,
+  sessionKeysEqual,
+  type CaviTeamPortalId,
+  type ParsedAgentSessionKey,
+} from "./registry/canonical-team-registry.js";
+export { PORTAL_CLIENT_ID_HEADER } from "../../core/http/client-id.js";
+export * from "./registry/portal-library-registry.js";
+export * from "./discourse/contracts.js";
+export * from "./discourse/normalize.js";
+export * from "./domain/index.js";
+export * from "./registry/team-registry.js";
+export * from "./registry/team-registry-config.js";