crewly 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Steve Huang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+# Crewly
+
+**Website:** [crewly.stevesprompt.com](https://crewly.stevesprompt.com/)
+
+Crewly is a multi-agent orchestration platform that coordinates AI coding agents (Claude Code, Gemini CLI, Codex) to work together as a team. It provides a web dashboard for real-time monitoring, task management, and team coordination — all running locally on your machine.
+
+## Prerequisites
+
+Before using Crewly, you need:
+
+- **Node.js** v20+ and **npm** v9+
+- **At least one** of the following AI coding CLIs installed:
+
+| Runtime | Install | Verify |
+|---------|---------|--------|
+| **Claude Code** (default) | `npm install -g @anthropic-ai/claude-code` | `claude --version` |
+| **Gemini CLI** | `npm install -g @google/gemini-cli` | `gemini --version` |
+| **Codex (OpenAI)** | `npm install -g @openai/codex` | `codex --version` |
+
+**API keys:** Gemini CLI requires `GEMINI_API_KEY` set in your environment. Codex CLI requires an OpenAI API key configured via its own setup. Claude Code authenticates through its own login flow.
+
+## Quick Start
+
+```bash
+# Install Crewly
+npm install -g crewly
+
+# Start Crewly
+npx crewly start
+```
+
+That's it. This starts the backend server and opens the web dashboard in your browser. From there you can:
+
+1. Create a **team** with agents assigned to roles (developer, QA, PM, etc.)
+2. Assign the team to a **project** (any local code directory)
+3. Watch agents work in real time through live terminal streams
+
+## Agent Runtimes
+
+Crewly launches AI agents as CLI processes in terminal sessions. Each agent can use a different runtime:
+
+| Runtime | Default Command | Notes |
+|---------|-----------------|-------|
+| **Claude Code** | `claude --dangerously-skip-permissions` | Default runtime |
+| **Gemini CLI** | `gemini --yolo` | Requires `GEMINI_API_KEY` |
+| **Codex (OpenAI)** | `codex --full-auto` | Requires OpenAI API key |
+
+- The default runtime is **Claude Code**. You can change it in the dashboard under **Settings**.
+- You can select a different runtime per team or per agent when creating them.
+- You can customize the launch command for any runtime under **Settings > Runtime Commands**.
+
+## How It Works
+
+```
+You (Dashboard) → Crewly Backend → PTY Sessions (AI agents)
+                       ↓
+                  Agent Skills ← Agents call bash skills to coordinate
+                       ↓
+                  File Storage (~/.crewly/ & project/.crewly/)
+```
+
+1. You create a **team** in the dashboard with agents assigned to roles
+2. You assign the team to a **project** (any local code directory)
+3. Crewly launches each agent as a CLI process in its own terminal session
+4. Agents receive role-specific prompts and use **skills** (bash scripts) to communicate, report progress, and manage tasks
+5. You monitor everything in real time through the web dashboard
+
+## Configuration
+
+Optional environment variables (set in `.env` at project root or in your shell):
+
+```bash
+GEMINI_API_KEY=your_key_here       # Required for Gemini CLI runtime
+
+SLACK_BOT_TOKEN=xoxb-...           # Optional: Slack integration
+SLACK_APP_TOKEN=xapp-...
+SLACK_SIGNING_SECRET=...
+
+LOG_LEVEL=info                     # debug, info, warn, error
+```
+
+## Development (From Source)
+
+For contributors who want to work on Crewly itself:
+
+```bash
+git clone https://github.com/your-org/crewly.git
+cd crewly
+npm install
+npm run build
+npm run dev          # Starts backend + frontend with hot-reload
+```
+
+## License
+
+MIT

package/config/auto-assign/default-config.yaml

@@ -0,0 +1,74 @@
+# Auto-Assignment Configuration
+# This file defines the default auto-assignment settings for AgentMux.
+# Copy this to your project's .agentmux/config/auto-assign.yaml to customize.
+
+# Enable/disable auto-assignment
+enabled: true
+
+# Assignment Strategy Configuration
+strategy:
+  # How tasks are prioritized: fifo, priority, deadline, custom
+  prioritization: priority
+
+  # Role matching rules
+  # Each rule defines which task types a role can handle
+  roleMatching:
+    - role: developer
+      taskTypes: [feature, fix, refactor, test, implement]
+      priority: 1
+
+    - role: frontend-developer
+      taskTypes: [feature, fix, ui, component, style, frontend]
+      priority: 1
+
+    - role: backend-developer
+      taskTypes: [feature, fix, api, service, database, backend]
+      priority: 1
+
+    - role: qa
+      taskTypes: [test, review, verify, qa]
+      priority: 1
+      exclusive: true  # Only QA can handle these tasks
+
+    - role: tester
+      taskTypes: [test, review, verify]
+      priority: 2
+
+    - role: pm
+      taskTypes: [planning, review, coordination, documentation]
+      priority: 1
+
+    - role: tpm
+      taskTypes: [planning, coordination, tracking]
+      priority: 1
+
+    - role: pgm
+      taskTypes: [planning, management, coordination]
+      priority: 1
+
+    - role: designer
+      taskTypes: [design, ui, ux, mockup]
+      priority: 1
+      exclusive: true
+
+  # Load balancing settings
+  loadBalancing:
+    enabled: true
+    maxConcurrentTasks: 1      # One task per agent at a time
+    preferIdleAgents: true     # Prioritize assigning to idle agents
+
+  # Dependency handling
+  dependencies:
+    respectBlocking: true       # Don't assign blocked tasks
+    waitForDependencies: true   # Wait for dependencies to complete
+
+# Notification settings
+notifications:
+  notifyOnIdle: true            # Notify when agent becomes idle
+  idleThresholdMinutes: 5       # Wait this long before idle notification
+  notifyOnNoTasks: true         # Notify when no tasks available
+
+# Rate limits
+limits:
+  maxAssignmentsPerDay: 50      # Max assignments per agent per day
+  cooldownBetweenTasks: 60      # Seconds to wait between task assignments

package/config/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["constants.ts"],"names":[],"mappings":"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"}

package/config/constants.test.ts

@@ -0,0 +1,469 @@
+/**
+ * Unit tests for Crewly cross-domain constants
+ * 
+ * This test file validates the centralized constants that are shared
+ * across all Crewly domains (backend, frontend, CLI).
+ */
+
+import {
+  CREWLY_CONSTANTS,
+  AGENT_IDENTITY_CONSTANTS,
+  WEB_CONSTANTS,
+  TIMING_CONSTANTS,
+  MESSAGE_CONSTANTS,
+  ENV_CONSTANTS,
+  type AgentStatus,
+  type WorkingStatus,
+  type AgentRole,
+  type AgentId,
+  type MessageType,
+} from './constants.js';
+
+describe('Crewly Cross-Domain Constants', () => {
+  describe('CREWLY_CONSTANTS', () => {
+    describe('SESSIONS', () => {
+      test('should have valid orchestrator name', () => {
+        expect(CREWLY_CONSTANTS.SESSIONS.ORCHESTRATOR_NAME).toBe('crewly-orc');
+        expect(typeof CREWLY_CONSTANTS.SESSIONS.ORCHESTRATOR_NAME).toBe('string');
+      });
+
+      test('should have valid timeout values', () => {
+        expect(CREWLY_CONSTANTS.SESSIONS.DEFAULT_TIMEOUT).toBe(120000);
+        expect(CREWLY_CONSTANTS.SESSIONS.REGISTRATION_CHECK_INTERVAL).toBe(5000);
+        expect(CREWLY_CONSTANTS.SESSIONS.CLAUDE_DETECTION_CACHE_TIMEOUT).toBe(30000);
+      });
+
+      test('timeout values should be positive numbers', () => {
+        const timeouts = [
+          CREWLY_CONSTANTS.SESSIONS.DEFAULT_TIMEOUT,
+          CREWLY_CONSTANTS.SESSIONS.REGISTRATION_CHECK_INTERVAL,
+          CREWLY_CONSTANTS.SESSIONS.CLAUDE_DETECTION_CACHE_TIMEOUT,
+        ];
+
+        timeouts.forEach((timeout) => {
+          expect(typeof timeout).toBe('number');
+          expect(timeout).toBeGreaterThan(0);
+        });
+      });
+    });
+
+    describe('PATHS', () => {
+      test('should have all required paths', () => {
+        expect(CREWLY_CONSTANTS.PATHS.CREWLY_HOME).toBe('.crewly');
+        expect(CREWLY_CONSTANTS.PATHS.TEAMS_FILE).toBe('teams.json');
+        expect(CREWLY_CONSTANTS.PATHS.PROJECTS_FILE).toBe('projects.json');
+        expect(CREWLY_CONSTANTS.PATHS.CONFIG_DIR).toBe('config');
+        expect(CREWLY_CONSTANTS.PATHS.PROMPTS_DIR).toBe('prompts');
+        expect(CREWLY_CONSTANTS.PATHS.TASKS_DIR).toBe('tasks');
+        expect(CREWLY_CONSTANTS.PATHS.SPECS_DIR).toBe('specs');
+        expect(CREWLY_CONSTANTS.PATHS.MEMORY_DIR).toBe('memory');
+      });
+
+      test('file paths should have proper extensions', () => {
+        expect(CREWLY_CONSTANTS.PATHS.TEAMS_FILE).toMatch(/\.json$/);
+        expect(CREWLY_CONSTANTS.PATHS.PROJECTS_FILE).toMatch(/\.json$/);
+        expect(CREWLY_CONSTANTS.PATHS.RUNTIME_FILE).toMatch(/\.json$/);
+        expect(CREWLY_CONSTANTS.PATHS.SCHEDULED_MESSAGES_FILE).toMatch(/\.json$/);
+        expect(CREWLY_CONSTANTS.PATHS.MESSAGE_DELIVERY_LOGS_FILE).toMatch(/\.json$/);
+      });
+
+      test('directory names should not contain slashes', () => {
+        const dirs = [
+          CREWLY_CONSTANTS.PATHS.CONFIG_DIR,
+          CREWLY_CONSTANTS.PATHS.PROMPTS_DIR,
+          CREWLY_CONSTANTS.PATHS.TASKS_DIR,
+          CREWLY_CONSTANTS.PATHS.SPECS_DIR,
+          CREWLY_CONSTANTS.PATHS.MEMORY_DIR,
+        ];
+
+        dirs.forEach((dir) => {
+          expect(dir).not.toMatch(/\//);
+          expect(dir.length).toBeGreaterThan(0);
+        });
+      });
+    });
+
+    describe('AGENT_STATUSES', () => {
+      test('should have all required statuses', () => {
+        expect(CREWLY_CONSTANTS.AGENT_STATUSES.INACTIVE).toBe('inactive');
+        expect(CREWLY_CONSTANTS.AGENT_STATUSES.ACTIVATING).toBe('activating');
+        expect(CREWLY_CONSTANTS.AGENT_STATUSES.ACTIVE).toBe('active');
+      });
+
+      test('all statuses should be lowercase strings', () => {
+        Object.values(CREWLY_CONSTANTS.AGENT_STATUSES).forEach((status) => {
+          expect(typeof status).toBe('string');
+          expect(status).toBe(status.toLowerCase());
+        });
+      });
+    });
+
+    describe('WORKING_STATUSES', () => {
+      test('should have all required working statuses', () => {
+        expect(CREWLY_CONSTANTS.WORKING_STATUSES.IDLE).toBe('idle');
+        expect(CREWLY_CONSTANTS.WORKING_STATUSES.IN_PROGRESS).toBe('in_progress');
+      });
+
+      test('all working statuses should be lowercase strings', () => {
+        Object.values(CREWLY_CONSTANTS.WORKING_STATUSES).forEach((status) => {
+          expect(typeof status).toBe('string');
+          expect(status).toBe(status.toLowerCase());
+        });
+      });
+    });
+
+    describe('ROLES', () => {
+      test('should have all required roles', () => {
+        expect(CREWLY_CONSTANTS.ROLES.ORCHESTRATOR).toBe('orchestrator');
+        expect(CREWLY_CONSTANTS.ROLES.PROJECT_MANAGER).toBe('pm');
+        expect(CREWLY_CONSTANTS.ROLES.TECH_LEAD).toBe('tpm');
+        expect(CREWLY_CONSTANTS.ROLES.DEVELOPER).toBe('developer');
+        expect(CREWLY_CONSTANTS.ROLES.QA).toBe('qa');
+        expect(CREWLY_CONSTANTS.ROLES.DEVOPS).toBe('devops');
+      });
+
+      test('should have display names for all roles', () => {
+        Object.values(CREWLY_CONSTANTS.ROLES).forEach((role) => {
+          expect(CREWLY_CONSTANTS.ROLE_DISPLAY_NAMES).toHaveProperty(role);
+          expect(typeof CREWLY_CONSTANTS.ROLE_DISPLAY_NAMES[role as keyof typeof CREWLY_CONSTANTS.ROLE_DISPLAY_NAMES]).toBe('string');
+        });
+      });
+
+      test('display names should be properly formatted', () => {
+        Object.values(CREWLY_CONSTANTS.ROLE_DISPLAY_NAMES).forEach((displayName) => {
+          expect(displayName.charAt(0)).toMatch(/[A-Z]/);
+          expect(displayName.length).toBeGreaterThan(0);
+        });
+      });
+    });
+
+    describe('AGENT_IDS', () => {
+      test('should have orchestrator ID defined', () => {
+        expect(CREWLY_CONSTANTS.AGENT_IDS.ORCHESTRATOR_ID).toBe('orchestrator');
+      });
+
+      test('should be a valid string constant', () => {
+        const orchestratorId: AgentId = CREWLY_CONSTANTS.AGENT_IDS.ORCHESTRATOR_ID;
+        expect(typeof orchestratorId).toBe('string');
+        expect(orchestratorId.length).toBeGreaterThan(0);
+        expect(orchestratorId).toBe('orchestrator');
+      });
+
+      test('orchestrator ID should match role constant', () => {
+        expect(CREWLY_CONSTANTS.AGENT_IDS.ORCHESTRATOR_ID).toBe(CREWLY_CONSTANTS.ROLES.ORCHESTRATOR);
+      });
+    });
+  });
+
+  describe('AGENT_IDENTITY_CONSTANTS', () => {
+    describe('ORCHESTRATOR', () => {
+      test('should have complete orchestrator identity', () => {
+        const orch = AGENT_IDENTITY_CONSTANTS.ORCHESTRATOR;
+
+        expect(orch.ID).toBe('orchestrator');
+        expect(orch.SESSION_NAME).toBe('crewly-orc');
+        expect(orch.ROLE).toBe('orchestrator');
+      });
+
+      test('should reference existing constants consistently', () => {
+        const orch = AGENT_IDENTITY_CONSTANTS.ORCHESTRATOR;
+
+        // Verify references point to correct source constants
+        expect(orch.ID).toBe(CREWLY_CONSTANTS.AGENT_IDS.ORCHESTRATOR_ID);
+        expect(orch.SESSION_NAME).toBe(CREWLY_CONSTANTS.SESSIONS.ORCHESTRATOR_NAME);
+        expect(orch.ROLE).toBe(CREWLY_CONSTANTS.ROLES.ORCHESTRATOR);
+      });
+
+      test('should maintain type safety', () => {
+        const orchestratorId: AgentId = AGENT_IDENTITY_CONSTANTS.ORCHESTRATOR.ID;
+        const orchestratorRole: AgentRole = AGENT_IDENTITY_CONSTANTS.ORCHESTRATOR.ROLE;
+
+        expect(orchestratorId).toBe('orchestrator');
+        expect(orchestratorRole).toBe('orchestrator');
+      });
+
+      test('should provide constants for agent heartbeat system', () => {
+        // These constants are essential for the new agent heartbeat architecture
+        expect(typeof AGENT_IDENTITY_CONSTANTS.ORCHESTRATOR.ID).toBe('string');
+        expect(typeof AGENT_IDENTITY_CONSTANTS.ORCHESTRATOR.SESSION_NAME).toBe('string');
+        expect(typeof AGENT_IDENTITY_CONSTANTS.ORCHESTRATOR.ROLE).toBe('string');
+
+        // All should be non-empty
+        expect(AGENT_IDENTITY_CONSTANTS.ORCHESTRATOR.ID.length).toBeGreaterThan(0);
+        expect(AGENT_IDENTITY_CONSTANTS.ORCHESTRATOR.SESSION_NAME.length).toBeGreaterThan(0);
+        expect(AGENT_IDENTITY_CONSTANTS.ORCHESTRATOR.ROLE.length).toBeGreaterThan(0);
+      });
+    });
+
+    test('should maintain consistency across all orchestrator references', () => {
+      // All orchestrator constants should be consistent
+      expect(CREWLY_CONSTANTS.AGENT_IDS.ORCHESTRATOR_ID).toBe('orchestrator');
+      expect(CREWLY_CONSTANTS.ROLES.ORCHESTRATOR).toBe('orchestrator');
+      expect(CREWLY_CONSTANTS.SESSIONS.ORCHESTRATOR_NAME).toBe('crewly-orc');
+
+      // Identity helper should match
+      const orch = AGENT_IDENTITY_CONSTANTS.ORCHESTRATOR;
+      expect(orch.ID).toBe('orchestrator');
+      expect(orch.ROLE).toBe('orchestrator');
+      expect(orch.SESSION_NAME).toBe('crewly-orc');
+    });
+  });
+
+  describe('WEB_CONSTANTS', () => {
+    describe('PORTS', () => {
+      test('should have valid port numbers', () => {
+        expect(WEB_CONSTANTS.PORTS.BACKEND).toBe(8787);
+        expect(WEB_CONSTANTS.PORTS.FRONTEND).toBe(8788);
+      });
+
+      test('ports should be in valid range', () => {
+        [WEB_CONSTANTS.PORTS.BACKEND, WEB_CONSTANTS.PORTS.FRONTEND].forEach((port) => {
+          expect(port).toBeGreaterThan(1023);
+          expect(port).toBeLessThan(65536);
+        });
+      });
+
+      test('frontend and backend ports should be different', () => {
+        expect(WEB_CONSTANTS.PORTS.FRONTEND).not.toBe(WEB_CONSTANTS.PORTS.BACKEND);
+      });
+    });
+
+    describe('ENDPOINTS', () => {
+      test('should have all required endpoints', () => {
+        expect(WEB_CONSTANTS.ENDPOINTS.HEALTH).toBe('/health');
+        expect(WEB_CONSTANTS.ENDPOINTS.API_BASE).toBe('/api');
+        expect(WEB_CONSTANTS.ENDPOINTS.TEAMS).toBe('/api/teams');
+        expect(WEB_CONSTANTS.ENDPOINTS.PROJECTS).toBe('/api/projects');
+        expect(WEB_CONSTANTS.ENDPOINTS.ORCHESTRATOR).toBe('/api/orchestrator');
+        expect(WEB_CONSTANTS.ENDPOINTS.TERMINAL).toBe('/api/terminal');
+        expect(WEB_CONSTANTS.ENDPOINTS.TASKS).toBe('/api/tasks');
+      });
+
+      test('all endpoints should start with forward slash', () => {
+        Object.values(WEB_CONSTANTS.ENDPOINTS).forEach((endpoint) => {
+          expect(endpoint).toMatch(/^\/[a-z]/);
+        });
+      });
+
+      test('API endpoints should start with /api', () => {
+        const apiEndpoints = [
+          WEB_CONSTANTS.ENDPOINTS.TEAMS,
+          WEB_CONSTANTS.ENDPOINTS.PROJECTS,
+          WEB_CONSTANTS.ENDPOINTS.ORCHESTRATOR,
+          WEB_CONSTANTS.ENDPOINTS.TERMINAL,
+          WEB_CONSTANTS.ENDPOINTS.TASKS,
+        ];
+
+        apiEndpoints.forEach((endpoint) => {
+          expect(endpoint).toMatch(/^\/api\//);
+        });
+      });
+    });
+  });
+
+  describe('TIMING_CONSTANTS', () => {
+    describe('RETRIES', () => {
+      test('should have valid retry configuration', () => {
+        expect(TIMING_CONSTANTS.RETRIES.MAX_ATTEMPTS).toBe(3);
+        expect(TIMING_CONSTANTS.RETRIES.BASE_DELAY).toBe(1000);
+        expect(TIMING_CONSTANTS.RETRIES.MAX_DELAY).toBe(10000);
+      });
+
+      test('retry values should be positive', () => {
+        Object.values(TIMING_CONSTANTS.RETRIES).forEach((value) => {
+          expect(typeof value).toBe('number');
+          expect(value).toBeGreaterThan(0);
+        });
+      });
+
+      test('max delay should be greater than base delay', () => {
+        expect(TIMING_CONSTANTS.RETRIES.MAX_DELAY).toBeGreaterThan(TIMING_CONSTANTS.RETRIES.BASE_DELAY);
+      });
+    });
+
+    describe('INTERVALS', () => {
+      test('should have valid interval values', () => {
+        expect(TIMING_CONSTANTS.INTERVALS.HEALTH_CHECK).toBe(30000);
+        expect(TIMING_CONSTANTS.INTERVALS.MEMORY_CLEANUP).toBe(300000);
+        expect(TIMING_CONSTANTS.INTERVALS.STATUS_UPDATE).toBe(10000);
+        expect(TIMING_CONSTANTS.INTERVALS.ACTIVITY_MONITOR).toBe(15000);
+        expect(TIMING_CONSTANTS.INTERVALS.CLEANUP).toBe(60000);
+        expect(TIMING_CONSTANTS.INTERVALS.BATCH_DELAY).toBe(500);
+        expect(TIMING_CONSTANTS.INTERVALS.RATE_LIMIT_WINDOW).toBe(1000);
+        expect(TIMING_CONSTANTS.INTERVALS.TASK_CLEANUP).toBe(300000);
+      });
+
+      test('all intervals should be positive numbers', () => {
+        Object.values(TIMING_CONSTANTS.INTERVALS).forEach((interval) => {
+          expect(typeof interval).toBe('number');
+          expect(interval).toBeGreaterThan(0);
+        });
+      });
+
+      test('cleanup interval should be greater than batch delay', () => {
+        expect(TIMING_CONSTANTS.INTERVALS.CLEANUP).toBeGreaterThan(
+          TIMING_CONSTANTS.INTERVALS.BATCH_DELAY
+        );
+      });
+
+      test('task cleanup should be greater than rate limit window', () => {
+        expect(TIMING_CONSTANTS.INTERVALS.TASK_CLEANUP).toBeGreaterThan(
+          TIMING_CONSTANTS.INTERVALS.RATE_LIMIT_WINDOW
+        );
+      });
+    });
+
+    describe('TIMEOUTS', () => {
+      test('should have valid timeout values', () => {
+        expect(TIMING_CONSTANTS.TIMEOUTS.CLAUDE_INIT).toBe(45000);
+        expect(TIMING_CONSTANTS.TIMEOUTS.AGENT_SETUP).toBe(90000);
+        expect(TIMING_CONSTANTS.TIMEOUTS.TASK_COMPLETION).toBe(300000);
+        expect(TIMING_CONSTANTS.TIMEOUTS.WEBSOCKET).toBe(30000);
+        expect(TIMING_CONSTANTS.TIMEOUTS.HTTP_HEALTH_CHECK).toBe(3000);
+        expect(TIMING_CONSTANTS.TIMEOUTS.API_REQUEST_QUICK).toBe(2000);
+        expect(TIMING_CONSTANTS.TIMEOUTS.SHUTDOWN).toBe(2000);
+        expect(TIMING_CONSTANTS.TIMEOUTS.CONNECTION).toBe(10000);
+      });
+
+      test('all timeouts should be positive numbers', () => {
+        Object.values(TIMING_CONSTANTS.TIMEOUTS).forEach((timeout) => {
+          expect(typeof timeout).toBe('number');
+          expect(timeout).toBeGreaterThan(0);
+        });
+      });
+
+      test('http health check timeout should be reasonable', () => {
+        expect(TIMING_CONSTANTS.TIMEOUTS.HTTP_HEALTH_CHECK).toBeLessThanOrEqual(10000);
+        expect(TIMING_CONSTANTS.TIMEOUTS.HTTP_HEALTH_CHECK).toBeGreaterThanOrEqual(1000);
+      });
+
+      test('connection timeout should be reasonable', () => {
+        expect(TIMING_CONSTANTS.TIMEOUTS.CONNECTION).toBeGreaterThanOrEqual(5000);
+        expect(TIMING_CONSTANTS.TIMEOUTS.CONNECTION).toBeLessThanOrEqual(30000);
+      });
+    });
+  });
+
+  describe('MESSAGE_CONSTANTS', () => {
+    describe('LIMITS', () => {
+      test('should have valid message limits', () => {
+        expect(MESSAGE_CONSTANTS.LIMITS.CHUNK_SIZE).toBe(1500);
+        expect(MESSAGE_CONSTANTS.LIMITS.SMALL_CHUNK_SIZE).toBe(200);
+        expect(MESSAGE_CONSTANTS.LIMITS.MAX_BUFFER_SIZE).toBe(100);
+      });
+
+      test('chunk size should be larger than small chunk size', () => {
+        expect(MESSAGE_CONSTANTS.LIMITS.CHUNK_SIZE).toBeGreaterThan(MESSAGE_CONSTANTS.LIMITS.SMALL_CHUNK_SIZE);
+      });
+
+      test('all limits should be positive numbers', () => {
+        Object.values(MESSAGE_CONSTANTS.LIMITS).forEach((limit) => {
+          expect(typeof limit).toBe('number');
+          expect(limit).toBeGreaterThan(0);
+        });
+      });
+    });
+
+    describe('TYPES', () => {
+      test('should have all required message types', () => {
+        const expectedTypes = ['system', 'user', 'agent', 'error', 'broadcast'];
+        expectedTypes.forEach((type) => {
+          expect(Object.values(MESSAGE_CONSTANTS.TYPES)).toContain(type);
+        });
+      });
+
+      test('message types should be lowercase strings', () => {
+        Object.values(MESSAGE_CONSTANTS.TYPES).forEach((type) => {
+          expect(typeof type).toBe('string');
+          expect(type).toBe(type.toLowerCase());
+        });
+      });
+    });
+  });
+
+  describe('ENV_CONSTANTS', () => {
+    test('should have all required environment variables', () => {
+      const expectedEnvVars = [
+        'TMUX_SESSION_NAME',
+        'CREWLY_ROLE',
+        'API_PORT',
+        'CREWLY_MCP_PORT',
+        'PROJECT_PATH',
+        'AGENT_ROLE',
+        'NODE_ENV',
+        'DEV_MODE',
+      ];
+
+      expectedEnvVars.forEach((envVar) => {
+        expect(Object.values(ENV_CONSTANTS)).toContain(envVar);
+      });
+    });
+
+    test('all env var names should be uppercase with underscores', () => {
+      Object.values(ENV_CONSTANTS).forEach((envVar) => {
+        expect(envVar).toMatch(/^[A-Z_]+$/);
+      });
+    });
+
+    test('env var names should not be empty', () => {
+      Object.values(ENV_CONSTANTS).forEach((envVar) => {
+        expect(envVar.length).toBeGreaterThan(0);
+      });
+    });
+  });
+
+  describe('Type Helpers', () => {
+    test('AgentStatus type should include all status values', () => {
+      const testStatus: AgentStatus = 'active';
+      expect(['active', 'inactive', 'activating']).toContain(testStatus);
+    });
+
+    test('WorkingStatus type should include all working status values', () => {
+      const testWorkingStatus: WorkingStatus = 'idle';
+      expect(['idle', 'in_progress']).toContain(testWorkingStatus);
+    });
+
+    test('AgentRole type should include all role values', () => {
+      const testRole: AgentRole = 'developer';
+      expect(['orchestrator', 'pm', 'tpm', 'developer', 'qa', 'devops']).toContain(testRole);
+    });
+
+    test('MessageType type should include all message type values', () => {
+      const testMessageType: MessageType = 'system';
+      expect(Object.values(MESSAGE_CONSTANTS.TYPES)).toContain(testMessageType);
+    });
+  });
+
+  describe('Constants Structure', () => {
+    test('all main constant objects should be defined', () => {
+      expect(CREWLY_CONSTANTS).toBeDefined();
+      expect(WEB_CONSTANTS).toBeDefined();
+      expect(TIMING_CONSTANTS).toBeDefined();
+      expect(MESSAGE_CONSTANTS).toBeDefined();
+      expect(ENV_CONSTANTS).toBeDefined();
+    });
+
+    test('constants should be immutable (const assertions)', () => {
+      // These tests verify that const assertions are working
+      expect(typeof CREWLY_CONSTANTS).toBe('object');
+      expect(typeof WEB_CONSTANTS).toBe('object');
+      expect(typeof TIMING_CONSTANTS).toBe('object');
+      expect(typeof MESSAGE_CONSTANTS).toBe('object');
+      expect(typeof ENV_CONSTANTS).toBe('object');
+    });
+  });
+
+  describe('Cross-Domain Consistency', () => {
+    test('orchestrator session name should be consistent', () => {
+      expect(CREWLY_CONSTANTS.SESSIONS.ORCHESTRATOR_NAME).toBe('crewly-orc');
+    });
+
+    test('timeout values should be reasonable', () => {
+      // Agent setup timeout should be longer than Claude init timeout
+      expect(TIMING_CONSTANTS.TIMEOUTS.AGENT_SETUP).toBeGreaterThan(TIMING_CONSTANTS.TIMEOUTS.CLAUDE_INIT);
+      
+      // Task completion timeout should be longest
+      expect(TIMING_CONSTANTS.TIMEOUTS.TASK_COMPLETION).toBeGreaterThan(TIMING_CONSTANTS.TIMEOUTS.AGENT_SETUP);
+    });
+  });
+});