dsh-ntr 0.3.0 → 0.3.2

package/src/client/acp-ui.tsx

@@ -78,6 +78,24 @@ export interface AcpChatInjected {
   acp: AcpStore
   /** Resolve the session's command/projection face; `undefined` before the session materializes. */
   faceFor(sessionId: string): AcpSessionFace | undefined
+  /**
+   * The runtime's `sessions.fork` face (the host's own branching primitive,
+   * resolved structurally per call); `undefined` when the host half lacks it —
+   * the branch button then renders disabled (`hostUnavailable`), never hidden.
+   */
+  hostFork?: () => AcpHostForkFace | undefined
+  /** The workspace's `openSession` face (the branch click's final step). */
+  openSession?: (sessionId: string) => void
+}
+
+/** The slice of the client runtime's session service the branch button needs. */
+export interface AcpHostForkFace {
+  /**
+   * Fork the DSH session tree at the latest completed turn. Resolves the CHILD
+   * session id; the host owns the cut-point snapping, history copy, `(1)`
+   * title and workspace attribution — the plugin rewrites none of it.
+   */
+  fork(options: { sessionId: string; increaseTitle?: boolean }): Promise<unknown>
 }
 
 // ---- The session standard kit (framework-provided, declared structurally) ----
@@ -305,6 +323,13 @@ export interface AcpStagedSession {
 /**
  * Which session the composer is currently staged on.
  *
+ * The renderer's own current scope binding is the first answer when the caller
+ * passes it (`currentSessionId`, read from `uiSession.adapter.current` in the
+ * browser entry): that is the exact session the host has selected, while the
+ * list can retain more than one row in a multi-view layout. Falling back to
+ * the list is still required — a host without that scope adapter, and the old
+ * snapshot shape below, have no better source.
+ *
  * Old runtimes answer from `snapshot.current` (with `currentAddress` as the
  * subagent marker). rc.2 has no `current`: the staged session is the row the
  * main view retains (`retainedBy.mainView > 0`) — the exact rule
@@ -312,8 +337,16 @@ export interface AcpStagedSession {
  * row with `origin === "subagent"` is an addressed subagent route. `undefined`
  * when nothing is staged yet (the list has not loaded, or no row holds the main
  * view): callers must stand down rather than guess.
+ *
+ * A current id the list has no row for is ALSO `undefined`: the selection may
+ * be a subagent address, and guessing "not a subagent" there would let the
+ * gate install ACP chrome on a route the plugin must not drive. The next list
+ * notification retries.
  */
-export function stagedSessionOf(snapshot: AcpSessionsSnapshot | undefined): AcpStagedSession | undefined {
+export function stagedSessionOf(
+  snapshot: AcpSessionsSnapshot | undefined,
+  currentSessionId?: string,
+): AcpStagedSession | undefined {
   if (snapshot === undefined) return undefined
   if (snapshot.current !== undefined) {
     return {
@@ -323,6 +356,11 @@ export function stagedSessionOf(snapshot: AcpSessionsSnapshot | undefined): AcpS
     }
   }
   const byId = snapshot.byId ?? {}
+  if (currentSessionId !== undefined) {
+    const row = byId[currentSessionId]
+    if (row === undefined) return undefined
+    return { sessionId: currentSessionId, row, subagent: row.origin === 'subagent' }
+  }
   // Candidate set is `byId`, NOT `ids`. In rc.2 the controller projects
   // `ids` from the host list only, then appends two fallback families to
   // `byId` without an `ids` entry: subagent-catalog children of a projected
@@ -349,8 +387,9 @@ export function stagedSessionOf(snapshot: AcpSessionsSnapshot | undefined): AcpS
 export function stagedIsAcpMode(
   snapshot: AcpSessionsSnapshot | undefined,
   acpMode?: (sessionId: string) => boolean | undefined,
+  currentSessionId?: string,
 ): boolean {
-  const staged = stagedSessionOf(snapshot)
+  const staged = stagedSessionOf(snapshot, currentSessionId)
   if (staged === undefined || staged.subagent) return false
   const listed = rowAgentPreset(staged.row)
   if (listed !== undefined) return listed === ACP_PRESET_ID
@@ -795,6 +834,15 @@ const STYLE = `
 .ntr-acp-chip.is-static:hover { background: var(--dsw-alias-bg-layer-2, #f3f4f6); }
 .ntr-acp-chip.is-active { border-color: var(--dsw-alias-state-business-primary, #2563eb); color: var(--dsw-alias-state-business-primary, #2563eb); background: color-mix(in srgb, var(--dsw-alias-state-business-primary, #2563eb) 10%, transparent); }
 .ntr-acp-chip-label { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+/* Composer context-occupancy ring (conversation.composer.dock,
+   context-meter.tsx): the agent's own prompt-side used/size in the host
+   ContextMeter's ring geometry, pill and tokens, so it reads as that meter's
+   sibling in the bottom info row. Gated inside the component; absent until the
+   agent reports a sample. */
+.ntr-acp-meter { display: inline-flex; align-items: center; gap: 6px; padding: 1px 8px; border-radius: 24px; color: var(--dsw-alias-label-tertiary, #9ca3af); font-family: inherit; font-size: var(--dsh-content-font-size-secondary, 13px); font-variant-numeric: tabular-nums; line-height: calc(20px + var(--dsh-content-font-delta-secondary, 0px)); white-space: nowrap; flex: none; }
+.ntr-acp-meter-track { fill: none; stroke: var(--dsw-alias-border-l3, #e5e7eb); stroke-width: 2px; }
+.ntr-acp-meter-fill { fill: none; stroke: var(--dsw-alias-label-tertiary, #9ca3af); stroke-width: 2px; stroke-linecap: round; }
+.ntr-acp-meter-percent { color: inherit; }
 /* The lock hand-off (src/client/agent-lock-anim.ts): the outgoing agent base
    breaks into debris for 460ms, then the edge tag condenses from the same
    particles. Both halves read one shared clock in that module; these durations
@@ -970,6 +1018,79 @@ const STYLE = `
 .ntr-permission-option:focus-visible, .ntr-permission-cancel:focus-visible { outline: 2px solid var(--dsw-alias-state-business-primary, #2563eb); outline-offset: 2px; }
 .ntr-permission-cancel { margin-left: auto; color: var(--dsw-alias-label-secondary, #6b7280); }
 .ntr-permission-error { padding: 4px 8px; border-radius: 6px; background: color-mix(in srgb, var(--dsw-alias-state-error-primary, #b91c1c) 12%, transparent); color: var(--dsw-alias-state-error-primary, #b91c1c); font-size: 11px; word-break: break-word; }
+/* ---- Released-session banner (conversation.input.dock, released-banner.tsx) ---- */
+/* Same composer-width formula as the permission dock above: the slot spans
+   the column, the card lines up with the input box. One row of state + one
+   action; the error pins under it, beside the button that failed. */
+.ntr-released-banner {
+  box-sizing: border-box;
+  width: calc(100% - var(--dsh-composer-side-clearance, 16px) - var(--dsh-composer-side-clearance, 16px));
+  max-width: var(--dsh-composer-card-max-width, 920px);
+  margin: 0 auto;
+  display: flex; flex-direction: column; gap: 6px;
+  padding: 8px 12px;
+  border: 1px solid var(--dsw-alias-border-l2, #d1d5db);
+  border-left: 3px solid var(--dsw-alias-state-warn-primary, #d97706);
+  border-radius: 10px;
+  background: var(--dsw-alias-bg-layer-1, #fff);
+  font-size: 12px; line-height: 1.5;
+}
+.ntr-released-banner-row { display: flex; align-items: center; gap: 10px; min-width: 0; }
+.ntr-released-banner-text { display: flex; flex-direction: column; gap: 2px; flex: 1; min-width: 0; }
+.ntr-released-banner-title { font-weight: 600; }
+.ntr-released-banner-body { color: var(--dsw-alias-label-secondary, #6b7280); }
+.ntr-released-banner .ntr-acp-more { flex: none; white-space: nowrap; }
+/* ---- NTR message actions (conversation.chat.assistant-actions) ---- */
+/* In an NTR conversation the host's like / dislike / branch icons are the
+   plugin's business (the agent decides its own feedback surface, and the
+   host's branch would fork a conversation the agent does not remember). The
+   three icons hide under the html[data-ntr-acp] scope marker, by their
+   LOCALIZED aria-labels — the only stable handles the host leaves (its button
+   classes are CSS-module hashes and there is no data-* hook). Hiding the
+   button is the WHOLE job: the host's Tooltip clones its child without a
+   wrapper element, so there is no container left behind to plug the row gap
+   — and any :has(> button…) rule would match the actions row itself (and the
+   list slot's shared display:contents anchor), hiding the entire row. The
+   :not([data-ntr-branch]) exemption is the pass our OWN button carries —
+   same label, same row. Known fragility: a host copy change or a third
+   language un-hides the icons; the entry probes the labels once per page and
+   warns in the console. */
+html[data-ntr-acp] [data-turn-tail] button[aria-label="在新对话中分支"]:not([data-ntr-branch]),
+html[data-ntr-acp] [data-turn-tail] button[aria-label="Branch into a new conversation"]:not([data-ntr-branch]),
+html[data-ntr-acp] [data-turn-tail] button[aria-label="好的回答"],
+html[data-ntr-acp] [data-turn-tail] button[aria-label="有问题的回答"],
+html[data-ntr-acp] [data-turn-tail] button[aria-label="取消标记"],
+html[data-ntr-acp] [data-turn-tail] button[aria-label="Good response"],
+html[data-ntr-acp] [data-turn-tail] button[aria-label="Bad response"],
+html[data-ntr-acp] [data-turn-tail] button[aria-label="Remove rating"] {
+  display: none !important;
+}
+/* The plugin's own branch button, dressed exactly like the host's .action
+   class (the values are copied from the host's compiled CSS, token colors
+   only). It rides the same actions row, so the host's row gap, font-delta
+   sizing and the [data-actions-reveal] hover rules already govern it. */
+.ntr-branch-action {
+  width: calc(28px + var(--dsh-content-font-delta, 0px));
+  height: calc(28px + var(--dsh-content-font-delta, 0px));
+  color: var(--dsw-alias-label-tertiary, #9ca3af);
+  cursor: pointer;
+  background: none;
+  border: none;
+  border-radius: 28px;
+  justify-content: center;
+  align-items: center;
+  padding: 6px;
+  display: inline-flex;
+}
+.ntr-branch-action svg { width: calc(15px + var(--dsh-content-font-delta, 0px)); height: calc(15px + var(--dsh-content-font-delta, 0px)); }
+.ntr-branch-action:hover { background: var(--dsw-alias-interactive-bg-hover, #0000000d); color: var(--dsw-alias-label-secondary, #6b7280); }
+.ntr-branch-action[data-unavailable] { cursor: default; opacity: 0.4; }
+.ntr-branch-action[data-unavailable]:hover { color: var(--dsw-alias-label-tertiary, #9ca3af); background: none; }
+.ntr-branch-action:focus-visible { outline: 2px solid var(--dsw-alias-state-business-primary, #2563eb); outline-offset: 2px; }
+/* A failed branch click, pinned in the row beside the button (the conversation
+   surface of the settings banner the store also writes). One line, truncated;
+   the full text is the title tooltip and the banner. */
+.ntr-branch-error { max-width: 260px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: 11px; line-height: calc(28px + var(--dsh-content-font-delta, 0px)); color: var(--dsw-alias-state-error-primary, #b91c1c); }
 /* ---- NTR settings dialog (shell.overlay) ---- */
 /* Frame-wide surface opened from the agent base's empty-roster menu. The
    overlay layer itself is click-through, so the layer opts back in and blocks

package/src/client/acp-view.tsx

@@ -19,7 +19,7 @@ import type {} from '@deepseek-ai/dsh-client-ui-conversation/client'
 import { ensureAcpStyle, useUi } from './acp-ui.tsx'
 import type { AcpChatInjected } from './acp-ui.tsx'
 import type { Block, ChatTranscript } from './store.ts'
-import type { AgentView, ChatSessionView } from '../protocol.ts'
+import type { AgentView, ChatSessionView, SessionView } from '../protocol.ts'
 
 /** Props of the ACP view entry (injected face + the frame's session id). */
 export interface AcpViewProps extends AcpChatInjected {
@@ -338,6 +338,20 @@ function boundSession(list: readonly ChatSessionView[]): ChatSessionView | undef
   return list.find(session => !session.released) ?? list[0]
 }
 
+/**
+ * Whether an empty stream means "history exists but is not shown yet": the
+ * record was restored from disk after a host restart (the agent's replay has
+ * not landed), or a resume cleared the buffer ahead of the replay. The view
+ * then promises the replay instead of claiming the conversation never
+ * happened — "还没有消息" to someone whose chat plane still shows yesterday's
+ * turns is exactly the kind of contradiction this file's copy rules exist to
+ * prevent. In-memory released sessions keep their buffer, so this only fires
+ * when the buffer really is absent.
+ */
+export function historyAwaitsReplay(session: Pick<SessionView, 'released' | 'hasHistory'>): boolean {
+  return session.released === true && session.hasHistory === true
+}
+
 /**
  * Everything the view can read that says "this conversation is set up on an
  * agent": a live or parked ACP session, the host's binding (`session/chat-list`'s
@@ -467,10 +481,15 @@ export function AcpConversationView(props: AcpViewProps) {
     node.scrollTop = node.scrollHeight
   }, [blockCount, tail])
 
+  // The gate installs the NTR tab only for a conversation it has confirmed as
+  // ACP; a stale release must not paint NTR content into an ordinary one for a
+  // frame, so anything but the affirmative verdict renders nothing.
+  if (ui.acpMode[sessionId] !== true) return null
+
   if (transcript === undefined) {
-    // `ui.acpMode[sessionId]` is `undefined` until the host has answered for
-    // this conversation; the copy builder reads that as "unknown" and says
-    // nothing rather than guessing.
+    // The guard above makes this a confirmed ACP conversation; the copy
+    // builder keeps its "unknown" branch for callers that only read facts
+    // (`docs` and tests), not for this rendered surface.
     const empty = acpEmptyCopy({
       bound: boundAgent,
       hasAgents: ui.agents.length > 0,
@@ -547,7 +566,13 @@ export function AcpConversationView(props: AcpViewProps) {
         }}
       >
         {transcript.blocks.length === 0
-          ? <div className="ntr-acp-empty-hint">{t('还没有消息：在下面的输入框里发给它。', 'Nothing yet — send it a message below.')}</div>
+          ? (
+            <div className="ntr-acp-empty-hint">
+              {historyAwaitsReplay(session)
+                ? t('进程已释放；历史将在恢复后回放显示。', 'The process is released — history replays once it is restored.')
+                : t('还没有消息：在下面的输入框里发给它。', 'Nothing yet — send it a message below.')}
+            </div>
+          )
           : transcript.blocks.map((block, index) => <BlockView key={index} block={block} label={acp.label} localeRev={ui.localeRev} />)}
       </div>
     </div>

package/src/client/branch-action.tsx

@@ -0,0 +1,160 @@
+/**
+ * The NTR branch button (slot `conversation.chat.assistant-actions`): in an
+ * ACP conversation this is the ONLY branch entry — the host's like / dislike /
+
+ * branch icons are hidden under `html[data-ntr-acp]` (see acp-ui.tsx), and
+ * this button takes the host branch's place with the same icon, size and
+ * row position (order 20, after the hidden feedback entry's order 10).
+ *
+ * Clicking runs the fixed two-stage branch: the HOST forks the DSH session
+ * tree first (`sessions.fork`, structurally resolved), then the plugin adopts
+ * the ACP side (`session/chat-fork-adopt` → the agent's own `session/fork`),
+ * so the child conversation's agent actually remembers the parent context —
+ * see the NTR message-actions plan, §D5/§D7.
+ *
+ * Availability is the store's `forkStateOf` six-state mapping over facts the
+ * button never derives itself: the host's per-row `fork` verdict
+ * (`session/chat-list`), the SSE running flag, the host-fork structural probe,
+ * and the DOM tail verdict. The tail check reads the host's OWN
+ * `[data-turn-tail]` marker (`data-actions-reveal === "always"` = the latest
+ * completed turn) and fails CLOSED: a missing marker disables the button
+ * rather than risking a fork cut at a point the user is not looking at.
+ */
+
+import { useLayoutEffect, useRef, useState } from 'react'
+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 { forkStateOf } from './store.ts'
+import type { ChatForkState } from './store.ts'
+
+/**
+ * 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
+ * `IconBranchOutlineRegular` / `…Medium` but NOT `…16`, newer packages export
+ * `…16` — and a hard import of one name compiles to a plain property read
+ * (`primitives.IconBranchOutline16`), so the missing export is `undefined`
+ * and `<undefined />` throws "Element type is invalid". The slot's error
+ * boundary then abdicates the whole entry: no button, no tooltip, nothing in
+ * any log — the exact silent disappearance this picker exists to prevent.
+ * Rendering the button never depends on the icon: with all three absent the
+ * click still works, only the 28px glyph is missing.
+ */
+export function branchIconOf(source: Record<string, unknown>): ComponentType<Record<string, never>> | undefined {
+  return (source.IconBranchOutline16 ?? source.IconBranchOutlineRegular ?? source.IconBranchOutlineMedium) as
+    | ComponentType<Record<string, never>>
+    | undefined
+}
+const BranchIcon = branchIconOf(primitives as unknown as Record<string, unknown>)
+/** What the label reads for each state (zh / en pairs, per the plan's §D4). */
+function tooltipFor(state: ChatForkState, label: (zh: string, en: string) => string): string {
+  switch (state) {
+    case 'ready': return label('在新对话中分支', 'Branch into a new conversation')
+    case 'unsupported': return label('该 agent 不支持原生分叉', 'This agent cannot fork natively')
+    case 'released': return label('会话已挂起，先发一条消息恢复再分叉', 'Resume this session before branching')
+    case 'busy': return label('当前轮次结束后才能分叉', 'Wait for the current turn to finish')
+    case 'notTail': return label('仅可从已完成轮次的最后一条消息分支', 'Available only on the last message of a completed turn')
+    case 'hostUnavailable': return label('当前宿主不提供分叉', 'This host does not support branching')
+  }
+}
+
+export function AcpBranchAction(props: AcpChatInjected & { sessionId: string }) {
+  const ui = useUi(props.acp)
+  const buttonRef = useRef<HTMLButtonElement>(null)
+  const [pending, setPending] = useState(false)
+  /**
+   * The host's own availability verdict for the turn tail this button sits
+   * in, re-read after EVERY render (no dep array): the marker flips without
+   * any store event of our own when a new turn lands, and before the first
+   * layout pass the ref is not attached yet. Two facts, both the HOST's:
+   * `data-actions-reveal === "always"` (this tail is the latest turn and
+   * completed) and the host branch button's own `data-unavailable` (a stricter
+   * gate — a tail whose final node is not the transcript's last, or a turn
+   * with later nodes, is one the HOST refuses to fork). Reading the host's
+   * button keeps the plugin's readiness a SUBSET of the host's: wherever the
+   * two would disagree about the cut point, the plugin button disables, and
+   * the remaining clicks fork at the same latest-completed prefix the host
+   * would (the tail marked `always` is the latest completed turn, which is
+   * exactly where the host's fallback `atSeq` lands).
+   */
+  const [tailReady, setTailReady] = useState(false)
+  useLayoutEffect(() => {
+    const tail = buttonRef.current?.closest('[data-turn-tail]')
+    const hostBranch = tail?.querySelector('button[aria-label="在新对话中分支"]:not([data-ntr-branch]), button[aria-label="Branch into a new conversation"]:not([data-ntr-branch])')
+    setTailReady(
+      tail?.getAttribute('data-actions-reveal') === 'always'
+      && hostBranch?.hasAttribute('data-unavailable') !== true,
+    )
+  })
+  /**
+   * The click's local failure line. The store ALSO flashes the same reason
+   * into the settings banner, but the user is HERE — without this row the
+   * click would "do nothing" visibly, the exact invisibility the permission
+   * dock's pinned-error pattern exists to prevent.
+   */
+  const [failure, setFailure] = useState<string | undefined>(undefined)
+
+  // ACP conversations only, fail-closed: the slot renders in EVERY
+  // conversation, and the confirmed verdict (`session/chat-list`, folded from
+  // the runtime row by the seat gate) is the same fact the scope marker and
+  // the CSS hiding run on. `undefined` renders nothing. The row guard keeps
+  // the button from rendering on a conversation whose rows have not landed —
+  // without it a rc.2-style host (verdict folded from the row preset, ahead
+  // of the list read) would show a disabled button flashing the `released`
+  // tooltip for a perfectly live conversation.
+  if (ui.acpMode[props.sessionId] !== true) return null
+  if (ui.chatSessionsFor !== props.sessionId) return null
+
+  const row = ui.chatSessionsFor === props.sessionId ? ui.chatSessions[0] : undefined
+  const forkFace = props.hostFork?.()
+  // The row's `running` only refreshes on a chat-list read, so a turn that
+  // just started would leave it stale for seconds; the SSE-facing session
+  // view is the live copy of the same fact.
+  const liveRunning = row !== undefined && ui.sessions.some(s => s.sessionId === row.sessionId && s.running)
+  const state = forkStateOf(row, forkFace !== undefined, tailReady, liveRunning)
+  const disabled = state !== 'ready' || pending
+  const branchLabel = props.acp.label('在新对话中分支', 'Branch into a new conversation')
+
+  const onClick = (): void => {
+    if (state !== 'ready' || pending) return
+    setPending(true)
+    setFailure(undefined)
+    void props.acp.forkChatSession(props.sessionId, sessionId => {
+      // Re-resolved per click: a face that vanished between render and click
+      // fails loudly in the notice banner and the local line instead of
+      // throwing here.
+      const face = props.hostFork?.()
+      if (face === undefined) throw new Error('acp: host fork service is gone')
+      return face.fork({ sessionId, increaseTitle: true })
+    }).then(outcome => {
+      // A failure opens NOTHING (an unadopted child is a copied-history
+      // conversation the user did not ask to visit) and says why, right here.
+      if ('childId' in outcome) props.openSession?.(outcome.childId)
+      else setFailure(outcome.failure)
+    }).finally(() => { setPending(false) })
+  }
+
+  return (
+    <>
+      <Tooltip label={tooltipFor(state, props.acp.label)} side="bottom">
+        <button
+          ref={buttonRef}
+          type="button"
+          className="ntr-branch-action"
+          aria-label={branchLabel}
+          aria-disabled={disabled || undefined}
+          data-ntr-branch=""
+          data-unavailable={disabled || undefined}
+          onClick={disabled ? undefined : onClick}
+        >
+          {BranchIcon === undefined ? null : <BranchIcon />}
+        </button>
+      </Tooltip>
+      {failure !== undefined && (
+        <span className="ntr-branch-error" role="alert" title={failure}>{failure}</span>
+      )}
+    </>
+  )
+}

package/src/client/composer-mode.tsx

@@ -65,6 +65,44 @@ export function agentModeTitle(agentId: string | undefined, acp: AcpStore): stri
   )
 }
 
+/**
+ * Whether this conversation is one the agent-mode control may serve.
+ *
+ * An EXPLICIT non-ACP verdict outranks a lingering session row: switching a
+ * conversation off the NTR preset does not close its ACP session, so "a row
+ * exists" alone would keep this control on an ordinary conversation — the same
+ * precedence the agent tag, the context ring and the released banner already
+ * apply. Only while the host has not answered (`undefined`) does a bound
+ * session count as proof, which is what keeps the control available before the
+ * host's first `session/chat-list` answer lands.
+ */
+export function agentModeVisible(
+  acpMode: boolean | undefined,
+  hasBoundSession: boolean,
+): boolean {
+  if (acpMode === false) return false
+  return acpMode === true || hasBoundSession
+}
+
+/**
+ * The mode the select shows as in force.
+ *
+ * A LIVE session is the authority (it is what the agent runs right now). A
+ * RELEASED row only describes the mode the agent was parked ON, so a newer
+ * pick — which `applyChatChoice` will apply on the next resume — outranks it
+ * (and the parked row still beats the catalog default). Same precedence as
+ * the model and thought level in `describeRoute`: a pre-switch on a parked
+ * session must be visible or the control reads as dead.
+ */
+export function modeInForce(
+  target: { released?: boolean; modes?: { currentModeId?: string } } | undefined,
+  persisted: string | undefined,
+  fallback?: string,
+): string {
+  const live = target !== undefined && target.released !== true ? target.modes?.currentModeId : undefined
+  return live ?? persisted ?? target?.modes?.currentModeId ?? fallback ?? ''
+}
+
 export function AcpComposerMode({ acp, sessionId, useSession }: ComposerModeProps) {
   const ui = useUi(acp)
   const dshSessionId = String(sessionId)
@@ -85,9 +123,10 @@ export function AcpComposerMode({ acp, sessionId, useSession }: ComposerModeProp
   // unconditionally), so it must gate itself. The `defaultAgent` fallback below
   // would otherwise put an ACP mode select into ORDINARY conversations: the
   // agent id is plugin-global, so "an agent is configured" is not the same
-  // question as "this conversation is served by one". A live session is itself
-  // proof; otherwise it is the same host verdict the seat gate reads.
-  const isAcp = target !== undefined || ui.acpMode[dshSessionId] === true
+  // question as "this conversation is served by one". A live session is proof
+  // only while the host has not answered; an explicit `false` wins over the
+  // lingering row a preset switch leaves behind (see `agentModeVisible`).
+  const isAcp = agentModeVisible(ui.acpMode[dshSessionId], target !== undefined)
   // The agent this conversation is set up on, live session or not. Before the
   // first message there is no session to read a mode list from, yet the user is
   // already choosing the agent — and the mode is one of the things they may
@@ -116,6 +155,12 @@ export function AcpComposerMode({ acp, sessionId, useSession }: ComposerModeProp
     void acp.loadAgentCatalog(agentId)
   }, [acp, agentId, isAcp, target])
 
+  // The whole control is ACP-only: a lingering live session row survives a
+  // preset switch, so its `availableModes` are NOT a licence to render here.
+  // Without this guard an ordinary conversation kept an agent-mode select
+  // beside its native controls (reported as "the bottom bar lost its native
+  // capabilities").
+  if (!isAcp) return null
   const live = target?.modes?.availableModes ?? []
   // TWO sources, one list. A live session's `session/new` answer is the
   // authority on which modes exist and which is in force; the probed catalog
@@ -123,20 +168,21 @@ export function AcpComposerMode({ acp, sessionId, useSession }: ComposerModeProp
   // agent published on ITS throwaway session). A live session always wins.
   const modes = live.length > 0
     ? live
-    : (isAcp ? catalog?.mode?.choices ?? [] : []).map(choice => ({ id: choice.id, name: choice.name, description: choice.description }))
+    : (catalog?.mode?.choices ?? []).map(choice => ({ id: choice.id, name: choice.name, description: choice.description }))
   if (modes.length === 0) return null
-  // The mode IN FORCE comes from the live session; before one exists the only
-  // claims available are the agent's own reported current mode and the pick this
-  // conversation recorded (a pick outranks the agent's default, exactly like the
-  // model and thought level do in `describeRoute`).
+  // The mode IN FORCE: a live session is the authority, before one exists (or
+  // while one is parked) the claims available are the pick this conversation
+  // recorded and the agent's own reported current mode (a pick outranks the
+  // agent's default, exactly like the model and thought level do in
+  // `describeRoute`; the parked row yields to the pick — see `modeInForce`).
   const persisted = ui.chatChoice[dshSessionId]?.agentId === agentId
     ? ui.chatChoice[dshSessionId]?.mode
     : undefined
-  const current = target?.modes?.currentModeId
-    ?? persisted
-    ?? catalog?.mode?.currentValue
-    ?? modes[0]?.id
-    ?? ''
+  const current = modeInForce(
+    target,
+    persisted,
+    catalog?.mode?.currentValue ?? modes[0]?.id,
+  )
 
   return (
     <label

package/src/client/context-meter.tsx

@@ -0,0 +1,128 @@
+/**
+ * Composer context-occupancy ring at `conversation.composer.dock` — the bottom
+ * info row below the input card, where the host also renders its ContextMeter.
+ *
+ * WHY A PLUGIN-OWNED RING: the host's meter reads its `contextPressure`
+ * projection, folded from DSH provider-usage samples plus a route capacity. An
+ * ACP conversation produces neither — the agent owns the request and the host
+ * never sees its prompt — so the native meter renders nothing there. This ring
+ * reports the agent's OWN `usage_update` used/size instead: occupancy only. ACP
+ * declares no system/tools/messages split, so no breakdown is invented.
+ *
+ * Registered for every conversation and gating itself: it renders only for an
+ * ACP conversation whose session row carries usage. The row comes from
+ * `session/chat-list`; the store live-patches it from the coalesced
+ * `usage_update` frames (see `AcpStore.flushUpdates`).
+ */
+
+import { useEffect } from 'react'
+// Type-only: pulls the ui-conversation SlotMap merge into this program.
+import type {} from '@deepseek-ai/dsh-client-ui-conversation/client'
+import { ensureAcpStyle, useUi } from './acp-ui.tsx'
+import type { AcpSessionHook } from './acp-ui.tsx'
+import type { AcpStore, UiState } from './store.ts'
+import type { SessionView } from '../protocol.ts'
+
+/** Props of the composer entry (injected face + the frame's standard kit). */
+export interface AcpContextMeterProps {
+  /** Injected face: the chat session id this entry belongs to. */
+  sessionId: string
+  /** Framework-bound conversation snapshot hook (`SessionStandardProps.useSession`). */
+  useSession: AcpSessionHook
+  acp: AcpStore
+}
+
+export interface ContextOccupancy {
+  /** Rounded occupancy percentage, clamped to 0..100. */
+  percent: number
+  used: number
+  size: number
+}
+
+/**
+ * The sample this conversation's ring should show, or `undefined` when the
+ * entry must render nothing. An explicit `acpMode === false` outranks a stale
+ * `chatSessions` row: the conversation's preset left NTR while its ACP session
+ * was still alive, and the ring must leave with it (same precedence as the
+ * agent tag's `agentTagVisible`). While the verdict is unknown, a LIVE row is
+ * proof; a PARKED one is not — it can outlive the preset switch, and the ring
+ * must not appear on an ordinary conversation during the answer window.
+ */
+export function acpMeterUsage(
+  ui: Pick<UiState, 'acpMode' | 'chatSessions' | 'chatSessionsFor'>,
+  dshSessionId: string,
+): SessionView['usage'] | undefined {
+  if (ui.acpMode[dshSessionId] === false) return undefined
+  if (ui.chatSessionsFor !== dshSessionId) return undefined
+  const live = ui.chatSessions.find(row => !row.released)
+  // A PARKED row alone is not proof this conversation is still in NTR mode:
+  // switching off the preset leaves the ACP session record alive, and while the
+  // host has not answered (`undefined`) the ring must not appear on an
+  // ordinary conversation. A live row is proof; a parked one needs the
+  // affirmative verdict.
+  if (live === undefined && ui.acpMode[dshSessionId] !== true) return undefined
+  return (live ?? ui.chatSessions[0])?.usage
+}
+
+/**
+ * Bounded display occupancy from one agent sample. `undefined` (no meter) for
+ * an absent / malformed / zero-capacity sample rather than a made-up 0%.
+ */
+export function contextOccupancy(usage: SessionView['usage'] | undefined): ContextOccupancy | undefined {
+  if (usage === undefined) return undefined
+  const { used, size } = usage
+  if (!Number.isFinite(used) || !Number.isFinite(size) || used < 0 || size <= 0) return undefined
+  return { percent: Math.min(100, Math.round(used / size * 100)), used, size }
+}
+
+/** Compact token count for the tooltip, in the host meter's K/M shape. */
+export function compactTokenCount(value: number): string {
+  if (value < 1e3) return String(Math.round(value))
+  const thousands = value / 1e3
+  if (value < 1e6) {
+    return `${thousands >= 100 ? String(Math.round(thousands)) : String(Math.round(thousands * 10) / 10)}K`
+  }
+  const millions = value / 1e6
+  return `${millions >= 100 ? String(Math.round(millions)) : String(Math.round(millions * 10) / 10)}M`
+}
+
+/** Ring geometry matches the host ContextMeter: 14px viewBox, 2px stroke. */
+const RADIUS = 5.5
+const CIRCUMFERENCE = 2 * Math.PI * RADIUS
+
+export function AcpContextMeter({ acp, sessionId, useSession }: AcpContextMeterProps) {
+  ensureAcpStyle()
+  const ui = useUi(acp)
+  const dshSessionId = String(sessionId)
+  // A fresh conversation gets its ACP session binding during its first turn,
+  // and no SSE frame announces that; the running flip is the re-read trigger
+  // every composer entry shares.
+  const running = useSession(snapshot => snapshot.running)
+  useEffect(() => {
+    void acp.loadChatSessions(dshSessionId)
+  }, [acp, dshSessionId, running])
+
+  const context = contextOccupancy(acpMeterUsage(ui, dshSessionId))
+  if (context === undefined) return null
+
+  const title = acp.label(
+    `上下文已用 ${String(context.percent)}% · ${compactTokenCount(context.used)} / ${compactTokenCount(context.size)}`,
+    `${String(context.percent)}% of context used · ${compactTokenCount(context.used)} / ${compactTokenCount(context.size)}`,
+  )
+  return (
+    <span className="ntr-acp-meter" role="img" aria-label={title} title={title}>
+      <svg viewBox="0 0 14 14" width="14" height="14" aria-hidden="true">
+        <circle className="ntr-acp-meter-track" cx="7" cy="7" r={RADIUS} />
+        <circle
+          className="ntr-acp-meter-fill"
+          cx="7"
+          cy="7"
+          r={RADIUS}
+          strokeDasharray={`${String(CIRCUMFERENCE * context.percent / 100)} ${String(CIRCUMFERENCE)}`}
+          transform="rotate(-90 7 7)"
+        />
+      </svg>
+      <span className="ntr-acp-meter-percent">{context.percent}%</span>
+    </span>
+  )
+}