dsh-zen-remote 1.1.16 → 2.0.0

package/src/client/remote-group-expansion.ts

@@ -0,0 +1,190 @@
+/**
+ * T64: the keeper that remembers and restores the SERVER groups' expansion
+ * across page loads. The host purges its own expansion record of every key
+ * not in the current workspace list the moment that list goes ready
+ * (`retainAccountKeys`) — on a sub-client the local workspaces go ready
+ * first, so the `zr~…` keys die on every load and every server group comes
+ * back collapsed. This module mirrors the host's record into the plugin's
+ * OWN storage key while it exists and re-applies it once the host has
+ * dropped it, by clicking the group row — a real user click, so the host
+ * writes its own state back and the two never disagree.
+ *
+ * Per tick: sync the host-recorded `zr~` keys into the plugin record
+ * (the host's value IS the user's latest choice), then for each server
+ * group row the host holds NO record for, click it when its
+ * `aria-expanded` disagrees with the wanted state — the plugin record's
+ * value, defaulting to EXPANDED (the group was showing its sessions before
+ * the purge). A group the host already records is never touched. One group
+ * is auto-clicked at most ONCE per page load — if the click did not land
+ * (React lag, a lost race with the host's own write), re-clicking would
+ * only fight the host. A DOM that does not match the expected shape (no
+ * row, no `aria-expanded`) is skipped silently.
+ *
+ * Runs only in the CLIENT role, via the SAME cached client-config probe as
+ * the current-session reporter (T62) — a host has no server groups. The
+ * tick cadence is its own 1s interval (the shared shape, not a shared
+ * timer): the restore must land right after the workspace list merges,
+ * whenever that happens.
+ */
+import {
+  HOST_WORKSPACE_VIEW_KEY,
+  REMOTE_GROUP_EXPANSION_KEY,
+  parseExpansionRecord,
+  parseHostGroupExpansion,
+  planRemoteGroupExpansion,
+} from '../client-data/remote-group-expansion.ts'
+import { probeClientConfigRole } from './remote-share-register.ts'
+
+const CHECK_INTERVAL_MS = 1_000
+
+const ROW_SELECTOR = '[role="treeitem"][data-row-key^="workspace:zr~"]'
+const ROW_KEY_PREFIX = 'workspace:'
+
+/** The one row face used: read the two attributes, click like a user. */
+interface RowElement {
+  getAttribute(name: string): string | null
+  click(): void
+}
+
+/** The storage face used, narrowed to the two methods (structurally typed:
+ * this module compiles under the client tsconfig with DOM lib, but tests
+ * inject stubs). */
+interface StorageLike {
+  getItem(key: string): string | null
+  setItem(key: string, value: string): void
+}
+
+interface DocumentLike {
+  querySelectorAll(selectors: string): Iterable<Element>
+}
+
+/** One matched row: the group id, its current expansion, and the click. */
+interface RowHandle {
+  key: string
+  expanded: boolean
+  click(): void
+}
+
+export interface RemoteGroupExpansionKeeperOptions {
+  /** Both storage reads and writes. Default: the page's localStorage; a
+   * broken or absent one makes every tick a no-op. */
+  storage?: StorageLike
+  /** The role probe. Default: the shared cached client-config probe. */
+  probeRole?: () => Promise<'host' | 'client' | undefined>
+  /** The sidebar's server group rows. Default: the real DOM query — rows
+   * without a readable `aria-expanded` are skipped. Tests inject fake rows
+   * with click recorders. */
+  queryRows?: () => RowHandle[]
+  /** The re-check interval; default 1000ms. */
+  intervalMs?: number
+}
+
+/**
+ * Start the keeper loop. Returns the disposer (interval) the mounting
+ * effect calls on teardown.
+ */
+export function startRemoteGroupExpansionKeeper(options: RemoteGroupExpansionKeeperOptions = {}): () => void {
+  const readStorage = (): StorageLike | undefined => {
+    const storage = options.storage ?? (globalThis as { localStorage?: StorageLike | null }).localStorage
+    return storage !== null && storage !== undefined && typeof storage.getItem === 'function' && typeof storage.setItem === 'function'
+      ? storage
+      : undefined
+  }
+  const probeRole = options.probeRole ?? probeClientConfigRole
+  const queryRows = options.queryRows ?? (() => {
+    const doc = (globalThis as { document?: DocumentLike }).document
+    if (doc === undefined) return []
+    const out: RowHandle[] = []
+    for (const el of doc.querySelectorAll(ROW_SELECTOR)) {
+      const row = el as unknown as RowElement
+      const rowKey = row.getAttribute('data-row-key')
+      const expanded = row.getAttribute('aria-expanded')
+      if (rowKey === null || expanded === null) continue
+      out.push({ key: rowKey.slice(ROW_KEY_PREFIX.length), expanded: expanded === 'true', click: () => row.click() })
+    }
+    return out
+  })
+
+  let role: 'host' | 'client' | undefined
+  // One auto-click per group per page load, ever — not per tick. (T66: a
+  // group whose ROW disappears has its marker dropped — see the tick.)
+  const clickedOnce = new Set<string>()
+  let inFlight = false
+
+  // T66: a storage write/read can throw (a private-mode quota, a poisoned
+  // extension wrapper) — one bad key must not reject the tick's promise or
+  // kill the loop. A failed read degrades to "absent" (the pure layer's
+  // empty-record rule), a failed write is skipped until the next tick.
+  const readKey = (storage: StorageLike, key: string): string | null => {
+    try {
+      return storage.getItem(key)
+    } catch {
+      return null
+    }
+  }
+  const writeKey = (storage: StorageLike, key: string, value: string): void => {
+    try {
+      storage.setItem(key, value)
+    } catch {
+      // Silent: the next tick recomputes and tries again.
+    }
+  }
+
+  const tick = async (): Promise<void> => {
+    if (role === undefined) {
+      const answer = await probeRole()
+      // A failed probe changes nothing — the next tick asks again; a
+      // definite answer is stable for the page's life.
+      if (answer !== undefined) role = answer
+    }
+    if (role !== 'client') return
+    const storage = readStorage()
+    if (storage === undefined) return
+    // A malformed value on either side degrades to an empty record (the
+    // pure layer's rule) — a wiped plugin record then re-applies the
+    // default-expanded state, which is the honest reading of "no memory".
+    const hostRecord = parseHostGroupExpansion(readKey(storage, HOST_WORKSPACE_VIEW_KEY))
+    const pluginRecord = parseExpansionRecord(readKey(storage, REMOTE_GROUP_EXPANSION_KEY))
+    const rowHandles = queryRows()
+    // T66: a group whose row left the DOM (a server switch, a workspace
+    // list refresh) loses its once-per-load marker — when the row comes
+    // back it may be restored once more, exactly like on a fresh load.
+    const presentKeys = new Set(rowHandles.map((handle) => handle.key))
+    for (const key of [...clickedOnce]) {
+      if (!presentKeys.has(key)) clickedOnce.delete(key)
+    }
+    const plan = planRemoteGroupExpansion({
+      hostRecord,
+      pluginRecord,
+      rows: rowHandles.map(({ key, expanded }) => ({ key, expanded })),
+    })
+    const nextRecordJson = JSON.stringify(plan.record)
+    if (nextRecordJson !== JSON.stringify(pluginRecord)) {
+      writeKey(storage, REMOTE_GROUP_EXPANSION_KEY, nextRecordJson)
+    }
+    for (const key of plan.clicks) {
+      if (clickedOnce.has(key)) continue
+      clickedOnce.add(key)
+      rowHandles.find((candidate) => candidate.key === key)?.click()
+    }
+  }
+  const tickOnce = (): void => {
+    // One re-check at a time: a slow tick must not pile up parallel tries.
+    if (inFlight) return
+    inFlight = true
+    void tick().finally(() => { inFlight = false })
+  }
+
+  const timer = setInterval(() => { tickOnce() }, options.intervalMs ?? CHECK_INTERVAL_MS)
+  tickOnce()
+  return () => { clearInterval(timer) }
+}
+
+/**
+ * Mount the keeper as one page-lifetime effect, beside the current-session
+ * reporter (T62): before the desktop-shell gate in apply(), same client-role
+ * probe, same 1s cadence — its own timer, its own file.
+ */
+export function mountRemoteGroupExpansionKeeper(ctx: { effect(fn: () => () => void, name: string): void }, options: RemoteGroupExpansionKeeperOptions = {}): void {
+  ctx.effect(() => startRemoteGroupExpansionKeeper(options), 'dsh-zen-remote: remote group expansion keeper')
+}

package/src/client/remote-share-css.ts

@@ -0,0 +1,54 @@
+/**
+ * Styles for the T33b session-sharing parts — the title-row remote icon's
+ * three states and nothing else (the menu item is an official
+ * MenuItemButton and needs no CSS; the settings list draws on the settings
+ * block's own zr-settings-* sheet). Injected as one
+ * `<style data-plugin="dsh-zen-remote-remote-share">` tag BEFORE apply's
+ * desktop gate: the desktop app IS the main server and its title row is
+ * where the icon lives. Every selector is scoped under the button's own
+ * attribute, so nothing here can reach host elements (the title row's
+ * layout especially — this box is a fixed 28px grid item and shrinks for
+ * nobody).
+ *
+ * On the phone shell the icon needs no rules of its own: the mobile
+ * stylesheet blanket-hides every child of the
+ * `conversation.session.header.actions` slot wrapper (styles/header.css.ts),
+ * which this entry is.
+ */
+
+export const REMOTE_SHARE_CSS = `
+button.zr-remote-toggle[data-zen-remote="remote-toggle"] {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 28px;
+  height: 28px;
+  flex-shrink: 0;
+  padding: 0;
+  border: none;
+  border-radius: 6px;
+  background: transparent;
+  color: var(--dsw-alias-label-tertiary);
+  cursor: pointer;
+  position: relative;
+}
+button.zr-remote-toggle[data-zen-remote="remote-toggle"]:hover {
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+button.zr-remote-toggle[data-zen-remote="remote-toggle"][data-state="on"],
+button.zr-remote-toggle[data-zen-remote="remote-toggle"][data-state="watched"] {
+  color: var(--dsw-alias-state-business-primary, #4f6ef7);
+}
+/* The "a desktop client is watching" dot: a live signal outside the glyph's
+   box so it never collides with the 16px artwork. */
+button.zr-remote-toggle[data-zen-remote="remote-toggle"][data-state="watched"]::after {
+  content: '';
+  position: absolute;
+  top: 3px;
+  right: 3px;
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: var(--dsw-alias-state-success-primary, #16a34a);
+}
+`

package/src/client/remote-share-register.ts

@@ -0,0 +1,244 @@
+/**
+ * Registration for the T33b session-sharing parts — the work that must run
+ * BEFORE apply's desktop-shell gate (the desktop app IS the main server:
+ * its title row and session menus are exactly where these parts live),
+ * extracted so the Node-side desktop-gate test can drive it against a fake
+ * ctx (the components are .tsx; they arrive as parameters, keeping this
+ * module JSX-free and importable under Node's type stripping — the same
+ * trick register-settings.ts uses).
+ *
+ * Registers the title-row remote icon on
+ * `conversation.session.header.actions` (order 25, past the official jobs
+ * entry at 20 so the two never tie) and the remote toggle on
+ * `sidebar.workspaces.session.menu.item` (order 500, under the official
+ * archive row, behind a group hairline), plus the one stylesheet both
+ * surfaces need.
+ *
+ * The parts render and poll only on the HOST role (T33b-fix): this module
+ * wires the shares store's role from the SAME two-level decision the
+ * settings page makes (settings-form.ts's shared `settingsRoleOf`) — the
+ * configForms row document first, and while the row is silent the effective
+ * role probed from `/_dsh/mobile-nav/client-config` (T17: the route carries
+ * the merged role). The decision re-runs on every scope snapshot update, so
+ * a snapshot that resolves late — or a row whose role appears after the
+ * probe already answered — re-decides, and a deployment switched back to
+ * host recovers. The wiring hangs off a lazy `ctx.inject(['configForms'], …)`;
+ * where the settings service never arrives, one fallback probe wires the
+ * role on its own (guarded: a snapshot answer always wins over it).
+ *
+ * The `sidebar.workspaces.session.menu.item` SlotMap entry is declared here
+ * as a structural mirror: this package does not depend on
+ * dsh-client-ui-workspace (the slot's owner), whose type-only merges would
+ * normally provide it. The mirror records what the workspace browser
+ * actually hands its entries: the row props (`sessionId`, `displayTitle`),
+ * the `[open, setOpen]` pair it passes as the render occurrence's
+ * hookContext, and the list-level inject whose `menuOpenState` hook factory
+ * binds that pair — official rows call it `useMenuOpenState` and close the
+ * menu with it.
+ */
+import type { ReactNode } from 'react'
+import type { SessionId } from './compat/types.ts'
+import type { ClientContext } from './compat/types.ts'
+import { getSharesStore } from '../client-data/shares.ts'
+import type { SharesStore } from '../client-data/shares.ts'
+import { CLIENT_CONFIG_ROUTE, savedRowRole, settingsRoleOf } from '../client-data/settings-form.ts'
+import type { ClientConfigBody } from '../client-data/settings-form.ts'
+import { NS } from './locales.ts'
+import { REMOTE_SHARE_CSS } from './remote-share-css.ts'
+import { SETTINGS_ENTRY_ID } from './settings/register-settings.ts'
+import type { RemoteHeaderIconProps } from './RemoteHeaderIcon.tsx'
+import type { RemoteShareMenuProps } from './RemoteShareMenu.tsx'
+
+/** The `[open, setOpen]` pair the workspace Menu hands every row entry. */
+export type SessionMenuOpenState = readonly [boolean, (open: boolean) => void]
+
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+  interface SlotMap {
+    'sidebar.workspaces.session.menu.item': {
+      kind: 'list'
+      scope: 'root'
+      owner: { sessionId: SessionId, displayTitle: string }
+      hookContext: SessionMenuOpenState
+      inject: { hooks: { menuOpenState: (context: unknown) => () => SessionMenuOpenState } }
+    }
+  }
+}
+
+/** The header icon component (a .tsx factory result; parameter for Node). */
+export type RemoteHeaderIconComponent = (props: RemoteHeaderIconProps) => ReactNode
+/** The menu-item component (a .tsx factory result; parameter for Node). */
+export type RemoteShareMenuComponent = (props: RemoteShareMenuProps) => ReactNode
+
+/**
+ * The page's one client-config probe (T17's fallback role source). Only a
+ * DEFINITE answer is cached — the route answered with a body, so its role
+ * reading is stable for the process's lifetime (the role cannot change
+ * without a restart). A FAILED probe (network error, non-2xx, unparseable
+ * body) resolves `undefined` and is NOT cached: the next snapshot update
+ * probes again, and until one answers the role reads unknown — never a
+ * guessed host (T33b-fix2). `refetch` bypasses the cache and replaces it
+ * with a fresh answer; the wiring uses it when the form scope's status
+ * changed (the settings page re-probes on the same signal). Exported since
+ * T62: the current-session reporter reuses the same cached probe (one
+ * route read per page, whatever part asks first).
+ */
+let probeAnswer: 'host' | 'client' | undefined
+let probeInFlight: Promise<'host' | 'client' | undefined> | undefined
+export function probeClientConfigRole(refetch = false): Promise<'host' | 'client' | undefined> {
+  if (!refetch) {
+    if (probeAnswer !== undefined) return Promise.resolve(probeAnswer)
+    if (probeInFlight !== undefined) return probeInFlight
+  }
+  // Always tracked so a settled probe — failed ones especially — never
+  // lingers: a stale in-flight promise would hand future probes its old
+  // `undefined` without asking the route again.
+  probeInFlight = fetch(CLIENT_CONFIG_ROUTE)
+    .then((res) => (res.ok ? res.json() as Promise<ClientConfigBody> : undefined))
+    .then((body) => {
+      // A body without a role field (an older build) still reads host —
+      // resolveConfig's "anything not exactly 'client'" default; only a
+      // request-level failure stays undefined.
+      const answer: 'host' | 'client' | undefined = body === undefined ? undefined : body.role === 'client' ? 'client' : 'host'
+      if (answer !== undefined) probeAnswer = answer
+      return answer
+    })
+    .catch(() => undefined)
+    .finally(() => { probeInFlight = undefined })
+  return probeInFlight
+}
+
+/** How one probe is issued — the real route reader, or the check/test
+ * double. `refetch` mirrors {@link probeClientConfigRole}: true drops any
+ * cached answer and asks again. */
+export type ClientConfigProbe = (refetch?: boolean) => Promise<'host' | 'client' | undefined>
+
+export interface WireSharesRoleOptions {
+  /** Called once a definite verdict was applied (the no-configForms
+   * fallback checks this before trusting its own probe). */
+  onVerdict?: () => void
+  /** The probe to consult while the row document is silent. Defaults to
+   * the real client-config reader; tests inject a controllable double so
+   * they never depend on module-level probe state. */
+  probe?: ClientConfigProbe
+}
+
+/**
+ * Wire a shares store's role off one configForms scope: the saved row role
+ * wins (settingsRoleOf), while the row is silent the client-config probe
+ * fills the gap, and every scope update re-decides. Verdicts of
+ * `'unknown'` — snapshot still loading, probe pending or FAILED — leave
+ * the store untouched: nothing polls and nothing renders (never a guessed
+ * host). A scope STATUS change (loading→ready, a mirror resync) drops the
+ * probe answer and probes again, the same two signals the settings page's
+ * probe effect re-runs on.
+ * @param scope - the plugin row's shared configuration form scope.
+ * @param store - the shares store whose role this wiring drives.
+ * @param options - verdict callback and probe injection.
+ * @returns disposer releasing the scope subscription.
+ */
+export function wireSharesRole(
+  scope: {
+    getSnapshot(): { status: 'loading' | 'ready' | 'unavailable', value?: unknown, user?: unknown }
+    subscribe(listener: () => void): () => void
+  },
+  store: Pick<SharesStore, 'setRole'>,
+  options: WireSharesRoleOptions = {},
+): () => void {
+  const { onVerdict, probe = probeClientConfigRole } = options
+  let probed: 'host' | 'client' | undefined
+  let lastStatus: 'loading' | 'ready' | 'unavailable' | undefined
+  let probing = false
+  /** Re-decide. `fromProbe` marks the re-entry after a probe settled: the
+   * answer is already in `probed`, and starting another probe here would
+   * loop (a failed answer re-probing forever, a cached one starving the
+   * event loop). Snapshot updates enter through `apply` instead. */
+  const evaluate = (fromProbe: boolean): void => {
+    const snap = scope.getSnapshot()
+    // The form scope moved between loading/ready/unavailable: the previous
+    // probe answer no longer stands in for this state — ask again (the
+    // settings page's effect re-runs on exactly this signal).
+    const statusChanged = lastStatus !== undefined && snap.status !== lastStatus
+    lastStatus = snap.status
+    if (statusChanged) probed = undefined
+    // The row document answers first; only a row-silent snapshot needs the
+    // probe (the settings page's exact rule — see settingsRoleOf). A failed
+    // probe is not remembered: the NEXT snapshot update probes again — the
+    // probe's own completion path must not (see fromProbe).
+    const rowRole = savedRowRole(snap)
+    if (!fromProbe && snap.status !== 'loading' && rowRole === undefined && !probing) {
+      probing = true
+      void probe(statusChanged).then((answer) => {
+        probing = false
+        // A FAILED probe changes no verdict — leave the role exactly as it
+        // was (unknown stays unknown; never a guessed host) and wait for
+        // the next snapshot update to try again.
+        if (answer === undefined) return
+        probed = answer
+        evaluate(true)
+      })
+    }
+    const verdict = settingsRoleOf(snap.status, snap, probed)
+    if (verdict === 'unknown') return
+    onVerdict?.()
+    store.setRole(verdict)
+  }
+  const apply = (): void => { evaluate(false) }
+  apply()
+  return scope.subscribe(apply)
+}
+
+/**
+ * Register the stylesheet and the two sharing parts. Gate-independent by
+ * design — the caller (apply) places this before its desktop gate.
+ * @param ctx - client root context.
+ * @param headerIcon - the title-row icon component.
+ * @param menuItem - the session-menu toggle component.
+ */
+export function registerRemoteShareUi(
+  ctx: ClientContext,
+  headerIcon: RemoteHeaderIconComponent,
+  menuItem: RemoteShareMenuComponent,
+): void {
+  ctx.effect(() => {
+    const tag = document.createElement('style')
+    tag.dataset.plugin = 'dsh-zen-remote-remote-share'
+    tag.textContent = REMOTE_SHARE_CSS
+    document.head.appendChild(tag)
+    return () => { tag.remove() }
+  }, 'dsh-zen-remote: remote-share styles')
+
+  ctx.slots.inject('conversation.session.header.actions', () => ctx.slots.register({
+    name: 'conversation.session.header.actions',
+    id: 'remote-share-icon',
+    order: 25,
+    locale: NS,
+    inject: () => ({ shares: getSharesStore() }),
+  }, headerIcon))
+
+  ctx.slots.inject('sidebar.workspaces.session.menu.item', () => ctx.slots.register({
+    name: 'sidebar.workspaces.session.menu.item',
+    id: 'remote-share',
+    order: 500,
+    locale: NS,
+    inject: () => ({ shares: getSharesStore() }),
+  }, menuItem))
+
+  // The role wiring is lazy on configForms: where the service exists the
+  // scope snapshot decides (and keeps deciding on every update); where it
+  // never arrives, the fallback probe below wires the role on its own —
+  // but a snapshot answer always wins over it.
+  const store = getSharesStore()
+  let snapshotAnswered = false
+  ctx.inject(['configForms'], (formsCtx) => {
+    const scope = formsCtx.configForms.get(SETTINGS_ENTRY_ID)
+    const off = wireSharesRole(scope, store, { onVerdict: () => { snapshotAnswered = true } })
+    formsCtx.effect(() => off, 'dsh-zen-remote: remote-share role')
+  })
+  void probeClientConfigRole().then((answer) => {
+    // A definite answer wires the role; a FAILED probe wires nothing —
+    // the parts stay dark (unknown) rather than guessing host
+    // (T33b-fix2), and a wiring verdict that arrives later still wins.
+    if (snapshotAnswered || answer === undefined) return
+    store.setRole(answer)
+  })
+}

package/src/client/remote-status-css.ts

@@ -0,0 +1,64 @@
+/**
+ * Styles for the T34 sub-client status parts — the title-row connection
+ * icon's states and the composer's readonly banner. Injected as one
+ * `<style data-plugin="dsh-zen-remote-remote-status">` tag BEFORE apply's
+ * desktop gate (a desktop app in the client role has remote sessions too; on
+ * a host the parts render nothing for local sessions, so the desktop stays
+ * pixel-identical).
+ *
+ * T34-fix: the input itself is disabled through the HOST's component
+ * capability — `ctx.conversation.blocks.set(sessionId, { reason })`, the
+ * composer-block contract — not through any CSS override; what remains here
+ * is scoped under the parts' own attributes and can reach nothing but them.
+ */
+
+export const REMOTE_STATUS_CSS = `
+button.zr-remote-status[data-zen-remote="remote-status"] {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 28px;
+  height: 28px;
+  flex-shrink: 0;
+  padding: 0;
+  border: none;
+  border-radius: 6px;
+  background: transparent;
+  color: var(--dsw-alias-label-tertiary);
+  cursor: pointer;
+}
+button.zr-remote-status[data-zen-remote="remote-status"]:hover {
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+button.zr-remote-status[data-zen-remote="remote-status"][data-state="online"] {
+  color: var(--dsw-alias-state-business-primary, #4f6ef7);
+}
+/* offline / revoked / unpaired: the default grey is the state, dimmed a
+   little so a dead or unpaired link reads instantly */
+button.zr-remote-status[data-zen-remote="remote-status"][data-state="offline"],
+button.zr-remote-status[data-zen-remote="remote-status"][data-state="revoked"],
+button.zr-remote-status[data-zen-remote="remote-status"][data-state="unpaired"] {
+  color: var(--dsw-alias-label-tertiary);
+  opacity: 0.75;
+}
+button.zr-remote-status[data-zen-remote="remote-status"][data-state="mismatch"] {
+  color: var(--dsw-alias-state-warning-primary, #d97706);
+}
+
+/* The composer banner: a dock entry, so on desktop it is one full-width row
+   of the composer column (the slot anchor is display:contents and the
+   composer column is a flex column — the item stretches to the column
+   width WITHOUT an explicit width, which would stack with the side margins
+   and overflow the input column, T34-fix). Styled after the host's own
+   composer notice, standalone. */
+.zr-remote-banner[data-zen-remote="remote-banner"] {
+  box-sizing: border-box;
+  margin: 0 max(16px, var(--dsh-composer-side-clearance, 16px));
+  border-radius: var(--dsw-radius-md, 8px);
+  background: var(--dsw-alias-interactive-bg-hover, rgba(0, 0, 0, 0.04));
+  color: var(--dsw-alias-label-secondary, inherit);
+  padding: 6px 10px;
+  font-size: 12px;
+  line-height: 18px;
+}
+`

package/src/client/remote-status-register.ts

@@ -0,0 +1,107 @@
+/**
+ * Registration for the T34 sub-client status parts — the work that must run
+ * BEFORE apply's desktop gate (a desktop app in the client role has remote
+ * sessions too), extracted so the Node-side desktop-gate test can drive it
+ * against a fake ctx (the components are .tsx; they arrive as parameters,
+ * keeping this module JSX-free and importable under Node's type stripping —
+ * the same trick register-settings.ts / remote-share-register.ts use).
+ *
+ * Registers the title-row connection icon on
+ * `conversation.session.header.actions` (order 26, past the T33b share icon
+ * at 25 so the two never tie) and the composer banner on
+ * `conversation.input.dock` (order 15, between the official todo panel at 0
+ * and the queue dock at 20), plus the one stylesheet both surfaces need.
+ *
+ * The banner's disable rides the HOST's composer-block contract (T34-fix):
+ * the inject face hands the component a per-session `setComposerBlock`
+ * binding over `ctx.conversation.blocks` (dsh-client-ui-conversation's
+ * `ComposerBlocks`, resolved lazily at call time — the row context may still
+ * be assembling when this registration runs, and the composer that consumes
+ * the block is the conversation plugin's own UI, so the service is there by
+ * the time a banner can stand). A composition without the service degrades
+ * to a no-op binding: the banner still renders, the disable is simply absent.
+ *
+ * No role wiring here, unlike the T33b parts: the store only polls while a
+ * part is SUBSCRIBED, and both parts gate the subscription itself on the
+ * virtual id (remote-status.ts's subscribeIfVirtual — a local session never
+ * opens one) — so a host page never polls, without needing the settings
+ * role to tell it apart.
+ */
+import type { ReactNode } from 'react'
+import type { ClientContext, SessionId } from './compat/types.ts'
+import { getRemoteStatusStore } from '../client-data/remote-status.ts'
+import { NS } from './locales.ts'
+import { REMOTE_STATUS_CSS } from './remote-status-css.ts'
+import type { RemoteStatusIconProps } from './RemoteStatusIcon.tsx'
+import type { RemoteComposerBannerProps } from './RemoteComposerBanner.tsx'
+
+/** The icon component (a .tsx factory result; parameter for Node). */
+export type RemoteStatusIconComponent = (props: RemoteStatusIconProps) => ReactNode
+/** The composer banner component (a .tsx factory result; parameter for Node). */
+export type RemoteComposerBannerComponent = (props: RemoteComposerBannerProps) => ReactNode
+
+/**
+ * The one face of `ctx.conversation.blocks` (dsh-client-ui-conversation,
+ * `contract/composer-blocks.d.ts`) this plugin uses. A structural mirror:
+ * the providing package is a peerDependency whose type-only merges the
+ * tsconfig paths already pull in for slots, but the service itself is read
+ * lazily through `ctx.get` — the mirror keeps this module honest without
+ * hard-depending on the host's type layout.
+ */
+interface ComposerBlocksLike {
+  set(sessionId: SessionId, block: { readonly reason: string } | undefined): void
+}
+
+/** Resolve the composer-block registry at CALL time, or undefined where the
+ * conversation service never arrived (compositions without a composer — or a
+ * context shape without the lazy getter at all). */
+function composerBlocksOf(ctx: ClientContext): ComposerBlocksLike | undefined {
+  if (typeof ctx.get !== 'function') return undefined
+  const conversation = ctx.get('conversation') as { blocks?: ComposerBlocksLike } | undefined
+  return conversation?.blocks
+}
+
+/**
+ * Register the stylesheet and the two status parts. Gate-independent by
+ * design — the caller (apply) places this before its desktop gate.
+ * @param ctx - client root context.
+ * @param icon - the title-row connection icon component.
+ * @param banner - the composer banner component.
+ */
+export function registerRemoteStatusUi(
+  ctx: ClientContext,
+  icon: RemoteStatusIconComponent,
+  banner: RemoteComposerBannerComponent,
+): void {
+  ctx.effect(() => {
+    const tag = document.createElement('style')
+    tag.dataset.plugin = 'dsh-zen-remote-remote-status'
+    tag.textContent = REMOTE_STATUS_CSS
+    document.head.appendChild(tag)
+    return () => { tag.remove() }
+  }, 'dsh-zen-remote: remote-status styles')
+
+  ctx.slots.inject('conversation.session.header.actions', () => ctx.slots.register({
+    name: 'conversation.session.header.actions',
+    id: 'remote-status-icon',
+    order: 26,
+    locale: NS,
+    inject: () => ({ status: getRemoteStatusStore() }),
+  }, icon))
+
+  ctx.slots.inject('conversation.input.dock', () => ctx.slots.register({
+    name: 'conversation.input.dock',
+    id: 'remote-status-banner',
+    order: 15,
+    locale: NS,
+    inject: (sessionId: SessionId) => ({
+      status: getRemoteStatusStore(),
+      // Raise/clear THIS session's composer block (undefined clears — the
+      // contract's own clear method; `forget` would drop the store
+      // entirely and is the host's teardown verb, not ours).
+      setComposerBlock: (reason: string | undefined) => {
+        composerBlocksOf(ctx)?.set(sessionId, reason === undefined ? undefined : { reason })
+      },
+    }),
+  }, banner))
+}