atomadic-forge 0.75.2__tar.gz → 0.76.0__tar.gz

{atomadic_forge-0.75.2 → atomadic_forge-0.76.0}/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+## v0.76.0 — 2026-05-08
+
+- feat(forge): graft — surgical single-symbol cross-repo capability transfer
+- fix(lint): clear 14 ruff violations blocking CI
+- release: v0.75.3
+- fix(forge): GAP-014 — harvest fail-loud on missing/empty sources
+
+
+## v0.75.3 — 2026-05-08
+
+### Changed
+
+- d4b631b feat(metrics): sync tagged repo metrics surfaces (GP Lane C W6)
+
+
 ## v0.75.2 — 2026-05-08
 
 ### Changed

{atomadic_forge-0.75.2/src/atomadic_forge.egg-info → atomadic_forge-0.76.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.75.2
+Version: 0.76.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
@@ -176,11 +176,11 @@ Forge enforces a **5-tier monadic law** — every source file belongs to exactly
 | `forge plan` | Bounded execution plan with risk + rollback |
 | `forge chat` | Terminal copilot over forge docs |
 
-**84 CLI verbs total.** Full reference: [docs/02-commands.md](docs/02-commands.md)
+**59 CLI verbs total.** Full reference: [docs/02-commands.md](docs/02-commands.md)
 
 ---
 
-## MCP Server — 10 Tools, 112 Actions
+## MCP Server — 10 Tools, 116 Actions
 
 Forge ships a Model Context Protocol server. Add it to Cursor, Claude Code, Aider, Devin, or any MCP-compatible agent:
 
@@ -200,7 +200,7 @@ Forge ships a Model Context Protocol server. Add it to Cursor, Claude Code, Aide
 | Tool | Actions | What it does |
 |------|---------|-------------|
 | `welcome` | — | RECOMMENDED FIRST CALL: onboarding scan, score, narrative, capability tour |
-| `explore` | 16 | Analyze, understand, discover — recon/explain/call_graph/call_graph_summary/smell/lineage/harvest/synergy/scan/swarm/churn/surface_gaps/capability_scout/dead_code/maintainability/concept_bridge |
+| `explore` | 17 | Analyze, understand, discover — recon/explain/call_graph/call_graph_summary/smell/lineage/harvest/synergy/scan/swarm/churn/surface_gaps/capability_scout/dead_code/maintainability/concept_bridge |
 | `audit` | 23 | Quality gates, change safety, trust |
 | `plan` | 10 | Orient + dev utilities — context/compose/policy/recipes/generate/apply/locate/commit/scaffold/steersman |
 | `transmute` | 3 | **FLAGSHIP** spaghetti→certified pipeline — auto/cherry/finalize |
@@ -223,10 +223,10 @@ Full tool reference: [docs/MCP_TOOLS.md](docs/MCP_TOOLS.md) | First call: `welco
 | Metric | Value |
 |--------|-------|
 
-| MCP tools | **10 tools · 112 actions** |
-| CLI verbs | **84** |
-| Source files | **228** (~45K LOC) |
-| Tests | **1555 passing** across **112 test files** |
+| MCP tools | **10 tools · 116 actions** |
+| CLI verbs | **59** |
+| Source files | **232** (~47K LOC) |
+| Tests | **1578 passing** across **114 test files** |
 | Lean4 formal proofs | **872 theorems** (mathematically verified core logic) |
 | Monadic tiers | **5** (a0 → a4, strict upward-only composition) |
 | Languages | Python, JS/TS, Swift, Kotlin, Go, Rust |

{atomadic_forge-0.75.2 → atomadic_forge-0.76.0}/README.md

@@ -144,11 +144,11 @@ Forge enforces a **5-tier monadic law** — every source file belongs to exactly
 | `forge plan` | Bounded execution plan with risk + rollback |
 | `forge chat` | Terminal copilot over forge docs |
 
-**84 CLI verbs total.** Full reference: [docs/02-commands.md](docs/02-commands.md)
+**59 CLI verbs total.** Full reference: [docs/02-commands.md](docs/02-commands.md)
 
 ---
 
-## MCP Server — 10 Tools, 112 Actions
+## MCP Server — 10 Tools, 116 Actions
 
 Forge ships a Model Context Protocol server. Add it to Cursor, Claude Code, Aider, Devin, or any MCP-compatible agent:
 
@@ -168,7 +168,7 @@ Forge ships a Model Context Protocol server. Add it to Cursor, Claude Code, Aide
 | Tool | Actions | What it does |
 |------|---------|-------------|
 | `welcome` | — | RECOMMENDED FIRST CALL: onboarding scan, score, narrative, capability tour |
-| `explore` | 16 | Analyze, understand, discover — recon/explain/call_graph/call_graph_summary/smell/lineage/harvest/synergy/scan/swarm/churn/surface_gaps/capability_scout/dead_code/maintainability/concept_bridge |
+| `explore` | 17 | Analyze, understand, discover — recon/explain/call_graph/call_graph_summary/smell/lineage/harvest/synergy/scan/swarm/churn/surface_gaps/capability_scout/dead_code/maintainability/concept_bridge |
 | `audit` | 23 | Quality gates, change safety, trust |
 | `plan` | 10 | Orient + dev utilities — context/compose/policy/recipes/generate/apply/locate/commit/scaffold/steersman |
 | `transmute` | 3 | **FLAGSHIP** spaghetti→certified pipeline — auto/cherry/finalize |
@@ -191,10 +191,10 @@ Full tool reference: [docs/MCP_TOOLS.md](docs/MCP_TOOLS.md) | First call: `welco
 | Metric | Value |
 |--------|-------|
 
-| MCP tools | **10 tools · 112 actions** |
-| CLI verbs | **84** |
-| Source files | **228** (~45K LOC) |
-| Tests | **1555 passing** across **112 test files** |
+| MCP tools | **10 tools · 116 actions** |
+| CLI verbs | **59** |
+| Source files | **232** (~47K LOC) |
+| Tests | **1578 passing** across **114 test files** |
 | Lean4 formal proofs | **872 theorems** (mathematically verified core logic) |
 | Monadic tiers | **5** (a0 → a4, strict upward-only composition) |
 | Languages | Python, JS/TS, Swift, Kotlin, Go, Rust |

{atomadic_forge-0.75.2 → atomadic_forge-0.76.0}/docs/IDE_INTEGRATION.md

@@ -16,7 +16,7 @@ See `vscode-extension/README.md` for settings + usage.
 
 ## 2. MCP server (works with any MCP-aware assistant)
 
-Forge ships a fully-typed MCP server with **10 tools dispatching 112 actions** spanning recon, wire, certify, plan, enforce, emergent, synergy, wisdom, lineage, hive coordination, and AAAA-Nexus trust gates.  Any of these clients can attach:
+Forge ships a fully-typed MCP server with **10 tools dispatching 116 actions** spanning recon, wire, certify, plan, enforce, emergent, synergy, wisdom, lineage, hive coordination, and AAAA-Nexus trust gates.  Any of these clients can attach:
 
 - **Claude Code** (Anthropic CLI) — `claude mcp add atomadic-forge -- forge mcp serve --project ${workspaceFolder}`
 - **Cursor** — Settings → MCP Servers → add the same command above

atomadic_forge-0.76.0/docs/commands/metrics.md

@@ -0,0 +1,91 @@
+# `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`
+
+## Forge metrics
+
+Use the top-level command when updating Forge's own public counters.
+
+```bash
+forge metrics
+forge metrics --apply
+forge metrics --json
+```
+
+`--apply` rewrites `forge_metrics.json`. This artifact is Forge-specific:
+README badges, release automation, and Worker metadata read from it.
+
+## Product repo metrics
+
+Use the `repo` subcommand when updating any product repository's own public
+surface.
+
+```bash
+forge metrics repo --project /path/to/product
+forge metrics repo --project /path/to/product --apply
+forge metrics repo --project /path/to/product --json
+forge metrics repo --project /path/to/product --init-config --apply
+forge metrics repo --project /path/to/product --apply --commit --push
+```
+
+The repo sync is intentionally separate from Forge metrics. It computes the
+target repo's source files, source lines, test files, languages, name, and
+version, then plans these bounded writes:
+
+| File | Update |
+|------|--------|
+| `repo_metrics.json` | Canonical product metrics artifact |
+| `README.md` | Metrics copy block between `<!-- forge:metrics:start -->` markers |
+| `server.json` | MCP registry version and description, when present |
+
+Dry-run is the default. Passing `--apply` writes the product surface and does
+not mutate `forge_metrics.json`.
+
+### Config and live external surfaces
+
+Repos can opt into a custom metrics surface with
+`.atomadic-forge/repo-metrics.config.json`:
+
+```json
+{
+  "schema_version": "atomadic-forge.repo_metrics_config/v1",
+  "artifact_path": "public/metrics.json",
+  "document_globs": ["README.md", "docs/**/*.md", "website/**/*.mdx"],
+  "readme_block": true,
+  "sync_server_json": true,
+  "extra_metrics": {
+    "customer_count": 42
+  },
+  "aliases": {
+    "customers": "customer_count"
+  }
+}
+```
+
+`artifact_path` is the JSON file your site or Worker can serve. For example,
+set it to `public/metrics.json`, deploy that folder, and the website can fetch
+the same live repo metrics as ordinary JSON.
+
+Any configured document can contain inline metric markers:
+
+```md
+Source files: <!-- forge:metric key=source_file_count format=comma -->0<!-- /forge:metric -->
+Customers: <!-- forge:metric customers -->0<!-- /forge:metric -->
+Languages: <!-- forge:metric languages -->unknown<!-- /forge:metric -->
+```
+
+On `forge metrics repo --apply`, Forge scans the configured document globs,
+updates every marker it finds, writes the metrics artifact, and leaves
+unmarked prose alone. Supported marker formats are `plain`, `comma`,
+`compact`, and `json`. Markers inside fenced code blocks are treated as
+examples and are not updated.
+
+For release automation, pass `--commit` to stage and commit only the files
+Forge planned to write. Pass `--push` to commit if needed and push the current
+branch after the metrics surface is refreshed.
+

{atomadic_forge-0.75.2 → atomadic_forge-0.76.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "atomadic-forge"
-version = "0.75.2"
+version = "0.76.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.76.0/src/atomadic_forge/a1_at_functions/cosine_similarity.py

@@ -0,0 +1,22 @@
+"""Grafted from search_symbols.py (lines 410–423) by `forge graft`."""
+from __future__ import annotations
+
+import math
+
+SCHEMA_VERSION_GRAFT_COSINE_SIMILARITY = "atomadic-forge.graft.cosine_similarity/v1"
+
+def cosine_similarity(a: list[float], b: list[float]) -> float:
+    """Cosine similarity in pure Python (no numpy).
+
+    Returns 0.0 if either vector is zero-length or the lists differ in size.
+    Uses ``math.sqrt`` and ``sum()`` — no external deps.
+    """
+    if not a or not b or len(a) != len(b):
+        return 0.0
+    dot = sum(x * y for x, y in zip(a, b, strict=False))
+    norm_a = math.sqrt(sum(x * x for x in a))
+    norm_b = math.sqrt(sum(y * y for y in b))
+    if norm_a == 0.0 or norm_b == 0.0:
+        return 0.0
+    return dot / (norm_a * norm_b)
+

atomadic_forge-0.76.0/src/atomadic_forge/a1_at_functions/graft_extract.py

@@ -0,0 +1,221 @@
+"""Tier a1 — pure source-extraction helpers for ``forge graft``.
+
+Given a Python source file and a top-level symbol name (function or class),
+return the exact source slice for that symbol — with its docstring,
+decorators, and trailing whitespace preserved. No imports, no deps,
+no I/O beyond the input read. AST-based: deterministic and reproducible.
+
+This is the read-only half of the graft pipeline. The write half lives
+in a3 (``graft_feature``) so this module stays a pure-tier-1 helper.
+"""
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class GraftExtract:
+    """One extracted symbol slice ready to drop into a target file.
+
+    * ``symbol_name`` — the bare top-level name (no qualifier dotting).
+    * ``kind`` — ``"function"`` (def) | ``"async_function"`` (async def) |
+      ``"class"`` (class).
+    * ``source`` — the verbatim source slice, INCLUDING any preceding
+      decorators and the body. Ends with a trailing newline.
+    * ``imports_needed`` — the set of bare module names the symbol's body
+      references. Caller resolves these against the source file's import
+      table to build the new module's import block.
+    * ``start_line`` / ``end_line`` — 1-based line numbers in the source
+      file (for diagnostics and lineage).
+    """
+    symbol_name: str
+    kind: str
+    source: str
+    imports_needed: frozenset[str]
+    start_line: int
+    end_line: int
+
+
+def _walk_imports_used(node: ast.AST) -> set[str]:
+    """Return the set of bare module names that the AST subtree references.
+
+    Recognizes ``ast.Name`` references (e.g. ``math.sqrt`` → ``math``) and
+    ``ast.Attribute`` chains (e.g. ``math.pi`` → ``math``). The result is
+    a superset of "names that look like modules" — the caller is
+    responsible for filtering against the source file's actual imports.
+    """
+    used: set[str] = set()
+    for sub in ast.walk(node):
+        if isinstance(sub, ast.Name):
+            used.add(sub.id)
+        elif isinstance(sub, ast.Attribute):
+            # Walk to the leftmost Name in the attribute chain.
+            cur: ast.AST = sub
+            while isinstance(cur, ast.Attribute):
+                cur = cur.value
+            if isinstance(cur, ast.Name):
+                used.add(cur.id)
+    return used
+
+
+def _import_table(tree: ast.Module) -> dict[str, str]:
+    """Build a mapping from bound name → "import statement source".
+
+    Records every ``import X`` and ``from Y import Z [as W]`` at module
+    level. The bound name is what shows up in code; the source is the
+    one-liner we'd emit verbatim into the new module. Aliased imports
+    (``import numpy as np``) bind ``np``, not ``numpy``.
+    """
+    table: dict[str, str] = {}
+    for node in tree.body:
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                bound = alias.asname or alias.name.split(".")[0]
+                if alias.asname:
+                    table[bound] = f"import {alias.name} as {alias.asname}"
+                else:
+                    table[bound] = f"import {alias.name}"
+        elif isinstance(node, ast.ImportFrom):
+            module = node.module or ""
+            level = node.level or 0
+            prefix = "." * level + module if level or module else ""
+            for alias in node.names:
+                bound = alias.asname or alias.name
+                if alias.asname:
+                    table[bound] = (
+                        f"from {prefix} import {alias.name} as {alias.asname}"
+                    )
+                else:
+                    table[bound] = f"from {prefix} import {alias.name}"
+    return table
+
+
+def extract_symbol(source_file: Path, symbol_name: str) -> GraftExtract:
+    """Extract a top-level function or class slice from ``source_file``.
+
+    Returns a :class:`GraftExtract` carrying the verbatim source plus the
+    set of stdlib/third-party imports the symbol's body references that
+    are bound at module scope in ``source_file``.
+
+    Raises:
+        FileNotFoundError: ``source_file`` does not exist.
+        KeyError:          no top-level symbol named ``symbol_name`` was
+                           found in the AST. Mismatched casing or nested
+                           definitions are not silently substituted.
+        SyntaxError:       ``source_file`` does not parse as Python.
+    """
+    src_path = Path(source_file)
+    if not src_path.is_file():
+        raise FileNotFoundError(f"graft source not found: {src_path}")
+    text = src_path.read_text(encoding="utf-8")
+    tree = ast.parse(text, filename=str(src_path))
+    lines = text.splitlines(keepends=True)
+
+    target = None
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef):
+            if node.name == symbol_name:
+                target = node
+                break
+
+    if target is None:
+        raise KeyError(
+            f"no top-level symbol named {symbol_name!r} in {src_path.name}"
+        )
+
+    # AST start_lineno points at the `def`/`class` line. Decorators are
+    # stored separately; their source precedes the def by one line each.
+    if getattr(target, "decorator_list", None):
+        start = min(d.lineno for d in target.decorator_list)
+    else:
+        start = target.lineno
+    end = getattr(target, "end_lineno", start)
+    slice_lines = lines[start - 1 : end]
+    source = "".join(slice_lines)
+    if not source.endswith("\n"):
+        source = source + "\n"
+
+    # Resolve imports: walk the symbol body for names used, intersect with
+    # the source file's import table. Stdlib refs like ``math.sqrt`` come
+    # back as needing ``import math``.
+    used = _walk_imports_used(target)
+    table = _import_table(tree)
+    imports_needed = frozenset(name for name in used if name in table)
+
+    if isinstance(target, ast.AsyncFunctionDef):
+        kind = "async_function"
+    elif isinstance(target, ast.FunctionDef):
+        kind = "function"
+    else:
+        kind = "class"
+
+    return GraftExtract(
+        symbol_name=symbol_name,
+        kind=kind,
+        source=source,
+        imports_needed=imports_needed,
+        start_line=start,
+        end_line=end,
+    )
+
+
+def render_grafted_module(
+    extract: GraftExtract,
+    *,
+    source_file: Path,
+    import_table: dict[str, str] | None = None,
+    docstring_prefix: str = "",
+) -> str:
+    """Render a stand-alone Python module that wraps the extracted symbol.
+
+    The output module:
+      * starts with a triple-quoted docstring describing the graft origin;
+      * imports only what the symbol body actually uses (resolved via
+        ``import_table`` or a fresh scan of ``source_file``);
+      * embeds the extracted source slice verbatim.
+
+    The resulting text is ready to write to disk and pass through
+    ``forge wire`` / ``forge certify`` without manual edits.
+    """
+    if import_table is None:
+        text = Path(source_file).read_text(encoding="utf-8")
+        tree = ast.parse(text)
+        import_table = _import_table(tree)
+
+    needed_imports = sorted(
+        import_table[name]
+        for name in extract.imports_needed
+        if name in import_table
+    )
+    # Skip relative imports — they don't resolve in the new module.
+    needed_imports = [imp for imp in needed_imports
+                      if not imp.startswith("from .")]
+
+    parts: list[str] = []
+    docstring_body = (
+        f'"""{docstring_prefix}Grafted from '
+        f'{Path(source_file).name} (lines '
+        f'{extract.start_line}–{extract.end_line}) by `forge graft`."""'
+    )
+    parts.append(docstring_body)
+    parts.append("from __future__ import annotations")
+    parts.append("")
+    if needed_imports:
+        parts.extend(needed_imports)
+        parts.append("")
+    # Surface-gap-discoverable: emit a SCHEMA_VERSION_GRAFT_<NAME>
+    # constant so the existing entry-point walker recognizes the grafted
+    # symbol as a wireable a1 function. Without this, auto-wire skips
+    # the graft because the heuristic only inspects modules carrying
+    # a structured-output contract marker.
+    upper_name = extract.symbol_name.upper().lstrip("_")
+    parts.append(
+        f'SCHEMA_VERSION_GRAFT_{upper_name} = '
+        f'"atomadic-forge.graft.{extract.symbol_name}/v1"'
+    )
+    parts.append("")
+    parts.append(extract.source.rstrip())
+    parts.append("")  # trailing newline
+    return "\n".join(parts) + "\n"

{atomadic_forge-0.75.2 → atomadic_forge-0.76.0}/src/atomadic_forge/a1_at_functions/mcp_protocol.py

@@ -1397,6 +1397,150 @@ def _tool_doc_drift(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
     return detect_doc_drift(root)
 
 
+
+def _tool_agent_plan(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for agent_plan_emitter.emit_agent_plan."""
+    from .agent_plan_emitter import emit_agent_plan
+    return emit_agent_plan(args)
+
+
+def _tool_ast_scope_blueprint(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for ast_scope_lock.build_ast_scope_blueprint."""
+    from .ast_scope_lock import build_ast_scope_blueprint
+    return build_ast_scope_blueprint(args)
+
+
+def _tool_mint_ast_locks(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for ast_scope_lock.mint_ast_locks."""
+    from .ast_scope_lock import mint_ast_locks
+    blueprint = str(args.get('blueprint', ''))
+    return mint_ast_locks(blueprint=blueprint)
+
+
+def _tool_add_node(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for ast_scope_lock.add_node."""
+    from .ast_scope_lock import add_node
+    node = args.get('node')
+    return add_node(node=node)
+
+
+def _tool_class_signals(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for body_extractor.detect_class_signals."""
+    from .body_extractor import detect_class_signals
+    target = args.get('target')
+    return detect_class_signals(target=target)
+
+
+def _tool_body(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for body_extractor.extract_body."""
+    from .body_extractor import extract_body
+    source_path = str(args.get('source_path', ''))
+    symbol_name = str(args.get('symbol_name', ''))
+    language = str(args.get('language', ''))
+    return extract_body(source_path=source_path, symbol_name=symbol_name, language=language)
+
+
+def _tool_documentation(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for certify_checks.check_documentation."""
+    from .certify_checks import check_documentation
+    root = Path(args.get('project_root', project_root)).resolve()
+    return check_documentation(root)
+
+
+def _tool_tests_present(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for certify_checks.check_tests_present."""
+    from .certify_checks import check_tests_present
+    root = Path(args.get('project_root', project_root)).resolve()
+    return check_tests_present(root)
+
+
+def _tool_count_untiered_source_files(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for certify_checks.count_untiered_source_files."""
+    from .certify_checks import count_untiered_source_files
+    root = Path(args.get('project_root', project_root)).resolve()
+    return count_untiered_source_files(root)
+
+
+def _tool_tier_layout(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for certify_checks.check_tier_layout."""
+    from .certify_checks import check_tier_layout
+    root = Path(args.get('project_root', project_root)).resolve()
+    package = str(args.get('package', ''))
+    return check_tier_layout(root, package=package)
+
+
+def _tool_no_upward_imports(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for certify_checks.check_no_upward_imports."""
+    from .certify_checks import check_no_upward_imports
+    root = Path(args.get('project_root', project_root)).resolve()
+    package = str(args.get('package', ''))
+    return check_no_upward_imports(root, package=package)
+
+
+def _tool_ci_workflow(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for certify_checks.check_ci_workflow."""
+    from .certify_checks import check_ci_workflow
+    root = Path(args.get('project_root', project_root)).resolve()
+    return check_ci_workflow(root)
+
+
+def _tool_changelog(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for certify_checks.check_changelog."""
+    from .certify_checks import check_changelog
+    root = Path(args.get('project_root', project_root)).resolve()
+    return check_changelog(root)
+
+
+def _tool_chat_context(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for chat_context.build_chat_context."""
+    from .chat_context import build_chat_context
+    paths = list(args.get('paths', []))
+    return build_chat_context(paths=paths)
+
+
+def _tool_effects(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for classify_tier.detect_effects."""
+    from .classify_tier import detect_effects
+    node = args.get('node')
+    return detect_effects(node=node)
+
+
+def _tool_compliance(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for compliance_checker.check_compliance."""
+    from .compliance_checker import check_compliance
+    receipt = args.get('receipt')
+    return check_compliance(receipt=receipt)
+
+
+def _tool_compliance_framework(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for compliance_checker.check_compliance_framework."""
+    from .compliance_checker import check_compliance_framework
+    receipt = args.get('receipt')
+    framework = str(args.get('framework', ''))
+    return check_compliance_framework(receipt=receipt, framework=framework)
+
+
+def _tool_cosine_similarity(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for cosine_similarity.cosine_similarity."""
+    from .cosine_similarity import cosine_similarity
+    a = list(args.get('a', []))
+    b = list(args.get('b', []))
+    return cosine_similarity(a=a, b=b)
+
+
+def _tool_update_readme(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for doc_auto_update.update_readme."""
+    from .doc_auto_update import update_readme
+    project_root = Path(args.get('project_root', project_root)).resolve()
+    return update_readme(project_root)
+
+
+def _tool_update_extended_docs(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
+    """Auto-generated MCP handler for doc_auto_update.update_extended_docs."""
+    from .doc_auto_update import update_extended_docs
+    project_root = Path(args.get('project_root', project_root)).resolve()
+    return update_extended_docs(project_root)
+
 def _tool_smell_scan(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
     """Run code-smell detection (cyclomatic complexity + long functions
     + duplicated bodies). Pure: composes the a1 ``smell_scan`` walker."""
@@ -2418,6 +2562,46 @@ def _tool_explore(project_root: Path, args: dict[str, Any]) -> dict[str, Any]:
         return _tool_dead_code(project_root, inner)
     elif action == "maintainability":
         return _tool_maintainability(project_root, inner)
+    elif action == "agent_plan":
+        return _tool_agent_plan(project_root, inner)
+    elif action == "ast_scope_blueprint":
+        return _tool_ast_scope_blueprint(project_root, inner)
+    elif action == "mint_ast_locks":
+        return _tool_mint_ast_locks(project_root, inner)
+    elif action == "add_node":
+        return _tool_add_node(project_root, inner)
+    elif action == "class_signals":
+        return _tool_class_signals(project_root, inner)
+    elif action == "body":
+        return _tool_body(project_root, inner)
+    elif action == "documentation":
+        return _tool_documentation(project_root, inner)
+    elif action == "tests_present":
+        return _tool_tests_present(project_root, inner)
+    elif action == "count_untiered_source_files":
+        return _tool_count_untiered_source_files(project_root, inner)
+    elif action == "tier_layout":
+        return _tool_tier_layout(project_root, inner)
+    elif action == "no_upward_imports":
+        return _tool_no_upward_imports(project_root, inner)
+    elif action == "ci_workflow":
+        return _tool_ci_workflow(project_root, inner)
+    elif action == "changelog":
+        return _tool_changelog(project_root, inner)
+    elif action == "chat_context":
+        return _tool_chat_context(project_root, inner)
+    elif action == "effects":
+        return _tool_effects(project_root, inner)
+    elif action == "compliance":
+        return _tool_compliance(project_root, inner)
+    elif action == "compliance_framework":
+        return _tool_compliance_framework(project_root, inner)
+    elif action == "cosine_similarity":
+        return _tool_cosine_similarity(project_root, inner)
+    elif action == "update_readme":
+        return _tool_update_readme(project_root, inner)
+    elif action == "update_extended_docs":
+        return _tool_update_extended_docs(project_root, inner)
     elif action == "concept_bridge":
         return _tool_concept_bridge(project_root, inner)
     elif action == "lineage":
@@ -2698,7 +2882,8 @@ TOOLS: dict[str, dict[str, Any]] = {
                     "enum": ["recon", "explain", "call_graph", "call_graph_summary",
                              "smell_scan", "churn", "surface_gaps", "capability_scout",
                              "dead_code", "maintainability", "concept_bridge",
-                             "lineage", "harvest", "synergy", "scan", "swarm"],
+                             "lineage", "harvest", "synergy", "scan", "swarm",
+                             "agent_plan"],
                     "default": "recon",
                     "description": (
                         "'recon' — tier map; 'explain' — narrative; "