crewly 1.0.0

package/dist/backend/backend/src/constants.d.ts

@@ -0,0 +1,669 @@
+/**
+ * Backend-specific constants
+ * Re-exported from the main config constants for backend use
+ */
+export declare const AGENT_IDENTITY_CONSTANTS: {
+    readonly ORCHESTRATOR: {
+        readonly ID: "orchestrator";
+        readonly SESSION_NAME: "crewly-orc";
+        readonly ROLE: "orchestrator";
+    };
+};
+export declare const TIMING_CONSTANTS: {
+    readonly RETRIES: {
+        readonly MAX_ATTEMPTS: 3;
+        readonly BASE_DELAY: 1000;
+        readonly MAX_DELAY: 10000;
+    };
+    readonly INTERVALS: {
+        readonly HEALTH_CHECK: 30000;
+        readonly MEMORY_CLEANUP: number;
+        readonly STATUS_UPDATE: 10000;
+        readonly ACTIVITY_MONITOR: 15000;
+        readonly CLEANUP: 60000;
+        readonly BATCH_DELAY: 500;
+        readonly RATE_LIMIT_WINDOW: 1000;
+        readonly TASK_CLEANUP: 300000;
+    };
+    readonly TIMEOUTS: {
+        readonly CLAUDE_INIT: 45000;
+        readonly AGENT_SETUP: 90000;
+        readonly TASK_COMPLETION: number;
+        readonly WEBSOCKET: 30000;
+        readonly ORCHESTRATOR_SETUP: 30000;
+        readonly TASK_MONITOR_POLL: 2000;
+        readonly HEALTH_CHECK_TIMEOUT: 1000;
+        readonly HTTP_HEALTH_CHECK: 3000;
+        readonly API_REQUEST_QUICK: 2000;
+        readonly SHUTDOWN: 2000;
+        readonly CONNECTION: 10000;
+        readonly AGENT_DEFAULT: 300000;
+        readonly CONTEXT_REFRESH: 1800000;
+        readonly WS_PING: 60000;
+        readonly WS_PING_INTERVAL: 25000;
+        readonly BACKUP: 3600000;
+        readonly RATE_LIMIT_WINDOW: 900000;
+        readonly COMMAND_TIMESTAMP_OFFSET: 300000;
+        readonly COMMAND_TIMESTAMP_OFFSET_LONG: 600000;
+    };
+};
+export declare const MEMORY_CONSTANTS: {
+    readonly PATHS: {
+        readonly AGENTS_DIR: "agents";
+        readonly KNOWLEDGE_DIR: "knowledge";
+        readonly SESSIONS_DIR: "sessions";
+        readonly LATEST_SUMMARY: "latest-summary.md";
+        readonly DAILY_LOG_DIR: "logs/daily";
+        readonly GOALS_DIR: "goals";
+        readonly GOALS_FILE: "goals.md";
+        readonly FOCUS_FILE: "current_focus.md";
+        readonly DECISIONS_LOG: "decisions_log.md";
+        readonly LEARNING_DIR: "learning";
+        readonly WHAT_WORKED_FILE: "what_worked.md";
+        readonly WHAT_FAILED_FILE: "what_failed.md";
+        readonly GLOBAL_LEARNING_DIR: "learning";
+        readonly CROSS_PROJECT_INSIGHTS: "cross_project_insights.md";
+        readonly AGENTS_INDEX: "agents-index.json";
+    };
+    readonly AGENT_FILES: {
+        readonly MEMORY: "memory.json";
+        readonly ROLE_KNOWLEDGE: "role-knowledge.json";
+        readonly PREFERENCES: "preferences.json";
+        readonly PERFORMANCE: "performance.json";
+        readonly SOP_CUSTOM_DIR: "sop-custom";
+    };
+    readonly PROJECT_FILES: {
+        readonly INDEX: "index.json";
+        readonly PATTERNS: "patterns.json";
+        readonly DECISIONS: "decisions.json";
+        readonly GOTCHAS: "gotchas.json";
+        readonly RELATIONSHIPS: "relationships.json";
+        readonly LEARNINGS: "learnings.md";
+    };
+    readonly LIMITS: {
+        readonly MAX_ROLE_KNOWLEDGE_ENTRIES: 500;
+        readonly MAX_PATTERN_ENTRIES: 200;
+        readonly MAX_DECISION_ENTRIES: 100;
+        readonly MAX_GOTCHA_ENTRIES: 200;
+        readonly MAX_RELATIONSHIP_ENTRIES: 500;
+        readonly MAX_FILE_SIZE_BYTES: 1048576;
+        readonly MAX_QUERY_RESULTS: 50;
+        readonly MIN_CONFIDENCE_THRESHOLD: 0.2;
+        readonly PRUNE_AFTER_DAYS: 90;
+    };
+    readonly DEFAULTS: {
+        readonly INITIAL_CONFIDENCE: 0.5;
+        readonly CONFIDENCE_REINFORCEMENT: 0.1;
+        readonly MAX_CONFIDENCE: 1;
+        readonly MIN_CONFIDENCE: 0;
+    };
+    readonly SCHEMA: {
+        readonly CURRENT_VERSION: 1;
+        readonly MIN_SUPPORTED_VERSION: 1;
+    };
+    readonly CATEGORIES: {
+        readonly ROLE_KNOWLEDGE: readonly ["best-practice", "anti-pattern", "tool-usage", "workflow"];
+        readonly PATTERN: readonly ["api", "component", "service", "testing", "styling", "database", "config", "other"];
+        readonly GOTCHA_SEVERITY: readonly ["low", "medium", "high", "critical"];
+        readonly LEARNING: readonly ["pattern", "decision", "gotcha", "insight", "improvement"];
+        readonly RELATIONSHIP: readonly ["depends-on", "uses", "extends", "implements", "calls", "imported-by"];
+    };
+};
+export declare const CONTINUATION_CONSTANTS: {
+    readonly DETECTION: {
+        readonly IDLE_CYCLES_BEFORE_CHECK: 2;
+        readonly STALE_THRESHOLD_MINUTES: 20;
+        readonly ACTIVITY_POLL_INTERVAL_MS: 120000;
+    };
+    readonly EVENTS: {
+        readonly DEBOUNCE_MS: 5000;
+        readonly DEDUP_WINDOW_MS: 10000;
+        readonly CLEANUP_INTERVAL_MS: 60000;
+    };
+    readonly ITERATIONS: {
+        readonly DEFAULT_MAX: 10;
+        readonly ABSOLUTE_MAX: 50;
+        readonly WARNING_THRESHOLD: 0.8;
+    };
+    readonly TIMEOUTS: {
+        readonly ANALYSIS_MS: 10000;
+        readonly ACTION_MS: 30000;
+        readonly PROMPT_INJECTION_MS: 15000;
+    };
+    readonly PATTERNS: {
+        readonly COMPLETION: readonly ["task completed", "task done", "successfully completed", "implementation complete", "all tests pass", "ready for review"];
+        readonly WAITING: readonly ["waiting for", "awaiting", "blocked by", "need input", "please provide", "let me know"];
+        readonly ERROR: readonly ["error:", "failed:", "exception:", "cannot", "unable to", "permission denied"];
+    };
+    readonly CONFIDENCE: {
+        readonly ACTION_THRESHOLD: 0.6;
+        readonly HIGH: 0.8;
+        readonly MEDIUM: 0.5;
+        readonly LOW: 0.3;
+    };
+};
+export declare const ORCHESTRATOR_RESTART_CONSTANTS: {
+    readonly MAX_RESTARTS_PER_WINDOW: 3;
+    readonly COOLDOWN_WINDOW_MS: 3600000;
+    readonly RESTART_DELAY_MS: 5000;
+};
+export declare const AGENT_SUSPEND_CONSTANTS: {
+    readonly DEFAULT_IDLE_TIMEOUT_MINUTES: 10;
+    readonly IDLE_CHECK_INTERVAL_MS: 120000;
+    readonly DEBUG_LOG_MAX_AGE_HOURS: 24;
+    readonly REHYDRATION_TIMEOUT_MS: 45000;
+    readonly EXEMPT_ROLES: readonly ["orchestrator"];
+};
+export declare const VERSION_CHECK_CONSTANTS: {
+    readonly NPM_REGISTRY_URL: "https://registry.npmjs.org/crewly/latest";
+    readonly CHECK_CACHE_FILE: ".update-check";
+    readonly CACHE_TTL_MS: number;
+    readonly REQUEST_TIMEOUT_MS: 5000;
+};
+export declare const ORCHESTRATOR_SESSION_NAME = "crewly-orc";
+export declare const ORCHESTRATOR_ROLE = "orchestrator";
+export declare const ORCHESTRATOR_WINDOW_NAME = "Crewly Orchestrator";
+export declare const AGENT_INITIALIZATION_TIMEOUT = 90000;
+export declare const CLAUDE_INITIALIZATION_TIMEOUT = 45000;
+export declare const CREWLY_CONSTANTS: {
+    readonly INIT_SCRIPTS: {
+        readonly CLAUDE: "initialize_claude.sh";
+    };
+    readonly SESSIONS: {
+        readonly ORCHESTRATOR_NAME: "crewly-orc";
+        readonly DEFAULT_TIMEOUT: 120000;
+        readonly REGISTRATION_CHECK_INTERVAL: 5000;
+        readonly CLAUDE_DETECTION_CACHE_TIMEOUT: 30000;
+        readonly DEFAULT_SHELL: "/bin/bash";
+    };
+    readonly PATHS: {
+        readonly CREWLY_HOME: ".crewly";
+        readonly TEAMS_FILE: "teams.json";
+        readonly PROJECTS_FILE: "projects.json";
+        readonly RUNTIME_FILE: "runtime.json";
+        readonly SCHEDULED_MESSAGES_FILE: "scheduled-messages.json";
+        readonly MESSAGE_DELIVERY_LOGS_FILE: "message-delivery-logs.json";
+        readonly CONFIG_DIR: "config";
+        readonly PROMPTS_DIR: "prompts";
+        readonly TASKS_DIR: "tasks";
+        readonly SPECS_DIR: "specs";
+        readonly MEMORY_DIR: "memory";
+        readonly DOCS_DIR: "docs";
+        readonly DOCS_INDEX_FILE: "docs-index.json";
+    };
+    readonly AGENT_STATUSES: {
+        readonly INACTIVE: "inactive";
+        readonly STARTING: "starting";
+        readonly STARTED: "started";
+        readonly ACTIVE: "active";
+        readonly SUSPENDED: "suspended";
+        readonly ACTIVATING: "activating";
+    };
+    readonly WORKING_STATUSES: {
+        readonly IDLE: "idle";
+        readonly IN_PROGRESS: "in_progress";
+    };
+    readonly ROLES: {
+        readonly ORCHESTRATOR: "orchestrator";
+        readonly PROJECT_MANAGER: "pm";
+        readonly TECH_LEAD: "tpm";
+        readonly DEVELOPER: "developer";
+        readonly QA: "qa";
+        readonly DEVOPS: "devops";
+    };
+    readonly AGENT_IDS: {
+        readonly ORCHESTRATOR_ID: "orchestrator";
+    };
+    readonly ROLE_DISPLAY_NAMES: {
+        readonly orchestrator: "Orchestrator";
+        readonly pm: "Project Manager";
+        readonly tpm: "Technical Project Manager";
+        readonly developer: "Developer";
+        readonly qa: "Quality Assurance";
+        readonly devops: "DevOps Engineer";
+    };
+    readonly ORCHESTRATOR: {
+        readonly DISPLAY_NAME: "Orchestrator";
+        readonly WINDOW_NAME: "Crewly Orchestrator";
+        readonly SESSION_PREFIX: "crewly_";
+    };
+};
+export declare const ENV_CONSTANTS: {
+    /** Session name (legacy: kept for compatibility with older agents) */
+    readonly TMUX_SESSION_NAME: "TMUX_SESSION_NAME";
+    readonly CREWLY_ROLE: "CREWLY_ROLE";
+    /** Base URL for the Crewly backend API (used by orchestrator bash skills) */
+    readonly CREWLY_API_URL: "CREWLY_API_URL";
+    /** Gemini API key for embedding-based knowledge search */
+    readonly GEMINI_API_KEY: "GEMINI_API_KEY";
+};
+export declare const AGENT_TIMEOUTS: {
+    readonly ORCHESTRATOR_INITIALIZATION: 120000;
+    readonly REGULAR_AGENT_INITIALIZATION: 75000;
+};
+export declare const RUNTIME_TYPES: {
+    readonly CLAUDE_CODE: "claude-code";
+    readonly GEMINI_CLI: "gemini-cli";
+    readonly CODEX_CLI: "codex-cli";
+};
+export declare const PTY_CONSTANTS: {
+    readonly MAX_DATA_LISTENERS: 100;
+    readonly MAX_EXIT_LISTENERS: 50;
+    readonly DEFAULT_MAX_HISTORY_SIZE: number;
+    readonly DEFAULT_SCROLLBACK: 5000;
+    readonly DEFAULT_COLS: 80;
+    readonly DEFAULT_ROWS: 24;
+    readonly MAX_RESIZE_COLS: 1000;
+    readonly MAX_RESIZE_ROWS: 1000;
+    /** Delay before escalating from SIGTERM to SIGKILL in forceKill (ms) */
+    readonly FORCE_KILL_ESCALATION_DELAY: 500;
+    /** Delay before escalating from SIGTERM to SIGKILL in forceDestroyAll (ms) */
+    readonly FORCE_DESTROY_ESCALATION_DELAY: 1000;
+};
+export declare const SESSION_COMMAND_DELAYS: {
+    /** Delay after sending a message (allows terminal to process bracketed paste) */
+    readonly MESSAGE_DELAY: 1000;
+    /** Delay after sending a key (allows key to be processed) */
+    readonly KEY_DELAY: 200;
+    /** Delay after clearing command line (allows terminal to reset) */
+    readonly CLEAR_COMMAND_DELAY: 100;
+    /** Delay after setting environment variable */
+    readonly ENV_VAR_DELAY: 100;
+    /** Delay for Claude Code to recover from state changes */
+    readonly CLAUDE_RECOVERY_DELAY: 300;
+    /** Delay between message delivery retry attempts */
+    readonly MESSAGE_RETRY_DELAY: 1000;
+    /** Additional delay for Claude Code to start processing after message sent */
+    readonly MESSAGE_PROCESSING_DELAY: 500;
+    /** Progressive re-check intervals for Claude Code delivery verification (ms).
+     *  Total window: 500ms (processing delay) + 1000 + 2000 + 3000 = 6.5s */
+    readonly CLAUDE_VERIFICATION_INTERVALS: readonly [1000, 2000, 3000];
+};
+export declare const TERMINAL_CONTROLLER_CONSTANTS: {
+    readonly DEFAULT_CAPTURE_LINES: 50;
+    readonly MAX_CAPTURE_LINES: 500;
+    readonly MAX_OUTPUT_SIZE: 16384;
+};
+export declare const CHAT_CONSTANTS: {
+    /** Regex pattern for extracting conversation ID from chat messages */
+    readonly CONVERSATION_ID_PATTERN: RegExp;
+    /** Regex pattern for extracting conversation ID from response markers */
+    readonly RESPONSE_CONVERSATION_ID_PATTERN: RegExp;
+    /** Message format prefix for chat routing */
+    readonly MESSAGE_PREFIX: "CHAT";
+};
+/**
+ * Unified notification marker constants.
+ * Used by the orchestrator to send messages to chat, Slack, or both
+ * via a single `[NOTIFY]...[/NOTIFY]` block with a JSON payload.
+ */
+export declare const NOTIFY_CONSTANTS: {
+    /** Regex for extracting complete [NOTIFY]...[/NOTIFY] blocks from terminal output */
+    readonly MARKER_PATTERN: RegExp;
+    /** Opening marker string for detection */
+    readonly OPEN_TAG: "[NOTIFY]";
+    /** Closing marker string */
+    readonly CLOSE_TAG: "[/NOTIFY]";
+};
+/**
+ * Slack proactive notification constants.
+ * @deprecated Use NOTIFY_CONSTANTS instead. Legacy [SLACK_NOTIFY] markers are still
+ * processed for backward compatibility but new orchestrator output should use [NOTIFY].
+ */
+export declare const SLACK_NOTIFY_CONSTANTS: {
+    /** Regex for extracting complete [SLACK_NOTIFY]...[/SLACK_NOTIFY] blocks from terminal output */
+    readonly MARKER_PATTERN: RegExp;
+    /** Opening marker string for detection */
+    readonly OPEN_TAG: "[SLACK_NOTIFY]";
+    /** Closing marker string */
+    readonly CLOSE_TAG: "[/SLACK_NOTIFY]";
+};
+export declare const EVENT_DELIVERY_CONSTANTS: {
+    /** Timeout for waiting for prompt detection (ms) */
+    readonly PROMPT_DETECTION_TIMEOUT: 10000;
+    /** Timeout for waiting for delivery confirmation (ms) */
+    readonly DELIVERY_CONFIRMATION_TIMEOUT: 5000;
+    /** Total timeout for message delivery with retries (ms) */
+    readonly TOTAL_DELIVERY_TIMEOUT: 30000;
+    /** Default timeout for pattern matching (ms) */
+    readonly DEFAULT_PATTERN_TIMEOUT: 30000;
+    /** Initial delay for terminal to echo short messages (ms) */
+    readonly INITIAL_MESSAGE_DELAY: 300;
+    /** Extra time for multi-line paste indicator detection (ms) */
+    readonly PASTE_CHECK_DELAY: 1200;
+    /** Delay between Enter key retry attempts (ms) */
+    readonly ENTER_RETRY_DELAY: 800;
+    /** Maximum number of Enter key retry attempts */
+    readonly MAX_ENTER_RETRIES: 3;
+    /** Delay after Enter retries exhausted before verifying message left input line (ms) */
+    readonly POST_ENTER_VERIFICATION_DELAY: 500;
+    /** Maximum buffer size for terminal output collection (bytes) */
+    readonly MAX_BUFFER_SIZE: 10000;
+    /** Minimum buffer length to consider processing detection valid */
+    readonly MIN_BUFFER_FOR_PROCESSING_DETECTION: 50;
+    /** Timeout for waiting for agent to return to prompt before delivery (ms) */
+    readonly AGENT_READY_TIMEOUT: 120000;
+    /** Interval for polling agent prompt readiness (ms) */
+    readonly AGENT_READY_POLL_INTERVAL: 2000;
+};
+/**
+ * Constants for terminal content formatting.
+ * Used by formatMessageContent to safely process terminal output.
+ */
+export declare const TERMINAL_FORMATTING_CONSTANTS: {
+    /** Maximum repeat count for cursor movement sequences (prevents memory exhaustion) */
+    readonly MAX_CURSOR_REPEAT: 1000;
+};
+/**
+ * Terminal detection patterns for Claude Code interaction.
+ * These patterns are used across multiple services to detect terminal state.
+ */
+export declare const TERMINAL_PATTERNS: {
+    /**
+     * Braille spinner characters used by Claude Code to indicate processing.
+     * Pattern: ⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏
+     */
+    readonly SPINNER: RegExp;
+    /**
+     * Claude Code's "working" indicator (filled circle).
+     */
+    readonly WORKING_INDICATOR: RegExp;
+    /**
+     * Combined pattern for detecting any processing activity.
+     * Includes spinner, working indicator, and status text.
+     */
+    readonly PROCESSING: RegExp;
+    /**
+     * Pattern for detecting paste indicator in bracketed paste mode.
+     * Appears as "[Pasted text #N +M lines]" in Claude Code.
+     */
+    readonly PASTE_INDICATOR: RegExp;
+    /**
+     * Pattern to detect if paste indicator is still visible (stuck state).
+     */
+    readonly PASTE_STUCK: RegExp;
+    /**
+     * Agent prompt indicators (characters that appear at input prompts).
+     * Includes Claude Code (❯, >, ⏵), bash ($), and Gemini CLI (!).
+     */
+    readonly PROMPT_CHARS: readonly ["❯", ">", "⏵", "$", "!"];
+    /**
+     * Claude Code idle prompt detection.
+     * Matches:
+     * - ❯ or ⏵ or $ alone on a line (standard Claude Code prompt)
+     * - ❯❯ followed by space or end-of-line (bypass permissions prompt,
+     *   e.g. "❯❯ bypass permissions on (shift+tab to cycle)")
+     */
+    readonly CLAUDE_CODE_PROMPT: RegExp;
+    /**
+     * Gemini CLI idle prompt detection.
+     * Matches:
+     * - > or ! followed by a space (TUI prompt, may have placeholder text)
+     * - Box-drawing border (│, ┃) followed by > or ! (TUI bordered prompt)
+     * - "Type your message …" or "YOLO mode …" textual prompts
+     */
+    readonly GEMINI_CLI_PROMPT: RegExp;
+    /**
+     * Combined prompt pattern for any runtime (union of Claude Code + Gemini CLI).
+     * Use runtime-specific patterns when you need to distinguish between runtimes.
+     */
+    readonly PROMPT_STREAM: RegExp;
+    /**
+     * Processing indicators including status text patterns.
+     */
+    readonly PROCESSING_INDICATORS: readonly [RegExp, RegExp, RegExp, RegExp];
+    /**
+     * Pattern for detecting Claude Code processing with status text.
+     */
+    readonly PROCESSING_WITH_TEXT: RegExp;
+};
+/**
+ * Message queue constants for sequential message processing.
+ * Used by the MessageQueueService for orchestrator communication.
+ */
+export declare const MESSAGE_QUEUE_CONSTANTS: {
+    /** Maximum number of messages allowed in the queue */
+    readonly MAX_QUEUE_SIZE: 100;
+    /** Default timeout for a single message response (ms) */
+    readonly DEFAULT_MESSAGE_TIMEOUT: 120000;
+    /** Maximum number of completed/failed messages retained in history */
+    readonly MAX_HISTORY_SIZE: 50;
+    /** Delay between processing consecutive messages (ms) */
+    readonly INTER_MESSAGE_DELAY: 500;
+    /** Maximum number of requeue retries before permanently failing a message */
+    readonly MAX_REQUEUE_RETRIES: 5;
+    /** Queue persistence file name (stored under crewly home) */
+    readonly PERSISTENCE_FILE: "message-queue.json";
+    /** Queue persistence directory name */
+    readonly PERSISTENCE_DIR: "queue";
+    /** Socket.IO event names for queue status updates */
+    readonly SOCKET_EVENTS: {
+        /** Emitted when a new message is enqueued */
+        readonly MESSAGE_ENQUEUED: "queue:message_enqueued";
+        /** Emitted when a message starts processing */
+        readonly MESSAGE_PROCESSING: "queue:message_processing";
+        /** Emitted when a message is completed */
+        readonly MESSAGE_COMPLETED: "queue:message_completed";
+        /** Emitted when a message fails */
+        readonly MESSAGE_FAILED: "queue:message_failed";
+        /** Emitted when a message is cancelled */
+        readonly MESSAGE_CANCELLED: "queue:message_cancelled";
+        /** Emitted with full queue status update */
+        readonly STATUS_UPDATE: "queue:status_update";
+    };
+};
+/**
+ * Event bus constants for the agent event pub/sub system.
+ * Used by EventBusService for subscription management and notification delivery.
+ */
+export declare const EVENT_BUS_CONSTANTS: {
+    /** Default subscription time-to-live in minutes */
+    readonly DEFAULT_SUBSCRIPTION_TTL_MINUTES: 30;
+    /** Maximum allowed subscription TTL in minutes (24 hours) */
+    readonly MAX_SUBSCRIPTION_TTL_MINUTES: 1440;
+    /** Maximum subscriptions per subscriber session */
+    readonly MAX_SUBSCRIPTIONS_PER_SESSION: 50;
+    /** Maximum total subscriptions across all sessions */
+    readonly MAX_TOTAL_SUBSCRIPTIONS: 200;
+    /** Interval for cleaning up expired subscriptions (ms) */
+    readonly CLEANUP_INTERVAL: 60000;
+    /** Prefix for event notification messages delivered to orchestrator */
+    readonly EVENT_MESSAGE_PREFIX: "EVENT";
+};
+/**
+ * Constants for Slack thread file storage.
+ * Used by SlackThreadStoreService to persist thread conversations
+ * and agent-thread associations.
+ */
+export declare const SLACK_THREAD_CONSTANTS: {
+    /** Directory name under crewly home for thread files */
+    readonly STORAGE_DIR: "slack-threads";
+    /** JSON file mapping agents to their originating threads */
+    readonly AGENT_INDEX_FILE: "agent-index.json";
+    /** File extension for thread conversation files */
+    readonly FILE_EXTENSION: ".md";
+    /** Maximum age for thread files before cleanup (30 days) */
+    readonly MAX_THREAD_AGE_MS: number;
+};
+/**
+ * Constants for Slack bridge fallback delivery.
+ * When the reply-slack skill doesn't deliver within the wait window,
+ * the bridge sends the response directly as a fallback.
+ */
+export declare const SLACK_BRIDGE_CONSTANTS: {
+    /** Time to wait for the reply-slack skill to deliver before fallback (ms) */
+    readonly SKILL_DELIVERY_WAIT_MS: 10000;
+};
+/**
+ * Constants for NOTIFY Slack delivery reconciliation.
+ * Used by NotifyReconciliationService to retry failed Slack deliveries
+ * using persisted chat messages as the source of truth.
+ */
+export declare const NOTIFY_RECONCILIATION_CONSTANTS: {
+    /** Interval between reconciliation runs (5 minutes) */
+    readonly RECONCILIATION_INTERVAL_MS: number;
+    /** Maximum age of messages to consider for reconciliation (24 hours) */
+    readonly MAX_MESSAGE_AGE_MS: number;
+    /** Maximum number of delivery attempts before marking as failed */
+    readonly MAX_DELIVERY_ATTEMPTS: 5;
+    /** Delay before first reconciliation run after startup (30 seconds) */
+    readonly STARTUP_DELAY_MS: number;
+};
+/**
+ * Constants for Claude Code session resume via /resume slash command.
+ * Used when restarting agents that were previously running before a backend restart.
+ */
+export declare const CLAUDE_RESUME_CONSTANTS: {
+    /** Delay after sending /resume for the session picker to appear (ms) */
+    readonly SESSION_PICKER_DELAY_MS: 3000;
+    /** Timeout for Claude to resume and return to prompt (ms) */
+    readonly RESUME_READY_TIMEOUT_MS: 30000;
+};
+/**
+ * Constants for Gemini CLI shell mode detection and escape.
+ * Gemini CLI enters "shell mode" when it receives a `!` prefix or via `/shell`.
+ * In shell mode, input is executed as shell commands instead of being sent to the model.
+ * The prompt changes from `>` to `!` (or `$` in some versions).
+ */
+export declare const GEMINI_SHELL_MODE_CONSTANTS: {
+    /**
+     * Patterns that indicate Gemini CLI is in shell mode.
+     * Matches `!` prompt char (with optional box-drawing border) when NOT followed
+     * by typical chat prompt indicators like "Type your message".
+     */
+    readonly SHELL_MODE_PROMPT_PATTERNS: readonly [RegExp, RegExp];
+    /** Delay after sending Escape to wait for mode switch (ms) */
+    readonly ESCAPE_DELAY_MS: 500;
+    /** Maximum attempts to exit shell mode */
+    readonly MAX_ESCAPE_ATTEMPTS: 3;
+};
+/**
+ * Constants for runtime exit detection monitoring.
+ * Used by RuntimeExitMonitorService to detect when an agent CLI exits.
+ */
+export declare const RUNTIME_EXIT_CONSTANTS: {
+    /** Maximum rolling buffer size for terminal output (bytes) */
+    readonly MAX_BUFFER_SIZE: 8192;
+    /** Debounce delay after exit pattern match before confirming (ms) */
+    readonly CONFIRMATION_DELAY_MS: 500;
+    /**
+     * Grace period after monitoring start to ignore false positives (ms).
+     * Set to 0 because exit patterns (e.g. "Agent powering down",
+     * "Interaction Summary") are specific enough to not appear during
+     * normal runtime initialization output.
+     */
+    readonly STARTUP_GRACE_PERIOD_MS: 0;
+};
+/**
+ * Constants for sub-agent message queue.
+ * Used by SubAgentMessageQueue to buffer messages for agents that haven't
+ * completed initialization (status !== 'active') yet.
+ */
+export declare const SUB_AGENT_QUEUE_CONSTANTS: {
+    /** Maximum messages per agent before dropping oldest */
+    readonly MAX_QUEUE_SIZE: 50;
+    /** Delay between flushed messages on registration (ms) */
+    readonly FLUSH_INTER_MESSAGE_DELAY: 2000;
+};
+/**
+ * Constants for proactive system resource monitoring and alerting.
+ * Used by SystemResourceAlertService to poll metrics, check thresholds,
+ * and send user-facing notifications before resources are exhausted.
+ */
+export declare const SYSTEM_RESOURCE_ALERT_CONSTANTS: {
+    /** Polling interval for resource checks (ms) */
+    readonly POLL_INTERVAL: 60000;
+    /** Cooldown between repeated alerts for the same metric (ms) */
+    readonly ALERT_COOLDOWN: 600000;
+    /** Thresholds for triggering alerts */
+    readonly THRESHOLDS: {
+        readonly DISK_WARNING: 85;
+        readonly DISK_CRITICAL: 95;
+        readonly MEMORY_WARNING: 85;
+        readonly MEMORY_CRITICAL: 95;
+        readonly CPU_WARNING: 80;
+        readonly CPU_CRITICAL: 95;
+    };
+};
+/**
+ * Constants for Slack image download and temporary storage.
+ * Used by SlackImageService to validate, download, and manage
+ * images sent by users in Slack messages.
+ */
+export declare const SLACK_IMAGE_CONSTANTS: {
+    /** Temp directory for downloaded images (relative to ~/.crewly/) */
+    readonly TEMP_DIR: "tmp/slack-images";
+    /** Maximum allowed file size for image downloads (20 MB) */
+    readonly MAX_FILE_SIZE: number;
+    /** Supported image MIME types for download (SVG excluded — not accepted by LLM vision APIs) */
+    readonly SUPPORTED_MIMES: readonly ["image/png", "image/jpeg", "image/gif", "image/webp"];
+    /**
+     * Expected Content-Type prefixes for valid image responses from Slack.
+     * Used to detect when Slack returns an HTML error page instead of an image.
+     */
+    readonly VALID_RESPONSE_CONTENT_TYPES: readonly ["image/"];
+    /**
+     * Magic byte signatures for supported image formats.
+     * Used to verify that a downloaded file is actually an image
+     * (Slack can return 200 OK with an HTML body when auth fails).
+     */
+    readonly IMAGE_MAGIC_BYTES: {
+        readonly PNG: readonly [137, 80, 78, 71];
+        readonly JPEG: readonly [255, 216, 255];
+        readonly GIF87: readonly [71, 73, 70, 56, 55];
+        readonly GIF89: readonly [71, 73, 70, 56, 57];
+        readonly WEBP_RIFF: readonly [82, 73, 70, 70];
+    };
+    /** Interval for cleaning up expired temp files (1 hour) */
+    readonly CLEANUP_INTERVAL: number;
+    /** Maximum age for temp files before cleanup (24 hours) */
+    readonly FILE_TTL: number;
+    /** Maximum concurrent image downloads per message */
+    readonly MAX_CONCURRENT_DOWNLOADS: 3;
+    /** Warning threshold for temp directory total size (500 MB) */
+    readonly MAX_TEMP_DIR_SIZE: number;
+    /** Maximum redirect hops to follow during file download */
+    readonly MAX_DOWNLOAD_REDIRECTS: 5;
+    /** Maximum number of retry attempts for Slack API 429 responses */
+    readonly UPLOAD_MAX_RETRIES: 3;
+    /** Default backoff delay (ms) when no Retry-After header is present */
+    readonly UPLOAD_DEFAULT_BACKOFF_MS: 5000;
+};
+/**
+ * Constants for generic file uploads to Slack channels.
+ * Used by the upload-file endpoint and send-pdf-to-slack skill
+ * to validate and upload arbitrary file types (PDF, images, docs, etc.).
+ */
+export declare const SLACK_FILE_UPLOAD_CONSTANTS: {
+    /** Temp directory for generated PDFs (relative to ~/.crewly/) */
+    readonly TEMP_DIR: "tmp/slack-pdfs";
+    /** Maximum allowed file size for uploads (20 MB — Slack limit) */
+    readonly MAX_FILE_SIZE: number;
+    /** File extensions accepted for upload */
+    readonly SUPPORTED_EXTENSIONS: readonly [".pdf", ".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".txt", ".csv", ".doc", ".docx", ".xls", ".xlsx"];
+    /** Maximum number of retry attempts for Slack API 429 responses */
+    readonly UPLOAD_MAX_RETRIES: 3;
+    /** Default backoff delay (ms) when no Retry-After header is present */
+    readonly UPLOAD_DEFAULT_BACKOFF_MS: 5000;
+};
+/**
+ * Constants for Gemini embedding-based knowledge search.
+ * Used by KnowledgeSearchService when GEMINI_API_KEY is configured.
+ */
+export declare const EMBEDDING_CONSTANTS: {
+    /** Gemini embedding model identifier */
+    readonly GEMINI_MODEL: "text-embedding-004";
+    /** Base endpoint for Gemini generative language API */
+    readonly GEMINI_ENDPOINT: "https://generativelanguage.googleapis.com/v1beta/models";
+    /** Timeout for embedding API calls (ms) */
+    readonly TIMEOUT_MS: 10000;
+    /** Maximum documents to embed in a single batch */
+    readonly MAX_BATCH_SIZE: 20;
+    /** Expected embedding vector dimensions */
+    readonly EMBEDDING_DIMENSIONS: 768;
+};
+export type AgentStatus = (typeof CREWLY_CONSTANTS.AGENT_STATUSES)[keyof typeof CREWLY_CONSTANTS.AGENT_STATUSES];
+export type WorkingStatus = (typeof CREWLY_CONSTANTS.WORKING_STATUSES)[keyof typeof CREWLY_CONSTANTS.WORKING_STATUSES];
+export type RuntimeType = (typeof RUNTIME_TYPES)[keyof typeof RUNTIME_TYPES];
+export type AgentId = string;
+//# sourceMappingURL=constants.d.ts.map

package/dist/backend/backend/src/constants.d.ts.map

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