dsh-zen-remote 2.2.6 → 2.2.8

package/lib/client.js

@@ -7236,63 +7236,6 @@ function releaseThumbnailsExcept(keep) {
     }
 }
 };
-__modules["client/host-attach.js"] = function (require, module, exports) {
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HOST_ATTACH_INPUT = void 0;
-exports.hostAttachPresent = hostAttachPresent;
-exports.useOwnAttachUi = useOwnAttachUi;
-const react_1 = require("react");
-/**
- * The host composer's own hidden file picker, when the running DSH ships one.
- *
- * DSH 0.1.5 grew a native attachment flow (dsh-attachment / dsh-client-file-
- * upload): the official tool row carries a second `_add` paperclip whose click
- * drives an `<input type="file" hidden>` that is a DIRECT sibling of the
- * buttons inside `_tools`. That input is the one structural, locale-free
- * proof that the host implements composer attachment upload — the button
- * itself can only be told apart from the "+" command menu by its localized
- * aria-label, and the capability prop (`addFiles`) lives on the composer
- * bar's own inject face, which never reaches `conversation.input.left`
- * registrants. Scoped to `_tools` children so a third-party plugin parking
- * its own file input somewhere else in the composer cannot be misread as
- * the official feature; `:not([data-mobile-nav])` keeps OUR picker
- * (`attach-picker`) out of the match.
- */
-exports.HOST_ATTACH_INPUT = '[data-slot="conversation.composer.bar"] [class$="_tools"] > input[type="file"]:not([data-mobile-nav])';
-/** Synchronous read: does this host's composer ship its own attach picker? */
-function hostAttachPresent() {
-    return document.querySelector(exports.HOST_ATTACH_INPUT) !== null;
-}
-/**
- * True while OUR attachment UI should mount (the host has none of its own).
- *
- * The rule this encodes (2026-09-11): where the host implements attachment
- * upload, the phone composer shows exactly ONE attach control — the host's —
- * and this plugin's S7 button and chips row stand down; on a host without
- * one (DSH ≤ 0.1.2), both load as they always have.
- *
- * `useLayoutEffect`, not `useEffect`: on the composer's very first mount our
- * slot child renders in the same React pass as the host's tool row, so the
- * state initializer below reads the DOM BEFORE either exists — the layout
- * effect re-checks after the commit and before the browser paints, so the
- * demotion to hidden (or, on an old host, the decision to stay) never
- * reaches the screen as a flash. The MutationObserver covers the lifetime
- * after that: the picker's existence only really changes with the page, but
- * a dynamic host plugin or a reload must not strand a stale verdict.
- */
-function useOwnAttachUi() {
-    const [own, setOwn] = (0, react_1.useState)(() => !hostAttachPresent());
-    (0, react_1.useLayoutEffect)(() => {
-        const check = () => setOwn(!hostAttachPresent());
-        const observer = new MutationObserver(check);
-        observer.observe(document.body, { childList: true, subtree: true });
-        check();
-        return () => observer.disconnect();
-    }, []);
-    return own;
-}
-};
 __modules["client/MobileAttachButton.js"] = function (require, module, exports) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -7301,7 +7244,6 @@ const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
 const dsh_client_ui_primitives_1 = require("@deepseek-ai/dsh-client-ui-primitives");
 const attach_upload_ts_1 = require("./client/attach-upload.js");
-const host_attach_ts_1 = require("./client/host-attach.js");
 /** Post one file to the host route and return the workspace-relative path it landed on. */
 async function uploadFile(sessionId, file) {
     const response = await fetch((0, attach_upload_ts_1.uploadUrl)(sessionId, file.name), {
@@ -7327,12 +7269,20 @@ async function uploadFile(sessionId, file) {
  * the CLIENT's picker — no `accept` attribute on purpose, so iOS offers the
  * full 相册 / 拍照 / 选取文件 sheet rather than one of them.
  *
- * DSH 0.1.5 gave the official tool row its own paperclip (the host attachment
- * flow), which made TWO identical controls on a phone. This button now stands
- * down entirely while the host ships its own picker (`host-attach.ts` probes
- * for it) — the official flow uploads into `~/.dsh/attachments` and renders
- * its own rail, so the composer keeps exactly one attach affordance. On a
- * host without one (DSH ≤ 0.1.2) everything below loads exactly as before.
+ * DSH 0.1.5 gave the official tool row its own paperclip, and this button
+ * used to stand down whenever that flow's hidden `<input type="file">` was
+ * probed in the composer (that probe file is deleted with #31), keeping one
+ * attach control per composer. DSH 0.2.x then removed the standalone
+ * paperclip (the file action moved into the `+` command menu) while KEEPING
+ * the hidden input, so the probe matched on every host and the phone composer
+ * was left with no attach affordance at all. The phone shell now always
+ * renders this button — its picker is the CLIENT's (相册 / 拍照 / 选取文件),
+ * and every attachment takes the same `@.dsh-uploads/` draft-token path on
+ * every DSH version. On DSH ≤ 0.1.5, which still ships the second official
+ * paperclip, composer.css.ts hides it below 768px so the row keeps exactly
+ * one attach control. Subagent sessions stay buttonless, mirroring the host:
+ * the official InputBar disables its own file input while
+ * `subagent !== null`.
  *
  * Every picked file takes the SAME path: upload to the node half, then append
  * `@.dsh-uploads/name` to the draft through the official write path — no DOM
@@ -7347,21 +7297,25 @@ async function uploadFile(sessionId, file) {
  * Files upload one at a time: a phone uplink gains nothing from parallelism
  * and a serial loop keeps the mentions in pick order.
  */
-function MobileAttachButton({ t, sessionId, useInput, inputActions }) {
+function MobileAttachButton({ t, sessionId, useInput, inputActions, useSessions }) {
     const picker = (0, react_1.useRef)(null);
     const [busy, setBusy] = (0, react_1.useState)(false);
     const [error, setError] = (0, react_1.useState)(null);
     const draft = useInput((state) => state.draft);
-    const ownUi = (0, host_attach_ts_1.useOwnAttachUi)();
+    // Same session-row read the share icon/menu use (RemoteHeaderIcon.tsx):
+    // `origin: 'subagent'` is the only subagent signal that reaches slot
+    // registrants — the InputBar's own `subagent` prop does not.
+    const row = useSessions((sessions) => sessions.byId[sessionId]);
     // Uploads are awaited, so the `draft` captured at pick time goes stale — the
     // user can keep typing while a file is in flight. The ref is refreshed on
     // every render (useInput re-renders us on each draft change), so the loop
     // below can rebase onto whatever the composer holds right now.
     const liveDraft = (0, react_1.useRef)(draft);
     liveDraft.current = draft;
-    // The host's own attach button owns this seat now — render nothing (the
-    // hidden picker input goes with it). All hooks stay above this line.
-    if (!ownUi)
+    // Subagent sessions get no attach affordance, mirroring the host (its own
+    // file input is disabled while a subagent session is open). All hooks stay
+    // above this line.
+    if (row?.origin === 'subagent')
         return null;
     const pick = async (event) => {
         const files = Array.from(event.target.files ?? []);
@@ -7410,7 +7364,6 @@ const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
 const dsh_client_ui_primitives_1 = require("@deepseek-ai/dsh-client-ui-primitives");
 const attach_upload_ts_1 = require("./client/attach-upload.js");
-const host_attach_ts_1 = require("./client/host-attach.js");
 /**
  * Attachment preview row (S7.1), in `conversation.input.dock` — the official
  * full-width row above the composer card, which composer.css.ts already lays
@@ -7439,16 +7392,9 @@ const host_attach_ts_1 = require("./client/host-attach.js");
  */
 function MobileAttachChips({ t, useInput, inputActions }) {
     const draft = useInput((state) => state.draft);
-    const ownUi = (0, host_attach_ts_1.useOwnAttachUi)();
     (0, react_1.useEffect)(() => {
         (0, attach_upload_ts_1.releaseThumbnailsExcept)((0, attach_upload_ts_1.mentionsIn)(draft));
     }, [draft]);
-    // Same gate as MobileAttachButton (host-attach.ts): where the host ships
-    // its own attachment flow, our chips row stands down too — the official
-    // rail owns the preview seat. The effect above still runs, so object URLs
-    // from OUR flow get revoked even after the switch.
-    if (!ownUi)
-        return null;
     const attachments = (0, attach_upload_ts_1.mentionsIn)(draft);
     if (attachments.length === 0)
         return null;
@@ -9581,18 +9527,33 @@ exports.HOME_CSS = `/* ---------- phone app shell (< 768px) ---------- */
     flex: none;
     border-radius: 6px;
     object-fit: contain;
-  }
-  /* Dark theme (real-device report, 2026-08-17): the runtime favicon is a
-     dark-on-transparent whale mark, illegible on the dark page. Force a
-     white silhouette regardless of the source image's own colors —
-     brightness(0) collapses every opaque pixel to black first, invert(1)
-     then flips that to white; transparent pixels stay transparent either
-     way. Same body[data-ds-dark-theme] marker as the home-row hairline
-     above (AGENTS.md: prefers-color-scheme never fires, the app switches
-     themes via this attribute with color-scheme hardcoded to light). */
-  body[data-ds-dark-theme] [data-mobile-nav="home-logo"] {
+    /* rc.3 fix (2026-10-25, Safari real-device report "logo 不显示"): the
+       host now ships TWO media-scoped favicons and the first in DOM order
+       is the DARK one — a WHITE whale (fill #fff). useSiteIconHref picks
+       the first link unconditionally, so on a light page the logo arrived
+       white-on-light and vanished. brightness(0) collapses ANY source (the
+       old single black favicon or the new white one) to a black silhouette,
+       making light mode correct for both hosts; the dark-theme rules below
+       re-invert it to white. */
+    filter: brightness(0);
+  }
+  /* Dark theme (real-device report, 2026-08-17): force a white silhouette
+     regardless of the source image's own colors — brightness(0) collapses
+     every opaque pixel to black first, invert(1) then flips that to white;
+     transparent pixels stay transparent either way. Three dark signals,
+     deliberately redundant: the pre-rc.3 body[data-ds-dark-theme] marker,
+     and rc.3's resolved <html data-ds-theme-source> ("dark" pinned, or
+     "system" under a dark OS — rc.3 stamps the resolved scheme on
+     html[style] with no body attribute until the first theme flip). */
+  body[data-ds-dark-theme] [data-mobile-nav="home-logo"],
+  html[data-ds-theme-source="dark"] [data-mobile-nav="home-logo"] {
     filter: brightness(0) invert(1);
   }
+  @media (prefers-color-scheme: dark) {
+    html[data-ds-theme-source="system"] [data-mobile-nav="home-logo"] {
+      filter: brightness(0) invert(1);
+    }
+  }
   [data-mobile-nav="ws-switch"] {
     display: inline-flex;
     align-items: center;
@@ -10598,11 +10559,16 @@ __modules["client/styles/composer.css.js"] = function (require, module, exports)
 //
 // Official structure this file reshapes (verified live at 390px, see the S3
 // report): InputBar renders
-//   _card > _row > [_tools > (_add, _modes > PermissionSelect, input.left)]
+//   _card > _row > [_tools > (_add, input[type=file] hidden, _modes >
+//                             PermissionSelect, input.left)]
 //                  [_trailing > (_standardControls > (input.right, input.model), _activity, _primary)]
 // with `_tools` / `_trailing` / `_standardControls` as inner flex groups
 // (0.1.7 added `_standardControls` and moved the ContextMeter out of the row
-// into the dock under the card). Flattening all three to
+// into the dock under the card). That hidden file input is the stand-down
+// probe host-attach.ts USED to key on — since #31 the phone's own attach
+// button is a permanent resident instead, and DSH 0.1.5's second `_add`
+// button (the standalone paperclip 0.2.x removed) is hidden by section 2.
+// Flattening all three to
 // `display: contents` turns every control into a direct flex item of `_row`,
 // which is what makes a pure `order` reflow possible without touching a
 // single official component.
@@ -10616,8 +10582,21 @@ const ROOT = '[data-slot="conversation.composer.bar"] > [class$="_root"]';
 const RING_W = '30px';
 /** DSH 0.1.7's wrapper around input.right + input.model inside `_trailing`. */
 const STD = `${ROW} > [class$="_trailing"] > [class$="_standardControls"]`;
-/** The model seat's own root inside the trailing group (long form so it beats the <=1023px pill rules in layout.css.ts). */
-const MODEL = `${STD} > [data-slot="conversation.input.model"] > [class$="_root"]`;
+/**
+ * The model seat's content, whichever plugin owns it: officially ModelSelect's
+ * `_root`, but a third party can replace the whole `conversation.input.model`
+ * slot (…codex-ui mounts its own selector there), and a subagent session has
+ * nothing matching `_root` at all. Spelled `*:not(…)` rather than bare `> *`
+ * on purpose: `:not([data-mobile-nav])` carries the same (0,1,0) the old
+ * `[class$="_root"]` did, keeping every rule below a full attribute CLASS
+ * ahead of the ≤1023px pill rules in layout.css.ts — their `[data-phase] …
+ * :has(…)` forms measure (0,6,1) on the trigger and (0,7,1) on the label
+ * with `!important`, so a bare `> *` would leave the phone winning by
+ * exactly one class on every MODEL-derived rule, one upstream attr away
+ * from losing. The :not() also keeps this plugin's own nodes from ever
+ * reading as the model seat, should one ever be mounted there.
+ */
+const MODEL = `${STD} > [data-slot="conversation.input.model"] > *:not([data-mobile-nav])`;
 /** The permission select's trigger button (structure only — the PermissionSelect hashed classes are never named). */
 const PERM = `${ROW} > [class$="_tools"] > [class$="_modes"]`;
 /**
@@ -10652,6 +10631,12 @@ exports.COMPOSER_CSS = `/* ---------- phone composer (< 768px) ---------- */
 [data-mobile-nav="attach-picker"] {
   display: none !important;
 }
+/* The composer-chips strip (effects/model-sheet-extras.ts) — same
+   every-width default as the picker above: the phone block re-shows it
+   inside the dock rail; the desktop shell keeps none. */
+[data-mobile-nav="composer-chips"] {
+  display: none !important;
+}
 
 @media (max-width: 767px) {
   /* --- 1. flatten the two official groups ---
@@ -10675,8 +10660,12 @@ exports.COMPOSER_CSS = `/* ---------- phone composer (< 768px) ---------- */
   }
 
   /* --- 2. the running order ---
-     The attachment button (S3 placeholder, S7 wires it up) sits leftmost;
-     the official "+" command menu keeps its seat right next to it, where
+     The attachment button (S3 placeholder, S7 wires it up) sits leftmost and
+     is a PERMANENT resident now (#31): on DSH 0.2.x the standalone paperclip
+     moved into the "+" command menu while its hidden <input type="file">
+     stayed in _tools, so the old host-attach stand-down probe matched on
+     every host and the phone composer was left with no attach affordance at
+     all. The official "+" command menu keeps its seat right next to it, where
      the two "insert something" affordances read as one cluster. */
   ${ROW} [data-mobile-nav="attach"] {
     order: 1 !important;
@@ -10684,6 +10673,14 @@ exports.COMPOSER_CSS = `/* ---------- phone composer (< 768px) ---------- */
   ${ROW} > [class$="_tools"] > [class$="_add"] {
     order: 2 !important;
   }
+  /* DSH ≤ 0.1.5 still renders that second _add button (the standalone
+     paperclip) as a direct _tools child; hide it below 768px so the row
+     keeps exactly one attach control — ours, which uploads into the session
+     workspace the phone can actually reach. On 0.2.x the only button in
+     _tools is the first of its type, so this never matches. */
+  ${ROW} > [class$="_tools"] > button[class$="_add"]:nth-of-type(2) {
+    display: none !important;
+  }
   ${ROW} > [class$="_tools"] > [class$="_modes"] {
     order: 3 !important;
     /* Rigid on purpose. This seat holds the permission chip, whose own
@@ -10835,7 +10832,8 @@ exports.COMPOSER_CSS = `/* ---------- phone composer (< 768px) ---------- */
      caps the pill so the row's elastic gap survives extreme model ids;
      the label rules below override the <=1023px grow rules in
      layout.css.ts (flex 1 1 auto) that would otherwise pad the pill. */
-  ${MODEL} > [class$="_trigger"] {
+  ${MODEL} > [class$="_trigger"],
+  ${MODEL} > button {
     background: var(--dsw-specific-selector, rgba(127, 127, 127, .12)) !important;
     height: 30px !important;
     width: auto !important;
@@ -10861,6 +10859,18 @@ exports.COMPOSER_CSS = `/* ---------- phone composer (< 768px) ---------- */
     flex: none !important;
     white-space: nowrap !important;
   }
+  /* Third-party model selectors (…codex-ui) render a bare <button> with no
+     _trigger classes and text straight inside it; give that button the same
+     shrink+truncate contract the official label gets, so a long model id
+     ellipsizes instead of stretching the row. The official trigger also
+     matches this (harmless: it already ellipsizes its own label). */
+  ${MODEL} > button {
+    max-width: 100% !important;
+    min-width: 0 !important;
+    overflow: hidden !important;
+    text-overflow: ellipsis !important;
+    white-space: nowrap !important;
+  }
   /* PermissionSelect wraps its trigger in the Menu primitive's root span,
      which must shrink to the icon button's fixed width. */
   ${PERM} > span:has(> button[class$="_trigger"]) {
@@ -10928,90 +10938,97 @@ exports.COMPOSER_CSS = `/* ---------- phone composer (< 768px) ---------- */
     border-radius: 12px !important;
     font-size: 15px !important;
   }
-  /* --- 4a. third-party composer entries live in the model sheet ---
-     effects/model-sheet-extras.ts parks the \`conversation.input.right\`
-     container inside the model menu while that menu is open and puts it back
-     when it closes; these rules are the two halves of that trip.
+  /* --- 4a. third-party composer entries live in the dock's chip strip ---
+     effects/model-sheet-extras.ts collects the composer's secondary controls
+     (input.right, input.left, and anything a third party parks directly into
+     _tools / _standardControls / _trailing / _row) and moves the REAL nodes
+     into [data-mobile-nav="composer-chips"] — a 26px horizontally
+     scrollable strip the effect mounts at the head of the dock rail above
+     the card. Always visible, one tap, no sheet in between.
 
-     In the row: hidden, but ONLY once the effect has marked the container as
-     one it manages. Keying the hide off the marker rather than off "not
-     currently parked" is what makes the failure direction safe — if the
-     effect declines to act (nothing in the slot but the vision toggle, so
-     nothing worth moving) or never runs at all, the marker is absent, this
-     rule does not match, and the controls stay exactly where the host put
-     them. The inverse spelling hid them in the row whenever they were not in
-     the sheet, which in those same cases left them reachable from neither
-     place (caught in review, 2026-09-06).
-     Hiding by ancestor rather than by a display rule on the container itself
-     is what lets the parked copy style itself freely — same element, two
-     homes, two rule sets. \`!important\` because the slot container carries an
-     inline \`display: contents\`. */
-  ${STD} > [data-slot="conversation.input.right"][data-zen-sheet-extras] {
+     In the row: hidden, but ONLY once the effect has marked them. Two opt-in
+     markers, both written by the effect: the input.right CONTAINER gets
+     data-zen-sheet-extras (so an emptied wrapper leaves no flex gap), and
+     every collected node gets data-zen-composer-extra. Visibility comes back
+     the moment a node is parked (="open") or the effect releases it (marker
+     removed) — a version of the effect that declines to act, or never runs
+     at all, leaves every control exactly where the host put it; nothing can
+     end up hidden from both places at once (the 2026-09-06 review's rule). */
+  [data-slot="conversation.input.right"][data-zen-sheet-extras],
+  [data-zen-composer-extra]:not([data-zen-composer-extra="open"]) {
     display: none !important;
   }
-  /* Parked in the sheet: a column of full-width rows in the sheet's own
-     language, so a relocated control reads as a sibling of 模型 and 推理等级
-     rather than a chip that wandered in. */
-  ${MODEL_MENU} > [data-zen-sheet-extras] {
+  /* The strip itself: one 26px line at the rail's head (order 0, document
+     order first via the effect's prepend), scrolling sideways when the
+     collected controls overflow. Scoped to the dock CHILD — the generic
+     marker also sits on the emptied input.right container in the row, where
+     nothing but the opt-in hide above may touch it. This specificity (0,2,0)
+     is what beats the section 7 \`> *\` cage wherever they overlap (overflow,
+     max-width, radius are all !important there too). */
+  [data-slot="conversation.input.dock"] > [data-mobile-nav="composer-chips"] {
     display: flex !important;
-    flex-direction: column !important;
-    gap: 2px !important;
-    width: 100% !important;
-  }
-  /* Undo the row's compaction on every parked control: back to full width and
-     the 48px the sheet's own cells use. \`> * > *\` reaches both shapes without
-     naming either plugin — subscriptions wraps its trigger in a positioning
-     div, vision-router puts its button straight in the slot. */
-  ${MODEL_MENU} > [data-zen-sheet-extras] > *,
-  ${MODEL_MENU} > [data-zen-sheet-extras] > * > button {
-    width: 100% !important;
-    max-width: none !important;
+    flex-flow: row nowrap !important;
+    align-items: center !important;
+    gap: 6px !important;
+    order: 0 !important;
+    flex: 0 1 auto !important;
     min-width: 0 !important;
-    justify-content: flex-start !important;
+    max-width: 100% !important;
+    min-height: 26px !important;
+    max-height: 26px !important;
+    border-radius: 0 !important;
+    overflow-x: auto !important;
+    overflow-y: hidden !important;
+    scrollbar-width: none !important;
   }
-  ${MODEL_MENU} > [data-zen-sheet-extras] button {
-    box-sizing: border-box !important;
-    min-height: 48px !important;
-    height: auto !important;
-    padding: 0 12px !important;
-    gap: 10px !important;
-    border-radius: 12px !important;
-    border: none !important;
-    background: transparent !important;
-    font-size: 15px !important;
-    /* Both plugins center their chip label, which is right for a pill in the
-       row and wrong for a full-width row: the sheet's own cells start their
-       label at the left edge. justify-content covers the flex triggers,
-       text-align the ones that are not flex containers. */
-    text-align: left !important;
-    justify-content: flex-start !important;
+  [data-slot="conversation.input.dock"] > [data-mobile-nav="composer-chips"]::-webkit-scrollbar {
+    display: none !important;
   }
-  /* Order comes from the row (compat.css.ts puts the vision toggle at 5 so it
-     parks beside the context ring), and that rule still matches in here on
-     ≤ 0.1.2 — the inline sheet is a DOM descendant of the composer bar even
-     though it paints as a fixed layer (the 0.1.5 body portal is not, where
-     this is a harmless no-op). Reset it so the sheet follows DOM order
-     instead of inheriting a decision that was about a different layout. */
-  ${MODEL_MENU} > [data-zen-sheet-extras] > * {
+  /* Parked controls shrink from whatever the row allowed them to the rail's
+     26px pill scale: auto width again (no full-width rows here), tight
+     height, and the chip font the rest of the rail uses. */
+  [data-mobile-nav="composer-chips"] > * {
+    flex: 0 0 auto !important;
     order: 0 !important;
+    display: inline-flex !important;
+    align-items: center !important;
+    min-height: 26px !important;
+    max-height: 26px !important;
+    width: auto !important;
+    max-width: none !important;
   }
-  /* The vision toggle is squeezed to a 28px icon in the row (compat.css.ts);
-     in the sheet it is a row, so its label comes back and the icon leads. */
-  ${MODEL_MENU} > [data-zen-sheet-extras] [data-vision-router-mode-toggle] > span {
+  [data-mobile-nav="composer-chips"] button {
+    box-sizing: border-box !important;
+    height: 26px !important;
+    min-height: 26px !important;
+    max-height: 26px !important;
+    width: auto !important;
+    padding: 0 10px !important;
+    gap: 5px !important;
+    border-radius: 999px !important;
+    font-size: 11.5px !important;
+    line-height: 18px !important;
+    white-space: nowrap !important;
+  }
+  /* The vision toggle is squeezed to a 28px icon-only button in the row
+     (compat.css.ts); in the strip it is a 14px icon + text pill, so its
+     label comes back. */
+  [data-mobile-nav="composer-chips"] [data-vision-router-mode-toggle] > span {
     display: inline !important;
   }
-  ${MODEL_MENU} > [data-zen-sheet-extras] [data-vision-router-mode-toggle] > svg:first-of-type {
-    width: 18px !important;
-    height: 18px !important;
+  [data-mobile-nav="composer-chips"] [data-vision-router-mode-toggle] > svg:first-of-type {
+    width: 14px !important;
+    height: 14px !important;
   }
   /* The speed chip opens a menu of its own, anchored \`bottom: 100%\` to its
-     trigger. Inside the sheet — which is \`overflow: hidden\` so its rounded
-     top clips its content — that menu would be cut off. Same escape section 4
-     uses for the host's two menus: position: fixed leaves the clip behind
-     (the sheet sets \`transform: none\`, so nothing between here and the
-     viewport captures fixed positioning) and it lands as its own sheet on top
-     of this one. */
-  ${MODEL_MENU} > [data-zen-sheet-extras] [role="menu"] {
+     trigger. Inside the strip — which is \`overflow-x: auto\`, so its content
+     clips at the strip's box — that menu would be cut off. Same escape
+     section 4 uses for the host's two menus: position: fixed leaves the clip
+     behind and it lands as its own bottom sheet over the composer. */
+  [class$="_composerSeat"]:has([data-zen-sheet-extras] [role="menu"]) {
+    z-index: 60 !important;
+  }
+  [data-zen-sheet-extras] [role="menu"] {
     position: fixed !important;
     left: 0 !important;
     right: 0 !important;
@@ -11026,13 +11043,13 @@ exports.COMPOSER_CSS = `/* ---------- phone composer (< 768px) ---------- */
     border-radius: 16px 16px 0 0 !important;
     border-bottom: none !important;
     padding: 8px 8px calc(8px + var(--mnav-sab)) !important;
-    /* Above the model sheet it sits on (60, section 4), below the session-info
-       sheet's 70 (info.css.ts) — it is a child of the model sheet, not a peer
-       of the page's own layers. */
+    /* Above the page content behind the seat (the seat is raised to 60 by
+       the rule above while a parked menu is open), below the session-info
+       sheet's 70 (info.css.ts). */
     z-index: 61 !important;
     box-shadow: 0 -8px 32px rgba(0, 0, 0, .18) !important;
   }
-  ${MODEL_MENU} > [data-zen-sheet-extras] [role="menu"] [role="menuitemradio"] {
+  [data-zen-sheet-extras] [role="menu"] [role="menuitemradio"] {
     min-height: 48px !important;
     border-radius: 12px !important;
     font-size: 15px !important;
@@ -11060,7 +11077,10 @@ exports.COMPOSER_CSS = `/* ---------- phone composer (< 768px) ---------- */
   body:has(${MODEL} > [class$="_menu"]) [data-chat-flow] + div,
   body:has(> [id$="-menu"][class$="_menu"]:is([role="menu"], [role="group"])) [data-chat-flow] + div,
   /* T70: the portaled permission menu (marked by effects/permission-sheet.ts). */
-  body:has(> div[role="menu"][data-zen-sheet="perm"]) [data-chat-flow] + div {
+  body:has(> div[role="menu"][data-zen-sheet="perm"]) [data-chat-flow] + div,
+  /* T-issue30: an inline menu a parked chip opened (escaped to a fixed
+     sheet by 4a). */
+  body:has([data-zen-sheet-extras] [role="menu"]) [data-chat-flow] + div {
     display: none !important;
   }
   /* --- 5. input box: two lines minimum, five lines maximum ---
@@ -14194,164 +14214,288 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.installModelSheetExtras = installModelSheetExtras;
 /** Phone breakpoint — same query every phone-only effect in this plugin uses. */
 const PHONE_QUERY = '(max-width: 767px)';
-/** The model pill itself. Absent in a subagent session — see `sync`. */
-const MODEL_SEAT_SELECTOR = '[data-slot="conversation.input.model"]';
-/** The model pill's own popup, which section 4 of composer.css.ts turns into
- * a bottom sheet — inline under the pill on ≤ 0.1.2, portaled to body on
- * 0.1.5+ (same two spellings as composer.css.ts's MODEL_MENU; the body form
- * is the only body-level `role=menu` with an `-menu` id, measured on
- * 0.1.5-rc.2). Appending into the portal root is no different from the
- * inline case: React leaves nodes it did not create alone, and the sheet
- * still unmounts on close, which is what the detached-menu path handles. */
-const MENU_SELECTOR = '[data-slot="conversation.input.model"] [class$="_menu"], body > [id$="-menu"][role="menu"]';
+/** The composer bar slot: the scan root, and the anchor the synthetic dock
+ * rail hangs beside (hero stage). */
+const BAR_SELECTOR = '[data-slot="conversation.composer.bar"]';
 /**
- * The third-party composer controls this effect relocates. Both register into
- * `conversation.input.right`; moving the slot container rather than its
- * children keeps them together and leaves exactly one node to put back.
+ * Where a secondary control can legally sit in the composer, as ONE selector
+ * list scanned inside the bar. Slots first (input.right / input.left), then
+ * the official flex groups, then the row itself — a third party may inject
+ * at any of the six (subscriptions and vision-router register into
+ * input.right; dsh-workbuddy's credits and dsh-skills-ui's chips hang off
+ * _row directly). Every position excludes `[data-mobile-nav]` so this
+ * plugin's own nodes (the strip itself, and anything else we mount) are
+ * never collected, and the official controls by name, so the whitelist
+ * never fights the host. opt-in by marker, never `:not()`-hide unclaimed
+ * nodes — the failure direction is "extra control stays visible", never
+ * "control hidden from both places".
  */
-const EXTRAS_SELECTOR = '[data-slot="conversation.input.right"]';
+const EXTRAS_SELECTOR = [
+    '[data-slot="conversation.input.right"] > *:not([data-mobile-nav])',
+    '[data-slot="conversation.input.left"] > *:not([data-mobile-nav])',
+    '[class$="_tools"] > *:not(button[class$="_add"]):not(input[type="file"]):not([class$="_modes"]):not([data-slot="conversation.input.left"]):not([data-mobile-nav])',
+    '[class$="_standardControls"] > *:not([data-slot="conversation.input.model"]):not([data-slot="conversation.input.right"]):not([data-mobile-nav])',
+    '[class$="_trailing"] > *:not([class$="_standardControls"]):not([class$="_activity"]):not([class$="_primary"]):not([data-mobile-nav])',
+    '[class$="_row"] > *:not([class$="_tools"]):not([class$="_trailing"]):not([data-mobile-nav])',
+].join(', ');
 /**
- * dsh-vision-router's own mount marker. Used here only to answer "is there
- * anything in this slot BESIDES the vision toggle" — see `worthMoving`.
+ * dsh-vision-router's own mount marker. Used only to answer "is the single
+ * collected control the vision toggle" — see `worthMoving`.
  */
 const VISION_SELECTOR = '[data-vision-router-mode-toggle]';
 /**
- * Set on the container while this effect manages it, in the row and in the
- * sheet alike. It is the styling hook for both halves in composer.css.ts, and
- * it is deliberately what the row's `display: none` keys off: without the
- * marker the controls stay exactly where the host put them, so a version of
- * this file that declines to act — or never runs at all — cannot leave them
- * hidden in the row and absent from the sheet, i.e. unreachable.
+ * On the input.right CONTAINER while the effect manages any of its children,
+ * and on the strip itself. It is the styling hook for both halves in
+ * composer.css.ts (the emptied container hides without leaving a flex gap;
+ * an inline `[role="menu"]` opened by a parked chip escapes the strip's
+ * overflow clip through it). It is deliberately what the row's
+ * `display: none` keys off: without the marker the controls stay exactly
+ * where the host put them, so a version of this file that declines to act —
+ * or never runs at all — cannot leave them hidden in the row and absent from
+ * the strip, i.e. unreachable.
  */
 const MANAGED = 'data-zen-sheet-extras';
 /**
- * Is the slot holding anything that actually costs the row width?
+ * On every collected NODE while it is parked in the strip. Purely opt-in:
+ * the marker's absence never hides anything, and `releaseAll` removes it —
+ * an unmarked control is the host's own business again.
+ */
+const EXTRA = 'data-zen-composer-extra';
+/**
+ * Is there anything collected that actually costs the row width?
  *
  * The row is one nowrap flex line whose only elastic item is the model pill
  * (composer.css.ts section 1), so entries here are paid for out of the model
- * name. But that is only a problem once something WIDE lands in the slot —
- * today dsh-plugin-subscriptions' speed chip, which renders "速度 · 标准" and
- * eats ~70px. dsh-vision-router's toggle alone is a 28px icon that the row
- * accommodates fine, and moving it on its own would cost a tap (it becomes
- * two: open the sheet, then toggle) to buy width nobody needed.
+ * name. But that is only a problem once something WIDE lands there — today
+ * dsh-plugin-subscriptions' speed chip, which renders "速度 · 标准" and eats
+ * ~70px. dsh-vision-router's toggle alone is a 28px icon that the row
+ * accommodates fine, and moving it on its own would cost nothing visually
+ * but would hide a one-tap control behind a scroll (user review, 2026-09-06).
  *
- * So: relocate only when the slot holds an entry that is not the vision
- * toggle. With no such entry — subscriptions not installed, or installed but
- * not contributing on this model — nothing moves and the row keeps its one
- * icon, which is the behaviour asked for (user review, 2026-09-06).
+ * So: move only when the collection holds an entry that is not (or does not
+ * contain) the vision toggle. With no such entry — subscriptions not
+ * installed, or installed but not contributing on this model — nothing moves
+ * and the row keeps its one icon. Why width rather than sniffing for
+ * subscriptions by name: the slot system adds no per-registration marker, so
+ * naming the plugin would anchor on a marker we'd have to add to our own
+ * fork of it, and the feature would die the day the fork is dropped. The
+ * width question is the real question anyway, and this asks it directly.
  *
- * Why this rather than sniffing for subscriptions by name: the slot system
- * adds no per-registration marker (measured — entries render straight into the
- * container) and subscriptions marks nothing of its own, so naming it would
- * mean adding a marker to our fork of that plugin and anchoring on it. That
- * marker dies the day the fork is dropped, and the feature would go quiet
- * with nothing to catch it. The width question is the real question anyway,
- * and this asks it directly.
+ * Unlike the pre-#30 design, NOTHING here depends on the official model
+ * pill existing: replaced model slots (…codex-ui) and subagent sessions —
+ * which have no pill at all — collect and relocate exactly like everyone
+ * else.
  */
-function worthMoving(extras) {
-    return [...extras.children].some(child => !child.matches(VISION_SELECTOR));
+function worthMoving(controls) {
+    if (controls.length === 0)
+        return false;
+    if (controls.length === 1) {
+        const child = controls[0];
+        if (child === undefined)
+            return false;
+        // "is or contains" — some plugins wrap their toggle in a positioning node.
+        if (child.matches(VISION_SELECTOR) || child.querySelector(VISION_SELECTOR) !== null)
+            return false;
+    }
+    return true;
 }
 /**
- * Phone: park the composer row's third-party controls inside the model sheet.
+ * Phone: move the composer row's secondary third-party controls into a
+ * 26px horizontally-scrollable strip inside the dock rail above the card —
+ * always visible, one tap from anywhere, no sheet in between.
  *
- * With the speed chip and the vision toggle both present on a GPT model the
- * row runs out of width. Both are model-scoped settings, so the model sheet —
- * which already holds 模型 and 推理等级 — is where they belong (user request,
- * 2026-09-06).
+ * Why move the real controls instead of drawing our own rows that drive
+ * them: the same reason native-trigger-overlay.ts moves the real trigger. A
+ * stand-in has to script the original, which is a road this plugin does not
+ * go down — beyond the trusted-input wall that effect documents, our own
+ * rows would have to mirror every piece of state (speed tier, disabled,
+ * aria-pressed, whether a vision twin exists for the current model) and
+ * would rot on the next upstream restyle. Moving the node keeps one source
+ * of truth: their React roots go on owning and updating these elements, we
+ * only change where they hang — never cloneNode, and the move is anchored
+ * with a Comment at the original spot so `unparkAll` can put each node back
+ * exactly where React left it.
  *
- * Why move the real controls instead of drawing our own rows that drive them:
- * the same reason native-trigger-overlay.ts moves the real trigger. A stand-in
- * has to script the original, which is a road this plugin does not go down —
- * beyond the trusted-input wall that effect documents, our own rows would have
- * to mirror every piece of state (speed tier, disabled, aria-pressed, whether
- * a vision twin exists for the current model) and would rot on the next
- * upstream restyle. Moving the node keeps one source of truth: their React
- * roots go on owning and updating these elements, we only change where they
- * hang.
+ * Measured 2026-09-06 (DSH 0.1.2, 390px) before the original version of
+ * this effect — the two things that would have killed the approach both
+ * hold: a relocated control survives host re-renders (typing into the
+ * composer re-renders the row and does not yank it back) and stays
+ * hit-testable at its new position.
  *
- * Measured 2026-09-06 (DSH 0.1.2, 390px) before writing this — the two things
- * that would have killed the approach both hold: a relocated control survives
- * host re-renders (typing into the composer re-renders the row and does not
- * yank it back) and stays hit-testable at its new position.
- *
- * Restoring on close is not cosmetic. The sheet unmounts when it closes and
- * anything still inside goes with it, so the controls would vanish from the
- * page while their React roots kept updating detached nodes. The observer
- * therefore watches the menu leaving too, and the parked node is held as a
- * reference rather than looked up — once the menu is detached a document
- * query can no longer find it.
+ * Known hazard, inherent to relocating React-owned nodes: a control whose
+ * REGISTRATION unmounts while parked (plugin disabled, slot re-keyed) is
+ * removed by React through its ORIGINAL parent — `parent.removeChild(child)`
+ * throws when the child moved, and the exception lands in React's commit.
+ * Updates that keep the registration mounted (state-driven re-renders,
+ * text/attribute changes, a control's own inner nodes unmounting) are safe:
+ * those removals run inside the parked subtree, where every parent-child
+ * link React recorded still holds. Parking is also fully reversible — any
+ * decline path (desktop, nothing worth moving, teardown) hands every node
+ * back before anything is removed.
  */
 function installModelSheetExtras(ctx) {
     ctx.effect(() => {
         const phone = window.matchMedia(PHONE_QUERY);
-        /** The container while parked in the sheet, plus where to put it back. */
-        let parked = null;
-        const park = (node, menu) => {
-            if (parked !== null || node.parentElement === null)
-                return;
-            parked = { node, parent: node.parentElement, next: node.nextSibling };
-            menu.appendChild(node);
+        /** Parked nodes with the Comment anchoring each one's original spot. */
+        let parked = [];
+        let syntheticDock = null;
+        /** Collected controls, document order; parked ones appended so the set
+         * stays stable while they live in the strip. */
+        const collect = (bar) => {
+            const controls = Array.from(bar.querySelectorAll(EXTRAS_SELECTOR));
+            for (const { node } of parked) {
+                if (node.isConnected && !controls.includes(node))
+                    controls.push(node);
+            }
+            return controls;
         };
-        const unpark = () => {
-            if (parked === null)
+        const park = (node, strip) => {
+            if (node.parentElement === null)
                 return;
-            const { node, parent, next } = parked;
-            parked = null;
-            // The menu may already be detached, having taken the container with it.
-            // The node itself is still live either way; re-home it only if its old
-            // parent is still on the page (when the whole composer went away, the
-            // owning React roots rebuild the slot on the next mount).
-            if (parent.isConnected)
-                parent.insertBefore(node, next);
+            const placeholder = document.createComment('zen-composer-extra');
+            node.parentElement.insertBefore(placeholder, node);
+            node.setAttribute(EXTRA, 'open');
+            strip.appendChild(node);
+            parked.push({ node, placeholder });
+        };
+        const unparkAll = () => {
+            for (const { node, placeholder } of parked) {
+                // Re-home only while the anchor still marks the spot AND that home
+                // is on the page — when the whole composer went away, the owning
+                // React roots rebuild the slot on the next mount.
+                if (placeholder.parentNode !== null && placeholder.parentNode.isConnected) {
+                    placeholder.parentNode.insertBefore(node, placeholder);
+                }
+                placeholder.remove();
+                node.removeAttribute(EXTRA);
+            }
+            parked = [];
         };
-        /** Hand the container back to the host, marker and all. */
-        const release = (node) => {
-            unpark();
-            node?.removeAttribute(MANAGED);
+        /** Everything the effect owns, back to host-placed defaults: parked
+         * nodes re-homed, strip, synthetic rail and every marker gone.
+         * Idempotent — teardown and every decline path go through here. */
+        const releaseAll = () => {
+            unparkAll();
+            document.querySelector('[data-mobile-nav="composer-chips"]')?.remove();
+            syntheticDock?.remove();
+            syntheticDock = null;
+            const bar = document.querySelector(BAR_SELECTOR);
+            const scope = bar ?? document;
+            for (const node of scope.querySelectorAll(`[${EXTRA}]`))
+                node.removeAttribute(EXTRA);
+            bar?.querySelector('[data-slot="conversation.input.right"]')?.removeAttribute(MANAGED);
+        };
+        /** The rail the strip lives in — the host's own dock, or a synthetic
+         * stand-in while the hero composer has rendered none yet. */
+        const adoptDock = (bar) => {
+            // :not([data-zen-synthetic-dock]) is load-bearing: the synthetic rail
+            // is bar's SIBLING carrying the same data-slot, so an unqualified
+            // query would find it as the "real" dock, delete it as stale, recreate
+            // it after — the observer would oscillate forever.
+            const dock = bar.parentElement?.querySelector('[data-slot="conversation.input.dock"]:not([data-zen-synthetic-dock])') ?? null;
+            if (dock !== null) {
+                if (syntheticDock !== null) {
+                    // Real dock appeared: hand every parked node back before the
+                    // synthetic rail (and the strip inside it) is destroyed — removing
+                    // a rail full of React-owned controls would detach them from the
+                    // page. sync re-parks them into the new strip right after.
+                    unparkAll();
+                    syntheticDock.remove();
+                    syntheticDock = null;
+                }
+                return dock;
+            }
+            if (syntheticDock === null || !syntheticDock.isConnected) {
+                syntheticDock = document.createElement('div');
+                syntheticDock.setAttribute('data-slot', 'conversation.input.dock');
+                syntheticDock.setAttribute('data-zen-synthetic-dock', '');
+                bar.parentNode?.insertBefore(syntheticDock, bar);
+            }
+            return syntheticDock;
+        };
+        const ensureStrip = (home) => {
+            let strip = home.querySelector('[data-mobile-nav="composer-chips"]');
+            if (strip === null) {
+                strip = document.createElement('div');
+                strip.setAttribute('data-mobile-nav', 'composer-chips');
+                strip.setAttribute(MANAGED, '');
+                // Document-order first; CSS `order: 0` keeps it the rail's leftmost
+                // pill line among the order-0 ties.
+                home.prepend(strip);
+            }
+            return strip;
         };
         const sync = () => {
-            const extras = document.querySelector(EXTRAS_SELECTOR);
-            if (extras === null) {
-                unpark();
+            const bar = document.querySelector(BAR_SELECTOR);
+            if (bar === null) {
+                releaseAll();
                 return;
             }
-            // No model pill, no sheet to park into — a subagent session has none.
-            // Claiming the slot there would hide the controls from the row with
-            // nowhere to show them instead, which is the unreachable state the
-            // marker is meant to prevent.
-            const seat = document.querySelector(MODEL_SEAT_SELECTOR);
-            if (!phone.matches || seat === null || !worthMoving(extras)) {
-                release(extras);
+            // A parked node its own React root unmounted is dead weight; drop it
+            // and its anchor before collecting, so it neither blocks nor hides.
+            parked = parked.filter(({ node, placeholder }) => {
+                if (node.isConnected)
+                    return true;
+                placeholder.remove();
+                return false;
+            });
+            const controls = collect(bar);
+            if (!phone.matches || !worthMoving(controls)) {
+                releaseAll();
                 return;
             }
-            extras.setAttribute(MANAGED, '');
-            const menu = document.querySelector(MENU_SELECTOR);
-            if (menu === null)
-                unpark();
-            else
-                park(extras, menu);
+            const home = adoptDock(bar);
+            const strip = ensureStrip(home);
+            // Parked entries the set has outgrown (an uninstalled plugin, a
+            // re-render that moved a control into a claimed position) go home and
+            // lose their marker.
+            parked = parked.filter(({ node, placeholder }) => {
+                if (controls.includes(node) && node.isConnected)
+                    return true;
+                if (node.isConnected && placeholder.parentNode !== null && placeholder.parentNode.isConnected) {
+                    placeholder.parentNode.insertBefore(node, placeholder);
+                }
+                placeholder.remove();
+                node.removeAttribute(EXTRA);
+                return false;
+            });
+            for (const node of controls) {
+                if (!parked.some((entry) => entry.node === node))
+                    park(node, strip);
+            }
+            // Stale markers anywhere in the bar — parked ones are in `controls`,
+            // so they survive this sweep.
+            for (const node of bar.querySelectorAll(`[${EXTRA}]`)) {
+                if (!controls.includes(node))
+                    node.removeAttribute(EXTRA);
+            }
+            const right = bar.querySelector('[data-slot="conversation.input.right"]');
+            if (right !== null) {
+                const rightManaged = right.children.length > 0 ||
+                    parked.some(({ placeholder }) => placeholder.parentNode === right);
+                if (rightManaged)
+                    right.setAttribute(MANAGED, '');
+                else
+                    right.removeAttribute(MANAGED);
+            }
         };
         // Synchronous in the observer callback, never behind rAF: the callback is
-        // a microtask and runs before this frame paints, so the controls are in
-        // the sheet the first time it is drawn. A rAF would land a frame late and
-        // show one frame of the sheet without them (AGENTS.md's "晚一帧" rule).
-        // Body-level childList is the same shape modal-back.ts uses; aria-expanded
-        // is watched too so a close that reuses the node still re-syncs.
+        // a microtask and runs before this frame paints, so the strip and the
+        // parked nodes are in place the first time their frame is drawn. A rAF
+        // would land a frame late (AGENTS.md's "晚一帧" rule). Body-level
+        // childList is the same shape modal-back.ts uses. The observer also sees
+        // this effect's own moves; sync is idempotent, so the extra pass is a
+        // no-op.
         const observer = new MutationObserver(sync);
-        observer.observe(document.body, {
-            childList: true,
-            subtree: true,
-            attributes: true,
-            attributeFilter: ['aria-expanded'],
-        });
+        observer.observe(document.body, { childList: true, subtree: true });
         phone.addEventListener('change', sync);
         sync();
         return () => {
             observer.disconnect();
             phone.removeEventListener('change', sync);
-            release(document.querySelector(EXTRAS_SELECTOR));
+            releaseAll();
         };
-    }, 'dsh-mobile-nav: model sheet extras');
+    }, 'dsh-mobile-nav: composer chips extras');
 }
 };
 __modules["client/effects/permission-sheet.js"] = function (require, module, exports) {