dsh-zen-remote 2.3.5 → 2.3.6

package/scripts/check-info-sheet-stacking.mjs

@@ -14,6 +14,9 @@
 // Run: node scripts/check-info-sheet-stacking.mjs   (needs Node >= 23.6 type stripping)
 import assert from 'node:assert/strict'
 import { INFO_CSS } from '../src/client/styles/info.css.ts'
+import { CONTENT_CSS } from '../src/client/styles/content.css.ts'
+import { LAYOUT_CSS } from '../src/client/styles/layout.css.ts'
+import { en, zh } from '../src/client/locales.ts'
 
 /** Host z-index values this sheet has to out-rank (dsh-client-ui-conversation). */
 const HOST_COMPOSER_SEAT = 7
@@ -52,4 +55,86 @@ assert.ok(
   'the header promotion escaped the (max-width: 767px) block — it would change the desktop layout',
 )
 
+// ---- UI-1 (2026-10-30): turn-tail clock + info-card stat cells -------------
+// Lives here rather than in its own script because package.json's test line
+// is an explicit list, and the info-card half of UI-1 is this sheet's own
+// content. Both halves regress silently (CSS still parses, the card still
+// opens), so they get the same loud-failure treatment as the stacking rule.
+
+/** Body of the single rule whose selector line matches `selector` exactly. */
+const ruleBody = (css, selector, label) => {
+  const escaped = selector.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const match = new RegExp(`(?:^|\\n)\\s*${escaped}\\s*\\{([^}]*)\\}`).exec(css)
+  assert.ok(match, `${label}: rule \`${selector}\` is gone`)
+  return match[1]
+}
+
+// DSH 0.2.x wraps the usage button and the 24h clock in one non-wrapping
+// inline-flex _endInfo. The 0.1.x-era rule (flex-basis: 100% + white-space:
+// normal on the clock) squeezed "18:06" onto two lines inside it.
+const tailTime = ruleBody(
+  CONTENT_CSS,
+  '[data-chat-flow-kind="turn-tail"] [class$="_actions"] [class$="_timeEnd"]',
+  'content.css.ts',
+)
+assert.ok(
+  /white-space:\s*nowrap\s*!important/.test(tailTime),
+  'turn-tail _timeEnd must declare white-space: nowrap !important — the clock may never break mid-"18:06"',
+)
+assert.ok(
+  !/flex-basis:\s*100%/.test(tailTime),
+  'turn-tail _timeEnd still carries flex-basis: 100% — the 0.1.x "own line" clamp that squeezes the clock inside _endInfo',
+)
+assert.ok(
+  !/white-space:\s*normal/.test(tailTime),
+  'turn-tail _timeEnd still carries white-space: normal — this is what let the clock wrap',
+)
+assert.ok(
+  /flex:\s*none\s*!important/.test(tailTime),
+  'turn-tail _timeEnd must be flex: none — a shrinkable clock is the squeeze itself',
+)
+
+// The other half of the root cause: layout.css.ts used to make the clock a
+// shrinkable flex item (flex: 0 1 auto + min-width: 0) for every message row.
+const rowTime = ruleBody(LAYOUT_CSS, '[data-phase] [class$="_actions"] [class$="_timeEnd"]', 'layout.css.ts')
+assert.ok(/flex:\s*none\s*!important/.test(rowTime), 'layout.css.ts _timeEnd must be flex: none !important')
+assert.ok(
+  !/min-width:\s*0/.test(rowTime) && !/flex:\s*0 1 auto/.test(rowTime),
+  'layout.css.ts _timeEnd is shrinkable again (min-width: 0 / flex: 0 1 auto) — the clock will be squeezed inside _endInfo',
+)
+
+// _endInfo wraps as a unit, and the row may grow instead of clipping.
+const endInfo = ruleBody(
+  CONTENT_CSS,
+  '[data-chat-flow-kind="turn-tail"] [class$="_actions"] [class$="_endInfo"]',
+  'content.css.ts',
+)
+assert.ok(/flex:\s*none/.test(endInfo), 'turn-tail _endInfo must be flex: none so the usage + clock group wraps whole')
+const tailRows = [...CONTENT_CSS.matchAll(/\n\s*\[data-chat-flow-kind="turn-tail"\] \[class\$="_actions"\]\s*\{([^}]*)\}/g)]
+const tailRow = tailRows.map((m) => m[1]).find((body) => /flex-wrap/.test(body))
+assert.ok(tailRow, 'content.css.ts lost the wrapping turn-tail _actions rule')
+assert.ok(
+  /height:\s*auto\s*!important/.test(tailRow) && /overflow:\s*visible\s*!important/.test(tailRow),
+  'turn-tail _actions must release the host fixed height (height: auto) and layout.css.ts overflow: hidden (overflow: visible), or a wrapped second line is cut off',
+)
+
+// Desktop no-op: every turn-tail rule above has to sit inside the phone block.
+const contentPhone = /@media \(max-width: 767px\) \{/.exec(CONTENT_CSS)
+assert.ok(contentPhone, 'content.css.ts lost its phone media query')
+assert.ok(
+  CONTENT_CSS.indexOf('[data-chat-flow-kind="turn-tail"]') > contentPhone.index,
+  'a turn-tail rule escaped the (max-width: 767px) block — it would change the desktop layout',
+)
+
+// Info-card stat cells: turns + steps merged into one cell, output speed in
+// the freed slot. Both dictionaries must carry the keys or t() prints the key.
+for (const [name, dict] of [['zh', zh], ['en', en]]) {
+  for (const key of ['infoStatTurnsSteps', 'infoStatSpeed']) {
+    assert.ok(
+      typeof dict[key] === 'string' && dict[key].length > 0,
+      `locales.ts ${name} is missing '${key}' — the info card would render the raw key as a label`,
+    )
+  }
+}
+
 console.log('check-info-sheet-stacking: ok')

package/src/adapters/dsh-better-sidebar/index.ts

@@ -15,8 +15,11 @@
  * model spend (commit-message generation), documented as such; NO path
  * fencing; `open.external` refuses for a remote session; `settings.*` and
  * `/sidebar/bundle` stay local; the adapter registers as whole-machine
- * data (consent per plugin, default off). PB-15: the 0.26.0 WebSocket
- * `/sidebar/ws/sidechat` is deliberately NOT declared (not bridged).
+ * data (consent per plugin, default off). PB-15 left the 0.26.0 WebSocket
+ * `/sidebar/ws/sidechat` undeclared; PB-26b bridges it — its ids ride the
+ * post-handshake JSON frames (`{"op":"watch","threadIds":[...]}`), which
+ * the json-body upgrade gate locates, classifies and rewrites frame by
+ * frame on both halves.
  *
  * The `cwd` handling is the one subtle part: better-sidebar resolves a
  * request's working directory as the session's own `header.cwd` first and
@@ -147,6 +150,16 @@ export const dshBetterSidebarAdapter: BridgeAdapter = {
     // file paths, not session ids).
     { path: '/sidebar/ws/agent-opens', match: 'exact', methods: ['GET'], upgrade: true, locator: { in: 'query', name: 'sessionId' } },
     { path: '/sidebar/ws/fs-watch', match: 'exact', methods: ['GET'], upgrade: true, locator: { in: 'query', name: 'sessionId' } },
+    // The side-chat push feed (PB-26b; lib/index.js's third registerUpgrade):
+    // the upgrade URL carries NO query — the browser's first frame after the
+    // handshake is `{"op":"watch","threadIds":[...]}` and the plugin pushes
+    // `{"threadId":"..."}` per event. The json-body locator rides the FRAME
+    // gate: the client half classifies and rewrites every watch frame (an
+    // empty list — unsubscribe-all — crosses untouched), the server's send
+    // gate share-checks each frame before the plugin sees it, and the
+    // client.response hook below virtualizes the pushed threadId so the
+    // browser's `wantedRef.includes(frame.threadId)` comparison fires.
+    { path: '/sidebar/ws/sidechat', match: 'exact', methods: ['GET'], upgrade: true, locator: { in: 'json-body', fields: ['threadIds'] } },
   ],
   client: {
     request: (ctx) => {
@@ -160,6 +173,22 @@ export const dshBetterSidebarAdapter: BridgeAdapter = {
       return { allow: true }
     },
     response: (ctx) => {
+      // PB-26b: the sidechat ws PUSH frames name their thread on the TOP
+      // level — `{"threadId":"<real id>"}`. The browser compares
+      // `wantedRef.current.includes(frame.threadId)` against the VIRTUAL ids
+      // it watched, so a real id here would silently miss every push; the
+      // virtualized form rides in its place. A frame with no usable tid (a
+      // non-object, or an id that is already virtual) crosses untouched.
+      if (ctx.pathname === '/sidebar/ws/sidechat') {
+        if (ctx.body !== null && typeof ctx.body === 'object' && !Array.isArray(ctx.body)) {
+          const record = ctx.body as Record<string, unknown>
+          const tid = record.threadId
+          if (typeof tid === 'string' && tid !== '' && !ctx.isVirtual(tid)) {
+            return { ...record, threadId: ctx.virtualize(tid) }
+          }
+        }
+        return ctx.body
+      }
       const name = apiMethodOf(ctx.pathname)
       if (name === '') return ctx.body
       const spec = SIDEBAR_METHODS[name]

package/src/client/MobileSessionInfo.tsx

@@ -100,6 +100,17 @@ function formatDuration(ms: number): string {
   return `${Math.floor(whole / 60)}m${whole % 60}s`
 }
 
+/**
+ * Decode-throughput figure: whole tokens from ten up, one decimal below.
+ * Ported digit-for-digit from dsh-client-ui-chat lib/client.js
+ * formatTokensPerSecond (DSH 0.2.x TurnUsagePanel; verified 2026-10-30),
+ * which also owns the "{tps} tok/s" unit the cell appends.
+ */
+function formatTokensPerSecond(tps: number): string {
+  const clamped = Math.max(0, tps)
+  return clamped >= 10 ? String(Math.round(clamped)) : String(Math.round(clamped * 10) / 10)
+}
+
 /** Sum of the three disjoint prompt-side billing buckets. */
 function billedInputTokens(usage: { uncachedInputTokens: number; cacheReadTokens: number; cacheWriteTokens: number }): number {
   return usage.uncachedInputTokens + usage.cacheReadTokens + usage.cacheWriteTokens
@@ -448,8 +459,24 @@ export function MobileSessionInfo({
   }
 
   const cells: Array<{ label: string; value: string; sub: string | undefined }> = [
-    { label: t('infoStatTurns'), value: stats === undefined ? NA : String(stats.turns), sub: undefined },
-    { label: t('infoStatSteps'), value: stats === undefined ? NA : String(stats.steps), sub: undefined },
+    /* Turns and steps share one cell ("3 / 12") so the grid stays 2×3 with
+       output speed taking the freed slot (UI-1, 2026-10-30). */
+    {
+      label: t('infoStatTurnsSteps'),
+      value: stats === undefined ? NA : `${stats.turns} / ${stats.steps}`,
+      sub: undefined,
+    },
+    /* Same guard and formula as the official TurnUsagePanel: decodeMs > 0
+       is its "we have a throughput reading" test, so a session with no
+       usage-reporting step shows the placeholder, never "0 tok/s". */
+    {
+      label: t('infoStatSpeed'),
+      value:
+        stats === undefined || stats.decodeMs <= 0
+          ? NA
+          : `${formatTokensPerSecond(stats.decodeTokens / (stats.decodeMs / 1e3))} tok/s`,
+      sub: undefined,
+    },
     {
       label: t('infoStatTtft'),
       value: stats === undefined || stats.ttftSteps === 0 ? NA : formatDuration(stats.ttftMs / stats.ttftSteps),

package/src/client/locales.ts

@@ -35,6 +35,8 @@ export const zh = {
   'activityOpen': '查看子代理与后台任务',
   'infoStatTurns': '轮次',
   'infoStatSteps': '步骤',
+  'infoStatTurnsSteps': '轮次 / 步数',
+  'infoStatSpeed': '输出速度',
   'infoStatTtft': '首字延迟',
   'infoStatLlm': '模型耗时',
   'infoStatTool': '工具耗时',
@@ -549,6 +551,8 @@ export const en: Record<MobileNavKey, string> = {
   'activityOpen': 'View subagents and background tasks',
   'infoStatTurns': 'Turns',
   'infoStatSteps': 'Steps',
+  'infoStatTurnsSteps': 'Turns / Steps',
+  'infoStatSpeed': 'Output speed',
   'infoStatTtft': 'TTFT',
   'infoStatLlm': 'LLM time',
   'infoStatTool': 'Tool time',

package/src/client/styles/content.css.ts

@@ -84,15 +84,25 @@ export const CONTENT_CSS = `/* ---------- chat markdown content (< 768px) ------
     max-width: none !important;
   }
 
-  /* Turn-tail metadata (2026-08-18): the timing stats ("18:06 · 用时 29秒 ·
-     首 token 0.9秒 · 163 tok/s") are desktop-hover-revealed (official
-     [data-time-hover-root] gate holds them at opacity 0 until :hover /
-     :focus-within) — a phone never hovers, so they were simply invisible;
-     and even ignoring that, the row is nowrap + overflow:hidden (plus this
-     plugin's own legacy ellipsis clamp in layout.css.ts), which clipped the
-     text. On phones: always visible, own full-width line under the action
-     icons, wrapping freely, one type size down. !important + the extra
-     [class$="_actions"] hop out-specifies both upstream and layout.css.ts. */
+  /* Turn-tail metadata (2026-08-18; reshaped 2026-10-30 for DSH 0.2.x): the
+     tail's 24h clock is desktop-hover-revealed (official
+     [data-time-hover-root] gate holds it at opacity 0 until :hover /
+     :focus-within) — a phone never hovers, so it was simply invisible; and
+     the row is a fixed-height nowrap + overflow:hidden flex line (plus this
+     plugin's own clamp in layout.css.ts), which clipped it.
+
+     DSH 0.2.x (MessageIconActions, dsh-client-ui-chat) groups the usage
+     button (TurnUsagePanel) and the clock (_timeEnd) inside ONE inline-flex
+     _endInfo (min-width: 0; align-items: center; gap: 8px; margin-left: 8px)
+     that never wraps internally. The 0.1.x-era rule here gave _timeEnd
+     flex-basis: 100% + white-space: normal — inside _endInfo that no longer
+     reads as "own full-width line", it reads as "shrink to nothing and
+     break", and with the transcript-wide overflow-wrap: anywhere above,
+     "18:06" rendered as two lines. On phones now: always visible; the row
+     may grow in height and wrap; _endInfo drops to the next line as one
+     unit when icons + usage + clock do not fit; the clock itself never
+     shrinks or breaks. !important + the extra [class$="_actions"] hop
+     out-specifies both upstream and layout.css.ts. */
   /* Pin the tail row's width chain before allowing wrap: with wrap enabled
      the row's intrinsic (shrink-to-fit) width collapses to its widest
      single icon, taking the whole tail down to ~16px. */
@@ -100,9 +110,26 @@ export const CONTENT_CSS = `/* ---------- chat markdown content (< 768px) ------
   [data-chat-flow-kind="turn-tail"] [class$="_actions"] {
     width: 100%;
   }
+  /* height: auto releases the upstream fixed height: calc(28px + …);
+     overflow: visible beats layout.css.ts's overflow: hidden (same
+     specificity — this file is concatenated last, so it wins the tie). A
+     wrapped second line must not be cut off vertically; min-height keeps
+     the one-line case at the upstream height so nothing shifts when it
+     fits. */
   [data-chat-flow-kind="turn-tail"] [class$="_actions"] {
     flex-wrap: wrap;
     row-gap: 2px;
+    height: auto !important;
+    min-height: 28px;
+    overflow: visible !important;
+  }
+  /* _endInfo moves as a whole: flex: none so the usage + clock group is
+     never asked to shrink — when the row is too narrow the entire group
+     wraps to the next line instead of compressing the clock inside it.
+     max-width keeps an unusually long usage label inside the column. */
+  [data-chat-flow-kind="turn-tail"] [class$="_actions"] [class$="_endInfo"] {
+    flex: none;
+    max-width: 100%;
   }
   /* Wide companion to the rule below: mirrors the upstream hover-gate
      selector shape directly, with no assumptions about the tail's DOM
@@ -113,13 +140,16 @@ export const CONTENT_CSS = `/* ---------- chat markdown content (< 768px) ------
     opacity: 1 !important;
     transition: none !important;
   }
+  /* overflow-wrap / word-break: normal undo the [data-chat-flow]
+     overflow-wrap: anywhere inherited from the top of this block — that is
+     the rule that let "18:06" break between digits once its box was
+     squeezed. */
   [data-chat-flow-kind="turn-tail"] [class$="_actions"] [class$="_timeEnd"] {
     opacity: 1 !important;
-    flex-basis: 100% !important;
-    white-space: normal !important;
-    overflow: visible !important;
-    text-overflow: clip !important;
-    padding-left: 0 !important;
+    flex: none !important;
+    white-space: nowrap !important;
+    overflow-wrap: normal !important;
+    word-break: normal !important;
     font-size: 12px;
     line-height: 18px;
   }

package/src/client/styles/layout.css.ts

@@ -139,12 +139,18 @@ export const LAYOUT_CSS = `/* ---------- mobile-only layout ---------- */
   [data-phase] [class$="_actions"] {
     overflow: hidden !important;
   }
+  /* The 24h clock ("18:06" / "MM-DD 18:06") is a fixed-size item: it must
+     never be the thing that shrinks. DSH 0.2.x wraps it with the usage
+     button in an inline-flex _endInfo (min-width: 0), so a shrinkable
+     time (the old flex: 0 1 auto + min-width: 0) got squeezed inside that
+     non-wrapping box and "18:06" broke into two lines. flex: none pins its
+     width; the turn-tail rules in content.css.ts let _endInfo wrap as a
+     whole instead. */
   [data-phase] [class$="_actions"] [class$="_timeEnd"] {
-    flex: 0 1 auto !important;
-    min-width: 0 !important;
+    flex: none !important;
+    white-space: nowrap !important;
     overflow: hidden !important;
     text-overflow: ellipsis !important;
-    white-space: nowrap !important;
   }
 
   [data-phase] [class$="_scroll"]:has(p) {

package/src/index.ts

@@ -743,6 +743,14 @@ export function apply(ctx: Context, config: MobileNavConfig = {}): void {
         // best-effort bookkeeping — it must never be able to fail the
         // creation that triggered it.
         try {
+          // PB-26a: record the subagent→parent link the moment the child
+          // exists — for EVERY source. A sidechat child (better-sidebar's
+          // sidechat.start → agents.create) rides no workspace and writes
+          // no catalog; until its first session/event the index knew
+          // nothing of it, so the relay answered not-shared for a session
+          // whose share it inherits through its parent, and the forwarded
+          // status frames the client needs to announce the row never left.
+          parentIndex.observe(agent.session)
           if (source !== 'startup') return
           onSessionCreated(agent.session.header, {
             store,
@@ -1578,6 +1586,11 @@ export function apply(ctx: Context, config: MobileNavConfig = {}): void {
         // 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,
+        // PB-26a: a response rewrite that minted a virtual id (a sidechat
+        // child from `rewriteIds.fields` or an adapter's `virtualize`) is the
+        // client's only early notice of a row that rides no workspace/follow
+        // frame — hand it to the summary sync so the sidebar row appears.
+        onMintedVirtualIds: (ids) => { interceptHandle?.nudgeSummarySync(ids) },
         log: (format, ...args) => { ctx.logger?.info(`dsh-zen-remote ${format}`, ...args) },
       })
       pluginRouteHandle = handle

package/src/intercept.ts

@@ -671,6 +671,12 @@ export interface InterceptHandle {
    * re-judges NOW — the mergers dedupe no-change calls — instead of
    * waiting for the next frame or the 1s fallback poll. */
   currentSessionChanged(): void
+  /** PB-26a: trigger a summary-sync check for virtual session ids discovered
+   * OUTSIDE workspace/follow (a sidechat childId the plugin bridge just
+   * minted in a response rewrite, for instance). Empty and non-virtual
+   * entries are dropped; a batch with nothing left is a no-op. Reaches every
+   * live merged `$events` stream, and the pending slot when none is open. */
+  nudgeSummarySync(ids: readonly string[]): void
 }
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
@@ -2013,6 +2019,15 @@ async function* mergedEventsStream(deps: MergedEventsStreamDeps): AsyncGenerator
   /** The ids the in-flight round asked (its triggering batches) — marked at
    * completion, joined by nothing (mid-flight batches queue instead). */
   let askingNow: string[] = []
+  /** PB-26a: the newest REAL-TIME running flag this stream delivered per
+   * VIRTUAL session id (the leg's forwarded `api-session/status` frames
+   * only — never the synthesized status-sync frames). Read when a row is
+   * first announced: a status frame that reached the UI BEFORE its row
+   * existed was dropped by the host (handleSessionStatus only updates
+   * sessions already in its summaries), and a flip during the list pull is
+   * newer than the snapshot's `running` — either way the announce must be
+   * followed by the live value. Cleared with a fresh serving period. */
+  const latestLiveStatus = new Map<string, boolean>()
   const scheduleRetry = (): void => {
     if (retryTimer !== undefined || retryAt.size === 0) return
     const earliest = Math.min(...retryAt.values())
@@ -2072,6 +2087,15 @@ async function* mergedEventsStream(deps: MergedEventsStreamDeps): AsyncGenerator
           if (announced.has(rowId)) continue
           announced.add(rowId)
           channel.push(frame)
+          // PB-26a: the row is born in the UI carrying the snapshot's
+          // `running`; when this stream delivered a live status for it the
+          // host could not apply (no row yet) or that postdates the
+          // snapshot, realign right behind the added frame — only when the
+          // two disagree, a matching flag needs no second frame.
+          const liveRunning = latestLiveStatus.get(rowId)
+          if (liveRunning !== undefined && liveRunning !== (isPlainObject(row) && row.running === true)) {
+            channel.push({ type: 'emit', event: 'api-session/status', args: [rowId, liveRunning] })
+          }
         }
         // T65-fix ask bookkeeping: a returned id is announced and done; an
         // id the server did NOT return either exhausts its attempts or
@@ -2206,6 +2230,10 @@ async function* mergedEventsStream(deps: MergedEventsStreamDeps): AsyncGenerator
       askedForGood.clear()
       askAttempts.clear()
       retryAt.clear()
+      // PB-26a: the live flags belong to the serving period that delivered
+      // them — the status re-sync below re-reads every row from a fresh
+      // snapshot.
+      latestLiveStatus.clear()
       if (retryTimer !== undefined) {
         clock.clearTimeout(retryTimer)
         retryTimer = undefined
@@ -2370,6 +2398,20 @@ async function* mergedEventsStream(deps: MergedEventsStreamDeps): AsyncGenerator
             if (isPlainObject(frame) && frame.type === 'emit' && frame.event === 'api-session/status') {
               const rowId = Array.isArray(frame.args) ? frame.args[0] : undefined
               if (typeof rowId === 'string' && rowId !== '') liveStatusSeq.set(rowId, ++statusSeq)
+              // PB-26a: the rewritten frame is the proved shape (`args` =
+              // [virtualId, running]). Remember the live flag under the
+              // VIRTUAL id, and — when this stream has not announced the row
+              // — pull the list now: a sidechat / subagent child rides no
+              // workspace/follow frame, so this status is the client's first
+              // (and, until the next turn, only) notice that the row exists.
+              // The frame itself still crosses at once, below.
+              const args = isPlainObject(rewritten) && Array.isArray(rewritten.args) ? rewritten.args : undefined
+              const virtualId = args?.[0]
+              const running = args?.[1]
+              if (typeof virtualId === 'string' && typeof running === 'boolean') {
+                latestLiveStatus.set(virtualId, running)
+                if (!announced.has(virtualId)) handleForwardedBatch([virtualId])
+              }
             }
             // The orphan-close bookkeeping rides the two id-carrying frame
             // types: waterfalls enter the record (once per leg — a repeat
@@ -3498,6 +3540,10 @@ export function installIntercept(options: InstallInterceptOptions): InterceptHan
     currentSessionChanged() {
       for (const listener of [...currentSessionListeners]) listener()
     },
+    nudgeSummarySync(ids: readonly string[]) {
+      const virtualIds = ids.filter((id) => typeof id === 'string' && id !== '' && isVirtual(id))
+      if (virtualIds.length > 0) summarySync.noteForwardedSessionIds(virtualIds)
+    },
   }
 }
 

package/src/plugin-adapter-core.ts

@@ -25,7 +25,7 @@
 import { createHash } from 'node:crypto'
 import { isVirtual, fromVirtual } from './virtual-id.js'
 import { MAX_UPLOAD_BYTES } from './upload-limits.js'
-import type { NormalizedBridgeRoute, NormalizedDeclaration } from './plugin-bridge.js'
+import type { BridgeLocator, NormalizedBridgeRoute, NormalizedDeclaration } from './plugin-bridge.js'
 import { BRIDGE_METHODS, DEFAULT_ROUTE_BODY_BYTES } from './plugin-bridge.js'
 
 export { fromVirtual }
@@ -327,6 +327,15 @@ export function normalizeAdapter(input: unknown, installedVersion: string, optio
         methods: route.methods.length === 1 && route.methods[0] === 'GET' ? undefined : [...route.methods],
         maxBody: route.maxBody === DEFAULT_ROUTE_BODY_BYTES ? undefined : route.maxBody,
         upgrade: route.upgrade ? true : undefined,
+        // PB-26b: an upgrade route whose ids do NOT ride the query keeps its
+        // locator on the registry entry — the tunnel's validation and the
+        // client's upgrade surrogate read where the ids actually arrive (the
+        // sidechat ws watch carries them in the post-handshake JSON frames).
+        // A query route's declaration stays EXACTLY the 2.1 shape — no
+        // locator key — so every older consumer and digest is untouched
+        // (the adapter digest always covered route.locator and never
+        // covered the declaration routes' shape).
+        ...(route.upgrade && route.locator.in !== 'query' ? { locator: route.locator as BridgeLocator } : {}),
       })),
     digest,
   }
@@ -483,6 +492,16 @@ export function locateAdapterIds(route: NormalizedAdapterRoute, pathname: string
       for (const field of locator.fields) {
         const value = body[field]
         if (typeof value === 'string' && value !== '') hits.push({ kind: 'json-body', key: field, value })
+        // PB-26b: a field may carry a LIST of ids — better-sidebar's sidechat
+        // ws watch frame sends `{"op":"watch","threadIds":[...]}`. Every
+        // non-empty string element is one hit under the same field key, so
+        // classify/rewrite treat the batch exactly like repeated query
+        // values: every id virtual → remote, one mixed in → refuse.
+        else if (Array.isArray(value)) {
+          for (const item of value) {
+            if (typeof item === 'string' && item !== '') hits.push({ kind: 'json-body', key: field, value: item })
+          }
+        }
       }
     }
   }
@@ -549,7 +568,15 @@ export function rewriteAdapterRequest(
     } else {
       if (bodyCopy === undefined && isRecord(body)) bodyCopy = { ...body }
       if (bodyCopy !== undefined) {
-        bodyCopy[hit.key!] = real
+        const current = bodyCopy[hit.key!]
+        // PB-26b: an array field rewrites IN PLACE, element for element —
+        // only the entries equal to this hit's located value swap for their
+        // real halves, so a mixed batch of ids keeps its shape and order.
+        if (Array.isArray(current)) {
+          bodyCopy[hit.key!] = current.map((item) => (item === hit.value ? real : item))
+        } else {
+          bodyCopy[hit.key!] = real
+        }
         bodyText = JSON.stringify(bodyCopy)
       }
     }