dsh-ntr 0.3.1 → 0.3.3

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, "%"] })] }));
+}

package/lib/client/index.js

@@ -8,16 +8,59 @@
 import { AcpStore } from "./store.js";
 import { AcpSettingsSection } from "./panel.js";
 import { AcpComposerMode } from "./composer-mode.js";
+import { AcpContextMeter } from "./context-meter.js";
 import { AcpComposerAgentTag, AcpSessionControls, AcpSessionMenu } from "./session-controls.js";
 import { AcpConversationView } from "./acp-view.js";
 import { AcpSettingsDialog } from "./settings-dialog.js";
 import { PermissionDock } from "./permission-dock.js";
+import { ReleasedBanner } from "./released-banner.js";
+import { AcpBranchAction, resolveHostFork } from "./branch-action.js";
+import { createActivityPillClaim, DOCK_SLOT } from "./activity-pill.js";
 import { createModelSeatClaim, createPermissionSeatClaim, MODEL_SEAT_KEY, PERMISSION_SEAT_KEY, } from "./model-seat.js";
-import { acpModeFromPresetEvent, rowAgentPreset, stagedIsAcpMode, stagedSessionOf, } from "./acp-ui.js";
+import { acpModeFromPresetEvent, ACP_PRESET_ID, rowAgentPreset, stagedIsAcpMode, stagedSessionOf, } from "./acp-ui.js";
 import { createSlashIsolation, slashAcpVerdict } from "./slash-isolation.js";
 export const name = 'dsh-ntr-client';
 export const inject = ['slots', 'connection'];
 const browserPrefersZh = typeof navigator !== 'undefined' && /^zh\b/i.test(navigator.language);
+/**
+ * The NTR scope marker (`html[data-ntr-acp]`): the ONLY hook the message-action
+ * hiding CSS keys on, so the host's like / dislike / branch icons disappear in
+ * exactly the conversations this gate has confirmed to run the ACP preset —
+ * and reappear the moment the evidence stops answering (every `standDown`
+ * clears it; non-ACP sessions never see it). Idempotent per call.
+ */
+const setScopeMarker = (active) => {
+    if (typeof document === 'undefined')
+        return;
+    document.documentElement.toggleAttribute('data-ntr-acp', active);
+};
+/**
+ * One-shot sanity probe for the aria-label hiding: the host's action buttons
+ * carry LOCALIZED labels and no data-* hook, so a copy change (or a third
+ * language) silently un-hides them while everything else keeps working. Once
+ * the marker is on and a turn tail is actually on screen, check that at least
+ * one label the rules key on still exists and leave one console line for
+ * whoever debugs "the icons came back" — dev-visible, never user UI.
+ */
+let probedHostLabels = false;
+const probeHostActionLabels = () => {
+    if (probedHostLabels || typeof document === 'undefined')
+        return;
+    // No turn tail rendered yet: the check would answer from nothing, so leave
+    // the probe armed for the next activation instead of burning it once.
+    if (document.querySelector('[data-turn-tail]') === null)
+        return;
+    probedHostLabels = true;
+    const found = document.querySelector([
+        'button:not([data-ntr-branch])[aria-label="在新对话中分支"]',
+        'button:not([data-ntr-branch])[aria-label="Branch into a new conversation"]',
+        'button[aria-label="好的回答"]',
+        'button[aria-label="Good response"]',
+    ].join(', '));
+    if (found === null) {
+        console.warn('[dsh-ntr] none of the host message-action labels matched; the like/dislike/branch icons may not be hidden in NTR conversations');
+    }
+};
 /**
  * How long a host verdict may stand as the gate's ONLY fact source before the
  * gate asks the host again.
@@ -97,11 +140,36 @@ export function apply(ctx) {
             return undefined;
         }
     };
+    /**
+     * The runtime's `sessions.fork`, resolved per call: `undefined` renders the
+     * branch button disabled (`hostUnavailable`) instead of hiding it, so a
+     * host that gains the primitive later is picked up on the next render.
+     */
+    const hostFork = () => {
+        try {
+            return resolveHostFork(service('sessions'));
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /** Focus a session in the workspace (the branch click's last step). */
+    const openSession = (sessionId) => {
+        try {
+            service('uiWorkspace')?.openSession?.(sessionId);
+        }
+        catch {
+            // Opening is presentation; a host without the workspace service leaves
+            // the branched session in the sidebar list, reachable by hand.
+        }
+    };
     /** The injected face every ACP conversation entry receives. */
     const chatFace = (sessionId) => ({
         acp: store,
         sessionId: String(sessionId),
         faceFor,
+        hostFork,
+        openSession,
     });
     ctx.effect(() => ctx.slots.inject('settings.section', () => ctx.slots.register({
         name: 'settings.section',
@@ -140,6 +208,12 @@ export function apply(ctx) {
         // composer-mode.tsx, so the composed-props constraint cannot be met by type
         // (see the note there). Runtime passes the real shares either way.
     }, AcpComposerMode)), 'dsh-ntr: composer agent-mode control');
+    // The agent's OWN context occupancy in the composer's bottom info row
+    // (`conversation.composer.dock` — the dock below the input card where the
+    // host renders its native ContextMeter) is installed by the ACP-mode gate
+    // below, with the same lifetime as the NTR view tab and the seats. It is
+    // NOT registered unconditionally: in an ordinary conversation this row must
+    // hold the host's native meter and nothing of ours (see `holdAuxEntries`).
     // Its picker rides the composer's overlay seat — the platform's home for
     // menus, so the popup floats above the card instead of being clipped by it.
     ctx.effect(() => ctx.slots.inject('conversation.input.overlay', () => ctx.slots.register({
@@ -178,6 +252,32 @@ export function apply(ctx) {
         // session id this dock belongs to (same contract as every other entry).
         inject: (sessionId) => chatFace(sessionId),
     }, PermissionDock)), 'dsh-ntr: conversation permission dock');
+    // The released-session banner in the same dock seat: when this
+    // conversation's agent process is parked (idle release or crash), one row
+    // says so and offers the explicit resume — the gesture form of the
+    // "next message resumes it" promise. Gated inside the component on the
+    // chat-list rows (released banner renders iff nothing live is left).
+    ctx.effect(() => ctx.slots.inject('conversation.input.dock', () => ctx.slots.register({
+        name: 'conversation.input.dock',
+        id: 'acp-released-banner',
+        order: 20,
+        inject: (sessionId) => chatFace(sessionId),
+    }, ReleasedBanner)), 'dsh-ntr: released-session banner');
+    // The NTR branch entry riding the host's own assistant-actions row
+    // (`conversation.chat.assistant-actions` — list, session scope; the
+    // positional inject argument is the chat session id, like every other
+    // session slot). Registered for EVERY conversation; the component gates
+    // itself on the confirmed ACP verdict (non-ACP renders nothing), and the
+    // `data-ntr-branch` attribute it stamps is the CSS pass that keeps the
+    // hiding rules from swallowing the plugin's own button (same aria-label as
+    // the host's). Order 20 puts it after the (hidden) feedback entry's 10 —
+    // visually the spot the host's own branch button occupied.
+    ctx.effect(() => ctx.slots.inject('conversation.chat.assistant-actions', () => ctx.slots.register({
+        name: 'conversation.chat.assistant-actions',
+        id: 'ntr-branch',
+        order: 20,
+        inject: (sessionId) => chatFace(sessionId),
+    }, AcpBranchAction)), 'dsh-ntr: message branch action');
     /**
      * The client runtime's session list store, read structurally. Used to find
      * the session the composer is staged on and whether it runs the ACP preset —
@@ -189,6 +289,30 @@ export function apply(ctx) {
             return undefined;
         return list;
     };
+    /**
+     * The renderer's current Session scope observable, when this host exposes it.
+     * This is the source the host's own main-view picker prefers; the list's
+     * retained rows are only the fallback for hosts without the adapter.
+     */
+    const currentScopeSource = () => {
+        try {
+            const current = service('uiSession')?.adapter?.current;
+            return current !== undefined && typeof current.getSnapshot === 'function' ? current : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /** The session the composer is actually staged on, if the runtime can say. */
+    const currentScopeSessionId = () => {
+        try {
+            const key = currentScopeSource()?.getSnapshot?.()?.key;
+            return typeof key === 'string' && key !== '' ? key : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
     /**
      * Chat session ids the ACP-mode tracker has already asked the host about (the
      * `session/chat-list` fallback), mapped to WHEN the last ask went out. The
@@ -214,6 +338,8 @@ export function apply(ctx) {
     const acpModeVerdict = (sessionId) => store.getSnapshot().acpMode[sessionId];
     ctx.effect(() => {
         let stopWatch;
+        /** Subscription to the renderer's current Session binding (see `currentScopeSource`). */
+        let stopCurrent;
         /**
          * The claim on the host's model seat, held while the staged conversation
          * runs the ACP preset. That cell is where the host's own base sits (the
@@ -249,6 +375,82 @@ export function apply(ctx) {
          * available yet.
          */
         let permissionClaim;
+        /**
+         * Claim on the dock's `activity` cell (`conversation.composer.dock`, id
+         * `activity`), held for the same ACP-mode spell as the two seats. The
+         * occupant renders the HOST's ActivityPill with the plugin's burst speed
+         * patched into its `sessionStats`; it is a list cell, so the claim is
+         * identified by id rather than by the slot's heads[0]. If the host shape is
+         * not one this bundle knows, no claim is created and the native pill stays.
+         */
+        let activityClaim;
+        let activityDiag = 'idle';
+        const noteActivityDiag = (line) => {
+            if (line === activityDiag)
+                return;
+            activityDiag = line;
+            // Success and the ordinary older-host "no activity entry" are silent; a
+            // shape mismatch or a lost registration must leave a breadcrumb. The ACP
+            // view has no line for this surface, and a missing speed fix is otherwise
+            // invisible.
+            if (!/failed|missing|taken|gave up|still held/.test(line))
+                return;
+            console.warn(`[dsh-ntr] ${line}`);
+        };
+        /**
+         * ACP-only auxiliary entries: the NTR view tab and the composer's context
+         * ring. Unlike the two seats these are `list` slots with no visibility
+         * predicate of their own, so "self-hide in the component" cannot remove a
+         * tab from the header or free the native bottom row. They are installed by
+         * this gate for exactly the same lifetime as the claims and disposed on
+         * every stand-down — a standard conversation then has no NTR tab at all,
+         * and the host's native context meter sits alone in its dock row.
+         */
+        let viewEntry;
+        let meterEntry;
+        const releaseAuxEntries = () => {
+            try {
+                viewEntry?.();
+            }
+            catch { }
+            viewEntry = undefined;
+            try {
+                meterEntry?.();
+            }
+            catch { }
+            meterEntry = undefined;
+        };
+        const holdAuxEntries = () => {
+            // A refused registration leaves the native surface in place (fail-open);
+            // the next evaluation retries when the slot is declared.
+            if (viewEntry === undefined) {
+                try {
+                    viewEntry = ctx.slots.inject('conversation.view', () => ctx.slots.register({
+                        name: 'conversation.view',
+                        id: 'acp',
+                        order: 20,
+                        label: () => label('NTR', 'NTR'),
+                        inject: (sessionId) => chatFace(sessionId),
+                    }, AcpConversationView));
+                }
+                catch {
+                    viewEntry = undefined;
+                }
+            }
+            if (meterEntry === undefined) {
+                try {
+                    meterEntry = ctx.slots.inject('conversation.composer.dock', () => ctx.slots.register({
+                        name: 'conversation.composer.dock',
+                        id: 'acp-context-meter',
+                        order: 10,
+                        inject: (sessionId) => chatFace(sessionId),
+                    }, AcpContextMeter));
+                }
+                catch {
+                    meterEntry = undefined;
+                }
+            }
+        };
         /**
          * Last diagnostic line from {@link syncAcpMode}. Every way this gate can
          * end with the native seat still on screen used to be silent — an inner
@@ -261,7 +463,8 @@ export function apply(ctx) {
         let seatDiag = 'idle';
         let permissionSeatDiag = 'idle';
         /**
-         * Hand BOTH cells back to their shipped occupants.
+         * Hand every ACP-only surface back: both composer cells, the NTR view tab
+         * and the context ring.
          *
          * Every path that is not "this staged conversation is CONFIRMED to run the
          * ACP preset" ends here — including the paths that carry no verdict at all
@@ -283,6 +486,8 @@ export function apply(ctx) {
             // read identically in the one place either is observable.
             permissionSeatDiag = `${reason} (released)`;
             disarmVerdictReask();
+            setScopeMarker(false);
+            releaseAuxEntries();
             if (claim !== undefined) {
                 claim.release();
                 claim = undefined;
@@ -291,6 +496,10 @@ export function apply(ctx) {
                 permissionClaim.release();
                 permissionClaim = undefined;
             }
+            if (activityClaim !== undefined) {
+                activityClaim.release();
+                activityClaim = undefined;
+            }
         };
         /**
          * Re-ask timer for the staged session, armed while the row is silent and a
@@ -324,7 +533,13 @@ export function apply(ctx) {
                 standDown('no session list service');
                 return;
             }
-            const staged = stagedSessionOf(snapshot);
+            // Prefer the renderer's own current selection; the list's retained rows
+            // are the fallback for hosts without the scope adapter. A multi-view
+            // layout can leave several rows retained, and judging the first one (or
+            // the one the previous switch left behind) would hold the ACP chrome
+            // while an ordinary conversation is on screen — the reported drift.
+            const current = currentScopeSessionId();
+            const staged = stagedSessionOf(snapshot, current);
             if (staged === undefined) {
                 standDown('no staged session (nothing retains the main view)');
                 return;
@@ -381,14 +596,24 @@ export function apply(ctx) {
             // nothing. Both cells follow the same evidence — the staged
             // conversation's preset — through one {@link standDown}, so neither can
             // stay claimed after the evidence for it stops answering.
-            if (!stagedIsAcpMode(snapshot, acpModeVerdict)) {
+            if (!stagedIsAcpMode(snapshot, acpModeVerdict, current)) {
+                // The row's own verdict is authoritative even when it says no: fold it
+                // into the store so every per-conversation surface (the branch
+                // button's ACP gate included) stops rendering without waiting for a
+                // host read. A silent row folds nothing — that case is the ask path's.
+                if (rowAgentPreset(staged.row) !== undefined)
+                    store.noteAcpMode(staged.sessionId, false);
                 standDown(`staged ${staged.sessionId} is not in ACP mode`);
                 return;
             }
             // The row speaks, so the host verdict is not this gate's only fact
-            // source and no re-ask timer is needed.
-            if (rowAgentPreset(staged.row) !== undefined)
+            // source and no re-ask timer is needed. The same fold in the affirmative
+            // direction: the runtime row IS the preset truth, and the branch
+            // button's gate reads the folded map, not the snapshot.
+            if (rowAgentPreset(staged.row) !== undefined) {
+                store.noteAcpMode(staged.sessionId, rowAgentPreset(staged.row) === ACP_PRESET_ID);
                 disarmVerdictReask();
+            }
             // Stays re-runnable on purpose: the seat is not declared before the
             // composer bar mounts, a registration can be refused, and the cell can be
             // taken from us later. The claim reports each of those through the
@@ -396,6 +621,8 @@ export function apply(ctx) {
             // next evaluation (store mutation, list notification, preset frame, or a
             // change to the cell itself) simply tries again.
             seatDiag = `staged ${staged.sessionId} is ACP mode`;
+            setScopeMarker(true);
+            probeHostActionLabels();
             claim ??= createModelSeatClaim({
                 slots: ctx.slots,
                 occupant: () => AcpSessionControls,
@@ -415,6 +642,21 @@ export function apply(ctx) {
                 onDiag: (line) => { permissionSeatDiag = `staged ${staged.sessionId} · ${line}`; },
             });
             permissionClaim.sync();
+            // The dock's activity pill is a list CELL, not a whole slot: this claim
+            // shadows the shipped `activity` entry by id and renders it back with the
+            // plugin's burst speed. No host entry / inject / locale -> undefined and
+            // the native pill is untouched; the next evaluation retries.
+            activityClaim ??= createActivityPillClaim({
+                slots: ctx.slots,
+                inject: (sessionId) => chatFace(sessionId),
+                onDiag: noteActivityDiag,
+            });
+            activityClaim?.sync();
+            // The tab and the occupancy ring have the same lifetime as the claims:
+            // they exist only while this staged conversation is an ACP one, and a
+            // stand-down disposes them (a standard conversation must not see an NTR
+            // tab, and the host's native bottom row must stand alone there).
+            holdAuxEntries();
             // Confirmed ACP on a silent row: the verdict is all the evidence there
             // is, so it gets a re-ask deadline (see {@link ACP_MODE_VERDICT_TTL_MS}).
             if (rowAgentPreset(staged.row) === undefined)
@@ -472,6 +714,19 @@ export function apply(ctx) {
             const list = sessionsList();
             if (list !== undefined && stopWatch === undefined)
                 stopWatch = list.subscribe(runGate);
+            // The selection can move without the list changing (a tab or sidebar
+            // click), and `uiSession.current` is the host's own answer to "which
+            // conversation is on screen". Re-run the gate on that transition so the
+            // ACP chrome leaves before the newly staged ordinary conversation paints.
+            const current = currentScopeSource();
+            if (current?.subscribe !== undefined && stopCurrent === undefined) {
+                try {
+                    stopCurrent = current.subscribe(runGate);
+                }
+                catch {
+                    stopCurrent = undefined;
+                }
+            }
             attachPresetFrames();
             runGate();
         };
@@ -524,7 +779,7 @@ export function apply(ctx) {
         // retakes the cell only when it is actually holding something that is not
         // ours — so this is evidence-driven, not a poll.
         const stopCell = ctx.on('slots/changed', (...args) => {
-            if (args[0] !== MODEL_SEAT_KEY && args[0] !== PERMISSION_SEAT_KEY)
+            if (args[0] !== MODEL_SEAT_KEY && args[0] !== PERMISSION_SEAT_KEY && args[0] !== DOCK_SLOT)
                 return;
             runGate();
         });
@@ -538,7 +793,12 @@ export function apply(ctx) {
             stopCell();
             stopPreset?.();
             stopWatch?.();
+            stopCurrent?.();
             disarmVerdictReask();
+            // The scope marker dies with the gate: a reload (HMR) must not leave the
+            // hiding CSS pointed at conversations nothing confirms anymore.
+            setScopeMarker(false);
+            releaseAuxEntries();
             if (claim !== undefined) {
                 claim.release();
                 claim = undefined;
@@ -547,6 +807,10 @@ export function apply(ctx) {
                 permissionClaim.release();
                 permissionClaim = undefined;
             }
+            if (activityClaim !== undefined) {
+                activityClaim.release();
+                activityClaim = undefined;
+            }
             store.noteSeatDiag('gate disposed');
             store.notePermissionSeatDiag('gate disposed');
         };
@@ -582,9 +846,9 @@ export function apply(ctx) {
                 const sources = triggers.live?.sources;
                 return Array.isArray(sources) ? sources : undefined;
             },
-            verdict: (sessionId) => slashAcpVerdict(sessionsList()?.getSnapshot(), sessionId, id => store.getSnapshot().acpMode[id]),
+            verdict: (sessionId) => slashAcpVerdict(sessionsList()?.getSnapshot(), sessionId, id => store.getSnapshot().acpMode[id], currentScopeSessionId()),
             ensureVerdict: async (sessionId) => {
-                const held = () => slashAcpVerdict(sessionsList()?.getSnapshot(), sessionId, id => store.getSnapshot().acpMode[id]);
+                const held = () => slashAcpVerdict(sessionsList()?.getSnapshot(), sessionId, id => store.getSnapshot().acpMode[id], currentScopeSessionId());
                 const known = held();
                 if (known !== undefined)
                     return known;
@@ -674,11 +938,10 @@ export function apply(ctx) {
     // diffs). Session-scope list entry; the view ring renders it one tab at a
     // time. Meanwhile the agent's prose and thinking ride the NATIVE chat plane
     // through the LLM adapter — see docs/acp-convergence.md §2.1.
-    ctx.effect(() => ctx.slots.inject('conversation.view', () => ctx.slots.register({
-        name: 'conversation.view',
-        id: 'acp',
-        order: 20,
-        label: () => 'NTR',
-        inject: (sessionId) => chatFace(sessionId),
-    }, AcpConversationView)), 'dsh-ntr: ACP view tab');
+    //
+    // It is installed by the ACP-mode gate above (`holdAuxEntries`) and NOT at
+    // plugin load: the host projects every registered `conversation.view` entry
+    // into EVERY session's tab strip, so an unconditional registration showed
+    // the NTR tab on ordinary conversations too. The gate's lifetime is the
+    // only per-session seam the host offers.
 }

package/lib/client/model-seat.js

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