dsh-pause-session 0.1.0 → 0.2.0

package/lib/types/client/control.d.ts

@@ -1,52 +1,20 @@
 /**
  * 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
  */
-import type { ClientRemote } from '@deepseek-ai/dsh-api-remotes/client';
 import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
-import type { BurstPolicy } from './burst.js';
-import type { GlobalReading } from './global.js';
-/**
- * The whole-app answer as the session headers read it, or `undefined` before
- * that control has heard from the host. Reading it costs nothing: it is the
- * published snapshot, not a host round-trip.
- */
-export type AggregateSource = () => GlobalReading | undefined;
+import type { PauseTransport } from './remote.js';
 /**
  * What the Session-header control knows about one session: what the host
  * reported, or that no answer has arrived (`undefined`) or the last read
@@ -77,68 +45,36 @@ export interface PauseState {
 }
 /** Owns the published reading per session; nothing else writes that state. */
 export declare class PauseControl {
-    private readonly commands;
+    private readonly transport;
     private readonly lifetime;
-    private readonly aggregate;
     /** State source the Session-header contribution binds its selector hook to. */
     readonly store: SnapshotStore<PauseState>;
-    /** 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. */
     private readonly shown;
     /** Highest read sequence requested per session: an answer older than it is dropped. */
     private readonly latest;
-    /**
-     * 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.
-     */
-    private readonly owed;
-    /**
-     * 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.
-     */
-    private trailing;
-    /**
-     * 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.
-     */
-    private readonly derived;
-    /** The bounded burst of reads one transition buys; see `./burst.ts`. */
-    private readonly burst;
     private reads;
     /**
-     * @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: ClientRemote['commands'], lifetime: AbortSignal, windowMs?: number, policy?: Omit<BurstPolicy, 'windowMs' | 'waitsMs'>, aggregate?: AggregateSource);
+    constructor(transport: PauseTransport, lifetime: AbortSignal);
     /**
      * Read the host's state for one session.
      * @param sessionId - session whose control was rendered.
      * @returns after this read's answer is published or superseded by a newer one.
      */
     refresh(sessionId: SessionId): Promise<void>;
-    /**
-     * 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: {
+        readonly sessions: Readonly<Record<string, {
+            readonly phase: PausePhase;
+            readonly runningTools: readonly string[];
+            readonly rearmGoal?: boolean;
+        }>>;
+    } | undefined): void;
+    /** A new pushed snapshot may have moved every header; read them once. */
     refreshAll(): void;
-    /**
-     * 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}.
-     */
     private readAll;
     /** One session's read, published unless a newer read of that session supersedes it. */
     private readOne;
@@ -152,81 +88,12 @@ export declare class PauseControl {
     toggle(sessionId: SessionId): Promise<void>;
     /**
      * 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.
      */
     toggleGoal(sessionId: SessionId): Promise<void>;
-    /** 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. */
     private read;
     private publish;
-    /**
-     * 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.
-     */
-    private answerIsKnown;
-    /**
-     * Whether the whole-app answer says the park holds nothing at all: the one
-     * predicate the derivation below and its revocation share.
-     */
-    private nothingParked;
-    /**
-     * 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.
-     */
-    private deriveActive;
-    /**
-     * 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(): void;
-    /**
-     * 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.
-     */
-    private follow;
-    /**
-     * 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.
-     */
-    private moving;
-    /**
-     * 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(): void;
 }

package/lib/types/client/global.d.ts

@@ -1,57 +1,16 @@
 /**
  * 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
  */
-import type { ClientRemote } from '@deepseek-ai/dsh-api-remotes/client';
 import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { GlobalStatus, TriageAction, TriageRow } from '../shared.js';
-import type { BurstPolicy } from './burst.js';
+import type { PauseTransport } from './remote.js';
 /** What the whole-app control knows: the host's answer, or that it could not ask. */
 export type GlobalReading = {
     readonly kind: 'reported';
@@ -74,11 +33,15 @@ export interface GlobalPauseState {
     panelOpen: boolean;
     /** The host's decision list; absent until the panel asks for it. */
     triage: TriageReading | undefined;
+    /** The last action or read refusal, shown verbatim in the panel. */
+    error?: string;
+    /** The last snapshot's per-session details, for the draining progress copy. */
+    sessions?: Readonly<Record<string, {
+        readonly runningTools: readonly string[];
+    }>>;
 }
-/** The command one listed verb runs, named from the one vocabulary the host registers. */
-export declare const TRIAGE_DECISION_COMMAND: Readonly<Record<TriageAction, string>>;
 /**
- * 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
@@ -98,169 +61,48 @@ export declare function addressingSession(state: {
         };
     } | undefined>>;
 }): SessionId | undefined;
-/**
- * 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.
- */
-export declare function registeredAddress(status: GlobalStatus): SessionId | undefined;
-/**
- * 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.
- */
-export declare function parkedAddress(status: GlobalStatus): SessionId | undefined;
 /** Owns the published whole-app reading; nothing else writes that state. */
 export declare class PauseGlobalControl {
-    private readonly commands;
+    private readonly transport;
     private readonly lifetime;
     /** State source the whole-app contribution binds its selector hook to. */
     readonly store: SnapshotStore<GlobalPauseState>;
-    /** The session the shell asked this control through; reads start here. */
+    /** The session the shell asked this control through; list reads use it. */
     private 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.
-     */
-    private 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.
-     */
-    private served;
     /** Highest decision-list read requested: an answer older than it is dropped. */
     private latestTriage;
-    /** Highest read sequence requested: an answer older than it is dropped. */
-    private latest;
     /**
-     * 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.
+     * @param transport - the native namespace source and actions.
+     * @param lifetime - aborts in-flight reads when the plugin unloads.
      */
-    private owed;
-    /** The bounded burst of reads one transition buys; see `./burst.ts`. */
-    private readonly burst;
+    constructor(transport: PauseTransport, lifetime: AbortSignal);
     /**
-     * @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.
-     */
-    constructor(commands: ClientRemote['commands'], lifetime: AbortSignal, windowMs?: number, policy?: Omit<BurstPolicy, 'windowMs' | 'waitsMs'>);
-    /**
-     * 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.
      */
     refresh(sessionId: SessionId): Promise<void>;
-    /** Whether the host has answered: a state, not the absence of one it never sent. */
-    private answered;
-    /**
-     * 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.
-     */
+    /** Apply one pushed snapshot directly. */
+    apply(snapshot: {
+        readonly global: GlobalStatus;
+        readonly sessions: Readonly<Record<string, {
+            readonly runningTools: readonly string[];
+        }>>;
+    } | undefined): void;
+    /** A pushed snapshot may have moved the aggregate and the open list. */
     refreshAll(): void;
     /**
-     * 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.
-     */
-    private readAll;
-    /**
-     * 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.
-     */
-    private target;
-    /**
-     * 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.
-     */
-    private readAggregate;
-    /**
-     * 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.
-     */
-    private readAt;
-    /**
-     * 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: boolean): void;
-    /**
-     * 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. */
     refreshTriage(): Promise<void>;
-    /**
-     * 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.
-     */
-    private reread;
-    /** One decision-list read, addressed at the session the user is on. */
-    private readTriage;
     /**
      * 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.
      */
@@ -268,58 +110,16 @@ export declare class PauseGlobalControl {
     /**
      * 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.
      */
     toggle(sessionId: SessionId): Promise<void>;
-    /** Ask the host for the decision list, in the browser's vocabulary. */
+    /** Read the aggregate once and publish it. */
+    private readAggregate;
+    private reread;
+    /** One decision-list read, addressed at the session the user is on. */
+    private readTriage;
+    /** Ask the native namespace for the decision list. */
     private readTriageRows;
-    /** Ask the host what the whole-app park state is, in the browser's vocabulary. */
-    private read;
     private publish;
-    /**
-     * 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.
-     */
-    private follow;
-    /**
-     * 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.
-     */
-    private moving;
-    /**
-     * 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.
-     */
-    private unansweredPanel;
-    /**
-     * 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(): void;
 }

package/lib/types/client/index.d.ts

@@ -14,11 +14,12 @@
  * 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.

package/lib/types/client/locales.d.ts

@@ -2,14 +2,11 @@
 /** Simplified Chinese dictionary (the key-set source of truth). */
 export declare const zh: {
     'pause.aria': string;
-    'pause.tip': string;
-    'resume.aria': string;
     'resume.tip': string;
     'draining.aria': string;
     'parking.aria': string;
     'safe.aria': string;
     'flushFailed.aria': string;
-    'state.paused': string;
     'state.draining': string;
     'state.parking': string;
     'state.safe': string;
@@ -25,6 +22,8 @@ export declare const zh: {
     'all.resume.aria': string;
     'all.idle': string;
     'all.finishing': string;
+    'all.cancel': string;
+    'all.cancel.aria': string;
     'all.unclean': string;
     'all.unclean.aria': string;
     'all.safe': string;
@@ -54,7 +53,6 @@ export declare const zh: {
     'triage.continue.aria': string;
     'triage.note': string;
     'triage.note.aria': string;
-    'triage.note.hint': string;
     'triage.review': string;
     'triage.review.aria': string;
     'triage.leave': string;

package/lib/types/client/pill.d.ts

@@ -10,11 +10,11 @@
  * 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
  */
 import type { ReactNode } from 'react';