▲
                       ╱ ╲
                      ╱   ╲          [LVL 0: THE SURFACE CROWD — 90% OF HIRES]
                     ╱  if ╲         • if/else, index-based for-loops, basic lists
                    ╱ .get()╲        • Calling pip packages & LLM SDK wrappers
                   ╱  FastAPI╲       • Blindly writing `async def` without knowing why
                  ╱   Basic   ╲      • "Everything is a variable" mental model
~~~~~~~~~~~~~~~~~╱~~~DSA/OOP~~~╲~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                ╱   WATERLINE   ╲   [LVL 1: SHALLOW WATER — INTERMEDIATE DEVS]
               ╱─────────────────╲  • Standard decorators, context managers (`with`)
              ╱  *args / **kwargs ╲ • Basic typing, Pydantic models, standard OOP
             ╱   uv workspaces     ╲• Knowing "GIL makes threads slow" (surface)
            ╱───────────────────────╲
           ╱ [LVL 2: DEEP WATER — LANGUAGE MECHANICS & LAZY PIPELINES]
          ╱  • `__init__.py`, `__all__`, import hooks & module caching (`sys.modules`)
         ╱   • Abstract Syntax Trees (`ast` module), bytecode disassembly (`dis`)
        ╱    • Metaprogramming, `type()` dynamic class creation, `__new__` vs `__init__`
       ╱     • Closures & free variables backed by `PyCellObject` (`__closure__`)
      ╱      • Unlearning eager lists: Streaming O(1) memory generator pipelines
     ╱         verified with `tracemalloc` & `sys.getsizeof` memory benchmarks
    ╱────────────────────────────────────────────────────────────────────────────
   ╱  [LVL 3: THE CPYTHON OBJECT MODEL, DESCRIPTORS & GARBAGE COLLECTION]
  ╱   • Philosophy: Python has NO "variables" — only untyped Names bound to
 ╱      heap-allocated `PyObject`s; name lifecycle != object lifecycle.
╱     • Why Python is heavy: No compile-time C++/Rust `vtable` for attributes.
│       Every object stays in perpetual dynamic-dispatch mode via `__dict__`
│       hash tables unless locked down via C-level member descriptors (`__slots__`).
│     • The Exact Attribute Lookup Engine (`object.__getattribute__` Order):
│       ┌──────────────────────────────────────────────────────────────────┐
│       │ 1. Search `type(obj).__mro__` for a DATA Descriptor              │
│       │    (defines BOTH `__get__` and `__set__` / `__delete__`)         │
│       │ 2. Check `obj.__dict__` (Instance namespace hash table)          │
│       │ 3. Fallback to `type(obj).__mro__` NON-DATA Descriptor           │
│       │    (Functions, `@staticmethod`, `@classmethod`, binding `self`)  │
│       └──────────────────────────────────────────────────────────────────┘
│     • How `__slots__` Saves Gigabytes of RAM in Production:
│       └── Replaces the per-instance dynamic `__dict__` (and `__weakref__`)
│           with fixed C-struct offsets (`PyMemberDef` / `tp_getset` descriptors)
│           stored directly on the `PyTypeObject`.
│     • Raw C-Struct Header Overhead & Cyclic Garbage Collection (`gc`):
│       ┌──────────────────────────────────────────────────────────────────┐
│       │ [PyGC_Head: 16B] (Only on container objects tracked for cycles)  │
│       │ struct _object (PyObject)                                        │
│       │ ├── ob_refcnt (Py_ssize_t: 8B) ◄── Mutated on every reference    │
│       │ └── ob_type   (PyTypeObject*: 8B) ◄── Type slots (`tp_descr_*`)  │
│       └──────────────────────────────────────────────────────────────────┘
│       └── Why the GIL exists: Concurrent threads mutating `ob_refcnt` and
│           resizing `__dict__` without the GIL cause immediate C-heap races.
│       └── Why `ob_refcnt` isn't enough: Reference cycles (`A <-> B`) never hit
│           zero! CPython uses a 3-Generation (`Gen 0/1/2`) doubly-linked list
│           Cyclic GC to detect unreachable islands—or we break cycles upfront
│           using zero-refcount `weakref` pointers.
├────────────────────────────────────────────────────────────────────────────────
│  [LVL 4: THE ASYNCIO EVOLUTION — FROM ITERATORS TO COROUTINE STATE MACHINES]
│  • Async didn't appear by magic; it is built on the Generator Protocol stack:
│    1. Iterator Protocol (`__iter__` / `__next__`)
│       └── Raises `StopIteration(value)` — the ONLY exception in Python that
│           carries a return value payload inside the exception instance itself!
│    2. Generator Protocol (`PyGenObject`)
│       └── Bidirectional channels: `.send(val)`, `.throw(exc)`, `.close()`
│    3. Subgenerator Delegation (`yield from`)
│       └── Automatically forwards `.send()`/`.throw()` down a chain of
│           subgenerators and catches `StopIteration.value` as an expression.
│    4. Native Coroutines (`PyCoroObject` / `async` & `await`)
│       └── Event loop traps suspended `PyFrameObject` chains at `YIELD_VALUE`
│           and resumes execution when epoll/kqueue readiness fires.
├────────────────────────────────────────────────────────────────────────────────
│  [LVL 5: THE ABYSS — CEVAL.C, PYFRAME LINKED LISTS & STACK UNWINDING] (MY ZONE)
│  • Why Python cannot use a contiguous C CPU stack for Python functions:
│    └── Dynamic typing + generators require frames to outlive their caller.
│  • `PyThreadState` (`tstate`) & `_PyEval_EvalFrameDefault` (The C Eval Loop):
│    ┌─────────────────┐      ┌─────────────────────┐      ┌────────────────────┐
│    │ PyThreadState   │      │ PyFrameObject (Cur) │      │ PyFrameObject(Prev)│
│    │ ├── cframe      │─────►│ ├── f_back          │─────►│ ├── f_back ──► NULL│
│    │ ├── current_exc │      │ ├── f_code (PyCode) │      │ ├── f_valuestack   │
│    │ └── interp      │      │ ├── f_lasti (Instr) │      │ └── Block / Exc    │
│    └─────────────────┘      └─────────────────────┘      └────────────────────┘
│  • Intra-Frame Bytecode Jumps & The Block Stack (`PyTryBlock` / Exc Table):
│    └── `try/except/finally` & loops don't create new function frames; handles
│        push onto an internal block stack that jumps bytecode offsets (`f_lasti`)
│        inside the SAME `PyFrameObject` while cleaning the evaluation value stack.
│  • Physical Stack Unwinding & Exception Chaining:
│    └── When an unhandled exception escapes a frame, `ceval.c` physically pops
│        the `PyFrameObject` linked list (`f_back`), attaches each unwound frame
│        into a linked `PyTracebackObject` (`tb_next`, `tb_frame`, `tb_lasti`),
│        and links causal chains via `__cause__` (`raise ... from ...`) and
│        `__context__` (implicit exception during handler execution).
└────────────────────────────────────────────────────────────────────────────────

                        ▲
                       ╱ ╲
                      ╱   ╲          [LVL 0: THE SURFACE CROWD — 90% OF HIRES]
                     ╱ let ╲         • Writing `let mut`, `Vec`, `String`, `match`
                    ╱.clone()╲       • Slapping `.clone()` & `.unwrap()` everywhere
                   ╱#[derive] ╲      • Copy-pasting `#[tokio::main]` without knowing
                  ╱   Basic    ╲       what a Future or Reactor actually compiles to
~~~~~~~~~~~~~~~~~╱~~Syntax/CLI~~╲~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                ╱   WATERLINE    ╲  [LVL 1: SHALLOW WATER — INTERMEDIATE DEVS]
               ╱──────────────────╲ • Basic borrowing (`&T` vs `&mut T`), slices
              ╱  Option / Result   ╲• Trait implementations, generics, Cargo crates
             ╱   Collections / Iter ╲• Using channels & `Arc<Mutex<T>>` by habit
            ╱────────────────────────╲
           ╱ [LVL 2: DEEP WATER — OWNERSHIP, COMBINATORS, COW & DISPATCH]
          ╱  • Explicit lifetime annotations (`'a`, `'b`, `'static`), variance
         ╱   • Functional error architectures: `Option::take()` in-place extraction,
        ╱      combinators (`map`, `and_then`, `unwrap_or_else`), custom error
       ╱       chains (`std::error::Error`, `source()`, `Box<dyn Error>`)
      ╱      • Smart Pointers & Interior Mutability: `Box<T>`, `Rc<T>`, `Weak<T>`
     ╱         (breaking reference cycles), `Cell<T>`, `RefCell<T>`, `UnsafeCell<T>`
    ╱        • Copy-on-Write (`Cow<'a, B>`): Zero-allocation reads (`Cow::Borrowed`)
   ╱           that only allocate & clone onto the heap (`Cow::Owned`) if mutated!
  ╱          • Static Dispatch (Monomorphization — zero vtable) vs. Dynamic
 ╱             Dispatch (`&dyn Trait` Fat Pointers: `[data_ptr | vtable_ptr]`)
╱────────────────────────────────────────────────────────────────────────────────
│  [LVL 3: COMPILER MEMORY LAYOUT, NICHE OPTIMIZATIONS & LLVM PROFILES]
│  • Why Rust structs don't match C struct order by default (`repr(Rust)`):
│    `rustc` automatically shuffles struct fields and enum variants in memory
│    to eliminate alignment padding bytes and shrink CPU cache footprint:
│    ┌────────────────────────────────────────────────────────────────────┐
│    │ Declared: struct Bad { a: u8, b: u64, c: u8 } (C layout: 24 bytes) │
│    │ Compiled: Reordered by rustc ──► [b: u64 | a: u8 | c: u8 + 6 pad]  │
│    │           Shrinks total struct footprint from 24 bytes to 16 bytes │
│    └────────────────────────────────────────────────────────────────────┘
│  • Niche Value Optimization (Zero-Overhead Enums):
│    └── `size_of::<Option<&T>>()` == `size_of::<&T>()` (8 bytes, NOT 16!).
│        `rustc` uses the invalid `0x0` null bit-pattern as the `None` tag.
│  • Cargo & LLVM Surgical Compilation Tuning (`Cargo.toml` Profiles):
│    └── Compiling third-party dependencies with `-O3` LLVM vectorization while
│        keeping local incremental builds instant:
│        `[profile.dev.package."*"] opt-level = 3`
│    └── Production binary hardening via `lto = "fat"` (cross-crate LLVM
│        inlining), `codegen-units = 1`, and `panic = "abort"`.
│  • Low-Level OS & Filesystem Interaction:
│    └── Buffered descriptor I/O, zero-copy slice parsing, OS process/signal
│        handling, and thread-safe `Mutex` poisoning recovery (`into_inner()`).
├────────────────────────────────────────────────────────────────────────────────
│  [LVL 4: MANUAL ASYNC STATE MACHINES, PINNING & SELF-REFERENTIAL ENUMS]
│  • Rust has NO built-in green-thread runtime. Every `async fn` is compiled
│    into a zero-allocation `enum` state machine where each `.await` point is a
│    distinct enum variant storing only the live variables across that yield:
│    ┌────────────────────────────────────────────────────────────────────────┐
│    │ enum GeneratedFuture {                                                 │
│    │     State0_Unpolled { arg: Socket },                                   │
│    │     State1_WaitingOnRead { buf: [u8; 64], buf_ref: *const u8 }, ◄─┐    │
│    │     State2_Done,                                                  │    │
│    │ } // Self-referential pointer inside State1! ─────────────────────┘    │
│    └────────────────────────────────────────────────────────────────────────┘
│  • Why `Pin<&mut Self>` & `!Unpin` Are Mandatory for Manual Async:
│    └── Across an `.await` suspension point, an async state machine holds a
│        pointer to its own internal field (`buf_ref -> buf`). If the caller
│        moves that `enum` in memory (`mem::swap`), `buf_ref` dangles (Segfault)!
│    └── `Pin<&mut Self>` locks the state machine's memory address in place
│        before `match` polling transitions:
│        `fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Output>`
├────────────────────────────────────────────────────────────────────────────────
│  [LVL 5: THE ABYSS — PYO3 INTERNALS (`PyCell`, `Bound`), GIL & SLINT] (MY ZONE)
│  • How PyO3 Bridges Rust Structs (`#[pyclass]`) into CPython Without UB:
│    ┌────────────────────────────────────────────────────────────────────────┐
│    │ Heap Allocation of a `#[pyclass]` Object Inside CPython (`PyCell<T>`)  │
│    │ ┌─────────────────────────┬──────────────────────┬───────────────────┐ │
│    │ │ PyObject Header (16B)   │ PyCell Borrow Flag   │ Native Rust Struct│ │
│    │ │ (ob_refcnt + ob_type)   │ (isize: 0 / +N / -1) │ (Your Rust Fields)│ │
│    │ └─────────────────────────┴──────────────────────┴───────────────────┘ │
│    └────────────────────────────────────────────────────────────────────────┘
│    └── Crossing the Binary Wall: `#[pyclass]` & `#[pymethods]` populate static C
│        staging slots (`tp_methods`, `tp_getset`, `tp_new`) on `PyTypeObject`.
│        At import, `PyType_Ready()` injects C-ABI trampoline descriptors into
│        `Class.__dict__` that jump the +16B `PyObject` header wall in O(1) time.
│    └── Why `PyCell` Exists: Python allows unlimited aliases to the same object,
│        but Rust requires exclusive `&mut T` access. `PyCell` enforces Rust's
│        borrow checker at RUNTIME—preventing `&mut self` re-entrancy deadlocks.
│  • Pointer Hierarchy Across the FFI Boundary:
│    ├── `Bound<'py, T>`: GIL-attached smart pointer (`'py` lifetime proves the
│    │                    thread holds the GIL; zero-cost C-API dispatch).
│    └── `Py<T>`: GIL-independent reference stored inside Rust structs/threads;
│                 must call `.bind(py)` with a `Python<'py>` token to read/mutate.
└────────────────────────────────────────────────────────────────────────────────

[LATE 2024] ──► Engineered Custom Dynamic MCP Client & Universal Protocol Wrapper
  │             • Built before mainstream agent frameworks had plug-and-play MCP support.
  │             • Handled multi-transport (stdio, HTTP/SSE, HTTPS), JSON-RPC handshakes,
  │               and recursive URI resource resolution (`contents` unwrapping).
  ▼
[SEPT 2025] ──► Integrated Autonomous Browser Agent (`browser-use`) with OS Process Isolation
  │             • Adopted a full year before browser-using agents became standard.
  │             • Evolved from prototype into a custom metaclass/driver & `bubus` event
  │               lifecycle engine with dedicated subprocess `stdout` isolation and
  │               custom persistent `keep_alive` state recovery.
  ▼
[OCT 2026]  ──► Phase 1 Monorepo Decoupling (`uv` Workspace) & Stateless Turnkey Engine
  │             • Purged ~6,800 lines of legacy coupled code; enforced strict Layering
  │               Invariant (`Desktop/GUI ──► Core`; Core NEVER imports platforms).
  │             • Architected `ContextRegistry` & `ColdWindEngine.process_ticket()`.
  ▼
[NOV 2026]  ──► Native Rust + Slint 1.16 + PyO3 0.26 Desktop Engine (`ai-workflow-gui`)
                • Dual-thread MPSC actor bridge separating Thread 0 (60 FPS Slint UI)
                  from Thread N (CPython GIL worker) with per-package `-O3` LLVM tuning.

┌────────────────────────────────────────────────────────────────────────────────────────┐
│                        COLD WIND CORE: TURNKEY EXECUTION PIPELINE                        │
└────────────────────────────────────────────────────────────────────────────────────────┘
 [Platform: CLI / Slint GUI]
       │
       ├──► 1. Fast-Path Slash Command (`/clear`, `/exit`) ──► Handled Locally (0 Tokens!)
       │
       └──► 2. Submits `TicketIn(user_message, working_state)`
                     │
                     ▼
         ┌──────────────────────────────────────────────────────────────────────┐
         │ ColdWindEngine.process_ticket() (Stateless Turnkey Facade)           │
         ├──────────────────────────────────────────────────────────────────────┤
         │ • Validates message schemas & syncs `StateAccessor` with LangGraph   │
         │ • Routes via `classify_agent` (Local Classifier / Planned Javelin)   │
         └───────────┬──────────────────────────┬───────────────────────────────┘
                     │                          │
         ┌───────────▼───────────┐  ┌───────────▼───────────────────────────────┐
         │ Direct Tool / Slash   │  │ Hierarchical Agent Orchestrator (`/agent`)│
         │ • Universal MCP Client│  │ • Node-specific model & agent binding     │
         │ • Isolated Browser    │  │ • Full pass/fail argument & reasoning logs│
         └───────────┬───────────┘  └───────────┬───────────────────────────────┘
                     └──────────────┬───────────┘
                                    ▼
         ┌──────────────────────────────────────────────────────────────────────┐
         │ Returns `TicketOut(status, new_working_state, transcript, usage)`    │
         │ + Streams Typed `LogEntry` Telemetry to Rotating Category Files      │
         └──────────────────────────────────────────────────────────────────────┘

Thread 0 (Main OS Thread — Slint 60/144 FPS UI)       Thread N (Background Rust Worker + CPython GIL)
┌─────────────────────────────────────────────┐       ┌─────────────────────────────────────────────┐
│ • Renders GPU-accelerated `.slint` views    │       │ • Holds `ColdWindEngine` & `SlintGuiContext`│
│ • Holds `!Send` `Rc` models (`VecModel`)    │       │ • Acquires `Python::with_gil(|py| ...)`     │
│ • User clicks Send ──► `tx.try_send(Ticket)`├──────►│ • Calls `engine.process_ticket(TicketIn)`   │
│   (Takes 0.001ms — UI NEVER freezes!)       │ MPSC  │ • Streams `LogEntry` via `#[pyclass]` sink  │
│                                             │◄──────┤ • Dispatches UI mutation via `ui_weak` +    │
│ • Updates collapsible Thinking Accordion    │ Weak  │   `slint::invoke_from_event_loop(...)`      │
└─────────────────────────────────────────────┘       └─────────────────────────────────────────────┘