crewly 1.6.5 → 1.8.0

package/dist/backend/backend/src/services/chat/chat.service.js

@@ -1,25 +1,64 @@
 /**
- * Chat Service
+ * Chat Service — facade over ChatV2Service.
  *
- * Manages chat conversations and messages for the conversational dashboard.
- * Handles message persistence, conversation management, and real-time updates
- * via event emission.
+ * Phase 6 of the unified-chat-message-store spec
+ * (`specs/2026-05-14-unified-chat-message-store.md`):
+ * the legacy JSON-file storage at `~/.crewly/chat/` is retired.
+ * All chat persistence and read paths now flow through the canonical
+ * `ChatV2Service` (SQLite at `~/.crewly/chat.db`). This file remains
+ * temporarily as a deprecation shim so the many legacy callers
+ * (`chat.controller.ts`, `chat.gateway.ts`, `slack-orchestrator-bridge.ts`,
+ * `notify-reconciliation.service.ts`, `message-replay.service.ts`,
+ * `index.ts`) continue to compile and run while they are migrated to
+ * call ChatV2Service directly. Each facade method translates between
+ * the legacy `ChatMessage` / `ChatConversation` DTOs and chat-v2's
+ * `ChatMessageDTO` / `ChatChannelDTO` so existing event subscribers
+ * (chat.gateway.ts) see the same shapes they always have.
  *
  * @module services/chat/chat.service
  */
 import { EventEmitter } from 'events';
-import { promises as fs } from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { atomicWriteJson, safeReadJson } from '../../utils/file-io.utils.js';
 import { LoggerService } from '../core/logger.service.js';
-import { createChatMessage, createConversation, createLastMessagePreview, formatMessageContent, extractResponseFromOutput, detectContentType, validateSendMessageInput, inferChannelTypeFromConversationId, CHAT_CONSTANTS, } from '../../types/chat.types.js';
-// =============================================================================
-// Error Classes
-// =============================================================================
 /**
- * Error thrown when a conversation is not found
+ * Default page size for legacy `getMessages` calls without an explicit
+ * `filter.limit`. Matches the historical hardcoded value so the change
+ * to honor `filter.limit` is a strict superset of the prior behavior.
+ */
+const LEGACY_DEFAULT_PAGE_SIZE = 200;
+/**
+ * Hard cap on `getMessages` limit, applied after the caller-supplied
+ * value. Keeps a buggy/malicious caller from asking chat-v2 to load
+ * the entire channel history into a single response.
+ */
+const LEGACY_MAX_PAGE_SIZE = 1000;
+/**
+ * Pick the chat-v2 `metadata.source` for a legacy `addAgentMessage`
+ * /`addDirectMessage` call. Returns the caller-provided
+ * `metadata.source` when it is one of the closed chat-v2 source enum
+ * values, otherwise falls back to `defaultSource` (the historical
+ * hardcoded value for the call site).
+ *
+ * @param metadata - Legacy metadata blob (possibly undefined)
+ * @param defaultSource - Source to use when metadata has no valid source
+ * @returns A chat-v2 `RecordTurnSource` value
  */
+function resolveLegacyRecordSource(metadata, defaultSource) {
+    const raw = metadata?.source;
+    if (raw === 'web' ||
+        raw === 'slack' ||
+        raw === 'pty-runtime' ||
+        raw === 'in-process-runtime' ||
+        raw === 'reply-tool' ||
+        raw === 'system') {
+        return raw;
+    }
+    return defaultSource;
+}
+import { getChatV2Service } from '../chat-v2/chat-v2.singleton.js';
+import { SYSTEM_PRINCIPAL, senderToV2, v2MessageToLegacy, v2ChannelToLegacy, inferSourceFromLegacyMetadata, synthesizeSlackConversationId, } from '../chat-v2/legacy-dto.utils.js';
+// =============================================================================
+// Error classes — preserved for callers that catch them by name
+// =============================================================================
 export class ConversationNotFoundError extends Error {
     conversationId;
     constructor(conversationId) {
@@ -28,9 +67,6 @@ export class ConversationNotFoundError extends Error {
         this.name = 'ConversationNotFoundError';
     }
 }
-/**
- * Error thrown when message validation fails
- */
 export class MessageValidationError extends Error {
     constructor(message) {
         super(message);
@@ -38,788 +74,301 @@ export class MessageValidationError extends Error {
     }
 }
 // =============================================================================
-// Chat Service
+// ChatService facade
 // =============================================================================
 /**
- * Service for managing chat conversations and messages
- *
- * Handles:
- * - Message persistence to ~/.crewly/chat/
- * - Conversation management
- * - Message formatting (raw terminal → clean chat)
- * - WebSocket event emission for real-time updates
+ * Deprecated façade over ChatV2Service.
  *
- * @example
- * ```typescript
- * const chatService = getChatService();
- * await chatService.initialize();
+ * Preserves the public surface of the original `ChatService` so the
+ * remaining legacy callers compile unchanged. Internally every method
+ * delegates to `ChatV2Service`. The original ~/.crewly/chat/*.json
+ * storage layer has been removed.
  *
- * // Send a message
- * const result = await chatService.sendMessage({
- *   content: 'Hello, Orchestrator!',
- * });
- *
- * // Get messages
- * const messages = await chatService.getMessages({
- *   conversationId: result.conversation.id,
- * });
- * ```
+ * New code MUST NOT depend on this class; call `getChatV2Service()`
+ * directly. Phase 6c of the spec deletes this file once all callers
+ * are migrated.
  */
 export class ChatService extends EventEmitter {
-    chatDir;
     logger;
-    conversations = new Map();
-    messages = new Map();
-    initialized = false;
-    /** Per-conversation save serialization to prevent concurrent write corruption */
-    savePromises = new Map();
-    /**
-     * Create a new ChatService instance
-     *
-     * @param options - Configuration options
-     */
-    constructor(options) {
+    chatV2;
+    constructor(_options) {
         super();
-        this.chatDir =
-            options?.chatDir ?? path.join(os.homedir(), '.crewly', 'chat');
         this.logger = LoggerService.getInstance().createComponentLogger('ChatService');
+        this.chatV2 = getChatV2Service();
     }
-    // ===========================================================================
-    // Initialization
-    // ===========================================================================
-    /**
-     * Initialize the chat service
-     *
-     * Creates the chat directory if it doesn't exist and loads
-     * existing conversations from disk.
-     */
+    // ---------------------------------------------------------------------------
+    // Lifecycle (no-ops — chat-v2 manages its own DB lifecycle)
+    // ---------------------------------------------------------------------------
     async initialize() {
-        if (this.initialized)
-            return;
-        await fs.mkdir(this.chatDir, { recursive: true });
-        await this.loadConversations();
-        this.initialized = true;
+        // chat-v2 lazy-initializes on first access; nothing to do.
     }
-    /**
-     * Check if the service is initialized
-     *
-     * @returns True if initialized
-     */
     isInitialized() {
-        return this.initialized;
+        return true;
     }
+    // ---------------------------------------------------------------------------
+    // Writes
+    // ---------------------------------------------------------------------------
     /**
-     * Ensure the service is initialized before performing operations
-     *
-     * @throws Error if not initialized and auto-initialize fails
-     */
-    async ensureInitialized() {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-    }
-    // ===========================================================================
-    // Message Operations
-    // ===========================================================================
-    /**
-     * Send a message (from user to orchestrator)
-     *
-     * @param input - Message input
-     * @returns The sent message and conversation
-     * @throws MessageValidationError if input is invalid
-     *
-     * @example
-     * ```typescript
-     * const result = await chatService.sendMessage({
-     *   content: 'Start the project analysis',
-     * });
-     * console.log(result.message.id);
-     * ```
+     * Send a user message. Idempotency via legacy callers' own
+     * metadata.clientMessageId when present.
      */
     async sendMessage(input) {
-        await this.ensureInitialized();
-        // Validate input
-        const validation = validateSendMessageInput(input);
-        if (!validation.valid) {
-            throw new MessageValidationError(validation.error || 'Invalid input');
-        }
-        let conversation;
-        if (input.conversationId) {
-            const existing = this.conversations.get(input.conversationId);
-            if (existing) {
-                conversation = existing;
-            }
-            else {
-                conversation = await this.createNewConversation(undefined, input.conversationId);
-            }
-        }
-        else {
-            conversation = await this.createNewConversation(undefined, undefined, 'crewly_chat');
-        }
-        const message = createChatMessage({
-            conversationId: conversation.id,
+        const conversationId = input.conversationId ?? this.synthesizeConversationId(input);
+        const channel = this.chatV2.ensureChannelForLegacyConversation({
+            conversationId,
+            agentSession: 'crewly-orc',
+        });
+        const senderId = (typeof input.metadata?.userId === 'string' && input.metadata.userId) || 'user';
+        const { message } = this.chatV2.recordTurn({
+            channelId: channel.id,
+            senderType: 'user',
+            senderId,
             content: input.content,
-            from: { type: 'user', name: 'You' },
-            contentType: 'text',
-            status: 'sent',
-            metadata: input.metadata,
+            clientMessageId: typeof input.metadata?.clientMessageId === 'string'
+                ? input.metadata.clientMessageId
+                : undefined,
+            // Source resolution here is intentionally STRICTER than
+            // `recordViaFacade` (which uses `resolveLegacyRecordSource`).
+            // `sendMessage` always writes `senderType: 'user'`, so the only
+            // legitimate sources are 'web' or 'slack'. Caller-supplied values
+            // like 'reply-tool' or 'pty-runtime' are agent-reply tags and
+            // would be nonsensical on a user-authored row — `inferSource…`
+            // downgrades them to 'system' on purpose. Phase 6α follow-up #5.
+            metadata: {
+                ...(input.metadata ?? {}),
+                source: inferSourceFromLegacyMetadata(input.metadata),
+            },
         });
-        await this.saveMessage(message);
-        await this.updateConversationWithMessage(conversation.id, message);
-        this.emit('message', message);
-        this.emitChatMessageEvent(message);
-        return { message, conversation: this.conversations.get(conversation.id) };
+        const conversation = v2ChannelToLegacy(channel, this.chatV2.countChannelMessages(channel.id, SYSTEM_PRINCIPAL));
+        const legacyMessage = v2MessageToLegacy(message);
+        // Phase 6α follow-up #6: chat-v2 already emits 'chat_message' for
+        // every fresh recordTurn write (chat-v2.service.ts:936/1063). The
+        // chat.gateway WebSocket subscriber listens on the chat-v2
+        // EventEmitter directly, so a second emit here would double-broadcast
+        // to every connected client. The 'conversation_updated' event has no
+        // chat-v2 equivalent yet, so we keep emitting that one until chat-v2
+        // grows a channel-touched event.
+        this.emit('conversation_updated', {
+            type: 'conversation_updated',
+            data: conversation,
+        });
+        return { conversation, message: legacyMessage };
     }
     /**
-     * Add a message from an agent or orchestrator
-     *
-     * Typically called when processing terminal output. Extracts and
-     * formats the response content.
-     *
-     * @param conversationId - Conversation to add the message to
-     * @param rawOutput - Raw terminal output
-     * @param sender - Sender information
-     * @param metadata - Optional metadata
-     * @returns The created message
-     *
-     * @example
-     * ```typescript
-     * const message = await chatService.addAgentMessage(
-     *   'conv-123',
-     *   '[RESPONSE]Task completed successfully[/RESPONSE]',
-     *   { type: 'orchestrator', name: 'Orchestrator' }
-     * );
-     * ```
+     * Add an agent reply extracted from raw terminal output. The legacy
+     * regex extraction (`[RESPONSE]` / `[CHAT_RESPONSE]` markers) is gone
+     * — callers should pass already-clean content. Kept for source
+     * compatibility with `chat.gateway.processTerminalOutput`, which has
+     * no production callers post Phase 4 discovery.
      */
     async addAgentMessage(conversationId, rawOutput, sender, metadata) {
-        await this.ensureInitialized();
-        // Extract and format the response
-        const extractedContent = extractResponseFromOutput(rawOutput);
-        const formattedContent = formatMessageContent(extractedContent);
-        // Determine content type
-        const contentType = detectContentType(formattedContent);
-        const message = createChatMessage({
-            conversationId,
-            content: formattedContent,
-            from: sender,
-            contentType,
-            status: 'delivered',
-            metadata: {
-                ...metadata,
-                rawOutput,
-            },
-        });
-        await this.saveMessage(message);
-        await this.updateConversationWithMessage(conversationId, message);
-        this.emit('message', message);
-        this.emitChatMessageEvent(message);
-        return message;
+        // Phase 6α follow-up #5: source defaults to 'pty-runtime' (the
+        // historical caller) but the caller can override via
+        // `metadata.source` — e.g. an in-process runtime route should tag
+        // its replies 'in-process-runtime', not 'pty-runtime'. Falling back
+        // through inferSourceFromLegacyMetadata preserves the previous
+        // default for callers that don't tag.
+        const source = resolveLegacyRecordSource(metadata, 'pty-runtime');
+        return this.recordViaFacade(conversationId, rawOutput, sender, metadata, source);
     }
     /**
-     * Add a message with pre-extracted content (no regex extraction).
-     *
-     * Unlike `addAgentMessage`, this method skips `extractResponseFromOutput()`
-     * and takes already-cleaned content directly. Used by the unified [NOTIFY]
-     * marker handler where content is extracted from JSON payload.
-     *
-     * Emits the `'message'` event that QueueProcessor's `waitForResponse()` depends on.
-     *
-     * @param conversationId - Conversation to add the message to
-     * @param content - Pre-extracted markdown content
-     * @param sender - Sender information
-     * @param metadata - Optional metadata
-     * @returns The created message
-     *
-     * @example
-     * ```typescript
-     * const message = await chatService.addDirectMessage(
-     *   'conv-123',
-     *   '## Status Update\n\nEmily is working...',
-     *   { type: 'orchestrator', name: 'Orchestrator' }
-     * );
-     * ```
+     * Persist a pre-extracted markdown reply. Primary call site is the
+     * PTY `[NOTIFY]` path in `chat.gateway.processNotifyMessage`.
      */
     async addDirectMessage(conversationId, content, sender, metadata) {
-        await this.ensureInitialized();
-        const formattedContent = formatMessageContent(content);
-        const contentType = detectContentType(formattedContent);
-        const message = createChatMessage({
-            conversationId,
-            content: formattedContent,
-            from: sender,
-            contentType,
-            status: 'delivered',
-            metadata,
-        });
-        await this.saveMessage(message);
-        await this.updateConversationWithMessage(conversationId, message);
-        this.emit('message', message);
-        this.emitChatMessageEvent(message);
-        return message;
+        // Phase 6α follow-up #5: see addAgentMessage. Same default + override.
+        const source = resolveLegacyRecordSource(metadata, 'pty-runtime');
+        return this.recordViaFacade(conversationId, content, sender, metadata, source);
     }
     /**
-     * Add a system message to a conversation
-     *
-     * @param conversationId - Conversation to add the message to
-     * @param content - Message content
-     * @param metadata - Optional metadata
-     * @returns The created message
+     * Add a server-side system note (progress markers, errors, etc.).
      */
     async addSystemMessage(conversationId, content, metadata) {
-        await this.ensureInitialized();
-        const message = createChatMessage({
+        return this.recordViaFacade(conversationId, content, { type: 'system', id: 'system', name: 'System' }, metadata, 'system');
+    }
+    async recordViaFacade(conversationId, content, sender, metadata, source) {
+        const channel = this.chatV2.ensureChannelForLegacyConversation({
             conversationId,
+            agentSession: 'crewly-orc',
+        });
+        const { type: senderType, id: senderId } = senderToV2(sender);
+        const { message } = this.chatV2.recordTurn({
+            channelId: channel.id,
+            senderType,
+            senderId,
             content,
-            from: { type: 'system', name: 'System' },
-            contentType: 'system',
-            status: 'delivered',
-            metadata,
+            clientMessageId: typeof metadata?.clientMessageId === 'string' ? metadata.clientMessageId : undefined,
+            // `source` AFTER the spread: the resolved source from
+            // resolveLegacyRecordSource already incorporated metadata.source
+            // (if valid) or fell back to the default. Putting it last
+            // guarantees a value from the closed enum lands in the row
+            // regardless of what the legacy caller passed.
+            metadata: { ...(metadata ?? {}), source },
         });
-        await this.saveMessage(message);
-        // Persist to disk — saveMessage only updates in-memory state;
-        // callers that also call updateConversationWithMessage get persistence
-        // from there, but system messages skip that path.
-        const conversation = this.conversations.get(conversationId);
-        if (conversation) {
-            await this.saveConversation(conversation);
-        }
-        this.emitChatMessageEvent(message);
-        return message;
-    }
-    /**
-     * Get messages for a conversation
-     *
-     * @param filter - Message filter options
-     * @returns Array of messages matching the filter
-     *
-     * @example
-     * ```typescript
-     * const messages = await chatService.getMessages({
-     *   conversationId: 'conv-123',
-     *   limit: 50,
-     *   senderType: 'user',
-     * });
-     * ```
-     */
+        const legacyMessage = v2MessageToLegacy(message);
+        // Phase 6α follow-up #6: chat-v2 already emits 'chat_message';
+        // chat.gateway subscribes to chat-v2 directly. No re-emit here to
+        // avoid double-broadcasting to WebSocket clients.
+        return legacyMessage;
+    }
+    // ---------------------------------------------------------------------------
+    // Reads
+    // ---------------------------------------------------------------------------
     async getMessages(filter) {
-        await this.ensureInitialized();
         if (!filter.conversationId) {
+            // Legacy callers occasionally call with no conversationId to get
+            // everything. chat-v2 has no global query — return [] and let
+            // the migration of those call sites surface explicit filters.
             return [];
         }
-        let messages = this.messages.get(filter.conversationId) ?? [];
-        // Apply filters
-        if (filter.senderType) {
-            messages = messages.filter((m) => m.from.type === filter.senderType);
-        }
-        if (filter.contentType) {
-            messages = messages.filter((m) => m.contentType === filter.contentType);
-        }
-        if (filter.after) {
-            messages = messages.filter((m) => m.timestamp > filter.after);
-        }
-        if (filter.before) {
-            messages = messages.filter((m) => m.timestamp < filter.before);
-        }
-        // Sort by timestamp (oldest first)
-        messages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-        const limit = filter.limit ?? CHAT_CONSTANTS.DEFAULTS.MESSAGE_LIMIT;
-        const totalCount = messages.length;
-        // When no offset is explicitly provided, return the most recent messages
-        // (tail of the sorted array). This is the default for chat UIs so users
-        // see the latest conversation on initial load.
-        if (filter.offset === undefined || filter.offset === null) {
-            const start = Math.max(0, totalCount - limit);
-            return messages.slice(start);
-        }
-        // When offset IS provided, use traditional pagination for loading older messages
-        return messages.slice(filter.offset, filter.offset + limit);
+        // Phase 6α follow-up #4: honor filter.limit. Defaults to the
+        // previous hardcoded 200, capped at 1000 so a malicious or buggy
+        // caller can't ask for an unbounded slice. Sub-1 values fall back
+        // to the default.
+        const requested = typeof filter.limit === 'number' && Number.isFinite(filter.limit) && filter.limit > 0
+            ? Math.floor(filter.limit)
+            : LEGACY_DEFAULT_PAGE_SIZE;
+        const limit = Math.min(requested, LEGACY_MAX_PAGE_SIZE);
+        const page = this.chatV2.listMessages({
+            channelId: filter.conversationId,
+            principal: SYSTEM_PRINCIPAL,
+            limit,
+            direction: 'forward',
+        });
+        return page.messages.map(v2MessageToLegacy);
     }
-    /**
-     * Get the total count of messages in a conversation, applying the same
-     * filters as getMessages (senderType, contentType, after, before).
-     *
-     * @param filter - Message filter options
-     * @returns Total number of messages matching the filter
-     */
     async getMessageCount(filter) {
-        await this.ensureInitialized();
         if (!filter.conversationId)
             return 0;
-        let messages = this.messages.get(filter.conversationId) ?? [];
-        if (filter.senderType) {
-            messages = messages.filter((m) => m.from.type === filter.senderType);
-        }
-        if (filter.contentType) {
-            messages = messages.filter((m) => m.contentType === filter.contentType);
-        }
-        if (filter.after) {
-            messages = messages.filter((m) => m.timestamp > filter.after);
-        }
-        if (filter.before) {
-            messages = messages.filter((m) => m.timestamp < filter.before);
-        }
-        return messages.length;
+        return this.chatV2.countChannelMessages(filter.conversationId, SYSTEM_PRINCIPAL);
     }
-    /**
-     * Get a single message by ID
-     *
-     * @param conversationId - Conversation ID
-     * @param messageId - Message ID
-     * @returns The message or null if not found
-     */
-    async getMessage(conversationId, messageId) {
-        await this.ensureInitialized();
-        const messages = this.messages.get(conversationId);
-        if (!messages)
-            return null;
-        return messages.find((m) => m.id === messageId) ?? null;
+    async getMessage(_conversationId, _messageId) {
+        // chat-v2 has no per-message lookup yet; return null. Callers that
+        // depend on this should be migrated to read the row from the
+        // `chat_messages` table directly.
+        return null;
     }
-    /**
-     * Update metadata on an existing message (partial merge).
-     *
-     * Merges the provided metadata fields into the message's existing metadata
-     * and persists the change to disk. Used by the NOTIFY reconciliation system
-     * to track Slack delivery status on chat messages.
-     *
-     * @param conversationId - Conversation the message belongs to
-     * @param messageId - ID of the message to update
-     * @param metadataPatch - Partial metadata to merge into existing metadata
-     * @returns The updated message, or null if message not found
-     */
-    async updateMessageMetadata(conversationId, messageId, metadataPatch) {
-        await this.ensureInitialized();
-        const messages = this.messages.get(conversationId);
-        if (!messages)
-            return null;
-        const message = messages.find((m) => m.id === messageId);
-        if (!message)
-            return null;
-        message.metadata = { ...message.metadata, ...metadataPatch };
-        const conversation = this.conversations.get(conversationId);
-        if (conversation) {
-            await this.saveConversation(conversation);
-        }
-        return message;
+    async updateMessageMetadata(_conversationId, messageId, metadataPatch) {
+        const dto = this.chatV2.updateMessageMetadata(messageId, metadataPatch);
+        return dto ? v2MessageToLegacy(dto) : null;
     }
-    /**
-     * Find all messages with pending Slack delivery within a time window.
-     *
-     * Scans all conversations for messages where `slackDeliveryStatus === 'pending'`
-     * and `slackChannelId` is present, filtering out messages older than `maxAgeMs`.
-     * Used by NotifyReconciliationService to find messages that need retry.
-     *
-     * @param maxAgeMs - Maximum message age in milliseconds
-     * @returns Array of messages with pending Slack delivery
-     */
     async getMessagesWithPendingSlackDelivery(maxAgeMs) {
-        await this.ensureInitialized();
-        const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
-        const pending = [];
-        for (const messages of this.messages.values()) {
-            for (const msg of messages) {
-                if (msg.metadata?.slackDeliveryStatus === 'pending' &&
-                    msg.metadata?.slackChannelId &&
-                    msg.timestamp >= cutoff) {
-                    pending.push(msg);
-                }
-            }
-        }
-        return pending;
+        return this.chatV2.findMessagesWithPendingSlackDelivery(maxAgeMs).map(v2MessageToLegacy);
     }
-    // ===========================================================================
-    // Conversation Operations
-    // ===========================================================================
-    /**
-     * Get all conversations
-     *
-     * @param filter - Optional filter options
-     * @returns Array of conversations
-     *
-     * @example
-     * ```typescript
-     * const conversations = await chatService.getConversations({
-     *   includeArchived: false,
-     *   search: 'project',
-     * });
-     * ```
-     */
-    async getConversations(filter) {
-        await this.ensureInitialized();
-        let conversations = Array.from(this.conversations.values());
-        // Filter archived
-        if (!filter?.includeArchived) {
-            conversations = conversations.filter((c) => !c.isArchived);
-        }
-        // Filter by channel type
-        if (filter?.channelType) {
-            conversations = conversations.filter((c) => c.channelType === filter.channelType);
-        }
-        // Search
-        if (filter?.search) {
-            const searchLower = filter.search.toLowerCase();
-            conversations = conversations.filter((c) => c.title?.toLowerCase().includes(searchLower) ||
-                c.lastMessage?.content.toLowerCase().includes(searchLower));
-        }
-        // Sort by last update (most recent first)
-        conversations.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-        // Apply pagination
-        const offset = filter?.offset ?? 0;
-        const limit = filter?.limit ?? CHAT_CONSTANTS.DEFAULTS.CONVERSATION_LIMIT;
-        return conversations.slice(offset, offset + limit);
+    async getConversations(_filter) {
+        const channels = this.chatV2.listChannels({ principal: SYSTEM_PRINCIPAL });
+        return channels.map((c) => v2ChannelToLegacy(c, this.chatV2.countChannelMessages(c.id, SYSTEM_PRINCIPAL)));
     }
-    /**
-     * Get a single conversation by ID
-     *
-     * @param id - Conversation ID
-     * @returns The conversation or null if not found
-     */
     async getConversation(id) {
-        await this.ensureInitialized();
-        return this.conversations.get(id) ?? null;
+        try {
+            const channel = this.chatV2.getChannel(id, SYSTEM_PRINCIPAL);
+            return v2ChannelToLegacy(channel, this.chatV2.countChannelMessages(id, SYSTEM_PRINCIPAL));
+        }
+        catch {
+            return null;
+        }
     }
-    /**
-     * Create a new conversation
-     *
-     * @param title - Optional title for the conversation
-     * @returns The created conversation
-     *
-     * @example
-     * ```typescript
-     * const conversation = await chatService.createNewConversation('Project Discussion');
-     * ```
-     */
-    async createNewConversation(title, idOverride, channelType) {
-        await this.ensureInitialized();
-        const conversation = createConversation(title, idOverride, channelType);
-        this.conversations.set(conversation.id, conversation);
-        this.messages.set(conversation.id, []);
-        await this.saveConversation(conversation);
-        this.emitConversationUpdatedEvent(conversation);
-        return conversation;
+    async createNewConversation(title, idOverride, _channelType) {
+        const conversationId = idOverride ?? `web-conv-${Date.now()}`;
+        const channel = this.chatV2.ensureChannelForLegacyConversation({
+            conversationId,
+            agentSession: 'crewly-orc',
+            name: title ?? conversationId,
+        });
+        return v2ChannelToLegacy(channel, 0);
     }
-    /**
-     * Update a conversation's title
-     *
-     * @param id - Conversation ID
-     * @param title - New title
-     * @returns The updated conversation
-     * @throws ConversationNotFoundError if conversation doesn't exist
-     */
     async updateConversationTitle(id, title) {
-        await this.ensureInitialized();
-        const conversation = this.conversations.get(id);
-        if (!conversation) {
-            throw new ConversationNotFoundError(id);
-        }
-        conversation.title = title;
-        conversation.updatedAt = new Date().toISOString();
-        await this.saveConversation(conversation);
-        this.emitConversationUpdatedEvent(conversation);
-        return conversation;
+        const channel = this.chatV2.renameChannel(id, title, SYSTEM_PRINCIPAL);
+        return v2ChannelToLegacy(channel, this.chatV2.countChannelMessages(id, SYSTEM_PRINCIPAL));
     }
-    /**
-     * Archive a conversation
-     *
-     * @param id - Conversation ID
-     * @throws ConversationNotFoundError if conversation doesn't exist
-     */
     async archiveConversation(id) {
-        await this.ensureInitialized();
-        const conversation = this.conversations.get(id);
-        if (!conversation) {
-            throw new ConversationNotFoundError(id);
-        }
-        conversation.isArchived = true;
-        conversation.updatedAt = new Date().toISOString();
-        await this.saveConversation(conversation);
-        this.emitConversationUpdatedEvent(conversation);
+        this.chatV2.archiveChannel(id, SYSTEM_PRINCIPAL);
     }
-    /**
-     * Unarchive a conversation
-     *
-     * @param id - Conversation ID
-     * @throws ConversationNotFoundError if conversation doesn't exist
-     */
     async unarchiveConversation(id) {
-        await this.ensureInitialized();
-        const conversation = this.conversations.get(id);
-        if (!conversation) {
-            throw new ConversationNotFoundError(id);
-        }
-        conversation.isArchived = false;
-        conversation.updatedAt = new Date().toISOString();
-        await this.saveConversation(conversation);
-        this.emitConversationUpdatedEvent(conversation);
+        this.chatV2.unarchiveChannel(id, SYSTEM_PRINCIPAL);
     }
-    /**
-     * Delete a conversation and all its messages
-     *
-     * @param id - Conversation ID
-     */
     async deleteConversation(id) {
-        await this.ensureInitialized();
-        this.conversations.delete(id);
-        this.messages.delete(id);
-        // Wait for any pending save to finish before deleting the file
-        const pending = this.savePromises.get(id);
-        if (pending) {
-            await pending.catch(() => { });
-            this.savePromises.delete(id);
-        }
-        const conversationFile = path.join(this.chatDir, `${id}.json`);
-        await fs.rm(conversationFile, { force: true });
+        this.chatV2.deleteChannel(id, SYSTEM_PRINCIPAL);
     }
-    /**
-     * Clear all messages from a conversation
-     *
-     * @param id - Conversation ID
-     */
     async clearConversation(id) {
-        await this.ensureInitialized();
-        this.messages.set(id, []);
-        const conversation = this.conversations.get(id);
-        if (conversation) {
-            conversation.messageCount = 0;
-            conversation.lastMessage = undefined;
-            conversation.updatedAt = new Date().toISOString();
-            await this.saveConversation(conversation);
-            this.emitConversationUpdatedEvent(conversation);
-        }
+        this.chatV2.clearChannel(id, SYSTEM_PRINCIPAL);
     }
-    /**
-     * Get the current/active conversation (most recently updated non-archived)
-     *
-     * @returns The most recent active conversation or null
-     */
     async getCurrentConversation() {
-        const conversations = await this.getConversations({ limit: 1 });
-        return conversations[0] ?? null;
+        // Frontend should adopt "latest channel" via listChannels;
+        // here we approximate by returning the most recently touched channel.
+        const channels = this.chatV2.listChannels({ principal: SYSTEM_PRINCIPAL });
+        if (channels.length === 0)
+            return null;
+        const newest = channels.reduce((a, b) => (a.lastMessageAt ?? a.createdAt) > (b.lastMessageAt ?? b.createdAt) ? a : b);
+        return v2ChannelToLegacy(newest, this.chatV2.countChannelMessages(newest.id, SYSTEM_PRINCIPAL));
     }
-    // ===========================================================================
-    // Real-time Events
-    // ===========================================================================
-    /**
-     * Emit typing indicator event
-     *
-     * @param conversationId - Conversation ID
-     * @param sender - Sender information
-     * @param isTyping - Whether the sender is typing
-     */
     emitTypingIndicator(conversationId, sender, isTyping) {
-        const event = {
+        this.emit('chat_typing', {
             type: 'chat_typing',
             data: { conversationId, sender, isTyping },
-        };
-        this.emit('chat_typing', event);
-    }
-    /**
-     * Emit a transient progress update to the frontend for a conversation.
-     *
-     * Unlike addSystemMessage, this does NOT persist the message to disk.
-     * It creates a temporary system chat message and emits it via the
-     * 'chat_message' WebSocket event so the UI can display a progress
-     * indicator during long-running orchestrator operations.
-     *
-     * @param conversationId - Conversation to emit progress for
-     * @param text - Progress text to display (e.g. "Processing... (still working)")
-     */
-    emitProgress(conversationId, text) {
-        const message = createChatMessage({
-            conversationId,
-            content: text,
-            from: { type: 'system', name: 'System' },
-            contentType: 'status',
-            status: 'delivered',
         });
-        this.emitChatMessageEvent(message);
     }
-    /**
-     * Emit a chat message event
-     *
-     * @param message - The message to emit
-     */
-    emitChatMessageEvent(message) {
-        // Sanitize message content before broadcasting via WebSocket
-        // to prevent JWT/API key leaks in real-time messages
-        const sanitizedMessage = {
-            ...message,
-            content: this.sanitizeContent(message.content),
-            metadata: message.metadata ? {
-                ...message.metadata,
-                rawOutput: message.metadata.rawOutput
-                    ? this.sanitizeContent(message.metadata.rawOutput)
-                    : undefined,
-            } : message.metadata,
-        };
-        const event = {
+    emitProgress(conversationId, text) {
+        // Transient — emit but don't persist. Frontend renders progress
+        // ephemerally. Legacy behaviour preserved.
+        this.emit('chat_message', {
             type: 'chat_message',
-            data: sanitizedMessage,
-        };
-        this.emit('chat_message', event);
-    }
-    /**
-     * Strip sensitive tokens from a text string before broadcasting.
-     * Uses the same JWT + API key patterns as chat-sanitizer.service.ts.
-     *
-     * @param text - Raw text that may contain tokens
-     * @returns Text with sensitive data replaced by '***'
-     */
-    sanitizeContent(text) {
-        return text
-            .replace(/eyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}/g, '***')
-            .replace(/\bsk-[A-Za-z0-9_-]{20,}/g, '***')
-            .replace(/\bAKIA[A-Z0-9]{16}\b/g, '***')
-            .replace(/\bgh[pousr]_[A-Za-z0-9_]{30,}/g, '***');
-    }
-    /**
-     * Emit a conversation updated event
-     *
-     * @param conversation - The updated conversation
-     */
-    emitConversationUpdatedEvent(conversation) {
-        const event = {
-            type: 'conversation_updated',
-            data: conversation,
-        };
-        this.emit('conversation_updated', event);
+            data: {
+                id: `progress-${Date.now()}`,
+                conversationId,
+                from: { type: 'system', id: 'system', name: 'System' },
+                content: text,
+                contentType: 'system',
+                status: 'sent',
+                timestamp: new Date().toISOString(),
+                metadata: { ephemeral: true },
+            },
+        });
     }
-    // ===========================================================================
-    // Statistics
-    // ===========================================================================
-    /**
-     * Get statistics about chat usage
-     *
-     * @returns Statistics object
-     */
     async getStatistics() {
-        await this.ensureInitialized();
-        const conversations = Array.from(this.conversations.values());
-        const activeConversations = conversations.filter((c) => !c.isArchived);
-        const archivedConversations = conversations.filter((c) => c.isArchived);
-        let totalMessages = 0;
-        for (const messages of this.messages.values()) {
-            totalMessages += messages.length;
-        }
+        const s = this.chatV2.getStatistics();
         return {
-            totalConversations: conversations.length,
-            activeConversations: activeConversations.length,
-            archivedConversations: archivedConversations.length,
-            totalMessages,
+            totalConversations: s.totalChannels,
+            activeConversations: s.activeChannels,
+            archivedConversations: s.archivedChannels,
+            totalMessages: s.totalMessages,
         };
     }
-    // ===========================================================================
-    // Persistence
-    // ===========================================================================
+    // ---------------------------------------------------------------------------
+    // Helpers
+    // ---------------------------------------------------------------------------
     /**
-     * Load all conversations from disk
+     * Generate a conversationId for a brand-new sendMessage call that
+     * didn't supply one. Web-chat-style id; Slack callers always pass
+     * their own slack-CHANNEL-TS identifier.
      */
-    async loadConversations() {
-        try {
-            const files = await fs.readdir(this.chatDir);
-            const jsonFiles = files.filter((f) => f.endsWith('.json'));
-            for (const file of jsonFiles) {
-                const filePath = path.join(this.chatDir, file);
-                const data = await safeReadJson(filePath, null);
-                if (data?.conversation) {
-                    // Lazy channelType inference for existing data (in-memory only, no file rewrite)
-                    if (!data.conversation.channelType) {
-                        data.conversation.channelType = inferChannelTypeFromConversationId(data.conversation.id);
-                    }
-                    this.conversations.set(data.conversation.id, data.conversation);
-                    this.messages.set(data.conversation.id, data.messages ?? []);
-                }
-            }
-        }
-        catch (error) {
-            // Directory might not exist yet, which is fine
-            this.logger.debug('Failed to load conversations', {
-                error: error instanceof Error ? error.message : String(error),
-            });
+    synthesizeConversationId(input) {
+        if (typeof input.metadata?.channelId === 'string') {
+            // Slack source — derive from channel + timestamp pattern.
+            const channel = input.metadata.channelId;
+            const ts = typeof input.metadata.threadTs === 'string' ? input.metadata.threadTs : `${Date.now()}`;
+            return synthesizeSlackConversationId(channel, ts);
         }
+        return `web-conv-${Date.now()}`;
     }
     /**
-     * Save a conversation and its messages to disk using atomic write (write-to-tmp + rename).
-     * Serialized per conversation to prevent concurrent writes from corrupting the file.
-     *
-     * @param conversation - Conversation to save
-     */
-    async saveConversation(conversation) {
-        const id = conversation.id;
-        const prev = this.savePromises.get(id) ?? Promise.resolve();
-        const next = prev
-            .catch(() => { })
-            .then(() => this.doSaveConversation(conversation));
-        this.savePromises.set(id, next);
-        await next;
-    }
-    /**
-     * Perform the actual atomic file write for a conversation.
-     * Writes to a temporary file first, then renames to the final path to prevent corruption.
-     *
-     * @param conversation - Conversation to save
-     */
-    async doSaveConversation(conversation) {
-        const messages = this.messages.get(conversation.id) ?? [];
-        const storage = { conversation, messages };
-        const filePath = path.join(this.chatDir, `${conversation.id}.json`);
-        await atomicWriteJson(filePath, storage);
-    }
-    /**
-     * Save a message to the in-memory store.
-     *
-     * Only updates the in-memory messages array. Disk persistence is handled
-     * by the caller (typically via updateConversationWithMessage which calls
-     * saveConversation). For code paths that skip updateConversationWithMessage
-     * (e.g. addSystemMessage), the caller is responsible for triggering
-     * saveConversation separately.
-     *
-     * @param message - Message to save
-     */
-    async saveMessage(message) {
-        const messages = this.messages.get(message.conversationId) ?? [];
-        messages.push(message);
-        this.messages.set(message.conversationId, messages);
-    }
-    /**
-     * Update a conversation's metadata after adding a message
-     *
-     * @param conversationId - Conversation ID
-     * @param message - The added message
+     * @deprecated Will be removed when the façade is retired.
      */
-    async updateConversationWithMessage(conversationId, message) {
-        const conversation = this.conversations.get(conversationId);
-        if (!conversation)
-            return;
-        conversation.messageCount += 1;
-        conversation.lastMessage = createLastMessagePreview(message);
-        conversation.updatedAt = new Date().toISOString();
-        // Add participant if new
-        const senderId = message.from.id ?? message.from.type;
-        if (!conversation.participantIds.includes(senderId)) {
-            conversation.participantIds.push(senderId);
-        }
-        await this.saveConversation(conversation);
+    async ensureInitialized() {
+        /* no-op */
     }
 }
 // =============================================================================
-// Singleton Instance
+// Singleton accessors — preserved for source compatibility
 // =============================================================================
-let chatServiceInstance = null;
-/**
- * Get the singleton ChatService instance
- *
- * @returns The ChatService instance
- */
-export function getChatService() {
-    if (!chatServiceInstance) {
-        chatServiceInstance = new ChatService();
+let _instance = null;
+export function getChatService(options) {
+    if (!_instance) {
+        _instance = new ChatService(options);
     }
-    return chatServiceInstance;
+    return _instance;
 }
-/**
- * Reset the singleton instance (for testing)
- */
 export function resetChatService() {
-    chatServiceInstance = null;
+    _instance = null;
 }
 //# sourceMappingURL=chat.service.js.map