dsh-pause-session 0.1.0 → 0.2.1

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

@@ -0,0 +1,77 @@
+/**
+ * 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.
+ *
+ * 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.
+ */
+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/composition.d.ts

@@ -1,58 +1,34 @@
 /**
- * Rebuild the scoped Agent composition a parked Session ran under.
+ * What a parked Session needs to come back as itself.
  *
- * Activation is not only a persisted Session: the Agent preset supplies the
- * scoped tools, prompt sections, skills, and — for a subagent child — the
- * delegation context, persona, and tool restriction that were in force before
- * the park. A resume that loads the log without that setup starts a different
- * Agent on the same history.
+ * A root Session is loaded directly: the Agent preset it ran supplies the
+ * scoped tools, prompt sections, and skills, so the resume mounts that preset
+ * before the Agent is published. A subagent child is not loaded here at all —
+ * the subagent runtime owns its activation, composition, and tree membership,
+ * and cold-resumes it when this plugin delivers the wake through
+ * `ctx.subagents.prompt`.
  *
- * The preset a Session runs is the `agentPreset` projection, never the
- * creation-time header alone: a blank Session may select another preset before
- * its first turn, and the projection records the selection that actually ran.
- * A child with no independent selection joins its live parent's preset
- * generation; one that selected independently mounts the projected preset.
- * The durable child descriptor supplies the persona, tool filter, and route
- * that are reapplied only on cold resume.
- *
- * Both services are optional. A profile without `agentPresets` has no scoped
- * preset composition to restore, and this module leaves the resume unchanged.
- * A profile that mounts one but cannot read the Session projection cannot
- * prove what composition the Session ran, so it fails the resume instead of
- * silently starting a different Agent.
+ * The two cases are told apart by one read of the Session's own log, which is
+ * the same read the press-time resumability check already pays for.
  * @module dsh-pause-session/composition
  */
 import type { Context } from '@deepseek-ai/cordis';
-import type { Agent, AgentOptions, AgentSetup } from '@deepseek-ai/dsh-agent';
-import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session';
-/** The setup and route options a resumed Agent receives from its stored composition. */
-export interface RestoredComposition {
-    /** The durable child route, when the descriptor recorded one. */
-    readonly agentOptions?: AgentOptions;
+import type { AgentSetup } from '@deepseek-ai/dsh-agent';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+/** How one parked Session comes back. */
+export type ParkedComposition = {
+    /** An ordinary Session the plugin loads itself. */
+    readonly kind: 'root';
     /** The scoped Agent world to mount before the Agent is published. */
     readonly setup?: AgentSetup;
-}
-/**
- * A stored subagent route that no resume may reactivate.
- *
- * A one-shot child is terminal by contract; activating it as a root Agent
- * would turn a finished delegation into an ordinary conversation that happens
- * to share its Session id.
- */
-export declare class UnresumableSessionError extends Error {
-    constructor(sessionId: SessionId);
-}
-/**
- * Whether the child's own log selected a preset before its descriptor.
- *
- * The creation-time selection precedes the first `subagent/descriptor`; a
- * selection after the descriptor belongs to the child's own later history and
- * does not decide which composition cold resume joins. This mirrors the
- * subagent runtime's own cold-resume rule.
- * @param events - the child's own log suffix, without the fork-inherited prefix.
- * @returns whether the child carries an independent preset selection.
- */
-export declare function hasIndependentPresetSelection(events: readonly SessionEvent[]): boolean;
+} | {
+    /**
+     * A subagent child. The subagent runtime restores its composition from the
+     * persisted descriptor and preset projection, so the plugin only delivers
+     * the wake.
+     */
+    readonly kind: 'child';
+};
 /**
  * Whether a local Session may be parked under a promise of a later resume.
  *
@@ -73,22 +49,20 @@ export declare function hasIndependentPresetSelection(events: readonly SessionEv
  */
 export declare function isResumableSession(ctx: Context, sessionId: SessionId, signal?: AbortSignal): Promise<boolean>;
 /**
- * Read one parked Session's stored composition and build the resume options.
+ * Read one parked Session's own log and decide how it comes back.
+ *
+ * A child returns as `child` with no setup: the subagent runtime restores the
+ * composition from the descriptor and the preset projection, and mounting a
+ * second one here would start a different Agent on the same history.
  *
- * The returned `setup` belongs to the unpublished Agent scope, so all
- * registrations exist before `agent/created`. For a root Session the setup
- * mounts the Session's projected preset, or the profile's default when the
- * Session never selected one. For a child under a live parent it applies the
- * child composition: an independent preset mounts separately, while an
- * inherited composition joins the parent's current generation; the historical
- * descriptor's persona and tool filter are reapplied in both cases.
+ * A root resolves the preset it ran — the projection, never the creation-time
+ * header alone, because a blank Session may select another preset before its
+ * first turn — and hands back the setup that mounts it. A profile with no
+ * preset roster has no scoped composition to restore and resumes unchanged.
  * @param ctx - host context carrying the optional preset and Session-query services.
  * @param sessionId - the parked Session being resumed.
- * @param parent - the live direct parent, when a child is resumed under it.
  * @param signal - cancellation for the observation read.
- * @returns the Agent options and setup to pass to `agents.resume`.
- * @throws {UnresumableSessionError} when the stored child route is one-shot.
- * @throws when a mounted preset roster cannot read the Session projection, or
- * a recorded preset cannot be restored.
+ * @returns how this Session comes back.
+ * @throws when a mounted preset roster cannot read the Session projection.
  */
-export declare function restoreComposition(ctx: Context, sessionId: SessionId, parent: Agent | undefined, signal?: AbortSignal): Promise<RestoredComposition>;
+export declare function readParkedComposition(ctx: Context, sessionId: SessionId, signal?: AbortSignal): Promise<ParkedComposition>;

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";
 /**
@@ -50,7 +51,7 @@ export type Config = z.infer<typeof ConfigShape>;
 export declare const Config: z.ZodPreprocess<z.ZodObject<{
     silentWakeRoutes: z.ZodDefault<z.ZodArray<z.ZodString>>;
     maxListedLogEvents: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>>;
+}, z.core.$strip>, unknown>;
 /**
  * Mount the durable pause registry, the pause gate, the activity fold, their
  * session control, and the clean resume path.
@@ -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,25 @@
+/**
+ * The order a batch release walks: parent before child, shallowest first.
+ *
+ * A single tree release already has the pre-order from its own walk, so this
+ * module serves the batch path, where the recorded sessions may span several
+ * trees. `listDescendants` stamps each row with its distance from the listing
+ * root, so one catalog read per recorded root places every member. A session
+ * the walk never reached is its own root and releases with the first level.
+ * @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 {
+    /** 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 one list per depth level, shallowest first.
+ */
+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;