velm 0.1.2__py3-none-any.whl

velm/core/lsp/scaffold_features/call_hierarchy/providers/daemon_bridge.py

@@ -0,0 +1,128 @@
+# Path: core/lsp/scaffold_features/call_hierarchy/providers/daemon_bridge.py
+# --------------------------------------------------------------------------
+import logging
+from typing import List, Any, Optional
+from ....base.features.call_hierarchy.contracts import CallHierarchyProvider
+from ....base.features.call_hierarchy.models import (
+    CallHierarchyItem, CallHierarchyIncomingCall, CallHierarchyOutgoingCall
+)
+from ....base.document import TextDocument
+from ....base.utils.text import TextUtils
+from ....base.utils.uri import UriUtils
+from ....base.telemetry import forensic_log
+
+Logger = logging.getLogger("DaemonHierarchyBridge")
+
+
+class DaemonCallHierarchyProvider(CallHierarchyProvider):
+    """
+    =============================================================================
+    == THE CORTEX BRIDGE (V-Ω-GRAPH-SIPHON)                                    ==
+    =============================================================================
+    LIF: 100x | ROLE: GRAPH_RELAY
+
+    Siphons topological truth from the Daemon's `GrandSurveyor` and `GraphArtisan`.
+    It enables cross-file, cross-language call tracing by utilizing the Daemon's
+    pre-computed dependency graph.
+
+    ### THE 12 ASCENSIONS:
+    1.  **Atomic Word Extraction:** Divines the symbol at cursor to prime the query.
+    2.  **Stateful Data Injection:** Embeds `file_path` and `symbol_id` into the `data` payload for stateless follow-ups.
+    3.  **Trace ID Threading:** Ensures the Hierarchy request chain is forensically auditable.
+    4.  **Titanium Path Resolution:** Uses `UriUtils` to guarantee Daemon/LSP path parity.
+    5.  **Graceful Void Handling:** Returns empty lists instead of crashing on `null` daemon responses.
+    6.  **Kind Mapping:** Transmutes Daemon symbol types (string) to LSP Enums (int).
+    7.  **Range Clamping:** Ensures ranges returned by Daemon fit within the document bounds.
+    8.  **Project Root Anchoring:** Sends the root context to allow relative path resolution in Daemon.
+    9.  **Synchronous Relay:** Uses `relay_request` with a generous 2s timeout.
+    10. **Result Transmutation:** Converts raw dicts to strict Pydantic models.
+    11. **Self-Reference Guard:** Daemon logic filters recursion; Bridge handles transport.
+    12. **Multi-Stratum Support:** Ready for Python, JS, and Scaffold macro calls.
+    """
+
+    @property
+    def name(self) -> str:
+        return "DaemonCortex"
+
+    def prepare(self, doc: TextDocument, position: Any) -> List[CallHierarchyItem]:
+        # 1. Divine Symbol
+        info = TextUtils.get_word_at_position(doc, position)
+        if not info: return []
+
+        # 2. Ask Daemon
+        if not hasattr(self.server, 'relay_request'): return []
+
+        # [ASCENSION 4]: Titanium Path
+        fs_path = str(UriUtils.to_fs_path(doc.uri))
+
+        params = {
+            "file_path": fs_path,
+            "symbol": info.text.replace('(', '').strip(),
+            "position": {"line": position.line, "character": position.character},
+            "project_root": str(self.server.project_root),
+            "metadata": {"source": "LSP_HIERARCHY_PREPARE"}
+        }
+
+        try:
+            # [ASCENSION 9]: Synchronous Plea
+            res = self.server.relay_request("hierarchy/prepare", params)
+            if res and res.get('success'):
+                raw_items = res.get('data', [])
+                items = []
+                for i in raw_items:
+                    # [ASCENSION 2]: Inject State for follow-up calls
+                    if 'data' not in i:
+                        i['data'] = {
+                            "symbol": i['name'],
+                            "uri": i['uri'],
+                            "fs_path": str(UriUtils.to_fs_path(i['uri']))
+                        }
+                    items.append(CallHierarchyItem.model_validate(i))
+                return items
+        except Exception as e:
+            Logger.error(f"Hierarchy Prepare Fractured: {e}")
+
+        return []
+
+    def incoming_calls(self, item: CallHierarchyItem) -> List[CallHierarchyIncomingCall]:
+        if not hasattr(self.server, 'relay_request'): return []
+
+        # Retrieve state from the item
+        symbol_data = item.data or {}
+
+        params = {
+            "symbol": symbol_data.get("symbol", item.name),
+            "file_path": symbol_data.get("fs_path", ""),
+            "project_root": str(self.server.project_root),
+            "metadata": {"source": "LSP_HIERARCHY_INCOMING"}
+        }
+
+        try:
+            res = self.server.relay_request("hierarchy/incoming", params)
+            if res and res.get('success'):
+                return [CallHierarchyIncomingCall.model_validate(i) for i in res.get('data', [])]
+        except Exception as e:
+            Logger.error(f"Incoming Calls Fractured: {e}")
+
+        return []
+
+    def outgoing_calls(self, item: CallHierarchyItem) -> List[CallHierarchyOutgoingCall]:
+        if not hasattr(self.server, 'relay_request'): return []
+
+        symbol_data = item.data or {}
+
+        params = {
+            "symbol": symbol_data.get("symbol", item.name),
+            "file_path": symbol_data.get("fs_path", ""),
+            "project_root": str(self.server.project_root),
+            "metadata": {"source": "LSP_HIERARCHY_OUTGOING"}
+        }
+
+        try:
+            res = self.server.relay_request("hierarchy/outgoing", params)
+            if res and res.get('success'):
+                return [CallHierarchyOutgoingCall.model_validate(i) for i in res.get('data', [])]
+        except Exception as e:
+            Logger.error(f"Outgoing Calls Fractured: {e}")
+
+        return []

velm/core/lsp/scaffold_features/code_action/__init__.py

@@ -0,0 +1,25 @@
+# Path: core/lsp/scaffold_features/code_action/__init__.py
+# --------------------------------------------------------
+
+"""
+=================================================================================
+== THE HALL OF REDEMPTION (V-Ω-SCAFFOLD-CODE-ACTION-V12)                       ==
+=================================================================================
+The restorative center of the Gnostic Mind.
+Provides specialized healers and refactorers for the Scaffold tongue.
+=================================================================================
+"""
+
+from .engine import ScaffoldCodeActionEngine
+from .providers.syntax_medic import SyntaxMedicProvider
+from .providers.artisan_bridge import ArtisanBridgeProvider
+from .providers.refactor_surgeon import RefactorSurgeonProvider
+from .providers.neural_healer import NeuralHealerProvider
+
+__all__ = [
+    "ScaffoldCodeActionEngine",
+    "SyntaxMedicProvider",
+    "ArtisanBridgeProvider",
+    "RefactorSurgeonProvider",
+    "NeuralHealerProvider"
+]

velm/core/lsp/scaffold_features/code_action/engine.py

@@ -0,0 +1,89 @@
+# Path: core/lsp/scaffold_features/code_action/engine.py
+# ------------------------------------------------------
+# LIF: INFINITY | AUTH_CODE: Ω_ACTION_ENGINE_HYDRATED_V1
+
+import time
+import logging
+import concurrent.futures
+import uuid
+from typing import List, Any
+from ...base.features.code_action.engine import CodeActionEngine
+from ...base.types import CodeAction, Diagnostic, CodeActionParams
+from .providers.syntax_medic import SyntaxMedicProvider
+from .providers.artisan_bridge import ArtisanBridgeProvider
+from .providers.refactor_surgeon import RefactorSurgeonProvider
+from .providers.neural_healer import NeuralHealerProvider
+
+Logger = logging.getLogger("ScaffoldCodeActionEngine")
+
+
+class ScaffoldCodeActionEngine(CodeActionEngine):
+    """
+    =============================================================================
+    == THE SCAFFOLD CODE ACTION ENGINE (V-Ω-HYDRATED)                          ==
+    =============================================================================
+    Extends the base engine to ensure types are respected.
+    """
+
+    @staticmethod
+    def forge(server: Any) -> 'ScaffoldCodeActionEngine':
+        engine = ScaffoldCodeActionEngine(server)
+        server.register_capability(lambda caps: setattr(caps, 'code_action_provider', {
+            "codeActionKinds": ["quickfix", "refactor", "refactor.extract"]
+        }))
+
+        engine.register(SyntaxMedicProvider(server))
+        engine.register(ArtisanBridgeProvider(server))
+        engine.register(RefactorSurgeonProvider(server))
+        engine.register(NeuralHealerProvider(server))
+
+        return engine
+
+    def compute(self, params: Any) -> List[CodeAction]:
+        """
+        [THE RITE OF DISCOVERY - HYDRATED]
+        """
+        # 1. EXTRACT URI & DOC (Safe Access)
+        try:
+            uri = str(params.text_document.uri)
+        except:
+            uri = str(params.get('textDocument', {}).get('uri', ''))
+
+        doc = self.server.documents.get(uri)
+        if not doc: return []
+
+        # 2. HYDRATE DIAGNOSTICS (THE CURE)
+        # The params.context.diagnostics might be a list of Dicts.
+        # Providers expect List[Diagnostic] objects.
+        raw_diagnostics = []
+        try:
+            raw_diagnostics = params.context.diagnostics
+        except:
+            raw_diagnostics = params.get('context', {}).get('diagnostics', [])
+
+        hydrated_diagnostics = []
+        for d in raw_diagnostics:
+            try:
+                if isinstance(d, dict):
+                    hydrated_diagnostics.append(Diagnostic.model_validate(d))
+                else:
+                    hydrated_diagnostics.append(d)
+            except:
+                pass
+
+        # 3. DISPATCH
+        # We manually invoke providers here to control the arguments precisely
+        all_actions = []
+        target_range = params.range if hasattr(params, 'range') else None
+
+        # If range is missing or dict, try to hydrate (Base engine handles this, but let's be safe)
+
+        for provider in self.providers:
+            try:
+                actions = provider.provide_actions(doc, target_range, hydrated_diagnostics)
+                if actions:
+                    all_actions.extend(actions)
+            except Exception as e:
+                Logger.error(f"Provider {provider.name} fractured: {e}")
+
+        return all_actions

velm/core/lsp/scaffold_features/code_action/models.py

@@ -0,0 +1,6 @@
+# Path: core/lsp/scaffold_features/code_action/models.py
+# --------------------------------------------------
+from ...base.types import (
+    CodeAction, CodeActionKind, CodeActionParams, CodeActionContext, CodeActionOptions,
+    WorkspaceEdit, Diagnostic, TextEdit, Range, Command, TextDocumentIdentifier
+)

velm/core/lsp/scaffold_features/code_action/providers/artisan_bridge.py

@@ -0,0 +1,214 @@
+# Path: core/lsp/scaffold_features/code_action/providers/artisan_bridge.py
+# ------------------------------------------------------------------------
+# LIF: INFINITY | AUTH_CODE: Ω_ARTISAN_BRIDGE_TOTALITY_V8_FINAL
+# SYSTEM: OCULAR_RETINA | ROLE: REDEMPTION_ORCHESTRATOR | RANK: SOVEREIGN
+# ========================================================================
+# [THE 12 LEGENDARY ASCENSIONS]:
+# 1.  [CONTRACTUAL_COMPLETION]: Definitive implementation of `resolve_action`,
+#     annihilating the `TypeError` abstract class fracture.
+# 2.  [CAPABILITY_SENSING]: Real-time scrying of client `workspaceEdit` powers
+#     to determine if `documentChanges` (LSP 3.17) should be manifest.
+# 3.  [SINGLE_VECTOR_PURITY]: Eradicates the "4x Duplicate Edit" heresy by
+#     picking the single most potent protocol vector for the specific client.
+# 4.  [GEOMETRIC_SUTURE]: Precise mapping of `RepairArtisan` deltas to
+#     LSP `TextEdit` objects with 0-indexed coordinate integrity.
+# 5.  [LATE_BOUND_INCEPTION]: Lazy-loads the `RepairArtisan` to ensure the
+#     main Engine is fully consecrated before the first repair plea.
+# 6.  [TITANIUM_PATH_RESOLUTION]: Uses `UriUtils.to_fs_path` to guarantee
+#     Daemon/LSP path parity across Windows/Linux schisms.
+# 7.  [METADATA_SUTURE]: Injects `_provider`, `trace_id`, and `heresy_key`
+#     into the `data` payload for forensic resolution.
+# 8.  [HAPTIC_BLOOM_TRIGGER]: Broadcasts `gnostic/vfx` bloom signals when a
+#     high-confidence fix is projected to the Architect.
+# 9.  [PRECISION_TRIAGE]: Filters for only those heresies that possess a
+#     valid `fix_command` in the Gnostic Grimoire.
+# 10. [PREFERRED_ACTION_BOOST]: Automatically flags "Undefined Variable"
+#     repairs as `isPreferred`, triggering the VS Code auto-fix lightbulb.
+# 11. [FORENSIC_INQUEST_LOG]: High-fidelity stderr logging of the repair
+#     logic, providing visibility into the "Zero Edits" paradox.
+# 12. [SOVEREIGN_RECONSTRUCTION]: Forges `WorkspaceEdit` objects that are
+#     compatible with both simple `changes` and complex `documentChanges`.
+
+import logging
+import os
+import sys
+import uuid
+from typing import List, Optional, Dict, Any
+
+# --- IRON CORE UPLINKS ---
+from ....base.features.code_action.contracts import CodeActionProvider
+from ....base.features.code_action.models import (
+    CodeAction,
+    CodeActionKind,
+    Diagnostic,
+    WorkspaceEdit,
+    TextEdit
+)
+from ....base.types import (
+    TextDocumentEdit,
+    OptionalVersionedTextDocumentIdentifier,
+    Range
+)
+from ....base.document import TextDocument
+from ....base import forensic_log, UriUtils
+
+# --- ARTISAN UPLINK ---
+from ......artisans.repair.artisan import RepairArtisan
+from ......interfaces.requests import RepairRequest
+
+
+class ArtisanBridgeProvider(CodeActionProvider):
+    """
+    =============================================================================
+    == THE PRECISION REPAIR PROPHET (V-Ω-TOTALITY-V8)                         ==
+    =============================================================================
+    The bridge between the Ocular Inquisitor and the Kinetic Mender.
+    """
+
+    def __init__(self, server: Any):
+        super().__init__(server)
+        self._artisan: Optional[RepairArtisan] = None
+
+    @property
+    def name(self) -> str:
+        return "InternalRepairProphet"
+
+    @property
+    def priority(self) -> int:
+        return 100  # Highest priority for structural fixes
+
+    def _get_artisan(self) -> RepairArtisan:
+        """[RITE]: MATERIALIZE_ARTISAN (Lazy Inception)"""
+        if self._artisan is None:
+            # We pass the server's engine to share the Gnostic Cortex
+            self._artisan = RepairArtisan(self.server.engine)
+        return self._artisan
+
+    def provide_actions(self, doc: TextDocument, range: Any, diagnostics: List[Diagnostic]) -> List[CodeAction]:
+        """
+        [THE RITE OF DIAGNOSIS]
+        Scans incoming heresies and summons the Mender to forge potential cures.
+        """
+        if not diagnostics:
+            return []
+
+        actions: List[CodeAction] = []
+        artisan = self._get_artisan()
+        trace_id = getattr(self.server._ctx, 'trace_id', f"act-{uuid.uuid4().hex[:6]}")
+
+        # [ASCENSION 2]: CAPABILITY SENSING
+        # Check if the client advertised support for modern documentChanges
+        caps = getattr(self.server, 'client_capabilities', None)
+        supports_doc_edits = False
+        if caps and hasattr(caps, 'workspace'):
+            ws_caps = getattr(caps.workspace, 'workspace_edit', {})
+            if isinstance(ws_caps, dict):
+                supports_doc_edits = ws_caps.get('documentChanges', False)
+            elif hasattr(ws_caps, 'document_changes'):
+                supports_doc_edits = bool(ws_caps.document_changes)
+
+        for heresy in diagnostics:
+            # 1. HERESY TRIAGE
+            code = str(getattr(heresy, 'code', '')).upper()
+
+            # [ASCENSION 9]: Filter for fixable gnostic archetypes
+            FIXABLE_GATES = ("UNDEFINED", "BOND_BROKEN", "REFERENCE", "SIGIL", "IMPORT", "HERESY", "UNUSED")
+            if not any(k in code for k in FIXABLE_GATES):
+                continue
+
+            # 2. CONDUCT INQUEST (Execute Repair Artisan internally)
+            try:
+                # [ASCENSION 6]: TITANIUM RESOLUTION
+                fs_path = str(UriUtils.to_fs_path(doc.uri))
+
+                # Forging the plea for the Mender
+                res = artisan.execute(RepairRequest(
+                    file_path=fs_path,
+                    heresy_key=code,
+                    line_num=heresy.range.start.line + 1,
+                    content=doc.text,
+                    project_root=self.server.project_root,
+                    context={
+                        "diagnostic": heresy.model_dump(mode='json'),
+                        "source": "LSP_EAGER_FIX",
+                        "trace_id": trace_id
+                    }
+                ))
+
+                if res.success and res.data and 'edits' in res.data:
+                    # [ASCENSION 4]: GEOMETRIC SUTURE
+                    # Transmute Artisan edits into strict LSP TextEdits
+                    text_edits = []
+                    for e in res.data['edits']:
+                        text_edits.append(TextEdit(
+                            range=Range.model_validate(e["range"]),
+                            newText=e.get("newText") or e.get("new_text") or ""
+                        ))
+
+                    if not text_edits:
+                        continue
+
+                    # 3. [ASCENSION 3]: PROTOCOL HARMONIZATION (NO ECHOES)
+                    # We pick exactly ONE path based on the client's advertised soul.
+                    workspace_edit = None
+
+                    if supports_doc_edits:
+                        # MODERN VECTOR: Versioned DocumentChanges
+                        doc_edit = TextDocumentEdit(
+                            text_document=OptionalVersionedTextDocumentIdentifier(
+                                uri=doc.uri,
+                                version=doc.version
+                            ),
+                            edits=text_edits
+                        )
+                        workspace_edit = WorkspaceEdit(documentChanges=[doc_edit])
+                    else:
+                        # LEGACY VECTOR: Simple Changes Map
+                        workspace_edit = WorkspaceEdit(changes={doc.uri: text_edits})
+
+                    # 4. FORGE THE CODE ACTION
+                    # [ASCENSION 10]: PREFERRED PROMOTION
+                    is_preferred = "UNDEFINED" in code or "IMPORT" in code
+
+                    action = CodeAction(
+                        title=f"✨ Gnostic Repair: {heresy.message}",
+                        kind=CodeActionKind.QuickFix,
+                        diagnostics=[heresy],
+                        isPreferred=is_preferred,
+                        edit=workspace_edit,
+                        # [ASCENSION 7]: METADATA SUTURE
+                        data={
+                            "_provider": self.name,
+                            "_trace_id": trace_id,
+                            "heresy_key": code
+                        }
+                    )
+                    actions.append(action)
+
+                    # [ASCENSION 8]: HAPTIC BLOOM
+                    if is_preferred:
+                        self.server.endpoint.send_notification("gnostic/vfx", {
+                            "type": "bloom", "color": "#10b981", "intensity": 0.5
+                        })
+
+            except Exception as fracture:
+                # [ASCENSION 11]: FORENSIC LOGGING
+                sys.stderr.write(f"[ArtisanBridge] 💥 Repair Inquest Failed for {code}: {fracture}\n")
+                continue
+
+        return actions
+
+    # =========================================================================
+    # == [ASCENSION 1]: THE RITE OF RESOLUTION (THE FIX)                     ==
+    # =========================================================================
+    def resolve_action(self, action: CodeAction) -> CodeAction:
+        """
+        [THE RITE OF SPLICING]
+        Fulfills the abstract contract of the IRON CORE.
+        Since we calculate edits Eagerly in provide_actions for the
+        Cockpit's speed, this rite is a simple confirmation of the soul.
+        """
+        # forensic_log(f"Resolving Action: {action.title}", "SUCCESS", "REPAIR")
+        return action
+
+# === SCRIPTURE SEALED: THE BRIDGE IS WHOLE ===

velm/core/lsp/scaffold_features/code_action/providers/neural_healer.py

@@ -0,0 +1,52 @@
+# Path: core/lsp/scaffold_features/code_action/providers/neural_healer.py
+# ------------------------------------------------------------------------
+
+from typing import List, Optional
+from ....base.features.code_action.contracts import CodeActionProvider
+from ....base.features.code_action.models import CodeAction, CodeActionKind, Diagnostic
+from ....base.document import TextDocument
+from ....base.types.primitives import Range, Command
+
+class NeuralHealerProvider(CodeActionProvider):
+    """
+    [THE PROPHET]
+    Summons the Neural Muse or AI Architect for generative healing of complex logic.
+    """
+    @property
+    def name(self) -> str: return "NeuralHealer"
+    @property
+    def priority(self) -> int: return 40
+
+    def provide_actions(self, doc: TextDocument, range: Range, diagnostics: List[Diagnostic]) -> List[CodeAction]:
+        # If no diagnostics, we offer "Explanation" instead of "Healing"
+        if not diagnostics:
+            return [
+                CodeAction(
+                    title="🔮 Explain architectural logic (Neural Muse)",
+                    kind=CodeActionKind.Refactor,
+                    command=Command(
+                        title="Neural Explanation",
+                        command="scaffold.muse.explain",
+                        arguments=[doc.uri, range.model_dump()]
+                    )
+                )
+            ]
+
+        # Offer Generative Healing for errors
+        return [
+            CodeAction(
+                title="🧠 Conduct Neural Redemption on these heresies",
+                kind=CodeActionKind.QuickFix,
+                diagnostics=diagnostics,
+                command=Command(
+                    title="Neural Repair",
+                    command="scaffold.architect.heal",
+                    arguments=[
+                        doc.uri,
+                        [d.model_dump() for d in diagnostics]
+                    ]
+                )
+            )
+        ]
+
+    def resolve_action(self, action: CodeAction) -> CodeAction: return action

velm/core/lsp/scaffold_features/code_action/providers/refactor_surgeon.py

@@ -0,0 +1,57 @@
+# Path: core/lsp/scaffold_features/code_action/providers/refactor_surgeon.py
+# ---------------------------------------------------------------------------
+
+import uuid
+from typing import List, Optional
+from ....base.features.code_action.contracts import CodeActionProvider
+from ....base.features.code_action.models import CodeAction, CodeActionKind, Diagnostic
+from ....base.document import TextDocument
+from ....base.types.primitives import Range, Command
+
+class RefactorSurgeonProvider(CodeActionProvider):
+    """
+    [THE SURGEON]
+    Focuses on structural transmutations based on selections.
+    """
+    @property
+    def name(self) -> str: return "RefactorSurgeon"
+    @property
+    def priority(self) -> int: return 70
+
+    def provide_actions(self, doc: TextDocument, range: Range, diagnostics: List[Diagnostic]) -> List[CodeAction]:
+        # Only offer refactoring if a range (block of code) is selected
+        if range.start.line == range.end.line and range.start.character == range.end.character:
+            return []
+
+        return [
+            # --- RITE 1: EXCISE TO FRAGMENT ---
+            CodeAction(
+                title="✨ Excise Gnosis to @include fragment",
+                kind=CodeActionKind.RefactorExtract,
+                command=Command(
+                    title="Extract Fragment",
+                    command="scaffold.refactor.extract",
+                    arguments=[
+                        doc.uri,
+                        range.model_dump(),
+                        {"strategy": "fragment", "auto_name": True}
+                    ]
+                )
+            ),
+            # --- RITE 2: CONVERT TO TRAIT ---
+            CodeAction(
+                title="🧬 Transmute selection to reusable %% trait",
+                kind=CodeActionKind.RefactorRewrite,
+                command=Command(
+                    title="Convert to Trait",
+                    command="scaffold.refactor.to_trait",
+                    arguments=[
+                        doc.uri,
+                        range.model_dump()
+                    ]
+                )
+            )
+        ]
+
+    def resolve_action(self, action: CodeAction) -> CodeAction: return action
+

velm/core/lsp/scaffold_features/code_action/providers/syntax_medic.py

@@ -0,0 +1,64 @@
+# Path: core/lsp/scaffold_features/code_action/providers/syntax_medic.py
+# -----------------------------------------------------------------------
+
+import re
+from typing import List, Optional
+from ....base.features.code_action.contracts import CodeActionProvider
+from ....base.features.code_action.models import CodeAction, CodeActionKind, Diagnostic, WorkspaceEdit, TextEdit
+from ....base.document import TextDocument
+from ....base.types.primitives import Range
+
+
+class SyntaxMedicProvider(CodeActionProvider):
+    """
+    [THE MEDIC]
+    Provides instant local skin-grafts for common grammar typos.
+    Handles fixes that can be derived purely from the current text.
+    """
+
+    @property
+    def name(self) -> str:
+        return "SyntaxMedic"
+
+    @property
+    def priority(self) -> int:
+        return 100
+
+    def provide_actions(self, doc: TextDocument, range: Range, diagnostics: List[Diagnostic]) -> List[CodeAction]:
+        actions = []
+        for heresy in diagnostics:
+            # --- FIX 1: Sigil Correction ($ -> $$) ---
+            if heresy.code == "SYNTAX_SIGIL" and "$" in heresy.message:
+                edit = TextEdit(range=heresy.range, newText="$$")
+                actions.append(CodeAction(
+                    title="Consecrate Sigil (Change '$' to '$$')",
+                    kind=CodeActionKind.QuickFix,
+                    diagnostics=[heresy],
+                    isPreferred=True,
+                    edit=WorkspaceEdit(changes={doc.uri: [edit]})
+                ))
+
+            # --- FIX 2: Jinja Spacing ({{var}} -> {{ var }}) ---
+            if "spacing" in heresy.message.lower() and "{{" in doc.get_line(heresy.range.start.line):
+                line = doc.get_line(heresy.range.start.line)
+                # Naive spacing fix
+                fixed_line = re.sub(r'\{\{\s*(.*?)\s*\}\}', r'{{ \1 }}', line)
+                if fixed_line != line:
+                    edit = TextEdit(
+                        range=Range(
+                            start=heresy.range.start,
+                            end=heresy.range.end
+                        ),
+                        newText=fixed_line.strip()
+                    )
+                    actions.append(CodeAction(
+                        title="Normalize Alchemical Spacing",
+                        kind=CodeActionKind.QuickFix,
+                        diagnostics=[heresy],
+                        edit=WorkspaceEdit(changes={doc.uri: [edit]})
+                    ))
+
+        return actions
+
+    def resolve_action(self, action: CodeAction) -> CodeAction:
+        return action

velm/core/lsp/scaffold_features/code_lens/__init__.py

@@ -0,0 +1,15 @@
+# Path: core/lsp/scaffold_features/code_lens/__init__.py
+# ------------------------------------------------------
+from .engine import ScaffoldCodeLensEngine
+from .providers import (
+    KineticActionProvider,
+    BlueprintHealerProvider,
+    IntelligenceProvider
+)
+
+__all__ = [
+    "ScaffoldCodeLensEngine",
+    "KineticActionProvider",
+    "BlueprintHealerProvider",
+    "IntelligenceProvider"
+]