velm 0.1.2__py3-none-any.whl

velm/symphony/polyglot/wards/python_ward.py

@@ -0,0 +1,37 @@
+# Path: scaffold/symphony/polyglot/wards/python_ward.py
+
+def get_harness(sanctum_abs_path: str) -> str:
+    """Returns the Gnostic Ward Harness for the Python runtime."""
+    return f'''
+# --- BEGIN SCAFFOLD GNOSTIC WARD (PYTHON) ---
+import os, pathlib, builtins, shutil
+__sc_sanctum_path__ = pathlib.Path(r"{sanctum_abs_path}")
+print(f"--- Gnostic Filesystem Ward Engaged (Sanctum: {{__sc_sanctum_path__}}) ---", flush=True)
+
+__sc_profane_open__ = builtins.open
+__sc_profane_Path__ = pathlib.Path
+
+def __sc_path_adjudicator__(path_obj_or_str, rite_name="Unknown"):
+    try:
+        # We must resolve relative to the current CWD of the script
+        abs_path = __sc_profane_Path__(os.path.abspath(str(path_obj_or_str))).resolve()
+        if not str(abs_path).startswith(str(__sc_sanctum_path__)):
+            raise PermissionError(f"[Gnostic Ward Heresy] The '{{rite_name}}' rite's attempt to access '{{abs_path}}' outside the sacred sanctum was struck down.")
+    except Exception as e:
+        raise PermissionError(f"[Gnostic Ward Heresy] A paradox occurred while adjudicating the path for '{{rite_name}}': {{e}}")
+
+def __sc_gnostic_open__(file, *args, **kwargs):
+    __sc_path_adjudicator__(file, "open")
+    return __sc_profane_open__(file, *args, **kwargs)
+
+class GnosticPath(__sc_profane_Path__):
+    def __new__(cls, *args, **kwargs):
+        if args:
+            __sc_path_adjudicator__(args[0], "Path()")
+        return super().__new__(cls, *args, **kwargs)
+
+builtins.open = __sc_gnostic_open__
+pathlib.Path = GnosticPath
+# --- END SCAFFOLD GNOSTIC WARD ---
+'''
+

velm/symphony/polyglot/wards/ruby_ward.py

@@ -0,0 +1,49 @@
+# Path: scaffold/symphony/polyglot/wards/ruby_ward.py
+
+def get_harness(sanctum_abs_path: str) -> str:
+    """Returns the Gnostic Ward Harness for the Ruby runtime."""
+    return f'''
+# --- BEGIN SCAFFOLD GNOSTIC WARD (RUBY) ---
+require 'pathname'
+
+$__sc_sanctum_path__ = Pathname.new('{sanctum_abs_path}').realpath
+puts "--- Gnostic Filesystem Ward Engaged (Sanctum: #{{$__sc_sanctum_path__}}) ---"
+
+def __sc_path_adjudicator__(path_str, rite_name)
+  begin
+    abs_path = Pathname.new(path_str).realpath
+    unless abs_path.to_s.start_with?($__sc_sanctum_path__.to_s)
+      raise PermissionError, "[Gnostic Ward Heresy] The '#{{rite_name}}' rite\\'s attempt to access '#{{abs_path}}' outside the sacred sanctum was struck down."
+    end
+  rescue => e
+    raise PermissionError, "[Gnostic Ward Heresy] A paradox occurred while adjudicating '#{{path_str}}': #{{e.message}}"
+  end
+end
+
+class File
+  # Save the profane, original rite
+  class << self
+    alias_method :__sc_profane_open__, :open
+  end
+
+  # Forge the new, Gnostically-aware rite
+  def self.open(*args, &block)
+    __sc_path_adjudicator__(args[0], 'File.open')
+    __sc_profane_open__(*args, &block)
+  end
+end
+
+class Pathname
+  # Save the profane, original rite
+  alias_method :__sc_profane_initialize__, :initialize
+
+  # Forge the new, Gnostically-aware rite
+  def initialize(path)
+    # The Gaze is upon the very moment of a Pathname's birth.
+    __sc_path_adjudicator__(path, 'Pathname.new')
+    __sc_profane_initialize__(path)
+  end
+end
+# --- END SCAFFOLD GNOSTIC WARD ---
+'''
+

velm/symphony/proclamations/base.py

@@ -0,0 +1,39 @@
+# Path: scaffold/symphony/proclamations/base.py
+# ---------------------------------------------
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Dict, Any
+
+if TYPE_CHECKING:
+    from ....core.alchemist import DivineAlchemist
+    from ....creator.registers import QuantumRegisters
+    from ....symphony.conductor_core.engine import SymphonyEngine
+    from rich.console import Console
+
+class ProclamationHandler(ABC):
+    """
+    The abstract soul of a Proclamation Scribe.
+    Defines the unbreakable contract for rendering Gnostic truths.
+    """
+    def __init__(
+        self,
+        alchemist: "DivineAlchemist",
+        console: "Console",
+        engine: "SymphonyEngine",
+        registers: "QuantumRegisters"
+    ):
+        self.alchemist = alchemist
+        self.console = console
+        self.engine = engine
+        self.regs = registers
+
+    @property
+    @abstractmethod
+    def key(self) -> str:
+        """The sacred keyword that summons this Scribe (e.g., 'table', 'file')."""
+        pass
+
+    @abstractmethod
+    def execute(self, gnostic_arguments: str):
+        """The one true rite of proclamation."""
+        pass

velm/symphony/proclamations/file_scribe.py

@@ -0,0 +1,47 @@
+# Path: scaffold/symphony/proclamations/file_scribe.py
+# ----------------------------------------------------
+
+import ast
+from pathlib import Path
+from .base import ProclamationHandler
+from ...utils import atomic_write
+
+
+class FileProclamationHandler(ProclamationHandler):
+    """The Scribe of Persistent Truth."""
+
+    @property
+    def key(self) -> str:
+        return "file"
+
+    def execute(self, gnostic_arguments: str):
+        """Parses `path="...", content="..."` and writes to the sanctum."""
+        try:
+            # Safely parse the arguments as a Python dictionary
+            args = ast.literal_eval(f"dict({gnostic_arguments})")
+            path_str = args.get("path")
+            content_str = args.get("content", "")
+
+            if not path_str:
+                raise ValueError("'path' argument is required.")
+
+            # Resolve path relative to the current sanctum
+            target_path = (self.regs.sanctum.root / path_str).resolve()
+
+            # Transmute content with variables
+            final_content = self.alchemist.transmute(content_str, self.regs.gnosis)
+
+            if not self.regs.dry_run:
+                atomic_write(
+                    target_path,
+                    final_content,
+                    self.regs.logger,
+                    self.regs.project_root,
+                    transaction=self.regs.transaction
+                )
+                self.console.print(f"✒️ Inscribed Gnosis to [cyan]{path_str}[/cyan]")
+            else:
+                self.console.print(f"[DRY-RUN] Would inscribe Gnosis to [cyan]{path_str}[/cyan]")
+
+        except Exception as e:
+            raise ValueError(f"Failed to parse 'file' proclamation: {e}")

velm/symphony/proclamations/panel_scribe.py

@@ -0,0 +1,46 @@
+# Path: scaffold/symphony/proclamations/panel_scribe.py
+# -----------------------------------------------------
+
+from rich.panel import Panel
+from rich.text import Text
+from rich.align import Align
+from rich.box import DOUBLE
+
+from .base import ProclamationHandler
+from ...symphony.execution.kinetic_titan.semantics import SemanticGrimoire
+
+
+class PanelProclamationHandler(ProclamationHandler):
+    """The Scribe of the Imperial Decree."""
+
+    @property
+    def key(self) -> str:
+        return "panel"  # This is the default/fallback scribe
+
+    def execute(self, gnostic_arguments: str):
+        """Forges a luminous, double-bordered panel."""
+
+        # In this simple case, the argument is the message itself.
+        final_message = self.alchemist.transmute(gnostic_arguments, self.regs.gnosis)
+
+        clean_msg = final_message.strip()
+        if len(clean_msg) >= 2 and clean_msg[0] in ('"', "'") and clean_msg[-1] == clean_msg[0]:
+            clean_msg = clean_msg[1:-1]
+
+        icon = SemanticGrimoire.divine_icon("proclaim")
+
+        text_content = Text(clean_msg, justify="center")
+        text_content.stylize("bold white")
+        SemanticGrimoire.enhance(text_content)
+
+        panel = Panel(
+            text_content,
+            title=f"[bold yellow]{icon} PROCLAMATION[/bold yellow]",
+            border_style="magenta",
+            box=DOUBLE,
+            padding=(1, 2),
+            expand=True
+        )
+
+        if not self.regs.dry_run:
+            self.console.print(panel)

velm/symphony/proclamations/router.py

@@ -0,0 +1,65 @@
+# Path: scaffold/symphony/proclamations/router.py
+# -----------------------------------------------
+
+import re
+from typing import TYPE_CHECKING, Dict, Any, Type
+
+from .base import ProclamationHandler
+from .panel_scribe import PanelProclamationHandler
+from .file_scribe import FileProclamationHandler
+# --- THE DIVINE SUMMONS OF THE NEW SCRIBES ---
+from .table_scribe import TableProclamationHandler
+from .slack_scribe import SlackProclamationHandler
+
+if TYPE_CHECKING:
+    from ....core.alchemist import DivineAlchemist
+    from ....creator.registers import QuantumRegisters
+    from ....symphony.conductor_core.engine import SymphonyEngine
+    from rich.console import Console
+
+# === THE PANTHEON OF PROCLAMATIONS (ASCENDED) ===
+PROCLAMATION_PANTHEON: Dict[str, Type[ProclamationHandler]] = {
+    "panel": PanelProclamationHandler,
+    "file": FileProclamationHandler,
+    "table": TableProclamationHandler,  # The Structured Scribe is enshrined
+    "slack": SlackProclamationHandler,  # The Celestial Herald is enshrined
+}
+# ===============================================
+
+# Regex to find the Scribe's key: `key(...)` or `key:`
+PROCLAMATION_KEY_REGEX = re.compile(r"^\s*(\w+)\s*[:\(]")
+
+
+def dispatch_proclamation(
+        raw_plea: str,
+        alchemist: "DivineAlchemist",
+        console: "Console",
+        engine: "SymphonyEngine",
+        registers: "QuantumRegisters"
+):
+    """
+    The one true rite of proclamation dispatch.
+    """
+    key = "panel"  # Default Scribe
+    gnostic_arguments = raw_plea
+
+    match = PROCLAMATION_KEY_REGEX.match(raw_plea)
+    if match:
+        potential_key = match.group(1).lower()
+        if potential_key in PROCLAMATION_PANTHEON:
+            key = potential_key
+            if raw_plea.strip().startswith(f"{key}:"):
+                gnostic_arguments = raw_plea.split(":", 1)[1].strip()
+            elif raw_plea.strip().startswith(f"{key}("):
+                start = raw_plea.find('(')
+                end = raw_plea.rfind(')')
+                if start != -1 and end != -1:
+                    gnostic_arguments = raw_plea[start + 1:end]
+
+    HandlerClass = PROCLAMATION_PANTHEON.get(key)
+    if not HandlerClass:
+        HandlerClass = PanelProclamationHandler
+        gnostic_arguments = raw_plea
+
+    handler = HandlerClass(alchemist, console, engine, registers)
+    handler.execute(gnostic_arguments)

velm/symphony/proclamations/slack_scribe.py

@@ -0,0 +1,93 @@
+# Path: scaffold/symphony/proclamations/slack_scribe.py
+# -----------------------------------------------------
+
+import os
+import ast
+import requests
+from .base import ProclamationHandler
+from ...contracts.heresy_contracts import ArtisanHeresy
+
+
+class SlackProclamationHandler(ProclamationHandler):
+    """
+    =================================================================================
+    == THE CELESTIAL HERALD (V-Ω-SLACK-MESSENGER)                                  ==
+    =================================================================================
+    @gnosis:title Proclamation Scribe: slack()
+    @gnosis:summary Broadcasts a Gnostic message to a Slack channel via webhook.
+    @gnosis:LIF 10,000,000,000,000
+
+    This divine artisan is the Celestial Herald, a bridge between the Symphony's
+    internal reality and the collaborative cosmos of Slack. It transmutes a Gnostic
+    plea into a secure, rich, and context-aware webhook notification.
+
+    ### THE PANTHEON OF 12 ASCENDED FACULTIES:
+
+    1.  **Secure by Default:** It righteously refuses to operate unless a
+        `SCAFFOLD_SLACK_WEBHOOK_URL` is enshrined in the environment, preventing secret leaks.
+    2.  **The Alchemical Heart:** It transmutes the `message` with Jinja, allowing for
+        dynamic, variable-rich proclamations (e.g., "Deployment of {{ version }} complete!").
+    3.  **Rich Payloads:** It understands `channel`, `username`, and `icon_emoji`,
+        allowing for fully customized messenger identities.
+    4.  **Markdown Native:** The `message` payload is transmitted as Slack `mrkdwn`,
+        enabling rich formatting like `*bold*`, `_italic_`, and `` `code` ``.
+    5.  **The Dry-Run Prophet:** In simulation mode, it proclaims a detailed, formatted
+        dossier of the message it *would* have sent, without touching the network.
+    6.  **The Resilient Messenger:** It wraps the celestial communion in a `try...except`
+        block with a timeout, raising a luminous `ArtisanHeresy` upon failure.
+    7.  **Asynchronous Prophecy:** Its design is inherently thread-safe, ready for a
+        future ascension where it is summoned into a parallel reality to prevent blocking.
+    8.  **The Unbreakable Ward of Parsing:** Safely parses arguments using `ast.literal_eval`.
+    9.  **The Luminous Voice:** Proclaims its success or failure to the Gnostic Chronicle.
+    10. **The Sovereign Soul:** A pure, self-contained artisan honoring its sacred contract.
+    11. **Zero-Config (Optional):** If no `channel` is provided, it relies on the
+        webhook's own default channel, simplifying the plea.
+    12. **The Unbreakable Contract:** It flawlessly honors every vow of the `ProclamationHandler`
+        contract, its soul pure and its purpose absolute.
+    """
+
+    @property
+    def key(self) -> str:
+        return "slack"
+
+    def execute(self, gnostic_arguments: str):
+        """Parses arguments and dispatches the Slack message."""
+        webhook_url = os.getenv("SCAFFOLD_SLACK_WEBHOOK_URL")
+        if not webhook_url:
+            raise ArtisanHeresy(
+                "Slack Heresy: The `SCAFFOLD_SLACK_WEBHOOK_URL` environment variable is not set.",
+                suggestion="Define the webhook URL in your environment to enable Slack proclamations."
+            )
+
+        try:
+            args = ast.literal_eval(f"dict({gnostic_arguments})")
+            message_raw = args.get("message")
+            if not message_raw:
+                raise ValueError("'message' argument is required.")
+
+            # Transmute the message content
+            message = self.alchemist.transmute(message_raw, self.regs.gnosis)
+
+            payload = {"text": message}
+            if "channel" in args:
+                payload["channel"] = args["channel"]
+            if "username" in args:
+                payload["username"] = args["username"]
+            if "icon_emoji" in args:
+                payload["icon_emoji"] = args["icon_emoji"]
+
+            if self.regs.dry_run:
+                self.console.print(f"[DRY-RUN] Would send Slack message to '{payload.get('channel', 'default')}':")
+                self.console.print(f" > {message}")
+                return
+
+            response = requests.post(webhook_url, json=payload, timeout=10)
+            response.raise_for_status()
+
+            self.console.print(
+                f"🗣️  Proclaimed Gnosis to Slack channel '[cyan]{payload.get('channel', 'default')}[/cyan]'.")
+
+        except (ValueError, SyntaxError) as e:
+            raise ArtisanHeresy(f"Failed to parse 'slack' proclamation arguments: {e}")
+        except requests.RequestException as e:
+            raise ArtisanHeresy(f"Celestial Communion with Slack failed: {e}")

velm/symphony/proclamations/table_scribe.py

@@ -0,0 +1,109 @@
+# Path: scaffold/symphony/proclamations/table_scribe.py
+# -----------------------------------------------------
+
+import ast
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from .base import ProclamationHandler
+from ...contracts.heresy_contracts import ArtisanHeresy
+
+
+class TableProclamationHandler(ProclamationHandler):
+    """
+    =================================================================================
+    == THE STRUCTURED SCRIBE (V-Ω-DYNAMIC-DATA-VISUALIZER)                         ==
+    =================================================================================
+    @gnosis:title Proclamation Scribe: table()
+    @gnosis:summary Forges a rich terminal table from dynamic Gnostic data.
+    @gnosis:LIF 10,000,000,000,000
+
+    This divine artisan transforms structured data (lists of lists, lists of dicts)
+    into a luminous, perfectly aligned `rich.Table`. It is the voice of order for
+    the Symphony's Gnostic proclamations.
+
+    ### THE PANTHEON OF 12 ASCENDED FACULTIES:
+
+    1.  **The Dynamic Schema:** Forges table columns on-the-fly from the `headers` argument.
+    2.  **The Alchemical Heart:** Transmutes the `rows` argument, resolving any `{{...}}`
+        Jinja variables to fetch data from the Symphony's living context.
+    3.  **The Polyglot Data Soul:** Intelligently renders data from both lists of lists
+        (e.g., `[['a', 1], ['b', 2]]`) and lists of dictionaries.
+    4.  **The Gnostic Stylist:** Accepts `title` and `style` arguments to customize the
+        table's aesthetic, allowing for context-aware (e.g., `style="red"`) proclamations.
+    5.  **The Responsive Layout:** The forged table automatically expands to the terminal
+        width, ensuring perfect alignment in any viewing sanctum.
+    6.  **The Dry-Run Prophet:** In simulation mode, it proclaims its intent and the
+        shape of the data it would have rendered, without painting the table.
+    7.  **The Unbreakable Ward of Parsing:** Its argument parsing is shielded by a `try...except`
+        block, preventing malformed Gnosis from shattering the Symphony.
+    8.  **The Type Purifier:** Righteously converts all cell data to strings before rendering,
+        annihilating potential `rich` type heresies.
+    9.  **The Rich Integration:** It wields the full, divine power of the `rich.Table`
+        artisan, including its advanced layout and styling capabilities.
+    10. **The Sovereign Soul:** It is a pure, self-contained artisan that perfectly
+        honors the `ProclamationHandler` contract.
+    11. **The Luminous Voice:** Proclaims its intent to the Gnostic Chronicle, providing
+        a clear audit trail of its every rite.
+    12. **The Extensible Mind:** Its architecture is forged to easily accept future Gnostic
+        arguments like `caption`, `show_lines`, or `justify_map`.
+    """
+
+    @property
+    def key(self) -> str:
+        return "table"
+
+    def execute(self, gnostic_arguments: str):
+        """Parses `headers=[...], rows={{...}}` and forges the Table."""
+        try:
+            # Safely parse the arguments string into a dictionary
+            args = ast.literal_eval(f"dict({gnostic_arguments})")
+
+            headers = args.get("headers")
+            rows_data_raw = args.get("rows")
+            title = args.get("title", "Gnostic Proclamation")
+            style = args.get("style", "magenta")
+
+            if not headers or not isinstance(headers, list):
+                raise ValueError("'headers' must be a list of strings.")
+            if rows_data_raw is None:
+                raise ValueError("'rows' argument is required.")
+
+            # Transmute the rows data, which might be a Jinja variable
+            rows = self.alchemist.transmute(f"{{{{ {rows_data_raw} }}}}", self.regs.gnosis)
+
+            if not isinstance(rows, list):
+                # Attempt to load from JSON if it's a string
+                try:
+                    rows = ast.literal_eval(str(rows))
+                    if not isinstance(rows, list): raise ValueError()
+                except:
+                    raise TypeError(f"Resolved 'rows' data is not a list. Type: {type(rows)}")
+
+            if self.regs.dry_run:
+                self.console.print(
+                    f"[DRY-RUN] Would proclaim a table titled '{title}' with {len(headers)} columns and {len(rows)} rows.")
+                return
+
+            # Forge the Table
+            table = Table(title=f"[bold]{title}[/bold]", border_style=style, box=ROUNDED, show_header=True,
+                          header_style=f"bold {style}")
+
+            for header in headers:
+                table.add_column(header, justify="left", overflow="fold")
+
+            # Populate Rows
+            for row in rows:
+                if isinstance(row, list):
+                    table.add_row(*[str(cell) for cell in row])
+                elif isinstance(row, dict):
+                    # For dicts, we extract values in the order of the headers
+                    row_values = [str(row.get(h, 'N/A')) for h in headers]
+                    table.add_row(*row_values)
+
+            self.console.print(table)
+
+        except (ValueError, SyntaxError, TypeError) as e:
+            raise ArtisanHeresy(f"Failed to parse 'table' proclamation arguments: {e}",
+                                details=f"Raw Arguments: {gnostic_arguments}")

velm/symphony/release.symphony

@@ -0,0 +1,31 @@
+# Path: symphony/release.symphony
+# -------------------------------
+
+# The final, sacred rite of ascension.
+# Usage: scaffold run symphony/release.symphony --var version_bump=patch
+
+%% proclaim: "Beginning the Rite of Celestial Ascension..."
+
+# Vow 1: The Sanctum must be pure.
+>> git status --porcelain as git_status
+?? stdout_contains: ""
+
+# Vow 2: The Architect must proclaim the nature of the ascension.
+?? variable_equals: version_bump, "patch" | "minor" | "major"
+
+# The Rite of Version Transmutation
+>> poetry version {{ version_bump }}
+?? succeeds
+
+# The Rite of Forging
+>> poetry build
+?? succeeds
+
+# The Architect's Final Vow
+?? confirm: "Proclaim this new ascension to the PyPI cosmos?"
+
+# The Final Proclamation
+>> poetry publish
+?? succeeds
+
+%% proclaim: "Apotheosis Complete. The new version is manifest."

velm/symphony/renderers/__init__.py

@@ -0,0 +1,17 @@
+# Path: scaffold/symphony/renderers/__init__.py
+# ---------------------------------------------
+from .base import Renderer
+from .rich_renderer import RichRenderer
+from .basic_renderer import BasicRenderer
+from .github_renderer import GitHubActionsRenderer
+from .cinematic_renderer import CinematicRenderer
+from .stream_renderer import StreamRenderer
+from .raw_renderer import RawRenderer
+__all__ = [
+    'Renderer',
+    'RichRenderer',
+    'BasicRenderer',
+    'GitHubActionsRenderer',
+    'CinematicRenderer',
+    'StreamRenderer'
+]

velm/symphony/renderers/base.py

@@ -0,0 +1,72 @@
+# scaffold/symphony/renderers/base.py
+# -----------------------------------------
+import sys
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Optional, Any, List, TYPE_CHECKING, Union, Dict
+
+if TYPE_CHECKING:
+    from ..conductor import SymphonyConductor
+    from ...contracts.symphony_contracts import ConductorEvent, SymphonyResult, Edict, ActionResult
+
+
+class Renderer(ABC):
+    """
+    =================================================================================
+    == THE SACRED CONTRACT OF THE VOICE (V-Ω-SUSPENDABLE)                          ==
+    =================================================================================
+    LIF: 10,000,000,000,000
+    """
+
+    def __init__(self, conductor: 'SymphonyConductor'):
+        self.conductor = conductor
+
+    @abstractmethod
+    def suspend(self):
+        """
+        [THE RITE OF SILENCE]
+        Pauses any active Live displays or spinners to allow another Artisan
+        (like the Intercession Altar) to take control of the terminal.
+        """
+        pass
+
+    @abstractmethod
+    def resume(self):
+        """
+        [THE RITE OF RETURN]
+        Resumes the Live display after the interruption.
+        """
+        pass
+
+    # --- Legacy / Optional Hooks ---
+    def conduct_interactive_plea(self, prompt_text: str, default: bool = True): ...
+
+    def render_summary_dossier(self, result: 'SymphonyResult'): ...
+
+    def render_paradox(self, heresy: Exception, traceback_obj: Any, captured_output: Optional[str] = None): ...
+
+    def render_action_prologue(self, edict: 'Edict', transmuted_command: str, sanctum: Path): ...
+
+    def render_action_epilogue(self, live_context: Any, result: 'ActionResult'): ...
+
+    def update_live_stream(self, live_context: Any, line: Union[str, Any]): ...
+
+    def render_polyglot_prologue(self, edict: 'Edict', sanctum: Path): ...
+
+    def render_vow_result(self, is_pure: bool, reason: str, edict: 'Edict'): ...
+
+    def render_state_change(self, key: str, value: str, relative_sanctum: Path): ...
+
+    def render_proclamation(self, message: str, sanctum: Optional[Path] = None): ...
+
+    def render_block_prologue(self, edict: 'Edict', title: str): ...
+
+    def render_block_epilogue(self, edict: 'Edict'): ...
+
+    def render_intercession_altar(self, edict: 'Edict', heresy: Exception): ...
+
+    def render_comment(self, raw_scripture: str): ...
+
+    def render_foreign_adjudication(self, results: List[Any], edict: 'Edict'): ...
+
+    def render_structured_status(self, proclamations: List[Dict], line_num: int): ...

velm/symphony/renderers/basic_renderer/__init__.py

@@ -0,0 +1,12 @@
+# Path: scaffold/symphony/renderers/basic_renderer/__init__.py
+# ------------------------------------------------------------
+
+"""
+=================================================================================
+== THE SANCTUM OF THE FORENSIC SCRIBE (V-Ω-MODULAR-GATEWAY)                    ==
+=================================================================================
+This sanctum exposes the unified BasicRenderer facade.
+"""
+from .facade import BasicRenderer
+
+__all__ = ["BasicRenderer"]

velm/symphony/renderers/basic_renderer/codex.py

@@ -0,0 +1,16 @@
+# Path: scaffold/symphony/renderers/basic_renderer/codex.py
+# ---------------------------------------------------------
+from typing import Dict
+
+class BasicCodex:
+    """The visual language of the Forensic Scribe."""
+    ICONS: Dict[str, str] = {
+        "action": "⚙️", "vow": "⚖️", "state": "🔮",
+        "success": "✔", "failure": "✘", "prologue": "▶", "epilogue": "■",
+        "stream": "│"
+    }
+    STYLES: Dict[str, str] = {
+        "command": "bold cyan", "success": "green", "failure": "red",
+        "vow": "magenta", "state": "yellow", "prologue": "dim", "epilogue": "dim",
+        "log_stream": "white"
+    }