dsh-caduceus 0.12.1 → 0.12.3

package/dist/bridge/bridge.d.ts

@@ -35,4 +35,4 @@ export declare class Bridge {
     }>;
 }
 /** Build the process card for one snapshot (exported for render tests). */
-export declare function progressCardForSnapshot(snapshot: StatusSnapshot, sessionTitle: string | undefined, recentEvent: string, tail: string, now: number, presetMissing?: boolean, extraLines?: readonly string[], stopButton?: boolean): FeishuCard;
+export declare function progressCardForSnapshot(snapshot: StatusSnapshot, sessionTitle: string | undefined, recentEvent: string, tail: string, now: number, presetMissing?: boolean, extraLines?: readonly string[], stopButton?: boolean, stepLines?: readonly string[], stepNote?: string): FeishuCard;

package/dist/bridge/bridge.js

@@ -29,11 +29,12 @@ 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 { aggregateMetrics, formatMetricsLine, formatPerformanceLines } from '../metrics.js';
+import { DEFAULT_CARD_POLICY, foldsAtTurnEnd, formatStepLines, showsStepElapsed, stepLimit, stepLinesFromEvents, } from '../card-policy.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 { clipLabel, collapsedProcessCard, finalCard, finalCardPlainText, progressCard, } from '../render/cards.js';
 import { CardStream, systemClock } from '../render/stream.js';
 import { mintSessionId, scopeKey, SCOPE_KEY_SEPARATOR } from '../session-key.js';
 import { StatusTracker, shouldNotifyTerminal, stateForTurnEnd, recentEventText, statusLabel, statusTemplate, statusText, terminalNotice, } from '../status.js';
@@ -230,6 +231,7 @@ export class Bridge {
                 state.running = true;
                 state.stopRequested = false;
                 state.lastOutput = '';
+                state.replies = [];
                 state.progress?.dispose();
                 state.progress = this.#makeCardStream(state);
                 await this.#renderProgress(state);
@@ -262,8 +264,15 @@ export class Bridge {
             }
             case 'assistant/message': {
                 const text = assistantTextFromEvent(event.data);
-                if (text.length > 0)
+                if (text.length > 0) {
                     state.lastOutput = text;
+                    const trimmed = text.trim();
+                    if (trimmed.length > 0 && state.replies[state.replies.length - 1] !== trimmed) {
+                        state.replies.push(trimmed);
+                        if (state.replies.length > 3)
+                            state.replies.shift();
+                    }
+                }
                 await this.#renderProgress(state);
                 break;
             }
@@ -295,6 +304,16 @@ export class Bridge {
     }
     async #processInbound(message) {
         const state = this.#stateFor(message);
+        const pending = state.pendingCollapse;
+        if (pending !== undefined) {
+            state.pendingCollapse = undefined;
+            try {
+                await this.#transport.updateCard(pending.messageId, pending.card);
+            }
+            catch (error) {
+                this.#logger.warn(`deferred collapse failed: ${errorMessage(error)}`);
+            }
+        }
         state.lastInboundMessageId = message.messageId;
         state.ownerOpenId = message.senderOpenId;
         // Startup-stage failures have no session to notify yet; the first message
@@ -860,21 +879,30 @@ export class Bridge {
             state.progress = undefined;
         }
         const card = finalCard(finalInput);
+        // 过程卡按 dsh 的「工作步骤收起时机」处理：completion 立刻置灰收起；
+        // next-input 留到下一次输入再收，正文始终另发一张摘要卡。
+        const policy = this.#policy();
         if (messageId !== undefined) {
-            try {
-                await this.#transport.updateCard(messageId, card);
+            const collapsed = this.#collapsedCard(state, snapshot, kind);
+            if (foldsAtTurnEnd(policy)) {
+                try {
+                    if (process.env.CADUCEUS_DEBUG === '1')
+                        console.error('[dbg] collapse', messageId);
+                    await this.#transport.updateCard(messageId, collapsed);
+                }
+                catch (error) {
+                    this.#logger.warn(`collapse patch failed: ${errorMessage(error)}`);
+                }
             }
-            catch (error) {
-                await this.#finalFallback(state, finalInput, error);
+            else {
+                state.pendingCollapse = { messageId, card: collapsed };
             }
         }
-        else {
-            try {
-                await this.#sendNewCard(state, card);
-            }
-            catch (error) {
-                await this.#finalFallback(state, finalInput, error);
-            }
+        try {
+            await this.#sendNewCard(state, card);
+        }
+        catch (error) {
+            await this.#finalFallback(state, finalInput, error);
         }
         await this.#sendOutboundMedia(state, outbound.entries);
         if (shouldNotifyTerminal(kind)) {
@@ -944,7 +972,7 @@ export class Bridge {
     #finalCardInput(state, snapshot, body, finalState, finalStateLabel) {
         const sessionTitle = this.#titleOf(state)?.trim() ?? state.title;
         return {
-            title: '飞书会话 · 过程',
+            title: '飞书会话 · 回答',
             // Event-derived, never the (possibly stale) tracker snapshot.
             stateLabel: finalStateLabel,
             steps: snapshot.steps,
@@ -1714,6 +1742,7 @@ export class Bridge {
             running: false,
             status: new StatusTracker(),
             lastOutput: '',
+            replies: [],
             reactionQueue: [],
             reactionStarts: new Map(),
             logEvents: [],
@@ -1729,6 +1758,8 @@ export class Bridge {
                 return sent;
             },
             update: async (messageId, card) => {
+                if (process.env.CADUCEUS_DEBUG === '1')
+                    console.error('[dbg] stream.update', messageId, card.header?.title.content);
                 await this.#transport.updateCard(messageId, card);
             },
         };
@@ -1854,16 +1885,56 @@ export class Bridge {
             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);
+        // 性能与用量：dsh 的 ui-chat.performanceUsage 决定密度；caduceus 的
+        // `metrics: off` 仅作排障用的整体关闭开关。
+        const policy = this.#policy();
+        if (this.#config.metrics !== 'off') {
+            const metrics = await this.#metricsFor(state, snapshot);
+            for (const line of formatPerformanceLines(metrics, policy.performance)) {
+                extraLines.push(line);
+            }
         }
+        const steps = this.#stepLines(state, snapshot, policy);
         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);
+        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, steps.lines, steps.note);
+    }
+    /** Card policy from dsh's live settings; defaults only when unavailable. */
+    #policy() {
+        try {
+            return this.#options.cardPolicyProvider?.() ?? DEFAULT_CARD_POLICY;
+        }
+        catch {
+            return DEFAULT_CARD_POLICY;
+        }
+    }
+    /** Step rows for the current turn, limited by the transcript level. */
+    #stepLines(state, snapshot, policy) {
+        const all = stepLinesFromEvents(state.logEvents, Number.POSITIVE_INFINITY, {
+            turn: snapshot.turn,
+            elapsed: showsStepElapsed(policy.transcript),
+        });
+        const limit = stepLimit(policy.transcript);
+        const shown = Number.isFinite(limit) ? all.slice(Math.max(0, all.length - limit)) : all;
+        const lines = formatStepLines(shown);
+        const note = all.length > shown.length ? `共 ${all.length} 次调用，显示最近 ${shown.length} 条` : undefined;
+        return { lines, ...(note === undefined ? {} : { note }) };
+    }
+    /** Greyed, collapsed record of the finished turn's process card. */
+    #collapsedCard(state, snapshot, kind) {
+        const policy = this.#policy();
+        const steps = this.#stepLines(state, snapshot, policy);
+        const card = progressCardForSnapshot(snapshot, state.title, recentEventText(snapshot), '', this.#now(), state.sessionId !== undefined && this.#presetFailures.has(state.sessionId), [], false, steps.lines, steps.note);
+        const noteLines = [`已收起 · ${snapshot.steps} 步`];
+        if (kind !== undefined && kind !== 'completed')
+            noteLines[0] += ` · ${statusLabel(stateForTurnEnd(kind))}`;
+        if (policy.foldedReplies === 'all' && state.replies.length > 0) {
+            for (const [index, reply] of state.replies.slice(-3).entries()) {
+                noteLines.push(`过程回复 ${index + 1}：${clipLabel(reply.replace(/\s+/g, ' '), 60)}`);
+            }
+        }
+        return collapsedProcessCard(card, noteLines.join('\n'));
     }
     async #replyText(state, text) {
         if (text.length === 0)
@@ -1883,10 +1954,12 @@ export class Bridge {
     }
 }
 /** Build the process card for one snapshot (exported for render tests). */
-export function progressCardForSnapshot(snapshot, sessionTitle, recentEvent, tail, now, presetMissing = false, extraLines = [], stopButton = false) {
+export function progressCardForSnapshot(snapshot, sessionTitle, recentEvent, tail, now, presetMissing = false, extraLines = [], stopButton = false, stepLines = [], stepNote) {
     return progressCard({
         title: '飞书会话 · 过程',
         ...(extraLines.length === 0 ? {} : { extraLines }),
+        ...(stepLines.length === 0 ? {} : { stepLines }),
+        ...(stepNote === undefined || stepNote.length === 0 ? {} : { stepNote }),
         ...(stopButton ? { stopButton: true } : {}),
         stateLabel: statusLabel(snapshot.state),
         steps: snapshot.steps,

package/dist/bridge/types.d.ts

@@ -171,6 +171,12 @@ export interface BridgeOptions {
     readonly permissionPresetsProvider?: () => PermissionPresetsLike | undefined;
     /** Session log reader for `/usage` (`sessionQuery.readSession().events`). */
     readonly usageProvider?: (sessionId: string) => Promise<readonly unknown[] | undefined> | readonly unknown[] | undefined;
+    /**
+     * Card presentation level, read live from dsh's own settings
+     * (`ui-chat` / `ui-settings-general`). Resolved lazily per render so a
+     * settings change applies without a restart.
+     */
+    readonly cardPolicyProvider?: () => import('../card-policy.js').CardPolicy;
     /** Locale source (dsh settings/env); default zh. */
     readonly languageProvider?: () => import('../i18n.js').Lang;
     /** Lazily resolve dsh's approval service (agent-scoped setPolicy). */

package/dist/card-policy.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Card presentation policy — mirrors dsh's own Chat/General settings so the
+ * Feishu card shows the same amount of process detail as the Web UI instead of
+ * inventing a second set of knobs.
+ *
+ * Read live from the `settings` service (`describe()`), which returns the
+ * active profile's entry values:
+ *
+ * - `ui-chat.transcriptView`            工作步骤展示
+ * - `ui-chat.collapseTiming`            工作步骤收起时机
+ * - `ui-chat.foldedReplies`             收起后显示的回复
+ * - `ui-chat.performanceUsage`          性能与用量
+ * - `ui-settings-general.developerTools` 显示代码工作视图
+ *
+ * @module dsh-caduceus/card-policy
+ */
+/** Transcript detail levels accepted by dsh's Chat settings. */
+export declare const TRANSCRIPT_MODES: readonly ["compact", "standard", "detailed", "verbose"];
+export type TranscriptMode = (typeof TRANSCRIPT_MODES)[number];
+/** When the completed turn's process folds away. */
+export declare const COLLAPSE_TIMINGS: readonly ["completion", "next-input"];
+export type CollapseTiming = (typeof COLLAPSE_TIMINGS)[number];
+/** Which assistant replies stay visible once the process folds. */
+export declare const FOLDED_REPLIES: readonly ["all", "final"];
+export type FoldedReplies = (typeof FOLDED_REPLIES)[number];
+/** Performance/usage line density. */
+export declare const PERFORMANCE_MODES: readonly ["compact", "detailed"];
+export type PerformanceMode = (typeof PERFORMANCE_MODES)[number];
+/** Everything the card renderer needs to know about the user's detail level. */
+export interface CardPolicy {
+    readonly transcript: TranscriptMode;
+    readonly collapseTiming: CollapseTiming;
+    readonly foldedReplies: FoldedReplies;
+    readonly developerTools: boolean;
+    readonly performance: PerformanceMode;
+}
+/**
+ * dsh's shipped defaults. Used only when the settings service is unavailable
+ * (headless boot, older runtime) — never as a user-facing default override.
+ */
+export declare const DEFAULT_CARD_POLICY: CardPolicy;
+/** One `settings.describe()` entry, narrowed to what the policy reads. */
+export interface SettingsEntryLike {
+    readonly ns?: unknown;
+    readonly id?: unknown;
+    readonly value?: unknown;
+}
+/**
+ * Map live settings entries onto the card policy. Unknown or malformed values
+ * fall back to dsh's defaults per field, so one bad field never blanks the card.
+ */
+export declare function cardPolicyFromSettings(entries: readonly SettingsEntryLike[] | undefined): CardPolicy;
+/** How many step lines a transcript mode shows; `Infinity` = the whole turn. */
+export declare function stepLimit(mode: TranscriptMode): number;
+/** Per-step elapsed time is part of the `detailed` and `verbose` levels. */
+export declare function showsStepElapsed(mode: TranscriptMode): boolean;
+/** Tool invocation total belongs to `detailed` and up. */
+export declare function showsToolCount(mode: TranscriptMode): boolean;
+/** Fold the process card as soon as the turn ends (`next-input` defers it). */
+export declare function foldsAtTurnEnd(policy: CardPolicy): boolean;
+/** One rendered step line. */
+export interface StepLine {
+    readonly label: string;
+    readonly done: boolean;
+    readonly durationMs?: number;
+}
+/**
+ * Reduce the in-memory event window to step lines for the current turn.
+ *
+ * `tool/call` carries the name and `tool/result` carries the matching
+ * `message.source.callId`, so a call is `done` once its result arrives and the
+ * pair yields a duration. Only the last `limit` lines are returned; callers
+ * surface the total separately.
+ */
+export declare function stepLinesFromEvents(events: readonly unknown[], limit: number, options?: {
+    readonly turn?: number;
+    readonly elapsed?: boolean;
+}): StepLine[];
+/** Render step lines the way the card shows them: one tool per row. */
+export declare function formatStepLines(lines: readonly StepLine[]): string[];

package/dist/card-policy.js

@@ -0,0 +1,169 @@
+/**
+ * Card presentation policy — mirrors dsh's own Chat/General settings so the
+ * Feishu card shows the same amount of process detail as the Web UI instead of
+ * inventing a second set of knobs.
+ *
+ * Read live from the `settings` service (`describe()`), which returns the
+ * active profile's entry values:
+ *
+ * - `ui-chat.transcriptView`            工作步骤展示
+ * - `ui-chat.collapseTiming`            工作步骤收起时机
+ * - `ui-chat.foldedReplies`             收起后显示的回复
+ * - `ui-chat.performanceUsage`          性能与用量
+ * - `ui-settings-general.developerTools` 显示代码工作视图
+ *
+ * @module dsh-caduceus/card-policy
+ */
+/** Transcript detail levels accepted by dsh's Chat settings. */
+export const TRANSCRIPT_MODES = ['compact', 'standard', 'detailed', 'verbose'];
+/** When the completed turn's process folds away. */
+export const COLLAPSE_TIMINGS = ['completion', 'next-input'];
+/** Which assistant replies stay visible once the process folds. */
+export const FOLDED_REPLIES = ['all', 'final'];
+/** Performance/usage line density. */
+export const PERFORMANCE_MODES = ['compact', 'detailed'];
+/**
+ * dsh's shipped defaults. Used only when the settings service is unavailable
+ * (headless boot, older runtime) — never as a user-facing default override.
+ */
+export const DEFAULT_CARD_POLICY = {
+    transcript: 'compact',
+    collapseTiming: 'completion',
+    foldedReplies: 'final',
+    developerTools: false,
+    performance: 'compact',
+};
+function asRecord(value) {
+    return typeof value === 'object' && value !== null
+        ? value
+        : undefined;
+}
+function entryValue(entries, namespace) {
+    for (const entry of entries) {
+        const key = typeof entry.ns === 'string' ? entry.ns : entry.id;
+        if (key === namespace)
+            return asRecord(entry.value);
+    }
+    return undefined;
+}
+function pick(record, field, allowed, fallback) {
+    const raw = record?.[field];
+    return typeof raw === 'string' && allowed.includes(raw)
+        ? raw
+        : fallback;
+}
+/**
+ * Map live settings entries onto the card policy. Unknown or malformed values
+ * fall back to dsh's defaults per field, so one bad field never blanks the card.
+ */
+export function cardPolicyFromSettings(entries) {
+    if (entries === undefined)
+        return DEFAULT_CARD_POLICY;
+    const chat = entryValue(entries, 'ui-chat');
+    const general = entryValue(entries, 'ui-settings-general');
+    const developerTools = general?.['developerTools'];
+    return {
+        transcript: pick(chat, 'transcriptView', TRANSCRIPT_MODES, DEFAULT_CARD_POLICY.transcript),
+        collapseTiming: pick(chat, 'collapseTiming', COLLAPSE_TIMINGS, DEFAULT_CARD_POLICY.collapseTiming),
+        foldedReplies: pick(chat, 'foldedReplies', FOLDED_REPLIES, DEFAULT_CARD_POLICY.foldedReplies),
+        developerTools: typeof developerTools === 'boolean' ? developerTools : DEFAULT_CARD_POLICY.developerTools,
+        performance: pick(chat, 'performanceUsage', PERFORMANCE_MODES, DEFAULT_CARD_POLICY.performance),
+    };
+}
+/** How many step lines a transcript mode shows; `Infinity` = the whole turn. */
+export function stepLimit(mode) {
+    switch (mode) {
+        case 'compact':
+            return 1;
+        case 'standard':
+            return 3;
+        case 'detailed':
+            return 5;
+        case 'verbose':
+            return Number.POSITIVE_INFINITY;
+    }
+}
+/** Per-step elapsed time is part of the `detailed` and `verbose` levels. */
+export function showsStepElapsed(mode) {
+    return mode === 'detailed' || mode === 'verbose';
+}
+/** Tool invocation total belongs to `detailed` and up. */
+export function showsToolCount(mode) {
+    return mode !== 'compact';
+}
+/** Fold the process card as soon as the turn ends (`next-input` defers it). */
+export function foldsAtTurnEnd(policy) {
+    return policy.collapseTiming === 'completion';
+}
+function seconds(ms) {
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+/**
+ * Reduce the in-memory event window to step lines for the current turn.
+ *
+ * `tool/call` carries the name and `tool/result` carries the matching
+ * `message.source.callId`, so a call is `done` once its result arrives and the
+ * pair yields a duration. Only the last `limit` lines are returned; callers
+ * surface the total separately.
+ */
+export function stepLinesFromEvents(events, limit, options = {}) {
+    const calls = new Map();
+    const order = [];
+    for (const raw of events) {
+        const event = asRecord(raw);
+        if (event === undefined)
+            continue;
+        const data = asRecord(event.data);
+        if (data === undefined)
+            continue;
+        if (options.turn !== undefined) {
+            const turn = data['turn'];
+            if (typeof turn === 'number' && turn !== options.turn)
+                continue;
+        }
+        const time = typeof event.time === 'number' ? event.time : undefined;
+        if (event.type === 'tool/call') {
+            const callId = typeof data['callId'] === 'string' ? data['callId'] : undefined;
+            const name = typeof data['name'] === 'string' ? data['name'] : '调用';
+            if (callId === undefined)
+                continue;
+            calls.set(callId, { label: name, at: time ?? 0, done: false });
+            order.push(callId);
+            continue;
+        }
+        if (event.type === 'tool/result') {
+            const message = asRecord(data['message']);
+            const source = asRecord(message?.['source']);
+            const callId = typeof source?.['callId'] === 'string' ? source['callId'] : undefined;
+            if (callId === undefined)
+                continue;
+            const entry = calls.get(callId);
+            if (entry === undefined)
+                continue;
+            entry.done = true;
+            if (time !== undefined && entry.at > 0)
+                entry.durationMs = Math.max(0, time - entry.at);
+        }
+    }
+    const lines = order
+        .map((callId) => calls.get(callId))
+        .filter((entry) => entry !== undefined)
+        .map((entry) => ({
+        label: entry.label,
+        done: entry.done,
+        ...(options.elapsed === true && entry.durationMs !== undefined
+            ? { durationMs: entry.durationMs }
+            : {}),
+    }));
+    if (!Number.isFinite(limit))
+        return lines;
+    return lines.slice(Math.max(0, lines.length - limit));
+}
+/** Render step lines the way the card shows them: one tool per row. */
+export function formatStepLines(lines) {
+    return lines.map((line) => {
+        const mark = line.done ? '✓' : '▸';
+        const duration = line.durationMs === undefined ? '' : ` · ${seconds(line.durationMs)}`;
+        return `${mark} ${line.label}${duration}`;
+    });
+}

package/dist/config.d.ts

@@ -92,7 +92,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     admins: z<string[], string[], "plain">;
     lang: z<"zh" | "en" | "auto", "zh" | "en" | "auto", "plain">;
     exportCacheMaxAgeHours: z<number, number, "plain">;
-    metrics: z<"off" | "compact" | "detailed", "off" | "compact" | "detailed", "plain">;
+    metrics: z<"compact" | "detailed" | "off", "compact" | "detailed" | "off", "plain">;
 }>>, Schemastery.ObjectT<NoInfer<{
     appId: z<string, string, "plain">;
     appSecret: z<string, string, "plain">;
@@ -124,7 +124,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     admins: z<string[], string[], "plain">;
     lang: z<"zh" | "en" | "auto", "zh" | "en" | "auto", "plain">;
     exportCacheMaxAgeHours: z<number, number, "plain">;
-    metrics: z<"off" | "compact" | "detailed", "off" | "compact" | "detailed", "plain">;
+    metrics: z<"compact" | "detailed" | "off", "compact" | "detailed" | "off", "plain">;
 }>>, "plain">;
 /** Default card patch throttle: half of Feishu's 5 QPS budget. */
 export declare const DEFAULT_CARD_THROTTLE_MS = 400;

package/dist/index.js

@@ -15,6 +15,7 @@ import { createRequire } from 'node:module';
 import { dirname, join } from 'node:path';
 import { backfillSessionOwnership, scanSessionDirs } from './backfill.js';
 import { Bridge } from './bridge/bridge.js';
+import { cardPolicyFromSettings } from './card-policy.js';
 import { runHarnessCommand } from './commands/harness.js';
 import { cleanupExportCache, parseSessionEvents } from './export.js';
 import { resolveLang } from './i18n.js';
@@ -54,6 +55,20 @@ function agentOptions(ctx) {
         return {};
     }
 }
+/** Read dsh's live Chat/General settings as a card policy (lazy each render). */
+function makeCardPolicy(ctx) {
+    const read = () => {
+        try {
+            const settings = ctx.get('settings');
+            const entries = settings?.describe?.();
+            return cardPolicyFromSettings(entries);
+        }
+        catch {
+            return cardPolicyFromSettings(undefined);
+        }
+    };
+    return read;
+}
 /** Adapt `ctx.get('agents')` to the bridge's structural seam. */
 function makeAgents(ctx) {
     const service = () => ctx.get('agents');
@@ -217,6 +232,8 @@ export function apply(ctx, config = {}) {
         sessionIdsProvider: () => scanSessionDirs().map((entry) => entry.sessionId),
         // Lazy per use: the preset registry can register AFTER this plugin mounts.
         agentPresetsProvider: () => ctx.get('agentPresets'),
+        // Card detail follows dsh's own Chat/General settings (live, no restart).
+        cardPolicyProvider: makeCardPolicy(ctx),
         selfCheck,
         interactive,
         rootCtx: ctx,

package/dist/metrics.d.ts

@@ -7,6 +7,7 @@
  *
  * @module dsh-caduceus/metrics
  */
+import type { PerformanceMode } from './card-policy.js';
 export type MetricsMode = 'off' | 'compact' | 'detailed';
 export interface Metrics {
     readonly rounds: number;
@@ -26,3 +27,9 @@ export declare function aggregateMetrics(events: readonly unknown[]): Metrics;
 export declare function formatTokenCount(value: number): string;
 /** One-line metrics summary; empty when mode is off or nothing to show. */
 export declare function formatMetricsLine(metrics: Metrics, mode: MetricsMode): string;
+/**
+ * Performance/usage block, laid out per the user's dsh `性能与用量` level:
+ * `compact` is one dense line, `detailed` splits rate from volume so neither
+ * line has to be read across a long `·` chain.
+ */
+export declare function formatPerformanceLines(metrics: Metrics, performance: PerformanceMode): string[];

package/dist/metrics.js

@@ -133,3 +133,36 @@ export function formatMetricsLine(metrics, mode) {
     }
     return parts.join(' · ');
 }
+/**
+ * Performance/usage block, laid out per the user's dsh `性能与用量` level:
+ * `compact` is one dense line, `detailed` splits rate from volume so neither
+ * line has to be read across a long `·` chain.
+ */
+export function formatPerformanceLines(metrics, performance) {
+    const rate = [];
+    if (metrics.tokensPerSecond !== undefined) {
+        rate.push(`${Math.round(metrics.tokensPerSecond)} tok/s`);
+    }
+    if (metrics.cacheHitPercent !== undefined)
+        rate.push(`缓存 ${metrics.cacheHitPercent}%`);
+    if (metrics.contextPercent !== undefined)
+        rate.push(`上下文 ${metrics.contextPercent}%`);
+    const volume = [];
+    if (metrics.rounds > 0)
+        volume.push(`${metrics.rounds} 轮`);
+    if (metrics.steps > 0)
+        volume.push(`${metrics.steps} 步`);
+    if (metrics.totalTokens > 0)
+        volume.push(`${formatTokenCount(metrics.totalTokens)} tok`);
+    if (performance === 'compact') {
+        // 简洁档：一行放完，但把速度、总量、缓存分开读得懂的顺序。
+        const merged = [...volume, ...rate];
+        return merged.length === 0 ? [] : [merged.join(' · ')];
+    }
+    const lines = [];
+    if (rate.length > 0)
+        lines.push(`性能：${rate.join(' · ')}`);
+    if (volume.length > 0)
+        lines.push(`用量：${volume.join(' · ')}`);
+    return lines;
+}

package/dist/render/cards.d.ts

@@ -36,24 +36,44 @@ export interface ProgressCardInput {
     /** Unix epoch ms when the turn started; used for the elapsed line. */
     readonly startedAt?: number;
     readonly now?: number;
-    /** Session title shown on the state line when known. */
+    /** Session title shown above the state line when known. */
     readonly sessionTitle?: string;
-    /** Latest tool/event label (clipped to 40 characters). */
+    /** Latest tool/event label (kept for callers that have no step log). */
     readonly recentEvent?: string;
     /** Assistant output tail shown while the turn runs (≤8 KB). */
     readonly tail?: string;
     /** Append `（preset 未挂载）` to the state line. */
     readonly presetMissing?: boolean;
+    /** 性能与用量 block, already density-adjusted for the user's level. */
+    readonly metricLines?: readonly string[];
+    /** Step log rows (one tool per row), already limited for the level. */
+    readonly stepLines?: readonly string[];
+    /** `共 N 次调用，显示最近 M 条` when the log was truncated. */
+    readonly stepNote?: string;
 }
 /** Clip by Unicode code point so a label never exceeds the budget. */
 export declare function clipLabel(text: string, maxChars?: number): string;
 /**
- * The single per-turn card: state line (title/state/steps/tools/elapsed) and a
- * one-line recent event. It deliberately carries NO assistant body — the final
- * message is the only place an answer is rendered, so a short answer can never
- * appear twice.
+ * The single per-turn card, laid out in stacked blocks so nothing is crammed
+ * onto one `·` chain:
+ *
+ *   会话标题
+ *   状态行（状态 + 已运行）
+ *   性能与用量（按档位一行或两行）
+ *   附加状态（压缩 / 协作 / 已请求停止）
+ *   ───
+ *   步骤流水（一行一个工具，按档位限量）
+ *   ───
+ *   正文尾部
+ *   [停止]
+ *   脚注
+ *
+ * It deliberately carries NO assistant body beyond the tail — the final card is
+ * the only place a complete answer is rendered.
  */
 export declare function progressCard(input: ProgressCardInput): FeishuCard;
+/** Turn the live process card into the greyed, collapsed record of the turn. */
+export declare function collapsedProcessCard(card: FeishuCard, note: string): FeishuCard;
 export interface FinalCardInput {
     readonly title: string;
     readonly stateLabel: string;

package/dist/render/cards.js

@@ -41,18 +41,30 @@ export function clipLabel(text, maxChars = 40) {
     return Array.from(text).slice(0, maxChars).join('');
 }
 /**
- * The single per-turn card: state line (title/state/steps/tools/elapsed) and a
- * one-line recent event. It deliberately carries NO assistant body — the final
- * message is the only place an answer is rendered, so a short answer can never
- * appear twice.
+ * The single per-turn card, laid out in stacked blocks so nothing is crammed
+ * onto one `·` chain:
+ *
+ *   会话标题
+ *   状态行（状态 + 已运行）
+ *   性能与用量（按档位一行或两行）
+ *   附加状态（压缩 / 协作 / 已请求停止）
+ *   ───
+ *   步骤流水（一行一个工具，按档位限量）
+ *   ───
+ *   正文尾部
+ *   [停止]
+ *   脚注
+ *
+ * It deliberately carries NO assistant body beyond the tail — the final card is
+ * the only place a complete answer is rendered.
  */
 export function progressCard(input) {
-    const stateLine = [];
+    const elements = [];
     const sessionTitle = input.sessionTitle?.trim();
     if (sessionTitle !== undefined && sessionTitle.length > 0) {
-        stateLine.push(`会话：${clipLabel(sessionTitle)}`);
+        elements.push(div(`会话：${clipLabel(sessionTitle)}`));
     }
-    stateLine.push(`**${input.stateLabel}**`, `步数 ${input.steps}`, `工具 ${input.tools}`);
+    const stateLine = [`**${input.stateLabel}**`];
     if (input.startedAt !== undefined) {
         const now = input.now ?? Date.now();
         const seconds = Math.max(0, Math.floor((now - input.startedAt) / 1000));
@@ -60,17 +72,34 @@ export function progressCard(input) {
     }
     if (input.presetMissing === true)
         stateLine.push('（preset 未挂载）');
-    const elements = [
-        div(stateLine.join(' · ')),
-        div(`最近：${clipLabel(input.recentEvent ?? '（无）')}`),
-    ];
+    elements.push(div(stateLine.join(' · ')));
+    for (const line of input.metricLines ?? []) {
+        if (line.trim().length > 0)
+            elements.push(div(line));
+    }
     for (const line of input.extraLines ?? []) {
         if (line.trim().length > 0)
             elements.push(div(line));
     }
+    const stepRows = (input.stepLines ?? []).filter((line) => line.trim().length > 0);
+    const rows = stepRows.length > 0
+        ? stepRows
+        : input.recentEvent === undefined
+            ? []
+            : [`最近：${clipLabel(input.recentEvent)}`];
+    if (rows.length > 0) {
+        elements.push({ tag: 'hr' });
+        for (const row of rows)
+            elements.push(div(row));
+        const note = input.stepNote?.trim();
+        if (note !== undefined && note.length > 0)
+            elements.push(div(`_${note}_`));
+    }
     const tail = input.tail === undefined ? '' : tailText(input.tail);
-    if (tail.trim().length > 0)
+    if (tail.trim().length > 0) {
+        elements.push({ tag: 'hr' });
         elements.push(div(tail));
+    }
     if (input.stopButton === true) {
         elements.push({
             tag: 'action',
@@ -84,9 +113,28 @@ export function progressCard(input) {
             ],
         });
     }
-    elements.push(div('_过程消息；收尾会把终稿更新到本卡。_'));
+    elements.push(div('_过程消息；结束后会置灰收起，正文另发。_'));
     return buildCard({ title: input.title, template: 'blue', elements });
 }
+/** Turn the live process card into the greyed, collapsed record of the turn. */
+export function collapsedProcessCard(card, note) {
+    // Drop the buttons and the running-time footnote: both would lie on a card
+    // that has already ended.
+    const elements = card.elements.filter((element) => element.tag !== 'action' &&
+        !element.text?.content?.startsWith('_过程消息'));
+    const text = note.trim();
+    if (text.length > 0)
+        elements.push(div(`_${text}_`));
+    const grey = {
+        config: card.config,
+        ...(card.header === undefined
+            ? {}
+            : { header: { ...card.header, template: 'grey' } }),
+        elements,
+    };
+    assertCardFits(grey);
+    return grey;
+}
 /** State-line parts shared by the card markdown and the text fallback. */
 function finalStateLine(input, markdown) {
     const parts = [];

package/lib/client.js

@@ -85,7 +85,7 @@ function openDrawer(props) {
 		fontSize: "18px"
 	});
 	const version = document.createElement("p");
-	version.textContent = `${t("panel.version")} 0.12.1`;
+	version.textContent = `${t("panel.version")} 0.12.3`;
 	const session = document.createElement("p");
 	session.textContent = `${t("drawer.session")}: ${props.sessionId ?? t("drawer.none")}`;
 	const loaded = document.createElement("p");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-caduceus",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "description": "Feishu/Lark surface plugin for DeepSeek Harness (dsh): one topic per session, SOUL persona sync, streaming process cards, /status and /doctor.",
   "type": "module",
   "main": "./dist/index.js",