crewly 1.6.3 → 1.6.5

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';
@@ -35,6 +35,9 @@ 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 { 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 +45,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';
@@ -52,6 +54,7 @@ import { TokenUsageService } from './services/monitoring/token-usage.service.js'
 import { agentHeartbeatMiddleware } from './middleware/agent-heartbeat.middleware.js';
 import { RedisCacheService } from './services/cache/redis-cache.service.js';
 import { OrchestratorRestartService } from './services/orchestrator/orchestrator-restart.service.js';
+import { setOrchestratorSetupDependencies } from './services/orchestrator/orchestrator-setup.service.js';
 import { IdleDetectionService } from './services/agent/idle-detection.service.js';
 import { AgentSuspendService } from './services/agent/agent-suspend.service.js';
 import { AgentHeartbeatMonitorService } from './services/agent/agent-heartbeat-monitor.service.js';
@@ -60,6 +63,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';
@@ -122,7 +126,6 @@ export class CrewlyServer {
     schedulerService;
     messageSchedulerService;
     activityMonitorService;
-    taskTrackingService;
     teamActivityWebSocketService;
     teamsJsonWatcherService;
     apiController;
@@ -137,6 +140,10 @@ export class CrewlyServer {
     autoLearningSubscriber = 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;
@@ -206,15 +213,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);
@@ -254,6 +262,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');
@@ -282,24 +307,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
@@ -315,24 +330,115 @@ 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,
+        // 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);
+            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);
@@ -831,6 +937,21 @@ export class CrewlyServer {
                     error: error instanceof Error ? error.message : String(error),
                 });
             }
+            // Wire orchestrator-setup service for SlackBridge auto-recovery (B0).
+            // Without this, the bridge's auto-recovery path returns "deps not
+            // initialized" and falls through to the offline branch.
+            try {
+                setOrchestratorSetupDependencies({
+                    agentRegistrationService: this.apiController.agentRegistrationService,
+                    storageService: this.storageService,
+                });
+                this.logger.info('OrchestratorSetupService wired with dependencies');
+            }
+            catch (error) {
+                this.logger.warn('Failed to wire OrchestratorSetupService (non-critical)', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
             // Wire and start OrchestratorHeartbeatMonitorService for auto-restart
             try {
                 const orchHbSessionBackend = getSessionBackendSync();
@@ -876,7 +997,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');
                 }
@@ -899,7 +1020,6 @@ export class CrewlyServer {
             try {
                 const runtimeExitMonitor = RuntimeExitMonitorService.getInstance();
                 runtimeExitMonitor.setAgentRegistrationService(this.apiController.agentRegistrationService);
-                runtimeExitMonitor.setTaskTrackingService(this.taskTrackingService);
                 runtimeExitMonitor.setEventBusService(this.eventBusService);
             }
             catch (error) {
@@ -969,8 +1089,40 @@ export class CrewlyServer {
                     path: '/ws/chat',
                     authMode: jwtSecret ? 'jwt' : 'dev-anonymous',
                 });
+                // 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),
                 });
@@ -1376,12 +1528,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) {
@@ -1458,8 +1625,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();
@@ -1495,6 +1663,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.)
@@ -1518,21 +1705,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;
+                    if (!wi.target)
                         return false;
-                    // Skip stale tasks — assignedAt older than threshold
-                    const taskTime = new Date(t.assignedAt || 0).getTime();
+                    // 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;
@@ -1540,24 +1733,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),
                             });
                         }
@@ -1993,6 +2186,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) => {
@@ -2455,6 +2691,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();