cli-jaw 2.2.16 → 2.2.17

package/dist/src/agent/spawn/queue.js

@@ -2,24 +2,44 @@
 import crypto from 'node:crypto';
 import { groupQueueKey } from '../../messaging/session-key.js';
 import { stripUndefined } from '../../core/strip-undefined.js';
+import { withSessionScope } from '../../core/session-context.js';
+import { sessionLanes } from '../../orchestrator/session-lanes.js';
+import { scopeForChatSession } from '../../orchestrator/scope.js';
 export const FALLBACK_MAX_RETRIES = 3;
-export function createQueueController(deps) {
+export function createQueueController(deps, lanes = sessionLanes) {
+    const multiSessionEnabled = deps.isMultiSessionEnabled();
+    const localSessionScopeEnabled = deps.isLocalSessionScopeEnabled?.() === true;
+    if (multiSessionEnabled)
+        deps.migrateQueuedMessagesV1ToV2();
     function normalizeQueueItem(row) {
         try {
             const parsed = JSON.parse(row.payload);
             if (typeof parsed?.id !== 'string' || typeof parsed?.prompt !== 'string' || typeof parsed?.source !== 'string') {
                 return [];
             }
+            const chatSessionId = typeof parsed.chatSessionId === 'string' ? parsed.chatSessionId : 'default';
+            const remoteKey = typeof parsed.remoteKey === 'string' ? parsed.remoteKey : undefined;
+            const persistedScope = multiSessionEnabled && typeof parsed.scope === 'string' ? parsed.scope : 'default';
+            const scope = persistedScope === 'default'
+                ? scopeForChatSession(chatSessionId, remoteKey, localSessionScopeEnabled)
+                : persistedScope;
             return [stripUndefined({
+                    ...(multiSessionEnabled ? { schemaVersion: 2 } : {}),
                     id: parsed.id,
                     prompt: parsed.prompt,
                     source: parsed.source,
-                    scope: 'default',
+                    scope,
+                    ...(multiSessionEnabled ? {
+                        chatSessionId,
+                        ...(remoteKey ? { remoteKey } : {}),
+                    } : {}),
                     target: parsed.target,
                     chatId: parsed.chatId,
                     requestId: parsed.requestId,
                     overrides: parsed.overrides,
                     replyViaTarget: parsed.replyViaTarget === true,
+                    ...(multiSessionEnabled && parsed.collect === true ? { collect: true } : {}),
+                    ...(multiSessionEnabled && parsed.priority === 'head' ? { priority: 'head' } : {}),
                     ts: typeof parsed.ts === 'number' ? parsed.ts : Date.now(),
                 })];
         }
@@ -28,83 +48,133 @@ export function createQueueController(deps) {
         }
     }
     function loadPersistedQueue() {
-        return deps.listQueuedMessages.all().flatMap(normalizeQueueItem);
+        const recovered = deps.listQueuedMessages.all().flatMap(normalizeQueueItem);
+        if (!multiSessionEnabled)
+            return recovered;
+        return [
+            ...recovered.filter(item => item.priority === 'head'),
+            ...recovered.filter(item => item.priority !== 'head'),
+        ];
     }
     const messageQueue = loadPersistedQueue();
     if (messageQueue.length > 0) {
         console.log(`[queue] recovered ${messageQueue.length} persisted message(s) from previous session`);
     }
-    let queueProcessing = false;
-    // ─── 429 Retry Timer State ──────────────────────────
-    // INVARIANT: single-main — 동시에 1개의 main spawnAgent만 존재한다고 가정.
-    // 멀티 main task 도입 시 request-id 키 맵으로 전환 필요.
-    let retryPendingTimer = null;
-    let retryPendingResolve = null;
-    let retryPendingOrigin = null;
-    let retryPendingIsEmployee = false;
-    const fallbackState = new Map();
-    let queueHoldId = null;
-    let queueHoldTimer = null;
     const QUEUE_HOLD_TIMEOUT_MS = 10_000;
-    function clearRetryTimer(resumeQueue = true) {
-        if (retryPendingTimer) {
-            clearTimeout(retryPendingTimer);
-            retryPendingTimer = null;
-            console.log('[jaw:retry] timer cancelled');
-            if (retryPendingResolve) {
+    const drainingScopes = new Set();
+    const retryByScope = new Map();
+    const fallbackByScope = new Map();
+    const holdByScope = new Map();
+    const scheduledItemIds = new Set();
+    const normalizeScope = (scopeKey = 'default') => multiSessionEnabled ? scopeKey : 'default';
+    function retryEntry(scopeKey) {
+        const scope = normalizeScope(scopeKey);
+        let state = retryByScope.get(scope);
+        if (!state) {
+            state = { timer: null, resolve: null, origin: null, isEmployee: false };
+            retryByScope.set(scope, state);
+        }
+        return state;
+    }
+    function fallbackStateForScope(scopeKey) {
+        const scope = normalizeScope(scopeKey);
+        let state = fallbackByScope.get(scope);
+        if (!state) {
+            state = new Map();
+            fallbackByScope.set(scope, state);
+        }
+        return state;
+    }
+    function clearRetryTimer(scopeKeyOrResume = 'default', resumeQueue = true) {
+        const legacyCall = typeof scopeKeyOrResume === 'boolean';
+        const scope = normalizeScope(legacyCall ? 'default' : scopeKeyOrResume);
+        const shouldResume = legacyCall ? scopeKeyOrResume : resumeQueue;
+        const state = retryByScope.get(scope);
+        if (state?.timer) {
+            clearTimeout(state.timer);
+            state.timer = null;
+            console.log(`[jaw:retry] timer cancelled scope=${scope}`);
+            if (state.resolve) {
                 deps.broadcast('agent_done', {
                     text: '⏹️ 재시도 취소됨',
                     error: true,
-                    origin: retryPendingOrigin || 'web',
-                    ...(retryPendingIsEmployee ? { isEmployee: true } : {}),
-                }, retryPendingIsEmployee ? 'internal' : 'public');
-                retryPendingResolve({ text: '', code: -1 });
-                retryPendingResolve = null;
-                retryPendingOrigin = null;
-                retryPendingIsEmployee = false;
+                    origin: state.origin || 'web',
+                    ...(state.isEmployee ? { isEmployee: true } : {}),
+                }, state.isEmployee ? 'internal' : 'public');
+                state.resolve({ text: '', code: -1 });
+                state.resolve = null;
+                state.origin = null;
+                state.isEmployee = false;
             }
-            if (resumeQueue)
-                processQueue();
+            if (shouldResume)
+                void processQueue(scope);
         }
     }
-    function resetFallbackState() {
-        clearRetryTimer(true);
-        fallbackState.clear();
+    function resetFallbackState(scopeKey = 'default') {
+        if (scopeKey === null) {
+            for (const scope of retryByScope.keys())
+                clearRetryTimer(scope, false);
+            retryByScope.clear();
+            fallbackByScope.clear();
+        }
+        else {
+            const scope = normalizeScope(scopeKey);
+            clearRetryTimer(scope, false);
+            retryByScope.delete(scope);
+            fallbackByScope.delete(scope);
+        }
         console.log('[jaw:fallback] state reset');
     }
-    function getFallbackState() {
-        return Object.fromEntries(fallbackState);
+    function getFallbackState(scopeKey = 'default') {
+        if (scopeKey === null) {
+            return Object.fromEntries([...fallbackByScope].map(([scope, state]) => [scope, Object.fromEntries(state)]));
+        }
+        return Object.fromEntries(fallbackStateForScope(scopeKey));
     }
-    function setQueueHold(id, timeoutMs = QUEUE_HOLD_TIMEOUT_MS) {
-        if (queueHoldId && queueHoldId !== id)
-            clearQueueHold();
-        queueHoldId = id;
-        if (queueHoldTimer)
-            clearTimeout(queueHoldTimer);
-        const holdId = id;
-        queueHoldTimer = setTimeout(() => {
-            if (queueHoldId !== holdId)
+    function setQueueHold(scopeKey, idOrTimeout, timeoutMs = QUEUE_HOLD_TIMEOUT_MS) {
+        const legacyCall = typeof idOrTimeout !== 'string';
+        const scope = normalizeScope(legacyCall ? 'default' : scopeKey);
+        const id = legacyCall ? scopeKey : idOrTimeout;
+        const timeout = typeof idOrTimeout === 'number' ? idOrTimeout : timeoutMs;
+        const previous = holdByScope.get(scope);
+        if (previous)
+            clearTimeout(previous.timer);
+        const timer = setTimeout(() => {
+            if (holdByScope.get(scope)?.id !== id)
                 return;
-            console.warn(`[queue:hold] hold for ${holdId} expired after ${timeoutMs}ms`);
-            clearQueueHold();
-        }, timeoutMs);
-        console.log(`[queue:hold] set for ${id}`);
+            console.warn(`[queue:hold] hold for ${id} expired after ${timeout}ms scope=${scope}`);
+            clearQueueHold(scope, id);
+        }, timeout);
+        holdByScope.set(scope, { id, timer });
+        console.log(`[queue:hold] set for ${id} scope=${scope}`);
     }
-    function clearQueueHold(id, opts) {
-        if (id && queueHoldId !== id)
+    function clearQueueHold(scopeKey = 'default', idOrOpts, opts) {
+        const legacyCall = typeof idOrOpts === 'object' || (arguments.length === 1 && typeof scopeKey === 'string');
+        const requestedId = legacyCall ? scopeKey ?? undefined : idOrOpts;
+        const clearOpts = typeof idOrOpts === 'object' ? idOrOpts : opts;
+        let scope;
+        if (scopeKey === null) {
+            if (!requestedId)
+                return;
+            const match = [...holdByScope].find(([, hold]) => hold.id === requestedId);
+            if (!match)
+                return;
+            scope = match[0];
+        }
+        else {
+            scope = normalizeScope(legacyCall ? 'default' : scopeKey);
+        }
+        const hold = holdByScope.get(scope);
+        if (!hold || (requestedId && hold.id !== requestedId))
             return;
-        if (queueHoldTimer)
-            clearTimeout(queueHoldTimer);
-        queueHoldTimer = null;
-        const hadHold = queueHoldId !== null;
-        if (hadHold)
-            console.log(`[queue:hold] cleared (was ${queueHoldId})`);
-        queueHoldId = null;
-        if (hadHold && (opts?.resume ?? true))
-            queueMicrotask(() => processQueue());
+        clearTimeout(hold.timer);
+        holdByScope.delete(scope);
+        console.log(`[queue:hold] cleared (was ${hold.id}) scope=${scope}`);
+        if (clearOpts?.resume ?? true)
+            queueMicrotask(() => { void processQueue(scope); });
     }
-    function getQueueHoldId() {
-        return queueHoldId;
+    function getQueueHoldId(scopeKey = 'default') {
+        return holdByScope.get(normalizeScope(scopeKey))?.id ?? null;
     }
     function getQueuedMessageSnapshotForScope(scope) {
         return messageQueue
@@ -116,10 +186,11 @@ export function createQueueController(deps) {
             ts: item.ts,
         }));
     }
-    function queueUpdatePayload() {
+    function queueUpdatePayload(scope = 'default') {
         return {
             pending: messageQueue.length,
-            queued: getQueuedMessageSnapshotForScope('default'),
+            queued: getQueuedMessageSnapshotForScope(scope),
+            ...(multiSessionEnabled ? { scope } : {}),
         };
     }
     function drainHeartbeatPendingSoon() {
@@ -134,6 +205,7 @@ export function createQueueController(deps) {
         if (idx === -1)
             return { removed: null, pending: messageQueue.length };
         const [removed] = messageQueue.splice(idx, 1);
+        scheduledItemIds.delete(id);
         try {
             deps.deleteQueuedMessage.run(id);
         }
@@ -141,133 +213,206 @@ export function createQueueController(deps) {
             console.warn(`[queue] DB delete failed for ${id}:`, err.message);
         }
         console.log(`[queue] -1 (${messageQueue.length} pending) removed=${id}`);
-        deps.broadcast('queue_update', queueUpdatePayload());
+        deps.broadcast('queue_update', queueUpdatePayload(removed.scope));
         return { removed: removed, pending: messageQueue.length };
     }
     function enqueueMessage(prompt, source, meta) {
         const item = stripUndefined({
+            ...(multiSessionEnabled ? { schemaVersion: 2 } : {}),
             id: crypto.randomUUID(),
             prompt,
             source,
-            scope: meta?.scope || 'default',
+            scope: multiSessionEnabled ? (meta?.scope || 'default') : 'default',
+            ...(multiSessionEnabled ? {
+                chatSessionId: meta?.chatSessionId || deps.getActiveChatSession(),
+                ...(meta?.remoteKey ? { remoteKey: meta.remoteKey } : {}),
+            } : {}),
             target: meta?.target,
             chatId: meta?.chatId,
             requestId: meta?.requestId,
             overrides: meta?.overrides,
             replyViaTarget: meta?.replyViaTarget,
+            ...(multiSessionEnabled && meta?.collect === true ? { collect: true } : {}),
+            ...(multiSessionEnabled && meta?.front === true ? { priority: 'head' } : {}),
             ts: Date.now(),
         });
         deps.insertQueuedMessage.run(item.id, JSON.stringify(item));
-        messageQueue.push(item);
+        if (multiSessionEnabled && meta?.front === true)
+            messageQueue.unshift(item);
+        else
+            messageQueue.push(item);
         console.log(`[queue] +1 (${messageQueue.length} pending)`);
-        deps.broadcast('queue_update', queueUpdatePayload());
-        processQueue();
+        deps.broadcast('queue_update', queueUpdatePayload(item.scope));
+        void processQueue(item.scope);
         return item.id;
     }
-    // Queue policy: "fair" — batch head runs, tail goes after remaining
-    async function processQueue() {
-        if (queueProcessing)
-            return;
-        if (!deps.isSpawnBusy() && !deps.hasBlockingWorkers() && deps.hasPendingWorkerReplays()) {
+    // Queue policy: "fair" — batch head runs, tail goes after remaining.
+    // Pending worker replays are intentionally not gated here: orchestrate()
+    // drains them at entry, avoiding the documented processQueue deadlock.
+    async function processQueue(scopeKey = 'default') {
+        const requestedScope = normalizeScope(scopeKey);
+        if (!deps.isSpawnBusy(requestedScope)
+            && !deps.hasBlockingWorkers(requestedScope)
+            && deps.hasPendingWorkerReplays(requestedScope)) {
             queueMicrotask(() => {
                 deps.importPipeline()
-                    .then(({ drainPendingReplays }) => drainPendingReplays({ origin: 'system' }))
+                    .then(({ drainPendingReplays }) => drainPendingReplays(requestedScope, { origin: 'system' }))
                     .catch(err => console.error('[processQueue:drain]', err.message));
             });
         }
-        if (!deps.isSpawnBusy()
-            && !deps.hasBlockingWorkers()
-            && !deps.hasPendingWorkerReplays()
+        if (!deps.isSpawnBusy(requestedScope)
+            && !deps.hasBlockingWorkers(requestedScope)
+            && !deps.hasPendingWorkerReplays(requestedScope)
             && messageQueue.length === 0
-            && !queueHoldId) {
+            && !holdByScope.has(requestedScope)) {
             drainHeartbeatPendingSoon();
         }
-        if (deps.isSpawnBusy()
-            || deps.hasBlockingWorkers()
-            || messageQueue.length === 0
-            || queueHoldId)
-            return;
-        // NOTE: hasPendingWorkerReplays() is intentionally NOT gated here —
-        // orchestrate() drains pending replays at entry (pipeline.ts drainPendingReplays),
-        // so the queued user message still arrives AFTER the worker result. Keeping this
-        // gate caused a deadlock (see devlog/_plan/260417_message_duplication/02_*).
-        queueProcessing = true;
-        const first = messageQueue[0];
-        const groupKey = groupQueueKey(first.source, first.target);
-        const batch = [];
-        const remaining = [];
-        for (const m of messageQueue) {
-            const key = groupQueueKey(m.source, m.target);
-            if (key === groupKey)
-                batch.push(m);
-            else
-                remaining.push(m);
-        }
-        messageQueue.length = 0;
-        if (batch.length > 1) {
-            messageQueue.push(...remaining, ...batch.slice(1));
-        }
-        else {
-            messageQueue.push(...remaining);
+        let item;
+        for (const candidate of messageQueue) {
+            const candidateScope = normalizeScope(candidate.scope);
+            if (scheduledItemIds.has(candidate.id) || drainingScopes.has(candidateScope) || holdByScope.has(candidateScope))
+                continue;
+            if (deps.isSpawnBusy(candidateScope) || deps.hasBlockingWorkers(candidateScope))
+                continue;
+            if (deps.hasPendingWorkerReplays(candidateScope)) {
+                queueMicrotask(() => {
+                    deps.importPipeline()
+                        .then(({ drainPendingReplays }) => drainPendingReplays(candidateScope, { origin: 'system' }))
+                        .catch(err => console.error('[processQueue:drain]', err.message));
+                });
+                continue;
+            }
+            item = candidate;
+            break;
         }
-        const item = batch[0];
-        const combined = item.prompt;
-        const source = item.source;
-        const target = item.target;
-        const chatId = item.chatId;
-        const requestId = item.requestId;
-        const overrides = item.overrides;
-        const replyViaTarget = item.replyViaTarget;
-        const origin = source || 'web';
-        console.log(`[queue] processing 1/${batch.length} message(s) for ${groupKey}, ${messageQueue.length} remaining`);
-        let inserted = false;
-        try {
-            deps.insertMessage.run('user', combined, source, '', deps.getWorkingDir(), deps.getActiveChatSession());
-            deps.deleteQueuedMessage.run(item.id);
-            inserted = true;
-            deps.broadcast('new_message', { role: 'user', content: combined, source, fromQueue: true });
-            deps.broadcast('queue_update', queueUpdatePayload());
-            const { orchestrate, orchestrateContinue, orchestrateReset, isContinueIntent, isResetIntent } = await deps.importPipeline();
-            const task = isResetIntent(combined)
-                ? orchestrateReset({ origin, target, chatId, requestId, overrides, replyViaTarget, _skipInsert: true })
-                : isContinueIntent(combined)
-                    ? orchestrateContinue({ origin, target, chatId, requestId, overrides, replyViaTarget, _skipInsert: true })
-                    : orchestrate(combined, { origin, target, chatId, requestId, overrides, replyViaTarget, _skipInsert: true });
-            try {
-                await task;
+        if (!item)
+            return;
+        const itemScope = normalizeScope(item.scope);
+        drainingScopes.add(itemScope);
+        scheduledItemIds.add(item.id);
+        queueMicrotask(() => { void processQueue(itemScope); });
+        await lanes.runDetachedTurn(itemScope, async () => {
+            const liveIndex = messageQueue.findIndex(candidate => candidate.id === item.id);
+            if (liveIndex === -1) {
+                scheduledItemIds.delete(item.id);
+                drainingScopes.delete(itemScope);
+                queueMicrotask(() => { void processQueue(itemScope); });
+                return;
             }
-            catch (err) {
-                const msg = err.message;
-                console.error('[queue:orchestrate]', msg);
-                deps.broadcast('orchestrate_done', { text: `[error] ${msg}`, error: true, origin, chatId, target, requestId, replyViaTarget });
+            const collectedItems = multiSessionEnabled && item.collect
+                ? messageQueue.filter(candidate => normalizeScope(candidate.scope) === itemScope && candidate.collect === true && !scheduledItemIds.has(candidate.id))
+                : [];
+            const runItems = [item, ...collectedItems];
+            const runIds = new Set(runItems.map(candidate => candidate.id));
+            for (let index = messageQueue.length - 1; index >= 0; index--) {
+                if (runIds.has(messageQueue[index].id))
+                    messageQueue.splice(index, 1);
             }
-        }
-        catch (setupErr) {
-            console.error('[queue:setup]', setupErr);
-            if (!inserted) {
-                messageQueue.unshift(item);
+            for (const runItem of runItems)
+                scheduledItemIds.delete(runItem.id);
+            const groupKey = groupQueueKey(item.source, item.target);
+            const combined = runItems.map(candidate => candidate.prompt).join('\n\n');
+            const source = item.source;
+            const target = item.target;
+            const chatId = item.chatId;
+            const requestId = item.requestId;
+            const overrides = item.overrides;
+            const replyViaTarget = item.replyViaTarget;
+            const origin = source || 'web';
+            console.log(`[queue] processing message for ${groupKey}, ${messageQueue.length} remaining`);
+            const effectiveSessionId = multiSessionEnabled
+                ? (item.chatSessionId || deps.getActiveChatSession())
+                : deps.getActiveChatSession();
+            let inserted = false;
+            try {
+                const sessionScope = { scope: item.scope, chatSessionId: effectiveSessionId };
+                const eventScope = multiSessionEnabled
+                    ? { scope: item.scope, sessionId: effectiveSessionId }
+                    : undefined;
+                deps.insertMessage.run('user', combined, source, '', deps.getWorkingDir(), effectiveSessionId);
+                inserted = true;
+                for (const runItem of runItems) {
+                    try {
+                        deps.deleteQueuedMessage.run(runItem.id);
+                    }
+                    catch (err) {
+                        console.warn(`[queue] DB delete failed for ${runItem.id}:`, err.message);
+                    }
+                }
+                if (multiSessionEnabled) {
+                    deps.broadcast('new_message', { role: 'user', content: combined, source, fromQueue: true, ...eventScope });
+                }
+                else {
+                    deps.broadcast('new_message', { role: 'user', content: combined, source, fromQueue: true });
+                }
+                deps.broadcast('queue_update', queueUpdatePayload(item.scope));
+                await withSessionScope(sessionScope, async () => {
+                    const { orchestrate, orchestrateContinue, orchestrateReset, isContinueIntent, isResetIntent } = await deps.importPipeline();
+                    const scopedMeta = stripUndefined({
+                        origin, target, chatId, requestId, scope: item.scope,
+                        chatSessionId: effectiveSessionId,
+                        ...(item.remoteKey ? { remoteKey: item.remoteKey } : {}),
+                        overrides, replyViaTarget, _skipInsert: true,
+                    });
+                    const task = isResetIntent(combined)
+                        ? orchestrateReset(scopedMeta)
+                        : isContinueIntent(combined)
+                            ? orchestrateContinue(scopedMeta)
+                            : orchestrate(combined, scopedMeta);
+                    try {
+                        await task;
+                    }
+                    catch (err) {
+                        const msg = err.message;
+                        console.error('[queue:orchestrate]', msg);
+                        deps.broadcast('orchestrate_done', { text: `[error] ${msg}`, error: true, origin, chatId, target, requestId, replyViaTarget, ...(eventScope || {}) });
+                    }
+                });
             }
-            else {
-                deps.broadcast('orchestrate_done', { text: `[error] setup failed: ${setupErr.message}`, error: true, origin, chatId, target, requestId, replyViaTarget });
+            catch (setupErr) {
+                console.error('[queue:setup]', setupErr);
+                if (!inserted) {
+                    messageQueue.unshift(...runItems);
+                }
+                else {
+                    deps.broadcast('orchestrate_done', { text: `[error] setup failed: ${setupErr.message}`, error: true, origin, chatId, target, requestId, replyViaTarget,
+                        ...(multiSessionEnabled ? { scope: item.scope, sessionId: effectiveSessionId } : {}) });
+                }
             }
-        }
-        finally {
-            queueProcessing = false;
-            queueMicrotask(() => processQueue());
-        }
+            finally {
+                for (const runItem of runItems)
+                    scheduledItemIds.delete(runItem.id);
+                drainingScopes.delete(itemScope);
+                queueMicrotask(() => { void processQueue(itemScope); });
+            }
+        });
     }
-    function purgeQueueOnStop(reason) {
-        if (messageQueue.length === 0)
+    function purgeQueueOnStop(scopeKey, reason) {
+        const scope = scopeKey === null ? null : normalizeScope(scopeKey);
+        const droppedItems = messageQueue.filter(item => scope === null || normalizeScope(item.scope) === scope);
+        if (droppedItems.length === 0)
             return;
-        const dropped = messageQueue.length;
-        for (const item of messageQueue.splice(0)) {
+        const droppedIds = new Set(droppedItems.map(item => item.id));
+        const scopes = new Set(droppedItems.map(item => item.scope));
+        for (let index = messageQueue.length - 1; index >= 0; index--) {
+            const item = messageQueue[index];
+            if (!droppedIds.has(item.id))
+                continue;
+            messageQueue.splice(index, 1);
+            scheduledItemIds.delete(item.id);
             try {
                 deps.deleteQueuedMessage.run(item.id);
             }
             catch { /* best-effort */ }
         }
-        console.log(`[jaw:stop] cleared ${dropped} pending message(s) (reason=${reason})`);
-        deps.broadcast('queue_update', queueUpdatePayload());
+        console.log(`[jaw:stop] cleared ${droppedItems.length} pending message(s) (reason=${reason})`);
+        if (multiSessionEnabled) {
+            for (const scope of scopes)
+                deps.broadcast('queue_update', queueUpdatePayload(scope));
+        }
+        else {
+            deps.broadcast('queue_update', queueUpdatePayload());
+        }
     }
     return {
         enqueueMessage,
@@ -276,23 +421,35 @@ export function createQueueController(deps) {
         setQueueHold,
         clearQueueHold,
         getQueueHoldId,
+        // The gate is read once at construction, so every scope collapses onto 'default'
+        // for the whole process life when it is off. Callers that build a scope key must
+        // ask this instead of re-reading settings, or they look at a lane the queue never
+        // uses (a live-settings read made session deletion miss real work).
+        isScopedQueue: () => multiSessionEnabled,
         clearRetryTimer,
         resetFallbackState,
         getFallbackState,
         getQueuedMessageSnapshotForScope,
         messageQueue,
-        fallbackState,
-        isRetryPending: () => !!retryPendingTimer,
-        isQueueBusy: () => queueProcessing,
+        fallbackStateForScope,
+        isRetryPending: (scopeKey = 'default') => scopeKey === null
+            ? [...retryByScope.values()].some(state => state.timer !== null)
+            : Boolean(retryByScope.get(normalizeScope(scopeKey))?.timer),
+        isQueueBusy: (scopeKey = 'default') => scopeKey === null
+            ? drainingScopes.size > 0
+            : drainingScopes.has(normalizeScope(scopeKey)),
         purgeQueueOnStop,
-        retryState: {
-            get timer() { return retryPendingTimer; },
-            get resolve() { return retryPendingResolve; },
-            get origin() { return retryPendingOrigin; },
-            setTimer: (t) => { retryPendingTimer = t; },
-            setResolve: (r) => { retryPendingResolve = r; },
-            setOrigin: (o) => { retryPendingOrigin = o; },
-            setIsEmployee: (v) => { retryPendingIsEmployee = v; },
+        retryStateForScope: (scopeKey) => {
+            const state = retryEntry(scopeKey);
+            return {
+                get timer() { return state.timer; },
+                get resolve() { return state.resolve; },
+                get origin() { return state.origin; },
+                setTimer: (t) => { state.timer = t; },
+                setResolve: (r) => { state.resolve = r; },
+                setOrigin: (o) => { state.origin = o; },
+                setIsEmployee: (v) => { state.isEmployee = v; },
+            };
         },
     };
 }