two-brain-audit 0.1.0__tar.gz

two_brain_audit-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,31 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        python-version: ["3.10", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install
+        run: pip install -e ".[dev]"
+
+      - name: Lint
+        run: ruff check src/ tests/
+
+      - name: Test
+        run: pytest --tb=short -q

two_brain_audit-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

two_brain_audit-0.1.0/.gitignore

@@ -0,0 +1,39 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Testing
+.pytest_cache/
+htmlcov/
+.coverage
+coverage.xml
+
+# Type checking
+.mypy_cache/
+
+# Runtime artifacts
+*.db
+*.db-shm
+*.db-wal
+audit_baseline.json
+demo_baseline.json
+
+# OS
+.DS_Store
+Thumbs.db

two_brain_audit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Max
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

two_brain_audit-0.1.0/PKG-INFO

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: two-brain-audit
+Version: 0.1.0
+Summary: Dual-layer audit system combining automated scoring (left brain) with manual qualitative grading (right brain) and reconciliation.
+Project-URL: Homepage, https://github.com/maxtheman/two-brain-audit
+Project-URL: Repository, https://github.com/maxtheman/two-brain-audit
+Project-URL: Issues, https://github.com/maxtheman/two-brain-audit/issues
+Author: Max
+License-Expression: MIT
+License-File: LICENSE
+Keywords: audit,grading,quality,reconciliation,scoring
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: all
+Requires-Dist: flask>=3.0; extra == 'all'
+Requires-Dist: httpx>=0.27; extra == 'all'
+Requires-Dist: pywebview>=5.0; extra == 'all'
+Requires-Dist: semgrep>=1.60; extra == 'all'
+Provides-Extra: dashboard
+Requires-Dist: flask>=3.0; extra == 'dashboard'
+Provides-Extra: dev
+Requires-Dist: flask>=3.0; extra == 'dev'
+Requires-Dist: httpx>=0.27; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: pywebview>=5.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Requires-Dist: semgrep>=1.60; extra == 'dev'
+Provides-Extra: github
+Requires-Dist: httpx>=0.27; extra == 'github'
+Provides-Extra: llm
+Requires-Dist: httpx>=0.27; extra == 'llm'
+Provides-Extra: native
+Requires-Dist: flask>=3.0; extra == 'native'
+Requires-Dist: pywebview>=5.0; extra == 'native'
+Provides-Extra: semgrep
+Requires-Dist: semgrep>=1.60; extra == 'semgrep'
+Description-Content-Type: text/markdown
+
+# Two-Brain Audit
+
+A dual-layer audit system that combines automated quantitative scoring (**left brain**) with manual qualitative grading (**right brain**) and reconciles them automatically.
+
+```
+  LEFT BRAIN (Auto)              RIGHT BRAIN (Manual)
+  ─────────────────              ────────────────────
+  pytest pass rate    ──┐    ┌── Human grade (A)
+  ruff lint score     ──┤    ├── LLM review findings
+  semgrep scan        ──┤    ├── User feedback (4.2/5)
+  endpoint health     ──┘    └── Team notes
+                        │    │
+                        ▼    ▼
+                    ┌──────────┐
+                    │RECONCILER│
+                    └────┬─────┘
+                         │
+              ┌──────────┼──────────┐
+              ▼          ▼          ▼
+           Aligned    Diverged    Failing
+           (green)    (yellow)     (red)
+```
+
+## Why Two Brains?
+
+| Scenario | Auto catches it | Manual catches it |
+|----------|:-:|:-:|
+| Test coverage drops silently | Yes | Maybe |
+| "Feels slow" but metrics are fine | No | Yes |
+| Stale manual grade after major refactor | Yes (divergence) | No |
+| Security vuln in dependency | Yes (scanner) | No |
+| UX regression that tests can't express | No | Yes |
+| Reviewer optimism ("looks good to me") | Yes (cross-validation) | No |
+
+## Quick Start
+
+```bash
+pip install two-brain-audit
+
+two-brain-audit init                      # create DB + baseline sidecar
+two-brain-audit register --preset python  # 8 dimensions for Python projects
+two-brain-audit run light                 # first scan (~2s)
+two-brain-audit status                    # view scores + divergences
+```
+
+```
+Dimension                  Auto   Grade  Manual  Status
+-----------------------------------------------------------------
+  test_coverage            0.930      A      —   ok
+  lint_score               1.000      S      —   ok
+  type_coverage            0.720     B-      —   ok
+  security                 0.500      D      —   ok
+
+Overall: B+ (0.788)
+```
+
+### Web Dashboard
+
+```bash
+pip install two-brain-audit[dashboard]
+two-brain-audit dashboard                 # http://localhost:8484/audit/
+```
+
+Dark-mode UI with grade ring, score bars, divergence alerts, tier triggers, and a feedback widget. Zero external dependencies.
+
+**[Full walkthrough with examples → docs/QUICKSTART.md](docs/QUICKSTART.md)**
+
+## Features
+
+- **12-grade scale** (S through F) with automatic score-to-grade conversion
+- **4 audit tiers** — light (CI), medium (on-demand), daily (scheduled), weekly (deep scan)
+- **Divergence detection** — auto vs manual disagreement surfaces automatically
+- **Ratchet rules** — prevent silent score regression per dimension
+- **User feedback** — star rating + free text, optionally classified by LLM
+- **5 presets** — Python, REST API, Database, Infrastructure, ML Pipeline
+- **4 integrations** — GitHub, semgrep, PyPI, Ollama (pluggable)
+- **3 exporters** — JSON, CSV, Markdown reports
+- **Web dashboard** — self-contained Flask blueprint, embed anywhere
+- **CLI** — `init`, `run`, `status`, `health`, `export`, `dashboard`
+- **CI-friendly** — `two-brain-audit health` returns exit code 0/1 + JSON
+
+## Python API
+
+```python
+from two_brain_audit import AuditEngine, Dimension, Tier
+
+engine = AuditEngine(db_path="audit.db", baseline_path="audit_baseline.json")
+
+engine.register(Dimension(
+    name="test_coverage",
+    check=lambda: (passed / total, {"passed": passed, "total": total}),
+    confidence=0.95,
+    tier=Tier.LIGHT,
+))
+
+results = engine.run_tier("daily")
+health = engine.health_check()        # {"ok": True, "grade": "A", ...}
+engine.record_feedback(score=0.8, text="Looking good")
+```
+
+## Flask Integration
+
+```python
+from two_brain_audit.dashboard import create_blueprint
+app.register_blueprint(create_blueprint(engine), url_prefix="/audit")
+```
+
+## Presets
+
+| Preset | Dimensions | Best for |
+|--------|-----------|----------|
+| `python` | test coverage, lint, types, deps, docs, security, complexity, imports | Python repos |
+| `api` | endpoint health, latency, errors, auth, schema, rate limits, CORS, TLS | REST APIs |
+| `database` | schema, indexes, queries, backups, replication, pool, migrations | Databases |
+| `infrastructure` | uptime, certs, resources, config drift, secrets, DNS, CDN, containers | DevOps |
+| `ml_pipeline` | model freshness, data drift, latency, accuracy, features, GPU, experiments | ML workflows |
+
+## Docs
+
+- **[Quickstart Guide](docs/QUICKSTART.md)** — step-by-step with examples
+- **[Architecture](docs/ARCHITECTURE.md)** — design decisions and data flow
+- **[examples/biged/](examples/biged/)** — 12-dimension reference implementation
+
+## Origin
+
+Extracted from [BigEd CC](https://github.com/maxtheman/Education) after production use on a 125-skill AI fleet with 12 audit dimensions, 4 tiers, and automated daily/weekly scheduling.
+
+## License
+
+MIT

two_brain_audit-0.1.0/README.md

@@ -0,0 +1,130 @@
+# Two-Brain Audit
+
+A dual-layer audit system that combines automated quantitative scoring (**left brain**) with manual qualitative grading (**right brain**) and reconciles them automatically.
+
+```
+  LEFT BRAIN (Auto)              RIGHT BRAIN (Manual)
+  ─────────────────              ────────────────────
+  pytest pass rate    ──┐    ┌── Human grade (A)
+  ruff lint score     ──┤    ├── LLM review findings
+  semgrep scan        ──┤    ├── User feedback (4.2/5)
+  endpoint health     ──┘    └── Team notes
+                        │    │
+                        ▼    ▼
+                    ┌──────────┐
+                    │RECONCILER│
+                    └────┬─────┘
+                         │
+              ┌──────────┼──────────┐
+              ▼          ▼          ▼
+           Aligned    Diverged    Failing
+           (green)    (yellow)     (red)
+```
+
+## Why Two Brains?
+
+| Scenario | Auto catches it | Manual catches it |
+|----------|:-:|:-:|
+| Test coverage drops silently | Yes | Maybe |
+| "Feels slow" but metrics are fine | No | Yes |
+| Stale manual grade after major refactor | Yes (divergence) | No |
+| Security vuln in dependency | Yes (scanner) | No |
+| UX regression that tests can't express | No | Yes |
+| Reviewer optimism ("looks good to me") | Yes (cross-validation) | No |
+
+## Quick Start
+
+```bash
+pip install two-brain-audit
+
+two-brain-audit init                      # create DB + baseline sidecar
+two-brain-audit register --preset python  # 8 dimensions for Python projects
+two-brain-audit run light                 # first scan (~2s)
+two-brain-audit status                    # view scores + divergences
+```
+
+```
+Dimension                  Auto   Grade  Manual  Status
+-----------------------------------------------------------------
+  test_coverage            0.930      A      —   ok
+  lint_score               1.000      S      —   ok
+  type_coverage            0.720     B-      —   ok
+  security                 0.500      D      —   ok
+
+Overall: B+ (0.788)
+```
+
+### Web Dashboard
+
+```bash
+pip install two-brain-audit[dashboard]
+two-brain-audit dashboard                 # http://localhost:8484/audit/
+```
+
+Dark-mode UI with grade ring, score bars, divergence alerts, tier triggers, and a feedback widget. Zero external dependencies.
+
+**[Full walkthrough with examples → docs/QUICKSTART.md](docs/QUICKSTART.md)**
+
+## Features
+
+- **12-grade scale** (S through F) with automatic score-to-grade conversion
+- **4 audit tiers** — light (CI), medium (on-demand), daily (scheduled), weekly (deep scan)
+- **Divergence detection** — auto vs manual disagreement surfaces automatically
+- **Ratchet rules** — prevent silent score regression per dimension
+- **User feedback** — star rating + free text, optionally classified by LLM
+- **5 presets** — Python, REST API, Database, Infrastructure, ML Pipeline
+- **4 integrations** — GitHub, semgrep, PyPI, Ollama (pluggable)
+- **3 exporters** — JSON, CSV, Markdown reports
+- **Web dashboard** — self-contained Flask blueprint, embed anywhere
+- **CLI** — `init`, `run`, `status`, `health`, `export`, `dashboard`
+- **CI-friendly** — `two-brain-audit health` returns exit code 0/1 + JSON
+
+## Python API
+
+```python
+from two_brain_audit import AuditEngine, Dimension, Tier
+
+engine = AuditEngine(db_path="audit.db", baseline_path="audit_baseline.json")
+
+engine.register(Dimension(
+    name="test_coverage",
+    check=lambda: (passed / total, {"passed": passed, "total": total}),
+    confidence=0.95,
+    tier=Tier.LIGHT,
+))
+
+results = engine.run_tier("daily")
+health = engine.health_check()        # {"ok": True, "grade": "A", ...}
+engine.record_feedback(score=0.8, text="Looking good")
+```
+
+## Flask Integration
+
+```python
+from two_brain_audit.dashboard import create_blueprint
+app.register_blueprint(create_blueprint(engine), url_prefix="/audit")
+```
+
+## Presets
+
+| Preset | Dimensions | Best for |
+|--------|-----------|----------|
+| `python` | test coverage, lint, types, deps, docs, security, complexity, imports | Python repos |
+| `api` | endpoint health, latency, errors, auth, schema, rate limits, CORS, TLS | REST APIs |
+| `database` | schema, indexes, queries, backups, replication, pool, migrations | Databases |
+| `infrastructure` | uptime, certs, resources, config drift, secrets, DNS, CDN, containers | DevOps |
+| `ml_pipeline` | model freshness, data drift, latency, accuracy, features, GPU, experiments | ML workflows |
+
+## Docs
+
+- **[Quickstart Guide](docs/QUICKSTART.md)** — step-by-step with examples
+- **[Architecture](docs/ARCHITECTURE.md)** — design decisions and data flow
+- **[examples/biged/](examples/biged/)** — 12-dimension reference implementation
+
+## Origin
+
+Extracted from [BigEd CC](https://github.com/maxtheman/Education) after production use on a 125-skill AI fleet with 12 audit dimensions, 4 tiers, and automated daily/weekly scheduling.
+
+## License
+
+MIT

two_brain_audit-0.1.0/docs/ARCHITECTURE.md

@@ -0,0 +1,191 @@
+# Architecture
+
+## Design Philosophy
+
+The two-brain audit system is built on one core insight: **neither automated scoring nor manual review alone is sufficient**. Automated checks catch drift, regressions, and known-bad patterns with high reliability but can't assess "feel" or strategic fit. Manual reviews catch what code can't express, but are subject to optimism bias, staleness, and inconsistency.
+
+The two-brain pattern combines both and adds **reconciliation with teeth**: when the brains disagree, the system surfaces that disagreement rather than silently choosing a winner.
+
+## Architecture Overview
+
+```
+┌──────────────────────────────────────────────────────────┐
+│                     AuditEngine                          │
+│                                                          │
+│  ┌─────────────┐  ┌───────────┐  ┌──────────────────┐   │
+│  │ Dimension    │  │ Sidecar   │  │ Reconciler       │   │
+│  │ Registry     │  │ (.json)   │  │                  │   │
+│  │              │  │           │  │ divergence       │   │
+│  │ check()→     │  │ manual    │  │ detection        │   │
+│  │ (score,      │  │ grades    │  │ ratchet check    │   │
+│  │  detail)     │  │ ratchets  │  │ weekly merge     │   │
+│  │              │  │ feedback  │  │ status classify   │   │
+│  └──────┬───────┘  └─────┬─────┘  └────────┬─────────┘   │
+│         │                │                  │             │
+│         └────────┬───────┘──────────────────┘             │
+│                  │                                        │
+│         ┌────────▼────────┐                               │
+│         │   AuditDB       │                               │
+│         │   (SQLite)      │                               │
+│         │                 │                               │
+│         │ audit_scores    │                               │
+│         │ user_feedback   │                               │
+│         └─────────────────┘                               │
+└──────────────────────────────────────────────────────────┘
+         │              │              │
+    ┌────▼────┐   ┌─────▼─────┐  ┌────▼────┐
+    │  CLI    │   │ Dashboard │  │ Export  │
+    │         │   │ (Flask)   │  │ JSON/   │
+    │ init    │   │           │  │ CSV/    │
+    │ run     │   │ REST API  │  │ Markdown│
+    │ status  │   │           │  │         │
+    └─────────┘   └───────────┘  └─────────┘
+```
+
+## Key Design Decisions
+
+### 1. Dimensions are callables, not configs
+
+A dimension's `check` is a plain `Callable[[], tuple[float, dict]]`. No YAML schemas, no special DSL. This means:
+- Any Python function can be a check
+- Checks can call subprocess, HTTP, DB, or pure logic
+- Testing is trivial (mock the callable)
+- No serialization/deserialization overhead
+
+### 2. Sidecar over DB for manual grades
+
+Manual grades live in `audit_baseline.json`, not the database. Why:
+- **Git-trackable** — diffs show grade changes in code review
+- **Human-editable** — no special tooling needed to update
+- **Atomic** — read the whole file, write the whole file (no partial states)
+- **Portable** — copy between environments without DB migration
+
+The DB stores the time-series of auto scores and reconciliation results. The sidecar stores the current truth of manual assessment.
+
+### 3. Tier hierarchy is inclusive
+
+Each tier includes all checks from lower tiers:
+```
+weekly ⊃ daily ⊃ medium ⊃ light
+```
+
+This means running `daily` also runs all `light` and `medium` checks. There's no way to run "only daily checks" because the lower tiers provide the foundation that daily reconciliation needs.
+
+### 4. Divergence requires confidence
+
+A divergence is only flagged when:
+```
+abs(auto_score - manual_score) > 0.15 AND auto_confidence >= 0.5
+```
+
+Low-confidence dimensions (like `usability_ux` at 0.30) can't trigger divergence because we don't trust the auto score enough to contradict a human reviewer. The confidence floor prevents noisy alerts.
+
+### 5. Three resolution paths (not just two)
+
+Most audit systems offer "fix it" or "ignore it". We add a third:
+1. **Update manual grade** — acknowledge the auto score is right
+2. **Acknowledge** — dismiss without changing (visible but dimmed)
+3. **LLM review** — get a second opinion from an external model
+
+The LLM review path is valuable because it resolves the "who's right?" question without requiring a full human re-audit. It's a structured single-call prompt, not a conversation.
+
+### 6. Ratchets are advisory by default
+
+Ratchets prevent silent regression: once you declare "testing should be at least A", a drop below that floor is flagged. But in v0.1, ratchets produce WARN, not FAIL.
+
+This is deliberate — new users shouldn't have their CI broken by a feature they just set up. Promote to FAIL per-dimension after tuning the system for your codebase.
+
+### 7. Presets are starting points, not constraints
+
+Presets provide dimension definitions with stub check functions. The expectation is:
+- Use a preset to get started fast
+- Replace stub checks with real implementations for your project
+- Add/remove dimensions as needed
+
+A preset is a Python list of `Dimension` objects, not a locked configuration.
+
+### 8. Integrations are optional and pluggable
+
+Each integration (GitHub, semgrep, PyPI, Ollama) is:
+- A separate module with its own dependencies
+- Configured via `configure(**kwargs)` (no global config file)
+- Provides `checks()` that return callables wire-able to dimensions
+
+If you don't install `two-brain-audit[github]`, the GitHub integration simply isn't available. No broken imports, no missing-dep errors at runtime.
+
+## Data Flow
+
+### Scoring Run
+
+```
+1. Engine.run_tier("daily")
+2. For each dimension where tier ≤ requested tier:
+   a. Call dimension.check() → (score, detail)
+   b. Clamp score to [0.0, 1.0]
+   c. Load manual grade from sidecar
+   d. Compare: divergent if gap > 0.15 AND confidence ≥ 0.5
+   e. Write DimensionResult to audit_scores table
+3. Return list of DimensionResult
+```
+
+### Reconciliation
+
+```
+1. Dr. Ders / scheduler triggers daily run at 3:00 AM
+2. Run all dimensions up to daily tier
+3. For each dimension with divergence=1 AND acknowledged=0:
+   a. Push SSE alert (if dashboard is running)
+   b. Flag in smoke test output
+4. Check ratchet targets — flag any below floor
+5. Aggregate user feedback into sidecar
+```
+
+### Feedback Loop
+
+```
+1. User submits feedback (stars/slider + text)
+2. Score stored in user_feedback table
+3. (Optional) Text classified by LLM into dimensions
+4. Daily reconciliation aggregates into sidecar per-dimension
+5. UX confidence adjusts: min(0.75, 0.30 + feedback_count/100 * 0.45)
+```
+
+## File Layout
+
+```
+two-brain-audit/
+├── src/two_brain_audit/
+│   ├── __init__.py          # Public API exports
+│   ├── engine.py            # AuditEngine, Dimension, DimensionResult
+│   ├── db.py                # SQLite storage (audit_scores, user_feedback)
+│   ├── sidecar.py           # JSON sidecar read/write
+│   ├── grades.py            # Grade ↔ score conversion
+│   ├── tiers.py             # Tier enum + scheduling
+│   ├── reconciler.py        # Weekly merge, ratchet check, status classify
+│   ├── feedback.py          # LLMClassifier protocol, conversion helpers
+│   ├── cli.py               # CLI entry point
+│   ├── dashboard/           # Optional Flask blueprint
+│   └── exporters/           # JSON, CSV, Markdown report generators
+├── presets/                  # Dimension configs per project type
+│   ├── python_project.py    # 8 dimensions for Python repos
+│   ├── api_service.py       # 8 dimensions for REST APIs
+│   ├── database.py          # 7 dimensions for database health
+│   ├── infrastructure.py    # 8 dimensions for DevOps/infra
+│   └── ml_pipeline.py       # 7 dimensions for ML workflows
+├── integrations/             # Pluggable external data sources
+│   ├── github.py            # CI status, open bugs, stale PRs
+│   ├── semgrep.py           # SAST security scanning
+│   ├── pypi.py              # Dependency version drift
+│   └── ollama.py            # Local model health
+├── examples/biged/           # Reference implementation (12 dimensions)
+├── tests/                    # pytest test suite
+├── docs/                     # This file + future guides
+├── pyproject.toml            # Build config, deps, tool settings
+└── README.md                 # User-facing documentation
+```
+
+## Origin
+
+Extracted from BigEd CC (`github.com/maxtheman/Education`) after production use on a 125-skill AI fleet. The BigEd implementation lives in `fleet/audit_scorer.py` (1,088 lines) and uses all 12 dimensions across 4 tiers with Dr. Ders scheduling daily/weekly runs.
+
+The extraction preserves the battle-tested core while making it configurable for any project type.