dsh-plugin-mobile-gateway 0.7.0 → 0.7.2

package/lib/index.mjs

@@ -6,7 +6,7 @@
 //     feed the browser UI consumes) to connected mobile clients as curated
 //     JSON text frames.
 //  2. Mobile -> agent: clients send a message through the same socket; the
-//     plugin admits it through the official host API (apiProxy.sessions.prompt)
+//     plugin admits it through the DSH Remote Gateway Host API.
 //     so it enters the target session exactly like a browser-submitted prompt.
 //
 // Wire protocol (JSON text frames):
@@ -45,6 +45,12 @@
 //                     { "type": "directory-create", "path", "name" } -> create one child directory
 //                     { "type": "workspace-create", "path" }       -> create workspace over a dir
 //                     { "type": "fork", "sessionId", "atSeq"? }    -> branch a new session from a completed turn
+//                     { "type": "session-cancel", "sessionId" }     -> stop the active turn and retain queued work
+//                     { "type": "queue-update", "sessionId", "itemId",
+//                       "action": "edit"|"remove"|"steer", "text"? }
+//                        -> edit/remove one pending item or move it into the current turn
+//                     { "type": "session-archive", "sessionId" }    -> hide a session from workspace surfaces
+//                     { "type": "session-rename", "sessionId", "title" } -> persist a user-owned session title
 //                     { "type": "models", "sessionId"? }           -> per-session catalog (with sessionId) or global (without)
 //                     { "type": "providers" }                       -> configurable provider list (live/dormant)
 //                     { "type": "commands", "sessionId" }          -> slash-command catalog for this session
@@ -68,7 +74,7 @@
 //                     { "type": "question-cancel", "rpcId", "sessionId" }
 //                     { "type": "approval-response", "rpcId", "sessionId", "approvalId",
 //                       "outcome": "allowed-once"|"rejected" }
-//   server -> client: { "kind": "hello", "protocol": 3, "capabilities": ["images", "commands", "tasks", "goals", "file-downloads"],
+//   server -> client: { "kind": "hello", "protocol": 3, "capabilities": ["images", "commands", "tasks", "goals", "session-cancel", "queue-control", "session-archive", "session-rename", "file-downloads"],
 //                       "authenticated", "device"?, "port", "clients" }
 //                     { "kind": "pong", "at" }
 //                     { "kind": "subscribed", "sessionId" }
@@ -88,6 +94,14 @@
 //                       "path", "name", "mediaType", "size", "chunkBytes" }
 //                     { "kind": "file-download-chunk", "transferId", "offset", "data", "eof", "sha256"? }
 //                     { "kind": "file-download-cancelled", "transferId" }
+//                     { "kind": "session-cancelled", "sessionId", "accepted": true }
+//                     { "kind": "queue-item-updated", "sessionId", "itemId", "action", "accepted": true }
+//                     { "kind": "session-queues", "queues": { "<sessionId>": [...] } }
+//                     { "kind": "session-queue", "sessionId", "items": [...] }
+//                     { "kind": "session-archived", "sessionId", "archivedSessionIds" }
+//                     { "kind": "session-renamed", "sessionId", "title", "seq" }
+//                     { "kind": "session-archives", "archivedSessionIds" }
+//                     { "kind": "session-title-changed", "sessionId", "title", "seq", "time", "source"? }
 //                     { "kind": "error", "code", "message", "requestType"?, "sessionId"? }
 //                     { "kind": "event", "sessionId", "seq", "time", "event": { ... } }
 //                     { "kind": "tasks", "sessionId", "asOfSeq", "todos" }
@@ -114,6 +128,7 @@ import crypto from 'node:crypto'
 import Schema from '@deepseek-ai/schemastery'
 import { WebSocketServer } from 'ws'
 import devicesModule from './devices.js'
+import { createDshHostAdapter } from './dsh-host-adapter.mjs'
 import QRCode from 'qrcode'
 
 const { createRegistry } = devicesModule
@@ -283,6 +298,14 @@ function buildWireEvent(session, event) {
         event: { type: 'assistant/message', turn: d.turn, step: d.step, text, reasoning, toolCalls, ...(images.length ? { images } : {}) },
       })
     }
+    case 'session/title':
+      return Object.assign(base, {
+        event: {
+          type: 'session/title',
+          title: d.title,
+          ...(d.source ? { source: d.source } : {}),
+        },
+      })
     case 'tool/call':
       return Object.assign(base, {
         event: { type: 'tool/call', turn: d.turn, step: d.step, callId: d.callId, name: d.name, arguments: d.arguments },
@@ -407,25 +430,15 @@ function commandNameOf(line) {
   return (end === -1 ? trimmed.slice(1) : trimmed.slice(1, end)) || null
 }
 
-async function listHostCommands(typertGateway, sessionId) {
-  const listed = await typertGateway.invoke({
-    namespace: 'commands',
-    method: 'list',
-    args: { agentId: sessionId },
-    signal: new AbortController().signal,
-  })
+async function listHostCommands(host, sessionId) {
+  const listed = await host.commands.list(sessionId, new AbortController().signal)
   if (!Array.isArray(listed)) throw new Error('commands/list returned an invalid catalog')
   return listed
 }
 
-async function executeHostCommand(typertGateway, sessionId, line, images, requestType) {
+async function executeHostCommand(host, sessionId, line, images, requestType) {
   try {
-    const execution = await typertGateway.invoke({
-      namespace: 'commands',
-      method: 'execute',
-      args: { agentId: sessionId, line, images },
-      signal: new AbortController().signal,
-    })
+    const execution = await host.commands.execute(sessionId, line, images, new AbortController().signal)
     if (execution === undefined || execution === null) {
       return { kind: 'error', code: 'unknown-command', message: `unknown or malformed command: ${line}`, requestType, sessionId }
     }
@@ -445,7 +458,7 @@ async function executeHostCommand(typertGateway, sessionId, line, images, reques
   }
 }
 
-async function admitCommand(typertGateway, msg) {
+async function admitCommand(host, msg) {
   const sessionId = requireSessionId(msg)
   if (sessionId.error) return sessionId.error
   const line = typeof msg.line === 'string' ? msg.line.trim() : ''
@@ -456,7 +469,7 @@ async function admitCommand(typertGateway, msg) {
   const parsedImages = parseWireImages(msg.images, 'command-execute')
   if (parsedImages.error) return { ...parsedImages.error, sessionId: sessionId.value }
   try {
-    const listed = await listHostCommands(typertGateway, sessionId.value)
+    const listed = await listHostCommands(host, sessionId.value)
     const descriptor = listed.find((command) => command && command.name === name)
     if (!descriptor) {
       return { kind: 'error', code: 'unknown-command', message: `command not found: /${name}`, requestType: 'command-execute', sessionId: sessionId.value }
@@ -464,7 +477,7 @@ async function admitCommand(typertGateway, msg) {
     if (parsedImages.value.length > 0 && descriptor.input?.images !== true) {
       return { kind: 'error', code: 'bad-request', message: `/${name} does not accept image attachments`, requestType: 'command-execute', sessionId: sessionId.value }
     }
-    return executeHostCommand(typertGateway, sessionId.value, line, parsedImages.value, 'command-execute')
+    return executeHostCommand(host, sessionId.value, line, parsedImages.value, 'command-execute')
   } catch (error) {
     const code = error && error.code ? error.code : 'internal'
     const message = error && error.message ? error.message : String(error)
@@ -497,44 +510,30 @@ async function admitMessage(api, msg) {
         if (createPayload.workspaceId) log('mobile message: both workspaceId and cwd given, using workspaceId')
         else createPayload.cwd = msg.cwd.trim()
       }
-      const created = await api.sessions.create({ rpcId: crypto.randomUUID(), payload: createPayload })
-      if (!created.result.ok) {
-        return { kind: 'error', code: created.result.error.code, message: created.result.error.message }
-      }
-      sessionId = created.result.value.sessionId
+      const created = await api.sessions.create(createPayload)
+      sessionId = created.sessionId
       log(`mobile message created new session ${sessionId} (${JSON.stringify(createPayload)})`)
     }
 
     const resp = await api.sessions.prompt({
-      rpcId: crypto.randomUUID(),
-      payload: {
-        sessionId,
-        mode,
-        // Match the official WebUI ordering: images first, optional text last.
-        content: [...imageParts, ...(text ? [{ type: 'text', text }] : [])],
-        ...(typeof msg.clientTimeZone === 'string' && msg.clientTimeZone.trim() ? { clientTimeZone: msg.clientTimeZone.trim() } : {}),
-      },
+      sessionId,
+      mode,
+      // Match the official WebUI ordering: images first, optional text last.
+      content: [...imageParts, ...(text ? [{ type: 'text', text }] : [])],
+      ...(typeof msg.clientTimeZone === 'string' && msg.clientTimeZone.trim() ? { clientTimeZone: msg.clientTimeZone.trim() } : {}),
     })
-    if (resp.result.ok) {
-      log(`mobile message accepted: session=${sessionId} mode=${mode} images=${imageParts.length} text="${text.slice(0, 60)}"`)
-      return {
-        kind: 'sent',
-        sessionId,
-        mode,
-        ...(resp.result.value.command ? { command: resp.result.value.command } : {}),
-      }
-    }
-    log(`mobile message rejected: ${resp.result.error.code}: ${resp.result.error.message}`)
+    log(`mobile message accepted: session=${sessionId} mode=${mode} images=${imageParts.length} text="${text.slice(0, 60)}"`)
     return {
-      kind: 'error',
-      code: resp.result.error.code,
-      message: resp.result.error.message,
-      ...(sessionId ? { sessionId } : {}),
+      kind: 'sent',
+      sessionId,
+      mode,
+      ...(resp.command ? { command: resp.command } : {}),
     }
   } catch (error) {
+    const code = error && error.code ? error.code : 'internal'
     const message = error && error.message ? error.message : String(error)
     log(`mobile message failed: ${message}`)
-    return { kind: 'error', code: 'internal', message, ...(sessionId ? { sessionId } : {}) }
+    return { kind: 'error', code, message, ...(sessionId ? { sessionId } : {}) }
   }
 }
 
@@ -543,23 +542,17 @@ async function admitMessage(api, msg) {
 // the uniform `{ kind: 'error', code, message, requestType }` frame.
 async function proxyQuery(api, type, method, payload, signal) {
   try {
-    const req = { rpcId: crypto.randomUUID(), payload }
-    const resp = signal ? await method(req, signal) : await method(req)
-    if (resp.result.ok) {
-      log(`query ok: ${type}`)
-      return { kind: type, ...resp.result.value }
-    }
-    log(`query rejected: ${type} -> ${resp.result.error.code}: ${resp.result.error.message}`)
-    return {
-      kind: 'error',
-      code: resp.result.error.code,
-      message: resp.result.error.message,
-      requestType: type,
+    const value = signal ? await method(payload, signal) : await method(payload)
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+      throw new Error(`${type} returned an invalid response`)
     }
+    log(`query ok: ${type}`)
+    return { kind: type, ...value }
   } catch (error) {
+    const code = error && error.code ? error.code : 'internal'
     const message = error && error.message ? error.message : String(error)
-    log(`query failed: ${type} -> ${message}`)
-    return { kind: 'error', code: 'internal', message, requestType: type }
+    log(`query failed: ${type} -> ${code}: ${message}`)
+    return { kind: 'error', code, message, requestType: type }
   }
 }
 
@@ -1190,7 +1183,7 @@ async function loadCommandOptions(api, command, sessionId) {
   }
 }
 
-async function selectCommandOption(api, typertGateway, command, sessionId, optionId) {
+async function selectCommandOption(api, host, command, sessionId, optionId) {
   const catalog = await loadCommandOptions(api, command, sessionId)
   if (catalog.kind !== 'command-options') return catalog
   const option = catalog.options.find((candidate) => candidate.id === optionId)
@@ -1206,12 +1199,12 @@ async function selectCommandOption(api, typertGateway, command, sessionId, optio
 
   if (command === 'permission') {
     try {
-      const execution = await typertGateway.invoke({
-        namespace: 'commands',
-        method: 'execute',
-        args: { agentId: sessionId, line: '/permission ' + optionId, images: [] },
-        signal: new AbortController().signal,
-      })
+      const execution = await host.commands.execute(
+        sessionId,
+        '/permission ' + optionId,
+        [],
+        new AbortController().signal,
+      )
       if (!execution || !execution.result) throw new Error('permission command returned an invalid result')
       if (execution.result.kind === 'error') {
         return { kind: 'error', code: 'command-error', message: execution.result.text, requestType: 'command-select', sessionId }
@@ -1256,7 +1249,20 @@ async function selectCommandOption(api, typertGateway, command, sessionId, optio
 }
 
 // Dispatch one mobile query frame; returns the wire frame to send back.
-async function handleQuery(api, typertGateway, agentDefaultModel, msg) {
+async function handleQuery(api, host, agentDefaultModel, msg) {
+  if (msg.type === 'session-create') {
+    if (typeof msg.requestId !== 'string' || !msg.requestId.trim()) {
+      return { kind: 'error', code: 'bad-request', message: 'session-create requires a requestId', requestType: 'session-create' }
+    }
+    const payload = {}
+    if (typeof msg.workspaceId === 'string' && msg.workspaceId.trim()) {
+      payload.workspaceId = msg.workspaceId.trim()
+    } else if (typeof msg.cwd === 'string' && msg.cwd.trim()) {
+      payload.cwd = msg.cwd.trim()
+    }
+    const frame = await proxyQuery(api, 'session-created', api.sessions.create.bind(api.sessions), payload)
+    return { ...frame, ...(frame.kind === 'error' ? { requestType: 'session-create' } : {}), requestId: msg.requestId }
+  }
   if (msg.type === 'workspaces') {
     return proxyQuery(api, 'workspaces', api.workspace.list.bind(api.workspace), {})
   }
@@ -1360,6 +1366,96 @@ async function handleQuery(api, typertGateway, agentDefaultModel, msg) {
     }
     return frame
   }
+  if (msg.type === 'session-cancel') {
+    const sessionId = requireSessionId(msg)
+    if (sessionId.error) return sessionId.error
+    const frame = await proxyQuery(
+      api,
+      'session-cancel',
+      api.sessions.cancel.bind(api.sessions),
+      { sessionId: sessionId.value },
+    )
+    if (frame.kind === 'error') return { ...frame, sessionId: sessionId.value }
+    return { ...frame, kind: 'session-cancelled', sessionId: sessionId.value }
+  }
+  if (msg.type === 'queue-update') {
+    const sessionId = requireSessionId(msg)
+    if (sessionId.error) return sessionId.error
+    const itemId = typeof msg.itemId === 'string' && msg.itemId.trim() ? msg.itemId.trim() : null
+    const actionKind = typeof msg.action === 'string' ? msg.action.trim() : ''
+    if (!itemId || !['edit', 'remove', 'steer'].includes(actionKind)) {
+      return {
+        kind: 'error',
+        code: 'bad-request',
+        message: 'queue-update requires itemId and action edit, remove, or steer',
+        requestType: 'queue-update',
+        sessionId: sessionId.value,
+      }
+    }
+    let action
+    if (actionKind === 'edit') {
+      if (typeof msg.text !== 'string' || !msg.text.trim()) {
+        return {
+          kind: 'error',
+          code: 'bad-request',
+          message: 'queue-update edit requires non-empty text',
+          requestType: 'queue-update',
+          sessionId: sessionId.value,
+          itemId,
+        }
+      }
+      action = { kind: 'edit', content: [{ type: 'text', text: msg.text }] }
+    } else {
+      action = { kind: actionKind }
+    }
+    const frame = await proxyQuery(
+      api,
+      'queue-update',
+      api.sessions.updateQueue.bind(api.sessions),
+      { sessionId: sessionId.value, itemId, action },
+    )
+    if (frame.kind === 'error') return { ...frame, sessionId: sessionId.value, itemId }
+    return {
+      ...frame,
+      kind: 'queue-item-updated',
+      sessionId: sessionId.value,
+      itemId,
+      action: actionKind,
+    }
+  }
+  if (msg.type === 'session-archive') {
+    const sessionId = requireSessionId(msg)
+    if (sessionId.error) return sessionId.error
+    const frame = await proxyQuery(
+      api,
+      'session-archive',
+      api.workspace.archiveSession.bind(api.workspace),
+      { sessionId: sessionId.value },
+    )
+    if (frame.kind === 'error') return { ...frame, sessionId: sessionId.value }
+    return { ...frame, kind: 'session-archived', sessionId: sessionId.value }
+  }
+  if (msg.type === 'session-rename') {
+    const sessionId = requireSessionId(msg)
+    if (sessionId.error) return sessionId.error
+    if (typeof msg.title !== 'string' || !msg.title.trim()) {
+      return {
+        kind: 'error',
+        code: 'bad-request',
+        message: 'session-rename requires a non-empty title',
+        requestType: 'session-rename',
+        sessionId: sessionId.value,
+      }
+    }
+    const frame = await proxyQuery(
+      api,
+      'session-rename',
+      api.sessions.rename.bind(api.sessions),
+      { sessionId: sessionId.value, title: msg.title },
+    )
+    if (frame.kind === 'error') return { ...frame, sessionId: sessionId.value }
+    return { ...frame, kind: 'session-renamed', sessionId: sessionId.value }
+  }
   if (msg.type === 'workspace-create') {
     const wsPath = typeof msg.path === 'string' && msg.path.trim() !== '' ? msg.path.trim() : null
     if (!wsPath) {
@@ -1386,7 +1482,7 @@ async function handleQuery(api, typertGateway, agentDefaultModel, msg) {
     return proxyQuery(api, 'providers', api.llm.providers.bind(api.llm), {})
   }
   if (msg.type === 'command-execute') {
-    return admitCommand(typertGateway, msg)
+    return admitCommand(host, msg)
   }
   if (msg.type === 'commands') {
     const sessionId = requireSessionId(msg)
@@ -1398,7 +1494,7 @@ async function handleQuery(api, typertGateway, agentDefaultModel, msg) {
       // the mobile wire. The Web UI also contributes /model client-side; expose
       // the equivalent action here so mobile clients can render the same menu.
       const [listed, skillFrame] = await Promise.all([
-        listHostCommands(typertGateway, sessionId.value),
+        listHostCommands(host, sessionId.value),
         api.skills && typeof api.skills.list === 'function'
           ? proxyQuery(api, 'skills', api.skills.list.bind(api.skills), { sessionId: sessionId.value })
           : Promise.resolve({ kind: 'error', code: 'unsupported', message: 'skill catalog is unavailable', requestType: 'skills' }),
@@ -1476,7 +1572,7 @@ async function handleQuery(api, typertGateway, agentDefaultModel, msg) {
     const command = typeof msg.command === 'string' && msg.command.trim() !== '' ? msg.command.trim() : null
     const optionId = typeof msg.optionId === 'string' && msg.optionId !== '' ? msg.optionId : null
     if (!command || !optionId) return { kind: 'error', code: 'bad-request', message: 'command-select requires command and optionId', requestType: 'command-select', sessionId: sessionId.value }
-    return selectCommandOption(api, typertGateway, command, sessionId.value, optionId)
+    return selectCommandOption(api, host, command, sessionId.value, optionId)
   }
   if (msg.type === 'select-model') {
     const sessionId = requireSessionId(msg)
@@ -1518,14 +1614,14 @@ async function handleQuery(api, typertGateway, agentDefaultModel, msg) {
     // command registry handler WITHOUT sending anything to the model, and the
     // api-remotes agent lookup resumes cold sessions just like prompt does.
     try {
-      const execution = await typertGateway.invoke({
-        namespace: 'commands',
-        method: 'execute',
-        // commands/execute 的当前 Typert descriptor 要求 images 字段始终存在；
-        // 权限斜杠命令没有附件，因此显式传空数组。
-        args: { agentId: sessionId.value, line: '/permission ' + name, images: [] },
-        signal: new AbortController().signal,
-      })
+      // commands/execute 的当前 Typert descriptor 要求 images 字段始终存在；
+      // 权限斜杠命令没有附件，因此显式传空数组。
+      const execution = await host.commands.execute(
+        sessionId.value,
+        '/permission ' + name,
+        [],
+        new AbortController().signal,
+      )
       if (execution === undefined || execution === null) {
         return { kind: 'error', code: 'unknown-command', message: 'command not found: /permission', requestType: 'permission', sessionId: sessionId.value }
       }
@@ -1863,16 +1959,16 @@ const plugin = {
   name: 'mobile-gateway',
   Config,
   // Hard dependencies: the gateway registers on the host web server and
-  // admits mobile messages through the host API gateway. Cordis must not
+  // admits mobile messages through the Host Remote Gateway. Cordis must not
   // activate this row before either service exists.
-  inject: ['webServer', 'apiProxy', 'typertGateway', 'agentDefaultModel'],
+  inject: ['webServer', 'typertGateway', 'agentDefaultModel'],
   // exported for local tests; Cordis ignores unknown plugin fields
   admitMessage,
   handleQuery,
   apply(ctx, config) {
     const webServer = ctx.webServer
-    const api = ctx.apiProxy
-    const typertGateway = ctx.typertGateway
+    const api = createDshHostAdapter(ctx.typertGateway)
+    const host = api
     const agentDefaultModel = ctx.agentDefaultModel
     const options = {
       path: DEFAULT_WS_PATH,
@@ -1929,7 +2025,9 @@ const plugin = {
         log(`file download expiry failed: ${error && error.message ? error.message : String(error)}`)
       })
     }, Math.min(options.fileDownloadIdleMs, 30_000))
-    const interactionMuxAbort = new AbortController()
+    const backgroundStreamAbort = new AbortController()
+    let archivedSessionIds = null
+    let sessionQueues = null
     let counter = 0
     let gatewayEnabled = options.gatewayEnabled === true
     let waitExpiresAt = null
@@ -2013,12 +2111,25 @@ const plugin = {
     const broadcastInteractionFrame = (frame) => {
       const wire = JSON.stringify(frame)
       for (const client of clients) {
+        if (client.mobileChannel === 'conversation') continue
         if (client.filterSessionId && client.filterSessionId !== frame.sessionId) continue
         if (client.readyState === 1) client.send(wire)
       }
     }
 
+    // Session-list metadata must reach every connected client even when it is
+    // subscribed to one conversation. Subscriptions only scope the heavier
+    // conversation and interaction streams.
+    const broadcastSessionMetadataFrame = (frame) => {
+      const wire = JSON.stringify(frame)
+      for (const client of clients) {
+        if (client.mobileChannel === 'conversation') continue
+        if (client.readyState === 1) client.send(wire)
+      }
+    }
+
     const replayPendingInteractions = (ws, trigger) => {
+      if (ws.mobileChannel === 'conversation') return { questionCount: 0, approvalCount: 0 }
       let questionCount = 0
       let approvalCount = 0
       for (const pending of pendingQuestions.values()) {
@@ -2035,6 +2146,97 @@ const plugin = {
       return { questionCount, approvalCount }
     }
 
+    const hasInteractionClient = (sessionId) => [...clients].some((client) => (
+      client.readyState === 1
+      && client.mobileChannel !== 'conversation'
+      && (!client.filterSessionId || client.filterSessionId === sessionId)
+    ))
+
+    const completeQuestion = (pending, action, answer, cancellationCode = 'ASK_CANCELLED') => {
+      if (pendingQuestions.get(pending.rpcId) !== pending) return false
+      pendingQuestions.delete(pending.rpcId)
+      pending.cleanup()
+      if (action === 'answer') pending.resolve(answer)
+      else {
+        const error = new Error('question cancelled by mobile user')
+        error.name = 'UserQuestionError'
+        error.code = cancellationCode
+        pending.reject(error)
+      }
+      broadcastInteractionFrame({
+        kind: 'question-resolved',
+        rpcId: pending.rpcId,
+        sessionId: pending.sessionId,
+        outcome: action === 'answer' ? 'answered' : 'cancelled',
+      })
+      return true
+    }
+
+    const normalizeQuestionAnswers = (pending, answers) => {
+      if (answers.length !== pending.questions.length) return { error: 'answers must cover every question exactly once' }
+      const normalized = []
+      for (let index = 0; index < pending.questions.length; index += 1) {
+        const question = pending.questions[index]
+        const answer = answers[index]
+        if (!answer || typeof answer !== 'object' || answer.id !== question.id || !Array.isArray(answer.selected)) {
+          return { error: 'answers must preserve question order, ids, and selected arrays' }
+        }
+        if (answer.selected.some((label) => typeof label !== 'string')) return { error: 'selected values must be strings' }
+        if (new Set(answer.selected).size !== answer.selected.length) return { error: 'selected values must not repeat' }
+        const offered = new Set((question.options || []).map((option) => option.label))
+        if (answer.selected.some((label) => !offered.has(label))) return { error: 'selected values must match offered option labels' }
+        if (question.multiSelect !== true && answer.selected.length > 1) return { error: 'single-select questions accept at most one selection' }
+        let custom
+        if (answer.custom !== undefined) {
+          if (typeof answer.custom !== 'string' || !answer.custom.trim()) return { error: 'custom answers must be non-empty strings' }
+          custom = answer.custom.trim()
+        }
+        if (question.multiSelect !== true && custom !== undefined && answer.selected.length > 0) {
+          return { error: 'single-select custom answers cannot accompany a selection' }
+        }
+        normalized.push({ id: answer.id, selected: [...answer.selected], ...(custom === undefined ? {} : { custom }) })
+      }
+      return { value: { answers: normalized } }
+    }
+
+    const completeApproval = (pending, outcome) => {
+      if (pendingApprovals.get(pending.rpcId) !== pending) return false
+      pendingApprovals.delete(pending.rpcId)
+      pending.cleanup()
+      pending.resolve(outcome)
+      broadcastInteractionFrame({
+        kind: 'approval-resolved',
+        rpcId: pending.rpcId,
+        sessionId: pending.sessionId,
+        approvalId: pending.approvalId,
+        outcome,
+      })
+      return true
+    }
+
+    const fallbackQuestion = (pending) => {
+      if (pendingQuestions.get(pending.rpcId) !== pending) return
+      pendingQuestions.delete(pending.rpcId)
+      pending.cleanup()
+      Promise.resolve().then(pending.next).then(pending.resolve, pending.reject)
+    }
+
+    const fallbackApproval = (pending) => {
+      if (pendingApprovals.get(pending.rpcId) !== pending) return
+      pendingApprovals.delete(pending.rpcId)
+      pending.cleanup()
+      Promise.resolve().then(pending.next).then(pending.resolve, pending.reject)
+    }
+
+    const releaseUnclaimedInteractions = () => {
+      for (const pending of [...pendingQuestions.values()]) {
+        if (!hasInteractionClient(pending.sessionId)) fallbackQuestion(pending)
+      }
+      for (const pending of [...pendingApprovals.values()]) {
+        if (!hasInteractionClient(pending.sessionId)) fallbackApproval(pending)
+      }
+    }
+
     const respondToQuestion = async (msg, cancel = false) => {
       const rpcId = typeof msg.rpcId === 'string' && msg.rpcId.trim() ? msg.rpcId.trim() : null
       const sessionId = typeof msg.sessionId === 'string' && msg.sessionId.trim() ? msg.sessionId.trim() : null
@@ -2042,46 +2244,30 @@ const plugin = {
         return { kind: 'error', code: 'bad-request', message: `${msg.type} requires rpcId and sessionId`, requestType: msg.type }
       }
 
-      if (cancel) {
-        const pending = pendingQuestions.get(rpcId)
-        if (pending && pending.sessionId !== sessionId) {
-          return { kind: 'error', code: 'bad-request', message: 'sessionId does not match the pending question', requestType: msg.type, sessionId }
-        }
-      } else if (!Array.isArray(msg.answers)) {
+      const pending = pendingQuestions.get(rpcId)
+      if (!pending) {
+        return { kind: 'question-response', rpcId, sessionId, action: cancel ? 'cancel' : 'answer', accepted: false, reason: 'not-pending' }
+      }
+      if (pending.sessionId !== sessionId) {
+        return { kind: 'error', code: 'bad-request', message: 'sessionId does not match the pending question', requestType: msg.type, sessionId }
+      }
+      if (!cancel && !Array.isArray(msg.answers)) {
         return { kind: 'error', code: 'bad-request', message: 'question-answer requires an answers array', requestType: msg.type, sessionId }
       }
-
-      const result = cancel
-        ? { ok: false, error: { code: 'cancelled', message: 'question cancelled by mobile user', details: {} } }
-        : {
-            ok: true,
-            value: {
-              sessionId,
-              answer: {
-                answers: msg.answers.map((answer) => ({
-                  id: answer && answer.id,
-                  selected: answer && answer.selected,
-                  ...(answer && answer.custom !== undefined ? { custom: answer.custom } : {}),
-                })),
-              },
-            },
-          }
-
-      try {
-        const receipt = await api.respond({ type: 'client-response', rpcId, result })
-        log(`question response: rpcId=${rpcId} session=${sessionId} action=${cancel ? 'cancel' : 'answer'} accepted=${receipt.accepted}${receipt.accepted ? '' : ` reason=${receipt.reason}`}`)
-        return {
-          kind: 'question-response',
-          rpcId,
-          sessionId,
-          action: cancel ? 'cancel' : 'answer',
-          accepted: receipt.accepted,
-          ...(!receipt.accepted ? { reason: receipt.reason } : {}),
-        }
-      } catch (error) {
-        const message = error && error.message ? error.message : String(error)
-        log(`question response failed: rpcId=${rpcId} ${message}`)
-        return { kind: 'error', code: 'internal', message, requestType: msg.type, sessionId }
+      const normalized = cancel ? null : normalizeQuestionAnswers(pending, msg.answers)
+      if (normalized?.error) {
+        return { kind: 'error', code: 'bad-response', message: normalized.error, requestType: msg.type, sessionId }
+      }
+      const answer = normalized?.value
+      const accepted = completeQuestion(pending, cancel ? 'cancel' : 'answer', answer)
+      log(`question response: rpcId=${rpcId} session=${sessionId} action=${cancel ? 'cancel' : 'answer'} accepted=${accepted}`)
+      return {
+        kind: 'question-response',
+        rpcId,
+        sessionId,
+        action: cancel ? 'cancel' : 'answer',
+        accepted,
+        ...(!accepted ? { reason: 'not-pending' } : {}),
       }
     }
 
@@ -2098,30 +2284,22 @@ const plugin = {
       }
 
       const pending = pendingApprovals.get(rpcId)
-      if (pending && (pending.sessionId !== sessionId || pending.approvalId !== approvalId)) {
+      if (!pending) {
+        return { kind: 'approval-response', rpcId, sessionId, approvalId, outcome, accepted: false, reason: 'not-pending' }
+      }
+      if (pending.sessionId !== sessionId || pending.approvalId !== approvalId) {
         return { kind: 'error', code: 'bad-request', message: 'approval-response does not match the pending approval', requestType: msg.type, sessionId }
       }
-
-      try {
-        const receipt = await api.respond({
-          type: 'client-response',
-          rpcId,
-          result: { ok: true, value: { sessionId, approvalId, outcome } },
-        })
-        log(`approval response: rpcId=${rpcId} approvalId=${approvalId} session=${sessionId} outcome=${outcome} accepted=${receipt.accepted}${receipt.accepted ? '' : ` reason=${receipt.reason}`}`)
-        return {
-          kind: 'approval-response',
-          rpcId,
-          sessionId,
-          approvalId,
-          outcome,
-          accepted: receipt.accepted,
-          ...(!receipt.accepted ? { reason: receipt.reason } : {}),
-        }
-      } catch (error) {
-        const message = error && error.message ? error.message : String(error)
-        log(`approval response failed: rpcId=${rpcId} ${message}`)
-        return { kind: 'error', code: 'internal', message, requestType: msg.type, sessionId }
+      const accepted = completeApproval(pending, outcome)
+      log(`approval response: rpcId=${rpcId} approvalId=${approvalId} session=${sessionId} outcome=${outcome} accepted=${accepted}`)
+      return {
+        kind: 'approval-response',
+        rpcId,
+        sessionId,
+        approvalId,
+        outcome,
+        accepted,
+        ...(!accepted ? { reason: 'not-pending' } : {}),
       }
     }
 
@@ -2300,6 +2478,8 @@ const plugin = {
         wss.handleUpgrade(req, socket, head, (ws) => {
           const id = ++counter
           ws.filterSessionId = undefined
+          const requestedChannel = req.headers['x-dsh-channel']
+          ws.mobileChannel = ['control', 'conversation'].includes(requestedChannel) ? requestedChannel : 'legacy'
           ws.deviceId = device && device.id
           clients.add(ws)
           if (device) registry.connected(device.id)
@@ -2320,6 +2500,12 @@ const plugin = {
               return
             }
             if (!msg || typeof msg.type !== 'string') return
+            const conversationRequest = ['message', 'history', 'subscribe', 'unsubscribe'].includes(msg.type)
+            if ((ws.mobileChannel === 'control' && conversationRequest) ||
+                (ws.mobileChannel === 'conversation' && !conversationRequest && msg.type !== 'ping')) {
+              ws.send(JSON.stringify({ kind: 'error', code: 'wrong-channel', requestType: msg.type, message: 'Request belongs to the other mobile channel' }))
+              return
+            }
 
             if (msg.type === 'ping') {
               ws.send(JSON.stringify({ kind: 'pong', at: Date.now() }))
@@ -2349,15 +2535,16 @@ const plugin = {
               })
             } else if (msg.type === 'workspaces' || msg.type === 'sessions' || msg.type === 'history' || msg.type === 'attachment' ||
                        msg.type === 'search' || msg.type === 'host' || msg.type === 'directories' || msg.type === 'directory-create' ||
-                       msg.type === 'workspace-create' || msg.type === 'models' || msg.type === 'commands' || msg.type === 'command-execute' ||
+                       msg.type === 'workspace-create' || msg.type === 'session-create' || msg.type === 'models' || msg.type === 'commands' || msg.type === 'command-execute' ||
                        msg.type === 'command-options' || msg.type === 'command-select' || msg.type === 'select-model' ||
                        msg.type === 'permission-options' || msg.type === 'permission' || msg.type === 'context-usage' ||
                        msg.type === 'agent-presets' || msg.type === 'defaults' || msg.type === 'set-default' ||
                        msg.type === 'session-stats' || msg.type === 'default-model' ||
-                       msg.type === 'save-default-model' || msg.type === 'fork' || msg.type === 'providers' ||
+                       msg.type === 'save-default-model' || msg.type === 'fork' || msg.type === 'session-cancel' || msg.type === 'queue-update' ||
+                       msg.type === 'session-archive' || msg.type === 'session-rename' || msg.type === 'providers' ||
                        msg.type === 'tasks' || msg.type === 'goal' || msg.type === 'goal-edit' ||
                        msg.type === 'goal-pause' || msg.type === 'goal-resume' || msg.type === 'goal-clear') {
-              handleQuery(api, typertGateway, agentDefaultModel, msg).then((frame) => {
+              handleQuery(api, host, agentDefaultModel, msg).then((frame) => {
                 if (frame && ws.readyState === 1) ws.send(JSON.stringify(frame))
               })
             } else {
@@ -2368,6 +2555,7 @@ const plugin = {
           ws.on('close', () => {
             clients.delete(ws)
             if (ws.deviceId) registry.disconnected(ws.deviceId)
+            releaseUnclaimedInteractions()
             fileTransfers.closeClient(ws).catch((error) => {
               log(`file download cleanup failed: ${error && error.message ? error.message : String(error)}`)
             })
@@ -2385,12 +2573,30 @@ const plugin = {
           ws.send(JSON.stringify({
             kind: 'hello',
             protocol: 3,
-            capabilities: ['images', 'commands', 'tasks', 'goals', ...(options.fileDownloadsEnabled ? ['file-downloads'] : [])],
+            capabilities: [
+              'split-channels',
+              'images',
+              'session-create',
+              'commands',
+              'tasks',
+              'goals',
+              'session-cancel',
+              'queue-control',
+              'session-archive',
+              'session-rename',
+              ...(options.fileDownloadsEnabled ? ['file-downloads'] : []),
+            ],
             port: transport.port || webServer.port,
             clients: clients.size,
             authenticated: !!device,
             ...(device ? { device: { id: device.id, name: device.name } } : {}),
           }))
+          if (ws.mobileChannel !== 'conversation' && archivedSessionIds !== null) {
+            ws.send(JSON.stringify({ kind: 'session-archives', archivedSessionIds }))
+          }
+          if (ws.mobileChannel !== 'conversation' && sessionQueues !== null) {
+            ws.send(JSON.stringify({ kind: 'session-queues', queues: Object.fromEntries(sessionQueues) }))
+          }
           replayPendingInteractions(ws, 'connect')
         })
     }
@@ -2448,112 +2654,221 @@ const plugin = {
       if (clients.size === 0) return
       const wire = buildWireEvent(session, event)
       if (!wire) return
+      if (event.type === 'session/title' && typeof event.data?.title === 'string') {
+        broadcastSessionMetadataFrame({
+          kind: 'session-title-changed',
+          sessionId: String(session.id),
+          title: event.data.title,
+          seq: event.seq,
+          time: event.time,
+          ...(event.data.source ? { source: event.data.source } : {}),
+        })
+      }
       const payload = JSON.stringify(wire)
       for (const client of clients) {
+        if (client.mobileChannel === 'control') continue
         if (client.filterSessionId && client.filterSessionId !== String(session.id)) continue
         if (client.readyState === 1) client.send(payload)
       }
     })
     log('session/event listener attached')
 
-    const interactionMuxTask = api.events && typeof api.events.mux === 'function' && typeof api.respond === 'function'
-      ? (async () => {
-          try {
-            for await (const envelope of api.events.mux(
-              { rpcId: crypto.randomUUID(), payload: {} },
-              interactionMuxAbort.signal,
-            )) {
-              const payload = envelope && envelope.payload
-              if (!payload || typeof payload.type !== 'string') continue
-              log(`interaction observed: type=${payload.type} hasRpc=${envelope.rpcId !== undefined} hasSession=${payload.sessionId !== undefined} hasApprovalId=${payload.approvalId !== undefined} hasToolName=${payload.toolName !== undefined}`)
-              if (payload.type === 'question/requested') {
-                const rpcId = String(envelope.rpcId)
-                const pending = {
-                  rpcId,
-                  sessionId: String(payload.sessionId),
-                  questions: payload.questions,
-                }
-                pendingQuestions.set(rpcId, pending)
-                broadcastInteractionFrame(questionFrameFor(rpcId, pending))
-                log(`question requested: rpcId=${rpcId} session=${pending.sessionId} questions=${Array.isArray(pending.questions) ? pending.questions.length : 0}`)
-              } else if (payload.type === 'approval/requested') {
-                const rpcId = String(envelope.rpcId)
-                const pending = {
-                  rpcId,
-                  sessionId: String(payload.sessionId),
-                  approvalId: String(payload.approvalId),
-                  toolName: payload.toolName,
-                  ...(payload.callId !== undefined ? { callId: payload.callId } : {}),
-                  ...(payload.reason !== undefined ? { reason: payload.reason } : {}),
-                }
-                pendingApprovals.set(rpcId, pending)
-                broadcastInteractionFrame(approvalFrameFor(rpcId, pending))
-                log(`approval requested: rpcId=${rpcId} approvalId=${pending.approvalId} session=${pending.sessionId} tool=${pending.toolName}`)
-              } else if (payload.type === 'question/resolved') {
-                const questionRpcId = String(payload.questionRpcId)
-                pendingQuestions.delete(questionRpcId)
-                broadcastInteractionFrame({
-                  kind: 'question-resolved',
-                  rpcId: questionRpcId,
-                  sessionId: String(payload.sessionId),
-                  outcome: payload.outcome,
-                })
-                log(`question resolved: rpcId=${questionRpcId} session=${payload.sessionId} outcome=${payload.outcome}`)
-              } else if (payload.type === 'approval/resolved') {
-                const approvalId = String(payload.approvalId)
-                const sessionId = String(payload.sessionId)
-                const entry = [...pendingApprovals.entries()].find(([, pending]) => pending.approvalId === approvalId && pending.sessionId === sessionId)
-                if (!entry) {
-                  log(`approval resolved without pending request: approvalId=${approvalId} session=${sessionId} outcome=${payload.outcome}`)
-                  continue
-                }
-                const [rpcId, pending] = entry
-                pendingApprovals.delete(rpcId)
-                broadcastInteractionFrame({
-                  kind: 'approval-resolved',
-                  rpcId,
-                  sessionId,
-                  approvalId,
-                  outcome: payload.outcome,
-                })
-                log(`approval resolved: rpcId=${rpcId} approvalId=${approvalId} session=${sessionId} outcome=${payload.outcome}`)
-              } else if (payload.type === 'session/projection' && (payload.key === 'todos' || payload.key === 'goal')) {
-                const sessionId = String(payload.sessionId)
-                const kind = payload.key === 'todos' ? 'tasks-updated' : 'goal-updated'
-                const valueKey = payload.key === 'todos' ? 'todos' : 'goal'
-                broadcastInteractionFrame({
-                  kind,
-                  sessionId,
-                  asOfSeq: payload.seq,
-                  [valueKey]: payload.value,
-                })
-                log(`projection forwarded: key=${payload.key} session=${sessionId} seq=${payload.seq}`)
-              } else {
-                log(`interaction ignored: type=${payload.type}`)
-              }
+    const disposeQuestions = ctx.on('user-questions/request', (request, next) => {
+      const sessionId = request?.agent?.id === undefined ? null : String(request.agent.id)
+      if (!sessionId || !Array.isArray(request.questions) || !hasInteractionClient(sessionId)) return next()
+      const rpcId = crypto.randomUUID()
+      return new Promise((resolve, reject) => {
+        const onAbort = () => {
+          const pending = pendingQuestions.get(rpcId)
+          if (pending) completeQuestion(pending, 'cancel', undefined, 'ASK_ABORTED')
+        }
+        request.signal?.addEventListener('abort', onAbort, { once: true })
+        const pending = {
+          rpcId,
+          sessionId,
+          questions: request.questions,
+          next,
+          resolve,
+          reject,
+          cleanup: () => request.signal?.removeEventListener('abort', onAbort),
+        }
+        pendingQuestions.set(rpcId, pending)
+        broadcastInteractionFrame(questionFrameFor(rpcId, pending))
+        log(`question requested: rpcId=${rpcId} session=${sessionId} questions=${request.questions.length}`)
+      })
+    }, { prepend: true })
+
+    const disposeApprovals = ctx.on('approval/request', (request, next) => {
+      const sessionId = request?.agent?.id === undefined ? null : String(request.agent.id)
+      if (!sessionId || typeof request.toolName !== 'string' || !hasInteractionClient(sessionId)) return next()
+      const rpcId = crypto.randomUUID()
+      const approvalId = crypto.randomUUID()
+      return new Promise((resolve, reject) => {
+        const onAbort = () => {
+          const pending = pendingApprovals.get(rpcId)
+          if (pending) completeApproval(pending, 'cancelled')
+        }
+        request.signal?.addEventListener('abort', onAbort, { once: true })
+        const pending = {
+          rpcId,
+          sessionId,
+          approvalId,
+          toolName: request.toolName,
+          ...(request.callId !== undefined ? { callId: request.callId } : {}),
+          ...(request.reason !== undefined ? { reason: request.reason } : {}),
+          next,
+          resolve,
+          reject,
+          cleanup: () => request.signal?.removeEventListener('abort', onAbort),
+        }
+        pendingApprovals.set(rpcId, pending)
+        broadcastInteractionFrame(approvalFrameFor(rpcId, pending))
+        log(`approval requested: rpcId=${rpcId} approvalId=${approvalId} session=${sessionId} tool=${request.toolName}`)
+      })
+    }, { prepend: true })
+
+    const waitForBackgroundRetry = () => new Promise((resolve) => {
+      if (backgroundStreamAbort.signal.aborted) {
+        resolve()
+        return
+      }
+      const finish = () => {
+        clearTimeout(timer)
+        backgroundStreamAbort.signal.removeEventListener('abort', finish)
+        resolve()
+      }
+      const timer = setTimeout(finish, 1_000)
+      backgroundStreamAbort.signal.addEventListener('abort', finish, { once: true })
+    })
+
+    const installArchivedSessionIds = (value) => {
+      if (!Array.isArray(value)) throw new Error('workspace/follow returned invalid archivedSessionIds')
+      const next = value.map((sessionId) => String(sessionId))
+      if (archivedSessionIds !== null
+        && archivedSessionIds.length === next.length
+        && archivedSessionIds.every((sessionId, index) => sessionId === next[index])) return
+      archivedSessionIds = next
+      broadcastSessionMetadataFrame({ kind: 'session-archives', archivedSessionIds: next })
+      log(`session archive state forwarded: count=${next.length}`)
+    }
+
+    const normalizeQueueItems = (value, endpoint) => {
+      if (!Array.isArray(value)) throw new Error(`${endpoint} returned invalid queue items`)
+      return value.map((candidate) => {
+        const message = candidate && typeof candidate === 'object' && !Array.isArray(candidate)
+          ? candidate.message
+          : null
+        if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)
+          || typeof candidate.id !== 'string' || !candidate.id
+          || !['queued', 'steering', 'context'].includes(candidate.placement)
+          || !message || typeof message !== 'object' || Array.isArray(message)
+          || typeof message.id !== 'string' || !message.id
+          || !Array.isArray(message.content)
+          || (candidate.rpcId !== undefined && typeof candidate.rpcId !== 'string')) {
+          throw new Error(`${endpoint} returned an invalid queue item`)
+        }
+        return {
+          id: candidate.id,
+          placement: candidate.placement,
+          ...(candidate.rpcId === undefined ? {} : { rpcId: candidate.rpcId }),
+          message: { id: message.id, content: message.content },
+        }
+      })
+    }
+
+    const installSessionQueueBaseline = (value) => {
+      if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('session/control baseline returned invalid queues')
+      }
+      const next = new Map()
+      for (const [sessionId, items] of Object.entries(value)) {
+        next.set(sessionId, normalizeQueueItems(items, 'session/control baseline'))
+      }
+      sessionQueues = next
+      broadcastSessionMetadataFrame({ kind: 'session-queues', queues: Object.fromEntries(next) })
+      log(`session queue baseline forwarded: sessions=${next.size}`)
+    }
+
+    const installSessionQueue = (sessionIdValue, itemsValue) => {
+      const sessionId = typeof sessionIdValue === 'string' && sessionIdValue ? sessionIdValue : null
+      if (!sessionId) throw new Error('session/control returned an invalid queue sessionId')
+      const items = normalizeQueueItems(itemsValue, 'session/control queue')
+      if (sessionQueues === null) sessionQueues = new Map()
+      sessionQueues.set(sessionId, items)
+      broadcastSessionMetadataFrame({ kind: 'session-queue', sessionId, items })
+      log(`session queue forwarded: session=${sessionId} items=${items.length}`)
+    }
+
+    const workspaceTask = (async () => {
+      while (!backgroundStreamAbort.signal.aborted) {
+        try {
+          const stream = await api.openWorkspaceStream(backgroundStreamAbort.signal)
+          for await (const frame of stream) {
+            if (frame?.type === 'baseline') {
+              installArchivedSessionIds(frame.value?.archivedSessionIds)
+            } else if (frame?.type === 'archived') {
+              installArchivedSessionIds(frame.archivedSessionIds)
             }
-          } catch (error) {
-            if (!interactionMuxAbort.signal.aborted) {
-              log(`interaction mux failed: ${error && error.message ? error.message : String(error)}`)
+          }
+          if (!backgroundStreamAbort.signal.aborted) log('workspace stream ended; retrying')
+        } catch (error) {
+          if (!backgroundStreamAbort.signal.aborted) {
+            log(`workspace stream failed; retrying: ${error && error.message ? error.message : String(error)}`)
+          }
+        }
+        if (!backgroundStreamAbort.signal.aborted) await waitForBackgroundRetry()
+      }
+    })()
+    void workspaceTask
+
+    const controlTask = (async () => {
+      while (!backgroundStreamAbort.signal.aborted) {
+        try {
+          const stream = await api.openControlStream(backgroundStreamAbort.signal)
+          for await (const frame of stream) {
+            if (frame?.type === 'baseline') {
+              installSessionQueueBaseline(frame.value?.queues)
+            } else if (frame?.type === 'queue') {
+              installSessionQueue(frame.sessionId, frame.items)
+            } else if (frame?.type === 'projection' && (frame.key === 'todos' || frame.key === 'goal')) {
+              const sessionId = String(frame.sessionId)
+              const kind = frame.key === 'todos' ? 'tasks-updated' : 'goal-updated'
+              const valueKey = frame.key === 'todos' ? 'todos' : 'goal'
+              broadcastInteractionFrame({
+                kind,
+                sessionId,
+                asOfSeq: frame.seq,
+                [valueKey]: frame.value,
+              })
+              log(`projection forwarded: key=${frame.key} session=${sessionId} seq=${frame.seq}`)
             }
           }
-        })()
-      : null
-    if (interactionMuxTask) log('api gateway interaction mux attached')
-    else log('api gateway interaction mux unavailable; human-in-the-loop disabled')
+          if (!backgroundStreamAbort.signal.aborted) log('session control stream ended; retrying')
+        } catch (error) {
+          if (!backgroundStreamAbort.signal.aborted) {
+            log(`session control stream failed; retrying: ${error && error.message ? error.message : String(error)}`)
+          }
+        }
+        if (!backgroundStreamAbort.signal.aborted) await waitForBackgroundRetry()
+      }
+    })()
+    void controlTask
+    log('Host waterfall interaction listeners, workspace stream, and session control stream attached')
 
     ctx.effect(() => () => {
       if (waitTimer) clearTimeout(waitTimer)
       clearInterval(fileTransferExpiryTimer)
-      interactionMuxAbort.abort()
-      pendingQuestions.clear()
-      pendingApprovals.clear()
+      backgroundStreamAbort.abort()
+      for (const pending of [...pendingQuestions.values()]) fallbackQuestion(pending)
+      for (const pending of [...pendingApprovals.values()]) fallbackApproval(pending)
       fileTransfers.dispose().catch((error) => {
         log(`file download disposal failed: ${error && error.message ? error.message : String(error)}`)
       })
       disposeUpgrade()
       disposeMgmt()
       disposeEvents()
+      disposeQuestions()
+      disposeApprovals()
       if (lanServer) lanServer.close()
       for (const client of clients) client.terminate()
       clients.clear()