dsh-claude-desktop-theme 0.5.0 → 0.5.2

package/lib/index.js

@@ -10,8 +10,8 @@ var DEFAULT_PERSONALIZATION = Object.freeze({
   greetingName: ""
 });
 var DEFAULT_FEATURES = Object.freeze({
-  shell: true,
   sidebar: true,
+  "right-panel": true,
   "new-session": true,
   conversation: true,
   "tool-calls": true,
@@ -1258,11 +1258,11 @@ function mountWorktrees(ctx, enabled) {
 var HEX_COLOUR = /^(#[0-9a-fA-F]{3}|#[0-9a-fA-F]{6})?$/;
 var FONT_NAME = new RegExp(`^[\\p{L}\\p{N} ._-]{0,${FONT_NAME_MAX_LENGTH}}$`, "u");
 var Config = z.object({
-  enabled: z.boolean().default(false).description("\u542F\u7528 CCD \u98CE\u683C\u754C\u9762").volatile(),
+  enabled: z.boolean().default(false).description("\u5F00\u542F / \u5173\u95ED Claude \u4E3B\u9898").volatile(),
   debug: z.boolean().default(false).description("\u5728\u63A7\u5236\u53F0\u8F93\u51FA\u8C03\u8BD5\u65E5\u5FD7").volatile(),
   features: z.object({
-    shell: z.boolean().default(DEFAULT_FEATURES.shell),
     sidebar: z.boolean().default(DEFAULT_FEATURES.sidebar),
+    "right-panel": z.boolean().default(DEFAULT_FEATURES["right-panel"]),
     "new-session": z.boolean().default(DEFAULT_FEATURES["new-session"]),
     conversation: z.boolean().default(DEFAULT_FEATURES.conversation),
     "tool-calls": z.boolean().default(DEFAULT_FEATURES["tool-calls"]),
@@ -1286,10 +1286,10 @@ var Config = z.object({
     code: z.string().default(DEFAULT_FONTS.code).description("\u4EE3\u7801\u4E0E\u7B49\u5BBD\u5B57\u4F53\u540D\uFF08\u7559\u7A7A\u7528\u7CFB\u7EDF\u6808\uFF09").pattern(FONT_NAME)
   }).default({ ...DEFAULT_FONTS }).description("\u5B57\u4F53").volatile(),
   personalization: z.object({
-    petStyle: z.union(["whale", "claude"]).default(DEFAULT_PERSONALIZATION.petStyle).description("\u8F93\u5165\u6846\u5BA0\u7269\u6837\u5F0F"),
+    petStyle: z.union(["whale", "claude", "none"]).default(DEFAULT_PERSONALIZATION.petStyle).description("\u8F93\u5165\u6846\u5BA0\u7269\u6837\u5F0F"),
     runningStyle: z.union(["whale", "claude"]).default(DEFAULT_PERSONALIZATION.runningStyle).description("\u804A\u5929\u8F93\u51FA\u4E2D\u7684\u7B49\u5F85\u56FE\u6807\u4E0E\u72B6\u6001\u6837\u5F0F"),
-    replySignatureStyle: z.union(["whale", "claude"]).default(DEFAULT_PERSONALIZATION.replySignatureStyle).description("\u56DE\u590D\u7ED3\u675F\u540E\u7684\u7B7E\u540D\u56FE\u6807\u6837\u5F0F"),
-    greetingStyle: z.union(["explore", "claude"]).default(DEFAULT_PERSONALIZATION.greetingStyle).description("\u9996\u9875\u95EE\u5019\u8BED\u4E0E\u56FE\u6807\u6837\u5F0F"),
+    replySignatureStyle: z.union(["whale", "claude", "none"]).default(DEFAULT_PERSONALIZATION.replySignatureStyle).description("\u56DE\u590D\u7ED3\u675F\u540E\u7684\u7B7E\u540D\u56FE\u6807\u6837\u5F0F"),
+    greetingStyle: z.union(["explore", "claude", "none"]).default(DEFAULT_PERSONALIZATION.greetingStyle).description("\u9996\u9875\u95EE\u5019\u8BED\u4E0E\u56FE\u6807\u6837\u5F0F"),
     greetingName: z.string().default("").pattern(/^.{0,64}$/u).description("\u95EE\u5019\u8BED\u4E2D\u7684\u79F0\u547C\uFF08\u53EF\u7559\u7A7A\uFF09")
   }).default({ ...DEFAULT_PERSONALIZATION }).description("\u4E2A\u6027\u5316").volatile(),
   view: z.object({

package/lib/types/client/compat/account-balance-hint.d.ts

@@ -0,0 +1,11 @@
+import type { Disposer } from '../contracts/ports.ts';
+export interface AccountBalanceBreakdown {
+    total: string;
+    toppedUp: string;
+    granted: string;
+}
+/** The account menu owns this top-layer hint, including its delayed teardown. */
+export declare function mountAccountBalanceHint(menu: HTMLElement, row: HTMLElement, zh: boolean): {
+    update: (balance: AccountBalanceBreakdown | undefined, message: string) => void;
+    dispose: Disposer;
+};

package/lib/types/client/compat/account-balance.d.ts

@@ -1,8 +1,10 @@
 import type { Disposer } from '../contracts/ports.ts';
+import { type AccountBalanceBreakdown } from './account-balance-hint.ts';
 /** Last completed display, retained across menu openings for the same account. */
 export interface AccountBalanceCache {
     text?: string;
     description?: string;
+    balance?: AccountBalanceBreakdown;
 }
 /** One usage row in the lower-left account menu; polling lives only while open. */
 export declare function mountAccountBalance(menu: HTMLElement, cache?: AccountBalanceCache): Disposer;

package/lib/types/client/compat/conversation-stream.d.ts

@@ -0,0 +1,5 @@
+import type { Disposer } from '../contracts/ports.ts';
+/** Only append-only visible text gets an entrance; reparsing is already visible. */
+export declare function streamingAppendStart(previous: string, text: string): number | null;
+/** Fade new reply text through native Ranges: never wrap, clone or delay Markdown. */
+export declare function mountConversationStream(document: Document, report: (error: unknown) => void): Disposer;

package/lib/types/client/compat/files-pane.d.ts

@@ -40,8 +40,8 @@ import type { Disposer } from '../contracts/ports.ts';
  *
  * Everything written here lands on host nodes as `data-ccd-files-*` markers or
  * as plugin-owned nodes beside them, and the disposer takes all of it back.
- * The module is unconditional: the right panel exists in both DSH builds and
- * behind every feature switch.
+ * The module shares the right-panel feature lifetime with its stylesheet,
+ * so disabling that feature removes every enhancement before its styles.
  */
 /** The state of the tree, written on the Files root: `hidden` or absent. */
 export declare const TREE_ATTRIBUTE = "data-ccd-files-tree";

package/lib/types/client/compat/header-menu-actions.d.ts

@@ -3,8 +3,6 @@ import type { Context } from '@deepseek-ai/cordis';
 export interface HeaderMenuActions {
     read(id: string): {
         title: string;
-        folder: string;
-        path: string;
     } | null;
     rename(id: string, title: string): Promise<void>;
     fork(id: string): Promise<void>;

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

@@ -13,10 +13,9 @@
  * and the static web frontend's markdown classes (`_markdown_1ypvv_5`) are
  * identical in both builds, so neither needs an entry here.
  *
- * The tables are pinned to the DSH version the plugin declares
- * (`dsh.engines.dsh = "=0.2.0-rc.2"`): a later release may rehash every prefix
- * again, and both tables then have to be refreshed from that build's
- * `app.asar` — the same single-place update `host-dom.ts` documents.
+ * Keep the authored build stable and register each verified release below.
+ * A new release may rehash every prefix; read its tables from `app.asar`.
+ * The latest macOS build is also the preload fallback before the frame mounts.
  */
 /** One shipped DSH build and the prefixes it uses for the pinned classes. */
 export interface HostBuild {
@@ -38,6 +37,8 @@ export declare const PINNED_BUILD: HostBuild;
  * prefix this plugin authored.
  */
 export declare const WINDOWS_BUILD: HostBuild;
+/** DSH `0.2.1-rc.3`, macOS commit `be72761e`, read from its shipped app.asar. */
+export declare const MACOS_BUILD: HostBuild;
 /** Every build whose class names this plugin knows how to speak. */
 export declare const HOST_BUILDS: readonly HostBuild[];
 /** How a document's build was decided. */

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

@@ -65,7 +65,7 @@ export declare const HOST: Readonly<{
      * inline (the resolved width, or `100vw` in full screen). Its
      * `data-sidebar-right-panel` (`push` / `fullscreen`) and
      * `data-sidebar-right-open` are the package's own stable hooks, so the card
-     * `shell.css` paints on it survives a build whose classes were rehashed; this
+     * `features/right-panel/frame.css` paints on it survives a build whose classes were rehashed; this
      * plugin authors no selector for the panel's hashed class.
      */
     readonly rightbarPanel: '[data-sidebar-right-panel]';
@@ -77,7 +77,7 @@ export declare const HOST: Readonly<{
      * on, `pane` a dock column that would otherwise paint the canvas over it,
      * `strip` the tab strip (the card's header row), `divider` the hairline
      * between two columns, `empty` a column no tab has claimed. Only
-     * `features/shell/right-panel.css` reads them.
+     * `features/right-panel/right-panel.css` reads them.
      */
     readonly dockSurface: '[data-dockkit-surface]';
     readonly dockPane: '[data-dockkit-pane]';
@@ -144,6 +144,8 @@ export declare const HOST: Readonly<{
     readonly sidebarPanelRow: '._3WPZCG_panelRow';
     readonly sidebarPanelTitle: '._3WPZCG_panelTitle';
     readonly sidebarPanelGlyph: '._3WPZCG_panelGlyph';
+    /** SidebarRoot.module.css: the panel list's More card (`PanelMoreMenu`). */
+    readonly sidebarMoreMenu: '._3WPZCG_moreMenu';
     readonly sidebarRegionArea: '._3WPZCG_regionArea';
     readonly sidebarFootArea: '._3WPZCG_footArea';
     readonly sidebarSettingsArea: '._3WPZCG_settingsArea';
@@ -346,6 +348,13 @@ export declare const HOST: Readonly<{
         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: `MenuItemButton`'s wrap, its button and the separator a
+        wrap may lead with — the markup the plugin's own rows in a host menu
+        repeat (`features/sidebar-editor/MoreCardRows.tsx`), so the card's
+        keyboard walk and every popup rule reach them as host rows. */
+    readonly menuItemWrap: '._itemWrap_4ub78_90';
+    readonly menuItemButton: '._item_4ub78_90';
+    readonly menuSeparator: '._separator_4ub78_80';
     /** 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. */
@@ -438,6 +447,14 @@ export type HostAnchors = Readonly<Record<keyof typeof ANCHOR, string>>;
  * @param document - the renderer document to speak to.
  */
 export declare function hostSelectors(document: Document): HostSelectors;
+export interface MenuRowClasses {
+    readonly itemWrap: string;
+    readonly item: string;
+    readonly itemLabel: string;
+    readonly separator: string;
+}
+/** The `Menu` primitive's row classes, for rows this plugin renders into a host menu. */
+export declare function menuRowClasses(document: Document): MenuRowClasses;
 /** The anchors of this document's build; see {@link hostSelectors}. */
 export declare function hostAnchors(document: Document): HostAnchors;
 export interface HostProbe {

package/lib/types/client/compat/search-palette-port.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { SearchPalettePort } from '../contracts/ports.ts';
+/** Read the palette's lists from the host catalogs and drive the host's own navigation. */
+export declare function searchPalettePort(ctx: Context, document: Document, report: (error: unknown) => void): SearchPalettePort;

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

@@ -0,0 +1,32 @@
+import type { Disposer } from '../contracts/ports.ts';
+import type { SidebarPanelsPort } from './sidebar-panels.ts';
+/** The panel id this module read off a row's position in the list. */
+export declare const SIDEBAR_PANEL_ATTRIBUTE = "data-ccd-panel";
+/** Marks the list child the Edit sidebar dialog took out of the column. */
+export declare const SIDEBAR_PANEL_HIDDEN_ATTRIBUTE = "data-ccd-panel-hidden";
+/** The ids the Edit sidebar dialog keeps out of the column. */
+export interface HiddenPanels {
+    has(id: string): boolean;
+    subscribe(listener: () => void): Disposer;
+}
+export interface SidebarPanelRows {
+    /** A copy of the glyph a panel's row draws, for the dialog's list. */
+    glyph(id: string): Element | null;
+    dispose: Disposer;
+}
+/**
+ * Name the panel rows by id and keep the hidden ones out of the column.
+ *
+ * `PanelRow` exposes no id, but `SidebarRoot` renders exactly one row per
+ * `sidebar.panellist` entry, in the order the port reads — the host's own pin
+ * filter is never written (its only setter reaches the More card's rows, which
+ * leave it alone) — so a row's position is its identity. When the counts
+ * disagree for a frame (an entry registering while the column has not caught
+ * up), the marks are withdrawn rather than guessed: nothing is hidden until the
+ * two agree again.
+ *
+ * A hidden row stays where React rendered it: the mark goes on the list child
+ * that holds it, and `sidebar-editor.css` takes that child out of the flow, so
+ * the list's gap closes and DSH keeps every node and handler.
+ */
+export declare function mountSidebarPanelRows(document: Document, port: SidebarPanelsPort, hidden: HiddenPanels, report: (error: unknown) => void): SidebarPanelRows;

package/lib/types/client/compat/sidebar-more-menu.d.ts

@@ -0,0 +1,13 @@
+import type { Disposer } from '../contracts/ports.ts';
+/** Marks the sidebar More card this module places beside its row. */
+export declare const SIDEBAR_MORE_MENU_ATTRIBUTE = "data-ccd-sidebar-more-menu";
+/**
+ * Open the sidebar panel list's More card to the right of its row, like the
+ * reference's sidebar menu, and shorten its two entry-customization rows.
+ *
+ * `SidebarRoot` renders the card with the primitive's default bottom side and
+ * rewrites `left`/`top` on every frame, so the position is published as two
+ * custom properties the stylesheet applies with `!important`; React keeps
+ * owning the inline coordinates and the rows keep their host handlers.
+ */
+export declare function mountSidebarMoreMenu(document: Document, report: (error: unknown) => void): Disposer;

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

@@ -3,8 +3,16 @@ export interface SidebarNavigationIcons {
     readonly newSession: string;
     readonly plugins: string;
     readonly routines: string;
+    readonly more: string;
+    readonly theme: string;
 }
 export declare const SIDEBAR_NAV_ATTRIBUTE = "data-ccd-nav";
+/** Marks the glyph this plugin's own Theme panel draws, so its row is known by
+    what it renders rather than by a label another panel could share. */
+export declare const THEME_PANEL_GLYPH_ATTRIBUTE = "data-ccd-theme-glyph";
+/** The name a panel row shows once this module has renamed it: 插件 reads 自定义
+    and 自动化任务 reads 定时任务, every other panel keeps its own label. */
+export declare function panelDisplayName(document: Document, name: string): string;
 /** 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. */

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

@@ -0,0 +1,62 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { ReactElement } from 'react';
+import type { Disposer } from '../contracts/ports.ts';
+/**
+ * The sidebar's global panels as `ui-sidebar` lists them.
+ *
+ * Verified against the installed DSH 0.2.1-rc.3 client bundle: `SidebarRoot`
+ * reads `sidebar.panellist` entries' `id`, `order` and `label` (a string or a
+ * thunk), sorts them by `order`, and renders one `PanelRow` per entry — the
+ * entry's component is only the row's glyph, rendered with `{ size, active }`.
+ * The centre column renders the `main` keyed entry whose `key` is the active
+ * panel id. `ui-sidebar` is outside the SDK baseline, so the boundary stays
+ * structural here, like `settings-section.ts`.
+ */
+export declare const SIDEBAR_PANEL_SLOT = "sidebar.panellist";
+/** Rows of the panel list's More card; `ui-sidebar` shows More while this list has entries. */
+export declare const SIDEBAR_PANEL_ACTIONS_SLOT = "sidebar.panellist.actions";
+export interface SidebarPanel {
+    readonly id: string;
+    /** The name the row shows, after `sidebar-navigation.ts` renamed it. */
+    readonly label: string;
+}
+/** The panel list `ui-sidebar` renders and the one call that opens an entry. */
+export interface SidebarPanelsPort {
+    /** Every registered panel in the order the column lists them. */
+    panels(): readonly SidebarPanel[];
+    subscribe(listener: () => void): Disposer;
+    /** The panel the centre column shows, or null on a Session. */
+    active(): string | null;
+    select(id: string): void;
+}
+/**
+ * @param ctx - client context carrying the slot and layout services.
+ * @param document - the renderer document, whose language names renamed rows.
+ */
+export declare function sidebarPanelsPort(ctx: Context, document: Document): SidebarPanelsPort;
+export interface MainPanelRegistration<P> {
+    readonly id: string;
+    readonly order: number;
+    readonly locale: string;
+    readonly label: () => string;
+    /** The centre column's page while the panel is active. */
+    readonly page: (props: P) => ReactElement | null;
+    /** The row's glyph, rendered with the column's `{ size, active }`. */
+    readonly glyph: (props: {
+        readonly size?: number;
+        readonly active?: boolean;
+    }) => ReactElement | null;
+}
+/** Register a global panel: its sidebar row and the page it opens. */
+export declare function mountMainPanel<P>(ctx: Context, panel: MainPanelRegistration<P>): Disposer;
+/**
+ * Add rows to the panel list's More card. `PanelMoreMenu` renders every
+ * `sidebar.panellist.actions` entry, by `order`, inside its `Menu` list with
+ * `{ entries, onOpen, onPinnedChange, onDismiss }`; `inject`'s face is merged
+ * over those owner props.
+ */
+export declare function mountMoreCardRows<P>(ctx: Context, entry: {
+    readonly id: string;
+    readonly order: number;
+    readonly inject: () => Record<string, unknown>;
+}, rows: (props: P) => ReactElement | null): Disposer;

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

@@ -1,18 +1,17 @@
-import type { Disposer } from '../contracts/ports.ts';
-/** Marks the sidebar column whose field is currently parked above New Session. */
+import type { Disposer, SearchPaletteOpener } from '../contracts/ports.ts';
+/** Marks the sidebar column whose Search row this module placed below New Session. */
 export declare const SIDEBAR_SEARCH_PLACED_ATTRIBUTE = "data-ccd-sidebar-search-placed";
 /**
- * Park the browsing region's search field above New Session.
+ * Give Search its own navigation row below New Session, like the reference's
+ * sidebar, and open the search palette from it.
  *
- * The field belongs to `ui-workspace`'s `WorkspaceBrowser`, and React removes
- * it from the section header whenever the sidebar collapses to its rail.
- * Moving the React-owned node would make that removal target the wrong parent,
- * so the node stays where React put it and is positioned over the gap that New
- * Session opens above itself. That gap sits after the brand row when the brand
- * is visible and directly below the window strip when it is not.
- *
- * The section header keeps its own row. With the search slot out of flow, its
- * label takes the leading edge and the native View options trigger stays on the
- * trailing edge.
+ * The host's field belongs to `ui-workspace`'s `WorkspaceBrowser`, and React
+ * removes it from the section header whenever the sidebar collapses to its
+ * rail, so the node stays where React put it. While the row is placed,
+ * `sidebar.css` takes the field out of sight without making it unfocusable: the
+ * host's own `session.search` shortcut (⌘K) still focuses it, and that focus is
+ * what this module turns into opening the palette. The row itself is the
+ * plugin's own button, inserted after New Session's node; React never addresses
+ * it, so a re-render only needs it put back.
  */
-export declare function mountSidebarSearch(document: Document, report: (error: unknown) => void): Disposer;
+export declare function mountSidebarSearch(document: Document, icon: string, palette: SearchPaletteOpener, report: (error: unknown) => void): Disposer;

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

@@ -17,7 +17,8 @@ export declare function openFolderLabel(text: string, zh: boolean): string | nul
  * commit that mounts it and never shows the host's glyph first.
  *
  * @param document - renderer document carrying the hero chip and the portal.
- * @param port - Workspace order and new-worktree choices.
+ * @param port - Workspace order and new-worktree choices (the toggle itself is
+ *   `mountWorktreeChip`, beside the folder chip).
  * @param report - sink for observer failures; the native label stays untouched.
  * @returns disposer that disconnects every observer and restores each label.
  */

package/lib/types/client/compat/workspace-worktree.d.ts

@@ -26,7 +26,17 @@ export declare class WorktreeChoices implements WorktreePickerPort {
     subscribe(listener: () => void): Disposer;
     prepare(session: string, create: (workspace: string, from?: string) => Promise<WorktreeResult>): Promise<void>;
 }
-/** Claude's compact bottom row: a menu checkbox with a purely visual switch. */
-export declare function mountWorktreeToggle(card: HTMLElement, workspace: string, port: WorktreePickerPort): Disposer;
+/**
+ * Claude's worktree toggle beside the folder chip: a pressed chip, not a menu
+ * row. It is shown only for a new session whose folder is a Git repository,
+ * and the optional runtime is enabled. Recheck while visible and on returning
+ * to the composer so plugin enable/disable does not leave a stale button.
+ *
+ * @param document - renderer document carrying the hero workspace row.
+ * @param port - per-session worktree choices.
+ * @param workspaceOf - the Workspace a session belongs to.
+ * @param report - sink for observer failures.
+ */
+export declare function mountWorktreeChip(document: Document, port: WorktreePickerPort, workspaceOf: (session: string) => string | undefined, report: (error: unknown) => void): Disposer;
 /** Request retries reuse the Host's per-session result, including after a lost response. */
 export declare function createSessionWorktree(session: string, workspace: string, from?: string): Promise<WorktreeResult>;

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

@@ -296,6 +296,108 @@ export interface ContextPanelPort {
     /** Flip the panel between its collapsed and expanded states. */
     toggleExpanded(): void;
 }
+/** One Session as the search palette lists it. */
+export interface PaletteSession {
+    readonly id: string;
+    readonly title: string;
+    /** Title of the Workspace the Session is accounted to; null when ungrouped. */
+    readonly workspace: string | null;
+    /** Durable activity time, milliseconds since the epoch. */
+    readonly updatedAt: number;
+    readonly running: boolean;
+    readonly archived: boolean;
+    readonly pinned: boolean;
+}
+/** One Workspace as the search palette lists it. */
+export interface PaletteProject {
+    readonly id: string;
+    readonly title: string;
+    readonly path: string;
+    /** Sessions accounted to it, archived ones included. */
+    readonly sessions: number;
+}
+/** A schedule's stored rule, reduced to what its label needs. */
+export type PaletteScheduleRule = {
+    readonly kind: 'once';
+    readonly at: string;
+} | {
+    readonly kind: 'every';
+    readonly seconds: number;
+} | {
+    readonly kind: 'daily';
+    readonly time: string;
+} | {
+    readonly kind: 'weekly';
+    readonly time: string;
+    readonly weekdays: readonly number[];
+} | {
+    readonly kind: 'cron';
+    readonly expression: string;
+};
+/** One scheduled task from the host catalog. */
+export interface PaletteSchedule {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly title: string;
+    readonly prompt: string;
+    readonly rule: PaletteScheduleRule;
+    readonly active: boolean;
+    /** Last durably delivered run, milliseconds since the epoch; null before the first. */
+    readonly lastRunAt: number | null;
+}
+/** Everything the palette lists, as one immutable value. */
+export interface SearchPaletteSnapshot {
+    /** Listed Sessions: no provisional blanks and no subagent children. */
+    readonly sessions: readonly PaletteSession[];
+    /** Workspaces in the host's own order. */
+    readonly projects: readonly PaletteProject[];
+    /** Null on a build without the schedule interface, or while it cannot be read. */
+    readonly schedules: readonly PaletteSchedule[] | null;
+}
+/** Run count read from a task's delivery history; `more` when the page was full. */
+export interface PaletteScheduleRuns {
+    readonly count: number;
+    readonly more: boolean;
+}
+/**
+ * The host data and navigation the search palette is drawn from.
+ *
+ * Every list is read from the host's own catalogs (`sessions.list`,
+ * `workspaces.list`, `schedule/catalog()`) and every action goes through the
+ * host's own navigation or mutation, so the palette keeps no copy of state.
+ */
+export interface SearchPalettePort {
+    /** The current lists; the object identity changes only when a list does. */
+    getSnapshot(): SearchPaletteSnapshot;
+    subscribe(listener: () => void): Disposer;
+    /** Re-read the schedule catalog; the palette asks on every open. */
+    refreshSchedules(): void;
+    scheduleRuns(id: string): Promise<PaletteScheduleRuns>;
+    /** The host's message-content search; at most its own result bound. */
+    searchContent(query: string, signal: AbortSignal): Promise<readonly {
+        readonly sessionId: string;
+        readonly snippet: string;
+    }[]>;
+    openSession(id: string): void;
+    /** Open the New Session page, in a Workspace and with a draft when given. */
+    startSession(options?: {
+        readonly workspaceId?: string;
+        readonly prompt?: string;
+    }): void;
+    /** Show the Scheduled tasks page and the task's own detail. */
+    openSchedule(id: string): void;
+    setPinned(id: string, pinned: boolean): Promise<void>;
+    setArchived(id: string, archived: boolean): Promise<void>;
+    /** Fork a Session and open the child. */
+    fork(id: string): Promise<void>;
+    copy(text: string): Promise<void>;
+}
+/** Opens the search palette; the sidebar row mirrors its open state. */
+export interface SearchPaletteOpener {
+    open(): void;
+    isOpen(): boolean;
+    subscribe(listener: () => void): Disposer;
+}
 /** Actual SDK types, never a second definition of DSH component props. */
 export interface HostServices {
     readonly slots: Context['slots'];

package/lib/types/client/features/composer-pet/claude-frames.d.ts

@@ -6,7 +6,7 @@
 export type ClaudeFrame = readonly [body: string, shade: string, eyes: string, laptop: string];
 export declare const CLAUDE_GROUND_Y = 23.5;
 export declare const CLAUDE_IDLE: ClaudeFrame;
-/** Pose order and hold times follow the recording; identical clean silhouettes
- * are reused so compression noise cannot animate otherwise stationary edges. */
+/** Reuse clean silhouettes for the recorded sequence; typing uses a steady
+ * far / passing / near cadence instead of changing the hands' contours. */
 export declare const CLAUDE_FRAMES: readonly ClaudeFrame[];
 export declare const CLAUDE_TRACK: readonly number[];

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

@@ -0,0 +1,5 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { FeatureEnvironment } from '../../contracts/feature.ts';
+import type { CleanupScope } from '../../core/cleanup.ts';
+/** Styles, injected controls and pane layout share the right-sidebar switch. */
+export declare function mountRightPanel(ctx: Context, environment: FeatureEnvironment, scope: CleanupScope): void;

package/lib/types/client/features/search-palette/SearchPalette.d.ts

@@ -0,0 +1,23 @@
+import type { ReactElement } from 'react';
+import type { SearchPaletteOpener, SearchPalettePort } from '../../contracts/ports.ts';
+/** The palette's open state, shared with the sidebar row that opens it. */
+export interface PaletteState extends SearchPaletteOpener {
+    close(): void;
+}
+interface Props {
+    readonly state: PaletteState;
+    readonly port: SearchPalettePort;
+    readonly report: (error: unknown) => void;
+}
+/**
+ * The search palette: a modal card opened from the sidebar's Search row or ⌘K.
+ *
+ * It is drawn after the reference — a borderless field with a close button, a
+ * row of type tabs, sectioned results with the current row's `…` and ↵, and a
+ * footer of key hints — over lists read from the host's own catalogs. The
+ * card is a native modal `<dialog>`, so focus, the top layer and Esc are the
+ * browser's; the body is mounted per opening, so each opening starts from 全部
+ * with an empty field.
+ */
+export declare function SearchPalette({ state, port, report }: Props): ReactElement;
+export {};

package/lib/types/client/features/search-palette/model.d.ts

@@ -0,0 +1,109 @@
+import type { PaletteProject, PaletteSchedule, PaletteScheduleRule, PaletteScheduleRuns, PaletteSession, SearchPaletteSnapshot } from '../../contracts/ports.ts';
+/** The palette's type filter; `all` mixes every list. */
+export type PaletteTab = 'all' | 'session' | 'project' | 'schedule';
+/** The first matched run of a label, as UTF-16 offsets. */
+export type MatchRange = readonly [start: number, end: number] | null;
+export type PaletteEntry = {
+    readonly kind: 'session';
+    readonly key: string;
+    readonly session: PaletteSession;
+    readonly match: MatchRange;
+    readonly snippet: string | null;
+} | {
+    readonly kind: 'project';
+    readonly key: string;
+    readonly project: PaletteProject;
+    readonly match: MatchRange;
+} | {
+    readonly kind: 'schedule';
+    readonly key: string;
+    readonly schedule: PaletteSchedule;
+    readonly match: MatchRange;
+} | {
+    readonly kind: 'action';
+    readonly key: string;
+    readonly prompt: string;
+} | {
+    readonly kind: 'filter';
+    readonly key: string;
+    readonly tab: PaletteTab;
+};
+export interface PaletteSection {
+    readonly id: string;
+    readonly title: string;
+    readonly entries: readonly PaletteEntry[];
+}
+/** One row of an entry's `…` menu; `primary` is what Enter does on the row. */
+export interface PaletteAction {
+    readonly id: 'open' | 'pin' | 'unpin' | 'fork' | 'archive' | 'unarchive' | 'new-session' | 'copy-path' | 'open-session';
+    readonly label: string;
+    readonly primary?: boolean;
+}
+export interface PaletteCopy {
+    readonly placeholder: string;
+    readonly close: string;
+    readonly tabs: Readonly<Record<PaletteTab, string>>;
+    readonly recent: string;
+    readonly actions: string;
+    readonly filters: string;
+    readonly newSession: string;
+    readonly empty: string;
+    readonly archived: string;
+    readonly running: string;
+    readonly ended: string;
+    readonly more: string;
+    readonly hints: {
+        readonly close: string;
+        readonly tabs: string;
+        readonly filter: string;
+        readonly actions: string;
+        readonly compose: string;
+    };
+    readonly menu: Readonly<Record<PaletteAction['id'], string>>;
+    readonly runs: (count: number, more: boolean) => string;
+    readonly sessionCount: (count: number) => string;
+    readonly daily: string;
+    readonly weekdays: string;
+    readonly weekday: readonly string[];
+    readonly weeklyPrefix: string;
+    readonly weekdaySeparator: string;
+    readonly every: (amount: number, unit: 'hour' | 'minute' | 'second') => string;
+    readonly date: (month: number, day: number, year: number | null) => string;
+    readonly failed: (message: string) => string;
+}
+/** The palette's own words, in the document's language. */
+export declare function paletteCopy(language: string): PaletteCopy;
+/** The repeat rule as the reference's title suffix: 每天 9:51 / Daily 9:51. */
+export declare function scheduleRuleLabel(rule: PaletteScheduleRule, copy: PaletteCopy, now?: Date): string;
+/** What a schedule row reads: the task name, then its repeat rule. */
+export declare function scheduleLabel(schedule: PaletteSchedule, copy: PaletteCopy, now?: Date): string;
+/** The right-hand reading of a schedule row. */
+export declare function scheduleMeta(schedule: PaletteSchedule, runs: PaletteScheduleRuns | undefined, copy: PaletteCopy): string;
+/** Case-insensitive first occurrence, or null; an empty query matches nothing. */
+export declare function matchRange(text: string, query: string): MatchRange;
+export interface PaletteQuery {
+    /** The field's raw text; a leading `/` asks for the filter list. */
+    readonly query: string;
+    readonly tab: PaletteTab;
+    /** Content hits from the host search for this query, by Session id. */
+    readonly content?: ReadonlyMap<string, string> | undefined;
+    readonly now?: Date;
+}
+/** Which tabs this build can fill. */
+export declare function paletteTabs(snapshot: SearchPaletteSnapshot): readonly PaletteTab[];
+/** Whether the field's text asks for the filter list rather than a search. */
+export declare function isFilterQuery(query: string): boolean;
+/**
+ * The palette's sections for one query and tab.
+ *
+ * Without a query, 全部 shows the reference's 最近使用 (Sessions and tasks by
+ * their last activity) above its 操作, and each type tab lists its own rows.
+ * With a query, rows are found by title (a project also by path, a task also
+ * by its prompt), ranked prefix → word start → anywhere, then by recency;
+ * Sessions the host's content search found are appended with their snippet.
+ */
+export declare function paletteSections(snapshot: SearchPaletteSnapshot, input: PaletteQuery, copy: PaletteCopy): PaletteSection[];
+/** An entry's `…` menu, primary action first; empty for rows without one. */
+export declare function entryActions(entry: PaletteEntry, copy: PaletteCopy): readonly PaletteAction[];
+/** Relative activity time for a Session row: 3 小时前 / 3 hours ago. */
+export declare function relativeTime(at: number, language: string, now?: number): string;