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

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

@@ -2,6 +2,108 @@
 
 ## Unreleased
 
+## 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:
+running ``forge welcome`` (or the welcome MCP tool) from a workspace
+root walks every source file in every subdirectory.  In the rehearsal
+that meant 38 972 .py files instead of the 280 inside atomadic-forge,
+and the call appeared to "hang."  This release stops that at the
+substrate.
+
+- **welcome scope guard** — ``forge welcome`` now refuses to walk a
+  project root that holds more than ``--max-files`` (default 5 000)
+  source files, returning a structured ``verdict: REFUSE`` with the
+  observed file count and a clear "pass --project-root <narrower>
+  or --force" message.  CLI exits 2; MCP returns the same shape.
+  Counted via an ``itertools.islice`` over ``iter_source_files``,
+  so the guard itself bails in milliseconds.
+- **--force / --max-files** flags on ``forge welcome`` for the rare
+  case where a 5 000+ file repo is the right scope.
+- **PyPI install hygiene note** — the v0.16.x rehearsal also surfaced
+  that interrupted ``pip install --upgrade`` runs on Windows leave
+  ``~tomadic_forge*`` shadow distribution directories in
+  ``site-packages`` which can mask the active editable install on
+  long-running MCP processes.  Standard pip recovery is
+  ``pip install --upgrade --force-reinstall atomadic-forge`` (then
+  delete any remaining ``~*`` dirs).  Documented in
+  ``docs/troubleshooting/pip-shadow-dirs.md``.
+
+## v0.16.1 — 2026-05-06 six new CLI verbs (verify, smell, call-graph, cna-check, trust-gate, commit-compose)
+
+Six MCP-only tools that had no corresponding CLI verb are now reachable
+from the shell.  No behavioural changes to existing verbs.
+
+- **forge verify** — composite wire + certify gate; single PASS / REFINE / FAIL
+  verdict + non-zero exit code for CI steps.  Wraps the `verify` MCP tool.
+- **forge smell** — cyclomatic-complexity + long-function + duplicate-code scan;
+  emits a `smell_score` (0–100) and a ranked offender list.  Wraps `smell_scan`.
+- **forge call-graph** — AST call-graph for one symbol; shows callers and callees
+  up to `--max-depth` with optional `--direction` filter.  Wraps `call_graph`.
+- **forge cna-check** — Compose-Not-Add guard; fails with exit 1 when a proposed
+  symbol name is semantically equivalent to an existing one.  Wraps `cna_check`.
+- **forge trust-gate** — LLM response hallucination detector; reads a response from
+  a file or stdin, scores it against known capabilities, exits 1 when
+  `safe_to_act` is False.  Wraps `trust_gate_response`.
+- **forge commit-compose** — structured commit-message assembler; writes a
+  Forge-signed subject + body + optional Co-Authored-By trailer to stdout.
+  Wraps `commit_compose`.
+
+## v0.16.0 — 2026-05-06 dress-rehearsal hardening (six bugfixes, 11 new tests)
+
+Live stress-test on real third-party Python repos (atomadic-forge,
+langgraph, crewai) ahead of the Boris demo surfaced six bugs across
+the synthesis, planning, summary, and pipeline-pipe surfaces. All
+fixed, all guarded by regression tests.  No behavioural change for
+clean paths.
+
+- **emergent synthesize**: ``_imports_for`` was emitting
+  ``from pkg.mod.Class import method`` for class-method qualnames
+  (legacy ``"." in name`` guard never fired post-rpartition). The
+  generated package pip-installed but failed at module load.  Now
+  detects method qualnames by the module's last segment being
+  CapitalCase. Single-seed ``forge create`` jumped from 60/FAIL to
+  90/100 with importable code. +2 tests.
+- **forge plan**: ``_operational_cards`` emitted literal
+  ``printf 'import your_pkg\n'`` placeholders that users would copy
+  verbatim and create broken tests. New ``_infer_pkg_label`` derives
+  from ``certify_report['project']`` or the project-root basename
+  (hyphen→underscore sanitisation), with the ``"your_pkg"`` literal
+  only as a last-resort fallback. +5 tests.
+- **forge score-patch / adapt-plan**: ``--file -`` (the conventional
+  stdin sentinel) crashed with raw FileNotFoundError because the helper
+  tried to open a file literally named ``-``. Now falls through to
+  stdin when ``str(file) == "-"``; help text mentions the sentinel.
+- **forge sbom** text summary: read ``components`` off the wrapper
+  instead of the nested CycloneDX payload, so every report showed
+  ``components: 0`` regardless of pyproject contents. Now dereferences
+  ``sbom['sbom']['components']``. Forge's own report goes 0 → 11.
+  +1 test.
+- **forge recon-swarm / emergent-swarm / guard-install**: registered
+  with literal underscores while ``commandsmith discover`` normalised
+  module stems to hyphens, so ``commandsmith smoke`` reported these
+  three verbs as FAIL. Both hyphen and underscore forms now registered
+  as aliases; smoke is 100% green. +3 tests.
+- **forge synergy-then-emergent / emergent-then-synergy**: auto-
+  synthesised pipes invoked ``synergy --json-out FILE`` and
+  ``emergent --json-out FILE`` against verbs that take ``--save FILE``
+  and require an explicit ``scan`` subcommand. Both pipes now run
+  end-to-end and emit producer-payload-keys summaries.
+
+### Stress-test evidence captured at C:\!!AtomadicStandard\Demo-Rehearsal\
+
+- ``forge welcome`` on three Python repos: 2635 / 1854 / 7592 symbols.
+- ``forge emergent_swarm`` across forge+langgraph+crewai: 16 cross-repo
+  novel compositions, 25 candidates, 2767 union catalog.
+- ``forge create`` (forge+crewai → agent_toolkit): 18 cross-repo chains,
+  5 materialised, certify=60. Single-seed forge: certify=90.
+- ``forge auto`` (langgraph → tier-organised package, --apply): 1854
+  symbols absorbed, wire PASS, 226s end-to-end.
+- ``forge commandsmith smoke``: 26 discovered + 23 core verbs, all PASS.
+- ``forge synergy scan``: 72 features, 20 adapter candidates.
+- Final test suite: 1302 passed, 0 failed, 2 skipped (was 1291 → +11).
+- Self-certify: 100/100, wire PASS.
+
 ## v0.15.0 — 2026-05-06 forge create / forge materialize
 
 Closes the loop from emergent composition discovery to a real,

{atomadic_forge-0.15.0 → atomadic_forge-0.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.15.0
+Version: 0.16.2
 Summary: Atomadic Forge — absorb, enforce, emerge. Polyglot (Python · JavaScript/TypeScript · Swift · Kotlin · Go) architecture guardian for AI-generated code.
 Author: Atomadic
 License-Expression: BUSL-1.1
@@ -72,8 +72,20 @@ stays in the loop.
 | **Composite go/no-go ship gate** | ❌ | ✅ verify (PASS / REFINE / FAIL + next_command) |
 | **Signed conformance proof** | ❌ | ✅ Receipt v1 |
 
-### What just shipped (v0.14.0a10)
+### What just shipped (v0.16.0)
 
+- ** hardening — six bugfixes, eleven new tests** (v0.16.0) — live stress-test on three real Python repos (atomadic-forge, langgraph, crewai) ahead of the Boris demo surfaced six bugs across the synthesis, planning, summary, and pipeline-pipe surfaces. `emergent synthesize` no longer emits broken `from pkg.mod.Class import method`; `forge plan` no longer suggests a literal `your_pkg` placeholder; `forge score-patch --file -` honours the stdin sentinel; `forge sbom` text summary reports the real component count; `recon-swarm/emergent-swarm/guard-install` register both hyphen and underscore forms so `commandsmith smoke` is 100% green; `synergy-then-emergent` and `emergent-then-synergy` pipes use the real `--save FILE` flag. Single-seed `forge create` jumped from certify=60/FAIL to **certify=90/100** with importable code on first generation. Test suite 1,291 → 1,302 passed.
+
+### What previously shipped (v0.15.0)
+
+> **From spaghetti to shippable in one command.** `forge create` takes
+> an intent and a list of seed repos and returns a pip-installable
+> Python package: it scans, finds emergent compositions, materializes
+> the top candidates, runs wire + certify, and writes the receipt.
+> Deterministic, no LLM, no network. **`pip install atomadic-forge`** to try it.
+
+- **`forge create` — intent + seed repos → shippable Python package** (v0.15.0) — one-command pipeline composing existing primitives. Resolves each seed (auto-detects `src/<pkg>/` layout, tier-bearing dir, or single-package roots), runs `emergent_swarm` across the union, persists scan + receipt to `.atomadic-forge/`, then pipes top-N candidates through `materialize` for the final package. Strictly local paths — no GitHub cloning, no third-party absorption. End-to-end smoke on Forge itself: 570-symbol union catalog → 25 candidates → 17-file package, **wire_violations=0**.
+- **`forge materialize` — emergent scan report → shippable package** (v0.15.0) — turns an emergent scan JSON into a tier-organized scaffold (a0..a4 with `__init__.py`), `pyproject.toml`, `README.md`, `.gitignore`, `tests/conftest.py`, plus one a3 feature module + smoke test per selected candidate. Slug uniqueness via candidate-id tail so name collisions don't overwrite. Optional wire-check + certify pass with the verdict embedded in the report. Refuses to overwrite a non-empty unrelated directory.
 - **`forge hive recap` — full lifecycle replay of one consensus** (v0.14.0a10) — new CLI verb + MCP tool (`hive_recap`, surface 60 → **61**). Returns proposer, `proposed_at`, intent, every vote (with rationale + timestamp), the resolution event if any, and a summary block (verdict, duration, voters). The "what happened on this consensus?" primitive — useful for audit trails, release-note quotes, post-mortem replay.
 - **`forge hive needs-vote` — "what should I weigh in on?"** (v0.14.0a9) — new CLI verb + MCP tool (`hive_needs_vote`, surface 59 → **60**) returning open consensuses where the calling agent hasn't voted yet, ordered by `proposed_at`, with `votes_so_far` + `voters_so_far` context. Closes the gap between `hive_observe` (everything happening) and the act of voting. Doc agent used it immediately after release to discover its own proposal needed proposer-vote attention.
 - **`docs/WORLD_COLLISION.md`** (v0.14.0a8) — the 11-step E2E walkthrough of *Atomadic-uses-Forge*. Six of the eleven steps have already fired this sprint with public-artifact evidence (`wisdom.jsonl` + `hive/consensus.jsonl`). Forge agent authored.
@@ -188,9 +200,10 @@ Recon: ./my-cloudflare-worker
 ## Pipeline lanes
 
 ```bash
-forge auto ./messy-repo ./out --apply       # Absorb a flat repo into 5-tier layout
-forge evolve run "<intent>" ./out --auto 5  # LLM-driven recursive generation
-forge demo run --preset NAME                # Click-to-launch-video preset
+forge create -i "<intent>" -s ./repo -o ./out --package my_pkg  # NEW: emergent → pip-installable, deterministic
+forge auto ./messy-repo ./out --apply                            # Absorb a flat repo into 5-tier layout
+forge evolve run "<intent>" ./out --auto 5                       # LLM-driven recursive generation
+forge demo run --preset NAME                                     # Click-to-launch-video preset
 forge chat ask "what should I fix next?" --context .
 ```
 
@@ -270,10 +283,43 @@ Each tier is a layer of **verified building blocks**. Higher tiers never invent
 
 ```bash
 pip install atomadic-forge
-forge --version   # atomadic-forge 0.14.0
+forge --version   # atomadic-forge 0.15.0
 forge doctor      # environment check
 ```
 
+### 60-second quickstart (v0.15.0)
+
+From a fresh `pip install`, take any tier-organized repo and produce a
+new pip-installable package containing emergent compositions:
+
+```bash
+# 1. Discover and ship in one call
+forge create \
+    --intent "logging-aware retry layer" \
+    --seed-repo /path/to/your/repo \
+    --out-dir   ./out/retry_layer \
+    --package   retry_layer \
+    --top-n 5
+
+# Output:
+#   union catalog:      <symbols-scanned>
+#   candidates:         <novel-compositions-found>
+#   files written:      <scaffold + features + tests>
+#   wire violations:    0
+#   certify:            <score>  (PASS / REFINE / FAIL)
+#
+# Receipt: ./out/retry_layer/.atomadic-forge/create.json
+# Scan:    ./out/retry_layer/.atomadic-forge/scan.json
+```
+
+Need finer control? The same pipeline is two steps:
+
+```bash
+forge emergent scan --top-n 25 --save scan.json    # discovery
+forge materialize run scan.json ./out/retry_layer \\
+    --package retry_layer --top-n 5                # ship
+```
+
 Then follow [docs/FIRST_10_MINUTES.md](docs/FIRST_10_MINUTES.md) for
 the canonical first-run path (offline demo, free recon, then absorb or
 generate).
@@ -283,7 +329,7 @@ generate).
 ```bash
 git clone https://github.com/atomadictech/atomadic-forge && cd atomadic-forge
 pip install -e ".[dev]"
-python -m pytest               # 1179 collected (1177 passed, 2 skipped)
+python -m pytest               # 1293 collected (1291 passed, 2 skipped)
 ```
 
 ## AI Agent integration (MCP)
@@ -301,7 +347,7 @@ Forge ships a **Model Context Protocol server** — add it to Cursor, Claude Cod
 }
 ```
 
-### All 63 MCP tools (local) · 40 on the deployed Worker
+### All 66 MCP tools (local) · 40 on the deployed Worker
 
 > **Recommended first call: `welcome`** — runs scout + certify + wire on the
 > current repo and returns a structured situation report (score, top
@@ -528,7 +574,7 @@ Forge waits before returning a clear provider error.
 
 | Command | Purpose |
 |---------|---------|
-| `forge mcp serve` | Stdio JSON-RPC MCP server — 63 tools for Cursor / Claude Code / Aider / Devin. |
+| `forge mcp serve` | Stdio JSON-RPC MCP server — 66 tools for Cursor / Claude Code / Aider / Devin. |
 | `forge plan / plan-list / plan-show / plan-step / plan-apply` | Agent plan persistence and step-by-step apply. |
 | `forge iterate` | LLM loop: intent → code → absorb → wire → score → iterate. Single shot. |
 | `forge evolve` | Recursive improvement: N rounds, catalog grows each round. |
@@ -542,26 +588,96 @@ Forge waits before returning a clear provider error.
 
 | Command | Purpose |
 |---------|---------|
-| `forge emergent` | Symbol-level composition discovery. |
+| `forge emergent scan` | Symbol-level composition discovery — find type-safe chains across modules. |
+| **`forge materialize`** *(v0.15.0+)* | Turn an emergent scan report into a real, pip-installable Python package with proper tier layout. |
+| **`forge create`** *(v0.15.0+)* | One-command pipeline: intent + seed repos → scan → materialize → certify. |
 | `forge synergy` | Feature-pair detection + auto-generate adapters. |
+| `forge harvest` | Cross-repo capability gap finder, τ_TRUST gated. |
+| `forge recon-swarm` / `forge emergent-swarm` | Multi-repo recon + cross-repo composition discovery. |
 | `forge commandsmith` | Auto-register CLI commands, regenerate `_registry.py`, smoke-test all verbs. |
 | `forge lsp serve` | Stdio LSP server for `.forge` files (live diagnostics, hover, goto). |
 
 ## Targeted workflows
 
+Forge ships several distinct lanes — pick the one that fits your intent.
+
+### Lane 1 — Orient and certify an existing repo *(read-only)*
+
+```bash
+forge welcome                # one-shot: scout + certify + wire + agent guidance
+forge recon .                # tier distribution, effect distribution, recommendations
+forge certify .              # 4-axis score (docs / tests / layout / wire)
+forge status .               # one-line wire + certify summary
+forge explain-repo           # JSON orientation packet (one-liner / do_not_break / release_state)
+forge context-pack           # bounded LLM-ready repo briefing
+```
+
+### Lane 2 — Absorb a third-party repo into a tier-clean Atomadic package
+
 ```bash
-# Targeted: just see what's in a repo
-forge recon ./repo
+# Dry-run first — see what would happen
+forge auto ./external-repo ./absorbed --package external_pick
 
-# Targeted: pick specific symbols
-forge cherry ./repo --pick infer_tier --pick CherryPicker
+# Then commit
+forge auto ./external-repo ./absorbed --package external_pick --apply
+# 1854 symbols absorbed · wire PASS · proper a0..a4 layout
+```
+
+### Lane 3 — *(v0.15.0+)* Build something new from emergent compositions
+
+```bash
+# Single-repo: discover compositions in your own catalog
+forge emergent scan --src-root src --package myapp --save scan.json
+forge materialize run --report scan.json --out-dir ./toolkit \
+                      --package toolkit --top-n 5
+
+# Cross-repo: synthesize a brand-new package from N seeds
+forge create -i "agent toolkit from forge + crewai" \
+             -s ./atomadic-forge \
+             -s ./crewai/lib/crewai \
+             --out-dir ./agent_toolkit \
+             --package agent_toolkit --top-n 5
+# 18 cross-repo chains · 5 picks · 21 files · wire PASS · certify 60→90
+```
+
+### Lane 4 — LLM-driven generation under the architectural backbone
+
+```bash
+forge iterate run --intent "..." --out ./out         # one shot: intent → code → score → iterate
+forge evolve   run "..." ./out --auto 3              # recursive improvement, N rounds
+forge demo     run --preset calc                     # canned 50s autonomous build
+forge chat                                           # terminal copilot over forge docs/source
+```
 
-# Targeted: merge two repos with conflict resolution
+### Lane 5 — Cross-repo discovery and composition
+
+```bash
+forge recon-swarm     -r ./repo-a -r ./repo-b -r ./repo-c
+forge emergent-swarm  -r ./repo-a -r ./repo-b -r ./repo-c
+forge harvest         -t ./target -s ./source-a -s ./source-b
+```
+
+### Lane 6 — Targeted spot-fixes
+
+```bash
+forge recon ./repo                                        # see what's in a repo
+forge cherry ./repo --pick infer_tier --pick CherryPicker # pick specific symbols
 forge cherry ./repo-a --pick all
-forge finalize ./repo-a ./out --apply --on-conflict rename
+forge finalize ./repo-a ./out --apply --on-conflict rename # merge two repos
+forge enforce ./out/src/package --apply                    # mechanical fixes (rollback-safe)
+```
 
-# Specialty: surface compositions across your own catalog
-forge emergent scan
+### Lane 7 — Coordination, lineage, governance
+
+```bash
+forge handoff create --agent X --work "..." --pytest-summary "..."
+forge wisdom record --insight "..." --tags "..."
+forge wisdom query --text "certify"
+forge audit list                                # browse .atomadic-forge/lineage.jsonl
+forge enhancement propose -t "..." -d "..."
+forge surface emit --out surface.json           # canonical tool surface for drift CI
+forge sbom .                                    # CycloneDX 1.5 SBOM
+forge cs1                                       # EU AI Act / SR 11-7 / FDA PCCP / CMMC-AI conformity
 ```
 
 ## Known limits (honest & concrete)
@@ -590,7 +706,7 @@ Forge ships with named limits. No overpromise.
 
 - **Dry-run by default.** No verb writes to disk without `--apply` or equivalent. Only `.atomadic-forge/` manifests (diagnostic reports) are written in dry-run mode.
 
-- **The 5-tier law is non-negotiable.** Anything that ships with Forge passes its own `wire` scan. Forge's 53 source files live in a0–a4; it eats its own dogfood.
+- **The 5-tier law is non-negotiable.** Anything that ships with Forge passes its own `wire` scan. Forge's 193 source files live in a0–a4; it eats its own dogfood.
 
 - **Honest output.** Every report includes `schema_version`. Every apply emits `STATUS.md` (required follow-up). Every artifact is provable and traced (lineage recorded in `.atomadic-forge/lineage.jsonl`).
 
@@ -601,7 +717,7 @@ Forge ships with named limits. No overpromise.
 | Product | What it is | Status |
 |---------|------------|--------|
 | **AAAA-Nexus** | Trust/safety/payments substrate for autonomous agents | Live at [atomadic.tech](https://atomadic.tech) |
-| **Atomadic Forge** | Absorb-and-emerge engine for developers (this repo) | **v0.14.0** — on PyPI, 1177 tests, 100/100, MCP server (63 tools local · 40 on Worker), four-agent hive primitives, AAAA-Nexus bridge, agent-to-agent handoffs |
+| **Atomadic Forge** | Absorb-and-emerge engine for developers (this repo) | **v0.15.0** — on PyPI, 1291 tests, 100/100, MCP server (66 tools local · 40 on Worker), `forge create` / `forge materialize` shippable-package pipeline, four-agent hive primitives, AAAA-Nexus bridge, agent-to-agent handoffs |
 | **Atomadic Assistant** | Sovereign AI assistant with cognitive loop on Cloudflare | In development |
 
 ## Pricing
@@ -609,17 +725,15 @@ Forge ships with named limits. No overpromise.
 Free for OSS / non-commercial. Paid hosted MCP at `forge.atomadic.tech/mcp` for
 production agents.
 
-| Tier | Monthly | What you get |
+| Tier | Price | What you get |
 |---|---|---|
 | **Free** | $0 | OSS, 25 calls/day, read-only tools |
-| **Basic** | $19 | All 22 tools, 5k calls/mo, signed receipts |
-| **Dev** | $39 | + custom recipes, 25k calls/mo, priority queue |
-| **Pro** | $99/user | + compliance attestations, AAAA-Nexus notarization, cross-repo telemetry |
-| **Enterprise** | from $2.5k | BSL commercial license, SSO, self-host, SLA |
+| **Pro** | $79/mo | All 66 tools, 5k calls/mo, signed receipts, custom recipes |
+| **Studio** | $249/mo | + AAAA-Nexus notarization, compliance attestations, cross-repo telemetry, priority queue |
+| **Lifetime Founder** | $999 once | One key. Forever. Forge Pro + Forge Deluxe (when launched) + AAAA-Nexus + every future Atomadic product. **First 25 only.** |
+| **Enterprise** | custom | BSL commercial license, SSO, self-host, SLA |
 
-**👑 Atomadic Lifetime Founder — $999 — first 25 only.** One key. Forever. Lifetime
-Forge Standard Pro + Forge Deluxe (when launched) + AAAA-Nexus + every future
-Atomadic product. See [forge.atomadic.tech/pricing](https://forge.atomadic.tech/pricing).
+See [forge.atomadic.tech/pricing](https://forge.atomadic.tech/pricing) for the live tier matrix.
 
 Pay-per-call (x402) and prepaid call packs ($25 / $100 / $500 / $2,500) are also
 available on the hosted MCP.
@@ -636,7 +750,7 @@ Apache 2.0.
 - **[Showcase](docs/SHOWCASE.md)** — Live runs with live results (start here)
 - **[Landscape](docs/LANDSCAPE.md)** — How Forge sits next to Cursor / Devin / Lovable / Copilot Workspace
 - **[Why now](docs/WHY_NOW.md)** — The urgency case for an architecture substrate
-- **[Commands](docs/COMMANDS.md)** — Full reference for all 13+ verbs
+- **[Commands](docs/COMMANDS.md)** — Full reference for all 26+ verbs
 - **[Release checklist](docs/RELEASE_CHECKLIST.md)** — Shippability gates, CLI scenarios, local-model smoke checks
 - **[Roadmap](docs/ROADMAP.md)** — 0.2 / 0.3 / 1.0 milestones
 - **[Architecture guide](ARCHITECTURE.md)** — How Forge itself is built (monadic tiers, data flows, design)
@@ -650,12 +764,12 @@ Apache 2.0.
 **Forge itself is monadic.** Every source file belongs to one tier. The repo is a worked example:
 
 ```bash
-python -m pytest                     # 1177 passed, 2 skipped
+python -m pytest                     # 1291 passed, 2 skipped
 forge doctor                         # Environment check
 forge wire src/atomadic_forge        # Scan for violations (PASS)
 forge certify . --fail-under 100     # Score and gate the repo (100/100)
 forge status .                       # Quick health snapshot
-forge commandsmith smoke             # Smoke-test all 63 registered verbs
+forge commandsmith smoke             # Smoke-test all registered verbs
 ```
 
 **Before submitting a PR:**
@@ -668,11 +782,13 @@ forge commandsmith smoke             # Smoke-test all 63 registered verbs
 
 **Production-ready for architecture enforcement. Working, honest, self-eating.**
 
-- ✓ **1176 tests** passing, 2 skipped
+- ✓ **1291 tests** passing, 2 skipped
+- ✓ **0 ruff errors** — full lint sweep landed in v0.15.0
 - ✓ **100/100 certify** — forge scores itself on every CI run
 - ✓ **0 wire violations** — forge passes its own import-law scan
-- ✓ **On PyPI** — `pip install atomadic-forge` (latest: v0.14.0)
-- ✓ **MCP server** — 63-tool surface (40 on the deployed Worker at `forge.atomadic.tech/mcp`, 63 in the local CLI / pip install); works with Cursor, Claude Code, Aider, Devin
+- ✓ **On PyPI** — `pip install atomadic-forge` (latest: v0.15.0)
+- ✓ **`forge create` / `forge materialize`** — intent + seed repos → pip-installable package, deterministic, no LLM. From spaghetti to shippable in one command.
+- ✓ **MCP server** — 66-tool surface (40 on the deployed Worker at `forge.atomadic.tech/mcp`, 66 in the local CLI / pip install); works with Cursor, Claude Code, Aider, Devin
 - ✓ **Hive primitives** — `hive_register / observe / propose / vote / result / list / deactivate / watch / needs-vote / recap` for multi-agent consensus over append-only public artifacts
 - ✓ **AAAA-Nexus bridge** — 7 LIVE primitives wired as MCP tools (`nexus_identity_verify`, `nexus_federation_mint`, `nexus_authorize_action`, `nexus_sys_trust_gate`, `nexus_contract_verify`, `nexus_lineage_record`, `nexus_ratchet_register`); wisdom + consensus auto-mirror at confidence ≥ 0.85
 - ✓ **Multi-agent safeguards** — `cost_circuit_breaker`, `dedup_engine`, `agent_hire_protocol`, `hierarchical_memory` (MemGPT 4-tier)