dsh-claude-desktop-theme 0.2.0 → 0.4.0

package/lib/types/client/features/shell/index.d.ts

@@ -1,8 +1,14 @@
 import type { ImplementedFeature } from '../../contracts/feature.ts';
 /**
  * Window frame and column geometry: flat surfaces, the sidebar column and its
- * divider. The three tracks stay entirely `ui-layout`'s solve, so resizing the
- * sidebar with the handle moves the divider the pointer is on; the plugin only
- * paints the columns.
+ * divider, and the right panel's floating card. The three tracks stay entirely
+ * `ui-layout`'s solve, so resizing the sidebar with the handle moves the divider
+ * the pointer is on; the plugin only paints the columns.
+ *
+ * The right panel is a column's occupant rather than a track, so its card is
+ * two sheets: `shell.css` insets the panel's box and paints the surface, and
+ * `right-panel.css` dresses what the panel draws inside it — the file tree's
+ * rows included, which belong to no feature of this plugin's own. Both mount
+ * with the frame, because neither has a switch of its own to lose.
  */
 export declare const shellFeature: ImplementedFeature;

package/lib/types/client/features/sidebar/index.d.ts

@@ -3,7 +3,7 @@ import type { ImplementedFeature } from '../../contracts/feature.ts';
  * Sidebar presentation: compact navigation rows, flat project groups and a
  * calmer foot. Every entry DSH registers — New Session, the global panel list,
  * the workspace browser and Settings — stays exactly where the host put it; the
- * account menu is reshaped, never re-authored.
+ * account menu gains a More submenu that forwards the host feedback action.
  *
  * The one list policy this module owns is the provisional New Session row: DSH
  * creates the Session as soon as New Session is used, and the host marks that

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/statistics/books.d.ts

@@ -13,8 +13,7 @@
  * ```
  *
  * Only the sentence is copied; nothing is fetched and no book text is
- * involved. The copy stays English, exactly as the reference writes it —
- * including its typographic apostrophe and multiplication sign.
+ * involved. Titles and sentences are localized into Simplified Chinese.
  */
 /** One comparable book: the title as printed, and the tokens it would take. */
 export interface Book {

package/lib/types/client/features/statistics/format.d.ts

@@ -1,8 +1,8 @@
 /**
  * Number and date formatting for the statistics card.
  *
- * The card's copy is English, so its separators and its 12-hour clock are too:
- * every formatter here is fixed to `en-US`, which is what the reference uses.
+ * The card uses Simplified Chinese dates and a 24-hour clock. Compact token
+ * units stay unchanged so the metrics and chart labels fit the card.
  * They live in their own module because both the data layer (`view.ts`) and the
  * DOM layer (`card.ts`) need them, and neither should import the other.
  */
@@ -21,14 +21,14 @@ export declare function formatCount(value: number): string;
  */
 export declare function formatTokens(value: number): string;
 /**
- * One hour of the day, as the reference labels it (`11 AM`).
+ * One hour of the day in the 24-hour clock (`11:00`).
  *
  * @param hour - local hour, 0-23.
  * @returns the label.
  */
 export declare function formatHour(hour: number): string;
 /**
- * One `YYYY-MM-DD` key as the reference labels a chart day (`Sep 30`).
+ * One `YYYY-MM-DD` key as a Chinese chart date (`9月30日`).
  *
  * @param date - local day key.
  * @returns the short label.

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/client/theme/mount.d.ts

@@ -3,8 +3,8 @@ import type { CleanupScope } from '../core/cleanup.ts';
 /**
  * Plugin-scoped presentation base: the root activation marker, the design
  * variables, the shared Composer geometry two features depend on (siblings must
- * not import each other), the host popup chrome (DESIGN.md §6.7) and the
- * semantic token overrides.
+ * not import each other), the host popup chrome (DESIGN.md §6.7), the ink the
+ * window's scrollbars are painted in and the semantic token overrides.
  *
  * The override layer is recomputed on every mount, so a configuration change
  * releases the previous layer through the same scope that owns the stylesheets

package/lib/types/client/theme/palette.d.ts

@@ -37,7 +37,7 @@ export interface Palette {
  */
 export declare const BUILT_IN_SURFACES: Readonly<{
     canvas: "#fcfcfb";
-    sidebar: "#fbfbfa";
+    sidebar: "#fbfbf9";
     border: "#e3e3e1";
 }>;
 /**

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;

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

@@ -0,0 +1,99 @@
+/** One content block, as far as pricing reads it. */
+export interface PricedBlock {
+    readonly type?: string;
+    readonly text?: string;
+    readonly name?: string;
+    readonly arguments?: string;
+    /** Every other field the block carries; pricing only ever serializes them. */
+    readonly [field: string]: unknown;
+}
+/** One model-visible message, as far as pricing reads it. */
+export interface PricedMessage {
+    /** Absent for a `user/message` payload, which *is* the message. */
+    readonly role?: string;
+    readonly content: readonly PricedBlock[];
+}
+/** One tool schema, as far as pricing reads it. */
+export interface PricedTool {
+    readonly name: string;
+}
+/** The structural slice of one session event this fold reads. */
+export interface PricedEvent {
+    readonly type: string;
+    readonly seq: number;
+    readonly surfaceOp?: 'append' | {
+        readonly startSeq: number;
+        readonly endSeq: number;
+    };
+    readonly data?: {
+        readonly content?: readonly PricedBlock[];
+        readonly message?: PricedMessage;
+        readonly source?: {
+            readonly kind?: string;
+            readonly changes?: readonly {
+                readonly action?: string;
+                readonly path?: string;
+            }[];
+            readonly entries?: readonly {
+                readonly name?: string;
+                readonly description?: string;
+            }[];
+        };
+    };
+}
+/**
+ * Price one content block list.
+ *
+ * @param blocks - the message's content.
+ * @returns heuristic tokens including per-block structural overhead.
+ */
+export declare function priceContent(blocks: readonly PricedBlock[]): number;
+/**
+ * Price one model-visible message.
+ *
+ * A system prompt is serialized as a plain string by every adapter, so the host
+ * prices it as text density plus role framing with no per-block overhead; every
+ * other role takes the per-block arm.
+ *
+ * @param message - the derived message, or null when the event produces none.
+ * @returns heuristic tokens.
+ */
+export declare function priceMessage(message: PricedMessage | null): number;
+/**
+ * The message one surface event projects to, or null when it produces none.
+ *
+ * @param event - one committed session event.
+ * @returns the message to price.
+ */
+export declare function derivedMessage(event: PricedEvent): PricedMessage | null;
+/** Whether an event carries a surface placement and therefore joins the fold. */
+export declare function isSurfaceEvent(event: PricedEvent): boolean;
+/**
+ * Price one tool schema on its own.
+ *
+ * The host prices the assembled array whole, so these per-tool numbers never
+ * add back up to it; {@link splitTools} is what keeps the two group rows
+ * summing to the host's own total.
+ *
+ * @param tool - one entry of `EpochHeader.tools`.
+ * @returns heuristic tokens for that entry alone.
+ */
+export declare function priceTool(tool: unknown): number;
+/**
+ * Price the assembled tool array exactly as the host does.
+ *
+ * @param tools - `EpochHeader.tools`.
+ * @returns the array's heuristic price; 0 when there are no tools.
+ */
+export declare function priceTools(tools: readonly PricedTool[] | undefined): number;
+/**
+ * Split one token total across weighted entries, preserving the total exactly.
+ *
+ * The last entry takes whatever rounding left over, so the rows a group draws
+ * always add back up to the group's own number.
+ *
+ * @param total - tokens to distribute.
+ * @param weights - one weight per entry; non-positive weights fall back to 1.
+ * @returns one token count per entry, summing to `total`.
+ */
+export declare function allocate(total: number, weights: readonly number[]): readonly number[];

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

@@ -0,0 +1,24 @@
+/**
+ * Mount the context panel's projection unit.
+ *
+ * The unit is the only thing the host half adds: the browser half reads the
+ * host's own `contextPressure` / `contextBreakdown` straight off the session
+ * list, so there is no route, no polling and no second state store — one
+ * registration on the session-projection seam, riding this plugin's fiber like
+ * `stats/unit.ts` does.
+ *
+ * A plugin's `apply` runs as soon as its own fiber starts, which can be before
+ * the projection registry exists: the optional injection below waits for it,
+ * and a deployment that mounts no registry simply never gets the panel's
+ * per-tool rows — the card falls back to the host's three numbers alone.
+ *
+ * @module
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Register the `ccdContext` unit, once the projection registry exists.
+ *
+ * @param ctx - host plugin context.
+ * @param isEnabled - current plugin switch, read at mount time.
+ */
+export declare function mountContextBreakdown(ctx: Context, isEnabled: () => boolean): void;

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

@@ -0,0 +1,136 @@
+/**
+ * Pure `ccdContext` fold over committed session events.
+ *
+ * The host already publishes `contextBreakdown` — system prompt, tools,
+ * conversation — and `contextPressure`. Neither says *which* tool, *which*
+ * instruction file or *which* skill holds the tokens, and nothing outside the
+ * token meter can answer that from a wire value. So this unit mirrors the
+ * meter's own surface fold: it prices every message-producing event with the
+ * same heuristic, honours `surfaceOp` replacements exactly as
+ * `contextBreakdown` does, and keeps the priced surface so the two classified
+ * kinds can be summed at read time.
+ *
+ * The mirror is exact rather than approximate — against a real 19 MB session
+ * log it reproduces the host's persisted `{systemTokens: 1953, toolsTokens:
+ * 7492, messageTokens: 93461}` to the token — and `tests/context-pricing.test.ts`
+ * pins that. What it deliberately does *not* do is restate the whole
+ * breakdown: the system prompt and the conversation are the host's numbers, and
+ * this unit only re-derives the two shares that come out of `messageTokens`.
+ *
+ * @module
+ */
+import type { ProjectionDefinition } from '@deepseek-ai/dsh-session-projection';
+import { CONTEXT_KEY, type ContextBreakdownView, type ContextEntry } from '../../shared/context.ts';
+import { type PricedEvent } from './pricing.ts';
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionStateMap {
+        ccdContext: ContextState;
+    }
+    interface SessionProjectionMap {
+        ccdContext: ContextBreakdownView;
+    }
+}
+/** The autocompaction policy this deployment runs, as the loader declares it. */
+export interface CompactionPolicy {
+    /** `thresholdRatio`; the window share a compaction may fill. */
+    readonly ratio: number;
+    /** `headroomTokens`; room kept above the summary budget. */
+    readonly headroom: number;
+}
+/** Node kinds the fold classifies; everything else is `OTHER`. */
+export declare const KIND_OTHER = 0;
+/** A retained `agent-instructions` message. */
+export declare const KIND_INSTRUCTIONS = 1;
+/** A retained `skill-catalog` message. */
+export declare const KIND_SKILLS = 2;
+/**
+ * One retained surface node: `[seq, tokens, kind, entries]`.
+ *
+ * `entries` is empty for anything but the two classified kinds; for those it is
+ * the node's own price already split across the files or skills it names, so
+ * summing a kind's entries is summing its nodes.
+ */
+export type ContextNode = readonly [
+    seq: number,
+    tokens: number,
+    kind: number,
+    entries: readonly ContextEntry[]
+];
+/** Fold state: plain JSON, one value per session. */
+export interface ContextState {
+    /** Every retained surface node, in model-visible order. */
+    readonly nodes: readonly ContextNode[];
+    /** Per-tool prices from the latest request envelope, largest first. */
+    readonly tools: readonly ContextEntry[];
+    /** `request/context` capacity, 0 until one is logged. */
+    readonly window: number;
+    /** The envelope's own output cap, or null when it declares none. */
+    readonly reserved: number | null;
+}
+/** Empty state for one session. */
+export declare function initContextState(): ContextState;
+/**
+ * One instruction message's price, split across the files it names.
+ *
+ * The paths come from `source.changes` — the structured record of what that
+ * message carries — and the split weights come from each file's own section, so
+ * a message carrying two files of very different size does not report them as
+ * equal. A path whose section cannot be located takes an even weight.
+ *
+ * @param event - the retained `agent-instructions` message.
+ * @param tokens - the message's own heuristic price.
+ * @returns one row per named file, summing to `tokens`.
+ */
+export declare function instructionEntries(event: PricedEvent, tokens: number): readonly ContextEntry[];
+/**
+ * One skill catalog's price, split across the entries it lists.
+ *
+ * The catalog's structured `entries` are the names; their descriptions are the
+ * only per-entry size the message carries, so they are what the split weighs.
+ *
+ * @param event - the retained `skill-catalog` message.
+ * @param tokens - the message's own heuristic price.
+ * @returns one row per listed skill, summing to `tokens`.
+ */
+export declare function skillEntries(event: PricedEvent, tokens: number): readonly ContextEntry[];
+/**
+ * Advance the fold by one committed event.
+ *
+ * @param state - state covering every earlier event.
+ * @param event - the next committed session event.
+ * @returns the next state, or the same reference when the event is not ours.
+ */
+export declare function applyContextEvent(state: ContextState, event: PricedEvent): ContextState;
+/**
+ * Project one state onto the client-visible value.
+ *
+ * @param state - current fold state.
+ * @param policy - the deployment's autocompaction policy, or null when none runs.
+ * @returns the whole current value.
+ */
+export declare function viewContext(state: ContextState, policy: CompactionPolicy | null): ContextBreakdownView;
+/** Read one persisted state row; lenient, because a read must never throw. */
+export declare function readContextState(value: unknown): ContextState;
+/** Read one wire view row, leniently — the schema slot never throws. */
+export declare function readContextView(value: unknown): ContextBreakdownView;
+/**
+ * The registry's wire-unit shape: the definition with its optional `wire`
+ * field made required, which is the overload a client-visible key registers
+ * through.
+ */
+type WireUnit = Omit<ProjectionDefinition<typeof CONTEXT_KEY>, 'wire'> & {
+    wire: NonNullable<ProjectionDefinition<typeof CONTEXT_KEY>['wire']>;
+};
+/**
+ * Build the unit this plugin registers on `ctx.sessionProjections`.
+ *
+ * The policy is read through a callback rather than captured once: the unit is
+ * registered while the plugin is on, and a settings write that enables or
+ * reconfigures compaction lands in the loader's entry tree without remounting
+ * this plugin.
+ *
+ * @param policy - reads the deployment's autocompaction policy, or null.
+ * @returns the projection unit.
+ */
+export declare function createContextProjection(policy: () => CompactionPolicy | null): WireUnit;
+export {};

package/lib/types/host/index.d.ts

@@ -24,6 +24,8 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
         'tool-calls': z<boolean, boolean, "defined">;
         statistics: z<boolean, boolean, "defined">;
         'composer-pet': z<boolean, boolean, "defined">;
+        'composer-stats': z<boolean, boolean, "defined">;
+        'context-panel': z<boolean, boolean, "defined">;
     }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
         shell: z<boolean, boolean, "defined">;
         sidebar: z<boolean, boolean, "defined">;
@@ -32,6 +34,8 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
         'tool-calls': z<boolean, boolean, "defined">;
         statistics: z<boolean, boolean, "defined">;
         'composer-pet': z<boolean, boolean, "defined">;
+        'composer-stats': z<boolean, boolean, "defined">;
+        'context-panel': z<boolean, boolean, "defined">;
     }>>>, "volatile-defined">;
     appearance: z<NoInfer<Schemastery.ObjectS<NoInfer<{
         canvas: z<string, string, "defined">;
@@ -49,6 +53,11 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
         uiCjk: z<string, string, "defined">;
         code: z<string, string, "defined">;
     }>>>, "volatile-defined">;
+    view: z<NoInfer<Schemastery.ObjectS<NoInfer<{
+        showEmptyGroups: z<boolean, boolean, "defined">;
+    }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        showEmptyGroups: z<boolean, boolean, "defined">;
+    }>>>, "volatile-defined">;
 }>>, Schemastery.ObjectT<NoInfer<{
     enabled: z<boolean, boolean, "volatile-defined">;
     debug: z<boolean, boolean, "volatile-defined">;
@@ -60,6 +69,8 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
         'tool-calls': z<boolean, boolean, "defined">;
         statistics: z<boolean, boolean, "defined">;
         'composer-pet': z<boolean, boolean, "defined">;
+        'composer-stats': z<boolean, boolean, "defined">;
+        'context-panel': z<boolean, boolean, "defined">;
     }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
         shell: z<boolean, boolean, "defined">;
         sidebar: z<boolean, boolean, "defined">;
@@ -68,6 +79,8 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
         'tool-calls': z<boolean, boolean, "defined">;
         statistics: z<boolean, boolean, "defined">;
         'composer-pet': z<boolean, boolean, "defined">;
+        'composer-stats': z<boolean, boolean, "defined">;
+        'context-panel': z<boolean, boolean, "defined">;
     }>>>, "volatile-defined">;
     appearance: z<NoInfer<Schemastery.ObjectS<NoInfer<{
         canvas: z<string, string, "defined">;
@@ -85,6 +98,11 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
         uiCjk: z<string, string, "defined">;
         code: z<string, string, "defined">;
     }>>>, "volatile-defined">;
+    view: z<NoInfer<Schemastery.ObjectS<NoInfer<{
+        showEmptyGroups: z<boolean, boolean, "defined">;
+    }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        showEmptyGroups: z<boolean, boolean, "defined">;
+    }>>>, "volatile-defined">;
 }>>, "plain">;
 /**
  * Host half: the configuration surface the interface reads, plus the read-only

package/lib/types/shared/config.d.ts

@@ -1,20 +1,35 @@
-export declare const FEATURE_IDS: readonly ['shell', 'sidebar', 'new-session', 'conversation', 'tool-calls', 'statistics', 'composer-pet'];
+/**
+ * The interface modules a configuration switch turns on.
+ *
+ * `composer-stats` is the one entry that mounts nothing of its own: it is the
+ * Composer status bar's statistics readouts — `compat/stats-values.ts` plus the
+ * Composer sheet — and it is off by default, so a fresh install shows the row
+ * without the host's readout cluster. Turning it on mirrors one short value per
+ * pill (the output rate, or the cache-hit share) in place of the host's own
+ * label.
+ */
+export declare const FEATURE_IDS: readonly ['shell', 'sidebar', 'new-session', 'conversation', 'tool-calls', 'statistics', 'composer-pet', 'composer-stats', 'context-panel'];
 export type FeatureId = typeof FEATURE_IDS[number];
 export type FeatureFlags = Readonly<Record<FeatureId, boolean>>;
 /** Fields of the background-colour section; an empty string means "built-in palette". */
 export declare const APPEARANCE_FIELDS: readonly ['canvas', 'sidebar'];
 /** Fields of the typeface section; an empty string means "system stack". */
 export declare const FONT_FIELDS: readonly ['uiLatin', 'uiCjk', 'code'];
+/** Fields of the view-options section. */
+export declare const VIEW_FIELDS: readonly ['showEmptyGroups'];
 export type AppearanceField = typeof APPEARANCE_FIELDS[number];
 export type FontField = typeof FONT_FIELDS[number];
+export type ViewField = typeof VIEW_FIELDS[number];
 export type AppearanceConfig = Readonly<Record<AppearanceField, string>>;
 export type FontsConfig = Readonly<Record<FontField, string>>;
+export type ViewConfig = Readonly<Record<ViewField, boolean>>;
 export interface StyleConfig {
     readonly enabled: boolean;
     readonly debug: boolean;
     readonly features: FeatureFlags;
     readonly appearance: AppearanceConfig;
     readonly fonts: FontsConfig;
+    readonly view: ViewConfig;
 }
 export interface StyleOptions {
     readonly enabled?: boolean;
@@ -22,11 +37,21 @@ export interface StyleOptions {
     readonly features?: Partial<FeatureFlags>;
     readonly appearance?: Partial<Record<AppearanceField, unknown>>;
     readonly fonts?: Partial<Record<FontField, unknown>>;
+    readonly view?: Partial<Record<ViewField, unknown>>;
 }
 export declare const DEFAULT_FEATURES: FeatureFlags;
 /** Empty strings keep the built-in palette and the system font stack in charge. */
 export declare const DEFAULT_APPEARANCE: AppearanceConfig;
 export declare const DEFAULT_FONTS: FontsConfig;
+/**
+ * The view-options section's defaults.
+ *
+ * `showEmptyGroups` is off, which means the sidebar hides a Workspace that has
+ * no Session under the current filter — the reference's own default for that
+ * switch, and the reason the row in the view-options card reads as "off" on a
+ * fresh install.
+ */
+export declare const DEFAULT_VIEW: ViewConfig;
 /** Font names longer than this are a pasted paragraph, not a family. */
 export declare const FONT_NAME_MAX_LENGTH = 64;
 /**