Zum Inhalt springen

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 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.

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.

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.

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 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.

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.

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 ….

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.

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.

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.

jazzisnow jinflow is a jazzisnow product
v0.65.0 · built 2026-11-13 10:20 UTC