atomadic-forge 0.51.6__tar.gz → 0.52.0__tar.gz

{atomadic_forge-0.51.6 → atomadic_forge-0.52.0}/.github/workflows/mcp-registry-publish.yml

@@ -116,14 +116,18 @@ jobs:
         run: |
           set -euo pipefail
           v="${{ steps.ver.outputs.version }}"
-          # Allow up to ~30s for the registry to propagate.
+          # Allow up to ~30s for the registry to propagate. The search
+          # endpoint returns ALL published versions; pick the one
+          # marked isLatest. (Earlier versions: we naively read [0]
+          # which returned a non-latest result.)
           for i in 1 2 3 4 5 6; do
             sleep 5
             got=$(curl -fsS "https://registry.modelcontextprotocol.io/v0/servers?search=atomadic-forge" \
-                   | jq -r '.servers[0].server.version' || echo "")
-            echo "registry reports version: $got (want $v)"
+                   | jq -r '.servers[] | select(._meta."io.modelcontextprotocol.registry/official".isLatest == true) | .server.version' \
+                   || echo "")
+            echo "registry reports latest version: $got (want $v)"
             if [ "$got" = "$v" ]; then
-              echo "PASS: registry shows v$v"
+              echo "PASS: registry shows v$v as isLatest"
               exit 0
             fi
           done

{atomadic_forge-0.51.6 → atomadic_forge-0.52.0}/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## Unreleased
 
+### feat(emergent-swarm): hub-node penalty in `emergent_swarm` scoring
+
+Symbols that appear in more than 3 chains are now penalised in
+`score_boosted`. For each doubling of cross-chain frequency above the
+threshold, 10 points are deducted from `score_boosted` (floor at 0).
+This prevents a single high-connectivity connector symbol from occupying
+all top-N emergent candidates; genuinely novel cross-repo chains surface
+instead. Affected candidates gain two new output fields:
+`hub_penalty` and `hub_max_symbol_freq`.
+
+### fix(forge_metrics): theorem count now reads from build attestation
+
+`forge_metrics.py` now reads `dist/BUILD_ATTESTATION_*.json` when the
+file exists, using the machine-verified Lean4 count as the canonical
+source rather than a raw file scan. Count corrected: 886 → 872.
+`forge_metrics.json` updated accordingly with `"basis": "build_attestation"`.
+
+### feat(absorb): new `forge absorb` command and supporting a1/a3 modules
+
+`harvest_absorb.py` (a1) — pure helpers for absorbing external Python
+repos: layout detection, package resolution, fingerprinting.
+`absorb_feature.py` (a3) — feature composing `harvest_absorb` and
+`emergent_swarm` for cross-repo composition.
+`commands/absorb.py` — CLI command exposing the absorb feature.
+
+### fix(mcp_protocol): remove duplicate dict-key lint violations
+
+Removed two pre-existing duplicate dict-key entries from `mcp_protocol.py`.
+
 ## v0.51.6 — 2026-05-07 — sequential cascade: registry fires AFTER PyPI lands
 
 v0.51.5 fired release.yml + mcp-registry-publish.yml in parallel. The

{atomadic_forge-0.51.6/src/atomadic_forge.egg-info → atomadic_forge-0.52.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.51.6
+Version: 0.52.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
@@ -206,9 +206,9 @@ Full tool reference: [docs/MCP_TOOLS.md](docs/MCP_TOOLS.md) | First call: `welco
 |--------|-------|
 | MCP tools | **10 tools · 64 actions** |
 | CLI verbs | **71** |
-| Source files | **211** (~40,145 LOC) |
-| Tests | **1,493 passing** across **96 test files** (1,409 static · pytest expands parametrize to 1,495 collected) |
-| Lean4 formal proofs | **886 theorems** across 38 files (mathematically verified core logic — IP-protected mhed-codex moat) |
+| Source files | **211** (~40,195 LOC) |
+| Tests | **1,495 passing** across **97 test files** (1,411 static · pytest expands parametrize to 1,495 collected) |
+| Lean4 formal proofs | **872 theorems** across 30 files (mathematically verified core logic — IP-protected mhed-codex moat) |
 | Monadic tiers | **5** (a0 → a4, strict upward-only composition) |
 | Languages | Python, JS/TS, Swift, Kotlin, Go, Rust |
 | Infrastructure cost | **$5/mo** |

{atomadic_forge-0.51.6 → atomadic_forge-0.52.0}/README.md

@@ -174,9 +174,9 @@ Full tool reference: [docs/MCP_TOOLS.md](docs/MCP_TOOLS.md) | First call: `welco
 |--------|-------|
 | MCP tools | **10 tools · 64 actions** |
 | CLI verbs | **71** |
-| Source files | **211** (~40,145 LOC) |
-| Tests | **1,493 passing** across **96 test files** (1,409 static · pytest expands parametrize to 1,495 collected) |
-| Lean4 formal proofs | **886 theorems** across 38 files (mathematically verified core logic — IP-protected mhed-codex moat) |
+| Source files | **211** (~40,195 LOC) |
+| Tests | **1,495 passing** across **97 test files** (1,411 static · pytest expands parametrize to 1,495 collected) |
+| Lean4 formal proofs | **872 theorems** across 30 files (mathematically verified core logic — IP-protected mhed-codex moat) |
 | Monadic tiers | **5** (a0 → a4, strict upward-only composition) |
 | Languages | Python, JS/TS, Swift, Kotlin, Go, Rust |
 | Infrastructure cost | **$5/mo** |

atomadic_forge-0.52.0/docs/commands/INDEX.md

@@ -0,0 +1,34 @@
+# ASS-ADE Commands
+
+Auto-generated index. One row per top-level CLI verb.
+
+| Verb | Help | Source | Surface |
+|------|------|--------|---------|
+| `absorb` | Absorb any Python repo (crewAI, langgraph, autogen, babyagi, …) into a tier-organized Atomadic package. | `atomadic_forge_seed` | `typer_app` |
+| `audit` | Surface the .atomadic-forge lineage log: list runs, inspect saved manifests, replay history. | `atomadic_forge_seed` | `typer_app` |
+| `chat` | Chat with a Forge-aware AI copilot over optional repo context. | `atomadic_forge_seed` | `typer_app` |
+| `commandsmith` | ``atomadic-forge commandsmith`` — manage the auto-wired CLI command registry. | `atomadic_forge_seed` | `typer_app` |
+| `config` | Configure Atomadic Forge — setup wizard + config management. | `atomadic_forge_seed` | `typer_app` |
+| `create` | One-command pipeline: scan local seed repos for emergent compositions and materialize the top-N into a shippable package. | `atomadic_forge_seed` | `typer_app` |
+| `demo` | One-shot launch-video verb: preset evolve + DEMO.md artifact. | `atomadic_forge_seed` | `typer_app` |
+| `emergent` | Synthesise new feature candidates from existing components. | `atomadic_forge_seed` | `typer_app` |
+| `emergent-swarm` | Round-5: cross-repo emergent composition discovery. Find chains visible only across the union of N repos. | `atomadic_forge_seed` | `typer_app` |
+| `emergent-then-synergy` | Run emergent to emit a JSON artifact, then feed it to synergy for the next phase. | `atomadic_forge_seed` | `typer_app` |
+| `enhancement` | Submit / list / show / publish Forge enhancement proposals — the self-improvement loop. Trust-gated at submission, human-gated at publish. | `atomadic_forge_seed` | `typer_app` |
+| `evolve` | Recursive self-improvement: run iterate N times, each round seeded by the previous round's growing catalog. | `atomadic_forge_seed` | `typer_app` |
+| `evolve-then-iterate` | Run evolve to emit a JSON artifact, then feed it to iterate for the next phase. | `atomadic_forge_seed` | `typer_app` |
+| `feature-then-emergent` | Run any feature, then fan its JSON output into emergent scan to surface novel compositions. | `atomadic_forge_seed` | `typer_app` |
+| `guard-install` | Round-5: install the four-layer architectural guard (pre-commit, CI workflow, CONTRIBUTING note, .forge-guard.json). | `atomadic_forge_seed` | `typer_app` |
+| `handoff` | Capture a structured session handoff so the next agent can pick up where this one left off. Writes JSON to .atomadic-forge/handoffs/<session_id>.json. | `atomadic_forge_seed` | `typer_app` |
+| `harvest` | Round-4: find symbols the target lacks but source repos have. Trust-gated by trust threshold. | `atomadic_forge_seed` | `typer_app` |
+| `hive` | Hive sync pipeline — agent registry + observation + consensus. The 4-agent collaboration substrate. | `atomadic_forge_seed` | `typer_app` |
+| `iterate` | Architecturally-coherent code generation: LLM emits, Forge enforces, loop iterates until certify clears. | `atomadic_forge_seed` | `typer_app` |
+| `materialize` | Turn emergent scan candidates into a shippable Python package (scaffold + features + certify). | `atomadic_forge_seed` | `typer_app` |
+| `metrics` | Emit forge_metrics.json — canonical metrics for README/CHANGELOG/welcome/worker. | `atomadic_forge_seed` | `typer_app` |
+| `recon-swarm` | Round-4: walk N repos, return a unified scout report with origin_repo annotations on every symbol. | `atomadic_forge_seed` | `typer_app` |
+| `relay` | Local relay daemon — receive signed job requests from the Worker MCP and dispatch them through the local CLI. v0.14.0-alpha. | `atomadic_forge_seed` | `typer_app` |
+| `surface` | Emit / check / diff the canonical Forge surface artifact (single source of truth for tools, recipes, schemas). | `atomadic_forge_seed` | `typer_app` |
+| `synergy` | Find feature/CLI synergies (producer-consumer pairs that aren't wired together) and optionally implement adapters. | `atomadic_forge_seed` | `typer_app` |
+| `synergy-then-emergent` | Run synergy to emit a JSON artifact, then feed it to emergent for the next phase. | `atomadic_forge_seed` | `typer_app` |
+| `welcome` | First-call handshake — scout + certify + wire packaged into one response so the agent immediately knows the repo state, top strengths, top priorities, and the single most useful next call. | `atomadic_forge_seed` | `typer_app` |
+| `wisdom` | Record / query / list cross-session wisdom — the institutional knowledge layer between lineage events and curated recipes. | `atomadic_forge_seed` | `typer_app` |

atomadic_forge-0.52.0/docs/commands/absorb.md

@@ -0,0 +1,9 @@
+# `atomadic-forge absorb`
+
+_Absorb any Python repo (crewAI, langgraph, autogen, babyagi, …) into a tier-organized Atomadic package._
+
+- **Module**: `atomadic_forge.commands.absorb`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

atomadic_forge-0.52.0/docs/commands/audit.md

@@ -0,0 +1,9 @@
+# `atomadic-forge audit`
+
+_Surface the .atomadic-forge lineage log: list runs, inspect saved manifests, replay history._
+
+- **Module**: `atomadic_forge.commands.audit`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

atomadic_forge-0.52.0/docs/commands/create.md

@@ -0,0 +1,9 @@
+# `atomadic-forge create`
+
+_One-command pipeline: scan local seed repos for emergent compositions and materialize the top-N into a shippable package._
+
+- **Module**: `atomadic_forge.commands.create`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

atomadic_forge-0.52.0/docs/commands/emergent-swarm.md

@@ -0,0 +1,19 @@
+# `atomadic-forge emergent-swarm`
+
+_Round-5: cross-repo emergent composition discovery. Find chains visible only across the union of N repos._
+
+- **Module**: `atomadic_forge.commands.emergent_swarm`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+
+## Scoring
+
+Each candidate receives a `score_boosted` value. Candidates whose most
+frequent constituent symbol appears in more than 3 chains across the
+swarm receive a hub-node penalty: 10 points are deducted from
+`score_boosted` per doubling of that symbol's cross-chain frequency
+above the threshold (floor at 0). This prevents a single high-connectivity
+connector from dominating all top-N slots. Penalised candidates carry
+`hub_penalty` and `hub_max_symbol_freq` in their output.
+

atomadic_forge-0.52.0/docs/commands/enhancement.md

@@ -0,0 +1,9 @@
+# `atomadic-forge enhancement`
+
+_Submit / list / show / publish Forge enhancement proposals — the self-improvement loop. Trust-gated at submission, human-gated at publish._
+
+- **Module**: `atomadic_forge.commands.enhancement`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

atomadic_forge-0.52.0/docs/commands/guard-install.md

@@ -0,0 +1,9 @@
+# `atomadic-forge guard-install`
+
+_Round-5: install the four-layer architectural guard (pre-commit, CI workflow, CONTRIBUTING note, .forge-guard.json)._
+
+- **Module**: `atomadic_forge.commands.guard_install`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

atomadic_forge-0.52.0/docs/commands/handoff.md

@@ -0,0 +1,9 @@
+# `atomadic-forge handoff`
+
+_Capture a structured session handoff so the next agent can pick up where this one left off. Writes JSON to .atomadic-forge/handoffs/<session_id>.json._
+
+- **Module**: `atomadic_forge.commands.handoff`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

atomadic_forge-0.52.0/docs/commands/harvest.md

@@ -0,0 +1,9 @@
+# `atomadic-forge harvest`
+
+_Round-4: find symbols the target lacks but source repos have. Trust-gated by trust threshold._
+
+- **Module**: `atomadic_forge.commands.harvest`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

atomadic_forge-0.52.0/docs/commands/hive.md

@@ -0,0 +1,9 @@
+# `atomadic-forge hive`
+
+_Hive sync pipeline — agent registry + observation + consensus. The 4-agent collaboration substrate._
+
+- **Module**: `atomadic_forge.commands.hive`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

atomadic_forge-0.52.0/docs/commands/materialize.md

@@ -0,0 +1,9 @@
+# `atomadic-forge materialize`
+
+_Turn emergent scan candidates into a shippable Python package (scaffold + features + certify)._
+
+- **Module**: `atomadic_forge.commands.materialize`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

atomadic_forge-0.52.0/docs/commands/metrics.md

@@ -0,0 +1,9 @@
+# `atomadic-forge metrics`
+
+_Emit forge_metrics.json — canonical metrics for README/CHANGELOG/welcome/worker._
+
+- **Module**: `atomadic_forge.commands.metrics`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

atomadic_forge-0.52.0/docs/commands/recon-swarm.md

@@ -0,0 +1,9 @@
+# `atomadic-forge recon-swarm`
+
+_Round-4: walk N repos, return a unified scout report with origin_repo annotations on every symbol._
+
+- **Module**: `atomadic_forge.commands.recon_swarm`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

atomadic_forge-0.52.0/docs/commands/relay.md

@@ -0,0 +1,9 @@
+# `atomadic-forge relay`
+
+_Local relay daemon — receive signed job requests from the Worker MCP and dispatch them through the local CLI. v0.14.0-alpha._
+
+- **Module**: `atomadic_forge.commands.relay`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

atomadic_forge-0.52.0/docs/commands/surface.md

@@ -0,0 +1,9 @@
+# `atomadic-forge surface`
+
+_Emit / check / diff the canonical Forge surface artifact (single source of truth for tools, recipes, schemas)._
+
+- **Module**: `atomadic_forge.commands.surface`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

atomadic_forge-0.52.0/docs/commands/welcome.md

@@ -0,0 +1,9 @@
+# `atomadic-forge welcome`
+
+_First-call handshake — scout + certify + wire packaged into one response so the agent immediately knows the repo state, top strengths, top priorities, and the single most useful next call._
+
+- **Module**: `atomadic_forge.commands.welcome`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

atomadic_forge-0.52.0/docs/commands/wisdom.md

@@ -0,0 +1,9 @@
+# `atomadic-forge wisdom`
+
+_Record / query / list cross-session wisdom — the institutional knowledge layer between lineage events and curated recipes._
+
+- **Module**: `atomadic_forge.commands.wisdom`
+- **Surface**: `typer_app`
+- **Source root**: `atomadic_forge_seed`
+- **Hidden**: `False`
+

{atomadic_forge-0.51.6 → atomadic_forge-0.52.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "atomadic-forge"
-version = "0.51.6"
+version = "0.52.0"
 description = "Atomadic Forge — absorb, enforce, emerge. Polyglot (Python · JavaScript/TypeScript · Rust · Go · Swift · Kotlin) architecture guardian for AI-generated code."
 readme = "README.md"
 requires-python = ">=3.10"

{atomadic_forge-0.51.6 → atomadic_forge-0.52.0}/src/atomadic_forge/a1_at_functions/forge_metrics.py

@@ -38,12 +38,17 @@ _LEAN_THEOREM_RE = re.compile(
 
 
 def count_lean_theorems(mhed_codex_root: Path) -> dict[str, Any]:
-    """Walk ``<mhed_codex_root>/proofs`` and count theorems + lemmas.
+    """Return the certified Lean theorem count for a Codex proof tree.
 
     The mhed-corpus repository is IP-protected — this function only
     surfaces aggregate counts to the public artifact. Source paths and
     file names are NEVER returned. Callers must not log the input path.
 
+    Prefer a build attestation when present: that file is the certified
+    proof-tree boundary produced by ``lake build``. A raw ``proofs/`` scan
+    is only a fallback for local working trees that have not produced an
+    attestation yet; it can overcount scratch or archived Lean files.
+
     Args:
         mhed_codex_root: directory containing a ``proofs/`` subtree of
             ``.lean`` files. If the directory does not exist or contains
@@ -54,6 +59,10 @@ def count_lean_theorems(mhed_codex_root: Path) -> dict[str, Any]:
         combined), ``theorems``, ``lemmas``, ``files``, ``found``.
         No paths. Counts are always int; never raises on missing path.
     """
+    attested = _count_lean_theorems_from_attestation(Path(mhed_codex_root))
+    if attested is not None:
+        return attested
+
     proofs_dir = Path(mhed_codex_root) / "proofs"
     if not proofs_dir.is_dir():
         return {
@@ -78,6 +87,61 @@ def count_lean_theorems(mhed_codex_root: Path) -> dict[str, Any]:
         "lemmas": lemmas,
         "files": len(files),
         "found": True,
+        "basis": "raw_proofs_scan",
+    }
+
+
+def _count_lean_theorems_from_attestation(
+    mhed_codex_root: Path,
+) -> dict[str, Any] | None:
+    """Read the newest build attestation if one exists.
+
+    Returns only aggregate fields safe for ``forge_metrics.json``. The
+    per-module hashes; those are deliberately not copied into Forge's public
+    metrics surface. The aggregate proof-tree hash is public-safe and lets
+    downstream agents verify the exact attested boundary.
+    """
+    dist_dir = Path(mhed_codex_root) / "dist"
+    if not dist_dir.is_dir():
+        return None
+    attestations = sorted(dist_dir.glob("BUILD_ATTESTATION_*.json"))
+    if not attestations:
+        return None
+    try:
+        data = json.loads(attestations[-1].read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return None
+    totals = data.get("totals")
+    if not isinstance(totals, dict):
+        return None
+    try:
+        count = int(totals["theorems_and_lemmas"])
+        sorry = int(totals.get("sorry", 0))
+        admit = int(totals.get("admit", 0))
+        modules = int(totals.get("modules", 0))
+        agent_rule_axioms = int(totals.get("agent_rule_axioms", 0))
+        free_parameters = int(totals.get("free_parameters_fit_to_data", 0))
+    except (KeyError, TypeError, ValueError):
+        return None
+    proof_tree = data.get("proof_tree")
+    proof_hash = ""
+    if isinstance(proof_tree, dict):
+        proof_hash = str(proof_tree.get("sha256_of_sorted_module_hashes", ""))
+    return {
+        "count": count,
+        "theorems": count,
+        "lemmas": 0,
+        "files": modules,
+        "modules": modules,
+        "sorry": sorry,
+        "admit": admit,
+        "agent_rule_axioms": agent_rule_axioms,
+        "free_parameters_fit_to_data": free_parameters,
+        "found": True,
+        "basis": "build_attestation",
+        "attestation_issued_at": str(data.get("issued_at", "")),
+        "proof_tree_hash": proof_hash,
+        "lake_build_status": str(data.get("lake_build_status", "")),
     }
 
 

atomadic_forge-0.52.0/src/atomadic_forge/a1_at_functions/harvest_absorb.py

@@ -0,0 +1,170 @@
+"""Tier a1 — pure helpers for the absorb-any-repo pipeline."""
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from pathlib import Path
+
+_TIER_DIR_NAMES = (
+    "a0_qk_constants",
+    "a1_at_functions",
+    "a2_mo_composites",
+    "a3_og_features",
+    "a4_sy_orchestration",
+)
+_SKIP_DIRS = frozenset({
+    ".git", ".github", ".venv", "venv", "env", ".env",
+    "__pycache__", ".pytest_cache", ".ruff_cache", ".mypy_cache",
+    "node_modules", "dist", "build", ".tox", "htmlcov",
+    ".atomadic-forge", "eggs", ".eggs",
+    "tests", "test", "testing", "benchmarks",
+    "examples", "scripts", "tools", "fixtures", "conftest",
+})
+
+
+class RepoLayout(str):
+    ATOMADIC_TIER = "atomadic_tier"
+    SRC_LAYOUT = "src_layout"
+    MONOREPO_LIB = "monorepo_lib"
+    MULTI_LIB = "multi_lib"
+    FLAT = "flat"
+    UNKNOWN = "unknown"
+
+
+@dataclass(frozen=True)
+class ResolvedRepo:
+    src_root: Path
+    package_name: str
+    layout: str
+    repo_root: Path
+
+
+def _has_tier_folders(p: Path) -> bool:
+    return any((p / n).is_dir() for n in _TIER_DIR_NAMES)
+
+
+def _is_python_package(p: Path) -> bool:
+    return p.is_dir() and (p / "__init__.py").is_file()
+
+
+def _find_packages_under(root: Path, max_depth: int = 3) -> list[Path]:
+    results: list[Path] = []
+
+    def _walk(p: Path, depth: int) -> None:
+        if depth > max_depth or p.name in _SKIP_DIRS:
+            return
+        if _is_python_package(p):
+            results.append(p)
+            return
+        for c in sorted(p.iterdir()):
+            if c.is_dir() and c.name not in _SKIP_DIRS:
+                _walk(c, depth + 1)
+
+    _walk(root, 0)
+    return results
+
+
+def _rank_packages(pkgs: list[Path]) -> list[Path]:
+    def _score(p: Path) -> tuple[int, int]:
+        n = p.name.lower()
+        pen = n.endswith(("_cli", "_test", "_tests", "_bench", "_example"))
+        return (0 if pen else 1, len(list(p.rglob("*.py"))))
+
+    return sorted(pkgs, key=_score, reverse=True)
+
+
+def classify_repo_layout(repo_root: Path | str) -> str:
+    p = Path(repo_root).resolve()
+    if _has_tier_folders(p):
+        return RepoLayout.ATOMADIC_TIER
+    src = p / "src"
+    if src.is_dir() and _find_packages_under(src, 1):
+        return RepoLayout.SRC_LAYOUT
+    lib = p / "lib"
+    if lib.is_dir() and _find_packages_under(lib, 3):
+        return RepoLayout.MONOREPO_LIB
+    libs = p / "libs"
+    if libs.is_dir() and _find_packages_under(libs, 2):
+        return RepoLayout.MULTI_LIB
+    if any(_is_python_package(c) for c in p.iterdir()):
+        return RepoLayout.FLAT
+    return RepoLayout.UNKNOWN
+
+
+def resolve_any_python_package(repo_root: Path | str) -> ResolvedRepo:
+    p = Path(repo_root).resolve()
+    if not p.exists():
+        raise ValueError(f"repo does not exist: {p}")
+    layout = classify_repo_layout(p)
+    if layout == RepoLayout.ATOMADIC_TIER:
+        return ResolvedRepo(src_root=p, package_name=p.name, layout=layout, repo_root=p)
+    if layout == RepoLayout.SRC_LAYOUT:
+        pkgs = _find_packages_under(p / "src", 1)
+        if pkgs:
+            return ResolvedRepo(
+                src_root=pkgs[0], package_name=pkgs[0].name, layout=layout, repo_root=p
+            )
+    if layout == RepoLayout.MONOREPO_LIB:
+        pkgs = _find_packages_under(p / "lib", 4)
+        if pkgs:
+            best = _rank_packages(pkgs)[0]
+            return ResolvedRepo(
+                src_root=best, package_name=best.name, layout=layout, repo_root=p
+            )
+    if layout == RepoLayout.MULTI_LIB:
+        pkgs = _find_packages_under(p / "libs", 3)
+        if pkgs:
+            best = _rank_packages(pkgs)[0]
+            return ResolvedRepo(
+                src_root=best, package_name=best.name, layout=layout, repo_root=p
+            )
+    if layout == RepoLayout.FLAT:
+        pkgs = [c for c in p.iterdir() if _is_python_package(c) and c.name not in _SKIP_DIRS]
+        if pkgs:
+            best = max(pkgs, key=lambda x: len(list(x.rglob("*.py"))))
+            return ResolvedRepo(
+                src_root=best, package_name=best.name, layout=layout, repo_root=p
+            )
+    all_pkgs = _find_packages_under(p, 5)
+    if all_pkgs:
+        best = _rank_packages(all_pkgs)[0]
+        return ResolvedRepo(
+            src_root=best, package_name=best.name, layout=RepoLayout.UNKNOWN, repo_root=p
+        )
+    raise ValueError(
+        f"could not resolve a Python package under {p} (layout={layout}). "
+        "Ensure the repo contains at least one directory with __init__.py."
+    )
+
+
+def build_swarm_repo_specs(repo_paths: list[Path | str]) -> list[dict]:
+    specs = []
+    for path in repo_paths:
+        try:
+            r = resolve_any_python_package(path)
+            specs.append({
+                "src_root": str(r.src_root),
+                "package": r.package_name,
+                "layout": r.layout,
+                "repo_root": str(r.repo_root),
+            })
+        except ValueError as e:
+            specs.append({
+                "src_root": str(path),
+                "package": Path(path).name,
+                "layout": RepoLayout.UNKNOWN,
+                "repo_root": str(path),
+                "error": str(e),
+            })
+    return specs
+
+
+def fingerprint_repo(repo_root: Path | str) -> str:
+    p = Path(repo_root).resolve()
+    parts: list[str] = []
+    for f in sorted(p.rglob("*.py")):
+        try:
+            parts.append(f"{f.relative_to(p)}:{f.stat().st_size}")
+        except OSError:
+            continue
+    return hashlib.sha256("\n".join(parts[:500]).encode()).hexdigest()[:12]

{atomadic_forge-0.51.6 → atomadic_forge-0.52.0}/src/atomadic_forge/a1_at_functions/mcp_protocol.py

@@ -3199,12 +3199,6 @@ _CLI_FALLBACKS: dict[str, str] = {
         "forge emergent scan <repo> --json — use explore(action=scan) via MCP | "
         "forge emergent swarm --json — use explore(action=swarm) via MCP"
     ),
-    # legacy names — transmute absorbed into plan in v0.39.0
-    "transmute": (
-        "forge auto <output> --apply — use plan(action=auto) via MCP | "
-        "forge cherry [--pick ...] — use plan(action=cherry) via MCP | "
-        "forge finalize <output> --apply — use plan(action=finalize) via MCP"
-    ),
     "code_intel": (
         "forge call-graph <qualname> --project-root <repo> --json — use explore(action=call_graph) via MCP | "
         "forge smell-scan --project-root <repo> --json — use explore(action=smell_scan) via MCP"
@@ -3227,13 +3221,6 @@ _CLI_FALLBACKS: dict[str, str] = {
     ),
     # legacy names — tool_factory absorbed into plan(action=scaffold) in v0.41.0
     "tool_factory": "MCP-only: tool_factory — use plan(action=scaffold) via MCP",
-    # legacy names — loop absorbed into plan in v0.39.0
-    "loop": (
-        "forge iterate run --intent '...' --output <dir> — use plan(action=iterate) via MCP | "
-        "MCP-only: plan(action=resume) | "
-        "forge evolve run --intent '...' --output <dir> — use plan(action=evolve) via MCP | "
-        "MCP-only: plan(action=evolve_step)"
-    ),
     "lineage": "forge surface list/show/log — use explore(action=lineage) via MCP",
     "hive": (
         "forge hive register --agent-name <name> --role <role> --json (action=register) | "