dsh-ntr 0.3.2 → 0.3.4

package/lib/client/activity-pill.js

@@ -0,0 +1,156 @@
+/**
+ * The composer dock's `x轮x步 · xx tok/s` pill on an ACP conversation.
+ *
+ * WHY SHADOW INSTEAD OF A SECOND PILL: the host's `ActivityPill` already states
+ * the two things this conversation has — turn/step counts and a whole-session
+ * decode speed — in the one place a speed belongs. Only its speed is wrong for
+ * ACP: the host divides the tokens a step emitted by `firstTokenTime →
+ * completedTime`, and that window contains every tool wait. Rendering a second
+ * speed beside it would leave two numbers on screen and no way to tell which
+ * is the honest one. So this module takes the host pill's own cell (`list` slot
+ * `conversation.composer.dock`, id `activity`) at a lower priority, renders the
+ * HOST's component, and hands it a patched `sessionStats` whose decode fields
+ * are the plugin's burst aggregate. Style, counts, dialog, aria and locale stay
+ * the host's; only the number changes.
+ *
+ * NON-ACP CONVERSATIONS PASS THROUGH. The shadow is installed only while the
+ * gate confirms the staged conversation runs the ACP preset, but a list entry
+ * is projected into EVERY session's composer. The wrapper therefore renders the
+ * host component with the ORIGINAL projection whenever `acpMode` is not
+ * affirmatively true, making the shadow visually indistinguishable from the
+ * shipped entry there.
+ *
+ * FAIL-OPEN IS STRUCTURAL: if the host entry, its inject face, its locale or
+ * its `performanceUsage` source is missing, no claim is created and the native
+ * pill stays exactly as shipped. If the host component rejects the patched
+ * projection, the slot's error boundary retires this entry and the native
+ * `activity` entry wins again. No CSS hiding and no DOM patching are involved.
+ */
+import { createElement, useMemo } from 'react';
+import { useUi } from "./acp-ui.js";
+import { createSeatClaim } from "./model-seat.js";
+export const DOCK_SLOT = 'conversation.composer.dock';
+export const ACTIVITY_ENTRY_ID = 'activity';
+/**
+ * The aggregate the dock should show: the sum of every ACP session backing this
+ * chat (the host pill's counts are whole-chat too), with a live `turn/metrics`
+ * entry preferred per session over its persisted row. `undefined` means "no
+ * measurable burst yet" — the wrapper then hides the speed instead of showing
+ * the host's tool-inclusive number.
+ */
+export function activityBurst(ui, dshSessionId) {
+    if (ui.chatSessionsFor !== dshSessionId)
+        return undefined;
+    let outputTokens = 0;
+    let burstMs = 0;
+    for (const row of ui.chatSessions) {
+        const measured = ui.burstStats[row.sessionId] ?? row.burst;
+        if (measured === undefined)
+            continue;
+        outputTokens += measured.outputTokens;
+        burstMs += measured.burstMs;
+    }
+    return outputTokens > 0 && burstMs > 0 ? { outputTokens, burstMs } : undefined;
+}
+/**
+ * Replace ONLY the decode half of the host's session stats.
+ *
+ * `decodeTokens` and `decodeMs` are the two fields the host's `decodeSpeed`
+ * reads (`decodeTokens / (decodeMs / 1000)`), so writing the plugin's aggregate
+ * there makes the host's own formatter, dialog row and aria label display the
+ * plugin's burst rate. Every other field — turns, steps, LLM/tool/TTFT — stays
+ * host-native. With no measurable burst the two decode fields are zeroed: the
+ * host then hides the speed (`decodeMs > 0` guard) while keeping the counts.
+ */
+export function patchedActivityStats(native, burst, acp) {
+    if (!acp || native === undefined)
+        return native;
+    if (burst !== undefined && burst.outputTokens > 0 && burst.burstMs > 0) {
+        return { ...native, decodeTokens: burst.outputTokens, decodeMs: burst.burstMs };
+    }
+    return { ...native, decodeTokens: 0, decodeMs: 0 };
+}
+function ActivityPillOccupant({ host: Host, ...props }) {
+    const ui = useUi(props.acp);
+    const dshSessionId = String(props.sessionId);
+    const acpMode = ui.acpMode[dshSessionId] === true;
+    const native = props.useProjection('sessionStats');
+    const burst = acpMode ? activityBurst(ui, dshSessionId) : undefined;
+    const stats = useMemo(() => patchedActivityStats(native, burst, acpMode), [native, burst?.outputTokens, burst?.burstMs, acpMode]);
+    // The current host pill reads exactly one projection. Returning `undefined`
+    // for another key keeps the wrapper from claiming support it has not been
+    // taught; a future host that asks for more will abdicate to the native entry.
+    const projection = useMemo(() => (key, selector) => {
+        if (key !== 'sessionStats')
+            return undefined;
+        return selector === undefined ? stats : selector(stats);
+    }, [stats]);
+    return createElement(Host, {
+        useChat: props.useChat,
+        useProjection: acpMode ? projection : props.useProjection,
+        usePerformanceUsage: props.usePerformanceUsage,
+        t: props.t,
+    });
+}
+function findHostActivity(slots) {
+    try {
+        if (slots.spec?.(DOCK_SLOT)?.kind !== 'list')
+            return undefined;
+        const heads = slots.entriesOfSlot?.(DOCK_SLOT) ?? [];
+        return heads.find(entry => entry.options?.id === ACTIVITY_ENTRY_ID);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Take the dock's `activity` cell for one ACP-mode spell.
+ *
+ * Returns `undefined` on any host shape this bundle cannot serve — an older
+ * host without the `activity` entry (0.1.5 ships `stats`), a slot kind change,
+ * a missing inject/locale, or no `performanceUsage` source. The native pill is
+ * then left untouched; that is the honest failure mode, not a hidden control.
+ */
+export function createActivityPillClaim(options) {
+    const host = findHostActivity(options.slots);
+    if (host === undefined
+        || host.component === undefined
+        || typeof host.inject !== 'function'
+        || typeof host.locale !== 'string'
+        || host.locale === '') {
+        options.onDiag?.('activity pill: host entry not available');
+        return undefined;
+    }
+    let performanceUsage;
+    try {
+        const face = host.inject();
+        performanceUsage = face?.hooks?.performanceUsage;
+    }
+    catch {
+        performanceUsage = undefined;
+    }
+    if (performanceUsage === undefined) {
+        options.onDiag?.('activity pill: host performance hook missing');
+        return undefined;
+    }
+    const Host = host.component;
+    return createSeatClaim({
+        slots: options.slots,
+        slotKey: DOCK_SLOT,
+        entryId: ACTIVITY_ENTRY_ID,
+        order: host.options?.order ?? 0,
+        locale: host.locale,
+        basePriority: -1,
+        occupant: () => (props) => createElement(ActivityPillOccupant, {
+            ...props,
+            host: Host,
+        }),
+        inject: (sessionId, actions) => ({
+            ...options.inject(sessionId, actions),
+            hooks: { performanceUsage },
+        }),
+        label: 'activity pill',
+        onDiag: options.onDiag,
+        maxClaims: options.maxClaims ?? 1,
+    });
+}

package/lib/client/branch-action.js

@@ -26,6 +26,22 @@ import { Tooltip } from '@deepseek-ai/dsh-client-ui-primitives';
 import * as primitives from '@deepseek-ai/dsh-client-ui-primitives';
 import { useUi } from "./acp-ui.js";
 import { forkStateOf } from "./store.js";
+/**
+ * Resolves the runtime's `sessions.fork` primitive, binding it to the service
+ * instance so that internal `this` accesses (such as `this.list.getSnapshot()`)
+ * resolve correctly when called through `face.fork(...)`.
+ * Returns `undefined` if the service or `fork` method is absent or not a function.
+ */
+export function resolveHostFork(sessionsService) {
+    try {
+        const sessions = sessionsService;
+        const fork = sessions?.fork;
+        return typeof fork === 'function' ? { fork: fork.bind(sessions) } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * The host's own branch-button icon, picked per host generation. The icon
  * exports MOVED between shipped hosts — desktop 0.2.1-rc.2 has

package/lib/client/index.js

@@ -14,7 +14,8 @@ import { AcpConversationView } from "./acp-view.js";
 import { AcpSettingsDialog } from "./settings-dialog.js";
 import { PermissionDock } from "./permission-dock.js";
 import { ReleasedBanner } from "./released-banner.js";
-import { AcpBranchAction } from "./branch-action.js";
+import { AcpBranchAction, resolveHostFork } from "./branch-action.js";
+import { createActivityPillClaim, DOCK_SLOT } from "./activity-pill.js";
 import { createModelSeatClaim, createPermissionSeatClaim, MODEL_SEAT_KEY, PERMISSION_SEAT_KEY, } from "./model-seat.js";
 import { acpModeFromPresetEvent, ACP_PRESET_ID, rowAgentPreset, stagedIsAcpMode, stagedSessionOf, } from "./acp-ui.js";
 import { createSlashIsolation, slashAcpVerdict } from "./slash-isolation.js";
@@ -146,8 +147,7 @@ export function apply(ctx) {
      */
     const hostFork = () => {
         try {
-            const fork = service('sessions')?.fork;
-            return typeof fork === 'function' ? { fork } : undefined;
+            return resolveHostFork(service('sessions'));
         }
         catch {
             return undefined;
@@ -375,6 +375,28 @@ export function apply(ctx) {
          * available yet.
          */
         let permissionClaim;
+        /**
+         * Claim on the dock's `activity` cell (`conversation.composer.dock`, id
+         * `activity`), held for the same ACP-mode spell as the two seats. The
+         * occupant renders the HOST's ActivityPill with the plugin's burst speed
+         * patched into its `sessionStats`; it is a list cell, so the claim is
+         * identified by id rather than by the slot's heads[0]. If the host shape is
+         * not one this bundle knows, no claim is created and the native pill stays.
+         */
+        let activityClaim;
+        let activityDiag = 'idle';
+        const noteActivityDiag = (line) => {
+            if (line === activityDiag)
+                return;
+            activityDiag = line;
+            // Success and the ordinary older-host "no activity entry" are silent; a
+            // shape mismatch or a lost registration must leave a breadcrumb. The ACP
+            // view has no line for this surface, and a missing speed fix is otherwise
+            // invisible.
+            if (!/failed|missing|taken|gave up|still held/.test(line))
+                return;
+            console.warn(`[dsh-ntr] ${line}`);
+        };
         /**
          * ACP-only auxiliary entries: the NTR view tab and the composer's context
          * ring. Unlike the two seats these are `list` slots with no visibility
@@ -474,6 +496,10 @@ export function apply(ctx) {
                 permissionClaim.release();
                 permissionClaim = undefined;
             }
+            if (activityClaim !== undefined) {
+                activityClaim.release();
+                activityClaim = undefined;
+            }
         };
         /**
          * Re-ask timer for the staged session, armed while the row is silent and a
@@ -616,6 +642,16 @@ export function apply(ctx) {
                 onDiag: (line) => { permissionSeatDiag = `staged ${staged.sessionId} · ${line}`; },
             });
             permissionClaim.sync();
+            // The dock's activity pill is a list CELL, not a whole slot: this claim
+            // shadows the shipped `activity` entry by id and renders it back with the
+            // plugin's burst speed. No host entry / inject / locale -> undefined and
+            // the native pill is untouched; the next evaluation retries.
+            activityClaim ??= createActivityPillClaim({
+                slots: ctx.slots,
+                inject: (sessionId) => chatFace(sessionId),
+                onDiag: noteActivityDiag,
+            });
+            activityClaim?.sync();
             // The tab and the occupancy ring have the same lifetime as the claims:
             // they exist only while this staged conversation is an ACP one, and a
             // stand-down disposes them (a standard conversation must not see an NTR
@@ -743,7 +779,7 @@ export function apply(ctx) {
         // retakes the cell only when it is actually holding something that is not
         // ours — so this is evidence-driven, not a poll.
         const stopCell = ctx.on('slots/changed', (...args) => {
-            if (args[0] !== MODEL_SEAT_KEY && args[0] !== PERMISSION_SEAT_KEY)
+            if (args[0] !== MODEL_SEAT_KEY && args[0] !== PERMISSION_SEAT_KEY && args[0] !== DOCK_SLOT)
                 return;
             runGate();
         });
@@ -771,6 +807,10 @@ export function apply(ctx) {
                 permissionClaim.release();
                 permissionClaim = undefined;
             }
+            if (activityClaim !== undefined) {
+                activityClaim.release();
+                activityClaim = undefined;
+            }
             store.noteSeatDiag('gate disposed');
             store.notePermissionSeatDiag('gate disposed');
         };

package/lib/client/model-seat.js

@@ -123,7 +123,7 @@ export const MAX_SEAT_CLAIMS = 4;
  * `entriesOfSlot` and performing bounded retakes if displaced by later registrations.
  */
 export function createSeatClaim(options) {
-    const { slots, slotKey, basePriority, occupant, inject } = options;
+    const { slots, slotKey, basePriority, occupant, inject, entryId } = options;
     const label = options.label ?? slotKey;
     const onDiag = options.onDiag;
     const maxClaims = options.maxClaims ?? MAX_SEAT_CLAIMS;
@@ -156,7 +156,10 @@ export function createSeatClaim(options) {
             return { declared: isDeclared, verified: false };
         try {
             const heads = slots.entriesOfSlot(slotKey) ?? [];
-            return { declared: isDeclared, verified: true, ...heads[0] === undefined ? {} : { entry: heads[0] } };
+            // A list slot projects one winner per id, so the cell this claim owns is
+            // the head WITH that id — not heads[0], which may be a sibling cell.
+            const entry = entryId === undefined ? heads[0] : heads.find(head => head.options?.id === entryId);
+            return { declared: isDeclared, verified: true, ...entry === undefined ? {} : { entry } };
         }
         catch {
             return { declared: isDeclared, verified: false };
@@ -176,6 +179,9 @@ export function createSeatClaim(options) {
         try {
             installed.push(slots.inject(slotKey, () => slots.register({
                 name: slotKey,
+                ...(entryId === undefined ? {} : { id: entryId }),
+                ...(options.order === undefined ? {} : { order: options.order }),
+                ...(options.locale === undefined ? {} : { locale: options.locale }),
                 priority: rank,
                 ...(inject ? { inject } : {}),
             }, component)));

package/lib/client/store.js

@@ -379,6 +379,7 @@ export class AcpStore {
         probingModels: {},
         probeErrors: {},
         chatSessions: [],
+        burstStats: {},
         tagHalo: { ...DEFAULT_TAG_HALO },
         approvalDeadlines: undefined,
         idleRelease: undefined,
@@ -1920,11 +1921,20 @@ export class AcpStore {
                 // entry would keep reading as a live session (the agent tag's halo
                 // breathes on `!released`) until some future turn re-reads the list.
                 const chatSessions = this.state.chatSessions.filter(s => s.sessionId !== event.sessionId);
+                // The burst aggregate belongs to this ACP session only; another
+                // session's entry must survive. Only patch when there was an entry.
+                const hadBurst = this.state.burstStats[event.sessionId] !== undefined;
+                let burstStats = this.state.burstStats;
+                if (hadBurst) {
+                    burstStats = { ...burstStats };
+                    delete burstStats[event.sessionId];
+                }
                 this.mutate({
                     sessions,
                     activeSessionId: active,
                     chatTranscripts: closedTranscripts,
                     ...(chatSessions.length !== this.state.chatSessions.length ? { chatSessions } : {}),
+                    ...(hadBurst ? { burstStats } : {}),
                     permissions: this.state.permissions.filter(p => p.sessionId !== event.sessionId),
                     ...(event.reason === 'agent-died'
                         ? this.logPatch('error', this.locale('会话因 agent 进程退出而终止', 'session ended: agent process died'), closingSession?.agentId)
@@ -2101,6 +2111,28 @@ export class AcpStore {
                 });
                 return Promise.resolve();
             }
+            case 'turn/metrics': {
+                // Plugin-side burst aggregate for one ACP session. A late LIVE frame
+                // must not regress a turn this page already saw finalized (frames can
+                // land out of order across a stream reconnect); any other frame writes
+                // the entry. Blocks / sessions stay untouched — this is a metric.
+                const prior = this.state.burstStats[event.sessionId];
+                if (event.final === false && prior !== undefined && prior.final === true && prior.turnId === event.turnId) {
+                    return Promise.resolve();
+                }
+                this.mutate({
+                    burstStats: {
+                        ...this.state.burstStats,
+                        [event.sessionId]: {
+                            outputTokens: event.outputTokens,
+                            burstMs: event.burstMs,
+                            turnId: event.turnId,
+                            final: event.final,
+                        },
+                    },
+                });
+                return Promise.resolve();
+            }
             case 'turn/start': {
                 this.openTurns.add(event.sessionId);
                 this.markWatchedRunning(event.sessionId, true);