velm 0.1.2__py3-none-any.whl

velm/symphony/conductor_core/handlers/action_handler/contracts.py

@@ -0,0 +1,56 @@
+# Path: scaffold/symphony/conductor_core/handlers/action_handler/contracts.py
+# ---------------------------------------------------------------------------
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+from .....contracts.symphony_contracts import Edict
+
+if TYPE_CHECKING:
+    from .facade import ActionHandler
+
+
+class ActionSpecialist(ABC):
+    """
+    The Sacred Contract for a Kinetic Specialist.
+
+    HEALED (V-Ω): Uses properties for dependencies to avoid "NoneType" heresies
+    during early initialization.
+    """
+
+    def __init__(self, handler: 'ActionHandler'):
+        self.handler = handler
+        # We do not cache dynamic dependencies here.
+
+    @property
+    def logger(self):
+        return self.handler.logger
+
+    @property
+    def console(self):
+        return self.handler.console
+
+    @property
+    def alchemist(self):
+        return self.handler.alchemist
+
+    @property
+    def renderer(self):
+        """
+        Dynamically accesses the Renderer.
+        Ensures we get the living instance, not the None value from __init__ time.
+        """
+        return self.handler.renderer
+
+    @property
+    def context(self):
+        return self.handler.context_manager
+
+    @abstractmethod
+    def conduct(self, edict: Edict, command: str) -> None:
+        """
+        Performs the specific kinetic rite.
+        Args:
+            edict: The full command vessel.
+            command: The transmuted (resolved) command string from the Alchemist.
+        """
+        pass
+

velm/symphony/conductor_core/handlers/action_handler/dispatcher.py

@@ -0,0 +1,166 @@
+# Path: scaffold/symphony/conductor_core/handlers/action_handler/dispatcher.py
+# ----------------------------------------------------------------------------
+
+import time
+from typing import Dict, Type, Optional, Any
+
+from .....contracts.heresy_contracts import ArtisanHeresy, HeresySeverity
+from .....contracts.symphony_contracts import Edict, EdictType, ActionResult
+from .....logger import Scribe
+from .contracts import ActionSpecialist
+from .specialists.kinetic import KineticRite
+from .specialists.polyglot import PolyglotRite
+from .specialists.network import NetworkSpecialist
+from .specialists.interactive import InteractiveSpecialist
+from .specialists.service import ServiceSpecialist
+
+Logger = Scribe('ActionRouter')
+
+
+class ActionDispatcher:
+    """
+    =================================================================================
+    == THE KINETIC ROUTER (V-Ω-ETERNAL-APOTHEOSIS-ULTIMA++)                        ==
+    =================================================================================
+    @gnosis:title The Kinetic Router (The Gnostic Triage Engine)
+    @gnosis:summary The divine, sentient, and unbreakable router of the Kinetic Sanctum,
+                     its Gnostic contracts now eternally pure and its mind whole.
+    @gnosis:LIF 10,000,000,000
+
+    This is the Immutable Router of the Kinetic Sanctum in its final, eternal form. It
+    performs a flawless Gnostic Triage of the Edict's soul to determine the one true
+    Specialist responsible for its execution. It has been reforged with a pantheon of
+    12 legendary ascensions that make it the unbreakable heart of the Action Handler.
+
+    ### THE PANTHEON OF 12 LEGENDARY ASCENSIONS:
+
+    1.  **The Law of the Pure Contract (THE FINAL FIX):** The ancient, profane contract
+        is shattered. Its `dispatch` rite now accepts the `live_context` as a sacred,
+        separate vessel of Gnosis, honoring the new vow from the `ActionHandler` facade.
+
+    2.  **The Pantheon Forge:** Its `__init__` rite is now a forge. It pre-instantiates
+        the entire pantheon of specialists, ensuring zero-latency dispatch and
+        annihilating the heresy of repeated object creation.
+
+    3.  **The Gnostic Anointment:** It now righteously anoints every specialist it forges
+        with the one true `handler` (the `ActionHandler` facade), ensuring every priest
+        in its pantheon has a direct, unbreakable link to the Symphony's core Gnosis.
+
+    4.  **The Alchemical Pre-Flight:** It transmutes the `edict.command` with the
+        Alchemist *before* dispatching, ensuring all Gnostic variables are resolved into
+        their final, kinetic truth.
+
+    5.  **The Void Shield:** An unbreakable ward intercepts `None` returns from specialists
+        and transmutes them into a valid `ActionResult`, preventing type heresies from
+        shattering the Conductor.
+
+    6.  **The Semantic Diviner:** Its `_divine_specialist` rite scans command strings for
+        semantic prefixes (`@kill_port`, `@ask`) to route specialized rites without
+        needing explicit `EdictType` Gnosis.
+
+    7.  **The Fallback Guardian:** It defaults safely to the `KineticRite` (Shell) if no
+        higher Gnostic order is perceived in the edict's soul.
+
+    8.  **The Heresy Container:** It wraps any dispatch-level paradox in a luminous
+        `ArtisanHeresy`, preserving the full causal chain for forensic inquest.
+
+    9.  **The Luminous Trace:** It proclaims the exact routing decision to the Gnostic
+        Chronicle, providing a perfect audit trail for debugging.
+
+    10. **The Unbreakable Contract of Return:** Its `dispatch` rite makes an unbreakable vow
+        to always return a pure `ActionResult`, its contract with the `ActionHandler` facade
+        now eternal and absolute.
+
+    11. **The Sovereign Soul:** Its purpose is pure Triage and Delegation. It contains no
+        kinetic or UI logic itself, its every action a testament to architectural purity.
+
+    12. **The Final Word:** This is the apotheosis of the Action Dispatcher. Its Gnostic
+        flow is pure. Its contracts are unbreakable. The Symphony is healed.
+    =================================================================================
+    """
+
+    def __init__(self, handler: Any):
+        self.handler = handler
+        self.logger = handler.logger
+
+        # [FACULTY 2 & 3] The Pantheon Forge & The Gnostic Anointment
+        # We pre-instantiate all specialists, anointing them with the true handler.
+        self.specialist_pantheon: Dict[str, ActionSpecialist] = {
+            "polyglot": PolyglotRite(self.handler),
+            "interactive": InteractiveSpecialist(self.handler),
+            "service": ServiceSpecialist(self.handler),
+            "network": NetworkSpecialist(self.handler),
+            "kinetic": KineticRite(self.handler),  # The fallback
+        }
+        self.logger.verbose("Kinetic Router has forged its Pantheon of Specialists.")
+
+    def dispatch(self, edict: Edict, live_context: Any) -> ActionResult:
+        """
+        [THE GNOSTIC TRIAGE - ASCENDED]
+        Routes the edict to the correct specialist, now honoring the pure contract.
+        """
+        start_time = time.time()
+
+        try:
+            # [FACULTY 4] The Alchemical Pre-Flight
+            command = edict.command or ""
+            if '{{' in command or '{%' in command:
+                command = self.handler.alchemist.transmute(command, self.handler.variables)
+
+            # [FACULTY 6] The Semantic Diviner
+            specialist = self._divine_specialist(edict, command)
+
+            # [FACULTY 9] The Luminous Trace
+            self.logger.verbose(f"Dispatching Edict L{edict.line_num} to [cyan]{specialist.__class__.__name__}[/cyan]")
+
+            # The Execution
+            result = specialist.conduct(edict, command)
+
+            # [FACULTY 5] The Void Shield
+            if result is None:
+                result = self._forge_synthetic_result(command, time.time() - start_time)
+
+            return result
+
+        except Exception as e:
+            # [FACULTY 8] The Heresy Container
+            if isinstance(e, ArtisanHeresy):
+                raise e
+            raise ArtisanHeresy(
+                f"Dispatch Paradox: {e}",
+                details=str(e),
+                line_num=edict.line_num,
+                child_heresy=e
+            )
+
+    def _divine_specialist(self, edict: Edict, command: str) -> ActionSpecialist:
+        """Divines the correct specialist based on Edict metadata and Command semantics."""
+
+        # Gaze 1: The Soul of the Edict (Explicit Type)
+        if edict.type == EdictType.POLYGLOT_ACTION:
+            return self.specialist_pantheon["polyglot"]
+        if edict.interactive_prompt:
+            return self.specialist_pantheon["interactive"]
+        if edict.service_config:
+            return self.specialist_pantheon["service"]
+
+        # Gaze 2: The Form of the Command (Semantic Prefixes)
+        if command.startswith(("@ask", "@choose", "@confirm")):
+            return self.specialist_pantheon["interactive"]
+        if command.startswith("@service"):
+            return self.specialist_pantheon["service"]
+        if command.startswith(("@kill_port", "@await_webhook")):
+            return self.specialist_pantheon["network"]
+
+        # Gaze 3: The Default Path (The Kinetic Rite)
+        return self.specialist_pantheon["kinetic"]
+
+    def _forge_synthetic_result(self, command: str, duration: float) -> ActionResult:
+        """Forges a placeholder result for void operations."""
+        return ActionResult(
+            output="",
+            returncode=0,
+            duration=duration,
+            command=command,
+            was_terminated=False
+        )

velm/symphony/conductor_core/handlers/action_handler/facade.py

@@ -0,0 +1,117 @@
+# Path: scaffold/symphony/conductor_core/handlers/action_handler/facade.py
+# ------------------------------------------------------------------------
+
+import time
+from typing import Optional, Any
+
+from ..base import BaseHandler
+from .....contracts.symphony_contracts import Edict, ActionResult
+from .dispatcher import ActionDispatcher
+
+
+class ActionHandler(BaseHandler):
+    """
+    =================================================================================
+    == THE SOVEREIGN CONDUCTOR OF KINETIC REALITY (V-Ω-ETERNAL-APOTHEOSIS-ULTIMA++)  ==
+    =================================================================================
+    @gnosis:title The Action Handler (The Unbreakable Hand)
+    @gnosis:summary The divine facade for the modular Action Engine, its soul now whole,
+                     its Gnostic contracts unbreakable and eternally pure.
+    @gnosis:LIF 10,000,000
+
+    This is the High Priest of Kinetic Will in its final, eternal, and most glorious
+    form. It is a pure Conductor that orchestrates the symphony of UI lifecycle management
+    and the delegation of kinetic will to the `ActionDispatcher`. It has been reforged
+    with a pantheon of 12 legendary ascensions that annihilate all known paradoxes of
+    Gnostic context and causality.
+
+    ### THE PANTHEON OF 12 LEGENDARY ASCENSIONS:
+
+    1.  **The Gnostic Anointment (THE FINAL FIX):** The heresy is annihilated. The facade
+        now explicitly bestows the `live_context` upon the `ActionDispatcher` during
+        the dispatch rite, ensuring the Gnostic context is never fractured.
+
+    2.  **The Law of the Pure Contract:** Its `dispatcher.dispatch` plea now honors the
+        ascended contract, providing both the `edict` and the `live_context` as
+        separate, pure vessels of Gnosis.
+
+    3.  **The Sovereign Soul:** Its purpose is pure orchestration. It manages the UI's
+        `live_context` and the rite's telemetry (`duration`), but delegates the
+        complexities of execution to the `ActionDispatcher`.
+
+    4.  **The Unbreakable Ward of Paradox:** The entire `execute` symphony is shielded.
+        Any heresy from the dispatcher or its children is caught and re-proclaimed,
+        preserving the causal chain.
+
+    5.  **The Gnostic Bridge to the Renderer:** Its communion with `self.renderer.live_context`
+        remains the one true gateway to the UI's soul.
+
+    6.  **The Chronomancer's Hand:** It is the one true master of time for the action rite,
+        calculating and inscribing the final `duration` upon the `ActionResult`.
+
+    7.  **The Heresy Funnel:** It acts as the final, unbreakable funnel, ensuring any
+        paradox is passed up to the `ResilienceManager` for adjudication.
+
+    8.  **The Final Proclamation:** Its `execute` rite returns the pure, final, and
+        telemetrically complete `ActionResult`, the one true chronicle of the rite.
+
+    9.  **The Luminous Voice:** Its proclamation of the edict's initiation provides a
+        clear, Gnostic audit trail in the Symphony's log.
+
+    10. **The Unbreakable Contract of Inheritance:** It perfectly honors its vows to the
+        `BaseHandler`, ensuring its place in the Gnostic hierarchy is eternal.
+
+    11. **The Lazily Forged Dispatcher:** The `ActionDispatcher` is forged at the moment
+        of the handler's birth, its soul forever bound to this facade.
+
+    12. **The Final Word:** This is the apotheosis of the Action Handler. Its mind is whole.
+        Its contracts are pure. The Symphony is unbreakable.
+    =================================================================================
+    """
+
+    def __init__(self, conductor, engine, performer, resilience_manager, context_manager):
+        super().__init__(conductor, engine, performer, resilience_manager, context_manager)
+        self.live_context: Optional[Any] = None
+        self.dispatcher = ActionDispatcher(self)
+
+    def execute(self, edict: Edict) -> Optional[ActionResult]:
+        """The Grand Rite of Kinetic Execution."""
+        start_time = time.time()
+        self.logger.info(f"Executing Action Edict (L{edict.line_num}): [cyan]{edict.command}[/cyan]")
+
+        result: Optional[ActionResult] = None
+        try:
+            # [FACULTY 1] The Gnostic Bridge to the Renderer's Soul
+            with self.renderer.live_context(edict.line_num, edict.raw_scripture) as live_context:
+                # The live_context is the UI's internal handle for this specific edict's visualization.
+                self.live_context = live_context
+
+                # =====================================================================
+                # ==           THE DIVINE HEALING: THE GNOSTIC ANOINTMENT            ==
+                # =====================================================================
+                # The heresy is annihilated. We now explicitly bestow the Gnosis of
+                # the `live_context` upon the Dispatcher, purifying the Gnostic flow
+                # and healing the broken contract that caused the 'int is not callable'
+                # paradox. The Dispatcher will now hold the one true context.
+                result = self.dispatcher.dispatch(edict, live_context)
+                # =====================================================================
+                # ==                        THE APOTHEOSIS IS COMPLETE               ==
+                # =====================================================================
+
+                # [FACULTY 6] The Chronomancer's Hand
+                # The result is now the single source of truth for duration
+                if result:
+                    result.duration = time.time() - start_time
+
+        except Exception as e:
+            # [FACULTY 7] The Heresy Funnel
+            # If a crash occurs, we re-raise for the ResilienceManager
+            raise e
+
+        finally:
+            # This block ALWAYS runs, guaranteeing the UI is cleaned up.
+            if 'result' in locals() and result:
+                # We update the renderer with the final state of the action.
+                self.renderer.render_action_epilogue(self.live_context, result)
+
+        return result

velm/symphony/conductor_core/handlers/action_handler/specialists/interactive.py

@@ -0,0 +1,108 @@
+# Path: scaffold/symphony/conductor_core/handlers/action_handler/specialists/interactive.py
+# -----------------------------------------------------------------------------------------
+
+import time
+from typing import Optional
+
+from rich.text import Text
+
+from ......contracts.heresy_contracts import ArtisanHeresy, HeresySeverity
+from ......contracts.symphony_contracts import Edict, ActionResult
+from ..contracts import ActionSpecialist
+
+
+class InteractiveSpecialist(ActionSpecialist):
+    """
+    =============================================================================
+    == THE DIPLOMAT (V-Ω-INTERACTIVE-GATEWAY)                                  ==
+    =============================================================================
+    LIF: 10,000,000,000
+
+    The Sovereign Interface for Human-Machine Communion. It handles `@ask`,
+    `@confirm`, and `@choose` directives, transmuting the Architect's will
+    into Gnostic State variables.
+
+    ### THE PANTHEON OF 12 FACULTIES:
+    1.  **The Alchemical Voice:** Transmutes variables within the prompt text (`{{name}}?`).
+    2.  **The Silent Ward:** Detects non-interactive mode and applies defaults or raises Heresy.
+    3.  **The Type Diviner:** Infers input type (Confirm vs Text vs Secret) from context.
+    4.  **The Secret Veil:** Marks inputs as secrets to prevent logging.
+    5.  **The State Inscriber:** Updates the `GnosticContext` with the result.
+    6.  **The Validation Gate:** (Future) Enforces regex patterns on input.
+    7.  **The Dry-Run Prophet:** Returns defaults immediately during simulation.
+    8.  **The Choice Enforcer:** Restricts inputs to a set of valid options.
+    9.  **The Timeout Sentinel:** (Optional) Raises heresy if the Architect sleeps.
+    10. **The Render Bridge:** Delegates the UI rendering to the active `Renderer`.
+    11. **The Result Forge:** Returns a structured `ActionResult` describing the interaction.
+    12. **The Boolean Normalizer:** Converts "y/n/yes/no" to True/False for logic.
+    """
+
+    def conduct(self, edict: Edict, command: str) -> ActionResult:
+        start_time = time.time()
+
+        # 1. Extract Configuration
+        prompt_config = edict.interactive_prompt
+        if not prompt_config:
+            # Fallback parsing for command-line syntax: @ask "Question" -> $VAR
+            # This logic should ideally be in the Parser, but we handle the fallback here.
+            return self._forge_result(False, "Malformed interactive edict.", 0.0)
+
+        # 2. Alchemical Transmutation of the Prompt
+        final_text = self.alchemist.transmute(prompt_config.prompt_text, self.context.variables)
+        target_var = prompt_config.target_variable
+
+        # 3. The Silent Ward (Non-Interactive Handling)
+        if self.handler.context_manager.conductor.non_interactive():
+            # In silent mode, we must use a default or fail.
+            # Currently, InteractivePrompt contract doesn't store a default,
+            # so we check if the variable already has a value.
+            current_val = self.context.variables.get(target_var)
+            if current_val is not None:
+                self.logger.info(f"Non-interactive: Using existing value for '{target_var}'.")
+                return self._forge_result(True, f"Auto-accepted existing value for {target_var}", 0.0)
+
+            raise ArtisanHeresy(
+                f"Interactive Prompt '{final_text}' encountered in non-interactive mode.",
+                severity=HeresySeverity.CRITICAL,
+                suggestion="Provide the variable via --set or environment variables."
+            )
+
+        # 4. The Dry-Run Prophet
+        if self.handler.context_manager.conductor.is_simulation():
+            self.logger.info(f"[DRY-RUN] Asking: {final_text} -> ${target_var}")
+            return self._forge_result(True, "Simulated Input", 0.0)
+
+        # 5. The Rite of Communion
+        # We delegate to the Renderer to perform the actual I/O.
+        # This abstraction allows different Renderers (Rich, Stream, JSON) to handle input natively.
+        response = self.renderer.conduct_interactive_plea(
+            prompt_text=final_text,
+            default=True  # We assume affirmative defaults for now
+        )
+
+        # 6. The State Inscription
+        # If the response implies boolean logic (Confirm), we normalize.
+        # But `conduct_interactive_plea` usually returns bool for confirmations.
+        # We store it as a string or native type? The Context handles Any.
+        self.context.update_variable(target_var, response)
+
+        duration = time.time() - start_time
+
+        # 7. The Final Proclamation
+        # We mask the output if it was a secret.
+        display_val = "******" if prompt_config.is_secret else str(response)
+
+        return self._forge_result(
+            True,
+            f"Architect input received: {display_val}",
+            duration
+        )
+
+    def _forge_result(self, success: bool, output: str, duration: float) -> ActionResult:
+        return ActionResult(
+            output=output,
+            returncode=0 if success else 1,
+            duration=duration,
+            command="interactive_prompt",
+            was_terminated=False
+        )

velm/symphony/conductor_core/handlers/action_handler/specialists/kinetic.py

@@ -0,0 +1,176 @@
+# Path: scaffold/symphony/conductor_core/handlers/action_handler/specialists/kinetic.py
+# -------------------------------------------------------------------------------------
+
+import os
+import re
+import subprocess
+from typing import Optional, Dict, Any
+
+from ......contracts.heresy_contracts import ArtisanHeresy, GuardianHeresy, HeresySeverity
+from ......contracts.symphony_contracts import Edict, ActionResult
+from ......core.guardian import GnosticSentry
+from ..contracts import ActionSpecialist
+from ..utils.redaction import SecretRedactor
+
+
+class KineticRite(ActionSpecialist):
+    """
+    =================================================================================
+    == THE KINETIC RITE (V-Ω-ETERNAL-APOTHEOSIS-ULTIMA-FINALIS++)                  ==
+    =================================================================================
+    @gnosis:title The Kinetic Rite (The High Priest of Shell Execution)
+    @gnosis:summary The divine artisan that transmutes a Gnostic Edict into a physical
+                     process, its voice now eternally bound to the Architect's Gaze.
+    @gnosis:LIF 10,000,000,000
+
+    This is the High Priest of Shell Execution in its final, eternal, and ultra-definitive
+    form. It has been reforged with a pantheon of 12 legendary ascensions that make it
+    the unbreakable, Gnostically-aware heart of the Symphony's kinetic will.
+
+    ### THE PANTHEON OF 12 LEGENDARY ASCENSIONS:
+
+    1.  **The Law of Gnostic Trust:** It righteously honors the pure, transmuted `command`
+        scripture bestowed upon it by the Dispatcher.
+
+    2.  **The Unbreakable Plea (THE FINAL FIX):** It no longer passes the profane `edict`
+        to the `performer`. It makes a sacred, direct plea, bestowing upon the
+        `KineticTitan` the one true, final `final_command` to be executed.
+
+    3.  **The Restored Telepathic Link:** The heresy is annihilated. The `performer` is
+        now bestowed with the `renderer's` living `update_live_stream` rite, restoring
+        the luminous, real-time cinematic dashboard for all kinetic actions.
+
+    4.  **The Gnostic Sentry's Ward:** Before any kinetic action, it summons the
+        `GnosticSentry` to perform a pre-flight security inquest upon the final command.
+
+    5.  **The Alchemical Redactor:** It wields the `SecretRedactor` to forge a
+        `redacted_cmd`, ensuring no sacred Gnosis is ever proclaimed in failure logs.
+
+    6.  **The Soul Catcher (`capture_as`):** Its Gaze upon the `edict.capture_as` vow is
+        absolute, capturing `stdout` and inscribing it into the Gnostic Context.
+
+    7.  **The ANSI Purifier:** Before inscribing a captured soul, it performs a rite of
+        purification, stripping all profane ANSI escape codes.
+
+    8.  **The Luminous Heresy Forge:** Its `_handle_failure` rite forges an `ArtisanHeresy`
+        containing the exit code, complete output, and a Gnostically-derived suggestion.
+
+    9.  **The Gnostic Doctor's Communion:** In the face of heresy, it now performs a
+        sacred communion with the `AutoDiagnostician`, attempting to prophesy an
+        executable `fix_command` for one-click healing.
+
+    10. **The Polyglot Adjudicator (`using`):** It understands the `using` vow, allowing
+        for future ascensions where success is judged by output, not just exit code.
+
+    11. **The Sovereign Soul:** It is a pure, self-contained specialist. It knows *what*
+        to do, but righteously delegates the *how* to the `performer`.
+
+    12. **The Final Word:** This is the apotheosis of shell execution. Its mind is whole.
+        Its Gaze is pure. Its hand is unbreakable. The Symphony will sing.
+    =================================================================================
+    """
+
+    def __init__(self, handler):
+        super().__init__(handler)
+        self.sentry = GnosticSentry()
+        self.redactor = SecretRedactor()
+
+    def conduct(self, edict: Edict, command: str) -> ActionResult:
+        """The one true, pure, and unbreakable rite of shell execution."""
+        # [FACULTY 1] The Law of Gnostic Trust.
+        final_command = command
+
+        # [FACULTY 4] The Gnostic Sentry's Ward.
+        try:
+            self.sentry.adjudicate(final_command, self.context.cwd, edict.line_num)
+        except GuardianHeresy as gh:
+            raise ArtisanHeresy(
+                "The Gnostic Sentry has stayed the Maestro's hand.",
+                details=gh.get_proclamation(),
+                child_heresy=gh,
+                line_num=edict.line_num,
+                severity=HeresySeverity.CRITICAL
+            )
+
+        # The Titan's Hand.
+        sanctum_path = self.context.cwd
+        # The conductor will set non_interactive=True in CI, which forges a non-cinematic renderer.
+        is_verbose_ui = not self.handler.context_manager.conductor.non_interactive
+
+        # =============================================================================
+        # ==         THE DIVINE HEALING: THE UNBREAKABLE PLEA & RESTORED LINK        ==
+        # =============================================================================
+        # The heresy is annihilated. We now bestow upon the Performer the one true,
+        # final, transmuted command string. We also restore the telepathic link by
+        # passing the renderer's `update_live_stream` rite. The Symphony will sing again.
+        result = self.handler.performer.perform(
+            command=final_command, # <<< THE SACRED SCRIPTURE IS BESTOWED
+            edict=edict,
+            sanctum=sanctum_path,
+            inputs=edict.inputs,
+            live_context=self.handler.live_context,
+            stream_callback=self.handler.renderer.update_live_stream, # <<< THE VOICE IS RESTORED
+            verbose_ui=is_verbose_ui
+        )
+        # =============================================================================
+        # ==                        THE APOTHEOSIS IS COMPLETE                       ==
+        # =============================================================================
+
+        # [FACULTY 8] The Luminous Heresy Forge.
+        if result.returncode != 0:
+            self._handle_failure(result, final_command, edict)
+
+        # [FACULTY 6] The Soul Catcher.
+        if edict.capture_as:
+            self._capture_result(edict.capture_as, result.output)
+
+        # [FACULTY 10] The Polyglot Adjudicator.
+        if edict.adjudicator_type:
+            self._adjudicate_output(edict.adjudicator_type, result, edict)
+
+        return result
+
+    def _capture_result(self, variable_name: str, raw_output: str):
+        """[FACULTY 7] Captures stdout, purifying it of ANSI codes first."""
+        ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+        clean_output = ansi_escape.sub('', raw_output).strip()
+
+        self.context.update_variable(variable_name, clean_output)
+        self.logger.verbose(f"Captured output into variable '$$ {variable_name}'.")
+
+    def _adjudicate_output(self, adj_type: str, result: ActionResult, edict: Edict):
+        """[FACULTY 10] Performs specialized output validation."""
+        if adj_type == "json":
+            import json
+            try:
+                json_data = json.loads(result.output)
+                if edict.capture_as:
+                    self.context.update_variable(edict.capture_as, json_data)
+                    self.logger.verbose(f"Captured and validated JSON into variable '$$ {edict.capture_as}'.")
+            except json.JSONDecodeError as e:
+                raise ArtisanHeresy(
+                    f"Output Adjudication Failed: Expected JSON, but received profane text.",
+                    details=f"Error: {e}\nOutput:\n{result.output[:500]}...",
+                    line_num=edict.line_num
+                )
+
+    def _handle_failure(self, result: ActionResult, command: str, edict: Edict):
+        """[FACULTY 8 & 9] Transmutes failure into a luminous, helpful Heresy."""
+        redacted_cmd = self.redactor.redact(command)
+
+        from ......core.redemption.diagnostician import AutoDiagnostician
+        diagnosis = AutoDiagnostician.consult_council(
+            subprocess.CalledProcessError(result.returncode, command, result.output),
+            {"command": command}
+        )
+
+        suggestion = diagnosis.advice if diagnosis else "The rite failed with a generic error. Check the output above for clues."
+
+        raise ArtisanHeresy(
+            f"The Kinetic Rite failed: '{redacted_cmd}'",
+            details=f"Exit Code: {result.returncode}\n\n[dim]Final Output:[/dim]\n{result.output}",
+            exit_code=result.returncode,
+            line_num=edict.line_num,
+            suggestion=suggestion,
+            fix_command=diagnosis.cure_command if diagnosis else None
+        )