@foxden-app/foxclaw 0.11.0 → 0.12.0

package/dist/core/orchestrator.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { parseCommand } from '../controller/commands.js';
-import { getTelegramCommands, getAntigravityTelegramCommands } from '../i18n.js';
+import { getTelegramCommands, getAntigravityTelegramCommands, getDshTelegramCommands } from '../i18n.js';
 import { isDefaultTelegramScope, resolveTelegramAddressing } from '../telegram/addressing.js';
 import { chunkTelegramMessage } from '../telegram/text.js';
 import { stageInboundAttachments } from './attachments.js';
@@ -27,6 +27,8 @@ export class UnifiedChannelOrchestrator {
     defaultBackendId;
     activeTurns = new Map();
     stalePanelDeleteTimers = new Map();
+    recoveryTimers = new Set();
+    ownsScope;
     backendProvider;
     get adapter() {
         return this.getAdapterForBackend(this.defaultBackendId);
@@ -40,6 +42,7 @@ export class UnifiedChannelOrchestrator {
         this.queueManager = new TurnQueueManager();
         this.customUi = options.customUi;
         this.backendProvider = options.backendProvider;
+        this.ownsScope = options.ownsScope ?? (() => true);
         if (options.backends) {
             for (const b of options.backends) {
                 this.backends.set(b.id, b);
@@ -173,6 +176,9 @@ export class UnifiedChannelOrchestrator {
                 ? `未找到目标后端: ${targetBackendId}`
                 : `Target backend not found: ${targetBackendId}`);
         }
+        if (this.activeTurns.has(scopeId) && (targetDesc.engineType === 'dsh' || this.getBackendDescriptorForScope(scopeId).engineType === 'dsh')) {
+            throw new Error(locale === 'zh' ? '请先中断当前任务，再切换后端。' : 'Interrupt the active turn before switching backends.');
+        }
         if (targetDesc.onSelect) {
             await targetDesc.onSelect(scopeId);
         }
@@ -219,29 +225,28 @@ export class UnifiedChannelOrchestrator {
         }
         else {
             this.store.clearBinding(scopeId);
-            const defaultEffort = targetDesc.engineType === 'antigravity' ? 'high' : 'medium';
+            const defaultEffort = targetDesc.engineType === 'dsh' ? null : targetDesc.engineType === 'antigravity' ? 'high' : 'medium';
             this.store.setChatSettings(scopeId, null, defaultEffort);
             this.store.setChatServiceTier(scopeId, null);
         }
         const isCodex = targetDesc.engineType === 'codex';
         const activeSettings = this.store.getChatSettings(scopeId);
         const modelText = activeSettings?.model ? `\`${activeSettings.model}\`` : (locale === 'zh' ? '引擎默认' : 'default');
-        const effortText = activeSettings?.reasoningEffort ?? (isCodex ? 'medium' : 'high');
+        const effortText = activeSettings?.reasoningEffort ?? (targetDesc.engineType === 'dsh' ? 'default' : isCodex ? 'medium' : 'high');
         const modeText = activeSettings?.activeTurnMessageMode ?? 'queue';
         const switchMsg = locale === 'zh'
             ? `🔄 **已切换至后端: ${targetDesc.name}** (\`${targetDesc.id}\`)\n\n` +
-                `• **引擎类型**: ${isCodex ? 'OpenAI Codex (App Server)' : 'Google Antigravity (AGY)'}\n` +
-                `• **绑定账号**: \`${targetDesc.account || '默认账号'}\`${targetDesc.details ? ` (${targetDesc.details})` : ''}\n` +
+                `• **引擎类型**: ${targetDesc.name}\n` +
+                (targetDesc.account ? `• **绑定账号**: \`${targetDesc.account}\`\n` : '') +
                 `• **会话状态**: ${saved?.threadId ? `已恢复历史会话 (\`${saved.threadId.slice(0, 16)}…\`)\n• **工作目录**: \`${saved.cwd ?? this.config.defaultCwd}\`` : '新会话就绪 (发送消息将开启新会话)'}\n` +
                 `• **记忆配置**: 模型 ${modelText} | 思考深度 \`${effortText}\` | 插话模式 \`${modeText}\`\n` +
-                `• **专属指令**: \`/models\` (${isCodex ? 'Codex模型' : 'Gemini模型'}), \`/auth\` (${isCodex ? 'OpenAI账号池' : 'Google授权'}), \`/threads\` (${isCodex ? 'Codex历史' : 'AGY历史'})\n\n` +
-                `⚡ **当前 Telegram Bot 已完全切换为 ${isCodex ? 'OpenAI Codex' : 'Google Antigravity'} 交互人格与执行引擎！**`
+                `• **操作**: \`/setup\` · \`/models\` · \`/threads\``
             : `🔄 **Switched to Backend: ${targetDesc.name}** (\`${targetDesc.id}\`)\n\n` +
-                `• **Engine**: ${isCodex ? 'OpenAI Codex (App Server)' : 'Google Antigravity (AGY)'}\n` +
-                `• **Account**: \`${targetDesc.account || 'default'}\`${targetDesc.details ? ` (${targetDesc.details})` : ''}\n` +
+                `• **Engine**: ${targetDesc.name}\n` +
+                (targetDesc.account ? `• **Account**: \`${targetDesc.account}\`\n` : '') +
                 `• **Thread**: ${saved?.threadId ? `Restored (\`${saved.threadId.slice(0, 16)}…\`)\n• **Directory**: \`${saved.cwd ?? this.config.defaultCwd}\`` : 'Ready (next prompt starts new thread)'}\n` +
                 `• **Restored Settings**: Model ${modelText} | Effort \`${effortText}\` | Message Mode \`${modeText}\`\n\n` +
-                `⚡ **Telegram Bot is now fully operated by ${isCodex ? 'OpenAI Codex' : 'Google Antigravity'}!**`;
+                `• **Controls**: \`/setup\` · \`/models\` · \`/threads\``;
         try {
             await this.sendMessage(scopeId, switchMsg);
         }
@@ -251,7 +256,7 @@ export class UnifiedChannelOrchestrator {
         try {
             if (scopeId.startsWith(BRIDGE_SCOPE_TELEGRAM_PREFIX)) {
                 const target = parseTelegramTargetFromBridgeScope(scopeId);
-                const cmds = isCodex ? getTelegramCommands(locale) : getAntigravityTelegramCommands(locale);
+                const cmds = targetDesc.engineType === 'dsh' ? getDshTelegramCommands(locale) : isCodex ? getTelegramCommands(locale) : getAntigravityTelegramCommands(locale);
                 await this.bot.setChatCommands(target.chatId, cmds);
             }
         }
@@ -302,7 +307,8 @@ export class UnifiedChannelOrchestrator {
         });
         // Requeue any interrupted turns from previous crash/restart
         try {
-            const requeued = this.store.requeueInterruptedQueuedTurnInputs();
+            const scopes = new Set(this.store.listQueuedTurnInputs().filter(input => this.ownsScope(input.scopeId)).map(input => input.scopeId));
+            const requeued = [...scopes].reduce((count, scopeId) => count + this.store.requeueInterruptedQueuedTurnInputs(scopeId), 0);
             if (requeued > 0) {
                 this.logger.info('orchestrator.requeued_interrupted_turns', { count: requeued });
             }
@@ -317,6 +323,8 @@ export class UnifiedChannelOrchestrator {
                 backendIds.add(desc.adapter.id);
             }
             const activePreviews = this.store.listActiveTurnPreviews().filter((p) => {
+                if (!this.ownsScope(p.scopeId))
+                    return false;
                 for (const bId of backendIds) {
                     if (p.turnId.startsWith(`${bId}_`))
                         return true;
@@ -352,6 +360,7 @@ export class UnifiedChannelOrchestrator {
                     ? (locale === 'zh' ? 'FoxClaw 服务重启中断，请在当前会话中从中断处继续完成刚才的工作。' : 'FoxClaw restarted while previous turn was running. Please resume and complete the work from where it left off.')
                     : (locale === 'zh' ? '请继续完成上一步未完成的任务。' : 'Please continue and complete the unfinished task from previous step.');
                 const resumeTimer = setTimeout(() => {
+                    this.recoveryTimers.delete(resumeTimer);
                     this.startPromptTurn(fakeEvent, resumePrompt, locale, {
                         reuseMessageId: prev.messageId,
                         forcedThreadId: prev.threadId || undefined,
@@ -362,11 +371,14 @@ export class UnifiedChannelOrchestrator {
                         });
                     });
                 }, 1500);
+                this.recoveryTimers.add(resumeTimer);
                 resumeTimer?.unref?.();
             }
             // Check for queued turns on scopes without active previews
             const queuedInputs = this.store.listQueuedTurnInputs();
             for (const q of queuedInputs) {
+                if (!this.ownsScope(q.scopeId))
+                    continue;
                 if (!recoveredScopes.has(q.scopeId) && !this.activeTurns.has(q.scopeId)) {
                     recoveredScopes.add(q.scopeId);
                     const locale = this.store.getChatSettings(q.scopeId)?.locale || 'zh';
@@ -383,10 +395,12 @@ export class UnifiedChannelOrchestrator {
                         replyToBot: false,
                     };
                     const drainTimer = setTimeout(() => {
+                        this.recoveryTimers.delete(drainTimer);
                         this.drainNextQueuedTurn(fakeEvent, locale).catch((err) => {
                             this.logger.warn('orchestrator.auto_drain_failed', { scopeId: q.scopeId, error: String(err) });
                         });
                     }, 2000);
+                    this.recoveryTimers.add(drainTimer);
                     drainTimer?.unref?.();
                 }
             }
@@ -397,11 +411,18 @@ export class UnifiedChannelOrchestrator {
     }
     async stop() {
         this.bot.stop();
+        for (const timer of this.stalePanelDeleteTimers.values())
+            clearTimeout(timer);
+        this.stalePanelDeleteTimers.clear();
+        for (const timer of this.recoveryTimers)
+            clearTimeout(timer);
+        this.recoveryTimers.clear();
         for (const [scopeId, turn] of this.activeTurns.entries()) {
             if (turn.flushTimer)
                 clearTimeout(turn.flushTimer);
             if (turn.typingTimer)
                 clearInterval(turn.typingTimer);
+            turn.suppressQueueDrain = true;
             turn.execution.cancel();
             this.activeTurns.delete(scopeId);
         }
@@ -656,12 +677,12 @@ export class UnifiedChannelOrchestrator {
         let effectivePrompt = prompt;
         let stagedAttachments;
         if (event.attachments && event.attachments.length > 0) {
-            const nonDocJson = event.attachments.filter((a) => !(a.kind === 'document' && (a.fileName?.endsWith('.json') || a.mimeType?.includes('json'))));
+            const nonDocJson = this.getAdapterForScope(scopeId).id === 'dsh' ? event.attachments : event.attachments.filter((a) => !(a.kind === 'document' && (a.fileName?.endsWith('.json') || a.mimeType?.includes('json'))));
             if (nonDocJson.length > 0) {
                 const staged = await stageInboundAttachments(this.messaging, cwd, threadId, nonDocJson, this.logger);
                 if (staged.length > 0) {
                     stagedAttachments = staged;
-                    effectivePrompt = buildAttachmentPrompt(prompt, staged);
+                    effectivePrompt = this.getAdapterForScope(scopeId).id === 'dsh' ? prompt : buildAttachmentPrompt(prompt, staged);
                 }
             }
         }
@@ -671,7 +692,11 @@ export class UnifiedChannelOrchestrator {
             if (mode === 'steer') {
                 const active = this.activeTurns.get(scopeId);
                 if (active) {
+                    if (this.getAdapterForScope(scopeId).id === 'dsh')
+                        active.suppressQueueDrain = true;
                     active.execution.cancel();
+                    if (this.getAdapterForScope(scopeId).id === 'dsh')
+                        await active.execution.waitForResult();
                     if (active.typingTimer)
                         clearInterval(active.typingTimer);
                     if (active.flushTimer)
@@ -717,6 +742,8 @@ export class UnifiedChannelOrchestrator {
     }
     async drainNextQueuedTurn(event, locale) {
         const scopeId = event.scopeId;
+        if (this.activeTurns.has(scopeId))
+            return;
         try {
             const nextQueued = this.store.peekQueuedTurnInput(scopeId);
             if (!nextQueued)
@@ -753,7 +780,7 @@ export class UnifiedChannelOrchestrator {
         const threadId = options?.forcedThreadId ?? binding?.threadId ?? null;
         const model = settings?.model || 'default';
         const isBoost = settings?.serviceTier === 'boost';
-        const effort = isBoost ? 'high' : (settings?.reasoningEffort ?? 'high');
+        const effort = isBoost ? 'high' : (settings?.reasoningEffort ?? (adapter.id === 'dsh' ? null : 'high'));
         const effectivePrompt = isBoost && !prompt.startsWith('[Boost Mode:')
             ? `[Boost Mode: Proceed with deep thinking, strategic planning, multiple perspectives, and rigorous verification.]\n\n${prompt}`
             : prompt;
@@ -937,7 +964,8 @@ export class UnifiedChannelOrchestrator {
                     });
                     const chunks = combineSummaryAndResponse(foldedTools, finalText || '(无输出 / No output)');
                     await this.safeDeliverChunks(scopeId, activeTurn.messageId, chunks);
-                    await this.drainNextQueuedTurn(event, locale).catch(() => { });
+                    if (!activeTurn.suppressQueueDrain)
+                        await this.drainNextQueuedTurn(event, locale).catch(() => { });
                     return;
                 }
                 if (res.status === 'ERROR') {
@@ -1004,15 +1032,18 @@ export class UnifiedChannelOrchestrator {
                             : '';
                         const chunks = combineSummaryAndResponse(foldedTools, finalText + warningNote);
                         await this.safeDeliverChunks(scopeId, activeTurn.messageId, chunks);
-                        await this.drainNextQueuedTurn(event, locale).catch(() => { });
+                        if (!activeTurn.suppressQueueDrain)
+                            await this.drainNextQueuedTurn(event, locale).catch(() => { });
                         return;
                     }
                     await this.safeDeliverMessage(scopeId, activeTurn.messageId, `❌ **${adapter.name} 错误**:\n\`\`\`\n${errorText}\n\`\`\``);
-                    await this.drainNextQueuedTurn(event, locale).catch(() => { });
+                    if (!activeTurn.suppressQueueDrain)
+                        await this.drainNextQueuedTurn(event, locale).catch(() => { });
                     return;
                 }
                 await this.safeDeliverMessage(scopeId, activeTurn.messageId, activeTurn.accumulatedText || '⚠️ 执行结束');
-                await this.drainNextQueuedTurn(event, locale).catch(() => { });
+                if (!activeTurn.suppressQueueDrain)
+                    await this.drainNextQueuedTurn(event, locale).catch(() => { });
             }
             catch (fatalErr) {
                 this.logger.error('orchestrator.turn_result_unhandled', { error: String(fatalErr) });
@@ -1075,11 +1106,13 @@ export class UnifiedChannelOrchestrator {
                         `\n\n⚠️ <i>(注意：任务执行中途异常中断: ${escapeTelegramHtml(err.message.slice(0, 120))})</i>`;
                     const chunks = combineSummaryAndResponse(foldedTools, fullAnswer);
                     await this.safeDeliverChunks(scopeId, activeTurn.messageId, chunks);
-                    await this.drainNextQueuedTurn(event, locale).catch(() => { });
+                    if (!activeTurn.suppressQueueDrain)
+                        await this.drainNextQueuedTurn(event, locale).catch(() => { });
                     return;
                 }
                 await this.safeDeliverMessage(scopeId, activeTurn.messageId, `❌ **执行异常**:\n\`\`\`\n${err.message}\n\`\`\``);
-                await this.drainNextQueuedTurn(event, locale).catch(() => { });
+                if (!activeTurn.suppressQueueDrain)
+                    await this.drainNextQueuedTurn(event, locale).catch(() => { });
             }
             catch (fatalErr) {
                 this.logger.error('orchestrator.turn_error_unhandled', { error: String(fatalErr) });
@@ -1168,7 +1201,11 @@ export class UnifiedChannelOrchestrator {
         }
         const active = this.activeTurns.get(scopeId);
         if (active) {
+            if (this.getAdapterForScope(scopeId).id === 'dsh')
+                active.suppressQueueDrain = true;
             active.execution.cancel();
+            if (this.getAdapterForScope(scopeId).id === 'dsh')
+                await active.execution.waitForResult();
             if (active.typingTimer)
                 clearInterval(active.typingTimer);
             if (active.flushTimer)
@@ -1184,7 +1221,11 @@ export class UnifiedChannelOrchestrator {
         const active = this.activeTurns.get(scopeId);
         const queuedCount = this.store.countQueuedTurnInputs(scopeId);
         if (active) {
+            if (this.getAdapterForScope(scopeId).id === 'dsh')
+                active.suppressQueueDrain = true;
             active.execution.cancel();
+            if (this.getAdapterForScope(scopeId).id === 'dsh')
+                await active.execution.waitForResult();
             if (active.flushTimer)
                 clearTimeout(active.flushTimer);
             if (active.typingTimer)
@@ -1238,7 +1279,11 @@ export class UnifiedChannelOrchestrator {
         this.store.cancelQueuedTurnInputs(scopeId);
         const active = this.activeTurns.get(scopeId);
         if (active) {
+            if (this.getAdapterForScope(scopeId).id === 'dsh')
+                active.suppressQueueDrain = true;
             active.execution.cancel();
+            if (this.getAdapterForScope(scopeId).id === 'dsh')
+                await active.execution.waitForResult();
             if (active.typingTimer)
                 clearInterval(active.typingTimer);
             if (active.flushTimer)
@@ -1264,12 +1309,15 @@ export class UnifiedChannelOrchestrator {
         const tokenLine = formatTokenUsageSummary(totalUsage, locale);
         const allUsages = this.store.getAllBackendTokenUsages();
         const breakdown = formatBackendTokenUsageBreakdown(allUsages);
+        const usageText = backendDesc.engineType === 'dsh'
+            ? (locale === 'zh' ? '• **Token 消耗**: DSH ACP 未提供逐轮统计\n' : '• **Token usage**: Per-turn counts are not exposed by DSH ACP\n')
+            : `${tokenLine}${breakdown}\n`;
         const text = locale === 'zh'
             ? `📊 **${adapter.name} 运行状态**\n\n` +
                 `• **当前引擎**: \`${backendDesc.name}\` (\`${backendDesc.id}\`)${backendDesc.account ? ` · \`${backendDesc.account}\`` : ''}\n` +
                 `• **状态**: ${isBusy ? '⚡ 正在执行任务' : '💤 空闲'}\n` +
                 `• **当前模型**: \`${settings?.model || '默认'}\`\n` +
-                `${tokenLine}${breakdown}\n` +
+                usageText +
                 `• **绑定会话**: \`${binding?.threadId || '(新会话)'}\`\n` +
                 `• **工作目录**: \`${binding?.cwd || this.config.defaultCwd}\`` +
                 (customStatus ? `\n${customStatus}` : '')
@@ -1277,14 +1325,14 @@ export class UnifiedChannelOrchestrator {
                 `• **Engine**: \`${backendDesc.name}\` (\`${backendDesc.id}\`)${backendDesc.account ? ` · \`${backendDesc.account}\`` : ''}\n` +
                 `• **State**: ${isBusy ? '⚡ Executing' : '💤 Idle'}\n` +
                 `• **Model**: \`${settings?.model || 'default'}\`\n` +
-                `${tokenLine}${breakdown}\n` +
+                usageText +
                 `• **Thread**: \`${binding?.threadId || '(new)'}\`\n` +
                 `• **Directory**: \`${binding?.cwd || this.config.defaultCwd}\`` +
                 (customStatus ? `\n${customStatus}` : '');
         const keyboard = [
             [
                 { text: '⚙️ 控制面板', callback_data: 'engine:setup:main' },
-                { text: '🧠 切换模型', callback_data: 'engine:setup:models' },
+                { text: '🧠 切换模型', callback_data: backendDesc.engineType === 'dsh' ? 'dsh:models' : 'engine:setup:models' },
             ],
         ];
         const allBackends = await this.listBackends();
@@ -1297,6 +1345,8 @@ export class UnifiedChannelOrchestrator {
         this.scheduleStalePanelDeletion(scopeId, msgId);
     }
     async sendSetupMenu(scopeId, locale, editMessageId) {
+        if (await this.customUi?.renderSetupMenu?.(scopeId, locale, editMessageId))
+            return;
         const settings = this.store.getChatSettings(scopeId);
         const mode = settings?.activeTurnMessageMode ?? 'queue';
         const isBoost = settings?.serviceTier === 'boost';
@@ -1322,7 +1372,7 @@ export class UnifiedChannelOrchestrator {
                 `Select setting to configure:`;
         const keyboard = [];
         // 1. Model choices (Codex style)
-        const models = await adapter.listModels();
+        const models = await adapter.listModels(scopeId);
         const modelButtons = [
             {
                 text: `${!currentModel || currentModel === 'default' ? '• ' : ''}${locale === 'zh' ? '默认模型' : 'Default'}`,
@@ -1396,10 +1446,12 @@ export class UnifiedChannelOrchestrator {
         }
     }
     async sendModelsMenu(scopeId, locale, editMessageId) {
+        if (await this.customUi?.renderModelsMenu?.(scopeId, locale, editMessageId))
+            return;
         const settings = this.store.getChatSettings(scopeId);
         const currentModel = settings?.model;
         const adapter = this.getAdapterForScope(scopeId);
-        const models = await adapter.listModels();
+        const models = await adapter.listModels(scopeId);
         const keyboard = [];
         for (let i = 0; i < models.length; i += 2) {
             const row = [];

package/dist/dsh/adapter.d.ts

@@ -0,0 +1,48 @@
+import type { SessionConfigSelectOption } from '@agentclientprotocol/sdk';
+import type { IEngineAdapter, EngineModel, EngineTurnRequest, EngineTurnExecution } from '../core/engine_spi.js';
+import type { AccessPresetValue } from '../types.js';
+import { DshClient, type SessionConfigOption } from './client.js';
+export declare function optionChoices(option?: SessionConfigOption): SessionConfigSelectOption[];
+export declare function modelId(value: string): string;
+interface ScopePreferences {
+    cwd: string;
+    threadId: string | null;
+    model: string | null;
+    effort: string | null;
+    access: AccessPresetValue;
+}
+interface ScopeSession {
+    client: DshClient;
+    sessionId: string;
+    cwd: string;
+    defaultModel: string;
+    defaultEffort: string | null;
+}
+/** Persistent DSH sessions over the shipped ACP profile. */
+export declare class DshEngineAdapter implements IEngineAdapter {
+    private readonly options;
+    readonly id = "dsh";
+    readonly name = "DeepSeek Harness (DSH)";
+    private readonly clients;
+    private readonly sessions;
+    private readonly pending;
+    private readonly busy;
+    private closed;
+    constructor(options: {
+        createClient: (scopeId: string) => DshClient;
+        preferences: (scopeId: string) => ScopePreferences;
+        bind: (scopeId: string, sessionId: string, cwd: string) => void;
+    });
+    sessionForScope(scopeId: string): Promise<ScopeSession>;
+    private openSession;
+    listModels(scopeId?: string): Promise<EngineModel[]>;
+    selectModel(scopeId: string, id: string | null): Promise<void>;
+    listEfforts(scopeId: string): Promise<SessionConfigSelectOption[]>;
+    selectEffort(scopeId: string, effort: string | null): Promise<void>;
+    setAccess(scopeId: string, access: AccessPresetValue): Promise<void>;
+    listSessions(scopeId: string, cursor?: string): Promise<import("@agentclientprotocol/sdk").ListSessionsResponse>;
+    isBusy(scopeId: string): boolean;
+    executeTurn(request: EngineTurnRequest): EngineTurnExecution;
+    stop(): Promise<void>;
+}
+export {};

package/dist/dsh/adapter.js

@@ -0,0 +1,192 @@
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs/promises';
+import { buildAttachmentPrompt, isNativeImageAttachment } from '../telegram/media.js';
+export function optionChoices(option) {
+    if (option?.type !== 'select')
+        return [];
+    return option.options.flatMap(item => 'options' in item ? item.options : [item]);
+}
+export function modelId(value) {
+    const route = JSON.parse(value);
+    if (!Array.isArray(route) || route.length !== 2 || !route.every(part => typeof part === 'string' && part.length > 0))
+        throw new Error('Invalid DSH model route');
+    return `${route[0]}/${route[1]}`;
+}
+/** Persistent DSH sessions over the shipped ACP profile. */
+export class DshEngineAdapter {
+    options;
+    id = 'dsh';
+    name = 'DeepSeek Harness (DSH)';
+    clients = new Map();
+    sessions = new Map();
+    pending = new Map();
+    busy = new Set();
+    closed = false;
+    constructor(options) {
+        this.options = options;
+    }
+    async sessionForScope(scopeId) {
+        if (this.closed)
+            throw new Error('DSH backend is stopped');
+        const existing = this.pending.get(scopeId);
+        if (existing)
+            return existing;
+        const task = this.openSession(scopeId).finally(() => this.pending.delete(scopeId));
+        this.pending.set(scopeId, task);
+        return task;
+    }
+    async openSession(scopeId) {
+        const prefs = this.options.preferences(scopeId);
+        let client = this.clients.get(scopeId);
+        if (!client) {
+            client = this.options.createClient(scopeId);
+            this.clients.set(scopeId, client);
+        }
+        await client.setAccess(prefs.access);
+        const previous = this.sessions.get(scopeId);
+        if (client.connected && previous && previous.sessionId === prefs.threadId && previous.cwd === prefs.cwd)
+            return previous;
+        if (previous && this.busy.has(scopeId))
+            throw new Error('DSH session is busy');
+        if (previous && client.connected)
+            await client.closeSession(previous.sessionId);
+        const sessionId = await client.session(prefs.cwd, prefs.threadId);
+        const config = client.configOptions(sessionId);
+        const model = config.find(item => item.id === 'model');
+        const effort = config.find(item => item.id === 'reasoning_effort');
+        const state = { client, sessionId, cwd: prefs.cwd, defaultModel: String(model?.currentValue ?? ''), defaultEffort: effort?.type === 'select' ? effort.currentValue : null };
+        this.sessions.set(scopeId, state);
+        this.options.bind(scopeId, sessionId, prefs.cwd);
+        return state;
+    }
+    async listModels(scopeId = 'dsh:catalog') {
+        const state = await this.sessionForScope(scopeId);
+        return optionChoices(state.client.configOptions(state.sessionId).find(option => option.id === 'model')).map(choice => ({ id: modelId(choice.value), name: choice.name, description: choice.description ?? undefined, isDefault: choice.value === state.defaultModel }));
+    }
+    async selectModel(scopeId, id) {
+        const state = await this.sessionForScope(scopeId);
+        const model = state.client.configOptions(state.sessionId).find(option => option.id === 'model');
+        const choice = optionChoices(model).find(choice => id === null ? choice.value === state.defaultModel : modelId(choice.value) === id);
+        if (!choice)
+            throw new Error(`DSH model unavailable: ${id}`);
+        await state.client.setConfig(state.sessionId, 'model', choice.value);
+        const effort = state.client.configOptions(state.sessionId).find(option => option.id === 'reasoning_effort');
+        state.defaultEffort = effort?.type === 'select' ? effort.currentValue : null;
+    }
+    async listEfforts(scopeId) {
+        const state = await this.sessionForScope(scopeId);
+        return optionChoices(state.client.configOptions(state.sessionId).find(option => option.id === 'reasoning_effort'));
+    }
+    async selectEffort(scopeId, effort) {
+        const state = await this.sessionForScope(scopeId);
+        const choices = await this.listEfforts(scopeId);
+        if (choices.length === 0 && effort === null)
+            return;
+        const value = effort ?? state.defaultEffort;
+        if (value === null || !choices.some(choice => choice.value === value))
+            throw new Error(`DSH reasoning effort unavailable: ${effort}`);
+        await state.client.setConfig(state.sessionId, 'reasoning_effort', value);
+    }
+    async setAccess(scopeId, access) {
+        const state = await this.sessionForScope(scopeId);
+        await state.client.setAccess(access);
+    }
+    async listSessions(scopeId, cursor) { return (await this.sessionForScope(scopeId)).client.listSessions(cursor); }
+    isBusy(scopeId) { return this.busy.has(scopeId); }
+    executeTurn(request) {
+        const emitter = new EventEmitter();
+        let cancelled = false;
+        let state;
+        let finished = false;
+        let ownsSlot = false;
+        let result = null;
+        let resolveResult;
+        const promise = new Promise(resolve => { resolveResult = resolve; });
+        let response = '';
+        let finalMessage = '';
+        let finalMessageId;
+        const tools = new Map();
+        const onUpdate = (notification) => {
+            if (notification.sessionId !== state?.sessionId)
+                return;
+            const update = notification.update;
+            if (update.sessionUpdate === 'agent_message_chunk' && update.content.type === 'text') {
+                if (update.messageId && update.messageId !== finalMessageId) {
+                    finalMessageId = update.messageId;
+                    finalMessage = '';
+                }
+                finalMessage += update.content.text;
+                response += update.content.text;
+                emitter.emit('delta', update.content.text);
+            }
+            else if (update.sessionUpdate === 'tool_call') {
+                tools.set(update.toolCallId, update.title);
+                emitter.emit('tool', { name: update.title, args: update.rawInput == null ? undefined : JSON.stringify(update.rawInput), status: 'running' });
+            }
+            else if (update.sessionUpdate === 'tool_call_update') {
+                emitter.emit('tool', { name: tools.get(update.toolCallId) ?? update.toolCallId, status: update.status === 'failed' ? 'failed' : update.status === 'completed' ? 'completed' : 'running' });
+            }
+        };
+        const run = async () => {
+            try {
+                if (this.busy.has(request.scopeId))
+                    throw new Error('DSH already has an active turn in this scope');
+                state = await this.sessionForScope(request.scopeId);
+                if (cancelled)
+                    return;
+                if (this.busy.has(request.scopeId))
+                    throw new Error('DSH already has an active turn in this scope');
+                this.busy.add(request.scopeId);
+                ownsSlot = true;
+                emitter.emit('conversation', state.sessionId);
+                await this.selectModel(request.scopeId, request.model === 'default' ? null : request.model);
+                await this.selectEffort(request.scopeId, request.effort ?? null);
+                if (cancelled)
+                    return;
+                const attachments = request.stagedAttachments ?? [];
+                const images = state.client.imageSupported ? attachments.filter(isNativeImageAttachment) : [];
+                const files = attachments.filter(attachment => !images.includes(attachment));
+                const content = [{ type: 'text', text: files.length ? buildAttachmentPrompt(request.prompt, files) : request.prompt }];
+                for (const attachment of images)
+                    content.push({ type: 'image', data: (await fs.readFile(attachment.localPath)).toString('base64'), mimeType: attachment.mimeType || 'image/jpeg' });
+                state.client.on('update', onUpdate);
+                if (cancelled)
+                    return;
+                const value = await state.client.agent.request('session/prompt', { sessionId: state.sessionId, prompt: content });
+                result = { kind: 'result', status: cancelled || value.stopReason === 'cancelled' ? 'INTERRUPTED' : 'SUCCESS', response: finalMessage || response, conversationId: state.sessionId };
+            }
+            catch (error) {
+                result = { kind: 'result', status: cancelled ? 'INTERRUPTED' : 'ERROR', response: finalMessage || response, error: error instanceof Error ? error.message : String(error), conversationId: state?.sessionId ?? request.threadId };
+            }
+            finally {
+                state?.client.off('update', onUpdate);
+                if (ownsSlot)
+                    this.busy.delete(request.scopeId);
+                result ??= { kind: 'result', status: 'INTERRUPTED', response: finalMessage || response, conversationId: state?.sessionId ?? request.threadId };
+                finished = true;
+                resolveResult(result);
+                emitter.emit('result', result);
+            }
+        };
+        queueMicrotask(() => { void run(); });
+        return {
+            cancel: () => {
+                if (finished || cancelled)
+                    return;
+                cancelled = true;
+                state?.client.cancelPermissions?.();
+                if (state?.client.connected)
+                    void state.client.agent.notify('session/cancel', { sessionId: state.sessionId }).catch(() => { });
+            },
+            waitForResult: () => promise,
+            on: (event, listener) => { emitter.on(event, listener); },
+        };
+    }
+    async stop() {
+        this.closed = true;
+        await Promise.allSettled([...this.pending.values()]);
+        await Promise.all([...this.clients.values()].map(client => client.stop()));
+        this.clients.clear();
+        this.sessions.clear();
+    }
+}

package/dist/dsh/client.d.ts

@@ -0,0 +1,46 @@
+import { EventEmitter } from 'node:events';
+import { type SessionConfigOption, type SessionNotification, type RequestPermissionRequest, type RequestPermissionResponse } from '@agentclientprotocol/sdk';
+import type { Logger } from '../logger.js';
+import type { AccessPresetValue } from '../types.js';
+export interface DshClientOptions {
+    cliBin: string;
+    sourceDir?: string | null;
+    home?: string | null;
+    profile: string;
+    patches: string[];
+    runtimeDir: string;
+    startupTimeoutMs: number;
+}
+/** An owned ACP process; protocol stdout stays separate from diagnostics. */
+export declare class DshClient extends EventEmitter {
+    readonly options: DshClientOptions;
+    readonly scopeId: string;
+    private readonly logger;
+    private process;
+    private connection;
+    private starting;
+    private stopping;
+    private optionsBySession;
+    private capabilities;
+    private policyPath;
+    private policyWrite;
+    private stderr;
+    permissionHandler?: (request: RequestPermissionRequest, signal: AbortSignal) => Promise<RequestPermissionResponse>;
+    cancelPermissions?: () => void;
+    constructor(options: DshClientOptions, scopeId: string, logger: Logger);
+    setAccess(preset: AccessPresetValue): Promise<void>;
+    private writeAccess;
+    start(): Promise<void>;
+    private launch;
+    get connected(): boolean;
+    get imageSupported(): boolean;
+    get agent(): import("@agentclientprotocol/sdk").ClientContext;
+    session(cwd: string, sessionId?: string | null): Promise<string>;
+    configOptions(sessionId: string): SessionConfigOption[];
+    setConfig(sessionId: string, configId: string, value: string): Promise<void>;
+    listSessions(cursor?: string): Promise<import("@agentclientprotocol/sdk").ListSessionsResponse>;
+    closeSession(sessionId: string): Promise<void>;
+    stop(): Promise<void>;
+    private dispose;
+}
+export type { SessionConfigOption, SessionNotification, RequestPermissionRequest, RequestPermissionResponse };