dsh-caduceus 0.7.1 → 0.12.1

package/dist/bridge/bridge.js

@@ -18,7 +18,7 @@
  */
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { basename, join } from 'node:path';
 import { planSlashLine } from '../commands/dispatch.js';
 import { helpText, parseCommand } from '../commands/parse.js';
 import { evaluateGate, logGate } from '../gate.js';
@@ -26,7 +26,13 @@ import { silentLogger } from '../logger.js';
 import { formatScopeLine, sessionIdTimestamp, sessionTimeLabel, shortSessionId, } from '../observability.js';
 import { buildDoctorReport, renderDoctorJson, renderDoctorText, } from '../doctor.js';
 import { writeOwnership } from '../ownership.js';
+import { defaultExportCacheDir } from '../home.js';
 import { extractMediaMarkers, resolveMedia } from '../media.js';
+import { aggregateUsage, renderUsageReport } from '../usage.js';
+import { aggregateMetrics, formatMetricsLine } from '../metrics.js';
+import { presetLabel, t } from '../i18n.js';
+import { buildPermissionCard, renderPermissionText, } from '../render/permission-card.js';
+import { readSessionLogFile, renderExportJsonl, renderExportMarkdown, truncateExport, writeExportFile, } from '../export.js';
 import { finalCard, finalCardPlainText, progressCard, } from '../render/cards.js';
 import { CardStream, systemClock } from '../render/stream.js';
 import { mintSessionId, scopeKey, SCOPE_KEY_SEPARATOR } from '../session-key.js';
@@ -94,6 +100,11 @@ export class Bridge {
     #queue = new ScopeQueue();
     #states = new Map();
     #chatIdBySession = new Map();
+    #permissionCards = new Map();
+    #stopCards = new Map();
+    #stopClicks = new Map();
+    #sessionMetrics = new Map();
+    #metricsFallbackWarned = new Set();
     #scopeBySession = new Map();
     constructor(options) {
         this.#options = options;
@@ -210,10 +221,14 @@ export class Bridge {
         const state = this.#states.get(key);
         if (state === undefined)
             return;
+        state.logEvents.push(event);
+        if (state.logEvents.length > 5000)
+            state.logEvents.shift();
         state.status.apply(event);
         switch (event.type) {
             case 'turn/start': {
                 state.running = true;
+                state.stopRequested = false;
                 state.lastOutput = '';
                 state.progress?.dispose();
                 state.progress = this.#makeCardStream(state);
@@ -266,6 +281,13 @@ export class Bridge {
                     await this.#renderProgress(state);
                 break;
             }
+            case 'compaction/start':
+            case 'compaction/end':
+            case 'team/member':
+            case 'team/task': {
+                await this.#renderProgress(state);
+                break;
+            }
             default:
                 // Informational events only refresh the tracker.
                 break;
@@ -370,10 +392,11 @@ export class Bridge {
                 const anomaly = fails.length > 0 && failAt !== undefined
                     ? `\n最近异常：${fails.join(',')} @ ${sessionTimeLabel(failAt, this.#now())}`
                     : '';
+                const permissionLine = this.#permissionLineFor(state);
                 await this.#replyText(state, `${selfLine === undefined ? '' : `${selfLine}\n`}${statusText(state.status.get(), {
                     ...(title === undefined ? {} : { title }),
                     ...(state.sessionId === undefined ? {} : { sessionId: state.sessionId }),
-                })}${anomaly}`);
+                })}${permissionLine === undefined ? '' : `\n${permissionLine}`}${anomaly}`);
                 return;
             }
             case 'stop': {
@@ -429,6 +452,18 @@ export class Bridge {
                 await this.#replyText(state, result.text);
                 return;
             }
+            case 'export': {
+                await this.#exportSession(state, command.json === true);
+                return;
+            }
+            case 'permission': {
+                await this.#handlePermission(state, command.preset);
+                return;
+            }
+            case 'usage-report': {
+                await this.#handleUsage(state);
+                return;
+            }
             case 'whoami': {
                 const openId = state.ownerOpenId ?? '';
                 const identity = this.#isAdmin(openId) ? '管理员' : '访客';
@@ -601,6 +636,207 @@ export class Bridge {
                 return;
         }
     }
+    /** `/permission`: Chinese overview; switches still go through dsh's command. */
+    /** Permission-card button callback: run the same dsh switch, then patch the card. */
+    async handlePermissionCardAction(action, name) {
+        const meta = this.#permissionCards.get(action.messageId);
+        if (meta === undefined)
+            return;
+        const state = this.#states.get(meta.key);
+        if (state === undefined)
+            return;
+        if (meta.ownerOpenId !== undefined && action.operatorOpenId !== meta.ownerOpenId) {
+            this.#logger.warn(`permission card ignored for non-owner ${action.operatorOpenId}`);
+            return;
+        }
+        const service = this.#options.permissionPresetsProvider?.();
+        const sessionId = state.sessionId;
+        if (service === undefined || sessionId === undefined)
+            return;
+        if (!service.names.includes(name)) {
+            await this.#replyText(state, t(this.#lang()).unknownPreset(name, service.names.join(', ')));
+            return;
+        }
+        const agent = this.#agents.get(sessionId);
+        if (agent === undefined)
+            return;
+        const result = await this.#options.runHarnessCommand?.(agent, `/permission ${name}`);
+        if (result === undefined) {
+            await this.#replyText(state, '切换失败：dsh 命令未返回结果。');
+            return;
+        }
+        const view = this.#permissionViewFor(state);
+        if (view !== undefined) {
+            try {
+                await this.#transport.updateCard(action.messageId, buildPermissionCard(view));
+            }
+            catch (error) {
+                this.#logger.warn(`permission card patch failed: ${errorMessage(error)}`);
+            }
+        }
+        await this.#replyText(state, translatePermissionOutput(result.text, name, this.#lang()));
+    }
+    /** `/usage`: aggregate durable assistant/message usage from the session log. */
+    async #handleUsage(state) {
+        const sessionId = state.sessionId ?? this.#sessionMap.get(state.key);
+        if (sessionId === undefined) {
+            await this.#replyText(state, '读不到会话日志（当前没有会话）');
+            return;
+        }
+        const provider = this.#options.usageProvider;
+        if (provider === undefined) {
+            await this.#replyText(state, '读不到会话日志（sessionQuery 服务不可用）');
+            return;
+        }
+        let events;
+        try {
+            events = await provider(sessionId);
+        }
+        catch (error) {
+            await this.#replyText(state, `读不到会话日志（${errorMessage(error)}）`);
+            return;
+        }
+        if (events === undefined) {
+            await this.#replyText(state, '读不到会话日志（sessionQuery 服务不可用）');
+            return;
+        }
+        const metricsLine = formatMetricsLine(aggregateMetrics(events), this.#config.metrics ?? 'compact');
+        await this.#replyText(state, renderUsageReport(aggregateUsage(events)) +
+            (metricsLine.length === 0 ? '' : `\n${metricsLine}`));
+    }
+    #lang() {
+        return this.#options.languageProvider?.() ?? 'zh';
+    }
+    #permissionViewFor(state) {
+        const service = this.#options.permissionPresetsProvider?.();
+        const sessionId = state.sessionId;
+        if (service === undefined || sessionId === undefined)
+            return undefined;
+        const agent = this.#agents.get(sessionId);
+        if (agent === undefined)
+            return undefined;
+        const current = service.current(agent.session);
+        const presets = service.names.map((name) => {
+            try {
+                const spec = service.resolve?.(name);
+                return {
+                    name,
+                    resolved: spec !== undefined,
+                    ...(spec?.sandbox === undefined ? {} : { sandbox: String(spec.sandbox) }),
+                    ...(spec?.approval === undefined ? {} : { approval: String(spec.approval) }),
+                };
+            }
+            catch {
+                return { name, resolved: false };
+            }
+        });
+        return { lang: this.#lang(), current, presets };
+    }
+    #permissionLineFor(state) {
+        const view = this.#permissionViewFor(state);
+        if (view === undefined)
+            return undefined;
+        const current = view.presets.find((preset) => preset.name === view.current);
+        const approval = current?.approval ?? '?';
+        return t(view.lang).approvalLine(view.current, t(view.lang).approvalLabel(approval));
+    }
+    async #handlePermission(state, preset) {
+        const resolved = await this.#tryResolve(state);
+        if (resolved === undefined) {
+            await this.#replyText(state, '当前没有可用会话。');
+            return;
+        }
+        const service = this.#options.permissionPresetsProvider?.();
+        if (service === undefined) {
+            // No service to validate/translate against: keep dsh's original output,
+            // explicitly labelled so the user knows it is the upstream text.
+            const raw = await this.#runDshCommandLine(resolved.agent, preset === undefined ? '/permission' : `/permission ${preset}`);
+            await this.#replyText(state, `（dsh 原文）\n${raw}`);
+            return;
+        }
+        if (preset === undefined) {
+            const view = this.#permissionViewFor(state);
+            if (view === undefined) {
+                const raw = await this.#runDshCommandLine(resolved.agent, '/permission');
+                await this.#replyText(state, `（dsh 原文）\n${raw}`);
+                return;
+            }
+            const card = buildPermissionCard(view);
+            try {
+                const sent = await this.#sendNewCard(state, card);
+                this.#permissionCards.set(sent.messageId, {
+                    key: state.key,
+                    ...(state.ownerOpenId === undefined ? {} : { ownerOpenId: state.ownerOpenId }),
+                });
+            }
+            catch {
+                await this.#replyText(state, renderPermissionText(view));
+            }
+            return;
+        }
+        if (!service.names.includes(preset)) {
+            await this.#replyText(state, `未知档位 ${preset}，可用：${service.names.join(', ')}`);
+            return;
+        }
+        const result = await this.#options.runHarnessCommand?.(resolved.agent, `/permission ${preset}`);
+        if (result === undefined) {
+            await this.#replyText(state, service === undefined
+                ? '（dsh 原文）\n权限服务不可用，dsh 命令未返回结果。'
+                : '切换失败：dsh 命令未返回结果。');
+            return;
+        }
+        await this.#replyText(state, translatePermissionOutput(result.text, preset, this.#lang()));
+    }
+    async #runDshCommandLine(agent, line) {
+        const result = await this.#options.runHarnessCommand?.(agent, line);
+        return result === undefined
+            ? '权限服务不可用，dsh 命令未返回结果。'
+            : result.text;
+    }
+    /** `/export`: write a local markdown/JSONL file and hand it to the MEDIA chain. */
+    async #exportSession(state, json) {
+        const sessionId = state.sessionId ?? this.#sessionMap.get(state.key);
+        if (sessionId === undefined) {
+            await this.#replyText(state, '当前没有可导出的会话。');
+            return;
+        }
+        let data;
+        try {
+            data = await this.#options.exportProvider?.(sessionId);
+            if (data === undefined)
+                data = readSessionLogFile(sessionId);
+        }
+        catch (error) {
+            await this.#replyText(state, `导出失败：${errorMessage(error)}`);
+            return;
+        }
+        if (data === undefined || (data.messages.length === 0 && data.rawJsonl === undefined)) {
+            await this.#replyText(state, '本会话没有可导出的日志。');
+            return;
+        }
+        const extension = json ? 'jsonl' : 'md';
+        const content = json
+            ? truncateExport(data.rawJsonl ?? renderExportJsonl(data.messages))
+            : renderExportMarkdown({
+                sessionId,
+                ...(state.title === undefined ? {} : { title: state.title }),
+                now: this.#now(),
+                messages: data.messages,
+            });
+        let path;
+        try {
+            path = writeExportFile(defaultExportCacheDir(), this.#scopeKind(state), sessionId, extension, content, this.#now());
+        }
+        catch (error) {
+            await this.#replyText(state, `导出失败：写入文件失败（${errorMessage(error)}）。`);
+            return;
+        }
+        const label = json ? 'JSONL' : 'markdown';
+        await this.#replyText(state, `MEDIA:${path}\n已导出会话 ${sessionId.slice(0, 8)}（${data.messages.length} 条消息，${label}）。`);
+        await this.#sendOutboundMedia(state, [
+            { path, name: basename(path), image: false },
+        ]);
+    }
     async #settleTurn(state, event) {
         state.running = false;
         const kind = turnEndReasonKind(event.data);
@@ -647,6 +883,8 @@ export class Bridge {
                 await this.#replyText(state, notice);
         }
         await this.#finishReactions(state, kind);
+        await this.#refreshSessionMetrics(state);
+        state.stopRequested = false;
         state.lastOutput = '';
     }
     /** Extract MEDIA markers, validate paths, and annotate the final card body. */
@@ -699,7 +937,7 @@ export class Bridge {
                 }
             }
             catch (error) {
-                this.#logger.warn(`media send failed for ${entry.name}: ${errorMessage(error)}`);
+                this.#logger.warn(`media send failed for ${entry.name} (${entry.path}): ${errorMessage(error)}`);
             }
         }
     }
@@ -867,19 +1105,52 @@ export class Bridge {
             return undefined;
         }
     }
-    async #stop(state) {
+    async #cancelCurrentTurn(state) {
         const sessionId = state.sessionId ?? this.#sessionMap.get(state.key);
-        if (sessionId === undefined) {
-            await this.#replyText(state, '本聊天/话题还没有会话。');
+        if (sessionId === undefined)
+            return { ok: false, reason: '本聊天/话题还没有会话。' };
+        const agent = this.#agents.get(sessionId);
+        if (agent === undefined)
+            return { ok: false, reason: '当前没有在跑的会话。' };
+        try {
+            agent.cancel({ kind: 'user' });
+            return { ok: true };
+        }
+        catch (error) {
+            return { ok: false, reason: `取消失败：${errorMessage(error)}` };
+        }
+    }
+    async #stop(state) {
+        const result = await this.#cancelCurrentTurn(state);
+        if (!result.ok) {
+            await this.#replyText(state, result.reason);
             return;
         }
-        const agent = this.#agents.get(sessionId);
-        if (agent === undefined) {
-            await this.#replyText(state, '当前没有在跑的会话。');
+        await this.#replyText(state, '已停止当前回合。后台任务仍在运行，完成后结果会回来。');
+    }
+    /** Stop button callback: same cancel path as `/stop`, once per second. */
+    async handleStopCardAction(action) {
+        const key = this.#stopCards.get(action.messageId);
+        if (key === undefined)
+            return;
+        const state = this.#states.get(key);
+        if (state === undefined || !state.running)
+            return;
+        const now = this.#now();
+        const last = this.#stopClicks.get(action.messageId);
+        if (last !== undefined && now - last < 1000)
+            return;
+        this.#stopClicks.set(action.messageId, now);
+        const result = await this.#cancelCurrentTurn(state);
+        if (!result.ok) {
+            this.#logger.warn(`stop card failed: ${result.reason}`);
             return;
         }
-        agent.cancel({ kind: 'user' });
-        await this.#replyText(state, '已请求停止当前一轮（cancel kind=user）。');
+        state.stopRequested = true;
+        if (state.progress?.messageId === action.messageId) {
+            await this.#renderProgress(state);
+            await state.progress?.flush();
+        }
     }
     async #rename(state, title) {
         const service = this.#sessionTitleService();
@@ -1044,7 +1315,9 @@ export class Bridge {
      * agent. Missing service warns once; setPolicy errors never block the turn.
      */
     #applyApprovalPolicy(agent) {
-        const policy = this.#options.approvalPolicy ?? 'ask';
+        const policy = this.#options.approvalPolicy;
+        if (policy === undefined)
+            return; // never override dsh's own default
         this.#logger.info(`agent approval policy=${policy}`);
         const provider = this.#options.approvalProvider;
         if (provider === undefined)
@@ -1071,11 +1344,13 @@ export class Bridge {
         const state = this.#states.get(key);
         if (state === undefined || state.ownerOpenId === undefined)
             return undefined;
+        const permissionLine = this.#permissionLineFor(state);
         return {
             scopeKey: state.key,
             chatId: state.chatId,
             ownerOpenId: state.ownerOpenId,
             sessionId,
+            ...(permissionLine === undefined ? {} : { permissionLine }),
         };
     }
     /**
@@ -1345,6 +1620,10 @@ export class Bridge {
         }
     }
     #bindSession(state, sessionId) {
+        if (state.sessionId !== undefined && state.sessionId !== sessionId) {
+            this.#sessionMetrics.delete(state.key);
+            this.#metricsFallbackWarned.delete(state.key);
+        }
         for (const [id, key] of this.#scopeBySession) {
             if (key === state.key && id !== sessionId)
                 this.#scopeBySession.delete(id);
@@ -1437,13 +1716,18 @@ export class Bridge {
             lastOutput: '',
             reactionQueue: [],
             reactionStarts: new Map(),
+            logEvents: [],
         };
         this.#states.set(key, created);
         return created;
     }
     #makeCardStream(state) {
         const channel = {
-            create: (card) => this.#sendNewCard(state, card),
+            create: async (card) => {
+                const sent = await this.#sendNewCard(state, card);
+                this.#stopCards.set(sent.messageId, state.key);
+                return sent;
+            },
             update: async (messageId, card) => {
                 await this.#transport.updateCard(messageId, card);
             },
@@ -1467,10 +1751,119 @@ export class Bridge {
         if (stream === undefined)
             return;
         const snapshot = state.status.get();
-        await stream.set(this.#progressCardFor(state, snapshot));
+        await stream.set(await this.#progressCardFor(state, snapshot));
+    }
+    /** Full-session metrics for a card; cold cache reads the log once. */
+    async #metricsFor(state, snapshot) {
+        const sessionId = state.sessionId ?? this.#sessionMap.get(state.key);
+        if (sessionId === undefined)
+            return aggregateMetrics(state.logEvents);
+        let cached = this.#sessionMetrics.get(state.key);
+        if (cached === undefined || cached.sessionId !== sessionId) {
+            const provider = this.#options.usageProvider;
+            if (provider === undefined) {
+                if (!this.#metricsFallbackWarned.has(state.key)) {
+                    this.#metricsFallbackWarned.add(state.key);
+                    this.#logger.warn('metrics fallback: process buffer');
+                }
+                return aggregateMetrics(state.logEvents);
+            }
+            try {
+                const events = await provider(sessionId);
+                if (events !== undefined) {
+                    cached = {
+                        sessionId,
+                        metrics: aggregateMetrics(events),
+                        refreshedAtSeq: events.length,
+                        turn: snapshot.turn,
+                    };
+                    this.#sessionMetrics.set(state.key, cached);
+                }
+            }
+            catch {
+                // fall through to the process buffer
+            }
+            if (cached === undefined || cached.sessionId !== sessionId) {
+                if (!this.#metricsFallbackWarned.has(state.key)) {
+                    this.#metricsFallbackWarned.add(state.key);
+                    this.#logger.warn('metrics fallback: process buffer');
+                }
+                return aggregateMetrics(state.logEvents);
+            }
+        }
+        const base = cached.metrics;
+        // During a turn whose events are not in the cached snapshot yet, add the
+        // in-memory turn delta so numbers move monotonically until turn/end.
+        if (!state.running || snapshot.turn <= cached.turn)
+            return base;
+        const usage = snapshot.usageTurn;
+        const input = base.inputTokens + (usage?.input ?? 0);
+        const output = base.outputTokens + (usage?.output ?? 0);
+        const cacheRead = base.cacheReadTokens + (usage?.cacheRead ?? 0);
+        const denominator = input + cacheRead;
+        const elapsed = snapshot.startedAt === undefined ? undefined : this.#now() - snapshot.startedAt;
+        const tokensPerSecond = elapsed !== undefined && elapsed >= 1000 && (usage?.output ?? 0) > 0
+            ? (usage?.output ?? 0) / (elapsed / 1000)
+            : undefined;
+        return {
+            rounds: Math.max(base.rounds, snapshot.turn),
+            steps: base.steps + snapshot.steps,
+            totalTokens: base.totalTokens + (usage?.total ?? 0),
+            inputTokens: input,
+            outputTokens: output,
+            cacheReadTokens: cacheRead,
+            ...(tokensPerSecond === undefined ? {} : { tokensPerSecond }),
+            ...(denominator === 0 ? {} : { cacheHitPercent: Math.round((cacheRead / denominator) * 100) }),
+            ...(base.contextPercent === undefined ? {} : { contextPercent: base.contextPercent }),
+        };
+    }
+    /** Recompute the full-session metrics once after each turn/end. */
+    async #refreshSessionMetrics(state) {
+        const sessionId = state.sessionId ?? this.#sessionMap.get(state.key);
+        if (sessionId === undefined)
+            return;
+        const provider = this.#options.usageProvider;
+        if (provider === undefined)
+            return;
+        try {
+            const events = await provider(sessionId);
+            if (events === undefined)
+                return;
+            this.#sessionMetrics.set(state.key, {
+                sessionId,
+                metrics: aggregateMetrics(events),
+                refreshedAtSeq: events.length,
+                turn: state.status.get().turn,
+            });
+            this.#metricsFallbackWarned.delete(state.key);
+        }
+        catch (error) {
+            this.#logger.warn(`metrics refresh failed: ${errorMessage(error)}`);
+        }
     }
-    #progressCardFor(state, snapshot) {
-        return progressCardForSnapshot(snapshot, state.title, recentEventText(snapshot), state.lastOutput, this.#now(), state.sessionId !== undefined && this.#presetFailures.has(state.sessionId));
+    async #progressCardFor(state, snapshot) {
+        const extraLines = [];
+        if (snapshot.compaction === 'running')
+            extraLines.push('上下文压缩中…');
+        else if (snapshot.compaction === 'done') {
+            extraLines.push(snapshot.compactionKept === undefined
+                ? '已压缩'
+                : `已压缩 · 保留 ${snapshot.compactionKept} 条`);
+        }
+        else if (snapshot.compaction === 'failed')
+            extraLines.push('上下文压缩失败');
+        if (snapshot.teamLine !== undefined)
+            extraLines.push(snapshot.teamLine);
+        const metricsMode = this.#config.metrics ?? 'compact';
+        if (metricsMode !== 'off') {
+            const metricsLine = formatMetricsLine(await this.#metricsFor(state, snapshot), metricsMode);
+            if (metricsLine.length > 0)
+                extraLines.push(metricsLine);
+        }
+        if (state.stopRequested === true) {
+            extraLines.push('已停止当前回合。后台任务仍在运行，完成后结果会回来。');
+        }
+        return progressCardForSnapshot(snapshot, state.title, recentEventText(snapshot), state.lastOutput, this.#now(), state.sessionId !== undefined && this.#presetFailures.has(state.sessionId), extraLines, state.running && state.stopRequested !== true);
     }
     async #replyText(state, text) {
         if (text.length === 0)
@@ -1490,9 +1883,11 @@ export class Bridge {
     }
 }
 /** Build the process card for one snapshot (exported for render tests). */
-export function progressCardForSnapshot(snapshot, sessionTitle, recentEvent, tail, now, presetMissing = false) {
+export function progressCardForSnapshot(snapshot, sessionTitle, recentEvent, tail, now, presetMissing = false, extraLines = [], stopButton = false) {
     return progressCard({
         title: '飞书会话 · 过程',
+        ...(extraLines.length === 0 ? {} : { extraLines }),
+        ...(stopButton ? { stopButton: true } : {}),
         stateLabel: statusLabel(snapshot.state),
         steps: snapshot.steps,
         tools: snapshot.tools,
@@ -1515,3 +1910,16 @@ function imageMediaType(contentType) {
     }
     return 'image/jpeg';
 }
+function translatePermissionOutput(text, requested, lang) {
+    const dict = t(lang);
+    const success = /^preset\s+(\S+)\s*$/.exec(text.trim());
+    if (success !== null) {
+        const name = success[1];
+        return dict.switchSucceeded(presetLabel(lang, name), name);
+    }
+    const unknown = /^unknown preset "([^"]+)" \(available: ([^)]*)\)\s*$/.exec(text.trim());
+    if (unknown !== null) {
+        return dict.unknownPreset(unknown[1], unknown[2]);
+    }
+    return dict.switchedElsewhere(text);
+}

package/dist/bridge/types.d.ts

@@ -13,6 +13,7 @@ import type { HarnessCommandResult } from '../commands/harness.js';
 import type { LoggerLike } from '../logger.js';
 import type { Clock } from '../render/stream.js';
 import type { DoctorInputs, DoctorSessionInfo } from '../doctor.js';
+import type { SessionExportProvider } from '../export.js';
 import type { InteractiveRuntime } from '../interactive/runtime.js';
 import type { SessionStore } from '../session-key.js';
 import type { Transport } from '../transport/types.js';
@@ -20,6 +21,15 @@ import type { Transport } from '../transport/types.js';
 export type BusyMode = 'queue' | 'steer' | 'interrupt';
 /** Session approval policy understood by dsh's approval service. */
 export type ApprovalPolicy = 'ask' | 'never';
+/** The slice of dsh's permissionPresets service the bridge needs. */
+export interface PermissionPresetsLike {
+    readonly names: readonly string[];
+    current(session: unknown): string;
+    resolve?(name: string): {
+        readonly sandbox?: unknown;
+        readonly approval?: unknown;
+    };
+}
 /** The slice of dsh's attachment service the bridge needs. */
 export interface AttachmentStoreLike {
     admitPromptContent(content: readonly unknown[]): Promise<readonly unknown[]>;
@@ -120,6 +130,8 @@ export interface BridgeConfig {
     readonly maxSendImageBytes?: number;
     /** Allowed roots for outbound MEDIA paths; empty = session cwd. */
     readonly mediaRoots?: readonly string[];
+    /** Process-card/usage metrics mode (default compact). */
+    readonly metrics?: import('../metrics.js').MetricsMode;
     /** Admin allowlist; empty disables access control (default). */
     readonly admins?: readonly string[];
 }
@@ -153,9 +165,17 @@ export interface BridgeOptions {
     readonly rootCtx?: unknown;
     /** Lazily resolve dsh's attachment service (image admission / file refs). */
     readonly attachmentProvider?: () => AttachmentStoreLike | undefined;
+    /** Optional session-log provider; falls back to reading $DSH_HOME on disk. */
+    readonly exportProvider?: SessionExportProvider;
+    /** Lazily resolve dsh's permissionPresets service. */
+    readonly permissionPresetsProvider?: () => PermissionPresetsLike | undefined;
+    /** Session log reader for `/usage` (`sessionQuery.readSession().events`). */
+    readonly usageProvider?: (sessionId: string) => Promise<readonly unknown[] | undefined> | readonly unknown[] | undefined;
+    /** Locale source (dsh settings/env); default zh. */
+    readonly languageProvider?: () => import('../i18n.js').Lang;
     /** Lazily resolve dsh's approval service (agent-scoped setPolicy). */
     readonly approvalProvider?: () => ApprovalServiceLike | undefined;
-    /** Desired session approval policy (default `ask`). */
+    /** Explicit session approval policy; undefined leaves dsh untouched. */
     readonly approvalPolicy?: ApprovalPolicy;
     /** `/doctor` data collector (wired by the gateway; not available in tests by default). */
     readonly doctorInputs?: (session: DoctorSessionInfo) => DoctorInputs | Promise<DoctorInputs>;

package/dist/commands/dispatch.d.ts

@@ -4,8 +4,8 @@
  *
  * The surface owns eight commands; every other slash line is forwarded to the
  * harness command registry (`runHarnessCommand`), except Web-only commands that
- * make no sense on a chat surface. `/export` is the required minimum; the list
- * is intentionally small and explicit.
+ * make no sense on a chat surface. `/export` is now implemented by the surface
+ * itself, so the list is intentionally empty; keep the seam for future entries.
  *
  * @module dsh-caduceus/commands/dispatch
  */

package/dist/commands/dispatch.js

@@ -4,14 +4,14 @@
  *
  * The surface owns eight commands; every other slash line is forwarded to the
  * harness command registry (`runHarnessCommand`), except Web-only commands that
- * make no sense on a chat surface. `/export` is the required minimum; the list
- * is intentionally small and explicit.
+ * make no sense on a chat surface. `/export` is now implemented by the surface
+ * itself, so the list is intentionally empty; keep the seam for future entries.
  *
  * @module dsh-caduceus/commands/dispatch
  */
 import { parseCommand } from './parse.js';
 /** Commands that exist only in the Web UI and are refused on Feishu. */
-export const WEB_ONLY_DENYLIST = ['export'];
+export const WEB_ONLY_DENYLIST = [];
 /** True when a slash-command name must not be forwarded to the harness. */
 export function isWebOnlyCommand(name) {
     return WEB_ONLY_DENYLIST.includes(name.toLowerCase());