jinflow CLI Cheat Sheet

Concepts

Term	What it is
Pack	Domain-specific analytics kit (e.g. Millesime for winemaking, Alptrack for ski resorts)
Tenant	One client / site. Pack-qualified: `hrcentral.vai`
KLS	Knowledge Store — the DuckDB file you build and explore
AFS	Artifact Store — the analytical framework (signals, theses, dbt, contracts)
Snapshot	Immutable, frozen copy of a KLS
DLZ	Data Landing Zone — where raw data arrives from the source system
Live Root	Where tenant instances live on disk (`~/.jinflow/live/` by default)
Deploy Root	Where the application package lives (CLI + JinDesk binary)
Make	Single build command. Phase 0 extracts, Phase 1d publishes OPS notes/bookmarks to AFS, then enrich → compile → dbt builds the KLS
Inspect	Read-only view of the extraction surface (`jinflow inspect`). Renders the `pipeline.yml` contract and verifies hashes; never runs extraction
Extraction Contract	`pipeline.yml` at the tenant AFS root: lists every extract file with SHA-256 pin and expected schema
Operating Mode	One of five deployment topologies: Local, Proxy (P2P2P), Cloud, Semi-Cloud, Make-as-a-Service
Supply-Org	Pricing grain dimension (SAP Plant). Canonical values in nuMetrix: `PHA`, `LOG`. Pricing key is `(material, supply_org)`

Installation

macOS

Download the release package, extract it, and add to your PATH:

export PATH="$HOME/jinflow:$PATH"    # add to your shell profile
jinflow version                       # verify installation

Windows

Download the latest release ZIP, extract it. Run via jinflow.bat or add the folder to your PATH.

Linux

Download the latest release tar.gz, extract it, add to PATH.

First-time config

jinflow us --live-root ~/jinflow-data        # where tenant data lives
jinflow us --api-key sk-ant-...              # Claude API key (for AI features)
jinflow us hrcentral.vai            # set default tenant

Commands

`jinflow us` — Configuration

jinflow us                                # show current config with provenance
jinflow us pack.tenant                    # set default tenant
jinflow us --live-root /path              # set data directory
jinflow us --api-key sk-ant-...           # set Claude API key
jinflow us --model claude-opus-4-6        # set AI model for evolve

`jinflow config` — Configuration inspector

jinflow config                                # show all resolved configuration
jinflow config display.precision              # show specific key with provenance
jinflow config --diff                         # show tenant overrides vs pack defaults
jinflow config hrcentral.vai     # specific tenant

`jinflow ls` — List tenants

jinflow ls                                # list all packs + tenants (KLS size, source system, CSV count)
jinflow ls --snapshots                    # include snapshot details for all tenants
jinflow ls --snapshots my_tenant           # snapshots for one tenant

`jinflow pick` — Interactive tenant picker

jinflow pick                              # list tenants, pick one, set as default

`jinflow init` — Create a tenant

jinflow init --pack hrcentral --tenant my_org --source-system opale
jinflow init --pack hrcentral --tenant my_org --dlz /path/to/dlz           # auto-detect source system
jinflow init --pack hrcentral --tenant my_org --display-name "My Organization"
jinflow init --pack hrcentral --tenant my_org --engine-repo /path           # custom engine repo

`jinflow clone` — Copy a tenant

jinflow clone hrcentral.vai --name sandbox         # → rmc_sandbox
jinflow clone hrcentral.vai --name sandbox --display-name "Sandbox"
jinflow clone hrcentral.vai --name sandbox --no-share-dlz  # independent DLZ copy

`jinflow afs update` — Sync tenant AFS with pack

jinflow afs update                            # dry-run (show what would change)
jinflow afs update --do-it                    # apply updates from domain pack
jinflow afs update hrcentral.vai               # specific tenant

`jinflow afs reset` — Hard-reset tenant AFS

jinflow afs reset                             # reset current tenant AFS to match pack exactly
jinflow afs reset hrcentral.vai                # specific tenant

`jinflow afs remote` — Manage git remote

jinflow afs remote                            # show current remote URL
jinflow afs remote https://github.com/org/afs.git  # set remote URL

`jinflow afs status` — AFS git status

jinflow afs status                            # show branch, tags, dirty files
jinflow afs status hrcentral.vai               # specific tenant

`jinflow afs log` — Build logbook

jinflow afs log                               # show commit history / build logbook

`jinflow afs pull` — Pull from remote

jinflow afs pull                              # fast-forward pull from remote

`jinflow afs push` — Commit and push

jinflow afs push                              # commit changes and push to remote
jinflow afs push -m "Updated signals"          # with commit message

`jinflow afs pp` — Pull then push

jinflow afs pp                                # pull then push in one command

`jinflow inspect` — Read-only view of the extraction surface

jinflow inspect                           # overview for the default tenant (entries + source status)
jinflow inspect --verbose                 # full detail: hashes, sizes, mtimes, output rows
jinflow inspect --contract                # render the full delivery specification (pipeline.yml)
jinflow inspect --check                   # verify SHA-256 hashes + structure contracts (CI exit code)
jinflow inspect <entry_id>                # filter to one entry
jinflow inspect --tenant hrcentral.vai     # specific tenant

jin inspect sees extraction; it never runs it. jin make does extraction — Phase 0 reads pipeline.yml, verifies every SHA-256, and writes CSVs into the AFS before the build phases begin. See the Extraction Guide for the trust-boundary model.

`jinflow sis flush` — Publish pending OPS notes/bookmarks to AFS

jinflow sis flush                         # publish pending OPS cells for the default tenant
jinflow sis flush --tenant hrcentral.vai   # specific tenant

Handy when you want OPS edits committed to the AFS without running a full make. jin make publishes OPS content automatically as Phase 1d, so most users never need this.

`jinflow generate` — Synthetic data

jinflow generate                          # generate synthetic data for default tenant
jinflow generate hrcentral.vai             # specific tenant

`jinflow make` — Build

jinflow make                              # build default tenant
jinflow make hrcentral.vai   # build specific tenant
jinflow make millesime                    # build all tenants in pack (wildcard)
jinflow make --afs /path/to/afs           # explicit AFS path
jinflow make --clean                      # drop and rebuild KLS from scratch
jinflow make --extract                    # extract XLSX → CSV in DLZ, then update-raw, then build
jinflow make --sync                 # copy CSVs from DLZ to raw/ before building
jinflow make --snapshot                   # freeze KLS after build (auto-tag: YYYYMMDD-HHMM)
jinflow make --snapshot post-audit        # freeze with named tag
jinflow make --skip-enrich                # skip CSV enrichment step
jinflow make --skip-validate              # skip CSV schema validation step
jinflow make --no-deps                    # skip dbt deps install
jinflow make --continue-on-error          # collect all errors instead of fail-fast
jinflow make --quiet                      # suppress subprocess output

Build pipeline phases:

Enrich CSVs (add lineage columns)
Validate CSV schemas
Compile all instruments (signals, theses, verdicts, SMEbits, BitBundles, lineage, entities, reports)
dbt build: core (bronze → silver → gold) → analytics (signals, theses, verdicts, SMEbits) → reports → lineage
Post-build: pipeline graph, audit reports (PDF), extract PDFs from KLS

After build, PDF reports are extracted from the KLS audit_reports table into kls/reports/{tenant_id}/*.pdf.

`jinflow explore` — Web UI

jinflow explore                           # default tenant, port 4000
jinflow explore rmc             # specific tenant
jinflow explore --afs /path/to/afs        # explicit AFS path
jinflow explore --db /path/to/kls.duckdb  # explicit KLS path
jinflow explore --snapshot post-audit     # open a specific snapshot
jinflow explore --port 3000               # custom port
jinflow explore --docker                  # run JinDesk in Docker
jinflow explore --no-open                 # don't open browser automatically

`jinflow snapshot` — Freeze current KLS

jinflow snapshot                          # auto-tag: YYYYMMDD-HHMM
jinflow snapshot post-audit               # named tag
jinflow snapshot hrcentral.vai             # specific tenant

`jinflow status` — AFS status

jinflow status                            # current AFS summary
jinflow status --afs /path/to/afs         # specific AFS

`jinflow scripts` — Script resolution

jinflow scripts                           # show which script wins at each layer
jinflow scripts hrcentral.vai              # specific tenant

`jinflow evolve` — AI exploration

jinflow evolve                            # interactive REPL (AI + SQL)
jinflow evolve hrcentral.vai  # specific tenant
jinflow evolve --afs /path/to/afs         # explicit AFS path
jinflow evolve --db /path/to/kls.duckdb   # explicit KLS path
jinflow evolve --model claude-opus-4-6    # choose AI model
jinflow evolve --no-ai                    # SQL-only mode (no API calls)

`jinflow sources` — Source file inventory

jinflow sources                           # show CSVs, schemas, row counts, DLZ lineage
jinflow sources hrcentral.vai # specific tenant

Each CSV row is prefixed with a status marker indicating how the file relates to the AFS CSV schema:

Mark	Meaning
`✓`	CSV is on disk and declared in the schema — fully accounted for
`·`	CSV is on disk but not declared — orphan file, or schema is out of date
`✗`	Schema expects this file, but it’s missing — build will fail until delivered
`-`	Schema expects this file, absent, but marked optional — safe to ignore (labeled “SKIP”)

Typical uses: all ✓ means schema and filesystem agree. Any ✗ means jin make will error. Any · is a hint that a new feed arrived (update the schema) or an orphan lingers (delete or archive).

`jinflow stat` — KLS statistics

jinflow stat                              # gold layer counts, analytics pyramid, health checks
jinflow stat hrcentral.vai                 # specific tenant

`jinflow purge` — Slim down KLS

jinflow purge hrcentral.vai          # dry-run (show stats)
jinflow purge hrcentral.vai --do-it  # drop bronze + silver tables

`jinflow notebook-pdf` — Export notebook as PDF

jinflow notebook-pdf nb_io_article_reconciliation           # export to PDF
jinflow notebook-pdf nb_io_article_reconciliation --lang de # German version
jinflow notebook-pdf nb_io_article_reconciliation -o out.pdf

`jinflow help` — Detailed help

jinflow help                              # list all commands
jinflow help make                         # detailed help for a command

`jinflow release-notes` — Generate release notes

jinflow release-notes                     # generate RELEASE_NOTES.md from git

`jinflow pack` — Pack operations

jinflow pack ls                           # list packs, artifacts, tenant sync status
jinflow pack ls --sync                    # include sync status for all tenants
jinflow pack clone millesime               # clone a domain pack from GitHub
jinflow pack clone millesime --https       # clone via HTTPS instead of SSH

`jinflow ship` — Build, sync, and refresh

jinflow ship                              # dry run: see what would happen
jinflow ship --do-it                      # current tenant → sync → refresh
jinflow ship --all --do-it                # all tenants → sync → refresh
jinflow ship --all --do-it --clean        # clean build all → sync → refresh
jinflow ship millesime --do-it            # one pack only

`jinflow cloud` — R2 cloud operations

jinflow cloud ls                          # list KLS files and R2 sync status
jinflow cloud ls --local-only             # only show local files
jinflow cloud sync --do-it                # upload KLS files to R2
jinflow cloud sync --do-it --prune        # upload + delete remote files not in local
jinflow cloud blacklist hrcentral.vai      # exclude tenant from sync
jinflow cloud blacklist hrcentral.vai --remove  # re-include tenant

`jinflow instance` — Manage deployed instances

jinflow instance ls                                    # list registered instances
jinflow instance add demo https://this-is.jinflow.io   # register an instance
jinflow instance remove demo                           # remove an instance
jinflow instance refresh demo                          # tell instance to re-download from R2
jinflow instance refresh --all                         # refresh all instances
jinflow instance refresh demo --scope pack --pack hrcentral  # refresh specific pack

`jinflow version` — Version info

jinflow version                           # show version + release notes

Evolve REPL

Two modes: ai.less (SQL + commands) and with.ai (Claude-powered natural language).

Command	Description
`SELECT ...`	Run any SQL (also INSERT, CREATE, any valid DuckDB statement)
`/tenants`	List tenants in the KLS
`/schema <name>`	Describe a DuckDB schema (e.g. `/schema rmc`)
`/probes`	List signals (also `/hypotheses`, `/diagnoses`, `/smebits`)
`/read <type> <id>`	Read artifact YAML (e.g. `/read probes probe_revenue_leakage`)
`/write <type> <id> <yaml>`	Write artifact to AFS (e.g. `/write probes probe_test '{...}'`)
`/delete <type> <id>`	Delete artifact from AFS
`/explain <Type> <id> [tenant]`	Entity dossier (e.g. `/explain Case CASE_0001 my_tenant`)
`/make [flags]`	Rebuild KLS without leaving the REPL (resets AI context)
`/ai`	Toggle AI mode on/off
`/help`	Show help
`exit`	Quit

In with.ai mode, type natural language — Claude queries DuckDB, reads/writes artifacts, and explains entities automatically.

Workflow

The core loop

  jinflow make        Build the KLS
       ↓
  jinflow explore     Browse findings in the web UI
       ↓
  jinflow evolve      Ask questions, discover patterns, add signals
       ↓
  /make               Rebuild from within evolve
       ↓
  Back to explore...

Onboarding a new tenant

jinflow init --pack hrcentral --tenant new_org --source-system opale
# place XLSX exports in DLZ: {dlz}/new_org/opale/xslx/
# or place CSVs directly:    {dlz}/new_org/opale/csv/
jinflow make hrcentral.new_university --extract --clean   # full pipeline
jinflow explore hrcentral.new_university

Snapshotting

jinflow make                     # iterate...
jinflow make --snapshot          # freeze when happy
jinflow explore --snapshot 20260311-1430   # revisit anytime

Syncing with the pack

jinflow afs update                   # dry-run — see what changed in the pack
jinflow afs update --do-it           # apply changes
jinflow make                     # rebuild with updated instruments

Data Flow

DLZ (Data Landing Zone)
  └── extract (XLSX → CSV)
       └── raw/ (immutable source CSVs)
            └── enrich → build/csv/ (enriched CSVs)
                 └── dbt build → KLS (DuckDB)
                      └── audit reports → kls/reports/*.pdf

Tenant Instance Layout

~/.jinflow/live/
  {pack}/
    {tenant}/
      afs/                          ← analytical framework (git repo)
        signals/, theses/, ...
        dbt/{pack}/
        reports/                    ← report YAML definitions
        jinflow.yml                 ← pack manifest
      raw/                          ← immutable source CSVs
        {source_system}/csv/
      build/                        ← intermediaries
        csv/                        ← enriched CSVs that dbt reads
      kls/                          ← KLS files
        {pack}_{tenant}_kls.duckdb        ← working copy
        post-audit.duckdb             ← named snapshot
        reports/                      ← PDF reports extracted from KLS
          {tenant_id}/
            report_executive_summary.pdf
            report_data_quality.pdf

Reports

Reports are declaratively defined (reports/*.yaml), compiled to dbt SQL by reportcompile.py, built as dbt models (tag:report), then rendered to PDF by auditreport.py (requires weasyprint). The PDFs are stored inside the KLS in an audit_reports table and extracted to kls/reports/{tenant_id}/*.pdf after every build.

Reports are also browsable in JinDesk at /{tenant}/reports.

Analytics Pyramid

                ┌─────────────┐
                │  Verdicts  │  WHY is it happening?
                ├─────────────┤
                │ Theses  │  WHAT is happening?
                ├─────────────┤
                │   Signals    │  What does the DATA show?
                ├─────────────┤
                │ Perspectives │  Entity-level health scores
                ├─────────────┤
                │    Gold     │  Product contract
                ├─────────────┤
                │   Silver    │  Domain truth
                ├─────────────┤
                │   Bronze    │  Structural ingestion
                └─────────────┘

    ┌─────────────┐
    │  SMEbits    │  Expert knowledge (free-floating)
    ├─────────────┤
    │ BitBundles  │  Curated narratives
    └─────────────┘

Environment Variables

Variable	Purpose
`JINFLOW_LIVE`	Override live root (data directory)
`JINFLOW_TENANT`	Override default tenant
`JINFLOW_DB_PATH`	Explicit KLS DuckDB path
`JINFLOW_AFS_ROOT`	AFS root (for JinDesk)
`JINFLOW_TENANTS_DIR`	Tenants directory (for JinDesk)
`JINFLOW_SYSTEM_DB_PATH`	System DB path (optional, operational state)
`JINFLOW_DEPLOY_ROOT`	Deploy root for app package
`ANTHROPIC_API_KEY`	Claude API key (for evolve)

jinflow is a jazzisnow product

v0.64.7 · built 2026-09-20 19:48 UTC 

jinflow CLI Cheat Sheet

Concepts

Installation

macOS

Windows

Linux

First-time config

Commands

jinflow us — Configuration

jinflow config — Configuration inspector

jinflow ls — List tenants

jinflow pick — Interactive tenant picker

jinflow init — Create a tenant

jinflow clone — Copy a tenant

jinflow afs update — Sync tenant AFS with pack

jinflow afs reset — Hard-reset tenant AFS

jinflow afs remote — Manage git remote

jinflow afs status — AFS git status

jinflow afs log — Build logbook

jinflow afs pull — Pull from remote

jinflow afs push — Commit and push

jinflow afs pp — Pull then push

jinflow inspect — Read-only view of the extraction surface

jinflow sis flush — Publish pending OPS notes/bookmarks to AFS

jinflow generate — Synthetic data

jinflow make — Build

jinflow explore — Web UI

jinflow snapshot — Freeze current KLS

jinflow status — AFS status

jinflow scripts — Script resolution

jinflow evolve — AI exploration

jinflow sources — Source file inventory

jinflow stat — KLS statistics

jinflow purge — Slim down KLS

jinflow notebook-pdf — Export notebook as PDF

jinflow help — Detailed help

jinflow release-notes — Generate release notes

jinflow pack — Pack operations

jinflow ship — Build, sync, and refresh

jinflow cloud — R2 cloud operations

jinflow instance — Manage deployed instances

jinflow version — Version info