crewly 1.6.4 → 1.7.0

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

@@ -13,7 +13,7 @@ import helmet from 'helmet';
 import morgan from 'morgan';
 import os from 'os';
 import { fileURLToPath } from 'url';
-import { StorageService, TmuxService, SchedulerService, MessageSchedulerService, ActivityMonitorService, TaskTrackingService, TeamActivityWebSocketService, TeamsJsonWatcherService, } from './services/index.js';
+import { StorageService, TmuxService, SchedulerService, MessageSchedulerService, ActivityMonitorService, TeamActivityWebSocketService, TeamsJsonWatcherService, } from './services/index.js';
 import { getSessionBackend, getSessionBackendSync, getSessionStatePersistence, destroySessionBackend, PtySessionBackend, } from './services/session/index.js';
 import { ApiController } from './controllers/api.controller.js';
 import { createApiRoutes } from './routes/api.routes.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,7 +35,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 { 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';
+import { RequestCascadeSubscriber } from './services/v3/request-cascade.subscriber.js';
 import { setRequestServiceEventBus, RequestService } from './services/v3/request.service.js';
 import { getSlackService } from './services/slack/slack.service.js';
 import { SlackThreadStoreService, setSlackThreadStore, getSlackThreadStore } from './services/slack/slack-thread-store.service.js';
@@ -42,7 +47,6 @@ import { GoogleChatThreadStoreService, setGchatThreadStore } from './services/me
 import { SlackImageService, setSlackImageService } from './services/slack/slack-image.service.js';
 import { NotifyReconciliationService } from './services/slack/notify-reconciliation.service.js';
 import { setEventBusService as setEventBusControllerService } from './controllers/event-bus/event-bus.controller.js';
-import { setEventBusServiceForTaskCleanup } from './controllers/task-management/task-management.controller.js';
 import { setTeamControllerEventBusService } from './controllers/team/team.controller.js';
 import { SkillCatalogService } from './services/skill/skill-catalog.service.js';
 import { setMessageQueueService as setChatMessageQueueService, setThreadStatusQueueService as setChatThreadStatusQueueService } from './controllers/chat/chat.controller.js';
@@ -61,6 +65,7 @@ import { RuntimeExitMonitorService } from './services/agent/runtime-exit-monitor
 import { ContextWindowMonitorService } from './services/agent/context-window-monitor.service.js';
 import { OAuthReloginMonitorService } from './services/agent/oauth-relogin-monitor.service.js';
 import { findPackageRoot } from './utils/package-root.js';
+import { isNativeBindingFatalError } from './utils/native-binding.utils.js';
 import { VersionCheckService } from './services/system/version-check.service.js';
 import { LogRotationService } from './services/session/log-rotation.service.js';
 import { AuditorSchedulerService } from './services/agent/auditor-scheduler.service.js';
@@ -123,7 +128,6 @@ export class CrewlyServer {
     schedulerService;
     messageSchedulerService;
     activityMonitorService;
-    taskTrackingService;
     teamActivityWebSocketService;
     teamsJsonWatcherService;
     apiController;
@@ -136,8 +140,15 @@ 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. */
+    requestDecomposeSubscriber = null;
+    requestStatusUpdateSubscriber = null;
+    requestCascadeSubscriber = null;
     notifyReconciliationService;
     systemResourceAlertService;
     reconcilerService = null;
@@ -207,15 +218,16 @@ export class CrewlyServer {
         this.schedulerService = new SchedulerService(this.storageService);
         this.messageSchedulerService = new MessageSchedulerService(this.tmuxService, this.storageService);
         this.activityMonitorService = ActivityMonitorService.getInstance();
-        this.taskTrackingService = new TaskTrackingService();
-        this.teamActivityWebSocketService = new TeamActivityWebSocketService(this.storageService, this.tmuxService, this.taskTrackingService);
+        // V3-only as of spec 2026-05-06-task-management-v1-deprecation.md.
+        // TaskTrackingService is deleted; in-progress task data and lifecycle
+        // events come from TaskPoolService + EventBusService respectively.
+        this.teamActivityWebSocketService = new TeamActivityWebSocketService(this.storageService, this.tmuxService);
         this.teamsJsonWatcherService = new TeamsJsonWatcherService();
         this.apiController = new ApiController(this.storageService, this.tmuxService, this.schedulerService, this.messageSchedulerService);
         // Wire up reliable delivery: both schedulers use AgentRegistrationService
         // for retry + progressive verification + background stuck-detection
         this.messageSchedulerService.setAgentRegistrationService(this.apiController.agentRegistrationService);
         this.schedulerService.setAgentRegistrationService(this.apiController.agentRegistrationService);
-        this.schedulerService.setTaskTrackingService(this.taskTrackingService);
         // Initialize message queue services (with disk persistence)
         // NOTE: Must be created before services that depend on them (scheduler, thread status queue)
         this.messageQueueService = new MessageQueueService(this.config.crewlyHome);
@@ -255,6 +267,23 @@ export class CrewlyServer {
         // triggers addToPool — the slack listener / TaskPool router below both
         // depend on this for the auto-close path b chain. Idempotent.
         TaskPoolService.getInstance().setEventBusService(this.eventBusService);
+        // P1 Bug B (Pool umbrella WI 72ca743a): Wire RequestService into the
+        // TaskPool singleton so addToPool intrinsically links new WIs into
+        // their parent Request.workItemIds[] — independent of the
+        // subscriber-driven path (request-sla.subscriber, V3DataService).
+        // Pre-fix, manual / programmatic / cron callers that bypassed the
+        // event chain left Requests with empty workItemIds[]. The linker is
+        // idempotent (request.service.ts:328 short-circuits on duplicate id)
+        // so subscriber-driven linking stays as belt-and-suspenders.
+        TaskPoolService.getInstance().setRequestService(RequestService.getInstance());
+        // P1 Bug C (Pool umbrella WI 72ca743a, sub-WI Bug C): Wire the inverse
+        // dependency — RequestService → TaskPool — so RequestService.update
+        // can refuse `Request → done` when any child WorkItem is still in a
+        // non-terminal state. Bug B (above) makes Request.workItemIds[]
+        // authoritative on every addToPool; Bug C makes the closure honor
+        // that data. The setter is duck-typed on IWorkItemQueryable so
+        // neither side needs a static import of the other.
+        RequestService.getInstance().setTaskPoolService(TaskPoolService.getInstance());
         // Wire Task Pool router so [TASK]-prefixed messages route through the pool
         this.queueProcessorService.setTaskPoolRouter(async (messageContent, targetSession) => {
             const { createWorkItem } = await import('./types/v2/work-item.types.js');
@@ -283,24 +312,14 @@ export class CrewlyServer {
         this.activityMonitorService.setEventBusService(this.eventBusService);
         setEventBusControllerService(this.eventBusService);
         setTeamControllerEventBusService(this.eventBusService);
-        setEventBusServiceForTaskCleanup(this.eventBusService);
-        // Architecture Upgrade Phase 6: Bridge task workflow events to EventBus
-        this.taskTrackingService.on('task_workflow_event', (payload) => {
-            this.eventBusService.publish({
-                id: `task-workflow-${payload.taskId || 'team'}-${Date.now()}`,
-                type: payload.type,
-                timestamp: new Date().toISOString(),
-                teamId: payload.teamId || '',
-                teamName: '',
-                memberId: payload.ownerMemberId || '',
-                memberName: '',
-                sessionName: payload.assignedSessionName || '',
-                previousValue: '',
-                newValue: payload.taskStatus || payload.type,
-                changedField: 'taskStatus',
-                taskId: payload.taskId,
-            });
-        });
+        // Wire team-activity-websocket to EventBus so it reacts to V3
+        // WorkItem lifecycle events (replaces the legacy
+        // TaskTrackingService.on('task_workflow_event') bridge that was
+        // deleted with the v1 task-management subsystem).
+        this.teamActivityWebSocketService.setEventBus(this.eventBusService);
+        // V3-only autonomy: AgentAutoClaimService (started later in boot)
+        // is the single autonomy loop. The legacy AutoAssignService has
+        // been retired — see spec 2026-05-06-task-management-v1-deprecation.md.
         // BRIDGE-1: subscribe to autonomy events (task:done_by_worker,
         // task:rejected, task:blocked, team:all_tasks_done, mission:*) and
         // create the appropriate WorkItem(s) — verification WI for TL on
@@ -316,24 +335,128 @@ 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();
-        // INBOUND-1: wire RequestService → bus, then subscribe SLA tracker.
-        // Order matters: setRequestServiceEventBus must run BEFORE any code
-        // path can call RequestService.create() — the slack listener at
-        // line ~370 is the first hot caller, but the slack service hasn't
-        // been initialised yet at this point in boot, so we're safe.
-        setRequestServiceEventBus(this.eventBusService);
-        this.requestSlaSubscriber = RequestSlaSubscriber.boot(this.eventBusService, RequestService.getInstance(), TaskPoolService.getInstance(), async ({ channelId, threadTs, messageText }) => {
-            // Production wiring of the 10-min escalation hook: nudge the user
-            // in the same Slack thread so they're never blind to the miss.
-            const slack = getSlackService();
-            await slack.sendMessage({
-                channelId,
-                threadTs,
-                text: messageText,
-            });
+        // 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.requestSlaSubscriber.start();
-        setRequestSlaSubscriber(this.requestSlaSubscriber);
+        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
+        // BEFORE any code path can call RequestService.create() — the slack
+        // listener at line ~370 is the first hot caller, but the slack
+        // service hasn't been initialised yet at this point in boot, so
+        // we're safe.
+        //
+        // Failure-isolated (issue #465): the entire v3 subscriber boot is
+        // wrapped in try/catch so a wiring failure logs + continues rather
+        // than crashing the whole backend. Neither subscriber is essential
+        // to API liveness — degrading them is preferable to losing the
+        // process. A single catch block treats both as a unit because the
+        // failure mode is "wiring is broken, fix the deploy" not
+        // "intermittently flaky"; partial recovery would be unnecessary
+        // complexity for v1. B0 broadcast (line ~2336) and TriggerEngine
+        // boot (line ~1464) already have equivalent isolation; this brings
+        // the v3 subscriber block in line with that pattern.
+        try {
+            setRequestServiceEventBus(this.eventBusService);
+            this.requestSlaSubscriber = RequestSlaSubscriber.boot(this.eventBusService, RequestService.getInstance(), TaskPoolService.getInstance(), async ({ channelId, threadTs, messageText }) => {
+                // Production wiring of the 10-min escalation hook: nudge the user
+                // in the same Slack thread so they're never blind to the miss.
+                const slack = getSlackService();
+                await slack.sendMessage({
+                    channelId,
+                    threadTs,
+                    text: messageText,
+                });
+            });
+            this.requestSlaSubscriber.start();
+            setRequestSlaSubscriber(this.requestSlaSubscriber);
+            // Pipeline-#4 follow-up: auto-decompose actionable L2 Requests on
+            // request:created. Sequenced AFTER the SLA subscriber so the
+            // respond_to_user WI seeding still runs first when both fire on
+            // the same event (deterministic listener-attach order; both run
+            // via the same in-process bus). Side note: order is semantically
+            // irrelevant — the linkWorkItem path keys on workitem:queued, not
+            // on relative listener position — but predictable startup ordering
+            // helps debug.
+            this.requestDecomposeSubscriber = RequestDecomposeSubscriber.boot(this.eventBusService, RequestService.getInstance(), TaskPoolService.getInstance());
+            this.requestDecomposeSubscriber.start();
+            setRequestDecomposeSubscriber(this.requestDecomposeSubscriber);
+            // Status-update subscriber: posts progress on Slack-originated
+            // Requests as their child WIs reach milestones, plus a heartbeat
+            // while work is still in flight. Closes the "long silence after
+            // orc's first ack" UX gap. Idempotent — duplicate boots are no-ops.
+            this.requestStatusUpdateSubscriber = new RequestStatusUpdateSubscriber({
+                eventBus: this.eventBusService,
+                requestService: RequestService.getInstance(),
+                taskPool: TaskPoolService.getInstance(),
+                slackPoster: async ({ channelId, text, threadTs }) => {
+                    // Post via the in-process SlackService to avoid a self-HTTP
+                    // hop. The /api/slack/send route's other side-effects (chat
+                    // persistence, thread-status replied marker) don't apply
+                    // to mid-thread heartbeat updates — those are only for
+                    // the user's direct reply, not for orc's progress pings.
+                    const slack = getSlackService();
+                    if (!slack.isConnected())
+                        return;
+                    await slack.sendMessage({ channelId, text, threadTs });
+                },
+                heartbeatMinutes: 30,
+            });
+            this.requestStatusUpdateSubscriber.start();
+            // Cascade subscriber: keeps Request.status in sync with the
+            // aggregate state of its child WIs by reacting to live task
+            // lifecycle events. Closes the gap left by V3DataService's
+            // retired `v3:task_*` subscriptions (see 2026-05-09 dogfood
+            // note in request-cascade.subscriber.ts).
+            this.requestCascadeSubscriber = new RequestCascadeSubscriber({
+                eventBus: this.eventBusService,
+                requestService: RequestService.getInstance(),
+                taskPool: TaskPoolService.getInstance(),
+                notifier: this.eventBusService,
+            });
+            this.requestCascadeSubscriber.start();
+        }
+        catch (subscriberBootErr) {
+            // Degraded mode: SLA tracking + auto-decompose are off, but the
+            // API surface and rest of the backend continue to serve. Ops can
+            // grep for `v3 subscriber boot failed` in logs to triage.
+            this.logger.error('v3 subscriber boot failed — degrading SLA + auto-decompose paths, continuing backend startup', {
+                error: subscriberBootErr instanceof Error
+                    ? subscriberBootErr.message
+                    : String(subscriberBootErr),
+            });
+            // Best-effort cleanup of any partial wiring so a later restart
+            // doesn't see stale singletons. The setters are idempotent.
+            setRequestSlaSubscriber(null);
+            setRequestDecomposeSubscriber(null);
+            setRequestServiceEventBus(null);
+            this.requestSlaSubscriber = null;
+            this.requestDecomposeSubscriber = null;
+            if (this.requestStatusUpdateSubscriber) {
+                try {
+                    this.requestStatusUpdateSubscriber.stop();
+                }
+                catch { /* best-effort */ }
+                this.requestStatusUpdateSubscriber = null;
+            }
+            if (this.requestCascadeSubscriber) {
+                try {
+                    this.requestCascadeSubscriber.stop();
+                }
+                catch { /* best-effort */ }
+                this.requestCascadeSubscriber = null;
+            }
+        }
         // Initialize Slack thread store for persistent thread conversations
         const slackThreadStore = new SlackThreadStoreService(this.config.crewlyHome);
         setSlackThreadStore(slackThreadStore);
@@ -368,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'];
@@ -422,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(),
                     });
@@ -892,7 +1034,7 @@ export class CrewlyServer {
                 const ctxSessionBackend = getSessionBackendSync();
                 if (ctxSessionBackend) {
                     const contextWindowMonitor = ContextWindowMonitorService.getInstance();
-                    contextWindowMonitor.setDependencies(ctxSessionBackend, this.apiController.agentRegistrationService, this.storageService, this.taskTrackingService, this.eventBusService);
+                    contextWindowMonitor.setDependencies(ctxSessionBackend, this.apiController.agentRegistrationService, this.storageService, this.eventBusService);
                     contextWindowMonitor.start();
                     this.logger.info('ContextWindowMonitorService started');
                 }
@@ -915,7 +1057,6 @@ export class CrewlyServer {
             try {
                 const runtimeExitMonitor = RuntimeExitMonitorService.getInstance();
                 runtimeExitMonitor.setAgentRegistrationService(this.apiController.agentRegistrationService);
-                runtimeExitMonitor.setTaskTrackingService(this.taskTrackingService);
                 runtimeExitMonitor.setEventBusService(this.eventBusService);
             }
             catch (error) {
@@ -974,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;
@@ -985,8 +1131,73 @@ 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
+                // singleton; null means "skip the cold-start probe", so this
+                // wiring is what flips onboarding mode on for the demo path.
+                try {
+                    const { OnboardingBootstrapService, setOnboardingBootstrapService } = await import('./services/orchestrator/onboarding-bootstrap.service.js');
+                    setOnboardingBootstrapService(new OnboardingBootstrapService({
+                        storage: this.storageService,
+                        chat: { countAllMessages: () => chatService.countAllMessages() },
+                    }));
+                    this.logger.info('OnboardingBootstrapService wired with storage + chat probes');
+                }
+                catch (wireErr) {
+                    this.logger.warn('Failed to wire OnboardingBootstrapService (non-critical)', {
+                        error: wireErr instanceof Error ? wireErr.message : String(wireErr),
+                    });
+                }
             }
             catch (error) {
+                // F-CYCLE7-1: a native-binding failure (e.g. better-sqlite3 built
+                // for the wrong arch) MUST crash the boot rather than be downgraded
+                // to a JSON-file fallback. The audit on 2026-05-07 caught this
+                // exact path: chat.db went stale at 11:17Z because dlopen errors
+                // were swallowed here as "non-critical", so operators had no signal
+                // to run `npm rebuild better-sqlite3 --build-from-source`.
+                //
+                // `isNativeBindingFatalError` matches structurally (not just via
+                // instanceof) so realm-boundary cases — same module loaded via
+                // two require paths — still trip the rethrow.
+                if (isNativeBindingFatalError(error)) {
+                    this.logger.error('FATAL native binding failed at chat-v2 boot — refusing to downgrade to JSON fallback. Run the printed remediation and restart.', { error: error.message });
+                    throw error;
+                }
                 this.logger.warn('Failed to start chat-v2 WS gateway (non-critical)', {
                     error: error instanceof Error ? error.message : String(error),
                 });
@@ -1073,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;
@@ -1080,13 +1292,17 @@ export class CrewlyServer {
                     if (req.status !== 'done')
                         continue;
                     const scid = req.sourceConversationItemId || '';
-                    if (!scid.startsWith('slack-'))
-                        continue;
-                    const m = scid.match(/^slack-(.+)-(\d+)[.-](\d+)$/);
-                    if (!m)
+                    // `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 [, channelId, t1, t2] = m;
-                    const threadKey = `${channelId}:${t1}.${t2}`;
+                    const threadKey = `${channelId}:${threadTs}`;
                     if (this.threadStatusQueueService.get(threadKey))
                         continue;
                     this.threadStatusQueueService.trackInbound({
@@ -1112,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)', {
@@ -1170,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') {
@@ -1177,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;
@@ -1189,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;
@@ -1392,12 +1632,27 @@ export class CrewlyServer {
                     error: v3Err instanceof Error ? v3Err.message : String(v3Err),
                 });
             }
+            // Start WorkItemDispatchSubscriber FIRST — AgentAutoClaim's recovery
+            // path delegates to its dispatchTo() for the "active target session"
+            // branch, so the singleton must be reachable when recovery fires.
+            try {
+                const { WorkItemDispatchSubscriber } = await import('./services/v3/workitem-dispatch.subscriber.js');
+                const dispatchSubscriber = WorkItemDispatchSubscriber.getInstance();
+                dispatchSubscriber.initialize(this.eventBusService);
+                dispatchSubscriber.start();
+                this.logger.info('WorkItemDispatchSubscriber started — workitem:queued events push to target sessions');
+            }
+            catch (dispatchErr) {
+                this.logger.warn('WorkItemDispatchSubscriber initialization failed (non-critical)', {
+                    error: dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr),
+                });
+            }
             // Start AgentAutoClaimService — auto-assign work to idle agents
             try {
                 const { AgentAutoClaimService } = await import('./services/v3/agent-auto-claim.service.js');
                 const autoClaimService = AgentAutoClaimService.getInstance();
                 autoClaimService.initialize(this.eventBusService);
-                autoClaimService.start();
+                await autoClaimService.start();
                 this.logger.info('AgentAutoClaimService started — idle agents will auto-claim work');
             }
             catch (autoClaimErr) {
@@ -1474,8 +1729,9 @@ export class CrewlyServer {
             VersionCheckService.getInstance().checkForUpdate().catch(() => {
                 // Silently ignore — version check is non-critical
             });
-            // Start periodic task file system sync (#137) — cleans up stale tracking entries
-            this.taskTrackingService.startAutoSync();
+            // V3-only as of spec 2026-05-06-task-management-v1-deprecation.md.
+            // The legacy `TaskTrackingService.startAutoSync()` is gone — V3
+            // task-pool reconciler owns lifecycle cleanup now.
             // Initialize token usage tracking: load persisted data and start periodic flush
             try {
                 const tokenUsageService = TokenUsageService.getInstance();
@@ -1511,6 +1767,25 @@ export class CrewlyServer {
                     });
                 }
             }
+            // C1 — boot-time state invariant check (Persistence P0 spec).
+            // Refuses to start serving traffic if the live teams directory
+            // is empty but a healthy backup snapshot exists. Override via
+            // CREWLY_FORCE_EMPTY_BOOT=1 for legitimate fresh-install / reset.
+            try {
+                await this.storageService.verifyStateInvariantOnBoot();
+            }
+            catch (invariantErr) {
+                const { StateInvariantViolation } = await import('./services/core/state-invariant.types.js');
+                if (invariantErr instanceof StateInvariantViolation) {
+                    this.logger.error('Boot aborted by state invariant check — refusing to serve traffic with wiped state', {
+                        currentTeamCount: invariantErr.currentTeamCount,
+                        backupTeamCount: invariantErr.backupTeamCount,
+                        backupTimestamp: invariantErr.backupTimestamp,
+                        message: invariantErr.message,
+                    });
+                }
+                throw invariantErr;
+            }
             // Start HTTP server with enhanced error handling
             await this.startHttpServer();
             // Load addons from ~/.crewly/addons/ (Pro features, extensions, etc.)
@@ -1534,21 +1809,27 @@ export class CrewlyServer {
             await this.autoStartOrchestratorIfEnabled();
             // Auto-restore agent sessions that were running before the last shutdown
             await this.autoRestoreAgentSessionsIfEnabled();
-            // #166: Auto-recover in-progress tasks after restart
-            // #196: Skip tasks older than 1 hour to avoid re-sending stale work
+            // #166: Auto-recover in-progress tasks after restart.
+            // #196: Skip tasks older than 1 hour to avoid re-sending stale work.
+            // V3-only as of spec 2026-05-06-task-management-v1-deprecation.md —
+            // reads WorkItems from TaskPoolService (replaces the prior
+            // `TaskTrackingService.getAllInProgressTasks()` call).
             try {
                 const TASK_RECOVERY_MAX_AGE_MS = 60 * 60 * 1000; // 1 hour
-                const inProgressTasks = await this.taskTrackingService.getAllInProgressTasks();
+                const { TaskPoolService } = await import('./services/task-pool/task-pool.service.js');
+                const allItems = await TaskPoolService.getInstance().getAllItems();
                 const now = Date.now();
-                const activeTasks = inProgressTasks.filter(t => {
-                    if (t.status !== 'assigned' && t.status !== 'active' && t.status !== 'working')
+                const activeTasks = allItems.filter(wi => {
+                    if (wi.status !== 'queued' && wi.status !== 'accepted' && wi.status !== 'running')
                         return false;
-                    // Skip stale tasks — assignedAt older than threshold
-                    const taskTime = new Date(t.assignedAt || 0).getTime();
+                    if (!wi.target)
+                        return false;
+                    // Skip stale tasks — startedAt/createdAt older than threshold
+                    const taskTime = new Date(wi.startedAt || wi.createdAt || 0).getTime();
                     if (now - taskTime > TASK_RECOVERY_MAX_AGE_MS) {
                         this.logger.info('Skipping stale task recovery (older than 1 hour)', {
-                            taskId: t.id,
-                            taskName: t.taskName,
+                            workItemId: wi.id,
+                            taskName: wi.title,
                             age: `${Math.round((now - taskTime) / 60000)} minutes`,
                         });
                         return false;
@@ -1556,24 +1837,24 @@ export class CrewlyServer {
                     return true;
                 });
                 if (activeTasks.length > 0) {
-                    this.logger.info('Found in-progress tasks to recover after restart', {
+                    this.logger.info('Found in-progress WorkItems to recover after restart', {
                         count: activeTasks.length,
                     });
-                    for (const task of activeTasks) {
+                    for (const wi of activeTasks) {
                         try {
-                            const recoveryMessage = `[SYSTEM — TASK RECOVERY] You were working on this task before the server restarted. Please continue:\n\nTask: ${task.taskName}\nPriority: ${task.priority || 'normal'}\nFile: ${task.taskFilePath}\n\nPlease check the current state and continue working.`;
-                            await this.apiController.agentRegistrationService.sendMessageToAgent(task.assignedSessionName, recoveryMessage, undefined);
+                            const recoveryMessage = `[SYSTEM — TASK RECOVERY] You were working on this task before the server restarted. Please continue:\n\nTask: ${wi.title}\nWorkItem: ${wi.id}\n\nFetch full brief: bash config/skills/agent/core/read-task/execute.sh '{"workItemId":"${wi.id}"}'\n\nPlease check the current state and continue working.`;
+                            await this.apiController.agentRegistrationService.sendMessageToAgent(wi.target, recoveryMessage, undefined);
                             this.logger.info('Task recovery message sent', {
-                                taskId: task.id,
-                                sessionName: task.assignedSessionName,
-                                taskName: task.taskName,
+                                workItemId: wi.id,
+                                sessionName: wi.target,
+                                taskName: wi.title,
                             });
                         }
                         catch (err) {
                             // Agent might not be online yet — DLQ in scheduler will handle it
                             this.logger.warn('Task recovery delivery deferred (agent may not be online yet)', {
-                                taskId: task.id,
-                                sessionName: task.assignedSessionName,
+                                workItemId: wi.id,
+                                sessionName: wi.target,
                                 error: err instanceof Error ? err.message : String(err),
                             });
                         }
@@ -1869,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', {
@@ -2009,6 +2331,49 @@ export class CrewlyServer {
                     websocketUrl: `ws://localhost:${this.config.webPort}`,
                     home: this.config.crewlyHome
                 });
+                // B0 (interim) per `.crewly/specs/2026-05-05-trigger-persistence-bug.md`:
+                // Broadcast `system:backend_restarted` exactly once per boot. The
+                // trigger engine (`backend/src/services/v3/trigger-engine.service.ts`)
+                // stores all `schedule-followup` / `watch-for-event` triggers in an
+                // in-memory `Map<string, Trigger>` that is wiped on every restart.
+                // Subscribers (e.g. self-watch-scribe, any TL using §3.0 universal
+                // delegator-rule) listen for this event as a freshness signal and
+                // re-arm their watchdogs. Re-arm latency drops from "manual cycle"
+                // to "next event tick" — closes the wipe-coverage-gap to seconds.
+                // B1 (full fix) is disk-backed declarative trigger config per the
+                // spec Path A; B0 is the unblock-first interim until B1 lands.
+                try {
+                    // AgentEvent shape (`backend/src/types/event-bus.types.ts:198`)
+                    // requires a fixed set of string fields. For system-scoped
+                    // events we use 'system' for member/session and leave team
+                    // fields empty — subscribers MUST gate on `type` rather than
+                    // team/member identity. Boot diagnostics (port, duration) are
+                    // already in the preceding `Crewly server started` log;
+                    // callers needing them can correlate by `timestamp`.
+                    this.eventBusService.publish({
+                        id: `system-backend-restarted-${Date.now()}`,
+                        type: 'system:backend_restarted',
+                        timestamp: new Date().toISOString(),
+                        teamId: '',
+                        teamName: '',
+                        memberId: '',
+                        memberName: 'system',
+                        sessionName: 'system',
+                        previousValue: 'stopped',
+                        newValue: 'started',
+                        changedField: 'agentStatus'
+                    });
+                    this.logger.info('Broadcast system:backend_restarted event', {
+                        port: this.config.webPort,
+                        bootDurationMs: duration
+                    });
+                }
+                catch (emitError) {
+                    // Failure isolation — never block boot on this telemetry.
+                    this.logger.warn('Failed to broadcast system:backend_restarted (non-fatal)', {
+                        error: emitError instanceof Error ? emitError.message : String(emitError)
+                    });
+                }
                 resolve();
             });
             this.httpServer.on('error', (error) => {
@@ -2260,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)) {
@@ -2464,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) {
@@ -2471,6 +2840,13 @@ export class CrewlyServer {
                 this.requestSlaSubscriber = null;
             }
             setRequestSlaSubscriber(null);
+            // Pipeline-#4 follow-up: stop the decompose subscriber and clear
+            // its module-level reference on the same shutdown window as SLA.
+            if (this.requestDecomposeSubscriber) {
+                this.requestDecomposeSubscriber.stop();
+                this.requestDecomposeSubscriber = null;
+            }
+            setRequestDecomposeSubscriber(null);
             setRequestServiceEventBus(null);
             // Clean up event bus service
             this.eventBusService.cleanup();