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

package/lib/index.js

@@ -1,5 +1,4 @@
 import { DEFAULT_DISCORD_SETTINGS, DiscordSettingsSchema, installDiscordSettings, normalizeDiscordSettings, } from './settings.js';
-import { settingsNamespace } from '@deepseek-ai/dsh-settings';
 import { installCancellationRoot } from './lifecycle.js';
 import { ALLOWED_MENTIONS_NONE, DISCORD_SUPPRESS_NOTIFICATIONS_FLAG, OUTBOUND_EPHEMERAL_FLAGS, safeTitle } from './policy/disclosure.js';
 import { validateHostCapabilities } from './startup.js';
@@ -10,7 +9,7 @@ import { createRestThreadPort } from './discord/thread-port.js';
 import { createComponentRegistry } from './discord/components.js';
 import { buildCommandRegistrations } from './discord/commands.js';
 import { startDiscordAdapter } from './compose.js';
-import { createModelPort, createWorkspaceCatalogPort, createWorkspaceResolver, readWorkspaceDetail, promptSession, createSessionViaProxy, cancelSessionViaProxy, steerSession, removeQueueItemViaProxy } from './dsh/api-proxy-face.js';
+import { createModelPort, createWorkspaceCatalogPort, createWorkspaceResolver, readWorkspaceDetail, promptSession, createSessionViaProxy, cancelSessionViaProxy, steerSession, removeQueueItemViaProxy, resolveHostFace } from './dsh/host-face.js';
 import { createApprovalStore } from './features/approval-store.js';
 import { createAskWiring } from './features/ask-wiring.js';
 import { sweepExpiredApprovals } from './features/approval-expiry.js';
@@ -22,7 +21,9 @@ import { createInteractionRouter } from './features/interaction-router.js';
 import { channelBindingKey, parseChannelBindingKey, threadBindingKey, parseThreadBindingKey, discordDomainSpec, CHANNEL_BINDINGS_TABLE, THREAD_BINDINGS_TABLE, INTENTS_TABLE } from './state/domain.js';
 import { planBindingReconciliation } from './features/reconcile-bindings.js';
 import { guildKeysToForget, sweepExpired } from './state/retention.js';
-import { listSessionIds, listSessionSummaries, createClientRespondPort } from './dsh/api-proxy-face.js';
+import { createHostEventRouter } from './dsh/host-events.js';
+import { listSessionIds, listSessionSummaries } from './dsh/host-face.js';
+import { installAskServicePatches } from './dsh/host-asks.js';
 import { createBindingStore } from './state/bindings.js';
 import { createIntentStore } from './state/intents.js';
 import { createTurnTracker } from './features/turn-ownership.js';
@@ -31,12 +32,13 @@ import { createSessionCreationFlow } from './features/session-creation.js';
 import { createResumeCandidatesPort } from './features/session-resume.js';
 import { createPromptSubmissionFlow } from './features/prompt-submission.js';
 import { createSessionMainline, requestIdFor } from './features/session-mainline.js';
+import { collectImages, createSafeImageDownloadPort } from './features/image-collection.js';
 import { startLiveRender } from './stream/live.js';
 import { planWorkspaceChannel, workspaceChannelName } from './features/workspace-channel.js';
 /** Stable Cordis plugin name for diagnostics. */
 export const name = 'dsh-discord';
 /** Host services required by the complete embedded adapter. */
-export const inject = ['apiProxy', 'credentials', 'settings', 'storageDomain', 'connection'];
+export const inject = ['sessionController', 'workspaceController', 'sessionQuery', 'webServer', 'credentials', 'settings', 'storageDomain', 'connection'];
 export const Config = DiscordSettingsSchema;
 /**
  * Fixed Milestone 1 Gateway intents: guilds, messages, content. Member data
@@ -74,7 +76,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
     const resolveLanguage = () => {
         if (current.language !== 'auto')
             return current.language;
-        const locale = ctx.get('settings').get(settingsNamespace('locale'));
+        const locale = ctx.get('settings').get('locale');
         return typeof locale?.preference === 'string' && locale.preference.startsWith('zh') ? 'zh' : 'en';
     };
     const copy = new Proxy({}, {
@@ -101,15 +103,20 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
     // Late-bound so the management channel can reach the runtime built inside
     // the composition IIFE below (the card's Connect button).
     const runtimeRef = { current: undefined };
-    installAdapterStatusRpc(ctx.get('connection'), statusTracker, {
-        tracker: statusTracker,
-        setToken: async (value) => {
-            await ctx.get('credentials').set(DISCORD_BOT_TOKEN_REF, value);
-            statusTracker.setCredential({ configured: true });
-        },
-        connect: () => { runtimeRef.current?.connect(); },
-        disconnect: () => { runtimeRef.current?.disconnect(); },
-    });
+    // Channel registration mounts a prefix route through our OWN context
+    // effect (see installAdapterStatusRpc: the host's connection.rpc.handle
+    // is owner-scoped and unusable from an external plugin).
+    {
+        installAdapterStatusRpc(ctx, statusTracker, {
+            tracker: statusTracker,
+            setToken: async (value) => {
+                await ctx.get('credentials').set(DISCORD_BOT_TOKEN_REF, value);
+                statusTracker.setCredential({ configured: true });
+            },
+            connect: () => { runtimeRef.current?.connect(); },
+            disconnect: () => { runtimeRef.current?.disconnect(); },
+        });
+    }
     void describeDiscordCredential(ctx.get('credentials'))
         .then((view) => { statusTracker.setCredential(view); })
         .catch((cause) => {
@@ -117,10 +124,10 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
         statusTracker.setCredential({ configured: false });
     });
     const credentials = ctx.get('credentials');
-    // The in-process apiProxy face: domain methods resolve RpcRequest →
-    // RpcResponse and never throw business errors; boundedness and outcome
-    // logging live in src/dsh/api-proxy-face.ts.
-    const apiProxy = ctx.get('apiProxy');
+    // The in-process 0.1.6 controller face: plain requests in, plain values
+    // out, business rejections as thrown RemoteErrors; boundedness and outcome
+    // logging live in src/dsh/host-face.ts.
+    const dsh = resolveHostFace(ctx);
     // Default-quiet logging (16.33): flow records ride the Host's debug level
     // only — the adapter prints nothing into the DSH process at the default
     // level. Failure-shaped events (…failed/…threw/…blocked/…unknown) escalate
@@ -132,13 +139,16 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
         }
         emitLog(ctx, /(?:failed|threw|blocked|unknown)/.test(event) ? 'warn' : 'debug', { event, detail: serialized });
     };
+    // The 0.1.6 event bridge (declared early: every session-acquisition site
+    // below tracks into it; the live renderer consumes its fan-in stream).
+    const hostEvents = createHostEventRouter(dsh.session, { log: rpcLog });
     void (async () => {
         // The durable domain gates the whole composition: no adapter starts
         // without its bindings/intents tables, and close() drains queued writes
         // on teardown (fail-closed across restarts, design §10).
         const domain = await ctx.storageDomain.open(discordDomainSpec);
         ctx.effect(() => () => { void domain.close(); }, 'discord durable domain');
-        const catalogPort = createWorkspaceCatalogPort(apiProxy, { log: rpcLog });
+        const catalogPort = createWorkspaceCatalogPort(dsh, { log: rpcLog });
         const policy = () => ({
             allowedGuildIds: [...current.allowedGuildIds],
             memberUserIds: [...current.memberUserIds],
@@ -179,7 +189,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
         const sharedRegistry = createComponentRegistry();
         const questionCancelPort = {
             cancel: async ({ sessionId }) => {
-                const cancelled = await cancelSessionViaProxy(apiProxy, { sessionId }, { log: rpcLog });
+                const cancelled = await cancelSessionViaProxy(dsh, { sessionId }, { log: rpcLog });
                 const turn = turnTracker.active(sessionId);
                 if (turn !== undefined)
                     turnTracker.complete(turn.requestId);
@@ -283,10 +293,50 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             };
         })();
         const dshSessionPort = {
-            createSession: request => createSessionViaProxy(apiProxy, request, { log: rpcLog }),
+            createSession: async (request) => {
+                const created = await createSessionViaProxy(dsh, request, { log: rpcLog });
+                if (created.outcome === 'completed')
+                    hostEvents.track(created.sessionId);
+                return created;
+            },
         };
         const dshPromptPort = {
-            submit: request => promptSession(apiProxy, { sessionId: request.sessionId, prompt: request.prompt }, { log: rpcLog, rpcId: request.requestId }),
+            submit: async (request) => {
+                const submitted = await promptSession(dsh, {
+                    sessionId: request.sessionId,
+                    prompt: request.prompt,
+                    ...(request.images === undefined ? {} : { images: request.images }),
+                }, { log: rpcLog, rpcId: request.requestId });
+                if (submitted.outcome === 'accepted')
+                    hostEvents.track(request.sessionId);
+                return submitted;
+            },
+        };
+        /**
+         * The bounded image collection boundary (16.50): downloads ride the
+         * safe-download port (allowlisted CDN hosts, capped sizes, timeout) and
+         * come back base64-encoded for the prompt parts.
+         */
+        const IMAGE_DOWNLOAD_TIMEOUT_MS = 15_000;
+        const imageCollector = {
+            collect: async ({ attachments }) => {
+                const result = await collectImages(createSafeImageDownloadPort(), {
+                    nowMs: Date.now(),
+                    timeoutMs: IMAGE_DOWNLOAD_TIMEOUT_MS,
+                    attachments,
+                });
+                if (result.outcome !== 'collected') {
+                    const reason = result.outcome === 'too-large' ? `too-large:${result.reason}` : result.outcome;
+                    return { outcome: 'failed', reason };
+                }
+                return {
+                    outcome: 'collected',
+                    images: result.downloaded.map(image => ({
+                        mediaType: image.mediaType,
+                        base64: Buffer.from(image.body).toString('base64'),
+                    })),
+                };
+            },
         };
         const composedMainline = createSessionMainline({
             threads: createThreadCreationFlow({
@@ -305,6 +355,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                 nowMs: () => Date.now(),
             }),
             turns: turnTracker,
+            images: imageCollector,
         });
         /** Mainline outcome → copy key; the string resolves live per language. */
         const MAINLINE_FAILURE_KEYS = {
@@ -314,6 +365,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             'session-unknown': 'mainlineSessionUnknown',
             'prompt-rejected': 'mainlinePromptRejected',
             'prompt-unknown': 'mainlinePromptUnknown',
+            'image-failed': 'mainlineImageFailed',
         };
         const mainline = {
             admitMention: async (request) => {
@@ -334,9 +386,13 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             },
             continueInThread: async (request) => {
                 const result = await composedMainline.continueInThread(request);
-                if (result.outcome === 'rejected' || result.outcome === 'unknown') {
+                if (result.outcome === 'rejected' || result.outcome === 'unknown' || result.outcome === 'image-failed') {
                     rpcLog('discord_continuation_not_queued', { messageId: request.messageId, outcome: result.outcome });
-                    const notice = result.outcome === 'rejected' ? copy.continuationRejected : copy.continuationUnknown;
+                    const notice = result.outcome === 'rejected'
+                        ? copy.continuationRejected
+                        : result.outcome === 'image-failed'
+                            ? copy.mainlineImageFailed
+                            : copy.continuationUnknown;
                     void withRest(rest => rest.request('POST', `/channels/${request.threadId}/messages`, { content: notice, flags: DISCORD_SUPPRESS_NOTIFICATIONS_FLAG, allowed_mentions: ALLOWED_MENTIONS_NONE }))
                         .catch((cause) => { rpcLog('discord_mainline_notice_failed', String(cause)); });
                 }
@@ -346,7 +402,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
         // Bind provision resolves the selection against the live catalog; the
         // Discord confirm button carries only opaque registry ids between the
         // command and the write.
-        const resolver = createWorkspaceResolver(apiProxy, { log: rpcLog });
+        const resolver = createWorkspaceResolver(dsh, { log: rpcLog });
         // Adapter-owned guild surfaces: the "DeepSeek Harness" category, the
         // general control channel (both provisioned on READY), and — on bind —
         // one channel per Workspace, named after its display title. Nothing
@@ -500,7 +556,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                     rpcLog('discord_reconcile_blocked', 'workspace-catalog-unavailable');
                     return;
                 }
-                const sessionIds = await listSessionIds(apiProxy, { log: rpcLog });
+                const sessionIds = await listSessionIds(dsh, { log: rpcLog });
                 if (sessionIds.outcome !== 'completed') {
                     rpcLog('discord_reconcile_blocked', 'session-list-unavailable');
                     return;
@@ -633,13 +689,44 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             }).catch((cause) => { rpcLog('discord_question_expiry_threw', String(cause)); });
         }, 30_000);
         ctx.effect(() => () => { clearInterval(expiryTimer); }, 'discord interaction expiry sweep');
-        // DSH approval respond face: the client-response echoes the ask's rpcId.
-        const clientRespond = createClientRespondPort(apiProxy, { log: rpcLog });
+        const threadForSession = (sessionId) => {
+            for (const [key, record] of threadTable.entries()) {
+                if (record.sessionId !== sessionId)
+                    continue;
+                const scope = parseThreadBindingKey(key);
+                if (scope !== undefined)
+                    return scope.threadId;
+            }
+            return undefined;
+        };
+        // DSH ask answerers (0.1.6 composed-approval model): the waterfalls
+        // dispatch on the BASE TREE's event bus (the profile composes one event
+        // tree per bundle and a waterfall only enumerates its own registry), so
+        // the listeners register there — resolved off a base service's context.
+        // Ask carrier: wrap the base-tree ask services at the method boundary
+        // (the composed-answerer waterfalls are not reachable from an external
+        // plugin's registrations — see host-asks.ts).
+        const approvalService = ctx.get('approval');
+        const questionsService = ctx.get('userQuestions');
+        if (approvalService === undefined)
+            throw new TypeError('dsh-discord cannot reach the approval service');
+        const hostAsksRef = { current: undefined };
+        hostAsksRef.current = installAskServicePatches(approvalService, questionsService, {
+            threadForSession,
+            askWiring,
+            approvalTimeoutMs: () => current.approvalTimeoutMs,
+            questionTimeoutMs: () => current.questionTimeoutMs,
+            nowMs: () => Date.now(),
+            log: rpcLog,
+        });
+        ctx.effect(() => () => { hostAsksRef.current?.dispose(); }, 'dsh-discord host ask answerers');
         const approvalRespondPort = {
-            respond: async ({ rpcId, sessionId, approvalId, outcome }) => {
-                const receipt = await clientRespond.respond(rpcId, { sessionId, approvalId, outcome });
-                rpcLog('discord_approval_respond_receipt', { rpcId, approvalId, outcome, receipt });
-                return receipt;
+            respond: ({ approvalId, outcome }) => {
+                const settled = hostAsksRef.current?.settleApproval(approvalId, outcome) ?? false;
+                rpcLog('discord_approval_settled', { approvalId, outcome, settled });
+                // The settle promise IS the confirmation: an in-process resolution
+                // has no wire receipt to doubt.
+                return Promise.resolve(settled ? { outcome: 'confirmed' } : { outcome: 'rejected', reason: 'not-pending' });
             },
         };
         const queueSnapshots = new Map();
@@ -657,10 +744,10 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             rpcLog('discord_guild_forget_deleted', { guildId, channels: plan.channelKeys.length, threads: plan.threadKeys.length });
         };
         const questionRespondPort = {
-            respond: async (input) => {
-                const receipt = await clientRespond.respond(input.rpcId, { sessionId: input.sessionId, answer: input.answer });
-                rpcLog('discord_question_respond_receipt', { rpcId: input.rpcId, receipt });
-                return receipt;
+            respond: (input) => {
+                const settled = hostAsksRef.current?.settleQuestion(input.rpcId, input.answer) ?? false;
+                rpcLog('discord_question_settled', { rpcId: input.rpcId, settled });
+                return Promise.resolve(settled ? { outcome: 'confirmed' } : { outcome: 'rejected', reason: 'not-pending' });
             },
         };
         const questionRoutingDeps = {
@@ -685,10 +772,15 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             handleQuestionComponent: input => handleSelectInput(questionRoutingDeps, input),
             handleQuestionModal: input => handleModalSubmit(questionRoutingDeps, input),
             dsh: {
-                cancel: sessionId => cancelSessionViaProxy(apiProxy, { sessionId }, { log: rpcLog }),
-                steer: (sessionId, prompt) => steerSession(apiProxy, { sessionId, prompt }, { log: rpcLog }),
-                removeQueueItem: (sessionId, itemId) => removeQueueItemViaProxy(apiProxy, { sessionId, itemId }, { log: rpcLog }),
-                readWorkspaceDetail: reference => readWorkspaceDetail(apiProxy, reference, { log: rpcLog }),
+                cancel: sessionId => cancelSessionViaProxy(dsh, { sessionId }, { log: rpcLog }),
+                steer: async (sessionId, prompt) => {
+                    const steered = await steerSession(dsh, { sessionId, prompt }, { log: rpcLog });
+                    if (steered.outcome === 'accepted')
+                        hostEvents.track(sessionId);
+                    return steered;
+                },
+                removeQueueItem: (sessionId, itemId) => removeQueueItemViaProxy(dsh, { sessionId, itemId }, { log: rpcLog }),
+                readWorkspaceDetail: reference => readWorkspaceDetail(dsh, reference, { log: rpcLog }),
             },
             catalogPort,
             resolver,
@@ -701,10 +793,10 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                 await channelTable.delete(bindChannelKey(guildId, channelId));
                 rpcLog('discord_reconcile_channel_retired', { channelId, reason: 'discord-deleted' });
             },
-            model: createModelPort(apiProxy, { log: rpcLog }),
+            model: createModelPort(dsh, { log: rpcLog }),
             modelSelectOperatorOnly: () => current.modelSelectOperatorOnly,
             resumeCandidates: createResumeCandidatesPort({
-                listSessions: () => listSessionSummaries(apiProxy, { log: rpcLog }),
+                listSessions: () => listSessionSummaries(dsh, { log: rpcLog }),
                 boundSessionIds: () => {
                     const bound = new Set();
                     for (const [, record] of threadTable.entries())
@@ -735,7 +827,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                         return { outcome: 'refused-control-channel' };
                     }
                 }
-                const summaries = await listSessionSummaries(apiProxy, { log: rpcLog });
+                const summaries = await listSessionSummaries(dsh, { log: rpcLog });
                 if (summaries.outcome !== 'completed')
                     return { outcome: 'failed' };
                 const summary = summaries.sessions.find(candidate => candidate.sessionId === sessionId);
@@ -786,6 +878,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                     createdAtMs: Date.now(),
                 });
                 rpcLog('discord_session_resumed', { sessionId, threadId: thread.body.id, title });
+                hostEvents.track(sessionId);
                 return { outcome: 'started', threadId: thread.body.id };
             },
             log: rpcLog,
@@ -898,28 +991,15 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
         void registerCommands().catch((cause) => {
             emitLog(ctx, 'warn', { event: 'discord_command_register_failed', cause: String(cause) });
         });
-        // ── Live streaming: DSH events.mux → per-thread Discord rendering ─────
+        // ── Live streaming: host follow/control fan-in → per-thread rendering ──
         // The queue snapshot cache (declared with the interaction router) is the
-        // /queue surface's data source: DSH 0.1.1 has no queue-list RPC, only the
-        // authoritative whole-snapshot mux frame.
-        const threadForSession = (sessionId) => {
-            for (const [key, record] of threadTable.entries()) {
-                if (record.sessionId !== sessionId)
-                    continue;
-                const scope = parseThreadBindingKey(key);
-                if (scope !== undefined)
-                    return scope.threadId;
-            }
-            return undefined;
-        };
+        // /queue surface's data source: the 0.1.6 `session/control` stream owns
+        // the authoritative whole-snapshot queue frames.
+        // The 0.1.6 event bridge: every session the adapter tracks (create,
+        // adopt, resume, prompt) joins one fan-in stream of live frames.
         const liveRef = { current: undefined };
         liveRef.current = startLiveRender({
-            frames: (signal) => {
-                const events = apiProxy.events;
-                if (events === undefined)
-                    throw new TypeError('apiProxy.events is unavailable on this Host');
-                return events.mux({ rpcId: crypto.randomUUID(), payload: {} }, signal);
-            },
+            frames: signal => hostEvents.stream(signal),
             threadForSession,
             delivery: {
                 send: async (request) => {
@@ -998,8 +1078,6 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             },
             updateIntervalMs: current.streamUpdateIntervalMs,
             typingIntervalMs: current.typingIntervalMs,
-            approvalTimeoutMs: current.approvalTimeoutMs,
-            questionTimeoutMs: current.questionTimeoutMs,
             verbosity: current.defaultVerbosity,
             log: rpcLog,
             interruptedMarker: () => copy.interruptedMarker,
@@ -1010,7 +1088,6 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                     turnTracker.complete(turn.requestId);
                 rpcLog('discord_turn_ended', { sessionId, hadActiveTurn: turn !== undefined });
             },
-            requests: askWiring,
         });
         ctx.effect(() => () => { liveRef.current?.dispose(); }, 'dsh-discord live render');
         ctx.effect(() => () => { runtimeRef.current?.dispose(); }, 'dsh-discord composed runtime');

package/lib/settings.js

@@ -1,4 +1,3 @@
-import { installSettingsSection } from '@deepseek-ai/dsh-settings';
 import z from '@deepseek-ai/schemastery';
 import { DISCORD_SETTINGS_NAMESPACE } from './settings-namespace.js';
 export { DISCORD_SETTINGS_NAMESPACE } from './settings-namespace.js';
@@ -92,7 +91,11 @@ export function validateDiscordSettings(input) {
 }
 export function installDiscordSettings(ctx, entry, onChange) {
     let source = () => entry;
-    installSettingsSection(ctx, DISCORD_SETTINGS_NAMESPACE, DiscordSettingsSchema, entry, {
+    const provider = ctx.get('settings');
+    if (provider === undefined || typeof provider.installSection !== 'function') {
+        throw new TypeError('settings provider with installSection is unavailable on this Host');
+    }
+    provider.installSection(ctx, DISCORD_SETTINGS_NAMESPACE, DiscordSettingsSchema, entry, {
         validate: value => { validateDiscordSettings(normalizeDiscordSettings(value)); },
         setSource: current => {
             source = () => normalizeDiscordSettings(current());

package/lib/startup.d.ts

@@ -6,7 +6,7 @@
  * with a single actionable diagnostic naming every gap.
  */
 /** The exact Host service roster the adapter requires (design decision 1). */
-export declare const REQUIRED_HOST_SERVICES: readonly ["apiProxy", "credentials", "settings", "storageDomain", "connection"];
+export declare const REQUIRED_HOST_SERVICES: readonly ["sessionController", "workspaceController", "sessionQuery", "webServer", "credentials", "settings", "storageDomain", "connection"];
 export type HostServiceName = (typeof REQUIRED_HOST_SERVICES)[number];
 /**
  * Validate every required Host capability through `resolveService`, which

package/lib/startup.js

@@ -7,26 +7,33 @@
  */
 /** The exact Host service roster the adapter requires (design decision 1). */
 export const REQUIRED_HOST_SERVICES = [
-    'apiProxy',
+    'sessionController',
+    'workspaceController',
+    'sessionQuery',
+    'webServer',
     'credentials',
     'settings',
     'storageDomain',
     'connection',
 ];
 /**
- * Minimum contract members per service, confirmed against the installed DSH
- * `0.1.1-rc.2` types. A service lacking any member means a version drift the
- * exact peer pin should have prevented; refuse rather than probe at runtime.
+ * Minimum contract members per service, confirmed against the 0.1.6
+ * controller faces (dsh-api-session-controller / dsh-api-workspace-controller
+ * / dsh-session-query). A service lacking any member means a version drift
+ * the startup probe should have refused; refuse rather than probe at runtime.
  */
 const REQUIRED_CONTRACT_MEMBERS = {
-    apiProxy: ['sessions', 'workspace', 'events', 'host'],
+    sessionController: ['prompt', 'create', 'list', 'cancel', 'updateQueue', 'selectModel', 'modelCatalog', 'follow', 'control'],
+    workspaceController: ['follow'],
+    sessionQuery: ['observeSession'],
+    webServer: [],
     credentials: ['resolve', 'describe', 'set', 'unset'],
-    settings: ['register'],
+    settings: ['installSection'],
     storageDomain: ['open'],
     connection: ['rpc'],
 };
 /** Actionable remediation hint appended to every activation failure. */
-const REMEDIATION = 'install @addozhang/dsh-discord into a dsh web profile providing the pinned DSH 0.1.1-rc.2 contracts';
+const REMEDIATION = 'install @addozhang/dsh-discord into a dsh web profile providing the 0.1.6 host controller services';
 function missingMembers(service, required) {
     if (service === undefined || service === null)
         return [...required];

package/lib/stream/live.d.ts

@@ -84,10 +84,6 @@ export interface LiveRenderDeps {
     threadName?: (channelId: string) => Promise<string | undefined>;
     updateIntervalMs: number;
     typingIntervalMs: number;
-    /** Approval ask deadline (approvalTimeoutMs setting). */
-    approvalTimeoutMs: number;
-    /** Question ask deadline (questionTimeoutMs setting). */
-    questionTimeoutMs: number;
     /** Coalescing budget for tool-activity edits (default 1s). */
     activityCoalesceMs?: number;
     verbosity?: DiscordVerbosity;
@@ -101,39 +97,6 @@ export interface LiveRenderDeps {
     interruptedMarker?: () => string;
     /** Turn ownership release on turn/end. */
     onTurnEnded?: (sessionId: string) => void;
-    /**
-     * Answerable server-request frames (interaction-routing spec): approvals
-     * and questions arrive as mux frames with an envelope rpcId the response
-     * must echo. The composition owns rendering, ownership, and expiry.
-     */
-    requests?: {
-        onApprovalRequested(input: {
-            sessionId: string;
-            threadId: string;
-            rpcId: string;
-            approvalId: string;
-            toolName: string;
-            reason?: string | undefined;
-            expiresAtMs: number;
-        }): void;
-        onApprovalResolved(input: {
-            sessionId: string;
-            approvalId: string;
-            outcome?: string | undefined;
-        }): void;
-        onQuestionRequested(input: {
-            sessionId: string;
-            threadId: string;
-            rpcId: string;
-            questions: Array<Record<string, unknown>>;
-            expiresAtMs: number;
-        }): void;
-        onQuestionResolved(input: {
-            sessionId: string;
-            questionRpcId: string;
-            outcome: 'answered' | 'cancelled';
-        }): void;
-    };
 }
 export declare function startLiveRender(deps: LiveRenderDeps): {
     dispose(): void;

package/lib/stream/live.js

@@ -15,6 +15,7 @@ import { createToolActivitySurface } from './tool-view.js';
 import { createAnswerFinalizer } from './finalizer.js';
 import { buildOutboundMessage } from './outbound.js';
 import { toolCategoryIcon } from './icons.js';
+import { shellCommandTitle } from './tool-view.js';
 import { discordChannelNameKey, safeTitle } from '../policy/disclosure.js';
 /** Coalescing budget for activity-message edits under parallel tools. */
 const DEFAULT_ACTIVITY_COALESCE_MS = 1_000;
@@ -313,7 +314,8 @@ export function startLiveRender(deps) {
             case 'tool/call': {
                 if (typeof data['callId'] !== 'string' || typeof data['name'] !== 'string')
                     return;
-                const title = presentationTitle(frameView);
+                const rawArguments = typeof data['arguments'] === 'string' ? data['arguments'] : undefined;
+                const title = presentationTitle(frameView) ?? shellCommandTitle(data['name'], rawArguments);
                 runtime.toolNames.set(data['callId'], data['name']);
                 if (title !== undefined)
                     runtime.toolTitles.set(data['callId'], title);
@@ -322,7 +324,7 @@ export function startLiveRender(deps) {
                     toolName: data['name'],
                     state: 'running',
                     title,
-                    rawArguments: typeof data['arguments'] === 'string' ? data['arguments'] : undefined,
+                    rawArguments,
                 });
                 runtime.activityScheduler?.schedule(renderActivityContent(runtime));
                 return;
@@ -375,7 +377,7 @@ export function startLiveRender(deps) {
             .join(' '), 120);
         return { id, summary: text === '' ? '（非文本消息）' : text };
     }
-    function handleFrame(raw, envelopeRpcId) {
+    function handleFrame(raw) {
         const frame = (typeof raw === 'object' && raw !== null ? raw : {});
         const type = frame['type'];
         const sessionId = typeof frame['sessionId'] === 'string' ? frame['sessionId'] : undefined;
@@ -436,52 +438,8 @@ export function startLiveRender(deps) {
             });
             return;
         }
-        if (type === 'approval/requested') {
-            const threadId = deps.threadForSession(sessionId);
-            if (threadId === undefined || deps.requests === undefined)
-                return;
-            deps.requests.onApprovalRequested({
-                sessionId,
-                threadId,
-                rpcId: envelopeRpcId ?? '',
-                approvalId: typeof frame['approvalId'] === 'string' ? frame['approvalId'] : '',
-                toolName: typeof frame['toolName'] === 'string' ? frame['toolName'] : 'tool',
-                reason: typeof frame['reason'] === 'string' ? frame['reason'] : undefined,
-                expiresAtMs: Date.now() + deps.approvalTimeoutMs,
-            });
-            return;
-        }
-        if (type === 'approval/resolved') {
-            deps.requests?.onApprovalResolved({
-                sessionId,
-                approvalId: typeof frame['approvalId'] === 'string' ? frame['approvalId'] : '',
-                outcome: typeof frame['outcome'] === 'string' ? frame['outcome'] : undefined,
-            });
-            return;
-        }
-        if (type === 'question/requested') {
-            const threadId = deps.threadForSession(sessionId);
-            if (threadId === undefined || deps.requests === undefined)
-                return;
-            const questions = Array.isArray(frame['questions']) ? frame['questions'] : [];
-            deps.requests.onQuestionRequested({
-                sessionId,
-                threadId,
-                rpcId: envelopeRpcId ?? '',
-                questions,
-                expiresAtMs: Date.now() + deps.questionTimeoutMs,
-            });
-            return;
-        }
-        if (type === 'question/resolved') {
-            const outcome = frame['outcome'] === 'cancelled' ? 'cancelled' : 'answered';
-            deps.requests?.onQuestionResolved({
-                sessionId,
-                questionRpcId: typeof frame['questionRpcId'] === 'string' ? frame['questionRpcId'] : '',
-                outcome,
-            });
-            return;
-        }
+        // Answerable asks no longer ride the frame stream: the 0.1.6 host routes
+        // them through the composed-answerer waterfalls (src/dsh/host-asks.ts).
         if (type !== 'session/event')
             return;
         const threadId = deps.threadForSession(sessionId);
@@ -508,18 +466,12 @@ export function startLiveRender(deps) {
                     if (isDisposed())
                         return;
                     try {
-                        const envelopeRpcId = (typeof frame === 'object' && frame !== null && 'rpcId' in frame)
-                            ? frame.rpcId
-                            : undefined;
-                        const payload = (typeof frame === 'object' && frame !== null && 'payload' in frame)
-                            ? frame.payload
-                            : frame;
                         if (TRACE) {
-                            const t = (typeof payload === 'object' && payload !== null ? payload.type : undefined);
-                            const sid = (typeof payload === 'object' && payload !== null ? payload.sessionId : undefined);
+                            const t = (typeof frame === 'object' && frame !== null ? frame.type : undefined);
+                            const sid = (typeof frame === 'object' && frame !== null ? frame.sessionId : undefined);
                             trace('frame', String(t), String(sid));
                         }
-                        handleFrame(payload, typeof envelopeRpcId === 'string' ? envelopeRpcId : undefined);
+                        handleFrame(frame);
                     }
                     catch (cause) {
                         deps.log?.('discord_live_frame_threw', { cause: String(cause) });