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

package/lib/features/adapter-status.js

@@ -95,9 +95,105 @@ export function createAdapterManagementHandler(deps) {
         return Promise.resolve({ ok: false, error: { code: 'bad-request', message: `Unknown ${DISCORD_RPC_CHANNEL} endpoint.` } });
     };
 }
-/** Register the management channel; returns the connection service's disposer. */
-export function installAdapterStatusRpc(connection, tracker, deps = { tracker }) {
-    return connection.rpc.handle(DISCORD_RPC_CHANNEL, createAdapterManagementHandler(deps), {
-        authority: 'loopback',
+function readBody(request) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        request.on('data', chunk => { chunks.push(chunk); });
+        request.on('end', () => { resolve(Buffer.concat(chunks).toString('utf8')); });
+        request.on('error', reject);
     });
 }
+/** The endpoint segment path under the channel, validated like the host's. */
+function endpointOf(channel, url) {
+    const pathname = url === undefined ? '' : url.split('?')[0] ?? '';
+    if (!pathname.startsWith(`${channel}/`))
+        return undefined;
+    const endpoint = pathname.slice(channel.length + 1);
+    const valid = endpoint.split('/').every(segment => segment !== '' && segment !== '.' && segment !== '..' && /^[A-Za-z0-9_$.-]+$/.test(segment));
+    return valid ? endpoint : undefined;
+}
+function respondEnvelope(response, rpcId, result) {
+    response.writeHead(200, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ type: 'server-response', rpcId, result }));
+}
+function badRequest(response, rpcId, message) {
+    respondEnvelope(response, rpcId, { ok: false, error: { code: 'gateway/bad-request', message, details: { issues: [] } } });
+}
+/**
+ * Serve one channel request: the connection service's fence first (the
+ * browser-auth + trusted-host verdict), then the host's channel wire
+ * protocol — POST + JSON `client-request` envelope whose method must match
+ * the endpoint, answered with a `server-response` envelope.
+ */
+async function serveChannel(connection, handler, request, response) {
+    const rejection = connection.requestRejection(request);
+    if (rejection !== undefined) {
+        response.writeHead(rejection);
+        response.end(rejection === 401 ? 'unauthorized' : 'forbidden');
+        return;
+    }
+    const endpoint = endpointOf(DISCORD_RPC_CHANNEL, request.url);
+    if (request.method !== 'POST' || endpoint === undefined) {
+        response.writeHead(404);
+        response.end('not found');
+        return;
+    }
+    const contentType = request.headers['content-type'];
+    const contentTypeText = (Array.isArray(contentType) ? contentType[0] : contentType)?.split(';', 1)[0]?.trim().toLowerCase();
+    if (contentTypeText !== 'application/json') {
+        response.writeHead(415);
+        response.end('content type must be application/json');
+        return;
+    }
+    let body;
+    try {
+        body = JSON.parse(await readBody(request));
+    }
+    catch {
+        response.writeHead(400);
+        response.end('body is not JSON');
+        return;
+    }
+    const message = body;
+    const rpcId = typeof message.rpcId === 'string' ? message.rpcId : '';
+    if (message.type !== 'client-request' || rpcId === '' || typeof message.method !== 'string'
+        || typeof message.payload !== 'object' || message.payload === null || Array.isArray(message.payload)) {
+        badRequest(response, rpcId, 'invalid client-request message');
+        return;
+    }
+    if (message.method !== endpoint) {
+        badRequest(response, rpcId, `method ${JSON.stringify(message.method)} does not match endpoint ${JSON.stringify(endpoint)}`);
+        return;
+    }
+    try {
+        const result = await handler(endpoint, message.payload, undefined);
+        respondEnvelope(response, rpcId, result);
+    }
+    catch (cause) {
+        response.writeHead(500);
+        response.end(`handler failure: ${String(cause)}`);
+    }
+}
+/**
+ * Register the management channel on the webServer through the plugin's own
+ * context effect. The 0.1.6 host's `connection.rpc.handle` mounts through
+ * the connection service's OWN inject scope — an external plugin's call is
+ * rejected ("cannot get property webServer without inject") and a runtime
+ * ctx.inject wrapper never fires on an already-started plugin, so the
+ * sanctioned shape is: our prefix route, the connection service's fence
+ * method, and the channel envelope replicated verbatim.
+ */
+export function installAdapterStatusRpc(ctx, tracker, deps = { tracker }) {
+    const connection = ctx.get('connection');
+    const webServer = ctx.get('webServer');
+    const handler = createAdapterManagementHandler(deps);
+    const disposer = ctx.effect(() => webServer.register({
+        kind: 'prefix',
+        path: DISCORD_RPC_CHANNEL,
+        handler: (request, response) => serveChannel(connection, handler, request, response),
+    }), 'dsh-discord management channel');
+    return () => {
+        if (typeof disposer === 'function')
+            disposer();
+    };
+}

package/lib/features/approval-store.d.ts

@@ -68,7 +68,7 @@ export interface ApprovalClick {
 }
 export type ApprovalDecision = {
     allowed: true;
-    /** Respond data built solely from the record, for apiProxy.respond. */
+    /** Respond data built solely from the record, for the settle port. */
     respond: {
         rpcId: string;
         sessionId: string;

package/lib/features/interaction-router.d.ts

@@ -11,7 +11,7 @@ import type { SharedRestClient } from '../discord/rest.js';
 import { type PolicyTable } from '../policy/authorization.js';
 import { type ProjectListPort } from './project-list.js';
 import type { WorkspaceResolver } from './project-bind.js';
-import type { CancelOutcome, PromptOutcome, QueueRemoveOutcome, WorkspaceDetailOutcome } from '../dsh/api-proxy-face.js';
+import type { CancelOutcome, PromptOutcome, QueueRemoveOutcome, WorkspaceDetailOutcome } from '../dsh/host-face.js';
 import type { TurnTracker } from './turn-ownership.js';
 import { type DshApprovalRespondPort } from './approval-routing.js';
 import { type DshModelPort } from './model-control.js';
@@ -20,7 +20,7 @@ import type { ApprovalStore } from './approval-store.js';
 import type { ChannelBinding } from '../state/records.js';
 import type { NormalizedInteraction } from '../gateway/inbound.js';
 import type { CopyTable } from '../i18n.js';
-/** The DSH faces the control commands submit through (apiProxy-backed). */
+/** The DSH faces the control commands submit through (host-face-backed). */
 export interface InteractionDshFace {
     cancel(sessionId: string): Promise<CancelOutcome>;
     steer(sessionId: string, prompt: string): Promise<PromptOutcome>;

package/lib/features/model-control.d.ts

@@ -11,7 +11,7 @@
  * any mutation.
  */
 import type { AccessDecision } from '../policy/authorization.js';
-import type { ModelSelectionShape, SessionModelsShape } from '../dsh/api-proxy-face.js';
+import type { ModelSelectionShape, SessionModelsShape } from '../dsh/host-face.js';
 export interface DshModelPort {
     models(sessionId: string): Promise<{
         outcome: 'completed';

package/lib/features/project-list.d.ts

@@ -1,6 +1,6 @@
 /**
  * `/project list` discovery (design.md §3, §13). The feature talks to DSH
- * through one narrow port (satisfied by the apiProxy adapter in production,
+ * through one narrow port (satisfied by the host-face adapter in production,
  * by fakes in tests): every registered Workspace is selectable, labels come
  * from the least-disclosure policy (safe titles, opaque `ws:` references,
  * duplicate disambiguation); per amended design §3 the bind autocomplete

package/lib/features/project-list.js

@@ -1,6 +1,6 @@
 /**
  * `/project list` discovery (design.md §3, §13). The feature talks to DSH
- * through one narrow port (satisfied by the apiProxy adapter in production,
+ * through one narrow port (satisfied by the host-face adapter in production,
  * by fakes in tests): every registered Workspace is selectable, labels come
  * from the least-disclosure policy (safe titles, opaque `ws:` references,
  * duplicate disambiguation); per amended design §3 the bind autocomplete

package/lib/features/session-resume.d.ts

@@ -6,7 +6,7 @@
  * title/id substring, and sort newest-first — Discord autocomplete caps at
  * 25 choices, the caller slices.
  */
-import type { SessionResumeRow } from '../dsh/api-proxy-face.js';
+import type { SessionResumeRow } from '../dsh/host-face.js';
 export type { SessionResumeRow };
 import type { CopyTable } from '../i18n.js';
 import { type SelectorOption } from '../discord/selector.js';

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';
@@ -37,7 +38,7 @@ import { planWorkspaceChannel, workspaceChannelName } from './features/workspace
 /** 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
@@ -75,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({}, {
@@ -102,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) => {
@@ -118,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
@@ -133,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],
@@ -180,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);
@@ -284,14 +293,24 @@ 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,
-                ...(request.images === undefined ? {} : { images: request.images }),
-            }, { 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
@@ -383,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
@@ -537,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;
@@ -670,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();
@@ -694,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 = {
@@ -722,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,
@@ -738,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())
@@ -772,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);
@@ -823,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,
@@ -935,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) => {
@@ -1035,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,
@@ -1047,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;