УНИВЕРСАЛЬНАЯ СХЕМА СИСТЕМЫ

СИСТЕМА = ЭЛЕМЕНТЫ + СТРУКТУРА + ПОВЕДЕНИЕ + КОНТЕКСТ

PHYSICAL_OBJECT {
  type: ENUM {
    ATOM,           // Неделимый элемент
    COMPOSITE,      // Составной объект
    CONTAINER       // Контейнер для других объектов
  }

  properties: {
    location: PATH,
    size: NUMBER,
    created_at: TIMESTAMP,
    modified_at: TIMESTAMP,
    owner: IDENTITY,
    permissions: PERMISSIONS
  }

  subtypes: {
    FILE,           // Файл на диске
    DIRECTORY,      // Директория
    DATABASE,       // База данных
    TABLE,          // Таблица в БД
    RECORD,         // Запись в таблице
    BINARY,         // Исполняемый файл
    RESOURCE        // Внешний ресурс (URL, API)
  }
}

VIRTUAL_OBJECT {
  type: ENUM {
    PROCESS,        // Запущенный процесс
    SESSION,        // Сессия
    TRANSACTION,    // Транзакция
    EVENT,          // Событие
    MESSAGE,        // Сообщение
    STREAM          // Поток данных
  }

  properties: {
    state: STATE,
    lifetime: DURATION,
    owner: IDENTITY,
    resources_used: [PHYSICAL_OBJECT]
  }
}

ABSTRACT_OBJECT {
  type: ENUM {
    CONCEPT,        // Концепция, идея
    SCHEMA,         // Схема, шаблон
    RULE,           // Правило
    CONSTRAINT,     // Ограничение
    ALGORITHM,      // Алгоритм
    PATTERN         // Паттерн
  }

  properties: {
    definition: TEXT,
    formalization: SCHEMA,
    examples: [INSTANCE]
  }
}

HIERARCHY {
  levels: [
    L0: ROOT,           // Корень всего
    L1: DOMAIN,         // Предметная область
    L2: SUBDOMAIN,      // Подобласть
    L3: COMPONENT,      // Компонент
    L4: ELEMENT,        // Элемент
    L5: SUBELEMENT,     // Подэлемент
    ...                 // Рекурсивно вглубь
  ]

  relation: CONTAINS    // Каждый уровень содержит следующий
}

SYSTEM_TYPE {
  classification: ENUM {
    TARGET {            // Целевая система
      questions: 9,
      focus: "Решение проблемы",
      has: [PROBLEM, SOLUTION, STAKEHOLDERS, METRICS]
    },

    SUPPORTING {        // Обеспечивающая система
      questions: 7,
      focus: "Поддержка других систем",
      has: [SERVICES, CLIENTS, SLA, CAPACITY]
    },

    INFORMATIONAL {     // Информационная система
      questions: 5,
      focus: "Хранение и передача знаний",
      has: [CONTENT, FORMAT, STRUCTURE, STORAGE]
    },

    PROCESS {           // Процесс
      questions: 8,
      focus: "Преобразование входа в выход",
      has: [INPUT, OUTPUT, STEPS, ACTORS, RESOURCES]
    },

    STRUCTURAL {        // Структура
      questions: 4,
      focus: "Описание устройства",
      has: [COMPONENTS, RELATIONS, PROPERTIES]
    },

    AGENT {             // Агент
      questions: 6,
      focus: "Автономное поведение",
      has: [GOAL, ACTIONS, ENVIRONMENT, SENSORS, ACTUATORS]
    }
  }
}

MODULE {
  interface: {
    inputs: [PORT],     // Точки входа
    outputs: [PORT],    // Точки выхода
    params: [PARAM],    // Параметры
    state: STATE        // Внутреннее состояние
  },

  implementation: {
    internals: [ELEMENT],   // Внутренние элементы
    logic: ALGORITHM,       // Логика работы
    data: DATA              // Внутренние данные
  },

  contracts: {
    requires: [DEPENDENCY],     // Что требует
    provides: [SERVICE],        // Что предоставляет
    guarantees: [CONSTRAINT]    // Что гарантирует
  }
}

ROLE {
  type: ENUM {
    PRODUCER,       // Создаёт что-то
    CONSUMER,       // Потребляет что-то
    TRANSFORMER,    // Преобразует
    ROUTER,         // Маршрутизирует
    COORDINATOR,    // Координирует
    VALIDATOR,      // Проверяет
    MONITOR,        // Наблюдает
    CONTROLLER,     // Управляет
    STORAGE,        // Хранит
    INTERFACE,      // Предоставляет интерфейс
    GATEWAY,        // Шлюз между системами
    ADAPTER         // Адаптирует интерфейсы
  }
}

LIFECYCLE {
  states: [
    CONCEPTION,     // Замысел
    DESIGN,         // Проектирование
    DEVELOPMENT,    // Разработка
    TESTING,        // Тестирование
    DEPLOYMENT,     // Развёртывание
    OPERATION,      // Эксплуатация
    MAINTENANCE,    // Поддержка
    EVOLUTION,      // Развитие
    DEPRECATION,    // Устаревание
    RETIREMENT,     // Вывод из эксплуатации
    ARCHIVAL        // Архивирование
  ],

  transitions: [
    (CONCEPTION → DESIGN),
    (DESIGN → DEVELOPMENT),
    (DEVELOPMENT → TESTING),
    (TESTING → DEPLOYMENT | DEVELOPMENT),  // Возврат при ошибках
    (DEPLOYMENT → OPERATION),
    (OPERATION → MAINTENANCE | EVOLUTION),
    (MAINTENANCE → OPERATION),
    (EVOLUTION → DEVELOPMENT),
    (OPERATION → DEPRECATION),
    (DEPRECATION → RETIREMENT),
    (RETIREMENT → ARCHIVAL)
  ]
}

PROCESS {
  definition: {
    name: STRING,
    purpose: STRING,
    trigger: TRIGGER,       // Что запускает
    preconditions: [CONDITION],
    postconditions: [CONDITION]
  },

  execution: {
    steps: [STEP],          // Последовательность шагов
    actors: [ACTOR],        // Кто выполняет
    resources: [RESOURCE],  // Что требуется
    duration: DURATION,     // Сколько времени
    cost: COST              // Стоимость
  },

  monitoring: {
    metrics: [METRIC],      // Метрики
    kpi: [KPI],             // Ключевые показатели
    sla: [SLA]              // Service Level Agreement
  }
}

STRUCTURAL_RELATION {
  type: ENUM {
    CONTAINS {              // A содержит B
      symbol: "⊃",
      inverse: BELONGS_TO,
      properties: {
        cardinality: "1:N",
        cascading_delete: BOOLEAN
      }
    },

    BELONGS_TO {            // A принадлежит B
      symbol: "⊂",
      inverse: CONTAINS,
      properties: {
        cardinality: "N:1",
        mandatory: BOOLEAN
      }
    },

    COMPOSED_OF {           // A состоит из B (композиция)
      symbol: "◆—",
      properties: {
        cardinality: "1:N",
        lifecycle_tied: true
      }
    },

    AGGREGATES {            // A агрегирует B (агрегация)
      symbol: "◇—",
      properties: {
        cardinality: "1:N",
        lifecycle_tied: false
      }
    },

    PART_OF {               // A часть B
      symbol: "—◆",
      inverse: COMPOSED_OF
    }
  }
}

FUNCTIONAL_RELATION {
  type: ENUM {
    DEPENDS_ON {            // A зависит от B
      symbol: "→",
      properties: {
        type: ENUM {COMPILE_TIME, RUNTIME, DATA},
        strength: ENUM {WEAK, STRONG, CRITICAL},
        optional: BOOLEAN
      }
    },

    PROVIDES_TO {           // A предоставляет сервис B
      symbol: "⇒",
      properties: {
        interface: INTERFACE,
        contract: CONTRACT,
        sla: SLA
      }
    },

    USES {                  // A использует B
      symbol: "↔",
      properties: {
        frequency: ENUM {RARE, PERIODIC, CONSTANT},
        volume: NUMBER
      }
    },

    CALLS {                 // A вызывает B
      symbol: "⟶",
      properties: {
        protocol: PROTOCOL,
        sync: BOOLEAN
      }
    },

    TRIGGERS {              // A запускает B
      symbol: "⚡→",
      properties: {
        event: EVENT,
        condition: CONDITION
      }
    },

    INHERITS {              // A наследует от B
      symbol: "⟨—",
      properties: {
        type: ENUM {INTERFACE, IMPLEMENTATION, BOTH}
      }
    },

    IMPLEMENTS {            // A реализует интерфейс B
      symbol: "⊨",
      properties: {
        interface: INTERFACE
      }
    }
  }
}

INFORMATION_RELATION {
  type: ENUM {
    READS {                 // A читает данные из B
      symbol: "R→",
      properties: {
        frequency: FREQUENCY,
        volume: NUMBER,
        consistency: ENUM {STRONG, EVENTUAL, WEAK}
      }
    },

    WRITES {                // A пишет данные в B
      symbol: "W→",
      properties: {
        frequency: FREQUENCY,
        volume: NUMBER,
        transactional: BOOLEAN
      }
    },

    SYNCS {                 // A синхронизируется с B
      symbol: "⇄",
      properties: {
        direction: ENUM {BIDIRECTIONAL, A_TO_B, B_TO_A},
        strategy: ENUM {FULL, INCREMENTAL, DELTA},
        schedule: SCHEDULE
      }
    },

    REFERENCES {            // A ссылается на B
      symbol: "→●",
      properties: {
        type: ENUM {HARD, SOFT, SYMBOLIC},
        integrity: BOOLEAN
      }
    },

    DERIVED_FROM {          // A выводится из B
      symbol: "⟹",
      properties: {
        transformation: FUNCTION,
        cacheable: BOOLEAN
      }
    }
  }
}

TEMPORAL_RELATION {
  type: ENUM {
    BEFORE {                // A происходит до B
      symbol: "⟨",
      properties: {
        min_gap: DURATION,
        max_gap: DURATION
      }
    },

    AFTER {                 // A происходит после B
      symbol: "⟩",
      properties: {
        min_gap: DURATION,
        max_gap: DURATION
      }
    },

    CONCURRENT {            // A и B происходят одновременно
      symbol: "∥",
      properties: {
        synchronization: ENUM {STRICT, LOOSE, NONE}
      }
    },

    SEQUENTIAL {            // A → B → C последовательно
      symbol: "⟶⟶",
      properties: {
        ordered: BOOLEAN,
        skippable: BOOLEAN
      }
    },

    PARALLEL {              // A и B параллельно
      symbol: "⫽",
      properties: {
        join_required: BOOLEAN
      }
    }
  }
}

METADATA {
  identity: {
    id: UUID,
    name: STRING,
    version: SEMVER,
    type: TYPE,
    created: TIMESTAMP,
    modified: TIMESTAMP,
    authors: [IDENTITY]
  },

  classification: {
    domain: DOMAIN,
    category: CATEGORY,
    tags: [TAG],
    keywords: [KEYWORD]
  },

  quality: {
    status: STATUS,
    maturity: ENUM {DRAFT, ALPHA, BETA, RC, STABLE, DEPRECATED},
    confidence: FLOAT[0..1],
    completeness: FLOAT[0..1]
  },

  governance: {
    owner: IDENTITY,
    stakeholders: [IDENTITY],
    reviewers: [IDENTITY],
    approval_required: BOOLEAN
  }
}

DOCUMENTATION {
  descriptive: {
    summary: TEXT,          // Краткое описание
    description: TEXT,      // Полное описание
    rationale: TEXT,        // Обоснование
    examples: [EXAMPLE]     // Примеры
  },

  technical: {
    architecture: DIAGRAM,
    api: API_SPEC,
    database: DB_SCHEMA,
    deployment: DEPLOYMENT_GUIDE
  },

  operational: {
    setup: GUIDE,
    usage: GUIDE,
    troubleshooting: GUIDE,
    faq: [QA]
  },

  governance: {
    decisions: [ADR],       // Architecture Decision Records
    changelog: [CHANGE],
    roadmap: [MILESTONE]
  }
}

METRICS {
  quantitative: {
    size: {
      lines_of_code: NUMBER,
      files_count: NUMBER,
      complexity: NUMBER
    },

    performance: {
      latency_p50: DURATION,
      latency_p95: DURATION,
      latency_p99: DURATION,
      throughput: NUMBER,
      error_rate: FLOAT[0..1]
    },

    reliability: {
      uptime: FLOAT[0..1],
      mtbf: DURATION,         // Mean Time Between Failures
      mttr: DURATION,         // Mean Time To Recovery
      availability: FLOAT[0..1]
    },

    business: {
      users: NUMBER,
      revenue: MONEY,
      cost: MONEY,
      roi: FLOAT
    }
  },

  qualitative: {
    maintainability: RATING,
    testability: RATING,
    usability: RATING,
    security: RATING
  }
}

UNIVERSAL_GRAPH {
  nodes: {
    type: NODE_TYPE {
      PHYSICAL,         // Физический объект
      LOGICAL,          // Логическая сущность
      VIRTUAL,          // Виртуальный объект
      ABSTRACT          // Абстракция
    },

    level: HIERARCHY_LEVEL {
      L0, L1, L2, L3, L4, ...
    },

    role: SYSTEM_TYPE {
      TARGET,           // 9 вопросов
      SUPPORTING,       // 7 вопросов
      INFORMATIONAL,    // 5 вопросов
      PROCESS,          // 8 вопросов
      STRUCTURAL,       // 4 вопроса
      AGENT             // 6 вопросов
    },

    state: LIFECYCLE_STATE,

    properties: MAP<STRING, VALUE>,

    metadata: METADATA
  },

  edges: {
    type: RELATION_TYPE {
      STRUCTURAL,       // Структурные связи
      FUNCTIONAL,       // Функциональные связи
      INFORMATIONAL,    // Информационные связи
      TEMPORAL          // Временные связи
    },

    direction: ENUM {
      UNIDIRECTIONAL,
      BIDIRECTIONAL
    },

    properties: MAP<STRING, VALUE>,

    weight: FLOAT,      // Вес связи

    metadata: METADATA
  }
}

┌─────────────────────────────────────────────────────────────────────┐
│                           UNIVERSE (L-∞)                             │
│                        Метасистема всех систем                       │
└────────────────────────────────┬────────────────────────────────────┘
                                 │ defines
                                 ↓
┌─────────────────────────────────────────────────────────────────────┐
│                         ONTOLOGY (L-1)                               │
│              Типы, Схемы, Правила, Паттерны                          │
└────────────────────────────────┬────────────────────────────────────┘
                                 │ instantiates
                                 ↓
┌─────────────────────────────────────────────────────────────────────┐
│                          ROOT (L0)                                   │
│                   Корень конкретной системы                          │
│                      (WORKSPACE, UNIVERSE)                           │
└───┬─────────────────────────────────────────────────────────────┬───┘
    │ contains (⊃)                                                 │
    ↓                                                              ↓
┌─────────────────────┐                                  ┌──────────────────┐
│   DOMAIN (L1)       │                                  │   CROSS-CUTTING  │
│   Предметная область│◄────────────uses (↔)─────────────┤   (Сквозные)     │
│                     │                                  │                  │
│ Types:              │                                  │ - Безопасность   │
│ • TARGET            │                                  │ - Логирование    │
│ • SUPPORTING        │                                  │ - Мониторинг     │
│ • INFORMATIONAL     │                                  │ - Аудит          │
└──────┬──────────────┘                                  └──────────────────┘
       │ contains (⊃)
       ↓
┌─────────────────────┐
│  SUBDOMAIN (L2)     │
│  Подобласть         │
│                     │
│ Roles:              │
│ • MAIN              │──────provides_to (⇒)──────┐
│ • SATELLITE         │                           │
│ • EXPERIMENT        │                           │
│ • SERVICE           │◄──────depends_on (→)──────┘
└──────┬──────────────┘
       │ contains (⊃)
       ↓
┌─────────────────────┐         ┌──────────────────────┐
│  COMPONENT (L3)     │         │  EXTERNAL SYSTEM     │
│  Модуль/Компонент   │         │  Внешняя система     │
│                     │         │                      │
│ Types:              │◄────────┤ - API                │
│ • APPLICATION       │  calls  │ - Service            │
│ • SERVICE           │  (⟶)   │ - Database           │
│ • LIBRARY           │         │ - Resource           │
│ • AGENT             │         └──────────────────────┘
└──────┬──────────────┘
       │ contains (⊃)
       ↓
┌─────────────────────┐
│   ELEMENT (L4)      │
│   Элемент           │
│                     │
│ Types:              │
│ • MODULE            │──────imports (⊲)──────┐
│ • CLASS             │                        │
│ • FUNCTION          │◄──────inherits (⟨—)───┘
│ • DATA              │
└──────┬──────────────┘
       │ contains (⊃)
       ↓
┌─────────────────────┐
│ SUBELEMENT (L5)     │
│ Подэлемент          │
│                     │
│ Types:              │
│ • METHOD            │
│ • PROPERTY          │
│ • VARIABLE          │
│ • STATEMENT         │
└─────────────────────┘

┌─────────────────────────────────────────────────────────────────────┐
│                          RUNTIME LAYER                               │
│                  (Процессы, выполняемые в реальном времени)          │
│                                                                      │
│  ┌──────────┐    triggers    ┌──────────┐    produces    ┌────────┐│
│  │  EVENT   │───────⚡→──────►│ PROCESS  │────────────────►│ OUTPUT ││
│  └──────────┘                └──────────┘                └────────┘│
│                                    │                                │
│                              consumes                               │
│                                    ↓                                │
│                              ┌──────────┐                           │
│                              │ RESOURCE │                           │
│                              └──────────┘                           │
└─────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────┐
│                           DATA LAYER                                 │
│                      (Данные на всех уровнях)                        │
│                                                                      │
│  CATALOG ──syncs (⇄)──► TRANSACTIONAL ──derives (⟹)──► ANALYTICAL  │
│    ▲                         │                              │       │
│    │                    writes (W→)                    reads (R→)   │
│    └─────────────────────────┴──────────────────────────────┘       │
└─────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────┐
│                        INFORMATION LAYER                             │
│                   (Знания, документация, метаданные)                 │
│                                                                      │
│  ONTOLOGY ───defines──► SCHEMA ───validates──► INSTANCE             │
│      │                     │                        │               │
│      │                     │                        │               │
│  documents (⊙)        describes (⊙)            exemplifies (⊙)      │
│      │                     │                        │               │
│      ↓                     ↓                        ↓               │
│  CONCEPT              SPECIFICATION              EXAMPLE             │
└─────────────────────────────────────────────────────────────────────┘

PHYSICAL_NODES {
  STORAGE: {
    FILE: {
      DOCUMENT (.md, .txt, .pdf),
      CODE (.py, .js, .php),
      DATA (.json, .csv, .xlsx),
      CONFIG (.yaml, .env, .conf),
      BINARY (.exe, .so, .dll)
    },

    DIRECTORY: {
      PROJECT_DIR,
      MODULE_DIR (@),
      DATA_DIR (_),
      FUNCTIONAL_DIR (design/, solution/)
    },

    DATABASE: {
      RELATIONAL (PostgreSQL, MySQL),
      NOSQL (MongoDB, Redis),
      GRAPH (Neo4j),
      TIMESERIES (InfluxDB)
    }
  },

  COMPUTE: {
    PROCESS: {
      DAEMON,
      SERVICE,
      WORKER,
      JOB
    },

    CONTAINER: {
      DOCKER,
      VM,
      SANDBOX
    }
  },

  NETWORK: {
    ENDPOINT,
    PORT,
    SOCKET,
    URL
  }
}

LOGICAL_NODES {
  ORGANIZATION: {
    WORKSPACE (L0),
    BUSINESS (L1),
    DIRECTION (L2),
    MODULE (L3),
    TASK (L4)
  },

  SYSTEM_TYPE: {
    TARGET (9 questions),
    SUPPORTING (7 questions),
    INFORMATIONAL (5 questions),
    PROCESS (8 questions),
    STRUCTURAL (4 questions),
    AGENT (6 questions)
  },

  ARCHITECTURE: {
    LAYER,
    COMPONENT,
    MODULE,
    PACKAGE,
    NAMESPACE
  }
}

FUNCTIONAL_NODES {
  CODE: {
    PACKAGE,
    MODULE,
    CLASS,
    INTERFACE,
    FUNCTION,
    METHOD,
    VARIABLE,
    CONSTANT
  },

  PROCESS: {
    WORKFLOW,
    STEP,
    TASK,
    OPERATION,
    TRANSACTION
  },

  SERVICE: {
    API,
    RPC,
    MESSAGE_QUEUE,
    EVENT_BUS
  }
}

INFORMATION_NODES {
  KNOWLEDGE: {
    ONTOLOGY,
    TAXONOMY,
    CONCEPT,
    RULE,
    PATTERN
  },

  DOCUMENTATION: {
    SPECIFICATION,
    GUIDE,
    TUTORIAL,
    REFERENCE,
    API_DOC
  },

  DATA_MODEL: {
    SCHEMA,
    ENTITY,
    ATTRIBUTE,
    RELATION,
    CONSTRAINT
  }
}

NODE_PROPERTIES {
  // Идентификация
  id: UUID,
  name: STRING,
  type: NODE_TYPE,

  // Иерархия
  level: HIERARCHY_LEVEL,
  parent: NODE_ID,
  children: [NODE_ID],

  // Классификация
  role: SYSTEM_TYPE,
  category: CATEGORY,
  tags: [TAG],

  // Физические свойства
  location: PATH | URL,
  size: NUMBER,
  checksum: HASH,

  // Временные свойства
  created_at: TIMESTAMP,
  modified_at: TIMESTAMP,
  accessed_at: TIMESTAMP,
  version: SEMVER,

  // Состояние
  status: STATUS,
  state: STATE,
  health: HEALTH,

  // Владение и доступ
  owner: IDENTITY,
  permissions: PERMISSIONS,
  acl: ACL,

  // Метрики
  metrics: METRICS,

  // Документация
  description: TEXT,
  documentation: URL | EMBEDDED,

  // Произвольные свойства
  custom: MAP<STRING, VALUE>
}

EDGE_PROPERTIES {
  // Идентификация
  id: UUID,
  type: RELATION_TYPE,

  // Направление
  source: NODE_ID,
  target: NODE_ID,
  direction: ENUM {UNI, BI},

  // Сила связи
  weight: FLOAT[0..1],
  strength: ENUM {WEAK, NORMAL, STRONG, CRITICAL},

  // Кратность
  cardinality: STRING,  // "1:1", "1:N", "N:M"

  // Условия
  condition: EXPRESSION,
  guard: BOOLEAN,

  // Временные свойства
  created_at: TIMESTAMP,
  valid_from: TIMESTAMP,
  valid_until: TIMESTAMP,

  // Поведение
  cascading: BOOLEAN,
  transitive: BOOLEAN,
  symmetric: BOOLEAN,

  // Произвольные свойства
  custom: MAP<STRING, VALUE>
}

PATTERN: NESTED_HIERARCHY {
  A ⊃ B ⊃ C ⊃ D ⊃ E

  rules:
    - Каждый элемент имеет ровно одного родителя
    - Корень не имеет родителя
    - Листья не имеют детей
    - Нет циклов

  operations:
    - traverse(direction: UP | DOWN)
    - find_root()
    - find_leaves()
    - depth()
    - path_to_root()
}

PATTERN: DEPENDENCY_GRAPH {
  A → B → C
  A → D → C

  rules:
    - Может быть несколько зависимостей
    - Допустимы циклы (с предупреждением)
    - Зависимости транзитивны

  operations:
    - resolve_dependencies()
    - detect_cycles()
    - topological_sort()
    - impact_analysis(node)
}

PATTERN: SERVICE_MESH {
  CLIENT ⟶ SERVICE_A ⇄ SERVICE_B
                ↓
           DATABASE

  rules:
    - Асинхронные вызовы
    - Может быть синхронизация
    - Требуется контракт (API)

  operations:
    - discover_services()
    - route_request()
    - load_balance()
    - circuit_break()
}

PATTERN: DATA_PIPELINE {
  SOURCE →[extract]→ STAGE_1 →[transform]→ STAGE_2 →[load]→ SINK

  rules:
    - Данные текут в одном направлении
    - Каждый этап преобразует данные
    - Поддерживается backpressure

  operations:
    - start_pipeline()
    - pause_pipeline()
    - monitor_throughput()
    - handle_errors()
}

WEB_APP {
  // Узлы
  nodes: [
    {id: "app", type: LOGICAL, role: TARGET, level: L3},
    {id: "frontend", type: COMPONENT, role: INTERFACE, level: L4},
    {id: "backend", type: COMPONENT, role: SUPPORTING, level: L4},
    {id: "database", type: PHYSICAL, role: STORAGE, level: L4},
    {id: "cache", type: PHYSICAL, role: SUPPORTING, level: L4}
  ],

  // Связи
  edges: [
    {source: "app", target: "frontend", type: CONTAINS},
    {source: "app", target: "backend", type: CONTAINS},
    {source: "frontend", target: "backend", type: CALLS},
    {source: "backend", target: "database", type: READS_WRITES},
    {source: "backend", target: "cache", type: USES}
  ]
}

ORDER_PROCESS {
  // Узлы
  nodes: [
    {id: "receive", type: STEP, role: INTERFACE},
    {id: "validate", type: STEP, role: VALIDATOR},
    {id: "assemble", type: STEP, role: TRANSFORMER},
    {id: "deliver", type: STEP, role: PRODUCER}
  ],

  // Связи
  edges: [
    {source: "receive", target: "validate", type: SEQUENTIAL},
    {source: "validate", target: "assemble", type: SEQUENTIAL},
    {source: "assemble", target: "deliver", type: SEQUENTIAL}
  ],

  // Процесс
  process: {
    trigger: "ORDER_CREATED",
    actors: ["Customer", "Manager", "Warehouse", "Courier"],
    metrics: {
      cycle_time: 24_hours,
      success_rate: 0.95
    }
  }
}

INVARIANTS {
  // Иерархия
  1. ∀ node: has_one_parent(node) ∨ is_root(node)
  2. ∀ node: ¬∃ path(node → node)  // Нет циклов в иерархии
  3. ∀ node: level(parent) < level(node)

  // Зависимости
  4. ∀ A,B: depends_on(A,B) ⇒ ¬depends_on(B,A)  // Прямо не рекомендуется
  5. ∀ A,B,C: depends_on(A,B) ∧ depends_on(B,C) ⇒ depends_on(A,C)  // Транзитивность

  // Типы
  6. ∀ node: has_exactly_one(node, PHYSICAL_TYPE)
  7. ∀ node: has_at_most_one(node, SYSTEM_TYPE)

  // Связи
  8. ∀ edge: exists(source(edge)) ∧ exists(target(edge))
  9. ∀ edge: compatible_types(source, target, edge.type)
}

VALIDATION_RULES {
  // Обязательные файлы
  ∀ project ∈ [L1, L2, L3]:
    must_have(project, "CLAUDE.md") ∧
    must_have(project, "index.yaml")

  // Специфичные файлы по типу
  ∀ project:
    (role = TARGET) ⇒ must_have(project, "PROJECT.md", questions=9)
    (role = INFORMATIONAL) ⇒ must_have(project, "INDEX.md", questions=5)

  // Согласованность метаданных
  ∀ node:
    index_yaml.type = node.type ∧
    index_yaml.level = node.level ∧
    index_yaml.status ∈ VALID_STATUSES
}

QUERIES {
  // Навигация
  get_parent(node) → Node
  get_children(node) → [Node]
  get_ancestors(node) → [Node]
  get_descendants(node) → [Node]

  // Поиск
  find_by_type(type) → [Node]
  find_by_role(role) → [Node]
  find_by_level(level) → [Node]
  find_by_property(key, value) → [Node]

  // Связи
  get_dependencies(node) → [Node]
  get_dependents(node) → [Node]
  get_related(node, relation_type) → [Node]

  // Анализ
  calculate_depth(node) → Number
  find_cycles() → [[Node]]
  calculate_coupling(node) → Number
  calculate_cohesion(module) → Number
}

TRANSFORMATIONS {
  // Создание
  create_node(type, properties) → Node
  create_edge(source, target, type) → Edge

  // Изменение
  update_node(node, properties) → Node
  update_edge(edge, properties) → Edge

  // Удаление
  delete_node(node, cascade=false) → Boolean
  delete_edge(edge) → Boolean

  // Рефакторинг
  move_node(node, new_parent) → Boolean
  split_node(node, criteria) → [Node]
  merge_nodes([nodes]) → Node
  extract_module(nodes) → Module
}