Make. Desk. Console.

A framework for analytical knowledge systems.
Three verbs. Three stores. One continuous cycle.

Knowledge isn’t built once.
It’s built, read, and authored again.

Every analytical system follows the same rhythm:
build a view of reality, look at what it reveals, refine it.

jinflow gives this rhythm a name — and a structure.

Three verbs, endlessly repeated

Make
Compile the AFS.
Build the KLS.
Validate everything.
→
Desk
Read the KLS.
Understand patterns.
Write the OPS.
→
Console
Draft new YAML
straight into the AFS.
One tenant only.

The loop closes by authoring — the console drafting a YAML into the AFS, or the Atelier writing one straight from the desk.
Each turn produces a richer, more accurate analytical system.

One Phase, One Tool

Each verb is a separate face of one CLI, deployable on its own.

jin make

The Builder
UI-less processing engine. Pure transformation.

Reads the AFS (YAML definitions, contracts) and the
delivered CSVs; writes the KLS. The security boundary.

Validates. Compiles. Builds. Done.

jin make acme.warehouse_east
Key Properties
No UI. No interactivity. No AI.

Workspace isolation. Never mutates source files.

Deterministic. Same AFS commit + same CSVs → same KLS bytes.

Deployable anywhere. Laptop. CI. Cloud function.

jin desk

JinDesk
The SvelteKit app people actually open.

Reads the KLS that make built, read-only.
Browse dimensions, findings, verdicts, expert knowledge.

See what the data says. Understand patterns.
Form new questions.
Key Properties
Reads the KLS read-only. No lock contention with make.

Writes the OPS. Notes, bookmarks, bell — operational state stays operational.

Desktop or web. macOS, Linux, Windows, browser.

Authors into the AFS via the Atelier — a signal written here changes what the next make computes.

jin console

The AI colleague
A conversational REPL, scoped to one tenant.

Queries what make built.
Walks lineage from finding to source row.
Drafts new YAML straight into the AFS.

jin console
Key Properties
Scoped to one tenant. Never queries across tenant schemas.

Reads the KLS and the AFS. Writes the AFS.

Lands like a hand-authored one. Built by the next make.

Human confirms. AI proposes, human approves.

The console drafts artefacts.
Make builds them. The desk reveals what changed.

console
new signal YAML
→
make
compile + build
→
desk
see new findings
→
console
refine thresholds
→
…

Every turn through the cycle refines understanding.
The system gets smarter because the artifacts get better.

AFS · KLS · OPS

Three named stores. Each with a clear owner.

Every piece of state has a home

AFS
Artifact Store
Git
All domain content.
CSVs, YAML definitions,
contracts, tenant configs.

Version-controlled.
Separate from engine code.
KLS
Knowledge Store
DuckDB
The analytical database.
Built product of make.

Medallion layers, findings,
verdicts, expert knowledge.
Read-only for desk and console.
OPS
Operational Store
SQLite → D1
Operational state, per tenant.
Notes, bookmarks, bell
resolutions, scenarios.

Never rebuilt. It outlives
every KLS — restore, don’t regenerate.

Clear ownership. No ambiguity.

AFS
artifacts
→
make
reads AFS
writes KLS
→
KLS
database
→
desk
reads KLS
writes OPS
KLS
database
→
console
reads KLS
writes AFS
→
AFS
artifacts
→
make
rebuilds

AFS is the input to make. KLS is the output.
The console reads the output and writes the input. The loop closes by authoring — no arrow leaves the OPS.

What jinflow Believes

Five commitments that shape every design decision.

  • Domain agnosticism. jinflow knows about artifacts, compilers, tenants, and layers — not about hospitals, materials, or billing. The domain is content, not framework.
  • Engine / content separation. The engine ships as a versioned package. Domain-specific content lives in a separate git repo — the AFS.
  • DuckDB as the universal contract. Make writes the KLS. The desk reads it. The console queries it. No other shared state between the three faces.
  • Workspace isolation. Make never mutates source directories. Temp workspace → compile → build → output.
  • Cloud readiness. Same Python library locally and in Lambda. Different callers, same engine.

nuMetrix on jinflow

Hospital material flow analytics — built on the cycle.

jinflow provides the how.
nuMetrix provides the what.

jinflow (framework)
Medallion pipeline (Bronze → Silver → Gold)
YAML → SQL compilers
Multi-tenant isolation
Taxonomy engine
JinDesk shell
AI-powered REPL

The machinery. Domain-agnostic.
nuMetrix (domain)
Cases, procedures, materials, billing
OPALE, SAP, Navision mappings
47 signals, 11 theses, 10 verdicts
55 entries, 15 Dossiers
Gold contract (7 entities)
3 source systems

The knowledge. All in the AFS.

A real example from nuMetrix

  • Make: Compile 47 signal YAMLs into SQL. Build DuckDB for hospital_zeta. 68K cases, 2.4M billing rows.
  • Desk: Open JinDesk. See that “Revenue Leakage from Unbilled Materials” is confirmed at CHF 2.8M.
  • Console: Ask Claude: “Which cost centers drive the leakage?” — AI queries KLS, identifies top 5 cost centers, drafts a new signal YAML into the AFS targeting OR documentation gaps.
  • Make: Rebuild with the new signal. Now the system detects OR-specific billing gaps.
  • Desk: See the new findings. The thesis evidence score shifts. Understanding deepens.

The jinflow vocabulary

M
Make
The build verb. AFS in, KLS out. Validate, compile, build. No UI, no AI — and the security boundary.
D
Desk
The reveal verb. JinDesk reads the KLS, writes the OPS, and authors into the AFS via the Atelier.
C
Console
The draft verb. AI-assisted, one tenant only. Queries the KLS, drafts new YAML into the AFS.
AFS
Artifact Store
Git repo with all domain content. CSVs, YAMLs, contracts. Input to make; written by the console and by the Atelier.
KLS
Knowledge Store
DuckDB. The built analytical database. Sole output of make. Read-only for desk and console.
OPS
Operational Store
SQLite/WAL, one per tenant. Notes, bookmarks, bell resolutions. Never rebuilt. Cloud path: D1.

Make it.
Read it.
Author it again.

Three verbs. Three stores.
One continuous cycle of understanding.

The knowledge system that gets better every time you use it.

jinflow.io