dsh-claude-desktop-theme 0.2.0 → 0.3.0

package/lib/types/client/compat/host-dom.d.ts

@@ -56,6 +56,7 @@ export declare const HOST: Readonly<{
     /** SidebarRoot.module.css: expanded macOS window-chrome toggle. */
     readonly sidebarToggle: '._3WPZCG_toggle';
     readonly sidebarNewSession: '._3WPZCG_newSession';
+    readonly sidebarNewSessionContent: '._3WPZCG_newSessionContent';
     readonly sidebarNewSessionLabel: '._3WPZCG_newSessionLabel';
     readonly sidebarNewSessionShortcut: '._3WPZCG_newSessionShortcut';
     readonly sidebarPanelList: '._3WPZCG_panelList';
@@ -70,6 +71,22 @@ export declare const HOST: Readonly<{
     readonly browserSectionHeader: '._7514NG_sectionHeader';
     readonly browserSectionLabel: '._7514NG_sectionLabel';
     readonly browserListArea: '._7514NG_listArea';
+    /**
+     * WorkspaceBrowser.module.css: the section header's view-options trigger —
+     * the one control there that is an `iconButton` *and* carries `wide` (its
+     * neighbours are `searchButton` and a plain `iconButton`), and the list class
+     * its card puts on the `Menu` surface. `compat/view-options.ts` reads the
+     * values out of that card and clicks its rows; the card itself is kept off
+     * screen while it does.
+     */
+    readonly viewOptionsTrigger: '._7514NG_sectionHeader ._7514NG_iconButton._7514NG_wide';
+    readonly viewOptionsMenu: '._7514NG_viewOptionsMenu';
+    /**
+     * WorkspaceBrowser.module.css: one Workspace's row container — the box that
+     * holds its Workspace row, its nested groups and its Session rows, and the
+     * box `compat/empty-groups.ts` hides when the group has nothing to show.
+     */
+    readonly workspaceGroup: '._7514NG_groupSection';
     readonly settingsTrigger: '.Dws9Sa_trigger';
     readonly settingsTriggerRow: '.Dws9Sa_triggerRow';
     readonly accountTrigger: '.ZogL4G_trigger';
@@ -104,6 +121,12 @@ export declare const HOST: Readonly<{
     readonly assistantMarkdown: '.gKv1-q_root';
     readonly markdownBody: '._markdown_1ypvv_5:not([data-markdown-variant="compact"])';
     readonly markdownFileMention: '._fileMention_1ypvv_85';
+    /**
+     * MarkdownText.module.css: the category glyph the host seats inside a URL
+     * anchor (and inside file mentions and URL-promoted inline code). `conversation.css`
+     * hides the anchor's copy; the reference draws link text alone.
+     */
+    readonly markdownLinkIcon: '._linkIcon_1ypvv_94';
     readonly conversationScroll: '.ST7X_W_scrollBody';
     /** ChatView.module.css: the transcript's own scroll column, inside the page's
         scroll viewport, and the two shells of the floating jump-to-bottom control
@@ -156,6 +179,17 @@ export declare const HOST: Readonly<{
     readonly modelSelectEffort: '.cl2Rlq_triggerEffort';
     /** PermissionSelect.module.css: compact permission text, keeping its button. */
     readonly permissionSelectLabel: '.wXeviG_triggerLabel';
+    /** PermissionSelect.module.css: the control itself, in the status bar and in
+        the new-session card alike — `compat/permission-menu.ts` reads the mode's
+        name off it, and writes the card's own wording back. */
+    readonly permissionSelectTrigger: '.wXeviG_trigger';
+    /** PermissionSelect.module.css: the one preset badge DSH marks (`EXP`), on
+        the trigger as well as on the option row it belongs to. */
+    readonly permissionSelectBadge: '.wXeviG_badge';
+    /** PermissionSelect.module.css: the badge row's own name, told apart from the
+        badge beside it — the row label carries both, and only this one is the
+        preset's name. */
+    readonly permissionSelectOptionLabelText: '.wXeviG_optionLabelText';
     /** TeamAction.module.css: native team dialog entry, retaining its label at every width. */
     readonly teamActionTrigger: '._2tNPVa_trigger';
     readonly teamActionLabel: '._2tNPVa_triggerLabel';
@@ -169,6 +203,15 @@ export declare const HOST: Readonly<{
     readonly statsSeparator: '.OpZ85W_sep';
     readonly statsPill: '.OpZ85W_pill';
     readonly contextMeterTrigger: '.y0jqnG_trigger';
+    /**
+     * ContextMeter.module.css: the host's own click-open breakdown panel. It is a
+     * `position: fixed` portal on `document.body` at `z-index: 1100` rather than a
+     * native popover, so this plugin's panel — a top-layer popover — paints over
+     * it; the marker the driver writes is the belt to that braces, and it keeps
+     * the host's panel out of the paint if a click ever reaches DSH's own
+     * handler. `compat/context-panel.ts` is the only reader.
+     */
+    readonly contextMeterPanel: '.y0jqnG_panel';
     readonly heroRoot: '.bocITq_root';
     readonly heroHeadline: '.bocITq_headline';
     readonly heroWorkspaceChip: '.bocITq_workspace';
@@ -180,6 +223,20 @@ export declare const HOST: Readonly<{
     /** Every menu surface the `Menu` primitive renders, portal or in place. */
     readonly menu: '[role="menu"]';
     readonly menuItem: '[role="menuitem"]';
+    /** Menu.module.css: the row's own label seat, the one box this plugin puts a
+        second line after (`compat/permission-menu.ts`). The `_4ub78_` prefix is
+        the static web frontend's bundle, identical in both installers, so it needs
+        no entry in `host-builds.ts` — the same fact `tokens.css` records for the
+        primitive's check mark. */
+    readonly menuItemLabel: '._itemLabel_4ub78_190';
+    /** Menu.module.css: the trailing mark a *selected* row draws — `Menu` renders
+        it only for the row whose id is in `selectedIds`, so its presence is how
+        `compat/view-options.ts` reads which option is current. */
+    readonly menuItemCheck: '._check_4ub78_179';
+    /** Menu.module.css: the scrolling row group inside the card — where the
+        permission card's heading is written, above the rows and outside the
+        keyboard's walk (that walk collects `button`s only). */
+    readonly menuViewport: '._viewport_4ub78_19';
 }>;
 /**
  * Anchors that must exist before a feature may touch the host DOM. They are
@@ -220,6 +277,13 @@ export declare const ANCHOR: Readonly<{
      * with a Session, so this is the seat the no-session pet is measured from.
      */
     readonly composerCardHero: ".ST7X_W_root[data-phase=\"hero\"] [data-composer-card]";
+    /**
+     * ConversationRoot.tsx: the conversation body, carrying the Session identity
+     * the context panel reads its projections by. The Composer seat — and so the
+     * context ring — is a descendant, which is what makes `closest()` from the
+     * trigger enough. The host's own stable hook rather than the hashed class.
+     */
+    readonly conversationSession: '[data-conversation-session]';
 }>;
 /** One document's selector table, resolved for the build that document runs. */
 export type HostSelectors = Readonly<Record<keyof typeof HOST, string>>;

package/lib/types/client/compat/permission-menu.d.ts

@@ -0,0 +1,88 @@
+import type { Disposer } from '../contracts/ports.ts';
+/** Names the preset a tagged row switches to; `theme/menus.css` keys the two-line cell off it. */
+export declare const PERMISSION_MODE_ATTRIBUTE = "data-ccd-permission-mode";
+/** Tags the card those rows sit in, so the stylesheet can reach the card itself. */
+export declare const PERMISSION_MENU_ATTRIBUTE = "data-ccd-permission-menu";
+/** One preset as the card draws it. */
+export interface PermissionPresetCopy {
+    /** DSH's machine value for the preset (`read-only`, `auto`, …): the row's identity, never shown. */
+    readonly value: string;
+    /** The name DSH renders, which is what a row is recognised by. */
+    readonly name: string;
+    /** The name to draw — the same wording wherever the host's is already the one to use. */
+    readonly label: string;
+    /** The preset's trailing badge: the word DSH prints, and the word to print instead. */
+    readonly badge?: {
+        readonly host: string;
+        readonly text: string;
+    };
+    /** The row's second line, saying what the mode does. */
+    readonly description: string;
+}
+/** The card's copy in one language. */
+export interface PermissionCopy {
+    /** The group's name, above the rows — the one thing the reference writes that the host does not. */
+    readonly heading: string;
+    readonly presets: readonly PermissionPresetCopy[];
+}
+/**
+ * The card's copy for the document on screen.
+ *
+ * DSH localises its own strings through `ctx.locale`; a third-party plugin may
+ * not borrow another package's namespace, so the second line follows the
+ * document language instead — the same rule `compat/header-labels.ts` follows.
+ *
+ * @param document - renderer document whose language DSH sets from the locale.
+ * @returns Chinese copy for a Chinese document, English otherwise.
+ */
+export declare function permissionCopy(document: Document): PermissionCopy;
+/**
+ * The permission picker's card, drawn the way the reference draws it.
+ *
+ * DSH's card is four flat rows of a preset's name — `仅可查看` / `工作区内修改`
+ * / `完全权限` / `Auto review` — one 20px line each, and the only thing that
+ * tells them apart is the name itself. The reference draws the same four
+ * choices as two-line cells: the mode's name over a sentence saying what the
+ * mode does, with the one flagged preset carrying a badge beside its name. The
+ * names are the host's and stay the host's; what this module adds is the second
+ * line, and its home is a node the host never renders — `optionDescription`
+ * exists in the permission catalog, but the picker passes it to the trigger's
+ * `title` and prints nothing in the row.
+ *
+ * So this is the one compat module that *writes* copy rather than rewriting
+ * what the host rendered, and the copy is this plugin's own: see
+ * `permissionCopy` above. It is kept in one table per document language, so a
+ * wording change is one edit in one place.
+ *
+ * Three facts decide how the rows are reached, and each is worth stating:
+ *
+ * - **A row is recognised by its name.** `Menu` rows carry no identity of their
+ *   own — no id, no data attribute, and the preset's own glyph is a thing this
+ *   plugin removes (`theme/menus.css` hides the icon seat) — so the name the
+ *   host localised is the only handle there is. That is the same fact
+ *   `compat/workspace-menu.ts` reads for its own row, and it fails safe: a
+ *   deployment that configured its own preset names matches nothing, and its
+ *   card keeps the host's single-line rows exactly as they are.
+ * - **The card is recognised by its rows.** The picker's trigger carries no
+ *   `aria-expanded` (unlike the account trigger and the hero chips), so the
+ *   portalled card cannot be tied back to the control that opened it; the card
+ *   a recognised row sits in is therefore the card this module tags. A card
+ *   none of whose rows is recognised is left whole — its heading with it, since
+ *   a heading over four unrecognised rows names nothing.
+ * - **Nothing here reorders a row.** The second line is inserted as the label's
+ *   next sibling and the heading as the row group's first child, so the
+ *   primitive's own keyboard walk — which collects `button`s out of the group,
+ *   not its children — steps over both, and every click target, focus order and
+ *   accessible name the host built is left where it was. The row keeps its own
+ *   name too: the inserted line widens what a screen reader reads out of the
+ *   row, which is the point of the sentence.
+ *
+ * The host mounts the card afresh on every open, so every pass is idempotent
+ * and every write is undone on release: a disabled plugin leaves DSH's own card
+ * on screen.
+ *
+ * @param document - renderer document carrying the status bar and the portal.
+ * @param report - sink for observer failures; the native card stays untouched.
+ * @returns disposer that disconnects the observers and takes every write back.
+ */
+export declare function mountPermissionMenu(document: Document, report: (error: unknown) => void): Disposer;

package/lib/types/client/compat/sidebar-navigation.d.ts

@@ -0,0 +1,11 @@
+import type { Disposer } from '../contracts/ports.ts';
+export interface SidebarNavigationIcons {
+    readonly newSession: string;
+    readonly plugins: string;
+    readonly routines: string;
+}
+export declare const SIDEBAR_NAV_ATTRIBUTE = "data-ccd-nav";
+/** Rename and decorate the native buttons without replacing React-owned nodes
+ * or handlers. Every write is conditional and reversible, including delayed
+ * mounts, locale changes, wide/rail rerenders and the native tooltip portals. */
+export declare function mountSidebarNavigation(document: Document, icons: SidebarNavigationIcons, report: (error: unknown) => void): Disposer;

package/lib/types/client/compat/stats-values.d.ts

@@ -7,14 +7,31 @@ export declare const TRAILING_WIDTH_PROPERTY = "--ccd-trailing-width";
 export declare const MODEL_MAX_WIDTH_PROPERTY = "--ccd-model-max-width";
 /** The one gap the trailing cluster uses, read to budget the model button. */
 export declare const CLUSTER_GAP_PROPERTY = "--ccd-cluster-gap";
+/**
+ * Root attribute carrying whether the readouts are drawn, whose values are
+ * `on` and `off`.
+ *
+ * Both states are published rather than only the off one: the stylesheet that
+ * hides the cluster keys on `off`, so a document where this module never ran —
+ * a frame the observers could not attach to — keeps the host's own readouts
+ * instead of losing them to a stylesheet default it cannot correct.
+ */
+export declare const STATS_ATTRIBUTE = "data-ccd-composer-stats";
 /**
  * The responsive statistics cluster sits before the model selector. Its dock is
  * a sibling of the card rather than a row child, so its wide-layout offset needs
  * the trailing group's live width. Readouts and their detail dialogs stay owned
  * by the host; wide columns mirror one short segment without changing the host label.
  *
+ * The cluster is the configuration's to keep or drop (`features.composer-stats`,
+ * off by default): its state is published on the root for the stylesheet, which
+ * draws it only while the readouts are on. The width measurements below are
+ * outside that switch — they budget the row whether or not the readouts are
+ * drawn, and a hidden cluster simply hands its width back to the model button.
+ *
  * @param document - renderer document carrying the Composer.
  * @param report - sink for observer failures; the native readouts stay.
+ * @param readouts - whether the configuration asks for the plugin's readouts.
  * @returns disposer that disconnects the observers and clears every property.
  */
-export declare function mountComposerStats(document: Document, report: (error: unknown) => void): Disposer;
+export declare function mountComposerStats(document: Document, report: (error: unknown) => void, readouts: boolean): Disposer;

package/lib/types/client/compat/view-options.d.ts

@@ -0,0 +1,58 @@
+import type { ViewOptionsPort, ViewOptionsSettingsPort } from '../contracts/ports.ts';
+/**
+ * The sidebar's view-options menu, driven instead of replaced.
+ *
+ * DSH's card is a `ui-primitives` `Menu` holding three labelled option groups —
+ * grouping mode, ordering, archived visibility — with the current option marked
+ * by the primitive's trailing check. The three values live in the workspace
+ * browser's own browser-local store, and nothing on the public face writes them:
+ * `UiWorkspace` (`dsh-client-ui-workspace/client` `navigation.d.ts`) publishes
+ * navigation, archive and directory operations only, and the store it keeps
+ * (`stores.d.ts`) exports its factory alone, so a second instance would hold a
+ * copy rather than the browser's state. The one handle that *does* write them is
+ * the host's own row: `WorkspaceBrowser`'s `onSelect` calls `setOpen(false)`
+ * after it applies the choice.
+ *
+ * So this module treats that card as the state API it effectively is. Opening
+ * the card reads it — the host's own menu is opened through the trigger's click
+ * with `DRIVING_ATTRIBUTE` keeping the sheet from drawing it — and choosing an
+ * option clicks the host's own row. Nothing is shown, nothing is synthesised
+ * beyond the clicks the host's control already answers, and the card the reader
+ * sees is the one `features/view-options` draws.
+ *
+ * Three details decide how the drive is written:
+ *
+ * - **The trigger's click is intercepted.** The host opens its card from the
+ *   trigger's `onClick`; a listener on the button that stops propagation keeps
+ *   React's delegated handler from running, so the card opens only when this
+ *   module drives it. The one flag `driving` is what lets our own clicks
+ *   through.
+ * - **React flushes a discrete event synchronously**, so the card is in the
+ *   document by the time the driving click returns; `settle` still waits a
+ *   microtask and then polls, because a build that mounts the card later must
+ *   not turn into a failed read — the card is off screen either way.
+ * - **A card that is not the pinned shape hands the click back.** `readCard`
+ *   refuses anything that is not three groups of at least two rows with exactly
+ *   one check each, and the click that opened it is then passed to DSH so its
+ *   own menu opens. A later build keeps its own interface instead of a card
+ *   with nothing in it.
+ */
+/** Marks the host popup this module is driving; the sheet keeps it off screen. */
+export declare const DRIVING_ATTRIBUTE = "data-ccd-view-options-driving";
+/** Marks the trigger while this plugin's card is the one on screen. */
+export declare const OPEN_ATTRIBUTE = "data-ccd-view-options-open";
+/** The driver's own face, plus the release the mounting scope holds. */
+export interface ViewOptionsDriver {
+    readonly port: ViewOptionsPort;
+    readonly settings: ViewOptionsSettingsPort;
+    /** Read persisted native preferences without showing either menu. */
+    inspect(): Promise<void>;
+    dispose(): void;
+}
+/**
+ * Watch the sidebar's view-options trigger and drive the host's card for it.
+ * @param document - renderer document carrying the sidebar and the portal.
+ * @param report - sink for observer failures; the native menu stays in charge.
+ * @returns the port the card reads through, and the release of every observer.
+ */
+export declare function createViewOptionsDriver(document: Document, report: (error: unknown) => void): ViewOptionsDriver;

package/lib/types/client/contracts/ports.d.ts

@@ -1,6 +1,7 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { ThemePreference, ThemeRuntime } from '@deepseek-ai/dsh-client-ui-theme/client';
 import type { UiWorkspace } from '@deepseek-ai/dsh-client-ui-workspace/client';
+import type { ContextBreakdown, ContextBreakdownView, ContextEntry } from '../../shared/context.ts';
 export type { ThemePreference };
 export type Disposer = () => void;
 /**
@@ -124,6 +125,146 @@ export interface BlankSessionsPort {
     /** Observe list replacements and row-state changes; returns the releaser. */
     subscribe(listener: () => void): Disposer;
 }
+/** One group of the host's view-options menu, as the host drew it. */
+export interface ViewOptionsGroupRead {
+    /** The heading the host drew above this group, in the document's language. */
+    readonly label: string;
+    /** Every row's own label, in the host's order. */
+    readonly labels: readonly string[];
+    /** Index of the row the host marks as current, or −1 when none is marked. */
+    readonly selected: number;
+}
+/** The host's view-options menu, read out of its own card. */
+export interface ViewOptionsRead {
+    /** The three groups in the host's own order: group by, order by, archived filter. */
+    readonly groups: readonly ViewOptionsGroupRead[];
+}
+/** Which of the host's three groups a choice belongs to. */
+export type ViewOptionsGroup = 0 | 1 | 2;
+/** What the card is drawn from: whether it is up, what it hangs from, and the
+    host's three values as they were read when it opened. */
+export interface ViewOptionsSnapshot {
+    readonly open: boolean;
+    readonly anchor: Element | null;
+    /** Null before the first open, and after the host's card could not be read. */
+    readonly values: ViewOptionsRead | null;
+}
+/**
+ * The sidebar's view-options menu, as this plugin's card needs it.
+ *
+ * DSH keeps the three view settings in the browser and publishes no way to read
+ * or write them, so the only handle is the host's own menu: opening this card
+ * reads it, and `choose` clicks one of its rows. `getSnapshot`/`subscribe`
+ * carry the whole of what the DOM side owns — the trigger, whether the card is
+ * up, and the values read for it.
+ */
+export interface ViewOptionsPort {
+    /** The current state; the object identity changes only when the state does. */
+    getSnapshot(): ViewOptionsSnapshot;
+    /** Observe opening, closing, and the trigger being replaced. */
+    subscribe(listener: () => void): Disposer;
+    /** Put the card away; the trigger's own state follows. */
+    close(): void;
+    /** Choose one option by driving the host's own row; false when it could not be reached. */
+    choose(group: ViewOptionsGroup, index: number): Promise<boolean>;
+}
+/** Native view preferences also used by the sidebar's empty-group policy. */
+export interface ViewOptionsSettingsPort {
+    getSnapshot(): ViewOptionsRead | null;
+    subscribe(listener: () => void): Disposer;
+}
+/** Authoritative membership, including sessions omitted from collapsed DOM. */
+export interface SidebarSessionsPort {
+    /** Durable history across all groups and filters; null while loading. */
+    hasHistory(): boolean | null;
+    /** Null while either catalog is still arriving; null filter keeps all history. */
+    populatedGroups(filter: number | null, nested: boolean): ReadonlySet<string> | null;
+    subscribe(listener: () => void): Disposer;
+}
+/**
+ * One session's context readings, as the client session list holds them.
+ *
+ * The host computes all of this itself: `contextPressure` is the ring's own
+ * occupancy and `contextBreakdown` its three-way composition, and both travel
+ * to the browser as wire projections on the session list. The panel reads them
+ * rather than recomputing them, so its header can never disagree with the ring
+ * beside it.
+ */
+export interface ContextProjectionRead {
+    /** `contextPressure.contextWindow`. */
+    readonly window: number;
+    /** Occupancy: `projectedTokens ?? pressureTokens`. */
+    readonly used: number;
+    /** `contextBreakdown.systemTokens`. */
+    readonly systemTokens: number;
+    /** `contextBreakdown.toolsTokens`. */
+    readonly toolsTokens: number;
+    /** `contextBreakdown.messageTokens`. */
+    readonly messageTokens: number;
+    /** This plugin's own `ccdContext` value, or null while it is not there. */
+    readonly breakdown: ContextBreakdownView | null;
+}
+/**
+ * The host's context projections, read off the client session list.
+ *
+ * `ctx.sessions.list` publishes every registered wire value per session
+ * (`SessionListState.projectionsBySession`) and carries rows for sessions that
+ * were never opened, so this is a plain snapshot read with no I/O. A build that
+ * does not publish the list yields null and the ring keeps DSH's own panel.
+ */
+export interface ContextProjectionPort {
+    /** One session's readings, or null when the list has nothing for it yet. */
+    read(sessionId: string): ContextProjectionRead | null;
+    /** Observe list replacements and live projection frames. */
+    subscribe(listener: () => void): Disposer;
+}
+/** One entry of a drill-down group, as the panel draws it. */
+export interface ContextDetailGroup {
+    /** The group's own name, in the document's language. */
+    readonly label: string;
+    /** The group's total, which is the authoritative number above it. */
+    readonly tokens: number;
+    /** The rows, largest first. */
+    readonly rows: readonly ContextEntry[];
+}
+/** What the context panel is drawn from. */
+export interface ContextPanelSnapshot {
+    readonly open: boolean;
+    /** The ring trigger the panel hangs from; null before the shell renders it. */
+    readonly anchor: Element | null;
+    /** The whole reading, or null while the ring has no numbers for this session. */
+    readonly breakdown: ContextBreakdown | null;
+    /** `mcp__` tools, largest first. */
+    readonly mcp: readonly ContextEntry[];
+    /** Built-in tools, largest first. */
+    readonly tools: readonly ContextEntry[];
+    /** Retained instruction files, largest first. */
+    readonly files: readonly ContextEntry[];
+    /** Retained skill-catalog entries, largest first. */
+    readonly skills: readonly ContextEntry[];
+    /** The panel's own expansion; it lives only while the panel is open. */
+    readonly expanded: boolean;
+}
+/**
+ * The context ring's breakdown panel, as this plugin's card needs it.
+ *
+ * DSH opens its own 264px panel from the ring's click, and that panel is the
+ * whole of its own affordance — no public face reads or drives it. So this port
+ * owns the interaction instead: the driver intercepts the trigger's click
+ * (DSH's handler is React-delegated at the root, so stopping the event on the
+ * button keeps the host's panel from ever opening), holds the open and expanded
+ * state, and publishes the host's own numbers beside this plugin's rows.
+ */
+export interface ContextPanelPort {
+    /** The current state; the object identity changes only when the state does. */
+    getSnapshot(): ContextPanelSnapshot;
+    /** Observe opening, closing, expanding, and the trigger being replaced. */
+    subscribe(listener: () => void): Disposer;
+    /** Put the panel away; the trigger's own state follows. */
+    close(): void;
+    /** Flip the panel between its collapsed and expanded states. */
+    toggleExpanded(): void;
+}
 /** Actual SDK types, never a second definition of DSH component props. */
 export interface HostServices {
     readonly slots: Context['slots'];
@@ -142,6 +283,12 @@ export interface HostServices {
      * session list; a null port leaves the native rows exactly as they are.
      */
     readonly blankSessions: BlankSessionsPort | null;
+    readonly sidebarSessions: SidebarSessionsPort | null;
+    /**
+     * The host's context projections, or null on a build that does not publish
+     * the session list; a null port leaves the ring's own panel in charge.
+     */
+    readonly contextProjections: ContextProjectionPort | null;
     /** The settings transport carrying this plugin's own configuration section. */
     readonly configForms: ConfigFormsPort;
 }

package/lib/types/client/features/context-panel/ContextPanel.d.ts

@@ -0,0 +1,12 @@
+import type { ReactElement } from 'react';
+import type { ContextPanelPort } from '../../contracts/ports.ts';
+export interface ContextPanelProps {
+    readonly port: ContextPanelPort;
+}
+/**
+ * The panel, in whichever of its two states the port says.
+ *
+ * @param props - the driver's port.
+ * @returns the card, or null while it is closed.
+ */
+export declare function ContextPanel({ port }: ContextPanelProps): ReactElement | null;

package/lib/types/client/features/context-panel/mount.d.ts

@@ -0,0 +1,20 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { FeatureEnvironment } from '../../contracts/feature.ts';
+import type { CleanupScope } from '../../core/cleanup.ts';
+/**
+ * Put the context ring's breakdown panel in the frame-wide overlay.
+ *
+ * The panel is this plugin's own surface, so it is registered like one: a React
+ * entry in `shell.overlay`, holding the driver that watches the ring's trigger
+ * and takes its click (`compat/context-panel.ts`). Nothing here writes session
+ * state — the numbers are the host's own projections, read off the session list
+ * — so a write can never re-mount the plugin behind the panel.
+ *
+ * A build that does not publish the session list yields no port, and the ring
+ * keeps DSH's own panel: the feature loses a richer reading, not the control.
+ *
+ * @param ctx - client root context carrying the slot service.
+ * @param environment - configuration, ports and logging for this activation.
+ * @param cleanup - scope owning the styles, the driver and the registration.
+ */
+export declare function mountContextPanel(ctx: Context, environment: FeatureEnvironment, cleanup: CleanupScope): void;

package/lib/types/client/features/settings/locales.d.ts

@@ -14,6 +14,9 @@ export declare const zh: {
     readonly 'section.features': '模块';
     readonly 'section.appearance': '外观';
     readonly 'section.fonts': '字体';
+    readonly 'section.view': '视图';
+    readonly 'field.showEmptyGroups': '显示空分组';
+    readonly 'hint.showEmptyGroups': '关掉时没有会话的工作区不再显示；视图选项菜单里的同一项';
     readonly 'field.enabled': '启用 CCD 风格界面';
     readonly 'field.theme': '主题';
     readonly 'theme.system': '跟随系统';
@@ -49,6 +52,10 @@ export declare const zh: {
     readonly 'feature.tool-calls': '工具调用展示';
     readonly 'feature.statistics': '统计卡片';
     readonly 'feature.composer-pet': '输入框小鲸鱼';
+    readonly 'feature.composer-stats': '状态栏统计读数';
+    readonly 'hint.composer-stats': '输出速度与缓存命中率，关掉时这两项不显示（默认）';
+    readonly 'feature.context-panel': '上下文分解面板';
+    readonly 'hint.context-panel': '点环打开的分段面板；关掉时环点开的是 DSH 原生面板';
 };
 export type SettingsKey = keyof typeof zh;
 /** English dictionary; every Chinese key has a counterpart. */

package/lib/types/client/features/sidebar/navigation-icons.d.ts

@@ -0,0 +1,6 @@
+/** Approved Claude sidebar SVG artwork, bundled as trusted static markup. */
+export declare const SIDEBAR_NAVIGATION_ICONS: Readonly<{
+    newSession: "<svg xmlns=\"http://www.w3.org/2000/svg\" class=\"claude-sidebar-icon\" data-icon=\"new\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" aria-hidden=\"true\">\n  <circle class=\"icon-disc\" cx=\"12\" cy=\"12\" r=\"12\" fill=\"currentColor\" fill-opacity=\"0.09\"/>\n  <path d=\"M12 7V17M7 12H17\" stroke=\"currentColor\" stroke-width=\"1.4\" stroke-linecap=\"round\"/>\n</svg>";
+    plugins: "<svg xmlns=\"http://www.w3.org/2000/svg\" class=\"claude-sidebar-icon\" data-icon=\"customize\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" aria-hidden=\"true\">\n  <g class=\"customize-case\" stroke=\"currentColor\" stroke-width=\"1.25\" stroke-linecap=\"round\" stroke-linejoin=\"round\">\n    <path d=\"M8 7V5.2C8 4.54 8.54 4 9.2 4H14.8C15.46 4 16 4.54 16 5.2V7\"/>\n    <rect x=\"3\" y=\"7\" width=\"18\" height=\"12.5\" rx=\"1.5\"/>\n    <path d=\"M3 13.5H7M9.5 13.5H14.5M17 13.5H21\"/>\n  </g>\n</svg>";
+    routines: "<svg xmlns=\"http://www.w3.org/2000/svg\" class=\"claude-sidebar-icon\" data-icon=\"routines\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" aria-hidden=\"true\">\n  <g stroke=\"currentColor\" stroke-width=\"1.3\" stroke-linecap=\"round\" stroke-linejoin=\"round\">\n    <circle cx=\"12\" cy=\"12\" r=\"9\"/>\n    <path class=\"routine-long-hand\" d=\"M12 12V7.4\"/>\n    <path d=\"M12 12L14.8 13.75\"/>\n  </g>\n</svg>";
+}>;

package/lib/types/client/features/view-options/ViewOptionsCard.d.ts

@@ -0,0 +1,30 @@
+import type { ReactElement } from 'react';
+import type { ViewOptionsPort } from '../../contracts/ports.ts';
+export interface ViewOptionsCardProps {
+    readonly port: ViewOptionsPort;
+    /** `view.showEmptyGroups`: whether empty Workspaces are kept on screen. */
+    readonly showEmptyGroups: boolean;
+    /** Write the switch back through the settings transport. */
+    readonly setShowEmptyGroups: (value: boolean) => void;
+}
+/**
+ * The sidebar's view-options card, drawn in this plugin's own words and geometry.
+ *
+ * DSH's own menu is a flat list of eight options under three grey headings. The
+ * reference draws the same settings as *value rows* — the dimension on the left,
+ * the current choice on the right, a disclosure mark at the end — with the
+ * options one level down in a card of their own, and the switch and the action
+ * that belong to the family at the bottom. So this card is that shape, and the
+ * host's menu is only ever read (`port.read`) and clicked (`port.choose`): the
+ * three values are the host's, its rows are what writes them, and the words of
+ * two of the three rows are the host's own — the card borrows the labels it read
+ * out of the host's card and renames only the archived-visibility triple, which
+ * is the one set the reference names differently (活跃 / 已归档 / 全部).
+ *
+ * Only `显示空分组` is this plugin's own state: it writes
+ * `view.showEmptyGroups` through the settings transport, and a write re-mounts
+ * the plugin, so the card closes behind it. `清除筛选` puts the filter rows back
+ * to their defaults and exists only while one of them is off its default, which
+ * is what the reference does with `Clear filters`.
+ */
+export declare function ViewOptionsCard({ port, showEmptyGroups, setShowEmptyGroups, }: ViewOptionsCardProps): ReactElement | null;

package/lib/types/client/features/view-options/mount.d.ts

@@ -0,0 +1,25 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { FeatureEnvironment } from '../../contracts/feature.ts';
+import type { CleanupScope } from '../../core/cleanup.ts';
+import type { ViewOptionsSettingsPort } from '../../contracts/ports.ts';
+/**
+ * Put the sidebar's view-options card in the frame-wide overlay.
+ *
+ * The card is this plugin's own surface, so it is registered like one: a React
+ * entry in `shell.overlay`, holding the driver that watches the host's trigger
+ * and drives the host's own menu (`compat/view-options.ts`). The one value the
+ * card writes is `view.showEmptyGroups`, and it goes through the settings
+ * transport the same way the configuration page writes its fields — a write
+ * re-mounts the plugin, which is why the card closes behind the switch.
+ *
+ * Nothing here fails the interface if the trigger is missing: the driver reports
+ * a card it cannot read and hands the click back to DSH, whose own menu opens.
+ *
+ * @param ctx - client root context carrying the slot service.
+ * @param environment - configuration, ports and logging for this activation.
+ * @param cleanup - scope owning the styles, the driver and the registration.
+ */
+export declare function mountViewOptions(ctx: Context, environment: FeatureEnvironment, cleanup: CleanupScope): {
+    settings: ViewOptionsSettingsPort;
+    showAllSessions(): void;
+};

package/lib/types/host/context/compaction.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The autocompaction policy this deployment actually runs.
+ *
+ * The panel's last row says how much of the window the compaction policy is
+ * holding back, and that number belongs to another plugin's configuration. DSH
+ * publishes no read face for it, so the loader's own entry tree is the source:
+ * an entry that is enabled *and* declares the policy's own fields
+ * (`thresholdRatio` / `headroomTokens`) is the backend that will compact this
+ * session, and an enabled `compaction-basic` with an empty config is that
+ * backend running on its defaults.
+ *
+ * A deployment with no such entry — which is this plugin's own machine, where
+ * `compaction-basic` is `disabled: true` — yields null, and the panel leaves
+ * the row out rather than drawing a threshold nobody enforces.
+ *
+ * @module
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { CompactionPolicy } from './unit.ts';
+/**
+ * The policy that will compact a session on this deployment.
+ *
+ * @param ctx - host plugin context carrying the loader.
+ * @returns the policy, or null when no enabled backend declares one.
+ */
+export declare function readCompactionPolicy(ctx: Context): CompactionPolicy | null;