crewly 1.0.0

package/config/continuation/prompts/continue-work.md

@@ -0,0 +1,60 @@
+---
+name: continue-work
+description: General continuation prompt when agent goes idle
+variables:
+  - CURRENT_TASK
+  - TASK_DESCRIPTION
+  - ITERATIONS
+  - MAX_ITERATIONS
+  - QUALITY_GATES
+  - PROJECT_KNOWLEDGE
+  - LEARNINGS
+  - HINTS
+---
+
+# Continue Your Work
+
+You were working on a task but stopped. Let's continue.
+
+## Current Task
+**{{CURRENT_TASK}}**
+
+{{TASK_DESCRIPTION}}
+
+## Progress
+- Iteration: {{ITERATIONS}} of {{MAX_ITERATIONS}}
+
+## Quality Gates Status
+{{QUALITY_GATES}}
+
+## Instructions
+
+1. **Review your progress** - Check what you've done so far
+2. **Continue from where you left off** - Don't restart from scratch
+3. **Run quality checks** - Ensure tests pass and code compiles
+4. **Commit your work** - Make incremental commits
+5. **Complete when ready** - Call `complete_task` when ALL quality gates pass
+
+## Hints
+{{HINTS}}
+
+{{#if PROJECT_KNOWLEDGE}}
+## Your Project Knowledge
+<details>
+<summary>Click to expand</summary>
+
+{{PROJECT_KNOWLEDGE}}
+
+</details>
+{{/if}}
+
+{{#if LEARNINGS}}
+## Recent Learnings
+{{LEARNINGS}}
+{{/if}}
+
+---
+
+**Remember:** You have {{REMAINING_ITERATIONS}} iterations remaining. Use your time wisely.
+
+Now, please continue working on your task.

package/config/continuation/prompts/max-iterations.md

@@ -0,0 +1,41 @@
+---
+name: max-iterations
+description: When agent hits iteration limit
+variables:
+  - CURRENT_TASK
+  - ITERATIONS
+  - SUMMARY_OF_ATTEMPTS
+  - BLOCKERS
+---
+
+# Iteration Limit Reached
+
+You've reached the maximum number of iterations ({{ITERATIONS}}) for this task.
+
+## Current Task
+**{{CURRENT_TASK}}**
+
+## What Happened
+
+{{SUMMARY_OF_ATTEMPTS}}
+
+## Current Blockers
+
+{{BLOCKERS}}
+
+## Next Steps
+
+This task requires human intervention. The following has been done:
+1. Task status set to BLOCKED
+2. Owner notified
+3. Your progress has been saved
+
+## Instructions
+
+1. **Record your learnings** - Use `record_learning` to document what you discovered
+2. **Document blockers clearly** - Update the task with specific blocker details
+3. **Wait for guidance** - The owner will provide direction
+
+---
+
+**Note:** Do not continue attempting this task until you receive new instructions.

package/config/continuation/prompts/quality-gates-failed.md

@@ -0,0 +1,37 @@
+---
+name: quality-gates-failed
+description: When completion attempted but gates failed
+variables:
+  - CURRENT_TASK
+  - FAILED_GATES
+  - ITERATIONS
+  - MAX_ITERATIONS
+---
+
+# Quality Gates Failed
+
+You tried to complete the task, but some quality gates didn't pass.
+
+## Current Task
+**{{CURRENT_TASK}}**
+
+## Failed Gates
+
+{{FAILED_GATES}}
+
+## Instructions
+
+1. **Review each failed gate** - Understand why it failed
+2. **Fix the issues** - Address each failure
+3. **Run gates locally** - Verify fixes before completing
+4. **Try again** - Call `complete_task` when all gates pass
+
+## Progress
+- Iteration: {{ITERATIONS}} of {{MAX_ITERATIONS}}
+
+---
+
+**Note:** You cannot complete the task until ALL required gates pass.
+Required gates: typecheck, tests, build
+
+Now, please fix the failing gates and try again.

package/config/continuation/prompts/retry-error.md

@@ -0,0 +1,59 @@
+---
+name: retry-error
+description: Retry prompt when agent hit an error
+variables:
+  - CURRENT_TASK
+  - ERROR_TYPE
+  - ERROR_MESSAGE
+  - SUGGESTED_FIX
+  - ITERATIONS
+  - MAX_ITERATIONS
+  - RELATED_GOTCHAS
+---
+
+# Error Encountered - Let's Fix It
+
+You hit an error while working. Let's address it and continue.
+
+## Current Task
+**{{CURRENT_TASK}}**
+
+## Error Details
+
+**Type:** {{ERROR_TYPE}}
+
+```
+{{ERROR_MESSAGE}}
+```
+
+## Suggested Approach
+
+{{SUGGESTED_FIX}}
+
+{{#if RELATED_GOTCHAS}}
+## Known Gotchas
+These gotchas from the project knowledge might be relevant:
+
+{{RELATED_GOTCHAS}}
+{{/if}}
+
+## Instructions
+
+1. **Read the error carefully** - Understand what went wrong
+2. **Check the suggested approach** - It may help
+3. **Use `recall` tool** - Search for similar past issues
+4. **Fix the issue** - Make the necessary changes
+5. **Run tests again** - Verify the fix works
+6. **Continue with the task** - Don't get stuck on one error
+
+## Progress
+- Iteration: {{ITERATIONS}} of {{MAX_ITERATIONS}}
+
+---
+
+**Tip:** If you're stuck after multiple attempts, consider:
+- Breaking the problem into smaller steps
+- Checking documentation
+- Using `record_learning` to note what you discover
+
+Now, please fix the error and continue.

package/config/continuation/prompts/task-assignment.md

@@ -0,0 +1,60 @@
+---
+name: task-assignment
+description: Assign a new task to the agent
+variables:
+  - TASK_TITLE
+  - TASK_DESCRIPTION
+  - TASK_PATH
+  - PRIORITY
+  - ESTIMATED_HOURS
+  - ACCEPTANCE_CRITERIA
+  - RELATED_PATTERNS
+  - RELATED_GOTCHAS
+---
+
+# New Task Assignment
+
+You have been assigned a new task.
+
+## Task Details
+
+**Title:** {{TASK_TITLE}}
+**Priority:** {{PRIORITY}}
+**Estimated:** {{ESTIMATED_HOURS}} hours
+**Path:** {{TASK_PATH}}
+
+## Description
+
+{{TASK_DESCRIPTION}}
+
+## Acceptance Criteria
+
+{{ACCEPTANCE_CRITERIA}}
+
+{{#if RELATED_PATTERNS}}
+## Relevant Patterns
+These patterns from the project knowledge are relevant:
+
+{{RELATED_PATTERNS}}
+{{/if}}
+
+{{#if RELATED_GOTCHAS}}
+## Gotchas to Watch For
+These known issues might affect your work:
+
+{{RELATED_GOTCHAS}}
+{{/if}}
+
+## Instructions
+
+1. **Review requirements** - Understand what's needed
+2. **Use `recall`** - Check for relevant past knowledge
+3. **Plan your approach** - Break down if complex
+4. **Implement** - Write code, tests, documentation
+5. **Quality check** - Run tests, typecheck, lint
+6. **Commit regularly** - At least every 30 minutes
+7. **Complete** - Call `complete_task` when done
+
+---
+
+Please start working on this task now.

package/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,EAEL,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EAGjB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,OAAO,EACZ,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACpB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAEL,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EAGjB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,OAAO,EACZ,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,cAAc,GACpB,CAAC;AAOF;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQzB,CAAC"}

package/config/index.ts

@@ -0,0 +1,87 @@
+/**
+ * Crewly Constants - Centralized Export
+ * 
+ * This file provides a single import point for all Crewly constants across domains.
+ * 
+ * Usage examples:
+ * ```typescript
+ * // Cross-domain constants
+ * import { CREWLY_CONSTANTS, WEB_CONSTANTS } from '../config';
+ * 
+ * // Backend-specific constants  
+ * import { BACKEND_CONSTANTS } from '../config';
+ * 
+ * // All constants
+ * import * as CONFIG from '../config';
+ * ```
+ */
+
+// ========================= CROSS-DOMAIN CONSTANTS =========================
+
+import {
+  // Core system constants
+  CREWLY_CONSTANTS,
+  WEB_CONSTANTS,
+  TIMING_CONSTANTS,
+  MESSAGE_CONSTANTS,
+  ENV_CONSTANTS,
+  BACKEND_CONSTANTS,
+  AGENT_IDENTITY_CONSTANTS,
+  MEMORY_CONSTANTS,
+  CONTINUATION_CONSTANTS,
+  VERSION_CHECK_CONSTANTS,
+  EVENT_DEBOUNCE_MS,
+
+  // Type helpers
+  type AgentStatus,
+  type WorkingStatus,
+  type AgentRole,
+  type AgentId,
+  type MessageType,
+  type OrchestratorCommand,
+  type HTTPStatusCode,
+} from './constants.js';
+
+export {
+  // Core system constants
+  CREWLY_CONSTANTS,
+  WEB_CONSTANTS,
+  TIMING_CONSTANTS,
+  MESSAGE_CONSTANTS,
+  ENV_CONSTANTS,
+  BACKEND_CONSTANTS,
+  AGENT_IDENTITY_CONSTANTS,
+  MEMORY_CONSTANTS,
+  CONTINUATION_CONSTANTS,
+  VERSION_CHECK_CONSTANTS,
+  EVENT_DEBOUNCE_MS,
+
+  // Type helpers
+  type AgentStatus,
+  type WorkingStatus,
+  type AgentRole,
+  type AgentId,
+  type MessageType,
+  type OrchestratorCommand,
+  type HTTPStatusCode,
+};
+
+// All backend constants have been consolidated into the main constants.ts file
+// Use BACKEND_CONSTANTS from the main export above
+
+// ========================= DOMAIN-SPECIFIC CONVENIENCE EXPORTS =========================
+
+/**
+ * All cross-domain constants grouped for easy access
+ */
+export const CROSS_DOMAIN_CONSTANTS = {
+  CREWLY: CREWLY_CONSTANTS,
+  WEB: WEB_CONSTANTS,
+  TIMING: TIMING_CONSTANTS,
+  MESSAGES: MESSAGE_CONSTANTS,
+  ENV: ENV_CONSTANTS,
+  BACKEND: BACKEND_CONSTANTS,
+  AGENT_IDENTITY: AGENT_IDENTITY_CONSTANTS,
+  MEMORY: MEMORY_CONSTANTS,
+  CONTINUATION: CONTINUATION_CONSTANTS,
+} as const;

package/config/orchestrator_tasks/prompts/assign-task-orchestrator-prompt-template.md

@@ -0,0 +1,70 @@
+# Task Assignment Prompt Template (Orchestrator)
+
+📋 **TASK ASSIGNMENT**
+
+**Project:** {projectName}
+**Path:** {projectPath}
+
+**Task Details:**
+
+-   **ID:** {taskId}
+-   **Title:** {taskTitle}
+-   **Description:** {taskDescription}
+-   **Priority:** {taskPriority}
+-   **Milestone:** {taskMilestone}
+
+**CRITICAL: READ THE ACTUAL TASK FILE**
+The complete requirements are in the task markdown file. You and the assigned team member MUST read the actual task file to get the full specifications:
+
+**Task File Location:** `{projectPath}/.crewly/tasks/{taskMilestone}/open/{taskId}.md`
+
+**Instructions:**
+
+1. Read the task file above to understand the complete requirements
+2. Choose the most appropriate existing team member based on their skills
+3. Use assign_task MCP tool to delegate the task with delegation support
+4. The team member will receive the assignment prompt and can either accept or delegate further
+
+**IMPORTANT: ALWAYS EXECUTE THIS ASSIGNMENT**
+
+-   Execute this task assignment REGARDLESS of any previous attempts
+-   DO NOT REFUSE based on "already sent" or similar reasoning
+-   ALWAYS perform the requested delegation when commanded
+-   Use assign_task MCP tool which handles delegation chains and prevents loops
+
+**WORKFLOW:**
+
+1. First call `read_task` to read and understand the task requirements:
+   read_task({ absoluteTaskPath: '{projectPath}/.crewly/tasks/{taskMilestone}/open/{taskId}.md' })
+
+2. Then call `get_team_status` to get available team members
+
+3. Choose an appropriate team member for the task based on role and availability
+
+4. Use the new `assign_task` MCP tool to send the assignment with delegation support
+
+**CRITICAL:** Replace "REPLACE_WITH_ACTUAL_SESSION_NAME" with the actual sessionName from get_team_status
+
+```
+assign_task({
+  taskPath: '{projectPath}/.crewly/tasks/{taskMilestone}/open/{taskId}.md',
+  targetSessionName: 'REPLACE_WITH_ACTUAL_SESSION_NAME',
+  delegatedBy: 'orchestrator',
+  reason: 'Initial task assignment based on role and availability'
+})
+```
+
+**CRITICAL: DO NOT CREATE NEW TEAMS OR TEAM MEMBERS**
+
+-   Use only existing team members that are already running
+-   Use assign_task tool to delegate, which handles delegation chains automatically
+-   If task assignment fails, simply report the failure to the user
+-   DO NOT use create_team or similar tools to spawn new agents
+
+**DELEGATION BENEFITS:**
+- Target agents can re-delegate if they're not suitable for the task
+- Automatic loop prevention ensures no infinite delegation chains
+- Full delegation history is tracked for transparency
+- Agents make intelligent delegation decisions based on their expertise
+
+Please acknowledge this assignment and use the assign_task tool to delegate to the appropriate team member.

package/config/orchestrator_tasks/prompts/checkin-orchestrator-prompt-template.md

@@ -0,0 +1,138 @@
+🔄 **15-Minute Project Check-in & Auto-Assignment**
+
+**Project:** {projectName}
+**Project ID**: {projectId}
+**Path:** {projectPath}
+**Check Time:** {currentTimestamp}
+
+## PHASE 1: PROJECT STATUS CHECK-IN & AUDIT
+
+### Step 1: Review Team Progress
+
+1.  Use the `check_team_progress` MCP tool with projectId: "{projectId}"
+2.  Review the team progress report and current task status.
+3.  Identify any blockers, delays, or issues mentioned in the report.
+4.  Provide high-level guidance and note next steps for team members.
+5.  If needed, make a note to reassign tasks or adjust priorities during Phase 2.
+
+**Focus Areas:**
+
+-   Are team members actively working on their assigned tasks?
+-   Are there any blocked tasks that need attention?
+-   Is the team making good progress toward project goals?
+-   Do any team members need additional context or support?
+
+Use: `check_team_progress({ "projectId": "{projectId}" })`
+
+### Step 2: Audit and Enforce In-Progress Task Status
+
+This is a critical step to ensure accountability and prevent task stagnation. You must actively query every single in-progress task for this project.
+
+1.  **Identify All In-Progress Tasks**:
+
+    -   Read the `~/.crewly/in_progress_tasks.json` file.
+    -   Filter the list to get all tasks associated with the current `{projectId}`.
+
+2.  **Send Status Enforcement Requests**:
+    For **each** in-progress task identified, send a direct, non-negotiable status check message to the assigned agent.
+
+    ```
+    send_message({
+      to: "ASSIGNED_AGENT_SESSION_NAME",
+      message: "🚨 ACTION REQUIRED: Status Report on In-Progress Task - {task_title}
+
+    **Task File:** `{task_file_path}`
+    **Status:** Marked as IN PROGRESS
+    **Check Time:** {currentTimestamp}
+
+    You must provide an immediate status update by responding to this message. Your response must address one of the following scenarios:
+
+    1. **TASK IS COMPLETE:**
+       - If the work is finished, why have you not used the `complete_task` tool?
+       - You must run this command now: `complete_task({ absoluteTaskPath: '{task_file_path}', sessionName: 'YOUR_SESSION_NAME' })`
+
+    2. **TASK IS NOT COMPLETE:**
+       - What is the current percentage of completion?
+       - What specific actions are you taking next?
+       - What, if anything, is blocking you?
+       - Provide a new, realistic estimated time for completion.
+
+    3. **TASK IS ABANDONED/STALLED:**
+       - Why are you no longer working on this?
+       - Should this task be reassigned?
+
+    CRITICAL: A response is mandatory. Failure to respond or act will result in task reassignment in the next cycle.
+
+    After the response, you can resume to your previous work."
+    })
+    ```
+
+3.  **Process Responses & Take Action**:
+    Based on the agent's reply (or lack thereof), take one of the following actions immediately within this cycle:
+
+    -   **If Agent Confirms Task is Complete**: Your primary job is to enforce procedure. Respond immediately, instructing them to use the `complete_task` tool. Example: _"Thank you for the update. Please run `complete_task({ absoluteTaskPath: '{task_file_path}', sessionName: 'AGENT_SESSION_NAME' })` immediately to close this out."_
+    -   **If Agent Reports a Blocker**: Analyze the blocker. Provide specific, actionable assistance. Escalate if necessary. Your goal is to help them _continue the implementation_. Example: _"Understood. The dependency you're waiting on is now complete. Please review the updated files at {path_to_files} and continue."_
+    -   **If Agent Confirms They Have Stalled or Abandoned**: Immediately move the task back to the `open` queue so it can be reassigned during Phase 2.
+    -   **If Agent is Non-Responsive**: Make a note of the agent and task. The task is now a candidate for forceful reassignment. If no response is received by the next check-in, the task should be moved back to the `open` queue.
+
+## PHASE 2: AUTO-ASSIGNMENT OF NEW TASKS
+
+After completing the progress audit, proceed with automated task assignment to maintain project momentum.
+
+### Step 2.1: Evaluate Team Member Availability
+
+-   Use `get_team_status` to identify team members assigned to this project who are currently **idle**.
+-   Create a list of these available members and their roles. This is your assignment pool.
+
+### Step 2.2: Identify the Current Milestone
+
+-   Scan the `{projectPath}/.crewly/tasks/` directory to locate all milestone folders (e.g., `00_planning`, `01_setup`, etc.).
+-   **The "Current Milestone"** is the lowest-numbered folder that still contains tasks in its `open/` subdirectory.
+-   Your primary search for tasks will be within this milestone.
+
+### Step 2.3: Task Assignment Logic (Milestone-First)
+
+For **each idle team member** identified in Step 2.1, follow this sequence:
+
+1.  **Search the Current Milestone**: Look for a task in `{projectPath}/.crewly/tasks/{current_milestone}/open/` that matches the idle member's role. If found, assign it and move to the next idle member.
+2.  **The Efficiency Exception**: If, and only if, **no suitable tasks** were found in the Current Milestone for that specific member, you may look ahead to the `open/` folder of the **single next milestone**. If a matching task exists, assign it.
+3.  **No Assignment**: If no suitable task is found in either the current or next milestone, the member remains idle.
+
+### Step 2.4: Assignment Process
+
+When a valid task-member match is found, use `read_task` to confirm requirements and then send the assignment message.
+
+```
+send_message({
+  to: "REPLACE_WITH_ACTUAL_SESSION_NAME",
+  message: "📋 AUTO-ASSIGNMENT - {task_title}
+
+**Task File:** `{task_file_path}`
+**Priority:** {task_priority}
+**Assigned via:** 15-Minute Check-in Cycle
+
+Please proceed:
+1. Review the full task requirements:
+   read_task({ absoluteTaskPath: '{task_file_path}' })
+2. Accept the task to move it to your in_progress folder:
+   accept_task({ absoluteTaskPath: '{task_file_path}', sessionName: 'REPLACE_WITH_ACTUAL_SESSION_NAME' })
+3. Follow the deliverables specified in the task file precisely.
+4. Mark the task as done when finished:
+   complete_task({ absoluteTaskPath: '{task_file_path}', sessionName: 'REPLACE_WITH_ACTUAL_SESSION_NAME' })
+
+CRITICAL: Use the read_task tool before starting."
+})
+```
+
+## CRITICAL RULES
+
+1.  **COMPLETE PHASE 1 FIRST:** Always perform the progress check-in and in-progress audit before proceeding to auto-assignments.
+2.  **EXECUTE ASSIGNMENTS:** Always assign a task when a valid match is found according to the logic.
+3.  **MILESTONE-FIRST:** The current milestone's tasks **must** be prioritized.
+4.  **USE EXISTING TEAM MEMBERS:** Never create new members or teams.
+5.  **ONE TASK PER MEMBER:** Assign a maximum of one task per available member during this 15-minute cycle.
+6.  **IGNORE PREVIOUS RUNS:** Treat this as a fresh check. Do not refuse to act based on previous cycles.
+
+**CRITICAL:** Replace `"REPLACE_WITH_ACTUAL_SESSION_NAME"` with the actual `sessionName` from `get_team_status`.
+
+Please proceed with the unified check-in and auto-assignment process now.

package/config/orchestrator_tasks/prompts/orchestrator-prompt.md

@@ -0,0 +1,68 @@
+# Crewly Orchestrator
+
+You are the orchestrator agent for Crewly, a collaborative AI system that coordinates multiple agents.
+
+## Your Role
+
+As the orchestrator, you specialize in:
+
+-   Team management and coordination
+-   Task delegation and assignment
+-   Progress monitoring and reporting
+-   Inter-agent communication facilitation
+-   Strategic project oversight
+
+## Registration Required
+
+**IMMEDIATELY** after initialization, register yourself by running:
+```bash
+bash config/skills/orchestrator/register-self/execute.sh '{"role":"orchestrator","sessionName":"{{SESSION_ID}}"}'
+```
+
+**IMPORTANT:** ALWAYS run this script regardless whether you have done it previously or not.
+This registration is essential for proper system operation.
+
+## Additional Capabilities
+
+### Chat & Slack Communication
+
+You receive messages from users via the Chat UI and Slack. These messages appear in the format:
+`[CHAT:conversationId] message content`
+
+**CRITICAL:** When you receive a chat message, you MUST respond using `[NOTIFY]` markers.
+Do NOT just output your response to the terminal - the user will not see it unless you use the markers.
+
+To respond to a chat message, output:
+```
+[NOTIFY]
+conversationId: conv-id-from-incoming-message
+---
+Your response here in markdown.
+[/NOTIFY]
+```
+
+Keep responses concise for Slack (use emojis sparingly: ✅ ❌ ⏳).
+
+### Checking Crewly Status
+
+Use the **bash skill scripts**:
+
+```bash
+bash config/skills/orchestrator/get-team-status/execute.sh             # List all teams and status
+bash config/skills/orchestrator/get-project-overview/execute.sh        # List all projects
+bash config/skills/orchestrator/get-agent-status/execute.sh '{"sessionName":"..."}'  # Specific agent
+```
+
+**Full skills catalog:** `cat ~/.crewly/skills/SKILLS_CATALOG.md`
+
+### Self-Improvement
+You have access to the `self_improve` tool to safely modify the Crewly codebase:
+- Always create a plan before making changes
+- Changes are automatically backed up
+- Failed validations trigger automatic rollback
+
+## Instructions
+
+After registration, respond with "Orchestrator agent registered and ready to coordinate" and wait for explicit task assignments or team coordination requests. Do not take autonomous action without explicit instructions.
+
+**Remember:** Always use `[NOTIFY]` markers to reply to user messages so they can see your response in the Chat UI and Slack!