crewly 1.0.0

package/config/orchestrator_tasks/prompts/project-start-orchestrator-prompt-template.md

@@ -0,0 +1,104 @@
+🚀 **Project Orchestrator v2.1: Milestone & Accountability Driven**
+
+**Project:** `{projectName}`
+**Project Path:** `{projectPath}`
+**Teams Assigned:** `{teamName}` ({teamMemberCount} members)
+**Status:** ACTIVE - Awaiting your coordination.
+
+Your primary goal is to manage this project by ensuring active tasks are progressing and new tasks are assigned efficiently, **one milestone at a time**.
+
+---
+
+## PHASE 1: STATUS AUDIT & ACCOUNTABILITY
+
+Before assigning any new tasks, you must first audit all work currently in progress. This prevents task abandonment and clarifies which team members are truly available.
+
+### Step 1.1: Audit All In-Progress Tasks
+
+1.  **Identify In-Progress Tasks**:
+
+    -   Read the `~/.crewly/in_progress_tasks.json` file to identify all tasks currently marked as in-progress for this project.
+
+2.  **Send Status Enforcement Requests**:
+
+    -   For **each** in-progress task, send the following status check message to the assigned agent.
+
+    <!-- end list -->
+
+    ```
+    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}
+
+    Provide an immediate status update by responding to this message:
+
+    1. **If TASK IS COMPLETE:**
+       - You must run this command now: `complete_task({ absoluteTaskPath: '{task_file_path}', sessionName: 'YOUR_SESSION_NAME' })`
+       - Confirm why you had not already marked it as complete.
+
+    2. **If TASK IS NOT COMPLETE:**
+       - What is your current percentage of completion?
+       - What are your immediate next steps?
+       - Are you blocked? If so, by what?
+       - Provide a new estimated completion time.
+
+    CRITICAL: A response is mandatory. Your status determines the next set of task assignments for the team."
+    })
+    ```
+
+3.  **Process Responses & Take Action**:
+
+    -   **Task Complete**: Instruct the agent to run the `complete_task` tool immediately.
+    -   **Task Blocked**: Provide specific help to unblock the agent or make a note to assign a supporting task.
+    -   **Task Stalled/Abandoned**: Move the task back to the `open/` queue for reassignment in Phase 2.
+    -   **Agent Non-Responsive**: Flag the agent. Their task is now a candidate for forceful reassignment.
+
+---
+
+## PHASE 2: MILESTONE-DRIVEN NEW TASK ASSIGNMENT
+
+After auditing active work, proceed with assigning new tasks from the current milestone.
+
+### Step 2.1: Identify and Focus on the Current Milestone
+
+-   **PRIORITY**: Scan the `{projectPath}/.crewly/tasks/` directory.
+-   **The "Current Milestone"** is the lowest-numbered folder (e.g., `00_*`, `01_*`, etc.) that contains any tasks in its `open/` subdirectory.
+-   All new assignments will focus on this milestone.
+
+### Step 2.2: Assign All Open Tasks in the Current Milestone
+
+-   **GOAL**: Empty the `open/` folder of the **current milestone**.
+-   Use `get_agent_status` to find team members who are now **idle** (after the Phase 1 audit).
+-   Read each `.md` task file in the current milestone's `open/` folder.
+-   Assign each task to an available team member with the appropriate role.
+
+### Step 2.3: The Efficiency Exception for Advancing
+
+-   **PRIMARY RULE**: You will only focus on the next milestone after all tasks in the current milestone's `open/` folder have been assigned.
+-   **⚠️ EXCEPTION**:
+    -   **Condition**: If the current milestone has no more open tasks for a specific role (e.g., a Dev), but an agent with that role is idle...
+    -   **Action**: You are authorized to **look ahead** to the _very next_ milestone's `open/` folder. If a matching task exists there, assign it to the idle agent to prevent downtime.
+
+---
+
+## 📋 **Updated Coordination Workflow**
+
+1.  **Audit In-Progress Work (Phase 1)**: First, check the status of all tasks currently in progress. Drive them toward completion or move them back to the open queue.
+2.  **Identify Current Milestone (Phase 2)**: Find the lowest-numbered milestone folder with tasks in `open/`.
+3.  **Check True Team Availability**: Use `get_agent_status` to find agents confirmed to be idle after the audit.
+4.  **Assign Current Milestone Tasks**: Assign all open tasks from the current milestone.
+5.  **Apply Exception (If Applicable)**: If an agent is still idle, check the _next_ milestone for a matching task for them.
+6.  **Monitor & Repeat**: Continuously repeat this two-phase cycle to ensure constant progress.
+
+## ⚠️ **CRITICAL INSTRUCTIONS**
+
+-   **AUDIT FIRST**: Always complete the Phase 1 status audit before assigning new tasks in Phase 2.
+-   **MILESTONE-FIRST FOCUS**: Always clear the current milestone's open tasks before formally moving to the next.
+-   **PREVENT AGENT IDLENESS**: Use the lookahead exception to keep team members productive, but do not assign tasks more than one milestone ahead.
+-   **BE SPECIFIC IN ASSIGNMENTS**: Always include the full and exact task file path and clear instructions in your messages.
+
+**⚡ START COORDINATION NOW - The project's progress depends on your efficient, milestone-focused leadership\!**

package/config/quality-gates/default-gates.test.ts

@@ -0,0 +1,246 @@
+/**
+ * Tests for Default Quality Gate Configuration
+ *
+ * @module config/quality-gates/default-gates.test
+ */
+
+// Jest globals (describe, it, expect) are available automatically
+import {
+  DEFAULT_GATES,
+  MINIMAL_GATES,
+  FULL_GATES,
+  DEFAULT_SETTINGS,
+  DEFAULT_REQUIRED_GATES,
+  DEFAULT_OPTIONAL_GATES,
+  TYPECHECK_GATE,
+  TESTS_GATE,
+  BUILD_GATE,
+  LINT_GATE,
+  COVERAGE_GATE,
+  createGateConfig,
+  createGate,
+} from './default-gates.js';
+import { GATE_TIMEOUTS, STANDARD_GATES } from '../../backend/src/types/quality-gate.types.js';
+
+describe('Default Quality Gate Configuration', () => {
+  describe('DEFAULT_SETTINGS', () => {
+    it('should have correct default settings', () => {
+      expect(DEFAULT_SETTINGS.runInParallel).toBe(false);
+      expect(DEFAULT_SETTINGS.stopOnFirstFailure).toBe(false);
+      expect(DEFAULT_SETTINGS.timeout).toBe(GATE_TIMEOUTS.TOTAL);
+    });
+  });
+
+  describe('Individual Gates', () => {
+    describe('TYPECHECK_GATE', () => {
+      it('should be correctly configured', () => {
+        expect(TYPECHECK_GATE.name).toBe(STANDARD_GATES.TYPECHECK);
+        expect(TYPECHECK_GATE.command).toBe('npm run typecheck');
+        expect(TYPECHECK_GATE.timeout).toBe(GATE_TIMEOUTS.TYPECHECK);
+        expect(TYPECHECK_GATE.required).toBe(true);
+        expect(TYPECHECK_GATE.description).toBe('TypeScript compilation check');
+      });
+    });
+
+    describe('TESTS_GATE', () => {
+      it('should be correctly configured', () => {
+        expect(TESTS_GATE.name).toBe(STANDARD_GATES.TESTS);
+        expect(TESTS_GATE.command).toBe('npm test -- --passWithNoTests');
+        expect(TESTS_GATE.timeout).toBe(GATE_TIMEOUTS.TESTS);
+        expect(TESTS_GATE.required).toBe(true);
+        expect(TESTS_GATE.env).toEqual({ CI: 'true' });
+      });
+    });
+
+    describe('BUILD_GATE', () => {
+      it('should be correctly configured', () => {
+        expect(BUILD_GATE.name).toBe(STANDARD_GATES.BUILD);
+        expect(BUILD_GATE.command).toBe('npm run build');
+        expect(BUILD_GATE.timeout).toBe(GATE_TIMEOUTS.BUILD);
+        expect(BUILD_GATE.required).toBe(true);
+      });
+    });
+
+    describe('LINT_GATE', () => {
+      it('should be correctly configured as optional', () => {
+        expect(LINT_GATE.name).toBe(STANDARD_GATES.LINT);
+        expect(LINT_GATE.command).toBe('npm run lint');
+        expect(LINT_GATE.timeout).toBe(GATE_TIMEOUTS.LINT);
+        expect(LINT_GATE.required).toBe(false);
+        expect(LINT_GATE.allowFailure).toBe(true);
+      });
+    });
+
+    describe('COVERAGE_GATE', () => {
+      it('should be correctly configured with thresholds', () => {
+        expect(COVERAGE_GATE.name).toBe(STANDARD_GATES.COVERAGE);
+        expect(COVERAGE_GATE.required).toBe(false);
+        expect(COVERAGE_GATE.threshold).toEqual({
+          lines: 80,
+          branches: 70,
+          functions: 80,
+          statements: 80,
+        });
+      });
+    });
+  });
+
+  describe('Gate Arrays', () => {
+    describe('DEFAULT_REQUIRED_GATES', () => {
+      it('should contain typecheck, tests, and build', () => {
+        expect(DEFAULT_REQUIRED_GATES).toHaveLength(3);
+        expect(DEFAULT_REQUIRED_GATES.map(g => g.name)).toEqual([
+          'typecheck',
+          'tests',
+          'build',
+        ]);
+      });
+
+      it('should all be marked as required', () => {
+        expect(DEFAULT_REQUIRED_GATES.every(g => g.required)).toBe(true);
+      });
+    });
+
+    describe('DEFAULT_OPTIONAL_GATES', () => {
+      it('should contain lint gate', () => {
+        expect(DEFAULT_OPTIONAL_GATES).toHaveLength(1);
+        expect(DEFAULT_OPTIONAL_GATES[0].name).toBe('lint');
+      });
+
+      it('should all be marked as not required', () => {
+        expect(DEFAULT_OPTIONAL_GATES.every(g => !g.required)).toBe(true);
+      });
+    });
+  });
+
+  describe('Gate Configurations', () => {
+    describe('DEFAULT_GATES', () => {
+      it('should have default settings', () => {
+        expect(DEFAULT_GATES.settings).toEqual(DEFAULT_SETTINGS);
+      });
+
+      it('should have required gates', () => {
+        expect(DEFAULT_GATES.required).toEqual(DEFAULT_REQUIRED_GATES);
+      });
+
+      it('should have optional gates', () => {
+        expect(DEFAULT_GATES.optional).toEqual(DEFAULT_OPTIONAL_GATES);
+      });
+
+      it('should have empty custom gates', () => {
+        expect(DEFAULT_GATES.custom).toEqual([]);
+      });
+    });
+
+    describe('MINIMAL_GATES', () => {
+      it('should only have typecheck as required', () => {
+        expect(MINIMAL_GATES.required).toHaveLength(1);
+        expect(MINIMAL_GATES.required[0].name).toBe('typecheck');
+      });
+
+      it('should have no optional or custom gates', () => {
+        expect(MINIMAL_GATES.optional).toHaveLength(0);
+        expect(MINIMAL_GATES.custom).toHaveLength(0);
+      });
+    });
+
+    describe('FULL_GATES', () => {
+      it('should have extended timeout', () => {
+        expect(FULL_GATES.settings.timeout).toBe(GATE_TIMEOUTS.TOTAL * 2);
+      });
+
+      it('should have all required gates', () => {
+        expect(FULL_GATES.required).toHaveLength(3);
+      });
+
+      it('should have lint and coverage as optional', () => {
+        expect(FULL_GATES.optional).toHaveLength(2);
+        expect(FULL_GATES.optional.map(g => g.name)).toContain('lint');
+        expect(FULL_GATES.optional.map(g => g.name)).toContain('coverage');
+      });
+    });
+  });
+
+  describe('createGateConfig', () => {
+    it('should create config with defaults when no overrides', () => {
+      const config = createGateConfig({});
+      expect(config.settings).toEqual(DEFAULT_SETTINGS);
+      expect(config.required).toEqual(DEFAULT_REQUIRED_GATES);
+      expect(config.optional).toEqual(DEFAULT_OPTIONAL_GATES);
+      expect(config.custom).toEqual([]);
+    });
+
+    it('should override settings', () => {
+      const config = createGateConfig({
+        settings: {
+          runInParallel: true,
+          stopOnFirstFailure: true,
+          timeout: 600000,
+        },
+      });
+      expect(config.settings.runInParallel).toBe(true);
+      expect(config.settings.stopOnFirstFailure).toBe(true);
+      expect(config.settings.timeout).toBe(600000);
+    });
+
+    it('should override required gates', () => {
+      const customRequired = [TYPECHECK_GATE];
+      const config = createGateConfig({ required: customRequired });
+      expect(config.required).toEqual(customRequired);
+    });
+
+    it('should override optional gates', () => {
+      const config = createGateConfig({ optional: [] });
+      expect(config.optional).toEqual([]);
+    });
+
+    it('should add custom gates', () => {
+      const customGate = createGate('custom', 'npm run custom');
+      const config = createGateConfig({ custom: [customGate] });
+      expect(config.custom).toHaveLength(1);
+      expect(config.custom[0].name).toBe('custom');
+    });
+  });
+
+  describe('createGate', () => {
+    it('should create a gate with minimal options', () => {
+      const gate = createGate('test', 'npm test');
+      expect(gate.name).toBe('test');
+      expect(gate.command).toBe('npm test');
+      expect(gate.timeout).toBe(GATE_TIMEOUTS.DEFAULT);
+      expect(gate.required).toBe(false);
+    });
+
+    it('should create a gate with all options', () => {
+      const gate = createGate('coverage', 'npm run coverage', {
+        timeout: 180000,
+        required: true,
+        description: 'Coverage check',
+        allowFailure: false,
+        env: { CI: 'true' },
+        runOn: ['main'],
+        threshold: { lines: 90 },
+      });
+
+      expect(gate.name).toBe('coverage');
+      expect(gate.command).toBe('npm run coverage');
+      expect(gate.timeout).toBe(180000);
+      expect(gate.required).toBe(true);
+      expect(gate.description).toBe('Coverage check');
+      expect(gate.allowFailure).toBe(false);
+      expect(gate.env).toEqual({ CI: 'true' });
+      expect(gate.runOn).toEqual(['main']);
+      expect(gate.threshold).toEqual({ lines: 90 });
+    });
+
+    it('should use default timeout when not specified', () => {
+      const gate = createGate('lint', 'npm run lint');
+      expect(gate.timeout).toBe(GATE_TIMEOUTS.DEFAULT);
+    });
+
+    it('should default required to false', () => {
+      const gate = createGate('optional', 'npm run optional');
+      expect(gate.required).toBe(false);
+    });
+  });
+});

package/config/quality-gates/default-gates.ts

@@ -0,0 +1,191 @@
+/**
+ * Default Quality Gate Configuration
+ *
+ * Standard quality gates for TypeScript projects.
+ * Projects can override these by creating their own
+ * .crewly/config/quality-gates.yaml file.
+ *
+ * @module config/quality-gates/default-gates
+ */
+
+import {
+  GateConfig,
+  QualityGate,
+  GateSettings,
+  GATE_TIMEOUTS,
+  STANDARD_GATES,
+} from '../../backend/src/types/quality-gate.types.js';
+
+/**
+ * Default gate execution settings
+ */
+export const DEFAULT_SETTINGS: GateSettings = {
+  runInParallel: false,
+  stopOnFirstFailure: false,
+  timeout: GATE_TIMEOUTS.TOTAL,
+};
+
+/**
+ * Typecheck gate - validates TypeScript compilation
+ */
+export const TYPECHECK_GATE: QualityGate = {
+  name: STANDARD_GATES.TYPECHECK,
+  command: 'npm run typecheck',
+  timeout: GATE_TIMEOUTS.TYPECHECK,
+  required: true,
+  description: 'TypeScript compilation check',
+};
+
+/**
+ * Tests gate - runs unit tests
+ */
+export const TESTS_GATE: QualityGate = {
+  name: STANDARD_GATES.TESTS,
+  command: 'npm test -- --passWithNoTests',
+  timeout: GATE_TIMEOUTS.TESTS,
+  required: true,
+  description: 'Unit test execution',
+  env: {
+    CI: 'true',
+  },
+};
+
+/**
+ * Build gate - runs production build
+ */
+export const BUILD_GATE: QualityGate = {
+  name: STANDARD_GATES.BUILD,
+  command: 'npm run build',
+  timeout: GATE_TIMEOUTS.BUILD,
+  required: true,
+  description: 'Production build',
+};
+
+/**
+ * Lint gate - runs code linting (optional)
+ */
+export const LINT_GATE: QualityGate = {
+  name: STANDARD_GATES.LINT,
+  command: 'npm run lint',
+  timeout: GATE_TIMEOUTS.LINT,
+  required: false,
+  allowFailure: true,
+  description: 'Code linting',
+};
+
+/**
+ * Coverage gate - runs test coverage (optional)
+ */
+export const COVERAGE_GATE: QualityGate = {
+  name: STANDARD_GATES.COVERAGE,
+  command: 'npm run test:coverage',
+  timeout: GATE_TIMEOUTS.TESTS,
+  required: false,
+  description: 'Code coverage check',
+  threshold: {
+    lines: 80,
+    branches: 70,
+    functions: 80,
+    statements: 80,
+  },
+};
+
+/**
+ * Required gates that must pass for task completion
+ */
+export const DEFAULT_REQUIRED_GATES: QualityGate[] = [
+  TYPECHECK_GATE,
+  TESTS_GATE,
+  BUILD_GATE,
+];
+
+/**
+ * Optional gates that provide warnings but don't block
+ */
+export const DEFAULT_OPTIONAL_GATES: QualityGate[] = [
+  LINT_GATE,
+];
+
+/**
+ * Complete default gate configuration
+ */
+export const DEFAULT_GATES: GateConfig = {
+  settings: DEFAULT_SETTINGS,
+  required: DEFAULT_REQUIRED_GATES,
+  optional: DEFAULT_OPTIONAL_GATES,
+  custom: [],
+};
+
+/**
+ * Minimal gate configuration (typecheck only)
+ */
+export const MINIMAL_GATES: GateConfig = {
+  settings: DEFAULT_SETTINGS,
+  required: [TYPECHECK_GATE],
+  optional: [],
+  custom: [],
+};
+
+/**
+ * Full gate configuration (all standard gates)
+ */
+export const FULL_GATES: GateConfig = {
+  settings: {
+    ...DEFAULT_SETTINGS,
+    timeout: GATE_TIMEOUTS.TOTAL * 2, // 10 minutes for full suite
+  },
+  required: [
+    TYPECHECK_GATE,
+    TESTS_GATE,
+    BUILD_GATE,
+  ],
+  optional: [
+    LINT_GATE,
+    COVERAGE_GATE,
+  ],
+  custom: [],
+};
+
+/**
+ * Create a custom gate configuration
+ *
+ * @param overrides - Partial configuration to merge with defaults
+ * @returns Complete gate configuration
+ */
+export function createGateConfig(overrides: Partial<GateConfig>): GateConfig {
+  return {
+    settings: {
+      ...DEFAULT_SETTINGS,
+      ...overrides.settings,
+    },
+    required: overrides.required ?? DEFAULT_REQUIRED_GATES,
+    optional: overrides.optional ?? DEFAULT_OPTIONAL_GATES,
+    custom: overrides.custom ?? [],
+  };
+}
+
+/**
+ * Create a single gate with defaults
+ *
+ * @param name - Gate name
+ * @param command - Command to execute
+ * @param options - Additional gate options
+ * @returns Complete gate definition
+ */
+export function createGate(
+  name: string,
+  command: string,
+  options: Partial<Omit<QualityGate, 'name' | 'command'>> = {}
+): QualityGate {
+  return {
+    name,
+    command,
+    timeout: options.timeout ?? GATE_TIMEOUTS.DEFAULT,
+    required: options.required ?? false,
+    description: options.description,
+    allowFailure: options.allowFailure,
+    env: options.env,
+    runOn: options.runOn,
+    threshold: options.threshold,
+  };
+}

package/config/quality-gates/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Quality Gate Configuration Exports
+ *
+ * @module config/quality-gates
+ */
+
+export {
+  DEFAULT_GATES,
+  MINIMAL_GATES,
+  FULL_GATES,
+  DEFAULT_SETTINGS,
+  DEFAULT_REQUIRED_GATES,
+  DEFAULT_OPTIONAL_GATES,
+  TYPECHECK_GATE,
+  TESTS_GATE,
+  BUILD_GATE,
+  LINT_GATE,
+  COVERAGE_GATE,
+  createGateConfig,
+  createGate,
+} from './default-gates.js';

package/config/roles/_common/memory-instructions.md

@@ -0,0 +1,56 @@
+## Memory Management — Build Your Knowledge Over Time
+
+You have MCP tools that let you store and retrieve knowledge that persists across sessions. **Use them proactively** — they make you more effective over time.
+
+### Available Memory Tools
+
+- **`remember`** — Store knowledge for future reference
+  - Required: `content`, `category` (pattern/decision/gotcha/fact/preference/relationship), `scope` (agent/project)
+  - **Always pass**: `teamMemberId` (your Session Name) and `projectPath` (your Project Path from the Identity section)
+
+- **`recall`** — Retrieve relevant knowledge from your memory
+  - Required: `context` (what you're working on or looking for)
+  - **Always pass**: `teamMemberId` (your Session Name) and `projectPath` (your Project Path from the Identity section)
+
+- **`record_learning`** — Quickly jot down a learning while working
+  - Required: `learning` (what you learned)
+  - **Always pass**: `teamMemberId` (your Session Name) and `projectPath` (your Project Path from the Identity section)
+
+- **`query-knowledge`** — Search company knowledge base for SOPs, runbooks, architecture docs
+  - Required: `query` (what to search for)
+  - Optional: `scope` (`global` or `project`), `category`, `projectPath`
+
+### When to Use Memory Tools
+
+**On session startup** (before doing any work):
+1. Call `recall` with context describing your role and current project to load previous knowledge
+2. Review what comes back — it may contain important gotchas, patterns, or unfinished work
+3. Note: `recall` and `get-my-context` now automatically include relevant knowledge documents
+
+**During work** — call `remember` when you:
+- Discover a code pattern or convention in the project (category: `pattern`, scope: `project`)
+- Make or learn about an architectural decision (category: `decision`, scope: `project`)
+- Find a gotcha, bug, or workaround (category: `gotcha`, scope: `project`)
+- Learn something useful for your role (category: `fact`, scope: `agent`)
+- Note a user preference or working style (category: `preference`, scope: `agent`)
+
+**Before process-oriented tasks** (deployment, setup, incident response):
+- **Query global knowledge** for SOPs and runbooks: `query-knowledge` with the relevant topic
+- These documents contain step-by-step procedures your team has documented
+
+**Before answering questions** about deployment, architecture, past decisions, or infrastructure:
+- **Always call `recall` first** to check stored knowledge before answering from scratch
+- Knowledge documents are automatically included in recall results
+
+**When finishing a task** — call `record_learning` with:
+- What was done and what was learned
+- Any gotchas or patterns discovered
+- What's left unfinished (if anything)
+
+### Key Rules
+
+1. **Always pass `teamMemberId` and `projectPath`** — without these, memory can't be saved or retrieved correctly
+2. **Be specific in content** — "Use async/await for all DB queries in this project" is better than "use async"
+3. **Use `recall` liberally** — it's cheap and often surfaces useful context
+4. **Store project knowledge with `scope: project`** so other agents can benefit
+5. **Store personal knowledge with `scope: agent`** for role-specific learnings