atomadic-forge 0.57.1__tar.gz → 0.59.0__tar.gz

{atomadic_forge-0.57.1/src/atomadic_forge.egg-info → atomadic_forge-0.59.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.57.1
+Version: 0.59.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

{atomadic_forge-0.57.1 → atomadic_forge-0.59.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "atomadic-forge"
-version = "0.57.1"
+version = "0.59.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.57.1 → atomadic_forge-0.59.0}/src/atomadic_forge/a0_qk_constants/error_codes.py

@@ -63,6 +63,25 @@ class FCode(TypedDict):
 
 
 F_CODE_REGISTRY: dict[str, FCode] = {
+    # ---- Cherry-pick / remote seed hydration (F0010-F0019) ----
+    "F0017": FCode(
+        code="F0017",
+        name="remote-seed-url-invalid",
+        severity="warn",
+        title="Remote seed URL could not be normalized for harvest/create.",
+        hint_key="",
+        auto_fixable=False,
+        doc_anchor="f0017-remote-seed-url-invalid",
+    ),
+    "F0018": FCode(
+        code="F0018",
+        name="remote-seed-hydration-failed",
+        severity="warn",
+        title="Remote seed repository could not be cloned or refreshed.",
+        hint_key="",
+        auto_fixable=False,
+        doc_anchor="f0018-remote-seed-hydration-failed",
+    ),
     # ---- Wire / upward-import violations (F0040-F0049) ----
     "F0040": FCode(
         code="F0040",

{atomadic_forge-0.57.1 → atomadic_forge-0.59.0}/src/atomadic_forge/a0_qk_constants/nexus_constants.py

@@ -22,11 +22,32 @@ DEFAULT_NEXUS_BASE_URL: Final[str] = "https://atomadic.tech"
 DEFAULT_NEXUS_MCP_PATH: Final[str] = "/mcp"
 
 # Auth: caller supplies ATOMADIC_MASTER_KEY (or per-agent subscription
-# key once the auth-worker side ships per-agent scoping). The bridge
-# never embeds keys in source.
+# key once the auth-worker side ships per-agent scoping). Forge's
+# public/auth gateway keys are accepted as aliases so paid users can
+# run Forge and Nexus from the same master key. The bridge never embeds
+# keys in source.
 ENV_NEXUS_BASE_URL: Final[str] = "ATOMADIC_NEXUS_URL"
 ENV_NEXUS_MASTER_KEY: Final[str] = "ATOMADIC_MASTER_KEY"
 ENV_NEXUS_SUBSCRIPTION_KEY: Final[str] = "ATOMADIC_SUBSCRIPTION_KEY"
+ENV_NEXUS_BASE_URL_ALIASES: Final[tuple[str, ...]] = (
+    "ATOMADIC_NEXUS_URL",
+    "AAAA_NEXUS_URL",
+)
+ENV_NEXUS_MASTER_KEY_ALIASES: Final[tuple[str, ...]] = (
+    "ATOMADIC_MASTER_KEY",
+    "FORGE_MASTER_API_KEY",
+    "AAAA_NEXUS_API_KEY",
+)
+ENV_NEXUS_SUBSCRIPTION_KEY_ALIASES: Final[tuple[str, ...]] = (
+    "ATOMADIC_SUBSCRIPTION_KEY",
+    "FORGE_API_KEY",
+)
+ENV_NEXUS_VAULT_PATH: Final[str] = "ATOMADIC_VAULT_ENV"
+NEXUS_PREMIUM_HINT: Final[str] = (
+    "Nexus attestation skipped. Purchase or configure a Nexus key, reuse "
+    "FORGE_MASTER_API_KEY as a master key, or wire x402 payments for "
+    "metered access."
+)
 
 # ── LIVE primitives we wire against (verified 2026-05-06) ────────────
 # Each is a tools/call name on the Nexus MCP. The bridge exposes
@@ -57,6 +78,11 @@ __all__ = [
     "SCHEMA_VERSION_NEXUS_CALL_V1",
     "DEFAULT_NEXUS_BASE_URL", "DEFAULT_NEXUS_MCP_PATH",
     "ENV_NEXUS_BASE_URL", "ENV_NEXUS_MASTER_KEY", "ENV_NEXUS_SUBSCRIPTION_KEY",
+    "ENV_NEXUS_BASE_URL_ALIASES",
+    "ENV_NEXUS_MASTER_KEY_ALIASES",
+    "ENV_NEXUS_SUBSCRIPTION_KEY_ALIASES",
+    "ENV_NEXUS_VAULT_PATH",
+    "NEXUS_PREMIUM_HINT",
     "NEXUS_TOOL_IDENTITY_VERIFY", "NEXUS_TOOL_FEDERATION_MINT",
     "NEXUS_TOOL_AUTHORIZE_ACTION", "NEXUS_TOOL_SYS_TRUST_GATE",
     "NEXUS_TOOL_CONTRACT_VERIFY", "NEXUS_TOOL_LINEAGE_RECORD",

atomadic_forge-0.59.0/src/atomadic_forge/a1_at_functions/ast_scope_lock.py

@@ -0,0 +1,253 @@
+"""Tier a1 — pure AST scope locks for multi-repo swarms.
+
+Golden Path Lane C W6 follow-on deliverable. ``audit(action='ast_scope')``
+uses this module to compress a proposed multi-repo mutation into exact
+function/class node envelopes before any agent edits files. AAAA-Nexus can
+attest the returned lock payload through existing lineage primitives, while
+the math here stays local, deterministic, and dependency-free.
+"""
+from __future__ import annotations
+
+import ast
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+SCHEMA_VERSION_AST_SCOPE_V1 = "atomadic-forge.ast_scope/v1"
+
+
+def _tier_for_path(path: str) -> str:
+    for part in Path(path).parts:
+        if part.startswith("a") and part in {
+            "a0_qk_constants",
+            "a1_at_functions",
+            "a2_mo_composites",
+            "a3_og_features",
+            "a4_sy_orchestration",
+        }:
+            return part
+    return ""
+
+
+def _sha(payload: Any, *, size: int = 16) -> str:
+    raw = json.dumps(payload, sort_keys=True, separators=(",", ":"), default=str)
+    return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:size]
+
+
+def _module_for(rel: str) -> str:
+    p = Path(rel).with_suffix("")
+    parts = [part for part in p.parts if part != "src"]
+    if parts and parts[-1] == "__init__":
+        parts.pop()
+    return ".".join(parts)
+
+
+def _node_source_digest(source_lines: list[str], start: int, end: int) -> str:
+    text = "\n".join(source_lines[max(0, start - 1): max(start - 1, end)])
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()[:16]
+
+
+def _collect_python_nodes(path: Path, *, project_root: Path) -> list[dict[str, Any]]:
+    rel = path.relative_to(project_root).as_posix()
+    try:
+        text = path.read_text(encoding="utf-8", errors="replace")
+        tree = ast.parse(text, filename=str(path))
+    except (OSError, SyntaxError):
+        return []
+    lines = text.splitlines()
+    module = _module_for(rel)
+    out: list[dict[str, Any]] = []
+
+    def add_node(node: ast.AST, *, name: str, kind: str) -> None:
+        start = int(getattr(node, "lineno", 1))
+        end = int(getattr(node, "end_lineno", start))
+        qualname = f"{module}.{name}" if module else name
+        out.append({
+            "node_id": "ast-" + _sha({"file": rel, "qualname": qualname, "start": start, "end": end}),
+            "file": rel,
+            "qualname": qualname,
+            "kind": kind,
+            "tier": _tier_for_path(rel),
+            "start_line": start,
+            "end_line": end,
+            "line_span": max(1, end - start + 1),
+            "source_digest": _node_source_digest(lines, start, end),
+        })
+
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+            add_node(node, name=node.name, kind="function")
+        elif isinstance(node, ast.ClassDef):
+            add_node(node, name=node.name, kind="class")
+            for sub in node.body:
+                if isinstance(sub, ast.FunctionDef | ast.AsyncFunctionDef):
+                    add_node(sub, name=f"{node.name}.{sub.name}", kind="method")
+    return out
+
+
+def _target_matches(node: dict[str, Any], targets: set[str]) -> bool:
+    if not targets:
+        return True
+    qual = str(node.get("qualname", ""))
+    return qual in targets or any(qual.endswith("." + t) for t in targets)
+
+
+def build_ast_scope_blueprint(
+    *,
+    project_roots: list[Path | str],
+    targets: list[str] | None = None,
+    max_nodes: int = 200,
+) -> dict[str, Any]:
+    """Return compressed AST node scope for one or more repos.
+
+    ``targets`` may contain full qualnames or suffixes such as
+    ``AuthClient.refresh``. When omitted, the blueprint inventories up to
+    ``max_nodes`` nodes per portfolio pass.
+    """
+    target_set = {t for t in (targets or []) if t}
+    repos: list[dict[str, Any]] = []
+    all_nodes: list[dict[str, Any]] = []
+    raw_py_file_count = 0
+    raw_line_count = 0
+    for root_raw in project_roots:
+        root = Path(root_raw).resolve()
+        repo_nodes: list[dict[str, Any]] = []
+        repo_py_file_count = 0
+        repo_line_count = 0
+        if root.exists():
+            for py_file in sorted(root.rglob("*.py")):
+                rel_parts = py_file.relative_to(root).parts
+                if any(part in {"__pycache__", ".venv", "venv", ".git"} for part in rel_parts):
+                    continue
+                repo_py_file_count += 1
+                raw_py_file_count += 1
+                try:
+                    lines_here = py_file.read_text(
+                        encoding="utf-8",
+                        errors="replace",
+                    ).count("\n") + 1
+                except OSError:
+                    lines_here = 0
+                repo_line_count += lines_here
+                raw_line_count += lines_here
+                for node in _collect_python_nodes(py_file, project_root=root):
+                    if _target_matches(node, target_set):
+                        node = {**node, "repo_root": str(root)}
+                        repo_nodes.append(node)
+                        all_nodes.append(node)
+                    if len(all_nodes) >= max_nodes:
+                        break
+                if len(all_nodes) >= max_nodes:
+                    break
+        repos.append({
+            "repo_root": str(root),
+            "exists": root.exists(),
+            "node_count": len(repo_nodes),
+            "python_file_count": repo_py_file_count,
+            "python_line_count": repo_line_count,
+        })
+        if len(all_nodes) >= max_nodes:
+            break
+    scanned_lines = sum(int(n["line_span"]) for n in all_nodes)
+    compressed_tokens = max(1, len(json.dumps(all_nodes, default=str)) // 4)
+    raw_token_estimate = max(compressed_tokens, raw_line_count * 4)
+    savings_pct = round(100.0 * (1.0 - (compressed_tokens / raw_token_estimate)), 1)
+    return {
+        "schema_version": SCHEMA_VERSION_AST_SCOPE_V1,
+        "project_roots": [str(Path(p).resolve()) for p in project_roots],
+        "targets": sorted(target_set),
+        "repos": repos,
+        "node_count": len(all_nodes),
+        "nodes": all_nodes,
+        "compressed_context": {
+            "ast_lines_retained": scanned_lines,
+            "raw_python_files": raw_py_file_count,
+            "raw_python_lines": raw_line_count,
+            "compressed_tokens_estimate": compressed_tokens,
+            "raw_tokens_estimate": raw_token_estimate,
+            "token_savings_pct": savings_pct,
+        },
+    }
+
+
+def mint_ast_locks(
+    blueprint: dict[str, Any],
+    *,
+    agent_ids: list[str] | None = None,
+    ttl_secs: int = 3600,
+) -> dict[str, Any]:
+    """Mint deterministic local locks over blueprint nodes.
+
+    These are not remote AAAA-Nexus tokens. They are scope payloads suitable
+    for Nexus ``lineage_record`` attestation or ``authorize_action`` resource
+    checks with today's live Nexus surface.
+    """
+    agents = agent_ids or ["agent-0"]
+    locks: list[dict[str, Any]] = []
+    nodes = list(blueprint.get("nodes") or [])
+    for idx, node in enumerate(nodes):
+        agent_id = agents[idx % len(agents)]
+        resource = (
+            f"{node.get('repo_root')}::{node.get('file')}:"
+            f"{node.get('start_line')}-{node.get('end_line')}::{node.get('qualname')}"
+        )
+        payload = {
+            "agent_id": agent_id,
+            "node_id": node.get("node_id"),
+            "resource": resource,
+            "ttl_secs": ttl_secs,
+            "source_digest": node.get("source_digest"),
+        }
+        locks.append({
+            "lock_id": "lock-" + _sha(payload, size=20),
+            **payload,
+            "allowed_file": node.get("file"),
+            "allowed_line_range": [node.get("start_line"), node.get("end_line")],
+            "tier": node.get("tier"),
+            "nexus_attestable": True,
+            "nexus_live_op": "lineage_record",
+        })
+    return {
+        "schema_version": "atomadic-forge.ast_locks/v1",
+        "blueprint_hash": _sha(blueprint, size=20),
+        "lock_count": len(locks),
+        "locks": locks,
+        "ttl_secs": ttl_secs,
+    }
+
+
+def ast_scope_plan(
+    *,
+    project_roots: list[Path | str],
+    targets: list[str] | None = None,
+    agent_ids: list[str] | None = None,
+    ttl_secs: int = 3600,
+    max_nodes: int = 200,
+) -> dict[str, Any]:
+    """Return blueprint + locks in one MCP-friendly envelope."""
+    blueprint = build_ast_scope_blueprint(
+        project_roots=project_roots,
+        targets=targets,
+        max_nodes=max_nodes,
+    )
+    locks = mint_ast_locks(blueprint, agent_ids=agent_ids, ttl_secs=ttl_secs)
+    return {
+        "schema_version": "atomadic-forge.ast_scope_plan/v1",
+        "blueprint": blueprint,
+        "locks": locks,
+        "verdict": "PASS" if locks["lock_count"] else "REFINE",
+        "summary": (
+            f"{blueprint['node_count']} AST node(s), "
+            f"{locks['lock_count']} lock(s), "
+            f"{blueprint['compressed_context']['token_savings_pct']}% estimated token savings"
+        ),
+    }
+
+
+__all__ = (
+    "SCHEMA_VERSION_AST_SCOPE_V1",
+    "ast_scope_plan",
+    "build_ast_scope_blueprint",
+    "mint_ast_locks",
+)

{atomadic_forge-0.57.1 → atomadic_forge-0.59.0}/src/atomadic_forge/a1_at_functions/cherry_pick.py

@@ -8,11 +8,28 @@ the assimilate phase; this layer just records intent.
 from __future__ import annotations
 
 from collections.abc import Iterable
+from pathlib import PurePosixPath
+
+from ..a0_qk_constants.lang_extensions import NON_TIER_SOURCE_DIRS
+
+
+def _is_in_non_tier_dir(file_rel: str) -> bool:
+    """True when the relative file path lives under a non-tier source dir.
+
+    Test files, benchmarks, and examples should never be promoted into
+    the tier surface of an absorbed package — they describe behavior of
+    *other* code, not new shipping symbols. Closes GAP-004.
+    """
+    if not file_rel:
+        return False
+    parts = PurePosixPath(file_rel.replace("\\", "/")).parts
+    return any(p in NON_TIER_SOURCE_DIRS for p in parts)
 
 
 def select_items(scout_report: dict, *, names: Iterable[str] | None = None,
                  pick_all: bool = False, min_confidence: float = 0.0,
-                 only_tier: str | None = None) -> dict:
+                 only_tier: str | None = None,
+                 include_non_tier_dirs: bool = False) -> dict:
     """Build a cherry_pick manifest from a scout report.
 
     Filters:
@@ -22,6 +39,9 @@ def select_items(scout_report: dict, *, names: Iterable[str] | None = None,
         (Forge currently emits 0.0 for hard hits and 0.5 for fallbacks; future
         versions will produce richer signals.)
       * ``only_tier`` — restrict to symbols already classified to this tier.
+      * ``include_non_tier_dirs`` — when False (default), drop symbols whose
+        source file lives under tests/, test/, benchmarks/, examples/, etc.
+        Pass True only when you explicitly want to absorb test fixtures.
     """
     syms = scout_report.get("symbols", [])
     wanted = set(names) if names else None
@@ -33,6 +53,9 @@ def select_items(scout_report: dict, *, names: Iterable[str] | None = None,
             continue
         if only_tier and s["tier_guess"] != only_tier:
             continue
+        if (not include_non_tier_dirs
+                and _is_in_non_tier_dir(s.get("file", ""))):
+            continue
         items.append({
             "qualname": s["qualname"],
             "target_tier": s["tier_guess"],

{atomadic_forge-0.57.1 → atomadic_forge-0.59.0}/src/atomadic_forge/a1_at_functions/emergent_signature_extract.py

@@ -14,6 +14,7 @@ from collections.abc import Iterable
 from pathlib import Path
 
 from ..a0_qk_constants.emergent_types import SymbolSignatureCard
+from ..a0_qk_constants.lang_extensions import PYTHON_EXTS
 
 _TIERS = (
     "a0_qk_constants", "a1_at_functions", "a2_mo_composites",
@@ -35,9 +36,17 @@ def _module_for(file: Path, src_root: Path, package: str) -> str:
     parts = list(rel.parts)
     if parts and parts[-1] == "__init__":
         parts.pop()
+    if not package:
+        return ".".join(parts)
     return ".".join([package, *parts]) if parts else package
 
 
+def _join_flat_module(package: str, module_parts: list[str]) -> str:
+    if not package:
+        return ".".join(module_parts)
+    return ".".join([package, *module_parts]) if module_parts else package
+
+
 def _tier_of(file: Path, src_root: Path) -> str:
     parts = file.relative_to(src_root).parts
     for p in parts:
@@ -58,6 +67,55 @@ def _domain_of(stem: str) -> str:
     return parts[0].lower() if parts else "misc"
 
 
+def _identifier_token(value: str, fallback: str = "symbol") -> str:
+    value = re.sub(r"[^A-Za-z0-9_]+", "_", value).strip("_")
+    if not value or value[0].isdigit():
+        value = f"{fallback}_{value}" if value else fallback
+    return value
+
+
+def _module_from_rel(file: str, package: str) -> str:
+    rel = Path(file).with_suffix("")
+    parts = [_identifier_token(p, "mod") for p in rel.parts]
+    if parts and parts[-1] == "__init__":
+        parts.pop()
+    if package:
+        return ".".join([_identifier_token(package, "pkg"), *parts])
+    return ".".join(parts)
+
+
+def _signature_from_scout_symbol(sym: dict, *, package: str) -> SymbolSignatureCard | None:
+    if sym.get("language") in (None, "python"):
+        return None
+    name = str(sym.get("name") or sym.get("qualname") or "").strip()
+    if not name:
+        return None
+    qual_tail = ".".join(_identifier_token(part, "member")
+                         for part in name.split(".") if part)
+    module = _module_from_rel(str(sym.get("file") or ""), package)
+    if not module or not qual_tail:
+        return None
+    effects = sym.get("effects") or []
+    output = (
+        "Callable"
+        if sym.get("kind") in {"function", "method"}
+        else "Mapping[str, Any]"
+        if sym.get("kind") == "class"
+        else "Any"
+    )
+    return SymbolSignatureCard(
+        name=qual_tail,
+        qualname=f"{module}.{qual_tail}",
+        module=module,
+        tier=str(sym.get("suggested_tier") or sym.get("tier_guess") or "a1_at_functions"),
+        domain=_domain_of(Path(str(sym.get("file") or name)).stem),
+        inputs=[("value", "Any")],
+        output=output,
+        is_pure="io" not in effects and "state" not in effects,
+        docstring=f"{sym.get('language')} {sym.get('kind')} surface",
+    )
+
+
 def _ann_text(node: ast.AST | None) -> str:
     if node is None:
         return "Any"
@@ -212,8 +270,18 @@ def harvest_signatures(
         # Caller passed a repo root, not a src layout.  Use the repo as the
         # walk root and fabricate a one-level package alias from the directory.
         walk_root = src_root
-        package_for_module = src_root.name.replace("-", "_")
-    for py_file in sorted(walk_root.rglob("*.py")):
+        if package and (src_root / f"{package}.py").is_file():
+            # PEP-621/setuptools py-modules layout: files are importable as
+            # top-level modules, not as ``repo_name.<module>``.
+            package_for_module = ""
+        elif package:
+            package_for_module = package
+        else:
+            package_for_module = src_root.name.replace("-", "_")
+    for py_file in sorted(
+        p for p in walk_root.rglob("*")
+        if p.is_file() and p.suffix.lower() in PYTHON_EXTS
+    ):
         if py_file.name.startswith("_"):
             continue
         # Use parts RELATIVE to walk_root so a hidden parent like
@@ -232,11 +300,23 @@ def harvest_signatures(
             module_parts = list(rel.parts)
             if module_parts and module_parts[-1] == "__init__":
                 module_parts.pop()
-            module = ".".join([package_for_module, *module_parts]) if module_parts else package_for_module
+            module = _join_flat_module(package_for_module, module_parts)
         except ValueError:
             module = package_for_module
         tier = _flat_tier_for(py_file)
         domain = _domain_of(py_file.stem)
         cards.extend(_harvest_one_file(py_file, module=module,
                                        tier=tier, domain=domain))
+
+    try:
+        from .scout_walk import harvest_repo
+        scout = harvest_repo(walk_root)
+    except Exception:
+        scout = {"symbols": []}
+    seen = {card["qualname"] for card in cards}
+    for sym in scout.get("symbols") or []:
+        card = _signature_from_scout_symbol(sym, package=package_for_module)
+        if card and card["qualname"] not in seen:
+            cards.append(card)
+            seen.add(card["qualname"])
     return cards

{atomadic_forge-0.57.1 → atomadic_forge-0.59.0}/src/atomadic_forge/a1_at_functions/emergent_synthesize.py

@@ -36,12 +36,19 @@ def _imports_for(chain_qualnames: list[str]) -> list[str]:
     return out
 
 
+def _is_class_method_qualname(q: str) -> bool:
+    module, _, _name = q.rpartition(".")
+    if not module:
+        return False
+    last_seg = module.rsplit(".", 1)[-1]
+    return bool(last_seg and last_seg[0].isupper())
+
+
 def render_emergent_feature(card: EmergentCandidateCard) -> str:
     chain = card["chain"]
     qualnames = chain["chain"]
     bridges = chain["bridges"]
     name = card["name"].replace("-", "_")
-    imports = _imports_for(qualnames)
     summary = card["summary"].replace('"""', "'''")
     novelty = "; ".join(card["novelty_signals"]) or "(none)"
     score = card["score"]
@@ -70,8 +77,6 @@ def render_emergent_feature(card: EmergentCandidateCard) -> str:
         "from typing import Any",
         "",
     ])
-    lines.extend(imports)
-    lines.append("")
     lines.append(f"def run_{name}(seed: Any) -> dict[str, Any]:")
     lines.append(f'    """Wired composition for {card["name"]}.')
     lines.append("")
@@ -80,17 +85,19 @@ def render_emergent_feature(card: EmergentCandidateCard) -> str:
     lines.append("    trace: list[Any] = []")
     lines.append("    value = seed")
     for i, q in enumerate(qualnames):
-        _module, _, callable_name = q.rpartition(".")
-        if "." in callable_name:
-            # method case — fall back to a noop trace step rather than guessing
-            # the receiver.  Manual wiring required.
+        module, _, callable_name = q.rpartition(".")
+        if _is_class_method_qualname(q):
+            # Method case — fall back to a noop trace step rather than guessing
+            # the receiver. Manual wiring required.
             lines.append(
                 f"    # NOTE: step {i+1} is a method ({callable_name}); "
                 "wire the receiver manually."
             )
             lines.append(f"    trace.append(({q!r}, 'unwired-method'))")
             continue
-        lines.append(f"    value = {callable_name}(value)")
+        alias = f"_step_{i+1}_{callable_name}"
+        lines.append(f"    from {module} import {callable_name} as {alias}")
+        lines.append(f"    value = {alias}(value)")
         lines.append(f"    trace.append(({q!r}, value))")
     lines.append("    return {'final': value, 'trace': trace}")
     lines.append("")

{atomadic_forge-0.57.1 → atomadic_forge-0.59.0}/src/atomadic_forge/a1_at_functions/git_churn.py

@@ -87,6 +87,12 @@ def compute_git_churn(
     stats.  Returns a minimal error dict if git is unavailable.
     """
     root = Path(project_root).resolve()
+    if not (root / ".git").exists():
+        return {
+            "schema_version": SCHEMA_VERSION_GIT_CHURN_V1,
+            "available": False,
+            "reason": "not a git repository root",
+        }
     counts = _commit_count_per_file(root, since=since)
     if not counts:
         return {