dsh-ntr 0.3.1 → 0.3.2

package/lib/client/index.js

@@ -8,16 +8,58 @@
 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 } from "./branch-action.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 +139,37 @@ 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 {
+            const fork = service('sessions')?.fork;
+            return typeof fork === 'function' ? { fork } : undefined;
+        }
+        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,60 @@ export function apply(ctx) {
          * available yet.
          */
         let permissionClaim;
+        /**
+         * 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 +441,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 +464,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;
@@ -324,7 +507,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 +570,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 +595,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 +616,11 @@ export function apply(ctx) {
                 onDiag: (line) => { permissionSeatDiag = `staged ${staged.sessionId} · ${line}`; },
             });
             permissionClaim.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 +678,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();
         };
@@ -538,7 +757,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;
@@ -582,9 +806,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 +898,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.
 }