dsh-ntr 0.3.2 → 0.3.3

package/src/client/activity-pill.tsx

@@ -0,0 +1,201 @@
+/**
+ * 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 type { ComponentType } from 'react'
+// Type-only: pulls the conversation SlotMap merge into this program.
+import type {} from '@deepseek-ai/dsh-client-ui-conversation/client'
+import type { SessionBurst } from '../protocol.ts'
+import { useUi } from './acp-ui.tsx'
+import type { AcpStore, UiState } from './store.ts'
+import { createSeatClaim } from './model-seat.tsx'
+import type { ModelSeatClaim, SeatEntry, SeatSlots } from './model-seat.tsx'
+
+export const DOCK_SLOT = 'conversation.composer.dock'
+export const ACTIVITY_ENTRY_ID = 'activity'
+
+type ActivityProjection = (key: string, selector?: (value: unknown) => unknown) => unknown
+type ActivityPerformanceHook = (selector?: (value: unknown) => unknown) => unknown
+type ActivityTranslate = (key: string, params?: Record<string, unknown>) => string
+
+/** The standard kit + injected face the shadow renders the host component with. */
+export interface ActivityPillHostProps {
+  sessionId: string
+  useChat: unknown
+  useProjection: ActivityProjection
+  usePerformanceUsage: ActivityPerformanceHook
+  t?: ActivityTranslate
+  acp: AcpStore
+}
+
+interface OccupantProps extends ActivityPillHostProps {
+  host: ComponentType<Record<string, unknown>>
+}
+
+/**
+ * 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: Pick<UiState, 'chatSessions' | 'chatSessionsFor' | 'burstStats'>,
+  dshSessionId: string,
+): SessionBurst | undefined {
+  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: Record<string, unknown> | undefined,
+  burst: SessionBurst | undefined,
+  acp: boolean,
+): Record<string, unknown> | undefined {
+  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 }: OccupantProps) {
+  const ui = useUi(props.acp)
+  const dshSessionId = String(props.sessionId)
+  const acpMode = ui.acpMode[dshSessionId] === true
+  const native = props.useProjection('sessionStats') as Record<string, unknown> | undefined
+  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<ActivityProjection>(
+    () => (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: SeatSlots): SeatEntry | undefined {
+  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
+  }
+}
+
+export interface ActivityPillClaimOptions {
+  slots: SeatSlots
+  /** Session-scoped face factory (the gate's `chatFace`). */
+  inject(sessionId: unknown, actions?: unknown): unknown
+  onDiag?(line: string): void
+  maxClaims?: number
+}
+
+/**
+ * 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: ActivityPillClaimOptions): ModelSeatClaim | undefined {
+  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: unknown
+  try {
+    const face = host.inject() as { hooks?: { performanceUsage?: unknown } } | undefined
+    performanceUsage = face?.hooks?.performanceUsage
+  } catch {
+    performanceUsage = undefined
+  }
+  if (performanceUsage === undefined) {
+    options.onDiag?.('activity pill: host performance hook missing')
+    return undefined
+  }
+  const Host = host.component as ComponentType<Record<string, unknown>>
+  return createSeatClaim({
+    slots: options.slots,
+    slotKey: DOCK_SLOT,
+    entryId: ACTIVITY_ENTRY_ID,
+    order: host.options?.order ?? 0,
+    locale: host.locale,
+    basePriority: -1,
+    occupant: () => (props: Record<string, unknown>) => createElement(ActivityPillOccupant, {
+      ...props,
+      host: Host,
+    } as unknown as OccupantProps),
+    inject: (sessionId, actions) => ({
+      ...(options.inject(sessionId, actions) as Record<string, unknown>),
+      hooks: { performanceUsage },
+    }),
+    label: 'activity pill',
+    onDiag: options.onDiag,
+    maxClaims: options.maxClaims ?? 1,
+  })
+}

package/src/client/branch-action.tsx

@@ -26,10 +26,28 @@ import type { ComponentType } from 'react'
 import { Tooltip } from '@deepseek-ai/dsh-client-ui-primitives'
 import * as primitives from '@deepseek-ai/dsh-client-ui-primitives'
 import { useUi } from './acp-ui.tsx'
-import type { AcpChatInjected } from './acp-ui.tsx'
+import type { AcpChatInjected, AcpHostForkFace } from './acp-ui.tsx'
 import { forkStateOf } from './store.ts'
 import type { ChatForkState } from './store.ts'
 
+/**
+ * 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: unknown): AcpHostForkFace | undefined {
+  try {
+    const sessions = sessionsService as {
+      fork?: (options: { sessionId: string; increaseTitle?: boolean }) => Promise<unknown>
+    } | null | undefined
+    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/src/client/index.tsx

@@ -26,7 +26,8 @@ import { AcpConversationView } from './acp-view.tsx'
 import { AcpSettingsDialog } from './settings-dialog.tsx'
 import { PermissionDock } from './permission-dock.tsx'
 import { ReleasedBanner } from './released-banner.tsx'
-import { AcpBranchAction } from './branch-action.tsx'
+import { AcpBranchAction, resolveHostFork } from './branch-action.tsx'
+import { createActivityPillClaim, DOCK_SLOT } from './activity-pill.tsx'
 import {
   createModelSeatClaim,
   createPermissionSeatClaim,
@@ -241,8 +242,7 @@ export function apply(ctx: Context): void {
    */
   const hostFork = (): AcpHostForkFace | undefined => {
     try {
-      const fork = service<StructuralServices['sessions']>('sessions')?.fork
-      return typeof fork === 'function' ? { fork } : undefined
+      return resolveHostFork(service<StructuralServices['sessions']>('sessions'))
     } catch {
       return undefined
     }
@@ -482,6 +482,26 @@ export function apply(ctx: Context): void {
      * available yet.
      */
     let permissionClaim: ModelSeatClaim | undefined
+    /**
+     * 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: ModelSeatClaim | undefined
+    let activityDiag = 'idle'
+    const noteActivityDiag = (line: string): void => {
+      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
@@ -567,6 +587,7 @@ export function apply(ctx: Context): void {
       releaseAuxEntries()
       if (claim !== undefined) { claim.release(); claim = undefined }
       if (permissionClaim !== undefined) { 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
@@ -706,6 +727,16 @@ export function apply(ctx: Context): void {
         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 as unknown as SeatSlots,
+        inject: (sessionId: unknown) => 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
@@ -826,7 +857,7 @@ export function apply(ctx: Context): void {
     // 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: unknown[]) => {
-      if (args[0] !== MODEL_SEAT_KEY && args[0] !== PERMISSION_SEAT_KEY) return
+      if (args[0] !== MODEL_SEAT_KEY && args[0] !== PERMISSION_SEAT_KEY && args[0] !== DOCK_SLOT) return
       runGate()
     })
     // Late services: the runtime's session list normally exists before this
@@ -847,6 +878,7 @@ export function apply(ctx: Context): void {
       releaseAuxEntries()
       if (claim !== undefined) { claim.release(); claim = undefined }
       if (permissionClaim !== undefined) { permissionClaim.release(); permissionClaim = undefined }
+      if (activityClaim !== undefined) { activityClaim.release(); activityClaim = undefined }
       store.noteSeatDiag('gate disposed')
       store.notePermissionSeatDiag('gate disposed')
     }

package/src/client/model-seat.tsx

@@ -128,7 +128,11 @@ export const MAX_SEAT_CLAIMS = 4
 /** One live entry in the cell, narrowed to what the claim reads. */
 export interface SeatEntry {
   component?: unknown
-  options?: { priority?: number; registrant?: string }
+  options?: { priority?: number; registrant?: string; id?: string; order?: number }
+  /** Entry-owned inject face; needed when the claim reuses a shipped occupant. */
+  inject?: (...args: unknown[]) => unknown
+  /** Locale namespace the occupant's `t` is bound to; needed for the same reuse. */
+  locale?: string
 }
 
 /** The slot-registry face this module uses (structural: the registry is not a dependency of this bundle). */
@@ -148,6 +152,12 @@ export interface SeatSlots {
  */
 export interface SeatRegisterOptions {
   name: string
+  /** List-slot cell to shadow; omitted for single/keyed registers. */
+  id?: string
+  /** Display position within the list; only meaningful with `id`. */
+  order?: number
+  /** Locale namespace the occupant's `t` is bound to. */
+  locale?: string
   priority?: number
   /**
    * The session-scoped face factory the renderer calls with the scope binding's
@@ -227,6 +237,15 @@ export interface PermissionSeatClaimOptions {
 export interface SeatClaimOptions {
   slots: SeatSlots
   slotKey: string
+  /**
+   * List-slot cell id to hold. Omitted for single/keyed seats; a list slot
+   * needs it because its winner view is one entry PER id, not one per slot.
+   */
+  entryId?: string
+  /** Display order for the installed list entry (same cell, so usually the shipped order). */
+  order?: number
+  /** Locale namespace the installed occupant resolves `t` against. */
+  locale?: string
   basePriority: number
   occupant(): unknown
   inject?(sessionId: unknown, actions?: unknown): unknown
@@ -265,7 +284,7 @@ interface CellView {
  * `entriesOfSlot` and performing bounded retakes if displaced by later registrations.
  */
 export function createSeatClaim(options: SeatClaimOptions): ModelSeatClaim {
-  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
@@ -293,7 +312,10 @@ export function createSeatClaim(options: SeatClaimOptions): ModelSeatClaim {
     if (typeof slots.entriesOfSlot !== 'function') 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 }
     }
@@ -312,6 +334,9 @@ export function createSeatClaim(options: SeatClaimOptions): ModelSeatClaim {
     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/src/client/store.ts

@@ -268,6 +268,11 @@ export interface UiState {
   chatSessions: ChatSessionView[]
   /** The DSH chat session id {@link chatSessions} was loaded for. */
   chatSessionsFor?: string
+  /**
+   * Live burst aggregate per ACP session id, from `turn/metrics`. Absent means
+   * no measured burst yet; a row's persisted `burst` is the reload seed.
+   */
+  burstStats: Record<string, { outputTokens: number; burstMs: number; turnId: string; final: boolean }>
   /**
    * The agent tag's halo preference (settings-editable display choice). The
    * tag reads it per render; the host answer in `resync` is the authority and
@@ -687,6 +692,7 @@ export class AcpStore {
     probingModels: {},
     probeErrors: {},
     chatSessions: [],
+    burstStats: {},
     tagHalo: { ...DEFAULT_TAG_HALO },
     approvalDeadlines: undefined,
     idleRelease: undefined,
@@ -2234,11 +2240,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)
@@ -2425,6 +2440,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)