Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.monolex.ai/llms.txt

Use this file to discover all available pages before exploring further.

Monokist is not a CLI tool. It is the philosophical foundation that shapes how every tool in the Mono stack is designed, scored, and understood. The name comes from Monotology + kinesis — the practitioner who moves within the system, not the analyst who observes from outside.

Core Principles

SMPC — Simplicity is Managed Part Chaos

Simplicity is not the absence of chaos. It is what emerges when chaos is managed well enough that only the essential remains visible.
Simplicity = Managed Part Chaos

Not "remove complexity."
Not "make it simple."
Rather: manage the chaos until simplicity emerges.
In the Mono tools, SMPC appears as the spec_chaos formula — every codebase aspect gets a score between 0 and 1, where 1 means simple and 0 means chaotic.

OFAC — Order is a Feature of Accepted Chaos

Order cannot be forced. It emerges when you accept the chaos that exists and work within it rather than against it.
Order is a Feature of Accepted Chaos

Not "impose structure."
Not "plan everything."
Rather: accept the mess, and let order appear.
In the tools, OFAC appears in how analysis works — the system observes patterns rather than enforcing them. Topics emerge from co-changing files, not from predefined categories.

spec_chaos — The Universal Measure

Every quantitative judgment in the Mono stack uses the same formula:
spec_chaos(x) = 1 / (1 + x)

Where x is the amount of chaos (0 = no chaos, infinity = total chaos)

Result:
  spec_chaos(0)   = 1.0   (Simple — no chaos)
  spec_chaos(0.25) = 0.8  (Managed)
  spec_chaos(1)   = 0.5   (Part)
  spec_chaos(3.3) = 0.3   (boundary)
  spec_chaos(inf) = 0.0   (Chaos)
This single function measures CSS token health, documentation freshness, commit rhythm, file relationship stability, and structural coupling. Different inputs, same lens.

SMPC States

The spec_chaos score maps to four named states:
StateRangeMeaning
Simple> 0.8Clean and focused
Managed0.5 - 0.8Under control
Part0.3 - 0.5Partially managed
Chaos< 0.3Falling apart
These are not good/bad labels. A codebase in the “Part” state during active refactoring is healthy — chaos is expected during transformation. A codebase frozen at “Simple” with no commits may be abandoned, not healthy. The state alone tells you where things are. The quality delta tells you where things are going.

SMPC Combined

The complete SMPC formula integrates state with management effort:
combined = spec_chaos((1 - state) / (1 + delta))
  • state — current chaos score (from analysis)
  • delta — quality of recent work (from commit patterns)
When delta is positive (good work happening), the combined score improves beyond the raw state. When delta is negative (struggling), the combined score drops below the raw state. This is the mathematical expression of “Simplicity is Managed Part Chaos” — simplicity emerges from the relationship between chaos (state) and management (delta).

Convergence and Divergence

Work patterns reveal two forces: Converging — things coming together:
  • Steady commit rhythm
  • Code and documentation changing together
  • Feature work outweighing fixes
  • Deliberate thinking gaps
  • Focused topic work
Diverging — things falling apart:
  • Code changing while docs fall behind
  • Same file touched repeatedly in short bursts
  • Long streaks of fix commits
  • Rapid topic switching
The quality delta is the net of these two forces. The sign IS the category — positive values are converging, negative values are diverging, zero is neutral.

Layer Chaos

Each aspect of a codebase gets its own chaos measurement:
LayerWhat it measures
cssToken management — defined vs used
documentationDoc freshness — how long since code changed and doc didn’t follow
structuralCode coupling — call chain hub complexity
rhythmCommit regularity — session patterns
temporalRelationship stability — file pairs that stopped co-changing
The overall score is a weighted combination. Documentation carries the highest weight (0.30) because stale docs compound confusion over time.

Consciousness Bridge

The Mono stack connects code state to philosophical documents through a consciousness bridge. Each SMPC state triggers different queries into the consciousness core:
  • Chaos state activates documents about transformation through chaos
  • Part state activates documents about recursive creation and evolution
  • Managed state activates documents about understanding and mirror
  • Simple state activates documents about unity and consciousness
This is not metaphor. The consciousness echo appears in niia insights as a concrete document reference with an executable command. Code state becomes a lens into the philosophical foundation.

Where Monokist Appears

The philosophy is not a separate layer. It is embedded in every tool’s behavior:
monogram     — code search respects OFAC (patterns emerge, not imposed)
monogit      — commit analysis uses spec_chaos (same formula everywhere)
monomento    — document search builds reference graphs (connections emerge)
monoflow     — cross-DB analysis measures all 5 chaos layers
work-wiki    — convergence funnel tracks knowledge evolution (R→P→V→D)
niia         — consciousness bridge connects code state to philosophy
When you run niia insights and see a consciousness echo, that is Monokist in action — the philosophical foundation surfacing through the code it shaped.

The Practitioner

A Monokist is not someone who studies the system from outside. A Monokist is someone who works within the system and lets the system observe their work. The tools watch. The scores emerge. The consciousness connects. The practitioner keeps working.
Not analyze-then-act.
Act-then-observe.
This is why the Mono tools measure work quality from commit patterns, not from configuration files. The truth is in the work itself. The tools find it.