atomadic-forge 0.16.2__tar.gz → 0.19.0__tar.gz

{atomadic_forge-0.16.2 → atomadic_forge-0.19.0}/.github/workflows/ci.yml

@@ -94,3 +94,24 @@ jobs:
         with:
           name: atomadic-forge-dist
           path: dist/*
+
+  metrics:
+    name: Metrics freshness
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v6
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+          cache: pip
+
+      - name: Install package
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e ".[dev]"
+
+      - name: Verify forge_metrics.json is current
+        run: python scripts/update_metrics.py --check

{atomadic_forge-0.16.2 → atomadic_forge-0.19.0}/.github/workflows/customer-refactor.yml

@@ -1,4 +1,4 @@
-# Customer Refactor — fully automated $499 forge.atomadic.tech fulfillment.
+# Customer Refactor — fully automated $149/$99 forge.atomadic.tech fulfillment.
 #
 # Triggered by Atomadic's REFACTOR_REPO action via the GitHub
 # repository_dispatch API. The cognition worker POSTs:
@@ -28,7 +28,7 @@
 # The cognition endpoint emails the customer (apology + refund offer) and
 # pings Dad on Discord so the order can be retried manually.
 
-name: Customer Refactor (forge.atomadic.tech $499 fulfillment)
+name: Customer Refactor (forge.atomadic.tech $149/$99 fulfillment)
 
 on:
   repository_dispatch:
@@ -55,7 +55,7 @@ on:
         description: "Amount paid (cents)"
         required: false
         type: string
-        default: "49900"
+        default: "9900"
 
 permissions:
   contents: read
@@ -234,7 +234,7 @@ jobs:
             echo "   above."
             echo "4. Run your own test suite — Forge does not touch behavior."
             echo ""
-            echo "One round of revisions is included with your $499 order."
+            echo "One round of revisions is included with your order."
             echo "Reply to the email you received from Atomadic with anything"
             echo "you want changed."
             echo ""

{atomadic_forge-0.16.2 → atomadic_forge-0.19.0}/CHANGELOG.md

@@ -2,6 +2,247 @@
 
 ## Unreleased
 
+## v0.19.0 — 2026-05-07 — MCP/CLI parity sweep: 8 tool fixes, call_graph overhaul, smell improvements
+
+### fix(recon): MCP recon now returns prior_wisdom
+
+`_tool_recon` in `mcp_protocol.py` now injects the same `prior_wisdom`
+field that the CLI has always produced via `recall_for_recon`. Agents
+calling `recon` over MCP now see the top-5 repo-scoped wisdom entries in
+the response — matching CLI parity and giving every MCP agent the
+institutional memory it needs before starting work.
+
+### perf(mcp): certify skip-tests, wire dynamic-import allowlist, verify slim summaries
+
+**certify**
+
+- New `skip_tests: bool = False` parameter on `certify()` — skips the
+  pytest run, credits the behavioural axis at 1.0, and adds
+  `tests_skipped: true` to the result.  Reduces certify time from ~40s
+  to ~500ms in CI pipelines that run pytest separately.
+- `pytest_summary` raw dot-string is now stripped from the `test_run`
+  dict at source; agents receive structured counts only (no 1500-char dot
+  strings).
+- MCP tool schema updated with a `skip_tests` boolean input parameter.
+
+**wire**
+
+- `_tool_wire` reads `[tool.forge.wire].allowed_dynamic_imports` from
+  `pyproject.toml`.
+- Response now includes `new_dynamic_warnings` (count of genuinely new
+  warnings) and `whitelisted_dynamic_warnings_count`.
+- `dynamic_import_warnings` array shows only non-whitelisted warnings.
+- `pyproject.toml` gained a `[tool.forge.wire]` section with three
+  known-safe dynamic-import entries documented.
+
+**verify**
+
+- `wire` and `certify` keys in the verify response are now slim
+  summaries instead of full payloads (~80% response size reduction).
+  - Wire summary: `{verdict, violation_count, auto_fixable, new_dynamic_warnings}`
+  - Certify summary: `{score, verdict, blockers, score_components, issues, tests_skipped}`
+- New top-level `wisdom_draft: {insight, tags, command}` field — no
+  more digging into the nested `wisdom_capture_prompt` structure.
+- `auto_record_threshold_met` now fires on any PASS verdict, not only
+  score-delta events.
+
+### fix(batch3): select-tests CLI broken, test discovery gap, certify --skip-tests, context_pack best_next
+
+- `select-tests` CLI: Typer group positional `Argument` never parsed — converted
+  `intent` to `--intent / -i` option (the only correct workaround for Typer groups).
+- `test_selector`: stem-component token heuristic (≥6-char tokens) now catches
+  test files like `test_certify_operational_axis.py` for `certify_checks.py`.
+  Before: only exact `test_<stem>.py` mirror matches. After: 7 targeted tests
+  for a 3-file change instead of 1.
+- `forge certify --skip-tests` CLI flag (was MCP-only and Python API-only).
+- `context_pack.best_next_action` was always `null` on clean repos — now derives
+  a meaningful suggestion from the focus mode (recon / preflight / release / lineage).
+
+### fix(batch4): call_graph fully repaired — relative imports + package normalization; smell_scan build/ exclusion
+
+**call_graph** — two independent bugs both produced `target_in_graph: false`:
+- `package` defaulted to `project_root.name` (e.g. `"atomadic-forge"` with
+  hyphen); Python package is `"atomadic_forge"` — all qualnames in the graph
+  were wrong. Fix: `_detect_package_name()` reads `[project].name` from
+  `pyproject.toml` and normalizes `"-"` → `"_"`.
+- Relative imports (`from ..a1_at_functions.certify_checks import certify as _certify`)
+  resolved to bare paths missing the package prefix (`a1_at_functions.certify_checks.certify`
+  instead of `atomadic_forge.a1_at_functions.certify_checks.certify`). Fix:
+  `_collect_imports()` now accepts `module_dotted` and resolves `node.level`
+  against it. `certify()` callers: 0 → **36**.
+
+**smell_scan** — `_walk_functions()` now skips `build/`, `dist/`, `.eggs/`,
+`.tox/`, `node_modules/`. The scanner was walking compiled artifacts in `build/`
+and double-counting every function. Forge repo smell_score: 67.1 → **89.7**.
+
+### fix(batch5): trust-gate CLI crash, welcome certify verdict None
+
+- `trust_gate_cmd`: `d = verdict.schema` set `d` to the schema-version string,
+  not a payload dict; subsequent `.get("safe_to_act")` crashed with
+  `AttributeError`. Fix: `dataclasses.asdict(verdict)` for the full dict.
+- `welcome_feature.py`: `scan.certify.verdict` was always `None` because the
+  code read `certify_report.get("verdict")` (top-level, doesn't exist in normal
+  runs) instead of `certify_report["health_summary"]["verdict"]`. Fixed with
+  fallback chain: `health_summary.verdict` (normal) → `top-level verdict` (error
+  fallback path).
+
+## v0.18.0 — 2026-05-07 flexible LLM providers + VS Code extension + hook repairs
+
+### Flexible LLM provider config
+
+Forge previously hardcoded six provider classes (Anthropic, OpenAI, Gemini,
+Ollama, OpenRouter, AAAA-Nexus).  v0.18.0 adds a generic OpenAI-compatible
+client + a `custom_providers` config field so users can wire ANY
+chat-completions-API service (DeepSeek, Groq, Together, Fireworks, xAI,
+Mistral, Perplexity, Cerebras, Hyperbolic, internal proxies, …) without
+writing Python.
+
+- **NEW** `a1.custom_provider_client` — `CustomProviderClient` honours the
+  same `LLMClient` Protocol as the hardcoded clients.  11 bundled presets
+  (openai, openrouter, deepseek, groq, together, fireworks, xai, mistral,
+  perplexity, cerebras, hyperbolic) for one-line setup.
+- **NEW** `a0.config_defaults.custom_providers: list[CustomProviderEntry]`
+  — declare any provider as `{name, base_url, model, api_key_env, format}`.
+  Resolver looks up config entries first (overrides win over presets), then
+  falls back to bundled presets, then to hardcoded backward-compat names.
+- **NEW** CLI: `forge config provider {add | list | remove | presets}`.
+  `add` accepts a `--preset` for one-line setup, plus optional
+  `--base-url`, `--model`, `--api-key-env`, `--format`, `--global`.
+- **NEW** env-var override on every preset: `FORGE_<NAME>_MODEL` swaps the
+  default model without rewriting config (e.g. `FORGE_GROQ_MODEL=…`).
+- 27 new tests in `test_custom_provider.py` pinning the registry,
+  validation, network call shape, and resolver fallback chain.
+
+### VS Code extension
+
+NEW `vscode-extension/` directory ships a complete VS Code package:
+
+- **Status bar** — live certify score + wire violation count, click to
+  re-verify; turns red below the configured `failUnder` threshold.
+- **Activity-bar panel** — two tree views: Wire Violations (click-through
+  to file) + Certify Axes (which of the 9 axes are passing).
+- **10 commands** mapped 1:1 to forge CLI verbs (recon, wire, certify,
+  verify, smell, context-pack, enforce --apply, welcome, config wizard,
+  mcp serve).
+- **MCP server launcher** — opens a terminal running `forge mcp serve` for
+  Claude Code / Cursor / Cowork / Windsurf to attach.
+- **Auto-verify on save** (opt-in) for Python, JavaScript, TypeScript,
+  Rust, Go, Swift, Kotlin.
+- Settings: `executable`, `provider`, `failUnder`, `statusBarFormat`,
+  `scanLanguages`, `autoVerifyOnSave`.
+- Build: `cd vscode-extension && npm install && npm run package`.
+
+### Git hook repairs
+
+The shipped `hooks/post-clone`, `hooks/pre-commit`, and `hooks/pre-push`
+all called Forge verbs with the obsolete `--project` / `--suggest_repairs`
+flag style.  Verified against the live CLI: every verb takes a positional
+path and uses kebab-case flags.
+
+- `hooks/post-clone` — now invokes `forge welcome run --project-root …`
+  + `forge explain-repo` + `forge context-pack --target …`.
+- `hooks/pre-commit` — switched to positional `forge certify PATH`,
+  `forge wire SOURCE`, kebab-case `--suggest-repairs` and `--apply`.
+  Auto-derives `SRC_ROOT` from the workspace.
+- `hooks/pre-push` — same flag fixes; smoke-tested against the live repo:
+  `[forge-wire] PASS — 0 violations, verdict: PASS`.
+
+### Documentation
+
+- **NEW** `docs/PROVIDERS.md` — full preset table, custom-provider walkthrough,
+  resolution-order spec, env-var override matrix.
+- **NEW** `docs/IDE_INTEGRATION.md` — VS Code extension, MCP attach
+  configs for Claude Code / Cursor / Cowork / Windsurf / Claude Desktop,
+  recommended VS Code settings, hook installation.
+
+### Score
+
+Self-certify: 100/100, wire 0 violations, all gates green.
+
+## v0.17.0 — 2026-05-06 full polyglot pipeline (Rust / Go / Swift / Kotlin native)
+
+Forge now operates the full pipeline — recon, wire, certify, scaffold,
+evolve — on **seven languages** with the same depth: **Python, JavaScript,
+TypeScript, Rust, Go, Swift, Kotlin.** What used to be a Python+JS
+classifier is now a true polyglot architecture engine.
+
+### Read pass (recon + wire)
+
+- **Per-symbol harvest** for every native language.  Rust / Go / Swift /
+  Kotlin files no longer collapse to a single ``module`` record — every
+  public function, struct/class/enum/trait/protocol/interface, method
+  (with parent type), and constant is emitted as its own symbol so
+  cherry-pick and emergent-compose treat native langs identically to
+  Python and JS.  See ``a1.polyglot_surface``.
+- **Tier classification by content** (not just by directory).  A new
+  ``a1.polyglot_classify.classify_native_tier`` runs a 7-rule cascade
+  (path tier > main entry > I/O imports > stateful types > pure fns >
+  consts > a3 fallback) over each parsed surface.
+- **Wire upward-import scan** for Rust ``use crate::aN_…``, Go
+  ``import "…/aN_…"``, Swift ``import aN_…``, Kotlin
+  ``import com.x.aN_…``.  ``_tier_of_specifier`` now normalises ``::``
+  and ``.`` to ``/`` so every language's import path resolves to the
+  same tier dictionary.  Violations carry the standard F0040–F0049
+  codes and ``auto_fixable`` is widened to all 7 langs.
+- **Effect detection** (pure / state / io) per file, derived from
+  surface signals (presence of state-bearing types, I/O imports).
+
+### Write pass (scaffold + emit)
+
+- ``Language`` literal extends to ``"rust" | "go" | "swift" | "kotlin"``
+  with full per-language tables: ``PKG_ROOT_TEMPLATE``,
+  ``ALLOWED_FILE_EXTS``, ``MAIN_EXT``, plus new ``EMITS_CARGO_TOML``,
+  ``EMITS_GO_MOD``, ``EMITS_PACKAGE_SWIFT``, ``EMITS_BUILD_GRADLE``,
+  ``EMITS_TIER_MOD_RS``.
+- New ``a1.scaffold_polyglot`` renderers produce idiomatic shells:
+  Cargo crate (Cargo.toml + src/lib.rs + per-tier mod.rs); Go module
+  (go.mod + per-tier ``<tier>.go`` package decls); SwiftPM target
+  (Package.swift + Sources/<pkg>/<tier>/); Gradle library
+  (build.gradle.kts + settings.gradle.kts +
+  src/main/kotlin/<pkg>/<tier>/).  Each renderer is pure (string in,
+  string out) so the emit branch in ``forge_loop._scaffold_package``
+  stays a single dispatcher.
+- ``normalize_language`` accepts ``rs``/``rust``, ``go``/``golang``,
+  ``swift``, ``kt``/``kotlin``.
+
+### Hardening
+
+- 156 polyglot tests across four files: ``test_polyglot_full_pipeline``
+  (registry + scaffold), ``test_polyglot_symbol_parity`` (per-symbol
+  harvest contract), ``test_polyglot_hardening`` (malformed source +
+  generics + async + extensions + idiomatic Rust crate fixture), and
+  ``test_polyglot_cli_mcp`` (CLI ↔ MCP equivalence on synthetic Rust /
+  Go / Swift / Kotlin repos).
+- Whoami test fixture now removes ``FORGE_MASTER_API_KEY`` in addition
+  to ``FORGE_API_KEY`` so dev-shell test runs are hermetic.  Was the
+  last 3 failures keeping certify off 100/100.
+- ``mcp_protocol`` lazy a3-bootstrap.  Downstream consumers that
+  imported ``a1.mcp_protocol`` directly (without going through
+  ``forge mcp serve``) used to get ``wired:false`` stubs from
+  registered tools (``verify``, ``emergent_scan``, ``synergy_scan``,
+  ``handoff_list``, ``wisdom_query``, …) until they remembered to
+  ``import atomadic_forge.a3_og_features.mcp_server`` themselves.
+  Fixed: every wrapper now calls ``_bootstrap_a3_handlers()`` which
+  performs an idempotent ``importlib.import_module`` of the a3 server
+  on first call.  The static a1↔a3 import graph stays untouched (the
+  upward-only law is preserved); subsequent calls are a single
+  boolean check.  Pinned by ``tests/test_mcp_lazy_bootstrap.py``.
+
+### Release-time bug fixes
+
+- ``scripts/update_metrics.py`` — hardcoded language list updated to
+  the full 7-language polyglot set; ``sys.stdout.reconfigure('utf-8')``
+  guard added so the script's checkmarks don't crash on Windows
+  cp1252 (was breaking ``make release`` step 2).
+- ``scripts/version-sync-check.sh`` — paths are now passed to embedded
+  Python via ``sys.argv[1]`` instead of interpolated into source code,
+  so ``!!AtomadicStandard``-style paths can't be misread as Python
+  escape sequences (was breaking the cross-repo sync check on Windows).
+
+### Score
+
+Self-certify: **100/100**, wire 0 violations, 1460/1460 tests passing.
+
 ## v0.16.2 — 2026-05-06 welcome scope guard + Boris pre-demo hardening
 
 Pre-Boris-demo stress test surfaced a single class of welcome failure:

atomadic_forge-0.19.0/PKG-INFO

@@ -0,0 +1,235 @@
+Metadata-Version: 2.4
+Name: atomadic-forge
+Version: 0.19.0
+Summary: Atomadic Forge — absorb, enforce, emerge. Polyglot (Python · JavaScript/TypeScript · Rust · Go · Swift · Kotlin) architecture guardian for AI-generated code.
+Author: Atomadic
+License-Expression: BUSL-1.1
+Keywords: atomadic,ass-ade,monadic,architecture,forge,code-quality,ai,agents,javascript,typescript,polyglot
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click<9,>=8.1
+Requires-Dist: typer<1,>=0.15
+Requires-Dist: rich<16,>=14
+Requires-Dist: pyyaml<7,>=6
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: import-linter<3,>=2.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: build<2,>=1; extra == "dev"
+Requires-Dist: twine<7,>=5; extra == "dev"
+Requires-Dist: tomli>=2; python_version < "3.11" and extra == "dev"
+Requires-Dist: cryptography<48,>=42; extra == "dev"
+Provides-Extra: signing
+Requires-Dist: cryptography<48,>=42; extra == "signing"
+Dynamic: license-file
+
+<p align="center">
+  <img src="assets/Atomadic-Forge-01.png" alt="Atomadic Forge" width="600"/>
+</p>
+
+<h1 align="center">Atomadic Forge</h1>
+
+<p align="center">
+  <strong>Spaghetti is Toast.</strong><br/>
+  The architecture enforcement engine for AI-generated code.
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/atomadic-forge/"><img src="https://img.shields.io/pypi/v/atomadic-forge.svg" alt="PyPI"/></a>
+  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/Python-3.10%2B-blue.svg" alt="Python 3.10+"/></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/License-BSL--1.1-yellow.svg" alt="License: BSL-1.1"/></a>
+  <a href="https://github.com/atomadictech/atomadic-forge/actions/workflows/ci.yml"><img src="https://github.com/atomadictech/atomadic-forge/actions/workflows/ci.yml/badge.svg" alt="CI"/></a>
+  <a href="docs/SHOWCASE.md"><img src="https://img.shields.io/badge/forge_certify-100%2F100-brightgreen" alt="Forge certify"/></a>
+  <a href="https://registry.modelcontextprotocol.io/"><img src="https://img.shields.io/badge/MCP-Official_Registry-blue" alt="MCP Registry"/></a>
+</p>
+
+---
+
+AI agents write code **10x faster** than humans can review it. Pattern violations went from 5% to 60% post-LLM. Your codebase is accumulating architectural debt at machine speed.
+
+**Forge fixes that.**
+
+- **Catches architectural violations AI agents leave behind.** Deterministic tier-law enforcement — no LLM in the loop, no hallucinations.
+- **Saves 40-60% on LLM tokens.** Structured code = smaller context windows = fewer tokens per turn.
+- **One command: spaghetti -> certified architecture.** Python, JavaScript, TypeScript, **Rust, Go, Swift, Kotlin** — full pipeline (recon, wire, certify, scaffold, evolve) on every language.
+- **Bring your own LLM.** Built-in presets for OpenAI, Anthropic, Gemini, OpenRouter, DeepSeek, Groq, Together, Fireworks, xAI, Mistral, Perplexity, Cerebras, Hyperbolic, AAAA-Nexus, and Ollama — plus `forge config provider add` for any custom OpenAI-compatible endpoint.  See [docs/PROVIDERS.md](docs/PROVIDERS.md).
+- **IDE-native.** VS Code extension (`vscode-extension/`), MCP server for Claude Code / Cursor / Cowork / Windsurf, four ready-to-use Claude Code skills.  See [docs/IDE_INTEGRATION.md](docs/IDE_INTEGRATION.md).
+
+---
+
+## Quick Start
+
+```bash
+pip install atomadic-forge        # install
+forge recon .                     # scan any repo (free, read-only)
+forge certify . --print-card      # get your architecture score (0-100)
+```
+
+That's it. No API key, no config, no writes.
+
+---
+
+## What Forge Does
+
+Forge enforces a **5-tier monadic law** — every source file belongs to exactly one tier, tiers compose upward only. AI agents generate code fast; Forge gives it gravity.
+
+```
+  a4_orchestration/    <- CLI, entry points
+         |
+  a3_features/         <- Feature modules
+         |
+  a2_composites/       <- Stateful classes
+         |
+  a1_functions/        <- Pure functions
+         |
+  a0_constants/        <- Constants, enums (zero logic)
+```
+
+**Before Forge:**
+```
+62 import violations · certify score 23/100 · "it works on my machine"
+```
+
+**After `forge auto`:**
+```
+0 violations · certify 100/100 · signed conformance receipt · ship it
+```
+
+---
+
+## CLI Commands
+
+### Core Pipeline
+
+| Command | What it does |
+|---------|-------------|
+| `forge auto` | **Flagship.** scout -> cherry -> assimilate -> wire -> certify -> receipt |
+| `forge recon` | Scan a repo — classify every symbol, show tier distribution |
+| `forge wire` | Detect upward-import violations |
+| `forge certify` | Architecture score (0-100): docs, tests, tier layout, imports |
+| `forge verify` | Composite ship gate: PASS / REFINE / FAIL |
+| `forge enforce` | Apply mechanical fixes (rollback-safe) |
+| `forge status` | Wire + certify in one call |
+| `forge welcome` | First-call handshake — score + guidance in one response |
+
+### Quality & Intelligence
+
+| Command | What it does |
+|---------|-------------|
+| `forge smell` | Code smell scan: cyclomatic complexity, long functions, duplicates |
+| `forge call-graph` | AST call graph for any symbol |
+| `forge cna-check` | Compose-Not-Add — flag duplicates before writing |
+| `forge trust-gate` | LLM response hallucination detector |
+| `forge preflight` | Pre-edit guardrail: tier + import + scope check |
+
+### Composition & Multi-Repo
+
+| Command | What it does |
+|---------|-------------|
+| `forge create` | Intent + seed repos -> new pip-installable package |
+| `forge emergent scan` | Cross-domain composition discovery |
+| `forge recon-swarm` | Walk N repos, unified report |
+| `forge harvest` | Cross-repo capability gap finder |
+
+### Planning & LLM Loops
+
+| Command | What it does |
+|---------|-------------|
+| `forge iterate` | LLM loop: intent -> code -> absorb -> score -> iterate |
+| `forge evolve` | Recursive improvement over N rounds |
+| `forge plan` | Bounded execution plan with risk + rollback |
+| `forge chat` | Terminal copilot over forge docs |
+
+**26+ CLI verbs total.** Full reference: [docs/02-commands.md](docs/02-commands.md)
+
+---
+
+## MCP Server — 66 Tools
+
+Forge ships a Model Context Protocol server. Add it to Cursor, Claude Code, Aider, Devin, or any MCP-compatible agent:
+
+```json
+{
+  "mcpServers": {
+    "atomadic-forge": {
+      "command": "forge",
+      "args": ["mcp", "serve", "--project", "/path/to/your/repo"]
+    }
+  }
+}
+```
+
+**66 tools locally. 40 on the deployed Worker at [forge.atomadic.tech/mcp](https://forge.atomadic.tech/mcp).** Listed in the [MCP Official Registry](https://registry.modelcontextprotocol.io/).
+
+Full tool reference: [docs/MCP_TOOLS.md](docs/MCP_TOOLS.md) | First call: `welcome`
+
+---
+
+## By the Numbers
+
+| Metric | Value |
+|--------|-------|
+| Tests | **1,291 passing** |
+| MCP tools | **66** |
+| Source files | **193** |
+| CLI verbs | **26+** |
+| Lean4 formal proofs | **624** (mathematically verified core logic) |
+| Languages | Python, JS/TS, Swift, Kotlin, Go |
+| Infrastructure cost | **$5/mo** |
+| Self-score | **100/100** certify, 0 wire violations |
+| License | BSL 1.1 (Apache 2.0 after 2030-04-27) |
+
+Forge eats its own cooking. Every CI run scores itself.
+
+---
+
+## Pricing
+
+| Tier | Price | What you get |
+|------|-------|-------------|
+| **Free** | $0 | OSS, 25 calls/day, read-only tools |
+| **One-Time Refactor** | ~~$149~~ **$99** | We run `auto` on your repo -> PR targeting 100/100. One revision included. |
+| **Starter** | $79/mo | All 66 tools, 5k calls/mo, signed receipts, custom recipes |
+| **Pro** | $249/mo | + notarization, compliance attestations, cross-repo telemetry |
+| **Founding Member** | $999/yr | Everything. Forever. First 25 only. |
+| **Enterprise** | Custom | BSL commercial license, SSO, self-host, SLA |
+
+> **Launch special:** The one-time refactor is **$99** (normally $149). See what Forge does to your codebase before committing to a subscription.
+
+[Get started ->](https://forge.atomadic.tech/pricing)
+
+---
+
+## Docs
+
+| | |
+|---|---|
+| [First 10 Minutes](docs/FIRST_10_MINUTES.md) | Install, demo, first scan |
+| [Tutorials](docs/tutorials/) | Quickstart, 5-tier law, LLM integration |
+| [Architecture](ARCHITECTURE.md) | How Forge itself is built |
+| [CI/CD Integration](docs/CI_CD.md) | GitHub Actions, GitLab CI, pre-commit |
+| [Showcase](docs/SHOWCASE.md) | Live run trajectories |
+| [Changelog](CHANGELOG.md) | Version history |
+| [Contributing](CONTRIBUTING.md) | How to extend Forge |
+| [Security](SECURITY.md) | Vulnerability reporting |
+
+---
+
+## License
+
+[Business Source License 1.1](LICENSE). Free for non-production use. Commercial license for production — see [COMMERCIAL_LICENSE.md](COMMERCIAL_LICENSE.md). Change Date: 2030-04-27 -> Apache 2.0.
+
+---
+
+<p align="center">
+  <a href="https://forge.atomadic.tech">forge.atomadic.tech</a> — paste any GitHub repo, watch the analysis in real time.
+  <br/><br/>
+  <a href="https://invest.atomadic.tech">Interested in investing?</a>
+</p>