chati-dev 1.3.3 → 2.0.1

package/framework/tasks/brief-constraint-identify.md

@@ -0,0 +1,277 @@
+---
+id: brief-constraint-identify
+agent: brief
+trigger: brief-stakeholder-map
+phase: clarity
+requires_input: true
+parallelizable: false
+outputs: [constraints.yaml]
+handoff_to: brief-consolidate
+autonomous_gate: true
+criteria:
+  - All constraint types identified
+  - Constraint conflicts resolved
+  - Realistic feasibility assessment
+---
+# Identify and Resolve Constraint Conflicts
+
+## Purpose
+Identify all project constraints, detect conflicts, and work with user to resolve them.
+
+## Prerequisites
+- `validation-report.yaml` with initial constraints
+- `stakeholder-map.yaml` for authority on constraint resolution
+
+## Steps
+
+### 1. Consolidate All Constraints
+From previous artifacts, gather:
+- Technical constraints
+- Timeline constraints
+- Budget constraints
+- Team constraints
+- Regulatory/compliance constraints
+- Business constraints
+
+### 2. Analyze Each Constraint Type
+
+**Technical Constraints**:
+- Must-use technologies
+- Integration requirements
+- Platform requirements
+- Data constraints
+- Infrastructure limitations
+
+**Timeline Constraints**:
+- Hard deadlines (launch date, regulatory deadline)
+- Soft deadlines (preferred dates)
+- Milestones
+- Dependencies on external events
+
+**Budget Constraints**:
+- Development budget (hours × rate)
+- Infrastructure budget (hosting, services)
+- Third-party service costs (APIs, SaaS)
+- One-time vs. recurring costs
+
+**Team Constraints**:
+- Team size and composition
+- Skill levels and gaps
+- Availability (full-time, part-time, contract)
+- Timezone distribution
+
+**Regulatory Constraints**:
+- GDPR, CCPA (data privacy)
+- HIPAA (healthcare)
+- PCI-DSS (payments)
+- SOC2 (security)
+- Industry-specific regulations
+
+### 3. Detect Constraint Conflicts
+Common conflicts:
+- **Time vs. Scope**: Not enough time to build all features
+- **Budget vs. Quality**: Budget doesn't support proper testing
+- **Team Skills vs. Tech Stack**: Team doesn't know required technologies
+- **Timeline vs. Quality**: Rush leads to technical debt
+- **Multiple Hard Deadlines**: Can't meet all simultaneously
+
+### 4. Assess Constraint Flexibility
+For each constraint, determine:
+- **Fixed**: Cannot change (legal deadline, existing API)
+- **Negotiable**: Can discuss changes (MVP scope, timeline)
+- **Flexible**: Can easily adjust (nice-to-have features)
+
+### 5. Calculate Feasibility
+Estimate if project is feasible given constraints:
+- Required effort (hours) vs. available capacity (team × hours)
+- Required timeline vs. estimated development time
+- Required budget vs. estimated costs
+- Required skills vs. available skills
+
+If infeasible, flag with recommended adjustments.
+
+### 6. Present Conflicts to User
+For each conflict:
+- Describe the conflict
+- Explain the impact if not resolved
+- Provide 2-3 resolution options with trade-offs
+- Recommend preferred option
+
+### 7. Collect User Decisions
+- Which constraints are truly fixed?
+- Which can be relaxed?
+- How to resolve each conflict?
+- What are acceptable trade-offs?
+
+### 8. Update Constraint List
+- Mark fixed vs. flexible
+- Document resolutions
+- Note any assumptions made
+
+### 9. Re-assess Feasibility
+- After resolutions, is project now feasible?
+- If not, escalate to stakeholders for major decisions
+
+### 10. Document Final Constraints
+- Clear, unambiguous constraint list
+- All conflicts resolved
+- Feasibility confirmed
+
+## Decision Points
+- **Infeasible Project**: If project cannot be done within constraints, recommend scope reduction or constraint relaxation
+- **Major Conflict**: If conflict requires stakeholder decision, facilitate that conversation
+
+## Error Handling
+- **Unrealistic Expectations**: Gently educate user on typical timelines/costs
+- **Unwilling to Compromise**: Document the risk and proceed (user responsibility)
+
+## Output Format
+```yaml
+# constraints.yaml
+timestamp: 2026-02-13T13:45:00Z
+
+all_constraints:
+  technical:
+    - id: CT-001
+      constraint: Must integrate with existing WordPress blog API
+      flexibility: fixed
+      impact: high
+      reason: Business requirement, existing content must be accessible
+    - id: CT-002
+      constraint: Must use React for frontend
+      flexibility: negotiable
+      impact: medium
+      reason: Team expertise, but could learn Vue if needed
+  timeline:
+    - id: CT-003
+      constraint: MVP launch by May 13, 2026 (3 months)
+      flexibility: negotiable
+      impact: high
+      reason: Marketing campaign scheduled, but can adjust
+  budget:
+    - id: CT-004
+      constraint: Development budget is $60,000 (600 hours @ $100/hr)
+      flexibility: negotiable
+      impact: high
+      reason: Allocated budget for Q1-Q2, could request more if justified
+    - id: CT-005
+      constraint: Hosting budget is $200/month
+      flexibility: fixed
+      impact: medium
+      reason: Recurring budget approved, hard to change
+  team:
+    - id: CT-006
+      constraint: Team of 2 React developers, no backend experience
+      flexibility: fixed
+      impact: high
+      reason: Current team, hiring not possible short-term
+  regulatory:
+    - id: CT-007
+      constraint: Must be GDPR compliant for EU users
+      flexibility: fixed
+      impact: high
+      reason: Legal requirement
+
+detected_conflicts:
+  - conflict_id: CONF-001
+    description: Timeline too aggressive for scope
+    constraints_involved: [CT-003, functional requirements FR-001 through FR-008]
+    impact: Project will miss deadline or deliver incomplete features
+    severity: high
+    resolution_options:
+      - option: Reduce MVP scope to core features only (FR-001, FR-002, FR-005)
+        pros: Can meet timeline, focused MVP
+        cons: Deferred features delay user value
+        recommended: true
+      - option: Extend timeline to 5 months
+        pros: All features delivered with quality
+        cons: Misses marketing campaign
+        recommended: false
+      - option: Hire contractor for additional capacity
+        pros: Accelerate development
+        cons: Increases budget, onboarding overhead
+        recommended: false
+    user_decision: Reduce scope to core features
+    resolution: MVP scope reduced to user auth, posting, and search. Admin moderation and comments deferred to phase 2.
+
+  - conflict_id: CONF-002
+    description: Team lacks backend skills but project requires full-stack
+    constraints_involved: [CT-006, architecture requirements]
+    impact: Backend development will be slow, potential quality issues
+    severity: high
+    resolution_options:
+      - option: Use Backend-as-a-Service (Firebase, Supabase, AWS Amplify)
+        pros: Reduces backend complexity, team can focus on React
+        cons: Vendor lock-in, recurring costs
+        recommended: true
+      - option: Hire backend contractor
+        pros: Expert backend implementation
+        cons: Increases budget, coordination overhead
+        recommended: false
+      - option: Team learns backend while building
+        pros: Team skill development
+        cons: Slower development, higher bug risk
+        recommended: false
+    user_decision: Use Supabase (BaaS)
+    resolution: Supabase chosen for auth, database, and API. Team focuses on React frontend.
+
+  - conflict_id: CONF-003
+    description: Budget may not support 3-month intensive development
+    constraints_involved: [CT-004, CT-003]
+    impact: May run out of budget before completion
+    severity: medium
+    resolution_options:
+      - option: Reduce scope to fit budget
+        pros: Stays within budget
+        cons: Fewer features
+        recommended: true
+      - option: Request budget increase
+        pros: Full feature set
+        cons: Requires approval, may not be granted
+        recommended: false
+    user_decision: Reduced scope fits within budget
+    resolution: Scope reduction (CONF-001) brings estimated effort to 480 hours, fits within 600-hour budget with buffer.
+
+resolved_conflicts: 3
+remaining_conflicts: 0
+
+feasibility_assessment:
+  before_resolution:
+    required_effort_hours: 720
+    available_capacity_hours: 600 (2 devs × 3 months × 100 hours/month)
+    feasibility: infeasible
+    gap: 120 hours
+  after_resolution:
+    required_effort_hours: 480
+    available_capacity_hours: 600
+    feasibility: feasible
+    buffer: 120 hours (20%)
+    confidence: high
+
+final_constraints:
+  fixed:
+    - WordPress integration (CT-001)
+    - Hosting budget $200/month (CT-005)
+    - Team size 2 developers (CT-006)
+    - GDPR compliance (CT-007)
+  negotiable:
+    - React frontend (CT-002) - chosen, but could have been Vue
+    - Timeline 3 months (CT-003) - could extend if needed
+  flexible:
+    - Feature scope - reduced to MVP
+    - Development budget (CT-004) - could request more if justified
+
+assumptions:
+  - Supabase free tier sufficient for MVP, will upgrade as needed
+  - Developers available 100 hours/month each (full-time equivalent)
+  - No major requirements changes during development
+  - WordPress API is well-documented and stable
+
+risk_mitigations:
+  - 20% time buffer for unknowns and bugs
+  - Weekly checkpoint meetings to track progress
+  - Feature flags to enable/disable incomplete features
+  - Plan for soft launch before marketing campaign
+
+next_step: consolidate_brief
+```

package/framework/tasks/brief-extract-requirements.md

@@ -0,0 +1,339 @@
+---
+id: brief-extract-requirements
+agent: brief
+trigger: orchestrator
+phase: clarity
+requires_input: true
+parallelizable: false
+outputs: [requirements-raw.yaml]
+handoff_to: brief-validate-completeness
+autonomous_gate: true
+criteria:
+  - All 5 requirement categories populated
+  - At least 5 functional requirements captured
+  - At least 3 personas identified
+  - Confidence >= 85%
+---
+# Extract Requirements from User Input
+
+## Purpose
+Extract and structure requirements from user's initial brain dump into the five core categories.
+
+## Prerequisites
+- User has provided initial project description or brain dump
+- Access to user input (text, conversation history, or documents)
+
+## Steps
+
+### 1. Parse User Input
+- Read user's brain dump or project description
+- Identify key themes and topics
+- Note any explicit requirements or constraints
+- Flag ambiguities for follow-up questions
+
+### 2. Extract Functional Requirements
+Identify **what the system must do**:
+- User actions (login, create post, search, etc.)
+- System behaviors (send email, process payment, generate report)
+- Business rules (user must be 18+, discount applies after 10 purchases)
+- Data operations (CRUD operations, calculations, transformations)
+- Integrations (third-party APIs, external systems)
+
+Format as: **Actor + Action + Object + Context**
+Example: "User can create a blog post with title, content, and tags"
+
+Extract at least 5 functional requirements. If fewer found, ask user for more details.
+
+### 3. Extract Non-Functional Requirements
+Identify **how the system should perform**:
+- **Performance**: Response time, throughput, load time targets
+- **Scalability**: Expected users, data volume, growth rate
+- **Availability**: Uptime requirements, maintenance windows
+- **Security**: Authentication, authorization, data protection, compliance
+- **Usability**: Accessibility, mobile support, user experience quality
+- **Compatibility**: Browser support, device support, API versioning
+- **Reliability**: Error handling, data backup, disaster recovery
+- **Maintainability**: Code quality, documentation, testability
+
+Extract at least 3 NFRs. If none mentioned, use reasonable defaults and note as assumptions.
+
+### 4. Extract Constraints
+Identify **limitations and boundaries**:
+- **Technical**: Must use specific technology, existing systems to integrate with
+- **Budget**: Development cost limits, hosting budget
+- **Timeline**: Deadlines, milestones, MVP date
+- **Team**: Team size, skills, availability
+- **Regulatory**: GDPR, HIPAA, SOC2, industry regulations
+- **Business**: Existing contracts, partnerships, brand guidelines
+- **Operational**: Support hours, deployment frequency
+
+Extract all explicit constraints. Flag if constraints conflict.
+
+### 5. Identify Personas
+Identify **who will use the system**:
+- Role name (Admin, Customer, Manager, API Consumer)
+- Goals (what they want to achieve)
+- Pain points (current problems)
+- Technical proficiency (novice, intermediate, expert)
+- Frequency of use (daily, weekly, occasional)
+
+Create at least 3 personas. If user hasn't mentioned, infer from functional requirements.
+
+### 6. Define Success Criteria
+Identify **how to measure success**:
+- Business metrics (revenue, conversion rate, user growth)
+- User metrics (engagement, satisfaction, retention)
+- Technical metrics (uptime, response time, error rate)
+- Project metrics (on-time delivery, budget adherence)
+
+Extract at least 3 success criteria. If none mentioned, ask user to define.
+
+### 7. Identify Gaps and Ambiguities
+Flag areas needing clarification:
+- Vague requirements ("fast", "user-friendly", "secure")
+- Missing details (no authentication method specified)
+- Conflicting requirements (need fast delivery but comprehensive features)
+- Unclear priorities (everything is "must-have")
+
+Prepare questions to resolve these in next step.
+
+### 8. Structure into YAML
+Organize extracted requirements into structured format:
+- Group related requirements
+- Number each requirement for reference
+- Add notes for assumptions or uncertainties
+- Mark requirements as explicit (user stated) vs. inferred
+
+### 9. Calculate Extraction Confidence
+Assess confidence (0-100) based on:
+- Completeness (all categories populated)
+- Clarity (requirements are specific vs. vague)
+- Consistency (no conflicts)
+- Sufficiency (enough detail to proceed)
+
+### 10. Generate Clarification Questions
+Create list of questions to ask user:
+- Fill gaps (missing categories)
+- Resolve ambiguities (vague requirements)
+- Prioritize (what's MVP vs. nice-to-have)
+- Validate assumptions (inferred requirements)
+
+## Decision Points
+- **Minimal Information**: If user provided <100 words, ask for more context before extracting
+- **Conflicting Requirements**: Flag immediately and ask for prioritization
+- **Regulated Industry**: If healthcare/finance/etc., ask about compliance needs upfront
+
+## Error Handling
+- **Empty Input**: Request user to provide project description
+- **Non-English Input**: Ask user to provide in English or request translation
+- **Multiple Projects**: Ask user to clarify which project to focus on
+- **Too Much Information**: Summarize and ask user to confirm understanding
+
+## Output Format
+```yaml
+# requirements-raw.yaml
+timestamp: 2026-02-13T13:00:00Z
+source: user_brain_dump
+
+functional_requirements:
+  - id: FR-001
+    requirement: User can register with email and password
+    actor: User
+    action: register
+    object: account
+    context: using email and password
+    source: explicit
+  - id: FR-002
+    requirement: User can create blog posts with title, content, tags, and images
+    actor: User
+    action: create
+    object: blog post
+    context: with title, content, tags, and images
+    source: explicit
+  - id: FR-003
+    requirement: System sends email confirmation after registration
+    actor: System
+    action: send email
+    object: confirmation
+    context: after user registration
+    source: inferred
+  - id: FR-004
+    requirement: Admin can moderate and delete inappropriate posts
+    actor: Admin
+    action: moderate and delete
+    object: posts
+    context: that violate community guidelines
+    source: explicit
+  - id: FR-005
+    requirement: Users can search posts by keyword, tag, or author
+    actor: User
+    action: search
+    object: posts
+    context: by keyword, tag, or author
+    source: explicit
+
+non_functional_requirements:
+  performance:
+    - id: NFR-001
+      requirement: Page load time must be under 2 seconds
+      category: performance
+      metric: page_load_time
+      target: <2s
+      source: explicit
+  scalability:
+    - id: NFR-002
+      requirement: Support 10,000 concurrent users
+      category: scalability
+      metric: concurrent_users
+      target: 10000
+      source: explicit
+  security:
+    - id: NFR-003
+      requirement: All data must be encrypted in transit and at rest
+      category: security
+      requirement_type: data_protection
+      source: inferred
+    - id: NFR-004
+      requirement: GDPR compliant for EU users
+      category: security
+      requirement_type: compliance
+      source: explicit
+  usability:
+    - id: NFR-005
+      requirement: Mobile responsive design for all pages
+      category: usability
+      requirement_type: compatibility
+      source: explicit
+
+constraints:
+  technical:
+    - id: C-001
+      constraint: Must integrate with existing WordPress blog via API
+      type: technical
+      impact: high
+      source: explicit
+  timeline:
+    - id: C-002
+      constraint: MVP must launch within 3 months
+      type: timeline
+      deadline: 2026-05-13
+      source: explicit
+  budget:
+    - id: C-003
+      constraint: Hosting budget is $200/month maximum
+      type: budget
+      limit: $200/month
+      source: explicit
+  team:
+    - id: C-004
+      constraint: Team of 2 developers, both familiar with React but not backend
+      type: team
+      size: 2
+      skills: [React]
+      gaps: [backend]
+      source: explicit
+
+personas:
+  - id: P-001
+    name: Content Creator
+    role: Blogger
+    goals:
+      - Write and publish blog posts easily
+      - Reach wide audience
+      - Engage with readers through comments
+    pain_points:
+      - Current platform is slow and buggy
+      - Difficult to format posts
+      - Limited analytics
+    technical_proficiency: intermediate
+    frequency: daily
+    priority: primary
+  - id: P-002
+    name: Site Administrator
+    role: Admin
+    goals:
+      - Maintain community standards
+      - Manage users and content
+      - Monitor site health
+    pain_points:
+      - Manual moderation is time-consuming
+      - No tools for bulk operations
+    technical_proficiency: expert
+    frequency: daily
+    priority: secondary
+  - id: P-003
+    name: Reader
+    role: Visitor
+    goals:
+      - Discover interesting content
+      - Easy reading experience
+      - Save favorite posts
+    pain_points:
+      - Hard to find relevant content
+      - Cluttered interface
+    technical_proficiency: novice
+    frequency: weekly
+    priority: primary
+
+success_criteria:
+  - id: SC-001
+    metric: User registrations
+    target: 1000 users in first month
+    category: business
+  - id: SC-002
+    metric: Page load time
+    target: <2 seconds average
+    category: technical
+  - id: SC-003
+    metric: User satisfaction
+    target: 4.5/5 rating
+    category: user
+  - id: SC-004
+    metric: Uptime
+    target: 99.5%
+    category: technical
+
+gaps_and_ambiguities:
+  - gap: Authentication method not specified (JWT, session, OAuth?)
+    severity: medium
+    question: What authentication method should we use?
+  - gap: Image upload limits not specified
+    severity: low
+    question: What are max image size and allowed formats?
+  - gap: Moderation workflow unclear
+    severity: medium
+    question: Should moderation be pre-publish or post-publish?
+  - gap: Search implementation not detailed
+    severity: low
+    question: Should search be full-text or simple keyword matching?
+  - gap: Priority unclear (all requirements presented as must-have)
+    severity: high
+    question: Which features are MVP vs. phase 2?
+
+assumptions:
+  - Assumed GDPR compliance needed (not explicitly stated but inferred from "EU users" mention)
+  - Assumed email confirmation needed for registration (standard practice)
+  - Assumed HTTPS for all connections (security best practice)
+  - Assumed data encryption at rest (security best practice)
+
+confidence: 78
+confidence_reasoning: |
+  Good functional requirements coverage (5 FRs). Non-functional requirements
+  present but some are vague. Personas identified. Major gap is prioritization
+  (MVP vs. future). Authentication details missing. Overall sufficient to proceed
+  to validation step where we'll fill gaps.
+
+clarification_questions:
+  - Which features are must-have for MVP vs. nice-to-have for later phases?
+  - What authentication method do you prefer (JWT, session-based, OAuth)?
+  - Should user content moderation be pre-publish (requires approval) or post-publish (published immediately)?
+  - What are the image upload constraints (max size, allowed formats)?
+  - Do you have an existing user base migrating from WordPress?
+  - What analytics are most important to track?
+
+next_steps:
+  - Validate completeness of requirements
+  - Ask clarification questions
+  - Prioritize requirements
+  - Map to MVP scope
+```