dsh-tui-theme 0.6.1 → 0.7.1

package/lib/types/shadowCleanup.d.ts

@@ -0,0 +1,39 @@
+/**
+ * One-shot guided cleanup for shadowing legacy theme files (tuiDialogs).
+ *
+ * On a runtime-themes host, byte-identical leftovers in ~/.dsh-tui/themes/
+ * (written by pre-0.10 plugin versions or a manual install) permanently
+ * shadow the runtime registry, so palette updates never reach the user. The
+ * existing toast points them out once; this module additionally offers a
+ * host-managed confirm dialog to delete the shadowing copies right away.
+ *
+ * Safety posture, unchanged from the toast-only era:
+ * - only files byte-identical to the bundled copy are ever touched — the
+ *   deletion goes through removeBundledThemes(), which re-checks every byte
+ *   at deletion time, so a file edited between detection and confirmation
+ *   survives;
+ * - declining (Esc, the cancel label, the host's 30s auto-cancel when no UI
+ *   is attached, or the seam never arriving on older hosts) keeps the exact
+ *   previous behavior: the toast stands, nothing is deleted;
+ * - the offer happens at most once per activation, and the dialog request is
+ *   owned by the activation's effect ledger, so a disposed activation cannot
+ *   leave an orphaned panel behind.
+ *
+ * tuiDialogs is the host's own managed dialog chrome (the pi
+ * ctx.ui.confirm seam): the TUI owns the keyboard and renders the panel next
+ * to its approval UI — the plugin never touches input itself, which keeps
+ * the "no input interception" boundary intact.
+ * @module dsh-tui-theme/shadowCleanup
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ToastSend } from './toast.js';
+/**
+ * Start the shadow-cleanup offer. Returns the offer function to call when
+ * shadowed files are detected (empty list = no-op). The tuiDialogs service
+ * is consumed through ctx.inject and may arrive before or after the offer —
+ * both orders converge on one dialog.
+ * @param ctx - The plugin's own activation context.
+ * @param sendToast - The toast relay sender for the cleanup result.
+ */
+export declare function startShadowCleanup(ctx: Context, sendToast: ToastSend): (files: readonly string[]) => void;
+//# sourceMappingURL=shadowCleanup.d.ts.map

package/lib/types/shadowCleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadowCleanup.d.ts","sourceRoot":"","sources":["../../src/shadowCleanup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAQ3C;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,GAAG,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,KAAK,IAAI,CAiFzG"}

package/lib/types/shadowCleanup.js

@@ -0,0 +1,122 @@
+/**
+ * One-shot guided cleanup for shadowing legacy theme files (tuiDialogs).
+ *
+ * On a runtime-themes host, byte-identical leftovers in ~/.dsh-tui/themes/
+ * (written by pre-0.10 plugin versions or a manual install) permanently
+ * shadow the runtime registry, so palette updates never reach the user. The
+ * existing toast points them out once; this module additionally offers a
+ * host-managed confirm dialog to delete the shadowing copies right away.
+ *
+ * Safety posture, unchanged from the toast-only era:
+ * - only files byte-identical to the bundled copy are ever touched — the
+ *   deletion goes through removeBundledThemes(), which re-checks every byte
+ *   at deletion time, so a file edited between detection and confirmation
+ *   survives;
+ * - declining (Esc, the cancel label, the host's 30s auto-cancel when no UI
+ *   is attached, or the seam never arriving on older hosts) keeps the exact
+ *   previous behavior: the toast stands, nothing is deleted;
+ * - the offer happens at most once per activation, and the dialog request is
+ *   owned by the activation's effect ledger, so a disposed activation cannot
+ *   leave an orphaned panel behind.
+ *
+ * tuiDialogs is the host's own managed dialog chrome (the pi
+ * ctx.ui.confirm seam): the TUI owns the keyboard and renders the panel next
+ * to its approval UI — the plugin never touches input itself, which keeps
+ * the "no input interception" boundary intact.
+ * @module dsh-tui-theme/shadowCleanup
+ */
+import { AsyncResource } from 'node:async_hooks';
+import { removeBundledThemes } from './themeAssets.js';
+import { PLUGIN_ID } from './pluginId.js';
+/**
+ * Start the shadow-cleanup offer. Returns the offer function to call when
+ * shadowed files are detected (empty list = no-op). The tuiDialogs service
+ * is consumed through ctx.inject and may arrive before or after the offer —
+ * both orders converge on one dialog.
+ * @param ctx - The plugin's own activation context.
+ * @param sendToast - The toast relay sender for the cleanup result.
+ */
+export function startShadowCleanup(ctx, sendToast) {
+    let dialogs;
+    let owner;
+    // The traceable service resolves its caller through the ambient Cordis
+    // activation (the same rule the toast relay works around): capture the
+    // inject's async scope and re-enter it for every call, including offers
+    // that arrive from another inject of this activation.
+    let scope;
+    let pending;
+    let offered = false;
+    let disposed = false;
+    const ask = (service, ownerCtx, files) => {
+        const names = files.join('、');
+        const request = {
+            title: '清理旧主题文件',
+            message: `检测到 ${files.length} 个与插件内置完全相同的旧主题文件（${names}），它们会遮蔽运行时主题，使配色无法随插件更新。要删除它们吗？`,
+            confirmLabel: '删除',
+            cancelLabel: '保留',
+        };
+        const call = () => {
+            if (scope === undefined)
+                return service.confirm(ownerCtx, request);
+            return scope.runInAsyncScope(() => service.confirm(ownerCtx, request));
+        };
+        // The real host resolves malformed requests with false rather than
+        // rejecting or throwing; a synchronous throw still means a hostile
+        // service, and a garnish must never propagate that upward.
+        try {
+            void call()
+                .then(confirmed => {
+                // A stale activation must not act on a late answer.
+                if (disposed || confirmed !== true)
+                    return;
+                const removed = removeBundledThemes([...files]);
+                if (removed.length === 0) {
+                    // Every candidate was edited (or vanished) between detection and
+                    // confirmation — the byte check protected them, and the earlier
+                    // toast already describes the situation.
+                    ctx.logger.info(`${PLUGIN_ID}: shadow cleanup confirmed, but no file was still byte-identical; nothing removed`);
+                    return;
+                }
+                ctx.logger.info(`${PLUGIN_ID}: removed ${removed.length} shadowing legacy file(s) after user confirmation`);
+                sendToast(`✿ 已清理 ${removed.length} 个旧主题文件，配色将随插件自动更新`, 'success');
+            })
+                .catch(error => {
+                ctx.logger.warn(`${PLUGIN_ID}: shadow cleanup dialog failed: ${String(error)}`);
+            });
+        }
+        catch (error) {
+            ctx.logger.warn(`${PLUGIN_ID}: shadow cleanup dialog failed: ${String(error)}`);
+        }
+    };
+    ctx.inject(['tuiDialogs'], dialogsCtx => {
+        if (disposed)
+            return;
+        dialogs = dialogsCtx.tuiDialogs;
+        owner = dialogsCtx;
+        scope = new AsyncResource('dsh-tui-theme-shadow-dialog');
+        dialogsCtx.effect(() => () => {
+            dialogs = undefined;
+            owner = undefined;
+            scope = undefined;
+        });
+        const files = pending;
+        if (files !== undefined) {
+            pending = undefined;
+            ask(dialogs, dialogsCtx, files);
+        }
+    });
+    ctx.effect(() => () => {
+        disposed = true;
+    });
+    return files => {
+        if (offered || disposed || files.length === 0)
+            return;
+        offered = true;
+        if (dialogs !== undefined && owner !== undefined) {
+            ask(dialogs, owner, files);
+        }
+        else {
+            pending = files;
+        }
+    };
+}

package/lib/types/statusLine.d.ts

@@ -6,18 +6,27 @@
  * ever appended to the session log). The host owns rendering and
  * sanitization; text is scalars only.
  *
+ * Two render paths, chosen once per activation (no hot switching):
+ * - dsh-TUI >= 0.10.1 (`registerView` present): a themed one-row rich view
+ *   (see statusView.ts) whose colors come from the active pink palette;
+ * - older hosts: the historical scalar `set()` line, which the host renders
+ *   uncolored + terminal dim.
+ *
  * The line belongs to the pink palettes: by default it only renders while a
  * pink theme is active (checked per render with the host's own theme
- * precedence, so a mid-session /theme switch takes effect within the pref
- * cache TTL — at most one clock tick); `statusScope: 'all-themes'` opts it
- * into every other theme too.
+ * precedence, so a mid-session /theme switch takes effect at the very next
+ * render — the pref file's mtime is re-checked per render; the TTL below is
+ * only the fallback for filesystems where mtime granularity can hide a
+ * rewrite); `statusScope: 'all-themes'` opts it into every other theme too
+ * (uncolored there — non-pink palettes are not readable from a plugin).
  *
  * Cost discipline: `session/event` is a token-level firehose (assistant/chunk
- * et al.), but the rendered text only changes at turn boundaries and on the
- * clock, so renders run on turn/start, turn/end, session/disposed, and the
- * 15s tick — never per streamed chunk. The persisted-pref read behind the
- * theme check is cached for the same tick length so a render is pure string
- * building.
+ * et al.), but the rendered content only changes at turn boundaries and on
+ * the clock, so pushes/renders run on turn/start, turn/end, session/disposed,
+ * and the 15s tick — never per streamed chunk. The persisted-pref read behind
+ * the theme check and the palette read behind the colors are each cached for
+ * the same tick length so a render is pure string building plus one cheap
+ * stat of the pref file.
  * @module dsh-tui-theme/statusLine
  */
 import type { Context } from '@deepseek-ai/cordis';
@@ -26,7 +35,11 @@ export type StatusScope = 'pink-only' | 'all-themes';
 export interface StatusOptions {
     /** Master switch (cordis-config layer only; not surfaced in /settings). */
     statusEnabled?: boolean;
-    /** Lead the line with the ✿ glyph. */
+    /** The character leading the line (default ✿; 1–2 display cells). */
+    statusGlyph?: string;
+    /** The character between the cells (default ·; 1–2 display cells). */
+    statusSeparator?: string;
+    /** Lead the line with the blossom glyph. */
     showGlyph?: boolean;
     /** Include the HH:MM clock. */
     showClock?: boolean;
@@ -38,8 +51,11 @@ export interface StatusOptions {
 /** Fully-resolved status knobs. */
 export type EffectiveStatus = Required<StatusOptions>;
 /**
- * @internal Drop the persisted-pref cache (verify.mjs only; not part of the
- * plugin's behavioral contract). Production invalidation is the TTL.
+ * @internal Drop the persisted-pref and palette caches (verify.mjs only; not
+ * part of the plugin's behavioral contract). Production invalidation is the
+ * mtime gate, with the TTL as the fallback. Both caches share the reset so
+ * test scenarios cannot couple through the 15s palette TTL the way they
+ * could through the pref one.
  */
 export declare function invalidateThemePrefCacheForTests(): void;
 /**

package/lib/types/statusLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"statusLine.d.ts","sourceRoot":"","sources":["../../src/statusLine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAQlD,mDAAmD;AACnD,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,YAAY,CAAA;AAEpD,MAAM,WAAW,aAAa;IAC5B,2EAA2E;IAC3E,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,sCAAsC;IACtC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,+BAA+B;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,0DAA0D;IAC1D,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,iEAAiE;IACjE,WAAW,CAAC,EAAE,WAAW,CAAA;CAC1B;AAED,mCAAmC;AACnC,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAA;AAsBrD;;;GAGG;AACH,wBAAgB,gCAAgC,IAAI,IAAI,CAEvD;AA0CD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,GAAG,IAAI,CAqEvF"}
+{"version":3,"file":"statusLine.d.ts","sourceRoot":"","sources":["../../src/statusLine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAkBlD,mDAAmD;AACnD,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,YAAY,CAAA;AAEpD,MAAM,WAAW,aAAa;IAC5B,2EAA2E;IAC3E,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,sEAAsE;IACtE,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,+BAA+B;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,0DAA0D;IAC1D,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,iEAAiE;IACjE,WAAW,CAAC,EAAE,WAAW,CAAA;CAC1B;AAED,mCAAmC;AACnC,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAA;AAsCrD;;;;;;GAMG;AACH,wBAAgB,gCAAgC,IAAI,IAAI,CAGvD;AAuGD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,GAAG,IAAI,CAyIvF"}

package/lib/types/statusLine.js

@@ -6,25 +6,38 @@
  * ever appended to the session log). The host owns rendering and
  * sanitization; text is scalars only.
  *
+ * Two render paths, chosen once per activation (no hot switching):
+ * - dsh-TUI >= 0.10.1 (`registerView` present): a themed one-row rich view
+ *   (see statusView.ts) whose colors come from the active pink palette;
+ * - older hosts: the historical scalar `set()` line, which the host renders
+ *   uncolored + terminal dim.
+ *
  * The line belongs to the pink palettes: by default it only renders while a
  * pink theme is active (checked per render with the host's own theme
- * precedence, so a mid-session /theme switch takes effect within the pref
- * cache TTL — at most one clock tick); `statusScope: 'all-themes'` opts it
- * into every other theme too.
+ * precedence, so a mid-session /theme switch takes effect at the very next
+ * render — the pref file's mtime is re-checked per render; the TTL below is
+ * only the fallback for filesystems where mtime granularity can hide a
+ * rewrite); `statusScope: 'all-themes'` opts it into every other theme too
+ * (uncolored there — non-pink palettes are not readable from a plugin).
  *
  * Cost discipline: `session/event` is a token-level firehose (assistant/chunk
- * et al.), but the rendered text only changes at turn boundaries and on the
- * clock, so renders run on turn/start, turn/end, session/disposed, and the
- * 15s tick — never per streamed chunk. The persisted-pref read behind the
- * theme check is cached for the same tick length so a render is pure string
- * building.
+ * et al.), but the rendered content only changes at turn boundaries and on
+ * the clock, so pushes/renders run on turn/start, turn/end, session/disposed,
+ * and the 15s tick — never per streamed chunk. The persisted-pref read behind
+ * the theme check and the palette read behind the colors are each cached for
+ * the same tick length so a render is pure string building plus one cheap
+ * stat of the pref file.
  * @module dsh-tui-theme/statusLine
  */
+import { readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { homeDir } from './themeAssets.js';
+import { bundledThemesDir, homeDir, themesTargetDir } from './themeAssets.js';
 import { readThemePref } from './autoTheme.js';
+import { sanitizeOrnament } from './ornament.js';
+import { createStatusStore, createStatusViewComponent, statusViewDescriptor, NO_COLORS, } from './statusView.js';
 import { PLUGIN_ID } from './pluginId.js';
 const GLYPH = '✿';
+const SEPARATOR = '·';
 // The tuiStatus contribution key (same value as the settings namespace and
 // the cordis plugin name — one literal would be three drift risks).
 const STATUS_KEY = PLUGIN_ID;
@@ -39,20 +52,41 @@ const THEME_PREF_TTL_MS = CLOCK_TICK_MS;
 const PINK_THEMES = new Set(['pink-night', 'pink-day', 'pink-ansi']);
 // `value: undefined` is a cached "no pref file / unparsable" answer, so the
 // common non-pink host (no theme.json at all) is one memory read per TTL
-// window instead of a failed syscall per render.
+// window instead of a failed syscall per render. `mtimeMs` is the change
+// signal the other way: the host rewrites theme.json alongside its
+// in-memory /theme switch, and the next render stats the file, so the
+// switch lands at that render instead of waiting out the TTL — the stale
+// window was invisible on the scalar path but shows as wrong colors on the
+// rich one. (mtime granularity on exotic filesystems can hide a rewrite;
+// the TTL bounds that miss.)
 let prefCache;
+/** -1 when the pref does not exist (a stable answer for the cache key). */
+function prefMtimeMs(dataDir) {
+    try {
+        return statSync(join(dataDir, 'theme.json')).mtimeMs;
+    }
+    catch {
+        return -1;
+    }
+}
 /**
- * @internal Drop the persisted-pref cache (verify.mjs only; not part of the
- * plugin's behavioral contract). Production invalidation is the TTL.
+ * @internal Drop the persisted-pref and palette caches (verify.mjs only; not
+ * part of the plugin's behavioral contract). Production invalidation is the
+ * mtime gate, with the TTL as the fallback. Both caches share the reset so
+ * test scenarios cannot couple through the 15s palette TTL the way they
+ * could through the pref one.
  */
 export function invalidateThemePrefCacheForTests() {
     prefCache = undefined;
+    colorsCache = undefined;
 }
 /**
  * The active theme name by the host's own precedence: DSH_TUI_THEME first,
  * then the persisted ~/.dsh-tui/theme.json pref (read through a one-tick
- * cache). The unforced path (OSC 11 auto-detection) only ever resolves to a
- * builtin palette, never a pink one, so "no pref" means non-pink.
+ * cache whose freshness is re-checked per render via the file's mtime —
+ * one stat, no read unless it moved). The unforced path (OSC 11
+ * auto-detection) only ever resolves to a builtin palette, never a pink
+ * one, so "no pref" means non-pink.
  *
  * This deliberately mirrors the host's ThemeProvider resolution chain
  * (`components/design-system/ThemeProvider.tsx`, baseline dsh-TUI 0.9.3);
@@ -64,15 +98,67 @@ function activeThemeName(dataDir) {
     if (env !== undefined && env !== '')
         return env;
     const now = Date.now();
-    if (prefCache === undefined || now - prefCache.at >= THEME_PREF_TTL_MS) {
-        prefCache = { at: now, value: readThemePref(dataDir) };
+    const mtimeMs = prefMtimeMs(dataDir);
+    if (prefCache === undefined ||
+        mtimeMs !== prefCache.mtimeMs ||
+        now - prefCache.at >= THEME_PREF_TTL_MS) {
+        prefCache = { at: now, mtimeMs, value: readThemePref(dataDir) };
     }
     return prefCache.value;
 }
-function isPinkThemeActive(dataDir) {
-    const name = activeThemeName(dataDir);
+function isPinkTheme(name) {
     return name !== undefined && PINK_THEMES.has(name);
 }
+// ── palette colors ──────────────────────────────────────────────────────────
+// Read from the effective pink palette with the same one-tick cache as the
+// pref: a legacy ~/.dsh-tui/themes/<name>.json first (it shadows the runtime
+// registry on old hosts), then this package's bundled copy. Non-pink themes
+// render uncolored.
+let colorsCache;
+function paletteCell(colors, keys) {
+    for (const key of keys) {
+        const value = colors[key];
+        if (typeof value === 'string' && value !== '')
+            return value;
+    }
+    return undefined;
+}
+function readPalette(name) {
+    // `accent` is the 0.10.1 canonical brand key; `claude` is the 0.9.x name
+    // the bundled JSONs still carry (the host aliases it at admission, but this
+    // read bypasses the host entirely).
+    for (const dir of [themesTargetDir(), bundledThemesDir()]) {
+        try {
+            const parsed = JSON.parse(readFileSync(join(dir, `${name}.json`), 'utf8'));
+            if (parsed.colors === null || typeof parsed.colors !== 'object')
+                continue;
+            return {
+                glyph: paletteCell(parsed.colors, ['accent', 'claude']),
+                // The clock/turns share the host's bottom-bar tier: the model name and
+                // its neighbours render with `inactiveShimmer` (host StatusLine.tsx),
+                // and the garnish reads consistent when it matches (user-tested — the
+                // body-text key was too heavy, the inactive tier still felt off).
+                // inactive then body text are the fallbacks for palettes that lack
+                // the shimmer key.
+                text: paletteCell(parsed.colors, ['inactiveShimmer', 'inactive', 'text']),
+                separator: paletteCell(parsed.colors, ['subtle', 'inactive']),
+            };
+        }
+        catch {
+            // Missing or unreadable source: try the next one.
+        }
+    }
+    return NO_COLORS;
+}
+function paletteFor(themeName) {
+    if (!isPinkTheme(themeName))
+        return NO_COLORS;
+    const now = Date.now();
+    if (colorsCache === undefined || colorsCache.name !== themeName || now - colorsCache.at >= THEME_PREF_TTL_MS) {
+        colorsCache = { at: now, name: themeName, colors: readPalette(themeName) };
+    }
+    return colorsCache.colors;
+}
 function clockText() {
     // "HH:MM" from toTimeString()'s "HH:MM:SS GMT…" prefix — locale independent.
     return new Date().toTimeString().slice(0, 5);
@@ -97,39 +183,84 @@ export function startStatusLine(ctx, getEffective) {
         const status = statusCtx.tuiStatus;
         const turns = new Map();
         let current;
-        let dispose;
+        let legacyDispose;
+        let viewDispose;
+        let store;
+        // The scalar path's render. Both paths compute the same cells; they only
+        // differ in how the result reaches the host.
+        const renderScalar = () => {
+            const eff = getEffective();
+            const themeName = activeThemeName(dataDir);
+            const cells = statusCells(eff, themeName);
+            const separator = sanitizeOrnament(eff.statusSeparator, SEPARATOR);
+            const parts = [cells.glyph, cells.clock, cells.turns].filter((value) => value !== undefined);
+            const text = parts.join(` ${separator} `);
+            if (text === lastText)
+                return;
+            lastText = text;
+            // The trailing identity must be the inject-scoped context (the same
+            // activation the traceable binds as caller) — the plugin's outer ctx
+            // is a different activation view and would be silently rejected.
+            legacyDispose = status.set(STATUS_KEY, text === '' ? undefined : text, statusCtx) ?? legacyDispose;
+        };
         let lastText;
         const render = () => {
             try {
-                const eff = getEffective();
-                const parts = [];
-                // The line is pink garnish: off on other themes unless opted in.
-                // The theme check runs here (not once at startup) so a mid-session
-                // /theme switch lands within one pref-cache TTL — the next tick or
-                // turn boundary.
-                const themeAllows = eff.statusScope === 'all-themes' || isPinkThemeActive(dataDir);
-                if (eff.statusEnabled && themeAllows) {
-                    if (eff.showGlyph)
-                        parts.push(GLYPH);
-                    if (eff.showClock)
-                        parts.push(clockText());
-                    if (eff.showTurns && current !== undefined) {
-                        parts.push(`${turns.get(current) ?? 0}✦`);
-                    }
-                }
-                const text = parts.join(' · ');
-                if (text === lastText)
+                if (store !== undefined) {
+                    const eff = getEffective();
+                    // One pref read per render, shared by the visibility check and the
+                    // palette: the module header's "one cheap stat" invariant holds on
+                    // both paths (statusCells and paletteFor each used to re-resolve).
+                    const themeName = activeThemeName(dataDir);
+                    const cells = statusCells(eff, themeName);
+                    store.push({
+                        visible: cells.glyph !== undefined || cells.clock !== undefined || cells.turns !== undefined,
+                        glyph: cells.glyph,
+                        clock: cells.clock,
+                        turns: cells.turns,
+                        separator: sanitizeOrnament(eff.statusSeparator, SEPARATOR),
+                        colors: paletteFor(themeName),
+                    });
                     return;
-                lastText = text;
-                // The trailing identity must be the inject-scoped context (the same
-                // activation the traceable binds as caller) — the plugin's outer ctx
-                // is a different activation view and would be silently rejected.
-                dispose = status.set(STATUS_KEY, text === '' ? undefined : text, statusCtx) ?? dispose;
+                }
+                renderScalar();
             }
             catch {
                 // Display garnish only: a rendering hiccup must never travel upward.
             }
         };
+        /** The three optional cells (all undefined = the line is off: master
+         *  switch, theme scope, and the toggles fold into this one shape).
+         *  Takes the theme name resolved once by the caller per render. */
+        function statusCells(eff, themeName) {
+            const enabled = eff.statusEnabled && (eff.statusScope === 'all-themes' || isPinkTheme(themeName));
+            if (!enabled)
+                return { glyph: undefined, clock: undefined, turns: undefined };
+            return {
+                glyph: eff.showGlyph ? sanitizeOrnament(eff.statusGlyph, GLYPH) : undefined,
+                clock: eff.showClock ? clockText() : undefined,
+                turns: eff.showTurns && current !== undefined ? `${turns.get(current) ?? 0}✦` : undefined,
+            };
+        }
+        // Rich path probe: a soft capability check, exactly like every other
+        // seam. registerView is fixed for the host's lifetime, so the choice is
+        // made once per activation; a refused registration (returned undefined)
+        // or a hostile one that throws falls back to set(). The throw defense is
+        // load-bearing: without it the error escapes the inject callback and
+        // takes the session/event wiring and the first render down with it.
+        if (typeof status.registerView === 'function') {
+            const viewStore = createStatusStore();
+            try {
+                const dispose = status.registerView(statusViewDescriptor(STATUS_KEY, createStatusViewComponent(viewStore)), statusCtx);
+                if (dispose !== undefined) {
+                    store = viewStore;
+                    viewDispose = dispose;
+                }
+            }
+            catch (error) {
+                statusCtx.logger.warn(`dsh-tui-theme: rich status view registration failed, staying on the scalar line: ${String(error)}`);
+            }
+        }
         statusCtx.on('session/event', (session, event) => {
             current = session;
             const type = event?.type;
@@ -155,11 +286,18 @@ export function startStatusLine(ctx, getEffective) {
         statusCtx.effect(() => () => {
             clearInterval(timer);
             try {
-                dispose?.();
+                legacyDispose?.();
             }
             catch {
                 // The host store is already gone on teardown — nothing to clear.
             }
+            try {
+                viewDispose?.();
+            }
+            catch {
+                // Same teardown race as above; the rich view is best-effort too.
+            }
+            store?.clear();
         });
         render();
     });

package/lib/types/statusView.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Rich status view (dsh-TUI >= 0.10.1 seam: `tuiStatus.registerView`).
+ *
+ * A compact one-row host React component that renders the blossom line with
+ * colors taken from the active pink palette — the one thing the scalar
+ * `tuiStatus.set` path can never do (the host renders set() text uncolored +
+ * terminal dim).
+ *
+ * Data channel: the component subscribes to a tiny plugin-side external
+ * store via the host React's useSyncExternalStore, exactly the "owns its
+ * live data via an external store" pattern the host seam documents. The
+ * plugin pushes scalar-only snapshots (turn boundaries, the clock tick,
+ * settings edits); the component maps one snapshot to themed Text cells and
+ * never touches the filesystem, timers, or events itself — it runs on the
+ * host's render thread and must stay a pure function of its snapshot.
+ *
+ * Host kit rules honored here: the component is created with the host React
+ * instance handed in via props (single-React rule — the plugin never imports
+ * react), and `Box`/`Text` receive only layout/color props (no focus,
+ * keyboard, wheel, or ref props; no pointer handlers either — the line is
+ * pure display).
+ * @module dsh-tui-theme/statusView
+ */
+import type { TuiStatusViewDescriptor } from '@deepseek-harness-tui/dsh-tui/extensions';
+/** Raw color values for one render, straight from the active palette (or
+ *  all undefined under non-pink themes — the terminal default then applies). */
+export interface StatusColors {
+    readonly glyph: string | undefined;
+    readonly text: string | undefined;
+    readonly separator: string | undefined;
+}
+export declare const NO_COLORS: StatusColors;
+/** Everything one render needs, as scalars only. Frozen by the store. */
+export interface StatusSnapshot {
+    readonly visible: boolean;
+    readonly glyph: string | undefined;
+    readonly clock: string | undefined;
+    /** The turn-count cell, e.g. "3✦" (undefined while no session is live). */
+    readonly turns: string | undefined;
+    readonly separator: string;
+    readonly colors: StatusColors;
+}
+/**
+ * The plugin-side external store the rich view subscribes to. Pushes are
+ * deduplicated: a snapshot equal to the current one notifies nobody, so a
+ * clock tick that changed nothing costs no React render.
+ */
+export interface StatusStore {
+    getSnapshot(): StatusSnapshot;
+    subscribe(listener: () => void): () => void;
+    push(next: StatusSnapshot): void;
+    /** Drop all listeners (activation teardown). */
+    clear(): void;
+}
+export declare function createStatusStore(): StatusStore;
+/** Structural views of the host kit; the real types live in the host. */
+interface StatusViewReact {
+    createElement(type: unknown, props: Record<string, unknown> | null, ...children: unknown[]): unknown;
+    useSyncExternalStore(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => StatusSnapshot): StatusSnapshot;
+}
+interface StatusViewUi {
+    readonly Box: unknown;
+    readonly Text: unknown;
+}
+export interface StatusViewProps {
+    readonly React: StatusViewReact;
+    readonly ui: StatusViewUi;
+}
+/**
+ * Build the rich view component bound to one store. The returned function is
+ * a host React component: it receives `{ React, ui }` from the host on every
+ * render and maps the current snapshot to a one-row themed Box.
+ */
+export declare function createStatusViewComponent(store: StatusStore): (props: StatusViewProps) => unknown;
+/**
+ * The registration descriptor for the rich view. The caller passes the same
+ * contribution key the scalar path uses, so the effect-ledger resource id
+ * and the headless order-test pin remain stable across both paths.
+ */
+export declare function statusViewDescriptor(key: string, component: TuiStatusViewDescriptor['component']): TuiStatusViewDescriptor;
+export {};
+//# sourceMappingURL=statusView.d.ts.map

package/lib/types/statusView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statusView.d.ts","sourceRoot":"","sources":["../../src/statusView.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0CAA0C,CAAA;AAEvF;gFACgF;AAChF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;CACvC;AAED,eAAO,MAAM,SAAS,EAAE,YAItB,CAAA;AAEF,yEAAyE;AACzE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,WAAW,IAAI,cAAc,CAAA;IAC7B,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAA;IAC3C,IAAI,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAAA;IAChC,gDAAgD;IAChD,KAAK,IAAI,IAAI,CAAA;CACd;AAeD,wBAAgB,iBAAiB,IAAI,WAAW,CA4C/C;AAED,yEAAyE;AACzE,UAAU,eAAe;IACvB,aAAa,CACX,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,EACrC,GAAG,QAAQ,EAAE,OAAO,EAAE,GACrB,OAAO,CAAA;IACV,oBAAoB,CAClB,SAAS,EAAE,CAAC,aAAa,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,EACpD,WAAW,EAAE,MAAM,cAAc,GAChC,cAAc,CAAA;CAClB;AACD,UAAU,YAAY;IACpB,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CACvB;AACD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;IAC/B,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAA;CAC1B;AAOD;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,WAAW,GACjB,CAAC,KAAK,EAAE,eAAe,KAAK,OAAO,CAqCrC;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,uBAAuB,CAAC,WAAW,CAAC,GAC9C,uBAAuB,CAEzB"}