dsh-ntr 0.3.1 → 0.3.3

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/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

@@ -0,0 +1,149 @@
+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";
+/**
+ * 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
+ * `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