@addozhang/dsh-discord 0.5.0-alpha.1 → 0.5.0-alpha.2

package/README.md

@@ -20,7 +20,7 @@ No extra process: the adapter is a DSH plugin that mounts straight onto your `ds
 
 - **Mention-driven sessions** — an authorized `@bot <task>` in a bound channel anchors a thread (your message becomes the first post), creates the DSH session, and submits the prompt at most once. Follow-ups inside the thread queue without a mention. Attached images ride along: they are downloaded from the Discord CDN within strict size/host bounds and submitted as image parts for multimodal models.
 - **Stream rendering** — typing indicator, one head message edited in place, per-tool activity rows, fenced long-answer splitting, one-time finalize; the activity message is deleted when the turn ends.
-- **Approvals & questions** — DSH ask frames become buttons, select menus, and a free-text modal. Ownership is enforced (the asker — or the thread owner on later turns — clicks), expiry sweeps fail closed, and settled controls grey out in place.
+- **Approvals & questions** — DSH asks become buttons, select menus, and a free-text modal. Ownership is enforced (the asker — or the thread owner on later turns — clicks), expiry sweeps fail closed, and settled controls grey out in place.
 - **Session control** — `/steer`, `/stop`, and `/queue list|remove` with turn-ownership checks; `/project bind|list|info` and `/session resume` for guild↔workspace binding and history; `/guild forget` for operator cleanup.
 - **Model selection** — `/model show` reads the session's live model directory; `/model select` walks an interactive provider → model → reasoning cascade, or applies a typed `provider/model` directly. Open to any authorized member by default; restrictable to Host operators.
 - **Settings card, bilingual out of the box** — token onboarding and connect/disconnect (stored in the Host credential service, never in settings or logs), guild allowlist, auto-archive, and language. Every Discord-visible string ships in Chinese and English; the bot follows the DSH language preference or a pinned choice.
@@ -28,7 +28,7 @@ No extra process: the adapter is a DSH plugin that mounts straight onto your `ds
 
 ## Requirements
 
-- The [dsh CLI](https://www.npmjs.com/package/@deepseek-ai/dsh) `0.1.1-rc.2` or newer, running a web profile
+- The [dsh CLI](https://www.npmjs.com/package/@deepseek-ai/dsh) `0.1.6-alpha.1` or a compatible newer release, running a web profile. Adapter `0.5.x` uses the 0.1.6 controller services and is not compatible with the former `apiProxy` host surface.
 - Node.js `^22.19.0 || >=24`
 - A Discord application with a bot user and the **MESSAGE CONTENT** privileged intent enabled (Developer Portal → your application → Bot → Privileged Gateway Intents)
 
@@ -119,7 +119,7 @@ The settings card exposes the three high-frequency fields (guild allowlist, auto
 - The adapter start chain is generation-counted, so Connect/Disconnect races with the initial boot yield exactly one gateway.
 - A credential probe falls back to `resolve()` because the Host's `describe()` misses env-sourced values — a connected adapter never reads as unconfigured.
 - Adapter logging is default-quiet: flow records ride the Host's debug level and failure-shaped events escalate to warn — nothing prints into the DSH process at the default level.
-- Wire-level live-path tracing: set `DSH_DISCORD_TRACE=1` before booting to emit mux frames, drop points, and delivery outcomes to stderr (default silent). It exists because the rc.2 Host wires no plugin log exporter and exposes no log-level switch — `logger.debug` output is unobservable — and should be dropped once the Host grows one.
+- Wire-level live-path tracing: set `DSH_DISCORD_TRACE=1` before booting to emit mux frames, drop points, and delivery outcomes to stderr (default silent). It exists because the Host wires no plugin log exporter and exposes no log-level switch at this surface — `logger.debug` output is unobservable — and should be dropped once the Host grows one.
 
 ## Known Limitations and Deferred Work
 

package/README.zh.md

@@ -20,7 +20,7 @@
 
 - **@提及驱动会话** — 在已绑定的频道中，被授权的 `@机器人 <任务>` 会锚定一个线程（你的消息成为首帖）、创建 DSH 会话，并且至多提交一次。线程内的后续消息无需 @ 即可排队。消息附带的图片会一并送达：在严格的大小与主机白名单约束下从 Discord CDN 下载，并作为 image parts 提交给多模态模型。
 - **流式渲染** — typing 指示、单条头消息原地编辑、逐工具活动行、代码围栏感知的长文分段、一次性收尾；Turn 结束时活动消息会被删除。
-- **审批与提问** — DSH ask 帧渲染为按钮、下拉菜单与自由文本弹窗。所有权强制校验（提问者——或后续 Turn 的线程属主——才能点击），超时清扫 fail-closed，结算后的控件原地置灰。
+- **审批与提问** — DSH 的 ask 渲染为按钮、下拉菜单与自由文本弹窗。所有权强制校验（提问者——或后续 Turn 的线程属主——才能点击），超时清扫 fail-closed，结算后的控件原地置灰。
 - **会话控制** — `/steer`、`/stop`、`/queue list|remove` 带运行所有权校验；`/project bind|list|info` 与 `/session resume` 管理 Guild↔工作区绑定与历史会话；`/guild forget` 供操作员清理。
 - **模型切换** — `/model show` 读取会话的实时模型目录；`/model select` 走交互式 provider → 模型 → 推理强度级联，也可直接填写 `provider/model` 应用。默认对所有授权成员开放，可收紧为仅 Host 操作员。
 - **设置卡片，开箱双语** — Token 引导与连接/断开（存入 Host 凭据服务，绝不写入设置或日志）、服务器白名单、自动归档与语言。所有 Discord 可见文案提供中英双语；Bot 默认跟随 DSH 语言偏好，也可从卡片固定。
@@ -28,7 +28,7 @@
 
 ## 环境要求
 
-- [dsh CLI](https://www.npmjs.com/package/@deepseek-ai/dsh) `0.1.1-rc.2` 或更新（web profile）
+- [dsh CLI](https://www.npmjs.com/package/@deepseek-ai/dsh) `0.1.6-alpha.1` 或兼容的更新版本（web profile）。适配器 `0.5.x` 使用 0.1.6 的控制器服务，与旧版 `apiProxy` 宿主面不兼容。
 - Node.js `^22.19.0 || >=24`
 - 一个 Discord 应用（含 Bot 用户），并在开发者门户启用 **MESSAGE CONTENT** 特权 intent（Developer Portal → 你的应用 → Bot → Privileged Gateway Intents）
 
@@ -120,7 +120,7 @@ dsh-discord:
 - 适配器启动链带代际计数，Connect/Disconnect 与初始启动竞争时只会产生一个 Gateway。
 - 凭据探测会回退到 `resolve()`：Host 的 `describe()` 不识别环境变量来源的值——已连接的适配器不会被误报为未配置。
 - 适配器日志默认静默：流程记录走 Host 的 debug 级别，失败形态的事件升到 warn——默认级别下不会向 DSH 进程打印任何内容。
-- 链路级 trace：启动前设置 `DSH_DISCORD_TRACE=1` 可将 mux 帧、丢弃点与投递结果输出到 stderr（默认静默）。存在原因：rc.2 Host 未为插件日志接线任何 exporter，也没有日志级别开关——`logger.debug` 输出不可见；Host 提供等价机制后应移除。
+- 链路级 trace：启动前设置 `DSH_DISCORD_TRACE=1` 可将 mux 帧、丢弃点与投递结果输出到 stderr（默认静默）。存在原因：Host 在该面上未为插件日志接线任何 exporter，也没有日志级别开关——`logger.debug` 输出不可见；Host 提供等价机制后应移除。
 
 ## 已知限制与推迟项
 

package/lib/dsh/host-asks.d.ts

@@ -73,6 +73,12 @@ export interface HostAskDeps {
     questionTimeoutMs(): number;
     nowMs(): number;
     log(event: string, detail?: unknown): void;
+    /**
+     * Claim/settle steering for the live progress line (turn-progress spec):
+     * called with `true` when a thread-bound ask is claimed, `false` when it
+     * settles (answered, cancelled, or expired).
+     */
+    onWaitState?(threadId: string, waiting: boolean): void;
 }
 /**
  * Wrap both ask services. Thread-bound sessions get the Discord ask flow;

package/lib/dsh/host-asks.js

@@ -91,6 +91,7 @@ export function installAskServicePatches(approval, questions, deps) {
         }
         const approvalId = crypto.randomUUID();
         deps.log('discord_approval_claimed', { approvalId, sessionId, threadId, toolName: req.toolName });
+        deps.onWaitState?.(threadId, true);
         deps.askWiring.onApprovalRequested({
             sessionId,
             threadId,
@@ -106,7 +107,10 @@ export function installAskServicePatches(approval, questions, deps) {
         pendingApprovals.set(approvalId, pending);
         if (req.signal?.aborted === true)
             pending.dispose();
-        void pending.promise.then(() => { void deps.askWiring.disableControl(approvalId); });
+        void pending.promise.then(() => {
+            deps.onWaitState?.(threadId, false);
+            void deps.askWiring.disableControl(approvalId);
+        });
         return pending.promise;
     };
     if (questions !== undefined && originalAsk !== undefined) {
@@ -123,6 +127,7 @@ export function installAskServicePatches(approval, questions, deps) {
                 return originalAsk(req);
             const rpcId = crypto.randomUUID();
             deps.log('discord_question_claimed', { rpcId, sessionId, threadId, questions: rows.length });
+            deps.onWaitState?.(threadId, true);
             deps.askWiring.onQuestionRequested({
                 sessionId,
                 threadId,
@@ -135,7 +140,10 @@ export function installAskServicePatches(approval, questions, deps) {
             pendingQuestions.set(rpcId, pending);
             if (req.signal?.aborted === true)
                 pending.dispose();
-            void pending.promise.then(() => { void deps.askWiring.disableControl(rpcId); });
+            void pending.promise.then(() => {
+                deps.onWaitState?.(threadId, false);
+                void deps.askWiring.disableControl(rpcId);
+            });
             return pending.promise;
         };
     }

package/lib/dsh/host-events.js

@@ -105,9 +105,19 @@ export function createHostEventRouter(services, options = {}) {
         const per = new AbortController();
         tracked.set(sessionId, per);
         void (async () => {
+            if (process.env['DSH_DISCORD_TRACE'] === '1')
+                console.error(`[dsh-discord:trace] follow-start session=${sessionId.slice(0, 8)} attempt=${String(attempt)}`);
             try {
                 consumer?.push({ type: 'session/subscribed', sessionId });
-                for await (const raw of services.follow({ address: { kind: 'session', sessionId } }, per.signal)) {
+                // The follow request MUST ask for assistant streaming: without the
+                // flag the host (alpha.2) delivers only the opening snapshot and
+                // never pushes later journal records — the live tail stays dead
+                // (diagnosis.md §D, run 2 vs run 3).
+                for await (const raw of services.follow({ address: { kind: 'session', sessionId }, assistantStream: true }, per.signal)) {
+                    if (process.env['DSH_DISCORD_TRACE'] === '1') {
+                        const dumped = JSON.stringify(raw);
+                        console.error(`[dsh-discord:trace] raw-follow-frame type=${String(isRecord(raw) ? raw['type'] : typeof raw)} frame=${dumped.length > 300 ? `${dumped.slice(0, 300)}…` : dumped}`);
+                    }
                     if (!isRecord(raw))
                         continue;
                     const frame = raw;
@@ -115,12 +125,23 @@ export function createHostEventRouter(services, options = {}) {
                     // same {type, data, seq} record envelope the rc.2 mux delivered;
                     // the seq watermark keeps replayed windows idempotent.
                     if (frame['type'] === 'event' || frame['type'] === 'snapshot') {
+                        // Two carriers, both real-machine verified (alpha.2): snapshot
+                        // windows batch their records under `records`, while live records
+                        // arrive as single-record frames — the record rides the `event`
+                        // key of the frame itself, no array. Snapshots without a records
+                        // array stay drops (malformed), live frames become their own
+                        // one-element batch.
                         const records = raw.records;
-                        if (!Array.isArray(records))
+                        const batch = Array.isArray(records)
+                            ? records
+                            : frame['type'] === 'event'
+                                ? [raw]
+                                : undefined;
+                        if (batch === undefined)
                             continue;
                         const through = watermark.get(sessionId) ?? 0;
                         let delivered = through;
-                        for (const record of records) {
+                        for (const record of batch) {
                             // Journal records arrive double-wrapped: {type:'event',
                             // event:{type, seq, time, data}} — the wire event rides the
                             // `event` key. Accept the flat shape defensively too.
@@ -138,6 +159,12 @@ export function createHostEventRouter(services, options = {}) {
                                 if (inner.seq > delivered)
                                     delivered = inner.seq;
                             }
+                            if (process.env['DSH_DISCORD_TRACE'] === '1') {
+                                // Full data dump (truncated): diagnosis needs the field
+                                // shapes, not just the key names — keys hide nesting.
+                                const dumped = JSON.stringify(inner.data);
+                                console.error(`[dsh-discord:trace] record type=${inner.type} seq=${String(inner.seq)} data=${dumped.length > 800 ? `${dumped.slice(0, 800)}…` : dumped}`);
+                            }
                             consumer?.push({
                                 type: 'session/event',
                                 sessionId,
@@ -150,16 +177,28 @@ export function createHostEventRouter(services, options = {}) {
                     else if (frame['type'] === 'assistant-stream') {
                         // Live assistant deltas ride the dedicated stream frames; the
                         // renderer's durable events already carry the message texts.
+                        if (process.env['DSH_DISCORD_TRACE'] === '1') {
+                            const dumped = JSON.stringify(frame);
+                            console.error(`[dsh-discord:trace] assistant-stream frame=${dumped.length > 300 ? `${dumped.slice(0, 300)}…` : dumped}`);
+                        }
                         continue;
                     }
+                    else if (process.env['DSH_DISCORD_TRACE'] === '1') {
+                        const dumped = JSON.stringify(frame);
+                        console.error(`[dsh-discord:trace] follow-frame UNHANDLED type=${String(frame['type'])} frame=${dumped.length > 400 ? `${dumped.slice(0, 400)}…` : dumped}`);
+                    }
                 }
             }
             catch (cause) {
                 if (!per.signal.aborted) {
+                    if (process.env['DSH_DISCORD_TRACE'] === '1')
+                        console.error(`[dsh-discord:trace] follow-threw session=${sessionId.slice(0, 8)} cause=${String(cause).slice(0, 300)}`);
                     log?.('discord_host_follow_threw', { sessionId, cause: String(cause) });
                 }
             }
             finally {
+                if (process.env['DSH_DISCORD_TRACE'] === '1')
+                    console.error(`[dsh-discord:trace] follow-end session=${sessionId.slice(0, 8)} aborted=${String(per.signal.aborted)} tracked=${String(tracked.get(sessionId) === per)}`);
                 if (tracked.get(sessionId) === per)
                     tracked.delete(sessionId);
                 // A follow stream may END normally once its snapshot is delivered
@@ -185,6 +224,10 @@ export function createHostEventRouter(services, options = {}) {
                     if (!isRecord(raw))
                         continue;
                     const frame = raw;
+                    if (process.env['DSH_DISCORD_TRACE'] === '1') {
+                        const dumped = JSON.stringify(frame);
+                        console.error(`[dsh-discord:trace] control type=${String(frame['type'])} frame=${dumped.length > 400 ? `${dumped.slice(0, 400)}…` : dumped}`);
+                    }
                     if (frame['type'] === 'queue' && typeof frame['sessionId'] === 'string') {
                         const rawItems = Array.isArray(frame['items']) ? frame['items'] : [];
                         const items = rawItems
@@ -218,6 +261,8 @@ export function createHostEventRouter(services, options = {}) {
             startLoop(sessionId);
         },
         stream(signal) {
+            if (process.env['DSH_DISCORD_TRACE'] === '1')
+                console.error(`[dsh-discord:trace] router-stream-open tracked=${String(tracked.size)} rearm=${String(tracked.size)}`);
             rootSignal = signal;
             const queue = createFrameQueue();
             consumer = queue;

package/lib/i18n.d.ts

@@ -85,6 +85,11 @@ declare const zh: {
     unboundNoticeAdministrator: string;
     unboundNoticeMember: string;
     interruptedMarker: string;
+    progressThinking: string;
+    progressThinkingStep: (step: number) => string;
+    progressWriting: string;
+    progressApprovalWait: string;
+    progressTurnSummary: (total: number, failed: number, breakdown: string) => string;
     modelNeedsThread: string;
     modelShowUnavailable: string;
     modelShowHeader: (sel: string, groups: number) => string;

package/lib/i18n.js

@@ -93,6 +93,13 @@ const zh = {
     unboundNoticeMember: '💡 此频道未绑定工作区；请工作区管理员运行 `/project bind`。',
     // ── stream renderer ──────────────────────────────────────────────────
     interruptedMarker: '*（已被中断）*',
+    progressThinking: '⏳ 思考中…',
+    progressThinkingStep: (step) => `⏳ 思考中…（步骤 ${String(step)}）`,
+    progressWriting: '✍️ 撰写回复…',
+    progressApprovalWait: '⏳ 等待审批…',
+    progressTurnSummary: (total, failed, breakdown) => failed > 0
+        ? `⚙️ 本轮 ${String(total)} 次工具调用 · ${String(failed)} 失败 ✗（${breakdown}）`
+        : `⚙️ 本轮 ${String(total)} 次工具调用 ✓（${breakdown}）`,
     // ── /model show / select ─────────────────────────────────────────────
     modelNeedsThread: '⚠️ /model 需要在已绑定 Session 的任务线程中使用（先在项目频道 @ 机器人）。',
     modelShowUnavailable: '⚠️ 模型目录暂时不可用，请稍后重试。',
@@ -215,6 +222,13 @@ const en = {
     unboundNoticeAdministrator: '💡 This channel is not bound to a workspace. A workspace administrator can run `/project bind` to create and bind the project channel.',
     unboundNoticeMember: '💡 This channel is not bound to a workspace; ask a workspace administrator to run `/project bind`.',
     interruptedMarker: '*(interrupted)*',
+    progressThinking: '⏳ Thinking…',
+    progressThinkingStep: (step) => `⏳ Thinking… (step ${String(step)})`,
+    progressWriting: '✍️ Writing the answer…',
+    progressApprovalWait: '⏳ Waiting for approval…',
+    progressTurnSummary: (total, failed, breakdown) => failed > 0
+        ? `⚙️ ${String(total)} tool calls this turn · ${String(failed)} failed ✗ (${breakdown})`
+        : `⚙️ ${String(total)} tool calls this turn ✓ (${breakdown})`,
     // ── /model show / select ─────────────────────────────────────────────
     modelNeedsThread: '⚠️ /model needs a thread bound to a Session (mention the bot in a project channel first).',
     modelShowUnavailable: '⚠️ The model catalog is temporarily unavailable; try again later.',

package/lib/index.js

@@ -711,6 +711,10 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
         if (approvalService === undefined)
             throw new TypeError('dsh-discord cannot reach the approval service');
         const hostAsksRef = { current: undefined };
+        // Ask-claim steering for the turn progress line (turn-progress spec):
+        // declared before the patches so the closure is stable; the live
+        // renderer attaches later in startup (asks cannot fire before then).
+        const liveProgressRef = { current: undefined };
         hostAsksRef.current = installAskServicePatches(approvalService, questionsService, {
             threadForSession,
             askWiring,
@@ -718,6 +722,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             questionTimeoutMs: () => current.questionTimeoutMs,
             nowMs: () => Date.now(),
             log: rpcLog,
+            onWaitState: (threadId, waiting) => { liveProgressRef.current?.setApprovalWait(threadId, waiting); },
         });
         ctx.effect(() => () => { hostAsksRef.current?.dispose(); }, 'dsh-discord host ask answerers');
         const approvalRespondPort = {
@@ -1081,6 +1086,13 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             verbosity: current.defaultVerbosity,
             log: rpcLog,
             interruptedMarker: () => copy.interruptedMarker,
+            progressCopy: () => ({
+                thinking: copy.progressThinking,
+                thinkingStep: copy.progressThinkingStep,
+                writing: copy.progressWriting,
+                approvalWait: copy.progressApprovalWait,
+                turnSummary: copy.progressTurnSummary,
+            }),
             onQueueSnapshot: (sessionId, items) => { queueSnapshots.set(sessionId, items); },
             onTurnEnded: (sessionId) => {
                 const turn = turnTracker.active(sessionId);
@@ -1089,6 +1101,8 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                 rpcLog('discord_turn_ended', { sessionId, hadActiveTurn: turn !== undefined });
             },
         });
+        // The ask patches steer the same renderer's progress line (3.2 wiring).
+        liveProgressRef.current = liveRef.current;
         ctx.effect(() => () => { liveRef.current?.dispose(); }, 'dsh-discord live render');
         ctx.effect(() => () => { runtimeRef.current?.dispose(); }, 'dsh-discord composed runtime');
     })().catch((cause) => {

package/lib/stream/live.d.ts

@@ -95,9 +95,23 @@ export interface LiveRenderDeps {
     }>) => void;
     /** Localized interruption suffix, resolved live (language can change). */
     interruptedMarker?: () => string;
+    /**
+     * Localized progress-phase copy, resolved live (language can change).
+     * Unset: the status line is omitted and only tool rows render (the
+     * pre-progress behavior).
+     */
+    progressCopy?: () => {
+        thinking: string;
+        thinkingStep: (step: number) => string;
+        writing: string;
+        approvalWait: string;
+        turnSummary: (total: number, failed: number, breakdown: string) => string;
+    };
     /** Turn ownership release on turn/end. */
     onTurnEnded?: (sessionId: string) => void;
 }
 export declare function startLiveRender(deps: LiveRenderDeps): {
     dispose(): void;
+    /** Approval-wait steering for the ask patches (turn-progress spec). */
+    setApprovalWait(threadId: string, waiting: boolean): void;
 };

package/lib/stream/live.js

@@ -61,6 +61,17 @@ function resultCallId(data) {
     const block = Array.isArray(message?.content) ? message.content[0] : undefined;
     return typeof block?.toolCallId === 'string' ? block.toolCallId : undefined;
 }
+/**
+ * The failure flag of a tool/result event. The rc.2 wire carried a top-level
+ * `error`; the 0.1.6 journal marks failure on the result block (`isError`).
+ */
+function resultFailed(data) {
+    if (data['error'] !== undefined)
+        return true;
+    const message = data['message'];
+    const block = Array.isArray(message?.content) ? message.content[0] : undefined;
+    return block?.isError === true;
+}
 /**
  * The Host presentation view's title for one tool event: a terminal call's
  * title IS the command; generic/diff cards title the call. Host-curated
@@ -97,6 +108,9 @@ export function startLiveRender(deps) {
             finalizer: undefined,
             headMessageId: undefined,
             activityMessageId: undefined,
+            activityFlush: undefined,
+            progressPhase: undefined,
+            phaseBeforeApproval: undefined,
             headFlush: undefined,
             stepSeq: 0,
             headAttempted: false,
@@ -146,6 +160,7 @@ export function startLiveRender(deps) {
         runtime.turnId = turnId;
         runtime.headMessageId = undefined;
         runtime.activityMessageId = undefined;
+        runtime.activityFlush = undefined;
         runtime.headFlush = undefined;
         runtime.headAttempted = false;
         runtime.activityAttempted = false;
@@ -168,6 +183,10 @@ export function startLiveRender(deps) {
             onFlushError: (cause) => { deps.log?.('discord_live_activity_flush_failed', { threadId, cause: String(cause) }); },
         });
         runtime.finalizer = undefined;
+        // The status line opens the turn in the thinking phase (spec
+        // turn-progress: the message exists from turn/start, before any tool).
+        runtime.progressPhase = { kind: 'thinking', step: 1 };
+        runtime.phaseBeforeApproval = undefined;
         // A fresh lifecycle per turn: start() no-ops on a stopped one, so a
         // second turn in the same thread would otherwise never type again.
         runtime.typing.dispose();
@@ -177,40 +196,84 @@ export function startLiveRender(deps) {
             onFailure: (cause) => { deps.log?.('discord_live_typing_threw', { threadId, cause: String(cause) }); },
         });
         runtime.typing.start();
+        runtime.activityScheduler.schedule(renderActivityContent(runtime));
     }
-    /** The activity message body: one icon + presentation title per call row. */
+    /** The status line's phase entry (undefined when copy is not provided). */
+    function progressPhaseLine(runtime) {
+        const copy = deps.progressCopy?.();
+        if (copy === undefined || runtime.progressPhase === undefined)
+            return undefined;
+        const phase = runtime.progressPhase;
+        switch (phase.kind) {
+            case 'thinking': return phase.step > 1 ? copy.thinkingStep(phase.step) : copy.thinking;
+            case 'tool': return `💻 ${truncateText(phase.title ?? phase.label, ACTIVITY_TITLE_MAX)}`;
+            case 'writing': return copy.writing;
+            case 'approval': return copy.approvalWait;
+        }
+    }
+    /**
+     * The turn's collapsed one-line summary (decision 5): the durable trace a
+     * finished turn leaves behind. Undefined when the turn ran no tools —
+     * those keep the pure Q&A thread and the message is deleted instead.
+     */
+    function renderTurnSummary(rows) {
+        const copy = deps.progressCopy?.();
+        if (copy === undefined || rows.length === 0)
+            return undefined;
+        const counts = new Map();
+        for (const row of rows)
+            counts.set(row.label, (counts.get(row.label) ?? 0) + 1);
+        const breakdown = truncateText([...counts.entries()].map(([label, n]) => `${label} ×${String(n)}`).join(' · '), 200);
+        const failed = rows.filter(row => row.state === 'failed').length;
+        return copy.turnSummary(rows.length, failed, breakdown);
+    }
+    /** The activity message body: phase line, then one icon + title per call row. */
     function renderActivityContent(runtime) {
         const rows = runtime.tools.render();
-        return rows.map(row => {
+        const rowLines = rows.map(row => {
             const title = truncateText(row.title ?? row.label, ACTIVITY_TITLE_MAX);
-            return `> ${toolCategoryIcon(row.label)} ${title}`;
-        }).join('\n');
+            const mark = row.state === 'succeeded' ? '✓ ' : row.state === 'failed' ? '✗ ' : '';
+            return `> ${mark}${toolCategoryIcon(row.label)} ${title}`;
+        });
+        const phaseLine = progressPhaseLine(runtime);
+        return phaseLine === undefined ? rowLines.join('\n') : [phaseLine, ...rowLines].join('\n');
     }
     /** Render the tool rows into one bounded activity message (create once, edit after). */
     function renderActivity(threadId, runtime) {
         return async () => {
-            if (runtime.tools.render().length === 0)
+            if (runtime.tools.render().length === 0 && progressPhaseLine(runtime) === undefined)
                 return;
-            // Tool titles are Host-presented free text (terminal commands): they
-            // go through the same outbound builder as every other message path.
-            const payload = buildOutboundMessage({ kind: 'tool', content: renderActivityContent(runtime) });
-            if (runtime.activityMessageId === undefined) {
-                if (runtime.activityAttempted)
-                    return;
-                const sent = await deps.delivery.send({ channelId: threadId, content: payload.content });
-                if (sent.outcome === 'completed')
-                    runtime.activityMessageId = sent.messageId;
-                else if (sent.outcome === 'unknown') {
-                    runtime.activityAttempted = true;
-                    deps.log?.('discord_live_activity_send_unknown', { threadId });
+            // The flush promise records the message id it created so turn/end's
+            // cleanup can delete a send that is still in flight (orphan guard).
+            const flush = (async () => {
+                // Tool titles are Host-presented free text (terminal commands): they
+                // go through the same outbound builder as every other message path.
+                const payload = buildOutboundMessage({ kind: 'tool', content: renderActivityContent(runtime) });
+                if (runtime.activityMessageId === undefined) {
+                    if (runtime.activityAttempted)
+                        return undefined;
+                    const sent = await deps.delivery.send({ channelId: threadId, content: payload.content });
+                    if (sent.outcome === 'completed') {
+                        runtime.activityMessageId = sent.messageId;
+                        return sent.messageId;
+                    }
+                    if (sent.outcome === 'unknown') {
+                        runtime.activityAttempted = true;
+                        deps.log?.('discord_live_activity_send_unknown', { threadId });
+                    }
+                    return undefined;
                 }
-                return;
-            }
-            await deps.delivery.edit({ channelId: threadId, messageId: runtime.activityMessageId, content: payload.content });
+                await deps.delivery.edit({ channelId: threadId, messageId: runtime.activityMessageId, content: payload.content });
+                return undefined;
+            })();
+            runtime.activityFlush = flush;
+            await flush;
         };
     }
     function handleSessionEvent(sessionId, threadId, runtime, event, frameView) {
         const data = event.data;
+        if (TRACE)
+            trace('handleSessionEvent', event.type, 'keys:', Object.keys(data).join(','));
         const turnId = typeof data['turn'] === 'number' ? String(data['turn']) : undefined;
         const stepId = typeof data['step'] === 'number' ? String(data['step']) : undefined;
         switch (event.type) {
@@ -229,6 +292,11 @@ export function startLiveRender(deps) {
                 runtime.headFlush = undefined;
                 runtime.headAttempted = false;
                 runtime.stepSeq += 1;
+                // A step boundary is a thinking boundary: the model is reasoning
+                // about the previous step's results before the next tool call.
+                // The journal's own step number is the display truth (stepSeq is a
+                // generation fence that also bumps at the turn boundary).
+                runtime.progressPhase = { kind: 'thinking', step: typeof data['step'] === 'number' ? data['step'] : runtime.stepSeq };
                 // The previous step's finalize disposed the scheduler; a fresh one
                 // carries the new step's chunk coalescing.
                 runtime.scheduler?.dispose();
@@ -237,6 +305,7 @@ export function startLiveRender(deps) {
                     onFlush: flushAnswer(threadId, runtime),
                     onFlushError: (cause) => { deps.log?.('discord_live_flush_failed', { threadId, cause: String(cause) }); },
                 });
+                runtime.activityScheduler?.schedule(renderActivityContent(runtime));
                 return;
             }
             case 'assistant/chunk': {
@@ -265,6 +334,9 @@ export function startLiveRender(deps) {
                 runtime.render.setAuthoritative({ turnId, stepId, text });
                 if (interrupted)
                     runtime.render.interrupt({ turnId, stepId });
+                // The step's answer is committed: the agent is writing its reply.
+                runtime.progressPhase = { kind: 'writing' };
+                runtime.activityScheduler?.schedule(renderActivityContent(runtime));
                 runtime.scheduler?.dispose();
                 runtime.scheduler = undefined;
                 if (text === '')
@@ -319,6 +391,8 @@ export function startLiveRender(deps) {
                 runtime.toolNames.set(data['callId'], data['name']);
                 if (title !== undefined)
                     runtime.toolTitles.set(data['callId'], title);
+                // The status line tracks the most recent call as the running phase.
+                runtime.progressPhase = { kind: 'tool', label: data['name'], title };
                 runtime.tools.record({
                     callId: data['callId'],
                     toolName: data['name'],
@@ -333,7 +407,7 @@ export function startLiveRender(deps) {
                 const callId = resultCallId(data);
                 if (callId === undefined)
                     return;
-                const failed = data['error'] !== undefined;
+                const failed = resultFailed(data);
                 runtime.tools.record({
                     callId,
                     toolName: runtime.toolNames.get(callId) ?? 'tool',
@@ -349,16 +423,36 @@ export function startLiveRender(deps) {
                 runtime.scheduler = undefined;
                 runtime.activityScheduler?.dispose();
                 runtime.activityScheduler = undefined;
-                // The activity message is the live "what's happening" surface only:
-                // at turn end it is deleted — the durable record is the Session log
-                // and the assistant's answer.
-                const activityMessageId = runtime.activityMessageId;
+                runtime.progressPhase = undefined;
+                runtime.phaseBeforeApproval = undefined;
+                // The activity message collapses at turn end (decision 5): a turn
+                // that ran tools is EDITED into its one-line summary — the durable
+                // process trace — while a zero-tool turn keeps the pure Q&A thread
+                // and is deleted. A send still in flight when the cleanup ran would
+                // orphan the message, so the collapse waits for the flush to settle
+                // first (stepSeq fences a turn that began meanwhile: its message
+                // owns the slot and must survive).
+                const epochAtEnd = runtime.stepSeq;
+                const settledId = runtime.activityMessageId;
                 runtime.activityMessageId = undefined;
-                if (activityMessageId !== undefined) {
-                    void deps.delivery.delete({ channelId: threadId, messageId: activityMessageId }).catch((cause) => {
+                const summary = renderTurnSummary(runtime.tools.render());
+                const pendingActivityFlush = Promise.resolve(runtime.activityFlush).catch(() => undefined);
+                void pendingActivityFlush.then(flushedId => {
+                    const id = runtime.activityMessageId ?? settledId ?? flushedId;
+                    if (id === undefined || runtime.stepSeq !== epochAtEnd)
+                        return;
+                    runtime.activityMessageId = undefined;
+                    if (summary !== undefined) {
+                        const payload = buildOutboundMessage({ kind: 'tool', content: summary });
+                        void deps.delivery.edit({ channelId: threadId, messageId: id, content: payload.content }).catch((cause) => {
+                            deps.log?.('discord_live_activity_summary_edit_threw', { threadId, cause: String(cause) });
+                        });
+                        return;
+                    }
+                    void deps.delivery.delete({ channelId: threadId, messageId: id }).catch((cause) => {
                         deps.log?.('discord_live_activity_delete_threw', { threadId, cause: String(cause) });
                     });
-                }
+                });
                 deps.onTurnEnded?.(sessionId);
                 return;
             }
@@ -503,5 +597,30 @@ export function startLiveRender(deps) {
             }
             runtimes.clear();
         },
+        /**
+         * Approval-wait steering for the ask patches (turn-progress spec): a
+         * claimed ask suspends the status line on the wait phase; settling
+         * restores the suspended phase so progress tracking resumes.
+         */
+        setApprovalWait(threadId, waiting) {
+            if (state.disposed)
+                return;
+            const runtime = runtimes.get(threadId);
+            if (runtime === undefined)
+                return;
+            if (waiting) {
+                if (runtime.progressPhase?.kind === 'approval')
+                    return;
+                runtime.phaseBeforeApproval = runtime.progressPhase;
+                runtime.progressPhase = { kind: 'approval' };
+            }
+            else {
+                if (runtime.progressPhase?.kind !== 'approval')
+                    return;
+                runtime.progressPhase = runtime.phaseBeforeApproval;
+                runtime.phaseBeforeApproval = undefined;
+            }
+            runtime.activityScheduler?.schedule(renderActivityContent(runtime));
+        },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addozhang/dsh-discord",
-  "version": "0.5.0-alpha.1",
+  "version": "0.5.0-alpha.2",
   "description": "Discord-first adapter for DeepSeek Harness",
   "license": "MIT",
   "type": "module",