feat: two-phase execution, think slugs, query enrichment (v1.6.0)

Two-Phase Tatlock Execution:
- orchestrate_tool_calls() for Phase 1 coordination
- synthesize_from_results() for Phase 2 butler-toned synthesis
- Guarantees butler personality in all responses

Automatic Think Slugs:
- Deterministic butler-perspective messages during expert delegation
- ActionType enum: RETRIEVE, RESEARCH, CREATE, CONTROL, RECORD
- HOUSEHOLD_THINK_MESSAGES mapping for all experts
- Streaming delegation wrappers with automatic think messages

Steward Query Enrichment:
- Auto-fill user context (location, timezone) when not specified
- _build_enriched_query() with regex word boundary matching
- enriched_query field in StewardRecommendation schema

Documentation:
- ORCHESTRATION_SCENARIOS.md rewritten with Mermaid diagrams
- New Housekeeper and Biographer scenarios
- TESTING_IMPROVEMENTS.md for future LLM testing patterns

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

src/agents/tatlock.py

@@ -630,6 +630,241 @@ class TatlockAgent(AgentInterface):
 
         logger.info("tatlock_scoped_run_complete")
 
+    async def orchestrate_tool_calls(
+        self,
+        user_message: str,
+        steward_note: str,
+        scoped_tools: list[Any],
+        message_history: list[dict],
+        tool_tracker: Any = None,
+    ) -> dict[str, Any]:
+        """
+        Phase 1: Execute tool calls and delegations, return structured results.
+
+        This is the coordination phase where Tatlock orchestrates tool calls
+        and expert delegations. The raw output is captured for Phase 2 synthesis.
+
+        Args:
+            user_message: The user's original message
+            steward_note: Note from Steward (invisible to user)
+            scoped_tools: List of tool definitions from household registry
+            message_history: Conversation history
+            tool_tracker: Optional tool call tracker for benchmarking
+
+        Returns:
+            dict with:
+                - tools_called: List of tool names that were called
+                - expert_results: Dict mapping expert names to their outputs
+                - tool_outputs: Dict mapping tool names to their outputs
+                - raw_output: The agent's raw text output
+        """
+        from pydantic_ai.models.openai import OpenAIChatModel
+        from pydantic_ai.providers.ollama import OllamaProvider
+        from pydantic_ai.settings import ModelSettings
+        from pydantic_ai.messages import (
+            ModelRequest,
+            ModelResponse,
+            UserPromptPart,
+            TextPart,
+            ToolCallPart,
+            ToolReturnPart,
+        )
+
+        logger.info(
+            "tatlock_orchestrate_tool_calls",
+            user_message_preview=user_message[:100],
+            scoped_tool_count=len(scoped_tools),
+            history_length=len(message_history),
+        )
+
+        # Create a fresh agent instance with scoped tools only
+        clean_host = self.ollama_host.rstrip('/')
+        base_url = f"{clean_host}/v1"
+
+        ollama_model = OpenAIChatModel(
+            model_name=self.model_name,
+            provider=OllamaProvider(base_url=base_url)
+        )
+
+        # Create agent with scoped tools
+        scoped_agent = Agent(
+            ollama_model,
+            system_prompt=TATLOCK_SYSTEM_PROMPT,
+            tools=scoped_tools,
+        )
+
+        # Prepend Steward's note to the request
+        enriched_message = f"{steward_note}\n\n{user_message}"
+
+        # Convert message history to PydanticAI format
+        pydantic_history = []
+        for msg in message_history:
+            role = msg.get("role")
+            content = msg.get("content", "")
+
+            if not content or not content.strip():
+                continue
+
+            if role == "user":
+                pydantic_history.append(
+                    ModelRequest(parts=[UserPromptPart(content=content)])
+                )
+            elif role == "assistant":
+                pydantic_history.append(
+                    ModelResponse(parts=[TextPart(content=content)])
+                )
+
+        # Run with scoped tools and tracker
+        result = await scoped_agent.run(
+            enriched_message,
+            message_history=pydantic_history if pydantic_history else None,
+            deps=tool_tracker,
+            model_settings=ModelSettings(extra_body={"tool_choice": "required"})
+        )
+
+        # Extract tool calls and results from the agent's messages
+        tools_called = []
+        expert_results = {}
+        tool_outputs = {}
+
+        # Parse through new messages to find tool calls and returns
+        for msg in result.new_messages():
+            if isinstance(msg, ModelResponse):
+                for part in msg.parts:
+                    if isinstance(part, ToolCallPart):
+                        tools_called.append(part.tool_name)
+            elif isinstance(msg, ModelRequest):
+                for part in msg.parts:
+                    if isinstance(part, ToolReturnPart):
+                        tool_name = part.tool_name
+                        content = part.content
+
+                        # Categorize as expert result or tool output
+                        if tool_name.startswith("delegate_to_"):
+                            expert_name = tool_name.replace("delegate_to_", "")
+                            expert_results[expert_name] = content
+                        else:
+                            tool_outputs[tool_name] = content
+
+        logger.info(
+            "tatlock_orchestration_complete",
+            tools_called=tools_called,
+            expert_count=len(expert_results),
+            tool_output_count=len(tool_outputs),
+        )
+
+        return {
+            "tools_called": tools_called,
+            "expert_results": expert_results,
+            "tool_outputs": tool_outputs,
+            "raw_output": result.output,
+        }
+
+    async def synthesize_from_results(
+        self,
+        user_message: str,
+        orchestration_results: dict[str, Any],
+        message_history: list[dict],
+    ) -> str:
+        """
+        Phase 2: Synthesize butler-toned response from gathered results.
+
+        This is the synthesis phase where Tatlock takes the coordination
+        results and produces a properly butler-toned response.
+
+        Args:
+            user_message: The user's original message
+            orchestration_results: Results from orchestrate_tool_calls()
+            message_history: Conversation history
+
+        Returns:
+            str: Butler-toned response synthesized from all results
+        """
+        from pydantic_ai.models.openai import OpenAIChatModel
+        from pydantic_ai.providers.ollama import OllamaProvider
+        from pydantic_ai.messages import ModelRequest, ModelResponse, UserPromptPart, TextPart
+
+        logger.info(
+            "tatlock_synthesize_from_results",
+            user_message_preview=user_message[:100],
+            expert_count=len(orchestration_results.get("expert_results", {})),
+            tool_count=len(orchestration_results.get("tool_outputs", {})),
+        )
+
+        # Build synthesis prompt with all available information
+        synthesis_parts = []
+        synthesis_parts.append(f"The user asked: {user_message}")
+        synthesis_parts.append("")
+
+        # Add expert findings if any
+        if orchestration_results.get("expert_results"):
+            synthesis_parts.append("Expert findings:")
+            for expert, result in orchestration_results["expert_results"].items():
+                synthesis_parts.append(f"- {expert.title()}: {result}")
+            synthesis_parts.append("")
+
+        # Add tool outputs if any
+        if orchestration_results.get("tool_outputs"):
+            synthesis_parts.append("Tool results:")
+            for tool, result in orchestration_results["tool_outputs"].items():
+                synthesis_parts.append(f"- {tool}: {result}")
+            synthesis_parts.append("")
+
+        synthesis_parts.append(
+            "Based on this information, provide a response to the user. "
+            "Maintain your butler personality - address them as 'sir', "
+            "use formal but personable language, and be helpful."
+        )
+
+        synthesis_prompt = "\n".join(synthesis_parts)
+
+        # Create synthesis agent (no tools needed)
+        clean_host = self.ollama_host.rstrip('/')
+        base_url = f"{clean_host}/v1"
+
+        ollama_model = OpenAIChatModel(
+            model_name=self.model_name,
+            provider=OllamaProvider(base_url=base_url)
+        )
+
+        # Synthesis agent uses butler prompt but no tools
+        synthesis_agent = Agent(
+            ollama_model,
+            system_prompt=TATLOCK_SYSTEM_PROMPT,
+            # No tools for synthesis phase
+        )
+
+        # Convert message history to PydanticAI format
+        pydantic_history = []
+        for msg in message_history:
+            role = msg.get("role")
+            content = msg.get("content", "")
+
+            if not content or not content.strip():
+                continue
+
+            if role == "user":
+                pydantic_history.append(
+                    ModelRequest(parts=[UserPromptPart(content=content)])
+                )
+            elif role == "assistant":
+                pydantic_history.append(
+                    ModelResponse(parts=[TextPart(content=content)])
+                )
+
+        # Run synthesis
+        result = await synthesis_agent.run(
+            synthesis_prompt,
+            message_history=pydantic_history if pydantic_history else None,
+        )
+
+        logger.info(
+            "tatlock_synthesis_complete",
+            response_preview=result.output[:100],
+        )
+
+        return result.output
+
     async def get_capabilities(self) -> dict:
         """Return current capabilities."""
         return {