dsh-pause-session 0.1.0 → 0.2.1

package/lib/client.js

@@ -7,711 +7,40 @@ window.__ModuleLoader__.load({
 		let react_jsx_runtime = require("react/jsx-runtime");
 		let react = require("react");
 		let _deepseek_ai_dsh_client_store = require("@deepseek-ai/dsh-client-store");
-		//#region lib/types/shared.js
-		/**
-		* The identities both halves of dsh-pause-session name, the status encodings they
-		* share, and the one spelling a host log line gives a caught value.
-		*
-		* The browser bundle may value-import only the shell's baseline module table,
-		* so this module imports nothing: the client half reads command names and the
-		* decode functions from it directly, and the host half derives the branded
-		* identities from the same strings.
-		*
-		* A third-party plugin's only live channel to the browser is the command
-		* registry — it can add neither a `ctx.remote` namespace nor a forwarded event,
-		* both of which are compiled into the harness's own API assembly. A command
-		* descriptor's only free-form field is its `description`, and a command
-		* result's only free-form field is its `text`, so the park state travels as a
-		* prefix plus `;`-separated fields on one of those. The text stays
-		* human-readable: the same words are what the slash-command menu shows.
-		*
-		* Every value inside a field is escaped, so a decoded name is the exact name
-		* that was encoded. Session ids, tool names, and call ids are the host's own
-		* data and may contain the `;`, `,`, `/`, or newline a field is separated by; a
-		* folded spelling would decode as a different name — a different row, looked up
-		* again.
-		* @module dsh-pause-session/shared
-		*/
-		/** Command that pauses the receiving session before its next model request. */
-		const PAUSE_COMMAND = "pause";
-		/** Command that resumes the receiving session; registered only while that session is paused. */
-		const RESUME_COMMAND = "pause-resume";
-		/** Command that resumes every parked session the registry remembers. */
-		const RESUME_ALL_COMMAND = "pause-resume-all";
-		/** Command that registers and parks every running session tree in one action. */
-		const PAUSE_ALL_COMMAND = "pause-all";
-		/** Command that reports the whole-app park state; registered globally, always. */
-		const STATE_ALL_COMMAND = "pause-state-all";
-		/** Command that reports the receiving session's park state; registered only while it is paused. */
-		const STATUS_COMMAND = "pause-state";
-		/** Command that turns the receiving session's own goal re-arm on or off; registered only while it is paused. */
-		const GOAL_COMMAND = "pause-goal";
-		/** Command that reports every session that did not stop cleanly. */
-		const TRIAGE_COMMAND = "pause-triage";
-		/** Command that resumes one session from the decision list exactly as the clean path would. */
-		const TRIAGE_CONTINUE_COMMAND = "pause-triage-continue";
-		/** Command that resumes one session from the decision list with the unknown-outcome note. */
-		const TRIAGE_NOTE_COMMAND = "pause-triage-note";
-		/** Command that opens one session from the decision list without spending a request. */
-		const TRIAGE_REVIEW_COMMAND = "pause-triage-review";
-		/** Command that leaves one session from the decision list exactly as it is. */
-		const TRIAGE_LEAVE_COMMAND = "pause-triage-leave";
-		/** Command that turns one listed session's goal re-arm on or off. */
-		const TRIAGE_GOAL_COMMAND = "pause-triage-goal";
-		/**
-		* One list field's text when the list is empty. A value that would itself spell
-		* this marker is escaped by {@link escapeField}, so an empty list and a list
-		* holding the marker stay different texts.
-		*/
-		const EMPTY_FIELD = "-";
-		/**
-		* One value previously written by {@link escapeField}.
-		* @param text - the encoded value, escapes included.
-		* @returns the value the host holds.
-		*/
-		function unescapeField(text) {
-			return text.replace(/\\(.)/g, (_escape, character) => character === "n" ? "\n" : character);
-		}
-		/**
-		* Split one encoded text on the separators that are not escaped, keeping each
-		* escape beside the character it protects so {@link unescapeField} can read it.
-		* @param text - an encoded text, without its prefix.
-		* @param separator - the single character to split on.
-		* @returns the parts, in order; always at least one.
-		*/
-		function splitFields(text, separator) {
-			const parts = [];
-			let part = "";
-			for (let at = 0; at < text.length; at += 1) {
-				const character = text[at] ?? "";
-				if (character === "\\") {
-					part += character + (text[at + 1] ?? "");
-					at += 1;
-					continue;
-				}
-				if (character === separator) {
-					parts.push(part);
-					part = "";
-					continue;
-				}
-				part += character;
-			}
-			parts.push(part);
-			return parts;
-		}
-		/**
-		* One field of an encoded text, by its key.
-		* @param fields - the separated fields of one encoded text.
-		* @param key - the field's key, without its `:`.
-		* @returns the field's value with its escapes still in place, or `undefined`
-		* when the text does not carry that field.
-		*/
-		function fieldOf(fields, key) {
-			const prefix = `${key}:`;
-			const at = fields.findIndex((field) => field.trim().startsWith(prefix));
-			return at < 0 ? void 0 : fields[at]?.trim().slice(prefix.length).trim();
-		}
-		/** The one word each phase is published as, and the whole decoding vocabulary. */
-		const PHASE_WORD = {
-			draining: "pausing",
-			parking: "saving",
-			safe: "paused",
-			"flush-failed": "save failed"
-		};
-		/**
-		* The two states of one record's goal re-arm field, in the one spelling both
-		* the per-session status and the decision list publish it with.
-		*/
-		const GOAL_ON = "on";
-		const GOAL_OFF = "off";
-		/**
-		* Decode a status previously written by {@link encodeParkStatus}.
-		* @param text - a command descriptor's description.
-		* @returns the status, or `undefined` when this text carries none — a foreign
-		* command, or a reading taken before the host published anything.
-		*/
-		function decodeParkStatus(text) {
-			if (!text.startsWith("pause: ")) return void 0;
-			const [head = "", ...rest] = splitFields(text.slice(7), ";");
-			const word = head.trim();
-			const phase = Object.keys(PHASE_WORD).find((candidate) => PHASE_WORD[candidate] === word);
-			if (phase === void 0) return void 0;
-			const goal = fieldOf(rest, "goal");
-			return {
-				phase,
-				safe: phase === "safe",
-				runningTools: decodeNames(fieldOf(rest, "tools")),
-				...goal === GOAL_ON ? { rearmGoal: true } : goal === GOAL_OFF ? { rearmGoal: false } : {}
-			};
-		}
-		/**
-		* Decode one id previously written by {@link encodeId}.
-		* @param field - the encoded field, escapes included.
-		* @returns the id; `undefined` when the text carries none — an absent field and
-		* the empty marker both mean the answer names no session, and a client that
-		* read either as one would address a session the host never named.
-		*/
-		function decodeId(field) {
-			const text = field?.trim();
-			if (text === void 0 || text.length === 0 || text === EMPTY_FIELD) return void 0;
-			return unescapeField(text);
-		}
-		/** Decode one list field. */
-		function decodeNames(field) {
-			const text = field?.trim();
-			if (text === void 0 || text.length === 0 || text === EMPTY_FIELD) return [];
-			return splitFields(text, ",").map((name) => unescapeField(name.trim())).filter((name) => name.length > 0);
-		}
-		/**
-		* Decode a whole-app status previously written by {@link encodeGlobalStatus}.
-		* @param text - a command result's text.
-		* @returns the status, or `undefined` when this text carries none.
-		*/
-		function decodeGlobalStatus(text) {
-			if (!text.startsWith("pause all: ")) return void 0;
-			const [head = "", ...fields] = splitFields(text.slice(11), ";");
-			const verdict = head.trim();
-			if (verdict !== "idle" && verdict !== "waiting" && verdict !== "safe") return void 0;
-			const byKey = /* @__PURE__ */ new Map();
-			for (const field of fields) {
-				const at = field.indexOf(":");
-				if (at < 0) continue;
-				byKey.set(field.slice(0, at).trim(), field.slice(at + 1).trim());
-			}
-			const count = (key) => {
-				const value = Number(byKey.get(key));
-				return Number.isSafeInteger(value) && value >= 0 ? value : 0;
-			};
-			const parkedAt = decodeId(byKey.get("parked-at"));
-			return {
-				verdict,
-				registered: count("registered"),
-				safe: count("safe"),
-				...parkedAt === void 0 ? {} : { parkedAt },
-				draining: decodeNames(byKey.get("draining")),
-				parking: count("parking"),
-				stalled: decodeNames(byKey.get("stalled")),
-				unresumable: decodeNames(byKey.get("unresumable")),
-				unreadTrees: decodeNames(byKey.get("unread-trees")),
-				jobs: decodeNames(byKey.get("jobs")),
-				blind: decodeNames(byKey.get("blind")).filter((spot) => spot === "trees" || spot === "jobs")
-			};
-		}
-		/** How one row is spelled in the published list; the wake field's state when the host can hand over the owed request. */
-		const WAKE_YES = "yes";
-		/** Decode {@link encodeTraces}; an item without a tool name is not a trace. */
-		function decodeTraces(field) {
-			const text = field?.trim();
-			if (text === void 0 || text.length === 0 || text === EMPTY_FIELD) return [];
-			return splitFields(text, ",").flatMap((item) => {
-				const [tool = "", callId = ""] = splitFields(item.trim(), "/");
-				if (tool.length === 0) return [];
-				return [{
-					tool: unescapeField(tool),
-					callId: unescapeField(callId)
-				}];
-			});
-		}
-		/**
-		* Decode a decision list previously written by {@link encodeTriageList}.
-		* @param text - a command result's text.
-		* @returns the list, or `undefined` when this text carries none.
-		*/
-		function decodeTriageList(text) {
-			if (!text.startsWith("pause triage: ")) return void 0;
-			const [head = "", ...rest] = splitFields(text.slice(14), ";");
-			if (!Number.isSafeInteger(Number(head.trim())) || Number(head.trim()) < 0) return void 0;
-			const rows = [];
-			let fields = [];
-			const flush = () => {
-				if (fields.length === 0) return;
-				const sessionId = fieldOf(fields, "row");
-				const phase = fieldOf(fields, "phase");
-				if (sessionId === void 0 || phase === void 0 || phase === "safe") return;
-				const stopped = fieldOf(fields, "stopped");
-				const reading = stopped === "unreadable" ? "unreadable" : "read";
-				const position = reading === "unreadable" || stopped === void 0 || stopped === EMPTY_FIELD ? null : /^(.*?)(?:\/turn (\d+)(?: step (\d+))?)?$/.exec(stopped);
-				rows.push({
-					sessionId: unescapeField(sessionId),
-					phase,
-					updatedAt: 0,
-					reading,
-					...position === null ? {} : {
-						lastEvent: unescapeField(position[1] ?? ""),
-						...position[2] === void 0 ? {} : { turn: Number(position[2]) },
-						...position[3] === void 0 ? {} : { step: Number(position[3]) }
-					},
-					traces: reading === "unreadable" ? [] : decodeTraces(fieldOf(fields, "traces")),
-					owed: fieldOf(fields, "owed") === WAKE_YES,
-					wakeable: fieldOf(fields, "wake") === WAKE_YES,
-					rearmGoal: fieldOf(fields, "goal") !== GOAL_OFF
-				});
-				fields = [];
-			};
-			for (const field of rest) {
-				if (field.trim().startsWith("row:")) flush();
-				fields.push(field);
-			}
-			flush();
-			return { rows };
-		}
-		//#endregion
-		//#region lib/types/client/burst.js
-		/**
-		* The re-read burst both browser controls share: a handful of reads after
-		* something moved, and silence once it settles.
-		*
-		* What a control reads is published through the host's command channel, and
-		* every read is two durable `command/run|done` records in the address session's
-		* log plus an aggregate read on the host. Reading is therefore something the
-		* host announces and the user asks for, never a heartbeat:
-		*
-		* - the host announces a transition by registering or unregistering the paused
-		*   session's marker commands, and — for a phase change, which no registration
-		*   of its own would show — by registering that session's status verb again.
-		*   Each of those emits `commands/change`, and that event, plus the user's own
-		*   press or decision, is what starts a burst;
-		* - one transition announces itself several times: a park registers two or three
-		*   marker commands per session and a phase change re-registers one, and the host
-		*   emits one `commands/change` per step. The burst therefore waits out a short
-		*   `windowMs` before its first read and any trigger inside that window
-		*   postpones it, so the announcements of one transition start one burst rather
-		*   than one each;
-		* - a change that arrives within `ACTION_ABSORB_MS` of the user's own action is
-		*   that action's own consequence, not news: the action already read the host,
-		*   so the answer is on screen, and the unregistrations it caused — one event
-		*   per marker command, measured seconds apart, which the window above cannot
-		*   merge — would only be read back. Such a change is absorbed, and each one
-		*   absorbed pushes the window out, because a storm that keeps arriving is
-		*   still the same storm. The window always closes: the first change after
-		*   `ACTION_ABSORB_MS` of quiet is news again, and a user action reads on its
-		*   own whatever the window says;
-		* - an absorbed change is deferred rather than lost: a control whose action left
-		*   a phase still moving asks for one look at the moment the window closes
-		*   ({@link ReadBurst.recheckAfterEcho}), which is the read that finds a
-		*   transition the window hid — the park can reach its final phase inside that
-		*   window and never announce anything again. One look per action, and only
-		*   while the state it left is still moving;
-		* - a burst is a fixed short list of waits, so at most that many reads answer
-		*   one transition, however long the page stays open;
-		* - a read that finds the verdict settled ends the burst at once, and the last
-		*   reading stays on screen — "the park is settled" is not a state change, so
-		*   it must not be re-asked;
-		* - a read that finds a phase still moving ends it just as fast. Every phase
-		*   transition is announced at its source, the flush that resolves `parking`
-		*   into `safe` included, and that announcement is the very event that starts
-		*   the next burst — so watching a moving phase from here spends records on a
-		*   transition that will speak for itself;
-		* - what the burst still owes after a read is delivery: the read one
-		*   announcement bought, and one more when a change lands while a pass is in
-		*   flight, which that pass cannot have answered. The bound is a bound, not a
-		*   heartbeat: a phase that never settles is left on screen unread until
-		*   something else moves;
-		* - the bound is a trade, taken knowingly: a reading left on screen when the
-		*   burst runs out is the host's own last answer, and the next trigger — a
-		*   forwarded change, a press, or the shell handing a control its session again
-		*   — reads the truth again. A reading nobody answered is never rendered as a
-		*   confident state. A longer watch is a longer list of waits, at a linear price
-		*   in the address session's log;
-		* - while the page is hidden no read is armed at all, and the wait a burst
-		*   still owed is armed again when the page comes back: hidden time is neither
-		*   charged to the burst nor lost from it.
-		*
-		* A burst is not restarted by a trigger that lands while one is running: every
-		* read it still owes happens after that trigger, so absorbing it loses nothing
-		* and a storm of registry changes costs one burst rather than one each.
-		* @module dsh-pause-session/client/burst
-		*/
-		/** The policy every control uses unless a caller says otherwise. */
-		const DEFAULT_BURST_POLICY = {
-			windowMs: 400,
-			waitsMs: [
-				400,
-				1e3,
-				2400,
-				4800
-			],
-			visible: defaultVisibility
-		};
-		/**
-		* How long after a client action a registry change is that action's own echo.
-		*
-		* A press, a release, a decision, a goal switch and an opened panel each read
-		* the host as they run, so their answer is already on screen when the host
-		* announces what they did — one `commands/change` per marker command, measured
-		* 0.44 s to 2.04 s apart, a cadence the coalescing window cannot merge. Reading
-		* those back is paying for an answer the user already has.
-		*
-		* The window is what makes `commands/change` mean "something moved that this
-		* browser did not do". It is refreshed by every change it absorbs, so a storm
-		* that keeps arriving stays absorbed rather than leaking one read per change,
-		* and it ends for good `ACTION_ABSORB_MS` after the last change: a change after
-		* that is news, and so is the next user action, which reads on its own.
-		*
-		* The margin over the measured 2.04 s gap is deliberate: a transition's own
-		* storm has to fit inside the window for the whole storm to stay absorbed.
-		*/
-		const ACTION_ABSORB_MS = 2500;
-		/**
-		* The waits one burst uses when its first wait is `first`: four reads spread
-		* over roughly ten times that. Long enough that a read a hidden page or an
-		* in-flight pass deferred is still taken, short enough that a state which never
-		* settles costs a handful of log records rather than a night of them.
-		* @param first - milliseconds before the burst's first read, after its window; `<= 0` disables bursting.
-		* @returns the waits, in order; empty when bursting is disabled.
-		*/
-		function burstWaits(first) {
-			return first > 0 ? [
-				first,
-				first * 2.5,
-				first * 6,
-				first * 12
-			] : [];
-		}
-		/**
-		* Whether the browser reports the page as on screen. A shell without a
-		* `document` (a test harness, a non-browser host) counts as visible: a control
-		* that could never read would be a worse lie than one that reads.
-		* @returns whether the page is visible now.
-		*/
-		function defaultVisibility() {
-			return (typeof document === "undefined" ? void 0 : document.visibilityState) !== "hidden";
-		}
-		/** The real clock: `setTimeout` clearing itself. */
-		const SYSTEM_CLOCK = {
-			set: (callback, ms) => setTimeout(callback, ms),
-			clear: (timer) => {
-				clearTimeout(timer);
-			}
-		};
-		/**
-		* One control's re-read burst. Every method is safe to call in any order and as
-		* often as the caller likes: a trigger starts at most one burst, and one burst
-		* never arms more than one read at a time.
-		*/
-		var ReadBurst = class {
-			onRead;
-			policy;
-			clock;
-			/** The armed wait, when one is counting down. */
-			timer;
-			/** Whether the burst is waiting out its collection window rather than a wait between reads. */
-			window = false;
-			/** Waits this burst has not spent yet, front first. */
-			left = [];
-			/** Whether a burst is in progress: it may be collecting, waiting, reading, or reading again. */
-			running = false;
-			/** The absorption window a client action opened, while one is open. */
-			absorbed;
-			/** Whether a control asked for the one look owed when the echo window closes. */
-			recheck = false;
-			/**
-			* @param onRead - one more read. Called only for a read the burst owes and the page can show.
-			* @param policy - the collection window, the waits, and the visibility source.
-			* @param clock - the timer implementation.
-			*/
-			constructor(onRead, policy, clock = SYSTEM_CLOCK) {
-				this.onRead = onRead;
-				this.policy = policy;
-				this.clock = clock;
-			}
-			/** Whether this control bursts at all. */
-			get enabled() {
-				return this.policy.waitsMs.length > 0;
-			}
-			/** Whether one more read is already counting down. */
-			get armed() {
-				return this.timer !== void 0;
-			}
-			/** Whether a burst is in progress, with or without a read counting down. */
-			get live() {
-				return this.running;
-			}
-			/** Whether a change right now is a client action's own echo. */
-			get absorbing() {
-				return this.absorbed !== void 0;
-			}
-			/**
-			* The user acted on this control and the action reads: a press, a release, a
-			* decision, a goal switch, an opened panel. Its read is the answer, and the
-			* registry changes it sets off announce themselves for a while afterwards, so
-			* until the window closes a trigger is that echo rather than news.
-			*
-			* Called as the action is taken, before its read lands, because the echo can
-			* arrive while the action is still running.
-			*/
-			absorb() {
-				if (!this.enabled) return;
-				this.armAbsorb();
-			}
-			/**
-			* Ask for one read at the moment the echo window closes, because the action's
-			* own read left a state that is still moving.
-			*
-			* The echo window swallows a transition announced inside it — the forwarded
-			* event carries no payload, so nothing distinguishes a marker registration
-			* from a phase change — and after the window no change is guaranteed to come:
-			* the transition that was hidden may be the last one this park makes. The
-			* look owed here is the read that finds it, one per action, and it is not a
-			* watch: once the window has closed, every further change is news and buys its
-			* own read. A control whose action left a settled state owes nothing and asks
-			* for nothing.
-			*/
-			recheckAfterEcho() {
-				if (!this.enabled) return;
-				this.recheck = true;
-			}
-			/**
-			* Something moved — a registry change. The burst first waits out its
-			* collection window, and every trigger that lands inside it restarts that
-			* window: the two or three registrations of one park start one burst rather
-			* than one each. A burst already past its window takes this as covered —
-			* every read it still owes happens after the change.
-			*
-			* @returns whether the change is news rather than a client action's own echo.
-			* The echo announces what the action's read already answered, so only a news
-			* trigger is a change a control still owes a read for; a change that lands
-			* while a burst is under way is covered by the read that burst already owes.
-			* `false` also for a disabled burst, which reads nothing at all.
-			*/
-			trigger() {
-				if (!this.enabled) return false;
-				if (this.absorbing) {
-					this.armAbsorb();
-					return false;
-				}
-				if (!this.running) {
-					this.running = true;
-					this.left = this.policy.waitsMs;
-					this.armWindow();
-					return true;
-				}
-				if (this.window) this.armWindow();
-				return true;
-			}
-			/**
-			* The control knows it still owes a read: a change that is news has arrived,
-			* or a reading just revealed something only a read can answer. A call outside
-			* any burst starts one. Absorption never applies here — this is not a change
-			* some action caused, it is a read the control already knows it needs.
-			*/
-			next() {
-				if (this.armed || this.window) return;
-				if (!this.running) {
-					this.running = true;
-					this.left = this.policy.waitsMs;
-				}
-				this.owe();
-			}
-			/**
-			* Nothing is moving: end the burst and forget it. The last reading stays
-			* published, and the next trigger starts a fresh burst. Two things outlive
-			* this: an action's absorption window, which is about what the action caused
-			* rather than about the state, and the one look it may still owe — see
-			* {@link recheckAfterEcho}.
-			*/
-			stop() {
-				this.running = false;
-				this.left = [];
-				this.window = false;
-				this.cancel();
-			}
-			/** Drop the armed wait. A burst that is still owed its read survives it; see {@link checkVisibility}. */
-			cancel() {
-				if (this.timer === void 0) return;
-				this.clock.clear(this.timer);
-				this.timer = void 0;
-			}
-			/**
-			* Re-evaluate one page-visibility change. Going off screen drops the armed
-			* wait — a hidden page is not being read — and coming back arms it again, so
-			* the burst resumes where it stopped instead of being spent while nobody was
-			* looking. A burst still collecting resumes its window, restarted from the
-			* moment the page came back: a trigger that arrived while it was hidden still
-			* postpones the read.
-			*/
-			checkVisibility() {
-				if (this.visibleNow()) {
-					this.arm();
-					return;
-				}
-				this.cancel();
-			}
-			/** Spend the next wait of the burst, or end it when the bound is reached. */
-			owe() {
-				const wait = this.left[0];
-				if (wait === void 0) {
-					this.running = false;
-					return;
-				}
-				this.armWait(wait);
-			}
-			/**
-			* (Re)start the collection window. While the page is hidden nothing is armed
-			* — hidden time is not charged to the burst — and a trigger that lands then
-			* is still collected, because coming back starts a whole window.
-			*/
-			armWindow() {
-				const wait = Math.max(this.policy.windowMs, 0);
-				if (!this.visibleNow()) {
-					this.window = true;
-					return;
-				}
-				this.cancel();
-				this.window = true;
-				this.timer = this.clock.set(() => {
-					this.timer = void 0;
-					this.window = false;
-					this.owe();
-				}, wait);
-			}
-			/** Put back whatever the burst still owed: its window, or the wait after a read. */
-			arm() {
-				if (this.window) {
-					this.armWindow();
-					return;
-				}
-				const wait = this.left[0];
-				if (wait !== void 0) this.armWait(wait);
-			}
-			/**
-			* (Re)start the absorption window a client action opened. A hidden page keeps
-			* absorbing: this window is about what the action caused, not about what the
-			* page is doing. When the window closes, the one look an unsettled action owes
-			* is taken; the window is restarted by every change it absorbs, so that look
-			* waits for the echo to actually stop.
-			*/
-			armAbsorb() {
-				this.cancelAbsorb();
-				this.absorbed = this.clock.set(() => {
-					this.absorbed = void 0;
-					if (!this.recheck) return;
-					this.recheck = false;
-					this.next();
-				}, Math.max(ACTION_ABSORB_MS, 0));
-			}
-			/** Close the absorption window: changes are news again. */
-			cancelAbsorb() {
-				if (this.absorbed === void 0) return;
-				this.clock.clear(this.absorbed);
-				this.absorbed = void 0;
-			}
-			/**
-			* Arm one wait, spending it when it fires. The wait stays in `left` until
-			* then, so a page hidden mid-wait takes the whole wait again: hidden time is
-			* neither charged to the burst nor lost from it.
-			*/
-			armWait(wait) {
-				if (this.timer !== void 0 || !this.visibleNow()) return;
-				this.timer = this.clock.set(() => {
-					this.timer = void 0;
-					this.left = this.left.slice(1);
-					this.onRead();
-				}, Math.max(wait, 0));
-			}
-			/** Whether the page counts as on screen now, with an absent `document` read as on screen. */
-			visibleNow() {
-				try {
-					return this.policy.visible();
-				} catch {
-					return true;
-				}
-			}
-		};
-		//#endregion
 		//#region lib/types/client/control.js
 		/**
 		* Browser-side reading and driving of the host's park state for one session.
 		*
-		* The host publishes no push channel of its own — a third-party plugin cannot
-		* add a Client Remote namespace or a forwarded event — so this control reads
-		* the host's command registry, which is the only live surface it can publish
-		* through: `commands.list(sessionId)` is a Client-callable read, and the
-		* forwarded `commands/change` event says when to read it again. The resume
-		* definition's presence in that list IS the host's "this session is paused"
-		* fact, and the companion status definition answers with the park state as of
-		* the read; this module never derives either from its own press. That one
-		* answer carries the record's goal opt-out as well, so the switch beside the
-		* pause button can show it without a second host round-trip — and without it,
-		* the control renders no switch at all.
+		* The browser reads the native `pauseSession` stream; actions travel through
+		* the same Remote namespace. No slash command is involved. The stream is
+		* host-authoritative, so this module never derives a state from its own press.
+		* The snapshot also carries the record's goal opt-out, so the switch beside the
+		* pause button can show it without a second host round-trip.
 		*
-		* Every phase the host reaches announces itself on that channel: a transition
-		* re-registers the status verb, so a transition is what buys the next read and a
-		* read that finds a phase still moving is the answer to the transition that
-		* produced it rather than a reason to keep asking (`./burst.ts`). One transition
-		* arrives as several registry changes — parking a session also registers its
-		* three commands — so the burst's own collection window is what turns a tick of
-		* changes into one read per shown session. A press or a goal switch reads as it
-		* runs, and the marker changes it causes are that action's own echo: those are
-		* absorbed for a short window (`./burst.ts`) rather than read back — except for
-		* the one look an action owes when that window closes, if the reading it left
-		* behind is still moving, because a transition announced inside the window would
-		* otherwise never be read at all.
-		*
-		* The whole-app control reads the same park and publishes what it found
-		* (`./global.ts`), and a header consults that answer before spending a read of
-		* its own: with nothing registered, no session can be paused, so a header that
-		* already says "running" is left saying it rather than paying a round-trip to
-		* hear it again. A header the host last showed on its way to a park is never
-		* answered that way — that reading is the newer fact — and the derivation is
-		* voided by the next whole-app answer that names a registered session, which
-		* the forwarded change a park causes is what brings in.
+		* The stream is the change feed. A pushed snapshot triggers one cached read per
+		* shown header; a press or goal switch reads the host's answer once after the
+		* action.
 		* @module dsh-pause-session/client/control
 		*/
 		const INITIAL$1 = { bySession: {} };
-		/** Phases that name a moment on the way to a park rather than a state it reached. */
-		const MOVING = /* @__PURE__ */ new Set(["draining", "parking"]);
 		/** Owns the published reading per session; nothing else writes that state. */
 		var PauseControl = class {
-			commands;
+			transport;
 			lifetime;
-			aggregate;
 			/** State source the Session-header contribution binds its selector hook to. */
 			store = (0, _deepseek_ai_dsh_client_store.createSnapshotStore)(INITIAL$1);
-			/** Sessions this control has shown; a host registry change re-reads every one of them. */
+			/** Sessions this control has shown; a pushed snapshot applies to every one. */
 			shown = /* @__PURE__ */ new Set();
 			/** Highest read sequence requested per session: an answer older than it is dropped. */
 			latest = /* @__PURE__ */ new Map();
-			/**
-			* Sessions a change has put back on the list of ones to read once — a
-			* transition this browser has been told about and has not answered yet.
-			*/
-			owed = /* @__PURE__ */ new Set();
-			/**
-			* Whether the look owed at the close of an echo window is still to be taken.
-			* It reads every shown session, exactly as a change does: the look exists
-			* because a change may have been swallowed, and a swallowed change carries no
-			* payload either.
-			*/
-			trailing = false;
-			/**
-			* Sessions whose header was answered from the whole-app "nothing is
-			* registered" instead of a read of their own, and which therefore have to be
-			* read for real if that answer stops holding.
-			*/
-			derived = /* @__PURE__ */ new Set();
-			/** The bounded burst of reads one transition buys; see `./burst.ts`. */
-			burst;
 			reads = 0;
 			/**
-			* @param commands - the Client-callable command namespace.
-			* @param lifetime - aborts in-flight calls and the burst when the plugin unloads.
-			* @param windowMs - how long the burst collects the registrations of one
-			* transition before its first read; also the wait after a press.
-			* @param policy - the burst waits and visibility source; defaults to the real page.
-			* @param aggregate - the whole-app control's published answer; absent means it is never consulted.
+			* @param transport - the native namespace source and actions.
+			* @param lifetime - aborts in-flight reads when the plugin unloads.
 			*/
-			constructor(commands, lifetime, windowMs = 400, policy = DEFAULT_BURST_POLICY, aggregate = () => void 0) {
-				this.commands = commands;
+			constructor(transport, lifetime) {
+				this.transport = transport;
 				this.lifetime = lifetime;
-				this.aggregate = aggregate;
-				this.burst = new ReadBurst(() => {
-					this.readAll();
-				}, {
-					...policy,
-					windowMs,
-					waitsMs: burstWaits(windowMs)
-				});
 			}
 			/**
 			* Read the host's state for one session.
@@ -720,50 +49,40 @@ window.__ModuleLoader__.load({
 			*/
 			async refresh(sessionId) {
 				await this.readOne(sessionId);
-				this.follow();
 			}
-			/**
-			* The host's command registry changed, so every session this control has
-			* shown may have moved — the forwarded event carries no payload, so the only
-			* honest answer is to look at all of them once. The reads run on the burst's
-			* own schedule rather than here, which is what makes a tick's worth of changes
-			* — parking a session registers three commands, and a phase change re-registers
-			* one more — one burst instead of one each. A change that is this browser's own
-			* action's echo owes nothing: the action read the host as it ran.
-			*/
+			/** Apply one pushed snapshot without spending a read per shown header. */
+			apply(snapshot) {
+				for (const sessionId of this.shown) {
+					if (snapshot === void 0) {
+						this.publish(sessionId, {
+							phase: "unavailable",
+							runningTools: []
+						});
+						continue;
+					}
+					const status = snapshot.sessions[String(sessionId)];
+					this.publish(sessionId, status === void 0 ? {
+						phase: "active",
+						runningTools: []
+					} : {
+						phase: status.phase,
+						runningTools: status.runningTools,
+						...status.rearmGoal === void 0 ? {} : { rearmGoal: status.rearmGoal }
+					});
+				}
+			}
+			/** A new pushed snapshot may have moved every header; read them once. */
 			refreshAll() {
 				if (this.shown.size === 0 || this.lifetime.aborted) return;
-				if (!this.burst.trigger()) return;
-				for (const sessionId of this.shown) this.owed.add(sessionId);
+				this.readAll();
 			}
-			/**
-			* One pass of the burst: every shown session a change still owes a read. The
-			* forwarded event carries no payload, so a change may have touched any of
-			* them and each is read once. A session the whole-app answer has already
-			* spoken for is answered from it instead of being asked about; see
-			* {@link answerIsKnown}.
-			*/
 			async readAll() {
-				if (this.lifetime.aborted) {
-					this.burst.stop();
-					return;
-				}
-				const pass = this.owed.size > 0 ? [...this.owed] : this.trailing ? [...this.shown] : [];
-				this.owed.clear();
-				this.trailing = false;
-				for (const sessionId of pass) {
-					if (this.answerIsKnown(sessionId)) {
-						this.deriveActive(sessionId);
-						continue;
-					}
-					await this.readOne(sessionId);
-				}
-				this.follow();
+				if (this.lifetime.aborted) return;
+				for (const sessionId of [...this.shown]) await this.readOne(sessionId);
 			}
 			/** One session's read, published unless a newer read of that session supersedes it. */
 			async readOne(sessionId) {
 				this.shown.add(sessionId);
-				this.derived.delete(sessionId);
 				const sequence = ++this.reads;
 				this.latest.set(sessionId, sequence);
 				const reading = await this.read(sessionId);
@@ -779,178 +98,66 @@ window.__ModuleLoader__.load({
 			*/
 			async toggle(sessionId) {
 				const current = this.store.getSnapshot().bySession[String(sessionId)]?.phase;
-				const line = current === void 0 || current === "active" ? `/${PAUSE_COMMAND}` : `/${RESUME_COMMAND}`;
-				this.burst.absorb();
-				if (!(await this.commands.execute(sessionId, line, [], this.lifetime)).ok) {
+				const action = current === void 0 || current === "active" ? "pause" : "resume";
+				if (!(await this.transport.act({
+					action,
+					sessionId: String(sessionId)
+				}, this.lifetime)).ok) {
 					this.publish(sessionId, {
 						phase: "unavailable",
 						runningTools: []
 					});
-					this.follow();
 					return;
 				}
 				await this.refresh(sessionId);
 			}
 			/**
 			* Flip this session's goal opt-out. The verb belongs to the session it
-			* changes — the host registers it there, and it takes no other target — so
-			* this press needs no listed row. What the switch shows afterwards is the
-			* host's next answer, never a local flip: a refused switch leaves the record
-			* exactly as it was, and the re-read is what says so.
+			* changes; the switch shows the host's next answer, never a local flip.
 			* @param sessionId - session whose switch was pressed.
 			* @returns after the control re-reads the host.
 			*/
 			async toggleGoal(sessionId) {
-				this.burst.absorb();
-				await this.commands.execute(sessionId, `/${GOAL_COMMAND}`, [], this.lifetime);
+				if (!(await this.transport.act({
+					action: "goal",
+					sessionId: String(sessionId)
+				}, this.lifetime)).ok) {
+					this.publish(sessionId, {
+						phase: "unavailable",
+						runningTools: []
+					});
+					return;
+				}
 				await this.refresh(sessionId);
 			}
-			/** Ask the host what this session's park state is, in the browser's vocabulary. */
+			/** Ask the native stream what this session's park state is. */
 			async read(sessionId) {
-				const listed = await this.commands.list(sessionId);
-				if (!listed.ok) return {
+				const snapshot = await this.transport.source.read(this.lifetime);
+				if (snapshot === void 0) return {
 					phase: "unavailable",
 					runningTools: []
 				};
-				if (!listed.value.some((descriptor) => descriptor.definitionId === "dsh-pause-session/resume")) return {
+				const status = snapshot.sessions[String(sessionId)];
+				if (status === void 0) return {
 					phase: "active",
 					runningTools: []
 				};
-				if (listed.value.find((descriptor) => descriptor.definitionId === "dsh-pause-session/status") === void 0) return {
-					phase: "parking",
-					runningTools: []
-				};
-				const answered = await this.commands.execute(sessionId, `/${STATUS_COMMAND}`, [], this.lifetime);
-				if (!answered.ok || answered.value === void 0) return {
-					phase: "unavailable",
-					runningTools: []
-				};
-				const text = answered.value.result.kind === "success" ? answered.value.result.text : void 0;
-				const decoded = text === void 0 ? void 0 : decodeParkStatus(text);
-				if (decoded === void 0) return {
-					phase: "parking",
-					runningTools: []
-				};
 				return {
-					phase: decoded.phase,
-					runningTools: decoded.runningTools,
-					...decoded.rearmGoal === void 0 ? {} : { rearmGoal: decoded.rearmGoal }
+					phase: status.phase,
+					runningTools: status.runningTools,
+					...status.rearmGoal === void 0 ? {} : { rearmGoal: status.rearmGoal }
 				};
 			}
 			publish(sessionId, reading) {
 				this.store.update((state) => {
+					const previous = state.bySession[String(sessionId)];
+					if (previous !== void 0 && previous.phase === reading.phase && previous.rearmGoal === reading.rearmGoal && previous.runningTools.length === reading.runningTools.length && previous.runningTools.every((tool, index) => tool === reading.runningTools[index])) return;
 					state.bySession = {
 						...state.bySession,
 						[String(sessionId)]: reading
 					};
 				});
 			}
-			/**
-			* Whether the park has already answered for this header: with nothing
-			* registered, no session can be paused, so a header that says this session is
-			* running carries the whole fact and the read that would confirm it is a host
-			* round-trip plus two records in that session's log for nothing.
-			*
-			* A header the host last showed on its way to a park is never answered this
-			* way: that reading is newer than the aggregate the derivation rests on, and
-			* only a fresh host answer may replace it.
-			*/
-			answerIsKnown(sessionId) {
-				const phase = this.store.getSnapshot().bySession[String(sessionId)]?.phase;
-				if (phase !== void 0 && phase !== "active") return false;
-				return this.nothingParked();
-			}
-			/**
-			* Whether the whole-app answer says the park holds nothing at all: the one
-			* predicate the derivation below and its revocation share.
-			*/
-			nothingParked() {
-				const aggregate = this.aggregate();
-				return aggregate?.kind === "reported" && aggregate.status.registered === 0;
-			}
-			/**
-			* Answer one header from the whole-app verdict, and remember that it was that
-			* kind of answer: the sessions to read for real are exactly the ones the
-			* aggregate may have been wrong about.
-			*/
-			deriveActive(sessionId) {
-				this.derived.add(sessionId);
-				this.publish(sessionId, {
-					phase: "active",
-					runningTools: []
-				});
-			}
-			/**
-			* The whole-app answer moved. Whatever was answered from "nothing is
-			* registered" is read for real the moment that stops holding — the session a
-			* header stood in for may be the one the park just took, possibly parked from
-			* another window whose change this browser only sees as the forwarded event.
-			* Called on every published aggregate, so it must do nothing while the
-			* derivation still holds.
-			*/
-			reconsider() {
-				if (this.derived.size === 0 || this.lifetime.aborted || this.nothingParked()) return;
-				for (const sessionId of this.derived) this.owed.add(sessionId);
-				this.derived.clear();
-				this.burst.next();
-			}
-			/**
-			* Decide what the burst owes after a read: another look while a change this
-			* browser has not answered is still outstanding, and nothing once none is.
-			*
-			* A phase that is still moving is left alone. The host announces every
-			* transition on its command channel — the flush that settles a park included,
-			* which changes no registration of its own — so a read that finds `draining`
-			* or `parking` is the answer to the transition that produced it, and watching
-			* that phase from here would spend reads on a move that is going to speak for
-			* itself. What the burst still owes is the delivery of an announcement: a read
-			* still armed when the change arrived, and a read for a change that landed
-			* while the last pass was in flight.
-			*
-			* The one transition that cannot speak for itself is the one this browser's
-			* own echo window swallowed: a press reads the host, the park moves while the
-			* window is still open, and the changes that would have announced it look
-			* exactly like the press's own registrations. So an action that left a phase
-			* still moving asks for one look when that window closes, and only then — the
-			* read is owed at a moment, not watched. Once nothing is owed, the last
-			* reading stays on screen; the next change, the next user action, or the shell
-			* handing this control a session again is what asks next.
-			*/
-			follow() {
-				if (this.lifetime.aborted) {
-					this.burst.stop();
-					return;
-				}
-				if (this.owed.size === 0) {
-					const hidden = this.burst.absorbing && this.moving();
-					if (hidden) this.burst.recheckAfterEcho();
-					this.trailing = hidden;
-					this.burst.stop();
-					return;
-				}
-				this.burst.next();
-			}
-			/**
-			* Whether any shown session's last reading is a phase the host has not
-			* finished walking — the only states an action's own echo could be hiding a
-			* transition behind.
-			*/
-			moving() {
-				const shown = this.store.getSnapshot().bySession;
-				for (const sessionId of this.shown) {
-					const phase = shown[String(sessionId)]?.phase;
-					if (phase !== void 0 && MOVING.has(phase)) return true;
-				}
-				return false;
-			}
-			/**
-			* Follow the page in and out of view. A hidden page is not being read — and
-			* the read the burst was about to take is not lost, it waits for the page to
-			* come back.
-			*/
-			watchVisibility() {
-				this.burst.checkVisibility();
-			}
 		};
 		//#endregion
 		//#region lib/types/client/view.js
@@ -994,11 +201,11 @@ window.__ModuleLoader__.load({
 		* @param reading - the host-reported reading, or `undefined` before the first answer.
 		* @returns the view for that reading.
 		*/
-		function pauseView(reading) {
+		function pauseView(reading, running = true) {
 			switch (reading?.phase) {
 				case "active": return {
 					paused: false,
-					enabled: true,
+					enabled: running,
 					ariaKey: "pause.aria",
 					runningTools: []
 				};
@@ -1007,16 +214,14 @@ window.__ModuleLoader__.load({
 					enabled: true,
 					ariaKey: "draining.aria",
 					labelKey: "state.draining",
-					runningTools: reading.runningTools,
-					...goalOf(reading)
+					runningTools: reading.runningTools
 				};
 				case "parking": return {
 					paused: true,
 					enabled: true,
 					ariaKey: "parking.aria",
 					labelKey: "state.parking",
-					runningTools: [],
-					...goalOf(reading)
+					runningTools: []
 				};
 				case "safe": return {
 					paused: true,
@@ -1031,8 +236,7 @@ window.__ModuleLoader__.load({
 					enabled: true,
 					ariaKey: "flushFailed.aria",
 					labelKey: "state.flushFailed",
-					runningTools: [],
-					...goalOf(reading)
+					runningTools: []
 				};
 				case "unavailable": return {
 					paused: false,
@@ -1072,6 +276,16 @@ window.__ModuleLoader__.load({
 			}
 		];
 		/**
+		* The decisions one row may offer. Continue and note both deliver the owed
+		* request, so they are absent when the log is unreadable or the host says it
+		* cannot wake the entry; the remaining decisions still give the user a way out.
+		* @param row - the rendered row.
+		* @returns the actions that can be taken on it.
+		*/
+		function triageActionsFor(row) {
+			return TRIAGE_ACTION_VIEWS.filter((action) => action.action !== "continue" && action.action !== "note" ? true : row.readable && row.wakeable);
+		}
+		/**
 		* The fifth listed verb, rendered apart from the four decisions: it is a
 		* switch on what the NEXT resume may spend, not a way to decide this row.
 		*/
@@ -1092,12 +306,19 @@ window.__ModuleLoader__.load({
 		* @returns the rows as the panel renders them.
 		*/
 		function triageView(reading) {
-			if (reading === void 0 || reading.kind === "unavailable") return {
+			if (reading === void 0) return {
 				visible: false,
+				unavailable: false,
+				rows: []
+			};
+			if (reading.kind === "unavailable") return {
+				visible: true,
+				unavailable: true,
 				rows: []
 			};
 			return {
 				visible: true,
+				unavailable: false,
 				rows: reading.rows.map((row) => ({
 					sessionId: row.sessionId,
 					phaseKey: PHASE_KEY[row.phase],
@@ -1114,7 +335,7 @@ window.__ModuleLoader__.load({
 		* @param reading - the host-reported reading, or `undefined` before the first answer.
 		* @returns the view for that reading.
 		*/
-		function globalPauseView(reading) {
+		function globalPauseView(reading, sessions) {
 			if (reading === void 0) return {
 				visible: false,
 				enabled: false,
@@ -1125,9 +346,9 @@ window.__ModuleLoader__.load({
 				unclean: 0
 			};
 			if (reading.kind === "unavailable") return {
-				visible: false,
+				visible: true,
 				enabled: false,
-				ariaKey: "unavailable.aria",
+				ariaKey: "all.unavailable.aria",
 				action: "none",
 				detail: "",
 				caveats: [],
@@ -1182,10 +403,14 @@ window.__ModuleLoader__.load({
 				};
 				case "waiting": return status.draining.length > 0 || status.parking > 0 ? {
 					...base,
-					ariaKey: "all.resume.aria",
-					action: "resume-all",
+					ariaKey: "all.cancel.aria",
+					action: "cancel-all",
 					labelKey: "all.finishing",
-					detail: `${String(status.safe)}/${String(status.registered)}`
+					detail: `${String(status.safe)}/${String(status.registered)}`,
+					running: status.draining.map((id) => {
+						const tools = sessions?.[id]?.runningTools ?? [];
+						return tools.length === 0 ? id : `${id}: ${tools.join(", ")}`;
+					}).join(", ") || void 0
 				} : {
 					...base,
 					enabled: false,
@@ -1201,67 +426,38 @@ window.__ModuleLoader__.load({
 		/**
 		* Browser-side reading and driving of the host's whole-app park state.
 		*
-		* The same one live channel the per-session control uses — a session command
-		* run through `ctx.remote.commands.execute`, plus the forwarded
-		* `commands/change` event as the only notification — carries the aggregate
-		* here. There is no push channel a third-party plugin can add, so the browser
-		* asks: `pause-state-all` is registered globally and its RESULT carries the
-		* whole-app status as of the read.
-		*
-		* The command channel is session-addressed, so the control needs one session
-		* to talk through. It picks a user session the host can serve (never a
-		* subagent's own session), preferring the one on screen; with no session at
-		* all there is nothing to ask, and the control claims nothing rather than
-		* inventing an answer. Once the host's own answer names the session the park
-		* belongs to, reads are addressed there instead: a read writes two records into
-		* the address session's transcript, and they belong in the session being parked
-		* rather than in whatever the user happens to be looking at. That name outlives
-		* the phases — a session that drained and parked cleanly names nothing else — so
-		* a clean park is addressed like a moving one. Failing that, the session the
-		* last answer reported as registered is remembered, then the one a read was last
-		* served through — an address change is the user looking somewhere else, not
-		* news about the park, and a park that has emptied out is no reason to start
-		* writing rows into every session the user opens next. An address that stops
-		* answering (its agent is gone) is forgotten and the read falls back to the next
-		* one, the session the shell asks with last, so a stale address costs an honest
-		* answer rather than a control that can never speak again.
-		*
-		* Every phase a session reaches announces itself through the registry — a
-		* transition re-registers that session's status verb — so a change is what buys
-		* the next read, and the flush that settles a park is announced like every other
-		* step (`./burst.ts`). A read that finds work still in flight is therefore the
-		* answer to the transition that produced it rather than a reason to keep asking;
-		* what the burst still owes is the delivery of a change, and the rows of a panel
-		* whose own read did not answer. A settled answer is left on screen unread: the
-		* panel stays readable and the pill keeps saying what it says, but the browser
-		* stops spending host round-trips and log records on a state that has stopped
-		* moving. What owes a read is the host's forwarded registry change, the user's
-		* own press or decision, and the first read at mount; once an answer is on
-		* screen, the shell handing this control another session to ask through is none
-		* of those. A press, a decision and an opened panel each read the host as they
-		* run, and the changes they set off are that action's own echo: those are
-		* absorbed for a short window (`./burst.ts`), so a forwarded change owes a read
-		* exactly when something moved that this browser did not do — with one look owed
-		* at the close of that window when the reading the action left is still moving,
-		* which is how a park that reaches its final phase inside the echo window is
-		* still read.
+		* The aggregate arrives from the native `pauseSession` stream. The stream is
+		* process-wide and writes nothing into any Session; actions travel through the
+		* same Remote namespace. A pushed snapshot is applied directly; a settled park
+		* costs nothing while its last answer stays on screen.
 		* @module dsh-pause-session/client/global
 		*/
+		/** Map one Remote row to the list's structured row. */
+		function wireTriageRow(row) {
+			return {
+				sessionId: row.sessionId,
+				phase: row.phase,
+				updatedAt: row.updatedAt,
+				reading: row.reading,
+				...row.lastEvent === void 0 ? {} : { lastEvent: row.lastEvent },
+				...row.turn === void 0 ? {} : { turn: row.turn },
+				...row.step === void 0 ? {} : { step: row.step },
+				traces: row.traces.map((trace) => ({
+					tool: trace.tool,
+					callId: trace.callId ?? ""
+				})),
+				owed: row.owed,
+				wakeable: row.wakeable,
+				rearmGoal: row.rearmGoal
+			};
+		}
 		const INITIAL = {
 			global: void 0,
 			panelOpen: false,
 			triage: void 0
 		};
-		/** The command one listed verb runs, named from the one vocabulary the host registers. */
-		const TRIAGE_DECISION_COMMAND = {
-			continue: TRIAGE_CONTINUE_COMMAND,
-			note: TRIAGE_NOTE_COMMAND,
-			review: TRIAGE_REVIEW_COMMAND,
-			leave: TRIAGE_LEAVE_COMMAND,
-			goal: TRIAGE_GOAL_COMMAND
-		};
 		/**
-		* The session a whole-app command is addressed to.
+		* The session a whole-app action is addressed to.
 		*
 		* A subagent's own session is never addressed: its agent belongs to a parent
 		* and is not the host's business to drive from the shell. Among the rest, the
@@ -1277,410 +473,955 @@ window.__ModuleLoader__.load({
 			});
 			return usable.find((id) => (state.byId[String(id)]?.retainedBy?.mainView ?? 0) > 0) ?? usable.find((id) => state.byId[String(id)]?.running === true) ?? usable[0];
 		}
-		/**
-		* The registered sessions one whole-app answer names, best address first: the
-		* one still draining is the one this host is executing against right now, the
-		* rest is the host's own vocabulary for a registered session it is not going to
-		* move any further.
-		*
-		* A stalled or unreadable record is deliberately not an address for a read —
-		* this host may not hold that session at all, and a read that could not be
-		* delivered would report "unavailable" for a transport reason rather than a
-		* state — but it is still a registered session, which is all the remembered
-		* address is for. The host's own answer is JSON: the branded ids arrive as the
-		* strings they were encoded as, exactly like the ids the shell hands the pill.
-		* @param status - the host's last whole-app answer.
-		* @returns the registered sessions the answer names, best first.
-		*/
-		function registeredSessions(status) {
-			return [
-				...status.draining,
-				...status.stalled,
-				...status.unresumable,
-				...status.unreadTrees
-			];
-		}
-		/**
-		* The session a registered park owns, when the host's answer names one that is
-		* still moving. This is how a read stops landing in whatever session the user
-		* happens to be looking at.
-		* @param status - the host's last whole-app answer.
-		* @returns a draining session, or `undefined` when the answer names none.
-		*/
-		function registeredAddress(status) {
-			const draining = status.draining[0];
-			return draining === void 0 ? void 0 : draining;
-		}
-		/**
-		* The session the host names as the park's own, whatever phase the park
-		* reached — the address a whole-app read belongs at.
-		*
-		* This is the fact {@link registeredAddress} cannot carry once a park is clean:
-		* a session that reached `safe` has nothing left to do, so no bucket names it,
-		* and a reader in another window would fall back to whatever session it is
-		* showing. An answer written before this field existed names no session here:
-		* an absent address, never one to guess at.
-		* @param status - the host's last whole-app answer.
-		* @returns the session the park belongs to, or `undefined` when the answer names none.
-		*/
-		function parkedAddress(status) {
-			return status.parkedAt === void 0 ? void 0 : status.parkedAt;
-		}
 		/** Owns the published whole-app reading; nothing else writes that state. */
 		var PauseGlobalControl = class {
-			commands;
+			transport;
 			lifetime;
 			/** State source the whole-app contribution binds its selector hook to. */
 			store = (0, _deepseek_ai_dsh_client_store.createSnapshotStore)(INITIAL);
-			/** The session the shell asked this control through; reads start here. */
+			/** The session the shell asked this control through; list reads use it. */
 			address;
-			/**
-			* The last session an answer reported as registered — the address a read
-			* falls back to when the host's own answer names no parked session, which is
-			* every reading written before that field existed.
-			*
-			* The buckets that feed it name only what is still moving, so they say
-			* nothing about a park that finished cleanly; the park's own name is the live
-			* fact, and this memory is what keeps the rows in the park's transcript for an
-			* answer that predates it. An empty registry does not clear it: a park whose
-			* sessions stopped moving has not moved out of its sessions.
-			*/
-			lastRegistered;
-			/**
-			* The session an aggregate read was last served through. Later reads keep
-			* going there: every read is two records in the address session's log, and
-			* the shell's address follows whatever the user is looking at, which is not
-			* where a row about the park belongs.
-			*/
-			served;
 			/** Highest decision-list read requested: an answer older than it is dropped. */
 			latestTriage = 0;
-			/** Highest read sequence requested: an answer older than it is dropped. */
-			latest = 0;
-			/**
-			* Whether a registry change has arrived that no completed read pass has
-			* answered. Set only for a change that is news — an absorbed echo of this
-			* browser's own action is already answered by that action's read.
-			*/
-			owed = false;
-			/** The bounded burst of reads one transition buys; see `./burst.ts`. */
-			burst;
 			/**
-			* @param commands - the Client-callable command namespace.
-			* @param lifetime - aborts in-flight calls and the burst when the plugin unloads.
-			* @param windowMs - how long the burst collects the registrations of one
-			* transition before its first read; also the wait after a press.
-			* @param policy - the burst waits and visibility source; defaults to the real page.
+			* @param transport - the native namespace source and actions.
+			* @param lifetime - aborts in-flight reads when the plugin unloads.
 			*/
-			constructor(commands, lifetime, windowMs = 400, policy = DEFAULT_BURST_POLICY) {
-				this.commands = commands;
+			constructor(transport, lifetime) {
+				this.transport = transport;
 				this.lifetime = lifetime;
-				this.burst = new ReadBurst(() => {
-					this.readAll();
-				}, {
-					...policy,
-					windowMs,
-					waitsMs: burstWaits(windowMs)
-				});
 			}
 			/**
-			* The shell handed this control a session: the one the pill mounted on, or
-			* the one the user has just moved to. Only a control with no answer yet reads
-			* here — the view moving is not the park moving, and after the first answer
-			* the forwarded registry change and the user's own press are what ask again.
-			* A read that came back with nothing is not an answer, so moving to another
-			* session is one more chance to reach the host rather than a control that
-			* stays mute until something else happens to change. The address is kept
-			* either way: it is where this control's presses and its decision list go, and
-			* the fallback a remembered address falls back to.
+			* The shell handed this control a session. The first call reads the aggregate;
+			* later calls only move where list reads and actions are addressed.
 			* @param sessionId - the session the shell asks through.
-			* @returns after this read's answer is published or superseded by a newer one.
 			*/
 			async refresh(sessionId) {
 				this.address = sessionId;
-				if (this.answered()) return;
 				await this.readAggregate();
-				this.follow();
 			}
-			/** Whether the host has answered: a state, not the absence of one it never sent. */
-			answered() {
-				return this.store.getSnapshot().global?.kind === "reported";
+			/** Apply one pushed snapshot directly. */
+			apply(snapshot) {
+				this.store.update((state) => {
+					state.sessions = snapshot?.sessions;
+				});
+				this.publish(snapshot === void 0 ? { kind: "unavailable" } : {
+					kind: "reported",
+					status: snapshot.global
+				});
 			}
-			/**
-			* The host's command registry changed: something may have moved, so a burst
-			* is owed. The reads run on the burst's own schedule rather than here, which
-			* is what coalesces a tick's worth of changes — parking N sessions announces
-			* three registrations each, and a phase change re-registers one more — into
-			* one burst. A change that is this browser's own action's echo owes nothing:
-			* the action read the host as it ran.
-			*/
+			/** A pushed snapshot may have moved the aggregate and the open list. */
 			refreshAll() {
-				if (this.address === void 0 || this.lifetime.aborted) return;
-				if (!this.burst.trigger()) return;
-				this.owed = true;
-			}
-			/**
-			* One read of the whole screen: the aggregate, plus the decision list while
-			* the user has it open. A closed panel spends no command calls on rows nobody
-			* is reading.
-			*/
-			async readAll() {
-				if (this.target() === void 0 || this.lifetime.aborted) {
-					this.owed = false;
-					this.burst.stop();
-					return;
-				}
-				this.owed = false;
-				await this.readAggregate();
-				if (this.store.getSnapshot().panelOpen) await this.readTriage();
-				this.follow();
-			}
-			/**
-			* The session a read goes through: the one the park is still draining, else
-			* the one the host names as the park's own, else the one a read was last
-			* served through, else the session the shell is on now. The park's own address
-			* comes first because a read's rows land in the transcript it was taken
-			* through, and the park — not the reader — is what they are about; its name
-			* survives the clean case, where every bucket above is empty and a park that
-			* finished would otherwise have no address at all.
-			* @param skip - an address this read already tried and could not reach. The
-			* fallback is the next candidate rather than the same one again.
-			*/
-			target(skip) {
-				const current = this.store.getSnapshot().global;
-				const named = current?.kind === "reported" ? current.status : void 0;
-				return [
-					named === void 0 ? void 0 : registeredAddress(named),
-					named === void 0 ? void 0 : parkedAddress(named),
-					this.lastRegistered,
-					this.served,
-					this.address
-				].find((candidate) => candidate !== void 0 && candidate !== skip);
-			}
-			/**
-			* Ask the host for the aggregate through the session a read goes through,
-			* with the one fallback an address that stopped answering is worth: the
-			* remembered address is forgotten, and the read is taken again through the
-			* next one — the session the shell is on at the latest. A memory of a session
-			* this host no longer holds would otherwise leave the control unable to say
-			* anything at all, and a single retry is the whole price of keeping it honest.
-			*/
-			async readAggregate() {
-				const address = this.target();
-				if (address === void 0) return;
-				if (!await this.readAt(address)) return;
-				const fallback = this.target(address);
-				if (fallback === void 0) return;
-				await this.readAt(fallback);
+				if (this.lifetime.aborted) return;
+				this.readAggregate();
+				if (this.store.getSnapshot().panelOpen) this.refreshTriage();
 			}
 			/**
-			* Publish one aggregate answer, unless a newer read was requested while this
-			* one was in flight: that answer would show a state the host has moved past.
-			* A served address is remembered, and one that did not answer is forgotten —
-			* that is what makes the read fall back to the next address rather than ask
-			* it again.
-			* @param sessionId - the session this read goes through.
-			* @returns whether this read came back without an answer; a superseded read is
-			* not one, because the newer read already owns the outcome.
-			*/
-			async readAt(sessionId) {
-				const sequence = ++this.latest;
-				const reading = await this.read(sessionId);
-				if (this.latest !== sequence) return false;
-				if (reading.kind === "reported") {
-					this.served = sessionId;
-					const registered = registeredSessions(reading.status)[0];
-					if (registered !== void 0) this.lastRegistered = registered;
-				} else {
-					if (this.served === sessionId) this.served = void 0;
-					if (this.lastRegistered === sessionId) this.lastRegistered = void 0;
-				}
-				this.publish(reading);
-				return reading.kind === "unavailable";
-			}
-			/**
-			* Open or close the decision list. Opening asks the host for the rows; there
-			* is no state to show without that answer. Opening is also a client action
-			* that reads, so the changes it sets off are absorbed rather than read back,
-			* and whether the burst owes anything is what its own read decides.
+			* Open or close the decision list. Opening asks for the rows; there is no
+			* state to show without that answer.
 			* @param open - whether the panel should be showing.
 			*/
 			setPanel(open) {
 				this.store.update((state) => {
 					state.panelOpen = open;
 				});
-				if (open) {
-					this.burst.absorb();
-					this.refreshTriage();
-					return;
-				}
-				this.follow();
+				if (open) this.refreshTriage();
 			}
-			/**
-			* Ask the host for the decision list through the session the user is on. The
-			* list is recorded per calling session and the decisions act only on rows
-			* that session was shown, so this read — unlike the aggregate — stays on the
-			* shell's own address.
-			*/
+			/** Ask the host for the decision list for the session the user is on. */
 			async refreshTriage() {
 				await this.readTriage();
-				this.follow();
-			}
-			/**
-			* Read the aggregate again because the user asked this control to act: the
-			* address is the session the shell is on, since a press is a user action on
-			* the session the user is looking at, and the host's answer is what the
-			* control shows next.
-			* @param sessionId - the session the shell is on.
-			*/
-			async reread(sessionId) {
-				this.address = sessionId;
-				await this.readAggregate();
-				this.follow();
-			}
-			/** One decision-list read, addressed at the session the user is on. */
-			async readTriage() {
-				const address = this.address;
-				if (address === void 0) return;
-				const sequence = ++this.latestTriage;
-				const reading = await this.readTriageRows(address);
-				if (this.latestTriage !== sequence) return;
-				this.store.update((state) => {
-					state.triage = reading;
-				});
 			}
 			/**
 			* Take one listed verb on one listed session, addressed through the session
-			* the user is on. The list is read first, because the host acts only on rows
-			* it has shown the calling session, and read again afterwards because the
-			* host's answer — not this control's assumption — is what the next render
-			* shows: a decision can release a session, and the goal switch changes what
-			* the row itself says.
+			* the user is on. A refusal is published verbatim rather than silently
+			* leaving the previous rows in place.
 			* @param sessionId - the listed session to act on.
 			* @param action - which listed verb was taken.
 			*/
 			async decide(sessionId, action) {
 				const address = this.address;
 				if (address === void 0) return;
-				this.burst.absorb();
-				await this.refreshTriage();
-				await this.commands.execute(address, `/${TRIAGE_DECISION_COMMAND[action]} ${sessionId}`, [], this.lifetime);
+				const answer = await this.transport.decide(String(address), sessionId, action, this.lifetime);
+				if (!answer.ok) {
+					this.store.update((state) => {
+						state.error = answer.message;
+					});
+					return;
+				}
+				this.store.update((state) => {
+					state.error = void 0;
+				});
 				await this.refreshTriage();
 				await this.reread(address);
 			}
 			/**
 			* Press the pill: park everything, or release everything the park owns.
 			* Which one it is comes from the host's own last answer, never from a local
-			* flip; the state shown afterwards is the host's answer again. A reading the
-			* view does not turn into a verb — every registered session is one the host
-			* will not wake — is not pressed at all.
+			* flip; the state shown afterwards is the host's answer again.
 			* @param sessionId - the session to address the verb to.
-			* @returns after the control re-reads the host.
 			*/
 			async toggle(sessionId) {
 				const current = this.store.getSnapshot().global;
 				if (current === void 0 || current.kind !== "reported") return;
 				const action = globalPauseView(current).action;
 				if (action === "none") return;
-				const line = action === "pause-all" ? `/${PAUSE_ALL_COMMAND}` : `/${RESUME_ALL_COMMAND}`;
-				this.burst.absorb();
-				if (!(await this.commands.execute(sessionId, line, [], this.lifetime)).ok) {
-					this.publish({ kind: "unavailable" });
-					this.follow();
+				const answer = await this.transport.act({
+					action,
+					sessionId: String(sessionId)
+				}, this.lifetime);
+				if (!answer.ok) {
+					this.store.update((state) => {
+						state.error = answer.message;
+					});
 					return;
 				}
+				this.store.update((state) => {
+					state.error = void 0;
+				});
 				await this.reread(sessionId);
 			}
-			/** Ask the host for the decision list, in the browser's vocabulary. */
-			async readTriageRows(sessionId) {
-				const answered = await this.commands.execute(sessionId, `/${TRIAGE_COMMAND}`, [], this.lifetime);
-				if (!answered.ok || answered.value === void 0) return { kind: "unavailable" };
-				const text = answered.value.result.kind === "success" ? answered.value.result.text : void 0;
-				const list = text === void 0 ? void 0 : decodeTriageList(text);
-				return list === void 0 ? { kind: "unavailable" } : {
+			/** Read the aggregate once and publish it. */
+			async readAggregate() {
+				const snapshot = await this.transport.source.read(this.lifetime);
+				if (snapshot === void 0) {
+					this.publish({ kind: "unavailable" });
+					return;
+				}
+				this.store.update((state) => {
+					state.sessions = snapshot.sessions;
+				});
+				this.publish({
 					kind: "reported",
-					rows: list.rows
-				};
+					status: snapshot.global
+				});
 			}
-			/** Ask the host what the whole-app park state is, in the browser's vocabulary. */
-			async read(sessionId) {
-				const answered = await this.commands.execute(sessionId, `/${STATE_ALL_COMMAND}`, [], this.lifetime);
-				if (!answered.ok || answered.value === void 0) return { kind: "unavailable" };
-				const text = answered.value.result.kind === "success" ? answered.value.result.text : void 0;
-				const status = text === void 0 ? void 0 : decodeGlobalStatus(text);
-				if (status === void 0) return { kind: "unavailable" };
-				return {
+			async reread(sessionId) {
+				this.address = sessionId;
+				await this.readAggregate();
+			}
+			/** One decision-list read, addressed at the session the user is on. */
+			async readTriage() {
+				const address = this.address;
+				if (address === void 0) return;
+				const sequence = ++this.latestTriage;
+				const reading = await this.readTriageRows(address);
+				if (this.latestTriage !== sequence) return;
+				this.store.update((state) => {
+					state.triage = reading;
+				});
+			}
+			/** Ask the native namespace for the decision list. */
+			async readTriageRows(sessionId) {
+				const rows = await this.transport.triage(String(sessionId), this.lifetime);
+				return rows === void 0 ? { kind: "unavailable" } : {
 					kind: "reported",
-					status
+					rows: rows.map(wireTriageRow)
 				};
 			}
 			publish(reading) {
 				this.store.update((state) => {
+					if (state.global?.kind === reading.kind && (reading.kind === "unavailable" || state.global?.kind === "reported" && JSON.stringify(state.global.status) === JSON.stringify(reading.status))) return;
 					state.global = reading;
 				});
 			}
-			/**
-			* Decide what the burst owes after a read: another look while a change this
-			* browser has not answered is outstanding, or while the open panel is still
-			* owed rows, and nothing once neither holds.
-			*
-			* A registered session standing at the park point is left alone: the flush
-			* that settles it announces itself on the command channel like every other
-			* transition, so watching it from here would spend reads on a move that is
-			* going to speak for itself. A verdict that stays `waiting` because a record
-			* is stalled, unresumable or unread is not settling either: nothing in this
-			* process will change it, and a session that starts moving again registers its
-			* markers, which is what asks next.
-			*
-			* The one transition that cannot speak for itself is the one this browser's
-			* own echo window swallowed: a press reads the host, the park reaches its
-			* final phase while the window is still open, and the changes that would have
-			* announced it look exactly like the press's own registrations. An action that
-			* left the park moving therefore asks for one look when that window closes,
-			* and only then. Once nothing is owed, the last reading stays published — the
-			* verdict, the pill and the rows are exactly what the host last reported.
-			*/
-			follow() {
-				if (this.lifetime.aborted) {
-					this.burst.stop();
-					return;
+		};
+		//#endregion
+		//#region lib/types/client/remote.js
+		/**
+		* Client-side bridge from the generated `pauseSession` Remote namespace to the
+		* control state machines.
+		*
+		* The native namespace is the only transport: the stream supplies snapshots and
+		* the action methods drive every button. No slash command is involved.
+		* @module dsh-pause-session/client/remote
+		*/
+		/** Convert one wire snapshot to the host-status vocabulary the controls already use. */
+		function snapshotOf(wire) {
+			return {
+				global: {
+					...wire.global,
+					parkedAt: wire.global.parkedAt,
+					draining: wire.global.draining,
+					stalled: wire.global.stalled,
+					unresumable: wire.global.unresumable,
+					unreadTrees: wire.global.unreadTrees,
+					jobs: wire.global.jobs,
+					blind: wire.global.blind
+				},
+				sessions: Object.fromEntries(Object.entries(wire.sessions).map(([id, status]) => [id, status]))
+			};
+		}
+		/** First retry delay after the stream drops, in milliseconds. */
+		const RECONNECT_BASE_MS = 300;
+		/** Ceiling for the reconnect backoff, in milliseconds. */
+		const RECONNECT_MAX_MS = 5e3;
+		/**
+		* Open the native status stream and expose its latest snapshot to both controls.
+		*
+		* The stream owns no retry of its own: a carrier can drop it on a mux reconnect,
+		* a host reload, or a network blip, and the controls must not stay unavailable
+		* until the page is refreshed. This source reconnects with a bounded backoff and
+		* republishes the new snapshot; while it is disconnected the last value is
+		* discarded, so readers see "unavailable" rather than a stale claim.
+		* @param remote - the generated Remote namespace.
+		* @param lifetime - client lifetime; aborting it releases the stream.
+		* @returns the cached source and its change subscription.
+		*/
+		function openRemoteSource(remote, lifetime) {
+			let latest;
+			let attempt = 0;
+			let timer;
+			/** Readers waiting for the first snapshot of any attempt. */
+			const waiters = /* @__PURE__ */ new Set();
+			const listeners = /* @__PURE__ */ new Set();
+			const snapshotListeners = /* @__PURE__ */ new Set();
+			const notify = () => {
+				for (const wake of [...waiters]) wake();
+				waiters.clear();
+				for (const listener of [...listeners]) listener();
+				for (const listener of [...snapshotListeners]) listener(latest);
+			};
+			const schedule = () => {
+				if (lifetime.aborted || timer !== void 0) return;
+				const delay = Math.min(RECONNECT_BASE_MS * 2 ** attempt, RECONNECT_MAX_MS);
+				attempt += 1;
+				timer = setTimeout(() => {
+					timer = void 0;
+					pump();
+				}, delay);
+			};
+			const pump = async () => {
+				if (lifetime.aborted) return;
+				try {
+					for await (const snapshot of remote.observe(lifetime)) {
+						attempt = 0;
+						latest = snapshotOf(snapshot);
+						notify();
+					}
+				} catch {}
+				if (lifetime.aborted) return;
+				latest = void 0;
+				notify();
+				schedule();
+			};
+			pump();
+			return {
+				onChange: (listener) => {
+					listeners.add(listener);
+					return () => {
+						listeners.delete(listener);
+					};
+				},
+				onSnapshot: (listener) => {
+					snapshotListeners.add(listener);
+					return () => {
+						snapshotListeners.delete(listener);
+					};
+				},
+				read: async (signal) => {
+					if (latest === void 0 && !lifetime.aborted) await new Promise((resolve) => {
+						const wake = () => {
+							waiters.delete(wake);
+							signal?.removeEventListener("abort", wake);
+							resolve();
+						};
+						waiters.add(wake);
+						signal?.addEventListener("abort", wake, { once: true });
+					});
+					signal?.throwIfAborted();
+					return latest;
 				}
-				if (!this.owed && !this.unansweredPanel()) {
-					if (this.burst.absorbing && this.moving()) this.burst.recheckAfterEcho();
-					this.burst.stop();
-					return;
+			};
+		}
+		/**
+		* Build the direct transport over one mounted Remote namespace.
+		* @param remote - the generated `pauseSession` namespace.
+		* @param lifetime - client lifetime.
+		* @returns the source and action methods the controls use.
+		*/
+		function remoteTransport(remote, lifetime) {
+			const source = openRemoteSource(remote, lifetime);
+			const failed = () => ({
+				ok: false,
+				message: "pause action failed"
+			});
+			return {
+				source,
+				act: async (request, signal) => {
+					const answer = await remote.act(request, signal);
+					return answer.ok ? answer.value ?? failed() : failed();
+				},
+				triage: async (caller, signal) => {
+					const answer = await remote.triage({ caller }, signal);
+					return answer.ok ? answer.value : void 0;
+				},
+				decide: async (caller, target, decision, signal) => {
+					const answer = await remote.decide({
+						caller,
+						target,
+						decision
+					}, signal);
+					return answer.ok ? answer.value ?? failed() : failed();
+				}
+			};
+		}
+		//#endregion
+		//#region src/client/zod-lite.ts
+		/** Build one identity codec node. */
+		function node() {
+			return {
+				parse: (value) => value,
+				safeParse: (value) => ({
+					success: true,
+					data: value
+				}),
+				readonly() {
+					return this;
+				},
+				optional() {
+					return this;
+				},
+				describe() {
+					return this;
+				}
+			};
+		}
+		/** The `z` namespace the generated client contribution expects. */
+		const z = {
+			string: node,
+			number: node,
+			boolean: node,
+			undefined: node,
+			literal: node,
+			union: node,
+			array: node,
+			record: node,
+			object: node,
+			strictObject: node,
+			enum: node
+		};
+		//#endregion
+		//#region ../../deepseek-harness/packages/typert/protocol/lib/types/remote-info.js
+		/** Lazy assembly of generated Remote definitions using caller-supplied Zod; no runtime imports. */
+		/**
+		* Retain one generated definition per endpoint without constructing parsers or projections.
+		* The class instance builds its shared descriptor/method index on first access;
+		* input schemas and JSON Schema projections are cached only when requested.
+		* @param spec - compiler-produced method facts and Zod factories.
+		* @param zod - the generated artifact's Zod runtime for named-input parsers.
+		* @returns a lazy, mountable info instance with no registration or transport effects.
+		*/
+		function createTypertRemoteInfo(spec, zod) {
+			return new RemoteInfo(spec, zod);
+		}
+		var RemoteInfo = class {
+			spec;
+			zod;
+			index;
+			constructor(spec, zod) {
+				this.spec = spec;
+				this.zod = zod;
+			}
+			get package() {
+				return this.spec.package;
+			}
+			get descriptors() {
+				return this.resolve().descriptors;
+			}
+			get methods() {
+				return this.resolve().methods;
+			}
+			resolve() {
+				if (this.index !== void 0) return this.index;
+				const zod = this.zod;
+				const descriptors = [];
+				const methods = Object.create(null);
+				for (const [endpoint, definition] of Object.entries(this.spec.methods)) {
+					const separator = endpoint.indexOf("/");
+					const namespace = endpoint.slice(0, separator);
+					const method = endpoint.slice(separator + 1);
+					const parameters = definition.parameters.map((parameter) => ({
+						...parameter,
+						wire: parameter.wire ?? parameter.name
+					}));
+					const descriptor = {
+						...definition,
+						id: `${this.spec.package}#${endpoint}`,
+						namespace,
+						method,
+						parameters,
+						result: definition.result.description === void 0 ? definition.result : new ResultValue(definition.result)
+					};
+					if (definition.invocation.kind === "direct") {
+						const inputs = [];
+						methods[endpoint] = Object.assign(descriptor, {
+							input(options) {
+								const strict = options?.strict === true;
+								return inputs[strict ? 1 : 0] ??= new NamedInput(parameters, strict, zod);
+							},
+							invoke(remote, input, signal) {
+								const named = input;
+								const values = parameters.map((parameter) => named[parameter.wire]);
+								if (definition.cancellation !== void 0) values.push(signal);
+								const receiver = Reflect.get(remote, namespace);
+								return Reflect.get(receiver, method).apply(receiver, values);
+							}
+						});
+					}
+					descriptors.push(descriptor);
 				}
-				this.burst.next();
+				return this.index = {
+					descriptors,
+					methods
+				};
 			}
-			/**
-			* Whether the park this control last read still has work on its way — the only
-			* state an action's own echo could be hiding a transition behind. A record
-			* that is stalled, unresumable or unread is not moving: nothing in this
-			* process will finish it.
-			*/
-			moving() {
-				const current = this.store.getSnapshot().global;
-				return current?.kind === "reported" && (current.status.draining.length > 0 || current.status.parking > 0);
+		};
+		function optional(parameter) {
+			return parameter.source === "json" && parameter.acceptsUndefined === true;
+		}
+		var NamedInput = class {
+			parameters;
+			strict;
+			zod;
+			schema;
+			projection;
+			constructor(parameters, strict, zod) {
+				this.parameters = parameters;
+				this.strict = strict;
+				this.zod = zod;
 			}
-			/**
-			* Whether the open panel is still owed its rows. Opening the panel reads them,
-			* so this holds only after a read that did not answer — the one debt no change
-			* created, and the one place a retry is the difference between an empty panel
-			* and the facts the host has. It is bounded by the burst like everything else.
-			*/
-			unansweredPanel() {
-				const state = this.store.getSnapshot();
-				return state.panelOpen && (state.triage === void 0 || state.triage.kind === "unavailable");
+			codec(parameter) {
+				return this.strict ? parameter.strictCodec : parameter.codec;
 			}
-			/**
-			* Follow the page in and out of view. A hidden page is not being read — and
-			* the read the burst was about to take is not lost, it waits for the page to
-			* come back.
-			*/
-			watchVisibility() {
-				this.burst.checkVisibility();
+			create = () => this.schema ??= this.zod.strictObject(Object.fromEntries(this.parameters.map((parameter) => {
+				const value = this.codec(parameter).create();
+				return [parameter.wire, optional(parameter) ? value.optional() : value.nonoptional()];
+			})));
+			get jsonSchema() {
+				return this.project().jsonSchema;
+			}
+			get jsonSchemaError() {
+				return this.project().jsonSchemaError;
+			}
+			project() {
+				if (this.projection !== void 0) return this.projection;
+				const unavailable = this.parameters.find((parameter) => this.codec(parameter).jsonSchema === void 0);
+				if (unavailable !== void 0) return this.projection = { jsonSchemaError: this.codec(unavailable).jsonSchemaError ?? `No JSON Schema for parameter ${unavailable.wire}` };
+				return this.projection = { jsonSchema: {
+					type: "object",
+					properties: Object.fromEntries(this.parameters.map((parameter) => [parameter.wire, {
+						...this.codec(parameter).jsonSchema,
+						...parameter.description === void 0 ? {} : { description: parameter.description }
+					}])),
+					required: this.parameters.filter((parameter) => !optional(parameter)).map((parameter) => parameter.wire),
+					additionalProperties: false
+				} };
 			}
 		};
+		var ResultValue = class {
+			spec;
+			projection;
+			constructor(spec) {
+				this.spec = spec;
+			}
+			get mode() {
+				return this.spec.mode;
+			}
+			get typeSymbol() {
+				return this.spec.typeSymbol;
+			}
+			get create() {
+				return this.spec.create;
+			}
+			get decode() {
+				return this.spec.decode;
+			}
+			get encode() {
+				return this.spec.encode;
+			}
+			get description() {
+				return this.spec.description;
+			}
+			get jsonSchemaError() {
+				return this.spec.jsonSchemaError;
+			}
+			get jsonSchema() {
+				if (this.projection === void 0) {
+					const schema = this.spec.jsonSchema;
+					this.projection = { value: schema === void 0 ? void 0 : {
+						...schema,
+						description: this.spec.description
+					} };
+				}
+				return this.projection.value;
+			}
+		};
+		//#endregion
+		//#region lib/typert.remote-client.js
+		let dsh_pause_session_pauseSession_act_parameter_0$schema$value;
+		const dsh_pause_session_pauseSession_act_parameter_0$schema = () => dsh_pause_session_pauseSession_act_parameter_0$schema$value ??= z.object({
+			"action": z.union([
+				z.literal("pause"),
+				z.literal("resume"),
+				z.literal("pause-all"),
+				z.literal("resume-all"),
+				z.literal("cancel-all"),
+				z.literal("goal")
+			]).readonly(),
+			"sessionId": z.string().readonly().describe("The Session the control is addressed through.")
+		});
+		let dsh_pause_session_pauseSession_act_result$schema$value;
+		const dsh_pause_session_pauseSession_act_result$schema = () => dsh_pause_session_pauseSession_act_result$schema$value ??= z.object({
+			"ok": z.boolean().readonly(),
+			"message": z.string().readonly()
+		});
+		let dsh_pause_session_pauseSession_decide_parameter_0$schema$value;
+		const dsh_pause_session_pauseSession_decide_parameter_0$schema = () => dsh_pause_session_pauseSession_decide_parameter_0$schema$value ??= z.object({
+			"caller": z.string().readonly(),
+			"target": z.string().readonly(),
+			"decision": z.union([
+				z.literal("goal"),
+				z.literal("continue"),
+				z.literal("note"),
+				z.literal("review"),
+				z.literal("leave")
+			]).readonly()
+		});
+		let dsh_pause_session_pauseSession_decide_result$schema$value;
+		const dsh_pause_session_pauseSession_decide_result$schema = () => dsh_pause_session_pauseSession_decide_result$schema$value ??= z.object({
+			"ok": z.boolean().readonly(),
+			"message": z.string().readonly()
+		});
+		let dsh_pause_session_pauseSession_observe_result$schema$value;
+		const dsh_pause_session_pauseSession_observe_result$schema = () => dsh_pause_session_pauseSession_observe_result$schema$value ??= z.object({
+			"global": z.object({
+				"verdict": z.union([
+					z.literal("idle"),
+					z.literal("waiting"),
+					z.literal("safe")
+				]).readonly(),
+				"registered": z.number().readonly(),
+				"safe": z.number().readonly(),
+				"parkedAt": z.union([z.undefined(), z.string()]).readonly().optional(),
+				"draining": z.array(z.string()).readonly(),
+				"parking": z.number().readonly(),
+				"stalled": z.array(z.string()).readonly(),
+				"unresumable": z.array(z.string()).readonly(),
+				"unreadTrees": z.array(z.string()).readonly(),
+				"jobs": z.array(z.string()).readonly(),
+				"blind": z.array(z.string()).readonly()
+			}).readonly(),
+			"sessions": z.record(z.string(), z.object({
+				"phase": z.union([
+					z.literal("safe"),
+					z.literal("active"),
+					z.literal("draining"),
+					z.literal("parking"),
+					z.literal("flush-failed")
+				]).readonly(),
+				"runningTools": z.array(z.string()).readonly(),
+				"rearmGoal": z.union([
+					z.undefined(),
+					z.literal(false),
+					z.literal(true)
+				]).readonly().optional()
+			})).readonly().readonly()
+		});
+		let dsh_pause_session_pauseSession_snapshot_result$schema$value;
+		const dsh_pause_session_pauseSession_snapshot_result$schema = () => dsh_pause_session_pauseSession_snapshot_result$schema$value ??= z.object({
+			"global": z.object({
+				"verdict": z.union([
+					z.literal("idle"),
+					z.literal("waiting"),
+					z.literal("safe")
+				]).readonly(),
+				"registered": z.number().readonly(),
+				"safe": z.number().readonly(),
+				"parkedAt": z.union([z.undefined(), z.string()]).readonly().optional(),
+				"draining": z.array(z.string()).readonly(),
+				"parking": z.number().readonly(),
+				"stalled": z.array(z.string()).readonly(),
+				"unresumable": z.array(z.string()).readonly(),
+				"unreadTrees": z.array(z.string()).readonly(),
+				"jobs": z.array(z.string()).readonly(),
+				"blind": z.array(z.string()).readonly()
+			}).readonly(),
+			"sessions": z.record(z.string(), z.object({
+				"phase": z.union([
+					z.literal("safe"),
+					z.literal("active"),
+					z.literal("draining"),
+					z.literal("parking"),
+					z.literal("flush-failed")
+				]).readonly(),
+				"runningTools": z.array(z.string()).readonly(),
+				"rearmGoal": z.union([
+					z.undefined(),
+					z.literal(false),
+					z.literal(true)
+				]).readonly().optional()
+			})).readonly().readonly()
+		});
+		let dsh_pause_session_pauseSession_triage_parameter_0$schema$value;
+		const dsh_pause_session_pauseSession_triage_parameter_0$schema = () => dsh_pause_session_pauseSession_triage_parameter_0$schema$value ??= z.object({ "caller": z.string().readonly() });
+		let dsh_pause_session_pauseSession_triage_result$schema$value;
+		const dsh_pause_session_pauseSession_triage_result$schema = () => dsh_pause_session_pauseSession_triage_result$schema$value ??= z.array(z.object({
+			"sessionId": z.string().readonly(),
+			"phase": z.union([
+				z.literal("draining"),
+				z.literal("parking"),
+				z.literal("flush-failed")
+			]).readonly(),
+			"updatedAt": z.number().readonly(),
+			"reading": z.union([z.literal("read"), z.literal("unreadable")]).readonly(),
+			"lastEvent": z.union([z.undefined(), z.string()]).readonly().optional(),
+			"turn": z.union([z.undefined(), z.number()]).readonly().optional(),
+			"step": z.union([z.undefined(), z.number()]).readonly().optional(),
+			"traces": z.array(z.object({
+				"tool": z.string().readonly(),
+				"callId": z.string().readonly()
+			})).readonly(),
+			"owed": z.boolean().readonly(),
+			"wakeable": z.boolean().readonly(),
+			"rearmGoal": z.boolean().readonly()
+		}));
+		let dsh_pause_session_pauseSession_act_parameter_0_strict$schema$value;
+		const dsh_pause_session_pauseSession_act_parameter_0_strict$schema = () => dsh_pause_session_pauseSession_act_parameter_0_strict$schema$value ??= z.strictObject({
+			"action": z.union([
+				z.literal("pause"),
+				z.literal("resume"),
+				z.literal("pause-all"),
+				z.literal("resume-all"),
+				z.literal("cancel-all"),
+				z.literal("goal")
+			]).readonly(),
+			"sessionId": z.string().readonly().describe("The Session the control is addressed through.")
+		});
+		let dsh_pause_session_pauseSession_decide_parameter_0_strict$schema$value;
+		const dsh_pause_session_pauseSession_decide_parameter_0_strict$schema = () => dsh_pause_session_pauseSession_decide_parameter_0_strict$schema$value ??= z.strictObject({
+			"caller": z.string().readonly(),
+			"target": z.string().readonly(),
+			"decision": z.union([
+				z.literal("goal"),
+				z.literal("continue"),
+				z.literal("note"),
+				z.literal("review"),
+				z.literal("leave")
+			]).readonly()
+		});
+		let dsh_pause_session_pauseSession_triage_parameter_0_strict$schema$value;
+		const dsh_pause_session_pauseSession_triage_parameter_0_strict$schema = () => dsh_pause_session_pauseSession_triage_parameter_0_strict$schema$value ??= z.strictObject({ "caller": z.string().readonly() });
+		const TYPERT_REMOTE = createTypertRemoteInfo({
+			package: "dsh-pause-session",
+			methods: {
+				"pauseSession/act": {
+					service: "pauseSession",
+					description: "Pause, resume, press every tree, resume every clean park, or flip one Session's goal re-arm.",
+					invocation: { kind: "direct" },
+					parameters: [{
+						name: "request",
+						description: "the button action.",
+						source: "json",
+						codec: {
+							mode: "strict",
+							typeSymbol: "dsh-pause-session/types#PauseActionRequest",
+							create: dsh_pause_session_pauseSession_act_parameter_0$schema,
+							jsonSchema: {
+								"type": "object",
+								"properties": {
+									"action": {
+										"type": "string",
+										"enum": [
+											"pause",
+											"resume",
+											"pause-all",
+											"resume-all",
+											"cancel-all",
+											"goal"
+										]
+									},
+									"sessionId": {
+										"type": "string",
+										"description": "The Session the control is addressed through."
+									}
+								},
+								"required": ["action", "sessionId"],
+								"additionalProperties": true
+							}
+						},
+						strictCodec: {
+							mode: "strict",
+							typeSymbol: "dsh-pause-session/types#PauseActionRequest",
+							create: dsh_pause_session_pauseSession_act_parameter_0_strict$schema,
+							jsonSchema: {
+								"type": "object",
+								"properties": {
+									"action": {
+										"type": "string",
+										"enum": [
+											"pause",
+											"resume",
+											"pause-all",
+											"resume-all",
+											"cancel-all",
+											"goal"
+										]
+									},
+									"sessionId": {
+										"type": "string",
+										"description": "The Session the control is addressed through."
+									}
+								},
+								"required": ["action", "sessionId"],
+								"additionalProperties": false
+							}
+						}
+					}],
+					cancellation: { parameter: "signal" },
+					result: {
+						mode: "strict",
+						typeSymbol: "dsh-pause-session/types#PauseActionResultWire",
+						create: dsh_pause_session_pauseSession_act_result$schema,
+						description: "the user-facing outcome.",
+						jsonSchema: {
+							"type": "object",
+							"properties": {
+								"ok": { "type": "boolean" },
+								"message": { "type": "string" }
+							},
+							"required": ["ok", "message"],
+							"additionalProperties": true
+						}
+					},
+					sourceLocation: {
+						"file": "packages/dsh-pause-session/src/remote.ts",
+						"line": 239,
+						"column": 9
+					}
+				},
+				"pauseSession/decide": {
+					service: "pauseSession",
+					description: "Take one decision on one listed Session.",
+					invocation: { kind: "direct" },
+					parameters: [{
+						name: "request",
+						description: "the caller, target, and decision.",
+						source: "json",
+						codec: {
+							mode: "strict",
+							typeSymbol: "dsh-pause-session/types#PauseDecisionRequest",
+							create: dsh_pause_session_pauseSession_decide_parameter_0$schema,
+							jsonSchema: {
+								"type": "object",
+								"properties": {
+									"caller": { "type": "string" },
+									"target": { "type": "string" },
+									"decision": {
+										"type": "string",
+										"enum": [
+											"goal",
+											"continue",
+											"note",
+											"review",
+											"leave"
+										]
+									}
+								},
+								"required": [
+									"caller",
+									"target",
+									"decision"
+								],
+								"additionalProperties": true
+							}
+						},
+						strictCodec: {
+							mode: "strict",
+							typeSymbol: "dsh-pause-session/types#PauseDecisionRequest",
+							create: dsh_pause_session_pauseSession_decide_parameter_0_strict$schema,
+							jsonSchema: {
+								"type": "object",
+								"properties": {
+									"caller": { "type": "string" },
+									"target": { "type": "string" },
+									"decision": {
+										"type": "string",
+										"enum": [
+											"goal",
+											"continue",
+											"note",
+											"review",
+											"leave"
+										]
+									}
+								},
+								"required": [
+									"caller",
+									"target",
+									"decision"
+								],
+								"additionalProperties": false
+							}
+						}
+					}],
+					cancellation: { parameter: "signal" },
+					result: {
+						mode: "strict",
+						typeSymbol: "dsh-pause-session/types#PauseActionResultWire",
+						create: dsh_pause_session_pauseSession_decide_result$schema,
+						description: "the user-facing outcome.",
+						jsonSchema: {
+							"type": "object",
+							"properties": {
+								"ok": { "type": "boolean" },
+								"message": { "type": "string" }
+							},
+							"required": ["ok", "message"],
+							"additionalProperties": true
+						}
+					},
+					sourceLocation: {
+						"file": "packages/dsh-pause-session/src/remote.ts",
+						"line": 264,
+						"column": 9
+					}
+				},
+				"pauseSession/observe": {
+					service: "pauseSession",
+					description: "Live status: the opening snapshot, then one new snapshot whenever the host reports a change.",
+					mode: "stream",
+					invocation: { kind: "direct" },
+					parameters: [],
+					cancellation: { parameter: "signal" },
+					result: {
+						mode: "strict",
+						typeSymbol: "dsh-pause-session/types#PauseSnapshotWire",
+						create: dsh_pause_session_pauseSession_observe_result$schema,
+						description: "the snapshot stream.",
+						jsonSchemaError: "typert tool schema: selected dictionaries require string keys and unconstrained JSON values"
+					},
+					sourceLocation: {
+						"file": "packages/dsh-pause-session/src/remote.ts",
+						"line": 201,
+						"column": 10
+					}
+				},
+				"pauseSession/snapshot": {
+					service: "pauseSession",
+					description: "One exact snapshot, used by tests and by a reconnect that cannot wait for the first stream item.",
+					invocation: { kind: "direct" },
+					parameters: [],
+					cancellation: { parameter: "signal" },
+					result: {
+						mode: "strict",
+						typeSymbol: "dsh-pause-session/types#PauseSnapshotWire",
+						create: dsh_pause_session_pauseSession_snapshot_result$schema,
+						description: "the current aggregate and session states.",
+						jsonSchemaError: "typert tool schema: selected dictionaries require string keys and unconstrained JSON values"
+					},
+					sourceLocation: {
+						"file": "packages/dsh-pause-session/src/remote.ts",
+						"line": 175,
+						"column": 9
+					}
+				},
+				"pauseSession/triage": {
+					service: "pauseSession",
+					description: "Read the morning decision list.",
+					invocation: { kind: "direct" },
+					parameters: [{
+						name: "request",
+						description: "the calling Session whose list is read.",
+						source: "json",
+						codec: {
+							mode: "strict",
+							typeSymbol: "dsh-pause-session/types#PauseTriageRequest",
+							create: dsh_pause_session_pauseSession_triage_parameter_0$schema,
+							jsonSchema: {
+								"type": "object",
+								"properties": { "caller": { "type": "string" } },
+								"required": ["caller"],
+								"additionalProperties": true
+							}
+						},
+						strictCodec: {
+							mode: "strict",
+							typeSymbol: "dsh-pause-session/types#PauseTriageRequest",
+							create: dsh_pause_session_pauseSession_triage_parameter_0_strict$schema,
+							jsonSchema: {
+								"type": "object",
+								"properties": { "caller": { "type": "string" } },
+								"required": ["caller"],
+								"additionalProperties": false
+							}
+						}
+					}],
+					cancellation: { parameter: "signal" },
+					result: {
+						mode: "strict",
+						typeSymbol: "dsh-pause-session#pauseSession/triage:result",
+						create: dsh_pause_session_pauseSession_triage_result$schema,
+						description: "the listed rows.",
+						jsonSchema: {
+							"type": "array",
+							"items": {
+								"type": "object",
+								"properties": {
+									"sessionId": { "type": "string" },
+									"phase": {
+										"type": "string",
+										"enum": [
+											"draining",
+											"parking",
+											"flush-failed"
+										]
+									},
+									"updatedAt": { "type": "number" },
+									"reading": {
+										"type": "string",
+										"enum": ["read", "unreadable"]
+									},
+									"lastEvent": { "type": "string" },
+									"turn": { "type": "number" },
+									"step": { "type": "number" },
+									"traces": {
+										"type": "array",
+										"items": {
+											"type": "object",
+											"properties": {
+												"tool": { "type": "string" },
+												"callId": { "type": "string" }
+											},
+											"required": ["tool", "callId"],
+											"additionalProperties": true
+										}
+									},
+									"owed": { "type": "boolean" },
+									"wakeable": { "type": "boolean" },
+									"rearmGoal": { "type": "boolean" }
+								},
+								"required": [
+									"sessionId",
+									"phase",
+									"updatedAt",
+									"reading",
+									"traces",
+									"owed",
+									"wakeable",
+									"rearmGoal"
+								],
+								"additionalProperties": true
+							}
+						}
+					},
+					sourceLocation: {
+						"file": "packages/dsh-pause-session/src/remote.ts",
+						"line": 252,
+						"column": 9
+					}
+				}
+			}
+		}, z);
 		//#endregion
 		//#region lib/types/client/icons.js
 		/** 16px stroke icon (currentColor): the two bars of a pause. */
@@ -1784,7 +1525,7 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region \0dsh-css:src/client/button.module.css.mjs
-		const css = ".FCO1_q_dsp{align-items:center;display:inline-flex;position:relative}.FCO1_q_dspBtn{width:26px;height:26px;color:var(--dsw-alias-label-secondary);cursor:pointer;user-select:none;background:0 0;border:1px solid #0000;border-radius:6px;justify-content:center;align-items:center;padding:0;transition:color .12s,background .12s,border-color .12s;display:inline-flex}.FCO1_q_dspBtn:hover{color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-layer-2);border-color:var(--dsw-alias-border-l1)}.FCO1_q_dspBtn:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}.FCO1_q_dspBtn:disabled{cursor:default;opacity:.5}.FCO1_q_dspBtn:disabled:hover{color:var(--dsw-alias-label-secondary);background:0 0;border-color:#0000}.FCO1_q_dspGoal{width:22px;height:22px;color:var(--dsw-alias-label-tertiary);cursor:pointer;user-select:none;background:0 0;border:1px solid #0000;border-radius:6px;justify-content:center;align-items:center;margin-left:2px;padding:0;transition:color .12s,background .12s,border-color .12s;display:inline-flex}.FCO1_q_dspGoal[aria-pressed=true]{color:var(--dsw-alias-label-secondary)}.FCO1_q_dspGoal:hover{color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-layer-2);border-color:var(--dsw-alias-border-l1)}.FCO1_q_dspGoal:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}@media (prefers-reduced-motion:reduce){.FCO1_q_dspGoal{transition:none}}.FCO1_q_dspState{color:var(--dsw-alias-label-secondary);white-space:nowrap;user-select:none;padding-left:6px;font-size:12px;line-height:18px}.FCO1_q_dspTip{z-index:20;max-width:min(46ch,100vw - 48px);color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-layer-2);border:1px solid var(--dsw-alias-border-l2);white-space:nowrap;text-overflow:ellipsis;opacity:0;pointer-events:none;border-radius:6px;padding:4px 10px;font-size:12px;line-height:18px;transition:opacity .12s,transform .12s;position:absolute;top:calc(100% + 6px);left:0;overflow:hidden;transform:translateY(-2px);box-shadow:0 4px 12px #0000002e}.FCO1_q_dsp:hover .FCO1_q_dspTip,.FCO1_q_dspBtn:focus-visible+.FCO1_q_dspTip{opacity:1;transform:translateY(0)}@media (prefers-reduced-motion:reduce){.FCO1_q_dspBtn,.FCO1_q_dspTip{transition:none}}.FCO1_q_dspPill{align-items:center;display:inline-flex;position:relative}.FCO1_q_dspPillBtn{max-width:min(38ch,100vw - 48px);color:var(--dsw-alias-label-secondary);background:var(--dsw-alias-bg-layer-2);border:1px solid var(--dsw-alias-border-l1);cursor:pointer;user-select:none;border-radius:999px;align-items:center;gap:6px;padding:5px 10px;font-size:12px;line-height:18px;transition:color .12s,background .12s,border-color .12s;display:inline-flex;box-shadow:0 4px 12px #00000024}.FCO1_q_dspPillBtn:hover{color:var(--dsw-alias-label-primary);border-color:var(--dsw-alias-border-l2)}.FCO1_q_dspPillIcon{justify-content:center;width:28px;height:28px;padding:0}.FCO1_q_dspPillBtn:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}.FCO1_q_dspPillBtn:disabled{cursor:default;opacity:.5}.FCO1_q_dspPillText{white-space:nowrap;text-overflow:ellipsis;overflow:hidden}.FCO1_q_dspPillDetail{font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-tertiary)}.FCO1_q_dspPillWarn{color:var(--dsw-alias-state-warn-primary,var(--dsw-alias-label-primary));font-weight:600}@media (prefers-reduced-motion:reduce){.FCO1_q_dspPillBtn{transition:none}}.FCO1_q_dspPillTriage{color:var(--dsw-alias-state-warn-primary,var(--dsw-alias-label-primary));background:var(--dsw-alias-bg-layer-2);border:1px solid var(--dsw-alias-border-l1);cursor:pointer;user-select:none;border-radius:999px;align-items:center;gap:2px;margin-right:4px;padding:4px 8px;font-size:12px;line-height:18px;display:inline-flex;box-shadow:0 4px 12px #00000024}.FCO1_q_dspPillTriage:hover{color:var(--dsw-alias-label-primary);border-color:var(--dsw-alias-border-l2)}.FCO1_q_dspPillTriage:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}.FCO1_q_dspPillPanel{z-index:30;text-align:left;background:var(--dsw-alias-bg-layer-2);border:1px solid var(--dsw-alias-border-l2);border-radius:8px;flex-direction:column;gap:8px;width:min(52ch,100vw - 48px);max-height:min(60vh,420px);padding:10px 12px;display:flex;position:absolute;top:calc(100% + 6px);right:0;overflow-y:auto;box-shadow:0 8px 24px #00000038}.FCO1_q_dspPillPanelHead{justify-content:space-between;align-items:center;gap:8px;font-weight:600;display:flex}.FCO1_q_dspPillPanelNote{color:var(--dsw-alias-label-secondary);margin:0;font-size:12px;line-height:18px}.FCO1_q_dspPillRows{flex-direction:column;gap:8px;margin:0;padding:0;list-style:none;display:flex}.FCO1_q_dspPillRow{border:1px solid var(--dsw-alias-border-l1);border-radius:6px;flex-direction:column;gap:4px;padding:8px;display:flex}.FCO1_q_dspPillRowHead{justify-content:space-between;align-items:baseline;gap:8px;display:flex}.FCO1_q_dspPillRowId{word-break:break-all;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:12px}.FCO1_q_dspPillRowPhase{color:var(--dsw-alias-state-warn-primary,var(--dsw-alias-label-primary));flex:none;font-size:12px}.FCO1_q_dspPillRowFacts{color:var(--dsw-alias-label-secondary);flex-direction:column;gap:2px;font-size:12px;line-height:18px;display:flex}.FCO1_q_dspPillRowActions{flex-wrap:wrap;gap:6px;padding-top:2px;display:flex}.FCO1_q_dspPillAction{color:var(--dsw-alias-label-secondary);border:1px solid var(--dsw-alias-border-l1);cursor:pointer;user-select:none;background:0 0;border-radius:4px;padding:3px 8px;font-size:12px;line-height:16px}.FCO1_q_dspPillAction:hover{color:var(--dsw-alias-label-primary);border-color:var(--dsw-alias-border-l2)}.FCO1_q_dspPillAction:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}";
+		const css = ".FCO1_q_dsp{align-items:center;display:inline-flex;position:relative}.FCO1_q_dspBtn{width:26px;height:26px;color:var(--dsw-alias-label-secondary);cursor:pointer;user-select:none;background:0 0;border:1px solid #0000;border-radius:6px;justify-content:center;align-items:center;padding:0;transition:color .12s,background .12s,border-color .12s;display:inline-flex}.FCO1_q_dspBtn:hover{color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-layer-2);border-color:var(--dsw-alias-border-l1)}.FCO1_q_dspBtn:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}.FCO1_q_dspBtn:disabled{cursor:default;opacity:.5}.FCO1_q_dspBtn:disabled:hover{color:var(--dsw-alias-label-secondary);background:0 0;border-color:#0000}.FCO1_q_dspGoal{width:22px;height:22px;color:var(--dsw-alias-label-tertiary);cursor:pointer;user-select:none;background:0 0;border:1px solid #0000;border-radius:6px;justify-content:center;align-items:center;margin-left:2px;padding:0;transition:color .12s,background .12s,border-color .12s;display:inline-flex}.FCO1_q_dspGoal[aria-pressed=true]{color:var(--dsw-alias-label-secondary)}.FCO1_q_dspGoal:hover{color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-layer-2);border-color:var(--dsw-alias-border-l1)}.FCO1_q_dspGoal:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}@media (prefers-reduced-motion:reduce){.FCO1_q_dspGoal{transition:none}}.FCO1_q_dspState{color:var(--dsw-alias-label-secondary);white-space:nowrap;user-select:none;padding-left:6px;font-size:12px;line-height:18px}@media (prefers-reduced-motion:reduce){.FCO1_q_dspBtn{transition:none}}.FCO1_q_dspPill{align-items:center;display:inline-flex;position:relative}.FCO1_q_dspPillBtn{max-width:min(38ch,100vw - 48px);color:var(--dsw-alias-label-secondary);background:var(--dsw-alias-bg-layer-2);border:1px solid var(--dsw-alias-border-l1);cursor:pointer;user-select:none;border-radius:999px;align-items:center;gap:6px;padding:5px 10px;font-size:12px;line-height:18px;transition:color .12s,background .12s,border-color .12s;display:inline-flex;box-shadow:0 4px 12px #00000024}.FCO1_q_dspPillBtn:hover{color:var(--dsw-alias-label-primary);border-color:var(--dsw-alias-border-l2)}.FCO1_q_dspPillIcon{justify-content:center;width:28px;height:28px;padding:0}.FCO1_q_dspPillBtn:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}.FCO1_q_dspPillBtn:disabled{cursor:default;opacity:.5}.FCO1_q_dspPillText{white-space:nowrap;text-overflow:ellipsis;overflow:hidden}.FCO1_q_dspPillDetail{font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-tertiary)}.FCO1_q_dspPillWarn{color:var(--dsw-alias-state-warn-primary,var(--dsw-alias-label-primary));font-weight:600}@media (prefers-reduced-motion:reduce){.FCO1_q_dspPillBtn{transition:none}}.FCO1_q_dspPillTriage{color:var(--dsw-alias-state-warn-primary,var(--dsw-alias-label-primary));background:var(--dsw-alias-bg-layer-2);border:1px solid var(--dsw-alias-border-l1);cursor:pointer;user-select:none;border-radius:999px;align-items:center;gap:2px;margin-right:4px;padding:4px 8px;font-size:12px;line-height:18px;display:inline-flex;box-shadow:0 4px 12px #00000024}.FCO1_q_dspPillTriage:hover{color:var(--dsw-alias-label-primary);border-color:var(--dsw-alias-border-l2)}.FCO1_q_dspPillTriage:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}.FCO1_q_dspPillPanel{z-index:30;text-align:left;background:var(--dsw-alias-bg-layer-2);border:1px solid var(--dsw-alias-border-l2);border-radius:8px;flex-direction:column;gap:8px;width:min(52ch,100vw - 48px);max-height:min(60vh,420px);padding:10px 12px;display:flex;position:absolute;top:calc(100% + 6px);right:0;overflow-y:auto;box-shadow:0 8px 24px #00000038}.FCO1_q_dspPillPanelHead{justify-content:space-between;align-items:center;gap:8px;font-weight:600;display:flex}.FCO1_q_dspPillError{color:var(--dsw-alias-state-error-primary);margin:0 0 8px;font-size:12px;line-height:18px}.FCO1_q_dspPillPanelNote{color:var(--dsw-alias-label-secondary);margin:0;font-size:12px;line-height:18px}.FCO1_q_dspPillRows{flex-direction:column;gap:8px;margin:0;padding:0;list-style:none;display:flex}.FCO1_q_dspPillRow{border:1px solid var(--dsw-alias-border-l1);border-radius:6px;flex-direction:column;gap:4px;padding:8px;display:flex}.FCO1_q_dspPillRowHead{justify-content:space-between;align-items:baseline;gap:8px;display:flex}.FCO1_q_dspPillRowId{word-break:break-all;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:12px}.FCO1_q_dspPillRowPhase{color:var(--dsw-alias-state-warn-primary,var(--dsw-alias-label-primary));flex:none;font-size:12px}.FCO1_q_dspPillRowFacts{color:var(--dsw-alias-label-secondary);flex-direction:column;gap:2px;font-size:12px;line-height:18px;display:flex}.FCO1_q_dspPillRowActions{flex-wrap:wrap;gap:6px;padding-top:2px;display:flex}.FCO1_q_dspPillAction{color:var(--dsw-alias-label-secondary);border:1px solid var(--dsw-alias-border-l1);cursor:pointer;user-select:none;background:0 0;border-radius:4px;padding:3px 8px;font-size:12px;line-height:16px}.FCO1_q_dspPillAction:hover{color:var(--dsw-alias-label-primary);border-color:var(--dsw-alias-border-l2)}.FCO1_q_dspPillAction:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}";
 		const tagId = "dsh-pause-session/button.module.css";
 		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId) + "]") === null) {
 			const tag = document.createElement("style");
@@ -1801,6 +1542,7 @@ window.__ModuleLoader__.load({
 			"dspPillAction": "FCO1_q_dspPillAction",
 			"dspPillBtn": "FCO1_q_dspPillBtn",
 			"dspPillDetail": "FCO1_q_dspPillDetail",
+			"dspPillError": "FCO1_q_dspPillError",
 			"dspPillIcon": "FCO1_q_dspPillIcon",
 			"dspPillPanel": "FCO1_q_dspPillPanel",
 			"dspPillPanelHead": "FCO1_q_dspPillPanelHead",
@@ -1815,8 +1557,7 @@ window.__ModuleLoader__.load({
 			"dspPillText": "FCO1_q_dspPillText",
 			"dspPillTriage": "FCO1_q_dspPillTriage",
 			"dspPillWarn": "FCO1_q_dspPillWarn",
-			"dspState": "FCO1_q_dspState",
-			"dspTip": "FCO1_q_dspTip"
+			"dspState": "FCO1_q_dspState"
 		};
 		//#endregion
 		//#region lib/types/client/pill.js
@@ -1832,11 +1573,11 @@ window.__ModuleLoader__.load({
 		* above the whole frame. The decision list hangs from the control into the
 		* conversation area below.
 		*
-		* The pill reads the host through the command channel only (`./global.ts`):
-		* with no answer, or with no session to ask through, it renders nothing rather
-		* than a state it would have to invent. The decision list is deliberately NOT
-		* part of that first read — it costs two more command calls, and a user who
-		* never opens it pays nothing; the panel asks for its own rows when it opens.
+		* The pill reads the native status stream through `./global.ts`. With no
+		* answer, or with no session to address an action through, it renders nothing
+		* rather than a state it would have to invent. The decision list is
+		* deliberately NOT part of that first read; the panel asks for its own rows
+		* when it opens.
 		* @module dsh-pause-session/client/pill
 		*/
 		/** One listed session's row, with the four decisions. */
@@ -1865,7 +1606,7 @@ window.__ModuleLoader__.load({
 					}),
 					(0, react_jsx_runtime.jsxs)("div", {
 						className: button_module_css_default.dspPillRowActions,
-						children: [TRIAGE_ACTION_VIEWS.map((action) => (0, react_jsx_runtime.jsx)("button", {
+						children: [triageActionsFor(row).map((action) => (0, react_jsx_runtime.jsx)("button", {
 							type: "button",
 							className: button_module_css_default.dspPillAction,
 							"aria-label": t(action.ariaKey),
@@ -1899,8 +1640,10 @@ window.__ModuleLoader__.load({
 			const reading = props.usePauseGlobal((state) => state.global);
 			const triage = props.usePauseGlobal((state) => state.triage);
 			const open = props.usePauseGlobal((state) => state.panelOpen);
+			const error = props.usePauseGlobal((state) => state.error);
+			const sessions = props.usePauseGlobal((state) => state.sessions);
 			const address = useSessions(addressingSession);
-			const view = globalPauseView(reading);
+			const view = globalPauseView(reading, sessions);
 			const list = triageView(triage);
 			const visible = showsPauseControl(useSession((snapshot) => snapshot.subagent));
 			(0, react.useEffect)(() => {
@@ -1910,7 +1653,8 @@ window.__ModuleLoader__.load({
 				address,
 				visible
 			]);
-			if (!visible || !view.visible || address === void 0) return null;
+			if (!visible || !view.visible) return null;
+			const actionable = view.enabled && address !== void 0;
 			const tip = view.caveats.map((caveat) => caveat.names.length === 0 ? t(caveat.key) : `${t(caveat.key)} (${caveat.names.join(", ")})`).join("\n");
 			return (0, react_jsx_runtime.jsxs)("span", {
 				className: button_module_css_default.dspPill,
@@ -1919,34 +1663,49 @@ window.__ModuleLoader__.load({
 						className: button_module_css_default.dspPillPanel,
 						role: "dialog",
 						"aria-label": t("triage.title"),
-						children: [(0, react_jsx_runtime.jsxs)("div", {
-							className: button_module_css_default.dspPillPanelHead,
-							children: [(0, react_jsx_runtime.jsx)("span", {
-								className: button_module_css_default.dspPillText,
-								children: t("triage.title")
-							}), (0, react_jsx_runtime.jsx)("button", {
-								type: "button",
-								className: button_module_css_default.dspPillAction,
-								"aria-label": t("triage.refresh.aria"),
-								onClick: () => {
-									setPanel(true);
-								},
-								children: t("triage.refresh.aria")
-							})]
-						}), !list.visible ? (0, react_jsx_runtime.jsx)("p", {
-							className: button_module_css_default.dspPillPanelNote,
-							children: t("triage.reading")
-						}) : list.rows.length === 0 ? (0, react_jsx_runtime.jsx)("p", {
-							className: button_module_css_default.dspPillPanelNote,
-							children: t("triage.empty")
-						}) : (0, react_jsx_runtime.jsx)("ul", {
-							className: button_module_css_default.dspPillRows,
-							children: list.rows.map((row) => (0, react_jsx_runtime.jsx)(TriageSessionRow, {
-								row,
-								decide,
-								t
-							}, row.sessionId))
-						})]
+						children: [
+							(0, react_jsx_runtime.jsxs)("div", {
+								className: button_module_css_default.dspPillPanelHead,
+								children: [(0, react_jsx_runtime.jsx)("span", {
+									className: button_module_css_default.dspPillText,
+									children: t("triage.title")
+								}), (0, react_jsx_runtime.jsx)("button", {
+									type: "button",
+									className: button_module_css_default.dspPillAction,
+									"aria-label": t("triage.refresh.aria"),
+									onClick: () => {
+										setPanel(true);
+									},
+									children: t("triage.refresh.aria")
+								})]
+							}),
+							error === void 0 ? null : (0, react_jsx_runtime.jsx)("p", {
+								className: button_module_css_default.dspPillError,
+								role: "status",
+								children: error
+							}),
+							view.running === void 0 ? null : (0, react_jsx_runtime.jsx)("p", {
+								className: button_module_css_default.dspPillPanelNote,
+								children: view.running
+							}),
+							!list.visible ? (0, react_jsx_runtime.jsx)("p", {
+								className: button_module_css_default.dspPillPanelNote,
+								children: t("triage.reading")
+							}) : list.unavailable ? (0, react_jsx_runtime.jsx)("p", {
+								className: button_module_css_default.dspPillPanelNote,
+								children: t("triage.unavailable")
+							}) : list.rows.length === 0 ? (0, react_jsx_runtime.jsx)("p", {
+								className: button_module_css_default.dspPillPanelNote,
+								children: t("triage.empty")
+							}) : (0, react_jsx_runtime.jsx)("ul", {
+								className: button_module_css_default.dspPillRows,
+								children: list.rows.map((row) => (0, react_jsx_runtime.jsx)(TriageSessionRow, {
+									row,
+									decide,
+									t
+								}, row.sessionId))
+							})
+						]
 					}),
 					view.unclean === 0 ? null : (0, react_jsx_runtime.jsxs)("button", {
 						type: "button",
@@ -1966,14 +1725,14 @@ window.__ModuleLoader__.load({
 						type: "button",
 						className: view.labelKey === void 0 && view.detail.length === 0 ? `${button_module_css_default.dspPillBtn} ${button_module_css_default.dspPillIcon}` : button_module_css_default.dspPillBtn,
 						"aria-label": t(view.ariaKey),
-						"aria-pressed": view.action === "resume-all",
-						disabled: !view.enabled,
+						"aria-pressed": view.action === "resume-all" || view.action === "cancel-all",
+						disabled: !actionable,
 						...tip.length === 0 ? {} : { title: tip },
 						onClick: () => {
-							toggle(address);
+							if (address !== void 0) toggle(address);
 						},
 						children: [
-							view.action === "resume-all" ? (0, react_jsx_runtime.jsx)(ResumeIcon, {}) : (0, react_jsx_runtime.jsx)(PauseIcon, {}),
+							view.action === "resume-all" || view.action === "cancel-all" ? (0, react_jsx_runtime.jsx)(ResumeIcon, {}) : (0, react_jsx_runtime.jsx)(PauseIcon, {}),
 							view.labelKey === void 0 ? null : (0, react_jsx_runtime.jsx)("span", {
 								className: button_module_css_default.dspPillText,
 								children: t(view.labelKey)
@@ -1997,14 +1756,11 @@ window.__ModuleLoader__.load({
 		/** Simplified Chinese dictionary (the key-set source of truth). */
 		const zh = {
 			"pause.aria": "暂停这个会话及其子代理：下一条模型请求不会发出",
-			"pause.tip": "暂停这个会话及其子代理",
-			"resume.aria": "恢复这个会话及其子代理",
 			"resume.tip": "恢复这个会话及其子代理",
 			"draining.aria": "正在暂停：还有工具在运行，工具运行完之后、下一条模型请求发出之前，会话会停住；按下可取消这次暂停",
 			"parking.aria": "正在暂停：正在保存待发输入；按下可取消这次暂停",
 			"safe.aria": "已暂停：待发输入已保存；按下可恢复",
 			"flushFailed.aria": "已暂停，但保存待发输入失败；按下可恢复",
-			"state.paused": "已暂停",
 			"state.draining": "正在暂停",
 			"state.parking": "正在保存",
 			"state.safe": "已暂停",
@@ -2020,10 +1776,13 @@ window.__ModuleLoader__.load({
 			"all.resume.aria": "恢复所有已暂停的会话",
 			"all.idle": "暂停所有会话",
 			"all.finishing": "正在暂停",
+			"all.cancel": "取消这次暂停",
+			"all.cancel.aria": "取消这次暂停并恢复会话",
 			"all.unclean": "有会话未暂停",
 			"all.unclean.aria": "有会话未暂停，不能在这里恢复；打开清单逐行处理",
-			"all.safe": "全部已暂停",
+			"all.safe": "已暂停",
 			"all.checking.aria": "正在读取暂停状态",
+			"all.unavailable.aria": "暂停状态暂不可用，正在重新连接",
 			"all.caveat.jobs": "后台任务仍在运行",
 			"all.caveat.unresumable": "含无法恢复的子代理",
 			"all.caveat.stalled": "未暂停，需要你决定",
@@ -2049,7 +1808,6 @@ window.__ModuleLoader__.load({
 			"triage.continue.aria": "继续：不添加消息，直接恢复",
 			"triage.note": "继续并附说明",
 			"triage.note.aria": "继续并附说明：告诉模型工具结果未知，不要盲目重试",
-			"triage.note.hint": "会加入这句话：",
 			"triage.review": "只看不运行",
 			"triage.review.aria": "只看不运行：不启动会话、不发请求；需要查看时在会话历史里打开",
 			"triage.leave": "保持暂停",
@@ -2061,14 +1819,11 @@ window.__ModuleLoader__.load({
 		/** English dictionary, checked complete against the zh key set. */
 		const en = {
 			"pause.aria": "Pause this session and its subagents: their next model request will not be sent",
-			"pause.tip": "Pause this session and its subagents",
-			"resume.aria": "Resume this session and its subagents",
 			"resume.tip": "Resume this session and its subagents",
 			"draining.aria": "Pausing: a tool is still running. The session pauses after the tool finishes and before its next model request; press to cancel the pause",
 			"parking.aria": "Pausing: saving pending input; press to cancel the pause",
 			"safe.aria": "Paused: pending input is saved; press to resume",
 			"flushFailed.aria": "Paused, but saving pending input failed; press to resume",
-			"state.paused": "Paused",
 			"state.draining": "Pausing",
 			"state.parking": "Saving",
 			"state.safe": "Paused",
@@ -2084,10 +1839,13 @@ window.__ModuleLoader__.load({
 			"all.resume.aria": "Resume all paused sessions",
 			"all.idle": "Pause all sessions",
 			"all.finishing": "Pausing",
+			"all.cancel": "Cancel this pause",
+			"all.cancel.aria": "Cancel this pause and resume the sessions",
 			"all.unclean": "Some sessions are not paused",
 			"all.unclean.aria": "Some sessions are not paused and cannot be resumed here; open the list to decide",
-			"all.safe": "All Paused",
+			"all.safe": "Paused",
 			"all.checking.aria": "Reading pause state",
+			"all.unavailable.aria": "Pause state unavailable; reconnecting",
 			"all.caveat.jobs": "background jobs are still running",
 			"all.caveat.unresumable": "contains a subagent that cannot be resumed",
 			"all.caveat.stalled": "did not pause; needs your decision",
@@ -2113,7 +1871,6 @@ window.__ModuleLoader__.load({
 			"triage.continue.aria": "Continue: resume without adding a message",
 			"triage.note": "Continue with a note",
 			"triage.note.aria": "Continue with a note: tell the model the tool result is unknown and not to retry blindly",
-			"triage.note.hint": "This text is added:",
 			"triage.review": "View only",
 			"triage.review.aria": "View only: do not start the session or send a request; open it from your session history to read it",
 			"triage.leave": "Leave it paused",
@@ -2140,11 +1897,12 @@ window.__ModuleLoader__.load({
 		* frame-wide overlay layer: it is read while looking at one conversation, and
 		* a sidebar or drawer that covers that area covers the control with it.
 		*
-		* Both controls are host-authoritative: they read state from the host's command
-		* registry and drive it through the host's session commands (`./control.ts` and
-		* `./global.ts` document why the command registry is the only live channel a
-		* third-party plugin can use). Each stays inert wherever that round-trip is
-		* unavailable rather than rendering a control that cannot tell the truth. The
+		* Both controls are host-authoritative. On a browser Host they read the
+		* native `pauseSession` stream, which keeps status reads out of the Session
+		* log. The same path serves Web and Desktop.
+		* User actions and status both use the generated native Remote namespace;
+		* no slash command is involved. Each control stays inert wherever no
+		* round-trip is available rather than rendering a state it cannot support. The
 		* header control also reads the whole-app answer the whole-app control
 		* publishes, so a park that holds nothing does not cost a host round-trip per
 		* header.
@@ -2156,8 +1914,7 @@ window.__ModuleLoader__.load({
 		const inject = [
 			"slots",
 			"locale",
-			"remote",
-			"remote.commands"
+			"remote"
 		];
 		/**
 		* The session's pause control: pause the session and its subagents before
@@ -2175,7 +1932,7 @@ window.__ModuleLoader__.load({
 		*/
 		function PauseButton(props) {
 			const { sessionId, refresh, toggle, toggleGoal, t, useSession } = props;
-			const view = pauseView(props.usePause((state) => state.bySession[String(sessionId)]));
+			const view = pauseView(props.usePause((state) => state.bySession[String(sessionId)]), useSession((snapshot) => snapshot.running) ?? false);
 			const visible = showsPauseControl(useSession((snapshot) => snapshot.subagent));
 			(0, react.useEffect)(() => {
 				refresh(sessionId);
@@ -2228,65 +1985,58 @@ window.__ModuleLoader__.load({
 			ctx.effect(() => () => {
 				lifetime.abort(/* @__PURE__ */ new Error("pause: client unloaded"));
 			}, "pause: lifetime");
-			const globalControl = new PauseGlobalControl(ctx.remote.commands, lifetime.signal);
-			const control = new PauseControl(ctx.remote.commands, lifetime.signal, void 0, void 0, () => globalControl.store.getSnapshot().global);
-			ctx.effect(() => globalControl.store.subscribe(() => {
-				control.reconsider();
-			}), "pause: the whole-app answer serves the session headers");
-			ctx.effect(() => ctx.remote.$on("commands/change", () => {
-				control.refreshAll();
-				globalControl.refreshAll();
-			}), "pause: host command registry changes");
-			ctx.effect(() => {
-				if (typeof document === "undefined") return () => {};
-				const onVisibility = () => {
-					control.watchVisibility();
-					globalControl.watchVisibility();
-				};
-				document.addEventListener("visibilitychange", onVisibility);
-				return () => {
-					document.removeEventListener("visibilitychange", onVisibility);
-				};
-			}, "pause: page visibility");
-			ctx.slots.inject("conversation.session.header.actions", () => ctx.slots.register({
-				name: "conversation.session.header.actions",
-				id: NS,
-				order: 40,
-				locale: NS,
-				inject: () => ({
-					hooks: { pause: control.store },
-					refresh: (sessionId) => {
-						control.refresh(sessionId);
-					},
-					toggle: (sessionId) => {
-						control.toggle(sessionId);
-					},
-					toggleGoal: (sessionId) => {
-						control.toggleGoal(sessionId);
-					}
-				})
-			}, PauseButton));
-			ctx.slots.inject("conversation.session.header.utilities", () => ctx.slots.register({
-				name: "conversation.session.header.utilities",
-				id: "pause-all",
-				order: 60,
-				locale: NS,
-				inject: () => ({
-					hooks: { pauseGlobal: globalControl.store },
-					refresh: (sessionId) => {
-						globalControl.refresh(sessionId);
-					},
-					toggle: (sessionId) => {
-						globalControl.toggle(sessionId);
-					},
-					setPanel: (open) => {
-						globalControl.setPanel(open);
-					},
-					decide: (sessionId, action) => {
-						globalControl.decide(sessionId, action);
-					}
-				})
-			}, PausePill));
+			if (typeof ctx.remote.$mount === "function") ctx.effect(async () => {
+				return await ctx.remote.$mount(TYPERT_REMOTE);
+			}, "pause: remote transport");
+			ctx.inject(["remote.pauseSession"], (remoteCtx) => {
+				const remote = remoteCtx.remote.pauseSession;
+				const transport = remoteTransport(remote, lifetime.signal);
+				const globalControl = new PauseGlobalControl(transport, lifetime.signal);
+				const control = new PauseControl(transport, lifetime.signal);
+				remoteCtx.effect(() => transport.source.onSnapshot((snapshot) => {
+					control.apply(snapshot);
+					globalControl.apply(snapshot);
+				}), "pause: native status stream");
+				remoteCtx.slots.inject("conversation.session.header.actions", () => remoteCtx.slots.register({
+					name: "conversation.session.header.actions",
+					id: NS,
+					order: 40,
+					locale: NS,
+					inject: () => ({
+						hooks: { pause: control.store },
+						refresh: (sessionId) => {
+							control.refresh(sessionId);
+						},
+						toggle: (sessionId) => {
+							control.toggle(sessionId);
+						},
+						toggleGoal: (sessionId) => {
+							control.toggleGoal(sessionId);
+						}
+					})
+				}, PauseButton));
+				remoteCtx.slots.inject("conversation.session.header.utilities", () => remoteCtx.slots.register({
+					name: "conversation.session.header.utilities",
+					id: "pause-all",
+					order: -11,
+					locale: NS,
+					inject: () => ({
+						hooks: { pauseGlobal: globalControl.store },
+						refresh: (sessionId) => {
+							globalControl.refresh(sessionId);
+						},
+						toggle: (sessionId) => {
+							globalControl.toggle(sessionId);
+						},
+						setPanel: (open) => {
+							globalControl.setPanel(open);
+						},
+						decide: (sessionId, action) => {
+							globalControl.decide(sessionId, action);
+						}
+					})
+				}, PausePill));
+			});
 		}
 		//#endregion
 		exports.PauseButton = PauseButton;