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

{atomadic_forge-0.52.0 → atomadic_forge-0.53.0}/.github/workflows/metrics-auto-regen.yml

@@ -10,8 +10,8 @@ name: Metrics Auto-Regenerate
 #   - Public surfaces (atomadic.tech, shields.io endpoints proxied by
 #     the worker) always read live numbers from the same JSON.
 #
-# Lean theorem count requires the IP-protected mhed-codex repo. The
-# FORGE_MHED_CODEX_REPO secret (org-level) provides a deploy-key URL;
+# Lean theorem count requires the IP-protected proof corpus repo. The
+# PROOF_CORPUS_DEPLOY_KEY secret (org-level) provides a deploy-key;
 # without it the lean_theorems block is preserved from the prior commit
 # (see surgical merge step below) so this workflow never destroys real
 # numbers when running without the IP repo attached.
@@ -52,37 +52,38 @@ jobs:
           echo "$out"
           passed=$(echo "$out" | grep -oE '[0-9]+ passed' | head -1 | grep -oE '[0-9]+')
           echo "passed=${passed:-0}" >> "$GITHUB_OUTPUT"
-      - name: Optionally clone IP-protected mhed-codex (preserves lean count)
+      - name: Optionally clone IP-protected proof corpus (preserves lean count)
         # GitHub Actions disallows `secrets.*` in `if` — runtime check
         # inside the script instead. No-op if the deploy key is unset.
         env:
-          MHED_CODEX_DEPLOY_KEY: ${{ secrets.MHED_CODEX_DEPLOY_KEY }}
+          PROOF_CORPUS_DEPLOY_KEY: ${{ secrets.PROOF_CORPUS_DEPLOY_KEY }}
+          PROOF_CORPUS_REPO_URL: ${{ secrets.PROOF_CORPUS_REPO_URL }}
         run: |
-          if [ -z "${MHED_CODEX_DEPLOY_KEY:-}" ]; then
-            echo "MHED_CODEX_DEPLOY_KEY not set — skipping mhed-codex clone."
+          if [ -z "${PROOF_CORPUS_DEPLOY_KEY:-}" ]; then
+            echo "PROOF_CORPUS_DEPLOY_KEY not set — skipping proof corpus clone."
             exit 0
           fi
           mkdir -p ~/.ssh && chmod 700 ~/.ssh
-          echo "$MHED_CODEX_DEPLOY_KEY" > ~/.ssh/mhed_key && chmod 600 ~/.ssh/mhed_key
-          GIT_SSH_COMMAND="ssh -i ~/.ssh/mhed_key -o StrictHostKeyChecking=no" \
-            git clone --depth 1 git@github.com:atomadictech/mhed-codex.git /tmp/mhed-codex
-          echo "FORGE_MHED_CODEX=/tmp/mhed-codex" >> "$GITHUB_ENV"
+          echo "$PROOF_CORPUS_DEPLOY_KEY" > ~/.ssh/corpus_key && chmod 600 ~/.ssh/corpus_key
+          GIT_SSH_COMMAND="ssh -i ~/.ssh/corpus_key -o StrictHostKeyChecking=no" \
+            git clone --depth 1 "$PROOF_CORPUS_REPO_URL" /tmp/proof-corpus
+          echo "FORGE_PROOF_CORPUS=/tmp/proof-corpus" >> "$GITHUB_ENV"
       - name: Regenerate forge_metrics.json
         run: |
           # Save the previous lean_theorems block so we can preserve it
-          # when no mhed-codex is attached (avoid zeroing the public
+          # when no proof corpus is attached (avoid zeroing the public
           # number on a routine source-only push).
           python -c "import json; d=json.load(open('forge_metrics.json')); print(json.dumps(d.get('lean_theorems', {})))" > /tmp/prev_lean.json
           forge metrics --apply --tests-passing ${{ steps.pytest.outputs.passed }}
-          # If no mhed-codex was attached this run, restore prior lean block.
-          if [ -z "${FORGE_MHED_CODEX:-}" ]; then
+          # If no proof corpus was attached this run, restore prior lean block.
+          if [ -z "${FORGE_PROOF_CORPUS:-}" ]; then
             python <<'PY'
           import json, pathlib
           p = pathlib.Path("forge_metrics.json")
           d = json.loads(p.read_text())
           prev = json.loads(pathlib.Path("/tmp/prev_lean.json").read_text())
           # Only restore if the freshly-computed block reports found=False
-          # (i.e. mhed-codex unavailable) AND the prior had a real count.
+          # (i.e. proof corpus unavailable) AND the prior had a real count.
           if not d.get("lean_theorems", {}).get("found") and prev.get("count"):
               d["lean_theorems"] = prev
               p.write_text(json.dumps(d, indent=2, sort_keys=True) + "\n")

{atomadic_forge-0.52.0 → atomadic_forge-0.53.0}/.github/workflows/metrics-drift.yml

@@ -4,10 +4,10 @@ name: Metrics Drift Gate
 # Any PR that changes TOOLS, CLI registry, source/test counts, or
 # pyproject.toml WITHOUT regenerating forge_metrics.json fails this check.
 #
-# Lean theorem count is recomputed only when the FORGE_MHED_CODEX repo is
+# Lean theorem count is recomputed only when the FORGE_PROOF_CORPUS repo is
 # accessible (CI env var). When not set, the lean_theorems block is
 # preserved from the in-tree forge_metrics.json so PRs that don't touch
-# mhed-codex don't get blocked here.
+# the proof corpus don't get blocked here.
 #
 # Fix when this fails:  forge metrics --apply && git add forge_metrics.json
 
@@ -41,7 +41,7 @@ jobs:
           set -euo pipefail
           # Save committed copy.
           cp forge_metrics.json /tmp/forge_metrics.committed.json
-          # Recompute (Lean count zero in CI unless FORGE_MHED_CODEX is wired).
+          # Recompute (Lean count zero in CI unless FORGE_PROOF_CORPUS is wired).
           forge metrics --apply
           # If the only delta is the timestamp, that's expected — strip it
           # before diffing so we only fail on substantive drift.
@@ -53,10 +53,10 @@ jobs:
           # this gate doesn't run pytest. Comparing them is meaningless.
           jq 'del(.tests_passing)' /tmp/a.json > /tmp/a2.json && mv /tmp/a2.json /tmp/a.json
           jq 'del(.tests_passing)' /tmp/b.json > /tmp/b2.json && mv /tmp/b2.json /tmp/b.json
-          # If FORGE_MHED_CODEX is not set, also ignore the lean_theorems
+          # If FORGE_PROOF_CORPUS is not set, also ignore the lean_theorems
           # block (will be 0 in CI but the committed artifact has the real
           # count from the IP repo).
-          if [ -z "${FORGE_MHED_CODEX:-}" ]; then
+          if [ -z "${FORGE_PROOF_CORPUS:-}" ]; then
             jq 'del(.lean_theorems)' /tmp/a.json > /tmp/a2.json && mv /tmp/a2.json /tmp/a.json
             jq 'del(.lean_theorems)' /tmp/b.json > /tmp/b2.json && mv /tmp/b2.json /tmp/b.json
           fi

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

@@ -2,6 +2,65 @@
 
 ## Unreleased
 
+## v0.53.0 — 2026-05-07 — Harvest synthesis: call-graph-summary, git churn, token budget
+
+### feat(synthesis): three new a1 capabilities absorbed from harvest pipeline
+
+**`call_graph_summary` — whole-package call-graph portfolio** (pyan synthesis)
+
+Adds `build_call_graph_summary()` to `a1_at_functions/call_graph.py`.
+Surfaces orphan functions (uncalled callers), hotspot functions by fan-in,
+and maximum call-chain depth for an entire package in one shot — distinct from
+the per-symbol BFS that `call_graph` already provides.
+
+- `forge call-graph-summary --project <root> [--package NAME] [--top-n N] [--json]`
+- MCP: `explore(action='call_graph_summary')`
+- Schema: `atomadic-forge.call_graph_summary/v1`
+
+**`git_churn` — file-level commit frequency** (Repomix synthesis)
+
+New `a1_at_functions/git_churn.py` with `compute_git_churn()`.
+Runs `git log --name-only` to build hotspot/stable file rankings, average and
+median commits per file, first/last commit dates. Returns a minimal error dict
+when git is unavailable so callers degrade gracefully.
+
+- `forge churn --project <root> [--since '6 months ago'] [--top-n N] [--all-files] [--json]`
+- MCP: `explore(action='churn')`
+- Schema: `atomadic-forge.git_churn/v1`
+
+**`token_estimate` — context-pack payload sizing** (Repomix synthesis)
+
+`emit_context_pack()` now includes `token_estimate: int` — a `len(json.dumps(pack)) // 4`
+approximation so agents can budget against context limits before dispatching.
+
+### metrics
+
+- CLI verbs: 74 (+2)
+- MCP actions: 66 (+2)
+- Tests: 1423 (+14 over v0.52.1)
+
+## v0.52.1 — 2026-05-07 — IP scrub: no private identifiers in public repo
+
+### fix(security): remove all private identifiers from public surfaces
+
+All internal project names, repo identifiers, and deploy-key secret
+names replaced with neutral public-safe labels throughout:
+
+- CI workflow secrets and env vars renamed to neutral `PROOF_CORPUS_*` prefix
+- Hardcoded SSH clone URL moved to `PROOF_CORPUS_REPO_URL` org secret
+- Python API param renamed to `proof_corpus_root`; internal helper to `_find_proof_corpus`
+- CLI flag renamed to `forge metrics --proof-corpus`
+- All docs (CHANGELOG, README, .gitignore) use neutral labels
+
+Zero functional changes. certify: 100/100. wire: 0 violations.
+
+### fix(test): git-ceiling tests clear inherited worktree env vars
+
+`test_worktree_status_non_git_runs` and
+`test_tools_call_doctor_with_include_worktree` now explicitly unset
+`GIT_DIR`/`GIT_WORK_TREE`/`GIT_COMMON_DIR` so they pass when running
+from inside a git worktree on Windows.
+
 ### feat(emergent-swarm): hub-node penalty in `emergent_swarm` scoring
 
 Symbols that appear in more than 3 chains are now penalised in
@@ -164,7 +223,7 @@ This release scrubs all of them while keeping the credibility markers:
 
 **IP-protected (stripped from public):**
 - Specific theorem names (no longer cited anywhere public)
-- Codex framework names ("MHED-TOE" → "system")
+- Internal framework names (removed from all public surfaces)
 - Math derivations (no `⌊Δ_RG/η⌋`, no Leech / Niemeier / Coxeter–Todd /
   Golay / Monster group / E₈ geometry references)
 - Greek-letter math (`τ_TRUST` → `TAU_TRUST`, `τ_trust` → `trust threshold`
@@ -233,8 +292,8 @@ or `pyproject.toml` triggers a regeneration. If the artifact drifted, a
 follow-up `chore(metrics): auto-regenerate [skip ci]` commit is pushed
 back to main. Stale numbers self-heal — no human intervention.
 
-When the `MHED_CODEX_DEPLOY_KEY` org secret is configured, the
-auto-regen also clones the IP-protected mhed-codex over deploy-key
+When the `PROOF_CORPUS_DEPLOY_KEY` org secret is configured, the
+auto-regen also clones the IP-protected proof corpus over deploy-key
 SSH and refreshes the Lean theorem count. Without the secret, the prior
 lean count is preserved (never zeroed by a routine push).
 
@@ -251,7 +310,7 @@ targeted-subset passes). The artifact now carries all three explicitly:
 
 Every public number Forge claims about itself — MCP tool count, action
 count, CLI verb count, source/test files, lines of code, and the count
-of formally-verified Lean4 theorems in the IP-protected mhed-codex
+of formally-verified Lean4 theorems in the IP-protected proof corpus
 moat — now lives in one canonical artifact: `forge_metrics.json` at the
 repo root, regenerated on every push by `forge metrics --apply`.
 
@@ -265,7 +324,7 @@ artifact drift out of sync with the live forge surface.
 - 71 CLI verbs
 - 211 source files · ~40,110 LOC
 - 96 test files
-- **886 Lean4 theorems across 38 files** (mhed-codex moat)
+- **886 Lean4 theorems across 38 files** (formal-proof moat)
 - monadic tiers = 5
 
 ### feat(cli/mcp): `forge metrics` verb — print or write the artifact
@@ -279,10 +338,10 @@ forge metrics --self-cert      # also embed certify score (slower)
 
 The verb composes a pure tier-a1 aggregator (`forge_metrics.py`) with
 the live MCP TOOLS dict and CLI registry. Source paths from the
-IP-protected mhed-codex repo are NEVER written into the public
+IP-protected proof corpus are NEVER written into the public
 artifact — only aggregate counts. Path resolution is via the
-`FORGE_MHED_CODEX` env var; gitignore protects `mhed-codex/` from
-ever being checked in.
+`FORGE_PROOF_CORPUS` env var; gitignore protects the proof corpus
+directory from ever being checked in.
 
 ### chore: corrected stale README numbers
 
@@ -3069,7 +3128,7 @@ shipped on master.
   roadmap explicit (v1.0 → v1.1 W8 polyglot_breakdown → v1.2 W12
   slsa_attestation → v2.0 W24 bao_rompf_witnesses). Both Lean4 corpora
   cited (`aethel-nexus-proofs` — 29 theorems, 0 sorry, 0 axioms — and
-  `mhed-toe-codex-v22` — 538 theorems, 0 sorry). All signing / lineage
+  `proof-corpus-v22` — 538 theorems, 0 sorry). All signing / lineage
   / attestation fields default to `None` so unsigned dev Receipts
   remain structurally valid. Tier-pure a0.
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.52.0
+Version: 0.53.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
@@ -208,7 +208,7 @@ Full tool reference: [docs/MCP_TOOLS.md](docs/MCP_TOOLS.md) | First call: `welco
 | CLI verbs | **71** |
 | 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) |
+| Lean4 formal proofs | **872 theorems** across 30 files (mathematically verified core logic — IP-protected formal verification 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 → atomadic_forge-0.53.0}/README.md

@@ -176,7 +176,7 @@ Full tool reference: [docs/MCP_TOOLS.md](docs/MCP_TOOLS.md) | First call: `welco
 | CLI verbs | **71** |
 | 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) |
+| Lean4 formal proofs | **872 theorems** across 30 files (mathematically verified core logic — IP-protected formal verification 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 → atomadic_forge-0.53.0}/docs/AGENTS_GUIDE.md

@@ -462,7 +462,7 @@ treated as non-code artifacts rather than misplaced source.
 | Resource URI | What it is | Use case |
 |---|---|---|
 | `forge://docs/receipt` | The Receipt schema spec | Agent reads this to know what the Receipt JSON contract is. |
-| `forge://docs/formalization` | Citations to `aethel-nexus-proofs` (29 theorems / 0 sorry) and `mhed-toe-corpus-v22` (538 theorems / 0 sorry) | Agent presenting Forge to a regulator: cite the proof corpus. |
+| `forge://docs/formalization` | Citations to `aethel-nexus-proofs` (29 theorems / 0 sorry) and `proof-corpus-v22` (538 theorems / 0 sorry) | Agent presenting Forge to a regulator: cite the proof corpus. |
 | `forge://lineage/chain` | Episodic L1 trace of every Forge run | Replay / debugging / audit. |
 | `forge://schema/receipt` | Machine-readable JSON Schema for the Receipt | Agent doing type-checked Receipt parsing. |
 | `forge://summary/blockers` | Same payload as `agent_summary` MCP tool | One-shot `resources/read` for clients that prefer resources over tools. |

{atomadic_forge-0.52.0 → atomadic_forge-0.53.0}/docs/RECEIPT.md

@@ -84,7 +84,7 @@ rejected by consumers. The set is pinned in
 | `artifacts` | list of `{name, path, sha256}` | pointers to `.atomadic-forge/*.json` evidence files |
 | `signatures.sigstore` | object \| null | Rekor uuid + log_index; populated by Lane A W2 signer |
 | `signatures.aaaa_nexus` | object \| null | base64 signature + key_id; from `/v1/verify/forge-receipt` |
-| `lean4_attestation` | object | corpus citations (`aethel-nexus-proofs`, `mhed-toe-corpus-v22`) |
+| `lean4_attestation` | object | corpus citations (`aethel-nexus-proofs`, `proof-corpus-v22`) |
 | `lineage.lineage_path` | string | opaque Vanguard ledger pointer (Lane A W4) |
 | `lineage.parent_receipt_hash` | string \| null | SHA-256 of the immediately prior Receipt |
 | `lineage.chain_depth` | int | 1 for first Receipt; n+1 per successor |
@@ -202,8 +202,8 @@ cited:
         "axiom_count": 0
       },
       {
-        "name": "mhed-toe-corpus-v22",
-        "repo_url": "https://github.com/AAAA-Nexus/mhed-toe-corpus",
+        "name": "proof-corpus-v22",
+        "repo_url": "https://example.com/proof-corpus",
         "ref_sha": "31bd09...",
         "theorem_count": 538,
         "sorry_count": 0,

{atomadic_forge-0.52.0 → atomadic_forge-0.53.0}/docs/compliance/CMMC_AI_MAPPING.md

@@ -150,7 +150,7 @@ classification":
 | Corpus | Theorems | Claim backed |
 |---|---|---|
 | `aethel-nexus-proofs` | 29, 0 sorry | Monadic composition law: tiers compose upward only |
-| `mhed-toe-corpus-v22` | 538, 0 sorry | Wire-scan completeness and soundness |
+| `proof-corpus-v22` | 538, 0 sorry | Wire-scan completeness and soundness |
 
 ---
 

{atomadic_forge-0.52.0 → atomadic_forge-0.53.0}/docs/compliance/EU_AI_ACT_ANNEX_IV.md

@@ -50,7 +50,7 @@ is satisfied by fields in the Atomadic Forge Receipt v1.
 | Corpus | Theorems | Sorry | Axioms |
 |--------|----------|-------|--------|
 | `aethel-nexus-proofs` | 29 | 0 | 0 |
-| `mhed-toe-corpus-v22` | 538 | 0 | 0 |
+| `proof-corpus-v22` | 538 | 0 | 0 |
 
 ### Annex IV §2(b) — Data governance and data management practices
 
@@ -113,7 +113,7 @@ Lean4 corpus with `sorry_count = 0`.  The standard Atomadic corpora are:
 | Corpus | Repository | Theorems | Sorry | Axioms | Status |
 |--------|-----------|----------|-------|--------|--------|
 | `aethel-nexus-proofs` | Internal | 29 | 0 | 0 | Attesting |
-| `mhed-toe-corpus-v22` | Internal | 538 | 0 | 0 | Attesting |
+| `proof-corpus-v22` | Internal | 538 | 0 | 0 | Attesting |
 
 ---
 

{atomadic_forge-0.52.0 → atomadic_forge-0.53.0}/docs/compliance/FDA_PCCP_MAPPING.md

@@ -73,7 +73,7 @@ Atomadic standard validation corpora:
 | Corpus | Theorems | Sorry | Validation claim |
 |--------|----------|-------|-----------------|
 | `aethel-nexus-proofs` | 29 | 0 | Structural invariants of the Atomadic monadic composition law |
-| `mhed-toe-corpus-v22` | 538 | 0 | Mathematical foundations of the tier-effect type system |
+| `proof-corpus-v22` | 538 | 0 | Mathematical foundations of the tier-effect type system |
 
 ### PCCP §II.C — Performance Monitoring Plan
 

{atomadic_forge-0.52.0 → atomadic_forge-0.53.0}/docs/compliance/SR_11-7_MAPPING.md

@@ -48,7 +48,7 @@ corpora cited in every signed Receipt provide:
 |---|---|
 | Theoretical basis documented | ASS-ADE MONADIC_DEVELOPMENT.md (5-tier law) + Lean4 proofs |
 | Assumptions stated and justified | `aethel-nexus-proofs` ref `abc1234` — 29 theorems, 0 sorry |
-| Mathematical properties verified | `mhed-toe-corpus-v22` ref `def5678` — 538 theorems, 0 sorry |
+| Mathematical properties verified | `proof-corpus-v22` ref `def5678` — 538 theorems, 0 sorry |
 
 A Receipt with no `lean4_attestation` or `sorry_count > 0` provides
 partial conceptual soundness evidence only.

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "atomadic-forge"
-version = "0.52.0"
+version = "0.53.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.52.0 → atomadic_forge-0.53.0}/src/atomadic_forge/a0_qk_constants/receipt_schema.py

@@ -187,7 +187,7 @@ class ReceiptLean4Corpus(TypedDict, total=False):
     Cites a machine-checked theorem corpus that backs a claim made by
     this Receipt. The Golden Path threads two corpora through every
     Receipt: ``aethel-nexus-proofs`` (29 theorems, 0 sorry, 0 axioms)
-    and ``mhed-toe-corpus-v22`` (538 theorems, 0 sorry).
+    and ``proof-corpus-v22`` (538 theorems, 0 sorry).
     """
     name: str                       # e.g. "aethel-nexus-proofs"
     repo_url: str

{atomadic_forge-0.52.0 → atomadic_forge-0.53.0}/src/atomadic_forge/a1_at_functions/agent_context_pack.py

@@ -13,6 +13,7 @@ single bundle. The orchestration that runs the scans lives in a3.
 """
 from __future__ import annotations
 
+import json
 import re
 from collections import Counter
 from pathlib import Path
@@ -136,6 +137,7 @@ class ContextPack(TypedDict, total=False):
     selected_tests: dict
     workflow_recipe: dict          # compose_tools plan when intent is provided
     suggested_next_steps: list[dict]
+    token_estimate: int            # rough token count (chars // 4); repomix synthesis
 
 
 def _read_repo_purpose(project_root: Path) -> str:
@@ -442,7 +444,7 @@ def emit_context_pack(
             project_root=project_root,
         )
 
-    return ContextPack(
+    pack = ContextPack(
         schema_version=SCHEMA_VERSION_CONTEXT_PACK_V1,
         project_root=str(project_root),
         repo_purpose=_read_repo_purpose(project_root),
@@ -478,4 +480,12 @@ def emit_context_pack(
             release_gate=release_gate,
             selected_tests=selected_tests,
         ),
+        token_estimate=0,
     )
+    # Patch token_estimate after build — rough approximation: JSON chars / 4 ≈ tokens.
+    # No external tokenizer required; accurate enough for context budget decisions.
+    try:
+        pack["token_estimate"] = len(json.dumps(pack, default=str)) // 4
+    except (TypeError, ValueError):
+        pass
+    return pack

{atomadic_forge-0.52.0 → atomadic_forge-0.53.0}/src/atomadic_forge/a1_at_functions/call_graph.py

@@ -419,3 +419,113 @@ def build_call_graph(args: dict[str, Any]) -> dict[str, Any]:
         "callees_count": len(callees),
         "target_in_graph": canonical_target in edges,
     }
+
+
+# ── Whole-package summary (pyan synthesis) ────────────────────────────
+
+SCHEMA_VERSION_CALL_GRAPH_SUMMARY_V1 = "atomadic-forge.call_graph_summary/v1"
+
+
+def _compute_fan_in(edges: dict[str, set[str]]) -> dict[str, int]:
+    fan_in: dict[str, int] = defaultdict(int)
+    for callees in edges.values():
+        for callee in callees:
+            fan_in[callee] += 1
+    return dict(fan_in)
+
+
+def _max_chain_depth(
+    edges: dict[str, set[str]],
+    starts: list[str],
+    *,
+    cap: int = 15,
+) -> int:
+    """BFS from each start node; return the longest path found (capped)."""
+    best = 0
+    for start in starts[:100]:
+        visited: set[str] = {start}
+        queue: deque[tuple[str, int]] = deque([(start, 0)])
+        while queue:
+            node, d = queue.popleft()
+            if d >= cap:
+                continue
+            for callee in edges.get(node, ()):
+                if callee not in visited:
+                    visited.add(callee)
+                    if d + 1 > best:
+                        best = d + 1
+                    queue.append((callee, d + 1))
+    return best
+
+
+def build_call_graph_summary(args: dict[str, Any]) -> dict[str, Any]:
+    """Whole-package call-graph portfolio: orphans, hotspots, max depth.
+
+    Synthesized from pyan (David Fraser) whole-graph analysis concepts.
+    Unlike ``build_call_graph`` (per-symbol callers/callees), this gives
+    a portfolio view of the entire package's call structure — useful for
+    dead-code audits, refactor prioritization, and complexity estimation.
+
+    Args (from the dispatcher):
+      * ``project_root`` (default: cwd): repo root.
+      * ``package`` (default: derived): top-level package name.
+      * ``top_n`` (default 10): number of hotspot/orphan rows to return.
+    """
+    project_root = Path(args.get("project_root") or ".").resolve()
+    top_n = min(int(args.get("top_n", 10)), 50)
+
+    _raw_package = args.get("package") or _detect_package_name(project_root)
+    package = _raw_package.replace("-", "_")
+
+    package_root = project_root / "src" / package
+    if not package_root.exists():
+        candidate = project_root / package
+        package_root = candidate if candidate.exists() else project_root
+
+    edges = _walk_package_edges(package_root, package=package)
+    aliases = _build_reexport_aliases(package_root, package=package)
+
+    if aliases:
+        canonical_edges: dict[str, set[str]] = defaultdict(set)
+        for caller, callees_set in edges.items():
+            canonical_caller = _canonicalize(caller, aliases)
+            for callee in callees_set:
+                canonical_edges[canonical_caller].add(
+                    _canonicalize(callee, aliases)
+                )
+        edges = dict(canonical_edges)
+
+    fan_in = _compute_fan_in(edges)
+
+    # Defined = every function that appears as a caller (has ≥1 outgoing edge).
+    defined: set[str] = {f for f in edges if f.startswith(package)}
+    called: set[str] = {f for f in fan_in if f.startswith(package)}
+
+    # Uncalled callers: defined but never called from within the package.
+    # These may be entry-points (CLI/MCP handlers) or dead code.
+    uncalled = sorted(defined - called)
+
+    # Hotspots: package functions with the highest internal fan-in.
+    hotspots = sorted(
+        [{"qualname": q, "fan_in": c} for q, c in fan_in.items()
+         if q.startswith(package)],
+        key=lambda x: -x["fan_in"],
+    )[:top_n]
+
+    max_depth = _max_chain_depth(edges, uncalled)
+
+    total_edges = sum(len(v) for v in edges.values())
+
+    return {
+        "schema_version": SCHEMA_VERSION_CALL_GRAPH_SUMMARY_V1,
+        "package": package,
+        "package_root": str(package_root),
+        "total_callers": len(defined),
+        "total_edges": total_edges,
+        "uncalled_callers_count": len(uncalled),
+        "uncalled_callers": uncalled[:top_n],
+        "hotspot_count": len(hotspots),
+        "hotspots": hotspots,
+        "max_call_depth": max_depth,
+        "alias_count": len(aliases),
+    }

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

@@ -6,7 +6,7 @@ Worker, shields.io badges) all derive from the same canonical artifact —
 ``forge_metrics.json`` — produced by this function. No string lives in two
 places; any drift is a CI-detectable bug.
 
-The function is pure: given the same repo + (optional) mhed-corpus path,
+The function is pure: given the same repo + (optional) proof corpus path,
 it returns the same dict. Every field carries a ``_basis`` description
 so consumers can trace a number back to its source.
 
@@ -37,10 +37,10 @@ _LEAN_THEOREM_RE = re.compile(
 )
 
 
-def count_lean_theorems(mhed_codex_root: Path) -> dict[str, Any]:
-    """Return the certified Lean theorem count for a Codex proof tree.
+def count_lean_theorems(proof_corpus_root: Path) -> dict[str, Any]:
+    """Return the certified Lean theorem count for the IP-protected proof corpus.
 
-    The mhed-corpus repository is IP-protected — this function only
+    The proof 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.
 
@@ -50,7 +50,7 @@ def count_lean_theorems(mhed_codex_root: Path) -> dict[str, Any]:
     attestation yet; it can overcount scratch or archived Lean files.
 
     Args:
-        mhed_codex_root: directory containing a ``proofs/`` subtree of
+        proof_corpus_root: directory containing a ``proofs/`` subtree of
             ``.lean`` files. If the directory does not exist or contains
             no proofs, returns ``{count: 0, files: 0, found: False}``.
 
@@ -59,11 +59,11 @@ 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))
+    attested = _count_lean_theorems_from_attestation(Path(proof_corpus_root))
     if attested is not None:
         return attested
 
-    proofs_dir = Path(mhed_codex_root) / "proofs"
+    proofs_dir = Path(proof_corpus_root) / "proofs"
     if not proofs_dir.is_dir():
         return {
             "count": 0, "theorems": 0, "lemmas": 0,
@@ -92,7 +92,7 @@ def count_lean_theorems(mhed_codex_root: Path) -> dict[str, Any]:
 
 
 def _count_lean_theorems_from_attestation(
-    mhed_codex_root: Path,
+    proof_corpus_root: Path,
 ) -> dict[str, Any] | None:
     """Read the newest build attestation if one exists.
 
@@ -101,7 +101,7 @@ def _count_lean_theorems_from_attestation(
     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"
+    dist_dir = Path(proof_corpus_root) / "dist"
     if not dist_dir.is_dir():
         return None
     attestations = sorted(dist_dir.glob("BUILD_ATTESTATION_*.json"))
@@ -223,7 +223,7 @@ def count_lines_of_code(repo_root: Path) -> int:
 def compute_forge_metrics(
     repo_root: Path,
     *,
-    mhed_codex_root: Path | None = None,
+    proof_corpus_root: Path | None = None,
     package_version: str | None = None,
     tools_count: int | None = None,
     actions_count: int | None = None,
@@ -241,7 +241,7 @@ def compute_forge_metrics(
 
     Args:
         repo_root: forge repo path (where ``src/`` and ``tests/`` live).
-        mhed_codex_root: optional path to mhed-corpus. When given,
+        proof_corpus_root: optional path to IP-protected proof corpus. When given,
             ``lean_theorems`` block is populated; when None, that block
             is zeroed and ``lean_theorems.found=False``.
         package_version: optional string. If None, the field is omitted.
@@ -286,8 +286,8 @@ def compute_forge_metrics(
         metrics["tests_passing"] = tests_passing
     # Lean theorem block — always present, populated only when found.
     # Public artifact carries counts only — never paths or file names.
-    if mhed_codex_root is not None:
-        lean = count_lean_theorems(Path(mhed_codex_root))
+    if proof_corpus_root is not None:
+        lean = count_lean_theorems(Path(proof_corpus_root))
     else:
         lean = {"count": 0, "theorems": 0, "lemmas": 0,
                 "files": 0, "found": False}