@linxin666/dsh-remote-web-ui 0.3.1 → 0.3.3

package/src/index.ts

@@ -31,10 +31,13 @@ import { lanIPv4Addresses } from './lan.ts'
 import { TunnelManager, type TunnelInfo } from './tunnel.ts'
 import {
   checkUpdates,
+  fetchGitHubReleaseNotes,
   fetchLatestVersion,
+  RELEASE_NOTES_CACHE_TTL_MS,
   resolveAnchorManifest,
   resolveUpdateTarget,
   runUpdateVerified,
+  type UpdateReleaseNotes,
   type UpdateRunResult,
 } from './update.ts'
 import { makeUpdateRoutes } from './update-routes.ts'
@@ -294,7 +297,7 @@ function applyImpl(ctx: Context, config?: Config): void {
     console.warn('remote-web-ui: apiProxy service unavailable — the mobile data channel is disabled')
   }
   // ── remote update ────────────────────────────────────────────────────────
-  // The dsh-web-ui self-update surface: probe the npm registry for family
+  // The dsh-web self-update surface: probe the npm registry for family
   // releases and run `pnpm update --latest` in the owning profile. Resolutions
   // anchor on the host process's own module graph, so the update always
   // targets the profile the running web GUI was booted from. The anchor path
@@ -309,6 +312,15 @@ function applyImpl(ctx: Context, config?: Config): void {
       return undefined
     }
   })
+
+  const releaseNotesCache = new Map<string, { at: number; notes?: UpdateReleaseNotes }>()
+  const fetchReleaseNotesCached = async (version: string): Promise<UpdateReleaseNotes | undefined> => {
+    const cached = releaseNotesCache.get(version)
+    if (cached !== undefined && Date.now() - cached.at < RELEASE_NOTES_CACHE_TTL_MS) return cached.notes
+    const notes = await fetchGitHubReleaseNotes(version, fetch)
+    releaseNotesCache.set(version, { at: Date.now(), notes })
+    return notes
+  }
   const updateRoutes = makeUpdateRoutes({
     // Control endpoints are host-surface only: a LAN/phone origin must never
     // trigger a real install on this machine.
@@ -323,6 +335,7 @@ function applyImpl(ctx: Context, config?: Config): void {
         }
       },
       fetchLatest: name => fetchLatestVersion(name, fetch),
+      fetchReleaseNotes: fetchReleaseNotesCached,
     }),
     run: async (): Promise<UpdateRunResult> => {
       const target = resolveUpdateTarget({ anchorManifestPath: resolveAnchorPath() })
@@ -332,7 +345,7 @@ function applyImpl(ctx: Context, config?: Config): void {
           ok: false,
           exitCode: null,
           output: '',
-          error: code === 'not-found' ? 'dsh-web-ui aggregate not installed' : 'local link install — update unavailable',
+          error: code === 'not-found' ? 'dsh-web aggregate not installed' : 'local link install — update unavailable',
           errorCode: code,
         }
       }
@@ -352,6 +365,7 @@ function applyImpl(ctx: Context, config?: Config): void {
             }
           },
           fetchLatest: name => fetchLatestVersion(name, fetch),
+          fetchReleaseNotes: fetchReleaseNotesCached,
         },
       })
     },

package/src/loopback.ts

@@ -8,7 +8,7 @@
  * Semantics: RFC 5735 IPv4 127/8, ::1, IPv4-mapped ::ffff:127/8 (matching the
  * remote-web-ui gate), localhost hostnames, plus the browser same-origin
  * markers (sec-fetch-site and Origin) for the request-level fence.
- * @module dsh-web-ui-shared/host/loopback
+ * @module dsh-web-shared/host/loopback
  */
 
 import type { IncomingMessage } from 'node:http'

package/src/mobile/api.ts

@@ -112,6 +112,14 @@ export async function sendCommand(sessionId: string, line: string): Promise<unkn
   })
 }
 
+/**
+ * Stop the session's active turn (the mobile stop button). Pending queued
+ * work is preserved and resumes in FIFO order once cancellation settles.
+ */
+export async function cancelSession(sessionId: string): Promise<{ accepted: true }> {
+  return await callUnary<{ accepted: true }>('session.cancel', { sessionId })
+}
+
 /** Fresh advisory model directory for one session (current + groups + failures). */
 export async function models(sessionId: string): Promise<SessionModels> {
   return await callUnary<SessionModels>('session.models', { sessionId })

package/src/mobile/mobile-styles.ts

@@ -1170,6 +1170,16 @@ body {
   opacity: 0.5;
 }
 
+/* Running state: the primary button carries only the square stop icon, so
+   it centers the glyph instead of sizing to text. */
+.chat-send-stop {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 44px;
+  padding: 0 12px;
+}
+
 .chat-load-older {
   align-self: center;
   margin: 4px 0;

package/src/mobile/views/ChatView.stream.test.tsx

@@ -7,8 +7,8 @@
  * to the plain renderMarkdown output) the moment the turn closes.
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { act, cleanup, render } from '@testing-library/react'
-import { ChatView, STREAM_RENDER_INTERVAL_MS } from './ChatView.tsx'
+import { act, cleanup, render, screen } from '@testing-library/react'
+import { ChatView, STREAM_RENDER_INTERVAL_MS, LONG_TEXT_LIMIT } from './ChatView.tsx'
 import { type SessionView } from './App.tsx'
 import { renderMarkdown } from '../markdown.ts'
 import type { SessionModels } from '@deepseek-ai/dsh-host-apiproxy/api/sessions'
@@ -22,6 +22,8 @@ vi.mock('../api.ts', () => ({
   models: vi.fn(),
   selectModel: vi.fn(),
   sendCommand: vi.fn(),
+  cancelSession: vi.fn(),
+  fetchPending: vi.fn(),
 }))
 vi.mock('./App.tsx', async importOriginal => {
   const actual = await importOriginal<typeof import('./App.tsx')>()
@@ -228,4 +230,34 @@ describe('ChatView streaming markdown throttle', () => {
     expect(renderMarkdownMock.mock.calls.length - beforeFinal).toBe(0)
     expect(normalize(body().innerHTML)).toBe(normalize(renderMarkdown(full)))
   })
+
+  it('does not collapse long text while streaming (pending) and collapses once turn finishes', async () => {
+    const mux = new FakeMux()
+    let container: HTMLElement
+    await act(async () => {
+      const rendered = render(<ChatView session={session} mux={mux as never} onBack={() => {}} />)
+      container = rendered.container
+    })
+
+    const hugeChunk = 'C'.repeat(LONG_TEXT_LIMIT + 200)
+
+    // Stream a chunk exceeding LONG_TEXT_LIMIT
+    await act(async () => {
+      chunk(mux, hugeChunk, 6)
+      vi.advanceTimersByTime(STREAM_RENDER_INTERVAL_MS + 5)
+    })
+
+    // During streaming (pending), message is not collapsed
+    expect(container!.querySelector('.chat-md-collapsed')).toBeNull()
+    expect(screen.queryByRole('button', { name: /展开全文/ })).toBeNull()
+
+    // Turn closes
+    await act(async () => {
+      finalMessage(mux, hugeChunk, 7)
+    })
+
+    // Once turn ends (not pending), message is collapsed and has expand button
+    expect(container!.querySelector('.chat-md-collapsed')).not.toBeNull()
+    expect(screen.getByRole('button', { name: new RegExp(`展开全文（${LONG_TEXT_LIMIT + 200} 字）`) })).toBeTruthy()
+  })
 })

package/src/mobile/views/ChatView.test.tsx

@@ -3,7 +3,7 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
 import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
 import type { SessionModels } from '@deepseek-ai/dsh-host-apiproxy/api/sessions'
-import { ChatView, MAX_TAIL_BUFFER_EVENTS } from './ChatView.tsx'
+import { ChatView, MAX_TAIL_BUFFER_EVENTS, LONG_TEXT_LIMIT } from './ChatView.tsx'
 import { type SessionView } from './App.tsx'
 import type { HistoryPage } from '../api.ts'
 import type { WireEvent } from '../messages.ts'
@@ -15,6 +15,8 @@ vi.mock('../api.ts', () => ({
   models: vi.fn(),
   selectModel: vi.fn(),
   sendCommand: vi.fn(),
+  cancelSession: vi.fn(),
+  fetchPending: vi.fn(),
 }))
 vi.mock('./App.tsx', async importOriginal => {
   const actual = await importOriginal<typeof import('./App.tsx')>()
@@ -24,7 +26,7 @@ vi.mock('./App.tsx', async importOriginal => {
     prompt: vi.fn(async () => {}),
   }
 })
-import { fetchMobilePreferences, models, selectModel, sendCommand } from '../api.ts'
+import { fetchMobilePreferences, models, selectModel, sendCommand, cancelSession, fetchPending } from '../api.ts'
 import { loadHistory, prompt } from './App.tsx'
 
 const session: SessionView = {
@@ -45,6 +47,18 @@ function historyPage(events: Array<{ event: WireEvent }>, extra: Record<string,
   return { events: events as never, hasMore: false, ...extra } as HistoryPage
 }
 
+/** Minimal mux stand-in: captures the ChatView's frame listener for hand-off. */
+class FakeMux {
+  listeners = new Set<(frame: unknown) => void>()
+  onFrame(listener: (frame: unknown) => void): () => void {
+    this.listeners.add(listener)
+    return () => { this.listeners.delete(listener) }
+  }
+  emit(frame: unknown): void {
+    for (const listener of this.listeners) listener(frame)
+  }
+}
+
 /** A full turn: user message, reasoning + text chunks, tool calls, final message. */
 function turnEvents(): Array<{ event: WireEvent }> {
   return [
@@ -72,6 +86,8 @@ const fetchMobilePreferencesMock = vi.mocked(fetchMobilePreferences)
 const modelsMock = vi.mocked(models)
 const selectModelMock = vi.mocked(selectModel)
 const sendCommandMock = vi.mocked(sendCommand)
+const cancelSessionMock = vi.mocked(cancelSession)
+const fetchPendingMock = vi.mocked(fetchPending)
 const loadHistoryMock = vi.mocked(loadHistory)
 const promptMock = vi.mocked(prompt)
 
@@ -95,6 +111,8 @@ beforeEach(() => {
   } satisfies SessionModels)
   selectModelMock.mockResolvedValue({ selected: { provider: 'fx', model: 'fx-2', reasoningEffort: 'high' } })
   sendCommandMock.mockResolvedValue({})
+  cancelSessionMock.mockResolvedValue({ accepted: true })
+  fetchPendingMock.mockResolvedValue({ approvals: [], questions: [] })
 })
 
 afterEach(() => {
@@ -639,3 +657,160 @@ describe('ChatView display toggles and context usage', () => {
     expect(screen.queryByText(/上下文/)).toBeNull()
   })
 })
+
+describe('ChatView stop button (#1041)', () => {
+  /** Emit one session lifecycle frame for the chat's session. */
+  function emitSessionEvent(mux: FakeMux, type: string, seq: number): void {
+    act(() => {
+      mux.emit({ type: 'session/event', sessionId: 's-1', event: makeEntry(type, {}, seq).event })
+    })
+  }
+
+  it('switches the composer primary to a stop button while running and cancels the turn', async () => {
+    loadHistoryMock.mockResolvedValue(historyPage([]))
+    const mux = new FakeMux()
+    render(<ChatView session={session} mux={mux as never} onBack={() => {}} />)
+
+    // Idle: the primary button is the (empty-draft disabled) send button.
+    const sendButton = await screen.findByRole('button', { name: '发送' })
+    expect((sendButton as HTMLButtonElement).disabled).toBe(true)
+
+    // Turn starts: the primary becomes an enabled stop button (square icon).
+    emitSessionEvent(mux, 'turn/start', 1)
+    const stopButton = (await screen.findByRole('button', { name: '停止' })) as HTMLButtonElement
+    expect(stopButton.disabled).toBe(false)
+
+    fireEvent.click(stopButton)
+    await waitFor(() => expect(cancelSessionMock).toHaveBeenCalledWith('s-1'))
+
+    // Turn ends: the primary flips back to send.
+    emitSessionEvent(mux, 'turn/end', 2)
+    expect(await screen.findByRole('button', { name: '发送' })).toBeTruthy()
+  })
+
+  it('disables the stop button while the cancel request is in flight', async () => {
+    loadHistoryMock.mockResolvedValue(historyPage([]))
+    let resolveCancel: (() => void) | undefined
+    cancelSessionMock.mockReturnValue(new Promise<{ accepted: true }>((resolve) => {
+      resolveCancel = () => { resolve({ accepted: true }) }
+    }))
+    const mux = new FakeMux()
+    render(<ChatView session={session} mux={mux as never} onBack={() => {}} />)
+    await screen.findByRole('button', { name: '发送' })
+
+    emitSessionEvent(mux, 'turn/start', 1)
+    const stopButton = (await screen.findByRole('button', { name: '停止' })) as HTMLButtonElement
+    fireEvent.click(stopButton)
+
+    // In flight: disabled and re-labeled; a second tap cannot double-submit.
+    const inflight = (await screen.findByRole('button', { name: '停止中' })) as HTMLButtonElement
+    expect(inflight.disabled).toBe(true)
+    fireEvent.click(inflight)
+    expect(cancelSessionMock).toHaveBeenCalledTimes(1)
+
+    await act(async () => { resolveCancel?.() })
+    emitSessionEvent(mux, 'turn/end', 2)
+    expect(await screen.findByRole('button', { name: '发送' })).toBeTruthy()
+  })
+
+  it('surfaces a cancel failure through the chat error line', async () => {
+    loadHistoryMock.mockResolvedValue(historyPage([]))
+    cancelSessionMock.mockRejectedValue(new Error('cancel exploded'))
+    const mux = new FakeMux()
+    render(<ChatView session={session} mux={mux as never} onBack={() => {}} />)
+    await screen.findByRole('button', { name: '发送' })
+
+    emitSessionEvent(mux, 'turn/start', 1)
+    fireEvent.click(await screen.findByRole('button', { name: '停止' }))
+    expect(await screen.findByText(/cancel exploded/)).toBeTruthy()
+  })
+})
+
+describe('ChatView message visibility and long text folding (#1065)', () => {
+  const toolOnlyEvents = (): Array<{ event: WireEvent }> => [
+    makeEntry('user/message', { id: 'u-1', role: 'user', content: [{ type: 'text', text: '查询文件' }] }, 0),
+    makeEntry('assistant/message', {
+      turn: 0,
+      step: 0,
+      message: { id: 'a-1', role: 'assistant', content: [] },
+    }, 1),
+    makeEntry('tool/call', { turn: 0, step: 0, callId: 'c1', name: 'read_file', arguments: '{"path":"/a"}' }, 2),
+  ]
+
+  it('hides assistant message completely (no air bubble) when only tool calls exist and tool toggle is off', async () => {
+    loadHistoryMock.mockResolvedValue(historyPage(toolOnlyEvents()))
+    const { container } = render(<ChatView session={session} onBack={() => {}} />)
+
+    expect(await screen.findByText('查询文件')).toBeTruthy()
+    // By default showToolCalls is true, tool disclosure is visible
+    expect(await screen.findByRole('button', { name: /工具/ })).toBeTruthy()
+
+    // Turn off tool-calls toggle
+    fireEvent.click(screen.getByRole('button', { name: /显示/ }))
+    const toolSwitch = await screen.findByRole('switch', { name: '工具调用' })
+    fireEvent.click(toolSwitch)
+
+    // The tool disclosure is gone, and the entire assistant message bubble is not rendered (no air bubble)
+    expect(screen.queryByRole('button', { name: /工具/ })).toBeNull()
+    const msgElements = container.querySelectorAll('.chat-msg')
+    expect(msgElements.length).toBe(1)
+    expect(msgElements[0]?.classList.contains('chat-msg-user')).toBe(true)
+  })
+
+  it('renders failed tag even if assistant message has no text or reasoning', async () => {
+    loadHistoryMock.mockResolvedValue(historyPage([
+      makeEntry('user/message', { id: 'u-1', role: 'user', content: [{ type: 'text', text: '测试失败' }] }, 0),
+      makeEntry('assistant/message', {
+        turn: 0,
+        step: 0,
+        message: { id: 'a-1', role: 'assistant', content: [] },
+      }, 1),
+      makeEntry('turn/end', { turn: 0, reason: { kind: 'error', message: 'timeout' } }, 2),
+    ]))
+    render(<ChatView session={session} onBack={() => {}} />)
+
+    expect(await screen.findByText('测试失败')).toBeTruthy()
+    expect(await screen.findByText('本次回复失败')).toBeTruthy()
+  })
+
+  it('collapses terminal assistant text exceeding LONG_TEXT_LIMIT and toggles open/close', async () => {
+    const longText = 'A'.repeat(LONG_TEXT_LIMIT + 100)
+    loadHistoryMock.mockResolvedValue(historyPage([
+      makeEntry('user/message', { id: 'u-1', role: 'user', content: [{ type: 'text', text: '生成长文本' }] }, 0),
+      makeEntry('assistant/message', {
+        turn: 0,
+        step: 0,
+        message: { id: 'a-1', role: 'assistant', content: [{ type: 'text', text: longText }] },
+      }, 1),
+    ]))
+    const { container } = render(<ChatView session={session} onBack={() => {}} />)
+
+    expect(await screen.findByText('生成长文本')).toBeTruthy()
+    const toggleButton = await screen.findByRole('button', { name: new RegExp(`展开全文（${LONG_TEXT_LIMIT + 100} 字）`) })
+    expect(toggleButton).toBeTruthy()
+    expect(container.querySelector('.chat-md-collapsed')).not.toBeNull()
+
+    // Expand
+    fireEvent.click(toggleButton)
+    expect(await screen.findByRole('button', { name: '收起' })).toBeTruthy()
+    expect(container.querySelector('.chat-md-collapsed')).toBeNull()
+  })
+
+  it('does not collapse terminal assistant text within LONG_TEXT_LIMIT', async () => {
+    const shortText = 'B'.repeat(LONG_TEXT_LIMIT)
+    loadHistoryMock.mockResolvedValue(historyPage([
+      makeEntry('user/message', { id: 'u-1', role: 'user', content: [{ type: 'text', text: '生成中等文本' }] }, 0),
+      makeEntry('assistant/message', {
+        turn: 0,
+        step: 0,
+        message: { id: 'a-1', role: 'assistant', content: [{ type: 'text', text: shortText }] },
+      }, 1),
+    ]))
+    const { container } = render(<ChatView session={session} onBack={() => {}} />)
+
+    expect(await screen.findByText('生成中等文本')).toBeTruthy()
+    expect(screen.queryByRole('button', { name: /展开全文/ })).toBeNull()
+    expect(container.querySelector('.chat-md-collapsed')).toBeNull()
+  })
+})
+

package/src/mobile/views/ChatView.tsx

@@ -16,7 +16,7 @@ import type { MuxFrame } from '@deepseek-ai/dsh-host-apiproxy/api/events'
 import type { SessionModels } from '@deepseek-ai/dsh-host-apiproxy/api/sessions'
 import { loadHistory, prompt, type SessionView } from './App.tsx'
 import { errorText, formatTime, staleHostHint } from './App.tsx'
-import { fetchMobilePreferences, models, selectModel, sendCommand, fetchPending, respondApproval, respondQuestion } from '../api.ts'
+import { fetchMobilePreferences, models, selectModel, sendCommand, cancelSession, fetchPending, respondApproval, respondQuestion } from '../api.ts'
 import type { PendingApproval, PendingQuestionItem } from '../api.ts'
 import { EventFolder, foldEvents, type RenderMessage, type ToolCallInfo, type WireEvent } from '../messages.ts'
 import { renderMarkdown } from '../markdown.ts'
@@ -167,6 +167,8 @@ export function ChatView({ session, mux, onBack }: ChatViewProps) {
   const [mobileEnterToSend, setMobileEnterToSend] = useState(true)
   /** Whether the assistant is currently generating (turn/start..turn/end). */
   const [running, setRunning] = useState(false)
+  /** Whether a stop request is in flight (guards the composer's stop button). */
+  const [stopping, setStopping] = useState(false)
   /** Pending tool approvals awaiting user decision (#1025). */
   const [pendingApprovals, setPendingApprovals] = useState<PendingApproval[]>([])
   /** Pending questions awaiting user answer (#1025). */
@@ -441,6 +443,24 @@ export function ChatView({ session, mux, onBack }: ChatViewProps) {
     )
   }, [input, sending, session.sessionId])
 
+  /**
+   * Stop the active turn (desktop parity: the composer's primary button
+   * becomes a stop button while running). The turn/end frame arriving over
+   * mux flips the button back; a failed request surfaces through the chat
+   * error line.
+   */
+  const stopTurn = useCallback(() => {
+    if (stopping) return
+    setStopping(true)
+    void cancelSession(session.sessionId).then(
+      () => { setStopping(false) },
+      (reason: unknown) => {
+        setStopping(false)
+        setError(errorText(reason))
+      },
+    )
+  }, [stopping, session.sessionId])
+
   const modelLabel = currentModel?.model ?? '模型'
   const permissionLabel = permissions === undefined
     ? undefined
@@ -547,8 +567,18 @@ export function ChatView({ session, mux, onBack }: ChatViewProps) {
             }
           }}
         />
-        <button type="button" className="chat-send" disabled={sending || input.trim() === ''} onClick={() => { void send() }}>
-          {sending ? '发送中…' : '发送'}
+        <button
+          type="button"
+          className={running ? 'chat-send chat-send-stop' : 'chat-send'}
+          {...(running ? { 'aria-label': stopping ? '停止中' : '停止' } : {})}
+          disabled={running ? stopping : sending || input.trim() === ''}
+          onClick={() => { if (running) void stopTurn(); else void send() }}
+        >
+          {running ? (
+            <svg viewBox="0 0 16 16" width="14" height="14" aria-hidden="true" focusable="false">
+              <rect x="3" y="3" width="10" height="10" rx="3" fill="currentColor" />
+            </svg>
+          ) : sending ? '发送中…' : '发送'}
         </button>
       </div>
       {sheet === 'model' && (
@@ -595,13 +625,21 @@ const MessageRow = memo(function MessageRow({ message, showToolCalls, showSystem
   showSystemMessages: boolean
 }) {
   // Injected user messages (sourceKind defined and not 'user') hide behind
-  // the system-message toggle. Assistant messages are never hidden.
+  // the system-message toggle.
   if (message.kind === 'user'
     && message.sourceKind !== undefined
     && message.sourceKind !== 'user'
     && !showSystemMessages) {
     return null
   }
+  const hasReasoning = message.kind === 'assistant' && message.reasoning !== undefined && message.reasoning !== ''
+  const hasTools = showToolCalls && message.kind === 'assistant' && message.tools !== undefined && message.tools.length > 0
+  const hasText = message.text !== ''
+  const hasFailTag = message.failed === true
+
+  if (!hasReasoning && !hasTools && !hasText && !hasFailTag) {
+    return null
+  }
   return (
     <div className={`chat-msg chat-msg-${message.kind}${message.pending === true ? ' chat-msg-pending' : ''}${message.failed === true ? ' chat-msg-failed' : ''}`}>
       {message.kind === 'assistant' && message.reasoning !== undefined && message.reasoning !== '' && (
@@ -750,7 +788,7 @@ function MarkdownText({ text, pending }: { text: string; pending: boolean }) {
       if (timerRef.current !== undefined) clearTimeout(timerRef.current)
     }
   }, [])
-  const long = text.length > LONG_TEXT_LIMIT
+  const long = !pending && text.length > LONG_TEXT_LIMIT
   const collapsed = long && !open
   return (
     <div className={'chat-msg-text chat-md' + (collapsed ? ' chat-md-collapsed' : '')}>
@@ -781,7 +819,7 @@ function CollapsibleText({ text }: { text: string }) {
   )
 }
 
-const LONG_TEXT_LIMIT = 1600
+export const LONG_TEXT_LIMIT = 6000
 const LONG_TEXT_PREVIEW = 800
 
 /** Latest non-empty line of a streaming reasoning buffer. */

package/src/mobile-api.ts

@@ -53,6 +53,7 @@ const MOBILE_ALLOWLIST = new Set([
   'session.models',
   'session.selectModel',
   'session.rename',
+  'session.cancel',
 ])
 
 /**
@@ -353,5 +354,6 @@ async function dispatch(apiProxy: ApiProxy, method: string, payload: unknown, rp
   if (method === 'session.models') return wrap(await apiProxy.sessions.models(request as never))
   if (method === 'session.selectModel') return wrap(await apiProxy.sessions.selectModel(request as never))
   if (method === 'session.rename') return wrap(await apiProxy.sessions.rename(request as never))
+  if (method === 'session.cancel') return wrap(await apiProxy.sessions.cancel(request as never))
   throw new Error(`unhandled allowlisted method ${method}`)
 }

package/src/mount-once.ts

@@ -1,7 +1,7 @@
 // Generated by scripts/sync-shared.mjs from shared/host/mount-once.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
 /**
  * Host single-instance guard shared by the plugin family. The family bundle
- * (dsh-web-ui-all / dsh-skins) namespaces every child row id (web-ui-*), so
+ * (dsh-web-all / dsh-skins) namespaces every child row id (web-ui-*), so
  * the loader accepts a standalone install of the same package side by side;
  * without this guard the second instance would still re-register the same
  * webserver routes, tools, settings namespaces, and system-prompt sections
@@ -15,7 +15,7 @@
  * return value as the fiber disposer, so the unmarker is returned, not run.
  */
 
-const MOUNTED = Symbol.for('dsh-web-ui.mounted-plugins')
+const MOUNTED = Symbol.for('dsh-web.mounted-plugins')
 
 interface MountRegistry {
   [MOUNTED]?: Set<string>