dsh-pause-session 0.1.0 → 0.2.1

package/lib/index.js

@@ -1,8 +1,9 @@
 import { z } from "zod";
 import { SessionId, deriveEventMessage, foldRequestHeader, foldSurface, interruptedTurnClosers } from "@deepseek-ai/dsh-session";
-import { CommandDefinitionId } from "@deepseek-ai/dsh-commands/brand";
-import { applyChildComposition, foldSubagentDescriptor } from "@deepseek-ai/dsh-subagent";
+import { randomUUID } from "node:crypto";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { Remote, RemoteError, TypertRemoteService, principalOf, remoteErrorOf } from "@deepseek-ai/dsh-typert-protocol";
+import { foldSubagentDescriptor } from "@deepseek-ai/dsh-subagent";
 import { DomainError, defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
 //#region lib/types/history.js
 /**
@@ -72,101 +73,16 @@ function routeNamed(events) {
 //#endregion
 //#region lib/types/shared.js
 /**
-* The identities both halves of dsh-pause-session name, the status encodings they
-* share, and the one spelling a host log line gives a caught value.
+* The identities both halves of dsh-pause-session name, the phase vocabulary
+* they share, and the one spelling a host log line gives a caught value.
 *
 * The browser bundle may value-import only the shell's baseline module table,
-* so this module imports nothing: the client half reads command names and the
-* decode functions from it directly, and the host half derives the branded
-* identities from the same strings.
-*
-* A third-party plugin's only live channel to the browser is the command
-* registry — it can add neither a `ctx.remote` namespace nor a forwarded event,
-* both of which are compiled into the harness's own API assembly. A command
-* descriptor's only free-form field is its `description`, and a command
-* result's only free-form field is its `text`, so the park state travels as a
-* prefix plus `;`-separated fields on one of those. The text stays
-* human-readable: the same words are what the slash-command menu shows.
-*
-* Every value inside a field is escaped, so a decoded name is the exact name
-* that was encoded. Session ids, tool names, and call ids are the host's own
-* data and may contain the `;`, `,`, `/`, or newline a field is separated by; a
-* folded spelling would decode as a different name — a different row, looked up
-* again.
+* so this module imports nothing. The native Remote payloads are the live
+* vocabulary; there is no command encoding or slash-command surface here.
 * @module dsh-pause-session/shared
 */
-/** Command that pauses the receiving session before its next model request. */
-const PAUSE_COMMAND = "pause";
-/** Command that resumes the receiving session; registered only while that session is paused. */
-const RESUME_COMMAND = "pause-resume";
-/** Command that resumes every parked session the registry remembers. */
-const RESUME_ALL_COMMAND = "pause-resume-all";
-/** Command that registers and parks every running session tree in one action. */
-const PAUSE_ALL_COMMAND = "pause-all";
-/** Command that reports the whole-app park state; registered globally, always. */
-const STATE_ALL_COMMAND = "pause-state-all";
-/** Command that reports the receiving session's park state; registered only while it is paused. */
-const STATUS_COMMAND = "pause-state";
-/** Command that turns the receiving session's own goal re-arm on or off; registered only while it is paused. */
-const GOAL_COMMAND = "pause-goal";
-/** Command that reports every session that did not stop cleanly. */
-const TRIAGE_COMMAND = "pause-triage";
-/** Command that resumes one session from the decision list exactly as the clean path would. */
-const TRIAGE_CONTINUE_COMMAND = "pause-triage-continue";
-/** Command that resumes one session from the decision list with the unknown-outcome note. */
-const TRIAGE_NOTE_COMMAND = "pause-triage-note";
-/** Command that opens one session from the decision list without spending a request. */
-const TRIAGE_REVIEW_COMMAND = "pause-triage-review";
-/** Command that leaves one session from the decision list exactly as it is. */
-const TRIAGE_LEAVE_COMMAND = "pause-triage-leave";
-/** Command that turns one listed session's goal re-arm on or off. */
-const TRIAGE_GOAL_COMMAND = "pause-triage-goal";
-/** Stable definition id of the pause command, matched by identity rather than by copy. */
-const PAUSE_DEFINITION_ID = "dsh-pause-session/pause";
-/** Stable definition id of the resume command: the host's own "this session is paused" fact. */
-const RESUME_DEFINITION_ID = "dsh-pause-session/resume";
-/** Stable definition id of the global resume command, matched by identity rather than by copy. */
-const RESUME_ALL_DEFINITION_ID = "dsh-pause-session/resume-all";
-/** Stable definition id of the whole-app pause command. */
-const PAUSE_ALL_DEFINITION_ID = "dsh-pause-session/pause-all";
-/** Stable definition id of the whole-app status read. */
-const STATE_ALL_DEFINITION_ID = "dsh-pause-session/state-all";
-/** Stable definition id of the status read, matched by identity rather than by copy. */
-const STATUS_DEFINITION_ID = "dsh-pause-session/status";
-/** Stable definition id of the paused session's own goal re-arm toggle. */
-const GOAL_DEFINITION_ID = "dsh-pause-session/goal";
-/** Stable definition id of the decision-list read. */
-const TRIAGE_DEFINITION_ID = "dsh-pause-session/triage";
-/** Stable definition id of the decision-list "continue" verb. */
-const TRIAGE_CONTINUE_DEFINITION_ID = "dsh-pause-session/triage-continue";
-/** Stable definition id of the decision-list "continue with the unknown-outcome note" verb. */
-const TRIAGE_NOTE_DEFINITION_ID = "dsh-pause-session/triage-note";
-/** Stable definition id of the decision-list "open without activating" verb. */
-const TRIAGE_REVIEW_DEFINITION_ID = "dsh-pause-session/triage-review";
-/** Stable definition id of the decision-list "leave it alone today" verb. */
-const TRIAGE_LEAVE_DEFINITION_ID = "dsh-pause-session/triage-leave";
-/** Stable definition id of the decision-list goal re-arm toggle. */
-const TRIAGE_GOAL_DEFINITION_ID = "dsh-pause-session/triage-goal";
-/** First token of every encoded status, so a descriptor is never parsed by accident. */
-const STATUS_PREFIX = "pause: ";
-/**
-* One list field's text when the list is empty. A value that would itself spell
-* this marker is escaped by {@link escapeField}, so an empty list and a list
-* holding the marker stay different texts.
-*/
-const EMPTY_FIELD = "-";
-/**
-* One field or item value, ready to sit inside an encoded text: every separator
-* (`;`, `,`, `/`, newline) and the escape character itself are escaped, and a
-* value that would spell {@link EMPTY_FIELD} is escaped so it is not read as an
-* empty list.
-* @param text - the value to encode, as the host holds it.
-* @returns the value as it appears inside an encoded field.
-*/
-function escapeField(text) {
-	const escaped = text.replace(/[\\;,\n/]/g, (character) => character === "\n" ? "\\n" : `\\${character}`);
-	return escaped.startsWith(EMPTY_FIELD) ? `\\${escaped}` : escaped;
-}
+/** Result copy for a press or a release the durable registry refused to record. */
+const UNRECORDED_TEXT = "pause could not write the pause registry, so it did not change the pause state.";
 /**
 * One log line's text for a caught value.
 * @param error - the caught value.
@@ -227,84 +143,6 @@ function foldTreePhases(phases) {
 		safe: worst === "safe"
 	};
 }
-/** The one word each phase is published as, and the whole decoding vocabulary. */
-const PHASE_WORD = {
-	draining: "pausing",
-	parking: "saving",
-	safe: "paused",
-	"flush-failed": "save failed"
-};
-/**
-* The two states of one record's goal re-arm field, in the one spelling both
-* the per-session status and the decision list publish it with.
-*/
-const GOAL_ON = "on";
-const GOAL_OFF = "off";
-/**
-* Encode one status for a command descriptor.
-* @param status - the state to publish.
-* @returns the descriptor text, e.g. `pause: draining; tools: edit, bash; goal: on`.
-*/
-function encodeParkStatus(status) {
-	return `${`${STATUS_PREFIX}${PHASE_WORD[status.phase]}`}${status.runningTools.length === 0 ? "" : `; tools: ${status.runningTools.map(escapeField).join(", ")}`}${status.rearmGoal === void 0 ? "" : `; goal: ${status.rearmGoal ? GOAL_ON : GOAL_OFF}`}`;
-}
-/**
-* First token of every encoded whole-app status. A different prefix from the
-* per-session status on purpose: one decoder must never read the other's text.
-*/
-const GLOBAL_STATUS_PREFIX = "pause all: ";
-/** Encode one list field. */
-function encodeNames(names) {
-	return names.length === 0 ? EMPTY_FIELD : names.map(escapeField).join(", ");
-}
-/**
-* Encode one optional session id: the empty marker when the park names none.
-* @param id - the session id, as the host holds it.
-* @returns the id as it appears inside an encoded field.
-*/
-function encodeId(id) {
-	return id === void 0 ? EMPTY_FIELD : escapeField(id);
-}
-/**
-* Encode one whole-app status for a command result.
-* @param status - the state to publish.
-* @returns the result text, e.g.
-* `pause all: waiting; registered: 3; safe: 1; parked-at: overnight; draining: overnight; parking: 1; stalled: -; unresumable: -; unread-trees: -; jobs: bash-1; blind: -`.
-*/
-function encodeGlobalStatus(status) {
-	return `${GLOBAL_STATUS_PREFIX}${status.verdict}; registered: ${status.registered}; safe: ${status.safe}; parked-at: ${encodeId(status.parkedAt)}; draining: ${encodeNames(status.draining)}; parking: ${status.parking}; stalled: ${encodeNames(status.stalled)}; unresumable: ${encodeNames(status.unresumable)}; unread-trees: ${encodeNames(status.unreadTrees)}; jobs: ${encodeNames(status.jobs)}; blind: ${encodeNames(status.blind)}`;
-}
-/**
-* First token of every encoded decision list. Separate from the per-session and
-* whole-app status prefixes on purpose, for the same reason those two are
-* separate: one decoder must never read another's text.
-*/
-const TRIAGE_PREFIX = "pause triage: ";
-/** How one row is spelled in the published list; the wake field's state when the host can hand over the owed request. */
-const WAKE_YES = "yes";
-/** One row's traces, as a list of `tool/callId` items. */
-function encodeTraces(traces) {
-	if (traces.length === 0) return EMPTY_FIELD;
-	return traces.map((trace) => `${escapeField(trace.tool)}/${escapeField(trace.callId)}`).join(", ");
-}
-/** One row's stop position, encoded as `<last event>` plus the step it belongs to. */
-function encodeStop(row) {
-	if (row.lastEvent === void 0) return EMPTY_FIELD;
-	const position = row.turn === void 0 ? "" : `/turn ${String(row.turn)}${row.step === void 0 ? "" : ` step ${String(row.step)}`}`;
-	return `${escapeField(row.lastEvent)}${position}`;
-}
-/**
-* Encode one decision list for a command result.
-* @param list - the rows to publish.
-* @returns the result text, e.g. `pause triage: 1; row: overnight; phase: draining; stopped: tool/call/turn 1 step 1; tools: gated; wake: yes`.
-*/
-function encodeTriageList(list) {
-	const head = `${TRIAGE_PREFIX}${String(list.rows.length)}`;
-	return list.rows.reduce((text, row) => {
-		const stopped = row.reading === "unreadable" ? "unreadable" : encodeStop(row);
-		return `${text}; row: ${escapeField(row.sessionId)}; phase: ${row.phase}; stopped: ${stopped}; traces: ${row.reading === "unreadable" ? EMPTY_FIELD : encodeTraces(row.traces)}; tools: ${row.reading === "unreadable" || row.traces.length === 0 ? EMPTY_FIELD : encodeNames(row.traces.map((trace) => trace.tool))}; owed: ${row.owed ? WAKE_YES : "no"}; wake: ${row.wakeable ? WAKE_YES : "no"}; goal: ${row.rearmGoal ? GOAL_ON : GOAL_OFF}`;
-	}, head);
-}
 //#endregion
 //#region lib/types/coldlog.js
 /**
@@ -316,7 +154,7 @@ function encodeTriageList(list) {
 * 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
@@ -355,8 +193,9 @@ const TRIAGE_WINDOW_EVENTS = 2e3;
 const TRIAGE_LOG_MAX_EVENTS = 1e6;
 /**
 * Events that are not the session's own story: the bookkeeping of the pause
-* command the user pressed, and the pending-input splices the inbox writes.
-* They are real and durable, but "it stopped right after `/pause` finished"
+* legacy command records a previous surface wrote, and the pending-input
+* splices the inbox writes. They are real and durable, but "it stopped right
+* after the action finished"
 * is not what "where did it stop" means.
 */
 const BOOKKEEPING_EVENTS = /* @__PURE__ */ new Set([
@@ -530,7 +369,7 @@ async function eventCount(handle, signal) {
 		if (await reaches(handle, mid, signal)) low = mid;
 		else high = mid;
 	}
-	return low;
+	return await reaches(handle, 0, signal) ? low + 1 : 0;
 }
 /**
 * Read one session's stored log, bounded to the events the list's facts need.
@@ -579,155 +418,6 @@ async function coldRead(ctx, sessionId, windowEvents = TRIAGE_WINDOW_EVENTS, sig
 	}
 }
 //#endregion
-//#region lib/types/composition.js
-/**
-* Rebuild the scoped Agent composition a parked Session ran under.
-*
-* 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.
-*
-* 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.
-* @module dsh-pause-session/composition
-*/
-/**
-* 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.
-*/
-var UnresumableSessionError = class extends Error {
-	constructor(sessionId) {
-		super(`subagent session "${String(sessionId)}" has a one-shot route and cannot be resumed`);
-		this.name = "UnresumableSessionError";
-	}
-};
-/**
-* 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.
-*/
-function hasIndependentPresetSelection(events) {
-	for (const event of events) {
-		if (event.type === "subagent/descriptor") return false;
-		if (event.type === "agent-preset/selected") return true;
-	}
-	return false;
-}
-/**
-* Whether a local Session may be parked under a promise of a later resume.
-*
-* A normal root Session has no child descriptor and is resumable. A local
-* subagent child is resumable only when its own durable descriptor is
-* `continuable`; a historical `one-shot` child is terminal and must never be
-* registered as a park the morning path would later have to refuse. External
-* executions have no local Session, so callers never reach this check.
-*
-* A profile without the optional Session-query service cannot prove the
-* descriptor's mode; it keeps the previous permissive behavior rather than
-* dropping every subagent. The web profile mounts the query service.
-* @param ctx - host context carrying the optional Session-query service.
-* @param sessionId - the local Session to inspect.
-* @param signal - cancellation for the observation read.
-* @returns whether a park of this Session may be resumed.
-* @throws the cancellation reason when `signal` aborts the read.
-*/
-async function isResumableSession(ctx, sessionId, signal) {
-	const query = ctx.get("sessionQuery");
-	if (query === void 0) return true;
-	const observation = await query.observeSession(sessionId, { ...signal === void 0 ? {} : { signal } });
-	try {
-		return foldSubagentDescriptor(observation.events.slice(observation.inheritedEventCount))?.mode !== "one-shot";
-	} finally {
-		observation[Symbol.dispose]();
-	}
-}
-/**
-* Read one parked Session's stored composition and build the resume options.
-*
-* 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.
-* @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.
-*/
-async function restoreComposition(ctx, sessionId, parent, signal) {
-	const presets = ctx.get("agentPresets");
-	const query = ctx.get("sessionQuery");
-	if (query === void 0) {
-		if (presets !== void 0) throw new Error("resuming a composed Agent requires the session-query service");
-		return {};
-	}
-	const observation = await query.observeSession(sessionId, { ...signal === void 0 ? {} : { signal } });
-	try {
-		const projections = observation.projections;
-		const ownEvents = observation.events.slice(observation.inheritedEventCount);
-		const descriptor = foldSubagentDescriptor(ownEvents);
-		if (descriptor?.mode === "one-shot") throw new UnresumableSessionError(sessionId);
-		if (presets === void 0 || projections === void 0) {
-			if (presets !== void 0) throw new Error("resuming a composed Agent requires projected Session state");
-			return {};
-		}
-		if (parent === void 0) {
-			const resolved = await presets.resolve(projections.values.agentPreset ?? void 0);
-			return { setup: async (agentCtx) => {
-				await presets.mount(agentCtx, resolved.id);
-			} };
-		}
-		const independentlySelected = hasIndependentPresetSelection(ownEvents);
-		const presetId = independentlySelected ? projections.values.agentPreset : void 0;
-		if (independentlySelected && typeof presetId !== "string") throw new Error(`subagent "${String(sessionId)}" has no projected agent preset to restore`);
-		const composition = {
-			...typeof presetId === "string" ? { agentPreset: presetId } : {},
-			...descriptor?.mode === "continuable" && descriptor.persona !== void 0 ? { persona: descriptor.persona } : {},
-			...descriptor?.mode === "continuable" && descriptor.toolFilter !== void 0 ? { toolFilter: descriptor.toolFilter } : {}
-		};
-		const agentOptions = descriptor?.mode === "continuable" ? {
-			...descriptor.agentProvider === void 0 ? {} : { provider: descriptor.agentProvider },
-			...descriptor.agentModel === void 0 ? {} : { model: descriptor.agentModel },
-			...descriptor.agentReasoningEffort === void 0 ? {} : { reasoningEffort: descriptor.agentReasoningEffort }
-		} : void 0;
-		return {
-			...agentOptions === void 0 ? {} : { agentOptions },
-			setup: async (agentCtx) => {
-				await applyChildComposition(agentCtx, parent, composition);
-			}
-		};
-	} finally {
-		observation[Symbol.dispose]();
-	}
-}
-//#endregion
 //#region lib/types/tree.js
 /**
 * One session's subagent tree, read from the parent catalogs.
@@ -830,11 +520,16 @@ async function walkDescendants(ctx, rootSessionId, signal) {
 */
 const PRESS_ROUNDS = 4;
 /** Fold one shared tree walk into the two doubts this report publishes. */
-function readingOf(walk) {
+function readingOf(walk, watch) {
 	return {
 		members: walk.members.map((member) => member.id),
 		unresumable: walk.members.some((member) => member.mode !== "continuable") || walk.unread.some((branch) => branch.reason === "unsupported"),
-		unread: walk.unreadWhole || walk.unread.some((branch) => branch.reason !== "unsupported")
+		unread: walk.unreadWhole || walk.unread.some((branch) => branch.reason !== "unsupported"),
+		running: walk.members.some((member) => {
+			if (member.mode === "continuable") return false;
+			const activity = watch.activity(member.id);
+			return activity.turnOpen || activity.runningTools.length > 0;
+		})
 	};
 }
 /**
@@ -853,6 +548,7 @@ function mountGlobalPause(ctx, watch, registry, deps) {
 	* instead of quietly leaving them out of a park it then calls safe.
 	*/
 	const unrecorded = /* @__PURE__ */ new Set();
+	const notResumable = /* @__PURE__ */ new Set();
 	/** Record or clear one session's "pressed and the registry refused" state. */
 	const markUnrecorded = (sessionId, flag) => {
 		if (flag) unrecorded.add(sessionId);
@@ -879,15 +575,18 @@ function mountGlobalPause(ctx, watch, registry, deps) {
 	* answer; the cache keeps that read from repeating a catalog round-trip it
 	* has already paid for.
 	*/
-	const walkTree = async (sessionId, signal) => {
+	const walkTree = async (sessionId, signal, shared) => {
 		signal?.throwIfAborted();
+		const provided = shared?.get(sessionId);
+		if (provided !== void 0) return readingOf(provided, watch);
 		const cached = walks.get(sessionId);
 		if (cached !== void 0) return cached;
 		const reading = ctx.get("subagents") === void 0 ? {
 			members: [],
 			unresumable: false,
-			unread: true
-		} : readingOf(await walkDescendants(ctx, sessionId, signal));
+			unread: true,
+			running: false
+		} : readingOf(await walkDescendants(ctx, sessionId, signal), watch);
 		walks.set(sessionId, reading);
 		return reading;
 	};
@@ -934,7 +633,7 @@ function mountGlobalPause(ctx, watch, registry, deps) {
 	* The park also names the session it belongs to, so a client can address its
 	* reads there rather than at whatever session it is showing.
 	*/
-	const status = async (signal) => {
+	const status = async (signal, sharedWalks) => {
 		const phases = /* @__PURE__ */ new Map();
 		for (const [sessionId, record] of registry.parked) phases.set(sessionId, {
 			phase: record.phase,
@@ -968,7 +667,7 @@ function mountGlobalPause(ctx, watch, registry, deps) {
 		const unreadTrees = [];
 		const owners = [...phases.keys()];
 		const parkedAt = owners.find((sessionId) => !unheld.has(sessionId)) ?? owners[0];
-		const trees = await Promise.all(owners.map(async (sessionId) => [sessionId, await walkTree(sessionId, signal)]));
+		const trees = await Promise.all(owners.map(async (sessionId) => [sessionId, await walkTree(sessionId, signal, sharedWalks)]));
 		for (const [sessionId, tree] of trees) {
 			if (tree.unresumable) unresumable.push(String(sessionId));
 			if (tree.unread) unreadTrees.push(String(sessionId));
@@ -978,14 +677,14 @@ function mountGlobalPause(ctx, watch, registry, deps) {
 		if (ctx.get("jobs") === void 0) blind.push("jobs");
 		const registered = phases.size;
 		return {
-			verdict: registered === 0 ? "idle" : safe === registered && unreadTrees.length === 0 ? "safe" : "waiting",
+			verdict: registered === 0 ? "idle" : safe === registered && unreadTrees.length === 0 && !trees.some(([, tree]) => tree.running) ? "safe" : "waiting",
 			registered,
 			safe,
 			...parkedAt === void 0 ? {} : { parkedAt: String(parkedAt) },
 			draining: draining.sort(),
 			parking,
 			stalled: stalled.sort(),
-			unresumable: unresumable.sort(),
+			unresumable: [...new Set(unresumable)].sort(),
 			unreadTrees: unreadTrees.sort(),
 			jobs: liveJobs(owners),
 			blind
@@ -1000,104 +699,197 @@ function mountGlobalPause(ctx, watch, registry, deps) {
 					signal?.throwIfAborted();
 					switch (await deps.press(sessionId, signal)) {
 						case "registered":
+							notResumable.delete(sessionId);
 							markUnrecorded(sessionId, false);
 							deps.look(sessionId);
 							break;
 						case "unrecordable":
 							markUnrecorded(sessionId, true);
 							break;
+						case "not-resumable":
+							notResumable.add(sessionId);
+							break;
 						default: break;
 					}
 				}
 			}
-			const answer = encodeGlobalStatus(await status(signal));
-			return unrecorded.size === 0 ? {
+			const aggregate = await status(signal);
+			const answer = aggregate.verdict === "safe" ? "Every session is paused." : aggregate.verdict === "idle" ? "Nothing is running." : "Pausing is in progress.";
+			const blocked = notResumable.size;
+			return unrecorded.size === 0 && blocked === 0 ? {
 				kind: "success",
 				text: answer
 			} : {
 				kind: "error",
-				text: answer
+				text: `${answer} ${String(blocked)} session${blocked === 1 ? "" : "s"} could not be paused because its route is not resumable.`
 			};
 		},
-		readStatus: async (signal) => ({
-			kind: "success",
-			text: encodeGlobalStatus(await status(signal))
-		}),
+		readState: async (signal, walks) => await status(signal, walks),
 		markUnrecorded
 	};
 }
 //#endregion
-//#region lib/types/resume.js
+//#region lib/types/release-order.js
 /**
-* The clean resume path: bring back a session a previous process parked, and
-* let it answer the input that was already pending when it stopped.
+* The order a batch release walks: parent before child, shallowest first.
 *
-* A resume invents no turn. At the park point the loop had claimed the
-* session's pending input onto the surface and built the request the gate then
-* held; after a restart that input is still the last thing the session says and
-* the model still owes it an answer. What is missing is only a reason for the
-* loop to build a request again, and the documented way to ask for one is a
-* wake input — a user message the loop claims.
+* 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
+*/
+/**
+* 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.
+*/
+async function releaseOrder(ctx, sessionIds, signal) {
+	const depth = /* @__PURE__ */ new Map();
+	const subagents = ctx.get("subagents");
+	if (subagents !== void 0) {
+		const owned = new Set(sessionIds);
+		for (const sessionId of sessionIds) {
+			signal?.throwIfAborted();
+			if (depth.has(sessionId)) continue;
+			depth.set(sessionId, 0);
+			try {
+				for (const row of await subagents.listDescendants(sessionId, signal)) {
+					if (row.kind !== "child" || !owned.has(row.id)) continue;
+					depth.set(row.id, row.depth);
+				}
+			} catch (error) {
+				if (signal?.aborted === true) throw error;
+				ctx.logger.warn(`pause: could not read the descendants of "${sessionId}": ${describeError(error)}`);
+			}
+		}
+	}
+	const levels = /* @__PURE__ */ new Map();
+	for (const sessionId of sessionIds) {
+		const level = depth.get(sessionId) ?? 0;
+		const bucket = levels.get(level);
+		if (bucket === void 0) levels.set(level, [sessionId]);
+		else bucket.push(sessionId);
+	}
+	return { levels: [...levels.keys()].sort((left, right) => left - right).map((level) => levels.get(level) ?? []) };
+}
+//#endregion
+//#region lib/types/composition.js
+/**
+* What a parked Session needs to come back as itself.
 *
-* The wake is invisible only on the routes the composition declares in
-* `silentWakeRoutes`, whose conversion drops an empty user message. On every
-* other route the loop's request carries one visible marker instead, and the
-* marker reaches the model; that is an accepted cost of resuming at all.
-* Whether an empty user message survives is a property of the route's
-* conversion rather than of the loop, so the route is resolved per session —
-* from the request header the session itself persisted.
+* 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 wake message is attributed to this plugin, never to the user: it is text
-* this module synthesized on the session's behalf, in the session's own log and
-* in front of the model, and a downstream consumer has to be able to tell it
-* apart from something the human typed.
+* 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
+*/
+/**
+* Whether a local Session may be parked under a promise of a later resume.
 *
-* Only a cleanly parked session takes this path. A record that never reached
-* the park point, or whose flush did not finish, describes work whose durable
-* state nobody knows; waking it would spend its owner's money on a guess, and
-* deciding those sessions is the morning list's job, not this path's. That
-* holds whether or not the recorded session happens to be live in this process:
-* liveness is not the park outcome, and a session can be live without ever
-* having stopped.
-* @module dsh-pause-session/resume
+* A normal root Session has no child descriptor and is resumable. A local
+* subagent child is resumable only when its own durable descriptor is
+* `continuable`; a historical `one-shot` child is terminal and must never be
+* registered as a park the morning path would later have to refuse. External
+* executions have no local Session, so callers never reach this check.
+*
+* A profile without the optional Session-query service cannot prove the
+* descriptor's mode; it keeps the previous permissive behavior rather than
+* dropping every subagent. The web profile mounts the query service.
+* @param ctx - host context carrying the optional Session-query service.
+* @param sessionId - the local Session to inspect.
+* @param signal - cancellation for the observation read.
+* @returns whether a park of this Session may be resumed.
+* @throws the cancellation reason when `signal` aborts the read.
+*/
+async function isResumableSession(ctx, sessionId, signal) {
+	const query = ctx.get("sessionQuery");
+	if (query === void 0) return true;
+	const observation = await query.observeSession(sessionId, { ...signal === void 0 ? {} : { signal } });
+	try {
+		return foldSubagentDescriptor(observation.events.slice(observation.inheritedEventCount))?.mode !== "one-shot";
+	} finally {
+		observation[Symbol.dispose]();
+	}
+}
+/**
+* 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.
+*
+* 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 signal - cancellation for the observation read.
+* @returns how this Session comes back.
+* @throws when a mounted preset roster cannot read the Session projection.
+*/
+async function readParkedComposition(ctx, sessionId, signal) {
+	const presets = ctx.get("agentPresets");
+	const query = ctx.get("sessionQuery");
+	if (query === void 0) {
+		if (presets !== void 0) throw new Error("resuming a composed Agent requires the session-query service");
+		return { kind: "root" };
+	}
+	const observation = await query.observeSession(sessionId, { ...signal === void 0 ? {} : { signal } });
+	try {
+		if (foldSubagentDescriptor(observation.events.slice(observation.inheritedEventCount)) !== void 0 || observation.header.origin === "subagent") return { kind: "child" };
+		if (presets === void 0) return { kind: "root" };
+		const projections = observation.projections;
+		if (projections === void 0) throw new Error("resuming a composed Agent requires projected Session state");
+		const resolved = await presets.resolve(projections.values.agentPreset ?? void 0);
+		return {
+			kind: "root",
+			setup: async (agentCtx) => {
+				await presets.mount(agentCtx, resolved.id);
+			}
+		};
+	} finally {
+		observation[Symbol.dispose]();
+	}
+}
+//#endregion
+//#region lib/types/resume-text.js
+/**
+* User-facing copy and result shapes for the clean resume and tree release.
+* @module dsh-pause-session/resume-text
 */
 /**
-* The one wake content a route that keeps an empty user message is given. It
-* names its producer, because it lands in the same user turn as the input the
-* model owes an answer to and must not read as part of it.
+* The one wake content a route that keeps an empty user message is given.
 */
 const WAKE_MARKER = "[pause: resumed from a pause]";
 /** Result copy for a resumed session; the model never sees it. */
 const RESUMED_TEXT = "This session resumed from where it paused.";
-/**
-* Result copy for a registered session this path refuses: its durable state is
-* not the outcome of a completed park, so waking it would be a guess.
-*/
+/** Result copy for a registered session whose park did not finish cleanly. */
 const UNCLEAN_TEXT = "pause did not resume this session: its pause did not finish cleanly, so it needs your decision.";
 /** Result copy when nothing is parked under that session. */
 const NOT_PARKED_TEXT = "pause has no pause recorded for this session.";
 /** Result copy for a session that is parked but could not be loaded back. */
 const ACTIVATION_FAILED_TEXT = "pause could not reopen this session, so it stayed paused.";
-/** Result copy for a one-shot subagent route: its Session exists, but no resume may reactivate it. */
+/** Result copy for a one-shot subagent route. */
 const UNRESUMABLE_TEXT = "pause did not resume this session: it is a one-shot subagent route and cannot be resumed.";
-/**
-* Result copy for the review decision. It is the one answer that promises
-* nothing happened, because opening a session to read it is the user's own
-* action in their session list — and activating its agent here would start a
-* session they asked only to look at.
-*/
+/** Result copy for the review decision. */
 const REVIEW_TEXT = "pause did not activate this session: it is still parked, and nothing was sent to a model. Open it from your session list when you want to read it.";
-/** Result copy for a change the durable registry refused to record. */
-const UNRECORDED_TEXT$1 = "pause could not write the pause registry, so it did not change the pause state.";
 /** Copy for one goal opt-out change. */
 const REARM_GOAL_ON_TEXT = "pause will re-open this session's goal when it resumes it.";
 const REARM_GOAL_OFF_TEXT = "pause will leave this session's goal closed when it resumes it.";
 /**
-* How one tree-wide release answers the person who pressed it. One release, one
-* sentence about all of it: what came back, and — by name, because those rows
-* are what the morning list is for — what did not.
+* How one tree-wide release answers the person who pressed it.
 * @param released - the sessions this release covered, in release order.
-* @returns the result text, e.g. `pause resumed 2 sessions from where they stopped; "child" did not pause completely`.
+* @returns one sentence about what came back and what did not.
 */
 function summarizeTreeRelease(released) {
 	const resumed = released.filter((attempt) => attempt.resumed).length;
@@ -1107,30 +899,32 @@ function summarizeTreeRelease(released) {
 	const named = refused.filter((attempt) => attempt.refusal === "not-clean").map((attempt) => `"${String(attempt.sessionId)}"`);
 	return `${head}; ${named.length === 0 ? `${String(refused.length)} could not be resumed` : refused.length === named.length ? `${named.join(", ")} did not pause completely` : `${named.join(", ")} did not pause completely, and ${String(refused.length - named.length)} more could not be resumed`}.`;
 }
+//#endregion
+//#region lib/types/resume-activation.js
 /**
-* Build the clean resume path.
-* @param ctx - host context carrying the agent store, the session store, and the goal service when one is mounted.
-* @param gate - the pause gate the resume releases.
-* @param registry - the durable list this path reads and forgets from.
-* @param options - the route knowledge the wake content depends on.
-* @param deps - the control-owned release order and the adopted-pause fact.
-* @returns the path the session control exposes.
+* Reactivate one parked Session and deliver the wake it owes.
+*
+* The two Session kinds come back through different owners. An ordinary
+* Session is loaded by this plugin and given the route its own log recorded.
+* A subagent child belongs to the subagent runtime: delivering the wake through
+* `ctx.subagents.prompt` is what cold-resumes it as a managed activation, under
+* its live tree root, with its persisted composition and tree membership
+* restored by the runtime itself.
+*
+* Both paths keep the same release order: the durable record goes first, then
+* the gate, so a record that cannot be dropped leaves the Session parked.
+* @module dsh-pause-session/resume-activation
 */
-function installResumePath(ctx, gate, registry, options, deps) {
-	/** The route the session's next request will use, as its own log recorded it. */
+/**
+* Build the activation closure.
+* @param ctx - host context carrying the agent store, subagent runtime, 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 root wake content depends on.
+* @returns the activation methods the resume path uses.
+*/
+function createActivator(ctx, gate, registry, options) {
 	const routeOf = (session) => session.requestHeader()?.config;
-	/**
-	* Give an agent that was loaded back without one the route its own log
-	* recorded. The loop refuses to build a request without a provider and model,
-	* and the persisted header is what the app's own activation path uses too, so
-	* this resumes onto the route the session stopped on.
-	*
-	* 0.2.2 replaced the installed route selection with the durable model-selection
-	* fold: `agent.model.current()` already returns a route replayed from the
-	* Session's own request headers, and `select()` records the header's route when
-	* that fold and the Agent options are both empty. The old per-agent
-	* `installModelSelection(agentCtx, selection)` no longer accepts a selection.
-	*/
 	const ensureRoute = (agent) => {
 		if (agent.model.current() !== void 0) return;
 		const config = routeOf(agent.session);
@@ -1141,22 +935,10 @@ function installResumePath(ctx, gate, registry, options, deps) {
 			...config.reasoningEffort === void 0 ? {} : { reasoningEffort: config.reasoningEffort }
 		});
 	};
-	/** What one wake input carries for the route in use. */
 	const wakeContent = (provider) => options.silentWakeRoutes.includes(provider) ? [] : [{
 		type: "text",
 		text: WAKE_MARKER
 	}];
-	/**
-	* Ask the loop for the request it owes this session. Nothing is woken when a
-	* request is already standing at the gate or the loop is already running: the
-	* continuation is in flight, and a second wake would duplicate it. The content
-	* is the route's business only for the silent wake; a note is the user's
-	* decision and goes on the wire as written, on every route. Either way the
-	* message is attributed to this plugin: the wake is this path speaking on the
-	* session's behalf, not the user's own input.
-	* @param agent - the live agent to wake.
-	* @param request - which wake this resume delivers.
-	*/
 	const wake = (agent, request) => {
 		if (request.kind === "none") return;
 		if (gate.isHeld(agent.id) || agent.status !== "idle") return;
@@ -1172,16 +954,6 @@ function installResumePath(ctx, gate, registry, options, deps) {
 			source: { kind: "pause" }
 		}));
 	};
-	/**
-	* Re-open one session's goal. Activation is process-local and is not part of
-	* the durable goal, so a restart leaves a healthy goal disarmed; only that
-	* case is repaired here. A goal the owner paused, blocked, or completed is a
-	* decision, and this path does not take decisions back. The wake (when there
-	* is one) runs first on purpose: the goal round driver queues the next round
-	* as soon as the agent is idle, and that round must not join the request that
-	* is answering the input already pending.
-	* @param agent - the agent whose goal may be re-armed.
-	*/
 	const rearmGoal = (agent) => {
 		const goals = ctx.get("goals");
 		if (goals === void 0) return;
@@ -1197,44 +969,29 @@ function installResumePath(ctx, gate, registry, options, deps) {
 			ctx.logger.warn(`pause: could not re-open the goal of "${agent.id}": ${describeError(error)}`);
 		}
 	};
-	/**
-	* Load one parked session back from its stored log and hand it the request it
-	* stopped in front of. The pause is not released until the durable record is
-	* gone, so a record that cannot be dropped leaves the session parked rather
-	* than silently running.
-	*
-	* Activation is what makes a session run again, so nothing but a resume does
-	* it: the review answer never reaches this function.
-	* @param sessionId - the parked session to bring back.
-	* @param request - which wake the decision delivers; see {@link WakeRequest}.
-	* @param rearm - whether the record's goal opt-out allows re-opening its goal.
-	* @param parentId - the direct parent a batch release already brought back,
-	* when there is one. A subagent child resumed under its live parent is the
-	* shape the harness's own cold resume uses; with no live parent the session
-	* comes back on its own, which is all that can be done with it.
-	* @param signal - cancellation for the stored composition read and load.
-	*/
-	const activate = async (sessionId, request, rearm, parentId, signal) => {
-		const parent = parentId === void 0 ? void 0 : ctx.agents.get(parentId);
+	/** Drop the durable record, then the gate: the order every release keeps. */
+	const releaseRecord = async (sessionId) => {
+		try {
+			await registry.forget(sessionId);
+		} catch (error) {
+			ctx.logger.warn(`pause: could not drop "${sessionId}" from the pause registry: ${describeError(error)}`);
+			return {
+				kind: "error",
+				text: UNRECORDED_TEXT
+			};
+		}
+		gate.resume(sessionId);
+	};
+	/** Load an ordinary Session, give it its recorded route, and deliver the wake. */
+	const activateRoot = async (sessionId, request, rearm, composition, signal) => {
 		let agent;
 		try {
-			const composition = await restoreComposition(ctx, sessionId, parent, signal);
 			agent = (await ctx.root.agents.resume({
 				resumeSessionId: sessionId,
-				...parent === void 0 ? {} : { parentAgent: parent },
-				...composition,
+				...composition.setup === void 0 ? {} : { setup: composition.setup },
 				...signal === void 0 ? {} : { signal }
 			})).agent;
 		} catch (error) {
-			if (error instanceof UnresumableSessionError) return {
-				sessionId,
-				resumed: false,
-				refusal: "unresumable",
-				answer: {
-					kind: "error",
-					text: UNRESUMABLE_TEXT
-				}
-			};
 			ctx.logger.warn(`pause: could not open "${sessionId}" from its stored log: ${describeError(error)}`);
 			return {
 				sessionId,
@@ -1248,22 +1005,78 @@ function installResumePath(ctx, gate, registry, options, deps) {
 		}
 		ensureRoute(agent);
 		wake(agent, request);
-		try {
-			await registry.forget(sessionId);
-		} catch (error) {
-			ctx.logger.warn(`pause: could not drop "${sessionId}" from the pause registry: ${describeError(error)}`);
-			return {
-				sessionId,
-				resumed: false,
-				refusal: "unrecorded",
+		const refused = await releaseRecord(sessionId);
+		if (refused !== void 0) return {
+			sessionId,
+			resumed: false,
+			refusal: "unrecorded",
+			answer: refused
+		};
+		if (rearm) rearmGoal(agent);
+		return {
+			sessionId,
+			resumed: true,
+			answer: {
+				kind: "success",
+				text: RESUMED_TEXT
+			}
+		};
+	};
+	/**
+	* Hand a subagent child the wake through the subagent runtime.
+	*
+	* The runtime owns the activation, so it is also the only thing that can
+	* cold-resume the child under its live tree root. An empty message would be
+	* dropped by a route whose conversion discards it, and the route is unknown
+	* before the child is live, so the marker is the content that always wakes it.
+	*/
+	const activateChild = async (sessionId, request, rearm, signal) => {
+		const subagents = ctx.get("subagents");
+		if (subagents === void 0) {
+			ctx.logger.warn(`pause: subagent runtime is not mounted; opening "${sessionId}" as a root Session`);
+			return await activateRoot(sessionId, request, rearm, { kind: "root" }, signal);
+		}
+		const content = [{
+			type: "text",
+			text: request.kind === "message" ? request.text : WAKE_MARKER
+		}];
+		try {
+			await subagents.prompt({
+				requestId: randomUUID(),
+				childSessionId: sessionId,
+				delivery: "queue",
+				content
+			}, signal ?? new AbortController().signal);
+		} catch (error) {
+			if (remoteErrorOf(error)?.code === "subagent/not-resumable") return {
+				sessionId,
+				resumed: false,
+				refusal: "unresumable",
 				answer: {
 					kind: "error",
-					text: UNRECORDED_TEXT$1
+					text: UNRESUMABLE_TEXT
+				}
+			};
+			ctx.logger.warn(`pause: could not continue subagent "${sessionId}": ${describeError(error)}`);
+			return {
+				sessionId,
+				resumed: false,
+				refusal: "activation-failed",
+				answer: {
+					kind: "error",
+					text: ACTIVATION_FAILED_TEXT
 				}
 			};
 		}
-		gate.resume(sessionId);
-		if (rearm) rearmGoal(agent);
+		const refused = await releaseRecord(sessionId);
+		if (refused !== void 0) return {
+			sessionId,
+			resumed: false,
+			refusal: "unrecorded",
+			answer: refused
+		};
+		const agent = ctx.agents.get(sessionId);
+		if (rearm && agent !== void 0) rearmGoal(agent);
 		return {
 			sessionId,
 			resumed: true,
@@ -1273,6 +1086,78 @@ function installResumePath(ctx, gate, registry, options, deps) {
 			}
 		};
 	};
+	const activate = async (sessionId, request, rearm, signal) => {
+		let composition;
+		try {
+			composition = await readParkedComposition(ctx, sessionId, signal);
+		} catch (error) {
+			ctx.logger.warn(`pause: could not read the composition of "${sessionId}": ${describeError(error)}`);
+			return {
+				sessionId,
+				resumed: false,
+				refusal: "activation-failed",
+				answer: {
+					kind: "error",
+					text: ACTIVATION_FAILED_TEXT
+				}
+			};
+		}
+		return composition.kind === "child" ? await activateChild(sessionId, request, rearm, signal) : await activateRoot(sessionId, request, rearm, composition, signal);
+	};
+	return {
+		activate,
+		ensureRoute,
+		wake,
+		rearmGoal
+	};
+}
+//#endregion
+//#region lib/types/resume.js
+/**
+* The clean resume path: bring back a session a previous process parked, and
+* let it answer the input that was already pending when it stopped.
+*
+* A resume invents no turn. At the park point the loop had claimed the
+* session's pending input onto the surface and built the request the gate then
+* held; after a restart that input is still the last thing the session says and
+* the model still owes it an answer. What is missing is only a reason for the
+* loop to build a request again, and the documented way to ask for one is a
+* wake input — a user message the loop claims.
+*
+* The wake is invisible only on the routes the composition declares in
+* `silentWakeRoutes`, whose conversion drops an empty user message. On every
+* other route the loop's request carries one visible marker instead, and the
+* marker reaches the model; that is an accepted cost of resuming at all.
+* Whether an empty user message survives is a property of the route's
+* conversion rather than of the loop, so the route is resolved per session —
+* from the request header the session itself persisted.
+*
+* The wake message is attributed to this plugin, never to the user: it is text
+* this module synthesized on the session's behalf, in the session's own log and
+* in front of the model, and a downstream consumer has to be able to tell it
+* apart from something the human typed.
+*
+* Only a cleanly parked session takes this path. A record that never reached
+* the park point, or whose flush did not finish, describes work whose durable
+* state nobody knows; waking it would spend its owner's money on a guess, and
+* deciding those sessions is the morning list's job, not this path's. That
+* holds whether or not the recorded session happens to be live in this process:
+* liveness is not the park outcome, and a session can be live without ever
+* having stopped.
+* @module dsh-pause-session/resume
+*/
+/**
+* Build the clean resume path.
+* @param ctx - host context carrying the agent store, the session store, and the goal service when one is mounted.
+* @param gate - the pause gate the resume releases.
+* @param registry - the durable list this path reads and forgets from.
+* @param options - the route knowledge the wake content depends on.
+* @param deps - the control-owned release order and the adopted-pause fact.
+* @returns the path the session control exposes.
+*/
+function installResumePath(ctx, gate, registry, options, deps) {
+	/** The route the session's next request will use, as its own log recorded it. */
+	const { activate, ensureRoute, wake, rearmGoal } = createActivator(ctx, gate, registry, options);
 	/**
 	* Load one unclean session back from its stored log.
 	*
@@ -1293,11 +1178,10 @@ function installResumePath(ctx, gate, registry, options, deps) {
 	* @param finalize - whether the decision continues the session (`'release'`)
 	* or only answers it (`'review'`); a review activates nothing and writes
 	* nothing.
-	* @param parentId - the direct parent a batch release already brought back, when there is one.
 	* @param signal - cancellation for the cold load and setup.
 	* @returns what happened, and the copy for whoever asked.
 	*/
-	const decideUnclean = async (sessionId, request, finalize, parentId, signal) => {
+	const decideUnclean = async (sessionId, request, finalize, signal) => {
 		const record = registry.get(sessionId);
 		if (record === void 0) return {
 			sessionId,
@@ -1318,7 +1202,7 @@ function installResumePath(ctx, gate, registry, options, deps) {
 			}
 		};
 		const live = ctx.agents.get(sessionId);
-		if (live === void 0) return await activate(sessionId, request, record.rearmGoal, parentId, signal);
+		if (live === void 0) return await activate(sessionId, request, record.rearmGoal, signal);
 		if (!gate.isPaused(sessionId)) {
 			ensureRoute(live);
 			wake(live, request);
@@ -1332,7 +1216,7 @@ function installResumePath(ctx, gate, registry, options, deps) {
 					refusal: "unrecorded",
 					answer: {
 						kind: "error",
-						text: UNRECORDED_TEXT$1
+						text: UNRECORDED_TEXT
 					}
 				};
 			}
@@ -1375,11 +1259,10 @@ function installResumePath(ctx, gate, registry, options, deps) {
 	* back is the press's own undo, and it delivers no wake.
 	* @param sessionId - the recorded session to resume.
 	* @param request - which wake this resume delivers; see {@link WakeRequest}.
-	* @param parentId - the direct parent a batch release already brought back, when there is one.
 	* @param signal - cancellation for the cold load and setup.
 	* @returns what happened, and the copy for whoever asked.
 	*/
-	const resumeSession = async (sessionId, request, parentId, signal) => {
+	const resumeSession = async (sessionId, request, signal) => {
 		const record = registry.get(sessionId);
 		const live = ctx.agents.get(sessionId);
 		if (live !== void 0) {
@@ -1412,7 +1295,7 @@ function installResumePath(ctx, gate, registry, options, deps) {
 						refusal: "unrecorded",
 						answer: {
 							kind: "error",
-							text: UNRECORDED_TEXT$1
+							text: UNRECORDED_TEXT
 						}
 					};
 				}
@@ -1474,52 +1357,7 @@ function installResumePath(ctx, gate, registry, options, deps) {
 				text: UNCLEAN_TEXT
 			}
 		};
-		return await activate(sessionId, request, record.rearmGoal, parentId, signal);
-	};
-	/**
-	* Order the recorded sessions so a session is released after the parent it
-	* hangs from: waking a child needs its direct parent to be live first. The
-	* relation is read from the parent catalogs themselves (which children this
-	* session actually has), never guessed from ids; a branch whose catalog
-	* cannot be read simply has no known parent and is released with the roots.
-	* @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, shallowest first.
-	*/
-	const releaseOrder = async (sessionIds, signal) => {
-		const owned = new Set(sessionIds);
-		const parentOf = /* @__PURE__ */ new Map();
-		const subagents = ctx.get("subagents");
-		if (subagents !== void 0) for (const sessionId of sessionIds) {
-			signal?.throwIfAborted();
-			try {
-				for (const child of await subagents.listChildren(sessionId, signal)) if (owned.has(child.id)) parentOf.set(child.id, sessionId);
-			} catch (error) {
-				if (signal?.aborted === true) throw error;
-				ctx.logger.warn(`pause: could not read the children of "${sessionId}": ${describeError(error)}`);
-			}
-		}
-		const depthOf = (sessionId) => {
-			let steps = 0;
-			const seen = /* @__PURE__ */ new Set([sessionId]);
-			for (let at = parentOf.get(sessionId); at !== void 0; at = parentOf.get(at)) {
-				if (seen.has(at)) break;
-				seen.add(at);
-				steps += 1;
-			}
-			return steps;
-		};
-		const levels = /* @__PURE__ */ new Map();
-		for (const sessionId of sessionIds) {
-			const level = depthOf(sessionId);
-			const bucket = levels.get(level);
-			if (bucket === void 0) levels.set(level, [sessionId]);
-			else bucket.push(sessionId);
-		}
-		return {
-			parents: parentOf,
-			levels: [...levels.keys()].sort((left, right) => left - right).map((level) => levels.get(level) ?? [])
-		};
+		return await activate(sessionId, request, record.rearmGoal, signal);
 	};
 	return {
 		resumeSession,
@@ -1535,7 +1373,10 @@ function installResumePath(ctx, gate, registry, options, deps) {
 					text: NOT_PARKED_TEXT
 				}
 			};
-			const cancelling = registered.every((member) => registry.get(member)?.phase !== "safe");
+			const cancelling = registered.every((member) => {
+				const record = registry.get(member);
+				return record !== void 0 && record.phase !== "safe" && !deps.adopted(member);
+			});
 			const released = [];
 			if (cancelling) for (const member of registered) {
 				signal?.throwIfAborted();
@@ -1551,27 +1392,22 @@ function installResumePath(ctx, gate, registry, options, deps) {
 					answer
 				});
 			}
-			else {
-				const release = await releaseOrder(registered, signal);
-				for (const level of release.levels) {
-					signal?.throwIfAborted();
-					for (const member of level) {
-						const record = registry.get(member);
-						if (record !== void 0 && record.phase !== "safe") {
-							released.push({
-								sessionId: member,
-								resumed: false,
-								refusal: "not-clean",
-								answer: {
-									kind: "error",
-									text: UNCLEAN_TEXT
-								}
-							});
-							continue;
+			else for (const member of registered) {
+				signal?.throwIfAborted();
+				const record = registry.get(member);
+				if (record !== void 0 && record.phase !== "safe") {
+					released.push({
+						sessionId: member,
+						resumed: false,
+						refusal: "not-clean",
+						answer: {
+							kind: "error",
+							text: UNCLEAN_TEXT
 						}
-						released.push(await resumeSession(member, { kind: "silent" }, release.parents.get(member), signal));
-					}
+					});
+					continue;
 				}
+				released.push(await resumeSession(member, { kind: "silent" }, signal));
 			}
 			const root = released.find((attempt) => attempt.sessionId === sessionId);
 			const refusals = released.filter((attempt) => !attempt.resumed && attempt.refusal !== void 0).map((attempt) => ({
@@ -1592,11 +1428,11 @@ function installResumePath(ctx, gate, registry, options, deps) {
 			};
 		},
 		resumeParked: async (signal) => {
-			const release = await releaseOrder(registry.list().map((entry) => entry.sessionId), signal);
+			const release = await releaseOrder(ctx, registry.list().map((entry) => entry.sessionId), signal);
 			const attempts = [];
 			for (const level of release.levels) {
 				signal?.throwIfAborted();
-				attempts.push(...await Promise.all(level.map((sessionId) => resumeSession(sessionId, { kind: "silent" }, release.parents.get(sessionId), signal))));
+				attempts.push(...await Promise.all(level.map((sessionId) => resumeSession(sessionId, { kind: "silent" }, signal))));
 			}
 			return attempts;
 		},
@@ -1607,7 +1443,7 @@ function installResumePath(ctx, gate, registry, options, deps) {
 				ctx.logger.warn(`pause: could not record the goal opt-out of "${sessionId}": ${describeError(error)}`);
 				return {
 					kind: "error",
-					text: UNRECORDED_TEXT$1
+					text: UNRECORDED_TEXT
 				};
 			}
 			return {
@@ -1632,8 +1468,8 @@ function installResumePath(ctx, gate, registry, options, deps) {
 * stored log through a read handle that claims no ownership and writes nothing,
 * so asking what happened cannot itself change what happened.
 *
-* WHAT ONE READ COSTS. The list is read again on every command-registry change
-* while the panel is open, and what it publishes is about the end of a log that
+* WHAT ONE READ COSTS. The list is read when the panel opens and when a native
+* action changes the park, and what it publishes is about the end of a log that
 * only grows, so `./coldlog.ts` bounds each row's read to that end. A row whose
 * facts the bound cannot hold reports itself unreadable rather than publishing
 * a fragment.
@@ -1656,10 +1492,10 @@ function installResumePath(ctx, gate, registry, options, deps) {
 * reported; a withheld promise costs a user nothing, a broken one spends their
 * money.
 *
-* WHO MAY DECIDE. A decision names its target as command input, and the command
-* channel carries no origin of its own, so this list acts only on rows its most
-* recent read published to the calling session: the caller's own read is what
-* makes a target actionable. Anything else is refused, not looked up.
+* WHO MAY DECIDE. A decision carries the calling session and its target as wire
+* input, so this list acts only on rows its most recent read published to the
+* calling session: the caller's own read is what makes a target actionable.
+* Anything else is refused, not looked up.
 *
 * TWO OF THE FIVE VERBS PUT THE SESSION BACK ON THE CLEAN PATH. Continue and
 * continue-with-the-note go through `ResumePath.decideUnclean`, which activates
@@ -1677,6 +1513,7 @@ function installResumePath(ctx, gate, registry, options, deps) {
 * parked session.
 * @module dsh-pause-session/triage
 */
+/** Result copy for a decision the list itself could not carry out. */
 /** Result copy for leaving one listed session alone. */
 const TRIAGE_LEFT_TEXT = "pause left this session paused; it is still on the list.";
 /** Result copy for a decision aimed at a session that is not on the list. */
@@ -1686,7 +1523,7 @@ const TRIAGE_NOT_LISTED_TEXT = "pause has no unfinished pause for this session."
 * The list is the only thing that legitimizes a target, so a target nobody read
 * is refused rather than acted on.
 */
-const TRIAGE_UNSHOWN_TEXT = "pause did not act: this Session has not been shown that row. Read the list first (/pause-triage).";
+const TRIAGE_UNSHOWN_TEXT = "pause did not act: this Session has not been shown that row. Read the decision list first.";
 /**
 * Model-facing text that goes with a wake when the user chooses to continue
 * with a note.
@@ -1743,7 +1580,7 @@ function rowOf(ctx, entry, events, complete) {
 function mountTriageList(ctx, registry, resumePath, windowEvents = TRIAGE_WINDOW_EVENTS) {
 	/**
 	* The rows each calling session was last shown by its own read. A decision
-	* names its target as command input, and the command channel carries no
+	* names its target as wire input, and the channel carries no
 	* origin of its own, so this is what ties a target to the list the user read:
 	* only a row this caller has been shown is acted on.
 	*/
@@ -1785,12 +1622,12 @@ function mountTriageList(ctx, registry, resumePath, windowEvents = TRIAGE_WINDOW
 			text: TRIAGE_LEFT_TEXT
 		};
 		if (action === "goal") return await resumePath.setRearmGoal(sessionId, !record.rearmGoal);
-		if (action === "review") return (await resumePath.decideUnclean(sessionId, { kind: "none" }, "review", void 0, signal)).answer;
+		if (action === "review") return (await resumePath.decideUnclean(sessionId, { kind: "none" }, "review", signal)).answer;
 		const wake = action === "continue" ? { kind: "silent" } : {
 			kind: "message",
 			text: UNKNOWN_OUTCOME_NOTE
 		};
-		return (await resumePath.decideUnclean(sessionId, wake, "release", void 0, signal)).answer;
+		return (await resumePath.decideUnclean(sessionId, wake, "release", signal)).answer;
 	};
 	return {
 		read: async (caller, signal) => {
@@ -1806,201 +1643,105 @@ function mountTriageList(ctx, registry, resumePath, windowEvents = TRIAGE_WINDOW
 	};
 }
 //#endregion
-//#region lib/types/control.js
-/**
-* 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`).
-* @module dsh-pause-session/control
-*/
+//#region lib/types/snapshot.js
 /**
-* Result copy for a session that just reached the pause point; the model never
-* sees it. The count is the point: the header control is the user's button for
-* one session's work, and that work includes the subagents under it, so the
-* press must not read as having stopped a single thing.
-* @param agents - how many subagents this press registered alongside the session.
-* @returns the copy for the person who pressed.
+* Pure projection of the durable park and each live tree into the native
+* snapshot. This module owns the phase fold and the goal opt-out; it does not
+* press, release, or decide anything.
+* @module dsh-pause-session/snapshot
 */
-function pausedText(agents) {
-	return `Paused ${agents === 0 ? "this session" : agents === 1 ? "this session and 1 subagent" : `this session and ${String(agents)} subagents`}. A running tool will finish first; no new model request will be sent. Press again to resume.`;
+/** The phase a durable record holds for one session, live or adopted. */
+function recordedPhase(deps, sessionId) {
+	return deps.marks.get(sessionId)?.phase ?? deps.registry.get(sessionId)?.phase;
 }
-/** Result copy for a press or a release the durable registry refused to record. */
-const UNRECORDED_TEXT = "pause could not write the pause registry, so it did not change the pause state.";
-/**
-* What a tree-wide press reports when it could not read the tree. The session
-* itself is paused and says so; its subagents are neither registered nor
-* vouched for, and the answer names that limit rather than letting the session's
-* own park stand for a tree nobody read.
-*/
-const TREE_UNREAD_TEXT = "pause could not read this session's subagent list, so it did not pause its subagents.";
-/** Result copy for a session whose own subagent route is terminal. */
-const NOT_RESUMABLE_PARK_TEXT = "pause did not register this session: its subagent route is one-shot and cannot be resumed.";
-/**
-* Result copy for a tree-wide press that could not record part of the tree.
-* The members it names are still running; the ones it does not are paused.
-* @param names - the members whose park record could not be written.
-* @returns the copy for the person who pressed.
-*/
-function unrecordedTreeText(names) {
-	return `pause could not save the pause for ${names.map((name) => `"${String(name)}"`).join(", ")}; they are still running. Everything else in the tree is paused.`;
+/** Fold one session's mark and its registered descendants into the header reading. */
+async function treeStatus(deps, sessionId, mark, signal, knownWalk) {
+	const walk = knownWalk ?? await walkDescendants(deps.ctx, sessionId, signal);
+	const phases = [mark.phase];
+	const extraRunning = [];
+	for (const member of walk.members) {
+		const phase = recordedPhase(deps, member.id);
+		if (phase !== void 0) {
+			phases.push(phase);
+			continue;
+		}
+		if (member.mode !== "continuable") {
+			const activity = deps.watch.activity(member.id);
+			if (activity.turnOpen || activity.runningTools.length > 0) {
+				phases.push("draining");
+				extraRunning.push(...activity.runningTools);
+			}
+		}
+	}
+	for (let at = 0; at < walk.unread.length + (walk.unreadWhole ? 1 : 0); at += 1) phases.push("parking");
+	const folded = foldTreePhases(phases);
+	const runningTools = [
+		...mark.phase === "draining" ? deps.watch.activity(sessionId).runningTools : [],
+		...walk.members.flatMap((member) => recordedPhase(deps, member.id) === "draining" ? deps.watch.activity(member.id).runningTools : []),
+		...extraRunning
+	];
+	const record = deps.registry.get(sessionId);
+	return {
+		phase: folded.phase,
+		safe: folded.safe,
+		runningTools,
+		...record === void 0 ? {} : { rearmGoal: record.rearmGoal }
+	};
 }
 /**
-* 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.
+* Read every live mark and the whole-app aggregate in one pass.
+* @param deps - the control-owned marks, watch, registry, and aggregate reader.
+* @param signal - cancellation for the tree walks and aggregate.
+* @returns the native snapshot.
 */
-const UNATTENDED_TEXT = "pause did not act: this command came from inside a model turn, and the park verbs act only on a person's command.";
-/**
-* Whether a command is being dispatched from inside a model turn.
-*
-* A person's slash command reaches the registry through the Client's command
-* Remote with no model turn around it; the loop runs every model-driven step —
-* tool calls included — under its own initiator boundary. The invocation itself
-* carries no origin: `command/run` records a constant `{ kind: 'user' }` source
-* for every executor caller. This is therefore the one signal available, and a
-* state-changing verb refuses when it says a model is driving.
-* @param ctx - host context carrying the agent store.
-* @returns whether a model turn is the initiator of this call.
-*/
-function modelIssued(ctx) {
-	try {
-		return ctx.agents.currentInitiator() !== void 0;
-	} catch {
-		return true;
-	}
+async function readSnapshot(deps, signal) {
+	const sessions = {};
+	const walks = /* @__PURE__ */ new Map();
+	await Promise.all([...deps.marks].map(async ([sessionId, mark]) => {
+		const walk = await walkDescendants(deps.ctx, sessionId, signal);
+		if (deps.ctx.get("subagents") !== void 0) walks.set(sessionId, walk);
+		sessions[String(sessionId)] = await treeStatus(deps, sessionId, mark, signal, walk);
+	}));
+	return {
+		global: await deps.readGlobal(signal, walks),
+		sessions
+	};
 }
+//#endregion
+//#region lib/types/park-state.js
 /**
-* Whether this host can read one recorded session at all — a live session, or a
-* stored log the persistence backend can observe.
-* @param ctx - host context carrying the session store and the optional persistence service.
-* @param sessionId - the recorded session to look for.
-* @returns whether the session can be acted on here.
+* 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
 */
-async function sessionReadable(ctx, sessionId) {
-	if (ctx.sessions.get(sessionId) !== void 0) return true;
-	const persistence = ctx.get("sessionPersistence");
-	if (persistence === void 0) return false;
-	try {
-		return await persistence.stat(sessionId) !== void 0;
-	} catch (error) {
-		ctx.logger.warn(`pause: could not look for the stored log of "${sessionId}": ${describeError(error)}`);
-		return true;
-	}
-}
-/** How resuming all parked sessions answers the command that asked for it. */
-function summarizeResume(attempts) {
-	const resumed = attempts.filter((attempt) => attempt.resumed).length;
-	const refused = attempts.length - resumed;
-	const head = resumed === 0 ? "pause resumed no session" : resumed === 1 ? "pause resumed 1 session from where it stopped" : `pause resumed ${resumed} sessions from where they stopped`;
-	if (refused === 0) return `${head}.`;
-	return `${head}; ${attempts.filter((attempt) => attempt.refusal === "not-clean").length === refused ? `${refused} did not pause completely and need your decision` : `${refused} could not be resumed`}.`;
-}
 /**
-* 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
-* 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.
-* @param registry - the durable pause list every phase change is written to.
-* @param options - route knowledge the clean resume path needs, and the decision list's read bound.
-* @returns the mount-time adoption step and the morning resume path.
+* 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.
 */
-function installSessionControl(ctx, gate, watch, registry, options) {
-	/** Marks per paused session; presence here mirrors the gate's own membership. */
+function installParkState(ctx, gate, registry, watch) {
 	const marks = /* @__PURE__ */ new Map();
-	/** Published marker sets per paused session; disposing one removes its three commands. */
-	const markers = /* @__PURE__ */ new Map();
-	/**
-	* Records this process did not hold again because the session behind them
-	* cannot be read here. Nothing can be parked, released, or decided for them
-	* from this process, so they are not marks — and the aggregate names them
-	* instead of counting them among the sessions this park owns.
-	*/
+	const unrecorded = /* @__PURE__ */ new Set();
 	const unheld = /* @__PURE__ */ new Set();
-	/** Bumped by every mark and every cancel; a stale generation publishes nothing. */
+	const listeners = /* @__PURE__ */ new Set();
+	let notification;
 	let generation = 0;
+	/** One snapshot per burst of host changes, not one per phase write. */
+	const notify = () => {
+		if (notification !== void 0) return;
+		notification = setTimeout(() => {
+			notification = void 0;
+			for (const listener of [...listeners]) listener();
+		}, 20);
+	};
 	const drop = (sessionId) => {
 		marks.delete(sessionId);
-		const marker = markers.get(sessionId);
-		if (marker === void 0) return;
-		markers.delete(sessionId);
-		Promise.resolve(marker.fiber.dispose()).catch((error) => {
-			ctx.logger.warn(`pause: session control cleanup failed: ${describeError(error)}`);
-		});
+		notify();
 	};
-	/**
-	* Write one phase to the durable registry, then publish it on the mark and
-	* announce it on the command channel.
-	*
-	* The order is the whole point: a phase is published only once a later
-	* process would read it back. A failed write leaves the mark on its previous
-	* phase, which is never cleaner than what the registry holds — the direction
-	* that matters, because "safe to close" is a promise about surviving the
-	* process, not about this process's memory.
-	*
-	* A phase that actually changed is also the moment every client is owed a
-	* fresh read: the announcement is what carries `parking` → `safe` out of this
-	* process, since the flush that resolves it changes no registration by
-	* itself. Announcing only on a change is also what keeps the channel quiet —
-	* a write that repeats the phase a mark already holds tells a reader nothing,
-	* so it must not cost one.
-	* @param sessionId - the paused session.
-	* @param mark - its live mark, updated in place on success.
-	* @param phase - the phase to record and publish.
-	* @returns whether the phase became durable.
-	*/
 	const commit = async (sessionId, mark, phase) => {
 		try {
 			await registry.record(sessionId, phase);
@@ -2010,124 +1751,14 @@ function installSessionControl(ctx, gate, watch, registry, options) {
 		}
 		const changed = mark.phase !== phase;
 		mark.phase = phase;
-		if (changed) markers.get(sessionId)?.announce();
+		if (changed) notify();
 		return true;
 	};
-	/** Whether this session is standing still at the park point. */
 	const parked = (sessionId) => {
 		const activity = watch.activity(sessionId);
 		if (activity.runningTools.length > 0) return false;
 		return gate.isHeld(sessionId) || !activity.turnOpen;
 	};
-	/**
-	* The phase a durable record holds for one session right now, whether or not
-	* this process holds it. A member whose session this host cannot read still
-	* has a record, and that record is the only thing anyone knows about it.
-	*/
-	const recordedPhase = (sessionId) => marks.get(sessionId)?.phase ?? registry.get(sessionId)?.phase;
-	/**
-	* The state this session's header reports: the worst phase among the members
-	* the session's own press registered, folded with the session's own.
-	*
-	* The control speaks for a tree, so it may not say "safe to close" while a
-	* member of that tree is still draining, stalled, or not readable — the user
-	* would close the lid on work this press started. A branch the walk could not
-	* read may hold a member nobody can see, so an unread branch counts as
-	* unfinished rather than as empty.
-	* @param mark - the session's own mark, whose phase the fold starts from.
-	* @returns the phase to publish and the goal opt-out that rides beside it.
-	*/
-	const treeStatus = async (sessionId, mark, signal) => {
-		const walk = await walkDescendants(ctx, sessionId, signal);
-		const phases = [mark.phase];
-		for (const member of walk.members) {
-			const phase = recordedPhase(member.id);
-			if (phase !== void 0) phases.push(phase);
-		}
-		for (let at = 0; at < walk.unread.length + (walk.unreadWhole ? 1 : 0); at += 1) phases.push("parking");
-		const folded = foldTreePhases(phases);
-		const record = registry.get(sessionId);
-		return {
-			phase: folded.phase,
-			safe: folded.safe,
-			runningTools: mark.phase === "draining" ? watch.activity(sessionId).runningTools : [],
-			...record === void 0 ? {} : { rearmGoal: record.rearmGoal }
-		};
-	};
-	/**
-	* Ensure one paused session has its three verbs registered. Registration is
-	* once per park: the status is answered by the command, not frozen into the
-	* descriptor, so a phase change needs no re-registration to be readable — the
-	* one {@link ParkMarkers.announce} performs is the announcement itself and
-	* nothing more.
-	*/
-	const publish = (sessionId) => {
-		const mark = marks.get(sessionId);
-		if (mark === void 0 || markers.has(sessionId)) return;
-		const agent = ctx.agents.get(sessionId);
-		if (agent === void 0) return;
-		const status = async (signal) => encodeParkStatus(await treeStatus(sessionId, mark, signal));
-		const definition = () => ({
-			definitionId: CommandDefinitionId(STATUS_DEFINITION_ID),
-			name: STATUS_COMMAND,
-			description: "Report this session's pause state",
-			handler: async (invocation) => ({
-				kind: "success",
-				text: await status(invocation.signal)
-			})
-		});
-		/** Re-register the status verb, which is the announcement every phase change rides. */
-		let announce;
-		const fiber = agent.ctx.inject(["commands"], (scope) => {
-			scope.commands.register({
-				definitionId: CommandDefinitionId(RESUME_DEFINITION_ID),
-				name: RESUME_COMMAND,
-				description: "Resume this paused session and its subagents",
-				handler: async (invocation) => modelIssued(ctx) ? {
-					kind: "error",
-					text: UNATTENDED_TEXT
-				} : (await resumePath.releaseTree(invocation.agent.id, invocation.signal)).answer
-			});
-			/** The status verb's current registration; {@link announce} replaces it. */
-			let registered = scope.commands.register(definition());
-			announce = () => {
-				registered();
-				registered = scope.commands.register(definition());
-			};
-			scope.commands.register({
-				definitionId: CommandDefinitionId(GOAL_DEFINITION_ID),
-				name: GOAL_COMMAND,
-				description: "Turn this paused Session's goal re-arm on or off",
-				handler: async () => {
-					if (modelIssued(ctx)) return {
-						kind: "error",
-						text: UNATTENDED_TEXT
-					};
-					const record = registry.get(sessionId);
-					if (record === void 0) return {
-						kind: "error",
-						text: NOT_PARKED_TEXT
-					};
-					return await resumePath.setRearmGoal(sessionId, !record.rearmGoal);
-				}
-			});
-		});
-		markers.set(sessionId, {
-			fiber,
-			announce: () => {
-				announce?.();
-			}
-		});
-	};
-	/**
-	* Walk one session's mark as far forward as its current activity allows.
-	*
-	* The move is published by `settle`, once the write that makes `parking`
-	* durable has resolved; until then the mark keeps answering with `draining`,
-	* which is less than the truth rather than more than the record can back.
-	* @param sessionId - the marked session to re-derive.
-	* @returns whether this call moved the mark out of `draining` (and so owes a flush).
-	*/
 	const advance = (sessionId) => {
 		const mark = marks.get(sessionId);
 		if (mark === void 0 || mark.phase !== "draining" || mark.advancing) return false;
@@ -2136,20 +1767,9 @@ function installSessionControl(ctx, gate, watch, registry, options) {
 		mark.advancing = true;
 		return true;
 	};
-	/**
-	* Flush a parked session at the session level and publish what actually
-	* happened.
-	*
-	* The flush is the promise that survives a crash: a handle's own flush would
-	* leave the routed live buffer — the pending input — in memory. `safe` is
-	* therefore reserved for a flush this process ran and that resolved; a
-	* session that is no longer in the store cannot be flushed at all, so its
-	* park stops at the phase that says the flush never happened.
-	*/
 	const settle = async (sessionId, attempt) => {
 		const mark = marks.get(sessionId);
 		if (mark === void 0 || mark.generation !== attempt) return;
-		/** Whether this attempt still owns the mark: a cancel or a newer press replaces or drops it. */
 		const owned = () => marks.get(sessionId) === mark && mark.generation === attempt;
 		const session = ctx.sessions.get(sessionId);
 		try {
@@ -2160,7 +1780,10 @@ function installSessionControl(ctx, gate, watch, registry, options) {
 			await commit(sessionId, mark, "parking");
 			if (!owned()) return;
 			try {
-				await ctx.sessions.flush(session);
+				if (!await ctx.sessions.flush(session)) {
+					await commit(sessionId, mark, "flush-failed");
+					return;
+				}
 			} catch (error) {
 				if (!owned()) return;
 				ctx.logger.warn(`pause: flush failed for "${sessionId}": ${describeError(error)}`);
@@ -2173,33 +1796,12 @@ function installSessionControl(ctx, gate, watch, registry, options) {
 			if (marks.get(sessionId) === mark && mark.phase === "draining") mark.advancing = false;
 		}
 	};
-	/** Look at one marked session and act on what it is doing. */
 	const look = (sessionId) => {
-		publish(sessionId);
+		if (marks.has(sessionId)) notify();
 		if (!advance(sessionId)) return;
 		const attempt = marks.get(sessionId)?.generation;
 		if (attempt !== void 0) settle(sessionId, attempt);
 	};
-	/**
-	* Press one session's pause and make it durable.
-	*
-	* The press IS a durable promise: a pause that cannot be recorded is taken
-	* back here rather than left as one a restart silently forgets. A session a
-	* pause already owns is left exactly where it is — including one adopted
-	* from an earlier process, whose outcome is not this process's to re-derive.
-	*
-	* A session with nothing live is left alone entirely. It has no request to
-	* hold and no session-level flush to run, so a record for it could only be
-	* one of two lies: `safe`, a park that never happened but that the clean path
-	* would silently resume, or a phase that never settles, which would keep
-	* "safe to close" from ever appearing. Registering the running tree therefore
-	* means registering the members a pause can actually hold and flush.
-	* @param sessionId - the session to pause.
-	* @param signal - cancellation for the resumability read and registry write.
-	* @param knownResumable - whether the caller already proved the local route is
-	* `continuable` from the parent catalog, avoiding a second Session read.
-	* @returns what the press did; only `registered` created a new park.
-	*/
 	const press = async (sessionId, signal, knownResumable = false) => {
 		if (ctx.sessions.get(sessionId) === void 0) return "not-live";
 		if (!knownResumable && !await isResumableSession(ctx, sessionId, signal)) return "not-resumable";
@@ -2213,12 +1815,132 @@ function installSessionControl(ctx, gate, watch, registry, options) {
 		marks.set(sessionId, mark);
 		if (await commit(sessionId, mark, "draining")) {
 			unheld.delete(sessionId);
+			notify();
 			return "registered";
 		}
-		drop(sessionId);
-		gate.resume(sessionId);
-		return "unrecordable";
+		drop(sessionId);
+		gate.resume(sessionId);
+		return "unrecordable";
+	};
+	const release = async (sessionId, text) => {
+		if (!gate.isPaused(sessionId)) return {
+			kind: "success",
+			text
+		};
+		try {
+			await registry.forget(sessionId);
+		} catch (error) {
+			ctx.logger.warn(`pause: could not drop "${sessionId}" from the pause registry: ${describeError(error)}`);
+			return {
+				kind: "error",
+				text: UNRECORDED_TEXT
+			};
+		}
+		gate.resume(sessionId);
+		notify();
+		return {
+			kind: "success",
+			text
+		};
+	};
+	const sync = (sessionId) => {
+		if (!gate.isPaused(sessionId)) {
+			drop(sessionId);
+			return;
+		}
+	};
+	return {
+		marks,
+		unrecorded,
+		unheld,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		notify,
+		press,
+		adopt: (sessionId, phase) => {
+			marks.set(sessionId, {
+				phase,
+				generation: ++generation,
+				origin: "registry",
+				advancing: false
+			});
+		},
+		look,
+		drop,
+		sync,
+		release,
+		markUnrecorded: (sessionId, blocked) => {
+			if (blocked) unrecorded.add(sessionId);
+			else unrecorded.delete(sessionId);
+		},
+		live: () => new Map([...marks].map(([sessionId, mark]) => [sessionId, {
+			phase: mark.phase,
+			moving: mark.origin === "press" && mark.phase !== "flush-failed" && ctx.sessions.get(sessionId) !== void 0
+		}])),
+		cleanup: () => {
+			if (notification !== void 0) clearTimeout(notification);
+			marks.clear();
+			listeners.clear();
+		}
 	};
+}
+//#endregion
+//#region lib/types/control.js
+/**
+* The session control the browser half drives: the pause verb, the park state
+* machine behind it, and the live state channel that accompanies both.
+*
+* 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
+*/
+/**
+* Whether this host can read one recorded session at all — a live session, or a
+* stored log the persistence backend can observe.
+* @param ctx - host context carrying the session store and the optional persistence service.
+* @param sessionId - the recorded session to look for.
+* @returns whether the session can be acted on here.
+*/
+async function sessionReadable(ctx, sessionId) {
+	if (ctx.sessions.get(sessionId) !== void 0) return true;
+	const persistence = ctx.get("sessionPersistence");
+	if (persistence === void 0) return false;
+	try {
+		return await persistence.stat(sessionId) !== void 0;
+	} catch (error) {
+		ctx.logger.warn(`pause: could not look for the stored log of "${sessionId}": ${describeError(error)}`);
+		return false;
+	}
+}
+/** How resuming all parked sessions answers the caller. */
+function summarizeResume(attempts) {
+	const resumed = attempts.filter((attempt) => attempt.resumed).length;
+	const refused = attempts.length - resumed;
+	const head = resumed === 0 ? "pause resumed no session" : resumed === 1 ? "pause resumed 1 session from where it stopped" : `pause resumed ${resumed} sessions from where they stopped`;
+	if (refused === 0) return `${head}.`;
+	return `${head}; ${attempts.filter((attempt) => attempt.refusal === "not-clean").length === refused ? `${refused} did not pause completely and need your decision` : `${refused} could not be resumed`}.`;
+}
+/**
+* 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 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.
+* @param registry - the durable pause list every phase change is written to.
+* @param options - route knowledge the clean resume path needs, and the decision list's read bound.
+* @returns the mount-time adoption step and the morning resume path.
+*/
+function installSessionControl(ctx, gate, watch, registry, options) {
+	const park = installParkState(ctx, gate, registry, watch);
 	/**
 	* Press one session's pause and register its whole tree behind it.
 	*
@@ -2242,29 +1964,35 @@ function installSessionControl(ctx, gate, watch, registry, options) {
 			registered: 0,
 			rootRegistered: false,
 			unrecorded: [],
-			unread: false
+			unread: false,
+			unresumable: [],
+			unreadBranches: []
 		};
 		const walk = await walkDescendants(ctx, sessionId, signal);
 		if (walk.unreadWhole) {
-			const pressed = await press(sessionId, signal);
-			if (pressed === "registered") look(sessionId);
+			const pressed = await park.press(sessionId, signal);
+			if (pressed === "registered") park.look(sessionId);
 			globalPause.markUnrecorded(sessionId, pressed === "unrecordable");
 			return {
 				members: pressed === "registered" ? 1 : 0,
 				registered: pressed === "registered" ? 1 : 0,
 				rootRegistered: pressed === "registered",
 				unrecorded: pressed === "unrecordable" ? [sessionId] : [],
-				unread: true
+				unread: true,
+				unresumable: [],
+				unreadBranches: []
 			};
 		}
 		const registered = [];
 		const unrecorded = [];
+		const unresumable = walk.members.filter((member) => member.mode !== "continuable").map((member) => member.id);
+		const unreadBranches = walk.unread.map((branch) => branch.id);
 		const members = walk.members.filter((member) => member.mode === "continuable");
 		for (const id of [sessionId, ...members.map((member) => member.id)]) {
-			const pressed = await press(id, signal, id !== sessionId);
+			const pressed = await park.press(id, signal, id !== sessionId);
 			if (pressed === "registered") {
 				registered.push(id);
-				look(id);
+				park.look(id);
 			} else if (pressed === "unrecordable") unrecorded.push(id);
 			globalPause.markUnrecorded(id, pressed === "unrecordable");
 		}
@@ -2273,214 +2001,115 @@ function installSessionControl(ctx, gate, watch, registry, options) {
 			registered: registered.length,
 			rootRegistered: registered.includes(sessionId),
 			unrecorded,
-			unread: false
-		};
-	};
-	const sync = (sessionId) => {
-		if (!gate.isPaused(sessionId)) {
-			drop(sessionId);
-			return;
-		}
-		publish(sessionId);
-	};
-	/**
-	* Take the pause back: the durable record goes first, so a process that dies
-	* in between does not re-hold a session the user has already released. A
-	* record that cannot be dropped leaves the session paused, which is the state
-	* the registry still describes.
-	*/
-	const release = async (sessionId, text) => {
-		if (!gate.isPaused(sessionId)) return {
-			kind: "success",
-			text
-		};
-		try {
-			await registry.forget(sessionId);
-		} catch (error) {
-			ctx.logger.warn(`pause: could not drop "${sessionId}" from the pause registry: ${describeError(error)}`);
-			return {
-				kind: "error",
-				text: UNRECORDED_TEXT
-			};
-		}
-		gate.resume(sessionId);
-		return {
-			kind: "success",
-			text
+			unread: unreadBranches.length > 0,
+			unresumable,
+			unreadBranches
 		};
 	};
 	const resumePath = installResumePath(ctx, gate, registry, options, {
-		release,
-		adopted: (sessionId) => marks.get(sessionId)?.origin === "registry"
+		release: park.release,
+		adopted: (sessionId) => park.marks.get(sessionId)?.origin === "registry"
 	});
 	const triage = mountTriageList(ctx, registry, resumePath, options.maxListedLogEvents);
-	/**
-	* The one handler the four decision verbs share. The list is addressed by
-	* session like every other command on this channel, so the row the user
-	* decided on travels as the command's own input. The calling session is what
-	* makes that row a target: the list acts only on rows it published to this
-	* caller, and never on a model's command.
-	*/
-	const decide = (action) => async (invocation) => {
-		if (modelIssued(ctx)) return {
-			kind: "error",
-			text: UNATTENDED_TEXT
-		};
-		const target = invocation.rawInput.trim();
-		if (target.length === 0) return {
-			kind: "error",
-			text: TRIAGE_NOT_LISTED_TEXT
-		};
-		return await triage.decide(invocation.agent.id, SessionId(target), action, invocation.signal);
-	};
 	const globalPause = mountGlobalPause(ctx, watch, registry, {
 		isPaused: (sessionId) => gate.isPaused(sessionId),
-		press,
-		look,
-		live: () => new Map([...marks].map(([sessionId, mark]) => [sessionId, {
-			phase: mark.phase,
-			moving: mark.origin === "press" && mark.phase !== "flush-failed" && ctx.sessions.get(sessionId) !== void 0
-		}])),
-		unheld: () => unheld
+		press: park.press,
+		look: park.look,
+		live: park.live,
+		unheld: () => park.unheld
 	});
+	const readSnapshot$1 = (signal) => readSnapshot({
+		ctx,
+		marks: park.marks,
+		watch,
+		registry,
+		readGlobal: globalPause.readState
+	}, signal);
 	ctx.effect(function* () {
-		yield ctx.commands.register({
-			definitionId: CommandDefinitionId(PAUSE_DEFINITION_ID),
-			name: PAUSE_COMMAND,
-			description: "Pause this Session and its subagents before their next model request",
-			handler: async (invocation) => {
-				if (modelIssued(ctx)) return {
-					kind: "error",
-					text: UNATTENDED_TEXT
-				};
-				const sessionId = invocation.agent.id;
-				const pressed = await pressTree(sessionId, invocation.signal);
-				if (pressed.unrecorded.length > 0) return {
-					kind: "error",
-					text: unrecordedTreeText(pressed.unrecorded)
-				};
-				if (!pressed.rootRegistered) return {
-					kind: "error",
-					text: NOT_RESUMABLE_PARK_TEXT
-				};
-				const agents = pressed.rootRegistered ? pressed.registered - 1 : pressed.registered;
-				if (pressed.unread) return {
-					kind: "success",
-					text: `${pausedText(agents)} ${TREE_UNREAD_TEXT}`
-				};
-				return {
-					kind: "success",
-					text: pausedText(agents)
-				};
-			}
-		});
-		yield ctx.commands.register({
-			definitionId: CommandDefinitionId(RESUME_ALL_DEFINITION_ID),
-			name: RESUME_ALL_COMMAND,
-			description: "Resume every paused session",
-			handler: async (invocation) => modelIssued(ctx) ? {
-				kind: "error",
-				text: UNATTENDED_TEXT
-			} : {
-				kind: "success",
-				text: summarizeResume(await resumePath.resumeParked(invocation.signal))
-			}
-		});
-		yield ctx.commands.register({
-			definitionId: CommandDefinitionId(PAUSE_ALL_DEFINITION_ID),
-			name: PAUSE_ALL_COMMAND,
-			description: "Pause every running Session and its subagents",
-			handler: async (invocation) => modelIssued(ctx) ? {
-				kind: "error",
-				text: UNATTENDED_TEXT
-			} : globalPause.pressAll(invocation.signal)
-		});
-		yield ctx.commands.register({
-			definitionId: CommandDefinitionId(STATE_ALL_DEFINITION_ID),
-			name: STATE_ALL_COMMAND,
-			description: "Report whether every session is paused",
-			handler: async (invocation) => globalPause.readStatus(invocation.signal)
-		});
-		yield ctx.commands.register({
-			definitionId: CommandDefinitionId(TRIAGE_DEFINITION_ID),
-			name: TRIAGE_COMMAND,
-			description: "List sessions that did not pause completely",
-			handler: async (invocation) => ({
-				kind: "success",
-				text: encodeTriageList(await triage.read(invocation.agent.id, invocation.signal))
-			})
-		});
-		yield ctx.commands.register({
-			definitionId: CommandDefinitionId(TRIAGE_CONTINUE_DEFINITION_ID),
-			name: TRIAGE_CONTINUE_COMMAND,
-			description: "Resume a listed session: <session id>",
-			handler: decide("continue")
-		});
-		yield ctx.commands.register({
-			definitionId: CommandDefinitionId(TRIAGE_NOTE_DEFINITION_ID),
-			name: TRIAGE_NOTE_COMMAND,
-			description: "Resume a listed session with a note that its tool result is unknown: <session id>",
-			handler: decide("note")
-		});
-		yield ctx.commands.register({
-			definitionId: CommandDefinitionId(TRIAGE_REVIEW_DEFINITION_ID),
-			name: TRIAGE_REVIEW_COMMAND,
-			description: "Open a listed session without running it: <session id>",
-			handler: decide("review")
-		});
-		yield ctx.commands.register({
-			definitionId: CommandDefinitionId(TRIAGE_LEAVE_DEFINITION_ID),
-			name: TRIAGE_LEAVE_COMMAND,
-			description: "Keep a listed session paused: <session id>",
-			handler: decide("leave")
-		});
-		yield ctx.commands.register({
-			definitionId: CommandDefinitionId(TRIAGE_GOAL_DEFINITION_ID),
-			name: TRIAGE_GOAL_COMMAND,
-			description: "Turn a listed Session's goal re-arm on or off: <session id>",
-			handler: decide("goal")
-		});
 		yield gate.onChange((sessionId) => {
-			sync(sessionId);
+			park.sync(sessionId);
 		});
 		yield gate.onHeld((sessionId) => {
 			queueMicrotask(() => {
-				look(sessionId);
+				park.look(sessionId);
 			});
 		});
 		yield watch.onChange((sessionId) => {
-			look(sessionId);
+			park.look(sessionId);
 		});
 		yield ctx.on("agent/created", ({ agent }) => {
-			sync(agent.id);
-		});
-		yield ctx.on("agent/disposed", ({ agent }) => {
-			markers.delete(agent.id);
+			park.sync(agent.id);
 		});
 		yield async () => {
-			const pending = [...markers.values()].map((marker) => marker.fiber.dispose());
-			markers.clear();
-			marks.clear();
-			await Promise.all(pending);
+			park.cleanup();
 		};
-	}, "pause: session control");
-	return { adopt: async () => {
-		for (const entry of registry.list()) {
-			if (!await sessionReadable(ctx, entry.sessionId)) {
-				unheld.add(entry.sessionId);
-				ctx.logger.warn(`pause: the pause recorded for "${entry.sessionId}" is not held: this host cannot read that session`);
-				continue;
+	}, "pause: session events");
+	return {
+		readSnapshot: readSnapshot$1,
+		subscribe: park.subscribe,
+		pressTree: async (sessionId, signal) => await pressTree(sessionId, signal),
+		releaseTree: async (sessionId, signal) => await resumePath.releaseTree(sessionId, signal),
+		pauseAll: async (signal) => {
+			const answer = await globalPause.pressAll(signal);
+			park.notify();
+			return answer;
+		},
+		cancelAll: async (signal) => {
+			const outcomes = [];
+			for (let round = 0; round < 3; round += 1) {
+				const before = registry.parked.size;
+				for (const sessionId of [...registry.parked.keys()]) {
+					signal?.throwIfAborted();
+					outcomes.push((await resumePath.releaseTree(sessionId, signal)).answer);
+				}
+				if (registry.parked.size === before) break;
 			}
-			if (gate.pause(entry.sessionId)) marks.set(entry.sessionId, {
-				phase: entry.phase,
-				generation: ++generation,
-				origin: "registry",
-				advancing: false
-			});
-			publish(entry.sessionId);
+			park.notify();
+			const failed = outcomes.filter((answer) => answer.kind === "error");
+			return failed.length === 0 ? {
+				kind: "success",
+				text: "Every pause was released."
+			} : {
+				kind: "error",
+				text: failed.map((answer) => answer.text).join(" ")
+			};
+		},
+		resumeAll: async (signal) => {
+			const answer = {
+				kind: "success",
+				text: summarizeResume(await resumePath.resumeParked(signal))
+			};
+			park.notify();
+			return answer;
+		},
+		toggleGoal: async (sessionId) => {
+			const record = registry.get(sessionId);
+			if (record === void 0) return {
+				kind: "error",
+				text: NOT_PARKED_TEXT
+			};
+			const answer = await resumePath.setRearmGoal(sessionId, !record.rearmGoal);
+			park.notify();
+			return answer;
+		},
+		readTriage: async (caller, signal) => await triage.read(caller, signal),
+		decideTriage: async (caller, target, action, signal) => {
+			const answer = await triage.decide(caller, target, action, signal);
+			park.notify();
+			return answer;
+		},
+		adopt: async () => {
+			for (const entry of registry.list()) {
+				if (!await sessionReadable(ctx, entry.sessionId)) {
+					park.unheld.add(entry.sessionId);
+					ctx.logger.warn(`pause: the pause recorded for "${entry.sessionId}" is not held: this host cannot read that session`);
+					continue;
+				}
+				if (gate.pause(entry.sessionId)) park.adopt(entry.sessionId, entry.phase);
+			}
+			for (const agent of ctx.agents.list()) park.sync(agent.id);
 		}
-		for (const agent of ctx.agents.list()) sync(agent.id);
-	} };
+	};
 }
 //#endregion
 //#region lib/types/gate.js
@@ -2784,6 +2413,399 @@ async function mountParkWatch(ctx) {
 		}
 	};
 }
+//#endregion
+//#region lib/types/remote.js
+/**
+* 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
+*/
+var __runInitializers = function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) if (kind === "field") initializers.unshift(_);
+		else descriptor[key] = _;
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
+/** Host callbacks the Remote service delegates to. */
+/**
+* Refuse a Remote call made by a principal other than the owner. In-process
+* callers (tests, the Host itself) have no invocation and are trusted.
+* @param ctx - the service Context.
+*/
+function ownerOnly(ctx) {
+	const invocation = ctx.invocation;
+	if (invocation === void 0) return;
+	if (invocation.peer.principal?.kind !== "owner") throw new RemoteError("pause/owner-only", "pause controls are available only to the owner", {});
+}
+/**
+* Record one state-changing Remote action in the host log. The principal is
+* the owning user for owner calls and trusted in-process invocations; no wire
+* field can forge it.
+* @param ctx - the service Context.
+* @param action - the action pressed.
+* @param sessionId - the addressed Session.
+*/
+function logAction(ctx, action, sessionId) {
+	const invocation = ctx.invocation;
+	const principal = principalOf(invocation);
+	ctx.logger.info(`pause: ${action} "${sessionId}"`, {
+		action,
+		sessionId,
+		principal: principal?.kind ?? "owner"
+	});
+}
+/** Host service exposed to the browser as the `pauseSession` Remote namespace. */
+let PauseRemote = (() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _snapshot_decorators;
+	let _observe_decorators;
+	let _act_decorators;
+	let _triage_decorators;
+	let _decide_decorators;
+	return class PauseRemote extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_snapshot_decorators = [Remote("snapshot")];
+			_observe_decorators = [Remote({ mode: "stream" })];
+			_act_decorators = [Remote("act")];
+			_triage_decorators = [Remote("triage")];
+			_decide_decorators = [Remote("decide")];
+			__esDecorate(this, null, _snapshot_decorators, {
+				kind: "method",
+				name: "snapshot",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "snapshot" in obj,
+					get: (obj) => obj.snapshot
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _observe_decorators, {
+				kind: "method",
+				name: "observe",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "observe" in obj,
+					get: (obj) => obj.observe
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _act_decorators, {
+				kind: "method",
+				name: "act",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "act" in obj,
+					get: (obj) => obj.act
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _triage_decorators, {
+				kind: "method",
+				name: "triage",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "triage" in obj,
+					get: (obj) => obj.triage
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _decide_decorators, {
+				kind: "method",
+				name: "decide",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "decide" in obj,
+					get: (obj) => obj.decide
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		api = __runInitializers(this, _instanceExtraInitializers);
+		/** One snapshot per host version, shared by every connected observer. */
+		snapshotCache;
+		/** Bumped by every host notification; each observer compares it to its own cursor. */
+		version = 0;
+		/** Observers waiting for the next version. */
+		waiters = /* @__PURE__ */ new Set();
+		unsubscribe;
+		/**
+		* @param ctx - host context owning the service.
+		* @param api - the pause engine behind the wire methods.
+		*/
+		constructor(ctx, api) {
+			super(ctx, "pauseSession", { namespace: "pauseSession" });
+			this.api = api;
+			this.unsubscribe = this.api.subscribe(() => {
+				this.version += 1;
+				this.snapshotCache = void 0;
+				for (const wake of [...this.waiters]) wake();
+				this.waiters.clear();
+			});
+			ctx.effect(() => this.unsubscribe, "pause: remote updates");
+		}
+		/**
+		* 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.
+		*/
+		async snapshot(signal) {
+			ownerOnly(this.ctx);
+			return await this.api.snapshot(signal);
+		}
+		/**
+		* 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.
+		*/
+		snapshotFor(version, signal) {
+			if (this.snapshotCache?.version === version) return this.snapshotCache.value;
+			const value = this.api.snapshot(signal);
+			this.snapshotCache = {
+				version,
+				value
+			};
+			return value;
+		}
+		/**
+		* Live status: the opening snapshot, then one new snapshot whenever the host
+		* reports a change.
+		* @param signal - stream cancellation.
+		* @returns the snapshot stream.
+		*/
+		async *observe(signal) {
+			ownerOnly(this.ctx);
+			let seen = -1;
+			for (;;) {
+				signal?.throwIfAborted();
+				if (this.version !== seen) {
+					seen = this.version;
+					yield await this.snapshotFor(seen, signal);
+					continue;
+				}
+				await new Promise((resolve, reject) => {
+					const finish = () => {
+						signal?.removeEventListener("abort", onAbort);
+						this.waiters.delete(finish);
+						resolve();
+					};
+					const onAbort = () => {
+						this.waiters.delete(finish);
+						signal?.removeEventListener("abort", onAbort);
+						reject(signal?.reason);
+					};
+					this.waiters.add(finish);
+					signal?.addEventListener("abort", onAbort, { once: true });
+					if (this.version !== seen) finish();
+				});
+			}
+		}
+		/**
+		* 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.
+		*/
+		async act(request, signal) {
+			ownerOnly(this.ctx);
+			logAction(this.ctx, request.action, request.sessionId);
+			return await this.api.act(request, signal);
+		}
+		/**
+		* Read the morning decision list.
+		* @param request - the calling Session whose list is read.
+		* @param signal - read cancellation.
+		* @returns the listed rows.
+		*/
+		async triage(request, signal) {
+			ownerOnly(this.ctx);
+			return await this.api.triage(request, signal);
+		}
+		/**
+		* Take one decision on one listed Session.
+		* @param request - the caller, target, and decision.
+		* @param signal - load cancellation.
+		* @returns the user-facing outcome.
+		*/
+		async decide(request, signal) {
+			ownerOnly(this.ctx);
+			logAction(this.ctx, request.decision, request.target);
+			return await this.api.decide(request, signal);
+		}
+	};
+})();
+//#endregion
+//#region lib/types/remote-adapter.js
+/**
+* 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
+*/
+/** Map the engine's aggregate status to the wire shape. */
+function globalOf(status) {
+	return {
+		verdict: status.verdict,
+		registered: status.registered,
+		safe: status.safe,
+		...status.parkedAt === void 0 ? {} : { parkedAt: String(status.parkedAt) },
+		draining: status.draining.map(String),
+		parking: status.parking,
+		stalled: status.stalled.map(String),
+		unresumable: status.unresumable.map(String),
+		unreadTrees: status.unreadTrees.map(String),
+		jobs: status.jobs.map(String),
+		blind: [...status.blind]
+	};
+}
+/** Map one engine status to the wire shape. */
+function sessionOf(status) {
+	return {
+		phase: status.phase,
+		runningTools: [...status.runningTools],
+		...status.rearmGoal === void 0 ? {} : { rearmGoal: status.rearmGoal }
+	};
+}
+/** Map one engine triage row to the wire shape. */
+function triageRowOf(row) {
+	return {
+		sessionId: row.sessionId,
+		phase: row.phase,
+		updatedAt: row.updatedAt,
+		reading: row.reading,
+		...row.lastEvent === void 0 ? {} : { lastEvent: row.lastEvent },
+		...row.turn === void 0 ? {} : { turn: row.turn },
+		...row.step === void 0 ? {} : { step: row.step },
+		traces: row.traces.map((trace) => ({
+			tool: trace.tool,
+			callId: trace.callId
+		})),
+		owed: row.owed,
+		wakeable: row.wakeable,
+		rearmGoal: row.rearmGoal
+	};
+}
+/** Map the engine's snapshot to the wire shape. */
+function snapshotOf(snapshot) {
+	return {
+		global: globalOf(snapshot.global),
+		sessions: Object.fromEntries(Object.entries(snapshot.sessions).map(([id, status]) => [id, sessionOf(status)]))
+	};
+}
+/** Convert one engine answer to the wire outcome. */
+function outcomeOf(answer) {
+	return {
+		ok: answer.kind === "success",
+		message: answer.text ?? (answer.kind === "success" ? "Done." : "Pause action failed.")
+	};
+}
+/** Convert a press outcome to the wire outcome. */
+function pressOutcomeOf(outcome) {
+	const names = (ids) => ids.map((id) => `"${String(id)}"`).join(", ");
+	if (outcome.unrecorded.length > 0) return {
+		ok: false,
+		message: `pause could not record ${names(outcome.unrecorded)}.`
+	};
+	if (!outcome.rootRegistered) return {
+		ok: false,
+		message: "pause did not register this session."
+	};
+	const caveats = [];
+	if (outcome.unresumable.length > 0) caveats.push(`these subagents cannot be resumed: ${names(outcome.unresumable)}.`);
+	if (outcome.unreadBranches.length > 0) caveats.push(`these subagent branches could not be read: ${names(outcome.unreadBranches)}.`);
+	if (outcome.unread && outcome.unreadBranches.length === 0) caveats.push("The subagent tree could not be fully read.");
+	return {
+		ok: true,
+		message: `Paused ${String(outcome.registered)} session${outcome.registered === 1 ? "" : "s"}.` + (caveats.length === 0 ? "" : ` ${caveats.join(" ")}`)
+	};
+}
+/**
+* Build the Remote callbacks over the mounted pause control.
+* @param control - the engine's host control surface.
+* @returns the wire API.
+*/
+function remoteApiOf(control) {
+	return {
+		snapshot: async (signal) => snapshotOf(await control.readSnapshot(signal)),
+		subscribe: (listener) => control.subscribe(listener),
+		act: async (request, signal) => {
+			const sessionId = SessionId(request.sessionId);
+			switch (request.action) {
+				case "pause": return pressOutcomeOf(await control.pressTree(sessionId, signal));
+				case "resume": return outcomeOf((await control.releaseTree(sessionId, signal)).answer);
+				case "pause-all": return outcomeOf(await control.pauseAll(signal));
+				case "resume-all": return outcomeOf(await control.resumeAll(signal));
+				case "cancel-all": return outcomeOf(await control.cancelAll(signal));
+				case "goal": return outcomeOf(await control.toggleGoal(sessionId, signal));
+			}
+		},
+		triage: async (request, signal) => {
+			return (await control.readTriage(SessionId(request.caller), signal)).rows.map(triageRowOf);
+		},
+		decide: async (request, signal) => {
+			const action = request.decision;
+			return outcomeOf(await control.decideTriage(SessionId(request.caller), SessionId(request.target), action, signal));
+		}
+	};
+}
 /**
 * The registry declaration. `version: 1` and no `compatibleVersions`: the
 * domain layer rejects a stored unit stamped with any other version rather than
@@ -2847,7 +2869,10 @@ async function openParkRegistry(ctx) {
 		list: entriesNow,
 		get parked() {
 			const entries = entriesNow();
-			if (cached !== void 0 && entries.length === cachedFrom.length && entries.every((entry, at) => entry === cachedFrom[at])) return cached;
+			if (cached !== void 0 && entries.length === cachedFrom.length && entries.every((entry, at) => {
+				const previous = cachedFrom[at];
+				return previous !== void 0 && entry.sessionId === previous.sessionId && entry.phase === previous.phase && entry.updatedAt === previous.updatedAt && entry.rearmGoal === previous.rearmGoal;
+			})) return cached;
 			cachedFrom = entries;
 			cached = new Map(entries.map((entry) => [entry.sessionId, entry]));
 			return cached;
@@ -2908,7 +2933,6 @@ const name = "dsh-pause-session";
 */
 const inject = [
 	"llm",
-	"commands",
 	"agents",
 	"sessions",
 	"sessionProjections",
@@ -2964,12 +2988,14 @@ async function apply(ctx, config = Config.parse({})) {
 	}, "pause: lifetime");
 	const gate = new PauseGate({ lifetime: lifetime.signal });
 	ctx.effect(() => ctx.on("llm/stream", (request, next) => gate.stream(request, next)), "pause: pause gate");
-	await installSessionControl(ctx, gate, await mountParkWatch(ctx), registry, {
+	const control = installSessionControl(ctx, gate, await mountParkWatch(ctx), registry, {
 		silentWakeRoutes: config.silentWakeRoutes,
 		maxListedLogEvents: config.maxListedLogEvents
-	}).adopt();
+	});
+	new PauseRemote(ctx, remoteApiOf(control));
+	await control.adopt();
 }
 //#endregion
-export { Config, DEFAULT_SILENT_WAKE_ROUTES, apply, inject, name };
+export { Config, DEFAULT_SILENT_WAKE_ROUTES, PauseRemote, apply, inject, name };
 
 //# sourceMappingURL=index.js.map