The Cycle — three stores, and what moves between them
Dieser Inhalt ist noch nicht in deiner Sprache verfügbar.
Every jinflow session is a loop through three verbs and three stores.
make builds, desk reveals, console drafts. They move data
through three substrates with strict ownership: the Artefact Store (AFS),
the Operational Store (OPS), and the Knowledge Store (KLS).
This page is the map. Every other page in the docs is a zoom-in on one of its arrows.
The picture
Section titled “The picture”The solid path builds and reveals. The dotted paths author.
Read it left to right: the AFS is the source of truth (declarative YAML). make reads the AFS and builds the KLS. desk reads the KLS and writes operational state to the OPS — notes, bookmarks, bell resolutions.
Then note what is not there: no arrow leaves the OPS. Operational state
stays operational. The loop closes not by draining a queue but by authoring
— the Atelier writing a YAML straight into the AFS, or console drafting one
there. Both dotted arrows end at the AFS because that is the only way into the
next build.
The perimeter — sources, pipeline.yml, Domain Pack Hub, identity — surrounds
the cycle but does not change its shape. See The perimeter below.
The three verbs
Section titled “The three verbs”make — the engine
Section titled “make — the engine”Reads from DLZ + AFS. Writes to KLS + AFS, and additively to the OPS.
make is the build pipeline and the security boundary. It runs the extraction
contract (Phase 0), syncs the DLZ into the tenant’s source/, validates and
enriches CSVs, compiles every YAML in the AFS to SQL, runs dbt to build Bronze →
Silver → Gold → signals → theses → verdicts, and stamps the result. The output
is a deterministic KLS: identical AFS commit + identical source CSVs = identical
KLS bytes. The same KLS also carries the AFS as a zipped BLOB
(_jinflow_afs_archive), so it is literally self-describing — no AFS needed to
read what is inside.
make does not read the OPS at all. It used to: Phase 1d opened the old SIS
to publish pending notes into the AFS, and an earlier build warned about
unflushed ones. Both are gone. It does write one thing there — the baked
identity tree, which during the Sense 61 ramp lives in both the KLS and the OPS
— and that write is additive: nothing reads the OPS copy yet.
See The make guide for the phase-by-phase breakdown.
desk — the UX
Section titled “desk — the UX”Reads from KLS + OPS. Writes to OPS continuously and to AFS via the Atelier.
desk is the SvelteKit web app users actually open (JinDesk). It reads the KLS
read-only — no lock contention with make — reads operational state from the
OPS (bookmarks, notes, bell), and serves the analytical interface. Two classes
of write happen here, and the difference between them is the whole point of
three stores:
- OPS-resident — notes, bookmarks, scenario state, bell resolutions. These are operational: they belong to the person working, not to the framework, and they stay where they are written.
- AFS-resident via the Atelier (Sense 29) — signal YAMLs from the Signal Builder, Statements (Subject Matter Level 0), lenses: anything that should change what the next build computes. These are written straight into the AFS, as a commit, at the moment they are made.
Bell events (Sense 33) are pub/sub between writers and readers, persisted in the OPS.
See JinDesk guide for every page in the UX.
console — the AI colleague
Section titled “console — the AI colleague”Reads from AFS + KLS. Writes to AFS.
console is the conversational REPL with read access to one tenant’s KLS and
AFS. It can run SQL, inspect the registry, walk lineage from finding to source
row, and draft new YAML that it writes directly into the AFS — signals,
theses, Subject Matter entries, lenses. Every artefact lands in the AFS the same
way a hand-authored one would, and gets built by the next make.
See Tutorial: Exploring with the console for a session walkthrough.
The fourth beat, and why it is gone
Section titled “The fourth beat, and why it is gone”The older model had a fourth verb, publish, which drained the operational
store back into the AFS as commits — and make ran the same drain as Phase
1d at the start of every build.
Both were retired on 2026-07-26, when operational citizens moved to the OPS (Sense 61). The reasoning is worth keeping, because it is the reason there are three stores and not two:
- A note is not a framework artefact. Draining notes into the AFS put operational state into the audit trail of the analysis, which made the AFS history harder to read and the notes no safer.
- The OPS outlives every KLS. It is restored from backup, never regenerated. Once that is true, “get it into the AFS before the next rebuild” stops being a rescue and becomes a category error.
- What should survive a rebuild is authored, not flushed. The Atelier already writes into the AFS at the moment of authoring. A queue drained later is a worse version of a commit made now.
So if you are looking for a publish verb, there is not one, and nothing
replaced it. Sense 21 — The Heartbeat describes the
loop as it was, amended by Sense 61.
The three stores
Section titled “The three stores”Artefact Store (AFS)
Section titled “Artefact Store (AFS)”A git repo per tenant containing every declarative artefact: signals, theses, verdicts, Subject Matter, Dossiers, lenses, perspectives, entities, contracts, glossary, pipeline.yml, brand config, dbt models. This is the source of truth for what should be computed. Every commit is attributed by The Scribe; the AFS history is the audit trail for the analysis.
Writers: init, console, desk via the Atelier, jin afs ….
Readers: make, desk, console.
Operational Store (OPS)
Section titled “Operational Store (OPS)”A SQLite/WAL file per tenant holding operational state: notes, bookmarks, bell resolutions, scenario state, drafts. The OPS is the working surface — fast, mutable, local, and durable: it outlives every KLS and is restored from backup rather than regenerated. Nothing drains it, and nothing needs to.
The engine owns the schema (P18), as it does for every store: one definition,
applied by an idempotent migration. JinDesk owns the operational citizens —
it is the writer for everything a person creates. make writes only the baked
identity tree, additively, during the Sense 61 ramp.
Writers: desk (continuous, for everything a person makes) · make (the baked
identity tree only) · jin ops ….
Readers: desk, jin ops ….
Knowledge Store (KLS)
Section titled “Knowledge Store (KLS)”A DuckDB file per tenant containing every Gold table, every signal_findings table, every thesis_verdict, every verdict_finding, plus the embedded AFS archive. The KLS is the built picture — read-only, snapshottable, immutable once frozen. It is what JinDesk reads and what console queries.
Writers: make only.
Readers: desk, console.
The perimeter
Section titled “The perimeter”DLZ (Sense 31) — the trust boundary for source data. Every CSV crossing it is declared in pipeline.yml, pinned by SHA-256, verified on every run, and logged in extract_log.jsonl. Bytes that don’t match the pin don’t enter.
Domain Pack Hub — the registry of analytical frameworks (nuMetrix, hrcentral, Millésime, etc.). jin init <pack>.<tenant> copies a pack’s starter kit into a new tenant AFS; jin afs update upgrades a tenant’s AFS to a newer pack version. After init, the pack is out of reach — the tenant AFS runs independently.
jinflow.central — the identity plane. Clerk-backed sign-in, role assignment, dev/prod environment routing, deploy machinery. Per-tenant work doesn’t touch it; per-organisation work does.
What changed since the old picture
Section titled “What changed since the old picture”If you’ve seen the hand-drawn sketch from early 2026, the cycle’s shape hasn’t changed — but the write-back loop has grown a small system around it (Atelier → Bell → publish → Scribe), and the source intake has gone from one “from client” arrow to a contracted boundary (pipeline.yml + extract_log.jsonl). The vocabulary also matured: Probes → Signals, Hypotheses → Theses, SMEbits → Subject Matter, Use Cases → Dossiers, and explore/evolve became desk/console. The substrates survived; one verb did not — see The fourth beat above.
Related
Section titled “Related”- The make guide — every phase of the build
- JinDesk guide — every page in the UX
- AI Integration Guide —
consoleconfiguration - Sense 21 — The Heartbeat — the loop as it was, before the fourth beat was retired
- Sense 29 — The Atelier — JinDesk writes
- Sense 31 — The Inlet — extraction contract
- Sense 33 — The Bell — pub/sub channel
- Sense 38 — The Scribe — commit attribution
- Sense 47 — The Log — unified event log
- Architecture diagrams — the same cycle across the five deployment topologies