dsh-zen-remote 1.0.0

package/src/client/effects/turn-fold.ts

@@ -0,0 +1,258 @@
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client'
+import { NS } from '../locales.ts'
+
+/** Phone breakpoint — same query every phone-only effect in this plugin uses. */
+const PHONE_QUERY = '(max-width: 767px)'
+
+/** ChatView's flow column (dsh-client-ui-conversation lib/client.js:5512).
+ * Trajectory and every other view render their own tree and never carry this
+ * marker, so scoping here is what keeps this effect Chat-only. */
+const FLOW = '[data-chat-flow]'
+
+/** Marker + selector of the injected summary row. */
+const CHIP = 'turn-fold'
+const CHIP_SELECTOR = '[data-mobile-nav="turn-fold"]'
+
+/** Whole-row node kinds that are turn *process*, not conversation content.
+ * Keys are ChatNodeSeat's own `data-chat-flow-kind` dispatch values
+ * (registerChatNodeRenderers, lib/client.js:9322): tool calls, injected
+ * context rows, and slash-command rows. Everything else stays visible —
+ * `user`/`steering` (the question), `assistant-step` (the prose, folded
+ * per-block below), `turn-tail` (the footer with its actions), and the
+ * error notices `turn-error` / `turn-max-tokens` / `model-retry`, which are
+ * exactly what a reader must not have to hunt for. */
+const PROCESS_KINDS = new Set(['context', 'tool-call', 'command'])
+
+/** Node kinds that open a new turn group. */
+const TURN_HEAD_KINDS = new Set(['user', 'steering'])
+
+/** ReasoningRow's own marker (lib/client.js:8966) — the Think disclosure
+ * rendered inside an assistant-step row, beside that step's prose. */
+const THINK = '[data-variant="think"]'
+
+/** Attribute the phone stylesheet turns into `display: none`. */
+const FOLD = 'data-mnav-fold'
+/** Per-item override written while its turn is expanded. */
+const OPEN = 'data-mnav-fold-open'
+
+/**
+ * True when the reasoning rows are the ONLY thing this row renders, so the
+ * whole flow item has to go: the flow column is `display: flex` with
+ * `gap: 16px`, and an emptied-out flex item still claims its gap — the
+ * reader would see the folded steps as a column of blank bands.
+ * Structural test, no class names: every ancestor from the reasoning rows'
+ * shared parent up to the flow item must be an only child.
+ */
+function foldsWholeRow(row: Element, thinks: readonly Element[]): boolean {
+  const first = thinks[0]
+  if (first === undefined) return false
+  const body = first.parentElement
+  if (body === null || body.childElementCount !== thinks.length) return false
+  let node: Element = body
+  while (node !== row) {
+    const parent = node.parentElement
+    if (parent === null) return false
+    if (parent.childElementCount !== 1) return false
+    node = parent
+  }
+  return true
+}
+
+/** The process items one flow row contributes: the row itself, its reasoning
+ * rows, or nothing at all. */
+function processItems(row: Element): readonly Element[] {
+  const kind = row.getAttribute('data-chat-flow-kind')
+  if (kind === null) return []
+  if (PROCESS_KINDS.has(kind)) return [row]
+  if (kind !== 'assistant-step') return []
+  const thinks = [...row.querySelectorAll(THINK)]
+  if (thinks.length === 0) return []
+  return foldsWholeRow(row, thinks) ? [row] : thinks
+}
+
+/**
+ * The summary row sitting immediately before `anchor`, created if absent.
+ * Idempotent by construction — React re-rendering the flow either leaves our
+ * button where it is (it only ever inserts and removes its OWN nodes) or
+ * drops it, and the next rescan puts it back.
+ */
+function chipBefore(anchor: Element): HTMLElement | null {
+  const previous = anchor.previousElementSibling
+  if (previous instanceof HTMLElement && previous.dataset['mobileNav'] === CHIP) return previous
+  const parent = anchor.parentElement
+  if (parent === null) return null
+  const chip = document.createElement('button')
+  chip.type = 'button'
+  chip.dataset['mobileNav'] = CHIP
+  parent.insertBefore(chip, anchor)
+  return chip
+}
+
+interface Group {
+  /** Stable id: the turn-opening row's node key (a positional id for a
+   * leading group whose question has not been paged in). */
+  readonly key: string
+  /** Every process element of this turn, in flow order. */
+  readonly items: Element[]
+}
+
+/** Split the flow column into turns: a group runs from one user/steering row
+ * up to (not including) the next. Rows that precede the first user row —
+ * a turn whose question has not been paged in yet — form a leading group of
+ * their own, so their process never becomes unreachable. */
+function groupsOf(flow: Element): readonly Group[] {
+  const groups: Group[] = []
+  let current: Group | undefined
+  for (const row of flow.children) {
+    const kind = row.getAttribute('data-chat-flow-kind')
+    if (kind === null) continue
+    if (current === undefined || TURN_HEAD_KINDS.has(kind)) {
+      current = { key: row.getAttribute('data-chat-flow-key') ?? `pos${groups.length}`, items: [] }
+      groups.push(current)
+    }
+    current.items.push(...processItems(row))
+  }
+  return groups
+}
+
+/**
+ * S8 — collapse a turn's process into one summary row (< 768px only).
+ *
+ * Route taken: DOM marking, not the `conversation.chat.node` keyed slot.
+ * That slot dispatches on node kind and a second registration at a key
+ * SHADOWS the official renderer (dsh-client-ui-slots index.d.ts:542 — the
+ * cell's lowest-priority live entry renders, there is no wrapping form and
+ * no `children` handle to the shadowed component). Taking `tool-call` would
+ * mean re-implementing every tool's presentation, its `t` seat comes from
+ * the entry's own declared locale namespace and its services from the
+ * registrant's own inject face — neither is reachable from here — and the
+ * registration is global, so the desktop no-op would be gone too.
+ *
+ * The DOM route needs no class names: ChatNodeSeat stamps every row with
+ * `data-chat-flow-kind` / `data-chat-flow-key` (lib/client.js:5228) and
+ * ReasoningRow stamps `data-variant="think"` — turn grouping is pure
+ * structure (the run of rows following one `user` row), never text.
+ *
+ * ponytail: one rAF-coalesced full rescan per DOM mutation batch, O(rows).
+ * If a very long session ever makes streaming feel heavy, narrow the
+ * observer to the flow column's own childList and diff instead.
+ */
+export function installTurnFold(ctx: ClientContext): void {
+  ctx.effect(() => {
+    const narrow = window.matchMedia(PHONE_QUERY)
+    const t = ctx.locale.bind(NS)
+    /** Turns the reader opened. Deliberately not persisted (spec: a reload
+     * returns to the default folded state). */
+    const expanded = new Set<string>()
+    let observer: MutationObserver | null = null
+    let frame = 0
+
+    const label = (chip: HTMLElement, count: number, running: boolean): void => {
+      const next = running ? t('turnFoldRunning', { count }) : t('turnFold', { count })
+      if (chip.textContent !== next) chip.textContent = next
+    }
+
+    const scan = (): void => {
+      const flow = document.querySelector(FLOW)
+      if (flow === null) return
+      // TurnStatus, ChatView's own running banner — present only while the
+      // last turn is still working (lib/client.js:5548).
+      const running = flow.querySelector(':scope > [role="status"]') !== null
+      const groups = groupsOf(flow)
+      const live = new Set<string>()
+
+      groups.forEach((group, index) => {
+        if (group.items.length === 0) return
+        const open = expanded.has(group.key)
+        for (const item of group.items) {
+          item.setAttribute(FOLD, '')
+          if (open) item.setAttribute(OPEN, '')
+          else item.removeAttribute(OPEN)
+        }
+        const first = group.items[0]
+        if (first === undefined) return
+        const anchor = first.closest('[data-chat-flow-key]') ?? first
+        const chip = chipBefore(anchor)
+        if (chip === null) return
+        chip.dataset['foldGroup'] = group.key
+        chip.setAttribute('aria-expanded', open ? 'true' : 'false')
+        if (open) chip.dataset['open'] = ''
+        else delete chip.dataset['open']
+        const groupRunning = running && index === groups.length - 1
+        if (groupRunning) chip.dataset['running'] = ''
+        else delete chip.dataset['running']
+        label(chip, group.items.length, groupRunning)
+        live.add(group.key)
+      })
+
+      for (const chip of flow.querySelectorAll<HTMLElement>(CHIP_SELECTOR)) {
+        const key = chip.dataset['foldGroup']
+        if (key === undefined || !live.has(key)) chip.remove()
+      }
+    }
+
+    const schedule = (): void => {
+      // The locale subscription below lives outside attach/detach, so this
+      // guard is what keeps a late dictionary registration from marking up
+      // the flow at >= 768px (real WebKit regression: chips and fold
+      // attributes appeared at 1280px — invisible, since every rule that
+      // hides anything is inside the phone media query, but still wrong).
+      if (observer === null) return
+      if (frame !== 0) return
+      frame = requestAnimationFrame(() => {
+        frame = 0
+        scan()
+        // Drop the records our own chip insertions just queued, so a rescan
+        // can never re-trigger itself (the debug-badge feedback-loop freeze).
+        observer?.takeRecords()
+      })
+    }
+
+    const onClick = (event: Event): void => {
+      const target = event.target
+      if (!(target instanceof Element)) return
+      const chip = target.closest<HTMLElement>(CHIP_SELECTOR)
+      const key = chip?.dataset['foldGroup']
+      if (key === undefined) return
+      if (expanded.has(key)) expanded.delete(key)
+      else expanded.add(key)
+      scan()
+    }
+
+    const clear = (): void => {
+      for (const chip of document.querySelectorAll(CHIP_SELECTOR)) chip.remove()
+      for (const item of document.querySelectorAll(`[${FOLD}]`)) {
+        item.removeAttribute(FOLD)
+        item.removeAttribute(OPEN)
+      }
+    }
+
+    const attach = (): void => {
+      if (observer !== null) return
+      observer = new MutationObserver(schedule)
+      observer.observe(document.body, { childList: true, subtree: true })
+      document.addEventListener('click', onClick)
+      scan()
+    }
+    const detach = (): void => {
+      observer?.disconnect()
+      observer = null
+      document.removeEventListener('click', onClick)
+      if (frame !== 0) cancelAnimationFrame(frame)
+      frame = 0
+      expanded.clear()
+      clear()
+    }
+
+    if (narrow.matches) attach()
+    const onChange = (event: MediaQueryListEvent): void => (event.matches ? attach() : detach())
+    narrow.addEventListener('change', onChange)
+    // A language switch changes the chip copy of every already-rendered turn.
+    const stopLocale = ctx.locale.subscribe(schedule)
+    return () => {
+      narrow.removeEventListener('change', onChange)
+      stopLocale()
+      detach()
+    }
+  }, 'dsh-mobile-nav: turn process fold')
+}

package/src/client/index.tsx

@@ -0,0 +1,227 @@
+import type { ClientContext, SessionId, WorkspaceId } from '@deepseek-ai/dsh-client-runtime/client'
+import { MobileNavToggle } from './MobileNavToggle.tsx'
+import { MobileNavOverlay } from './MobileNavOverlay.tsx'
+import { MobileDrawerFooter } from './MobileDrawerFooter.tsx'
+import { MobileHome } from './MobileHome.tsx'
+import { MobileHeaderActions, MobileHeaderUtilities } from './MobileSessionHeader.tsx'
+import { MobileSessionInfo } from './MobileSessionInfo.tsx'
+import { MobileAttachButton } from './MobileAttachButton.tsx'
+import { MobileAttachChips } from './MobileAttachChips.tsx'
+import { createNavStore } from './nav-store.ts'
+import { MOBILE_CSS } from './styles/index.ts'
+import { installDebugBadge } from './debug.ts'
+import { installPhoneChrome, installSunkInset, installViewportHeal } from './effects/phone-chrome.ts'
+import { installAionuiCompat } from './effects/aionui-compat.ts'
+import { installHeaderStatusDot } from './effects/header-status.ts'
+import { installGestures } from './effects/gestures.ts'
+import { installTurnFold } from './effects/turn-fold.ts'
+import { NS, en, zh } from './locales.ts'
+import type { MobileNavKey } from './locales.ts'
+
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+  interface LocaleNamespaceMap {
+    /** Directory-drawer controls copy. */
+    'mobileNav': MobileNavKey
+  }
+}
+
+/** Required services (cordis fiber inject — the loader passes all module exports as an object plugin). */
+export const inject = ['slots', 'layout', 'locale', 'sessionLogDownload', 'sessions', 'workspaces']
+
+/**
+ * Mobile-adaptive shell, browser half: injects the mobile stylesheet, then
+ * contributes the directory toggle to the session header and the backdrop +
+ * floating button to the shell overlay.
+ * @param ctx - client root context.
+ */
+export function apply(ctx: ClientContext): void {
+  ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'dsh-mobile-nav: dictionaries')
+
+  ctx.effect(() => {
+    const tag = document.createElement('style')
+    tag.dataset.plugin = 'dsh-zen-remote'
+    tag.dataset.pluginCss = 'dsh-zen-remote/mobile.css'
+    tag.textContent = MOBILE_CSS
+    document.head.appendChild(tag)
+    return () => {
+      tag.remove()
+    }
+  }, 'dsh-mobile-nav: styles')
+
+  // Diagnostic overlay for phone-side repros (?mobile-nav-debug=1).
+  installDebugBadge(ctx)
+
+  installPhoneChrome(ctx)
+
+  // Standalone-PWA only: undo the WebKit keyboard bug that permanently steals
+  // the status-bar height from the viewport (the ~60px band under the
+  // composer and the session list). No-op in any browser tab.
+  installViewportHeal(ctx)
+
+  // Registered after the heal so a viewport that heals is measured healed:
+  // when the strip is real, drop the home-indicator padding that would only
+  // stack more blank page on top of it.
+  installSunkInset(ctx)
+
+  installAionuiCompat(ctx)
+
+  // Session header running-status dot (S2): no official element exists to
+  // reposition, so this reads ctx.sessions directly and self-draws via CSS.
+  installHeaderStatusDot(ctx)
+
+  // S6: content-area swipe (Chat/Trajectory) + sheet drag-to-close.
+  installGestures(ctx)
+
+  // S8: fold a turn's process (tool calls, injected context, slash commands,
+  // Think rows) behind one summary chip. Chat view only, phone only — see
+  // effects/turn-fold.ts for why the keyed conversation.chat.node seat could
+  // not carry this.
+  installTurnFold(ctx)
+
+  // Page-stack store (apply world) — created before any registration so
+  // every slot below (the phone home screen, the session header's back
+  // button) shares the exact same handle/instance.
+  const nav = createNavStore()
+
+  ctx.slots.inject('conversation.session.header.actions', () => ctx.slots.register({
+    name: 'conversation.session.header.actions',
+    id: 'mobile-nav-toggle',
+    order: 10,
+    locale: NS,
+    inject: () => ({
+      toggleSidebar: () => ctx.layout.toggleSidebar(),
+    }),
+  }, MobileNavToggle))
+
+  // Session header back button + Chat/Trajectory view-switch row (S2).
+  // Renders unconditionally; CSS (styles/header.css.ts) keeps it hidden at
+  // >= 768px. Order is irrelevant here — the phone stylesheet hides every
+  // other header.actions entry and only re-shows this one.
+  //
+  // No `store: nav` here: this slot is session-scope while `nav` already
+  // mounts at shell.overlay's root scope, and a handle can only mount
+  // under one scope (runtime throws otherwise — see nav-store.ts). The
+  // back button dispatches GO_HOME_EVENT and MobileHome applies it.
+  ctx.slots.inject('conversation.session.header.actions', () => ctx.slots.register({
+    name: 'conversation.session.header.actions',
+    id: 'mobile-header-actions',
+    order: 0,
+    locale: NS,
+  }, MobileHeaderActions))
+
+  // Session-info entry (placeholder — S4 owns the sheet) + workbench entry
+  // (dsh-better-sidebar, see MobileSessionHeader.tsx for the trigger).
+  ctx.slots.inject('conversation.session.header.utilities', () => ctx.slots.register({
+    name: 'conversation.session.header.utilities',
+    id: 'mobile-header-utilities',
+    order: 0,
+    locale: NS,
+  }, MobileHeaderUtilities))
+
+  // Session-info sheet (S4): a second, sibling entry on the SAME slot as
+  // the ⓘ button above — it listens for the CustomEvent that button fires
+  // instead of sharing render state with it. Session scope gives this
+  // entry useProjection/sessionId (the stats grid) for free alongside the
+  // always-present useSessions/useWorkspaces (see MobileSessionInfo.tsx's
+  // header comment for the full mount-point tradeoff against shell.overlay).
+  ctx.slots.inject('conversation.session.header.utilities', () => ctx.slots.register({
+    name: 'conversation.session.header.utilities',
+    id: 'mobile-session-info',
+    order: 10,
+    locale: NS,
+    // The factory's own sessionId param is unused: every function below
+    // takes its own session id explicitly (they're generic action bindings
+    // reused verbatim, not closures over one particular session).
+    inject: (_sessionId: SessionId) => ({
+      forkSession: (id: SessionId) => ctx.sessions.fork({ sessionId: id }),
+      openSession: (id: SessionId) => ctx.sessions.open(id),
+      renameSession: (id: SessionId, title: string) => ctx.sessions.binding(id)?.session.rename(title),
+      archiveSession: (id: SessionId) => ctx.workspaces.archiveSession(id),
+      downloadSessionLog: (id: SessionId) => ctx.sessionLogDownload.download(id),
+    }),
+  }, MobileSessionInfo))
+
+  // Composer attachment seat (S7). Registered unconditionally;
+  // styles/composer.css.ts hides it at >= 768px and orders it into the
+  // leftmost seat of the phone composer row.
+  //
+  // No `inject` here: every attachment now rides the host upload route and
+  // the standard session props (`sessionId`, `inputActions`), so the button
+  // needs nothing bound off ctx. S7.1 removed the session.prompt binding that
+  // used to send inlineable images straight into the conversation.
+  ctx.slots.inject('conversation.input.left', () => ctx.slots.register({
+    name: 'conversation.input.left',
+    id: 'mobile-attach',
+    order: 0,
+    locale: NS,
+  }, MobileAttachButton))
+
+  // Attachment preview row (S7.1), above the composer card. Renders purely
+  // off the draft's @.dsh-uploads/ tokens — see MobileAttachChips.tsx. Order 0
+  // puts it left of the git branch chip (order 100) on the shared dock line.
+  ctx.slots.inject('conversation.input.dock', () => ctx.slots.register({
+    name: 'conversation.input.dock',
+    id: 'mobile-attach-chips',
+    order: 0,
+    locale: NS,
+  }, MobileAttachChips))
+
+  ctx.slots.inject('shell.overlay', () => ctx.slots.register({
+    name: 'shell.overlay',
+    id: 'mobile-nav-overlay',
+    order: 10,
+    locale: NS,
+    inject: () => ({
+      toggleSidebar: () => ctx.layout.toggleSidebar(),
+    }),
+  }, MobileNavOverlay))
+
+  // Phone app shell (< 768px): the full-screen session list that is level 1
+  // of the page stack. Owns the `nav` handle created above (root scope);
+  // the session header's back button listens for GO_HOME_EVENT instead of
+  // sharing the handle directly (see nav-store.ts and the comment above).
+  ctx.slots.inject('shell.overlay', () => ctx.slots.register({
+    name: 'shell.overlay',
+    id: 'mobile-home',
+    order: 20,
+    locale: NS,
+    store: nav,
+    inject: () => ({
+      openSession: (id: SessionId) => ctx.sessions.open(id),
+      startSession: (workspaceId?: WorkspaceId) => ctx.workspaces.startSession(workspaceId),
+      // S5 session-log chip — the same service call MobileDrawerFooter uses.
+      downloadSessionLog: (id: SessionId) => ctx.sessionLogDownload.download(id),
+    }),
+  }, MobileHome))
+
+  // Session log download, relocated from the session header to the drawer
+  // footer on mobile (the header capsule is hidden by CSS); the drawer
+  // footer also hosts the Files action that opens the dsh-web-ui explorer
+  // sheet.
+  //
+  // Footer stacking relies on the list-slot sort by (priority, order):
+  // dsh-remote-web-ui leaves it unset (default 0, its two icon buttons stay
+  // on top) and dsh-usage-stats uses 10. Order 5 keeps the Files + Session
+  // log pills directly under the icon row with the usage/balance badge
+  // below them — instead of a tie at 10 where registration order could
+  // wedge the badge between the icons and the pills.
+  ctx.slots.inject('sidebar.footer.action', () => ctx.slots.register({
+    name: 'sidebar.footer.action',
+    id: 'mobile-nav-session-log',
+    order: 5,
+    locale: NS,
+    inject: () => ({
+      downloadSessionLog: (sessionId: string) => ctx.sessionLogDownload.download(sessionId),
+      toggleSidebar: () => ctx.layout.toggleSidebar(),
+    }),
+  }, MobileDrawerFooter))
+}
+
+// Type-only augmentation imports: pull the layout / conversation / sidebar
+// SlotMap merges and the sessionLogDownload service typing into this program
+// without any runtime import.
+import type {} from '@deepseek-ai/dsh-client-ui-layout/client'
+import type {} from '@deepseek-ai/dsh-client-ui-conversation/client'
+import type {} from '@deepseek-ai/dsh-client-ui-sidebar/client'
+import type {} from '@deepseek-ai/dsh-client-locale/client'
+import type {} from '@deepseek-ai/dsh-session-log-export/client'

package/src/client/locales.ts

@@ -0,0 +1,109 @@
+/** `mobileNav` namespace dictionaries: drawer controls. */
+export const NS = 'mobileNav'
+
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export const zh = {
+  'open': '打开目录',
+  'close': '收起目录',
+  'backdrop': '点击关闭目录',
+  'sessionLog': '导出会话日志',
+  'files': '文件浏览',
+  'previewFullscreen': '全屏预览',
+  'previewExitFullscreen': '退出全屏',
+  'allWorkspaces': '全部',
+  'switchWorkspace': '切换工作区',
+  'newSession': '新建会话',
+  'noSessions': '还没有会话，点右下角加号开始',
+  'homeStatusOngoing': '运行中',
+  'homeStatusWarning': '待处理',
+  'homeStatusDone': '已完成',
+  'backToList': '返回会话列表',
+  'sessionInfo': '会话信息',
+  'workbench': '工作台',
+  'workbenchClose': '关闭工作台',
+  'switchView': '切换视图',
+  'attach': '添加附件',
+  'attachBusy': '上传中…',
+  'attachFailed': '上传失败，点按重试',
+  'attachRemove': '移除附件 {name}',
+  'infoClose': '关闭',
+  'infoMode': '模式',
+  'infoCwdFallback': '未知目录',
+  'infoSubagents': '{count} 个子代理',
+  'infoStatTurns': '轮次',
+  'infoStatSteps': '步骤',
+  'infoStatTtft': '首字延迟',
+  'infoStatLlm': '模型耗时',
+  'infoStatTool': '工具耗时',
+  'infoStatTokens': 'Token',
+  'infoCacheHit': '缓存 {percent}%',
+  'infoExport': '导出日志',
+  'infoRename': '重命名',
+  'infoRenamePrompt': '会话新名称',
+  'infoFork': 'Fork 会话',
+  'infoArchive': '归档',
+  'infoArchiveConfirm': '归档后将从会话列表隐藏，确定继续？',
+  'infoActionError': '操作失败：{message}',
+  'turnFold': '过程 · {count} 步',
+  'turnFoldRunning': '进行中 · {count} 步',
+  'settings': '设置',
+  'chipTaskboard': '任务看板',
+  'chipSsh': 'SSH',
+  'chipUsage': '用量',
+  'chipCustomize': '自定义入口',
+} as const
+
+/** English dictionary, key-identical to the Chinese source of truth. */
+export const en: Record<MobileNavKey, string> = {
+  'open': 'Open directory',
+  'close': 'Close directory',
+  'backdrop': 'Click to close directory',
+  'sessionLog': 'Session log',
+  'files': 'Files',
+  'previewFullscreen': 'Fullscreen preview',
+  'previewExitFullscreen': 'Exit fullscreen',
+  'allWorkspaces': 'All',
+  'switchWorkspace': 'Switch workspace',
+  'newSession': 'New session',
+  'noSessions': 'No sessions yet — tap + to start one',
+  'homeStatusOngoing': 'Running',
+  'homeStatusWarning': 'Needs attention',
+  'homeStatusDone': 'Done',
+  'backToList': 'Back to sessions',
+  'sessionInfo': 'Session info',
+  'workbench': 'Workbench',
+  'workbenchClose': 'Close workbench',
+  'switchView': 'Switch view',
+  'attach': 'Add attachment',
+  'attachBusy': 'Uploading…',
+  'attachFailed': 'Upload failed — tap to retry',
+  'attachRemove': 'Remove attachment {name}',
+  'infoClose': 'Close',
+  'infoMode': 'Mode',
+  'infoCwdFallback': 'Unknown directory',
+  'infoSubagents': '{count} subagents',
+  'infoStatTurns': 'Turns',
+  'infoStatSteps': 'Steps',
+  'infoStatTtft': 'TTFT',
+  'infoStatLlm': 'LLM time',
+  'infoStatTool': 'Tool time',
+  'infoStatTokens': 'Tokens',
+  'infoCacheHit': 'Cache {percent}%',
+  'infoExport': 'Export log',
+  'infoRename': 'Rename',
+  'infoRenamePrompt': 'New session name',
+  'infoFork': 'Fork session',
+  'infoArchive': 'Archive',
+  'infoArchiveConfirm': 'Archiving hides this session from the list. Continue?',
+  'infoActionError': 'Action failed: {message}',
+  'turnFold': 'Process · {count} steps',
+  'turnFoldRunning': 'Working · {count} steps',
+  'settings': 'Settings',
+  'chipTaskboard': 'Task board',
+  'chipSsh': 'SSH',
+  'chipUsage': 'Usage',
+  'chipCustomize': 'Customize shortcuts',
+}
+
+/** Key domain of the `mobileNav` namespace (zh is the source of truth). */
+export type MobileNavKey = keyof typeof zh

package/src/client/nav-store.ts

@@ -0,0 +1,78 @@
+import { defineStore } from '@deepseek-ai/dsh-client-runtime/client'
+import type { WorkspaceId } from '@deepseek-ai/dsh-client-runtime/client'
+
+/** The two levels of the phone page stack. */
+export type MobileView = 'home' | 'session'
+
+/**
+ * Session-list workspace filter: a pinned workspace, the explicit "all"
+ * choice, or `null` — the untouched default that follows the current
+ * session's workspace (resolved in the component, so a workspace that only
+ * appears after the first baseline still lands).
+ */
+export type WorkspaceFilter = WorkspaceId | 'all' | null
+
+/**
+ * `window` event a `conversation.session.header.*` slot (session scope)
+ * fires to move the ROOT-scope nav store back to `home` — see
+ * {@link GO_HOME_EVENT} below for why a store handle cannot cross this
+ * particular scope boundary directly.
+ */
+export const GO_HOME_EVENT = 'dsh-mobile-nav:go-home'
+
+/**
+ * `window` event the header's ⓘ button (`conversation.session.header.utilities`,
+ * session scope) fires to open the session-info sheet (S4, MobileSessionInfo.tsx)
+ * — a second, sibling entry on the SAME slot. Not a store handle for the same
+ * reason {@link GO_HOME_EVENT} isn't: two independent registrations sharing
+ * one scope could hold a common handle instead, but keeping the info sheet's
+ * open/closed state fully local (a plain `useState`) is simpler than adding a
+ * second store, and the event is one line either way.
+ */
+export const SESSION_INFO_EVENT = 'dsh-mobile-nav:session-info'
+
+/**
+ * Phone page-stack store (phone breakpoint only; the tablet/desktop layouts
+ * never read it). Deliberately NOT persisted: the spec's launch rule is
+ * "always land on the session list", so a reload must reset to `home`.
+ *
+ * Built by a factory instead of a module-level constant: a module-scope
+ * handle is a disguised singleton across plugin reloads (ui-slots docs).
+ *
+ * One handle IS shared by every registration of one apply() — but only
+ * within the SAME slot scope. This handle mounts at `shell.overlay`, a
+ * ROOT-scope slot (MobileHome.tsx); declaring the identical handle on a
+ * SESSION-scope slot (e.g. `conversation.session.header.actions`) throws at
+ * runtime ("store handle mounted under ... is already mounted under scope
+ * ...", confirmed 2026-08-17) — the framework creates one live instance per
+ * (handle, scope), and root/session are different scopes even for the same
+ * handle. A session-scope registration that needs to move the page stack
+ * (the S2 header back button) cannot hold `actions.show` directly; it
+ * dispatches {@link GO_HOME_EVENT} instead, and MobileHome — already
+ * mounted with this store — is the one that calls `actions.show('home')`.
+ * @returns a fresh store handle, shared by every SAME-SCOPE registration of
+ * one apply().
+ */
+export function createNavStore() {
+  return defineStore({
+    init: () => ({ view: 'home' as MobileView, workspace: null as WorkspaceFilter }),
+    actions: {
+      /**
+       * Move the page stack.
+       * @param draft - store draft.
+       * @param view - target level.
+       */
+      show: (draft, view: MobileView) => {
+        draft.view = view
+      },
+      /**
+       * Pin the session-list workspace filter.
+       * @param draft - store draft.
+       * @param workspace - workspace id, or 'all'.
+       */
+      filter: (draft, workspace: WorkspaceFilter) => {
+        draft.workspace = workspace
+      },
+    },
+  })
+}