{
  "backlog_item": {
    "id": "BL-001",
    "title": "Implement config parser",
    "description": "...",
    "priority": "HIGH",
    "estimated_hours": 4
  },
  "agent_role": "builder",
  "category": "feature",
  "complexity": "medium",
  "project_context": "Project goals and context...",
  "instructions": "Step-by-step agent instructions...",
  "relevant_files": ["src/config.py", "tests/test_config.py"],
  "similar_patterns": ["Look for pattern X in file Y"],
  "test_requirements": ["Unit tests", "Integration tests"],
  "architectural_notes": "Keep simple, follow patterns...",
  "success_criteria": ["All requirements met", "Tests pass"]
}

PM: Start work on BL-001

Delegator: [Calls scripts/create_delegation.py BL-001 --agent builder]

Created delegation package for BL-001:

**Backlog Item**: Implement config parser
**Agent**: builder
**Category**: feature
**Complexity**: medium

**Relevant Files**:
- src/config/ (existing config utilities)
- tests/test_config.py (test patterns)

**Similar Patterns**:
- Look for file loading patterns in src/utils/file_loader.py
- Follow existing test structure in tests/

**Test Requirements**:
- Unit tests for config loading
- Integration tests for YAML/JSON parsing
- Edge case coverage (empty files, invalid data)
- Test error handling

**Architectural Notes**:
- Keep simple - use standard library
- Follow existing module patterns
- Single responsibility per function

**Success Criteria**:
- [ ] Config parser works for YAML and JSON
- [ ] All edge cases handled
- [ ] Tests pass
- [ ] No stubs or placeholders
- [ ] Documentation updated

Package ready. Should I invoke builder agent?

User: Who should work on this complex auth feature?

Delegator: For a complex authentication feature, I recommend:

1. **architect** agent first
   - Design auth flow and security model
   - Define module boundaries
   - Specify integration points

2. **security** agent review
   - Validate security approach
   - Identify vulnerabilities
   - Recommend best practices

3. **builder** agent for implementation
   - Implement based on architect's design
   - Follow security recommendations
   - Complete with tests

This sequential approach ensures security-critical code is well-designed.

**Project**: my-cli-tool
**Type**: cli-tool
**Quality Bar**: balanced

**Primary Goals**:
- Implement configuration system
- Build comprehensive CLI interface
- Achieve 80% test coverage

**Roadmap Summary**:
We're focusing on core functionality first, then CLI polish, then documentation.

1. Analyze requirements and examine relevant files listed below
2. Design solution following existing patterns
3. Implement working code (no stubs or placeholders)
4. Add comprehensive tests per test requirements
5. Follow architectural notes
6. Update documentation

Focus on ruthless simplicity. Start with simplest solution that works.

1. Review code for philosophy compliance
2. Verify no stubs, placeholders, or dead code
3. Check test coverage against requirements
4. Validate architectural notes followed
5. Look for unnecessary complexity
6. Ensure documentation updated

Focus on ruthless simplicity and zero-BS implementation.

1. Analyze behavior and contracts
2. Review test requirements below
3. Design tests for edge cases
4. Implement comprehensive coverage
5. Verify all tests pass
6. Document test scenarios

Focus on testing behavior, not implementation details.

PM: [User approves starting work on BL-001]

I'll consult Work Delegator to prepare the delegation package...

[Invokes work-delegator skill]
[Delegator creates comprehensive package]

PM: Delegation package ready for builder agent.
    Estimated time: 4 hours (medium complexity)

    Should I start the workstream?

def estimate_complexity(item: dict) -> str:
    hours = item.get("estimated_hours", 4)

    # Base complexity
    if hours < 2:
        base = "simple"
    elif hours <= 6:
        base = "medium"
    else:
        base = "complex"

    # Adjust for technical signals
    text = item["title"] + " " + item["description"]
    signals = {
        "api_changes": "api" in text or "endpoint" in text,
        "db_changes": "database" in text or "schema" in text,
        "ui_changes": "ui" in text or "frontend" in text,
        "security": "auth" in text or "security" in text
    }

    complexity_count = sum(signals.values())

    # Increase complexity if 3+ technical signals
    if complexity_count >= 3:
        if base == "simple":
            base = "medium"
        elif base == "medium":
            base = "complex"

    return base

Item: "Implement config parser"
Keywords: ["implement", "config", "parser"]

Search paths:
- src/config/ → config.py, parser.py
- tests/ → test_config.py
- .claude/tools/ → (none)

Relevant files (3 found):
1. src/config/loader.py (matches "config")
2. tests/test_config.py (matches "config", "test")
3. src/utils/parser_base.py (matches "parser")

User: Delegate BL-009 (bug fix)

Delegator: [Creates package]

Delegation Package for BL-009:

**Bug Fix Workflow**: Write failing test first, then fix, verify test passes.

**Agent**: builder
**Complexity**: simple (2 hours)

**Relevant Files**:
- src/module_with_bug.py
- tests/test_module.py

**Instructions**:
1. Write test that reproduces bug
2. Verify test fails
3. Fix bug with minimal changes
4. Verify test passes
5. Check no regressions

**Success**: Bug fixed, test passes, no regressions.

User: Delegate BL-010 (complex auth feature)

Delegator: Given the complexity, I recommend a two-stage approach:

**Stage 1: Architecture** (architect agent)
- Design auth flow
- Define security model
- Specify integration points

**Stage 2: Implementation** (builder agent)
- Implement based on design
- Follow security best practices
- Comprehensive testing

Should I create delegation packages for both stages?

PM: Create delegation package for BL-001

Delegator: [Loads project context from .pm/config.yaml]

Package includes project context:

**Project**: my-cli-tool
**Quality Bar**: balanced (pragmatic testing, reasonable coverage)

**Primary Goals**:
1. Implement configuration system ← THIS ITEM DIRECTLY SUPPORTS
2. Build comprehensive CLI
3. Achieve 80% test coverage

This work is HIGH priority because it directly supports goal #1.