Flocci Library: The Team Wiki That Lives Inside Your Work, Not Beside It

The most important document at your company was never written down. It lived in one person’s head — how the billing migration actually worked, which client hates phone calls, why that one flag has stayed off since 2023, the reason the deploy script has a ninety-second sleep in the middle. Then that person gave two weeks’ notice, and on their last Friday the institutional memory walked out the front door in a tote bag with their houseplant. Nobody malicious happened. Nobody even noticed at first. The knowledge just… left, the way water leaves a room — quietly, completely, and only obvious once you reach for it and it’s gone.

The knowledge always leaves the same way

It rarely leaves in a dramatic exit. It leaves in the gap between what people know and what they ever bothered to record — because recording it was friction, and the tool for recording it lived in a different tab, behind a different login, disconnected from the place where the work actually happened.

That’s the quiet tragedy of the team wiki as a genre. Every company knows it should have one. Most companies have three, half-abandoned. The wiki becomes an island: you have to decide to go there, remember to update it, and reconcile it by hand with the notes, the tasks, the meeting where the decision was actually made. Knowledge capture that requires a special trip is knowledge capture that doesn’t happen. And so the org’s memory stays where it always was — in heads, on their way out the door.

Beneath that runs a second failure, quieter but more corrosive. The few things people do write down, they often write down together — and most collaborative editors handle “together” with a shrug. Last write wins. Two people open the same runbook, both edit, both hit save, and one of them silently erases the other. No warning, no conflict, no ghost of the lost paragraph. The wiki that was supposed to be the source of truth quietly eats half its own updates.

A wiki that behaves like a node, not an island

Flocci Library looks, at first glance, like a competent Notion-style wiki. A block editor with fifteen block types. Pages that nest into a parent/child tree — a self-referential parentId, with denormalized childIds so the sidebar tree renders fast — grouped under spaces, each carrying its own icon and color. You can star a page, comment in a thread, @mention a teammate with autocomplete. Content lives as a jsonb block array. It is, on its own, a clean and capable knowledge base.

But a wiki is worth exactly as much as it is wired into the place the work actually happens — and no further. Knowledge that sits one login and one context-switch away from the task is knowledge nobody reaches for; the deeper the documentation is embedded in the daily flow, the more it accrues instead of rotting. That embedding is the point of Library. It isn’t a wiki that happens to be made by Flocci — it’s one room in a five-app workspace, with Notes, Projects, Calendar, and the Infinity whiteboard alongside it, all sharing a single backend and a single Flocci account. Which means Library doesn’t integrate with your identity provider, your AI, your realtime layer. It inherits them, from the same shared core the other four apps run on.

The payoff of that architecture is a thing most wikis structurally cannot do: knowledge flows in from where it’s captured and out to the wider platform. A note jotted in Flocci Notes can be exported straight into a Library page — with an automatic cross-link back to the note. Quick capture graduates into structured documentation without a copy-paste, without a re-type, without the friction that was killing the whole enterprise. The half-formed thought you had on Tuesday becomes the runbook everyone reads on Friday, and the trail between them stays intact.

The 409 is the feature

Now the part that separates a serious knowledge base from a pretty one. Library’s saves are optimistic — the UI doesn’t block your keystrokes waiting on the server, so it feels instant. But optimism without a guard is exactly how last-write-wins tools lose data. So every save carries an If-Match check against the page’s updatedAt timestamp. If the page changed underneath you since you loaded it, the write doesn’t land quietly on top of your colleague’s edit. It comes back a 409 Conflict, and the UI raises a toast.

That toast is not an error. It’s the wiki refusing to lie to you. It’s the software admitting, out loud, “someone else touched this while you were typing — let’s not pretend that didn’t happen.” Most editors would have silently clobbered the other version and moved on, and you’d only discover the loss weeks later when the runbook was missing the one step that mattered. Library does last-write-wins the right way: it detects the collision and hands it back to a human, instead of resolving it by deletion.

Structured knowledge, guarded structure

Underneath the editor sits a domain model with the kind of restraint that reads as confidence: four tables doing real work. spaces, the top-level containers. pages, the self-referential tree carrying jsonb block content, the denormalized childIds and contentText, and the starred flag. page_comments, threaded, with mentions captured as a first-class array rather than scraped out of text. And an activity_log, where every edit, comment, mention, create, and delete lands per space — so a space isn’t just a folder of documents, it’s a history of who did what to them.

The whole surface is eighteen JWT-guarded endpoints mounted at /api/library. And crucially, not every action is equal. Any member can author and edit pages — the barrier to contributing knowledge is deliberately low, because that’s the barrier that was killing wikis in the first place. But the workspace’s structure is protected: creating, updating, deleting, and even trash-restoring a space is gated behind requireRole('owner','admin'). Anyone can write the page. Only stewards can rearrange the shelves. Spaces even auto-provision per org on first access, so a new team gets a home without an admin ceremony.

1. A space appears when you need it

   Spaces auto-provision per org on first access — each with its own icon and color — so there’s no cold-start setup ritual before a team can start writing.

2. Pages nest into a tree

   Author in the 15-block editor. Pages hang off parents via a self-referential parentId; denormalized childIds keep the sidebar tree fast to render.

3. Everyone stays in sync

   Every change streams over Socket.io, and the full-text GIN index means a teammate can find what you wrote by its contents seconds later.

4. Conflicts surface, they don't vanish

   An If-Match guard against updatedAt turns a concurrent save into a 409 and a conflict toast — never a silent overwrite.

5. The platform watches the shelves

   Space lifecycle events emit onto the Flocci Graph as workapps.space.{created,updated,deleted}, so the wider platform can observe how your knowledge is organized.

That last step is the tell. A space isn’t just a UI construct — its birth, edits, and death are published to the platform Graph through an outbox. The wiki is observable to the rest of Flocci. It behaves like a node in a larger knowledge graph, not a sealed island. Which is precisely the failure mode we started with, inverted: instead of knowledge leaking out of the system unrecorded, the system’s own structure is legible to everything around it.

Who it’s for, and how to use it well

Library is built for knowledge workers and small teams who are tired of the wiki being a separate errand. If your notes live in one app, your tasks in another, your meetings in a third, and your “documentation” in a fourth tab you forget exists, the disconnection is the problem — and Library’s answer is to make the wiki one room in a house you already live in, reachable through a login you already have.

The stack under all this is unglamorous in the good way: a shared Hono + Drizzle backend, React 18 and Vite 5 and TypeScript on the front, TanStack Query and Radix in between, sockets served from the same process on port 5012. The suite has no payments surface — this is a workspace, not a checkout. Every hard, boring platform problem — identity, SSO, realtime transport, AI routing, Graph emission — Library inherits rather than rebuilds, which leaves the product free to be about the only thing a wiki should be about: the knowledge, and keeping it.

Nobody has to carry it out the door

The person who knew how the billing migration worked is going to leave eventually. Everyone does. The question was never whether the institutional memory would try to walk out — it’s whether the room had a place to set it down first, and whether that place was close enough to the work that setting it down took no special trip.

Flocci Library is that place, deliberately built inside the workspace rather than beside it: one login away, streaming in real time, reading the full body of every page, catching the conflicting save instead of eating it, and wired so a passing note in Notes can become permanent knowledge with a single export. And a place like that doesn’t just hold knowledge — it compounds it. Every page written there makes the next one easier to find; every export from Notes, every space the Graph learns to watch, adds to a store that grows more valuable the longer the team works inside it. That is the difference between a living knowledge base and another folder of abandoned docs: the memory accrues instead of decaying. So when the person who knew how the billing migration worked finally gives their notice, they take the houseplant and the tote bag — and the knowledge stays behind, in the room where the next person will come looking for it.