dsh-zen-remote 2.3.3 → 2.3.5

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

@@ -111,39 +111,97 @@ const ACTIVE_ATTR = 'data-mnav-fold-on'
 /** Selector of the one row kind that can fold whole — see {@link foldsWholeRow}. */
 const STEP_SELECTOR = '[data-chat-flow-kind="assistant-step"]'
 
+/** Elements that show something without a text node of their own. Every other
+ * element is a wrapper: it is content only if something inside it is. */
+const SELF_VISIBLE = new Set([
+  'AUDIO', 'CANVAS', 'EMBED', 'HR', 'IFRAME', 'IMG', 'INPUT', 'OBJECT',
+  'PICTURE', 'SELECT', 'SVG', 'TEXTAREA', 'VIDEO',
+])
+
+/** The DOM surface {@link hasContentOutside} reads — kept this narrow so the
+ * verdict is testable off-DOM (test/turn-fold-blank-step.test.cjs). */
+export interface ContentNode {
+  readonly nodeType: number
+  readonly textContent: string | null
+  readonly childNodes: ArrayLike<ContentNode>
+  readonly tagName?: string
+  matches?(selector: string): boolean
+}
+
+/**
+ * True when `node` renders anything a reader could see outside the subtrees
+ * that match `skip`: a non-blank text node, or a {@link SELF_VISIBLE} element.
+ * Structural, no class names — same discipline as the rest of this effect.
+ */
+export function hasContentOutside(node: ContentNode, skip: string | null): boolean {
+  if (node.nodeType === 3) return (node.textContent ?? '').trim() !== ''
+  if (node.nodeType !== 1) return false
+  if (skip !== null && node.matches?.(skip) === true) return false
+  if (SELF_VISIBLE.has((node.tagName ?? '').toUpperCase())) return true
+  const children = node.childNodes
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i]
+    if (child !== undefined && hasContentOutside(child, skip)) return true
+  }
+  return false
+}
+
 /**
  * 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.
+ * Structural test, no class names: outside the reasoning rows the row holds
+ * nothing visible — only wrappers. Each reasoning block sits in its own
+ * ProcessReasoning wrapper, and since DSH 0.2.1-rc.5 a block whose display
+ * text is empty once a leading `<signature>…</signature>` is stripped renders
+ * its ReasoningRow as null and leaves that wrapper empty; an empty wrapper
+ * beside a Think must not keep the row unfolded.
  */
-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
+export function foldsWholeRow(row: ContentNode, thinks: readonly unknown[]): boolean {
+  if (thinks.length === 0) return false
+  return !hasContentOutside(row, THINK)
 }
 
-/** The process items one flow row contributes: the row itself, its reasoning
- * rows, or nothing at all. */
-function processItems(row: Element): readonly Element[] {
+/**
+ * True for an assistant-step row that renders nothing at all — no Think, no
+ * prose, no image, no notice. DSH 0.2.1-rc.5 produces one for a step whose
+ * only reasoning is a `<signature>…</signature>` (ReasoningRow hides itself,
+ * the wrappers stay). It is not process to count in the chip, and it is not
+ * content either: left alone it is a blank band in the flow (the gap again),
+ * so it is hidden on its own marker ({@link BLANK}) that the chip's open
+ * override never releases. On 0.2.1-rc.2, which renders such a block as an
+ * ordinary Think, the row is not blank and folds exactly as before.
+ */
+export function isBlankStep(row: ContentNode): boolean {
+  return !hasContentOutside(row, null)
+}
+
+/** Marker of a {@link isBlankStep} row; the stylesheet hides it while the
+ * fold is live. Never counted, never opened. */
+export const BLANK = 'data-mnav-blank'
+
+/** Hold {@link BLANK} on an assistant-step row exactly while it is
+ * {@link isBlankStep} — set the moment it empties, dropped the moment
+ * anything (a Think, prose, an image) arrives in it. */
+function markBlank(row: Element, thinks: readonly Element[]): void {
+  if (thinks.length === 0 && isBlankStep(row)) row.setAttribute(BLANK, '')
+  else row.removeAttribute(BLANK)
+}
+
+/** The process items one flow row contributes — the row itself, its reasoning
+ * rows, or nothing at all — and how many steps they are on the chip: a row
+ * folded whole still counts each reasoning block it holds, so the count does
+ * not depend on how the row had to be hidden. */
+function processItems(row: Element): { readonly items: readonly Element[], readonly steps: number } {
   const kind = row.getAttribute('data-chat-flow-kind')
-  if (kind === null) return []
-  if (PROCESS_KIND_SET.has(kind)) return [row]
-  if (kind !== 'assistant-step') return []
+  if (kind === null) return { items: [], steps: 0 }
+  if (PROCESS_KIND_SET.has(kind)) return { items: [row], steps: 1 }
+  if (kind !== 'assistant-step') return { items: [], steps: 0 }
   const thinks = [...row.querySelectorAll(THINK)]
-  if (thinks.length === 0) return []
-  return foldsWholeRow(row, thinks) ? [row] : thinks
+  markBlank(row, thinks)
+  if (thinks.length === 0) return { items: [], steps: 0 }
+  return { items: foldsWholeRow(row, thinks) ? [row] : thinks, steps: thinks.length }
 }
 
 /**
@@ -170,6 +228,8 @@ interface Group {
   readonly key: string
   /** Every process element of this turn, in flow order. */
   readonly items: Element[]
+  /** Steps the chip announces (see {@link processItems}). */
+  steps: number
 }
 
 /** Split the flow column into turns: a group runs from one user/steering row
@@ -183,10 +243,12 @@ function groupsOf(flow: Element): readonly Group[] {
     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: [] }
+      current = { key: row.getAttribute('data-chat-flow-key') ?? `pos${groups.length}`, items: [], steps: 0 }
       groups.push(current)
     }
-    current.items.push(...processItems(row))
+    const { items, steps } = processItems(row)
+    current.items.push(...items)
+    current.steps += steps
   }
   return groups
 }
@@ -279,7 +341,7 @@ export function installTurnFold(ctx: ClientContext): void {
         const groupRunning = running && index === groups.length - 1
         if (groupRunning) chip.dataset['running'] = ''
         else delete chip.dataset['running']
-        label(chip, group.items.length, groupRunning)
+        label(chip, group.steps, groupRunning)
         live.add(group.key)
       })
 
@@ -302,6 +364,11 @@ export function installTurnFold(ctx: ClientContext): void {
         stale.removeAttribute(FOLD)
         stale.removeAttribute(OPEN)
       }
+      // {@link BLANK} is held by groupsOf on every assistant-step row of this
+      // column; anything else carrying it left the column (or changed kind).
+      for (const stale of flow.querySelectorAll(`[${BLANK}]`)) {
+        if (stale.parentElement !== flow || !stale.matches(STEP_SELECTOR)) stale.removeAttribute(BLANK)
+      }
     }
 
     /**
@@ -359,6 +426,9 @@ export function installTurnFold(ctx: ClientContext): void {
         const thinks = [...row.querySelectorAll(THINK)]
         if (thinks.length > 0 && foldsWholeRow(row, thinks)) row.setAttribute(FOLD, '')
         else row.removeAttribute(FOLD)
+        // Same frame for the blank row (see {@link isBlankStep}): hidden
+        // before it paints its band, shown before its first content paints.
+        markBlank(row, thinks)
       }
     }
 
@@ -396,6 +466,7 @@ export function installTurnFold(ctx: ClientContext): void {
         item.removeAttribute(FOLD)
         item.removeAttribute(OPEN)
       }
+      for (const item of document.querySelectorAll(`[${BLANK}]`)) item.removeAttribute(BLANK)
     }
 
     const attach = (): void => {

package/src/client/styles/turn-fold.css.ts

@@ -83,6 +83,15 @@ const rules = (scope: string): string => `
     display: none !important;
   }
 
+  /* An assistant-step row that renders nothing at all (effects/turn-fold.ts
+     isBlankStep — DSH 0.2.1-rc.5 leaves one behind for a step whose only
+     reasoning is a <signature>…</signature>). Not a step: never counted on
+     the chip and never released by the open override, it would only ever
+     paint the flow column's 16px gap as a blank band. Literal mirror of BLANK in effects/turn-fold.ts. */
+  ${scope} [data-chat-flow] > [data-mnav-blank] {
+    display: none !important;
+  }
+
   /* Compact chip, sized like the composer's own pills rather than a button:
      it is a reading affordance in the middle of the message flow, so it has
      to stay quieter than the content around it. The flow column is a flex

package/src/client-data/wizard.ts

@@ -401,7 +401,7 @@ export function nginxSnippetText(input: SnippetInput): string | null {
     '        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;',
     '        proxy_set_header X-Forwarded-Proto $scheme;',
     '        proxy_buffering off;',
-    '        client_max_body_size 128m;',
+    '        client_max_body_size 512m;',
     '        proxy_read_timeout 3600s;',
     '        proxy_send_timeout 3600s;',
     '    }',

package/src/index.ts

@@ -16,6 +16,7 @@
  */
 
 import { createOwnerPeerSource, createSharedApiFetchGetter } from './owner-peer.js'
+import { readFileSync } from 'node:fs'
 import { lstat, mkdir, open, realpath, rename, rm, writeFile } from 'node:fs/promises'
 import type { FileHandle } from 'node:fs/promises'
 import type { IncomingMessage, ServerResponse } from 'node:http'
@@ -55,7 +56,7 @@ import { createRelayClient, RelayError, volatileUpdateTouchesServerName } from '
 import type { RelayClient } from './relay-client.js'
 import { computeFingerprints } from './fingerprint.js'
 import { runSelfCheck, installIntercept } from './intercept.js'
-import type { CurrentSessionRead, InterceptDiagnostics, InterceptHandle } from './intercept.js'
+import type { CurrentSessionRead, InterceptDiagnostics, InterceptHandle, SessionInventorySlot } from './intercept.js'
 import { checkGatewayShape } from './intercept-shape.js'
 import type { GatewayShapeCheck } from './intercept-shape.js'
 import { checkFetchRouteShape, installFetchRouteIntercept } from './fetch-route-intercept.js'
@@ -65,6 +66,12 @@ import type { PluginRouteInterceptDiagnostics, PluginRouteInterceptHandle, WebSe
 import { normalizeAdapter, adapterOwnsRegistryEntry } from './plugin-adapter-core.js'
 import type { NormalizedAdapter } from './plugin-adapter-core.js'
 import { ADAPTERS } from './adapters/index.js'
+// PB-19: the better-sidebar surface extractor, a PURE utility inside the
+// adapters directory — the one subdirectory import the wiring makes besides
+// the ADAPTERS array (test/adapters-pluggable.test.cjs pins both to this
+// file). The fs read that feeds it also lives HERE: nothing inside
+// src/adapters/ touches the disk.
+import { betterSidebarSurfaceDigest, extractBetterSidebarSurface, surfaceLooksHealthy } from './adapters/dsh-better-sidebar/surface.js'
 import { createRelayHandler, loadServerId, RELAY_PREFIX, resolveDshVersion } from './relay-server.js'
 import type { RelayGateway, RelayHandler } from './relay-server.js'
 import { createBridgeRegistry, compareBridges } from './plugin-bridge.js'
@@ -80,6 +87,7 @@ import { createVerificationManager } from './wizard/verify.js'
 import type { BridgeDeclaration, BridgeRegistry, BridgeStatus, ServerPluginEntry, ZenRemoteService } from './plugin-bridge.js'
 import { createPluginLoopback } from './plugin-loopback.js'
 import { createPluginTunnel } from './plugin-tunnel.js'
+import { DEFAULT_MAX_UPLOAD_BYTES } from './upload-limits.js'
 
 // The plugin bridge's public types (PB-1), re-exported so another plugin's
 // author can `import type { … } from 'dsh-zen-remote'` without reaching into
@@ -127,8 +135,11 @@ export const CLIENT_CONFIG_ROUTE = '/_dsh/mobile-nav/client-config'
 /** Workspace-relative directory uploads land in (also the `@` prefix the composer inserts). */
 export const UPLOAD_DIR = '.dsh-uploads'
 
-/** Body cap when the plugin row sets no `maxUploadBytes`. */
-export const DEFAULT_MAX_UPLOAD_BYTES = 20 * 1024 * 1024
+// The phone composer's default body cap lives in upload-limits.ts with the
+// plugin's other upload numbers (the comment there spells out why this must
+// stay phone-only and never size the relay); re-exported so the main entry's
+// public surface keeps the name.
+export { DEFAULT_MAX_UPLOAD_BYTES }
 
 /** Longest filename, in bytes, that survives sanitization (ext4/APFS leaf limit is 255). */
 const MAX_NAME_BYTES = 180
@@ -588,12 +599,18 @@ export function apply(ctx: Context, config: MobileNavConfig = {}): void {
   // (`packageOf(name, ctx.baseUrl)` — verified on 0.2.0-rc.2 to answer
   // `{name, version, dir, …}` or undefined; any other shape, a missing
   // service or a probe failure reads as "not installed" and the adapter
-  // stays out). A plugin that registers its OWN cooperative declaration
-  // always wins: the adapter yields at registration time (logged), and the
-  // runtime re-checks the registry digest on every request. Both roles run
-  // this loop — the registry entries drive the handshake table, the bridge
-  // verdicts and the settings listing on either side, while the returned
-  // array feeds the two request halves.
+  // stays out). PB-19 exception: a version OUTSIDE the list still registers
+  // when the installed build's wire-surface digest (extracted here from its
+  // lib/index.js, the wiring being the only place the feature touches the
+  // disk) is whitelisted in the adapter's `surfaces` table — a wire-identical
+  // patch release bridges without a zen-remote release, and every failure of
+  // the extraction is logged apart from the digest-mismatch refusal. A plugin
+  // that registers its OWN cooperative declaration always wins: the adapter
+  // yields at registration time (logged), and the runtime re-checks the
+  // registry digest on every request. Both roles run this loop — the registry
+  // entries drive the handshake table, the bridge verdicts and the settings
+  // listing on either side, while the returned array feeds the two request
+  // halves.
   const adapters: NormalizedAdapter[] = []
   {
     const adapterWarn = (text: string): void => { ctx.logger?.warn('dsh-zen-remote adapter: %s', text) }
@@ -601,7 +618,7 @@ export function apply(ctx: Context, config: MobileNavConfig = {}): void {
       try {
         const holder = ctx as unknown as { get?: (name: string) => unknown; baseUrl?: string }
         const packages = holder.get?.('pluginPackages') as { packageOf?: (specifier: string, parentURL: string) => unknown } | undefined
-        const found = packages?.packageOf?.(adapter.plugin, holder.baseUrl ?? '') as { version?: unknown } | undefined
+        const found = packages?.packageOf?.(adapter.plugin, holder.baseUrl ?? '') as { version?: unknown; dir?: unknown } | undefined
         const installedVersion = found !== null && typeof found === 'object' && typeof (found as { version?: unknown }).version === 'string'
           ? (found as { version: string }).version
           : undefined
@@ -609,14 +626,44 @@ export function apply(ctx: Context, config: MobileNavConfig = {}): void {
           adapterWarn(`${adapter.plugin}: target package (or its version) not found; not registered`)
           continue
         }
-        const normalized = normalizeAdapter(adapter, installedVersion)
+        // PB-19: a version outside the adapter's list gets ONE more chance —
+        // its wire surface. Extract it, hash it, and let normalizeAdapter
+        // judge the digest against the adapter's `surfaces` table. Anything
+        // that goes wrong here leaves the digest undefined — the core then
+        // refuses as a plain unlisted version, and the warns below name WHY
+        // no digest was offered (no dir, unreadable file, lost dispatch
+        // table), distinct from a digest that simply missed.
+        const unlisted = !adapter.versions.includes(installedVersion)
+        let surfaceDigest: string | undefined
+        if (unlisted) {
+          const dir = typeof found?.dir === 'string' && found.dir !== '' ? found.dir : undefined
+          if (dir === undefined) {
+            adapterWarn(`${adapter.plugin}: version ${installedVersion} is unlisted and packageOf gave no dir; no surface digest to offer`)
+          } else {
+            try {
+              const surface = extractBetterSidebarSurface(readFileSync(join(dir, 'lib/index.js'), 'utf8'))
+              if (!surfaceLooksHealthy(surface)) {
+                adapterWarn(`${adapter.plugin}: surface extractor lost the dispatch table (${surface.methods.length} methods) — treating as unknown surface`)
+              } else {
+                surfaceDigest = betterSidebarSurfaceDigest(surface)
+              }
+            } catch (error) {
+              adapterWarn(`${adapter.plugin}: cannot read ${join(dir, 'lib/index.js')} for a surface digest: ${error instanceof Error ? error.message : String(error)}`)
+            }
+          }
+        }
+        const normalized = normalizeAdapter(adapter, installedVersion, surfaceDigest === undefined ? undefined : { surfaceDigest })
         if (registry.get(normalized.plugin) !== undefined) {
           adapterWarn(`${normalized.plugin}: the plugin registers its own bridge declaration; the adapter yields`)
           continue
         }
         registry.registerNormalized(normalized.declaration)
         adapters.push(normalized)
-        ctx.logger?.info('dsh-zen-remote adapter: %s adapted at version %s', normalized.plugin, installedVersion)
+        if (unlisted && surfaceDigest !== undefined) {
+          ctx.logger?.info('dsh-zen-remote adapter: %s bridged by surface digest %s (version %s unlisted)', normalized.plugin, surfaceDigest, installedVersion)
+        } else {
+          ctx.logger?.info('dsh-zen-remote adapter: %s adapted at version %s', normalized.plugin, installedVersion)
+        }
       } catch (error) {
         adapterWarn(`${adapter.plugin} refused: ${error instanceof Error ? error.message : String(error)}`)
       }
@@ -1301,6 +1348,39 @@ export function apply(ctx: Context, config: MobileNavConfig = {}): void {
       // carries nothing new costs one compare.
       interceptHandle?.currentSessionChanged()
     }
+    // PB-25b: the KNOWN-real-session inventory — the union of the merged
+    // global streams' session snapshots (the workspace merger's sessionHome:
+    // every real id the sidebar currently holds as a `zr~` row). Each merged
+    // stream owns one slot; a report REPLACES that stream's share (never a
+    // delta — merge-streams' contract) and the union rebuilds wholesale on
+    // every report and dispose (stream count is single digits). The
+    // plugin-route rewrite reads the union LIVE per answer through the
+    // getter — the same live-read discipline as getServerId/getStatus: a
+    // snapshot captured at install time would be permanently empty (the
+    // streams start reporting after the install), and an id that appears
+    // between two stream refreshes waits for the next refresh by design
+    // (the documented ceiling in merge-streams.ts). Read-only consumption:
+    // nothing below ever mutates what a merger handed over.
+    const knownSessionShares = new Map<SessionInventorySlot, ReadonlySet<string>>()
+    const knownRealIds = new Set<string>()
+    const rebuildKnownRealIds = (): void => {
+      knownRealIds.clear()
+      for (const share of knownSessionShares.values()) {
+        for (const id of share) knownRealIds.add(id)
+      }
+    }
+    const createSessionInventorySlot = (): SessionInventorySlot => {
+      const slot: SessionInventorySlot = {
+        replace(ids) {
+          knownSessionShares.set(slot, ids)
+          rebuildKnownRealIds()
+        },
+        dispose() {
+          if (knownSessionShares.delete(slot)) rebuildKnownRealIds()
+        },
+      }
+      return slot
+    }
     const interceptDiagnostics = (): InterceptDiagnostics | undefined => {
       if (interceptHandle !== undefined) return interceptHandle.diagnostics()
       if (interceptRefused !== undefined) {
@@ -1334,6 +1414,9 @@ export function apply(ctx: Context, config: MobileNavConfig = {}): void {
         relay: relayClient,
         getServerId: () => relayClient.handshakeInfo?.serverId,
         getCurrentSession: () => reportedCurrentSession,
+        // PB-25b: each merged stream reports its real-session inventory
+        // share into the union above.
+        createSessionInventorySlot,
         log: (format, ...args) => { ctx.logger?.info(`dsh-zen-remote ${format}`, ...args) },
       })
       interceptHandle = handle
@@ -1491,6 +1574,10 @@ export function apply(ctx: Context, config: MobileNavConfig = {}): void {
         // routes' deny hooks read (better-sidebar's open.external carries
         // no session field of its own).
         getCurrentSession: () => (reportedCurrentSession.kind === 'open' ? reportedCurrentSession.sessionId : undefined),
+        // PB-25b: the known-real-session union, read LIVE per rewriteIds
+        // answer — the rewriteIds deep scan rewrites an id that already sits
+        // in the browser's view even when this request never carried it.
+        getKnownRealIds: () => knownRealIds,
         log: (format, ...args) => { ctx.logger?.info(`dsh-zen-remote ${format}`, ...args) },
       })
       pluginRouteHandle = handle

package/src/intercept.ts

@@ -605,6 +605,19 @@ export interface InterceptDiagnostics {
   closedSessions: ClosedSessionRecord[]
 }
 
+/** PB-25b: one merged global stream's share of the KNOWN-real-session
+ * inventory. REPLACE semantics: each `replace` call carries that stream's
+ * FULL current set (the workspace merger's sessionHome snapshot — every real
+ * id the sidebar currently holds as a `zr~` id), never a delta; `dispose`
+ * drops the share (the stream ended — its merger is gone, its ids may no
+ * longer be in the UI's view). The wiring unions the live shares into the
+ * read-only set the plugin-route rewrite consults; nothing here hands out a
+ * mutable reference to merge state. */
+export interface SessionInventorySlot {
+  replace(ids: ReadonlySet<string>): void
+  dispose(): void
+}
+
 export interface InstallInterceptOptions {
   /** The RAW gateway instance (`ctx.typertGateway[symbols.original]`), not
    * the cordis proxy — own properties on the proxy are ignored by everyone. */
@@ -629,6 +642,13 @@ export interface InstallInterceptOptions {
    * read got wrong — so the value must be carried in. Default: permanently
    * `unavailable` (the conservative fallback — tombstones stay). */
   getCurrentSession?: () => CurrentSessionRead
+  /** PB-25b: the inventory slot factory — one slot per merged global stream
+   * (only the workspace merger ever reports; the control merger has no
+   * session inventory). The wiring unions the live slots' shares into the
+   * set the plugin-route rewrite reads. Absent: no shares are ever reported
+   * and the plugin-route value scan stays exactly the request-local
+   * behavior. */
+  createSessionInventorySlot?: () => SessionInventorySlot
 }
 
 export interface InterceptHandle {
@@ -1339,6 +1359,10 @@ interface MergedGlobalStreamDeps {
    * sync can announce list rows the UI has no summary for; the control
    * route carries no session lists and never calls it. */
   summarySync: SessionSummarySync
+  /** PB-25b: the inventory slot factory (the wiring's union feed — see
+   * {@link SessionInventorySlot}). One slot per merged stream, disposed with
+   * it; absent when the wiring passed no factory. */
+  createSessionInventorySlot?: () => SessionInventorySlot
 }
 
 /**
@@ -1366,13 +1390,25 @@ async function* mergedGlobalStream(deps: MergedGlobalStreamDeps): AsyncGenerator
     log?.('client merge dropped a frame on %s: %s', endpoint, message)
   }
   const initial = relayIdentityOf(relay)
+  // PB-25b: this stream's inventory share — the workspace merger reports its
+  // full real-id set through it (replace-style), and the share dies with the
+  // stream (both exits below: the degraded local-only path and the main
+  // teardown). The control merger has no session inventory and never
+  // reports.
+  const sessionSlot = deps.createSessionInventorySlot?.()
   // Created eagerly so the local leg is observed from its first frame on.
   // The empty identity is a placeholder: the remote pump retargets before
   // any remote frame is ever fed (it only runs under a real handshake).
   let merger: WorkspaceMerger | ControlMerger =
     endpoint === 'session/control'
       ? createControlMerger({ serverId: initial?.serverId ?? '', serverName: initial?.serverName ?? '', onDiagnostic })
-      : createWorkspaceMerger({ serverId: initial?.serverId ?? '', serverName: initial?.serverName ?? '', onDiagnostic, now: clock.now })
+      : createWorkspaceMerger({
+          serverId: initial?.serverId ?? '',
+          serverName: initial?.serverName ?? '',
+          onDiagnostic,
+          now: clock.now,
+          ...(sessionSlot !== undefined ? { onKnownSessions: (ids: ReadonlySet<string>) => sessionSlot.replace(ids) } : {}),
+        })
 
   /**
    * The status annotation (T34) the CURRENT relay state maps onto, applied
@@ -1563,6 +1599,9 @@ async function* mergedGlobalStream(deps: MergedGlobalStreamDeps): AsyncGenerator
     // Remote-side setup failed: degrade to a pure local passthrough so the
     // UI's own stream is untouched and the remote leg never starts.
     log?.('client merge on %s degraded to local-only: %s', endpoint, messageOf(error))
+    // PB-25b: this stream never reports (no remote leg) — drop its share
+    // before the degraded passthrough takes over.
+    sessionSlot?.dispose()
     yield* localOnly(local)
     return
   }
@@ -1740,6 +1779,9 @@ async function* mergedGlobalStream(deps: MergedGlobalStreamDeps): AsyncGenerator
     if (signal !== undefined) signal.removeEventListener('abort', onExternalAbort)
     currentController?.abort()
     flushWaiters()
+    // PB-25b: the stream is over — its inventory share leaves the wiring's
+    // union (its ids may no longer be in the UI's view).
+    sessionSlot?.dispose()
     // Best-effort half-close of the local stream the consumer walked away
     // from — never awaited: an upstream that ignores return() must not
     // hang the teardown.
@@ -2425,6 +2467,9 @@ export function installIntercept(options: InstallInterceptOptions): InterceptHan
   // outlives individual stream generations so a nudge from a workspace leg
   // reaches whichever $events generation is open.
   const summarySync = createSessionSummarySync()
+  // PB-25b: the inventory slot factory (the wiring's union feed) — passed
+  // down to every merged stream, which owns one slot for its lifetime.
+  const createSessionInventorySlot = options.createSessionInventorySlot
   // T62: the current-session getter and the live-merged-stream listener
   // registry behind handle.currentSessionChanged().
   const getCurrentSession = options.getCurrentSession ?? (() => ({ kind: 'unavailable' }) as const)
@@ -3341,6 +3386,7 @@ export function installIntercept(options: InstallInterceptOptions): InterceptHan
             watchCurrentSession,
             watchUninstall,
             summarySync,
+            createSessionInventorySlot,
           })
         })()
       }

package/src/merge-streams.ts

@@ -220,6 +220,18 @@ export interface WorkspaceMergerOptions extends MergerIdentity {
   /** T65: the clock the tombstone hide-grace runs on. Default Date.now;
    * tests advance an injectable fake to cross the grace. */
   now?: () => number
+  /** PB-25b: the known-real-session inventory report — every time the
+   * session registry changes, the FULL current set of real ids this merger
+   * knows (the sessionHome keys: live ids and tombstones alike, each one the
+   * UI holds as a `zr~` id under this identity) is handed over as a fresh
+   * snapshot. REPLACE semantics, never a delta: the consumer's share is
+   * redefined wholesale by every report, so no invalidation bookkeeping
+   * exists on either side. Documented ceiling: an id that appears (or
+   * leaves) between two registry changes is invisible to the consumer until
+   * the next change reports — dumb but correct, and the wiring owns the
+   * other half of the contract (read-only consumption; the plugin-route
+   * rewrite never mutates merge state). */
+  onKnownSessions?: (ids: ReadonlySet<string>) => void
 }
 
 export interface WorkspaceMerger {
@@ -285,6 +297,7 @@ export interface WorkspaceMerger {
  */
 export function createWorkspaceMerger(options: WorkspaceMergerOptions): WorkspaceMerger {
   const onDiagnostic = options.onDiagnostic
+  const onKnownSessions = options.onKnownSessions
   let identity: MergerIdentity = { serverId: options.serverId, serverName: options.serverName }
 
   // The locally observed truth, updated from every local baseline / order /
@@ -359,19 +372,43 @@ export function createWorkspaceMerger(options: WorkspaceMergerOptions): Workspac
    * remembered under THIS workspace as its last home (originals, cumulative). */
   function learnSessions(record: Record<string, unknown>, workspaceId: string): void {
     if (!Array.isArray(record.sessionIds)) return
-    for (const id of record.sessionIds) if (typeof id === 'string') sessionHome.set(id, workspaceId)
+    let learned = false
+    for (const id of record.sessionIds) {
+      if (typeof id === 'string') {
+        sessionHome.set(id, workspaceId)
+        learned = true
+      }
+    }
+    // PB-25b: the inventory grew — re-report the full set (replace-style;
+    // see onKnownSessions). Once per record with string ids, never per id.
+    if (learned) reportKnownSessions()
   }
 
   /** Drop the ids whose last home was this workspace — tombstones die with
    * their group (a server remove / a workspace diffed away; a session that
    * moved on lives under its NEW home and survives this). */
   function forgetWorkspace(workspaceId: string): void {
+    let forgot = false
     for (const [id, home] of sessionHome) {
       if (home === workspaceId) {
         sessionHome.delete(id)
         closedAt.delete(id)
+        forgot = true
       }
     }
+    // PB-25b: the inventory shrank — the gone ids must leave the consumer's
+    // share with this refresh, or a session that left the sub-client's view
+    // would keep being rewritten.
+    if (forgot) reportKnownSessions()
+  }
+
+  /** PB-25b: the inventory report — the FULL sessionHome key set as a fresh
+   * snapshot, handed to the callback replace-style. Fired at the three
+   * registry mutation points (learn / forget / the identity end) rather than
+   * once per frame: a frame that changes nothing costs nothing, and any
+   * future frame type that touches the registry reports automatically. */
+  function reportKnownSessions(): void {
+    onKnownSessions?.(new Set(sessionHome.keys()))
   }
 
   /** T65: stamp the ids that JUST left a workspace's live list (their
@@ -885,6 +922,9 @@ export function createWorkspaceMerger(options: WorkspaceMergerOptions): Workspac
       // So does the shown set: a NEW server may reuse original workspace ids,
       // and a stale entry would forward the new server's empty groups.
       shown.clear()
+      // PB-25b: the inventory died with the identity — the empty report is
+      // what empties the consumer's share (a NEW server mints new ids).
+      reportKnownSessions()
       return out
     },
   }