dsh-ntr 0.3.1 → 0.3.3

package/lib/client.js

@@ -4,14 +4,61 @@ window.__ModuleLoader__.load({
 		var module = { exports: {} };
 		var exports = module.exports;
 		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		//#region \0rolldown/runtime.js
+		var __create = Object.create;
+		var __defProp = Object.defineProperty;
+		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+		var __getOwnPropNames = Object.getOwnPropertyNames;
+		var __getProtoOf = Object.getPrototypeOf;
+		var __hasOwnProp = Object.prototype.hasOwnProperty;
+		var __copyProps = (to, from, except, desc) => {
+			if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+				key = keys[i];
+				if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+			return to;
+		};
+		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+			value: mod,
+			enumerable: true
+		}) : target, mod));
+		//#endregion
 		let react = require("react");
 		let react_jsx_runtime = require("react/jsx-runtime");
+		let _deepseek_ai_dsh_client_ui_primitives = require("@deepseek-ai/dsh-client-ui-primitives");
+		_deepseek_ai_dsh_client_ui_primitives = __toESM(_deepseek_ai_dsh_client_ui_primitives, 1);
 		//#region src/protocol.ts
 		/** Default when nothing was ever saved: the breathing halo at normal speed. */
 		const DEFAULT_TAG_HALO = {
 			mode: "breath",
 			speed: "normal"
 		};
+		/**
+		* The idle-release windows the settings page offers, in MILLISECONDS.
+		*
+		* ONE ladder, shared by both halves: the browser snaps its slider to these
+		* values and the host accepts only these values, so a window the slider can
+		* produce is always a window the host runs. The first rung is 1 minute (an
+		* aggressive release), the rest are 5-minute steps up to an hour.
+		*/
+		const IDLE_RELEASE_MS = [
+			6e4,
+			3e5,
+			6e5,
+			9e5,
+			12e5,
+			15e5,
+			18e5,
+			21e5,
+			24e5,
+			27e5,
+			3e6,
+			33e5,
+			36e5
+		];
 		//#endregion
 		//#region src/client/store.ts
 		/** Returned by {@link deadlineRemainingLabel} once the deadline has passed. */
@@ -26,6 +73,29 @@ window.__ModuleLoader__.load({
 			return permissions.filter((permission) => permission.dshSessionId === dshSessionId);
 		}
 		/**
+		* The branch button's state for one conversation, in the precedence it renders:
+		* the host service missing beats everything (nothing can work), then the
+		* agent's fork capability, then the session's own state (a parked session
+		* before a running one), then the DOM's tail verdict, and only then ready.
+		*
+		* Every input is a fact someone else owns — the row's `fork` verdict is the
+		* host's, `hostFork` is the structural probe of the runtime's `sessions.fork`,
+		* `isTail` is read from the host's own `[data-turn-tail]` marker, and
+		* `liveRunning` is the SSE-driven running flag (the row's own `running` only
+		* refreshes on a chat-list read, so it would answer last turn). `undefined`
+		* facts degrade CLOSED: no row and no `fork` verdict both read as not-ready,
+		* never as a click-through.
+		*/
+		function forkStateOf(row, hostFork, isTail, liveRunning) {
+			if (!hostFork) return "hostUnavailable";
+			if (row === void 0) return "released";
+			if (row.fork === void 0) return "unsupported";
+			if (row.fork.supported !== true) return row.fork.reason ?? "unsupported";
+			if (liveRunning === true) return "busy";
+			if (!isTail) return "notTail";
+			return "ready";
+		}
+		/**
 		* Compact countdown for one ask, or `undefined` when there is nothing to count
 		* down (`wait` mode, or a frame without a deadline). Pure so the formatting is
 		* testable without a clock: the dock passes `Date.now()` on its tick.
@@ -331,8 +401,10 @@ window.__ModuleLoader__.load({
 				probingModels: {},
 				probeErrors: {},
 				chatSessions: [],
+				burstStats: {},
 				tagHalo: { ...DEFAULT_TAG_HALO },
 				approvalDeadlines: void 0,
+				idleRelease: void 0,
 				chatTranscripts: {},
 				acpMode: {},
 				chatBoundAgent: {},
@@ -353,6 +425,13 @@ window.__ModuleLoader__.load({
 			/** In-flight `session/chat-list` reads, keyed by chat session id. */
 			chatSessionReads = /* @__PURE__ */ new Map();
 			/**
+			* ACP session ids whose chat-list row was requested mid-turn (one read each).
+			* A conversation's first ACP session does not exist when the composer's
+			* mount/running read fires, so its first `usage_update` would find no row to
+			* patch; `turn/start` asks again once the host has materialized the session.
+			*/
+			chatSessionRowReads = /* @__PURE__ */ new Set();
+			/**
 			* Chat sessions whose list has answered at least once in this page. The
 			* FIRST answer only seeds the lock; a lock appearing on a later answer is a
 			* transition this page actually witnessed, and only that one is announced via
@@ -471,17 +550,25 @@ window.__ModuleLoader__.load({
 					else list.push(item);
 				}
 				let chatTranscripts = this.state.chatTranscripts;
+				let chatSessions = this.state.chatSessions;
 				let blocksChanged = false;
 				for (const [sessionId, items] of bySession) {
 					const last = items[items.length - 1];
+					const usage = usageOfBatch(items);
+					if (usage !== void 0) chatSessions = withSessionUsage(chatSessions, sessionId, usage);
 					const record = chatTranscripts[sessionId];
 					if (record !== void 0) {
 						let changed = false;
 						for (const item of items) if (foldUpdate(record.blocks, item.update)) changed = true;
+						const session = usage !== void 0 && !sameUsage(record.session.usage, usage) ? {
+							...record.session,
+							usage
+						} : record.session;
 						chatTranscripts = {
 							...chatTranscripts,
 							[sessionId]: {
 								...record,
+								session,
 								seq: last.seq,
 								...changed ? { blocks: [...record.blocks] } : {}
 							}
@@ -502,6 +589,7 @@ window.__ModuleLoader__.load({
 				}
 				const patch = {};
 				if (chatTranscripts !== this.state.chatTranscripts) patch.chatTranscripts = chatTranscripts;
+				if (chatSessions !== this.state.chatSessions) patch.chatSessions = chatSessions;
 				if (blocksChanged) patch.blocks = [...this.state.blocks];
 				if (Object.keys(patch).length > 0) this.mutate(patch);
 			}
@@ -550,7 +638,7 @@ window.__ModuleLoader__.load({
 			/** Snapshot refresh used on panel open and after a stream outage. */
 			async resync() {
 				try {
-					const [{ agents }, { sessions }, defaultAgentInfo, detectResult, presetResult, tagHaloResult, deadlinesResult, versionResult] = await Promise.all([
+					const [{ agents }, { sessions }, defaultAgentInfo, detectResult, presetResult, tagHaloResult, deadlinesResult, idleReleaseResult, versionResult] = await Promise.all([
 						this.call("agents/list"),
 						this.call("sessions/list"),
 						this.call("default/agent").catch(() => ({})),
@@ -558,6 +646,7 @@ window.__ModuleLoader__.load({
 						this.call("preset/status").catch(() => null),
 						this.call("ui/tag-halo").catch(() => ({ halo: { ...DEFAULT_TAG_HALO } })),
 						this.call("ui/approval-deadlines").catch(() => ({ deadlines: void 0 })),
+						this.call("ui/idle-release").catch(() => ({ idleRelease: void 0 })),
 						this.call("plugin/version").catch(() => null)
 					]);
 					const detectedAgents = detectResult && detectResult.agents.length > 0 ? detectResult.agents : this.state.detectedAgents.length > 0 ? this.state.detectedAgents : [...DEFAULT_KNOWN_PRESETS];
@@ -570,8 +659,10 @@ window.__ModuleLoader__.load({
 						preset: presetResult?.preset ?? void 0,
 						tagHalo: tagHaloResult?.halo ?? { ...DEFAULT_TAG_HALO },
 						approvalDeadlines: deadlinesResult.deadlines,
+						idleRelease: idleReleaseResult.idleRelease,
 						pluginVersion: versionResult?.version !== void 0 && versionResult.version !== "" ? versionResult.version : void 0
 					});
+					if (this.state.chatSessionsFor !== void 0) this.loadChatSessions(this.state.chatSessionsFor);
 					const active = this.state.activeSessionId ?? sessions[0]?.sessionId;
 					if (active !== void 0) await this.loadTranscript(active);
 				} catch (error) {
@@ -995,7 +1086,7 @@ window.__ModuleLoader__.load({
 			async readChatSessionList(dshSessionId, options, read) {
 				const settle = options?.settleVerdict === true || !this.acpModeLive.has(dshSessionId);
 				try {
-					const { sessions, acpMode, boundAgentId, lockedAgentId, choice } = await this.call("session/chat-list", {
+					const { sessions = [], acpMode, boundAgentId, lockedAgentId, choice } = await this.call("session/chat-list", {
 						dshSessionId,
 						refresh: true
 					});
@@ -1103,6 +1194,13 @@ window.__ModuleLoader__.load({
 			* being the one authorized exception. Same no-op-when-unchanged discipline as
 			* the other accessors, so a frame restating the held verdict costs no
 			* listener churn.
+			*
+			* The seat gate (`syncAcpMode`) is the SECOND caller: it folds the runtime
+			* row's own `agentPreset` — the same session-log source the frames announce —
+			* through here, in both directions. That hands the row the frame's authority
+			* on purpose (one provenance, one rank): a stale projection is corrected by
+			* the gate's next evaluation with fresher row data, and only HOST READS are
+			* barred from regressing what the runtime itself already said.
 			*/
 			noteAcpMode(dshSessionId, acpMode) {
 				this.acpModeLive.add(dshSessionId);
@@ -1186,12 +1284,99 @@ window.__ModuleLoader__.load({
 						modeId,
 						...agentId === void 0 ? {} : { agentId }
 					});
+					const safeAgent = agentId && agentId.trim() || void 0;
+					this.writeChoice(dshSessionId, (choice) => ({
+						...choice,
+						mode: modeId
+					}), safeAgent);
+					if (this.state.chatSessionsFor === dshSessionId) {
+						const owner = safeAgent ?? this.state.chatChoice[dshSessionId]?.agentId ?? this.state.chatBoundAgent[dshSessionId] ?? this.state.defaultAgent;
+						let changed = false;
+						const chatSessions = this.state.chatSessions.map((s) => {
+							if (s.agentId !== owner || !s.modes || s.modes.currentModeId === modeId) return s;
+							changed = true;
+							return {
+								...s,
+								modes: {
+									...s.modes,
+									currentModeId: modeId
+								}
+							};
+						});
+						if (changed) this.mutate({ chatSessions });
+					}
 				} catch (error) {
 					this.flashError(error);
 				}
 				await this.loadChatSessions(dshSessionId);
 			}
 			/**
+			* Bring the conversation's released ACP session back on a fresh process —
+			* the released banner's explicit form of the "next message resumes it"
+			* promise (`session/chat-resume`). A failure is reported through the notice
+			* AND rethrown (the `respondPermission` contract), so the banner can pin
+			* the message beside the button the user just pressed; the binding is
+			* re-read either way so the row follows the host's real answer.
+			*/
+			async resumeChatSession(dshSessionId) {
+				let failure;
+				try {
+					await this.call("session/chat-resume", { dshSessionId });
+				} catch (error) {
+					this.flashError(error);
+					failure = error;
+				}
+				await this.loadChatSessions(dshSessionId);
+				if (failure !== void 0) throw failure;
+			}
+			/**
+			* Branch one conversation (the NTR branch button's click): the fixed
+			* two-stage order — the HOST forks the DSH session tree first (copied
+			* history, `(1)` title, workspace), then the plugin adopts the ACP side via
+			* `session/chat-fork-adopt`, which runs the agent's own `session/fork` so
+			* the child actually remembers the parent context. Host first is structural:
+			* ACP fork has no cut-point parameter and nothing to return to if the host
+			* half failed second (see the plan's §D7).
+			*
+			* Resolves `{ childId }` on success, or `{ failure }` with one actionable
+			* line — the reason is ALSO flashed into the notice banner (a user-action
+			* failure, so the banner is its surface), and the local line is what the
+			* conversation renders beside the button (the user is not on the settings
+			* page). A failed adopt leaves the child an ordinary copied-history
+			* conversation (its first message starts a fresh `session/new` — today's
+			* behavior), never a half-bound one, and NOTHING is opened.
+			*
+			* `forkHost` is the runtime's `sessions.fork` face, resolved structurally by
+			* the entry and injected here: the store stays transport-free.
+			*/
+			async forkChatSession(dshSessionId, forkHost) {
+				let childId;
+				try {
+					childId = await forkHost(dshSessionId);
+				} catch (error) {
+					const failure = error instanceof Error ? error.message : String(error);
+					this.flashError(failure);
+					return { failure };
+				}
+				if (typeof childId !== "string" || childId === "") {
+					const failure = this.locale("宿主没有返回分支会话，分支未完成。", "The host returned no branched session; the branch did not complete.");
+					this.flashError(new Error(failure));
+					return { failure };
+				}
+				try {
+					await this.call("session/chat-fork-adopt", {
+						dshSessionId: childId,
+						parentDshSessionId: dshSessionId
+					});
+				} catch (error) {
+					const reason = error instanceof Error ? error.message : String(error);
+					const failure = this.locale(`分支会话已创建，但没有接上 agent 的上下文（${reason}）；在子会话里发送的第一条消息会开启全新会话。`, `The branched session was created but the agent context was not attached (${reason}); its first message will start a fresh session.`);
+					this.flashError(new Error(failure));
+					return { failure };
+				}
+				return { childId };
+			}
+			/**
 			* Start (or refresh) observation of every ACP transcript behind one DSH chat
 			* session. Blocks are rebuilt from scratch — the host buffer is the record,
 			* and this view is the only consumer that needs the raw agent stream.
@@ -1358,6 +1543,33 @@ window.__ModuleLoader__.load({
 			async resetApprovalDeadlines() {
 				await this.writeApprovalDeadlines({ reset: true });
 			}
+			/**
+			* Write the idle-release window (in ms).
+			*
+			* The host answer — the same route returns the window now in force — is
+			* the authority, so an optimistic write that the host trims self-corrects
+			* instead of drifting from what runs.
+			*/
+			async setIdleRelease(idleTimeoutMs) {
+				await this.writeIdleRelease({ idleTimeoutMs });
+			}
+			/**
+			* Drop the persisted override: the config file (or the built-in default)
+			* decides again.
+			*/
+			async resetIdleRelease() {
+				await this.writeIdleRelease({ reset: true });
+			}
+			async writeIdleRelease(payload) {
+				const previous = this.state.idleRelease;
+				try {
+					const result = await this.call("ui/idle-release-set", payload);
+					this.mutate({ idleRelease: result.idleRelease });
+				} catch (error) {
+					this.mutate({ idleRelease: previous });
+					this.flashError(error);
+				}
+			}
 			async writeApprovalDeadlines(payload) {
 				const previous = this.state.approvalDeadlines;
 				if (previous !== void 0) this.mutate({ approvalDeadlines: {
@@ -1404,10 +1616,24 @@ window.__ModuleLoader__.load({
 						dshSessionId,
 						modelId
 					});
+					const targetAgent = (agentId && agentId.trim() || void 0) ?? (modelId ? splitModelAgentId(modelId) : void 0);
 					this.writeChoice(dshSessionId, (choice) => ({
 						...choice,
 						modelId
-					}), agentId);
+					}), targetAgent);
+					if (this.state.chatSessionsFor === dshSessionId) {
+						const owner = targetAgent ?? this.state.chatChoice[dshSessionId]?.agentId ?? this.state.chatBoundAgent[dshSessionId] ?? this.state.defaultAgent;
+						let changed = false;
+						const chatSessions = this.state.chatSessions.map((s) => {
+							if (s.agentId !== owner || s.modelId === modelId) return s;
+							changed = true;
+							return {
+								...s,
+								modelId
+							};
+						});
+						if (changed) this.mutate({ chatSessions });
+					}
 				} catch (error) {
 					this.flashError(error);
 					throw error;
@@ -1421,13 +1647,27 @@ window.__ModuleLoader__.load({
 						...effort === void 0 ? {} : { effort },
 						...agentId === void 0 ? {} : { agentId }
 					});
+					const targetAgent = agentId && agentId.trim() || void 0;
 					this.writeChoice(dshSessionId, (choice) => {
 						const { effort: _dropped, ...rest } = choice;
 						return effort === void 0 ? rest : {
 							...rest,
 							effort
 						};
-					}, agentId);
+					}, targetAgent);
+					if (this.state.chatSessionsFor === dshSessionId) {
+						const owner = targetAgent ?? this.state.chatChoice[dshSessionId]?.agentId ?? this.state.chatBoundAgent[dshSessionId] ?? this.state.defaultAgent;
+						let changed = false;
+						const chatSessions = this.state.chatSessions.map((s) => {
+							if (s.agentId !== owner || s.reasoningEffort === effort) return s;
+							changed = true;
+							return {
+								...s,
+								reasoningEffort: effort
+							};
+						});
+						if (changed) this.mutate({ chatSessions });
+					}
 				} catch (error) {
 					this.flashError(error);
 					throw error;
@@ -1536,8 +1776,11 @@ window.__ModuleLoader__.load({
 					}
 					case "session/meta": {
 						const sessions = this.state.sessions.some((s) => s.sessionId === event.sessionId) ? this.state.sessions.map((s) => s.sessionId === event.sessionId ? event.session : s) : this.state.sessions;
+						let chatSessions = withSessionUsage(this.state.chatSessions, event.sessionId, event.session.usage);
+						chatSessions = withSessionModes(chatSessions, event.sessionId, event.session.modes);
 						this.mutate({
 							sessions,
+							...chatSessions === this.state.chatSessions ? {} : { chatSessions },
 							...this.watchedSessionPatch(event.sessionId, event.session)
 						});
 						return Promise.resolve();
@@ -1550,11 +1793,18 @@ window.__ModuleLoader__.load({
 						const closedTranscripts = { ...this.state.chatTranscripts };
 						delete closedTranscripts[event.sessionId];
 						const chatSessions = this.state.chatSessions.filter((s) => s.sessionId !== event.sessionId);
+						const hadBurst = this.state.burstStats[event.sessionId] !== void 0;
+						let burstStats = this.state.burstStats;
+						if (hadBurst) {
+							burstStats = { ...burstStats };
+							delete burstStats[event.sessionId];
+						}
 						this.mutate({
 							sessions,
 							activeSessionId: active,
 							chatTranscripts: closedTranscripts,
 							...chatSessions.length !== this.state.chatSessions.length ? { chatSessions } : {},
+							...hadBurst ? { burstStats } : {},
 							permissions: this.state.permissions.filter((p) => p.sessionId !== event.sessionId),
 							...event.reason === "agent-died" ? this.logPatch("error", this.locale("会话因 agent 进程退出而终止", "session ended: agent process died"), closingSession?.agentId) : {}
 						});
@@ -1563,10 +1813,7 @@ window.__ModuleLoader__.load({
 					case "session/released": {
 						const sessions = this.state.sessions.some((s) => s.sessionId === event.sessionId) ? this.state.sessions.map((s) => s.sessionId === event.sessionId ? event.session : s) : [...this.state.sessions, event.session];
 						this.openTurns.delete(event.sessionId);
-						const chatSessions = this.state.chatSessions.some((s) => s.sessionId === event.sessionId) ? this.state.chatSessions.map((s) => s.sessionId === event.sessionId ? {
-							...s,
-							released: true
-						} : s) : this.state.chatSessions;
+						const chatSessions = withSessionReleased(this.state.chatSessions, event.sessionId, true);
 						const cause = event.cause ?? "died";
 						let log = {};
 						if (cause === "workspace") log = this.logPatch("info", this.locale("agent 为切换工作区重启，会话已挂起；再次发送消息将自动恢复。", "agent restarted for its workspace; the session is paused and will resume on your next message."), event.session.agentId);
@@ -1588,8 +1835,10 @@ window.__ModuleLoader__.load({
 						const isActive = event.sessionId === this.state.activeSessionId;
 						const sessions = this.state.sessions.some((s) => s.sessionId === event.sessionId) ? this.state.sessions.map((s) => s.sessionId === event.sessionId ? event.session : s) : [...this.state.sessions, event.session];
 						const watched = this.state.chatTranscripts[event.sessionId];
+						const chatSessions = withSessionReleased(this.state.chatSessions, event.sessionId, false);
 						this.mutate({
 							sessions,
+							...chatSessions === this.state.chatSessions ? {} : { chatSessions },
 							...isActive ? { blocks: [] } : {},
 							...watched === void 0 ? {} : { chatTranscripts: {
 								...this.state.chatTranscripts,
@@ -1677,9 +1926,28 @@ window.__ModuleLoader__.load({
 						});
 						return Promise.resolve();
 					}
-					case "turn/start":
+					case "turn/metrics": {
+						const prior = this.state.burstStats[event.sessionId];
+						if (event.final === false && prior !== void 0 && prior.final === true && prior.turnId === event.turnId) return Promise.resolve();
+						this.mutate({ burstStats: {
+							...this.state.burstStats,
+							[event.sessionId]: {
+								outputTokens: event.outputTokens,
+								burstMs: event.burstMs,
+								turnId: event.turnId,
+								final: event.final
+							}
+						} });
+						return Promise.resolve();
+					}
+					case "turn/start": {
 						this.openTurns.add(event.sessionId);
 						this.markWatchedRunning(event.sessionId, true);
+						const chatSessionId = this.state.chatSessionsFor;
+						if (chatSessionId !== void 0 && !this.state.chatSessions.some((row) => row.sessionId === event.sessionId) && !this.chatSessionRowReads.has(event.sessionId)) {
+							this.chatSessionRowReads.add(event.sessionId);
+							this.loadChatSessions(chatSessionId);
+						}
 						if (event.sessionId === this.state.activeSessionId) {
 							this.state.blocks.push({
 								kind: "user",
@@ -1692,6 +1960,7 @@ window.__ModuleLoader__.load({
 							} : s) });
 						}
 						return Promise.resolve();
+					}
 					case "turn/end":
 						if (!this.openTurns.has(event.sessionId)) return Promise.resolve();
 						this.openTurns.delete(event.sessionId);
@@ -1873,6 +2142,113 @@ window.__ModuleLoader__.load({
 			"usage_update",
 			"session_info_update"
 		]);
+		/**
+		* Context occupancy carried by one raw `usage_update` frame, in the shape the
+		* session snapshots already use. A malformed frame is ignored (the last good
+		* sample stays on screen) instead of zeroing the meter.
+		*/
+		function usageFromUpdate(update) {
+			const used = update.used;
+			const size = update.size;
+			if (typeof used !== "number" || !Number.isFinite(used)) return void 0;
+			if (typeof size !== "number" || !Number.isFinite(size)) return void 0;
+			const cost = update.cost;
+			if (cost !== null && typeof cost === "object" && !Array.isArray(cost)) {
+				const row = cost;
+				if (typeof row.amount === "number" && Number.isFinite(row.amount) && typeof row.currency === "string" && row.currency !== "") return {
+					used,
+					size,
+					cost: {
+						amount: row.amount,
+						currency: row.currency
+					}
+				};
+			}
+			return {
+				used,
+				size
+			};
+		}
+		function sameUsage(left, right) {
+			if (left === right) return true;
+			if (left === void 0 || right === void 0) return false;
+			if (left.used !== right.used || left.size !== right.size) return false;
+			const leftCost = left.cost;
+			const rightCost = right.cost;
+			if (leftCost === void 0 || rightCost === void 0) return leftCost === rightCost;
+			return leftCost.amount === rightCost.amount && leftCost.currency === rightCost.currency;
+		}
+		/** Patch one session row's usage; other rows and an unchanged value keep their identities. */
+		function withSessionUsage(rows, sessionId, usage) {
+			let changed = false;
+			const next = rows.map((row) => {
+				if (row.sessionId !== sessionId || sameUsage(row.usage, usage)) return row;
+				changed = true;
+				return {
+					...row,
+					usage
+				};
+			});
+			return changed ? next : rows;
+		}
+		/**
+		* Flip one chat row's `released` flag (release/resume bookkeeping). The
+		* composer's own list (`session/chat-list` rows) has no other live writer —
+		* `session/released` must mark it, `session/reset` must un-mark it, or the
+		* agent tag's halo and the released banner read yesterday's process state.
+		*/
+		function withSessionReleased(rows, sessionId, released) {
+			let changed = false;
+			const next = rows.map((row) => {
+				if (row.sessionId !== sessionId || row.released === true === released) return row;
+				changed = true;
+				return {
+					...row,
+					released
+				};
+			});
+			return changed ? next : rows;
+		}
+		function sameModes(a, b) {
+			if (a === b) return true;
+			if (!a || !b) return false;
+			if (a.currentModeId !== b.currentModeId) return false;
+			const aModes = a.availableModes ?? [];
+			const bModes = b.availableModes ?? [];
+			if (aModes.length !== bModes.length) return false;
+			return aModes.every((m, i) => {
+				const o = bModes[i];
+				return m != null && o != null && m.id === o.id && m.name === o.name && m.description === o.description;
+			});
+		}
+		function withSessionModes(rows, sessionId, modes) {
+			if (!modes) return rows;
+			let changed = false;
+			const next = rows.map((row) => {
+				if (row.sessionId !== sessionId || sameModes(row.modes, modes)) return row;
+				changed = true;
+				return {
+					...row,
+					modes
+				};
+			});
+			return changed ? next : rows;
+		}
+		function splitModelAgentId(modelId) {
+			const at = modelId.indexOf("@");
+			return (at === -1 ? modelId.trim() : at === 0 ? "" : modelId.slice(0, at).trim()) || void 0;
+		}
+		/** Last well-formed `usage_update` in one coalesced batch (later ticks win). */
+		function usageOfBatch(items) {
+			let usage;
+			for (const item of items) {
+				const update = item.update;
+				if (update.sessionUpdate !== "usage_update") continue;
+				const parsed = usageFromUpdate(update);
+				if (parsed !== void 0) usage = parsed;
+			}
+			return usage;
+		}
 		function trimBlocks(blocks) {
 			if (blocks.length > MAX_BLOCKS) blocks.splice(0, blocks.length - MAX_BLOCKS);
 		}
@@ -1992,6 +2368,13 @@ window.__ModuleLoader__.load({
 		/**
 		* 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
@@ -1999,8 +2382,13 @@ window.__ModuleLoader__.load({
 		* 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.
 		*/
-		function stagedSessionOf(snapshot) {
+		function stagedSessionOf(snapshot, currentSessionId) {
 			if (snapshot === void 0) return void 0;
 			if (snapshot.current !== void 0) return {
 				sessionId: snapshot.current,
@@ -2008,6 +2396,15 @@ window.__ModuleLoader__.load({
 				subagent: snapshot.currentAddress !== void 0
 			};
 			const byId = snapshot.byId ?? {};
+			if (currentSessionId !== void 0) {
+				const row = byId[currentSessionId];
+				if (row === void 0) return void 0;
+				return {
+					sessionId: currentSessionId,
+					row,
+					subagent: row.origin === "subagent"
+				};
+			}
 			const order = /* @__PURE__ */ new Map();
 			for (const [index, id] of (snapshot.ids ?? []).entries()) order.set(id, index);
 			const rank = (id) => order.get(id) ?? Number.MAX_SAFE_INTEGER;
@@ -2021,8 +2418,8 @@ window.__ModuleLoader__.load({
 			};
 		}
 		/** Whether the staged session runs the ACP agent preset. */
-		function stagedIsAcpMode(snapshot, acpMode) {
-			const staged = stagedSessionOf(snapshot);
+		function stagedIsAcpMode(snapshot, acpMode, currentSessionId) {
+			const staged = stagedSessionOf(snapshot, currentSessionId);
 			if (staged === void 0 || staged.subagent) return false;
 			const listed = rowAgentPreset(staged.row);
 			if (listed !== void 0) return listed === "acp";
@@ -2514,6 +2911,15 @@ window.__ModuleLoader__.load({
 .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
@@ -2689,6 +3095,79 @@ window.__ModuleLoader__.load({
 .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
@@ -3146,22 +3625,14 @@ window.__ModuleLoader__.load({
 		* def (env / npmPackage / exposedModels included); the synthesized fallback
 		* covers only the fields an `AgentView` carries, so anything else compares as
 		* "changed" — the honest answer when the host never reported it.
+		*
+		* The idle-release field is compared AS STORED: an absent per-agent field
+		* means "follow the global window", and the host's resolved value must not be
+		* written back into it — that would freeze the global window into this agent's
+		* definition and the global slider would then never reach it.
 		*/
-		/**
-		* The idle-release window in effect for an agent: an unset per-agent field is
-		* resolved by the HOST and reported back on `AgentView`, so filling it from
-		* there keeps "unset" and "explicitly the host default" the same state —
-		* merely opening the form must never read as an unsaved change.
-		*/
-		function resolvedIdleTimeoutMs(def, activeAgent) {
-			if (def.idleTimeoutMs !== void 0 || activeAgent?.idleTimeoutMs === void 0) return def;
-			return {
-				...def,
-				idleTimeoutMs: activeAgent.idleTimeoutMs
-			};
-		}
 		function persistedDef(detected, activeAgent) {
-			if (detected.currentConfig !== void 0) return resolvedIdleTimeoutMs(detected.currentConfig, activeAgent);
+			if (detected.currentConfig !== void 0) return detected.currentConfig;
 			if (activeAgent === void 0) return void 0;
 			return {
 				id: activeAgent.id,
@@ -3170,8 +3641,7 @@ window.__ModuleLoader__.load({
 				args: [...activeAgent.args],
 				...activeAgent.cwd === void 0 ? {} : { cwd: activeAgent.cwd },
 				allowedCwdRoots: [...activeAgent.allowedCwdRoots],
-				env: {},
-				...activeAgent.idleTimeoutMs === void 0 ? {} : { idleTimeoutMs: activeAgent.idleTimeoutMs }
+				env: {}
 			};
 		}
 		/**
@@ -3192,7 +3662,7 @@ window.__ModuleLoader__.load({
 			if (exposureKey(payload.exposedModels) !== exposureKey(current.exposedModels)) return false;
 			if (mcpKey(payload.mcpServers) !== mcpKey(current.mcpServers)) return false;
 			if (payload.autoDiscoverModels !== false !== (current.autoDiscoverModels !== false)) return false;
-			if (payload.idleTimeoutMs !== void 0 && payload.idleTimeoutMs !== current.idleTimeoutMs) return false;
+			if (payload.idleTimeoutMs !== current.idleTimeoutMs) return false;
 			return true;
 		}
 		/**
@@ -3501,6 +3971,118 @@ window.__ModuleLoader__.load({
 			});
 		}
 		/**
+		* The idle-release window, as the settings page edits it.
+		*
+		* ONE control, because there is ONE window: how long a chat process may sit
+		* idle before it is parked. The slider snaps to the shared ladder
+		* ({@link IDLE_RELEASE_MS}), so every rung it offers is a window the host can
+		* run.
+		*
+		* The card reports the deployment baseline as the fact being overridden, and
+		* offers a reset ONLY when something is really overridden — the same rule the
+		* approval deadline card follows.
+		*/
+		function IdleReleaseCard(props) {
+			const { acp, ui } = props;
+			const release = ui.idleRelease;
+			if (release === void 0) return null;
+			const baseline = release.defaultIdleTimeoutMs;
+			const overridden = release.idleTimeoutMs !== baseline;
+			const index = IDLE_RELEASE_MS.indexOf(release.idleTimeoutMs);
+			const exact = index >= 0;
+			const shown = exact ? release.idleTimeoutMs : nearestIdleRung(release.idleTimeoutMs);
+			const note = release.configuredIdleTimeoutMs === void 0 || release.configuredIdleTimeoutMs === release.idleTimeoutMs ? void 0 : acp.label(`配置文件（cordis.patch.yml）设为 ${idleWindowText(release.configuredIdleTimeoutMs, acp)}，此处设置优先。`, `The config file (cordis.patch.yml) asks for ${idleWindowText(release.configuredIdleTimeoutMs, acp)}; the value set here wins.`);
+			const resetLabel = release.configuredIdleTimeoutMs === void 0 ? acp.label("恢复默认值", "Restore default") : acp.label("恢复配置文件的值", "Use config file value");
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+				className: "dwa-section",
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+					className: "dwa-section-heading",
+					children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+						className: "dwa-section-title",
+						children: acp.label("空闲释放", "Idle release")
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "dwa-section-copy",
+						children: acp.label("空闲多久后挂起聊天进程。", "How long an idle chat process is kept before it is parked.")
+					})] })
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					className: "dwa-preferences",
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dwa-preference-block",
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								className: "dwa-preference-label",
+								children: acp.label("释放窗口", "Release window")
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								className: "dwa-deadline-value",
+								children: idleWindowText(release.idleTimeoutMs, acp)
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+								className: "dwa-deadline-range",
+								type: "range",
+								min: 0,
+								max: IDLE_RELEASE_MS.length - 1,
+								step: 1,
+								value: exact ? index : IDLE_RELEASE_MS.indexOf(shown),
+								"aria-label": acp.label("释放窗口", "Release window"),
+								onChange: (event) => {
+									const next = IDLE_RELEASE_MS[Number(event.target.value)];
+									if (next !== void 0 && next !== release.idleTimeoutMs) acp.setIdleRelease(next);
+								}
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								className: "dwa-deadline-ticks",
+								children: IDLE_RELEASE_MS.filter((_, i) => i % 2 === 0).map((ms) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: idleWindowText(ms, acp) }, ms))
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								className: "dwa-preference-copy",
+								children: acp.label("挂起后会话仍保留，下一条消息自动恢复。", "A parked session is kept; the next message resumes it.")
+							}),
+							note !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								className: "dwa-deadline-flag",
+								children: ["⚠ ", note]
+							})
+						]
+					}), overridden && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						className: "dwa-deadline-reset",
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							className: "dwa-btn dwa-btn-secondary",
+							onClick: () => void acp.resetIdleRelease(),
+							children: resetLabel
+						})
+					})]
+				})]
+			});
+		}
+		/**
+		* The rung nearest a window that is not on the ladder — used only to park the
+		* thumb; the readout always prints the exact value.
+		*/
+		function nearestIdleRung(ms) {
+			let best = IDLE_RELEASE_MS[0];
+			let bestDistance = Number.POSITIVE_INFINITY;
+			for (const rung of IDLE_RELEASE_MS) {
+				const distance = Math.abs(rung - ms);
+				if (distance < bestDistance) {
+					bestDistance = distance;
+					best = rung;
+				}
+			}
+			return best;
+		}
+		/**
+		* `30 分钟` — the readout and the tick label, one formatter.
+		*
+		* ALWAYS minutes, even at the top of the ladder: a scale that runs "1 分钟"
+		* to "50 分钟" and then "1 小时" reads as two different scales.
+		*/
+		function idleWindowText(ms, acp) {
+			if (ms <= 0) return acp.label("永不释放", "Never");
+			const minutes = Math.round(ms / 6e4);
+			return acp.label(`${String(minutes)} 分钟`, `${String(minutes)}m`);
+		}
+		/**
 		* Local wall-clock `HH:MM:SS` for one runtime-log line. Hand-built on purpose:
 		* `toLocaleTimeString` may drop seconds or pick a 12-hour clock depending on
 		* the browser locale, which makes the column ragged and ambiguous.
@@ -3826,6 +4408,12 @@ window.__ModuleLoader__.load({
 								onClick: () => setPage("approvals"),
 								children: acp.label("审批时限", "Approval deadlines")
 							}),
+							ui.idleRelease !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								"aria-pressed": page === "processes",
+								onClick: () => setPage("processes"),
+								children: acp.label("进程管理", "Processes")
+							}),
 							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 								type: "button",
 								"aria-pressed": page === "appearance",
@@ -4029,6 +4617,13 @@ window.__ModuleLoader__.load({
 							ui
 						})
 					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						hidden: page !== "processes",
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IdleReleaseCard, {
+							acp,
+							ui
+						})
+					}),
 					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 						className: "dwa-section",
 						hidden: page !== "appearance",
@@ -4421,13 +5016,6 @@ window.__ModuleLoader__.load({
 			});
 		}
 		/**
-		* Hand copy of `DEFAULT_TUNING.idleTimeoutMs` (src/bridge.ts): the browser
-		* cannot import the host plane, and this number is only ever placeholder text
-		* for a NOT-yet-configured agent (a configured one renders the host's resolved
-		* value from `AgentView.idleTimeoutMs`). Keep the two in sync.
-		*/
-		const DEFAULT_IDLE_RELEASE_MS = 18e5;
-		/**
 		* Hand copy of `DEFAULT_TUNING.probeIdleTimeoutMs` (src/bridge.ts). A process
 		* that has never hosted a session — the model probe / post-save probe — lives
 		* by THIS window whatever the agent's own field says, so the placeholder has to
@@ -4451,7 +5039,7 @@ window.__ModuleLoader__.load({
 				})),
 				exposed: config?.exposedModels === void 0 ? void 0 : [...config.exposedModels],
 				autoDiscoverModels: config?.autoDiscoverModels !== false,
-				idleStr: idleText(activeAgent?.idleTimeoutMs ?? config?.idleTimeoutMs),
+				idleStr: idleText(config?.idleTimeoutMs),
 				mcpText: config?.mcpServers === void 0 ? "" : JSON.stringify(config.mcpServers, null, 2)
 			};
 		}
@@ -4652,18 +5240,18 @@ window.__ModuleLoader__.load({
 								children: [
 									/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
 										className: "dwa-form-label",
-										children: acp.label("空闲释放（毫秒）", "Idle Release (ms)")
+										children: acp.label("空闲释放覆盖（毫秒）", "Idle Release Override (ms)")
 									}),
 									/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
 										className: "dwa-input dwa-input-mono",
-										"aria-label": acp.label("空闲释放（毫秒）", "Idle Release (ms)"),
+										"aria-label": acp.label("空闲释放覆盖（毫秒）", "Idle Release Override (ms)"),
 										value: form.idleStr,
 										onChange: (e) => patch({ idleStr: e.target.value }),
-										placeholder: acp.label(`留空 = 宿主默认（承载会话 ${String(DEFAULT_IDLE_RELEASE_MS / 6e4)} 分钟 / 探测进程 ${String(DEFAULT_PROBE_RELEASE_MS / 6e4)} 分钟）`, `Blank = host default (${String(DEFAULT_IDLE_RELEASE_MS / 6e4)} min for a chat process / ${String(DEFAULT_PROBE_RELEASE_MS / 6e4)} min for a probe)`)
+										placeholder: acp.label(`留空 = 跟随全局设置（探测进程固定 ${String(DEFAULT_PROBE_RELEASE_MS / 6e4)} 分钟）`, `Blank = follow the global setting (probes always release after ${String(DEFAULT_PROBE_RELEASE_MS / 6e4)} min)`)
 									}),
 									/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 										className: idleInvalid ? "dwa-error" : "dwa-hint",
-										children: idleInvalid ? acp.label("必须是 0（永不释放）或 [1000, 86400000] 之间的整数毫秒。", "Must be 0 (never release) or an integer in [1000, 86400000] ms.") : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: acp.label("承载过会话的进程空闲后挂起；0 不释放，探测进程固定 5 分钟。", "Park idle chat processes; 0 keeps them alive. Probe processes always release after 5 minutes.") })
+										children: idleInvalid ? acp.label("必须是 0（永不释放）或 [1000, 86400000] 之间的整数毫秒。", "Must be 0 (never release) or an integer in [1000, 86400000] ms.") : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: acp.label("仅覆盖此智能体；留空即跟随「进程管理」的全局设置。", "Overrides this agent only; leave blank to follow the global setting in “Processes”.") })
 									})
 								]
 							})
@@ -5478,6 +6066,34 @@ window.__ModuleLoader__.load({
 		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.
+		*/
+		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.
+		*/
+		function modeInForce(target, persisted, fallback) {
+			return (target !== void 0 && target.released !== true ? target.modes?.currentModeId : void 0) ?? persisted ?? target?.modes?.currentModeId ?? fallback ?? "";
+		}
 		function AcpComposerMode({ acp, sessionId, useSession }) {
 			const ui = useUi(acp);
 			const dshSessionId = String(sessionId);
@@ -5492,7 +6108,7 @@ window.__ModuleLoader__.load({
 			]);
 			const bound = ui.chatSessionsFor === dshSessionId ? ui.chatSessions : [];
 			const target = bound.find((session) => !session.released) ?? bound[0];
-			const isAcp = target !== void 0 || ui.acpMode[dshSessionId] === true;
+			const isAcp = agentModeVisible(ui.acpMode[dshSessionId], target !== void 0);
 			const agentId = target?.agentId ?? ui.chatLockedAgent[dshSessionId] ?? ui.chatBoundAgent[dshSessionId] ?? ui.chatChoice[dshSessionId]?.agentId ?? (isAcp ? ui.defaultAgent : void 0);
 			const catalog = agentId === void 0 ? void 0 : ui.seatCatalogs[agentId];
 			(0, react.useEffect)(() => {
@@ -5504,15 +6120,15 @@ window.__ModuleLoader__.load({
 				isAcp,
 				target
 			]);
+			if (!isAcp) return null;
 			const live = target?.modes?.availableModes ?? [];
-			const modes = live.length > 0 ? live : (isAcp ? catalog?.mode?.choices ?? [] : []).map((choice) => ({
+			const modes = live.length > 0 ? live : (catalog?.mode?.choices ?? []).map((choice) => ({
 				id: choice.id,
 				name: choice.name,
 				description: choice.description
 			}));
 			if (modes.length === 0) return null;
-			const persisted = ui.chatChoice[dshSessionId]?.agentId === agentId ? ui.chatChoice[dshSessionId]?.mode : void 0;
-			const current = target?.modes?.currentModeId ?? persisted ?? catalog?.mode?.currentValue ?? modes[0]?.id ?? "";
+			const current = modeInForce(target, ui.chatChoice[dshSessionId]?.agentId === agentId ? ui.chatChoice[dshSessionId]?.mode : void 0, catalog?.mode?.currentValue ?? modes[0]?.id);
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
 				style: {
 					display: "inline-flex",
@@ -5548,6 +6164,109 @@ window.__ModuleLoader__.load({
 				})
 			});
 		}
+		//#endregion
+		//#region src/client/context-meter.tsx
+		/**
+		* 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`).
+		*/
+		/**
+		* 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.
+		*/
+		function acpMeterUsage(ui, dshSessionId) {
+			if (ui.acpMode[dshSessionId] === false) return void 0;
+			if (ui.chatSessionsFor !== dshSessionId) return void 0;
+			const live = ui.chatSessions.find((row) => !row.released);
+			if (live === void 0 && ui.acpMode[dshSessionId] !== true) return void 0;
+			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%.
+		*/
+		function contextOccupancy(usage) {
+			if (usage === void 0) return void 0;
+			const { used, size } = usage;
+			if (!Number.isFinite(used) || !Number.isFinite(size) || used < 0 || size <= 0) return void 0;
+			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. */
+		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;
+		function AcpContextMeter({ acp, sessionId, useSession }) {
+			ensureAcpStyle();
+			const ui = useUi$2(acp);
+			const dshSessionId = String(sessionId);
+			const running = useSession((snapshot) => snapshot.running);
+			(0, react.useEffect)(() => {
+				acp.loadChatSessions(dshSessionId);
+			}, [
+				acp,
+				dshSessionId,
+				running
+			]);
+			const context = contextOccupancy(acpMeterUsage(ui, dshSessionId));
+			if (context === void 0) 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 /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+				className: "ntr-acp-meter",
+				role: "img",
+				"aria-label": title,
+				title,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("svg", {
+					viewBox: "0 0 14 14",
+					width: "14",
+					height: "14",
+					"aria-hidden": "true",
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("circle", {
+						className: "ntr-acp-meter-track",
+						cx: "7",
+						cy: "7",
+						r: RADIUS
+					}), /* @__PURE__ */ (0, react_jsx_runtime.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)"
+					})]
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+					className: "ntr-acp-meter-percent",
+					children: [context.percent, "%"]
+				})]
+			});
+		}
 		const phases = /* @__PURE__ */ new Map();
 		/** The reveal serial whose ceremony has already played (or was skipped). */
 		const consumed = /* @__PURE__ */ new Map();
@@ -5840,8 +6559,8 @@ window.__ModuleLoader__.load({
 			if (agentId === void 0) return { efforts: [] };
 			const agentTitle = agents.find((agent) => agent.id === agentId)?.title ?? bound?.agentTitle ?? catalog?.title ?? agentId;
 			const pick = choice !== void 0 && choice.agentId === agentId ? choice : void 0;
-			const modelId = bound?.modelId ?? pick?.modelId;
-			const effort = bound?.reasoningEffort ?? pick?.effort;
+			const modelId = bound?.released === true ? pick?.modelId ?? bound?.modelId : bound?.modelId ?? pick?.modelId;
+			const effort = bound?.released === true ? pick?.effort ?? bound?.reasoningEffort : bound?.reasoningEffort ?? pick?.effort;
 			const reasoning = catalog?.reasoning;
 			const agentModel = catalog?.currentModel;
 			if (bound === void 0 && pick === void 0 && agentModel === void 0) return {
@@ -6020,9 +6739,6 @@ window.__ModuleLoader__.load({
 				agentListed,
 				agentId
 			]);
-			const route = describeRoute(agents, bound, lockedTo === void 0 ? ui.defaultAgent : void 0, catalog, lockedTo ?? ui.chatBoundAgent[sessionId], choice);
-			if (!agentBaseHasData(bound, agents, ui.agentsLoaded)) return null;
-			const routed = route.agentId !== void 0;
 			(0, react.useEffect)(() => {
 				if (lockedTo === void 0 || menu === null) return;
 				if (menu.sessionId === sessionId && menu.kind === "agent") closeAcpMenu();
@@ -6032,6 +6748,10 @@ window.__ModuleLoader__.load({
 				menu?.kind,
 				sessionId
 			]);
+			const route = describeRoute(agents, bound, lockedTo === void 0 ? ui.defaultAgent : void 0, catalog, lockedTo ?? ui.chatBoundAgent[sessionId], choice);
+			if (!agentBaseHasData(bound, agents, ui.agentsLoaded)) return null;
+			const routed = route.agentId !== void 0;
+			if (ui.acpMode[sessionId] !== true) return null;
 			const shattering = lockPhase === "shatter" && lockedTo !== void 0;
 			const showAgentBase = !agentBaseHidden(lockedTo) || shattering;
 			const modelLabel = routed ? route.modelLabel : void 0;
@@ -6337,6 +7057,7 @@ window.__ModuleLoader__.load({
 				agentId
 			]);
 			if (menu === null || menu.sessionId !== sessionId) return null;
+			if (ui.acpMode[sessionId] !== true) return null;
 			const route = describeRoute(agents, bound, lockedTo === void 0 ? ui.defaultAgent : void 0, catalog, lockedTo ?? ui.chatBoundAgent[sessionId], choice);
 			let model;
 			try {
@@ -6781,6 +7502,19 @@ window.__ModuleLoader__.load({
 			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.
+		*/
+		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
 		* `boundAgentId`, which outlives a closed session), and the persisted pick.
@@ -6869,6 +7603,7 @@ window.__ModuleLoader__.load({
 				if (node === null || !pinned.current) return;
 				node.scrollTop = node.scrollHeight;
 			}, [blockCount, tail]);
+			if (ui.acpMode[sessionId] !== true) return null;
 			if (transcript === void 0) {
 				const empty = acpEmptyCopy({
 					bound: boundAgent,
@@ -6980,7 +7715,7 @@ window.__ModuleLoader__.load({
 					},
 					children: transcript.blocks.length === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 						className: "ntr-acp-empty-hint",
-						children: t("还没有消息：在下面的输入框里发给它。", "Nothing yet — send it a message below.")
+						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) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(BlockView, {
 						block,
 						label: acp.label,
@@ -7184,6 +7919,234 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
+		//#region src/client/released-banner.tsx
+		/**
+		* The conversation's released-session banner: one row above the composer
+		* (`conversation.input.dock`) saying the agent process behind this
+		* conversation has been released, with the explicit resume button.
+		*
+		* WHY A BANNER: releasing a process is deliberately silent (constraint 19 —
+		* an idle teardown is the expected lifecycle, no `agent/notice`), and the
+		* only other trace was the NTR view tab's status badge — a surface most
+		* users never open. The "your next message resumes it" promise is real but
+		* unverifiable from the chat itself, so the banner states it here and the
+		* button turns it into a gesture (`session/chat-resume`), the explicit form
+		* of the same recovery the next prompt performs lazily.
+		*
+		* The gate is a pure function ({@link releasedBannerVisible}) — the seam the
+		* composer's other visibility decisions use, so the rules are testable with
+		* no DOM. Like the agent tag and the context ring, an explicit
+		* `acpMode === false` outranks a lingering `chatSessions` row: a conversation
+		* that left NTR mode must not keep claiming a parked NTR process.
+		*/
+		/**
+		* Whether the banner should render: this conversation's ACP session records
+		* are all released — the process is parked (idle release or crash) and
+		* nothing is live to serve the next message yet. An empty list (no agent has
+		* run here) and a live row anywhere both mean "nothing to recover", so the
+		* banner stays out of the way.
+		*/
+		function releasedBannerVisible(ui, dshSessionId) {
+			if (ui.acpMode[dshSessionId] === false) return false;
+			if (ui.chatSessionsFor !== dshSessionId) return false;
+			return ui.chatSessions.length > 0 && ui.chatSessions.every((row) => row.released === true);
+		}
+		function ReleasedBanner({ acp, sessionId }) {
+			ensureAcpStyle();
+			const ui = useUi$2(acp);
+			const dshSessionId = String(sessionId);
+			const [busy, setBusy] = (0, react.useState)(false);
+			const [error, setError] = (0, react.useState)();
+			(0, react.useEffect)(() => {
+				acp.loadChatSessions(dshSessionId);
+			}, [acp, dshSessionId]);
+			if (!releasedBannerVisible(ui, dshSessionId)) return null;
+			const resume = () => {
+				if (busy) return;
+				setBusy(true);
+				setError(void 0);
+				acp.resumeChatSession(dshSessionId).catch((failure) => {
+					setError(failure instanceof Error ? failure.message : String(failure));
+				}).finally(() => {
+					setBusy(false);
+				});
+			};
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "ntr-released-banner",
+				role: "region",
+				"aria-label": acp.label("进程已释放", "Process released"),
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					className: "ntr-released-banner-row",
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "ntr-released-banner-text",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "ntr-released-banner-title",
+							children: acp.label("进程已释放", "Process released")
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "ntr-released-banner-body",
+							children: acp.label("上下文已保留；下一条消息将自动恢复，或点击【恢复进程】按钮。", "Context is kept — your next message resumes it, or click [Resume process].")
+						})]
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+						type: "button",
+						className: "ntr-acp-more is-primary",
+						disabled: busy,
+						title: acp.label("立即拉起 agent 进程并恢复这个会话", "Bring the agent process back and restore this session now"),
+						onClick: resume,
+						children: busy ? acp.label("正在恢复…", "Resuming…") : acp.label("恢复进程", "Resume process")
+					})]
+				}), error !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+					className: "ntr-permission-error",
+					role: "alert",
+					children: error
+				})]
+			});
+		}
+		//#endregion
+		//#region src/client/branch-action.tsx
+		/**
+		* 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.
+		*/
+		/**
+		* 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.
+		*/
+		function resolveHostFork(sessionsService) {
+			try {
+				const sessions = sessionsService;
+				const fork = sessions?.fork;
+				return typeof fork === "function" ? { fork: fork.bind(sessions) } : void 0;
+			} catch {
+				return;
+			}
+		}
+		/**
+		* 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.
+		*/
+		function branchIconOf(source) {
+			return source.IconBranchOutline16 ?? source.IconBranchOutlineRegular ?? source.IconBranchOutlineMedium;
+		}
+		const BranchIcon = branchIconOf(_deepseek_ai_dsh_client_ui_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");
+			}
+		}
+		function AcpBranchAction(props) {
+			const ui = useUi$2(props.acp);
+			const buttonRef = (0, react.useRef)(null);
+			const [pending, setPending] = (0, react.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] = (0, react.useState)(false);
+			(0, react.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] = (0, react.useState)(void 0);
+			if (ui.acpMode[props.sessionId] !== true) return null;
+			if (ui.chatSessionsFor !== props.sessionId) return null;
+			const row = ui.chatSessionsFor === props.sessionId ? ui.chatSessions[0] : void 0;
+			const forkFace = props.hostFork?.();
+			const liveRunning = row !== void 0 && ui.sessions.some((s) => s.sessionId === row.sessionId && s.running);
+			const state = forkStateOf(row, forkFace !== void 0, 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(void 0);
+				props.acp.forkChatSession(props.sessionId, (sessionId) => {
+					const face = props.hostFork?.();
+					if (face === void 0) throw new Error("acp: host fork service is gone");
+					return face.fork({
+						sessionId,
+						increaseTitle: true
+					});
+				}).then((outcome) => {
+					if ("childId" in outcome) props.openSession?.(outcome.childId);
+					else setFailure(outcome.failure);
+				}).finally(() => {
+					setPending(false);
+				});
+			};
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Tooltip, {
+				label: tooltipFor(state, props.acp.label),
+				side: "bottom",
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+					ref: buttonRef,
+					type: "button",
+					className: "ntr-branch-action",
+					"aria-label": branchLabel,
+					"aria-disabled": disabled || void 0,
+					"data-ntr-branch": "",
+					"data-unavailable": disabled || void 0,
+					onClick: disabled ? void 0 : onClick,
+					children: BranchIcon === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(BranchIcon, {})
+				})
+			}), failure !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+				className: "ntr-branch-error",
+				role: "alert",
+				title: failure,
+				children: failure
+			})] });
+		}
+		//#endregion
 		//#region src/client/model-seat.tsx
 		/** Exact key of the composer's model seat (a `single`, session-scoped slot). */
 		const MODEL_SEAT_KEY = "conversation.input.model";
@@ -7206,7 +8169,7 @@ window.__ModuleLoader__.load({
 		* `entriesOfSlot` and performing bounded retakes if displaced by later registrations.
 		*/
 		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 ?? 4;
@@ -7236,10 +8199,11 @@ window.__ModuleLoader__.load({
 				};
 				try {
 					const heads = slots.entriesOfSlot(slotKey) ?? [];
+					const entry = entryId === void 0 ? heads[0] : heads.find((head) => head.options?.id === entryId);
 					return {
 						declared: isDeclared,
 						verified: true,
-						...heads[0] === void 0 ? {} : { entry: heads[0] }
+						...entry === void 0 ? {} : { entry }
 					};
 				} catch {
 					return {
@@ -7260,6 +8224,9 @@ window.__ModuleLoader__.load({
 				try {
 					installed.push(slots.inject(slotKey, () => slots.register({
 						name: slotKey,
+						...entryId === void 0 ? {} : { id: entryId },
+						...options.order === void 0 ? {} : { order: options.order },
+						...options.locale === void 0 ? {} : { locale: options.locale },
 						priority: rank,
 						...inject ? { inject } : {}
 					}, component)));
@@ -7371,6 +8338,159 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
+		//#region src/client/activity-pill.tsx
+		/**
+		* 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.
+		*/
+		const DOCK_SLOT = "conversation.composer.dock";
+		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.
+		*/
+		function activityBurst(ui, dshSessionId) {
+			if (ui.chatSessionsFor !== dshSessionId) return void 0;
+			let outputTokens = 0;
+			let burstMs = 0;
+			for (const row of ui.chatSessions) {
+				const measured = ui.burstStats[row.sessionId] ?? row.burst;
+				if (measured === void 0) continue;
+				outputTokens += measured.outputTokens;
+				burstMs += measured.burstMs;
+			}
+			return outputTokens > 0 && burstMs > 0 ? {
+				outputTokens,
+				burstMs
+			} : void 0;
+		}
+		/**
+		* 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.
+		*/
+		function patchedActivityStats(native, burst, acp) {
+			if (!acp || native === void 0) return native;
+			if (burst !== void 0 && 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$2(props.acp);
+			const dshSessionId = String(props.sessionId);
+			const acpMode = ui.acpMode[dshSessionId] === true;
+			const native = props.useProjection("sessionStats");
+			const burst = acpMode ? activityBurst(ui, dshSessionId) : void 0;
+			const stats = (0, react.useMemo)(() => patchedActivityStats(native, burst, acpMode), [
+				native,
+				burst?.outputTokens,
+				burst?.burstMs,
+				acpMode
+			]);
+			const projection = (0, react.useMemo)(() => (key, selector) => {
+				if (key !== "sessionStats") return void 0;
+				return selector === void 0 ? stats : selector(stats);
+			}, [stats]);
+			return (0, react.createElement)(Host, {
+				useChat: props.useChat,
+				useProjection: acpMode ? projection : props.useProjection,
+				usePerformanceUsage: props.usePerformanceUsage,
+				t: props.t
+			});
+		}
+		function findHostActivity(slots) {
+			try {
+				if (slots.spec?.("conversation.composer.dock")?.kind !== "list") return void 0;
+				return (slots.entriesOfSlot?.("conversation.composer.dock") ?? []).find((entry) => entry.options?.id === ACTIVITY_ENTRY_ID);
+			} catch {
+				return;
+			}
+		}
+		/**
+		* 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.
+		*/
+		function createActivityPillClaim(options) {
+			const host = findHostActivity(options.slots);
+			if (host === void 0 || host.component === void 0 || typeof host.inject !== "function" || typeof host.locale !== "string" || host.locale === "") {
+				options.onDiag?.("activity pill: host entry not available");
+				return;
+			}
+			let performanceUsage;
+			try {
+				performanceUsage = host.inject()?.hooks?.performanceUsage;
+			} catch {
+				performanceUsage = void 0;
+			}
+			if (performanceUsage === void 0) {
+				options.onDiag?.("activity pill: host performance hook missing");
+				return;
+			}
+			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) => (0, react.createElement)(ActivityPillOccupant, {
+					...props,
+					host: Host
+				}),
+				inject: (sessionId, actions) => ({
+					...options.inject(sessionId, actions),
+					hooks: { performanceUsage }
+				}),
+				label: "activity pill",
+				onDiag: options.onDiag,
+				maxClaims: options.maxClaims ?? 1
+			});
+		}
+		//#endregion
 		//#region src/client/slash-isolation.ts
 		/**
 		* Cross-instance marker. `apply()` can run again over the same live sources (a
@@ -7386,8 +8506,8 @@ window.__ModuleLoader__.load({
 		* caller reads as "not ACP" (fail-open: an ordinary conversation must never
 		* lose its native commands to a guess).
 		*/
-		function slashAcpVerdict(snapshot, sessionId, verdict) {
-			const staged = stagedSessionOf(snapshot);
+		function slashAcpVerdict(snapshot, sessionId, verdict, currentSessionId) {
+			const staged = stagedSessionOf(snapshot, currentSessionId);
 			if (staged !== void 0 && staged.sessionId === sessionId) {
 				const listed = rowAgentPreset(staged.row);
 				if (listed !== void 0) return listed === "acp";
@@ -7732,6 +8852,37 @@ window.__ModuleLoader__.load({
 		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;
+			if (document.querySelector("[data-turn-tail]") === null) return;
+			probedHostLabels = true;
+			if (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(", ")) === 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.
 		*
@@ -7807,11 +8958,31 @@ window.__ModuleLoader__.load({
 					return;
 				}
 			};
+			/**
+			* 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;
+				}
+			};
+			/** Focus a session in the workspace (the branch click's last step). */
+			const openSession = (sessionId) => {
+				try {
+					service("uiWorkspace")?.openSession?.(sessionId);
+				} catch {}
+			};
 			/** The injected face every ACP conversation entry receives. */
 			const chatFace = (sessionId) => ({
 				acp: store,
 				sessionId: String(sessionId),
-				faceFor
+				faceFor,
+				hostFork,
+				openSession
 			});
 			ctx.effect(() => ctx.slots.inject("settings.section", () => ctx.slots.register({
 				name: "settings.section",
@@ -7850,6 +9021,18 @@ window.__ModuleLoader__.load({
 				order: 10,
 				inject: (sessionId) => chatFace(sessionId)
 			}, PermissionDock)), "dsh-ntr: conversation permission dock");
+			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");
+			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 —
@@ -7861,6 +9044,28 @@ window.__ModuleLoader__.load({
 				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 !== void 0 && typeof current.getSnapshot === "function" ? current : void 0;
+				} catch {
+					return;
+				}
+			};
+			/** 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 : void 0;
+				} catch {
+					return;
+				}
+			};
+			/**
 			* 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
 			* ask is once per id so a host whose answer carries no `acpMode` cannot turn
@@ -7885,6 +9090,8 @@ window.__ModuleLoader__.load({
 			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
@@ -7921,6 +9128,66 @@ window.__ModuleLoader__.load({
 				*/
 				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;
+					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 = void 0;
+					try {
+						meterEntry?.();
+					} catch {}
+					meterEntry = void 0;
+				};
+				const holdAuxEntries = () => {
+					if (viewEntry === void 0) 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 = void 0;
+					}
+					if (meterEntry === void 0) 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 = void 0;
+					}
+				};
+				/**
 				* 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
 				* `catch { return [] }` and an outer `catch { … }` between them swallowed
@@ -7932,7 +9199,8 @@ window.__ModuleLoader__.load({
 				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
@@ -7949,6 +9217,8 @@ window.__ModuleLoader__.load({
 					seatDiag = reason;
 					permissionSeatDiag = `${reason} (released)`;
 					disarmVerdictReask();
+					setScopeMarker(false);
+					releaseAuxEntries();
 					if (claim !== void 0) {
 						claim.release();
 						claim = void 0;
@@ -7957,6 +9227,10 @@ window.__ModuleLoader__.load({
 						permissionClaim.release();
 						permissionClaim = void 0;
 					}
+					if (activityClaim !== void 0) {
+						activityClaim.release();
+						activityClaim = void 0;
+					}
 				};
 				/**
 				* Re-ask timer for the staged session, armed while the row is silent and a
@@ -7988,7 +9262,8 @@ window.__ModuleLoader__.load({
 						standDown("no session list service");
 						return;
 					}
-					const staged = stagedSessionOf(snapshot);
+					const current = currentScopeSessionId();
+					const staged = stagedSessionOf(snapshot, current);
 					if (staged === void 0) {
 						standDown("no staged session (nothing retains the main view)");
 						return;
@@ -8004,12 +9279,18 @@ window.__ModuleLoader__.load({
 						acpModeAsked.set(staged.sessionId, Date.now());
 						store.loadChatSessions(staged.sessionId, verdictHeld ? { settleVerdict: true } : void 0);
 					} else if (!verdictHeld && askedAt !== void 0) acpModeAsked.delete(staged.sessionId);
-					if (!stagedIsAcpMode(snapshot, acpModeVerdict)) {
+					if (!stagedIsAcpMode(snapshot, acpModeVerdict, current)) {
+						if (rowAgentPreset(staged.row) !== void 0) store.noteAcpMode(staged.sessionId, false);
 						standDown(`staged ${staged.sessionId} is not in ACP mode`);
 						return;
 					}
-					if (rowAgentPreset(staged.row) !== void 0) disarmVerdictReask();
+					if (rowAgentPreset(staged.row) !== void 0) {
+						store.noteAcpMode(staged.sessionId, rowAgentPreset(staged.row) === "acp");
+						disarmVerdictReask();
+					}
 					seatDiag = `staged ${staged.sessionId} is ACP mode`;
+					setScopeMarker(true);
+					probeHostActionLabels();
 					claim ??= createModelSeatClaim({
 						slots: ctx.slots,
 						occupant: () => AcpSessionControls,
@@ -8027,6 +9308,13 @@ window.__ModuleLoader__.load({
 						}
 					});
 					permissionClaim.sync();
+					activityClaim ??= createActivityPillClaim({
+						slots: ctx.slots,
+						inject: (sessionId) => chatFace(sessionId),
+						onDiag: noteActivityDiag
+					});
+					activityClaim?.sync();
+					holdAuxEntries();
 					if (rowAgentPreset(staged.row) === void 0) armVerdictReask();
 				};
 				let stopPreset;
@@ -8048,6 +9336,12 @@ window.__ModuleLoader__.load({
 				const attach = () => {
 					const list = sessionsList();
 					if (list !== void 0 && stopWatch === void 0) stopWatch = list.subscribe(runGate);
+					const current = currentScopeSource();
+					if (current?.subscribe !== void 0 && stopCurrent === void 0) try {
+						stopCurrent = current.subscribe(runGate);
+					} catch {
+						stopCurrent = void 0;
+					}
 					attachPresetFrames();
 					runGate();
 				};
@@ -8090,7 +9384,7 @@ window.__ModuleLoader__.load({
 				attach();
 				const stopStore = store.subscribe(runGate);
 				const stopCell = ctx.on("slots/changed", (...args) => {
-					if (args[0] !== "conversation.input.model" && args[0] !== "conversation.input.permission") return;
+					if (args[0] !== "conversation.input.model" && args[0] !== "conversation.input.permission" && args[0] !== "conversation.composer.dock") return;
 					runGate();
 				});
 				const stopService = ctx.on("internal/service", attach);
@@ -8100,7 +9394,10 @@ window.__ModuleLoader__.load({
 					stopCell();
 					stopPreset?.();
 					stopWatch?.();
+					stopCurrent?.();
 					disarmVerdictReask();
+					setScopeMarker(false);
+					releaseAuxEntries();
 					if (claim !== void 0) {
 						claim.release();
 						claim = void 0;
@@ -8109,6 +9406,10 @@ window.__ModuleLoader__.load({
 						permissionClaim.release();
 						permissionClaim = void 0;
 					}
+					if (activityClaim !== void 0) {
+						activityClaim.release();
+						activityClaim = void 0;
+					}
 					store.noteSeatDiag("gate disposed");
 					store.notePermissionSeatDiag("gate disposed");
 				};
@@ -8139,9 +9440,9 @@ window.__ModuleLoader__.load({
 						const sources = triggers.live?.sources;
 						return Array.isArray(sources) ? sources : void 0;
 					},
-					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 !== void 0) return known;
 						await store.loadChatSessions(sessionId);
@@ -8204,13 +9505,6 @@ window.__ModuleLoader__.load({
 					store.noteSlashDiag("idle");
 				};
 			}, "dsh-ntr: slash isolation");
-			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");
 		}
 		//#endregion
 		exports.apply = apply;