zwarm 3.2.1__py3-none-any.whl → 3.4.0__py3-none-any.whl

zwarm/cli/interactive.py

@@ -157,7 +157,7 @@ def cmd_help():
     table.add_column("Description")
 
     table.add_row("[bold]Session Lifecycle[/]", "")
-    table.add_row('spawn "task" [--dir PATH]', "Start new session")
+    table.add_row('spawn "task" [--dir PATH] [--model M]', "Start new session")
     table.add_row('c ID "message"', "Continue conversation")
     table.add_row("kill ID | all", "Stop session(s)")
     table.add_row("rm ID | all", "Delete session(s)")
@@ -307,7 +307,7 @@ def cmd_show(manager, session_id: str):
     icon = STATUS_ICONS.get(session.status.value, "?")
     console.print(f"\n{icon} [bold cyan]{session.short_id}[/] - {session.status.value}")
     console.print(f"  [dim]Task:[/] {session.task}")
-    console.print(f"  [dim]Turn:[/] {session.turn} | [dim]Runtime:[/] {session.runtime:.1f}s")
+    console.print(f"  [dim]Turn:[/] {session.turn} | [dim]Runtime:[/] {session.runtime}")
 
     # Token usage with cost estimate
     usage = session.token_usage
@@ -694,7 +694,7 @@ def run_interactive(
 
             elif cmd == "spawn":
                 if not args:
-                    console.print("  [red]Usage:[/] spawn \"task\" [--dir PATH]")
+                    console.print("  [red]Usage:[/] spawn \"task\" [--dir PATH] [--search]")
                 else:
                     # Parse spawn args
                     task_parts = []

zwarm/cli/main.py

@@ -122,16 +122,6 @@ Manage zwarm configurations.
 app.add_typer(configs_app, name="configs")
 
 
-class AdapterType(str, Enum):
-    codex_mcp = "codex_mcp"
-    claude_code = "claude_code"
-
-
-class ModeType(str, Enum):
-    sync = "sync"
-    async_ = "async"
-
-
 @app.command()
 def orchestrate(
     task: Annotated[Optional[str], typer.Option("--task", "-t", help="The task to accomplish")] = None,
@@ -228,6 +218,26 @@ def orchestrate(
         if orchestrator.instance_id and not instance:
             console.print(f"  [dim]Instance: {orchestrator.instance_id[:8]}[/]")
 
+        # Set up step callback for live progress display
+        def step_callback(step_num: int, tool_results: list) -> None:
+            """Print tool calls and results as they happen."""
+            if not tool_results:
+                return
+            for tool_info, result in tool_results:
+                name = tool_info.get("name", "?")
+                # Truncate args for display
+                args_str = str(tool_info.get("args", {}))
+                if len(args_str) > 80:
+                    args_str = args_str[:77] + "..."
+                # Truncate result for display
+                result_str = str(result)
+                if len(result_str) > 100:
+                    result_str = result_str[:97] + "..."
+                console.print(f"[dim]step {step_num}[/] → [cyan]{name}[/]({args_str})")
+                console.print(f"         └ {result_str}")
+
+        orchestrator._step_callback = step_callback
+
         # Run the orchestrator loop
         console.print("[bold]--- Orchestrator running ---[/]\n")
         result = orchestrator.run(task=task)
@@ -384,78 +394,68 @@ def pilot(
 @app.command()
 def exec(
     task: Annotated[str, typer.Option("--task", "-t", help="Task to execute")],
-    adapter: Annotated[AdapterType, typer.Option("--adapter", "-a", help="Executor adapter")] = AdapterType.codex_mcp,
-    mode: Annotated[ModeType, typer.Option("--mode", "-m", help="Execution mode")] = ModeType.sync,
     working_dir: Annotated[Path, typer.Option("--working-dir", "-w", help="Working directory")] = Path("."),
     model: Annotated[Optional[str], typer.Option("--model", help="Model override")] = None,
+    wait: Annotated[bool, typer.Option("--wait", help="Wait for completion and show result")] = False,
 ):
     """
-    Run a single executor directly (for testing).
+    Run a single Codex session directly (for testing).
 
-    Useful for testing adapters without the full orchestrator loop.
+    Spawns a session using CodexSessionManager - same as interactive/pilot.
+    Web search is always enabled via .codex/config.toml (set up by `zwarm init`).
 
     [bold]Examples:[/]
-        [dim]# Test Codex[/]
-        $ zwarm exec --task "What is 2+2?"
+        [dim]# Quick test[/]
+        $ zwarm exec --task "What is 2+2?" --wait
 
-        [dim]# Test Claude Code[/]
-        $ zwarm exec -a claude_code --task "List files in current dir"
+        [dim]# Run in background[/]
+        $ zwarm exec --task "Build feature"
 
-        [dim]# Async mode[/]
-        $ zwarm exec --task "Build feature" --mode async
+        [dim]# Web search is always available[/]
+        $ zwarm exec --task "Find latest FastAPI docs" --wait
     """
-    from zwarm.adapters import get_adapter
-
-    console.print(f"[bold]Running executor directly...[/]")
-    console.print(f"  Adapter: [cyan]{adapter.value}[/]")
-    console.print(f"  Mode: {mode.value}")
-    console.print(f"  Task: {task}")
-
-    # Use isolated codex config if available
-    config_path = working_dir / ".zwarm" / "codex.toml"
-    if not config_path.exists():
-        config_path = None
-
-    try:
-        executor = get_adapter(adapter.value, model=model, config_path=config_path)
-    except ValueError as e:
-        console.print(f"[red]Error:[/] {e}")
-        sys.exit(1)
-
-    async def run():
-        try:
-            session = await executor.start_session(
-                task=task,
-                working_dir=working_dir.absolute(),
-                mode=mode.value,
-                model=model,
-            )
-
-            console.print(f"\n[green]Session started:[/] {session.id[:8]}")
-
-            if mode == ModeType.sync:
-                response = session.messages[-1].content if session.messages else "(no response)"
-                console.print(f"\n[bold]Response:[/]\n{response}")
+    import time
+    from zwarm.sessions import CodexSessionManager, SessionStatus
 
-                # Interactive loop for sync mode
-                while True:
-                    try:
-                        user_input = console.input("\n[dim]> (type message or 'exit')[/] ")
-                        if user_input.lower() == "exit" or not user_input:
-                            break
+    console.print(f"[bold]Running Codex session...[/]")
+    console.print(f"  Task: {task[:60]}{'...' if len(task) > 60 else ''}")
+    if model:
+        console.print(f"  Model: {model}")
 
-                        response = await executor.send_message(session, user_input)
-                        console.print(f"\n[bold]Response:[/]\n{response}")
-                    except KeyboardInterrupt:
-                        break
-            else:
-                console.print("[dim]Async mode - session running in background.[/]")
-                console.print("Use 'zwarm status' to check progress.")
+    manager = CodexSessionManager(working_dir / ".zwarm")
+    effective_model = model or "gpt-5.1-codex-mini"
 
-        finally:
-            await executor.cleanup()
+    session = manager.start_session(
+        task=task,
+        working_dir=working_dir.absolute(),
+        model=effective_model,
+    )
 
-    asyncio.run(run())
+    console.print(f"\n[green]Session started:[/] {session.short_id}")
+
+    if wait:
+        console.print("[dim]Waiting for completion...[/]")
+        while True:
+            time.sleep(2)
+            session = manager.get_session(session.id)
+            if session.status != SessionStatus.RUNNING:
+                break
+
+        if session.status == SessionStatus.COMPLETED:
+            console.print(f"\n[green]✓ Completed[/]")
+            # Show last assistant message
+            for msg in reversed(session.messages):
+                if msg.role == "assistant":
+                    console.print(f"\n[bold]Response:[/]\n{msg.content}")
+                    break
+        else:
+            console.print(f"\n[red]Status:[/] {session.status.value}")
+            if session.error:
+                console.print(f"[red]Error:[/] {session.error}")
+    else:
+        console.print("[dim]Running in background. Check with:[/]")
+        console.print(f"  zwarm sessions")
+        console.print(f"  zwarm session show {session.short_id}")
 
 
 @app.command()
@@ -740,12 +740,12 @@ def init(
     [bold]Creates:[/]
         [cyan].zwarm/[/]              State directory for sessions and events
         [cyan].zwarm/config.toml[/]   Runtime settings (weave, adapter, watchers)
-        [cyan].zwarm/codex.toml[/]    Codex CLI settings (model, reasoning effort)
+        [cyan].zwarm/codex.toml[/]    Codex CLI settings (model, web search, etc.)
         [cyan]zwarm.yaml[/]           Project config (optional, with --with-project)
 
     [bold]Configuration relationship:[/]
         config.toml   → Controls zwarm itself (tracing, which watchers run)
-        codex.toml    → Controls the Codex CLI that runs executor sessions
+        codex.toml    → Codex settings, parsed by zwarm and passed via -c overrides
         zwarm.yaml    → Project-specific context injected into orchestrator
 
     [bold]Examples:[/]
@@ -939,7 +939,7 @@ def init(
     # Explain config files
     console.print("[bold]Configuration files:[/]")
     console.print("  [cyan].zwarm/config.toml[/]  - Runtime settings (Weave tracing, watchers)")
-    console.print("  [cyan].zwarm/codex.toml[/]   - Codex CLI settings (model, reasoning effort)")
+    console.print("  [cyan].zwarm/codex.toml[/]   - Codex CLI settings (model, web search, sandbox)")
     if create_project_config:
         console.print("  [cyan]zwarm.yaml[/]          - Project context and constraints")
     console.print()
@@ -982,6 +982,7 @@ def _generate_config_toml(
         "[executor]",
         f'adapter = "{adapter}"',
         "# model = \"\"  # Optional model override",
+        "# web_search = false  # Enable web search for delegated sessions",
         "",
         "[watchers]",
         f"enabled = {watchers}",
@@ -1006,22 +1007,35 @@ def _generate_codex_toml(
     """
     Generate codex.toml for isolated codex configuration.
 
-    This file is used by zwarm instead of ~/.codex/config.toml to ensure
-    consistent behavior across different environments.
+    This file is parsed by zwarm and settings are passed to codex via -c overrides.
+    Each .zwarm directory has its own codex config, independent of ~/.codex/config.toml.
     """
     lines = [
         "# Codex configuration for zwarm",
-        "# This file isolates zwarm's codex settings from your global ~/.codex/config.toml",
+        "# zwarm parses this file and passes settings to codex via -c overrides",
+        "# Each .zwarm dir has its own config, independent of ~/.codex/config.toml",
         "# Generated by 'zwarm init'",
         "",
         "# Model settings",
         f'model = "{model}"',
         f'model_reasoning_effort = "{reasoning_effort}"  # low | medium | high',
         "",
-        "# Approval settings - zwarm manages these automatically",
-        "# disable_response_storage = false",
+        "# DANGER MODE - bypasses all safety controls",
+        "# Set to true to use --dangerously-bypass-approvals-and-sandbox",
+        "full_danger = true",
+        "",
+        "# Web search - enables web_search tool for agents",
+        "[features]",
+        "web_search_request = true",
         "",
-        "# You can override any codex setting here",
+        "# Sandbox settings - network access required for web search",
+        "[sandbox_workspace_write]",
+        "network_access = true",
+        "",
+        "# Approval policy - 'never' means no human approval needed",
+        "# approval_policy = \"never\"",
+        "",
+        "# You can add any codex config key here",
         "# See: https://github.com/openai/codex#configuration",
         "",
     ]
@@ -1534,6 +1548,7 @@ def session_start(
     Start a new Codex session in the background.
 
     The session runs independently and you can check on it later.
+    Web search is always enabled via .codex/config.toml (set up by `zwarm init`).
 
     [bold]Examples:[/]
         [dim]# Simple task[/]
@@ -1541,6 +1556,9 @@ def session_start(
 
         [dim]# With specific model[/]
         $ zwarm session start "Refactor the API" --model gpt-5.1-codex-max
+
+        [dim]# Web search is always available[/]
+        $ zwarm session start "Research latest OAuth2 best practices"
     """
     from zwarm.sessions import CodexSessionManager
 

zwarm/cli/pilot.py

@@ -186,10 +186,12 @@ def build_pilot_orchestrator(
     lm_class = lm_map.get(lm_choice, GPT5LargeVerbose)
     lm = lm_class()
 
-    # Load configuration
+    # Load configuration from working_dir (not cwd!)
+    # This ensures config.toml and .env are loaded from the project being worked on
     config = load_config(
         config_path=config_path,
         overrides=overrides,
+        working_dir=working_dir,
     )
 
     # Resolve working directory
@@ -592,6 +594,18 @@ def execute_step_with_events(
     """
     had_message = False
 
+    # Update environment with current progress before perceive
+    # This ensures the observation has fresh step/token counts
+    if hasattr(orchestrator, "env") and hasattr(orchestrator.env, "update_progress"):
+        total_tokens = getattr(orchestrator, "_total_tokens", 0)
+        executor_usage = orchestrator.get_executor_usage() if hasattr(orchestrator, "get_executor_usage") else {}
+        orchestrator.env.update_progress(
+            step_count=getattr(orchestrator, "_step_count", 0),
+            max_steps=getattr(orchestrator, "maxSteps", 50),
+            total_tokens=total_tokens,
+            executor_tokens=executor_usage.get("total_tokens", 0),
+        )
+
     # Execute perceive (updates environment observation)
     orchestrator.perceive()
 
@@ -647,7 +661,7 @@ def execute_step_with_events(
 def run_until_response(
     orchestrator: Any,
     renderer: EventRenderer,
-    max_steps: int = 20,
+    max_steps: int = 60,
 ) -> List[tuple]:
     """
     Run the orchestrator until it produces a message response.
@@ -655,7 +669,7 @@ def run_until_response(
     Keeps stepping while the agent only produces tool calls.
     Stops when:
     - Agent produces a text message (returns to user)
-    - Max steps reached
+    - Max steps reached (configurable via orchestrator.max_steps_per_turn)
     - Stop condition triggered
 
     This is wrapped as a weave.op to group all child calls per turn.
@@ -663,7 +677,7 @@ def run_until_response(
     Args:
         orchestrator: The orchestrator instance
         renderer: Event renderer for output
-        max_steps: Safety limit on steps per turn
+        max_steps: Safety limit on steps per turn (default: 60)
 
     Returns:
         All tool results from the turn
@@ -701,6 +715,9 @@ def run_until_response(
             if not results:
                 break
 
+        # Show session status at end of turn (if there are any sessions)
+        render_session_status(orchestrator, renderer)
+
         return all_results
 
     return _run_turn()
@@ -756,6 +773,38 @@ def get_sessions_snapshot(orchestrator: Any) -> Dict[str, Any]:
     return {"sessions": []}
 
 
+def render_session_status(orchestrator: Any, renderer: EventRenderer) -> None:
+    """
+    Render a compact session status line if there are active sessions.
+
+    Shows: "Sessions: 2 running, 1 done, 0 failed"
+    Only displays if there are any sessions.
+    """
+    if not hasattr(orchestrator, "_session_manager"):
+        return
+
+    sessions = orchestrator._session_manager.list_sessions()
+    if not sessions:
+        return
+
+    running = sum(1 for s in sessions if s.status.value == "running")
+    completed = sum(1 for s in sessions if s.status.value == "completed")
+    failed = sum(1 for s in sessions if s.status.value == "failed")
+
+    # Build status line with colors
+    parts = []
+    if running > 0:
+        parts.append(f"[cyan]{running} running[/]")
+    if completed > 0:
+        parts.append(f"[green]{completed} done[/]")
+    if failed > 0:
+        parts.append(f"[red]{failed} failed[/]")
+
+    if parts:
+        status_line = ", ".join(parts)
+        console.print(f"[dim]Sessions:[/] {status_line}")
+
+
 def run_pilot(
     orchestrator: Any,
     *,
@@ -812,7 +861,8 @@ def _run_pilot_repl(
         })
 
         renderer.reset_turn()
-        results = run_until_response(orchestrator, renderer)
+        max_steps = getattr(orchestrator.config.orchestrator, "max_steps_per_turn", 60)
+        results = run_until_response(orchestrator, renderer, max_steps=max_steps)
 
         # Record checkpoint
         state.record(
@@ -1101,8 +1151,9 @@ def _run_pilot_repl(
 
         # Execute steps until agent responds with a message
         renderer.reset_turn()
+        max_steps = getattr(orchestrator.config.orchestrator, "max_steps_per_turn", 60)
         try:
-            results = run_until_response(orchestrator, renderer)
+            results = run_until_response(orchestrator, renderer, max_steps=max_steps)
         except Exception as e:
             renderer.error(f"Step failed: {e}")
             # Remove the user message on failure

zwarm/core/config.py

@@ -37,6 +37,7 @@ class ExecutorConfig:
     sandbox: str = "workspace-write"  # read-only | workspace-write | danger-full-access
     timeout: int = 3600
     reasoning_effort: str | None = "high"  # low | medium | high (default to high for compatibility)
+    # Note: web_search is always enabled via .codex/config.toml (set up by `zwarm init`)
 
 
 @dataclass
@@ -59,8 +60,8 @@ class OrchestratorConfig:
     prompt: str | None = None  # path to prompt yaml
     tools: list[str] = field(default_factory=lambda: ["delegate", "converse", "check_session", "end_session", "bash"])
     max_steps: int = 50
+    max_steps_per_turn: int = 60  # Max tool-call steps before returning to user (pilot mode)
     parallel_delegations: int = 4
-    sync_first: bool = True  # prefer sync mode by default
     compaction: CompactionConfig = field(default_factory=CompactionConfig)
 
     # Directory restrictions for agent delegations
@@ -172,8 +173,8 @@ class ZwarmConfig:
                 "prompt": self.orchestrator.prompt,
                 "tools": self.orchestrator.tools,
                 "max_steps": self.orchestrator.max_steps,
+                "max_steps_per_turn": self.orchestrator.max_steps_per_turn,
                 "parallel_delegations": self.orchestrator.parallel_delegations,
-                "sync_first": self.orchestrator.sync_first,
                 "compaction": {
                     "enabled": self.orchestrator.compaction.enabled,
                     "max_tokens": self.orchestrator.compaction.max_tokens,
@@ -195,15 +196,16 @@ class ZwarmConfig:
         }
 
 
-def load_env(path: Path | None = None) -> None:
+def load_env(path: Path | None = None, base_dir: Path | None = None) -> None:
     """Load .env file if it exists."""
     if path is None:
-        path = Path.cwd() / ".env"
+        base = base_dir or Path.cwd()
+        path = base / ".env"
     if path.exists():
         load_dotenv(path)
 
 
-def load_toml_config(path: Path | None = None) -> dict[str, Any]:
+def load_toml_config(path: Path | None = None, base_dir: Path | None = None) -> dict[str, Any]:
     """
     Load config.toml file.
 
@@ -211,11 +213,16 @@ def load_toml_config(path: Path | None = None) -> dict[str, Any]:
     1. Explicit path (if provided)
     2. .zwarm/config.toml (new standard location)
     3. config.toml (legacy location for backwards compat)
+
+    Args:
+        path: Explicit path to config.toml
+        base_dir: Base directory to search in (defaults to cwd)
     """
     if path is None:
+        base = base_dir or Path.cwd()
         # Try new location first
-        new_path = Path.cwd() / ".zwarm" / "config.toml"
-        legacy_path = Path.cwd() / "config.toml"
+        new_path = base / ".zwarm" / "config.toml"
+        legacy_path = base / "config.toml"
         if new_path.exists():
             path = new_path
         elif legacy_path.exists():
@@ -306,6 +313,7 @@ def load_config(
     toml_path: Path | None = None,
     env_path: Path | None = None,
     overrides: list[str] | None = None,
+    working_dir: Path | None = None,
 ) -> ZwarmConfig:
     """
     Load configuration with full precedence chain:
@@ -314,15 +322,24 @@ def load_config(
     3. YAML config file (if provided)
     4. CLI overrides (--set key=value)
     5. Environment variables (for secrets)
+
+    Args:
+        config_path: Path to YAML config file
+        toml_path: Explicit path to config.toml
+        env_path: Explicit path to .env file
+        overrides: CLI overrides (--set key=value)
+        working_dir: Working directory to search for config files (defaults to cwd).
+                    This is important when using --working-dir flag to ensure
+                    config is loaded from the project directory, not invoke directory.
     """
     # Load .env first (for secrets)
-    load_env(env_path)
+    load_env(env_path, base_dir=working_dir)
 
     # Start with defaults
     config_dict: dict[str, Any] = {}
 
     # Layer in config.toml
-    toml_config = load_toml_config(toml_path)
+    toml_config = load_toml_config(toml_path, base_dir=working_dir)
     if toml_config:
         config_dict = deep_merge(config_dict, toml_config)
 

zwarm/core/test_config.py

@@ -20,7 +20,6 @@ def test_default_config():
     assert config.executor.adapter == "codex_mcp"
     assert config.executor.sandbox == "workspace-write"
     assert config.orchestrator.lm == "gpt-5-mini"
-    assert config.orchestrator.sync_first is True
     assert config.state_dir == ".zwarm"
 
 
@@ -68,8 +67,8 @@ def test_apply_overrides():
     assert result["executor"]["adapter"] == "claude_code"
 
     # Override with boolean
-    result = apply_overrides(config, ["orchestrator.sync_first=false"])
-    assert result["orchestrator"]["sync_first"] is False
+    result = apply_overrides(config, ["executor.web_search=true"])
+    assert result["executor"]["web_search"] is True
 
     # Create new nested path
     result = apply_overrides(config, ["weave.project=my-project"])

zwarm/orchestrator.py

@@ -23,7 +23,6 @@ from wbal.helper import TOOL_CALL_TYPE, format_openai_tool_response
 from wbal.lm import LM as wbalLMGeneric
 from wbal.lm import GPT5LargeVerbose
 
-from zwarm.adapters import ExecutorAdapter, get_adapter
 from zwarm.core.compact import compact_messages, should_compact
 from zwarm.core.config import ZwarmConfig, load_config
 from zwarm.core.environment import OrchestratorEnv
@@ -72,7 +71,6 @@ class Orchestrator(YamlAgent):
     # State management
     _state: StateManager = PrivateAttr()
     _sessions: dict[str, ConversationSession] = PrivateAttr(default_factory=dict)
-    _adapters: dict[str, ExecutorAdapter] = PrivateAttr(default_factory=dict)
     _watcher_manager: WatcherManager | None = PrivateAttr(default=None)
     _resumed: bool = PrivateAttr(default=False)
     _total_tokens: int = PrivateAttr(default=0)  # Cumulative orchestrator tokens
@@ -83,9 +81,11 @@ class Orchestrator(YamlAgent):
             "total_tokens": 0,
         }
     )
+    # Callback for step progress (used by CLI to print tool calls)
+    _step_callback: Callable[[int, list[tuple[dict[str, Any], Any]]], None] | None = PrivateAttr(default=None)
 
     def model_post_init(self, __context: Any) -> None:
-        """Initialize state and adapters after model creation."""
+        """Initialize state after model creation."""
         super().model_post_init(__context)
 
         # Initialize state manager with instance isolation
@@ -151,40 +151,9 @@ class Orchestrator(YamlAgent):
         """Access state manager."""
         return self._state
 
-    def _get_adapter(self, name: str) -> ExecutorAdapter:
-        """Get or create an adapter by name using the adapter registry."""
-        if name not in self._adapters:
-            # Get model from config (adapters have their own defaults if None)
-            model = self.config.executor.model
-
-            # Use isolated codex config if available
-            config_path = self.working_dir / self.config.state_dir / "codex.toml"
-            if not config_path.exists():
-                config_path = None  # Fallback to adapter defaults
-
-            self._adapters[name] = get_adapter(
-                name, model=model, config_path=config_path
-            )
-        return self._adapters[name]
-
     def get_executor_usage(self) -> dict[str, int]:
-        """Get aggregated token usage across all executors."""
-        total = {
-            "input_tokens": 0,
-            "output_tokens": 0,
-            "total_tokens": 0,
-        }
-        for adapter in self._adapters.values():
-            if hasattr(adapter, "total_usage"):
-                usage = adapter.total_usage
-                for key in total:
-                    total[key] += usage.get(key, 0)
-        return total
-
-    @property
-    def executor_usage(self) -> dict[str, int]:
-        """Aggregated executor token usage (for Weave tracking)."""
-        return self.get_executor_usage()
+        """Get aggregated token usage from executor sessions."""
+        return self._executor_usage
 
     def save_state(self) -> None:
         """Save orchestrator state for resume."""
@@ -587,7 +556,11 @@ Review what was accomplished in the previous session and delegate new tasks as n
                 }
             # NUDGE and CONTINUE just continue
 
-            self.step()
+            tool_results = self.step()
+
+            # Call step callback if registered (for CLI progress display)
+            if self._step_callback:
+                self._step_callback(self._step_count, tool_results)
 
             if self.stopCondition:
                 break
@@ -599,8 +572,7 @@ Review what was accomplished in the previous session and delegate new tasks as n
 
     async def cleanup(self) -> None:
         """Clean up resources."""
-        for adapter in self._adapters.values():
-            await adapter.cleanup()
+        pass  # Session cleanup handled by CodexSessionManager
 
 
 def build_orchestrator(
@@ -631,15 +603,17 @@ def build_orchestrator(
     """
     from uuid import uuid4
 
-    # Load configuration
+    # Resolve working directory first (needed for config loading)
+    working_dir = working_dir or Path.cwd()
+
+    # Load configuration from working_dir (not cwd!)
+    # This ensures config.toml and .env are loaded from the project being worked on
     config = load_config(
         config_path=config_path,
         overrides=overrides,
+        working_dir=working_dir,
     )
 
-    # Resolve working directory
-    working_dir = working_dir or Path.cwd()
-
     # Generate instance ID if not provided (enables isolation by default for new runs)
     # For resume, instance_id should be provided explicitly
     if instance_id is None and not resume: