atomadic-forge 0.5.2__tar.gz → 0.6.0__tar.gz

{atomadic_forge-0.5.2 → atomadic_forge-0.6.0}/CHANGELOG.md

@@ -1,5 +1,117 @@
 # Changelog
 
+## 0.6.0 - Frontier features: dedup, budget, memory, swarm hiring, Ling-2.6-1T
+
+Major minor — five new capabilities cherry-picked from forge-deluxe-seed
+plus a frontier free-tier LLM, plus three MCP bug fixes and agent-optimized
+certify output.
+
+### Added — capabilities
+
+- **`dedup_engine`** — orchestrates `intent_similarity` + `code_signature`
+  + `research_note_distiller` to catch duplicate research notes AND
+  duplicate code logic at the gate. The "never reinvent the wheel"
+  primitive, ported with 13 tests.
+
+- **`cost_circuit_breaker`** — multi-tier (per-task / per-session /
+  per-day) USD + token budget with hard-kill, soft-warn-at-80%, and
+  no-progress stuck detection. Defaults match OpenHands
+  (MAX_ITERATIONS=100, $100/day). Closes the production-incident gap
+  ($47k loop, $30k loop) called out in cycle-14 SOTA research.
+
+- **`hierarchical_memory`** — 4-tier MemGPT pattern (M0 working /
+  M1 core pinned / M2 episodic / M3 reflection) with Park-2023
+  recency × importance × relevance scoring. Pure stdlib sqlite3 —
+  air-gappable.
+
+- **`agent_hire_protocol`** — 5-step swarm SOP (sealed-probe vetting
+  → trust gate → similarity check → contract → signed receipt) with
+  D_max=3 (ChatDev empirical limit) for safe multi-agent fanout.
+
+- **`ling` / `--provider ling`** — wires Ling-2.6-1T (1T-param MoE,
+  262K context, SOTA SWE-bench) via OpenRouter at the **free tier**.
+  Forge users now get a frontier model for iterate/evolve at zero
+  cost; OpenRouter default model also bumped from gemma-3-27b-it
+  to ling-2.6-1t.
+
+### Fixed
+
+### Fixed
+
+- **P0 (critical)** `recon` MCP tool no longer overflows LLM context
+  windows. `symbols[]` (771 K chars on forge itself) is stripped from
+  the default response; pass `verbose: true` to get the full walk.
+  `symbol_count` remains so agents still see cardinality inline.
+
+- **P1 (high)** `certify` behavioral score no longer reports `ran:
+  false, pass_ratio: 0.0` on repos using `xfailed`/`xpassed` pytest
+  status words. The `_parse_pytest_summary` parser now uses independent
+  per-metric regex patterns instead of a single monolithic regex that
+  choked on unknown status words between "passed" and "in Xs".
+  Atomadic-Lang's certify score recovers from 70 to 100.
+
+- **P2 (high)** `auto_plan` verdict no longer reports `PASS` for repos
+  with score < 75 and no action cards. `not cards` alone was treated as
+  PASS regardless of score; now requires `score >= 75`. No-input plans
+  (score defaults to 0.0) correctly return `FAIL`.
+
+### Added — certify polish
+
+- `certify` output now includes `health_summary` (score + verdict +
+  blockers + scan_duration_ms) — a single at-a-glance block for agent
+  loops that don't want to parse the full response.
+
+- `certify` output now includes `axes` dict with per-axis `ok` bool and
+  `how_to_fix` string. When an axis fails, agents get an explicit action
+  ("Add README.md at the project root." / "Run forge wire src
+  --suggest-repairs -- N violation(s).") instead of just a flag.
+
+- `certify` now reports `scan_duration_ms` at top level and inside
+  `health_summary` — agents doing performance budgeting can use this
+  for timeout planning.
+
+- New recipe `bump_version` — checklist for patch/minor/major bumps:
+  edit pyproject.toml, update __version__, write CHANGELOG entry,
+  certify, commit, tag.
+
+- New recipe `fix_test_detection` — debugging guide for when certify
+  reports `ran=false` or `pass_ratio=0` despite pytest passing locally:
+  traces xfailed parse failure, wrong-package import filter, and import
+  smoke failure paths.
+
+### Internal
+
+- CI Ruff lint debt cleared: 50 errors → 0 across recent merges
+  (I001/F401/UP037/UP006/UP035 auto-fixed; UP038/B006/E701/E702/F841
+  manually). Lint now blocks regressions instead of being permanently red.
+
+- Test count: 937 → 975 (+38) — every new capability shipped with
+  pinning tests; certify holds 100.0/100 across the lift.
+
+- README provider matrix updated: Anthropic default → `claude-sonnet-4-6`,
+  OpenAI default → `gpt-4o-mini` (with override hints), `ling` row added.
+
+- Live demo (`forge.atomadic.tech`) and invest links surfaced in README.
+
+---
+
+## 0.5.3 - Documentation metadata sync
+
+Small follow-up to `0.5.2` so the published package description and
+current-facing docs no longer advertise stale `0.3.x` version strings,
+old test counts, or the pre-`0.5.2` MCP tool count.
+
+### Fixed
+
+- README install and contributor snippets now show the current Forge
+  version family and `937 passed, 2 skipped`.
+- Current ecosystem positioning now reflects the `0.5.3` PyPI line and
+  23-tool MCP surface.
+- First-run and VS Code extension docs now reference the current MCP
+  surface/version expectations.
+
+---
+
 ## 0.5.2 - Agent ergonomics and language-aware guidance
 
 Implements the first round of quality-of-life improvements from the

{atomadic_forge-0.5.2 → atomadic_forge-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.5.2
+Version: 0.6.0
 Summary: Atomadic Forge — absorb, enforce, emerge. Polyglot (Python + JavaScript/TypeScript) architecture guardian for AI-generated code.
 Author: Atomadic
 License-Expression: BUSL-1.1
@@ -45,6 +45,8 @@ Dynamic: license-file
 
 > **Absorb. Enforce. Emerge.** The architecture substrate for AI-generated code — now polyglot (Python, JavaScript, TypeScript).
 
+🔗 **Try it live:** [forge.atomadic.tech](https://forge.atomadic.tech) — paste any GitHub repo and watch the analysis in real time.
+
 Forge is a monadic-architecture engine that does three things no existing
 tool combines:
 
@@ -185,7 +187,7 @@ Each tier is a layer of **verified building blocks**. Higher tiers never invent
 
 ```bash
 pip install atomadic-forge
-forge --version   # atomadic-forge 0.3.2
+forge --version   # atomadic-forge 0.5.3
 forge doctor      # environment check
 ```
 
@@ -198,7 +200,7 @@ generate).
 ```bash
 git clone https://github.com/atomadictech/atomadic-forge && cd atomadic-forge
 pip install -e ".[dev]"
-python -m pytest               # 841 passing, 2 skipped
+python -m pytest               # 937 passed, 2 skipped
 ```
 
 ## AI Agent integration (MCP)
@@ -320,9 +322,10 @@ forge chat ask "hello" --provider stub --no-cwd-context --json
 |----------|------|---------|---------------|-------------|
 | `gemini` | **free tier** | `GEMINI_API_KEY` / `GOOGLE_API_KEY` | `gemini-2.5-flash` | Best free cloud option; override with `FORGE_GEMINI_MODEL` |
 | `nexus` / `aaaa-nexus` | paid | `AAAA_NEXUS_API_KEY` | (Nexus default) | AAAA-Nexus sovereign AI; most reliable for long runs |
-| `anthropic` | paid | `ANTHROPIC_API_KEY` | `claude-3-5-sonnet-latest` | Highest code quality |
-| `openai` | paid | `OPENAI_API_KEY` | `gpt-4o-mini` | Cheap GPT path |
-| `openrouter` | **free tier available** | `OPENROUTER_API_KEY` | `google/gemma-3-27b-it:free` | Access 200+ models; good fallback when Gemini quota exhausted; override with `FORGE_OPENROUTER_MODEL` |
+| `anthropic` | paid | `ANTHROPIC_API_KEY` | `claude-sonnet-4-6` | Highest code quality (Claude 4.x; override with `claude-opus-4-7` for max reasoning or `claude-haiku-4-5-20251001` for speed) |
+| `openai` | paid | `OPENAI_API_KEY` | `gpt-4o-mini` | Cheap GPT path; override to `gpt-4.1` or `gpt-4o` for higher quality |
+| `openrouter` | **free tier available** | `OPENROUTER_API_KEY` | `inclusionai/ling-2.6-1t:free` | Access 200+ models; good fallback when Gemini quota exhausted; override with `FORGE_OPENROUTER_MODEL` |
+| `ling` | **free** | `OPENROUTER_API_KEY` | `inclusionai/ling-2.6-1t:free` | Shortcut for Ling-2.6-1T (1T-param MoE, 262K ctx, SOTA SWE-bench) — frontier model at zero cost via OpenRouter |
 | `ollama` | free, local | `FORGE_OLLAMA=1` | `qwen2.5-coder:7b` | Offline; fully private |
 | `stub` | free, offline | n/a | n/a | Tests, CI, dry-runs |
 
@@ -449,7 +452,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) | **0.3.2** — on PyPI, 841 tests, 100/100, MCP server, desktop GUI |
+| **Atomadic Forge** | Absorb-and-emerge engine for developers (this repo) | **0.5.3** — on PyPI, 937 tests, 100/100, 23-tool MCP server, desktop GUI |
 | **Atomadic Assistant** | Sovereign AI assistant with cognitive loop on Cloudflare | In development |
 
 ## License
@@ -477,7 +480,7 @@ Apache 2.0.
 **Forge itself is monadic.** Every source file belongs to one tier. The repo is a worked example:
 
 ```bash
-python -m pytest                     # 841 passing, 2 skipped
+python -m pytest                     # 937 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)
@@ -508,3 +511,7 @@ forge commandsmith smoke             # Smoke-test all 36+ registered verbs
 - ✓ **Cloudflare badge worker** — live certify score in any README
 - ✗ Chain-of-custody notarization (future)
 - ✗ Rust / Go tier classification (roadmap)
+
+---
+
+💰 **Interested in investing?** [invest.atomadic.tech](https://invest.atomadic.tech) — learn about the Atomadic Technologies ecosystem.

{atomadic_forge-0.5.2 → atomadic_forge-0.6.0}/README.md

@@ -13,6 +13,8 @@
 
 > **Absorb. Enforce. Emerge.** The architecture substrate for AI-generated code — now polyglot (Python, JavaScript, TypeScript).
 
+🔗 **Try it live:** [forge.atomadic.tech](https://forge.atomadic.tech) — paste any GitHub repo and watch the analysis in real time.
+
 Forge is a monadic-architecture engine that does three things no existing
 tool combines:
 
@@ -153,7 +155,7 @@ Each tier is a layer of **verified building blocks**. Higher tiers never invent
 
 ```bash
 pip install atomadic-forge
-forge --version   # atomadic-forge 0.3.2
+forge --version   # atomadic-forge 0.5.3
 forge doctor      # environment check
 ```
 
@@ -166,7 +168,7 @@ generate).
 ```bash
 git clone https://github.com/atomadictech/atomadic-forge && cd atomadic-forge
 pip install -e ".[dev]"
-python -m pytest               # 841 passing, 2 skipped
+python -m pytest               # 937 passed, 2 skipped
 ```
 
 ## AI Agent integration (MCP)
@@ -288,9 +290,10 @@ forge chat ask "hello" --provider stub --no-cwd-context --json
 |----------|------|---------|---------------|-------------|
 | `gemini` | **free tier** | `GEMINI_API_KEY` / `GOOGLE_API_KEY` | `gemini-2.5-flash` | Best free cloud option; override with `FORGE_GEMINI_MODEL` |
 | `nexus` / `aaaa-nexus` | paid | `AAAA_NEXUS_API_KEY` | (Nexus default) | AAAA-Nexus sovereign AI; most reliable for long runs |
-| `anthropic` | paid | `ANTHROPIC_API_KEY` | `claude-3-5-sonnet-latest` | Highest code quality |
-| `openai` | paid | `OPENAI_API_KEY` | `gpt-4o-mini` | Cheap GPT path |
-| `openrouter` | **free tier available** | `OPENROUTER_API_KEY` | `google/gemma-3-27b-it:free` | Access 200+ models; good fallback when Gemini quota exhausted; override with `FORGE_OPENROUTER_MODEL` |
+| `anthropic` | paid | `ANTHROPIC_API_KEY` | `claude-sonnet-4-6` | Highest code quality (Claude 4.x; override with `claude-opus-4-7` for max reasoning or `claude-haiku-4-5-20251001` for speed) |
+| `openai` | paid | `OPENAI_API_KEY` | `gpt-4o-mini` | Cheap GPT path; override to `gpt-4.1` or `gpt-4o` for higher quality |
+| `openrouter` | **free tier available** | `OPENROUTER_API_KEY` | `inclusionai/ling-2.6-1t:free` | Access 200+ models; good fallback when Gemini quota exhausted; override with `FORGE_OPENROUTER_MODEL` |
+| `ling` | **free** | `OPENROUTER_API_KEY` | `inclusionai/ling-2.6-1t:free` | Shortcut for Ling-2.6-1T (1T-param MoE, 262K ctx, SOTA SWE-bench) — frontier model at zero cost via OpenRouter |
 | `ollama` | free, local | `FORGE_OLLAMA=1` | `qwen2.5-coder:7b` | Offline; fully private |
 | `stub` | free, offline | n/a | n/a | Tests, CI, dry-runs |
 
@@ -417,7 +420,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) | **0.3.2** — on PyPI, 841 tests, 100/100, MCP server, desktop GUI |
+| **Atomadic Forge** | Absorb-and-emerge engine for developers (this repo) | **0.5.3** — on PyPI, 937 tests, 100/100, 23-tool MCP server, desktop GUI |
 | **Atomadic Assistant** | Sovereign AI assistant with cognitive loop on Cloudflare | In development |
 
 ## License
@@ -445,7 +448,7 @@ Apache 2.0.
 **Forge itself is monadic.** Every source file belongs to one tier. The repo is a worked example:
 
 ```bash
-python -m pytest                     # 841 passing, 2 skipped
+python -m pytest                     # 937 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)
@@ -476,3 +479,7 @@ forge commandsmith smoke             # Smoke-test all 36+ registered verbs
 - ✓ **Cloudflare badge worker** — live certify score in any README
 - ✗ Chain-of-custody notarization (future)
 - ✗ Rust / Go tier classification (roadmap)
+
+---
+
+💰 **Interested in investing?** [invest.atomadic.tech](https://invest.atomadic.tech) — learn about the Atomadic Technologies ecosystem.

{atomadic_forge-0.5.2 → atomadic_forge-0.6.0}/docs/AGENTS_GUIDE.md

@@ -58,7 +58,7 @@ Or against the installed CLI:
 
 ```bash
 $ forge --version
-atomadic-forge 0.5.2
+atomadic-forge 0.5.3
 ```
 
 The `--version` flag (and `-V`) is the canonical "Forge is wired in
@@ -368,7 +368,7 @@ Forge's normative answer; only the *attestation chain* is missing.
 | Symptom | Likely cause | Fix |
 |---|---|---|
 | Tools list returns 0 tools | MCP client didn't pass `--project .` | Check args in MCP config |
-| Tools list returns < 23 (e.g. 21 or 10) | Old `forge` install | `pip install -U atomadic-forge` (or `pip install -e .` from the repo). Pin `forge --version >= 0.5.2`. |
+| Tools list returns < 23 (e.g. 21 or 10) | Old `forge` install | `pip install -U atomadic-forge` (or `pip install -e .` from the repo). Pin `forge --version >= 0.5.3`. |
 | `wire` says PASS but agent still hits import errors | Agent is running tests in a different working directory | `--project` should match the test cwd |
 | `certify` returns score 90 instead of 100 | Project has no `.github/workflows/` and no `CHANGELOG.md` (operational axis is 0) | Add either; both are 5pts |
 | Receipt's `signatures` is null | `AAAA_NEXUS_API_KEY` not set, or AAAA-Nexus endpoint not yet shipped | Soft-fail behavior — Receipt is still valid for local use |

{atomadic_forge-0.5.2 → atomadic_forge-0.6.0}/docs/COMMANDS.md

@@ -1,6 +1,6 @@
 # Atomadic Forge — Command Reference
 
-All verbs available in the `forge` CLI as of 0.5.2.
+All verbs available in the `forge` CLI as of 0.5.3.
 
 ## Pipeline / absorption
 
@@ -419,7 +419,7 @@ Prints the installed Forge version and exits 0. Hardened in v0.3.0
 
 ```bash
 $ forge --version
-atomadic-forge 0.5.2
+atomadic-forge 0.5.3
 ```
 
 ### `.forge` sidecars — Lane D W8

{atomadic_forge-0.5.2 → atomadic_forge-0.6.0}/docs/FIRST_10_MINUTES.md

@@ -185,7 +185,7 @@ You now know enough to use Forge productively. For specific topics:
 - [tutorials/](tutorials/) — quickstart tutorials and the JS / TS path.
 - **[AGENTS_GUIDE.md](AGENTS_GUIDE.md)** — using Forge from a coding
   agent (Cursor / Claude Code / Aider / Devin / Copilot / Codex) via
-  the built-in MCP server. One config snippet, **21 tools**, 5
+  the built-in MCP server. One config snippet, **23 tools**, 5
   resources. The fastest way to put Forge in front of every PR your
   team's agents touch.
 - [MULTI_REPO.md](MULTI_REPO.md) — absorbing more than one repo at once.

{atomadic_forge-0.5.2 → atomadic_forge-0.6.0}/pyproject.toml

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

{atomadic_forge-0.5.2 → atomadic_forge-0.6.0}/src/atomadic_forge/__init__.py

@@ -9,4 +9,4 @@ Public version surface only — every symbol lives in its tier package and
 is re-exported lazily by the CLI.
 """
 
-__version__ = "0.5.2"
+__version__ = "0.6.0"

{atomadic_forge-0.5.2 → atomadic_forge-0.6.0}/src/atomadic_forge/a0_qk_constants/auth_constants.py

@@ -26,7 +26,6 @@ from __future__ import annotations
 
 from typing import TypedDict
 
-
 # ---- endpoints ----------------------------------------------------------
 
 DEFAULT_AUTH_ENDPOINT = "https://forge-auth.atomadic.tech/v1/forge/auth/verify"

{atomadic_forge-0.5.2 → atomadic_forge-0.6.0}/src/atomadic_forge/a1_at_functions/agent_plan_emitter.py

@@ -279,7 +279,8 @@ def emit_agent_plan(
     score = float((certify_report or {}).get("score", 0.0))
     if wire_report and wire_report.get("verdict") == "PASS" and score >= 100:
         verdict = "PASS"
-    elif not cards:
+    elif not cards and score >= 75:
+        # No action cards AND score is acceptable -- genuinely passing.
         verdict = "PASS"
     else:
         verdict = "FAIL"

{atomadic_forge-0.5.2 → atomadic_forge-0.6.0}/src/atomadic_forge/a1_at_functions/certify_checks.py

@@ -285,6 +285,7 @@ def check_changelog(root: Path) -> tuple[bool, dict]:
 
 def certify(root: Path, *, project: str = "Atomadic project",
             package: str | None = None) -> dict:
+    _scan_start = time.perf_counter()
     docs_ok, docs_d = check_documentation(root)
     tests_ok, tests_d = check_tests_present(root)
     layout_ok, layout_d = check_tier_layout(root, package)
@@ -358,12 +359,14 @@ def certify(root: Path, *, project: str = "Atomadic project",
                     "(or run `forge auto` to scaffold them).")
     if not wire_ok:
         issues.append(f"Upward-import violations: {wire_d['violation_count']}")
-        recs.append("Run `forge wire` to inspect violations, then move imports down-tier or split modules.")
+        recs.append("Run `forge wire` to inspect violations, then move imports "
+                    "down-tier or split modules.")
     if not no_stubs:
         issues.append(f"Stub bodies detected: {len(stub_findings)} "
                        "function(s) with `pass`/NotImplementedError/TODO")
         for f in stub_findings[:5]:
-            issues.append(f"  · {f['file']}:{f['lineno']} {f['qualname']} ({f['kind']})")
+            issues.append(f"  · {f['file']}:{f['lineno']} "
+                           f"{f['qualname']} ({f['kind']})")
         recs.append("Replace stub bodies with real implementations before shipping.")
     if smoke is not None and not importable:
         issues.append(f"Package fails to import: {smoke['error_kind']} — "
@@ -392,7 +395,7 @@ def certify(root: Path, *, project: str = "Atomadic project",
     #   docs / layout / wire     — 10 each   (30 max — structural axis)
     #   tests-present            —  5         (structural axis)
     #   importable runtime       — 25         (runtime axis)
-    #   tests-pass-ratio         — 30 max     (behavioural axis — rewards actual behaviour)
+    #   tests-pass-ratio         — 30 max     (behavioural axis)
     #   ci workflow              —  5         (operational axis)
     #   changelog/release notes  —  5         (operational axis)
     #   stub-body penalty        — up to 40 deducted
@@ -410,6 +413,9 @@ def certify(root: Path, *, project: str = "Atomadic project",
         + (5 if changelog_ok else 0)
     )
     score = max(0.0, float(structural + runtime + behavioral + operational) - stub_pen)
+    scan_duration_ms = int((time.perf_counter() - _scan_start) * 1000)
+    blockers = len([i for i in issues if not i.startswith("  ·")])
+    verdict = "PASS" if score >= 75 and blockers == 0 else "FAIL"
     return {
         "schema_version": "atomadic-forge.certify/v1",
         "project": project,
@@ -424,6 +430,12 @@ def certify(root: Path, *, project: str = "Atomadic project",
         "ci_workflow_present": ci_ok,
         "changelog_present": changelog_ok,
         "score": score,
+        "health_summary": {
+            "score": score,
+            "verdict": verdict,
+            "blockers": blockers,
+            "scan_duration_ms": scan_duration_ms,
+        },
         "score_components": {
             "structural":   structural,
             "runtime":      runtime,
@@ -433,6 +445,64 @@ def certify(root: Path, *, project: str = "Atomadic project",
         },
         "issues": issues,
         "recommendations": recs,
+        "axes": {
+            "documentation": {
+                "ok": docs_ok, "score_weight": 10,
+                "how_to_fix": ("Add README.md or docs/*.md files."
+                               if not docs_ok else None),
+            },
+            "tests_present": {
+                "ok": tests_ok, "score_weight": 5,
+                "how_to_fix": ("Create tests/test_*.py with at least one test."
+                               if not tests_ok else None),
+            },
+            "tier_layout": {
+                "ok": layout_ok, "score_weight": 10,
+                "how_to_fix": (
+                    "Add 3+ of a0_qk_constants/ a1_at_functions/ "
+                    "a2_mo_composites/ a3_og_features/ a4_sy_orchestration/."
+                ) if not layout_ok else None,
+            },
+            "wire_clean": {
+                "ok": wire_ok, "score_weight": 10,
+                "how_to_fix": (
+                    f"Fix {wire_d['violation_count']} upward import(s): "
+                    "run forge wire --suggest-repairs."
+                ) if not wire_ok else None,
+            },
+            "no_stubs": {
+                "ok": no_stubs, "score_weight": 0,
+                "how_to_fix": (
+                    f"Replace {len(stub_findings)} stub bodies "
+                    "(pass/NotImplementedError/TODO) with real code."
+                ) if not no_stubs else None,
+            },
+            "importable": {
+                "ok": importable, "score_weight": 25,
+                "how_to_fix": (
+                    f"Fix import error: {smoke['error_kind']} — "
+                     f"{smoke['error_message']}"
+                     if smoke else "Package not importable."
+                ) if not importable else None,
+            },
+            "tests_pass": {
+                "ok": test_pass_ratio == 1.0, "score_weight": 30,
+                "how_to_fix": (
+                    f"Fix {test_run['failed']} failing test(s)." if test_run
+                    else "Run pytest to diagnose."
+                ) if test_pass_ratio < 1.0 else None,
+            },
+            "ci_workflow": {
+                "ok": ci_ok, "score_weight": 5,
+                "how_to_fix": ("Add .github/workflows/ci.yml."
+                               if not ci_ok else None),
+            },
+            "changelog": {
+                "ok": changelog_ok, "score_weight": 5,
+                "how_to_fix": ("Add CHANGELOG.md (200+ bytes) at project root."
+                               if not changelog_ok else None),
+            },
+        },
         "detail": {"docs": docs_d, "tests": tests_d, "layout": layout_d,
                    "wire": wire_d,
                    "ci":  ci_d,

atomadic_forge-0.6.0/src/atomadic_forge/a1_at_functions/code_signature.py

@@ -0,0 +1,197 @@
+"""Tier a1 - deterministic semantic fingerprint for Python source.
+
+Pure stateless. Given a Python source string, returns stable hashes
+that survive renames, whitespace changes, and comment edits but
+break on real logic changes. The atomic primitive that makes
+"never reinvent the wheel" enforceable: two modules with identical
+function-shape signatures are duplicate logic.
+
+PREVENT pillar - block duplicate emits at the gate before they ship.
+
+Returned shape::
+
+    ModuleSignature(
+        schema="atomadic-forge.code-signature/v1",
+        module_hash="<hex>",        # full-module shape hash
+        functions=[FunctionSignature(...), ...],
+        classes=[ClassSignature(...), ...],
+        imports=("os", "ast", ...),  # sorted top-level imports
+    )
+
+Two ModuleSignatures with the same ``module_hash`` are byte-stable
+duplicates of each other's logic, regardless of identifier names
+or formatting.
+"""
+
+from __future__ import annotations
+
+import ast
+import hashlib
+from dataclasses import dataclass, field
+
+SCHEMA: str = "atomadic-forge.code-signature/v1"
+
+
+@dataclass(frozen=True)
+class FunctionSignature:
+    name: str
+    arg_count: int
+    is_async: bool
+    body_hash: str       # hash of normalized AST (no identifiers)
+    calls: tuple[str, ...]  # sorted set of names this function calls
+
+
+@dataclass(frozen=True)
+class ClassSignature:
+    name: str
+    method_count: int
+    has_state: bool      # __init__ assigns to self.X
+    body_hash: str
+
+
+@dataclass(frozen=True)
+class ModuleSignature:
+    schema: str = SCHEMA
+    module_hash: str = ""
+    functions: tuple[FunctionSignature, ...] = field(default_factory=tuple)
+    classes: tuple[ClassSignature, ...] = field(default_factory=tuple)
+    imports: tuple[str, ...] = field(default_factory=tuple)
+    parse_ok: bool = True
+
+
+def _normalize_ast(node: ast.AST) -> str:
+    """Walk an AST node and emit a string of just the structural
+    shape - no identifier names, no string literals, no docstrings.
+    Two functions with identical control flow + call shape get
+    identical normalized output regardless of variable names."""
+    parts: list[str] = []
+    for sub in ast.walk(node):
+        cls = type(sub).__name__
+        # Capture structural detail without leaking identifiers.
+        if isinstance(sub, ast.Constant):
+            parts.append(f"C:{type(sub.value).__name__}")
+        elif isinstance(sub, ast.BinOp):
+            parts.append(f"B:{type(sub.op).__name__}")
+        elif isinstance(sub, ast.Compare):
+            ops = "/".join(type(o).__name__ for o in sub.ops)
+            parts.append(f"Cmp:{ops}")
+        elif isinstance(sub, ast.UnaryOp):
+            parts.append(f"U:{type(sub.op).__name__}")
+        elif isinstance(sub, ast.For | ast.While | ast.If | ast.Try
+                              | ast.With | ast.Return | ast.Raise
+                              | ast.Assign | ast.AugAssign | ast.AnnAssign
+                              | ast.FunctionDef | ast.AsyncFunctionDef
+                              | ast.ClassDef | ast.Lambda | ast.ListComp
+                              | ast.DictComp | ast.SetComp | ast.GeneratorExp
+                              | ast.Import | ast.ImportFrom | ast.Call
+                              | ast.Attribute | ast.Subscript):
+            parts.append(cls)
+    return "|".join(parts)
+
+
+def _hash(s: str) -> str:
+    return hashlib.sha256(s.encode("utf-8")).hexdigest()[:16]
+
+
+def _called_names(func_node: ast.AST) -> tuple[str, ...]:
+    """Set of names called inside a function body. Used to detect
+    'this module just wraps existing primitives' (good reuse) vs
+    'this module reimplements logic locally' (bad)."""
+    out: set[str] = set()
+    for sub in ast.walk(func_node):
+        if isinstance(sub, ast.Call):
+            f = sub.func
+            if isinstance(f, ast.Name):
+                out.add(f.id)
+            elif isinstance(f, ast.Attribute):
+                out.add(f.attr)
+    return tuple(sorted(out))
+
+
+def _has_self_assign(func_node: ast.FunctionDef) -> bool:
+    for stmt in ast.walk(func_node):
+        if isinstance(stmt, ast.Assign):
+            for tgt in stmt.targets:
+                if (isinstance(tgt, ast.Attribute)
+                        and isinstance(tgt.value, ast.Name)
+                        and tgt.value.id == "self"):
+                    return True
+    return False
+
+
+def _signature_function(node: ast.FunctionDef | ast.AsyncFunctionDef
+                         ) -> FunctionSignature:
+    body_hash = _hash(_normalize_ast(node))
+    return FunctionSignature(
+        name=node.name,
+        arg_count=len(node.args.args) + len(node.args.kwonlyargs),
+        is_async=isinstance(node, ast.AsyncFunctionDef),
+        body_hash=body_hash,
+        calls=_called_names(node),
+    )
+
+
+def _signature_class(node: ast.ClassDef) -> ClassSignature:
+    methods = [n for n in node.body
+                if isinstance(n, ast.FunctionDef | ast.AsyncFunctionDef)]
+    has_state = any(_has_self_assign(m) for m in methods
+                     if isinstance(m, ast.FunctionDef)
+                     and m.name == "__init__")
+    body_hash = _hash(_normalize_ast(node))
+    return ClassSignature(
+        name=node.name,
+        method_count=len(methods),
+        has_state=has_state,
+        body_hash=body_hash,
+    )
+
+
+def _top_level_imports(tree: ast.Module) -> tuple[str, ...]:
+    out: set[str] = set()
+    for node in tree.body:
+        if isinstance(node, ast.Import):
+            out.update(a.name for a in node.names)
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                out.add(node.module)
+    return tuple(sorted(out))
+
+
+def signature_of(source: str) -> ModuleSignature:
+    """Pure: source -> ModuleSignature with stable shape hashes."""
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return ModuleSignature(parse_ok=False, module_hash=_hash(source))
+
+    funcs: list[FunctionSignature] = []
+    classes: list[ClassSignature] = []
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+            funcs.append(_signature_function(node))
+        elif isinstance(node, ast.ClassDef):
+            classes.append(_signature_class(node))
+
+    imports = _top_level_imports(tree)
+    # Module hash is order-invariant over functions + classes;
+    # sort by body_hash so two files with same content in different
+    # order collide.
+    fn_hashes = sorted(f.body_hash for f in funcs)
+    cls_hashes = sorted(c.body_hash for c in classes)
+    blob = "|".join(fn_hashes + cls_hashes + list(imports))
+    return ModuleSignature(
+        module_hash=_hash(blob),
+        functions=tuple(funcs),
+        classes=tuple(classes),
+        imports=imports,
+        parse_ok=True,
+    )
+
+
+def function_overlap(a: ModuleSignature, b: ModuleSignature
+                       ) -> tuple[FunctionSignature, ...]:
+    """Functions present in both modules with identical body_hash.
+    Use to spot 'this new module reimplements N functions that
+    already exist' before accepting an emit."""
+    a_by_hash = {f.body_hash: f for f in a.functions}
+    return tuple(f for f in b.functions if f.body_hash in a_by_hash)