feat(llm): extract adapter layer for standalone llm-connect package (S1+S2)

Stage 1 — Decouple:
- Move RunConfig + LLMResponse to markitect/llm/models.py (canonical)
- Move LLMAdapter + Mock/ErrorLLMAdapter to markitect/llm/adapter.py
- markitect/prompts/execution/models.py and llm_adapter.py become re-export shims
- All 4 adapters + factory.py updated to import from markitect.llm.*
- Parameterize app_name in toml_config.py (resolve_llm, get_default_layers,
  get_preference_layers): paths and env var now derived from app_name arg
- Add tests/test_llm_isolation.py: 7 isolation + backward-compat tests

Stage 2 — Extract:
- Standalone llm-connect package created at ~/llm-connect/
- All 18 llm files copied; markitect.* imports replaced with llm_connect.*
- LLMError base inlined in llm_connect/exceptions.py (no markitect dep)
- llm-connect installed into markitect-venv; declared in pyproject.toml

Smoke test: markitect llm-check succeeds (live Gemini API call).
Backward compat: markitect.prompts.execution.{models,llm_adapter} still work.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

markitect/prompts/execution/llm_adapter.py

@@ -1,169 +1,9 @@
 """
-LLM adapter interface for pluggable model providers.
+Re-exports from markitect.llm.adapter for backward compatibility.
 
-Implements abstraction layer for LLM integration, supporting
-multiple providers (OpenAI, Anthropic, local models, etc.).
+The LLM adapter interface was moved to markitect.llm.adapter in v1.1.
 """
 
-from abc import ABC, abstractmethod
-from typing import Dict, Any
+from markitect.llm.adapter import LLMAdapter, MockLLMAdapter, ErrorLLMAdapter
 
-from markitect.prompts.execution.models import RunConfig, LLMResponse
-
-
-class LLMAdapter(ABC):
-    """
-    Abstract base class for LLM providers.
-
-    Enables pluggable LLM backends without prescribing implementation.
-    Implementations can wrap OpenAI, Anthropic, or other APIs.
-    """
-
-    @abstractmethod
-    def execute_prompt(
-        self,
-        prompt: str,
-        config: RunConfig,
-    ) -> LLMResponse:
-        """
-        Execute a prompt with the LLM.
-
-        Args:
-            prompt: Compiled prompt text
-            config: Execution configuration
-
-        Returns:
-            LLMResponse with generated content
-
-        Raises:
-            Exception: On LLM API errors
-        """
-        pass
-
-    @abstractmethod
-    def validate_config(self, config: RunConfig) -> bool:
-        """
-        Validate that configuration is supported.
-
-        Args:
-            config: Configuration to validate
-
-        Returns:
-            True if valid, False otherwise
-        """
-        pass
-
-
-class MockLLMAdapter(LLMAdapter):
-    """
-    Mock LLM adapter for testing.
-
-    Returns deterministic responses without calling external APIs.
-    """
-
-    def __init__(self, mock_response: str = "Mock LLM response"):
-        """
-        Initialize mock adapter.
-
-        Args:
-            mock_response: Response to return
-        """
-        self.mock_response = mock_response
-        self.call_count = 0
-        self.last_prompt = None
-        self.last_config = None
-
-    def execute_prompt(
-        self,
-        prompt: str,
-        config: RunConfig,
-    ) -> LLMResponse:
-        """
-        Return mock response.
-
-        Args:
-            prompt: Prompt (stored for inspection)
-            config: Config (stored for inspection)
-
-        Returns:
-            Mock LLMResponse
-        """
-        self.call_count += 1
-        self.last_prompt = prompt
-        self.last_config = config
-
-        return LLMResponse(
-            content=self.mock_response,
-            model=config.model_name,
-            usage={
-                "prompt_tokens": len(prompt.split()),
-                "completion_tokens": len(self.mock_response.split()),
-                "total_tokens": len(prompt.split()) + len(self.mock_response.split()),
-            },
-            finish_reason="stop",
-            metadata={"mock": True},
-        )
-
-    def validate_config(self, config: RunConfig) -> bool:
-        """
-        Mock validation always succeeds.
-
-        Args:
-            config: Configuration
-
-        Returns:
-            Always True
-        """
-        return True
-
-    def reset(self) -> None:
-        """Reset mock state."""
-        self.call_count = 0
-        self.last_prompt = None
-        self.last_config = None
-
-
-class ErrorLLMAdapter(LLMAdapter):
-    """
-    Mock adapter that always raises an error.
-
-    Useful for testing error handling.
-    """
-
-    def __init__(self, error_message: str = "Mock LLM error"):
-        """
-        Initialize error adapter.
-
-        Args:
-            error_message: Error message to raise
-        """
-        self.error_message = error_message
-
-    def execute_prompt(
-        self,
-        prompt: str,
-        config: RunConfig,
-    ) -> LLMResponse:
-        """
-        Raise error.
-
-        Args:
-            prompt: Prompt
-            config: Config
-
-        Raises:
-            RuntimeError: Always
-        """
-        raise RuntimeError(self.error_message)
-
-    def validate_config(self, config: RunConfig) -> bool:
-        """
-        Validation succeeds.
-
-        Args:
-            config: Configuration
-
-        Returns:
-            True
-        """
-        return True
+__all__ = ["LLMAdapter", "MockLLMAdapter", "ErrorLLMAdapter"]

markitect/prompts/execution/models.py

@@ -12,6 +12,7 @@ from typing import Dict, Any, List, Optional
 from enum import Enum
 
 from markitect.prompts.models import calculate_bundle_digest
+from markitect.llm.models import RunConfig, LLMResponse  # canonical; re-exported here
 
 
 class ExecutionStage(Enum):
@@ -37,54 +38,6 @@ class RunStatus(Enum):
     SKIPPED = "skipped"  # Skipped due to identical InputBundleHash
 
 
-@dataclass
-class RunConfig:
-    """
-    Configuration for prompt execution.
-
-    Attributes:
-        model_name: LLM model to use
-        temperature: Model temperature (0.0-1.0)
-        max_tokens: Maximum tokens to generate
-        model_params: Additional model parameters
-        max_depth: Maximum generation depth for nested runs
-        skip_if_exists: Skip if identical InputBundleHash exists (FR-4.4)
-        timeout_seconds: Execution timeout
-    """
-    model_name: str = "gpt-4"
-    temperature: float = 0.7
-    max_tokens: int = 2000
-    model_params: Dict[str, Any] = field(default_factory=dict)
-    max_depth: int = 3
-    skip_if_exists: bool = True
-    timeout_seconds: int = 300
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary."""
-        return {
-            "model_name": self.model_name,
-            "temperature": self.temperature,
-            "max_tokens": self.max_tokens,
-            "model_params": self.model_params,
-            "max_depth": self.max_depth,
-            "skip_if_exists": self.skip_if_exists,
-            "timeout_seconds": self.timeout_seconds,
-        }
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "RunConfig":
-        """Create from dictionary."""
-        return cls(
-            model_name=data.get("model_name", "gpt-4"),
-            temperature=data.get("temperature", 0.7),
-            max_tokens=data.get("max_tokens", 2000),
-            model_params=data.get("model_params", {}),
-            max_depth=data.get("max_depth", 3),
-            skip_if_exists=data.get("skip_if_exists", True),
-            timeout_seconds=data.get("timeout_seconds", 300),
-        )
-
-
 @dataclass
 class InputBundle:
     """
@@ -151,35 +104,6 @@ class InputBundle:
         }
 
 
-@dataclass
-class LLMResponse:
-    """
-    Response from LLM execution.
-
-    Attributes:
-        content: Generated content
-        model: Model used
-        usage: Token usage statistics
-        finish_reason: Why generation stopped
-        metadata: Additional response metadata
-    """
-    content: str
-    model: str
-    usage: Dict[str, int] = field(default_factory=dict)
-    finish_reason: str = "stop"
-    metadata: Dict[str, Any] = field(default_factory=dict)
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary."""
-        return {
-            "content": self.content,
-            "model": self.model,
-            "usage": self.usage,
-            "finish_reason": self.finish_reason,
-            "metadata": self.metadata,
-        }
-
-
 @dataclass
 class PromptRun:
     """