Add handoff prompt for Haiku implementation

Complete briefing for starting T0.1 implementation:
- Context recap
- 9-task breakdown with verification steps
- Key constraints (no hardcoded values, independent activities, concurrency safety)
- Commit message style
- Troubleshooting guide

tasks/HANDOFF_PROMPT.md

@@ -0,0 +1,137 @@
+# Handoff Prompt: Implement T0 Milestone
+
+Use this prompt with Claude Haiku 4.5 to begin implementation of T0 tasks.
+
+---
+
+## Context
+
+You're implementing a Temporal-based multi-agent software orchestrator in Go. The system drives development work on arbitrary target repos using three LLM-backed roles:
+- **Planner** (reasoning model): reconciles state, dispatches tasks
+- **Judge** (reasoning model): reviews correctness, runs integration tests
+- **Implementer** (cheaper model): does actual work, learns from failures
+
+All code lives in `/Users/rockliang/workplace/Poimen/workflows/`.
+
+## What's Done
+
+- ✅ Full design doc: `/Users/rockliang/.claude/plans/considered-u-are-a-curried-reef.md`
+- ✅ Project scaffold: `PLAN.md`, `tasks/INDEX.md`, `tasks/board.md`
+- ✅ Roadmap: T0 (core, 9 tasks) → T1 (hardening) → T2 (scale) → T3 (features)
+- ✅ Task breakdown: `tasks/T0.1.md` through `tasks/T0.9.md` (each with verification criteria)
+
+## Your Job: Implement T0.1 → T0.9
+
+Start with T0.1 (repo scaffold). Each task:
+1. Read its markdown file in `tasks/T0.x.md`
+2. Implement the code sketches provided
+3. Write unit tests per verification section
+4. Run the verification command
+5. When it passes, mark `[ ]` → `[x]` in `tasks/board.md`
+6. Move to next task
+
+## Key Constraints
+
+1. **No hardcoded values:** All timeouts, retry counts, model IDs come from `OrchestratorConfig.Tuning` or `PromptSpec.Model` (read at runtime).
+2. **Activities are independent:** One concern per `action/*.go` file (git, skills, planner, judge, implementer, etc). Testable in isolation.
+3. **Testing is verification:** Unit tests via `go.temporal.io/sdk/testsuite` (mocked activities). E2E test (T0.9) against real `temporal.riotpiao.com`.
+4. **Go style:** Per `golang-skills` conventions — no naked `_ =`, proper error handling, idiomatic names.
+5. **Concurrency safety:** Shared FS with git worktrees + advisory lock. Test concurrent access.
+
+## Implementation Path
+
+```
+1. T0.1: Scaffold directories, go.mod, empty stubs
+   → verify: go build ./... succeeds
+
+2. T0.2: Shared types (ModelSpec, PromptSpec, OrchestratorConfig, etc.)
+   → verify: Unit test asserts all defaults
+
+3. T0.3: Git & locking (CloneRepoActivity, worktrees, squash-merge)
+   → verify: Test against local scratch repo
+
+4. T0.4: Pi & error classification (PrepareSkillsActivity, classifyPiErr)
+   → verify: Unit tests for 4xx/5xx/504 buckets
+
+5. T0.5: LLM agents & prompts (Planner/Judge/Implementer, llm/client.go)
+   → verify: Unit test renders PromptSpec with system prompt
+
+6. T0.6: TaskUnit workflow (retry loops, timeout escalation, lessons)
+   → verify: Testsuite: pass-first-try, fail-then-pass, timeout-escalation
+
+7. T0.7: Orchestrator workflow (config, signals, fan-out/fan-in, continue-as-new, 504 learning)
+   → verify: Testsuite: fan-out/fan-in, squash-merge, signal mutations
+
+8. T0.8: Worker & starter CLIs (cmd/worker, cmd/starter, internal/config)
+   → verify: go build succeeds, go run ./cmd/worker connects to temporal.riotpiao.com
+
+9. T0.9: End-to-end (real cluster + disposable forgejo repo, all 7 checks)
+   → verify: Full cycle with live signals, 5xx retry/exhaust, 504 learning, continue-as-new bounded
+```
+
+## Tools Available
+
+- `pi` command: Clone/fetch skills from homelab API
+  - Usage: `pi clone-or-fetch <skill-url>`
+  - Errors: 4xx (non-retryable), 5xx (retryable), 504 (stream timeout — learn and double timeout)
+
+- Temporal Web UI: `http://temporal.riotpiao.com:8080` (monitor workflows)
+- Forgejo instance: For disposable scratch repos during testing
+
+## Testing Locally
+
+Each task has a "Verification" section with a test command. Run it after implementing:
+
+```bash
+cd /Users/rockliang/workplace/Poimen/workflows
+go test -v ./tests -run Test<TaskName>
+```
+
+For T0.9 (e2e), you'll need:
+- Real Temporal cluster connection
+- Anthropic API key (`ANTHROPIC_API_KEY` env)
+- Forgejo repo access or local git repo
+
+## Commit Message Style
+
+```
+T0.x: Brief description
+
+Detailed explanation of what was implemented.
+
+Verification: <how you verified it works>
+```
+
+Example:
+```
+T0.2: Implement shared types with defaults
+
+Added ModelSpec, PromptSpec, OrchestratorConfig, ActivityTuning, PiRetryPolicy.
+All defaults documented: 5m ScheduleToCloseTimeout, 2s InitialInterval, 2.0 BackoffCoefficient, etc.
+
+Verification: go test ./tests -run TestTypesDefaults passes
+```
+
+## When Stuck
+
+1. Re-read the task markdown in `tasks/T0.x.md` — implementation sketches are concrete
+2. Check `PLAN.md` §Design sections for detailed logic (§Timeout Extension, §Pi Command Retry Policy, etc.)
+3. Look at the test case in the task markdown — it shows expected behavior
+4. If a task depends on prior work, make sure the prior task is complete first
+
+## After T0 Completes
+
+When all T0.1–T0.9 pass:
+```bash
+cd /Users/rockliang/workplace/Poimen/workflows
+git checkout main
+git merge --squash task/T0.1 task/T0.2 ... task/T0.9
+git commit -m "T0: Multi-agent orchestrator initial implementation"
+git push origin main
+```
+
+Then start T1 (or hand off to another assistant).
+
+---
+
+**Ready?** Start with `tasks/T0.1.md` and work through in order.