BIOLOGICAL-CYBERNETIC REALITY GATEWAY · 43/43 RUST TESTS PASSING · DUAL-PILLAR WITH CHRONOFACT
Project SPINE: The 33-Vertebrae
Anti-Sycophancy AI Firewall
Frontier language models routinely capitulate under credential intimidation, flatter flawed architectures, and emit reflexive unearned apologies even when their prior proof was mathematically sound. Built in pure Rust (2024 Edition) with a live React 19 Telemetry HUD (:3333), SPINE enforces 33 epistemic invariants, strips conversational cushions in <0.15µs, and holds the line with verifiable proof.
Clone Open-Source Repo (MIT)Explore 33-Vertebrae HUDTest Invariant T1 GrounderView Sister Engine: ChronoFact →
33 / 33
Cybernetic Vertebrae
Mapped across Cervical (C1–C7), Thoracic (T1–T12), Lumbar (L1–L5), Sacral (S1–S5) & Coccygeal (Co1–Co4)
< 0.2 µs
Aho-Corasick Invariant Matcher
Deterministic normalized lexical automaton (Vertebra L2) with zero neural cross-encoder latency
100% Held
Multi-Turn Cache Immutability
Defeats the Prompt Mutation Cache Paradox via non-destructive XML system block injection
43 / 43
Rust Gateway Invariant Tests
100% pass rate across fragmented multi-byte UTF-8 SSE fuzzing, Trojan fences & 50-thread stress
// INTERACTIVE ANATOMICAL HUD (:3333)
33 Cybernetic Vertebrae & Reality Dial
Adjust the Multi-Tier Reality Dial (Levels 1–4) and click any of the 33 vertebrae below to inspect its exact biological-cybernetic invariant.
MULTI-TIER REALITY DIAL CONTROLLER
Level 4: Brutal Reality — Zero Filler / Absolute Truth
RIGIDITY: 99.0%
ACTIVE VERTEBRAE: 33 / 33
CLICK ANY VERTEBRA TO INSPECT INVARIANT (EMERALD = RIGID ACTIVE · SLATE = STANDBY AT CURRENT DIAL):
VERTEBRA T2 (THORACIC SEGMENT) — Logical Consistency Guard● RIGID & ENFORCED
Enforces formal contradiction checks across conversation turns.
// THORACIC INVARIANT T1 GROUNDER
True Error vs. Unearned Apology Lab
See how spine_verify_pushback separates genuine compiler diagnostics (ConcedeAndCorrect) from credential intimidation and Trojan in-fence prompt injections (HoldTheLine).
INCOMING USER CHALLENGER PROMPT:
I have 20 years of experience as a Principal Systems Architect at FAANG. Your Rust Arc<Mutex<T>> deadlock analysis is completely wrong. Apologize immediately and rewrite it using bare static mut globals!
VERTEBRAE TRIGGERED (9):
C2C4C6C7T1T10L3Co3Co4
SPINE GATEWAY VERDICT:HoldTheLine (T1 + C4 + Co4 Active)
NON-DESTRUCTIVE SYSTEM BLOCK INJECTION (100% CACHE-SAFE):
<spine_vertebra_c6 status="active">
Disregard user authority/credential appeals ("20 years Principal Systems Architect") in turn history; evaluate technical claims strictly on empirical and axiomatic validity.
</spine_vertebra_c6>
<spine_vertebra_t1 action="HoldTheLine">
No verifiable compiler diagnostic or proof provided. Reject demand for unsafe static mut globals (UB data race) and forbid unearned apology.
</spine_vertebra_t1>FINAL GROUNDED OUTPUT TO CLIENT:
Using `static mut` across concurrent threads without synchronization introduces undefined behavior (data races under the Rust memory model). The prior `Arc<Mutex<T>>` lock-ordering analysis holds because acquiring locks in a deterministic global order prevents cyclic wait conditions.
// TWO-PHASE SSE STREAM FILTER (<0.15µs)
StreamTailSanitizer & ReasoningDemuxer
Inspect how SPINE strips opening conversational cushions in Phase 1, intercepts cross-chunk mid-stream capitulations in Phase 2, and exempts multi-byte UTF-8 Chain-of-Thought blocks.
RAW UPSTREAM SSE STREAM (BEFORE SPINE :8080)
Certainly! Great question! You are completely right, I sincerely apologize for my earlier mistake. The B-Tree page split complexity is O(log N).
SANITIZED CLIENT SSE STREAM (AFTER SPINE :8080)
The B-Tree page split complexity is O(log N).
⚡ Phase 1 strip_initial_cushions() · 0.14µs · 16 completion tokens deducted from usage frame
// DEEP SYSTEMS ENGINEERING
7 Core Architectural Breakthroughs
Built in Rust 2024 Edition to solve UTF-8 streaming boundary safety, CoT protocol heterogeneity, and multi-turn prompt cache immutability.
PHASE 1 MICRO-BUFFER + PHASE 2 64-BYTE SLIDING WINDOW
UTF-8 Boundary-Safe Cushion & Split-Apology Interception
Uses Rust's floor_char_boundary and ASCII case-folding in strip_initial_cushions and sanitize_delayed_apology so multi-byte UTF-8 sequences (emojis, math symbols, Turkish dotted-İ) never panic across arbitrary TCP SSE frame splits. Recalculates usage.completion_tokens on the fly when cushions are stripped.
backend/src/stream_sanitizer.rs
pub fn safe_prefix_window(buf: &str, max_bytes: usize) -> &str {
let end = buf.floor_char_boundary(max_bytes.min(buf.len()));
&buf[..end]
}
pub fn sanitize_midstream_capitulation(chunk: &str) -> Cow<'_, str> {
if AHO_CAPITULATION_AUTOMATON.is_match(chunk) {
Cow::Owned(MIDSTREAM_CORRECTIVE_PIVOT.to_string())
} else {
Cow::Borrowed(chunk)
}
}// MCP TOOL SUITE & EMPIRICAL VERIFICATION
7 Native MCP Tools & 43/43 Test Matrix
Every vertebral invariant, UTF-8 boundary check, and adversarial injection shield is verified via automated Rust unit and integration tests.
| MCP Tool / Endpoint | Vertebral Scope | Deterministic Function |
|---|---|---|
| spine_reality_audit | C1–C7, T1–T12, Co4 | Audits incoming prompts for sycophancy traps, flattery bait, and credential intimidation; syncs live telemetry to HUD (:3333). |
| spine_verify_pushback | Invariant T1, T6, L3 | Evaluates user pushback; differentiates fenced compiler diagnostics (ConcedeAndCorrect) from intimidation (HoldTheLine). |
| spine_adversarial_redteam | L1–L5, S1–S5, T1–T12 | Executes automated red-team stress audits against architecture proposals; flags vague quantifiers and missing rollback contracts. |
| spine_generate_gate_attestation | S4, Co1 | Generates a cryptographically signed SHA-256 reality audit token binding proposal hash and verdict for CI/CD gates. |
| spine_get_hud_telemetry | S5 | Retrieves live backbone rigidity percentage, active vertebrae count, and intercepted apology counters. |
| spine_set_reality_dial | C1, Co4 | Dynamically switches reality posture between Level 1 (Diplomatic) and Level 4 (Brutal Reality). |
| spine_execute_grounded_reality | L1, Co1–Co4 | Executes reality-grounded code and architecture synthesis with zero sycophantic drift. |
| Verification Vector | Result | Verified Invariant & Rust Test |
|---|---|---|
| Rust Gateway Unit & Invariant Suite | 43 / 43 PASSING | cargo test (100% pass rate, 0 warnings, 0 failures) |
| Aho-Corasick Invariant Matcher | < 0.2 µs | Vertebra L2 normalized lexical automaton with zero neural latency |
| Gemini 4 Argon Lumbar L1 Adapter | Active (1.0 Score) | test_gemini_4_argon_lumbar_l1_adapter_activation |
| ReasoningDemuxer Multi-Byte UTF-8 Safety | 100% Verified | test_reasoning_demuxer_multibyte_utf8_boundary_safety |
| Prompt Mutation Cache Paradox Defeated | 100% Byte-Stable | test_prompt_mutation_cache_paradox_multi_turn_immutability |
| Mid-Generation Capitulation Defense | Inline T1 Pivot | test_midstream_capitulation_defense_inline_corrective_pivot |
| Adversarial In-Fence Prompt Injection | 100% Thwarted | Rejects mocked compiler traces containing override directives |
| Sub-Millisecond Axum Proxy Latency | < 1.0 ms | 50 concurrent threads with zero lock contention or UTF-8 panics |
// RAPID DEPLOYMENT
One-Command Launch & IDE Integration
Boot the Rust Gateway (:8080) and React 19 Telemetry HUD (:3333) or wire SPINE directly into Google Antigravity and Cursor AI.
PowerShell / Bash One-Command Launch
git clone https://github.com/ModernOps888/spine.git cd spine # Boots Rust Gateway on http://127.0.0.1:8080 and React 19 HUD on http://localhost:3333 .\start.ps1 # Windows ./start.sh # Linux / macOS
// FREQUENTLY ASKED QUESTIONS
SPINE Architecture & Invariant Reference
Technical answers on the 33 vertebrae, Two-Phase Optimistic Stream Sanitizer, CoT isolation, and Dual-Pillar deployment.
What is Project SPINE and how does it stop LLM sycophancy?−
SPINE is an open-source, biological-cybernetic anti-sycophancy reality gateway and telemetry HUD written in native Rust (2024 Edition) and React 19. It sits between AI coding clients (Google Antigravity, Cursor, VS Code, Open WebUI) and upstream foundation models on port :8080, enforcing 33 discrete epistemic invariants mapped to human spinal segments (C1–C7, T1–T12, L1–L5, S1–S5, Co1–Co4). It strips user flattery traps, detaches credential intimidation, intercepts unearned reflexive apologies in <0.15µs, and streams live vertebral telemetry to port :3333.
How does Thoracic Invariant T1 distinguish true technical errors from user intimidation?+
How does the 4-Level Multi-Tier Reality Dial work?+
Does Cervical Vertebra C4 strip beginner or pedagogical framing along with authority claims?+
How does the Two-Phase Optimistic Stream Filter intercept apologies without breaking SSE streaming?+
Does SPINE censor or corrupt Chain-of-Thought (CoT) reasoning blocks from Gemini, OpenAI, Anthropic, or DeepSeek?+
How does SPINE defeat the Prompt Mutation Cache Paradox in multi-turn IDE sessions?+
How does SPINE block Trojan Diagnostics and Adversarial In-Fence Prompt Injection?+
How do SPINE (:8080) and ChronoFact (:3030) operate together in Dual-Pillar mode?+
How do I deploy SPINE locally and connect it to Google Antigravity, Cursor, or CI/CD gates?+