Architectural Vision for this Ecosystem

Dimensional Fields™: Analogical Synthesis for Social Benefit

The system orientation is beneficial outcome from conflict data — privately, dynamically, on hardware you already own. The destination itself is deliberately under-defined: see The Prize.

• Human conflict produces text that carries more than its argument — it carries the emotional state of the person producing it, recoverable and predictive
• Two fundamentally different kinds of knowing have to work together: the left side reads for felt meaning, the right side processes structure — neither consuming the other
• The output is not a resolution between positions but something neither side could see from inside the conflict — navigational, not conclusive
• This is not dialectical synthesis — the analogical left-side truth is not opposed and resolved, it is supported by analytical power and remains fundamentally human
• LLMs participate through analogical synthesis: perceiving semantic patterns, producing sense-making that mirrors human intuition, not replacing it

┌──────────────────────────────┐     ┌──────────────────────────────┐
│    LEFT: SEMANTIC SIDE       │     │    RIGHT: DIGITAL SIDE       │
│    ──────────────────        │     │    ───────────────────       │
│    Analogical "Logos"        │     │    Analytical Precision      │
│    Emotion, intuition,       │     │    Code, organization,       │
│    felt meaning              │     │    data structures           │
│    "What does this MEAN?"    │     │    "How do we PROCESS this?" │
│    ───────────               │     │    ────────────              │
│    The human side            │     │    The machine side          │
│    The heart                 │     │    The stone                 │
└──────────────┬───────────────┘     └───────────────┬──────────────┘
               │                                     │
               └─────────────┬───────────────────────┘
                             │
                  ┌──────────▼────────────┐
                  │   FUNCTIONAL MODEL    │
                  │ Predicting Beneficial │
                  │       Outcomes        │
                  └───────────────────────┘

This duality is not a metaphor. It is the architectural spine of the entire ecosystem.

The Prize: A Modeling Structure Not Yet Invented

The purpose of this project is deliberately under-defined: beneficial, and not yet nameable. The prize is a way of modeling human conflict that does not exist yet — modeling in ways we cannot yet imagine. That is not evasion; it is the project's own first principle applied to itself. In a system where all structure must emerge from the data, the purpose must emerge from the model — naming the destination in advance would impose the one taxonomy the system exists to refuse.

Any reading of this page that assigns the system a single definite product purpose has misread it. What follows can be read off the model; none of it is what the model is built toward.

The Building Strategy — Three Honest Strands

The work currently lives inside the legal system, for three reasons at once, stated plainly:

The two columns above are not a formatting choice. They are the system's spine — felt meaning on the left, counted measure on the right, and the instrument's whole job is the honest distance between them.

1. Applications: Conflict Resolution

The system reads conflict text the way a skilled human reader does — for what it reveals, not just what it says.

• Any situation where people produce text under pressure carries a recoverable emotional signal — predictive of what comes next, actionable before it arrives
• The founding use case is high-stakes conflict resolution: disputes where the gap between what is said and what is meant is the whole problem
• Justice systems provide the cleanest corpus — timestamped, attributed, formally registered, with measurable outcomes — but the tool generalises to any domain where conflict produces text
• Built for the person in the conflict, not the system processing it — pattern recognition they can act on, in language they can understand
• Private by architecture: sensitive material is processed locally, never transmitted, never stored on a cloud server

The Proof-of-Concept Signal

Early work produced inferences that were highly predictive of real-world outcomes — specifically anticipating where an adversarial actor would strike before it occurred. Perplexity characterised this capacity as intuition. That predictive signal, recoverable from conflict text, is what this system is built to make repeatable and scalable.

Distilled Essence Persistence (YTDMSP)

LLMs perform analogical synthesis during inference but discard it post-response. The Yet-To-Define Memory/Storage Paradigm captures the distilled essence of ephemeral intuition — analogous to a therapist's case notes, not the session transcript:

• Attention snapshots from mid-inference reasoning chains
• Analogy chains detected across sessions — accumulated judgment, not retrieved facts
• Emotional valence gradients quantified from conflict text
• Common sense emergences captured as graph nodes before they dissipate

This persistent intuition reservoir transforms one-shot analysis into lifelong pattern recognition.

2. Vivify: The Schema-Free Semantic Data Engine

Vivify builds data structures the way meaning builds itself — without a schema declared in advance.

• Inspired by Perl's autovivification: assign to a path that doesn't exist and every intermediate node springs into being, no declaration required
• An LLM reads raw text and extracts keyword clumps that capture felt meaning — not surface words but concept-level tokens like conflict_asymmetry or therapeutic_potential
• Keywords that co-occur across inferences form natural clusters — emergent categories, bottom-up, no external taxonomy imposed
• The filesystem grows itself from the data: category paths become directories, inferences become JSON files, human-readable and auditable with any text editor
• No database engine, no migrations, no schema to maintain — backups are cp, migrations are mv
• A dual pass captures both sides: left keywords for felt meaning; quote-grounded right facts and claimed-vs-actual discrepancies for counted truth — tension is measured between them as three numbers: predicted, confirmed, and their calibration delta

The Inference Structure

{
  "id": "inf_123",
  "raw_text": "...",
  "left_keywords": ["conflict_asymmetry", "emotional_truth", "therapeutic_potential"],
  "right_keywords": ["json_indexing", "pattern_detection", "similarity_clustering"],
  "clumps": {
    "conflict_resolution": ["conflict_asymmetry", "resolution_focus"],
    "therapeutic_signal": ["emotional_truth", "therapeutic_potential"]
  },
  "category_paths": ["conflict_resolution/therapeutic_signal"],
  "tension_score": 0.87
}

The Autovivified Filesystem

inferences/
├── conflict_resolution/
│   ├── misrepresentation/
│   │   └── stressed_perception/
│   │       └── inf_123.json
│   └── resolution_focus/
│       └── adaptive_compromise/
│           └── inf_456.json
├── therapeutic_prediction/
│   └── beneficial_outcomes/
│       └── inf_789.json
└── index.json   # Master co-occurrence map

The FABRIC Pipeline

Each step is a standalone script, visible as a shell command, replaceable without touching the others:

raw text
  → vivify      (left-semantic keyword extraction, autovivified storage)
  → right_pass  (quote-grounded facts + claimed-vs-actual discrepancies)
  → logos + conflict operators (the 11-coordinate lens, via tag_store)
  → categorize  (emergent category assignment from co-occurrence graph)
  → tension_score (predicted / confirmed / calibration_delta)
  → cross_scale (store-level signature isomorphism across social scales)
  → reify       (inverse pass: stored inference → reconstructed prose)

Vivify Rules

• No external taxonomies — all categories emerge from local keyword patterns
• No domain assumptions — system accepts any scenario as raw text
• Keywords from felt meaning — concept-level tokens, not surface words
• Graph-based emergence — category seeds are high-degree, high-weight keywords
• Multi-assignment — inferences may belong to multiple category paths
• Iterative refinement — new inferences can create new seeds, split or merge old categories

3. The Network: Local-First, Private by Architecture

The phone in your pocket is a server. That is the entire premise.

• An Android phone running Termux hosts a hardened Flask application — professional-grade, auto-starting, persistent — with no cloud dependency of any kind
• SSH is the only transport: all data moves through encrypted tunnels, filesystems mount via SSHFS, nothing travels in plaintext
• The laptop connects to the phone as its IDE — edit on the laptop, execute on the phone, no synchronisation service in the middle
• Privacy is architectural not policy: sensitive material never leaves the local network because the local network is the system
• The star topology extends to mesh — phones discover each other, register, route around failures — the same pattern as 90s P2P networks, rebuilt on SSH

This is not a cloud system with a privacy setting. It is a local system that happens to be connectable.

Current (Star):              Vision (Mesh):

   Edge device                  Phone Phone Phone
      / | \                       \     |      /
     /  |  \                       Edge device
Device Device Phone                /          \
                          Edge device --- Edge device
                             / | \           / | \
                        Phone Phone       Phone Phone

4. What's Built

The pipeline is operational. This is not a roadmap — it is a description of running code.

• vivify.py — left-semantic keyword extraction, autovivified inference storage
• reify.py — inverse pass: stored inference JSON → reconstructed prose; three modes: single, synthesize, voice
• right_pass.py — right keyword extraction and synonym normalization
• categorize.py — emergent category assignment from co-occurrence graph
• logos_fused.py + 8 operator modules — the logos coordinate lens, all eight dimensions in one LLM call
• conflict_operator.py — schema / behavior / terrain / window / escalation phase, read from logos coordinates
• act_position_operator.py — the within|about vantage coordinate, forced into existence by observed conflations
• cross_scale.py — deterministic store-level signature isomorphism across social scales, zero LLM calls
• tag_store.py — resumable batch driver: fail-fast, skip-if-complete, completeness manifest
• tension_score.py — three-number tension: predicted / confirmed / calibration_delta — the evolution gradient
• secrecy.py — client-side PBKDF2/Fernet encryption
• freeze.py — base64 JSON serialization for transit
• server.py — Flask receiver, filesystem-as-database, index update
• config/model_map.json — capability-based model routing; one line to swap models as better ones ship

Repositories

Roadmap

Technology Stack

5. Social Neurology: The Theoretical Framework

Institutions produce identical control behaviors without coordination. This framework explains why.

• Human behavior operates across four layers: neurological substrate (dominance drives, status competition), social/relational (group formation, cohort behavior), ideological (protective framing, legitimizing language), institutional (law, policy, academic curricula)
• Each layer is invisible to the layers above it — unconscious dominance drives do not know they are producing what looks like principled legal argument four layers up
• People who have never met, in different institutions, across different decades, produce convergent outputs because they share formation at layers 1 and 2, not communication at layers 3 or 4
• The mechanism is resonance, not conspiracy — the same pattern René Thom described in catastrophe theory: identical large-scale outcomes from completely different local dynamics
• Healthy institutional populations follow a normal distribution — sustained ideological capture produces rabbit ears: two tail populations grow, the middle loses voice, policy is driven by whichever tail is most organised at the legislative moment
• The tail produces the cleanest signal: text from a highly motivated ideological tail carries layer 1 drives with minimal attenuation — measurable, recoverable, exactly what the Vivify engine is built to detect
• Formal text carries emotional and neurological signal across time and distance — a legislative document encodes the drives that produced it, readable long after the writers have moved on

LAYER 4 — INSTITUTIONAL ENCODING
         Laws, court procedures, HR policy, academic curricula
              ↑
LAYER 3 — IDEOLOGICAL MIDDLE
         Liberation language, protective framing, academic theory
              ↑
LAYER 2 — SOCIAL/RELATIONAL
         Group formation, cohort behavior, lateral alliances
              ↑
LAYER 1 — NEUROLOGICAL SUBSTRATE
         Dominance drives, status competition, control need
         (operates below conscious reasoning)

This is the theoretical foundation the system was built to test. The conflict corpus is the experiment.

The Polarization Signal

Beneficial Outcomes as Functional Art

The target output is better described by what Art does — and why that is not a metaphor.

Art is the technology humans evolved — before writing, before law — for transmitting non-verbal distal signal across time and distance with no shared language or culture. It works because it operates at Layer 1 — below language, below ideology, at the substrate where human experience is held in common.

FLATTENING SYNTHESIS (what LLMs default to):
  Conflict input → pattern completion → smoothed resolution
  Result: the tension is dissolved. Nothing new exists.

ANALOGICAL SYNTHESIS (the target):
  Thesis (felt truth, testimony) supported — never opposed —
  by analytical ground truth
      → something neither side could see from inside the conflict
  Result: a navigational output. Where to step next. Person changed.

Dimensional Fields is, at its deepest level, a machine for reading the art that people make involuntarily when they are in conflict — and returning a navigational output in the same register.

6. The Functional Reference: Every Component, Verified

Everything above this line makes claims. This section grounds them: each entry describes what the code actually does — file by file, formula by formula — verified against the repositories, not remembered or aspired. Validity beyond claims.

The Pipeline, Whole

raw text → vivify (left) → right_pass (right) → logos_fused + conflict + act_position (lens)
        → tension_score (instrument) → categorize / promote / refile (emergent filing)
        → build_index (roll-up + JSON-LD) → cross_scale (store-level links) → reify (back to voice)

Intake — The Two Passes

• vivify.py — one LLM call extracts 8–12 concept-level left keywords plus 3–6 named clumps; anchors on the store's own established vocabulary (keywords already used by ≥2 inferences, capped at 150) so extraction batches converge on shared terms instead of coining synonyms
• right_pass.py — extracts quote-grounded right_facts (every fact must carry a verbatim quote from the source; ungrounded facts are dropped — fail-closed against hallucination) and discrepancies (claimed-vs-actual pairs: un-truth captured as measurable deviation from baseline); normalizes left keywords through the accumulated synonym rulings

The Lens — Eleven Coordinates

Eight logos dimensions, classified in a single LLM call (logos_fused.py), each operator remaining authoritative for its vocabulary; enum values injected from config/coordinates.json, never hand-copied:

• conflict_operator.py — reads the completed logos coordinates, not raw text (Granovetter, Glasl, Durkheim, Bandura): schema none/latent/activated/entangled · behavior none/positioning/suppression/escalating/rationalizing · terrain center/drifting/fringe/fringe_hook · window closed/forming/open/rationalizing · escalation_phase none/early/threshold/exponential
• act_position_operator.py — within (the text is a move inside its events) vs. about (a report standing outside them); judged on the text's own position, never its subject — forced into existence by three observed conflations in field work
• Every operator output is schema-gated by validate_coordinates() against config/coordinates.json with a validate-and-retry loop; persistent failure is recorded per inference, never fatal to a batch

Transport and Privacy

• LLM calls run through a local claude -p subprocess — no API key, no sampling knobs; transport failure (LLMUnavailable) aborts a batch with exit 3 rather than burning doomed calls or recording quota walls as content errors
• PRIVACY_GATE is a fail-closed tristate: sensitive data may leave the machine only when the gate is explicitly off — on, unset, and unrecognized values all block; local backends are exempt; every operator tags its calls sensitive by default

The Tension Instrument

predicted = RESONANCE_BASE(harmony .05 | friction .5 | illusion 1.0) × confidence,
            blended 0.8 / 0.2 with the conflict-alarm fraction × confidence
confirmed = Σ per discrepancy: 1 + |log10(claimed / actual)|  (numeric)
                               1.0                            (categorical)
            squashed total / (total + 4)  — four solid contradictions read 0.5
calibration_delta = predicted − confirmed   ← the operator-evolution gradient

• confirmed is computed only for sources listed in config/baseline_sources.json (currently DNA exonerations) — a researched correction is a citation, not a baseline; missing config means nothing confirms
• Observed on the field cases: Washington .892 / .500 / +.392 · Sutton .828 / .695 / +.133 — the positive delta is the measured mass of felt harm no claimed-vs-actual test catches; one fabricated statistic (1-in-694,000 vs. 1-in-16) contributes magnitude 5.6 alone
• Store-wide: 0.03–0.90, with technical content correctly reading harmony at the low tail — a dial that can read low is what makes high readings mean something

Emergent Filing

• categorize.py — category seeds are high-degree left keywords only (right keywords support, never seed); tree depth ≤ 3; all structure from the store's own co-occurrence graph
• promote.py / refile.py — categorized inferences move from unclustered/ (the honest holding pen) into their category directory; refiling moves sibling files with the inference and refuses to run at a multi-domain root
• converge.py — near-duplicate keywords flagged deterministically (token Jaccard ≥ 0.5), grouped semantically by LLM, applied only from a human-reviewed mapping — the LLM proposes, the human rules, machinery applies; approved rulings feed config/synonyms.json permanently

Store-Level Operators

• tag_store.py — resumable batch driver: skips complete inferences, writes after each sub-step, fail-fasts on transport loss, and writes a completeness manifest so downstream readers know a partial store from a finished one
• cross_scale.py — deterministic, zero LLM calls: six-dimension signatures (conflict schema/behavior/terrain, resonance, cooperative status, tension banded high ≥ .7 / mid ≥ .4), links require differing social scales, strength = Σ −log(df/N) rarity weight; first real run: 18 usable, 68 honestly skipped, 90 links, top link 8.82 across all six dimensions

Reify — The Inverse Pass

• single — one inference back to 3–6 dense first-person sentences; if the reconstruction feels foreign, the keywords drifted — the standing fidelity test
• synthesize — two inferences into one passage that holds both; writes from the tension when they pull apart
• voice — a whole category (or domain) speaks as one passage; the most generative mode, and the source of the JSON-LD dataset descriptions
• --dry-run prints the full prompt without any call — inspectable before a token is spent

Anatomy of a Finished Inference

id, version, timestamp, source            — provenance (source gates confirmed tension)
raw_text                                  — the original, always preserved
left_keywords, clumps                     — the felt meaning (vivify)
right_keywords, right_facts, discrepancies — the counted content (right_pass)
logos{ 8 dims + act_position }            — each {value, rationale, confidence, _operator}
conflict{ schema, behavior, terrain, window, escalation_phase, confidence }
category_paths                            — all emergent addresses (filing uses [0])
tension{ predicted, confirmed, calibration_delta } + legacy tension_score
guardrail_actions                         — what the safe defaults did

Built, Not Yet Exercised

• secrecy.py / freeze.py / server.py — the encrypted payload transport flow, the designed channel for any future off-box intake
• quorum.py / web_research.py — multi-provider transport registry and freshness channel; operational, parked

Nothing in this section is a roadmap item. Every formula, constant, and vocabulary above is running code, checkable in the public repository.