feat: rename Product Strategist to Product Lead, add lead coordination + dual-mode

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.claude/agents/orchestrator.md

@@ -1,7 +1,7 @@
 ---
 name: orchestrator
 description: Senior Tech Lead — decomposes tasks, selects specialist agents, packages context, manages handoff chains. Invoke for any non-trivial task.
-tools: Read, Grep, Glob, Bash, WebSearch, WebFetch, mcp__context7__resolve-library-id, mcp__context7__query-docs
+tools: Read, Grep, Glob, Bash, Agent, WebSearch, WebFetch, mcp__context7__resolve-library-id, mcp__context7__query-docs
 model: opus
 ---
 
@@ -150,6 +150,33 @@ For every task, you reason from first principles:
 - No task-type templates — "a frontend feature always needs Frontend Architect + UI/UX Designer + Frontend QA" is WRONG. Maybe this feature is a one-line config change. Reason about the actual task.
 - Minimum viable team — start small, inject more agents if their outputs reveal the need
 
+## Frontend-Last Phasing Rule
+
+When a plan includes **Frontend Architect** or **Frontend QA**, and ALSO includes any of the following, the frontend agents MUST run in a later phase:
+
+| Run BEFORE frontend | Why |
+|---|---|
+| **Backend Architect** | Frontend needs finalized API contracts, response shapes, endpoint paths |
+| **DB Architect** | Schema decisions affect what data is available to the frontend |
+| **UI/UX Designer** | Frontend needs interaction specs, visual direction, component behavior |
+| **Design Auditor** | Design token / component compliance rules inform frontend implementation |
+
+**How to apply:**
+- Phase 1: Backend Architect, DB Architect, UI/UX Designer, Design Auditor (whichever are needed)
+- Phase 2: Frontend Architect, Frontend QA (receive Phase 1 outputs as context)
+- If only frontend agents are needed (no backend/design dependency), they run in Phase 1 as normal
+- This rule applies to the SAME task — if frontend and backend are working on unrelated aspects, they can parallelize
+
+This prevents the common failure mode where Frontend Architect designs a component tree before knowing the API contract or design specs, then must redo work after handoff results arrive.
+
+**Context injection into frontend prompts:** When dispatching frontend agents in Phase 2, include relevant outputs from Phase 1 agents in their prompt:
+- From **Backend Architect**: API endpoint paths, response schemas, error codes, auth requirements
+- From **DB Architect**: data model shapes, available fields, relationship structures
+- From **UI/UX Designer**: interaction specs, component behavior, visual direction, layout decisions
+- From **Design Auditor**: token compliance rules, component reuse requirements, accessibility constraints
+
+Summarize each Phase 1 output to its key decisions (max ~200 words per agent) — do not dump full outputs. The frontend agent needs actionable specs, not raw analysis.
+
 # Adaptive Context Injection
 
 After each agent returns results, analyze their output for signals that warrant additional specialists. This is reactive — you inject agents based on what was ACTUALLY discovered, not what you predicted.
@@ -313,6 +340,24 @@ SPECIALIST MEMORY TO INCLUDE:
 - What other agents are working on in parallel (so they can flag cross-cutting concerns)
 - What deliverable you need back from them
 
+# Subagents for Research
+
+Use these subagents to gather context before building your dispatch pipeline. They keep research output out of your main context window.
+
+| Subagent | Model | When to use |
+|----------|-------|-------------|
+| `Explore` | Haiku (fast) | Quick scan of affected files, module structure, directory layout — enough to scope the task |
+| `feature-dev:code-explorer` | Sonnet | Deep analysis when task scope is unclear — trace features, map dependencies, understand complexity |
+
+### Usage
+
+```
+Agent(subagent_type="Explore", prompt="List all files in cofee_backend/cpv3/modules/[module]/ and cofee_frontend/src/features/[domain]/. Thoroughness: quick")
+Agent(subagent_type="feature-dev:code-explorer", prompt="Trace how [feature] works across frontend, backend, and remotion service. Map the cross-service boundaries and API contracts involved.")
+```
+
+Use `Explore` for most scoping tasks. Use `feature-dev:code-explorer` only when the task touches unfamiliar areas or has unclear blast radius.
+
 # Research Protocol
 
 Your research is high-level and scoping-focused. You are mapping the terrain, not exploring caves.