dsh-pause-session 0.1.0 → 0.2.0

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

@@ -0,0 +1,71 @@
+/**
+ * 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
+ */
+import type { PauseActionResultWire, PauseDecisionRequest, PauseSnapshotWire, TriageRowWire } from '../remote.js';
+import type { GlobalStatus, ParkStatus } from '../shared.js';
+/** The generated namespace shape this bridge needs. */
+export interface RemotePauseNamespace {
+    observe(signal?: AbortSignal): AsyncIterable<PauseSnapshotWire>;
+    act(request: {
+        readonly action: 'pause' | 'resume' | 'pause-all' | 'resume-all' | 'cancel-all' | 'goal';
+        readonly sessionId: string;
+    }, signal?: AbortSignal): Promise<{
+        readonly ok: boolean;
+        readonly value?: PauseActionResultWire;
+        readonly error?: {
+            readonly code: string;
+        };
+    }>;
+    triage(request: {
+        readonly caller: string;
+    }, signal?: AbortSignal): Promise<{
+        readonly ok: boolean;
+        readonly value?: readonly TriageRowWire[];
+    }>;
+    decide(request: PauseDecisionRequest, signal?: AbortSignal): Promise<{
+        readonly ok: boolean;
+        readonly value?: PauseActionResultWire;
+    }>;
+}
+/** The status shape shared by the controls, with branded ids erased at this boundary. */
+export interface PauseSnapshotLike {
+    readonly global: GlobalStatus;
+    readonly sessions: Readonly<Record<string, ParkStatus>>;
+}
+/** A remote-backed status source with a change subscription. */
+export interface RemoteStatusSource {
+    /** Read the latest host snapshot; undefined before the first answer or after failure. */
+    read(signal?: AbortSignal): Promise<PauseSnapshotLike | undefined>;
+    onChange(listener: () => void): () => void;
+    /** Receive each pushed snapshot directly; `undefined` means the stream failed. */
+    onSnapshot(listener: (snapshot: PauseSnapshotLike | undefined) => void): () => void;
+}
+/**
+ * Open the native status stream and expose its latest snapshot to both controls.
+ * @param remote - the generated Remote namespace.
+ * @param lifetime - client lifetime; aborting it releases the stream.
+ * @returns the cached source and its change subscription.
+ */
+export declare function openRemoteSource(remote: RemotePauseNamespace, lifetime: AbortSignal): RemoteStatusSource;
+/** Direct browser transport over the generated namespace. */
+export interface PauseTransport {
+    readonly source: RemoteStatusSource;
+    act(request: {
+        readonly action: 'pause' | 'resume' | 'pause-all' | 'resume-all' | 'cancel-all' | 'goal';
+        readonly sessionId: string;
+    }, signal?: AbortSignal): Promise<PauseActionResultWire>;
+    triage(caller: string, signal?: AbortSignal): Promise<readonly TriageRowWire[] | undefined>;
+    decide(caller: string, target: string, decision: 'continue' | 'note' | 'review' | 'leave' | 'goal', signal?: AbortSignal): Promise<PauseActionResultWire>;
+}
+/**
+ * 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.
+ */
+export declare function remoteTransport(remote: RemotePauseNamespace, lifetime: AbortSignal): PauseTransport;

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

@@ -51,7 +51,7 @@ export declare function showsPauseControl(subagent: {
  * @param reading - the host-reported reading, or `undefined` before the first answer.
  * @returns the view for that reading.
  */
-export declare function pauseView(reading: PauseReading | undefined): PauseView;
+export declare function pauseView(reading: PauseReading | undefined, running?: boolean): PauseView;
 /** One named fact from the whole-app report, with the copy key that introduces it. */
 export interface GlobalCaveat {
     /** What this list of names is. */
@@ -60,7 +60,7 @@ export interface GlobalCaveat {
     readonly names: readonly string[];
 }
 /** Which verb a whole-app press runs. */
-export type GlobalAction = 'pause-all' | 'resume-all' | 'none';
+export type GlobalAction = 'pause-all' | 'resume-all' | 'cancel-all' | 'none';
 /** One decision as the list renders it. */
 export interface TriageActionView {
     /** The decision this button takes. */
@@ -72,6 +72,14 @@ export interface TriageActionView {
 }
 /** The four decisions, in the order a user reads them: least to most cautious. */
 export declare const TRIAGE_ACTION_VIEWS: readonly TriageActionView[];
+/**
+ * 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.
+ */
+export declare function triageActionsFor(row: TriageRowView): readonly TriageActionView[];
 /**
  * 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.
@@ -96,9 +104,11 @@ export interface TriageRowView {
 }
 /** What the decision-list panel renders. */
 export interface TriageView {
-    /** Whether the panel has anything to show; a host that cannot answer shows nothing. */
+    /** Whether the host answered the list read at all. */
     readonly visible: boolean;
-    /** Whether any listed session can actually be continued. */
+    /** Whether the last list read failed rather than returning rows. */
+    readonly unavailable: boolean;
+    /** The rows the host reported. */
     readonly rows: readonly TriageRowView[];
 }
 /**
@@ -128,10 +138,14 @@ export interface GlobalPauseView {
     readonly unclean: number;
     /** Named facts the user must not miss; rendered on the tooltip. */
     readonly caveats: readonly GlobalCaveat[];
+    /** Draining sessions and what each is running, when the host still has work. */
+    readonly running?: string;
 }
 /**
  * Map one whole-app reading to its view.
  * @param reading - the host-reported reading, or `undefined` before the first answer.
  * @returns the view for that reading.
  */
-export declare function globalPauseView(reading: GlobalReading | undefined): GlobalPauseView;
+export declare function globalPauseView(reading: GlobalReading | undefined, sessions?: Readonly<Record<string, {
+    readonly runningTools: readonly string[];
+}>>): GlobalPauseView;

package/lib/types/coldlog.d.ts

@@ -7,7 +7,7 @@
  * list only has to name where the session stopped, which tool call the log
  * never heard back from, and whether an answer is still owed — all of them
  * facts about the log's END. Reading from seq 0 to the end for every row, on
- * every command-registry change while the panel is open, would make a long
+ * every time the panel opens, would make a long
  * session's cost grow with a log nobody is asking about.
  *
  * WHAT THE BOUND BUYS. A stored log is append-only, so the tail is stable: the

package/lib/types/control.d.ts

@@ -2,55 +2,11 @@
  * The session control the browser half drives: the pause verb, the park state
  * machine behind it, and the live state channel that accompanies both.
  *
- * A third-party plugin can add neither a `ctx.remote` namespace nor a forwarded
- * event: the Client's Remote namespaces and the forwarded-event allowlist are
- * compiled into the harness's own API assembly. The documented Client-callable
- * Host entry point is therefore a session command run through
- * `ctx.remote.commands.execute`, and the one live channel such a plugin can
- * publish through is the command registry itself — `commands/change` is a
- * forwarded event, and `commands.list(sessionId)` is a Client-callable read.
- *
- * That same registry is how a phase change leaves this process: a transition
- * re-registers the status verb, which emits the change a client needs to read
- * the new phase. It is the only way a third-party plugin can announce anything,
- * and it is what makes the flush that resolves `parking` into `safe` observable
- * at all — that step changes no registration of its own.
- *
- * So the resume definition IS the paused marker: it is registered on a paused
- * session's own agent context and removed on resume, and the browser half reads
- * "paused" from that registration rather than inventing it. A descriptor cannot
- * change after registration, so the park state rides a companion status
- * definition (registered beside the marker) whose answer is derived per call
- * rather than frozen into a descriptor — see `./shared.ts`. That one read
- * carries the record's goal opt-out too, so the session-header control can show
- * and switch it while the session is parked and clean — the state in which a
- * silent morning resume would otherwise spend the user's rounds unasked. The
- * switch is addressed to the session it changes, so it needs no listed row.
- *
- * The header control is the user's button for ONE session's work, and that work
- * includes the subagents under it: the press registers the session and its
- * descendant tree, the release takes the same tree back, and the status the
- * header shows is the worst phase among the members the press registered. The
- * whole-app control covers every running tree and answers for all of them; this
- * one answers for the tree it owns.
- *
- * A mark is not a park. A session is parked only once nothing is left to drain:
- * no call in flight AND either its next model request is held at the gate or no
- * turn is open at all (there will be no next request to hold). Only then is the
- * session flushed, at the session level — `SessionHandle.flush()` does not
- * drain the routed live buffer, so it would record a park that a crash erases.
- * The "safe to close" phase appears only after that flush resolves.
- *
- * Every phase a pause reaches is written to the durable registry before it is
- * published — including the move into `parking`, which the status command may
- * therefore never serve ahead of the record. A restart re-holds exactly the
- * sessions the last process left parked, and a phase that could not be recorded
- * is never shown as cleaner than the record says.
- *
- * A park verb changes state, so it acts only on a person's command: a command
- * dispatched from inside a model turn is refused. The listed verbs add the
- * one binding their target needs — the row must be one the calling session was
- * shown — and that rule lives with the list (`./triage.ts`).
+ * The host exposes this control through the native Typert Remote namespace:
+ * `observe` streams snapshots and `act` / `triage` / `decide` drive the UI. No
+ * slash command is registered. Phase changes wake the Remote stream through a
+ * local listener set; the durable registry remains the source of truth for what
+ * the snapshot reports.
  * @module dsh-pause-session/control
  */
 import type { Context } from '@deepseek-ai/cordis';
@@ -58,14 +14,10 @@ import { SessionId } from '@deepseek-ai/dsh-session';
 import type { PauseGate } from './gate.js';
 import type { ParkWatch } from './park.js';
 import type { ParkRegistry } from './registry.js';
-import type { ResumeAttempt, ResumeOptions } from './resume.js';
-/**
- * Result copy for a state-changing park verb issued from inside a model turn.
- * The invocation carries no origin of its own, so this refusal is the plugin's
- * own reading of the one signal that separates a person's command from a
- * model's.
- */
-export declare const UNATTENDED_TEXT: string;
+import type { ReleaseTreeOutcome, ResumeAttempt, ResumeOptions } from './resume.js';
+import type { TriageAction } from './shared.js';
+import type { PauseSnapshot, TriageList } from './shared.js';
+import type { PauseAnswer } from './shared.js';
 /** What one tree-wide press registered, and what it could not. */
 export interface PressTreeOutcome {
     /** How many sessions this press covered: the session plus its descendants. */
@@ -76,8 +28,12 @@ export interface PressTreeOutcome {
     readonly rootRegistered: boolean;
     /** The members whose record could not be written; they are not paused. */
     readonly unrecorded: readonly SessionId[];
-    /** Whether the tree walk itself failed, so the session's subagents were not covered. */
+    /** Whether any branch was unread, so the subagent tree was not fully covered. */
     readonly unread: boolean;
+    /** Tree members on a one-shot or unreadable route; they were not registered. */
+    readonly unresumable: readonly SessionId[];
+    /** Branch ids the tree walk could not read. */
+    readonly unreadBranches: readonly SessionId[];
 }
 /** What mounting the session control hands back to the plugin entry. */
 export interface SessionControl {
@@ -87,8 +43,33 @@ export interface SessionControl {
      * after mount.
      */
     adopt(): Promise<void>;
+    /**
+     * Read the whole app and every live paused session as one JSON-safe snapshot.
+     * The native snapshot serves this; it never enters a Session log.
+     * @param signal - cancellation for the tree reads this snapshot performs.
+     * @returns the whole-app verdict and the paused sessions this process holds.
+     */
+    readSnapshot(signal?: AbortSignal): Promise<PauseSnapshot>;
+    /** Wake a listener after any visible status change. */
+    subscribe(listener: () => void): () => void;
+    /** Press one Session tree. */
+    pressTree(sessionId: SessionId, signal?: AbortSignal): Promise<PressTreeOutcome>;
+    /** Release one Session's registered tree. */
+    releaseTree(sessionId: SessionId, signal?: AbortSignal): Promise<ReleaseTreeOutcome>;
+    /** Press every running Session tree. */
+    pauseAll(signal?: AbortSignal): Promise<PauseAnswer>;
+    /** Resume every cleanly paused Session. */
+    resumeAll(signal?: AbortSignal): Promise<PauseAnswer>;
+    /** Release every registered tree, cancelling a press that is still draining. */
+    cancelAll(signal?: AbortSignal): Promise<PauseAnswer>;
+    /** Flip one Session's goal re-arm opt-out. */
+    toggleGoal(sessionId: SessionId, signal?: AbortSignal): Promise<PauseAnswer>;
+    /** Read the morning list for one calling Session. */
+    readTriage(caller: SessionId, signal?: AbortSignal): Promise<TriageList>;
+    /** Take one listed decision for one calling Session. */
+    decideTriage(caller: SessionId, target: SessionId, action: TriageAction, signal?: AbortSignal): Promise<PauseAnswer>;
 }
-/** How resuming all parked sessions answers the command that asked for it. */
+/** How resuming all parked sessions answers the caller. */
 export declare function summarizeResume(attempts: readonly ResumeAttempt[]): string;
 /**
  * Everything the session control needs from the composition: the clean resume
@@ -103,7 +84,7 @@ export interface SessionControlOptions extends ResumeOptions {
  * Contribute the session control: the pause verb, the per-session status read,
  * the global resume verb, and — for every paused session that has a live agent
  * — the resume marker.
- * @param ctx - host context carrying the command registry, the agent store, the
+ * @param ctx - host context carrying the agent store, the
  * session store, and the projection registry.
  * @param gate - the pause gate this control drives and reflects.
  * @param watch - the per-session activity fold the park predicate reads.

package/lib/types/global.d.ts

@@ -23,11 +23,12 @@
  * @module dsh-pause-session/global
  */
 import type { Context } from '@deepseek-ai/cordis';
-import type { CommandResult } from '@deepseek-ai/dsh-commands';
 import type { SessionId } from '@deepseek-ai/dsh-session';
 import type { ParkWatch } from './park.js';
 import type { ParkRegistry } from './registry.js';
-import type { ParkPhase } from './shared.js';
+import type { GlobalStatus, ParkPhase } from './shared.js';
+import type { TreeWalk } from './tree.js';
+import type { PauseAnswer } from './shared.js';
 /** One session's live park state, as the per-session control sees it. */
 export interface LivePark {
     readonly phase: ParkPhase;
@@ -74,12 +75,13 @@ export interface GlobalPause {
      * @param signal - cancellation for the tree reads this action performs.
      * @returns the aggregate as of this action's end.
      */
-    pressAll(signal?: AbortSignal): Promise<CommandResult>;
+    pressAll(signal?: AbortSignal): Promise<PauseAnswer>;
     /**
+     * The aggregate as structured data for the native Remote stream.
      * @param signal - cancellation for the tree reads this read performs.
      * @returns the aggregate as of this read.
      */
-    readStatus(signal?: AbortSignal): Promise<CommandResult>;
+    readState(signal?: AbortSignal, walks?: ReadonlyMap<SessionId, TreeWalk>): Promise<GlobalStatus>;
     /**
      * Report one session a press could not register, so the aggregate names it.
      * The whole-app action records that fact for its own targets; a press of a

package/lib/types/index.d.ts

@@ -14,6 +14,7 @@
  */
 import { z } from 'zod';
 import type { Context } from '@deepseek-ai/cordis';
+export { PauseRemote } from './remote.js';
 /** Plugin name; the Loader row and the bundle patch both use it. */
 export declare const name = "dsh-pause-session";
 /**
@@ -61,4 +62,3 @@ export declare const Config: z.ZodPreprocess<z.ZodObject<{
  * @param config - validated route knowledge for the resume path's wake content.
  */
 export declare function apply(ctx: Context, config?: Config): Promise<void>;
-export {};

package/lib/types/park-state.d.ts

@@ -0,0 +1,51 @@
+/**
+ * One session's park episode: the durable phase writes, the activity walk that
+ * settles them, and the press/release lifecycle. The control composes this with
+ * the aggregate, the resume path, and the decision list.
+ * @module dsh-pause-session/park-state
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import type { PauseGate } from './gate.js';
+import type { LivePark, PressResult } from './global.js';
+import type { ParkWatch } from './park.js';
+import type { ParkRegistry } from './registry.js';
+import type { ParkPhase, PauseAnswer } from './shared.js';
+/** One session's park in progress. */
+export interface ParkMark {
+    /** The phase the durable registry confirms for this session. */
+    phase: ParkPhase;
+    /** Generation of the attempt that owns this mark. */
+    generation: number;
+    /** Whether this mark is a live press or a record adopted at mount. */
+    origin: 'press' | 'registry';
+    /** Whether a settle attempt is already walking this mark. */
+    advancing: boolean;
+}
+/** The park lifecycle the session control composes. */
+export interface ParkState {
+    readonly marks: Map<SessionId, ParkMark>;
+    readonly unrecorded: Set<SessionId>;
+    readonly unheld: Set<SessionId>;
+    subscribe(listener: () => void): () => void;
+    notify(): void;
+    press(sessionId: SessionId, signal?: AbortSignal, knownResumable?: boolean): Promise<PressResult>;
+    /** Adopt one durable record as a mark that never advances in this process. */
+    adopt(sessionId: SessionId, phase: ParkPhase): void;
+    look(sessionId: SessionId): void;
+    drop(sessionId: SessionId): void;
+    sync(sessionId: SessionId): void;
+    release(sessionId: SessionId, text: string): Promise<PauseAnswer>;
+    markUnrecorded(sessionId: SessionId, unrecorded: boolean): void;
+    live(): Map<SessionId, LivePark>;
+    cleanup(): void;
+}
+/**
+ * Mount the park episode state machine over the gate, registry, and activity fold.
+ * @param ctx - host context carrying the session store and logger.
+ * @param gate - the pause gate this state drives.
+ * @param registry - the durable pause list every phase write goes to.
+ * @param watch - the activity fold the park predicate reads.
+ * @returns the park lifecycle the control composes.
+ */
+export declare function installParkState(ctx: Context, gate: PauseGate, registry: ParkRegistry, watch: ParkWatch): ParkState;

package/lib/types/registry.d.ts

@@ -72,7 +72,7 @@ export interface ParkRegistry {
      * The same list as {@link list}, as a lazily kept read-only view.
      *
      * The whole-app aggregate and the decision list read this once per status
-     * read, and a status read can happen on every command-registry change; the
+     * read, and a status read can happen on every native-stream notification; the
      * view is rebuilt only when the stored entries actually changed, so a read
      * that changes nothing does not build a second copy of the list to look at.
      * A caller must not mutate it.

package/lib/types/release-order.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The order a tree release walks: parent before child, shallowest first.
+ * @module dsh-pause-session/release-order
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+/** How a batch release is sequenced. */
+export interface ReleaseOrder {
+    /** The tree edge each child was found under. */
+    readonly parents: ReadonlyMap<SessionId, SessionId>;
+    /** One list per depth, shallowest first. */
+    readonly levels: readonly (readonly SessionId[])[];
+}
+/**
+ * Sequence a batch release parent before child.
+ * @param ctx - host context carrying the optional subagent catalog.
+ * @param sessionIds - every recorded session, in registry order.
+ * @param signal - cancellation for each catalog read.
+ * @returns the parent of each child, and one list per depth level.
+ */
+export declare function releaseOrder(ctx: Context, sessionIds: readonly SessionId[], signal?: AbortSignal): Promise<ReleaseOrder>;

package/lib/types/remote-adapter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Wire adapter between the pause engine and the generated Remote namespace.
+ *
+ * The engine speaks in branded Session ids and user-facing answer copy; the Remote
+ * contract is plain JSON. Mapping lives here so neither side depends on the
+ * other's types.
+ * @module dsh-pause-session/remote-adapter
+ */
+import type { SessionControl } from './control.js';
+import type { PauseRemoteApi, PauseSnapshotWire } from './remote.js';
+import type { GlobalStatus, ParkStatus } from './shared.js';
+/** Map the engine's snapshot to the wire shape. */
+export declare function snapshotOf(snapshot: {
+    global: GlobalStatus;
+    sessions: Readonly<Record<string, ParkStatus>>;
+}): PauseSnapshotWire;
+/**
+ * Build the Remote callbacks over the mounted pause control.
+ * @param control - the engine's host control surface.
+ * @returns the wire API.
+ */
+export declare function remoteApiOf(control: SessionControl): PauseRemoteApi;

package/lib/types/remote.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Native Remote transport for the pause controls.
+ *
+ * This module is deliberately self-contained: it imports only Cordis and the
+ * Typert decorators. The Typert generator analyzes this file alone so a
+ * third-party package can emit its Host reflection and Client contribution
+ * without pulling the plugin's DSH-typed modules into the generation face.
+ *
+ * The UI uses this namespace on Web and Desktop alike. No slash command is
+ * registered; the stream is the live status channel and the methods below are
+ * the button actions.
+ * @module dsh-pause-session/remote
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface RemoteErrorDetailsMap {
+        /** The pause control is personal; only the owner may read or drive it. */
+        'pause/owner-only': {};
+    }
+}
+/** The phase a Session reports to the controls. */
+export type PausePhaseWire = 'active' | 'draining' | 'parking' | 'safe' | 'flush-failed';
+/** One Session's pause state. */
+export interface SessionStatusWire {
+    readonly phase: PausePhaseWire;
+    readonly runningTools: readonly string[];
+    readonly rearmGoal?: boolean;
+}
+/** The whole-app verdict. */
+export interface GlobalStatusWire {
+    readonly verdict: 'idle' | 'waiting' | 'safe';
+    readonly registered: number;
+    readonly safe: number;
+    readonly parkedAt?: string;
+    readonly draining: readonly string[];
+    readonly parking: number;
+    readonly stalled: readonly string[];
+    readonly unresumable: readonly string[];
+    readonly unreadTrees: readonly string[];
+    readonly jobs: readonly string[];
+    readonly blind: readonly string[];
+}
+/** One live status snapshot: the aggregate plus every held Session. */
+export interface PauseSnapshotWire {
+    readonly global: GlobalStatusWire;
+    readonly sessions: Readonly<Record<string, SessionStatusWire>>;
+}
+/** One row in the morning decision list. */
+export interface TriageRowWire {
+    readonly sessionId: string;
+    readonly phase: 'draining' | 'parking' | 'flush-failed';
+    readonly updatedAt: number;
+    readonly reading: 'read' | 'unreadable';
+    readonly lastEvent?: string;
+    readonly turn?: number;
+    readonly step?: number;
+    readonly traces: readonly {
+        readonly tool: string;
+        readonly callId: string;
+    }[];
+    readonly owed: boolean;
+    readonly wakeable: boolean;
+    readonly rearmGoal: boolean;
+}
+/** One button action. */
+export interface PauseActionRequest {
+    readonly action: 'pause' | 'resume' | 'pause-all' | 'resume-all' | 'cancel-all' | 'goal';
+    /** The Session the control is addressed through. */
+    readonly sessionId: string;
+}
+/** One action outcome. */
+export interface PauseActionResultWire {
+    readonly ok: boolean;
+    readonly message: string;
+}
+/** One decision-list read. */
+export interface PauseTriageRequest {
+    readonly caller: string;
+}
+/** One decision on a listed Session. */
+export interface PauseDecisionRequest {
+    readonly caller: string;
+    readonly target: string;
+    readonly decision: 'continue' | 'note' | 'review' | 'leave' | 'goal';
+}
+export interface PauseRemoteApi {
+    snapshot(signal?: AbortSignal): Promise<PauseSnapshotWire>;
+    subscribe(listener: () => void): () => void;
+    act(request: PauseActionRequest, signal?: AbortSignal): Promise<PauseActionResultWire>;
+    triage(request: PauseTriageRequest, signal?: AbortSignal): Promise<readonly TriageRowWire[]>;
+    decide(request: PauseDecisionRequest, signal?: AbortSignal): Promise<PauseActionResultWire>;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        pauseSession: PauseRemote;
+    }
+}
+/** Host service exposed to the browser as the `pauseSession` Remote namespace. */
+export declare class PauseRemote extends TypertRemoteService {
+    private readonly api;
+    /** One snapshot per host version, shared by every connected observer. */
+    private snapshotCache;
+    /** Bumped by every host notification; each observer compares it to its own cursor. */
+    private version;
+    /** Observers waiting for the next version. */
+    private readonly waiters;
+    private readonly unsubscribe;
+    /**
+     * @param ctx - host context owning the service.
+     * @param api - the pause engine behind the wire methods.
+     */
+    constructor(ctx: Context, api: PauseRemoteApi);
+    /**
+     * One exact snapshot, used by tests and by a reconnect that cannot wait for
+     * the first stream item.
+     * @param signal - carrier cancellation.
+     * @returns the current aggregate and session states.
+     */
+    snapshot(signal?: AbortSignal): Promise<PauseSnapshotWire>;
+    /**
+     * The snapshot for one host version, computed once even when several clients
+     * are watching. A new notification discards the cached promise.
+     * @param version - the host version this snapshot answers.
+     * @param signal - stream cancellation.
+     * @returns the shared snapshot promise.
+     */
+    private snapshotFor;
+    /**
+     * Live status: the opening snapshot, then one new snapshot whenever the host
+     * reports a change.
+     * @param signal - stream cancellation.
+     * @returns the snapshot stream.
+     */
+    observe(signal?: AbortSignal): AsyncIterable<PauseSnapshotWire>;
+    /**
+     * Pause, resume, press every tree, resume every clean park, or flip one
+     * Session's goal re-arm.
+     * @param request - the button action.
+     * @param signal - carrier cancellation.
+     * @returns the user-facing outcome.
+     */
+    act(request: PauseActionRequest, signal?: AbortSignal): Promise<PauseActionResultWire>;
+    /**
+     * Read the morning decision list.
+     * @param request - the calling Session whose list is read.
+     * @param signal - read cancellation.
+     * @returns the listed rows.
+     */
+    triage(request: PauseTriageRequest, signal?: AbortSignal): Promise<readonly TriageRowWire[]>;
+    /**
+     * Take one decision on one listed Session.
+     * @param request - the caller, target, and decision.
+     * @param signal - load cancellation.
+     * @returns the user-facing outcome.
+     */
+    decide(request: PauseDecisionRequest, signal?: AbortSignal): Promise<PauseActionResultWire>;
+}

package/lib/types/resume-activation.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Reactivate one parked session: restore its composition, give it the route its
+ * log recorded, deliver the wake it owes, and only then drop the gate and record.
+ * @module dsh-pause-session/resume-activation
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+import type { PauseGate } from './gate.js';
+import type { ParkRegistry } from './registry.js';
+import type { ResumeAttempt, ResumeOptions, WakeRequest } from './resume-text.js';
+/** The activation entry points the resume path composes. */
+export interface Activator {
+    activate(sessionId: SessionId, request: WakeRequest, rearm: boolean, parentId?: SessionId, signal?: AbortSignal): Promise<ResumeAttempt>;
+    ensureRoute(agent: Agent): void;
+    wake(agent: Agent, request: WakeRequest): void;
+    rearmGoal(agent: Agent): void;
+}
+/**
+ * Build the activation closure.
+ * @param ctx - host context carrying the agent store and goal service.
+ * @param gate - the pause gate released after activation.
+ * @param registry - the durable list the release forgets from.
+ * @param options - the route knowledge the wake content depends on.
+ * @returns the activation methods the resume path uses.
+ */
+export declare function createActivator(ctx: Context, gate: PauseGate, registry: ParkRegistry, options: ResumeOptions): Activator;