SpreadVerse Core — Principle-first platform foundation

01 — Architecture

The five-layer model.

Every layer flows downward. Higher layers depend on the contracts of lower layers — never on each other. Specific products and verticals appear later as examples, but the Core stays independent.

L5
End-user Experience

The surfaces the user actually touches. Built from product editions — never wires Core internals directly.
L4
Product Edition Layer

Vertical editions (Elite, Tawzora, future) define their own workflows, screens, forms, customer language.
L3
Domain Extension Layer

Controlled extensions use Core contracts only. Domain modules cannot import each other.
L2
Business Operating Kernel

Workflow, governance, commercial control, metadata — the runtime rules every edition obeys.
L1 · root
Uniform Core Foundation

Identity, tenancy, access, data contracts. Neutral. Reusable. The constitution every layer above inherits.

02 — Responsibility

What the Core owns.

The shared rules and reusable primitives. If a behavior is fundamental enough that two editions would re-invent it differently, it belongs here.

Identity

Users, sessions, auth

Single source of truth for who is acting.

Tenancy

Workspace boundaries

Workspace + organization isolation, enforced at the contract layer.

Access

Roles & policy

Roles, permissions, policy checks — uniform across editions.

Governance

Audit & approval

Traceability and approval discipline for every important action.

Data contracts

Shape & validation

API response shape, error shape, validation rules.

Metadata

Governed extensions

Controlled fields, field governance, agent-readable descriptions.

Workflow

Lifecycle & events

Statuses, tasks, events, lifecycle transitions.

Communication

Activity & notes

Notes, messages, activity history, notification concepts.

Documents

References & states

Document references, requirements, lifecycle states.

Commercial

Money primitives

Pricing, fee, cost, commission, receivable, payable, ledger concepts.

Reporting

Approved metrics

Approved metrics, reportable fields, cross-domain aggregation rules.

Agentic layer

Safe agent boundaries

Safe task boundaries, evidence reporting, no uncontrolled execution.

Editions later

What editions own.

Product editions may define their own workflows, screens, forms, customer language, document requirements, product rules, commercial models, and user journeys.

However — editions must not rewrite Core rules. Product-specific behavior is implemented as controlled extensions of:

Core Foundation
Business Operating Kernel
Domain Extension Layer
Metadata Governance
Agentic Development Rules

03 — Discipline

Non-negotiable
architecture rules.

These are not preferences. They are the conditions under which the platform stays maintainable as new editions ship. Violations are reverted, not negotiated.

i.

The Core must stay neutral and reusable.

No domain-specific concepts leak in. If a vertical needs it, it lives in an extension.
ii.

Domain extensions may use Core contracts only.

Never reach past the Core API. Never depend on internals.
iii.

Domain extensions must not directly import each other.

Cross-domain coupling becomes a vertical's gravitational pull. Mediate through Core.
iv.

Shared logic moves into Core-owned packages.

Or approved shared modules. Duplication is a tax with compounding interest.
v.

Metadata is governed, typed, auditable, agent-readable.

Untyped extension fields are the root cause of platform decay. Not allowed.
vi.

Every important action must be traceable and permissioned.

If it changes state, it has an actor, a policy check, and an audit record.
vii.

No fake-success validation scripts in production stages.

Tests that always pass are worse than no tests. Either it works on real evidence, or it ships broken.
viii.

Documentation distinguishes planned from implemented.

Aspirations don't earn the same typography as shipped reality.

04 — Direction

Early technical direction.

Planning targets. Not proof of implementation until the relevant package or app structure exists. v0.1

Frontend

React · Vite · TypeScript · Tailwind CSS · Radix UI

Backend

Node.js · Fastify · TypeScript

Database

PostgreSQL · Drizzle ORM

Queue · Realtime

Redis · BullMQ · Socket.IO

Testing

Vitest · Playwright · Testing Library

CI / CD

GitHub Actions · deployment target confirmed per stage

Observability

Structured logging · error tracking · metrics

Auth

Token-based · workspace-aware access control

planned repository shape

The-Ultimate-Core/
├── apps/
│   ├── client/                  # planned end-user web application
│   └── server/                  # planned API and worker application
├── packages/
│   ├── config/                  # shared configuration and env validation
│   ├── types/                   # shared types and schemas
│   ├── db/                      # database schema and migrations
│   ├── errors/                  # API error contracts
│   ├── logger/                  # structured logging package
│   ├── auth/                    # auth and permission helpers
│   ├── metadata/                # metadata governance contracts
│   ├── agent-contracts/         # agent-safe task contracts
│   └── design-system/           # shared UI tokens and primitives
├── docs/
├── .github/workflows/
├── package.json
└── pnpm-workspace.yaml

05 — Documents

Documentation index.

Current priority: documentation alignment and governance clarity — before code.

CORE_CONSTITUTION.md

Master principles for the Core foundation.

CORE_BOUNDARY_RULES.md

What belongs in Core vs. extensions.

DOMAIN_EXTENSION_RULES.md

Build extensions without fragmenting architecture.

METADATA_GOVERNANCE.md

Controlled metadata model. Anti-chaos rules.

AGENTIC_DEVELOPMENT_RULES.md

Safe agent / Codex development discipline.

ARCHITECTURE.md

Layer model and dependency direction.

API.md · DATABASE.md

Planned API contracts. Database conventions and data classification.

DEPLOYMENT.md · BRANCHING_STRATEGY.md

Deployment planning. Branching and delivery discipline.

Current priority

i. Keep language neutral.
ii. Define Core principles.
iii. Define boundary rules.
iv. Define metadata governance.
v. Define agentic development discipline.
vi. Only then — scaffold packages and applications.