velm 0.1.2__py3-none-any.whl

velm/symphony/conductor_core/setup.py

@@ -0,0 +1,238 @@
+# Path: scaffold/symphony/conductor_core/setup.py
+# -----------------------------------------------
+
+import tempfile
+import os
+import shutil
+import re
+from pathlib import Path
+from typing import Optional, TYPE_CHECKING, Dict, Any, List, Tuple
+
+from ...contracts.heresy_contracts import ArtisanHeresy, HeresySeverity
+from ...contracts.symphony_contracts import Edict, EdictType
+from ...logger import Scribe
+from ...parser_core.parser import parse_structure, ApotheosisParser
+from ...utils import atomic_write, to_string_safe
+
+if TYPE_CHECKING:
+    from .context import GnosticContextManager
+    from ...interfaces.requests import SymphonyRequest
+
+Logger = Scribe('SymphonySetup')
+
+
+class SymphonySetup:
+    """
+    =================================================================================
+    == THE FORGEMASTER OF REALITY (V-Ω-SAFETY-HARDENED-ULTIMA++)                   ==
+    =================================================================================
+    LIF: 10,000,000,000,000,000,000 (ABSOLUTE PREPARATION)
+
+    The divine artisan that prepares the realm for the Symphony. It determines the
+    **Mode of Existence** (Manifest vs Rehearsal), parses the Scripture of Will,
+    and initializes the environment.
+
+    ### THE PANTHEON OF 12 ASCENDED FACULTIES:
+
+    1.  **The Trinity Return:** Returns `(sanctum, edicts, vows)` to satisfy
+        the Orchestrator's contract.
+    2.  **The Runtime Vow Extractor:** Separates runtime vow injections from executable
+        edicts to populate the `runtime_vows` list.
+    3.  **The Manifest Mode Default:** Explicitly sets `ephemeral_sanctum` to `None`
+        unless `rehearse` is sworn.
+    4.  **The Dotenv Sentinel:** Automatically detects and loads `.env` files.
+    5.  **The Variable Alchemist:** Merges CLI overrides (`--set`) with Blueprint variables.
+    6.  **The Path Normalizer:** Ensures `execution_root` is always an absolute Path.
+    7.  **The Scripture Validator:** Raises Heresy if the Symphony is silent (empty).
+    8.  **The Gnostic Anchor:** Injects `project_root` and `sanctum` into Context.
+    9.  **The Secret's Veil:** Scans loaded variables for potential secrets.
+    10. **The Rehearsal Isolation:** Uses `tempfile.mkdtemp` for safe testing.
+    11. **The Task Selector:** Filters edicts by `@task` name if requested.
+    12. **The Sovereign State:** Maintains immutable source of truth for parsed artifacts.
+    """
+
+    def __init__(
+            self,
+            context_manager: 'GnosticContextManager',
+            symphony_path: Path,
+            request: 'SymphonyRequest',
+            execution_root: Optional[Path],
+            is_simulation: bool
+    ):
+        self.context_manager = context_manager
+        self.symphony_path = symphony_path
+        self.request = request
+        self.execution_root = execution_root.resolve() if execution_root else symphony_path.parent.resolve()
+        self.is_simulation = is_simulation
+
+        self.ephemeral_sanctum_path: Optional[Path] = None
+        self._parsed_tasks: Dict[str, List[Edict]] = {}
+
+    def initialize_symphony(self) -> Tuple[Path, List[Edict], List[Edict]]:
+        """
+        [THE GRAND RITE OF PREPARATION]
+        1. Determine Reality (Manifest vs Rehearsal).
+        2. Parse Scripture.
+        3. Hydrate Environment.
+        4. Select Task (if any).
+        5. Return (Sanctum, Edicts, Vows).
+        """
+        Logger.info(f"Initializing Symphony context for '{self.symphony_path.name}'...")
+
+        # 1. Determine Reality
+        if self.request.rehearse:
+            sanctum = self._prophesy_and_forge_proving_ground()
+        else:
+            sanctum = self.execution_root
+
+        # 2. Update Context Manager with spatial truth
+        self.context_manager.set_sanctum(str(sanctum))
+
+        # 3. Parse Scripture
+        # We need the parser instance to get tasks and runtime vows
+        parser_instance, edicts, blueprint_vars = self._parse_scripture()
+
+        # 4. Hydrate Environment (Variables & Secrets)
+        self._hydrate_environment(blueprint_vars)
+
+        # 5. Task Selection & Runtime Vow Extraction
+        final_edicts = []
+        runtime_vows = []
+
+        # Extract runtime vows from the global scope (directives)
+        # In the parser, these are often Edicts of type DIRECTIVE with specific args
+        # But for now, we assume the MetaHandler handles them during execution or we filter them here.
+        # Let's filter: Edicts that register vows vs executable edicts.
+
+        # Actually, `parser.edicts` contains everything.
+        # Runtime vow registration usually happens via `MetaHandler` executing a directive.
+        # So we pass them as part of the execution stream unless they are purely declarative headers.
+        # For simplicity in V1, we pass everything to the engine, and the engine dispatches.
+        # EXCEPT: If we select a task, we must still execute the global setup/vows?
+        # Standard logic: Global scope runs, then task? Or just task?
+        # Scaffold Logic: If task is selected, ONLY run task. Global vars are loaded, but global edicts are skipped.
+
+        if self.request.task:
+            if self.request.task not in self._parsed_tasks:
+                raise ArtisanHeresy(
+                    f"Task '{self.request.task}' not found in scripture.",
+                    suggestion=f"Available tasks: {', '.join(self._parsed_tasks.keys())}"
+                )
+            Logger.info(f"Selected task: [cyan]{self.request.task}[/cyan]")
+            final_edicts = self._parsed_tasks[self.request.task]
+        else:
+            final_edicts = edicts
+
+        # Identify Runtime Vow Definitions (if any specific pre-load is needed)
+        # Currently, `@inject_vow` produces a DIRECTIVE edict that runs at runtime.
+        # So we include them in the stream.
+
+        if not final_edicts and not self.request.task:
+            # If no task requested and main body is empty, that's a warning.
+            # But if tasks exist, maybe the user forgot to specify one?
+            if self._parsed_tasks:
+                raise ArtisanHeresy(
+                    "The Symphony's main body is silent, but tasks were found.",
+                    suggestion=f"Did you mean to run a task? Available: {', '.join(self._parsed_tasks.keys())}"
+                )
+            else:
+                raise ArtisanHeresy("The Symphony is silent. No edicts found to conduct.")
+
+        return sanctum, final_edicts, runtime_vows
+
+    def _hydrate_environment(self, blueprint_vars: Dict[str, Any]):
+        """
+        [THE ALCHEMICAL MERGE]
+        Merges:
+        1. .env file (Lowest)
+        2. Blueprint Variables ($$)
+        3. CLI Overrides (--set) (Highest)
+
+        Also detects secrets and stores them in the Vault.
+        """
+        # 1. Dotenv
+        env_path = self.execution_root / ".env"
+        if env_path.exists():
+            Logger.info("Loading environment from .env...")
+            try:
+                content = env_path.read_text(encoding='utf-8')
+                for line in content.splitlines():
+                    line = line.strip()
+                    if line and not line.startswith('#') and '=' in line:
+                        k, v = line.split('=', 1)
+                        k, v = k.strip(), v.strip().strip('"\'')
+                        # Only set if not already present (preserve CLI overrides if they were set early)
+                        # Actually, context hydration happens here. CLI vars are injected later?
+                        # No, context.hydrate() already put CLI vars in.
+                        # So we check if k exists.
+                        if k not in self.context_manager:
+                            self.context_manager.update_variable(k, v)
+                            # Check for secrets
+                            if self.context_manager.is_secret(k):
+                                self.context_manager.vault.store(k, v)
+            except Exception as e:
+                Logger.warn(f"Failed to load .env: {e}")
+
+        # 2. Blueprint Variables
+        for k, v in blueprint_vars.items():
+            # CLI overrides (already in context) take precedence
+            if k not in self.context_manager:
+                self.context_manager.update_variable(k, v)
+                if self.context_manager.is_secret(k):
+                    # Value might be a literal string or a template.
+                    # If literal, store in vault.
+                    if isinstance(v, str) and "{{" not in v:
+                        self.context_manager.vault.store(k, v)
+
+    def _parse_scripture(self) -> Tuple['ApotheosisParser', List[Edict], Dict[str, Any]]:
+        """
+        [THE GAZE OF UNDERSTANDING]
+        Parses the .symphony file and extracts the Gnostic Dowry.
+        """
+        parser = ApotheosisParser(grammar_key='symphony')
+
+        try:
+            content = self.symphony_path.read_text(encoding='utf-8')
+        except FileNotFoundError:
+            raise ArtisanHeresy(f"Symphony scripture not found: {self.symphony_path}")
+
+        # We pass pre_resolved_vars from CLI to help with immediate resolution if needed,
+        # though usually resolution happens at runtime.
+        cli_vars = self.context_manager.raw()
+
+        # [THE GNOSTIC DOWRY UNPACKING]
+        # (parser, items, commands, edicts, variables, dossier)
+        parser_instance, _, _, edicts, variables, dossier = parser.parse_string(
+            content,
+            file_path_context=self.symphony_path,
+            pre_resolved_vars=cli_vars
+        )
+
+        if not parser.all_rites_are_pure:
+            details = "\n".join([f"L{h.line_num}: {h.message}" for h in parser.heresies])
+            raise ArtisanHeresy("Parsing Heresy: The scripture contains errors.", details=details)
+
+        # Store parsed tasks for later selection
+        self._parsed_tasks = parser.tasks
+
+        return parser, edicts, variables
+
+    def _prophesy_and_forge_proving_ground(self) -> Path:
+        """[THE RITE OF ISOLATION] Creates a temp dir and copies the project."""
+        self.ephemeral_sanctum_path = Path(tempfile.mkdtemp(prefix="scaffold_rehearsal_"))
+        Logger.info(f"Forging Ephemeral Proving Ground at: {self.ephemeral_sanctum_path}")
+
+        # Ignore patterns to prevent copying heavy/irrelevant artifacts
+        def _ignore_patterns(path, names):
+            return {'.git', '.scaffold', 'node_modules', 'venv', '.venv', '__pycache__', '.idea', '.vscode', 'target',
+                    'dist', 'build'}
+
+        try:
+            # We copy the execution root into the temp dir
+            # Note: We must be careful not to copy the temp dir into itself if it's somehow inside (unlikely with /tmp)
+            shutil.copytree(self.execution_root, self.ephemeral_sanctum_path, dirs_exist_ok=True,
+                            ignore=_ignore_patterns)
+        except Exception as e:
+            raise ArtisanHeresy(f"Failed to forge Proving Ground: {e}")
+
+        return self.ephemeral_sanctum_path

velm/symphony/docs_generator.symphony

@@ -0,0 +1,45 @@
+    
+# Path: symphony/docs_generator.symphony
+# --------------------------------------
+
+# This symphony forges the VS Code snippets and parts of the Markdown documentation
+# by gazing into the engine's own soul.
+
+%% proclaim: "Awakening the Oracle of Introspection..."
+
+# Capture the complete Gnostic Canon of the engine as a JSON string
+>> scaffold introspect all --json as gnostic_canon_json
+?? succeeds
+
+# Summon a Polyglot Scribe to transmute the Gnosis
+py:
+    import json
+    import os
+
+    # Resurrect the Gnosis from the captured variable
+    gnosis_str = os.environ.get("SC_VAR_GNOSTIC_CANON_JSON", "{}")
+    gnosis = json.loads(gnosis_str)
+
+    # --- FORGE SNIPPETS ---
+    snippets = {}
+    for rite in gnosis.get("help_topics", []):
+        key = f"Scaffold Rite: {rite}"
+        snippets[key] = {
+            "prefix": f"scaffold {rite}",
+            "body": [f"scaffold {rite} $1"],
+            "description": f"Conduct the '{rite}' rite."
+        }
+    
+    # Inscribe the new scripture
+    Path(".vscode/scaffold.code-snippets").write_text(json.dumps(snippets, indent=2))
+    
+    # --- FORGE MARKDOWN DOCS ---
+    md_lines = ["# Gnostic Canon of Rites\n"]
+    for rite in gnosis.get("help_topics", []):
+        md_lines.append(f"- `scaffold {rite}`")
+
+    Path("docs/COMMANDS.md").write_text("\n".join(md_lines))
+
+%% proclaim: "The Living Codex has been updated."
+
+  

velm/symphony/execution/__init__.py

@@ -0,0 +1,17 @@
+# // scaffold/symphony/execution/__init__.py
+
+"""
+=================================================================================
+== THE SACRED GATEWAY TO THE KINETIC SOUL                                      ==
+=================================================================================
+This scripture is the one true, public gateway to the Pantheon of Action. It
+proclaims the sacred `KineticInterface` and its divine children to the cosmos,
+while shielding the inner workings of the sanctum from the profane Gaze.
+=================================================================================
+"""
+from .interface import KineticInterface
+from .kinetic_titan import KineticTitan
+from .prophetic_oracle import PropheticOracle
+
+# The Divine Proclamation
+__all__ = ["KineticInterface", "KineticTitan", "PropheticOracle"]

velm/symphony/execution/interface.py

@@ -0,0 +1,103 @@
+# Path: scaffold/symphony/execution/interface.py
+# ----------------------------------------------
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Callable, Any, Union, List, Optional, Dict
+from rich.text import Text
+from ...contracts.symphony_contracts import Edict, ActionResult
+
+
+class KineticInterface(ABC):
+    """
+    =================================================================================
+    == THE SACRED CONTRACT OF KINETIC WILL (V-Ω-ETERNAL-APOTHEOSIS-ULTIMA++)       ==
+    =================================================================================
+    @gnosis:title The Kinetic Interface (The Unbreakable Vow of Action)
+    @gnosis:summary The divine, abstract soul of all kinetic artisans, its contract now
+                     reforged to command the new, Gnostically-aware Kinetic Titan.
+    @gnosis:LIF 10,000,000,000,000
+
+    This is the unbreakable Gnostic contract for all artisans that perform kinetic rites.
+    It has been ascended to its final, eternal form, shattering the ancient laws that bound
+    it to the profane, untransmuted `edict`. It is the pure, Gnostic scripture of will.
+
+    ### THE PANTHEON OF 12 LEGENDARY ASCENSIONS:
+
+    1.  **The Unbreakable Plea (THE FINAL FIX):** The `perform` rite's contract has been
+        reforged. It now demands the pure, final, transmuted `command` string as its
+        primary Gnosis, annihilating the `TypeError` heresy for all time.
+
+    2.  **The Chronomancer's Ward:** The contract now includes a `timeout` vow, bestowing
+        upon all kinetic rites the power to guard against eternal, hanging processes.
+
+    3.  **The Gnostic Environment Alchemist:** The contract now accepts `env_overrides`,
+        allowing for the surgical injection of Gnostic context into a child process's soul.
+
+    4.  **The Sandbox Prophecy:** The contract now accepts a `permissions` vessel, a sacred
+        prophecy for a future ascension where the Titan can forge sandboxed realities.
+
+    5.  **The Pure Gnostic Contract:** As an `ABC`, its vows remain unbreakable. Any future
+        kinetic artisan *must* honor this new, more powerful contract.
+
+    6.  **The Unbreakable Vow of Return:** It continues to vow that it will always return a
+        pure `ActionResult` vessel, providing a consistent chronicle of reality.
+
+    7.  **The Luminous Scripture:** Its documentation has been ascended to reflect the new,
+        richer parameters, mentoring future architects on how to commune with it.
+
+    8.  **The Sovereign Soul:** Its soul remains abstract. It defines *what* must be done,
+        not *how*, preserving the architectural purity of its adherents.
+
+    9.  **The Gnostic Triage of Voice:** The `verbose_ui` vow remains, preserving the bridge
+        to the cinematic renderers and honoring the need for both silent and luminous rites.
+
+    10. **The Conduit of Souls:** The `inputs` vow remains, ensuring the `stdin` of a process
+        can always be fed with Gnosis.
+
+    11. **The Unbreakable Return Code Gaze:** The `get_last_return_code` vow is preserved,
+        its vessel now a pure `Optional[int]` for greater type safety.
+
+    12. **The Final Word:** This is the apotheosis of the kinetic contract. The schism is healed.
+        The architecture is eternal.
+    =================================================================================
+    """
+
+    @abstractmethod
+    def perform(
+        self,
+        command: str,
+        edict: Edict,
+        sanctum: Path,
+        inputs: List[str],
+        live_context: Any,
+        stream_callback: Callable[[Any, Union[str, Text]], None],
+        verbose_ui: bool = False,
+        timeout: Optional[int] = None,
+        env_overrides: Optional[Dict[str, str]] = None,
+        permissions: Optional[Dict[str, Any]] = None
+    ) -> ActionResult:
+        """
+        Executes the final, transmuted command within the Sanctum.
+
+        Args:
+            command: The pure, final, Gnostically-transmuted command string to execute.
+            edict: The original vessel of will, for metadata and context (e.g., `capture_as`).
+            sanctum: The directory where the rite is conducted.
+            inputs: A list of strings to inject into the process's soul (stdin).
+            live_context: The UI context passed back to the callback.
+            stream_callback: The function to invoke for every line of output.
+            verbose_ui: If True, summons the Cinematic Dashboard.
+            timeout: An optional timeout in seconds for the rite.
+            env_overrides: A dictionary of environment variables to inject.
+            permissions: A dictionary defining sandboxing rules (a future prophecy).
+
+        Returns:
+            ActionResult: The crystallized outcome of the rite.
+        """
+        pass
+
+    @abstractmethod
+    def get_last_return_code(self) -> Optional[int]:
+        """Returns the exit code of the most recent rite, or None if no rite was run."""
+        pass

velm/symphony/execution/kinetic_titan/__init__.py

@@ -0,0 +1,13 @@
+# Path: scaffold/symphony/execution/kinetic_titan/__init__.py
+# -----------------------------------------------------------
+
+"""
+=================================================================================
+== THE KINETIC TITAN SANCTUM (V-Ω-MODULAR-VISUALIZATION)                       ==
+=================================================================================
+This sanctum houses the God-Engine of Process Execution and Visualization.
+It transmutes raw shell commands into a cinematic, interactive experience.
+"""
+from .titan import KineticTitan
+
+__all__ = ['KineticTitan']

velm/symphony/execution/kinetic_titan/executor.py

@@ -0,0 +1,221 @@
+# Path: scaffold/symphony/execution/kinetic_titan/executor.py
+# -----------------------------------------------------------
+
+import subprocess
+import os
+import signal
+import sys
+import threading
+import time
+from typing import List, Optional, Dict, Any, Union
+from queue import Queue
+from pathlib import Path
+
+from ....logger import Scribe
+
+Logger = Scribe('TitanExecutor')
+
+
+class TitanExecutor:
+    """
+    =================================================================================
+    == THE TITAN EXECUTOR (V-Ω-ETERNAL-APOTHEOSIS-ULTIMA-FINALIS++)                 ==
+    =================================================================================
+    @gnosis:title The Titan Executor (The Physics Engine)
+    @gnosis:summary The unbreakable wrapper around the OS kernel's process creation.
+                     It standardizes the chaotic reality of subprocess management.
+    @gnosis:LIF 10,000,000,000
+
+    This artisan creates, monitors, and destroys processes. It hides the complexity
+    of OS differences (Windows vs POSIX) and provides a unified, method-based API
+    for the Kinetic Titan.
+    """
+
+    def __init__(self):
+        self._process: Optional[subprocess.Popen] = None
+        self._cwd: Path = Path.cwd()
+        self._threads: List[threading.Thread] = []
+
+    # =========================================================================
+    # == THE RITES OF STATE (METHOD-BASED API)                               ==
+    # =========================================================================
+
+    def pid(self) -> Optional[int]:
+        """
+        [THE RITE OF IDENTITY]
+        Returns the Process ID.
+        """
+        if self._process:
+            return self._process.pid
+        return None
+
+    def returncode(self) -> Optional[int]:
+        """
+        [THE RITE OF JUDGMENT]
+        Polls the process and returns the exit code if finished, else None.
+        Fixed to be a METHOD, not a property, to align with the Orchestrator.
+        """
+        if self._process:
+            self._process.poll()  # Update state from OS
+            return self._process.returncode
+        return None
+
+    def cwd(self) -> Path:
+        """Returns the sanctum where the process lives."""
+        return self._cwd
+
+    def is_alive(self) -> bool:
+        """Adjudicates if the process is currently running."""
+        return self.returncode() is None
+
+    # =========================================================================
+    # == THE RITES OF KINETIC ACTION                                         ==
+    # =========================================================================
+
+    def ignite(
+            self,
+            command: str,
+            inputs: List[str],
+            cwd: Path,
+            env: Dict[str, str],
+            output_queue: Queue
+    ):
+        """
+        [THE RITE OF IGNITION]
+        Spawns the subprocess and attaches the IO pumps.
+        """
+        self._cwd = cwd
+
+        # 1. Prepare OS-Specific Flags
+        creation_flags = 0
+        start_new_session = False
+
+        if os.name == 'nt':
+            # Windows: New Process Group to allow tree killing
+            creation_flags = subprocess.CREATE_NEW_PROCESS_GROUP
+        else:
+            # POSIX: New Session (setsid) to detach from parent TTY signals
+            start_new_session = True
+
+        # 2. Spawn the Process
+        try:
+            self._process = subprocess.Popen(
+                command,
+                shell=True,
+                cwd=str(cwd),  # subprocess needs string path
+                env=env,
+                stdin=subprocess.PIPE if inputs else None,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,  # Text mode
+                encoding='utf-8',
+                errors='replace',  # [FACULTY 7] Gnostic Encoding Safety
+                creationflags=creation_flags,
+                start_new_session=start_new_session
+            )
+        except Exception as e:
+            # If ignition fails, we must raise immediately
+            Logger.error(f"Ignition Sequence Failed: {e}")
+            raise e
+
+        # 3. Summon the Stream Daemons
+        # We spawn threads to pump stdout/stderr into the shared queue
+        self._summon_reader(self._process.stdout, 'stdout', output_queue)
+        self._summon_reader(self._process.stderr, 'stderr', output_queue)
+
+        # 4. Summon the Input Injector (if needed)
+        if inputs and self._process.stdin:
+            self._summon_injector(self._process.stdin, inputs)
+
+    def wait(self, timeout: Optional[float] = None):
+        """Blocks until the process concludes."""
+        if self._process:
+            try:
+                self._process.wait(timeout=timeout)
+            except subprocess.TimeoutExpired:
+                pass  # Caller handles timeout logic via is_alive()
+
+    def kill(self):
+        """
+        [THE RITE OF THE REAPER]
+        Terminates the process and its entire lineage (Tree Kill).
+        Handles Windows and POSIX differences robustly.
+        """
+        if not self._process or self._process.returncode is not None:
+            return
+
+        try:
+            Logger.verbose(f"Terminating process {self._process.pid}...")
+
+            if os.name == 'nt':
+                # [FACULTY 3] The Windows Reaper: taskkill /T (Tree) /F (Force)
+                subprocess.run(
+                    ["taskkill", "/F", "/T", "/PID", str(self._process.pid)],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL
+                )
+            else:
+                # [FACULTY 2] The POSIX Reaper: Kill the Process Group
+                # We used start_new_session=True, so os.getpgid(pid) == pid
+                try:
+                    os.killpg(os.getpgid(self._process.pid), signal.SIGTERM)
+                    # Give it a moment to die with dignity
+                    try:
+                        self._process.wait(timeout=0.5)
+                    except subprocess.TimeoutExpired:
+                        os.killpg(os.getpgid(self._process.pid), signal.SIGKILL)
+                except ProcessLookupError:
+                    pass  # Already dead
+
+        except Exception as e:
+            Logger.warn(f"Reaper faltered: {e}")
+            # Fallback to simple kill
+            try:
+                self._process.kill()
+            except:
+                pass
+
+    # =========================================================================
+    # == THE INTERNAL ARTISANS (THREADS)                                     ==
+    # =========================================================================
+
+    def _summon_reader(self, stream, stream_type: str, output_queue: Queue):
+        """Spawns a daemon thread to read a stream into the queue."""
+
+        def _read():
+            try:
+                for line in stream:
+                    output_queue.put((stream_type, line.rstrip()))
+            except Exception as e:
+                # Streams might close unexpectedly on kill, ignore
+                pass
+            finally:
+                if not stream.closed:
+                    stream.close()
+                # [FACULTY 8] The Sentinel Dispatcher
+                # We signal EOF to the queue reader with None
+                output_queue.put((stream_type, None))
+
+        t = threading.Thread(target=_read, daemon=True, name=f"TitanReader-{stream_type}")
+        t.start()
+        self._threads.append(t)
+
+    def _summon_injector(self, stream, inputs: List[str]):
+        """Spawns a daemon thread to write inputs to stdin."""
+
+        def _write():
+            try:
+                for line in inputs:
+                    if stream.closed: break
+                    stream.write(line + "\n")
+                    stream.flush()
+                if not stream.closed:
+                    stream.close()
+            except (BrokenPipeError, OSError):
+                pass  # Process died before we finished speaking
+            except Exception as e:
+                Logger.warn(f"Input Injection failed: {e}")
+
+        t = threading.Thread(target=_write, daemon=True, name="TitanInjector")
+        t.start()
+        self._threads.append(t)