crewly 1.6.5 → 1.7.0

package/dist/backend/backend/src/index.js

@@ -25,6 +25,7 @@ import { getSettingsService } from './services/settings/index.js';
 import { MemoryService } from './services/memory/memory.service.js';
 import { getImprovementStartupService } from './services/orchestrator/improvement-startup.service.js';
 import { initializeSlackIfConfigured, shutdownSlack } from './services/slack/index.js';
+import { resolveTeamByIdOrSlug, slugifyTeamName } from './services/workflow/team-identifier-resolver.js';
 import { initializeWhatsAppIfConfigured, shutdownWhatsApp } from './services/whatsapp/index.js';
 import { initializeGoogleChatIfConfigured } from './services/messaging/google-chat-initializer.js';
 import { initializeTelegramIfConfigured, shutdownTelegram } from './services/telegram/index.js';
@@ -34,6 +35,7 @@ import { ThreadStatusQueueService } from './services/messaging/thread-status-que
 import { EventBusService } from './services/event-bus/index.js';
 import { EventToWorkItemBridge } from './services/event-bus/event-to-workitem-bridge.service.js';
 import { AutoLearningSubscriber } from './services/memory/auto-learning.subscriber.js';
+import { MilestoneNotificationSubscriber } from './services/notification/milestone-notification.subscriber.js';
 import { RequestSlaSubscriber, setRequestSlaSubscriber, } from './services/v3/request-sla.subscriber.js';
 import { RequestDecomposeSubscriber, setRequestDecomposeSubscriber, } from './services/v3/request-decompose.subscriber.js';
 import { RequestStatusUpdateSubscriber } from './services/v3/request-status-update.subscriber.js';
@@ -138,6 +140,9 @@ export class CrewlyServer {
     eventToWorkItemBridge = null;
     /** LEARN-1: subscribes to terminal task / mission:replanned events and auto-records learnings. */
     autoLearningSubscriber = null;
+    // DF-1 #438 — symmetric to AutoLearningSubscriber; surfaces milestones
+    // to orc's chat queue.
+    milestoneNotificationSubscriber = null;
     /** INBOUND-1: subscribes to request:created and tracks 5/10 min SLA on respond_to_user WIs. */
     requestSlaSubscriber = null;
     /** Pipeline-#4 follow-up: subscribes to request:created and auto-decomposes actionable L2 Requests via plan() → addToPool. */
@@ -330,6 +335,19 @@ export class CrewlyServer {
         // contract (V1) and the V7/V9 self-checks in the co-located test.
         this.autoLearningSubscriber = AutoLearningSubscriber.boot(this.eventBusService);
         this.autoLearningSubscriber.start();
+        // DF-1 #438: symmetric notification subscriber. Same architectural
+        // pattern as AutoLearningSubscriber — listens to terminal lifecycle
+        // events (`task:verified`, `mission:replanned`) and enqueues a
+        // `[MILESTONE]` envelope into orc's chat queue. The QW-3 row in
+        // `config/roles/orchestrator/prompt.md` (#436) handles the
+        // always-forward-to-owner rule on the orc side; this subscriber
+        // closes the gap where an agent ships work but forgets to call
+        // `report-status --status milestone` (the agent-side QW-1 path).
+        this.milestoneNotificationSubscriber = new MilestoneNotificationSubscriber({
+            eventBus: this.eventBusService,
+            messageQueueService: this.messageQueueService,
+        });
+        this.milestoneNotificationSubscriber.start();
         // INBOUND-1 + Pipeline-#4 follow-up: wire RequestService → bus, then
         // boot both v3 subscribers (SLA tracker + auto-decompose). Order
         // matters within the block: setRequestServiceEventBus must run
@@ -473,28 +491,45 @@ export class CrewlyServer {
                 }
             }
         });
+        // Shared LiveReconcilerDataProvider instance used by both the
+        // Reconciler service and the TeamHealthWatchdog data provider.
+        // Sharing is required so the memory-pressure broadcast state
+        // (`consecutivePressureSkips` / `lastPressureNotifiedAt`) is
+        // counted ONCE per sustained pressure episode. Two separate
+        // instances would each cross the 5-skip threshold around the same
+        // time and publish two `system:memory_pressure` events with
+        // distinct `event.id` values (no debounce match), so orc would
+        // receive duplicates. See follow-up #5 from PR #543 review.
+        const liveDataProvider = new LiveReconcilerDataProvider();
+        liveDataProvider.setEventBus(this.eventBusService);
+        // Wire AgentRegistrationService so the memory-pressure eviction
+        // path can terminate idle agents to free wake slots (issue surfaced
+        // 2026-05-16: queued WIs for inactive Atlas could not get woken
+        // because the floor was held by idle product/marketing agents).
+        liveDataProvider.setAgentRegistrationService(this.apiController.agentRegistrationService);
         // Initialize Reconciler Service (V2 — system truth recomputation)
         {
             const reconcilerLogger = LoggerService.getInstance().createComponentLogger('ReconcilerInit');
             // Live data provider — connects Reconciler to Task Pool, Claim Service,
             // Storage Service, and Agent Suspend for real reconciliation including
             // Hybrid Wake (auto-rehydrating suspended agents when tasks go unclaimed).
-            const liveDataProvider = new LiveReconcilerDataProvider();
             this.reconcilerService = new ReconcilerService(liveDataProvider);
             setReconcilerService(this.reconcilerService);
             // Subscribe EventBus events for targeted reconciliation
             if (this.reconcilerService) {
                 const reconciler = this.reconcilerService;
-                const eventTypes = ['agent:idle', 'task:completed', 'task:failed', 'agent:inactive'];
-                for (const eventType of eventTypes) {
-                    this.eventBusService.subscribe({
-                        eventType,
-                        filter: {},
-                        subscriberSession: '__reconciler__',
-                        oneShot: false,
-                        ttlMinutes: 525_600, // 1 year — permanent subscription
-                    });
-                }
+                // 2026-05-15 Steve dogfood: the prior `subscribe({ subscriberSession:
+                // '__reconciler__' })` loop here was redundant AND wrong. The
+                // subscribe path routes critical events through
+                // `MessageQueueService.enqueue` keyed by `targetSession`, which
+                // then fails noisily because `__reconciler__` is not a PTY
+                // session ("Session '__reconciler__' does not exist", every
+                // reconciler tick). The in-process `event_published` listener
+                // below already drives the reconciler — no second wiring needed.
+                // Removed the subscribe-block; if a future change needs persistent
+                // metadata for the reconciler subscription, attach it as a real
+                // in-process subscriber via `onInProcess` rather than the
+                // session-targeted `subscribe` API.
                 // Listen for all published events and trigger targeted reconciliation
                 this.eventBusService.on('event_published', (payload) => {
                     const targetedEventTypes = ['task:completed', 'task:failed', 'agent:idle', 'agent:inactive'];
@@ -527,9 +562,11 @@ export class CrewlyServer {
                     thwLogger.warn('Reconciler not available; skipping TeamHealthWatchdog init.');
                 }
                 else {
-                    const reconcilerProvider = new LiveReconcilerDataProvider();
+                    // Reuse the shared LiveReconcilerDataProvider declared
+                    // above (follow-up #5 from PR #543 review) — instantiating
+                    // a second copy would double-broadcast memory-pressure.
                     const dataProvider = new LiveTeamHealthDataProvider({
-                        reconcilerProvider,
+                        reconcilerProvider: liveDataProvider,
                         getTeams: async () => StorageService.getInstance().getTeams(),
                         bootedAt: new Date(),
                     });
@@ -1078,6 +1115,11 @@ export class CrewlyServer {
                 const chatDispatcher = new ChatV2DispatcherService({
                     agentSink: this.apiController.agentRegistrationService,
                     mentionResolver: chatMentionResolver,
+                    // Phase B-2 — huddle roster lookup. ChatV2Service owns
+                    // the chat_channel_members table; the dispatcher just
+                    // needs the list of session names for a given channel
+                    // to fan-out a user message to every huddle member.
+                    huddleMembersFor: (channelId) => chatService.queryHuddleMembersForDispatch(channelId),
                 });
                 this.chatV2Gateway = chatGateway;
                 this.chatV2Dispatcher = chatDispatcher;
@@ -1089,6 +1131,39 @@ export class CrewlyServer {
                     path: '/ws/chat',
                     authMode: jwtSecret ? 'jwt' : 'dev-anonymous',
                 });
+                // Cloud Portal relay bridge — gives the Crewly Portal at
+                // crewlyai.com the same /agents experience by tunnelling chat-v2
+                // RPC calls through the Cloud relay queue + forwarding gateway
+                // broadcasts as `chat_event` messages. Only wired when Cloud Sync
+                // is running (BrowserRelayAdapter pattern).
+                try {
+                    const { ChatV2RelayAdapter } = await import('./services/chat-v2/chat-v2.relay-adapter.service.js');
+                    const { CloudSyncService } = await import('./services/cloud/cloud-sync.service.js');
+                    const { createOssAgentDirectoryProvider, createOssAgentPresenceProvider, } = await import('./services/chat-v2/chat-v2.providers.js');
+                    const sync = CloudSyncService.getInstance();
+                    if (sync) {
+                        const chatRelayAdapter = new ChatV2RelayAdapter({
+                            service: chatService,
+                            gateway: chatGateway,
+                            cloudSync: sync,
+                            // Wire the dispatcher so Portal-sent user messages also fire the
+                            // agent-side prompt (parity with the HTTP controller path).
+                            // Without this, Portal user-messages persist but the bound agent
+                            // never receives the `[CHAT:<id>]` prompt — orc/etc. stay silent.
+                            dispatcher: chatDispatcher,
+                            directory: createOssAgentDirectoryProvider(this.storageService),
+                            presence: createOssAgentPresenceProvider(this.storageService),
+                        });
+                        chatRelayAdapter.start();
+                        this.logger.info('ChatV2RelayAdapter started — Cloud Portal can now drive chat-v2 via relay');
+                    }
+                }
+                catch (err) {
+                    // Adapter wiring failure is non-fatal — local OSS UI still works.
+                    this.logger.warn('ChatV2RelayAdapter wiring skipped', {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
                 // Onboarding v3 (B1) — wire the cold-start detector with the
                 // chat-v2 service we just stood up. The orc bootstrap path
                 // (CrewlyAgentRuntimeService.detectOnboardingMode) probes this
@@ -1209,6 +1284,7 @@ export class CrewlyServer {
             // resume notification won't re-send already-answered conversations.
             try {
                 const { RequestService } = await import('./services/v3/request.service.js');
+                const { extractSlackChannelId, extractSlackThreadTs } = await import('./services/v3/request-sla.subscriber.js');
                 const reqSvc = RequestService.getInstance();
                 const allReqs = await reqSvc.listAll();
                 let backfilled = 0;
@@ -1216,13 +1292,17 @@ export class CrewlyServer {
                     if (req.status !== 'done')
                         continue;
                     const scid = req.sourceConversationItemId || '';
-                    if (!scid.startsWith('slack-'))
+                    // `extractSlack*` strips the optional `-msg-{ts}` thread-reply
+                    // suffix before parsing, so both top-level and in-thread
+                    // Requests resolve to the canonical `{channelId}:{threadRoot}`.
+                    // Previously a local regex was used here and its greedy `.+`
+                    // swallowed the suffix, producing a malformed threadKey that
+                    // missed the dedup check and bloated the persistence file.
+                    const channelId = extractSlackChannelId(scid);
+                    const threadTs = extractSlackThreadTs(scid);
+                    if (!channelId || !threadTs)
                         continue;
-                    const m = scid.match(/^slack-(.+)-(\d+)[.-](\d+)$/);
-                    if (!m)
-                        continue;
-                    const [, channelId, t1, t2] = m;
-                    const threadKey = `${channelId}:${t1}.${t2}`;
+                    const threadKey = `${channelId}:${threadTs}`;
                     if (this.threadStatusQueueService.get(threadKey))
                         continue;
                     this.threadStatusQueueService.trackInbound({
@@ -1248,9 +1328,7 @@ export class CrewlyServer {
             // but before the queue processor starts (so replayed messages are ready for delivery).
             try {
                 const { MessageReplayService } = await import('./services/messaging/message-replay.service.js');
-                const { getChatService } = await import('./services/chat/chat.service.js');
-                const chatService = getChatService();
-                const replayService = new MessageReplayService(this.messageQueueService, chatService, this.config.crewlyHome);
+                const replayService = new MessageReplayService(this.messageQueueService, this.config.crewlyHome);
                 const replayResult = await replayService.replayPendingMessages();
                 if (replayResult.replayedCount > 0) {
                     this.logger.info('Replayed pending messages from offline period (#247)', {
@@ -1306,6 +1384,16 @@ export class CrewlyServer {
                     this.logger.info('Executing cron task', { id: task.id, target: task.targetAgent });
                     await registrationRef.sendMessageToAgent(task.targetAgent, `[CRON_TASK:${task.id}] ${task.taskDescription}`);
                 });
+                // Issue #307: cron tasks created with `targetTeamId` set to a
+                // name slug (e.g. "stock-ops-team") instead of the UUID would
+                // silently 404 on every fire — `teams.find(t => t.id === teamId)`
+                // returned undefined and both callbacks returned `false` with
+                // no log surface. `resolveTeamByIdOrSlug` (imported statically
+                // at the top of the file) tries UUID first, then falls back
+                // to a slug match against `name`. Misses now surface a distinct
+                // warn-log with the available slugs so the cause is visible
+                // instead of hiding behind the generic "agent offline" warn
+                // from cron-task.service.
                 cronTaskService.setAgentStatusCallback(async (sessionName, teamId) => {
                     // Handle orchestrator separately — it's not in regular teams
                     if (sessionName === CREWLY_CONSTANTS.SESSIONS.ORCHESTRATOR_NAME || teamId === 'orchestrator') {
@@ -1313,9 +1401,16 @@ export class CrewlyServer {
                         return orchStatus?.agentStatus === 'active' || orchStatus?.agentStatus === 'started';
                     }
                     const teams = await storageRef.getTeams();
-                    const team = teams.find((t) => t.id === teamId);
-                    if (!team)
+                    const team = resolveTeamByIdOrSlug(teams, teamId);
+                    if (!team) {
+                        this.logger.warn('CronTask: targetTeamId resolves to no team', {
+                            sessionName,
+                            targetTeamId: teamId,
+                            availableSlugs: teams.slice(0, 10).map((t) => slugifyTeamName(t.name)),
+                            hint: 'Set targetTeamId to either the team UUID or one of availableSlugs (lowercase, spaces→-)',
+                        });
                         return false;
+                    }
                     const member = team.members.find((m) => m.sessionName === sessionName);
                     if (!member)
                         return false;
@@ -1325,16 +1420,25 @@ export class CrewlyServer {
                 cronTaskService.setAgentStartCallback(async (sessionName, teamId) => {
                     try {
                         const teams = await storageRef.getTeams();
-                        const team = teams.find((t) => t.id === teamId);
-                        if (!team)
+                        const team = resolveTeamByIdOrSlug(teams, teamId);
+                        if (!team) {
+                            this.logger.warn('CronTask auto-start: targetTeamId resolves to no team', {
+                                sessionName,
+                                targetTeamId: teamId,
+                                availableSlugs: teams.slice(0, 10).map((t) => slugifyTeamName(t.name)),
+                                hint: 'Set targetTeamId to either the team UUID or one of availableSlugs (lowercase, spaces→-)',
+                            });
                             return false;
+                        }
                         const member = team.members.find((m) => m.sessionName === sessionName);
                         if (!member)
                             return false;
                         await registrationRef.createAgentSession({
                             sessionName: member.sessionName,
                             role: member.role,
-                            teamId,
+                            // Use the resolved team's UUID — not the user-supplied identifier
+                            // — so downstream agent-registration always sees the canonical id.
+                            teamId: team.id,
                             memberId: member.id,
                         });
                         return true;
@@ -2046,15 +2150,56 @@ export class CrewlyServer {
             // and auditor sessions when auditor is disabled
             const isAuditorEnabled = process.env[AUDITOR_CONSTANTS.ENV_VAR]?.toLowerCase() === 'true'
                 || (process.env[AUDITOR_CONSTANTS.ENV_VAR] === undefined && AUDITOR_CONSTANTS.ENABLED_BY_DEFAULT);
-            const agentSessions = state.sessions.filter((s) => {
+            const baselineSessions = state.sessions.filter((s) => {
                 if (s.role === ORCHESTRATOR_ROLE)
                     return false;
                 if (!isAuditorEnabled && s.name === AUDITOR_SCHEDULER_CONSTANTS.AUDITOR_SESSION_NAME)
                     return false;
                 return true;
             });
+            // 2026-05-17 — gate by task-pool work. Pre-fix the boot path
+            // blindly resurrected every persisted session even when none had
+            // pending work, defeating the wake-gate philosophy (PR #574/#585)
+            // and bloating RAM until IdleDetection eventually drained them
+            // back. Now: only restore a session if the pool has at least one
+            // non-terminal WorkItem with `target === sessionName`. Idle
+            // agents stay dead until orc dispatches new work, at which point
+            // the dispatcher / wake path raises them on demand.
+            //
+            // Safety valve: if the pool lookup throws (e.g. SQLite not yet
+            // open during early boot), preserve the legacy behaviour rather
+            // than block all restores — better to over-restore than to
+            // silently strand work.
+            let agentSessions = baselineSessions;
+            try {
+                const pool = TaskPoolService.getInstance();
+                const allItems = await pool.getAllItems();
+                const targetedSessions = new Set();
+                for (const wi of allItems) {
+                    if (wi.status === 'done' || wi.status === 'cancelled')
+                        continue;
+                    const t = wi.target;
+                    if (typeof t === 'string' && t.length > 0)
+                        targetedSessions.add(t);
+                }
+                const filtered = baselineSessions.filter((s) => targetedSessions.has(s.name));
+                const skipped = baselineSessions
+                    .filter((s) => !targetedSessions.has(s.name))
+                    .map((s) => s.name);
+                if (skipped.length > 0) {
+                    this.logger.info('Skipping auto-restore for sessions with no pending WorkItem (idle agents stay dead until dispatched work arrives)', {
+                        skippedCount: skipped.length,
+                        skipped: skipped.slice(0, 20),
+                        truncated: skipped.length > 20,
+                    });
+                }
+                agentSessions = filtered;
+            }
+            catch (poolErr) {
+                this.logger.warn('Auto-restore could not query task pool; falling back to restoring every persisted session', { error: poolErr instanceof Error ? poolErr.message : String(poolErr) });
+            }
             if (agentSessions.length === 0) {
-                this.logger.debug('No non-orchestrator sessions to restore');
+                this.logger.info('No persisted agent sessions to restore (all idle, no pending WorkItems)');
                 return;
             }
             this.logger.info('Auto-restoring agent sessions from persisted state', {
@@ -2480,14 +2625,13 @@ export class CrewlyServer {
                     if (req.sourceConversationItemId.startsWith('slack-')) {
                         try {
                             const { ThreadStatusQueueService } = await import('./services/messaging/thread-status-queue.service.js');
+                            const { extractSlackChannelId, extractSlackThreadTs } = await import('./services/v3/request-sla.subscriber.js');
                             const tsq = ThreadStatusQueueService.getInstance();
-                            // sourceConversationItemId format: "slack-{channelId}-{messageTs}"
-                            // messageTs format in the ID uses hyphens: "1775935980-197679"
-                            // Slack threadTs uses dots: "1775935980.197679"
-                            const match = req.sourceConversationItemId.match(/^slack-(.+)-(\d+)[.-](\d+)$/);
-                            if (match) {
-                                const channelId = match[1];
-                                const threadTs = `${match[2]}.${match[3]}`;
+                            // Use the canonical parser (handles both `slack-{ch}-{ts}` and
+                            // the thread-reply `slack-{ch}-{root}-msg-{msgTs}` shapes).
+                            const channelId = extractSlackChannelId(req.sourceConversationItemId);
+                            const threadTs = extractSlackThreadTs(req.sourceConversationItemId);
+                            if (channelId && threadTs) {
                                 const threadKey = `${channelId}:${threadTs}`;
                                 // Create entry if not tracked, then mark terminal
                                 if (!tsq.get(threadKey)) {
@@ -2684,6 +2828,11 @@ export class CrewlyServer {
                 this.autoLearningSubscriber.stop();
                 this.autoLearningSubscriber = null;
             }
+            // DF-1 #438: same shutdown window as auto-learning above.
+            if (this.milestoneNotificationSubscriber) {
+                this.milestoneNotificationSubscriber.stop();
+                this.milestoneNotificationSubscriber = null;
+            }
             // INBOUND-1: stop the SLA subscriber and unset the module-level
             // references so a follow-up start() doesn't see stale singletons.
             if (this.requestSlaSubscriber) {