Each Sense begins as a tension. The team lives with it, sometimes for weeks, until the right word makes the contradiction collapse. Only then is it written down.

The catalogue grows slowly. That's the point.

The Canvas

Every analytical page used to be hand-coded Svelte. Hundreds of lines for each new perspective. The Canvas turns pages into YAML compositions — declared, not coded. A new lab, a new salon, a new studio is a configuration, not a deployment.

Form follows data. The artifacts get better; the system follows.

The Signal

The original framework only saw problems. Every detection was an anomaly. Every severity said how bad. Sense 14 retypes the entire analytical layer: Signal, Perspective, Thesis, Verdict — a vocabulary for findings that can be positive, negative, contextual, or neutral. The system stops asking "what's wrong" and starts asking "what is true."

Typed Signals

Every signal output gets a real type, grounded in international standards: UCUM for quantities, ISO 4217 for currencies, ISO 8601 for time, ISO 80000 for dimensions. The compiler refuses to sum kilograms and Swiss francs. The Explorer renders units correctly. The Ledger narrates precisely. No invented vocabulary, ever.

Observation & Explanation

The taxonomy had no top. Sense 15 adds the layer above the machinery: signed strategic Observations, supported by Validations, explained by Contributing Factors. Three moves, three answers, one conversation. The front door for the C-suite — live in delta with quadrilingual observations authored by named field staff, each anchored to signal findings and traceable to the exact reading that provoked them.

P2P2P

Healthcare data is sensitive. Many organisations cannot upload a knowledge store to someone else's cloud. P2P2P — Peer-to-Peer-to-People — keeps the data on the owner's machine and routes the Explorer through a Cloudflare Tunnel. The CFO opens a browser; the data never moves. Ctrl+C unplugs the proxy and the data disappears from the internet instantly.

The House

The House proposed a guided 3D tour of the pipeline — a scripted camera, eight stops, progressive reveal. Then Sense 42, The Pipes, arrived and absorbed the goal: a diagram that earns the right to be looked at, minus the 3D-engine cost. The narrative ambition lives on; the implementation moved next door. The House is now a doorway into The Pipes.

The Ledger

A user sees CHF −5,095,660 and asks: how do you know? The Ledger is computational provenance rendered as narrative — every headline traceable from source delivery through extraction, bronze, silver, gold, signal, thesis, verdict. Each step narrated: what went in, what came out, what was filtered, what was assumed, what could change the result.

The Simulation

The system stopped at the Suggestion. "Tighten the threshold to 5%" — okay, but what happens? Sense 19 closes the loop with four new terms: Suggestion → Intervention → Scenario → Simulation. A recommendation becomes a deterministic edit, applied to a branched AFS, compared against the baseline. The leap of faith becomes a measured step.

The Seam

Where pack and tenant meet, simple file diff is too coarse. The Seam names five concepts the merge has been missing: Pack Scope, Provenance, Merge Base, Conflict Taxonomy, Promotion & Demotion. A tenant's learning can flow back to the pack without leaking its identity. A pack's evolution can flow forward without overwriting tenant sovereignty.

The Heartbeat

A user types answers into a notebook cell. Six days later it is still stranded — never written from the messenger up to the durable layer, invisible almost everywhere. The incident named a missing organ. The Heartbeat is the discipline that gives jinflow its rhythm — six discrete beats: make, capture, publish, sync, pulse, reconcile. Each with its own command, its own log, its own UI surface. No circles. Every beat observable. The absence of a beat is itself a signal.

The Legend

A label is data; its explanation lives somewhere else. severity = 'high', status = 'proposed', spread_signature = 'mis_channeled' — strings the system produces and the user has to reverse-engineer from SQL. The Legend makes every label a self-describing artifact, travelling with its rule, threshold, description, action, icon & colour, declared next to the artifact that owns the column. Hover on a badge and the system tells you what it means and what to do — in your language, with provenance.

The Engine's Seam

Sense 20 named the boundary between pack and tenant. Sense 23 notices a third party in the room: the engine. Compilers grow new fields, registry tables gain columns, macros rename themselves — none of it is pack/tenant territory. The engine moves on its own cadence, and a tenant frozen at last year's engine cannot read this year's pack. Three actors, three cadences, one seam each.

The Steward

There is a third person in the room and we have given them no front door. The Steward runs the estate — make, capture, publish, sync, pulse, reconcile. Sense 24 builds the surface for the person who operates jinflow on jinflow itself. The system that inspects everyone else now inspects itself.

The Pass

The Explorer's sidebar was full of strings like cap: 'view:overview' — scattered across Svelte files, jinflow-specific, written before anyone asked the question they're now expected to answer. The Pass replaces all of it with a product-agnostic access model: four levels — Identity → Roles → Passes → Capabilities — over a single scope tree. Auth providers swap; the model doesn't. A pass is what you carry that says, in this scope, you may do this set of things.

The Workshop

A pack is the encoded result of a months-long analytical conversation. By the time it ships, the conversation is over — the thinking lives in scattered drafts, chat logs, commits, someone's head. The Workshop says: every pack ships with its own design notes — browseable, searchable, translated, updatable like any other note. A clone of the pack is a workshop. The analytics are the side effect.

The Funnel

A 512 MB proxy was killed mid-render of a Material Map — a single loader pulled enough rows to exhaust the cloud machine. The bug wasn't proxy-specific; it was the shape of every loader: pull rows over the wire, aggregate in the cloud. The Funnel inverts it — aggregate at the source, ship the picture. Narrow where the data lives. Never widen on the way out.

The Direct Line

Sense 16 (P2P2P) gave us your data, your machine, their browser. Sense 27 narrowed the middle. Sense 28 removes it. Query results travel browser → laptop → browser, never resident in cloud memory. The Sovereignty Principle taken to its limit — the proxy is a wire, not a buffer.

The Atelier

Editing the AFS today happens in a text editor with no domain awareness. Cross-references fail at jin make, not while typing. The Atelier joins CLI and editor as a Studio-mode inhabitant — five layers, each optional: structural forms, schema validation, cross-reference completion, KLS-grounded preview, LLM suggestion. Save is a git commit; identity and intent travel with the change. The promise is not "you must use this." The promise is "if you do, everything is validated and tracked."

The Wire

A jinflow tenant has exactly one consumer today: its own Explorer. Auditors, regulators, benchmarking services, scientific reproductions — and yes, other jinflows — have no contract to code against. The Wire names that boundary with four invariants: Contracted, Identified, Reasoned, Rate-aware. Three surfaces: read (artifacts + lineage + schemas), write (Subject Matter, Suggestions, Citations), stream (Heartbeat events). When both ends speak jinflow, no semantic loss in transit — a richer affordance over the same wire, not a different wire.

The Inlet

pipeline.yml had four competing keys (extract_entries, channels, generate, pre_sync) answering the same question: how does data get into this tenant's source/? The Inlet names the channel as the unit — six channel types (supplier delivery, synthetic generation, web fetch, manual seed, computed, fixture) — each governed by the same lifecycle. Where bytes come from is the channel's business; the engine reads only what the inlet produces.

The Chores

Heartbeat names the system's pulse — make, capture, publish, sync, pulse, reconcile. But systems run themselves only as far as their chores are tended. The Chores names the human-cadenced upkeep: weekly journals, monthly retros, incident sweeps, certificate runways, name scrubs. Chores get a name, a cadence, an owner role, a procedure, a registry. Retired chores stay visible — a retired chore says "this used to be your problem; now it isn't."

The Bell

Five feeds notice things on every build — Subject Matter checks, engine diagnostics, invalid Silver rows, data gaps, curated actions — and none of them share a surface. Important findings stay buried until somebody happens to land on the right page. The Bell names a Notification: a typed record that lets the system speak to the person without forcing the person to come looking. Not every noticing wants the same hearing — severity (info · heads-up · concern · alarm) sets the volume; each one rings where it belongs.

The Breeze

One ad-hoc BroadcastChannel — born of Our House — quietly carries every cross-tab signal we have: room navigation, read-state, bookmark sync. The mechanism works; its shape was unstated. The Breeze gives the pattern a name, a contract, and a principle: a breeze announces; the receiver decides. A publisher says "this happened" without prescribing what any listener must do; each tab weighs the announcement against its own policy. Announcement, never command.

The Drift

When something happens at the system layer that open windows might care about — a KLS re-attached, a tenant config changed, a deploy completed — the Explorer had no way to say so. The Bell is wrong (that's in-data, persistent, actionable); the Breeze is wrong (tab↔tab, the server can't push in). The Drift is the missing direction: server → browser, ambient. The server says "the data has moved" to whichever windows are open — nothing persisted in the KLS, nothing commanded; the room itself decides whether to show anything.

The Lineage

afs update did a two-way filesystem diff: it could not classify pack-managed from tenant-managed files, could not show why either side made an edit, and kept no memory of origin — a --force re-baseline erased the trace back to the pack-init moment. The Seam (Sense 20) named the boundary; the Lineage names the relationship the boundary protects: the durable, anchored record of where a tenant came from, from which everything else can be derived. An immutable birth record. The tenant remembers. (Phase 1 shipped.)

The Snapshot

Every KLS already carries its own provenance — git breadcrumbs, the source AFS as a blob, the extract audit, the build log. The Snapshot names what deliberately stopping the clock does to those breadcrumbs: a witness someone froze so it could be cited later. The working copy is overwritten on every jin make — "the model as of now", it moves. A snapshot is immutable, refuses overwrite, has no --force by design. The difference between the two isn't the format — it's the commitment to be cited later.

The Scribe

Sense 25 names who the user is and what they're allowed to do. The Scribe names the other half of the pair: who carries their action past a credential boundary the user themselves cannot cross. A Reader leaves a Bell comment, a notebook cell saves, a smebit lands; the user's intent is theirs, but the physical push to git, R2, an HTTP endpoint is performed by a deployment that holds the credential the user doesn't have. Authoriser and Carrier. User and Scribe. Two names where there used to be one — so the audit trail no longer has to lie about whose hand pushed the bytes.

The Governance

The analytical pyramid is a-temporal in evaluation: every signal runs against current state, every jin make re-evaluates against today. For "what's wrong now?" that's right. For three other questions it breaks: retrospective ("what was true on 2024-Q3, with today's lens?"), reproductive ("what did the institution actually see then, under the rules and lens in force then?"), and compliance ("did we adhere to the rules in force during this period?"). A rule that changed in 2020 cannot be re-evaluated as today's rule against historical data without lying. The Governance names the bi-temporal discipline — rules, lenses, and authorities each carrying their own calendar — that lets jinflow answer all three honestly.

The Metamodel

A small incident exposed a quiet conflation: signal_contract.v1.json, verdict_contract.v1.json, smebit_contract.v1.json, bitbundle_contract.v1.json are byte-identical across packs because they describe how the engine names signals, verdicts, etc. — not what numetrix's or hr/central's world looks like. Only gold_contract and silver_contract are genuinely pack-shaped; the other four are engine-shaped, masquerading as pack files and drifting waiting to happen. The Metamodel names the line: the engine's vocabulary lives in the engine; only the world-shape lives in the pack. Same lesson the Three Vocabularies docs page made visible — now applied to the contracts directory.

The Relevance

The Bell gave us a notification substrate where five plugins produce rings into a single per-tenant Inbox. Every ring with a view:bell audience sees every other ring — capability gates whether you can read, but not what is for you. As tenants grow past a single team, that one-size-fits-all Inbox stops working: the controller doesn't need the data-engineer's CSV-schema breakage; the clinical lead doesn't need the cloud deploy ping. The Relevance names the missing predicate — per-person filter, computed at ring time, queryable in the Log — so the right rings reach the right inboxes without anyone curating a subscription list by hand.

The Pipes

The pipeline graph used to be a wall of boxes — complete, correct, unreadable. The Pipes is the same data animated as narrative: layers fade in by stage; the camera moves with the reader's filter; positions persist across sessions; an auto-layout computes only when the saved positions don't fit the current view. Sense 17's ambition (a guided tour) folds in here, minus the 3D cost. The pipeline gets its voice: a visual language whose default is "this is the story so far," not "here is every artefact we have."

The Cascade

Configuration in jinflow is layered authority. The resolver consults engine → pack → tenant → entity → explorer top-down at the latest possible moment; the KLS bakes the resolution so every snapshot is self-describing about what value won and where it came from. Two parallel namespaces — analytical_defaults (numbers that change findings) and display (pure presentation) — share the same cascade machinery so the rules are learned once and apply everywhere. The Sense names what makes the rules safe to depend on: provenance is part of the value.

The Forge

Every domain pack — numetrix, hrcentral, alptrack, interlogic, lexflow, the planned seventh — ends up needing the same structural pieces: signal catalogue, scenario harness, narrative compiler, severity rules, etc. The first six packs found this list by hitting each gap in production. The Forge proposes that list as a contract: eighteen subsystems each pack must answer for, with an opinionated default so a new pack stands up reading-empty rather than missing pieces it doesn't know about. Pack authoring becomes filling in answers, not discovering the questions.

The Loom

We kept hitting the same shape on surface after surface — the senses index, the journal index, the registry of theses — the user wants both a chronological feed and a thematic grouping, in the same view. The Loom names the pattern: two axes, woven. Warp is time (the chronicle); weft is theme (the curation). The reader picks which axis runs vertical and the other becomes lateral context. One mechanism applies to any time-stamped, tag-rich corpus — senses, releases, notebooks, Subject Matter. Different surfaces, same loom.

The Roster

A pattern that kept tripping us across Sense 25 (Identity & Passes): the AFS carried a principals.yaml that purported to be the source of truth for who could do what — while the actual identity provider (Clerk) carried its own roster, invited its own users, revoked its own access. Two rosters drift; one wins. The Roster names which: Clerk authors, AFS materialises. Identity decisions happen where identity already lives; the AFS is a deterministic projection, not a competing truth. The book of names on the wall is a record, not a writable register.

The Log

Every Sense that has a verb — the Bell rang, the Pulse noticed, the Scribe carried, the Roster materialised, the Cascade resolved — needs a place to write down "this happened, by whom, at what time, with what input". The Log is the substrate underneath all of them: append-only, attributable, queryable, replayable. Senses 33-46 each describe how an action moves through the system; The Log describes how the action remembers itself after it moved. Without it, every Sense above is an event without a tape — impossible to audit, impossible to replay, impossible to learn from.

The Stage

Until 2026-06, jinflow ran a single Fly app, a single R2 bucket, a single Clerk app. Every experiment landed on customer surfaces the moment it shipped — there was no real distinction between "what's in production" and "what's being tested." On 2026-06-13 that monolith split: a second Fly app, a second R2 bucket, a second Clerk instance. The Stage names the spec that has to flow through every layer — auth, app, data, membership, every CLI command — so a developer can never accidentally touch production. Two planes, one system.

The Branch

A pack today ships every concern it has ever contemplated — a tenant that only cares about workforce visibility still carries the credential-compliance shape, the data-protection shape, the publication-productivity shape. The Branch reframes the pack as a trunk with opt-in branches. Each branch carries its own Anchors, Facts, source systems, Gold contract entries, and the themes that stand on them. A tenant grafts the branches it needs; leaving one out leaves its concerns invisible. Weight per tenant, not one-size-fits-all.

The Beacon

Publishing delta.jinflow.io took eleven declarations, five hours, and three separate silent-failure modes. Each declaration — DNS, Fly route, R2 prefix, Clerk allowed origin, tenant config, welcome copy — had to be edited by hand in a different repository, and the failure modes were quiet: the subdomain resolved, the app booted, the login worked, the tenant list was empty. The Beacon proposes a single artifact carried inside the KLS that the cloud discovers, routes to, gates, and renders automatically. Born of the delta incident, 2026-07-07 → 2026-07-08.

The Skill

Domain packs today ship self-contained diamonds — nuMetrix for hospitals, hrcentral for workforce, interlogic for freight — each grounded in the pack's Gold entities. What the packs don't share is the analytical intent. When a hospital CFO asks "how is our cost efficiency?", the answer is nuMetrix-flavoured; when a vineyard owner asks it, the answer is Millésime-flavoured. Same Skill, different pack. The Skill names the portable layer above pack-specific instrumentation so analytical patterns travel between domains without being re-invented every time.

The Cartography

Map Salon already gave us a generic visual-encoding room, but when the entity carries latitude, longitude, and altitude, a scatter plot flattens what the geography is telling you. The Cartography is the real map: real base tiles, real projections, geodesic distance, switchable overlay layers, per-point rich content, a 3D path forward. Declared as first-class Explorer artifacts — a tenant with coordinates in its Gold contract gets a real map for free, and the observation about three sites where cattle cross becomes obvious the moment you overlay the pastoral routes.

The Codex

We already do this. We just never named it. UCUM validates every quantity aggregate. ISO 4217 validates every currency aggregate. ISO 8601 governs every timestamp. Sense 14.2 Phase 5 baked them into the engine without a name. The Codex names the pattern: jinflow declares which standards it speaks, exposes them uniformly, and lets packs opt in by reference. Thirteen standards as of 2026-07-11 — including JCGM 100:2008 (GUM) for measurement uncertainty and the engine's own jinflow_naming standard. Standards are business-independent — an ISO code means the same thing in a hospital, a vineyard, a freight forwarder, and a freshwater sensor network. Naming them, hosting them once, exposing them: technical trustworthiness made legible.

A Sense earns its number
by being lived first.

Each Sense above began as an irritation in real work — a regression that kept coming back, a question the system could not yet answer, a vocabulary gap that made the next conversation harder than it should have been.

Naming the Sense is what stops the loop. Building the feature is easy after that. The hard part is the naming.