crewly 1.15.0 → 1.17.0

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

@@ -36,7 +36,11 @@ 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 { KRCompletionSubscriber } from './services/v3/kr-completion.subscriber.js';
+import { FallbackTriggerCleanupSubscriber } from './services/v3/fallback-trigger-cleanup.subscriber.js';
 import { MissionReminderService } from './services/v3/mission-reminder.service.js';
+import { OKROwnerGuidanceService } from './services/v3/okr-owner-guidance.service.js';
+import { KRTrackingService } from './services/v3/kr-tracking.service.js';
+import { getSlackOrchestratorBridge } from './services/slack/slack-orchestrator-bridge.js';
 import { OKRReviewService } from './services/v3/okr-review.service.js';
 import { bootEscalationService } from './services/v3/escalation-boot.js';
 import { TeamBudgetGateService } from './services/budget/team-budget-gate.service.js';
@@ -157,6 +161,7 @@ export class CrewlyServer {
     /** BRIDGE-1: subscribes to autonomy events and creates WorkItems. */
     eventToWorkItemBridge = null;
     krCompletionSubscriber = null;
+    fallbackTriggerCleanup = null;
     escalationService = null;
     hierarchyEscalationMonitor = null;
     /** LEARN-1: subscribes to terminal task / mission:replanned events and auto-records learnings. */
@@ -473,6 +478,48 @@ export class CrewlyServer {
                     error: reflectErr.message,
                 });
             }
+            // Daily memory consolidation (self-improvement wiring): the
+            // MemoryConsolidationService existed but nothing ever called
+            // consolidate(), so no agent ever had a consolidation.json. Run it
+            // for every active member once per day, with a boot-time catch-up
+            // when the last recorded sweep (CREWLY_HOME/self-improvement-
+            // state.json) is older than the interval. Non-fatal throughout.
+            try {
+                const { ConsolidationSchedulerService } = await import('./services/ai/self-improvement/consolidation-scheduler.service.js');
+                const { createMemoryConsolidationService } = await import('./services/ai/self-improvement/agent-memory-provider.js');
+                const { SELF_IMPROVEMENT_CONSTANTS } = await import('./constants.js');
+                const posIntMs = (raw, fallback) => {
+                    const n = Number(raw);
+                    return Number.isFinite(n) && n > 0 ? n : fallback;
+                };
+                const consolidation = createMemoryConsolidationService();
+                const scheduler = new ConsolidationSchedulerService({
+                    intervalMs: posIntMs(process.env[SELF_IMPROVEMENT_CONSTANTS.CONSOLIDATION_INTERVAL_ENV], SELF_IMPROVEMENT_CONSTANTS.CONSOLIDATION_INTERVAL_MS),
+                    consolidate: (sessionName) => consolidation.consolidate(sessionName),
+                    listActiveSessions: async () => {
+                        const sessions = [];
+                        const orc = await this.storageService.getOrchestratorStatus();
+                        if (orc && orc.agentStatus === CREWLY_CONSTANTS.AGENT_STATUSES.ACTIVE)
+                            sessions.push(orc.sessionName);
+                        const teams = await this.storageService.getTeams();
+                        for (const team of teams) {
+                            for (const member of team.members ?? []) {
+                                if (member.agentStatus === CREWLY_CONSTANTS.AGENT_STATUSES.ACTIVE && member.sessionName) {
+                                    sessions.push(member.sessionName);
+                                }
+                            }
+                        }
+                        return sessions;
+                    },
+                });
+                ConsolidationSchedulerService.setInstance(scheduler);
+                scheduler.start();
+            }
+            catch (consolidationErr) {
+                this.logger.warn('Memory consolidation scheduler failed to start (non-fatal)', {
+                    error: consolidationErr.message,
+                });
+            }
             // LLM-wiki → WorkItem bridge (2026-05-27): pending wiki queue
             // items + legacy migration candidates become claimable
             // WorkItems in the V3 pool. Replaces the bookkeep/reflect
@@ -566,11 +613,41 @@ export class CrewlyServer {
         // `kr-completion.subscriber.ts`.
         this.krCompletionSubscriber = KRCompletionSubscriber.boot(this.eventBusService);
         this.krCompletionSubscriber.start();
+        // A delegation's fallback timer is cancelled the moment its WorkItem
+        // finishes, so the orchestrator stops being woken to "check" work that
+        // is already verified (26 of 65 WorkItems on steamfun-ops, 2026-09-18).
+        this.fallbackTriggerCleanup = FallbackTriggerCleanupSubscriber.boot(this.eventBusService);
+        this.fallbackTriggerCleanup.start();
         // OKR loop closure: give the reminder sweep (mission:stale) and the
         // review service (mission:replanned) a bus to publish on. Both were
         // declared + bridged events with no publisher before this.
         MissionReminderService.getInstance().setEventBusService(this.eventBusService);
         OKRReviewService.getInstance().setEventBusService(this.eventBusService);
+        // Owner guidance for the goal layer: a pending OKR proposal is pushed to
+        // the owner (Slack via the orchestrator bridge + a line in the orc's
+        // queue) instead of waiting to be discovered on the Missions page, and
+        // a weekly digest summarises every mission. Runs inside the sweep.
+        {
+            const guidance = new OKROwnerGuidanceService({
+                listKeyResults: (missionId) => KRTrackingService.getInstance().listByMission(missionId),
+            });
+            guidance.setNotifiers(async ({ title, message, urgency, metadata }) => {
+                const bridge = getSlackOrchestratorBridge();
+                if (!bridge)
+                    return;
+                await bridge.sendNotification({
+                    type: 'okr_reminder',
+                    title,
+                    message,
+                    urgency,
+                    timestamp: new Date().toISOString(),
+                    metadata,
+                });
+            }, (content) => {
+                this.messageQueueService?.enqueue({ content, conversationId: 'system:okr', source: 'system_event' });
+            });
+            OKROwnerGuidanceService.setInstance(guidance);
+        }
         // Hierarchy escalation: a TL that has not acted on a worker's
         // verification handoff within 15 min triggers the documented bypass to
         // the orchestrator (`hierarchy:escalation` + [ESCALATION] queue message).
@@ -2334,15 +2411,18 @@ export class CrewlyServer {
             const result = await initializeSlackIfConfigured({
                 messageQueueService: this.messageQueueService,
             });
+            // Wire thread store into the bridge for persistent thread tracking.
+            // Done regardless of the boot outcome: with Cloud-owned Slack the
+            // connection can come up later (workspace installed from Settings)
+            // and the bridge must already know its stores.
+            const threadStore = getSlackThreadStore();
+            if (threadStore) {
+                const { getSlackOrchestratorBridge } = await import('./services/slack/slack-orchestrator-bridge.js');
+                const bridge = getSlackOrchestratorBridge();
+                bridge.setSlackThreadStore(threadStore);
+                bridge.setThreadStatusQueue(this.threadStatusQueueService);
+            }
             if (result.success) {
-                // Wire thread store into the bridge for persistent thread tracking
-                const threadStore = getSlackThreadStore();
-                if (threadStore) {
-                    const { getSlackOrchestratorBridge } = await import('./services/slack/slack-orchestrator-bridge.js');
-                    const bridge = getSlackOrchestratorBridge();
-                    bridge.setSlackThreadStore(threadStore);
-                    bridge.setThreadStatusQueue(this.threadStatusQueueService);
-                }
                 this.logger.info('Slack integration initialized successfully');
             }
             else if (result.attempted) {
@@ -3342,6 +3422,10 @@ export class CrewlyServer {
                 this.krCompletionSubscriber.stop();
                 this.krCompletionSubscriber = null;
             }
+            if (this.fallbackTriggerCleanup) {
+                this.fallbackTriggerCleanup.stop();
+                this.fallbackTriggerCleanup = null;
+            }
             if (this.escalationService) {
                 try {
                     await this.escalationService.stop();