Workshop OS · beta

Lumavera

Workshops are where culture gets built..

Lumavera runs the facilitated sessions that actually shape how a company works — workshops, retros, planning, decision rounds. Not a generic meeting app, not a project tracker. Roles, sessions, artifacts; one schema, one app, Supabase-backed.

Install See the roles GitHub

Stack

Next.js

Backend

Supabase

Roles

Session types

Status

Beta

Sessions — 4 types

What actually runs

The meetings that move a company are the facilitated kind.

Status calls keep the lights on. Workshops, retros, planning and decision rounds change what the lights are pointed at. Lumavera is built for the second category — and only the second category.

Workshops

The facilitated, outcome-owning kind. A crafted agenda, named roles, captured decisions. Not a status update with more chairs.

Retrospectives

What worked, what didn't, what changes. The retro is a session in its own right — with its own artifact template and its own audience.

Planning rounds

Quarterly, sprint, team charter. Series hold the recurring shape; each session inherits the template and mutates the plan on record.

Decision rounds

Proposal, discussion, call. The decision and its rationale land in an artifact owned by the decider, not lost in a thread.

Every session belongs to an organization. Recurring ones belong to a series — same shape, rolling artifacts, continuity without copy-paste.

Roles — 4

Affordance, not permission

Who is in the room changes what the room does.

Harmonia designed these. A role isn't a permission set — it's an affordance. What you can do, what you can see, what the tool hands you when your turn comes. Four roles, named out loud, visible to everyone else in the session.

Facilitator

Runs the session. Controls the agenda clock, captures decisions live, assigns artifact owners on the spot. Sees every draft and every raised hand.

Participant

Shows up with a voice, leaves with an action. RSVPs route through the capacity check; contributions attach to their name, not a pseudonymous chat handle.

Observer

Reads without voting. Leadership, cross-team visitors, the new hire in week two — they see the room, the room doesn't change because they're in it.

Artifact owner

The person the action point belongs to. Inherits edit rights on that artifact only; everyone else gets read within the org. Ownership is routable, transferable, and logged.

Harmonia says: the observer role exists on purpose. Leadership watching is a fact; making it a labelled role makes the room honest about it.

Artifacts — persist past the session

Nothing lost at session end

The session ends. The artifacts outlive it.

Metis runs shipping on this one. Every session emits typed artifacts — decisions, action points, retrospective summaries, attachments — that write to Supabase with row-level security scoped to the owning organization. The tab can close; the decision cannot.

Decisions

Proposal, call, dissent captured, date stamped. Searchable by org, by series, by the person who made the call.

Action points

One owner, one due date, one status. Rolled forward into the next session in the series automatically.

Retrospective summaries

The keeps, drops, tries — plus the change the team committed to. Carried into the next retro as the starting frame.

Attachments

Slides, whiteboards, miro exports. Mime-typed, owner-stamped, RLS-scoped to the session's organization.

One schema

Organizations, org_members, sessions, series, rsvps, attachments, categories. No separate warehouse for artifacts — they live where the sessions live.

Role-scoped RLS

Postgres row-level security enforces org-scoped reads and role-scoped writes. The policy is the perimeter; the app never sees rows it shouldn’t.

Series-aware

Recurring sessions inherit templates; open action points roll into the next session’s agenda. Continuity without manual grooming.

Tenancy model — one policy

The perimeter, in SQL

Org-scoped by default. Role-scoped where it matters.

Lumavera's multi-tenant boundary lives in Postgres, not in the app layer. Below is the policy shape: members of an organization can read its sessions; only facilitators and admins can write. The app inherits the boundary from the database — not the other way around.

-- sessions belong to one organization.
-- RLS is the perimeter; app code cannot bypass it.
alter table public.sessions enable row level security;

-- Read: any member of the org can see the session.
create policy "members read org sessions"
  on public.sessions for select
  using (
    exists (
      select 1 from public.org_members m
      where m.organization_id = sessions.organization_id
        and m.user_id = auth.uid()
    )
  );

-- Write: only facilitator (creator) or org admin.
create policy "facilitators write org sessions"
  on public.sessions for all
  using (
    sessions.created_by = auth.uid()
    or exists (
      select 1 from public.org_members m
      where m.organization_id = sessions.organization_id
        and m.user_id = auth.uid()
        and m.role = 'admin'
    )
  );

Same shape applies to rsvps, attachments, series. Every table carries an organization_id; every policy resolves through org_members.

Honest positioning — 03

What this is not

The adversary’s disclosure. Read before you install.

Ipcha Mistabra wrote this section. Lumavera is narrowly scoped on purpose. If you need one of the things below, reach for a different tool — Lumavera will disappoint you in exactly the way it was designed to.

Disclosure

Not a Zoom replacement.

Lumavera does not do video, breakout rooms, or live transcription. You bring the call; Lumavera runs the structure around it — agenda, roles, artifacts, follow-through.

Disclosure

Not a project tracker.

Action points are session artifacts, not a Jira substitute. If you need epics, sprints, burndown charts — keep your tracker. Lumavera hands the action point off, it doesn't manage it forever.

Disclosure

Facilitator-led by design.

There is no self-service "let the meeting run itself" mode. Someone names the agenda, someone owns the clock, someone captures the decisions. The tool assumes facilitation exists and makes it visible.

Install — beta

Two paths

Self-host on Supabase. Or ask for a hosted preview.

Lumavera is beta. If you run Supabase already, the self-host path is five commands. If you don't, the hosted preview is gated on a short conversation — Metis wants to know what kind of sessions you run before the sign-up link goes out.

Path A — self-host

Bring your own Supabase project

# 1. Clone
git clone https://github.com/nyxCore-Systems/WorkshopTool
cd WorkshopTool

# 2. Install
npm install

# 3. Point at your Supabase project
cp .env.example .env.local
# fill SUPABASE_URL + SUPABASE_ANON_KEY

# 4. Run
npm run dev

Schema migrations ship in supabase/migrations. Apply them with supabase db push; RLS policies land with the tables.

Path B — hosted preview

Gated. Small cohort. On purpose.

The hosted preview runs at lumavera.nyxcore.cloud behind a sign-up gate. We’re onboarding a handful of teams per week so we can watch the first retro together and fix the rough edges before they land in your workflow. Tell us how many sessions a week you run and what kind — Metis reads every one.

Request access Upstream repo

Metis, shipping note

Beta means the schema is stable enough to trust with real retros and loud enough about its edges that you’ll notice when we change one. Breaking migrations are flagged in the release notes a full session-cycle ahead of the cut — never inside one.

Aristaeus says: workshops shape culture. Ship the tool that respects that.

See the rest of the nyxCore ecosystem Talk to the team