crewly 1.20.358 → 1.20.360

package/dist/backend/backend/src/index.d.ts

@@ -71,6 +71,16 @@ export declare class CrewlyServer {
     private readonly deferredIdleSettle;
     /** Owner promises past due and never nudged at boot; their agents are restored and reminded once */
     private openCommitmentsAtBoot;
+    /**
+     * The boot restore is over: the queue drained, or there was nothing to
+     * restore. The boot maintenance passes wait for this (crewly#1353).
+     */
+    private bootRestoreDone;
+    /** When this backend booted (the memory hold on boot retries is time-boxed from here) */
+    private readonly bootAt;
+    /** Agents the boot restore handed to the retry because memory was tight (crewly#1353) */
+    private heldBackAtBoot;
+    private heldBackNoticeScheduled;
     private healthMonitoringInterval;
     private backgroundWatchdog;
     constructor(config?: Partial<StartupConfig>);
@@ -143,6 +153,53 @@ export declare class CrewlyServer {
      * Runs after orchestrator auto-start so the orchestrator is available.
      */
     private autoRestoreAgentSessionsIfEnabled;
+    /**
+     * Restore entries for owed agents that have no persisted session: built from
+     * the team config the way a team start would (member role and runtime, the
+     * team's first project as the working directory). A binding whose member is
+     * gone from the config by now is skipped.
+     *
+     * @param teams - Teams from storage
+     * @param bindings - Targets resolved to members (see selectAutoRestoreSessions)
+     * @returns Session entries in the shape the restore queue runs
+     */
+    private persistedSessionsForBindings;
+    /**
+     * A boot restore was deferred by the running-agent cap. The agent is owed
+     * something that does not expire on its own (an owner thread, a promise,
+     * queued messages), so keep trying until a slot frees (crewly#1337's retry;
+     * the queue check is replaced because not every debt is a queued message).
+     * Never throws.
+     *
+     * @param sessionName - The agent whose restore was deferred
+     */
+    private retryRestoreWhileOwed;
+    /**
+     * Why a boot launch outside the restore queue must wait this round
+     * (crewly#1353): memory is tight (within the first hour), the restore queue
+     * is still launching, or another boot launch began less than the launch
+     * spacing ago. Null = go.
+     *
+     * @returns Reason to hold, or null
+     */
+    private bootLaunchHold;
+    /**
+     * Gate for the boot maintenance passes (crewly#1353): resolves when the
+     * boot restore is over and memory is calm, or after the wait cap with
+     * `reduced: true`.
+     *
+     * @returns A gate function for the service constructors
+     */
+    private bootQuietGate;
+    /**
+     * The boot restore handed an agent to the retry because memory was tight.
+     * Once, when the first one is held back, schedule the one-line owner note
+     * that is sent only if some of them are still down after
+     * OWNER_NOTE_AFTER_MS (crewly#1353).
+     *
+     * @param sessionName - The agent held back
+     */
+    private noteHeldBackAtBoot;
     /**
      * Check for and handle pending self-improvement from hot-reload.
      * This runs at startup to validate or rollback any changes made
@@ -429,6 +486,7 @@ export declare class CrewlyServer {
      *
      * @param sessionName - The agent to start
      * @param firstPauseMs - Pause before the first attempt (default: the retry's own)
+     * @param opts - `boot`: a boot launch, held while memory is tight and paced with the restore queue (crewly#1353)
      */
     private retryStartWhileQueued;
     /**

package/dist/backend/backend/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../backend/src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../backend/src/index.ts"],"names":[],"mappings":"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"}

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

@@ -194,6 +194,7 @@ import { WorkItemWorktreeService } from './services/worktree/workitem-worktree.s
 import { WorkItemWorktreeSubscriber, createTerminalNotifier } from './services/worktree/workitem-worktree.subscriber.js';
 import { ResourceModeService, RESOURCE_MODE_CONSTANTS } from './services/agent/resource-mode.service.js';
 import { getRestoreQueue, RESTORE_TIER } from './services/agent/restore-queue.js';
+import { bootLaunchHoldReason, getBootLaunchPacer, readBootPressureSnapshot, scheduleHeldBackNotice, waitForBootQuiet, } from './services/agent/boot-pressure.js';
 import { sessionsToRestore } from './services/agent/restore-filter.js';
 import { ProjectMemoryService } from './services/memory/project-memory.service.js';
 import { TaskHistorySubscriber } from './services/memory/task-history.subscriber.js';
@@ -369,6 +370,16 @@ export class CrewlyServer {
     });
     /** Owner promises past due and never nudged at boot; their agents are restored and reminded once */
     openCommitmentsAtBoot = [];
+    /**
+     * The boot restore is over: the queue drained, or there was nothing to
+     * restore. The boot maintenance passes wait for this (crewly#1353).
+     */
+    bootRestoreDone = false;
+    /** When this backend booted (the memory hold on boot retries is time-boxed from here) */
+    bootAt = Date.now();
+    /** Agents the boot restore handed to the retry because memory was tight (crewly#1353) */
+    heldBackAtBoot = new Set();
+    heldBackNoticeScheduled = false;
     healthMonitoringInterval = null;
     backgroundWatchdog = null;
     constructor(config) {
@@ -1045,7 +1056,7 @@ export class CrewlyServer {
             // digest page compiled from the log. No LLM. Non-fatal.
             try {
                 const { WikiMaintenanceService } = await import('./services/wiki/wiki-maintenance.service.js');
-                const maintenance = new WikiMaintenanceService();
+                const maintenance = new WikiMaintenanceService({ bootGate: this.bootQuietGate() });
                 WikiMaintenanceService.setInstance(maintenance);
                 maintenance.start();
             }
@@ -1078,6 +1089,7 @@ export class CrewlyServer {
                         }
                         return agents;
                     },
+                    bootGate: this.bootQuietGate(),
                 });
                 AgentMemoryRefreshService.setInstance(refresh);
                 refresh.start();
@@ -1087,6 +1099,51 @@ export class CrewlyServer {
                     error: refreshErr.message,
                 });
             }
+            // Work records (#1349): one structured `(record)` entry per finished
+            // (or long-blocked) WorkItem in the project vault log — who asked, who
+            // did it, outputs, errors, helpers, outcome — from the WorkItem, its
+            // ticket, its children, the trace and the doer's transcript tail. The
+            // digest, search and the startup briefing read them. No LLM. Non-fatal.
+            try {
+                const [{ WorkRecordService }, { ProjectTicketService }, { getTraceStore }] = await Promise.all([
+                    import('./services/wiki/work-record.service.js'),
+                    import('./services/project-tickets/project-ticket.service.js'),
+                    import('./services/trace/trace-store.js'),
+                ]);
+                const pool = TaskPoolService.getInstance();
+                const tickets = ProjectTicketService.getInstance();
+                const records = new WorkRecordService({
+                    listWorkItems: () => pool.getAllItems(),
+                    findWorkItem: (id) => pool.findWorkItem(id),
+                    listTeams: () => this.storageService.getTeams(),
+                    listProjects: () => this.storageService.getProjects(),
+                    getTicket: (projectPath, id) => tickets.get(projectPath, id),
+                    getRequest: (id) => RequestService.getInstance().getById(id),
+                    readTrace: async (wi) => {
+                        const store = getTraceStore();
+                        const traceId = wi.traceId ?? store.traceByRef('workItem', wi.id);
+                        if (!traceId)
+                            return [];
+                        const all = await store.readAll(traceId);
+                        return all?.events ?? [];
+                    },
+                    locateTranscript: this.askTranscriptLocator(),
+                    eventBus: this.eventBusService,
+                    onTicketSettled: (listener) => tickets.onChange((change) => {
+                        const settled = change.ticket.status === 'done' || change.ticket.status === 'cancelled';
+                        if (settled && change.before.status !== change.ticket.status && change.ticket.workItemId)
+                            listener(change.ticket.workItemId);
+                    }),
+                    bootGate: this.bootQuietGate(),
+                });
+                WorkRecordService.setInstance(records);
+                records.start();
+            }
+            catch (recordErr) {
+                this.logger.warn('Work records failed to start (non-fatal)', {
+                    error: recordErr.message,
+                });
+            }
             // LLM-wiki → WorkItem bridge (2026-05-27): pending wiki queue
             // items + legacy migration candidates become claimable
             // WorkItems in the V3 pool. Replaces the bookkeep/reflect
@@ -4289,10 +4346,11 @@ export class CrewlyServer {
                     return r.success;
                 });
                 // Finished work cleans up after itself: a WorkItem / ticket reaching
-                // done or verified schedules one debounced janitor pass (safe rules
-                // unchanged — only landed, clean, unattended worktrees go).
-                this.eventBusService.onInProcess(['task:done', 'task:verified'], () => {
-                    WorktreeJanitorService.getInstance().requestTidy();
+                // a terminal state schedules one debounced janitor pass (safe rules
+                // unchanged — only landed, clean, unattended worktrees go) and notes
+                // the item's worktree as finished (its node_modules go after 1 day).
+                this.eventBusService.onInProcess(['task:done', 'task:verified', 'task:cancelled', 'task:failed'], (event) => {
+                    WorktreeJanitorService.getInstance().requestTidy(event.workItemId);
                 });
                 if (WorktreeJanitorService.getInstance().start()) {
                     this.logger.info('WorktreeJanitorService scheduled');
@@ -4785,12 +4843,14 @@ export class CrewlyServer {
             const settings = await settingsService.getSettings();
             if (!settings.general.autoResumeOnRestart) {
                 this.logger.info('Auto-resume on restart is disabled, skipping agent session restore');
+                this.bootRestoreDone = true;
                 return;
             }
             const persistence = getSessionStatePersistence();
             const state = await persistence.loadState();
             if (!state || state.sessions.length === 0) {
                 this.logger.debug('No persisted agent sessions to restore');
+                this.bootRestoreDone = true;
                 return;
             }
             // Filter out orchestrator sessions (already auto-started separately)
@@ -4824,33 +4884,70 @@ export class CrewlyServer {
                 });
             }
             let targets = null;
+            // Why each target other than a WorkItem is owed something; the reason
+            // is logged in the restore plan for agents that were idle at shutdown.
+            const owedReason = new Map();
+            // Agents an owner thread waits on: launched even while memory is tight (crewly#1353).
+            const ownerThreadWaits = new Set();
+            const noteOwed = (names, reason) => {
+                const out = [];
+                for (const name of names) {
+                    if (!owedReason.has(name))
+                        owedReason.set(name, reason);
+                    out.push(name);
+                }
+                return out;
+            };
             try {
                 const allItems = await TaskPoolService.getInstance().getAllItems();
                 // Work in hand only: active statuses, touched recently (see restore-filter),
                 // plus agents whose turn the last restart cut off.
                 const owed = await this.loadOwedWorkAtBoot();
                 targets = sessionsToRestore(allItems, [
-                    ...this.interruptedTurnsAtBoot.map((t) => t.sessionName),
+                    ...noteOwed(this.interruptedTurnsAtBoot.map((t) => t.sessionName), 'interrupted turn'),
                     // Agents with messages still waiting for them (restored from
                     // disk by the queue) — someone is owed an answer.
-                    ...SubAgentMessageQueue.getInstance().sessionsWithPending(),
+                    ...noteOwed(SubAgentMessageQueue.getInstance().sessionsWithPending(), 'queued messages'),
                     // Agents whose owner promise is past due and was never
                     // nudged: idle or not, they come back to be reminded once
                     // (2026-10-02, Eve). Not-yet-due and already-nudged
                     // promises are left to the open-items sweep.
-                    ...owed.map((c) => c.sessionName),
+                    ...noteOwed(owed.map((c) => c.sessionName), 'owed promise'),
                     // Agents an owner Slack thread waits on: a promised
                     // follow-up, an unanswered owner message, or an owner
                     // card they asked (2026-10-08: Atlas waited on a browser
                     // approval in the owner's thread and was skipped as "no
                     // work in hand").
-                    ...(await this.ownerThreadSessionsAtBoot()),
+                    ...noteOwed(await this.ownerThreadSessionsAtBoot().then((names) => { for (const n of names)
+                        ownerThreadWaits.add(n); return names; }), 'owner thread waits on it'),
                 ]);
             }
             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) });
             }
-            const selection = selectAutoRestoreSessions({ sessions: baselineSessions, teams, targets });
+            // A target that was not running at shutdown (idle-stopped earlier) is
+            // still owed something and comes back from its team binding — unless
+            // the owner stopped it, its team is paused, or its team moved to
+            // another machine (crewly#1348: Pia, 2026-10-16).
+            const { liveAgentSessions, movedAwayTeamIds } = await import('./services/messaging/owner-thread-sentinel.wiring.js');
+            const live = teams ? liveAgentSessions(teams, movedAwayTeamIds(this.config.crewlyHome)) : new Set();
+            const selection = selectAutoRestoreSessions({
+                sessions: baselineSessions,
+                teams,
+                targets,
+                heldBack: (name) => name === ORCHESTRATOR_SESSION_NAME || !live.has(name) || isOwnerStopped(name) || !!pausedTeamOfSession(name),
+            });
+            if (selection.droppedTargets.length > 0) {
+                this.logger.info('Not restoring owed agents that were idle at shutdown: no live team member is bound to the name, or it is held back', {
+                    dropped: selection.droppedTargets,
+                });
+            }
+            const idleAtShutdown = await this.persistedSessionsForBindings(teams ?? [], selection.fromTargets);
+            if (idleAtShutdown.length > 0) {
+                this.logger.info('Restoring owed agents that were idle at shutdown (not in the persisted state)', {
+                    sessions: idleAtShutdown.map((s) => `${s.name} (${owedReason.get(s.name) ?? 'work in hand'})`),
+                });
+            }
             if (selection.unbound.length > 0) {
                 this.logger.warn('Not auto-restoring sessions whose name no team member is bound to', {
                     unbound: selection.unbound,
@@ -4864,9 +4961,10 @@ export class CrewlyServer {
                     truncated: selection.skippedNoWork.length > 20,
                 });
             }
-            const agentSessions = selection.sessions;
+            const agentSessions = [...selection.sessions, ...idleAtShutdown];
             if (agentSessions.length === 0) {
                 this.logger.info('No persisted agent sessions to restore (all idle, no pending WorkItems)');
+                this.bootRestoreDone = true;
                 return;
             }
             this.logger.info('Auto-restoring agent sessions from persisted state', {
@@ -4883,6 +4981,7 @@ export class CrewlyServer {
                 owedSince.set(c.sessionName, Math.min(owedSince.get(c.sessionName) ?? Infinity, Number.isFinite(due) ? due : 0));
             }
             const leadRoles = TEAM_LEAD_CONSTANTS.LEAD_ROLES;
+            const wasIdle = new Set(idleAtShutdown.map((s) => s.name));
             const entries = agentSessions.map((session) => {
                 const ownerTimes = queueMessages.peek(session.name).filter((m) => m.meta?.owner === true).map((m) => m.queuedAt);
                 if (owedSince.has(session.name))
@@ -4911,18 +5010,31 @@ export class CrewlyServer {
                         });
                         if (!result.success)
                             this.logger.warn('Failed to restore agent session', { name: session.name, error: result.error });
+                        // Every slot was taken: keep trying until one frees instead of
+                        // dropping the agent (the owner's thread is still waiting).
+                        if (!result.success && result.errorCode === RESOURCE_MODE_CONSTANTS.START_DEFERRED_ERROR_CODE)
+                            this.retryRestoreWhileOwed(session.name);
                         return { success: result.success };
                     },
                     onReady: () => this.sendRecoveryFor(session.name),
+                    // Memory is tight and nobody waits on it: the retry brings it back
+                    // when the machine eases (held by bootLaunchHold), never dropped.
+                    onDeferred: () => {
+                        this.noteHeldBackAtBoot(session.name);
+                        this.retryRestoreWhileOwed(session.name);
+                    },
+                    essential: ownerTimes.length > 0 || session.role === ORCHESTRATOR_ROLE || ownerThreadWaits.has(session.name),
                 };
+                // An agent that was idle at shutdown says in the plan what it is owed.
+                const idle = wasIdle.has(session.name) ? ` (${owedReason.get(session.name) ?? 'work in hand'}; was idle at shutdown)` : '';
                 if (ownerTimes.length > 0) {
-                    return { ...base, tier: RESTORE_TIER.OWNER, ownerSince: Math.min(...ownerTimes), reason: 'owner message waiting' };
+                    return { ...base, tier: RESTORE_TIER.OWNER, ownerSince: Math.min(...ownerTimes), reason: `owner message waiting${idle}` };
                 }
                 if (session.role === ORCHESTRATOR_ROLE)
                     return { ...base, tier: RESTORE_TIER.ORCHESTRATOR, reason: 'orchestrator' };
                 if (leadRoles.includes(session.role ?? ''))
-                    return { ...base, tier: RESTORE_TIER.LEAD, reason: 'team lead with work in hand' };
-                return { ...base, tier: RESTORE_TIER.OTHER, reason: 'work in hand' };
+                    return { ...base, tier: RESTORE_TIER.LEAD, reason: `team lead with work in hand${idle}` };
+                return { ...base, tier: RESTORE_TIER.OTHER, reason: `work in hand${idle}` };
             });
             // Runs in the background; boot continues while agents come back.
             void getRestoreQueue()
@@ -4933,15 +5045,139 @@ export class CrewlyServer {
             })
                 .catch((error) => {
                 this.logger.error('Restore queue failed', { error: error instanceof Error ? error.message : String(error) });
+            })
+                .finally(() => {
+                this.bootRestoreDone = true;
             });
         }
         catch (error) {
+            this.bootRestoreDone = true;
             this.logger.error('Failed to auto-restore agent sessions', {
                 error: error instanceof Error ? error.message : String(error),
             });
             // Don't fail startup if auto-restore fails
         }
     }
+    /**
+     * Restore entries for owed agents that have no persisted session: built from
+     * the team config the way a team start would (member role and runtime, the
+     * team's first project as the working directory). A binding whose member is
+     * gone from the config by now is skipped.
+     *
+     * @param teams - Teams from storage
+     * @param bindings - Targets resolved to members (see selectAutoRestoreSessions)
+     * @returns Session entries in the shape the restore queue runs
+     */
+    async persistedSessionsForBindings(teams, bindings) {
+        if (bindings.length === 0)
+            return [];
+        let projectPaths = new Map();
+        try {
+            projectPaths = new Map((await this.storageService.getProjects()).map((p) => [p.id, p.path]));
+        }
+        catch (err) {
+            this.logger.warn('Could not read projects for the owed agents; restoring them in the server directory', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        const out = [];
+        for (const binding of bindings) {
+            const team = teams.find((t) => t.id === binding.teamId);
+            const member = team?.members.find((m) => m.id === binding.memberId);
+            if (!team || !member)
+                continue;
+            out.push({
+                name: binding.name,
+                cwd: (team.projectIds[0] && projectPaths.get(team.projectIds[0])) || process.cwd(),
+                command: '',
+                args: [],
+                runtimeType: member.runtimeType,
+                role: member.role,
+                teamId: team.id,
+                memberId: member.id,
+            });
+        }
+        return out;
+    }
+    /**
+     * A boot restore was deferred by the running-agent cap. The agent is owed
+     * something that does not expire on its own (an owner thread, a promise,
+     * queued messages), so keep trying until a slot frees (crewly#1337's retry;
+     * the queue check is replaced because not every debt is a queued message).
+     * Never throws.
+     *
+     * @param sessionName - The agent whose restore was deferred
+     */
+    retryRestoreWhileOwed(sessionName) {
+        void (async () => {
+            const { scheduleDeferredStartRetry } = await import('./services/messaging/deferred-start-retry.js');
+            const { activateAgentBySession } = await import('./controllers/team/team.controller.js');
+            await scheduleDeferredStartRetry(sessionName, {
+                activate: (n) => {
+                    getBootLaunchPacer().note();
+                    return activateAgentBySession(this.apiController, n);
+                },
+                hasPending: (n) => !isOwnerStopped(n),
+                hold: () => this.bootLaunchHold(),
+            });
+        })().catch((err) => {
+            this.logger.warn('Could not retry a deferred boot restore', {
+                sessionName,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        });
+    }
+    /**
+     * Why a boot launch outside the restore queue must wait this round
+     * (crewly#1353): memory is tight (within the first hour), the restore queue
+     * is still launching, or another boot launch began less than the launch
+     * spacing ago. Null = go.
+     *
+     * @returns Reason to hold, or null
+     */
+    bootLaunchHold() {
+        return bootLaunchHoldReason({
+            snapshot: readBootPressureSnapshot,
+            restoreRunning: () => getRestoreQueue().stats().running,
+            pacer: getBootLaunchPacer(),
+            bootAt: this.bootAt,
+        });
+    }
+    /**
+     * Gate for the boot maintenance passes (crewly#1353): resolves when the
+     * boot restore is over and memory is calm, or after the wait cap with
+     * `reduced: true`.
+     *
+     * @returns A gate function for the service constructors
+     */
+    bootQuietGate() {
+        return () => waitForBootQuiet({ restoreDone: () => this.bootRestoreDone });
+    }
+    /**
+     * The boot restore handed an agent to the retry because memory was tight.
+     * Once, when the first one is held back, schedule the one-line owner note
+     * that is sent only if some of them are still down after
+     * OWNER_NOTE_AFTER_MS (crewly#1353).
+     *
+     * @param sessionName - The agent held back
+     */
+    noteHeldBackAtBoot(sessionName) {
+        this.heldBackAtBoot.add(sessionName);
+        if (this.heldBackNoticeScheduled)
+            return;
+        this.heldBackNoticeScheduled = true;
+        void scheduleHeldBackNotice({
+            stillHeld: async () => {
+                const out = [];
+                for (const name of this.heldBackAtBoot) {
+                    if (!(await this.apiController.agentRegistrationService.isSessionLiveOrLaunching(name)))
+                        out.push(name);
+                }
+                return out;
+            },
+            notify: (line) => slackOwnerAlertNotifier({ title: 'Agents waiting on memory', message: line, urgent: false }),
+        });
+    }
     /**
      * Check for and handle pending self-improvement from hot-reload.
      * This runs at startup to validate or rollback any changes made
@@ -6875,14 +7111,21 @@ export class CrewlyServer {
      *
      * @param sessionName - The agent to start
      * @param firstPauseMs - Pause before the first attempt (default: the retry's own)
+     * @param opts - `boot`: a boot launch, held while memory is tight and paced with the restore queue (crewly#1353)
      */
-    retryStartWhileQueued(sessionName, firstPauseMs) {
+    retryStartWhileQueued(sessionName, firstPauseMs, opts = {}) {
         void (async () => {
             const { scheduleDeferredStartRetry } = await import('./services/messaging/deferred-start-retry.js');
             const { activateAgentBySession } = await import('./controllers/team/team.controller.js');
             await scheduleDeferredStartRetry(sessionName, {
-                activate: (n) => activateAgentBySession(this.apiController, n),
+                activate: (n) => {
+                    if (opts.boot)
+                        getBootLaunchPacer().note();
+                    return activateAgentBySession(this.apiController, n);
+                },
                 hasPending: (n) => SubAgentMessageQueue.getInstance().hasPending(n),
+                // Boot launches outside the restore queue keep its spacing and its memory gate (crewly#1353).
+                ...(opts.boot ? { hold: () => this.bootLaunchHold() } : {}),
                 ...(firstPauseMs !== undefined ? { firstPauseMs } : {}),
             });
         })().catch((err) => {
@@ -6899,13 +7142,14 @@ export class CrewlyServer {
      * (with its messages persisted) was never started again (Pia, 2026-10-16).
      */
     wakeQueuedAgentsAfterBoot() {
-        const restoring = new Set(getRestoreQueue().stats().order);
+        const restoreQueue = getRestoreQueue();
         const backend = getSessionBackendSync();
         const registration = this.apiController.agentRegistrationService;
         const sessions = SubAgentMessageQueue.getInstance()
             .sessionsWithPending()
             .filter((name) => name !== ORCHESTRATOR_SESSION_NAME &&
-            !restoring.has(name) &&
+            // Waiting in the restore queue or being started by it right now
+            !restoreQueue.isRestoring(name) &&
             !isOwnerStopped(name) &&
             !pausedTeamOfSession(name) &&
             !backend?.sessionExists(name) &&
@@ -6914,7 +7158,7 @@ export class CrewlyServer {
             return;
         this.logger.info('Starting agents that were down with messages queued for them', { sessions });
         for (const name of sessions)
-            this.retryStartWhileQueued(name, SUB_AGENT_QUEUE_CONSTANTS.BOOT_QUEUED_WAKE_DELAY_MS);
+            this.retryStartWhileQueued(name, SUB_AGENT_QUEUE_CONSTANTS.BOOT_QUEUED_WAKE_DELAY_MS, { boot: true });
     }
     /**
      * Write a system note into the orchestrator's own chat (the conversation