vibecore 0.5.0__tar.gz → 0.6.0__tar.gz

{vibecore-0.5.0 → vibecore-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibecore
-Version: 0.5.0
+Version: 0.6.0
 Summary: Build your own AI-powered automation tools in the terminal with this extensible agent framework
 Project-URL: Homepage, https://github.com/serialx/vibecore
 Project-URL: Repository, https://github.com/serialx/vibecore
@@ -158,7 +158,6 @@ Once vibecore is running, you can:
 ### Commands
 
 - `/help` - Show help and keyboard shortcuts
-- `/clear` - Clear the current session and start a new one
 
 ## Flow Mode (Experimental)
 
@@ -177,37 +176,56 @@ Flow Mode allows you to:
 
 ```python
 import asyncio
-from agents import Agent, Runner
-from vibecore.flow import flow, UserInputFunc
+from agents import Agent
+from vibecore.flow import Vibecore, VibecoreRunnerBase
 from vibecore.context import VibecoreContext
+from vibecore.settings import settings
 
 # Define your agent with tools
 agent = Agent[VibecoreContext](
     name="Assistant",
     instructions="You are a helpful assistant",
     tools=[...],  # Your tools here
+    model=settings.model,
 )
 
-# Define your conversation logic
-async def logic(app, ctx: VibecoreContext, user_input: UserInputFunc):
+# Create Vibecore instance
+vibecore = Vibecore[VibecoreContext, str]()
+
+# Define your conversation logic with decorator
+@vibecore.workflow()
+async def logic(
+    runner: VibecoreRunnerBase[VibecoreContext, str],
+) -> str:
     # Get user input programmatically
-    user_message = await user_input("What would you like to do?")
-    
-    # Process with agent
-    result = Runner.run_streamed(
+    user_message = await runner.user_input("What would you like to do?")
+
+    # Print status updates
+    await runner.print(f"Processing: {user_message}")
+
+    # Process with agent (handles streaming automatically)
+    result = await runner.run_agent(
         agent,
         input=user_message,
-        context=ctx,
-        session=app.session,
+        context=runner.context,
+        session=runner.session,
     )
-    
-    # Handle the response
-    app.current_worker = app.handle_streamed_response(result)
-    await app.current_worker.wait()
 
-# Run the flow
+    await runner.print("Done!")
+    return result.final_output
+
+# Run the flow in different modes
 async def main():
-    await flow(agent, logic)
+    # Option 1: TUI mode (full terminal interface)
+    result = await vibecore.run_textual(shutdown=False)
+
+    # Option 2: CLI mode (simple stdin/stdout)
+    # result = await vibecore.run_cli()
+
+    # Option 3: Static mode (programmatic, for testing)
+    # result = await vibecore.run("Calculate 2+2")
+
+    print(f"Final output: {result}")
 
 if __name__ == "__main__":
     asyncio.run(main())
@@ -225,11 +243,53 @@ Flow Mode shines when building complex multi-agent systems. See `examples/custom
 
 ### Key Components
 
-- **`flow()`**: Entry point that sets up the Vibecore app with your custom logic
-- **`logic()`**: Your async function that controls the conversation flow
-- **`UserInputFunc`**: Provides programmatic user input collection
-- **`VibecoreContext`**: Shared state across tools and agents
-- **Agent Handoffs**: Transfer control between specialized agents
+- **`Vibecore` class**: Main entry point that orchestrates your workflow
+- **`@vibecore.workflow()` decorator**: Defines your conversation logic function
+- **Runner argument**: Every workflow receives a runner instance for user input, printing, and agent execution
+- **`runner.user_input()`**: Programmatically collect user input
+- **`runner.print()`**: Display status messages to the user
+- **`runner.run_agent()`**: Execute agent with automatic streaming handling
+- **`runner.context`**: Shared state (VibecoreContext) across tools and agents
+- **`runner.session`**: Conversation history and persistence
+- **Multiple execution modes**:
+  - `run_textual()`: Full TUI with streaming (original behavior)
+  - `run_cli()`: Simple CLI with stdin/stdout
+  - `run()`: Static mode with predefined inputs (perfect for testing)
+- **Agent Handoffs**: Transfer control between specialized agents with context preservation
+
+> 🛠️ Upgrading from an older release? Read the [Runner Migration Guide](docs/runner_migration.md) for step-by-step instructions.
+
+### Multi-Mode Execution
+
+One of vibecore's key strengths is the ability to run the **same workflow code** in different execution modes without modification:
+
+#### TUI Mode (Textual User Interface)
+Full-featured terminal interface with streaming responses, tool visualization, and interactive controls:
+```python
+result = await vibecore.run_textual(shutdown=False)
+```
+
+#### CLI Mode (Command-Line Interface)
+Simple stdin/stdout interaction for scripting and automation:
+```python
+result = await vibecore.run_cli()
+```
+
+#### Static Mode (Programmatic)
+Execute with predefined inputs, perfect for testing and batch processing:
+```python
+# Single input
+result = await vibecore.run("Calculate 2+2")
+
+# Multiple inputs (for multi-turn workflows)
+result = await vibecore.run(["First query", "Follow-up", "Final question"])
+```
+
+This unified interface means you can:
+- **Develop once, deploy anywhere**: Write your workflow logic once and run it in any mode
+- **Test easily**: Use static mode for automated testing with predefined inputs
+- **Choose the right interface**: TUI for development, CLI for scripts, static for tests
+- **Extend to new modes**: Add custom runners (HTTP API, Discord bot, etc.) by implementing the runner interface
 
 ### Use Cases
 
@@ -446,11 +506,6 @@ When enabled, the path confinement system:
 - Resolves symlinks to prevent escapes
 - Blocks access to files outside allowed directories
 
-### Reasoning Effort
-
-- Set default via env var: `VIBECORE_REASONING_EFFORT` (minimal | low | medium | high)
-- Keyword triggers: `think` → low, `think hard` → medium, `ultrathink` → high
-
 ### Environment Variables
 
 ```bash
@@ -507,10 +562,15 @@ vibecore is built with a modular, extensible architecture:
 
 ## Recent Updates
 
-- **Path Confinement**: New security feature to restrict file and shell operations to specified directories
-- **Reasoning View**: New ReasoningMessage widget with live reasoning summaries during streaming
+- **Flow Mode Refactor (v0.5.0)**: Complete redesign with multi-mode execution support
+  - New `Vibecore` class with decorator-based workflow definition
+  - Unified interface: `user_input()`, `print()`, `run_agent()`
+  - Three execution modes: TUI, CLI, and static (perfect for testing)
+  - Cleaner API with less boilerplate and better type safety
+- **Path Confinement**: Security feature to restrict file and shell operations to specified directories
+- **Reasoning View**: ReasoningMessage widget with live reasoning summaries during streaming
 - **Context Usage Bar & CWD**: Footer shows token usage progress and current working directory
-- **Keyboard & Commands**: Ctrl+Shift+D toggles theme, Esc cancels, Ctrl+D double-press to exit, `/help` and `/clear` commands
+- **Keyboard & Commands**: Ctrl+Shift+D toggles theme, Esc cancels, Ctrl+D double-press to exit, `/help` command
 - **MCP Tool Output**: Improved rendering with Markdown and JSON prettification
 - **MCP Support**: Full integration with Model Context Protocol for external tool connections
 - **Print Mode**: `-p` flag to print response and exit for pipes/automation

{vibecore-0.5.0 → vibecore-0.6.0}/README.md

@@ -119,7 +119,6 @@ Once vibecore is running, you can:
 ### Commands
 
 - `/help` - Show help and keyboard shortcuts
-- `/clear` - Clear the current session and start a new one
 
 ## Flow Mode (Experimental)
 
@@ -138,37 +137,56 @@ Flow Mode allows you to:
 
 ```python
 import asyncio
-from agents import Agent, Runner
-from vibecore.flow import flow, UserInputFunc
+from agents import Agent
+from vibecore.flow import Vibecore, VibecoreRunnerBase
 from vibecore.context import VibecoreContext
+from vibecore.settings import settings
 
 # Define your agent with tools
 agent = Agent[VibecoreContext](
     name="Assistant",
     instructions="You are a helpful assistant",
     tools=[...],  # Your tools here
+    model=settings.model,
 )
 
-# Define your conversation logic
-async def logic(app, ctx: VibecoreContext, user_input: UserInputFunc):
+# Create Vibecore instance
+vibecore = Vibecore[VibecoreContext, str]()
+
+# Define your conversation logic with decorator
+@vibecore.workflow()
+async def logic(
+    runner: VibecoreRunnerBase[VibecoreContext, str],
+) -> str:
     # Get user input programmatically
-    user_message = await user_input("What would you like to do?")
-    
-    # Process with agent
-    result = Runner.run_streamed(
+    user_message = await runner.user_input("What would you like to do?")
+
+    # Print status updates
+    await runner.print(f"Processing: {user_message}")
+
+    # Process with agent (handles streaming automatically)
+    result = await runner.run_agent(
         agent,
         input=user_message,
-        context=ctx,
-        session=app.session,
+        context=runner.context,
+        session=runner.session,
     )
-    
-    # Handle the response
-    app.current_worker = app.handle_streamed_response(result)
-    await app.current_worker.wait()
 
-# Run the flow
+    await runner.print("Done!")
+    return result.final_output
+
+# Run the flow in different modes
 async def main():
-    await flow(agent, logic)
+    # Option 1: TUI mode (full terminal interface)
+    result = await vibecore.run_textual(shutdown=False)
+
+    # Option 2: CLI mode (simple stdin/stdout)
+    # result = await vibecore.run_cli()
+
+    # Option 3: Static mode (programmatic, for testing)
+    # result = await vibecore.run("Calculate 2+2")
+
+    print(f"Final output: {result}")
 
 if __name__ == "__main__":
     asyncio.run(main())
@@ -186,11 +204,53 @@ Flow Mode shines when building complex multi-agent systems. See `examples/custom
 
 ### Key Components
 
-- **`flow()`**: Entry point that sets up the Vibecore app with your custom logic
-- **`logic()`**: Your async function that controls the conversation flow
-- **`UserInputFunc`**: Provides programmatic user input collection
-- **`VibecoreContext`**: Shared state across tools and agents
-- **Agent Handoffs**: Transfer control between specialized agents
+- **`Vibecore` class**: Main entry point that orchestrates your workflow
+- **`@vibecore.workflow()` decorator**: Defines your conversation logic function
+- **Runner argument**: Every workflow receives a runner instance for user input, printing, and agent execution
+- **`runner.user_input()`**: Programmatically collect user input
+- **`runner.print()`**: Display status messages to the user
+- **`runner.run_agent()`**: Execute agent with automatic streaming handling
+- **`runner.context`**: Shared state (VibecoreContext) across tools and agents
+- **`runner.session`**: Conversation history and persistence
+- **Multiple execution modes**:
+  - `run_textual()`: Full TUI with streaming (original behavior)
+  - `run_cli()`: Simple CLI with stdin/stdout
+  - `run()`: Static mode with predefined inputs (perfect for testing)
+- **Agent Handoffs**: Transfer control between specialized agents with context preservation
+
+> 🛠️ Upgrading from an older release? Read the [Runner Migration Guide](docs/runner_migration.md) for step-by-step instructions.
+
+### Multi-Mode Execution
+
+One of vibecore's key strengths is the ability to run the **same workflow code** in different execution modes without modification:
+
+#### TUI Mode (Textual User Interface)
+Full-featured terminal interface with streaming responses, tool visualization, and interactive controls:
+```python
+result = await vibecore.run_textual(shutdown=False)
+```
+
+#### CLI Mode (Command-Line Interface)
+Simple stdin/stdout interaction for scripting and automation:
+```python
+result = await vibecore.run_cli()
+```
+
+#### Static Mode (Programmatic)
+Execute with predefined inputs, perfect for testing and batch processing:
+```python
+# Single input
+result = await vibecore.run("Calculate 2+2")
+
+# Multiple inputs (for multi-turn workflows)
+result = await vibecore.run(["First query", "Follow-up", "Final question"])
+```
+
+This unified interface means you can:
+- **Develop once, deploy anywhere**: Write your workflow logic once and run it in any mode
+- **Test easily**: Use static mode for automated testing with predefined inputs
+- **Choose the right interface**: TUI for development, CLI for scripts, static for tests
+- **Extend to new modes**: Add custom runners (HTTP API, Discord bot, etc.) by implementing the runner interface
 
 ### Use Cases
 
@@ -407,11 +467,6 @@ When enabled, the path confinement system:
 - Resolves symlinks to prevent escapes
 - Blocks access to files outside allowed directories
 
-### Reasoning Effort
-
-- Set default via env var: `VIBECORE_REASONING_EFFORT` (minimal | low | medium | high)
-- Keyword triggers: `think` → low, `think hard` → medium, `ultrathink` → high
-
 ### Environment Variables
 
 ```bash
@@ -468,10 +523,15 @@ vibecore is built with a modular, extensible architecture:
 
 ## Recent Updates
 
-- **Path Confinement**: New security feature to restrict file and shell operations to specified directories
-- **Reasoning View**: New ReasoningMessage widget with live reasoning summaries during streaming
+- **Flow Mode Refactor (v0.5.0)**: Complete redesign with multi-mode execution support
+  - New `Vibecore` class with decorator-based workflow definition
+  - Unified interface: `user_input()`, `print()`, `run_agent()`
+  - Three execution modes: TUI, CLI, and static (perfect for testing)
+  - Cleaner API with less boilerplate and better type safety
+- **Path Confinement**: Security feature to restrict file and shell operations to specified directories
+- **Reasoning View**: ReasoningMessage widget with live reasoning summaries during streaming
 - **Context Usage Bar & CWD**: Footer shows token usage progress and current working directory
-- **Keyboard & Commands**: Ctrl+Shift+D toggles theme, Esc cancels, Ctrl+D double-press to exit, `/help` and `/clear` commands
+- **Keyboard & Commands**: Ctrl+Shift+D toggles theme, Esc cancels, Ctrl+D double-press to exit, `/help` command
 - **MCP Tool Output**: Improved rendering with Markdown and JSON prettification
 - **MCP Support**: Full integration with Model Context Protocol for external tool connections
 - **Print Mode**: `-p` flag to print response and exit for pipes/automation

{vibecore-0.5.0 → vibecore-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vibecore"
-version = "0.5.0"
+version = "0.6.0"
 description = "Build your own AI-powered automation tools in the terminal with this extensible agent framework"
 readme = "README.md"
 authors = [
@@ -120,7 +120,7 @@ indent-style = "space"
 
 [tool.pyright]
 include = ["**/*.py"]
-exclude = ["**/__pycache__", ".venv", "venv", "build", "dist"]
+exclude = ["**/__pycache__", ".venv", "venv", "build", "dist", ".git"]
 pythonVersion = "3.11"
 venvPath = "."
 venv = ".venv"

{vibecore-0.5.0 → vibecore-0.6.0}/src/vibecore/agents/default.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING
 from agents import Agent
 from agents.extensions.handoff_prompt import prompt_with_handoff_instructions
 
-from vibecore.context import VibecoreContext
+from vibecore.context import FullVibecoreContext
 from vibecore.settings import settings
 from vibecore.tools.file.tools import edit, multi_edit, read, write
 from vibecore.tools.python.tools import execute_python
@@ -29,7 +29,7 @@ INSTRUCTIONS = (
 )
 
 
-def create_default_agent(mcp_servers: list["MCPServer"] | None = None) -> Agent[VibecoreContext]:
+def create_default_agent(mcp_servers: list["MCPServer"] | None = None) -> Agent[FullVibecoreContext]:
     """Create the general-purpose agent with appropriate tools.
 
     Args:
@@ -58,7 +58,7 @@ def create_default_agent(mcp_servers: list["MCPServer"] | None = None) -> Agent[
 
     instructions = prompt_with_handoff_instructions(instructions)
 
-    return Agent[VibecoreContext](
+    return Agent[FullVibecoreContext](
         name="Vibecore Agent",
         handoff_description="A versatile general-purpose assistant",
         instructions=instructions,

{vibecore-0.5.0 → vibecore-0.6.0}/src/vibecore/agents/task.py

@@ -3,7 +3,7 @@
 from agents import Agent
 from agents.extensions.handoff_prompt import prompt_with_handoff_instructions
 
-from vibecore.context import VibecoreContext
+from vibecore.context import FullVibecoreContext
 from vibecore.settings import settings
 from vibecore.tools.file.tools import edit, multi_edit, read, write
 from vibecore.tools.python.tools import execute_python
@@ -13,7 +13,7 @@ from vibecore.tools.todo.tools import todo_read, todo_write
 from .prompts import COMMON_PROMPT
 
 
-def create_task_agent(prompt: str) -> Agent[VibecoreContext]:
+def create_task_agent(prompt: str) -> Agent[FullVibecoreContext]:
     """Create a task agent with all tools except the Task tool.
 
     This agent is used by the Task tool to execute specific tasks.
@@ -51,7 +51,7 @@ def create_task_agent(prompt: str) -> Agent[VibecoreContext]:
 
     instructions = prompt_with_handoff_instructions(instructions)
 
-    return Agent[VibecoreContext](
+    return Agent[FullVibecoreContext](
         name="Task Agent",
         handoff_description="A task-specific agent",
         instructions=instructions,

{vibecore-0.5.0 → vibecore-0.6.0}/src/vibecore/cli.py

@@ -1,17 +1,21 @@
 """Vibecore CLI interface using typer."""
 
 import asyncio
+import contextlib
+import datetime
 import logging
+import sys
 from importlib.metadata import version
 from pathlib import Path
 
 import typer
+from agents.result import RunResultBase
 from textual.logging import TextualHandler
 
 from vibecore.agents.default import create_default_agent
-from vibecore.context import VibecoreContext
-from vibecore.main import VibecoreApp
+from vibecore.flow import AppIsExiting, Vibecore, VibecoreRunner
 from vibecore.mcp import MCPManager
+from vibecore.session import JSONLSession
 from vibecore.settings import settings
 
 app = typer.Typer()
@@ -110,49 +114,70 @@ def main(
     logger = logging.getLogger("openai.agents")
     logger.addHandler(TextualHandler())
 
-    # Create context
-    vibecore_ctx = VibecoreContext()
-
-    # Initialize MCP manager if configured
-    mcp_servers = []
-    if settings.mcp_servers:
-        # Create MCP manager
-        mcp_manager = MCPManager(settings.mcp_servers)
-        vibecore_ctx.mcp_manager = mcp_manager
-
-        # Get the MCP servers from the manager
-        mcp_servers = mcp_manager.servers
+    asyncio.run(
+        async_main(continue_session=continue_session, session_id=session_id, prompt=prompt, print_mode=print_mode)
+    )
 
-    # Create agent with MCP servers
-    agent = create_default_agent(mcp_servers=mcp_servers)
 
-    # Determine session to use
-    session_to_load = None
-    if continue_session:
-        session_to_load = find_latest_session()
-        if not session_to_load:
-            typer.echo("No existing sessions found for this project.")
-            raise typer.Exit(1)
-        typer.echo(f"Continuing session: {session_to_load}")
-    elif session_id:
-        session_to_load = session_id
-        typer.echo(f"Loading session: {session_to_load}")
-
-    # Create app
-    app_instance = VibecoreApp(vibecore_ctx, agent, session_id=session_to_load, print_mode=print_mode)
-
-    if print_mode:
-        # Run in print mode
-        import asyncio
-
-        # Use provided prompt or None to read from stdin
-        result = asyncio.run(app_instance.run_print(prompt))
-        # Print raw output to stdout
-        if result:
-            print(result)
-    else:
-        # Run normal TUI mode
-        app_instance.run()
+async def async_main(continue_session: bool, session_id: str | None, prompt: str | None, print_mode: bool):
+    # Create MCP manager
+    async with MCPManager(settings.mcp_servers) as mcp_manager:
+        # Create agent with MCP servers
+        agent = create_default_agent(mcp_servers=mcp_manager.servers)
+
+        # Create Vibecore instance
+        from vibecore.context import FullVibecoreContext
+
+        vibecore = Vibecore[FullVibecoreContext, RunResultBase](disable_user_input=False)
+
+        # Determine session to use
+        session_to_load = None
+        if continue_session:
+            session_to_load = find_latest_session()
+            if not session_to_load:
+                typer.echo("No existing sessions found for this project.")
+                raise typer.Exit(1)
+            typer.echo(f"Continuing session: {session_to_load}")
+        elif session_id:
+            session_to_load = session_id
+            typer.echo(f"Loading session: {session_to_load}")
+
+        if session_to_load is None:
+            # Generate a new session ID based on current date/time
+            session_to_load = f"chat-{datetime.datetime.now().strftime('%Y%m%d-%H%M%S')}"
+
+        session = JSONLSession(
+            session_id=session_to_load,
+            project_path=None,  # Will use current working directory
+            base_dir=settings.session.base_dir,
+        )
+
+        # Define workflow logic
+        @vibecore.workflow()
+        async def workflow(
+            runner: VibecoreRunner[FullVibecoreContext, RunResultBase],
+            user_message: str,
+        ) -> RunResultBase:
+            # Run the agent with the input
+            return await runner.run_agent(
+                agent,
+                input=user_message,
+                context=runner.context,
+                max_turns=settings.max_turns,
+                session=runner.session,
+            )
+
+        if print_mode:
+            # Use static runner for print mode - pass empty input since we get it in workflow
+            input_text = prompt.strip() if prompt else sys.stdin.read().strip()
+            result = await vibecore.run(input_text)
+            # Print raw output to stdout
+            print(result.final_output_as(str))
+        else:
+            # Run in TUI mode
+            with contextlib.suppress(AppIsExiting):
+                result = await vibecore.run_textual(prompt, session=session)
+                print(result)
 
 
 @auth_app.command("login")

{vibecore-0.5.0 → vibecore-0.6.0}/src/vibecore/context.py

@@ -1,29 +1,61 @@
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, Protocol, runtime_checkable
 
 from vibecore.tools.python.manager import PythonExecutionManager
 from vibecore.tools.todo.manager import TodoManager
 
 if TYPE_CHECKING:
     from vibecore.main import VibecoreApp
-    from vibecore.mcp import MCPManager
     from vibecore.tools.path_validator import PathValidator
 
 
+@runtime_checkable
+class TodoToolContext(Protocol):
+    """Context required by todo tools."""
+
+    todo_manager: TodoManager
+
+
+@runtime_checkable
+class PythonToolContext(Protocol):
+    """Context required by Python execution tools."""
+
+    python_manager: PythonExecutionManager
+
+
+@runtime_checkable
+class PathValidatorContext(Protocol):
+    """Context that provides a path validator for file-system tools."""
+
+    path_validator: "PathValidator"
+
+
+@runtime_checkable
+class AppAwareContext(Protocol):
+    """Context that exposes the optional Textual app for streaming updates."""
+
+    app: Optional["VibecoreApp"]
+
+
+@runtime_checkable
+class FullVibecoreContext(TodoToolContext, PythonToolContext, PathValidatorContext, AppAwareContext, Protocol):
+    """Protocol describing the full context required by Vibecore agents."""
+
+    ...
+
+
 @dataclass
-class VibecoreContext:
+class DefaultVibecoreContext:
     todo_manager: TodoManager = field(default_factory=TodoManager)
     python_manager: PythonExecutionManager = field(default_factory=PythonExecutionManager)
     app: Optional["VibecoreApp"] = None
-    context_fullness: float = 0.0
-    mcp_manager: Optional["MCPManager"] = None
 
     # Path confinement configuration
     allowed_directories: list[Path] = field(default_factory=list)
     path_validator: "PathValidator" = field(init=False)  # Always initialized, never None
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         """Initialize path validator with allowed directories."""
         from vibecore.tools.path_validator import PathValidator
 
@@ -49,13 +81,7 @@ class VibecoreContext:
 
         self.path_validator = PathValidator(self.allowed_directories)
 
-    def reset_state(self) -> None:
-        """Reset all context state for a new session."""
-        self.todo_manager = TodoManager()
-        self.python_manager = PythonExecutionManager()
-        self.context_fullness = 0.0
-        # Preserve allowed_directories across resets
-        # Re-initialize validator in case directories changed
-        from vibecore.tools.path_validator import PathValidator
 
-        self.path_validator = PathValidator(self.allowed_directories)
+if TYPE_CHECKING:
+    # Ensure DefaultVibecoreContext conforms to the VibecoreContext protocol for static analyzers
+    _default_context: FullVibecoreContext = DefaultVibecoreContext()