@foxden-app/foxclaw 0.12.0 → 0.13.0

package/dist/core/queued_engine_input.d.ts

@@ -0,0 +1,12 @@
+import type { StagedAttachment } from './attachment_types.js';
+export interface QueuedEngineInput {
+    version: 1;
+    prompt: string;
+    backendId: string;
+    cwd: string;
+    stagedAttachments: StagedAttachment[];
+}
+export declare function decodeQueuedEngineInput(inputJson: string, fallbackPrompt: string): QueuedEngineInput | {
+    prompt: string;
+    stagedAttachments: StagedAttachment[];
+};

package/dist/core/queued_engine_input.js

@@ -0,0 +1,16 @@
+export function decodeQueuedEngineInput(inputJson, fallbackPrompt) {
+    const input = JSON.parse(inputJson);
+    // Legacy queues contained only a Codex-shaped text input array.
+    if (Array.isArray(input)) {
+        const text = input[0]?.text;
+        return { prompt: typeof text === 'string' ? text : fallbackPrompt, stagedAttachments: [] };
+    }
+    if (typeof input !== 'object' || input === null || !('version' in input) || input.version !== 1 ||
+        !('prompt' in input) || typeof input.prompt !== 'string' ||
+        !('backendId' in input) || typeof input.backendId !== 'string' ||
+        !('cwd' in input) || typeof input.cwd !== 'string' ||
+        !('stagedAttachments' in input) || !Array.isArray(input.stagedAttachments)) {
+        throw new Error('Invalid queued engine input');
+    }
+    return input;
+}

package/dist/core/runtime_supervisor.d.ts

@@ -0,0 +1,19 @@
+export interface ManagedRuntime {
+    start?(): void | Promise<void>;
+    stop(): void | Promise<void>;
+}
+export interface ShutdownFailure {
+    name: string;
+    error: unknown;
+}
+/** Owns resources from allocation onward, including partially started runtimes. */
+export declare class RuntimeSupervisor {
+    private readonly entries;
+    private readonly identities;
+    private closing;
+    private shutdown;
+    register(name: string, resource: ManagedRuntime): void;
+    start(name: string): Promise<void>;
+    stop(): Promise<ShutdownFailure[]>;
+    private stopAll;
+}

package/dist/core/runtime_supervisor.js

@@ -0,0 +1,45 @@
+/** Owns resources from allocation onward, including partially started runtimes. */
+export class RuntimeSupervisor {
+    entries = [];
+    identities = new Set();
+    closing = false;
+    shutdown = null;
+    register(name, resource) {
+        if (this.closing)
+            throw new Error('Runtime supervisor is stopping');
+        if (this.identities.has(resource))
+            return;
+        if (this.entries.some(entry => entry.name === name))
+            throw new Error(`Runtime already registered: ${name}`);
+        this.identities.add(resource);
+        this.entries.push({ name, resource, start: null });
+    }
+    start(name) {
+        if (this.closing)
+            return Promise.reject(new Error('Runtime supervisor is stopping'));
+        const entry = this.entries.find(entry => entry.name === name);
+        if (!entry)
+            return Promise.reject(new Error(`Unknown runtime: ${name}`));
+        entry.start ??= Promise.resolve().then(() => entry.resource.start?.());
+        return entry.start;
+    }
+    stop() {
+        this.closing = true;
+        this.shutdown ??= this.stopAll();
+        return this.shutdown;
+    }
+    async stopAll() {
+        const failures = [];
+        // Consumers are registered after their dependencies and stopped before them.
+        for (const entry of [...this.entries].reverse()) {
+            await entry.start?.catch(() => { });
+            try {
+                await entry.resource.stop();
+            }
+            catch (error) {
+                failures.push({ name: entry.name, error });
+            }
+        }
+        return failures;
+    }
+}

package/dist/core/scope_operations.d.ts

@@ -0,0 +1,7 @@
+/** Serialize state changes for one conversation; unrelated scopes proceed independently. */
+export declare class ScopeOperations {
+    private readonly tails;
+    run<T>(scopeId: string, operation: () => Promise<T>): Promise<T>;
+    isIdle(): boolean;
+    idle(): Promise<void>;
+}

package/dist/core/scope_operations.js

@@ -0,0 +1,19 @@
+/** Serialize state changes for one conversation; unrelated scopes proceed independently. */
+export class ScopeOperations {
+    tails = new Map();
+    run(scopeId, operation) {
+        const previous = this.tails.get(scopeId) ?? Promise.resolve();
+        const next = previous.catch(() => { }).then(operation);
+        this.tails.set(scopeId, next);
+        void next.finally(() => {
+            if (this.tails.get(scopeId) === next)
+                this.tails.delete(scopeId);
+        }).catch(() => { });
+        return next;
+    }
+    isIdle() { return this.tails.size === 0; }
+    async idle() {
+        while (this.tails.size)
+            await Promise.allSettled([...this.tails.values()]);
+    }
+}

package/dist/core/stream_preview.js

@@ -1,5 +1,5 @@
 import { formatMetricTokenCount } from '../store/token_usage.js';
-import { chunkTelegramMessage } from '../telegram/text.js';
+import { chunkMessage } from './message_text.js';
 export function formatElapsedDuration(seconds, locale = 'zh') {
     if (!Number.isFinite(seconds) || seconds <= 0)
         return '0s';
@@ -75,14 +75,26 @@ export function buildFoldedToolsSummary(options) {
                 : '';
             previewLines = [...head, omittedNote, ...tail].filter(Boolean);
         }
-        toolDetailSection = `\n\n<i>${locale === 'zh' ? '工具调用记录:' : 'Tool calls:'}</i>\n${previewLines.join('\n')}`;
+        // Keep whole formatted lines within the summary budget; never slice through tags/entities.
+        const bounded = [];
+        let budget = 1500;
+        for (const line of [...previewLines].reverse()) {
+            if (line.length + 1 > budget)
+                continue;
+            bounded.unshift(line);
+            budget -= line.length + 1;
+        }
+        const omittedBySize = previewLines.length - bounded.length;
+        if (omittedBySize)
+            bounded.unshift(`<i>${locale === 'zh' ? `另有 ${omittedBySize} 项记录已收起` : `${omittedBySize} additional entries omitted`}</i>`);
+        toolDetailSection = `\n\n<i>${locale === 'zh' ? '工具调用记录:' : 'Tool calls:'}</i>\n${bounded.join('\n')}`;
     }
     return `<blockquote expandable>${header}${usageLine}${toolDetailSection}</blockquote>\n\n`;
 }
 export function combineSummaryAndResponse(foldedSummary, responseText, limit = 4000) {
     const content = (responseText || '(无输出 / No output)').trim();
     if (!foldedSummary) {
-        return chunkTelegramMessage(content, limit);
+        return chunkMessage(content, limit);
     }
     const combined = `${foldedSummary}${content}`;
     if (combined.length <= limit) {
@@ -96,18 +108,18 @@ export function combineSummaryAndResponse(foldedSummary, responseText, limit = 4
         if (splitAt >= Math.floor(remainingInFirstChunk / 3)) {
             const firstChunkText = content.slice(0, splitAt + 1).trim();
             const rest = content.slice(splitAt + 1).trim();
-            const restChunks = chunkTelegramMessage(rest, limit);
+            const restChunks = chunkMessage(rest, limit);
             return [`${foldedSummary}${firstChunkText}`, ...restChunks];
         }
     }
     // If foldedSummary takes up most of the message or no clean paragraph break was found,
     // foldedSummary gets its own clean message, and responseText is chunked independently.
-    const responseChunks = chunkTelegramMessage(content, limit);
+    const responseChunks = chunkMessage(content, limit);
     return [foldedSummary.trim(), ...responseChunks];
 }
 export function renderStreamPreviewContent(state) {
     const parts = [];
-    const name = state.engineName || 'AI';
+    const name = escapeTelegramHtml(state.engineName || 'AI');
     const roundText = state.stepIndex && state.stepIndex > 0 ? `第 ${state.stepIndex} 轮` : '';
     const toolText = typeof state.toolCount === 'number' && state.toolCount > 0 ? `累计执行 ${state.toolCount} 次工具` : '';
     const timeText = typeof state.elapsedSeconds === 'number' && state.elapsedSeconds > 0 ? `已耗时 ${state.elapsedSeconds}s` : '';
@@ -125,13 +137,13 @@ export function renderStreamPreviewContent(state) {
         parts.push('');
     }
     if (state.toolLines.length > 0) {
-        const recent = state.toolLines.slice(-6);
+        const recent = state.toolLines.slice(-3);
         parts.push(`<blockquote expandable>🛠️ <b>正在调用工具 (${state.toolLines.length} 项)</b>\n${recent.join('\n')}</blockquote>`);
         parts.push('');
     }
     if (state.accumulatedText) {
-        const preview = state.accumulatedText.slice(-3000);
-        parts.push(preview);
+        const preview = state.accumulatedText.slice(-1000);
+        parts.push(escapeTelegramHtml(preview));
     }
     else {
         parts.push(state.isBoost ? `🚀 ${name} (Boost 模式) 正在深度思考中…` : `⏳ ${name} 正在思考中…`);

package/dist/dsh/adapter.js

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
 import fs from 'node:fs/promises';
-import { buildAttachmentPrompt, isNativeImageAttachment } from '../telegram/media.js';
+import { buildAttachmentPrompt, isNativeImageAttachment } from '../core/attachment_files.js';
 export function optionChoices(option) {
     if (option?.type !== 'select')
         return [];
@@ -107,7 +107,7 @@ export class DshEngineAdapter {
         let finalMessageId;
         const tools = new Map();
         const onUpdate = (notification) => {
-            if (notification.sessionId !== state?.sessionId)
+            if (cancelled || notification.sessionId !== state?.sessionId)
                 return;
             const update = notification.update;
             if (update.sessionUpdate === 'agent_message_chunk' && update.content.type === 'text') {
@@ -170,13 +170,26 @@ export class DshEngineAdapter {
         };
         queueMicrotask(() => { void run(); });
         return {
-            cancel: () => {
-                if (finished || cancelled)
+            cancel: async () => {
+                if (finished || cancelled) {
+                    await promise;
                     return;
+                }
                 cancelled = true;
                 state?.client.cancelPermissions?.();
                 if (state?.client.connected)
-                    void state.client.agent.notify('session/cancel', { sessionId: state.sessionId }).catch(() => { });
+                    await state.client.agent.notify('session/cancel', { sessionId: state.sessionId }).catch(() => { });
+                let timer;
+                try {
+                    await Promise.race([promise, new Promise(resolve => { timer = setTimeout(resolve, 5000); })]);
+                    if (!finished)
+                        await this.clients.get(request.scopeId)?.stop();
+                    await promise;
+                }
+                finally {
+                    if (timer)
+                        clearTimeout(timer);
+                }
             },
             waitForResult: () => promise,
             on: (event, listener) => { emitter.on(event, listener); },

package/dist/dsh/backend.d.ts

@@ -0,0 +1,7 @@
+import type { AppConfig } from '../config.js';
+import type { BridgeStore } from '../store/database.js';
+import type { Logger } from '../logger.js';
+import type { ChannelPort } from '../core/channel_port.js';
+import type { BackendDescriptor } from '../core/engine_spi.js';
+/** Same definition is mounted on a shared bot or on a dedicated DSH bot. */
+export declare function createDshBackend(config: AppConfig, store: BridgeStore, logger: Logger, messaging: ChannelPort): BackendDescriptor;

package/dist/dsh/backend.js

@@ -0,0 +1,21 @@
+import { getDshTelegramCommands } from '../i18n.js';
+import { DshUi } from './ui.js';
+/** Same definition is mounted on a shared bot or on a dedicated DSH bot. */
+export function createDshBackend(config, store, logger, messaging) {
+    const ui = new DshUi(config, store, logger, messaging);
+    return {
+        id: ui.adapter.id, name: ui.adapter.name, engineType: ui.adapter.id, adapter: ui.adapter,
+        defaults: { reasoningEffort: null, supportedReasoningEfforts: [], boost: false, tokenUsage: false },
+        commands: getDshTelegramCommands,
+        createUi: host => ({
+            ownsCallback: data => data.startsWith('dsh:'),
+            getPendingApprovals: () => ui.pendingApprovals,
+            stop: () => ui.stop(),
+            renderCustomStatus: async (scopeId, locale) => ui.status(scopeId, locale),
+            renderSetupMenu: async (scopeId, locale, messageId) => { await ui.setup(scopeId, locale, host, messageId); return true; },
+            renderModelsMenu: async (scopeId, locale, messageId) => { await ui.models(scopeId, locale, host, messageId); return true; },
+            handleCustomCommand: (scopeId, command, args, locale) => ui.command(scopeId, command, args, locale, host),
+            handleCustomCallback: (scopeId, data, locale, _messageId, event) => ui.callback(scopeId, data, locale, host, event),
+        }),
+    };
+}

package/dist/dsh/runtime.d.ts

@@ -4,7 +4,6 @@ import type { BridgeStore } from '../store/database.js';
 /** Dedicated DSH bot using the same backend and channel orchestration as other bots. */
 export declare class DshTelegramRuntime {
     private readonly bot;
-    private readonly ui;
     private readonly orchestrator;
     private running;
     constructor(config: AppConfig, store: BridgeStore, logger: Logger);

package/dist/dsh/runtime.js

@@ -2,12 +2,11 @@ import { TelegramGateway } from '../telegram/gateway.js';
 import { TelegramMessagingPort } from '../channels/telegram/telegram_messaging_port.js';
 import { getDshTelegramCommands } from '../i18n.js';
 import { UnifiedChannelOrchestrator } from '../core/orchestrator.js';
-import { DshUi } from './ui.js';
+import { createDshBackend } from './backend.js';
 import { BRIDGE_SCOPE_TELEGRAM_PREFIX, parseTelegramTargetFromBridgeScope } from '../core/bridge_scope.js';
 /** Dedicated DSH bot using the same backend and channel orchestration as other bots. */
 export class DshTelegramRuntime {
     bot;
-    ui;
     orchestrator;
     running = false;
     constructor(config, store, logger) {
@@ -15,17 +14,10 @@ export class DshTelegramRuntime {
             throw new Error('DSH_BOT_TOKEN is required');
         this.bot = new TelegramGateway(config.dshBotToken, config.tgAllowedUserId, config.tgAllowedChatId, config.telegramPollIntervalMs, store, logger, true, getDshTelegramCommands);
         const messaging = new TelegramMessagingPort(this.bot);
-        this.ui = new DshUi(config, store, logger, messaging);
+        const backend = createDshBackend(config, store, logger, messaging);
         this.orchestrator = new UnifiedChannelOrchestrator({
-            config, store, logger, bot: this.bot, adapter: this.ui.adapter, messaging,
+            config, store, logger, bot: this.bot, backends: [backend], defaultBackendId: backend.id, messaging,
             ownsScope: scopeId => scopeId.startsWith(BRIDGE_SCOPE_TELEGRAM_PREFIX) && parseTelegramTargetFromBridgeScope(scopeId).botId === this.bot.identity,
-            customUi: {
-                renderCustomStatus: async (scopeId, locale) => this.ui.status(scopeId, locale),
-                renderSetupMenu: async (scopeId, locale, messageId) => { await this.ui.setup(scopeId, locale, this.orchestrator, messageId); return true; },
-                renderModelsMenu: async (scopeId, locale, messageId) => { await this.ui.models(scopeId, locale, this.orchestrator, messageId); return true; },
-                handleCustomCommand: (scopeId, command, args, locale) => this.ui.command(scopeId, command, args, locale, this.orchestrator),
-                handleCustomCallback: (scopeId, data, locale, _messageId, event) => this.ui.callback(scopeId, data, locale, this.orchestrator, event),
-            },
         });
         this.orchestrator.registerInboundHandlers();
     }
@@ -37,9 +29,8 @@ export class DshTelegramRuntime {
     async stop() {
         this.running = false;
         await this.orchestrator.stop();
-        await this.ui.stop();
     }
     getRuntimeStatus() {
-        return { id: this.bot.identity ?? 'dsh', username: this.bot.username, connected: this.running, activeTurns: this.orchestrator.getActiveTurnsCount(), pendingApprovals: this.ui.pendingApprovals, defaultBackend: 'dsh' };
+        return { id: this.bot.identity ?? 'dsh', username: this.bot.username, connected: this.running, activeTurns: this.orchestrator.getActiveTurnsCount(), pendingApprovals: this.orchestrator.getPendingApprovals(), defaultBackend: 'dsh' };
     }
 }

package/dist/dsh/ui.d.ts

@@ -1,10 +1,10 @@
 import type { AppConfig } from '../config.js';
 import type { BridgeStore } from '../store/database.js';
 import type { Logger } from '../logger.js';
-import type { TelegramMessagingPort } from '../channels/telegram/telegram_messaging_port.js';
+import type { ChannelPort } from '../core/channel_port.js';
 import type { AppLocale } from '../types.js';
-import type { TelegramCallbackEvent } from '../telegram/gateway.js';
-import type { UnifiedChannelOrchestrator } from '../core/orchestrator.js';
+import type { ChannelCallbackEvent } from '../core/channel_events.js';
+import type { BackendUiHost } from '../core/backend_ui.js';
 import { DshEngineAdapter } from './adapter.js';
 /** DSH controls shared by the unified bot and the optional dedicated bot. */
 export declare class DshUi {
@@ -16,14 +16,14 @@ export declare class DshUi {
     private readonly approvals;
     readonly adapter: DshEngineAdapter;
     get pendingApprovals(): number;
-    constructor(config: AppConfig, store: BridgeStore, logger: Logger, messaging: TelegramMessagingPort);
+    constructor(config: AppConfig, store: BridgeStore, logger: Logger, messaging: ChannelPort);
     private defaultAccess;
     private copy;
     status(scopeId: string, locale: AppLocale): string;
     private button;
     private panel;
-    setup(scopeId: string, locale: AppLocale, orchestrator: UnifiedChannelOrchestrator, messageId?: number): Promise<void>;
-    models(scopeId: string, locale: AppLocale, orchestrator: UnifiedChannelOrchestrator, messageId?: number): Promise<void>;
+    setup(scopeId: string, locale: AppLocale, orchestrator: BackendUiHost, messageId?: number): Promise<void>;
+    models(scopeId: string, locale: AppLocale, orchestrator: BackendUiHost, messageId?: number): Promise<void>;
     private efforts;
     private selectModel;
     private selectEffort;
@@ -31,8 +31,8 @@ export declare class DshUi {
     private threads;
     private open;
     private plugins;
-    command(scopeId: string, command: string, args: string, locale: AppLocale, orchestrator: UnifiedChannelOrchestrator): Promise<boolean>;
-    callback(scopeId: string, data: string, locale: AppLocale, orchestrator: UnifiedChannelOrchestrator, event?: TelegramCallbackEvent): Promise<boolean>;
+    command(scopeId: string, command: string, args: string, locale: AppLocale, orchestrator: BackendUiHost): Promise<boolean>;
+    callback(scopeId: string, data: string, locale: AppLocale, orchestrator: BackendUiHost, event?: ChannelCallbackEvent): Promise<boolean>;
     private requestPermission;
     stop(): Promise<void>;
 }

package/dist/dsh/ui.js

@@ -251,7 +251,7 @@ export class DshUi {
     async callback(scopeId, data, locale, orchestrator, event) {
         const answer = (text = '') => this.messaging.answerCallback(event?.callbackQueryId ?? '', text);
         if (!data.startsWith('dsh:')) {
-            if (orchestrator.getBackendDescriptorForScope(scopeId).engineType === 'dsh' && data.startsWith('engine:') && !['engine:setup:main', 'engine:setup:active_mode', 'engine:setup:new', 'engine:setup:backend'].includes(data) && !data.startsWith('engine:backend:')) {
+            if (orchestrator.getBackendDescriptorForScope(scopeId).engineType === 'dsh' && data.startsWith('engine:') && !['engine:setup:main', 'engine:setup:models', 'engine:setup:active_mode', 'engine:setup:new', 'engine:setup:backend'].includes(data) && !data.startsWith('engine:backend:')) {
                 await answer(this.copy(locale, '请重新打开 DSH 设置', 'Open DSH settings again'));
                 return true;
             }

package/dist/main.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { RuntimeSupervisor } from './core/runtime_supervisor.js';
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -605,7 +606,7 @@ function truncateStatusLine(value, maxLength) {
     return normalized.length <= maxLength ? normalized : `${normalized.slice(0, Math.max(0, maxLength - 1))}…`;
 }
 async function runServeCli() {
-    const [{ BridgeMessagingRouter }, { TelegramMessagingPort }, { WeixinChannelAdapter }, { WeixinMessagingPort }, { attachIlinkRuntimeFromBridgeLogger }, { loadWeixinAccount }, { Logger }, { BridgeStore }, { TelegramGateway }, { CodexAppClient }, { BridgeSessionCore }, { TelegramChannelAdapter }, { AuthCandidateMirror }, { CrossNodeAuthSync }, { OpencodeTelegramRuntime }, { DshTelegramRuntime }, { UnifiedBridgeCore }, { AntigravityAppClient }, { AntigravityAuthManager, linkAntigravityAuthTokens },] = await Promise.all([
+    const [{ BridgeMessagingRouter }, { TelegramMessagingPort }, { WeixinChannelAdapter }, { WeixinMessagingPort }, { attachIlinkRuntimeFromBridgeLogger }, { loadWeixinAccount }, { Logger }, { BridgeStore }, { TelegramGateway }, { CodexAppClient }, { BridgeSessionCore }, { TelegramChannelAdapter }, { AuthCandidateMirror }, { CrossNodeAuthSync }, { OpencodeTelegramRuntime }, { DshTelegramRuntime }, { createDshBackend }, { UnifiedBridgeCore }, { AntigravityAppClient }, { AntigravityAuthManager, linkAntigravityAuthTokens },] = await Promise.all([
         import('./channels/bridge_messaging_router.js'),
         import('./channels/telegram/telegram_messaging_port.js'),
         import('./channels/weixin/weixin_channel_adapter.js'),
@@ -622,7 +623,8 @@ async function runServeCli() {
         import('./auth/cross_node_sync.js'),
         import('./opencode/runtime.js'),
         import('./dsh/runtime.js'),
-        import('./antigravity/controller.js'),
+        import('./dsh/backend.js'),
+        import('./bridge/unified_bridge.js'),
         import('./antigravity/client.js'),
         import('./antigravity/auth.js'),
     ]);
@@ -632,11 +634,13 @@ async function runServeCli() {
     const authNotificationAggregator = createAuthRefreshNotificationAggregator(logger);
     attachIlinkRuntimeFromBridgeLogger(logger, config.wxIlinkRouteTag);
     const processLock = acquireProcessLock(config.lockPath);
+    const supervisor = new RuntimeSupervisor();
+    supervisor.register('process-lock', { stop: () => processLock.release() });
     let store = null;
     let weixinAdapter = null;
     let activeWeixinCore = null;
-    let activeTelegramAdapters = [];
-    let managedApps = [];
+    const activeTelegramAdapters = [];
+    const managedApps = [];
     let activeAuthMirror = null;
     let activeAuthSync = null;
     let activeOpencodeRuntime = null;
@@ -646,6 +650,30 @@ async function runServeCli() {
     let sharedAntigravityAuth = null;
     try {
         store = new BridgeStore(config.storePath);
+        supervisor.register('store', { stop: () => store?.close() });
+        supervisor.register('native-apps', { stop: async () => {
+                const apps = new Set([...managedApps, ...(sharedCodexApp ? [sharedCodexApp] : [])]);
+                const results = await Promise.allSettled([...apps].map(app => app.stop({ terminateServer: true })));
+                for (const result of results)
+                    if (result.status === 'rejected')
+                        logger.warn('codex.app-server.stop_failed', { error: serializeError(result.reason) });
+            } });
+        supervisor.register('channels-and-sync', { stop: async () => {
+                const failures = [];
+                const cleanups = [() => authNotificationAggregator.flushAll(), () => activeAuthSync?.stop(), () => activeAuthMirror?.stop(),
+                    () => weixinAdapter?.stop(), () => activeWeixinCore?.stop({ keepTransports: true }),
+                    ...activeTelegramAdapters.map(adapter => () => adapter.stop()),
+                    () => activeOpencodeRuntime?.stop(), () => activeDshRuntime?.stop()];
+                for (const cleanup of cleanups)
+                    try {
+                        await cleanup();
+                    }
+                    catch (error) {
+                        failures.push(error);
+                    }
+                if (failures.length)
+                    throw new AggregateError(failures, 'Runtime cleanup failed');
+            } });
         if (config.dshBotToken) {
             activeDshRuntime = new DshTelegramRuntime(config, store, logger);
             await activeDshRuntime.start();
@@ -668,15 +696,15 @@ async function runServeCli() {
             };
             writeDshStatus();
             const timer = setInterval(writeDshStatus, 5000);
-            const shutdown = async () => {
+            let shutdownPromise = null;
+            const shutdown = () => shutdownPromise ??= (async () => {
                 clearInterval(timer);
-                await activeDshRuntime.stop();
-                await activeOpencodeRuntime?.stop();
                 writeDshStatus(false);
-                store.close();
-                processLock.release();
+                const failures = await supervisor.stop();
+                for (const failure of failures)
+                    logger.warn('bridge.shutdown_failed', { resource: failure.name, error: serializeError(failure.error) });
                 process.exit(0);
-            };
+            })();
             process.on('SIGINT', () => void shutdown());
             process.on('SIGTERM', () => void shutdown());
             return;
@@ -748,6 +776,7 @@ async function runServeCli() {
                     ...codexApiProviderOverrides,
                     ...(isCodexDefault ? [] : ['cli_auth_credentials_store="file"']),
                 ]);
+            managedApps.push(codexApp);
             // Antigravity environment
             const isAntigravityDefault = backend === 'antigravity' && isDefaultRuntimeForBackend;
             let antigravityHome;
@@ -819,9 +848,8 @@ async function runServeCli() {
                 restoreImportedAuthCandidateState(store, event.record.candidateName, authRuntimeIds);
             },
         });
-        await mirror.initialize();
         activeAuthMirror = mirror;
-        managedApps = seeds.map((runtime) => runtime.app);
+        await mirror.initialize();
         const lastSelfUpdatePath = path.join(APP_HOME, 'runtime', 'last-self-update.json');
         let lastSelfUpdate = readSelfUpdateStatus(lastSelfUpdatePath);
         const runtimes = [];
@@ -841,7 +869,7 @@ async function runServeCli() {
                 ...(first?.codexAppServer ? { codexAppServer: first.codexAppServer } : {}),
                 botUsername: first?.botUsername ?? null,
                 currentBindings: store.countBindings(),
-                pendingApprovals: store.countPendingApprovals() + statuses.reduce((sum, status) => sum + status.dshPendingApprovals, 0) + (activeDshRuntime?.getRuntimeStatus().pendingApprovals ?? 0),
+                pendingApprovals: store.countPendingApprovals() + statuses.reduce((sum, status) => sum + status.pendingApprovals, 0) + (activeDshRuntime?.getRuntimeStatus().pendingApprovals ?? 0),
                 pendingUserInputs: store.countPendingUserInputs(),
                 queuedTurns: store.countQueuedTurnInputs(),
                 activeTurns: statuses.reduce((sum, status) => sum + status.activeTurns, 0)
@@ -973,18 +1001,20 @@ async function runServeCli() {
                 antigravityApp: seed.antigravityApp,
                 antigravityAuth: seed.antigravityAuth,
                 defaultBackendId: seed.defaultBackend,
+                backends: seed.config.dsh ? [createDshBackend(seed.config, store, logger, telegramMessaging)] : [],
                 selfUpdater,
             });
-            runtimes.push({ ...seed, core, telegram: new TelegramChannelAdapter(core) });
+            const telegram = new TelegramChannelAdapter(core);
+            activeTelegramAdapters.push(telegram);
+            runtimes.push({ ...seed, core, telegram });
         }
         if (config.wxEnabled) {
             const weixinApp = new CodexAppClient(config.codexCliBin, config.codexAppLaunchCmd, config.codexAppAutolaunch, config.codexAppServerStatePath, config.codexAppServerLogPath, logger, null, codexApiProviderOverrides);
+            managedApps.push(weixinApp);
             const outbound = new BridgeMessagingRouter(new TelegramMessagingPort(seeds[0].bot), new WeixinMessagingPort(store, (id) => loadWeixinAccount(config.weixinAccountsDir, id)));
             activeWeixinCore = new BridgeSessionCore(config, store, logger, seeds[0].bot, weixinApp, outbound, selfUpdater, coordinator, false);
-            managedApps.push(weixinApp);
             weixinAdapter = new WeixinChannelAdapter(activeWeixinCore, store, config, logger);
         }
-        activeTelegramAdapters = runtimes.map((runtime) => runtime.telegram);
         if (config.authSyncEnabled) {
             const authSyncTransportBot = seeds[0];
             const authSyncTransportLabel = authSyncTransportBot.bot.username
@@ -1051,40 +1081,22 @@ async function runServeCli() {
         }
         writeAggregateStatus();
         logger.info('bridge.started', { bots: runtimes.map((runtime) => runtime.id) });
-        const shutdown = async (signal) => {
+        let shutdownPromise = null;
+        const shutdown = (signal) => shutdownPromise ??= (async () => {
             logger.info('bridge.shutting_down', { signal });
-            await authNotificationAggregator.flushAll();
-            authSync?.stop();
-            mirror.stop();
-            await weixinAdapter?.stop();
-            await activeWeixinCore?.stop();
-            await Promise.all(runtimes.map((runtime) => runtime.telegram.stop()));
-            await activeOpencodeRuntime?.stop();
-            await activeDshRuntime?.stop();
             writeAggregateStatus(false);
-            const allManaged = [...managedApps, ...(sharedCodexApp ? [sharedCodexApp] : [])];
-            await Promise.all(allManaged.map((app) => app.stop({ terminateServer: true }).catch((error) => {
-                logger.warn('codex.app-server.stop_failed', { error: serializeError(error) });
-            })));
-            store?.close();
-            processLock.release();
+            const failures = await supervisor.stop();
+            for (const failure of failures)
+                logger.warn('bridge.shutdown_failed', { resource: failure.name, error: serializeError(failure.error) });
             process.exit(0);
-        };
+        })();
         process.on('SIGINT', () => void shutdown('SIGINT'));
         process.on('SIGTERM', () => void shutdown('SIGTERM'));
     }
     catch (error) {
-        await authNotificationAggregator.flushAll().catch(() => { });
-        activeAuthSync?.stop();
-        activeAuthMirror?.stop();
-        await weixinAdapter?.stop().catch(() => { });
-        await activeWeixinCore?.stop().catch(() => { });
-        await Promise.allSettled(activeTelegramAdapters.map((adapter) => adapter.stop()));
-        await activeOpencodeRuntime?.stop().catch(() => { });
-        await activeDshRuntime?.stop().catch(() => { });
-        await Promise.allSettled(managedApps.map((app) => app.stop({ terminateServer: true })));
-        store?.close();
-        processLock.release();
+        const failures = await supervisor.stop();
+        for (const failure of failures)
+            logger.warn('bridge.shutdown_failed', { resource: failure.name, error: serializeError(failure.error) });
         throw error;
     }
 }