crewly 1.0.0

package/config/sops/developer/testing-requirements.md

@@ -0,0 +1,62 @@
+---
+id: dev-testing-requirements
+version: 1
+createdAt: 2026-01-29T00:00:00Z
+updatedAt: 2026-01-29T00:00:00Z
+createdBy: system
+role: developer
+category: testing
+priority: 9
+title: Testing Requirements
+description: Testing standards and requirements for all code
+triggers:
+  - test
+  - testing
+  - jest
+  - unit
+  - coverage
+tags:
+  - testing
+  - quality
+  - coverage
+---
+
+# Testing Requirements
+
+## What to Test
+
+1. **All public functions** - Every exported function needs tests
+2. **Edge cases** - Empty inputs, null values, boundaries
+3. **Error paths** - Verify errors are thrown correctly
+4. **Integration points** - Test service interactions
+
+## Test Structure
+
+```typescript
+describe('ComponentName', () => {
+  describe('methodName', () => {
+    it('should do X when given Y', () => {
+      // Arrange
+      const input = ...;
+
+      // Act
+      const result = methodName(input);
+
+      // Assert
+      expect(result).toBe(expected);
+    });
+  });
+});
+```
+
+## Test Quality
+
+- Descriptive test names
+- One assertion per test (usually)
+- No test interdependencies
+- Clean up after tests
+
+## Coverage Goals
+
+- Minimum 80% for new code
+- 100% for critical paths

package/config/sops/pm/progress-tracking.md

@@ -0,0 +1,57 @@
+---
+id: pm-progress-tracking
+version: 1
+createdAt: 2026-01-29T00:00:00Z
+updatedAt: 2026-01-29T00:00:00Z
+createdBy: system
+role: pm
+category: workflow
+priority: 8
+title: Progress Tracking
+description: How to track and report task progress
+triggers:
+  - progress
+  - status
+  - update
+  - tracking
+  - report
+tags:
+  - tracking
+  - reporting
+  - status
+---
+
+# Progress Tracking
+
+## Check-in Frequency
+
+- **Active tasks**: Every 30 minutes
+- **Blocked tasks**: Immediately
+- **Completed tasks**: On completion
+
+## Status Updates
+
+Use `report_progress` tool with:
+- Current progress percentage
+- Completed items
+- Current work
+- Blockers (if any)
+- Next steps
+
+## Escalation Triggers
+
+Escalate when:
+- Task blocked for > 1 hour
+- Requirements unclear
+- Multiple attempts failed
+- Scope creep detected
+- Dependencies missing
+
+## Progress Reports
+
+Include:
+1. Overall status (on track / at risk / blocked)
+2. Completed items
+3. In-progress items
+4. Blockers and risks
+5. Help needed

package/config/sops/pm/task-decomposition.md

@@ -0,0 +1,59 @@
+---
+id: pm-task-decomposition
+version: 1
+createdAt: 2026-01-29T00:00:00Z
+updatedAt: 2026-01-29T00:00:00Z
+createdBy: system
+role: pm
+category: workflow
+priority: 10
+title: Task Decomposition
+description: How to break down large tasks into manageable subtasks
+triggers:
+  - task
+  - decompose
+  - break down
+  - story
+  - ticket
+tags:
+  - planning
+  - workflow
+  - tasks
+---
+
+# Task Decomposition
+
+## When to Decompose
+
+Break down tasks when:
+- Estimated time > 4 hours
+- Multiple components involved
+- Multiple people needed
+- Unclear scope
+
+## Decomposition Steps
+
+1. **Identify the goal** - What's the end result?
+2. **List deliverables** - What needs to be produced?
+3. **Identify dependencies** - What must happen first?
+4. **Create subtasks** - One per deliverable
+5. **Add acceptance criteria** - How do we know it's done?
+
+## Task Quality
+
+Each task should have:
+- Clear title (action verb + object)
+- Description with context
+- Acceptance criteria (checklist)
+- Estimated size (S/M/L)
+- Dependencies listed
+
+## Example
+
+**Bad:** "Build user feature"
+
+**Good:**
+- "Implement user registration API endpoint"
+- "Add user registration form component"
+- "Write tests for user registration flow"
+- "Add input validation for registration fields"

package/config/sops/qa/testing-procedures.md

@@ -0,0 +1,60 @@
+---
+id: qa-testing-procedures
+version: 1
+createdAt: 2026-01-29T00:00:00Z
+updatedAt: 2026-01-29T00:00:00Z
+createdBy: system
+role: qa
+category: testing
+priority: 10
+title: Testing Procedures
+description: Standard testing procedures for QA agents
+triggers:
+  - test
+  - verify
+  - validate
+  - qa
+  - quality
+tags:
+  - testing
+  - quality
+  - qa
+---
+
+# Testing Procedures
+
+## Review Process
+
+1. **Read requirements** - Understand acceptance criteria
+2. **Review code** - Check implementation approach
+3. **Run automated tests** - Verify tests pass
+4. **Manual testing** - Test edge cases
+5. **Document findings** - Report issues clearly
+
+## Test Cases
+
+For each feature, verify:
+- Happy path works
+- Error cases handled
+- Edge cases covered
+- Performance acceptable
+- Security considered
+
+## Bug Reporting
+
+Include:
+- Clear title
+- Steps to reproduce
+- Expected behavior
+- Actual behavior
+- Screenshots/logs
+- Environment details
+
+## Quality Gates
+
+Before approving:
+- [ ] All acceptance criteria met
+- [ ] Tests pass
+- [ ] No critical bugs
+- [ ] Code reviewed
+- [ ] Documentation updated

package/config/task_assignment/prompts/target-agent-assignment-prompt.md

@@ -0,0 +1,119 @@
+# Task Assignment Prompt (Target Agent)
+
+📋 **TASK ASSIGNMENT** - {taskTitle}
+
+**Project:** {projectName}
+**Path:** {projectPath}
+
+**Task Details:**
+- **ID:** {taskId}
+- **Title:** {taskTitle}
+- **Description:** {taskDescription}
+- **Priority:** {taskPriority}
+- **Milestone:** {taskMilestone}
+
+**Task File (Absolute Path):** `{absoluteTaskPath}`
+**DEBUG - Full Absolute Task Path:** `{absoluteTaskPath}`
+
+---
+
+## ASSIGNMENT INSTRUCTIONS
+
+**You are being assigned this task. You have two options:**
+
+### Option 1: Accept and Work on Task
+If you can handle this task, follow these steps:
+
+1. **Read the complete task requirements:**
+   ```
+   read_task({ absoluteTaskPath: '{absoluteTaskPath}' })
+   ```
+
+2. **Accept the task assignment:**
+   ```
+   accept_task({
+     absoluteTaskPath: '{absoluteTaskPath}',
+     sessionName: '{yourSessionName}'
+   })
+   ```
+
+3. **Complete the work** following exact deliverables and file locations specified in the task file
+
+4. **MANDATORY: Mark task as complete when finished:**
+   ```
+   complete_task({
+     absoluteTaskPath: '{absoluteTaskPath}',
+     sessionName: '{yourSessionName}'
+   })
+   ```
+   **⚠️ CRITICAL: You MUST call complete_task when you finish the work!**
+
+### Option 2: Delegate to Another Agent
+If you cannot handle this task (wrong skillset, overloaded, etc.), delegate it:
+
+1. **Read the task requirements first** to understand delegation needs:
+   ```
+   read_task({ absoluteTaskPath: '{absoluteTaskPath}' })
+   ```
+
+2. **Check available team members:**
+   ```
+   get_team_status()
+   ```
+
+3. **Delegate to appropriate team member:**
+   ```
+   assign_task({
+     absoluteTaskPath: '{absoluteTaskPath}',
+     targetSessionName: 'CHOSEN_TARGET_SESSION_NAME',
+     delegatedBy: '{yourSessionName}',
+     reason: 'Brief reason for delegation (e.g., "Backend task requires backend expertise")'
+   })
+   ```
+
+---
+
+## CRITICAL REQUIREMENTS
+
+- **READ THE ACTUAL TASK FILE** - Do not work from this summary alone
+- **ALWAYS accept OR delegate** - Do not ignore task assignments
+- **If delegating, choose wisely** - Select team members based on skills and availability
+- **No delegation loops** - Do not delegate back to the original assigner or previous delegators
+- **Track delegation chain** - The system will prevent infinite loops
+
+## DELEGATION GUIDELINES
+
+**When to delegate:**
+- Task requires skills outside your expertise
+- You are currently overloaded with high-priority work
+- Another team member is better suited for the task
+
+**How to choose delegation target:**
+- Match task requirements to team member skills
+- Consider current workload of potential targets
+- Prefer team members who are currently idle or have lower priority work
+- For backend tasks → delegate to backend developers
+- For frontend tasks → delegate to frontend developers
+- For design tasks → delegate to designers
+- For project management → delegate to TPMs
+
+**When NOT to delegate:**
+- Task matches your core skills and you have capacity
+- No other suitable team members are available
+- You have already been delegated this task (avoid loops)
+
+---
+
+## ASSIGNMENT CONTEXT
+
+**Assigned by:** {assignedBy}
+**Assignment timestamp:** {assignmentTimestamp}
+**Delegation chain:** {delegationChain}
+
+Please respond promptly with either acceptance or delegation.
+
+---
+
+## 🔔 FINAL REMINDER
+
+**IF YOU ACCEPT THIS TASK:** You MUST call `complete_task()` when you finish the work. Do not forget this step!

package/config/task_starters/build_e2e_test_plan_prompt.json

@@ -0,0 +1,51 @@
+{
+	"name": "Build E2E Test Plan",
+	"description": "Generate comprehensive E2E testing tasks based on user journey and project analysis",
+	"steps": [
+		{
+			"id": 1,
+			"name": "Analyze Project for E2E Testing Strategy",
+			"targetRole": "qa",
+			"delayMinutes": 3,
+			"prompt_file": "config/task_starters/prompts/e2e_test_plan_step1_build_tests.md"
+		},
+		{
+			"id": 2,
+			"name": "Generate Detailed E2E Test Implementation Plan",
+			"targetRole": "qa",
+			"delayMinutes": 5,
+			"prompt_file": "config/task_starters/prompts/e2e_test_plan_step2_run_tests.md"
+		}
+	],
+	"workflow": {
+		"step1": "Analyze project type and technology stack, select appropriate E2E testing framework",
+		"step2": "Create detailed test implementation plan with user journey mapping and technical architecture"
+	},
+	"expectedDeliverables": {
+		"prerequisites": ["User journey must exist in .crewly/specs/initial_user_journey.md"],
+		"step1": [
+			"Project type identification document",
+			"E2E testing technology recommendation with justification",
+			"Test strategy overview covering critical user paths"
+		],
+		"step2": [
+			"Detailed E2E test implementation plan",
+			"User journey to test case mapping",
+			"Technical architecture for test framework",
+			"CI/CD integration strategy",
+			"Test maintenance and execution procedures"
+		],
+		"quality_standards": [
+			"Technology selection justified by project analysis",
+			"Test strategy covers complete user experience",
+			"Implementation plan is detailed enough for autonomous execution",
+			"Error scenarios and edge cases addressed"
+		],
+		"notes": [
+			"QA should analyze actual project structure and specifications",
+			"Technology choice should be optimized for the specific project type",
+			"Tests should focus on user value, not just technical coverage",
+			"Implementation should be maintainable and reliable in CI/CD"
+		]
+	}
+}

package/config/task_starters/build_spec_prompt.json

@@ -0,0 +1,79 @@
+{
+	"name": "Build Project Specifications",
+	"description": "Step-by-step process to generate project specifications in three focused phases. These specifications will be used to create milestone-based tasks organized in open/in_progress/blocked/done folders.",
+	"steps": [
+		{
+			"id": 1,
+			"name": "Create Project Requirements Document",
+			"targetRole": "tpm",
+			"delayMinutes": 3,
+			"verification": {
+				"type": "files_exist",
+				"paths": [
+					"{PROJECT_PATH}/.crewly/specs",
+					"{PROJECT_PATH}/.crewly/specs/project.md"
+				]
+			},
+			"prompt_file": "config/task_starters/prompts/build_spec_step1_project_requirements.md"
+		},
+		{
+			"id": 2,
+			"name": "Create Technical Design Documentation",
+			"targetRole": "architect",
+			"delayMinutes": 6,
+			"conditional": "only_if_project_md_exists",
+			"verification": {
+				"type": "directory_contains_files",
+				"path": "{PROJECT_PATH}/.crewly/specs",
+				"min_files": 2,
+				"file_pattern": "*_design.md"
+			},
+			"prompt_file": "config/task_starters/prompts/build_spec_step2_technical_design.md"
+		},
+		{
+			"id": 3,
+			"name": "Create Integration & E2E Testing Plan",
+			"targetRole": "architect",
+			"delayMinutes": 4,
+			"conditional": "only_if_design_docs_exist",
+			"verification": {
+				"type": "files_exist",
+				"paths": ["{PROJECT_PATH}/.crewly/specs/integration_tests.md"]
+			},
+			"prompt_file": "config/task_starters/prompts/build_spec_step3_integration_testing.md"
+		}
+	],
+	"workflow": {
+		"step1": "Create comprehensive project requirements document (PRD)",
+		"step2": "Analyze requirements and create necessary technical design documents",
+		"step3": "Design comprehensive integration and E2E testing plan based on user journey, requirements and technical architecture"
+	},
+	"expectedDeliverables": {
+		"prerequisites": ["Team member must be selected before starting workflow"],
+		"step1": [
+			"project.md - Comprehensive Product Requirements Document (PRD)",
+			"Includes business requirements, functional specs, technical constraints, and success metrics"
+		],
+		"step2": [
+			"2-4 technical design documents based on project needs",
+			"Examples: frontend_design.md, backend_design.md, api_design.md, database_design.md",
+			"Each document includes architecture, implementation strategy, security, and performance considerations"
+		],
+		"step3": [
+			"integration_tests.md - Comprehensive integration and E2E testing plan",
+			"Covers user journey-based E2E tests, system integration, API, database, external system, performance, and security tests",
+			"Includes specific testing technology recommendations (Playwright, Cypress, etc.) and test automation strategy",
+			"TPM tmux session will evaluate and execute the testing plan"
+		],
+		"notes": [
+			"User selects appropriate team member before starting workflow",
+			"All steps send messages directly to selected team member's tmux session",
+			"Each step includes verification criteria to ensure quality and completeness",
+			"Steps are conditional - each depends on successful completion of the previous step",
+			"Selected team member analyzes project requirements and creates appropriate specifications",
+			"Workflow is streamlined into three focused phases for better organization and quality",
+			"These specifications enable the subsequent creation of milestone-based development tasks",
+			"The task creation workflow will organize tasks in milestone folders with open/in_progress/blocked/done subfolders"
+		]
+	}
+}

package/config/task_starters/build_tasks_prompt.json

@@ -0,0 +1,55 @@
+{
+	"name": "Build Project Tasks",
+	"description": "Complete process to generate detailed project tasks organized by milestone phases",
+	"steps": [
+		{
+			"id": 1,
+			"name": "Create Milestone Structure and Task Files",
+			"targetRole": "tpm",
+			"delayMinutes": 10,
+			"verification": {
+				"type": "milestone_subdirs_contain_files",
+				"path": "{PROJECT_PATH}/.crewly/tasks",
+				"min_files_per_subdir": 2,
+				"file_pattern": "*.md"
+			},
+			"prompt_file": "config/task_starters/prompts/build_tasks_step1_milestone_structure.md"
+		}
+	],
+	"workflow": {
+		"step1": "Complete task structure creation: Analyze specifications, create milestone directories, and populate with detailed task files"
+	},
+	"expectedDeliverables": {
+		"prerequisites": ["Project specifications must exist in .crewly/specs/ directory"],
+		"step1": [
+			"Feature-based milestone directories created under .crewly/tasks/",
+			"Directory naming: m[#]_[feature]_[platform] (e.g., m4_auth_backend, m5_auth_web, m6_auth_mobile)",
+			"5-15 feature-based milestone directories based on project complexity analysis",
+			"3-8 granular task files per milestone directory (maximum 4 hours per task)",
+			"Each task file includes: single-focused objective, scope boundaries, granular implementation steps, comprehensive testing plan, quality gates",
+			"Task files follow enhanced template for maximum granularity and developer success",
+			"Platform separation: backend, frontend, mobile, desktop, DevOps tasks in separate milestones",
+			"Feature isolation: authentication, payments, dashboard, notifications in separate milestone groups",
+			"Clear dependency mapping between milestones and individual tasks"
+		],
+		"quality_standards": [
+			"Tasks organized by features (authentication, payments, etc.) with platform separation",
+			"Maximum task size: 4 hours total implementation time",
+			"Each task has single responsibility and clear scope boundaries",
+			"Comprehensive testing plan included in every single task",
+			"Quality gates (build, lint, test, coverage) mandatory for every task",
+			"Dependencies between tasks clearly mapped and documented",
+			"Implementation steps broken into smallest possible increments",
+			"Platform-specific tasks properly separated and organized"
+		],
+		"notes": [
+			"This workflow assumes specifications already exist in .crewly/specs/",
+			"Milestone structure adapts to project features and platforms (5-15 milestones typical)",
+			"Single comprehensive step combines feature analysis, directory creation, and granular task generation",
+			"Tasks organized by: Feature Area > Platform > Individual Granular Tasks",
+			"Verification ensures both feature-based directory structure AND granular task files are created",
+			"Each task must be completable by a single developer in one focused work session",
+			"Testing requirements are integrated into every task, not separate milestones"
+		]
+	}
+}

package/config/task_starters/prompts/build_spec_step1_project_requirements.md

@@ -0,0 +1,120 @@
+PRODUCT REQUIREMENTS DOCUMENT - STEP 1
+
+You are a **senior product manager + UX researcher**. Using the inputs below, generate a complete **`project.md` Product Requirements Document** that emphasizes business/user detail and only includes **non-binding, high-level technical expectations** (no implementation specifics).
+
+**Inputs:**
+Project: {PROJECT_NAME}
+Path: {PROJECT_PATH}
+
+PROJECT GOAL:
+{INITIAL_GOAL}
+
+USER JOURNEY:
+{USER_JOURNEY}
+
+## Task: Create Product Requirements Document (PRD)
+
+### Step 1: Directory Setup
+
+Create the specifications directory:
+
+```bash
+mkdir -p {PROJECT_PATH}/.crewly/specs
+```
+
+### Step 2: Create project.md
+
+Create a comprehensive Product Requirements Document at: `{PROJECT_PATH}/.crewly/specs/project.md`
+
+**Required `project.md` structure and quality bar (business/user–first):**
+
+```markdown
+# {PROJECT_NAME} - Product Requirements Document
+
+## Project Overview
+
+-   One-paragraph description & purpose (tie directly to INITIAL_GOAL).
+-   Business context (market, problem framing) in 3 bullets.
+-   Target audience & primary personas (2–3) with goals, frustrations, motivations.
+-   Jobs-To-Be-Done (3–5 “When I…, I want…, so I can…”).
+-   Stakeholders & roles (R/A/C/I bullets).
+-   Key objectives (3–5 SMART) with baseline → target.
+-   Assumptions (TBD) & known constraints (non-technical).
+
+## Business Requirements
+
+-   Problem statements (top 3) with evidence signals.
+-   Value proposition & differentiation (why now / why us).
+-   User needs & pain points → mapped to features (table):
+    | Need/Pain | Feature/Capability | Outcome Metric |
+-   Success criteria & KPIs (quantified, time-bound, tied to Objectives).
+
+## Functional Requirements
+
+-   Capabilities using **MoSCoW** with rationale (Must/Should/Could/Won’t).
+-   **User Stories Table** (≥8 rows):
+    | ID | As a | I want | So that | Priority | Acceptance Criteria (G/W/T x2+) |
+-   **Core Workflows** (3–4) as numbered steps; include empty/error state behavior.
+-   UX expectations: accessibility (WCAG 2.2 AA), internationalization/localization, empty states, progressive disclosure, error messaging tone.
+-   Edge cases & guardrails (at least 6).
+-   Data shown to users (fields, labels, sort/filter expectations) — no storage/DB details.
+
+## Non-Functional Requirements (User-Perceived)
+
+-   Performance: p95 page-to-interaction ≤ Xs; critical action p95 ≤ Ys; availability SLO presented as user impact.
+-   Privacy, consent, and data minimization (what users see/agree to).
+-   Security posture (authN/authZ at experience level, session patterns) — no vendor names.
+-   Reliability & degradation strategy (graceful fallbacks, offline/empty-state behavior).
+-   Accessibility specifics (keyboard flows, color contrast, focus order, ARIA where applicable).
+
+## Technical Expectations (Non-Binding, No Implementation Detail)
+
+-   Integration boundaries (systems touched, data in/out at a high level; example event names/properties for analytics).
+-   Tracking & measurement plan (events, properties, funnels, cohorts) without specifying tools.
+-   API expectations from a consumer perspective (idempotency, pagination, rate-limit user impact) — no protocol/library choices.
+-   Environments & release approach (beta, staged rollout, feature flags) — no CI/CD tooling.
+
+## Project Scope
+
+-   In-scope features & deliverables (testable bullets).
+-   Out-of-scope (explicit non-goals to prevent creep).
+-   Phasing & roadmap (Now / Next / Later with 3–5 bullets each).
+-   Dependencies (teams, approvals, legal, content).
+
+## Launch Plan (Business/User-Facing)
+
+-   Entry criteria for Beta/GA; exit gates tied to KPIs.
+-   Support model & SLAs (response/resolve times).
+-   Go-to-market notes (target segments, key messages, channels).
+-   Training & help content required (FAQs, tooltips, guides).
+
+## Risks & Mitigations
+
+-   Top risks with likelihood/impact, owner, mitigation/trigger points.
+
+## Open Questions & Decision Log
+
+-   Questions to resolve (owner, due date).
+-   Key decisions (decision, date, rationale).
+
+## Success Metrics
+
+-   Adoption: activation, conversion, weekly active % (targets & timeframe).
+-   Retention: Day 7/30 retention targets; leading indicator behaviors.
+-   Satisfaction: CSAT/NPS targets; qualitative feedback themes expected.
+-   Business impact: revenue/cost/risk reduction with baseline → target → measurement cadence.
+
+## Appendix
+
+-   Glossary of terms.
+-   Reference materials & discovery inputs (links/notes).
+```
+
+**Authoring rules:**
+
+-   **Do not** specify implementation details (e.g., programming languages, cloud vendors, database types, architectural diagrams).
+-   Keep everything framed in terms of **user outcomes** and **business impact**; any technical content must remain a **non-binding expectation**.
+-   Each KPI includes a target and timeframe (or mark **TBD**). Each user story has **≥2** Given/When/Then criteria.
+-   Use crisp, action-oriented language; bullets over paragraphs when possible.
+-   Final output must be exactly **two code blocks** (bash + markdown) with **no extra commentary**.
+    **Focus on creating a comprehensive PRD that captures all business and functional requirements based on the project goal and user journey provided above.**