@foxden-app/foxclaw 0.11.1 → 0.13.0

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';
@@ -349,7 +350,7 @@ async function runSendVoiceCli() {
         throw new Error('Telegram voice files must be 50MB or smaller.');
     }
     const inferredBotId = parsed.botId ?? inferTelegramBotId(process.env.CODEX_HOME) ?? inferTelegramBotId(config.codexHome);
-    const allTokens = [...config.codexBotTokens, ...config.antigravityBotTokens];
+    const allTokens = [...config.codexBotTokens, ...config.antigravityBotTokens, ...(config.dshBotToken ? [config.dshBotToken] : [])];
     const { botId, botToken } = resolveTelegramVoiceTarget(allTokens, inferredBotId);
     const { BridgeStore } = await import('./store/database.js');
     const store = new BridgeStore(config.storePath);
@@ -395,7 +396,7 @@ async function runSendMediaCli() {
     }
     const plan = planTelegramOutboundMedia(filePath);
     const inferredBotId = parsed.botId ?? inferTelegramBotId(process.env.CODEX_HOME) ?? inferTelegramBotId(config.codexHome);
-    const allTokens = [...config.codexBotTokens, ...config.antigravityBotTokens];
+    const allTokens = [...config.codexBotTokens, ...config.antigravityBotTokens, ...(config.dshBotToken ? [config.dshBotToken] : [])];
     const { botId, botToken } = resolveTelegramVoiceTarget(allTokens, inferredBotId);
     const { BridgeStore } = await import('./store/database.js');
     const store = new BridgeStore(config.storePath);
@@ -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 }, { 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'),
@@ -621,7 +622,9 @@ async function runServeCli() {
         import('./auth/mirror.js'),
         import('./auth/cross_node_sync.js'),
         import('./opencode/runtime.js'),
-        import('./antigravity/controller.js'),
+        import('./dsh/runtime.js'),
+        import('./dsh/backend.js'),
+        import('./bridge/unified_bridge.js'),
         import('./antigravity/client.js'),
         import('./antigravity/auth.js'),
     ]);
@@ -631,19 +634,81 @@ 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;
+    let activeDshRuntime = null;
     let sharedCodexApp = null;
     let sharedAntigravityApp = null;
     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();
+            logger.info('dsh.bridge.started', activeDshRuntime.getRuntimeStatus());
+        }
+        if (config.opencodeBotToken) {
+            activeOpencodeRuntime = new OpencodeTelegramRuntime(config, store, logger);
+            await activeOpencodeRuntime.start();
+            logger.info('opencode.bridge.started', activeOpencodeRuntime.getRuntimeStatus());
+        }
+        if (config.dshBotToken && config.codexBotTokens.length === 0 && config.antigravityBotTokens.length === 0) {
+            const writeDshStatus = (running = true) => {
+                const status = activeDshRuntime.getRuntimeStatus();
+                writeRuntimeStatus(config.statusPath, {
+                    running, connected: running && status.connected, userAgent: 'DSH ACP', botUsername: status.username,
+                    currentBindings: store.countBindings(), pendingApprovals: status.pendingApprovals, pendingUserInputs: 0, queuedTurns: store.countQueuedTurnInputs(),
+                    activeTurns: running ? status.activeTurns + (activeOpencodeRuntime?.getRuntimeStatus().activeTurns ?? 0) : 0, lastError: null, updatedAt: new Date().toISOString(),
+                    channels: { telegram: running, weixin: false }, bots: [{ ...status, connected: running && status.connected }, ...(activeOpencodeRuntime ? [{ id: 'opencode', username: activeOpencodeRuntime.getRuntimeStatus().botUsername, connected: running && activeOpencodeRuntime.getRuntimeStatus().connected, activeTurns: activeOpencodeRuntime.getRuntimeStatus().activeTurns }] : [])],
+                });
+            };
+            writeDshStatus();
+            const timer = setInterval(writeDshStatus, 5000);
+            let shutdownPromise = null;
+            const shutdown = () => shutdownPromise ??= (async () => {
+                clearInterval(timer);
+                writeDshStatus(false);
+                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;
+        }
         const selfUpdater = createSelfUpdateRuntime({
             entryPoint,
             nodePath: process.execPath,
@@ -658,12 +723,7 @@ async function runServeCli() {
         if (config.codexCliBin) {
             sharedCodexApp = new CodexAppClient(config.codexCliBin, config.codexAppLaunchCmd, config.codexAppAutolaunch, config.codexAppServerStatePath, config.codexAppServerLogPath, logger, config.codexHome ? { CODEX_HOME: config.codexHome } : null, codexApiProviderOverrides);
         }
-        if (config.opencodeBotToken) {
-            activeOpencodeRuntime = new OpencodeTelegramRuntime(config, store, logger);
-            await activeOpencodeRuntime.start();
-            logger.info('opencode.bridge.started', activeOpencodeRuntime.getRuntimeStatus());
-        }
-        const totalBots = config.codexBotTokens.length + config.antigravityBotTokens.length;
+        const totalBots = config.codexBotTokens.length + config.antigravityBotTokens.length + (config.dshBotToken ? 1 : 0);
         const namespacedScopes = totalBots > 1;
         const seeds = [];
         const canonicalAuthDir = config.codexAuthDir ?? config.codexHome ?? path.join(os.homedir(), '.codex');
@@ -716,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;
@@ -787,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 = [];
@@ -809,27 +869,27 @@ async function runServeCli() {
                 ...(first?.codexAppServer ? { codexAppServer: first.codexAppServer } : {}),
                 botUsername: first?.botUsername ?? null,
                 currentBindings: store.countBindings(),
-                pendingApprovals: store.countPendingApprovals(),
+                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)
-                    + (weixinStatus?.activeTurns ?? 0),
+                    + (weixinStatus?.activeTurns ?? 0) + (activeDshRuntime?.getRuntimeStatus().activeTurns ?? 0),
                 lastError: statuses.find((status) => status.lastError)?.lastError
                     ?? weixinStatus?.lastError
                     ?? null,
                 updatedAt: new Date().toISOString(),
                 channels: { telegram: running, weixin: running && config.wxEnabled },
-                bots: runtimes.map((runtime, index) => ({
-                    id: runtime.id,
-                    username: statuses[index]?.botUsername ?? runtime.bot.username,
-                    connected: running && Boolean(statuses[index]?.connected),
-                    activeTurns: running ? (statuses[index]?.activeTurns ?? 0) : 0,
-                    runtimeKind: runtime.sharedDefaultRuntime ? 'default' : 'isolated',
-                    defaultBackend: runtime.defaultBackend,
-                    codexHome: statuses[index]?.codexHome ?? runtime.home,
-                    antigravityHome: runtime.antigravityHome,
-                    ...(statuses[index]?.codexAppServer ? { codexAppServer: statuses[index].codexAppServer } : {}),
-                })),
+                bots: [...runtimes.map((runtime, index) => ({
+                        id: runtime.id,
+                        username: statuses[index]?.botUsername ?? runtime.bot.username,
+                        connected: running && Boolean(statuses[index]?.connected),
+                        activeTurns: running ? (statuses[index]?.activeTurns ?? 0) : 0,
+                        runtimeKind: runtime.sharedDefaultRuntime ? 'default' : 'isolated',
+                        defaultBackend: runtime.defaultBackend,
+                        codexHome: statuses[index]?.codexHome ?? runtime.home,
+                        antigravityHome: runtime.antigravityHome,
+                        ...(statuses[index]?.codexAppServer ? { codexAppServer: statuses[index].codexAppServer } : {}),
+                    })), ...(activeDshRuntime ? [activeDshRuntime.getRuntimeStatus()] : [])],
                 ...(weixinStatus ? {
                     weixinRuntime: {
                         connected: running && weixinStatus.connected,
@@ -844,6 +904,7 @@ async function runServeCli() {
             });
         };
         const authSyncLocalIdle = () => runtimes.every((runtime) => runtime.core.isIdleForServiceUpdate())
+            && (activeDshRuntime?.getRuntimeStatus().activeTurns ?? 0) === 0
             && (!activeWeixinCore || activeWeixinCore.isIdleForServiceUpdate())
             && mirror.isIdle();
         const clusterUpdateScheduler = createClusterUpdateScheduler({
@@ -896,19 +957,19 @@ async function runServeCli() {
             statusUpdated: () => writeAggregateStatus(),
             getServiceStatus: async () => ({
                 currentVersion: readPackageVersion(),
-                bots: await Promise.all(runtimes.map(async (runtime) => {
-                    const status = runtime.core.getRuntimeStatus();
-                    return {
-                        id: runtime.id,
-                        username: status.botUsername ?? runtime.bot.username,
-                        connected: status.connected,
-                        activeTurns: status.activeTurns,
-                        runtimeKind: runtime.sharedDefaultRuntime ? 'default' : 'isolated',
-                        currentAuth: await runtime.core.getCurrentAuthLabel().catch(() => null),
-                        codexHome: status.codexHome ?? runtime.home,
-                        ...(status.codexAppServer ? { codexAppServer: status.codexAppServer } : {}),
-                    };
-                })),
+                bots: [...await Promise.all(runtimes.map(async (runtime) => {
+                        const status = runtime.core.getRuntimeStatus();
+                        return {
+                            id: runtime.id,
+                            username: status.botUsername ?? runtime.bot.username,
+                            connected: status.connected,
+                            activeTurns: status.activeTurns,
+                            runtimeKind: runtime.sharedDefaultRuntime ? 'default' : 'isolated',
+                            currentAuth: await runtime.core.getCurrentAuthLabel().catch(() => null),
+                            codexHome: status.codexHome ?? runtime.home,
+                            ...(status.codexAppServer ? { codexAppServer: status.codexAppServer } : {}),
+                        };
+                    })), ...(activeDshRuntime ? [activeDshRuntime.getRuntimeStatus()] : [])],
                 ...(activeWeixinCore ? {
                     weixinRuntime: {
                         connected: activeWeixinCore.getRuntimeStatus().connected,
@@ -940,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
@@ -1018,38 +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();
             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 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;
     }
 }
@@ -1537,10 +1584,23 @@ async function configureEnvInteractively(envPath, existed) {
         else {
             skipped.push('TG_ALLOWED_USER_ID');
         }
+        const dshToken = sanitizeEnvInput(await rl.question('DeepSeek Harness Telegram bot token (DSH_BOT_TOKEN) [optional]: '));
+        if (dshToken) {
+            updates.DSH_BOT_TOKEN = dshToken;
+            if (!codexTokens && !existed) {
+                updates.CODEX_BOT_TOKENS = '';
+                skipped.splice(skipped.indexOf('CODEX_BOT_TOKENS'), 1);
+            }
+            const dshSource = sanitizeEnvInput(await rl.question('DeepSeek Harness source directory (DSH_SOURCE_DIR) [Enter to use installed dsh]: '));
+            if (dshSource)
+                updates.DSH_SOURCE_DIR = normalizeUserPath(dshSource);
+            if (!/^\d+:[A-Za-z0-9_-]+$/.test(dshToken))
+                warnings.push('DSH_BOT_TOKEN does not look like a standard Telegram bot token.');
+        }
         const cwdDefault = defaultInitCwd();
         const cwdPrompt = cwdDefault
-            ? `Default Codex workspace (DEFAULT_CWD) [${cwdDefault}]: `
-            : 'Default Codex workspace (DEFAULT_CWD): ';
+            ? `Default workspace (DEFAULT_CWD) [${cwdDefault}]: `
+            : 'Default workspace (DEFAULT_CWD): ';
         const cwdAnswer = sanitizeEnvInput(await rl.question(cwdPrompt));
         const cwd = cwdAnswer ? normalizeUserPath(cwdAnswer) : cwdDefault;
         if (cwd) {
@@ -1741,12 +1801,24 @@ function runDoctorChecks() {
         ...(process.env.ANTIGRAVITY_BOT_TOKENS ?? '').split(','),
         process.env.ANTIGRAVITY_BOT_TOKEN ?? '',
     ].map((value) => value.trim()).filter(Boolean);
+    const dshToken = process.env.DSH_BOT_TOKEN?.trim();
+    const dshFlag = process.env.DSH_ENABLED;
+    const dshEnabled = dshFlag ? dshFlag !== 'false' && dshFlag !== '0' : Boolean(dshToken || process.env.DSH_SOURCE_DIR?.trim() || process.env.DSH_CLI_BIN?.trim());
     const checks = [
         ['node >= 24', Number(process.versions.node.split('.')[0]) >= 24],
-        ['codex cli available', hasConfiguredCommand(configuredCodexBin, 'codex')],
-        ['telegram bot token(s) configured', codexTokens.length > 0 || antigravityTokens.length > 0],
+        ['telegram bot token(s) configured', codexTokens.length > 0 || antigravityTokens.length > 0 || Boolean(dshToken)],
         ['telegram allowed user configured', Boolean(process.env.TG_ALLOWED_USER_ID)],
     ];
+    if (codexTokens.length > 0 || process.env.WX_ENABLED === 'true' || process.env.WX_ENABLED === '1')
+        checks.push(['codex cli available', hasConfiguredCommand(configuredCodexBin, 'codex')]);
+    if (dshEnabled) {
+        const source = process.env.DSH_SOURCE_DIR?.trim();
+        checks.push(['DSH CLI available', source ? fs.existsSync(path.join(path.resolve(source), 'apps/cli/src/bin.ts')) : hasConfiguredCommand(process.env.DSH_CLI_BIN, 'dsh')]);
+        if (dshToken)
+            checks.push(['DSH uses an independent Telegram bot', ![...codexTokens, ...antigravityTokens, process.env.OPENCODE_BOT_TOKEN?.trim()].includes(dshToken)]);
+    }
+    if (dshToken)
+        checks.push(['DSH backend enabled for its Telegram bot', dshEnabled]);
     if (process.env.OPENCODE_BOT_TOKEN?.trim()) {
         const configuredOpencodeBin = process.env.OPENCODE_CLI_BIN;
         checks.push(['opencode cli available', hasConfiguredCommand(configuredOpencodeBin, 'opencode')]);

package/dist/opencode/adapter.js

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
 import { formatSdkError } from './client.js';
-import { buildAttachmentPrompt } from '../telegram/media.js';
+import { buildAttachmentPrompt } from '../core/attachment_files.js';
 export class OpencodeEngineAdapter {
     client;
     defaultModel;
@@ -49,6 +49,8 @@ export class OpencodeEngineAdapter {
         }
         let finalResult = null;
         let turnError = null;
+        let accumulatedResponse = '';
+        let cleanup = () => { };
         const resultWaiters = [];
         const resolveWaiters = (res) => {
             while (resultWaiters.length > 0) {
@@ -68,8 +70,9 @@ export class OpencodeEngineAdapter {
                 }
                 if (cancelled)
                     return;
-                let accumulatedResponse = '';
                 const onEvent = (ev) => {
+                    if (cancelled)
+                        return;
                     if ('sessionId' in ev && ev.sessionId === sessionId) {
                         if (ev.kind === 'text') {
                             if (ev.delta) {
@@ -111,7 +114,7 @@ export class OpencodeEngineAdapter {
                         }
                     }
                 };
-                const cleanup = () => {
+                cleanup = () => {
                     this.client.off('event', onEvent);
                 };
                 this.client.on('event', onEvent);
@@ -138,19 +141,35 @@ export class OpencodeEngineAdapter {
                 }
             }
             catch (err) {
+                cleanup();
                 turnError = err instanceof Error ? err : new Error(String(err));
                 emitter.emit('error', turnError);
                 resolveWaiters(null);
             }
         };
-        void run();
+        const running = run();
+        let cancelling;
         return {
-            turnId: sessionId ?? undefined,
+            get turnId() { return sessionId ?? undefined; },
             cancel: () => {
-                cancelled = true;
-                if (sessionId) {
-                    void this.client.getClient().session.abort({ sessionID: sessionId }).catch(() => { });
-                }
+                if (finalResult)
+                    return Promise.resolve();
+                cancelling ??= (async () => {
+                    cancelled = true;
+                    await running;
+                    if (finalResult)
+                        return;
+                    if (sessionId) {
+                        const result = await this.client.getClient().session.abort({ sessionID: sessionId });
+                        if (result.error)
+                            throw new Error(formatSdkError(result.error));
+                    }
+                    cleanup();
+                    finalResult = { kind: 'result', status: 'INTERRUPTED', response: accumulatedResponse, conversationId: sessionId };
+                    emitter.emit('result', finalResult);
+                    resolveWaiters(finalResult);
+                })();
+                return cancelling.catch(error => { cancelling = undefined; throw error; });
             },
             waitForResult: async () => {
                 if (finalResult)

package/dist/opencode/controller.js

@@ -91,7 +91,7 @@ export class OpencodeBridgeCore {
     async stop() {
         if (!this.started)
             return;
-        this.bot.stop();
+        await this.bot.stop();
         for (const turn of this.activeTurns.values())
             this.clearTurnTimers(turn);
         for (const watch of this.watchers.values()) {

package/dist/store/channel_inbox.d.ts

@@ -0,0 +1,14 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { ChannelInbound } from '../core/channel_events.js';
+export interface InboxEntry {
+    id: string;
+    inbound: ChannelInbound;
+}
+/** Durable intake precedes business classification and acknowledgement to the transport. */
+export declare class ChannelInbox {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    accept(id: string, inbound: ChannelInbound): boolean;
+    complete(id: string): void;
+    pending(): InboxEntry[];
+}

package/dist/store/channel_inbox.js

@@ -0,0 +1,21 @@
+/** Durable intake precedes business classification and acknowledgement to the transport. */
+export class ChannelInbox {
+    db;
+    constructor(db) {
+        this.db = db;
+        db.exec(`CREATE TABLE IF NOT EXISTS channel_inbox (
+      receipt_id TEXT PRIMARY KEY, scope_id TEXT NOT NULL, payload TEXT,
+      completed_at INTEGER, created_at INTEGER NOT NULL);
+      CREATE INDEX IF NOT EXISTS channel_inbox_pending ON channel_inbox(completed_at, created_at);`);
+        db.prepare('DELETE FROM channel_inbox WHERE completed_at < ?').run(Date.now() - 90 * 86400_000);
+    }
+    accept(id, inbound) {
+        this.db.prepare('INSERT OR IGNORE INTO channel_inbox VALUES (?, ?, ?, NULL, ?)').run(id, inbound.event.scopeId, JSON.stringify(inbound), Date.now());
+        return this.db.prepare('SELECT completed_at FROM channel_inbox WHERE receipt_id = ?').get(id)?.completed_at === null;
+    }
+    complete(id) { this.db.prepare('UPDATE channel_inbox SET payload = NULL, completed_at = ? WHERE receipt_id = ?').run(Date.now(), id); }
+    pending() {
+        return this.db.prepare('SELECT receipt_id, payload FROM channel_inbox WHERE completed_at IS NULL ORDER BY created_at, receipt_id').all()
+            .map(row => ({ id: String(row.receipt_id), inbound: JSON.parse(String(row.payload)) }));
+    }
+}

package/dist/store/database.d.ts

@@ -1,4 +1,6 @@
-import type { AccessPresetValue, ActiveTurnMessageMode, AppLocale, CachedThread, ChatSessionSettings, CollaborationModeValue, GuidedPlanSessionRecord, GuidedPlanSessionState, PendingAttachmentBatchRecord, PendingAttachmentBatchStatus, PendingApprovalRecord, QueuedTurnInputRecord, QueuedTurnInputStatus, ReasoningEffortValue, ThreadBinding } from '../types.js';
+import { ChannelInbox } from './channel_inbox.js';
+import { TaskJournal } from './task_journal.js';
+import type { AccessPresetValue, ActiveTurnMessageMode, AppLocale, CachedThread, ChatSessionSettings, CollaborationModeValue, GuidedPlanSessionRecord, GuidedPlanSessionState, PendingAttachmentBatchRecord, PendingAttachmentBatchStatus, PendingApprovalRecord, QueuedTurnInputRecord, QueuedTurnInputStatus, ThreadBinding } from '../types.js';
 import type { CumulativeTokenTotals, CumulativeTokenUsageRecord, TokenUsageDelta } from './token_usage.js';
 export interface ActiveTurnPreviewRecord {
     turnId: string;
@@ -50,6 +52,8 @@ export interface CodexAuthPoolStats {
 export type CodexAuthCandidateState = 'active' | 'needs_repair';
 export declare class BridgeStore {
     private db;
+    readonly taskJournal: TaskJournal;
+    readonly channelInbox: ChannelInbox;
     constructor(dbPath: string);
     getTelegramOffset(botKey: string): number;
     setTelegramOffset(botKey: string, updateId: number): void;
@@ -71,9 +75,11 @@ export declare class BridgeStore {
         threadId: string;
     }>;
     getChatSettings(chatId: string): ChatSessionSettings | null;
-    setChatSettings(chatId: string, model: string | null, reasoningEffort: ReasoningEffortValue | null, locale?: AppLocale | null): void;
+    setChatSettings(chatId: string, model: string | null, reasoningEffort: string | null, locale?: AppLocale | null): void;
     setChatModel(chatId: string, model: string | null): void;
-    setChatEffort(chatId: string, effort: ReasoningEffortValue | null): void;
+    setChatEffort(chatId: string, effort: string | null): void;
+    /** Persist an adapter-advertised reasoning id without imposing Codex's vocabulary. */
+    setChatEngineEffort(chatId: string, effort: string | null): void;
     setChatLocale(chatId: string, locale: AppLocale): void;
     setChatAccessPreset(chatId: string, accessPreset: AccessPresetValue | null): void;
     setChatCollaborationMode(chatId: string, collaborationMode: CollaborationModeValue | null): void;
@@ -140,7 +146,7 @@ export declare class BridgeStore {
     countQueuedTurnInputs(scopeId?: string): number;
     updateQueuedTurnInputStatus(queueId: string, status: QueuedTurnInputStatus, error?: string | null): void;
     cancelQueuedTurnInputs(scopeId: string): number;
-    requeueInterruptedQueuedTurnInputs(): number;
+    requeueInterruptedQueuedTurnInputs(scopeId?: string): number;
     savePendingAttachmentBatch(record: PendingAttachmentBatchRecord): void;
     getPendingAttachmentBatch(batchId: string): PendingAttachmentBatchRecord | null;
     findPendingAttachmentBatchByMediaGroup(scopeId: string, mediaGroupId: string): PendingAttachmentBatchRecord | null;

package/dist/store/database.js

@@ -1,12 +1,18 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import { DatabaseSync } from 'node:sqlite';
+import { ChannelInbox } from './channel_inbox.js';
+import { TaskJournal } from './task_journal.js';
 import { migrateLegacyBridgeScopeIds } from './migrate_bridge_scope.js';
 export class BridgeStore {
     db;
+    taskJournal;
+    channelInbox;
     constructor(dbPath) {
         fs.mkdirSync(path.dirname(dbPath), { recursive: true });
         this.db = new DatabaseSync(dbPath);
+        this.taskJournal = new TaskJournal(this.db);
+        this.channelInbox = new ChannelInbox(this.db);
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS telegram_offsets (
         bot_key TEXT PRIMARY KEY,
@@ -403,6 +409,10 @@ export class BridgeStore {
         const current = this.getChatSettings(chatId);
         this.setChatSettings(chatId, current?.model ?? null, effort);
     }
+    /** Persist an adapter-advertised reasoning id without imposing Codex's vocabulary. */
+    setChatEngineEffort(chatId, effort) {
+        this.setChatEffort(chatId, effort);
+    }
     setChatLocale(chatId, locale) {
         const current = this.getChatSettings(chatId);
         this.writeChatSettings(chatId, current?.model ?? null, current?.reasoningEffort ?? null, locale, current?.accessPreset ?? null, current?.collaborationMode ?? null, current?.serviceTier ?? null, current?.activeTurnMessageMode ?? null, current?.activeBackendId ?? null);
@@ -748,12 +758,12 @@ export class BridgeStore {
     `).run(Date.now(), Date.now(), scopeId);
         return Number(result.changes ?? 0);
     }
-    requeueInterruptedQueuedTurnInputs() {
+    requeueInterruptedQueuedTurnInputs(scopeId) {
         const result = this.db.prepare(`
       UPDATE queued_turn_inputs
       SET status = 'queued', error = NULL, updated_at = ?, resolved_at = NULL
-      WHERE status = 'processing'
-    `).run(Date.now());
+      WHERE status = 'processing'${scopeId ? ' AND scope_id = ?' : ''}
+    `).run(Date.now(), ...(scopeId ? [scopeId] : []));
         return Number(result.changes ?? 0);
     }
     savePendingAttachmentBatch(record) {

package/dist/store/task_journal.d.ts

@@ -0,0 +1,32 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { ChannelTextEvent } from '../core/channel_events.js';
+import type { EngineTurnRequest, EngineTurnResult } from '../core/engine_spi.js';
+export type TaskState = 'accepted' | 'queued' | 'running' | 'awaiting_confirmation' | 'delivery_pending' | 'completed' | 'failed' | 'cancelled';
+export interface JournalTask {
+    id: string;
+    backendId: string;
+    state: TaskState;
+    event: ChannelTextEvent;
+    sourcePrompt: string;
+    request: EngineTurnRequest;
+    queueId: string | null;
+    previewMessageId: number;
+    result: EngineTurnResult | null;
+    delivery: string[];
+    deliveredChunks: number;
+    error: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+/** Original inputs, native outcome and delivery progress are distinct durable facts. */
+export declare class TaskJournal {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    atomic<T>(operation: () => T): T;
+    insert(task: JournalTask): void;
+    get(id: string): JournalTask | null;
+    listUnfinished(scopeId?: string): JournalTask[];
+    findReceipt(event: ChannelTextEvent, prompt: string): JournalTask | null;
+    forQueue(queueId: string): JournalTask | null;
+    update(id: string, state: TaskState, patch?: Partial<Omit<JournalTask, 'id' | 'backendId' | 'createdAt' | 'state'>>): JournalTask;
+}