dsh-ntr 0.3.1 → 0.3.2

package/lib/client/acp-ui.js

@@ -128,6 +128,13 @@ export function rowAgentPreset(row) {
 /**
  * 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
@@ -135,8 +142,13 @@ export function rowAgentPreset(row) {
  * 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) {
+export function stagedSessionOf(snapshot, currentSessionId) {
     if (snapshot === undefined)
         return undefined;
     if (snapshot.current !== undefined) {
@@ -147,6 +159,12 @@ export function stagedSessionOf(snapshot) {
         };
     }
     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
@@ -171,8 +189,8 @@ export function stagedSessionOf(snapshot) {
     return { sessionId, row, subagent: row?.origin === 'subagent' };
 }
 /** Whether the staged session runs the ACP agent preset. */
-export function stagedIsAcpMode(snapshot, acpMode) {
-    const staged = stagedSessionOf(snapshot);
+export function stagedIsAcpMode(snapshot, acpMode, currentSessionId) {
+    const staged = stagedSessionOf(snapshot, currentSessionId);
     if (staged === undefined || staged.subagent)
         return false;
     const listed = rowAgentPreset(staged.row);
@@ -423,6 +441,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
@@ -598,6 +625,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/lib/client/acp-view.js

@@ -209,6 +209,19 @@ const BlockView = memo(function BlockView({ block, label }) {
 function boundSession(list) {
     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) {
+    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
@@ -302,10 +315,15 @@ export function AcpConversationView(props) {
             return;
         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,
@@ -327,6 +345,8 @@ export function AcpConversationView(props) {
                     const node = event.currentTarget;
                     pinned.current = node.scrollHeight - node.scrollTop - node.clientHeight < 40;
                 }, children: transcript.blocks.length === 0
-                    ? _jsx("div", { className: "ntr-acp-empty-hint", children: t('还没有消息：在下面的输入框里发给它。', 'Nothing yet — send it a message below.') })
+                    ? (_jsx("div", { className: "ntr-acp-empty-hint", children: historyAwaitsReplay(session)
+                            ? t('进程已释放；历史将在恢复后回放显示。', 'The process is released — history replays once it is restored.')
+                            : t('还没有消息：在下面的输入框里发给它。', 'Nothing yet — send it a message below.') }))
                     : transcript.blocks.map((block, index) => _jsx(BlockView, { block: block, label: acp.label, localeRev: ui.localeRev }, index)) })] }));
 }

package/lib/client/branch-action.js

@@ -0,0 +1,133 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * 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 { 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";
+/**
+ * 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) {
+    return (source.IconBranchOutline16 ?? source.IconBranchOutlineRegular ?? source.IconBranchOutlineMedium);
+}
+const BranchIcon = branchIconOf(primitives);
+/** What the label reads for each state (zh / en pairs, per the plan's §D4). */
+function tooltipFor(state, label) {
+    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) {
+    const ui = useUi(props.acp);
+    const buttonRef = useRef(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(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 = () => {
+        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 (_jsxs(_Fragment, { children: [_jsx(Tooltip, { label: tooltipFor(state, props.acp.label), side: "bottom", children: _jsx("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, children: BranchIcon === undefined ? null : _jsx(BranchIcon, {}) }) }), failure !== undefined && (_jsx("span", { className: "ntr-branch-error", role: "alert", title: failure, children: failure }))] }));
+}

package/lib/client/composer-mode.js

@@ -34,6 +34,36 @@ function useUi(acp) {
 export function agentModeTitle(agentId, acp) {
     return acp.label(`agent 模式（${agentId ?? 'agent'}）：由 agent 自己定义。NTR 会话里 DSH 的 Access mode 不显示，模式就在此切换。`, `agent mode (${agentId ?? 'agent'}): defined by the agent. In an NTR conversation the DSH access mode is not shown, so this is where the mode is switched.`);
 }
+/**
+ * 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, hasBoundSession) {
+    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, persisted, fallback) {
+    const live = target !== undefined && target.released !== true ? target.modes?.currentModeId : undefined;
+    return live ?? persisted ?? target?.modes?.currentModeId ?? fallback ?? '';
+}
 export function AcpComposerMode({ acp, sessionId, useSession }) {
     const ui = useUi(acp);
     const dshSessionId = String(sessionId);
@@ -52,9 +82,10 @@ export function AcpComposerMode({ acp, sessionId, useSession }) {
     // 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
@@ -83,6 +114,13 @@ export function AcpComposerMode({ acp, sessionId, useSession }) {
             return;
         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
@@ -90,21 +128,18 @@ export function AcpComposerMode({ acp, sessionId, useSession }) {
     // 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 (_jsx("label", { style: { display: 'inline-flex', alignItems: 'center', fontSize: 12 }, 
         // No visible "Agent mode" caption (user decision, 2026-10-17): the option
         // labels are the agent's own mode names (Plan / Accept edits / …), which

package/lib/client/context-meter.js

@@ -0,0 +1,86 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * 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';
+import { ensureAcpStyle, useUi } from "./acp-ui.js";
+/**
+ * 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, dshSessionId) {
+    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) {
+    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) {
+    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 }) {
+    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 (_jsxs("span", { className: "ntr-acp-meter", role: "img", "aria-label": title, title: title, children: [_jsxs("svg", { viewBox: "0 0 14 14", width: "14", height: "14", "aria-hidden": "true", children: [_jsx("circle", { className: "ntr-acp-meter-track", cx: "7", cy: "7", r: RADIUS }), _jsx("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)" })] }), _jsxs("span", { className: "ntr-acp-meter-percent", children: [context.percent, "%"] })] }));
+}