atomadic-forge 0.83.0__tar.gz → 0.84.1__tar.gz

{atomadic_forge-0.83.0 → atomadic_forge-0.84.1}/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## v0.84.1 — 2026-05-08
+
+- fix(mcp): add missing `items` to `repos` and `queries` array schemas in `explore` tool — resolves VS Code MCP validator rejection
+
+
+## v0.84.0 — 2026-05-08
+
+- feat(forge): v0.84 — full polyglot graft + dynamic capabilities SoT
+
+
 ## v0.83.0 — 2026-05-08
 
 - feat(forge): v0.83 — JS/TS graft support; arm Atomadic with capability transfer

{atomadic_forge-0.83.0/src/atomadic_forge.egg-info → atomadic_forge-0.84.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.83.0
+Version: 0.84.1
 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.83.0 → atomadic_forge-0.84.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "atomadic-forge"
-version = "0.83.0"
+version = "0.84.1"
 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.84.1/src/atomadic_forge/a1_at_functions/graft_extract_polyglot.py

@@ -0,0 +1,354 @@
+"""Tier a1 — Rust + Kotlin counterparts to ``graft_extract`` and
+``graft_extract_js``. Same brace-balancing trick as the JS extractor;
+language-specific header regexes drive symbol detection.
+
+Rust supported headers:
+* ``pub fn name``, ``fn name``, ``pub async fn name``, ``async fn name``
+* ``pub struct Name``, ``struct Name``, ``pub enum Name``, ``enum Name``
+* ``pub trait Name``, ``trait Name``
+* ``impl Name`` / ``impl Trait for Name`` (block grouping)
+
+Kotlin supported headers:
+* ``fun name``, ``suspend fun name``, ``inline fun name``
+* ``class Name``, ``data class Name``, ``sealed class Name``,
+  ``object Name``, ``interface Name``
+* Modifiers tolerated: ``public/internal/private/protected/open/final/abstract``.
+
+Both reuse :func:`js_parser._balance_braces` for body extraction.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .js_parser import _balance_braces
+
+RUST_SUFFIXES: frozenset[str] = frozenset({".rs"})
+KOTLIN_SUFFIXES: frozenset[str] = frozenset({".kt", ".kts"})
+
+# ── Rust ───────────────────────────────────────────────────────────
+
+
+_RUST_HEADERS: tuple[tuple[str, str], ...] = (
+    ("function", r"^\s*(?:pub(?:\([^)]+\))?\s+)?(?:async\s+)?fn\s+{name}\b"),
+    ("struct",   r"^\s*(?:pub(?:\([^)]+\))?\s+)?struct\s+{name}\b"),
+    ("enum",     r"^\s*(?:pub(?:\([^)]+\))?\s+)?enum\s+{name}\b"),
+    ("trait",    r"^\s*(?:pub(?:\([^)]+\))?\s+)?trait\s+{name}\b"),
+    ("impl",     r"^\s*impl(?:\s*<[^>]+>)?\s+{name}\b"),
+)
+
+_RUST_USE = re.compile(
+    r"^\s*(?:pub\s+)?use\s+([^;]+);", re.MULTILINE,
+)
+
+
+# ── Kotlin ─────────────────────────────────────────────────────────
+
+
+_KOTLIN_MODS = (
+    r"(?:(?:public|internal|private|protected|open|final|abstract|"
+    r"sealed|data|inline|suspend|operator|infix|tailrec|external|override)\s+)*"
+)
+_KOTLIN_HEADERS: tuple[tuple[str, str], ...] = (
+    ("function",  rf"^\s*{_KOTLIN_MODS}fun\s+(?:<[^>]+>\s+)?(?:[A-Za-z_][\w<>.,?\s]*\.)?{{name}}\s*\("),
+    ("class",     rf"^\s*{_KOTLIN_MODS}class\s+{{name}}\b"),
+    ("object",    rf"^\s*{_KOTLIN_MODS}object\s+{{name}}\b"),
+    ("interface", rf"^\s*{_KOTLIN_MODS}interface\s+{{name}}\b"),
+)
+
+_KOTLIN_IMPORT = re.compile(
+    r"^\s*import\s+([\w.*]+)(?:\s+as\s+(\w+))?", re.MULTILINE,
+)
+
+
+# ── Shared dataclass ──────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class PolyglotGraftExtract:
+    """Language-agnostic graft slice for Rust / Kotlin."""
+    symbol_name: str
+    kind: str
+    source: str
+    imports_needed: frozenset[str]
+    sibling_refs: frozenset[str] = field(default_factory=frozenset)
+    start_line: int = 0
+    end_line: int = 0
+    language: str = ""
+
+
+# ── Helpers ───────────────────────────────────────────────────────
+
+
+def _line_of(text: str, offset: int) -> int:
+    return text.count("\n", 0, offset) + 1
+
+
+def _find_header(text: str, symbol_name: str,
+                  patterns: tuple[tuple[str, str], ...]) -> tuple[int, str] | None:
+    safe = re.escape(symbol_name)
+    for kind, pat in patterns:
+        rx = re.compile(pat.format(name=safe), re.MULTILINE)
+        m = rx.search(text)
+        if m:
+            return (m.start(), kind)
+    return None
+
+
+def _slice_balanced(text: str, header_start: int) -> tuple[str, int]:
+    """Slice from header through balanced braces. Returns (slice, end_offset)."""
+    open_idx = text.find("{", header_start)
+    if open_idx == -1:
+        # No body block — slice to next blank line or semicolon.
+        nl = text.find("\n\n", header_start)
+        end = nl if nl != -1 else len(text)
+        return text[header_start:end] + "\n", end
+    close_idx = _balance_braces(text, open_idx)
+    if close_idx == -1:
+        return text[header_start:], len(text)
+    end = close_idx + 1
+    if end < len(text) and text[end] == "\n":
+        end += 1
+    return text[header_start:end], end
+
+
+def _walk_idents(slice_text: str) -> set[str]:
+    """Identifiers referenced in slice (block + line comments stripped)."""
+    s = re.sub(r"/\*.*?\*/", " ", slice_text, flags=re.DOTALL)
+    s = re.sub(r"//[^\n]*", " ", s)
+    return set(re.findall(r"\b[A-Za-z_][\w]*\b", s))
+
+
+# ── Rust extractor ────────────────────────────────────────────────
+
+
+def _rust_import_table(text: str) -> dict[str, str]:
+    """Map ``last_segment`` (or alias) → full ``use`` line.
+
+    ``use std::collections::HashMap;`` → ``{"HashMap": "use std::collections::HashMap;"}``
+    ``use foo::Bar as Quux;``          → ``{"Quux":   "use foo::Bar as Quux;"}``
+    """
+    table: dict[str, str] = {}
+    for body in _RUST_USE.findall(text):
+        full = f"use {body.strip()};"
+        last = body.strip().split("::")[-1].strip()
+        # alias form
+        m = re.match(r"(\w+)\s+as\s+(\w+)", last)
+        if m:
+            table[m.group(2)] = full
+            continue
+        # group brace form `use foo::{A, B as X}`
+        m = re.match(r"\{([^}]+)\}", last)
+        if m:
+            for piece in m.group(1).split(","):
+                piece = piece.strip()
+                am = re.match(r"(\w+)\s+as\s+(\w+)", piece)
+                if am:
+                    table[am.group(2)] = full
+                else:
+                    name = piece.split(" as ")[-1].strip().strip("{}")
+                    if name:
+                        table[name] = full
+            continue
+        if last:
+            table[last] = full
+    return table
+
+
+def _rust_top_defs(text: str) -> set[str]:
+    out: set[str] = set()
+    for _kind, pat in _RUST_HEADERS:
+        rx = re.compile(
+            pat.replace("{name}", r"(?P<name>[A-Za-z_]\w*)"),
+            re.MULTILINE,
+        )
+        for m in rx.finditer(text):
+            out.add(m.group("name"))
+    return out
+
+
+def _walk_back_rust_attrs(text: str, header_start: int) -> int:
+    """Extend the slice start to include preceding ``#[...]`` attributes.
+
+    Walks each immediately-preceding non-blank line; if it starts with
+    ``#[`` (or `///` doc), include it. Stops at the first non-attribute,
+    non-doc line.
+    """
+    cursor = header_start
+    while cursor > 0:
+        line_start = text.rfind("\n", 0, cursor - 1) + 1
+        line = text[line_start:cursor].strip()
+        if line.startswith("#[") or line.startswith("///"):
+            cursor = line_start
+        else:
+            break
+    return cursor
+
+
+def extract_symbol_rust(source_file: Path,
+                        symbol_name: str) -> PolyglotGraftExtract:
+    p = Path(source_file)
+    if not p.is_file():
+        raise FileNotFoundError(f"graft source not found: {p}")
+    if p.suffix.lower() not in RUST_SUFFIXES:
+        raise ValueError(f"not a Rust source: {p.suffix}")
+    text = p.read_text(encoding="utf-8", errors="replace")
+    found = _find_header(text, symbol_name, _RUST_HEADERS)
+    if found is None:
+        raise KeyError(
+            f"no top-level Rust symbol named {symbol_name!r} in {p.name}",
+        )
+    header_start, kind = found
+    header_start = _walk_back_rust_attrs(text, header_start)
+    slice_text, end_offset = _slice_balanced(text, header_start)
+    refs = _walk_idents(slice_text) - {symbol_name}
+    table = _rust_import_table(text)
+    imports_needed = frozenset(name for name in refs if name in table)
+    siblings = _rust_top_defs(text) - {symbol_name}
+    sibling_refs = frozenset(refs & siblings)
+    return PolyglotGraftExtract(
+        symbol_name=symbol_name,
+        kind=kind,
+        source=slice_text.rstrip() + "\n",
+        imports_needed=imports_needed,
+        sibling_refs=sibling_refs,
+        start_line=_line_of(text, header_start),
+        end_line=_line_of(text, end_offset),
+        language="rust",
+    )
+
+
+def render_grafted_module_rust(extract: PolyglotGraftExtract,
+                                *, source_file: Path) -> str:
+    text = Path(source_file).read_text(encoding="utf-8", errors="replace")
+    table = _rust_import_table(text)
+    needed = sorted(table[n] for n in extract.imports_needed if n in table)
+    parts: list[str] = []
+    parts.append(
+        f"// Grafted from {Path(source_file).name} "
+        f"(lines {extract.start_line}–{extract.end_line}) by `forge graft`.",
+    )
+    parts.append("")
+    if needed:
+        parts.extend(needed)
+        parts.append("")
+    if extract.sibling_refs:
+        for sib in sorted(extract.sibling_refs):
+            parts.append(f"use crate::{sib}::{sib};")
+        parts.append("")
+    upper = re.sub(r"[^A-Za-z0-9]", "_", extract.symbol_name).upper().lstrip("_")
+    parts.append(
+        f'pub const SCHEMA_VERSION_GRAFT_{upper}: &str = '
+        f'"atomadic-forge.graft.{extract.symbol_name}/v1";',
+    )
+    parts.append("")
+    parts.append(extract.source.rstrip())
+    parts.append("")
+    return "\n".join(parts) + "\n"
+
+
+# ── Kotlin extractor ──────────────────────────────────────────────
+
+
+def _kotlin_import_table(text: str) -> dict[str, str]:
+    """Bound name → ``import a.b.C [as Alias]`` line.
+
+    Wildcard imports (``import a.b.*``) are skipped — too coarse to map
+    a single bound name back to a single line.
+    """
+    table: dict[str, str] = {}
+    for full, alias in _KOTLIN_IMPORT.findall(text):
+        if full.endswith(".*"):
+            continue
+        last = full.rsplit(".", 1)[-1]
+        local = alias or last
+        line = f"import {full}"
+        if alias:
+            line = f"import {full} as {alias}"
+        table[local] = line
+    return table
+
+
+def _kotlin_top_defs(text: str) -> set[str]:
+    out: set[str] = set()
+    for _kind, pat in _KOTLIN_HEADERS:
+        rx = re.compile(
+            pat.replace("{name}", r"(?P<name>[A-Za-z_]\w*)"),
+            re.MULTILINE,
+        )
+        for m in rx.finditer(text):
+            out.add(m.group("name"))
+    return out
+
+
+def extract_symbol_kotlin(source_file: Path,
+                          symbol_name: str) -> PolyglotGraftExtract:
+    p = Path(source_file)
+    if not p.is_file():
+        raise FileNotFoundError(f"graft source not found: {p}")
+    if p.suffix.lower() not in KOTLIN_SUFFIXES:
+        raise ValueError(f"not a Kotlin source: {p.suffix}")
+    text = p.read_text(encoding="utf-8", errors="replace")
+    found = _find_header(text, symbol_name, _KOTLIN_HEADERS)
+    if found is None:
+        raise KeyError(
+            f"no top-level Kotlin symbol named {symbol_name!r} in {p.name}",
+        )
+    header_start, kind = found
+    slice_text, end_offset = _slice_balanced(text, header_start)
+    refs = _walk_idents(slice_text) - {symbol_name}
+    table = _kotlin_import_table(text)
+    imports_needed = frozenset(n for n in refs if n in table)
+    siblings = _kotlin_top_defs(text) - {symbol_name}
+    sibling_refs = frozenset(refs & siblings)
+    return PolyglotGraftExtract(
+        symbol_name=symbol_name,
+        kind=kind,
+        source=slice_text.rstrip() + "\n",
+        imports_needed=imports_needed,
+        sibling_refs=sibling_refs,
+        start_line=_line_of(text, header_start),
+        end_line=_line_of(text, end_offset),
+        language="kotlin",
+    )
+
+
+def render_grafted_module_kotlin(extract: PolyglotGraftExtract,
+                                  *, source_file: Path,
+                                  package: str = "") -> str:
+    text = Path(source_file).read_text(encoding="utf-8", errors="replace")
+    table = _kotlin_import_table(text)
+    needed = sorted(table[n] for n in extract.imports_needed if n in table)
+    parts: list[str] = []
+    if package:
+        parts.append(f"package {package}")
+        parts.append("")
+    parts.append(
+        f"// Grafted from {Path(source_file).name} "
+        f"(lines {extract.start_line}–{extract.end_line}) by `forge graft`.",
+    )
+    parts.append("")
+    if needed:
+        parts.extend(needed)
+        parts.append("")
+    upper = re.sub(r"[^A-Za-z0-9]", "_", extract.symbol_name).upper().lstrip("_")
+    parts.append(
+        f'const val SCHEMA_VERSION_GRAFT_{upper} = '
+        f'"atomadic-forge.graft.{extract.symbol_name}/v1"',
+    )
+    parts.append("")
+    parts.append(extract.source.rstrip())
+    parts.append("")
+    return "\n".join(parts) + "\n"
+
+
+__all__ = [
+    "KOTLIN_SUFFIXES",
+    "RUST_SUFFIXES",
+    "PolyglotGraftExtract",
+    "extract_symbol_kotlin",
+    "extract_symbol_rust",
+    "render_grafted_module_kotlin",
+    "render_grafted_module_rust",
+]

{atomadic_forge-0.83.0 → atomadic_forge-0.84.1}/src/atomadic_forge/a1_at_functions/mcp_protocol.py

@@ -3087,6 +3087,7 @@ TOOLS: dict[str, dict[str, Any]] = {
                             "description": "[recon/harvest] Repo path."},
                 "repos": {
                     "type": "array",
+                    "items": {"type": "string"},
                     "description": "[recon] list of repo paths (max 23); [swarm] list of {src_root, package} objects.",
                     "minItems": 1, "maxItems": 23,
                 },
@@ -3121,6 +3122,7 @@ TOOLS: dict[str, dict[str, Any]] = {
                 # capability_scout params
                 "queries": {
                     "type": ["string", "array"],
+                    "items": {"type": "string"},
                     "description": "[capability_scout] Comma-separated or list of capability search queries.",
                 },
                 "per_query": {"type": "integer", "default": 8,

{atomadic_forge-0.83.0 → atomadic_forge-0.84.1}/src/atomadic_forge/a3_og_features/graft_feature.py

@@ -23,6 +23,7 @@ Pipeline::
 """
 from __future__ import annotations
 
+import json
 import shutil
 from dataclasses import asdict, dataclass
 from pathlib import Path
@@ -38,11 +39,79 @@ from ..a1_at_functions.graft_extract_js import (
     extract_symbol_js,
     render_grafted_module_js,
 )
+from ..a1_at_functions.graft_extract_polyglot import (
+    KOTLIN_SUFFIXES,
+    RUST_SUFFIXES,
+    extract_symbol_kotlin,
+    extract_symbol_rust,
+    render_grafted_module_kotlin,
+    render_grafted_module_rust,
+)
 from ..a1_at_functions.wire_check import scan_violations
 
 SCHEMA_VERSION_GRAFT_V1 = "atomadic-forge.graft/v1"
+SCHEMA_VERSION_CAPABILITIES_V1 = "atomadic.capabilities/v1"
 DEFAULT_TARGET_PACKAGE = "atomadic_forge"
 
+CAPABILITIES_RELPATH = "a0_qk_constants/capabilities.json"
+
+
+def _update_capabilities_sot(
+    pkg_dir: Path,
+    *,
+    symbol_name: str,
+    tier: str,
+    kind: str,
+    language: str,
+    source_file: str,
+    target_path: str,
+) -> str | None:
+    """Append/refresh an entry in the SoT capabilities.json under pkg_dir.
+
+    Best-effort: if the parent dir doesn't exist, do nothing (returns None).
+    The SoT is the file Atomadic loads at boot to know what powers he has;
+    keeping it dynamic means his self-awareness grows in lockstep with
+    every graft.
+    """
+    import datetime as _dt
+    sot_path = pkg_dir / CAPABILITIES_RELPATH
+    if not sot_path.parent.is_dir():
+        return None
+    now = _dt.datetime.now(_dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    payload: dict[str, Any]
+    try:
+        payload = json.loads(sot_path.read_text(encoding="utf-8"))
+        if not isinstance(payload, dict):
+            payload = {}
+    except (OSError, ValueError):
+        payload = {}
+    payload.setdefault("schema_version", SCHEMA_VERSION_CAPABILITIES_V1)
+    payload.setdefault("agent", pkg_dir.name)
+    caps = payload.setdefault("capabilities", [])
+    if not isinstance(caps, list):
+        caps = []
+    # Replace existing entry for the same symbol so re-grafts overwrite.
+    caps = [c for c in caps if c.get("name") != symbol_name]
+    caps.append({
+        "name": symbol_name,
+        "tier": tier,
+        "kind": kind,
+        "language": language,
+        "grafted_from": source_file,
+        "grafted_at_utc": now,
+        "module_path": target_path,
+    })
+    payload["capabilities"] = caps
+    payload["updated_at_utc"] = now
+    payload["count"] = len(caps)
+    try:
+        sot_path.write_text(
+            json.dumps(payload, indent=2, default=str), encoding="utf-8",
+        )
+        return str(sot_path)
+    except OSError:
+        return None
+
 # Tier the graft lands in based on extracted symbol kind. Functions
 # default to a1 (pure helpers); classes default to a2 (composites);
 # the caller can override with --tier.
@@ -176,13 +245,13 @@ def graft(
     source_path = Path(source_file).resolve()
     target_path_root = Path(target_root).resolve()
 
-    # v0.83: dispatch by source suffix. JS/TS sources go through the
-    # regex-based JS extractor; everything else uses the Python AST path.
-    is_js = source_path.suffix.lower() in JS_SUFFIXES
+    # v0.83/v0.84: dispatch by source suffix.
+    suffix = source_path.suffix.lower()
+    is_js = suffix in JS_SUFFIXES
+    is_rust = suffix in RUST_SUFFIXES
+    is_kotlin = suffix in KOTLIN_SUFFIXES
     if is_js:
         js_extract = extract_symbol_js(source_path, symbol_name)
-        # Adapt JsGraftExtract to the same shape as GraftExtract so the
-        # rest of the pipeline (rename, write, wire) stays unchanged.
         extract = GraftExtract(
             symbol_name=js_extract.symbol_name,
             kind=js_extract.kind,
@@ -192,6 +261,22 @@ def graft(
             end_line=js_extract.end_line,
             sibling_refs=js_extract.sibling_refs,
         )
+    elif is_rust:
+        rs = extract_symbol_rust(source_path, symbol_name)
+        extract = GraftExtract(
+            symbol_name=rs.symbol_name, kind=rs.kind, source=rs.source,
+            imports_needed=rs.imports_needed,
+            start_line=rs.start_line, end_line=rs.end_line,
+            sibling_refs=rs.sibling_refs,
+        )
+    elif is_kotlin:
+        kt = extract_symbol_kotlin(source_path, symbol_name)
+        extract = GraftExtract(
+            symbol_name=kt.symbol_name, kind=kt.kind, source=kt.source,
+            imports_needed=kt.imports_needed,
+            start_line=kt.start_line, end_line=kt.end_line,
+            sibling_refs=kt.sibling_refs,
+        )
     else:
         extract = extract_symbol(source_path, symbol_name)
 
@@ -212,27 +297,42 @@ def graft(
             end_line=extract.end_line,
         )
 
-    # JS arrows / classes default to a1; classes optionally to a2.
+    # Tier defaults vary by language for class-shaped kinds.
     if is_js:
-        js_default_tier = (
+        default_tier = (
             "a2_mo_composites" if extract.kind == "class" else "a1_at_functions"
         )
-        chosen_tier = tier or js_default_tier
+    elif is_rust:
+        default_tier = (
+            "a2_mo_composites" if extract.kind in ("struct", "enum", "trait", "impl")
+            else "a1_at_functions"
+        )
+    elif is_kotlin:
+        default_tier = (
+            "a2_mo_composites" if extract.kind in ("class", "object", "interface")
+            else "a1_at_functions"
+        )
     else:
-        chosen_tier = tier or _DEFAULT_TIERS.get(extract.kind, "a3_og_features")
+        default_tier = _DEFAULT_TIERS.get(extract.kind, "a3_og_features")
+    chosen_tier = tier or default_tier
+
+    if is_js:
+        dest_suffix = ".js"
+    elif is_rust:
+        dest_suffix = ".rs"
+    elif is_kotlin:
+        dest_suffix = ".kt"
+    else:
+        dest_suffix = ".py"
     dest = _resolve_target_module(
         target_path_root, package, chosen_tier, effective_name,
-        suffix=".js" if is_js else ".py",
+        suffix=dest_suffix,
     )
+
     if is_js:
-        # Re-extract via JS path to get the JsGraftExtract shape the
-        # JS renderer wants. Cheap (single file read + regex).
-        js_extract = extract_symbol_js(source_path, effective_name) \
-            if effective_name == symbol_name \
-            else extract_symbol_js(source_path, symbol_name)
+        from ..a1_at_functions.graft_extract_js import JsGraftExtract
+        js_extract = extract_symbol_js(source_path, symbol_name)
         if effective_name != symbol_name:
-            # Apply rename to the JS extract source too.
-            from ..a1_at_functions.graft_extract_js import JsGraftExtract
             renamed = _rename_symbol_in_source(
                 js_extract.source, symbol_name, effective_name,
             )
@@ -245,13 +345,15 @@ def graft(
                 start_line=js_extract.start_line,
                 end_line=js_extract.end_line,
             )
-        rendered = render_grafted_module_js(
-            js_extract, source_file=source_path,
-        )
+        rendered = render_grafted_module_js(js_extract, source_file=source_path)
+    elif is_rust:
+        rs_extract = extract_symbol_rust(source_path, symbol_name)
+        rendered = render_grafted_module_rust(rs_extract, source_file=source_path)
+    elif is_kotlin:
+        kt_extract = extract_symbol_kotlin(source_path, symbol_name)
+        rendered = render_grafted_module_kotlin(kt_extract, source_file=source_path)
     else:
-        rendered = render_grafted_module(
-            extract, source_file=source_path,
-        )
+        rendered = render_grafted_module(extract, source_file=source_path)
 
     backup_path: str | None = None
     written = False
@@ -274,13 +376,41 @@ def graft(
         bytes_written = len(rendered.encode("utf-8"))
         written = True
 
+        # v0.84: keep the agent's capabilities SoT current. Best-effort:
+        # if the package has an a0_qk_constants/ dir we drop a
+        # capabilities.json entry so an agent loading it knows what
+        # powers it now has. Skipped silently if no SoT directory.
+        pkg_root_dir = (
+            target_path_root / "src" / package
+            if (target_path_root / "src" / package).is_dir()
+            else target_path_root / package
+        )
+        language = (
+            "javascript" if is_js
+            else "rust" if is_rust
+            else "kotlin" if is_kotlin
+            else "python"
+        )
+        _update_capabilities_sot(
+            pkg_root_dir,
+            symbol_name=effective_name,
+            tier=chosen_tier,
+            kind=extract.kind,
+            language=language,
+            source_file=str(source_path),
+            target_path=str(dest),
+        )
+
         # Run a focused wire scan on the package: a graft that introduces
         # an upward import is rejected on the spot. Caller can roll back
         # using backup_path if needed.
         try:
-            wire_report = scan_violations(
-                target_path_root / "src" / package,
+            scan_root = (
+                target_path_root / "src" / package
+                if (target_path_root / "src" / package).is_dir()
+                else target_path_root / package
             )
+            wire_report = scan_violations(scan_root)
             wire_violations = int(wire_report.get("violation_count", 0))
             wire_verdict = wire_report.get("verdict", "UNKNOWN")
         except Exception:  # pragma: no cover - diagnostic only

{atomadic_forge-0.83.0 → atomadic_forge-0.84.1/src/atomadic_forge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.83.0
+Version: 0.84.1
 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.83.0 → atomadic_forge-0.84.1}/src/atomadic_forge.egg-info/SOURCES.txt

@@ -184,6 +184,7 @@ src/atomadic_forge/a1_at_functions/generation_quality.py
 src/atomadic_forge/a1_at_functions/git_churn.py
 src/atomadic_forge/a1_at_functions/graft_extract.py
 src/atomadic_forge/a1_at_functions/graft_extract_js.py
+src/atomadic_forge/a1_at_functions/graft_extract_polyglot.py
 src/atomadic_forge/a1_at_functions/handoff_builder.py
 src/atomadic_forge/a1_at_functions/harvest_absorb.py
 src/atomadic_forge/a1_at_functions/harvest_concept_bridge.py
@@ -407,6 +408,7 @@ tests/test_generation_quality.py
 tests/test_git_churn.py
 tests/test_graft_feature.py
 tests/test_graft_js.py
+tests/test_graft_polyglot.py
 tests/test_handoff.py
 tests/test_harvest_concept_bridge.py
 tests/test_harvest_source_warnings.py