dsh-claude-desktop-theme 0.4.2 → 0.4.4

package/lib/index.js

@@ -24,7 +24,7 @@ var DEFAULT_FONTS = Object.freeze({
 });
 var DEFAULT_VIEW = Object.freeze({
   showEmptyGroups: false,
-  groupByStatus: false,
+  groupByStatus: true,
   showHeaderSubagents: false,
   showHeaderTeam: false
 });
@@ -431,12 +431,14 @@ var UsageAggregator = class {
   ctx;
   warn;
   values = /* @__PURE__ */ new Map();
-  queued = [];
+  queued = /* @__PURE__ */ new Map();
   folding = /* @__PURE__ */ new Set();
   failures = /* @__PURE__ */ new Map();
   running = 0;
   refreshRun = null;
   snapshot = null;
+  dirty = true;
+  listed = /* @__PURE__ */ new Set();
   disposed = false;
   constructor(ctx, warn) {
     this.ctx = ctx;
@@ -444,7 +446,15 @@ var UsageAggregator = class {
   }
   /** The most recent snapshot; an empty one before the first refresh. */
   get current() {
-    return this.snapshot ?? aggregateUsage([], { now: Date.now(), pending: 0, missed: 0 });
+    if (this.snapshot === null || this.dirty) {
+      this.snapshot = aggregateUsage(this.values.values(), {
+        now: Date.now(),
+        pending: this.queued.size + this.running,
+        missed: this.failures.size
+      });
+      this.dirty = false;
+    }
+    return this.snapshot;
   }
   /**
    * Bring the snapshot up to date.
@@ -456,6 +466,7 @@ var UsageAggregator = class {
    * @returns the snapshot as of this pass.
    */
   refresh() {
+    if (this.disposed) return Promise.resolve(this.current);
     const running = this.refreshRun;
     if (running !== null) return running;
     const run = this.pass().finally(() => {
@@ -467,24 +478,34 @@ var UsageAggregator = class {
   /** Stop folding; in-flight reads settle but no longer publish. */
   dispose() {
     this.disposed = true;
-    this.queued.length = 0;
+    this.queued.clear();
+    this.values.clear();
+    this.failures.clear();
+    this.listed.clear();
+    this.snapshot = null;
   }
   async pass() {
     try {
       const candidates = await this.list();
+      if (this.disposed) return this.current;
       const listed = new Set(candidates.map((candidate) => candidate.header.id));
+      this.listed = listed;
       for (const id of [...this.values.keys()]) if (!listed.has(id)) this.values.delete(id);
       for (const id of [...this.failures.keys()]) if (!listed.has(id)) this.failures.delete(id);
+      for (const id of this.queued.keys()) if (!listed.has(id)) this.queued.delete(id);
       for (const candidate of candidates) {
         if (this.disposed) break;
         const value = this.readSafely(candidate);
         if (value === void 0) this.enqueue(candidate);
-        else this.values.set(candidate.header.id, value);
+        else {
+          this.queued.delete(candidate.header.id);
+          this.values.set(candidate.header.id, value);
+        }
       }
     } catch (error) {
       this.warn("session listing failed; the card keeps the last snapshot", error);
     }
-    this.publish();
+    this.invalidate();
     return this.current;
   }
   /** Every stored session the card counts, newest first. */
@@ -530,24 +551,25 @@ var UsageAggregator = class {
   /** Queue one cold fold unless it is already queued, running, or cooling down. */
   enqueue(candidate) {
     const id = candidate.header.id;
-    if (this.folding.has(id) || this.queued.some((entry) => entry.header.id === id)) return;
+    if (this.disposed || this.folding.has(id) || this.queued.has(id)) return;
     const failedAt = this.failures.get(id);
     if (failedAt !== void 0 && Date.now() - failedAt < RETRY_COOLDOWN_MS) return;
-    this.queued.push(candidate);
+    this.queued.set(id, candidate);
     this.pump();
   }
   /** Keep at most {@link FOLD_CONCURRENCY} folds in flight. */
   pump() {
     while (!this.disposed && this.running < FOLD_CONCURRENCY) {
-      const candidate = this.queued.shift();
+      const candidate = this.queued.values().next().value;
       if (candidate === void 0) return;
       const id = candidate.header.id;
+      this.queued.delete(id);
       this.folding.add(id);
       this.running += 1;
       void this.fold(candidate).finally(() => {
         this.folding.delete(id);
         this.running -= 1;
-        this.publish();
+        this.invalidate();
         this.pump();
       });
     }
@@ -560,7 +582,9 @@ var UsageAggregator = class {
     let handle;
     try {
       handle = await persistence.open(candidate.header.id, "read");
+      if (this.disposed || !this.listed.has(candidate.header.id)) return;
       const { events } = await handle.read(0);
+      if (this.disposed || !this.listed.has(candidate.header.id)) return;
       const block = cache.coldSnapshot(handle.header, handle.inheritedEventCount, events);
       const value = block.values[USAGE_KEY];
       if (this.disposed) return;
@@ -571,6 +595,7 @@ var UsageAggregator = class {
       this.values.set(candidate.header.id, value);
       this.failures.delete(candidate.header.id);
     } catch (error) {
+      if (this.disposed || !this.listed.has(candidate.header.id)) return;
       this.failures.set(candidate.header.id, Date.now());
       this.warn(`fold failed for session ${candidate.header.id}`, error);
     } finally {
@@ -582,14 +607,10 @@ var UsageAggregator = class {
       }
     }
   }
-  /** Recompute the snapshot from the values read so far. */
-  publish() {
+  /** Fold completions invalidate totals; only a route read pays for aggregation. */
+  invalidate() {
     if (this.disposed) return;
-    this.snapshot = aggregateUsage(this.values.values(), {
-      now: Date.now(),
-      pending: this.queued.length + this.running,
-      missed: this.failures.size
-    });
+    this.dirty = true;
   }
 };
 function mountStatistics(ctx, isEnabled) {

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

@@ -0,0 +1,8 @@
+import type { Disposer } from '../contracts/ports.ts';
+/**
+ * Reveal process containers through the host's own handlers. Changing CSS alone
+ * leaves hidden reasoning and process members under the host's collapse policy.
+ * Leaf reasoning/tool disclosures keep their independent state. Stable hooks
+ * come from ui-chat's TurnProcessNodeView and ChatGroupSeat in DSH rc.2.
+ */
+export declare function mountConversationProcess(document: Document, report: (error: unknown) => void): Disposer;

package/lib/types/client/compat/frame.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Coalesce DOM work into one paint frame.
+ *
+ * A mutation observer delivers one batch per microtask, and several documents
+ * (a panel drag, a streaming transcript, a slider writing its own inline
+ * style) can produce many batches between two paints. Doing a full geometry
+ * pass per batch multiplies the layout reads by the batch count; doing it once
+ * per frame is what the screen can actually use.
+ *
+ * The fallbacks are deliberate: an occluded Electron window throttles animation
+ * frames, and a frame without `requestAnimationFrame` at all (some test hosts)
+ * must still settle. In both cases the work runs on a timeout instead, so the
+ * published values are never left stale.
+ */
+/** One coalescing scheduler; `schedule` runs `task` once before the next paint. */
+export interface FrameScheduler {
+    /** Queue the task; repeated calls before it runs collapse into one. */
+    schedule(): void;
+    /** Drop a queued task without running it. */
+    cancel(): void;
+}
+/**
+ * Build a scheduler over one task.
+ *
+ * @param task - the read/write pass to run at most once per frame.
+ * @param win - the window supplying animation frames; defaults to the global.
+ * @returns the scheduler; its task never runs after `cancel`.
+ */
+export declare function frameScheduler(task: () => void, win?: Window | null): FrameScheduler;

package/lib/types/client/compat/hero-chips.d.ts

@@ -0,0 +1,9 @@
+import type { Disposer } from '../contracts/ports.ts';
+/** Measured hero row width, also reserved in the Composer tools group. */
+export declare const HERO_CHIP_WIDTH_PROPERTY = "--ccd-workspace-seat";
+/**
+ * Measure the complete workspace/preset row, whose chips size to their content.
+ * Reserve that width plus one gap in the tools group to separate the permission
+ * button. Observe label, font and viewport-driven size changes.
+ */
+export declare function mountHeroChips(document: Document, report: (error: unknown) => void): Disposer;

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

@@ -163,6 +163,9 @@ export declare const HOST: Readonly<{
     readonly browserList: '._7514NG_list';
     /** FlatList is the only native body the status presentation reorders. */
     readonly browserFlatList: '._7514NG_flatList';
+    /** StateDot's stable state attributes, used when root sessionStatus is absent. */
+    readonly sessionNeedsInput: '[aria-hidden="true"][data-state="warning"]';
+    readonly sessionWorking: '[aria-hidden="true"][data-state="ongoing"]';
     /** Rows.module.css: one Workspace's row, the line the merged header shares,
         and its trailing action group (`sidebar.css` parks both). */
     readonly workspaceRow: '.jJkEga_projectRow';
@@ -347,6 +350,9 @@ export declare const HOST: Readonly<{
  * means the frame is not the pinned one and the feature must stay off.
  */
 export declare const ANCHOR: Readonly<{
+    /** ui-chat TurnProcessNodeView / ChatGroupSeat: process containers, not leaf details. */
+    readonly turnProcess: 'button[data-turn-process]';
+    readonly stepProcessToggle: '[data-step-process] > div > button[data-process-activity]';
     readonly frame: '[data-slot="root"] > div';
     readonly sidebar: '[data-slot="sidebar"]';
     readonly workspaces: '[data-slot="sidebar.workspaces"]';

package/lib/types/client/compat/mutation-scope.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Whether a mutation batch can concern one region of the page.
+ *
+ * Several modules here observe the whole body because the host can move or
+ * rebuild their anchor at any time, then pay a geometry pass on every batch.
+ * Most batches, though, come from somewhere else — a drag in the right pane, a
+ * streaming transcript on another page, another plugin writing its own markup.
+ * This predicate lets a module skip those batches without narrowing what it
+ * observes, so an anchor that is replaced still reaches it.
+ *
+ * The answer is deliberately conservative: a region that is missing, detached
+ * or cannot answer `contains` makes every batch relevant, so a module that
+ * cannot yet measure is never starved of the mutation that would let it.
+ */
+/**
+ * Whether any record in a batch can move something inside `region`.
+ *
+ * `region` is the element the module measures — the composer, the scroller,
+ * the conversation root. A change inside it, on it, or on any of its ancestors
+ * counts, because those are the writes that can change its box. A `null`
+ * region, or one the host has already detached, makes the batch relevant:
+ * that is exactly the state in which the module has to look again.
+ *
+ * @param records - the observer's batch.
+ * @param region - the element being measured, or null while it is unknown.
+ * @returns true when the batch is worth a pass.
+ */
+export declare function recordsTouch(records: readonly MutationRecord[], region: Element | null): boolean;
+/**
+ * Whether a batch inserted a subtree the selector names.
+ *
+ * For modules that watch the whole body only because their anchor can be
+ * replaced: an insertion that matches the selector is the one structural event
+ * worth a pass, and it costs one `matches`/`querySelector` per inserted element
+ * rather than a scan of the document. The predicate is also conservative: a
+ * node from another realm, or one without the selector helpers, counts as a
+ * match.
+ *
+ * @param records - the observer's batch.
+ * @param selector - the marker whose arrival matters.
+ * @returns true when an inserted element is, or contains, a match.
+ */
+export declare function recordsIntroduce(records: readonly MutationRecord[], selector: string): boolean;

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

@@ -7,6 +7,7 @@ export interface PaneChromeOptions {
     readonly onNew: () => void;
     readonly onSelect: (id: string) => void;
     readonly onClose: (id: string) => void;
+    readonly onCloseGroup?: () => void;
     readonly closeTabs: readonly string[];
     readonly terminals: readonly {
         id: string;
@@ -16,6 +17,7 @@ export interface PaneChromeOptions {
     readonly files: readonly {
         id: string;
         title: string;
+        path: string;
         selected: boolean;
     }[];
     readonly panel: HTMLElement;

package/lib/types/client/compat/reply-signature.d.ts

@@ -0,0 +1,6 @@
+import type { Disposer } from '../contracts/ports.ts';
+/** The host marks only the latest turn ending in a reply as always revealed.
+ * Starting another turn clears that marker before its response is complete. */
+export declare const REPLY_SIGNATURE_SEAT = "[data-turn-tail][data-actions-reveal=\"always\"]:has(> [data-clock=\"end\"])";
+/** Keep one playful signature at the latest settled reply, following host swaps. */
+export declare function mountReplySignature(document: Document, report: (error: unknown) => void): Disposer;

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

@@ -21,7 +21,7 @@ export declare const VIEW_GLYPH_ATTRIBUTE = "data-ccd-view-glyph";
 /**
  * The parked pill's inset from the sidebar column's right edge, in px. Measured
  * at @2x on the reference: the column's divider sits 16 device px right of the
- * pill's right edge (docs/issues/img/todo-sidebar-sessions-target.webp).
+ * pill's right edge (DESIGN.md §6.5).
  */
 export declare const VIEW_DOCK_INSET = 8;
 /** Bundled artwork, one per shipped View; see features/conversation/view-switch-icons.ts. */

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

@@ -82,6 +82,8 @@ export interface SidebarRightPort {
     }): void;
     /** Focus a tab and the pane holding it; a missing tab is left alone. */
     focus(tabId: string): void;
+    /** Close a tab in the on-screen Session through the host's cleanup path. */
+    close?(tabId: string): void;
     /**
      * Open tab metadata across adopted Sessions — and, in the shipped face, the
      * snapshot store behind it: the plugin's pane layer re-reads the layout

package/lib/types/client/features/conversation/header-actions/HeaderActionButton.d.ts

@@ -11,8 +11,8 @@ export interface HeaderActionProps {
 /**
  * One view button for the conversation header.
  *
- * All three sit in the utilities group beside the native actions, led by the
- * project folder; the corner seat past them holds nothing (the panel's shipped
+ * All three sit in the utilities group beside the native actions, in terminal,
+ * browser, project folder order; the corner seat past them holds nothing (the panel's shipped
  * expand control is retired there and its action moves into the Session menu).
  * All three are the same control: the box size, hover surface and spacing
  * belong to the seat's own stylesheet

package/lib/types/client/features/conversation/header-actions/entries.d.ts

@@ -18,28 +18,24 @@ export declare const FILES_KIND = "files";
 /**
  * List orders inside `conversation.session.header.utilities`.
  *
- * The project folder leads the row, so it carries the lowest order of every
- * entry there is — below the retired open-in-app control (-10) and the native
- * scheduled-tasks entry (-5), not only below this plugin's own views: the
- * reference draws the folder as the cluster's first control, whatever a Session
- * happens to carry. The two views then land directly before the native session
- * menu at 0 and keep it as the cluster's closing entry.
+ * Terminal, browser and project folder sit directly before the native session
+ * menu at 0, in that order.
  */
-export declare const FOLDER_ORDER = -11;
-export declare const TERMINAL_ORDER = -2;
-export declare const BROWSER_ORDER = -1;
+export declare const TERMINAL_ORDER = -3;
+export declare const BROWSER_ORDER = -2;
+export declare const FOLDER_ORDER = -1;
 /** The views this plugin exposes in the utilities group, in cluster order. */
 export declare const VIEWS: readonly [{
-    readonly id: 'ccd-folder';
-    readonly kind: "files";
-    readonly order: -11;
-}, {
     readonly id: 'ccd-terminal';
     readonly kind: 'terminal';
-    readonly order: -2;
+    readonly order: -3;
 }, {
     readonly id: 'ccd-browser';
     readonly kind: 'browser';
+    readonly order: -2;
+}, {
+    readonly id: 'ccd-folder';
+    readonly kind: "files";
     readonly order: -1;
 }];
 /**
@@ -64,7 +60,7 @@ export type OpenViewKind = (kind: string, sessionId: string) => void;
 export declare function utilitiesEntry(view: (typeof VIEWS)[number], labels: Record<(typeof VIEWS)[number]['kind'] | typeof FILES_KIND, string>, open: OpenViewKind): {
     name: "conversation.session.header.utilities";
     id: "ccd-browser" | "ccd-folder" | "ccd-terminal";
-    order: -11 | -2 | -1;
+    order: -3 | -2 | -1;
     inject: (sessionId: string) => HeaderActionProps;
 };
 /**

package/lib/types/client/features/conversation/view-switch-icons.d.ts

@@ -1,8 +1,8 @@
 /**
  * The two View switcher glyphs, bundled as trusted static markup.
  *
- * Drawn to the reference's own segments (docs/issues/img/todo-sidebar-sessions-target.webp,
- * @2x): a pair of speech bubbles for the chat View and the `</>` pair for the
+ * Drawn to the reference's own segments (DESIGN.md §6.5, @2x): a pair of
+ * speech bubbles for the chat View and the `</>` pair for the
  * trajectory View, both on the CCD 16 grid — 1–1.2px stroke (each glyph's own
  * weight read off the reference), round caps and joins, `currentColor` ink,
  * ink box ≈ 12.5 × 11px inside the 16px artwork.

package/lib/types/client/features/model-controls/popup.d.ts

@@ -1,4 +1,23 @@
 import type { RefObject } from 'react';
+interface Size {
+    width: number;
+    height: number;
+}
+/**
+ * The panel's border box, kept between placements.
+ *
+ * Its size changes only when its own content does, which the resize observer
+ * below already reports, so each placement can read the trigger alone instead
+ * of forcing a second layout of the surface. The first read is the seeding one:
+ * the panel has been shown by the time `place()` runs, so its box is real.
+ *
+ * @param surface - the popover element.
+ * @returns the cached size, and a way to re-read it when the observer fires.
+ */
+export declare function cachedSize(surface: Element): {
+    current: () => Size;
+    refresh: () => void;
+};
 /** Viewport-clamped top-layer surface; focus and observers die with the panel. */
 export declare function usePopup(anchor: RefObject<HTMLButtonElement>, close: () => void): {
     panel: RefObject<HTMLDivElement>;
@@ -8,3 +27,4 @@ export declare function usePopup(anchor: RefObject<HTMLButtonElement>, close: ()
         visibility: 'hidden' | 'visible';
     };
 };
+export {};

package/lib/types/client/features/new-session/ripples.d.ts

@@ -1,8 +1,8 @@
 import type { HeroRippleImpulse } from '../../contracts/hero-canvas.ts';
-/** One character's stable grain and time-varying light, before the edge fade. */
+/** One cell's independently changing character and moving light, before edge fade. */
 export declare function rippleCell(x: number, y: number, elapsed: number, width: number, height: number, impulses?: readonly HeroRippleImpulse[]): {
     alpha: number;
     glyph: string;
 };
-/** Stationary ASCII rows lit by an autonomous, slowly swelling wave field. */
+/** Shimmering ASCII rows lit by an autonomous, slowly swelling wave field. */
 export declare function drawHeroRipples(canvas: HTMLCanvasElement, elapsed: number, impulses?: readonly HeroRippleImpulse[]): void;

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

@@ -10,7 +10,8 @@
  * are still being folded (`pending > 0`) the card is genuinely incomplete, so
  * it refreshes every couple of seconds; once the snapshot is complete it drops
  * to a slow poll. A missing route (the host half is off) hides the card rather
- * than failing the mount.
+ * than failing the mount. Hidden documents pause reads and resume immediately
+ * when visible, keeping background windows from repeatedly aggregating history.
  */
 import { type StatsSnapshot } from '../../../shared/stats.ts';
 import type { Logger } from '../../contracts/ports.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-claude-desktop-theme",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "license": "MIT",
   "description": "Claude Code Desktop-style theme for DeepSeek Harness (DSH) Desktop on macOS and Windows, with light/dark themes, model/effort pickers and an interactive pixel whale",
   "author": "zkforge",
@@ -85,7 +85,6 @@
     "check": "npm run typecheck && npm run check:architecture && npm test && npm run build && npm run check:package",
     "prepack": "npm run check",
     "pack:local": "npm pack --pack-destination artifacts",
-    "preview:install": "node scripts/install-local.mjs",
     "pet:gifs": "node scripts/pet-gifs.mjs",
     "effort:gifs": "node scripts/effort-gif.mjs"
   },