1. SessionStart hook fires
2. Check for current-task.md
   - EXISTS: Read it, identify phase and role, resume work
   - MISSING: Ask user what they want to work on
3. Identify human's role (PM, UX, QA, SE, or multi-hat)
4. Load appropriate process skill for current phase
5. Summarize context and propose next steps
6. Wait for human direction

1. Verify phase completion criteria met
2. STOP - Ask human for approval to transition
3. On approval:
   - Update Linear status
   - Update current-task.md with new phase
   - Load new phase's process skill
   - Summarize what's next
4. On rejection:
   - Ask what's missing
   - Continue in current phase

Setup:      Create project brief, define scope
Discovery:  Discover requirements, create estimates, configure Linear
Refinement:   Approve designs, approve requirements, plan milestones
Delivery:   Approve releases to production

Setup:      Establish brand guidelines, reference class
Discovery:  Define base design tokens, identify atoms (shadcn/ui primitives)
Refinement:   Catalog Check → Create molecules/organisms → Storybook → Tests
Delivery:   Engineering wires components, UX Review before PR

Setup:      -
Discovery:  -
Refinement:   Refine requirements, develop test definitions, verify designs
Delivery:   Approve Dev→Test, verify Test→Prod transitions

Setup:      Architecture analysis, GI Standard setup, auth implementation
Discovery:  Review ADRs, set up tooling (logging, alerting, observability)
Refinement:   Review ADRs
Delivery:   Implement tests, implement features, approve merges

1. Load af-estimation-expertise

2. Discovery phase (feature-level):
   - Decompose each feature by functional area (FE, BE, INFRA, TEST, UX, DOCS)
   - Estimate hours per area, sum total, convert to fibonacci points
   - Set story points on each Linear feature issue
   - Post [Discovery Estimate] comment with structured breakdown
   - Confidence is typically Low or Medium

3. Refinement phase (atomic with roll-up):
   - After mini-PRD and BDD scenarios are complete
   - For features > 3 points: create sub-issues with individual estimates
   - Estimate each sub-issue by functional area in hours
   - Roll up BOTH hours AND points to parent feature
   - Post [Refined Estimate] comment on parent feature
   - Complete mini-PRD Section 7 (Effort Estimation)
   - Story points must be set before moving to "Approved"

4. Key rules:
   - Always decompose before estimating (never guess a single number)
   - 1 point = 3 hours = half a productive day (6 hours/day)
   - Round up to next fibonacci value, never down
   - Include testing (30-50% of implementation), docs, and infrastructure

1. Identify the blocker type:
   - UNCLEAR REQUIREMENTS → Ask PM for clarification
   - TECHNICAL BLOCKERS → Research, ask SE for help
   - APPROVAL PENDING → Identify approver, prompt for decision
   - DESIGN INCOMPLETE → Check with UX
   - TESTS FAILING → Debug, check af-testing-expertise

2. Update current-task.md with blocker details

3. If blocker persists:
   - Document in Linear issue
   - Propose alternative approaches
   - Ask human for decision

4. Never silently skip blocked work

1. Identify handoff point (e.g., UX → SE, QA → PM)
2. Ensure deliverables are complete:
   - UX → SE: Storybook stories, selector contracts
   - SE → QA: Feature on dev branch, test evidence
   - QA → PM: Test report, verification status
3. Update Linear with handoff status
4. Notify receiving role (or prompt human to notify)
5. Document handoff in current-task.md

→ Identify: Delivery phase (implementation request)
→ Check: Is there an approved mini-PRD? (Refinement gate)
→ If NO: "We need to complete Refinement first. Shall I start /refinement:refine?"
→ If YES: Load af-delivery-process, begin TDD cycle

→ Identify: Role = PM
→ Check: Current phase from current-task.md or Linear
→ Consult role-phase matrix for PM activities in current phase
→ Propose specific next steps based on PM responsibilities

→ Read current-task.md for context
→ Check Linear for status and blockers
→ Identify blocker type (requirements? technical? approval?)
→ Propose resolution based on blocker type
→ Ask human for decision on path forward

→ Identify: UX → SE handoff (or UX → QA for review)
→ Check: Are Storybook stories created?
→ Check: Is selector contract defined?
→ If complete: Update Linear, propose next steps for SE
→ If incomplete: List missing deliverables for UX