@deepseek-ai/dsh-api-session-controller 0.1.6-alpha.1 → 0.1.7-alpha.1

package/lib/client.js

@@ -34,6 +34,27 @@ window.__ModuleLoader__.load({
 				this.name = "RemoteError";
 			}
 		};
+		/** Generic invocation-owned values returned by synchronous Client Context resolvers. */
+		/** Shared identity across independently bundled Context providers and Gateway. */
+		const TYPERT_OWNED_VALUE = Symbol.for("dsh.typert.owned-value");
+		/**
+		* Transfer cleanup ownership without adding another resource reference count.
+		* @param value - resolved payload passed to the invocation.
+		* @param release - non-throwing synchronous release, called at most once.
+		* @returns an owned payload disposed after invocation and reply settlement.
+		*/
+		function typertOwnedValue(value, release) {
+			let active = true;
+			return {
+				[TYPERT_OWNED_VALUE]: true,
+				value,
+				[Symbol.dispose]() {
+					if (!active) return;
+					active = false;
+					release();
+				}
+			};
+		}
 		//#endregion
 		//#region lib/types/client/sessions/history-records.js
 		/** Client range access and type narrowing for aligned Session history records. */
@@ -128,6 +149,7 @@ window.__ModuleLoader__.load({
 			"compaction/start",
 			"compaction/summary",
 			"deliverables/presented",
+			"developer/message",
 			"feedback/message-delete",
 			"feedback/message-put",
 			"feedback/record",
@@ -170,13 +192,15 @@ window.__ModuleLoader__.load({
 			"turn/end",
 			"turn/start",
 			"user/message",
-			"web/deepseek-search-llm-request"
+			"web/deepseek-search-llm-request",
+			"workspace/changes"
 		]);
 		//#endregion
 		//#region ../../core/session/lib/types/surface.js
 		/** Runtime counterpart of the message-producing event union. */
 		const SURFACE_EVENT_TYPES = new Set([
 			"system/message",
+			"developer/message",
 			"user/message",
 			"assistant/message",
 			"tool/result"
@@ -184,7 +208,7 @@ window.__ModuleLoader__.load({
 		/**
 		* Whether an event type can join the model-visible surface.
 		* @param type - event type to test.
-		* @returns true for one of the four message-producing event types.
+		* @returns true for one of the message-producing event types.
 		*/
 		function isSurfaceEligibleType(type) {
 			return SURFACE_EVENT_TYPES.has(type);
@@ -194,14 +218,33 @@ window.__ModuleLoader__.load({
 			return typeof value === "object" && value !== null && !Array.isArray(value);
 		}
 		/**
-		* Reject noncanonical request-header fields and contradictory tool failure metadata.
+		* Reject noncanonical request-header fields, developer roles/content, and contradictory tool failure metadata.
 		* This does not validate complete event payloads or embedded provider streams.
 		* @param event - event whose locally related payload fields are inspected.
 		* @param subject - event location to include in validation errors.
-		* @throws when request data/header is not an object, optional header fields are empty, or tool failure metadata contradicts its message.
+		* @throws when request-header fields, developer roles/content, or tool failure metadata are invalid.
 		*/
 		function validateSessionEventData(event, subject) {
 			const data = event.data;
+			if (SURFACE_EVENT_TYPES.has(event.type) && isRecord(data)) {
+				const message = event.type === "user/message" ? data : data["message"];
+				if (isRecord(message)) {
+					if (event.type === "developer/message" !== (message["role"] === "developer")) throw new Error(`${subject} developer/message and developer role must occur together`);
+					if (message["role"] !== "developer" && Array.isArray(message["content"]) && message["content"].some((block) => isRecord(block) && (block["type"] === "tool-addition" || block["type"] === "tool-removal"))) throw new Error(`${subject} tool-change blocks require developer role`);
+					if (event.type === "developer/message" && Array.isArray(message["content"])) {
+						let hasAdditions = false;
+						for (const block of message["content"]) {
+							if (!isRecord(block) || block["type"] !== "tool-addition" && block["type"] !== "tool-removal") continue;
+							if (typeof block["toolName"] !== "string" || block["toolName"].length === 0) throw new Error(`${subject} ${block["type"]} requires a nonempty toolName`);
+							if (block["type"] === "tool-addition") {
+								hasAdditions = true;
+								if (Object.hasOwn(block, "tool")) throw new Error(`${subject} tool-addition must omit inline tool definitions`);
+							}
+						}
+						if (hasAdditions ? !isEventSeq(data["headerSeq"]) : Object.hasOwn(data, "headerSeq")) throw new Error(`${subject} requires headerSeq exactly when tool additions are present`);
+					}
+				}
+			}
 			if (event.type === "request/header") {
 				if (!isRecord(data)) throw new Error(`${subject} data must be an object`);
 				const header = data["header"];
@@ -214,9 +257,7 @@ window.__ModuleLoader__.load({
 				if (!isRecord(data)) throw new Error(`${subject} data must be an object`);
 				if (data["error"] === void 0) return;
 				const message = data["message"];
-				const content = isRecord(message) ? message["content"] : void 0;
-				const block = Array.isArray(content) ? content[0] : void 0;
-				if (!isRecord(block) || block["isError"] !== true) throw new Error(`${subject} error requires message content[0].isError === true`);
+				if (!isRecord(message) || message["isError"] !== true) throw new Error(`${subject} error requires message.isError === true`);
 			}
 		}
 		/** Whether a runtime value is a non-negative safe event sequence. */
@@ -309,7 +350,6 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region lib/types/types.js
-		/** Browser-safe request, result, and lifecycle vocabulary for the Session Remote service. */
 		/** Maximum number of Sessions returned by one search. */
 		const SESSION_SEARCH_RESULT_LIMIT = 20;
 		/** Maximum search snippet length in Unicode code points. */
@@ -454,23 +494,7 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region lib/types/client/scope.js
-		/**
-		* Client Agent-scope primitive: mint a Cordis context tagged with the owning
-		* Agent's identity. The mechanism mirrors the host `dsh-scope` architecture
-		* (no-op plugin fiber + context tag + `Context.filter` routing predicate);
-		* the shape deliberately diverges: the filter lives on the actx itself
-		* instead of a separate carrier object, so scoped dispatch is plain cordis —
-		* `actx.bail(actx, event, payload)` / `actx.emit(actx, ...)` — with no
-		* wrapper. The host needs a detached carrier because its dispatch subject is
-		* the business Agent object; client scope events carry only ids, so the
-		* actx is the natural subject. The second divergence stands: the scope key
-		* is the branded `SessionId` (value compared), not an object identity — the
-		* agent and its session share one id (1:1, same axis; no separate AgentId
-		* brand), and a client scope's identity IS that wire id. Third divergence,
-		* deliberate: the client scopes the Agent IDENTITY, not a live Agent object
-		* — a cold session's host Agent is already disposed while its client actx
-		* stays alive for history viewing.
-		*/
+		/** Client scope generations route local events independently of Host Agent residency. */
 		/** Context tag written by {@link createScope}. */
 		const kScope = Symbol("dsh.client.scope");
 		/** Shared no-op plugin backing each Agent scope fiber. */
@@ -478,21 +502,22 @@ window.__ModuleLoader__.load({
 		/**
 		* Mint an Agent scope under `ctx`: a no-op plugin fiber whose context
 		* carries the agent tag and the dispatch filter — untagged listeners are
-		* admitted globally, tagged listeners only for a matching agent.
+		* admitted globally, tagged listeners only for the same Client generation.
 		* Registrations through the returned ctx dispose with the fiber.
 		* @param ctx - client root context the scope fiber mounts under.
-		* @param key - owning agent identity (the routing tag; agent id === session id).
+		* @param key - durable Session identity carried by this generation.
 		* @returns the tagged context and its backing fiber.
 		*/
 		function createScope(ctx, key) {
 			const fiber = ctx.plugin(agentScope);
+			const identity = { sessionId: key };
 			return {
 				fiber,
 				ctx: fiber.ctx.extend({
-					[kScope]: key,
+					[kScope]: identity,
 					[_deepseek_ai_cordis.Context.filter](listenerCtx) {
-						const tag = scopeOf(listenerCtx);
-						return tag === void 0 || tag === key;
+						const tag = scopeIdentityOf(listenerCtx);
+						return tag === void 0 || tag === identity;
 					}
 				})
 			};
@@ -503,6 +528,14 @@ window.__ModuleLoader__.load({
 		* @returns its agent identity (the session id), or undefined for root contexts.
 		*/
 		function scopeOf(ctx) {
+			return scopeIdentityOf(ctx)?.sessionId;
+		}
+		/**
+		* Read the exact generation identity inherited by a Client Context.
+		* @param ctx - scoped or root Client Context.
+		* @returns the generation identity, or undefined for an unscoped Context.
+		*/
+		function scopeIdentityOf(ctx) {
 			return ctx[kScope];
 		}
 		//#endregion
@@ -543,16 +576,219 @@ window.__ModuleLoader__.load({
 			return merged;
 		}
 		//#endregion
+		//#region ../../util/values/lib/index.js
+		/** Duplicate-install-safe JSON and immutable-value helpers. @module @deepseek-ai/dsh-util-values */
+		/**
+		* Mark an unreachable closed-union branch.
+		* @param value - impossible value; an unhandled typed variant fails at the call site.
+		* @param context - optional switch-site label included in the failure message.
+		* @returns never; a runtime value that escaped its type always throws.
+		*/
+		function assertNever(value, context) {
+			const rendered = JSON.stringify(value) ?? String(value);
+			throw new Error(`unreachable variant${context ? ` in ${context}` : ""}: ${rendered}`);
+		}
+		/** Whether a realm-owned intrinsic prototype is backed by its native constructor. */
+		function hasIntrinsicConstructor(prototype, name) {
+			const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
+			if (typeof constructor !== "function") return false;
+			try {
+				return constructor.name === name && constructor.prototype === prototype && Function.prototype.toString.call(constructor) === `function ${name}() { [native code] }`;
+			} catch {
+				return false;
+			}
+		}
+		/** Whether a candidate is one realm's intrinsic `Object.prototype`. */
+		function isIntrinsicObjectPrototype(value) {
+			return Object.getPrototypeOf(value) === null && hasIntrinsicConstructor(value, "Object");
+		}
+		/** Whether an array uses one realm's intrinsic `Array.prototype`, not a subclass or forged prototype. */
+		function hasPlainArrayPrototype(value) {
+			const prototype = Object.getPrototypeOf(value);
+			if (!Array.isArray(prototype) || !hasIntrinsicConstructor(prototype, "Array")) return false;
+			const objectPrototype = Object.getPrototypeOf(prototype);
+			return typeof objectPrototype === "object" && objectPrototype !== null && isIntrinsicObjectPrototype(objectPrototype);
+		}
+		/** Whether an object is a plain or null-prototype record from any JavaScript realm. */
+		function hasPlainObjectPrototype(value) {
+			const prototype = Object.getPrototypeOf(value);
+			return prototype === null || typeof prototype === "object" && isIntrinsicObjectPrototype(prototype);
+		}
+		/** Return every JSON-visible object key, or reject own data JSON would discard. */
+		function enumerableStringKeys(value) {
+			const keys = Reflect.ownKeys(value);
+			if (keys.some((key) => typeof key !== "string" || !Object.prototype.propertyIsEnumerable.call(value, key))) return void 0;
+			return keys;
+		}
+		/** Validate lossless JSON iteratively, optionally materializing a detached snapshot. */
+		function walkJsonValue(value, detach) {
+			const ancestors = /* @__PURE__ */ new Set();
+			let root;
+			const assign = (destination, item) => {
+				if (destination === void 0) return;
+				if (destination.kind === "root") root = item;
+				else if (destination.kind === "array") destination.target[destination.index] = item;
+				else Object.defineProperty(destination.target, destination.key, {
+					value: item,
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			};
+			const tasks = [{
+				kind: "visit",
+				value,
+				...detach ? { destination: { kind: "root" } } : {}
+			}];
+			for (let task = tasks.pop(); task !== void 0; task = tasks.pop()) {
+				if (task.kind === "leave") {
+					ancestors.delete(task.source);
+					continue;
+				}
+				if (task.kind === "array-item") {
+					if (!Object.prototype.hasOwnProperty.call(task.source, task.index)) return void 0;
+					tasks.push({
+						kind: "visit",
+						value: task.source[task.index],
+						...task.target === void 0 ? {} : { destination: {
+							kind: "array",
+							target: task.target,
+							index: task.index
+						} }
+					});
+					continue;
+				}
+				if (task.kind === "object-property") {
+					tasks.push({
+						kind: "visit",
+						value: task.source[task.key],
+						...task.target === void 0 ? {} : { destination: {
+							kind: "object",
+							target: task.target,
+							key: task.key
+						} }
+					});
+					continue;
+				}
+				const current = task.value;
+				if (current === null) {
+					assign(task.destination, null);
+					continue;
+				}
+				if (typeof current === "boolean" || typeof current === "string") {
+					assign(task.destination, current);
+					continue;
+				}
+				if (typeof current === "number") {
+					if (!Number.isFinite(current) || Object.is(current, -0)) return void 0;
+					assign(task.destination, current);
+					continue;
+				}
+				if (typeof current !== "object") return void 0;
+				if (ancestors.has(current)) return void 0;
+				if (Array.isArray(current)) {
+					if (!hasPlainArrayPrototype(current)) return void 0;
+					const length = current.length;
+					if (Reflect.ownKeys(current).length !== length + 1) return void 0;
+					const target = detach ? [] : void 0;
+					if (target !== void 0) assign(task.destination, target);
+					ancestors.add(current);
+					tasks.push({
+						kind: "leave",
+						source: current
+					});
+					for (let index = length - 1; index >= 0; index--) tasks.push({
+						kind: "array-item",
+						source: current,
+						index,
+						...target === void 0 ? {} : { target }
+					});
+					continue;
+				}
+				if (!hasPlainObjectPrototype(current)) return void 0;
+				const keys = enumerableStringKeys(current);
+				if (keys === void 0) return void 0;
+				const target = detach ? {} : void 0;
+				if (target !== void 0) assign(task.destination, target);
+				ancestors.add(current);
+				tasks.push({
+					kind: "leave",
+					source: current
+				});
+				for (let index = keys.length - 1; index >= 0; index--) {
+					const key = keys[index];
+					/* v8 ignore next -- the loop is bounded by the captured key count. */
+					if (key === void 0) return void 0;
+					tasks.push({
+						kind: "object-property",
+						source: current,
+						key,
+						...target === void 0 ? {} : { target }
+					});
+				}
+			}
+			return detach ? root : true;
+		}
+		/**
+		* Validate and detach lossless JSON in one read per property.
+		* @param value - candidate value to validate and detach.
+		* @returns the detached snapshot, or `undefined` when the value is not losslessly JSON-serializable.
+		*/
+		function snapshotJsonValue(value) {
+			return walkJsonValue(value, true);
+		}
+		/**
+		* Deep-freeze an object graph in place while leaving live AbortSignal objects mutable.
+		* @param value - value to freeze.
+		* @returns the same value after every reachable enumerable child is frozen.
+		*/
+		function deepFreeze(value) {
+			const seen = /* @__PURE__ */ new WeakSet();
+			const pending = [{
+				kind: "visit",
+				node: value
+			}];
+			while (pending.length > 0) {
+				const task = pending.pop();
+				/* v8 ignore next -- the loop condition guarantees one pending task. */
+				if (task === void 0) continue;
+				if (task.kind === "property") {
+					pending.push({
+						kind: "visit",
+						node: task.source[task.key]
+					});
+					continue;
+				}
+				const node = task.node;
+				if (node === null || typeof node !== "object") continue;
+				if (node instanceof AbortSignal) continue;
+				if (seen.has(node)) continue;
+				seen.add(node);
+				Object.freeze(node);
+				const keys = Object.keys(node);
+				for (let index = keys.length - 1; index >= 0; index--) {
+					const key = keys[index];
+					/* v8 ignore next -- the loop is bounded by the captured key count. */
+					if (key === void 0) continue;
+					pending.push({
+						kind: "property",
+						source: node,
+						key
+					});
+				}
+			}
+			return value;
+		}
+		//#endregion
 		//#region lib/types/client/sessions/lineage.js
 		/**
 		* Summaries -> flat list with lineage indentation. Root and sibling order
 		* follows the established input order; this projection never re-sorts a
 		* hydrated list from mutable timestamps.
 		* @param summaries - the host's session.list items.
-		* @param completed - sessions with a pending completion reminder (manager-owned live fact; absent = false).
 		* @returns display rows in render order.
 		*/
-		function flattenLineage(summaries, completed) {
+		function flattenLineage(summaries) {
 			const byId = /* @__PURE__ */ new Map();
 			for (const s of summaries) byId.set(s.sessionId, s);
 			const children = /* @__PURE__ */ new Map();
@@ -570,9 +806,9 @@ window.__ModuleLoader__.load({
 					return;
 				}
 				visited.add(s.sessionId);
+				const { agentAvailable: _agentAvailable, ...row } = s;
 				out.push({
-					...s,
-					completed: completed?.has(s.sessionId) ?? false,
+					...row,
 					depth
 				});
 				const kids = children.get(s.sessionId);
@@ -675,10 +911,14 @@ window.__ModuleLoader__.load({
 		//#region lib/types/client/sessions/projection-store.js
 		/**
 		* One session's projection values. Framework semantics, uniform across every
-		* key: a baseline seeds rows at its cut, a push frame updates one row, and in
-		* both paths a lower-or-equal seq loses — a replayed frame cannot regress a
-		* value, a stale baseline cannot overwrite a newer frame. A key the store has
-		* never seen reads `undefined` (capability absent). Faces are identity-stable
+		* key. Sequenced writes (a baseline seeds rows at its cut, a push frame
+		* updates one row) compare seqs among themselves: a lower-or-equal seq within
+		* the Host generation loses, so a replayed frame cannot regress a value and a
+		* stale baseline cannot overwrite a newer frame. Cached writes (the session
+		* list's zero-I/O block) only fill keys no sequenced row holds, and a baseline
+		* discards every cached row before it seeds, regardless of seq: the connected
+		* Session is the truth and a cached value never outranks it. A key the store
+		* has never seen reads `undefined` (capability absent). Faces are identity-stable
 		* per key (create-on-demand, cached) so the React side binds each exactly
 		* once; the store-level channel (`subscribeAny`) serves coarse consumers (the
 		* manager's list projection reads the `title` key).
@@ -733,41 +973,60 @@ window.__ModuleLoader__.load({
 			*/
 			apply(key, value, seq) {
 				const row = this.rows.get(key);
-				if (row !== void 0 && seq <= row.seq) return;
+				if (row?.kind === "sequenced" && seq <= row.seq) return;
 				this.rows.set(key, {
+					kind: "sequenced",
 					value,
 					seq
 				});
 				this.changed(key);
 			}
 			/**
-			* Seed from a history tail page's projections block: every carried key
-			* lands under the same seq rule as frames; a key the block omits is
-			* capability-absent as of the cut — its row clears unless a newer frame
-			* already superseded the cut (a stale baseline can neither overwrite nor
-			* clear newer values).
+			* Fill keys from a session-list block the Host labeled `cached`: a zero-I/O
+			* view of the persisted checkpoint. A cached value lands only where no
+			* sequenced row exists: a connected Session has already answered for such
+			* a key, and the list's view of the persisted checkpoint cannot be newer
+			* than it.
+			* @param values - whole values by key viewed from the persisted checkpoint.
+			*/
+			applyCached(values) {
+				for (const key of Object.keys(values)) {
+					if (this.rows.get(key)?.kind === "sequenced") continue;
+					this.rows.set(key, {
+						kind: "cached",
+						value: values[key]
+					});
+					this.changed(key);
+				}
+			}
+			/**
+			* Seed from a history tail page's projections block. Every cached row is
+			* discarded first, regardless of seq: the block comes from the connected
+			* Session, and a value viewed from the persisted checkpoint never outranks
+			* it. Then every carried key lands under the same seq rule as frames, and a
+			* key the block omits is capability-absent as of the cut — its row clears
+			* unless a newer frame already superseded the cut (a stale baseline can
+			* neither overwrite nor clear newer sequenced values).
 			* @param baseline - the response's projections block.
 			*/
 			seed(baseline) {
+				for (const [key, row] of this.rows) {
+					if (row.kind !== "cached") continue;
+					this.rows.delete(key);
+					this.changed(key);
+				}
 				const values = baseline.values;
 				for (const key of Object.keys(values)) this.apply(key, values[key], baseline.asOfSeq);
 				for (const [key, row] of this.rows) {
 					if (Object.hasOwn(values, key)) continue;
-					if (row.seq > baseline.asOfSeq) continue;
+					if (row.kind === "sequenced" && row.seq > baseline.asOfSeq) continue;
 					this.rows.delete(key);
 					this.changed(key);
 				}
 			}
-			/**
-			* Drop rows beyond a replacement control baseline. Such rows describe
-			* process state the Host lost before persisting it and would otherwise
-			* outrank recomputed lower-seq values forever. The caller seeds the new
-			* baseline immediately afterward.
-			* @param lastSeq - highest durable sequence reflected by the baseline.
-			*/
-			truncate(lastSeq) {
-				for (const [key, row] of this.rows) {
-					if (row.seq <= lastSeq) continue;
+			/** Discard one Host generation's values and watermarks while preserving subscribed faces. */
+			clear() {
+				for (const key of this.rows.keys()) {
 					this.rows.delete(key);
 					this.changed(key);
 				}
@@ -890,312 +1149,65 @@ window.__ModuleLoader__.load({
 				});
 			}
 			/**
-			* Prepend one older contiguous page.
-			* @param entries - newly loaded older entries.
-			* @param hasMore - whether still older history remains.
-			*/
-			prepend(entries, hasMore) {
-				this.window = concat(leaf(entries), this.window);
-				this.publish(hasMore, {
-					kind: "prepend",
-					entries
-				});
-			}
-			/**
-			* Append one contiguous live entry.
-			* @param entry - live tail entry.
-			*/
-			append(entry) {
-				const entries = [entry];
-				this.window = concat(this.window, leaf(entries));
-				this.publish(this.snapshot.hasMore, {
-					kind: "append",
-					entries
-				});
-			}
-			/**
-			* Replace one attempt's transient rows with its committed durable settlement.
-			* @param attemptId - process-local attempt whose live rows are now redundant.
-			* @param entry - durable settlement committed for that attempt.
-			*/
-			settleAssistant(attemptId, entry) {
-				const entries = materialize(this.window).filter((candidate) => candidate.type !== "transient" || candidate.event.data.attemptId !== attemptId);
-				if (entry !== void 0) {
-					const index = entries.findIndex((candidate) => candidate.event.seq > entry.event.seq);
-					if (index < 0) entries.push(entry);
-					else entries.splice(index, 0, entry);
-				}
-				this.window = leaf(entries);
-				this.publish(this.snapshot.hasMore, {
-					kind: "settle-assistant",
-					attemptId,
-					...entry === void 0 ? {} : { entry }
-				});
-			}
-			publish(hasMore, change) {
-				this.snapshot = windowSnapshot(this.window, hasMore, this.snapshot.revision + 1, change);
-				(0, _deepseek_ai_dsh_client_store.notifySubscribers)(this.listeners, "[session-controller] event feed");
-			}
-		};
-		//#endregion
-		//#region lib/types/client/time-zone.js
-		/** Browser-owned time-zone sampling for one prompt RPC. */
-		/**
-		* Resolve the current browser IANA zone for one outbound operation.
-		* @returns The browser-provided canonical zone.
-		* @throws when the runtime cannot provide a non-empty zone.
-		*/
-		function resolvedClientTimeZone() {
-			const timeZone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
-			if (typeof timeZone !== "string" || timeZone.length === 0) throw new Error("browser time zone is unavailable");
-			return timeZone;
-		}
-		//#endregion
-		//#region lib/types/client/sessions/queue-mirror.js
-		const QUEUE_PREVIEW_CHARS = 200;
-		function previewOf(content) {
-			const flat = content.filter((block) => block.type !== "image" && block.type !== "file").map((block) => block.type === "text" ? block.text : `[${block.type}]`).join(" ").replace(/\s+/g, " ").trim();
-			const chars = Array.from(flat);
-			return chars.length > QUEUE_PREVIEW_CHARS ? `${chars.slice(0, QUEUE_PREVIEW_CHARS).join("")}…` : flat;
-		}
-		function textOf(content) {
-			if (!content.every((block) => block.type === "text")) return null;
-			return content.map((block) => block.text).join("");
-		}
-		/** Authoritative transient queue projection and durable steering handoff. */
-		var SessionQueueMirror = class {
-			current = [];
-			/**
-			* Return the current immutable queue projection.
-			* @returns current queue rows.
-			*/
-			snapshot() {
-				return this.current;
-			}
-			/**
-			* Replace from one authoritative stream queue frame.
-			* @param items - complete host queue snapshot.
-			*/
-			replace(items) {
-				this.current = items.map((item) => {
-					const content = item.message.content;
-					return {
-						id: item.id,
-						messageId: item.message.id,
-						placement: item.placement,
-						...item.rpcId === void 0 ? {} : { rpcId: item.rpcId },
-						content,
-						preview: previewOf(content),
-						text: textOf(content)
-					};
-				});
-			}
-			/**
-			* Retire a transient steering row once its durable message enters the log.
-			* @param event - newly contiguous durable Session event.
-			* @returns whether the projection changed.
-			*/
-			acceptDurable(event) {
-				if (event.type !== "user/message") return false;
-				const messageId = event.data.id;
-				const index = this.current.findIndex((item) => item.placement === "steering" && item.messageId === messageId);
-				if (index < 0) return false;
-				this.current = this.current.filter((_item, candidate) => candidate !== index);
-				return true;
-			}
-		};
-		//#endregion
-		//#region ../../util/values/lib/index.js
-		/** Whether a realm-owned intrinsic prototype is backed by its native constructor. */
-		function hasIntrinsicConstructor(prototype, name) {
-			const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
-			if (typeof constructor !== "function") return false;
-			try {
-				return constructor.name === name && constructor.prototype === prototype && Function.prototype.toString.call(constructor) === `function ${name}() { [native code] }`;
-			} catch {
-				return false;
-			}
-		}
-		/** Whether a candidate is one realm's intrinsic `Object.prototype`. */
-		function isIntrinsicObjectPrototype(value) {
-			return Object.getPrototypeOf(value) === null && hasIntrinsicConstructor(value, "Object");
-		}
-		/** Whether an array uses one realm's intrinsic `Array.prototype`, not a subclass or forged prototype. */
-		function hasPlainArrayPrototype(value) {
-			const prototype = Object.getPrototypeOf(value);
-			if (!Array.isArray(prototype) || !hasIntrinsicConstructor(prototype, "Array")) return false;
-			const objectPrototype = Object.getPrototypeOf(prototype);
-			return typeof objectPrototype === "object" && objectPrototype !== null && isIntrinsicObjectPrototype(objectPrototype);
-		}
-		/** Whether an object is a plain or null-prototype record from any JavaScript realm. */
-		function hasPlainObjectPrototype(value) {
-			const prototype = Object.getPrototypeOf(value);
-			return prototype === null || typeof prototype === "object" && isIntrinsicObjectPrototype(prototype);
-		}
-		/** Return every JSON-visible object key, or reject own data JSON would discard. */
-		function enumerableStringKeys(value) {
-			const keys = Reflect.ownKeys(value);
-			if (keys.some((key) => typeof key !== "string" || !Object.prototype.propertyIsEnumerable.call(value, key))) return void 0;
-			return keys;
-		}
-		/** Validate lossless JSON iteratively, optionally materializing a detached snapshot. */
-		function walkJsonValue(value, detach) {
-			const ancestors = /* @__PURE__ */ new Set();
-			let root;
-			const assign = (destination, item) => {
-				if (destination === void 0) return;
-				if (destination.kind === "root") root = item;
-				else if (destination.kind === "array") destination.target[destination.index] = item;
-				else Object.defineProperty(destination.target, destination.key, {
-					value: item,
-					enumerable: true,
-					configurable: true,
-					writable: true
-				});
-			};
-			const tasks = [{
-				kind: "visit",
-				value,
-				...detach ? { destination: { kind: "root" } } : {}
-			}];
-			for (let task = tasks.pop(); task !== void 0; task = tasks.pop()) {
-				if (task.kind === "leave") {
-					ancestors.delete(task.source);
-					continue;
-				}
-				if (task.kind === "array-item") {
-					if (!Object.prototype.hasOwnProperty.call(task.source, task.index)) return void 0;
-					tasks.push({
-						kind: "visit",
-						value: task.source[task.index],
-						...task.target === void 0 ? {} : { destination: {
-							kind: "array",
-							target: task.target,
-							index: task.index
-						} }
-					});
-					continue;
-				}
-				if (task.kind === "object-property") {
-					tasks.push({
-						kind: "visit",
-						value: task.source[task.key],
-						...task.target === void 0 ? {} : { destination: {
-							kind: "object",
-							target: task.target,
-							key: task.key
-						} }
-					});
-					continue;
-				}
-				const current = task.value;
-				if (current === null) {
-					assign(task.destination, null);
-					continue;
-				}
-				if (typeof current === "boolean" || typeof current === "string") {
-					assign(task.destination, current);
-					continue;
-				}
-				if (typeof current === "number") {
-					if (!Number.isFinite(current) || Object.is(current, -0)) return void 0;
-					assign(task.destination, current);
-					continue;
-				}
-				if (typeof current !== "object") return void 0;
-				if (ancestors.has(current)) return void 0;
-				if (Array.isArray(current)) {
-					if (!hasPlainArrayPrototype(current)) return void 0;
-					const length = current.length;
-					if (Reflect.ownKeys(current).length !== length + 1) return void 0;
-					const target = detach ? [] : void 0;
-					if (target !== void 0) assign(task.destination, target);
-					ancestors.add(current);
-					tasks.push({
-						kind: "leave",
-						source: current
-					});
-					for (let index = length - 1; index >= 0; index--) tasks.push({
-						kind: "array-item",
-						source: current,
-						index,
-						...target === void 0 ? {} : { target }
-					});
-					continue;
-				}
-				if (!hasPlainObjectPrototype(current)) return void 0;
-				const keys = enumerableStringKeys(current);
-				if (keys === void 0) return void 0;
-				const target = detach ? {} : void 0;
-				if (target !== void 0) assign(task.destination, target);
-				ancestors.add(current);
-				tasks.push({
-					kind: "leave",
-					source: current
-				});
-				for (let index = keys.length - 1; index >= 0; index--) {
-					const key = keys[index];
-					/* v8 ignore next -- the loop is bounded by the captured key count. */
-					if (key === void 0) return void 0;
-					tasks.push({
-						kind: "object-property",
-						source: current,
-						key,
-						...target === void 0 ? {} : { target }
-					});
-				}
-			}
-			return detach ? root : true;
-		}
-		/**
-		* Validate and detach lossless JSON in one read per property.
-		* @param value - candidate value to validate and detach.
-		* @returns the detached snapshot, or `undefined` when the value is not losslessly JSON-serializable.
-		*/
-		function snapshotJsonValue(value) {
-			return walkJsonValue(value, true);
-		}
-		/**
-		* Deep-freeze an object graph in place while leaving live AbortSignal objects mutable.
-		* @param value - value to freeze.
-		* @returns the same value after every reachable enumerable child is frozen.
-		*/
-		function deepFreeze(value) {
-			const seen = /* @__PURE__ */ new WeakSet();
-			const pending = [{
-				kind: "visit",
-				node: value
-			}];
-			while (pending.length > 0) {
-				const task = pending.pop();
-				/* v8 ignore next -- the loop condition guarantees one pending task. */
-				if (task === void 0) continue;
-				if (task.kind === "property") {
-					pending.push({
-						kind: "visit",
-						node: task.source[task.key]
-					});
-					continue;
-				}
-				const node = task.node;
-				if (node === null || typeof node !== "object") continue;
-				if (node instanceof AbortSignal) continue;
-				if (seen.has(node)) continue;
-				seen.add(node);
-				Object.freeze(node);
-				const keys = Object.keys(node);
-				for (let index = keys.length - 1; index >= 0; index--) {
-					const key = keys[index];
-					/* v8 ignore next -- the loop is bounded by the captured key count. */
-					if (key === void 0) continue;
-					pending.push({
-						kind: "property",
-						source: node,
-						key
-					});
+			* Prepend one older contiguous page.
+			* @param entries - newly loaded older entries.
+			* @param hasMore - whether still older history remains.
+			*/
+			prepend(entries, hasMore) {
+				this.window = concat(leaf(entries), this.window);
+				this.publish(hasMore, {
+					kind: "prepend",
+					entries
+				});
+			}
+			/**
+			* Append one contiguous live entry.
+			* @param entry - live tail entry.
+			*/
+			append(entry) {
+				const entries = [entry];
+				this.window = concat(this.window, leaf(entries));
+				this.publish(this.snapshot.hasMore, {
+					kind: "append",
+					entries
+				});
+			}
+			/**
+			* Replace one attempt's transient rows with its committed durable settlement.
+			* @param attemptId - process-local attempt whose live rows are now redundant.
+			* @param entry - durable settlement committed for that attempt.
+			*/
+			settleAssistant(attemptId, entry) {
+				const entries = materialize(this.window).filter((candidate) => candidate.type !== "transient" || candidate.event.data.attemptId !== attemptId);
+				if (entry !== void 0) {
+					const index = entries.findIndex((candidate) => candidate.event.seq > entry.event.seq);
+					if (index < 0) entries.push(entry);
+					else entries.splice(index, 0, entry);
 				}
+				this.window = leaf(entries);
+				this.publish(this.snapshot.hasMore, {
+					kind: "settle-assistant",
+					attemptId,
+					...entry === void 0 ? {} : { entry }
+				});
 			}
-			return value;
+			publish(hasMore, change) {
+				this.snapshot = windowSnapshot(this.window, hasMore, this.snapshot.revision + 1, change);
+				(0, _deepseek_ai_dsh_client_store.notifySubscribers)(this.listeners, "[session-controller] event feed");
+			}
+		};
+		//#endregion
+		//#region lib/types/client/time-zone.js
+		/** Browser-owned time-zone sampling for one prompt RPC. */
+		/**
+		* Resolve the current browser IANA zone for one outbound operation.
+		* @returns The browser-provided canonical zone.
+		* @throws when the runtime cannot provide a non-empty zone.
+		*/
+		function resolvedClientTimeZone() {
+			const timeZone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+			if (typeof timeZone !== "string" || timeZone.length === 0) throw new Error("browser time zone is unavailable");
+			return timeZone;
 		}
 		//#endregion
 		//#region ../../llm/llm/lib/types/assistant-stream.js
@@ -1527,8 +1539,8 @@ window.__ModuleLoader__.load({
 			jumpTargetSeq = null;
 			/** The running jump loop's completion, shared by retargeting callers. */
 			jumpPromise = null;
-			/** Authoritative stream-only inbox snapshot; pending work never hits history. */
-			queueMirror = new SessionQueueMirror();
+			pendingHistory = null;
+			stopObservingInbox;
 			assistantStream = new ClientAssistantStream();
 			running = false;
 			address;
@@ -1541,7 +1553,7 @@ window.__ModuleLoader__.load({
 			promptAttempted = false;
 			/** A first accepted prompt stays in the engaging phase until its turn is observable. */
 			firstPromptPendingTurn = false;
-			/** Empty-log mirror (see ConversationSnapshot.blank); unknown bare sessions begin conservatively blank. */
+			/** New Session display state; unknown bare sessions begin conservatively blank. */
 			blankBit = true;
 			removed = false;
 			promptError = null;
@@ -1549,7 +1561,7 @@ window.__ModuleLoader__.load({
 			/** Local submission echoes, insertion-ordered (see SessionSnapshot.pendingSubmissions). */
 			pendingSubmissions = [];
 			/** Per-echo settlement state; `retiring` latches the first observation so a
-			*  queue frame and its durable event cannot both retire one echo. */
+			*  Inbox projection and its durable event cannot both retire one echo. */
 			submissionSettlements = /* @__PURE__ */ new Map();
 			/** Owns the addressed page/follow lifecycle while this Session is open. */
 			events;
@@ -1557,8 +1569,9 @@ window.__ModuleLoader__.load({
 			* Per-session projection value store (push model; see the session-projection
 			* subsystem page, docs/subsystems/session-projection.md): finished whole
 			* values computed on the Host, seeded by the tail page's
-			* projections block and updated by Session Controller control frames under the
-			* one higher-seq-wins rule. Keys are read via `projections.faceOf(key)`
+			* projections block and updated by Session Controller control frames;
+			* Host-sequenced writes merge under higher-seq-wins and cached list blocks
+			* yield to them (projection-store.ts). Keys are read via `projections.faceOf(key)`
 			* (the useProjection resolution face); the conversation snapshot never
 			* carries projection values, and no client-side domain folding exists.
 			* Manager-owned when constructed through SessionManager (frames route and
@@ -1594,6 +1607,9 @@ window.__ModuleLoader__.load({
 					this.snapshotCache = this.buildSnapshot();
 				});
 				this.snapshotCache = this.buildSnapshot();
+				this.stopObservingInbox = this.projections.faceOf("inbox").subscribe(() => {
+					this.observeSubmissionInbox();
+				});
 			}
 			/**
 			* Bind the Agent-scoped context minted by ClientSessions (single write;
@@ -1620,14 +1636,16 @@ window.__ModuleLoader__.load({
 			*/
 			beginSubmission(input) {
 				const requestId = randomUUID();
+				const placement = this.running ? input.mode === "steer" ? "steering" : "queued" : "transcript";
 				this.pendingSubmissions = [...this.pendingSubmissions, {
 					requestId,
-					placement: this.running ? input.mode === "steer" ? "steering" : "queued" : "transcript",
+					placement,
 					time: Date.now(),
 					text: input.text,
 					attachments: input.attachments
 				}];
 				this.submissionSettlements.set(requestId, {
+					placement,
 					onRetire: input.onRetire,
 					retiring: false
 				});
@@ -1695,9 +1713,9 @@ window.__ModuleLoader__.load({
 				}
 				if (this.blankBit) {
 					this.blankBit = false;
-					this.options.onEngaged?.(this);
 					this.notifier.markDirty();
 				}
+				this.options.onEngaged?.(this);
 				return result;
 			}
 			/**
@@ -1825,36 +1843,44 @@ window.__ModuleLoader__.load({
 					return this.jumpPromise;
 				}
 				if (this.loadingOlder) return Promise.resolve();
+				const events = this.events;
+				if (events === void 0) return Promise.resolve();
+				const pending = {
+					beforeSeq: this.baseSeq,
+					hasMore: this.hasMore,
+					pages: []
+				};
+				this.pendingHistory = pending;
 				this.jumpTargetSeq = seq;
 				this.loadingOlder = true;
 				this.notifier.markDirty();
 				const generation = this.openGeneration;
 				this.jumpPromise = (async () => {
 					try {
-						while (this.hasMore && this.jumpTargetSeq !== null && this.baseSeq > this.jumpTargetSeq) {
+						while (pending.hasMore && this.jumpTargetSeq !== null && pending.beforeSeq > this.jumpTargetSeq) {
 							if (generation !== this.openGeneration) return;
-							const events = this.events;
-							if (events === void 0) return;
-							const before = this.baseSeq;
+							const before = pending.beforeSeq;
 							await events.prepend({
-								beforeSeq: this.baseSeq,
+								beforeSeq: before,
 								maxMessages: 200
 							});
-							if (this.baseSeq >= before) return;
+							if (pending.beforeSeq >= before) return;
 						}
 					} catch (error) {
 						if (!(0, _deepseek_ai_dsh_api_gateway_client.isRemoteFailure)(error)) console.error("[session-controller] loadThrough failed:", error);
 					} finally {
 						this.jumpTargetSeq = null;
 						this.jumpPromise = null;
+						this.pendingHistory = null;
 						this.loadingOlder = false;
+						if (generation === this.openGeneration && pending.pages.length > 0) this.prependWindow(pending.pages.reverse().flat(), pending.hasMore);
 						this.notifier.markDirty();
 					}
 				})();
 				return this.jumpPromise;
 			}
 			/** Rebuild an opened history source after address replacement.
-			*  Invalidates any in-flight open first; queue state belongs to the independently
+			*  Invalidates any in-flight open first; projection state belongs to the independently
 			*  reconnecting control stream and remains untouched. */
 			async resync() {
 				if (this.openState === "cold") return;
@@ -1886,24 +1912,6 @@ window.__ModuleLoader__.load({
 				return this.snapshotCache;
 			}
 			/**
-			* Replace every transient control value for this Session from one stream baseline.
-			* @param queue - complete pending queue for this Session.
-			*/
-			replaceControl(queue) {
-				this.queueMirror.replace(queue);
-				this.observeSubmissionQueue(queue);
-				this.notifier.markDirty();
-			}
-			/**
-			* Apply one Session-addressed live control update.
-			* @param frame - queue replacement addressed to this Session.
-			*/
-			handleControlFrame(frame) {
-				this.queueMirror.replace(frame.items);
-				this.observeSubmissionQueue(frame.items);
-				this.notifier.markDirty();
-			}
-			/**
 			* Running-bit relay from the host stream (list entry and snapshot stay consistent).
 			* @param running - the new running state.
 			*/
@@ -1940,13 +1948,15 @@ window.__ModuleLoader__.load({
 				this.notifier.markDirty();
 			}
 			/**
-			* Blank-bit relay from the authoritative summary source (`session.list` and
-			* `api-session/added`). Monotone: once any signal (local first send,
-			* running flip, an earlier summary) cleared it, a stale true never
-			* re-blanks.
-			* @param blank - the summary's derived empty-log bit.
+			* Apply the Manager's effective display blank, further reconciled with the
+			* current `sessionListMetadata` projection. Local send attempts and current
+			* running state prevent re-blanking; an earlier false summary alone does not.
+			* The Manager retains acceptance and earlier running observations across
+			* Session-object replacement.
+			* @param blank - New Session display state after Manager reconciliation.
 			*/
 			handleBlank(blank) {
+				blank = blank && this.projections.values().sessionListMetadata?.blank !== false;
 				if (blank === this.blankBit) return;
 				if (blank && (this.promptAttempted || this.running)) return;
 				this.blankBit = blank;
@@ -1970,6 +1980,7 @@ window.__ModuleLoader__.load({
 			* @returns when the Remote iterator has completed teardown.
 			*/
 			async dispose() {
+				this.stopObservingInbox();
 				for (const requestId of [...this.submissionSettlements.keys()]) this.retireFailedSubmission(requestId);
 				this.openGeneration++;
 				const events = this.events;
@@ -2025,10 +2036,22 @@ window.__ModuleLoader__.load({
 				const visible = this.assistantStream.replace(entries, assistantStream);
 				this.baseSeq = SessionLogOffset(entries[0]?.event.seq ?? 0);
 				this.hasMore = hasMore;
+				if (this.pendingHistory !== null) {
+					this.pendingHistory.beforeSeq = this.baseSeq;
+					this.pendingHistory.hasMore = hasMore;
+					this.pendingHistory.pages.length = 0;
+				}
 				if (visible.some((entry) => entry.event.type === "turn/start")) this.firstPromptPendingTurn = false;
 				if (projections !== void 0) this.projections.seed(projections);
 				this.eventSource.replace(visible, hasMore);
+				if (projections !== void 0) {
+					for (const [requestId, { receipt }] of this.submissionSettlements) if (receipt !== void 0 && receipt.seq <= projections.asOfSeq) this.scheduleObservedRetirement(requestId, receipt.attachments);
+				}
 				for (const entry of visible) this.observeSubmissionEvent(entry.event);
+				if (projections !== void 0) {
+					const inbox = projections.values.inbox;
+					this.observeSteeringInsertions(inbox?.["next-step"] ?? [], 0, projections.asOfSeq);
+				}
 				this.notifier.markDirty();
 			}
 			publishAssistantEntry(result) {
@@ -2058,6 +2081,13 @@ window.__ModuleLoader__.load({
 			}
 			/** Prepend one stream-validated history page. */
 			prependWindow(entries, hasMore) {
+				if (this.pendingHistory !== null) {
+					const pending = this.pendingHistory;
+					pending.beforeSeq = entries[0] === void 0 ? pending.beforeSeq : SessionLogOffset(entries[0].event.seq);
+					pending.hasMore = hasMore;
+					pending.pages.push(entries);
+					return;
+				}
 				this.baseSeq = entries[0] === void 0 ? this.baseSeq : SessionLogOffset(entries[0].event.seq);
 				this.hasMore = hasMore;
 				this.eventSource.prepend(entries, hasMore);
@@ -2067,23 +2097,63 @@ window.__ModuleLoader__.load({
 				const event = entry.event;
 				const awaitingFirstTurn = this.firstPromptPendingTurn;
 				if (event.type === "turn/start") this.firstPromptPendingTurn = false;
-				const queueChanged = this.queueMirror.acceptDurable(event);
 				this.eventSource.append(entry);
 				this.observeSubmissionEvent(event);
-				return queueChanged || awaitingFirstTurn !== this.firstPromptPendingTurn;
+				return awaitingFirstTurn !== this.firstPromptPendingTurn;
 			}
-			/** Retire the matching echo when a durable browser-prompt `user/message` becomes visible. */
+			/** Observe durable acceptance even when insertion and claim share one projection notification. */
 			observeSubmissionEvent(event) {
-				if (this.submissionSettlements.size === 0 || event.type !== "user/message") return;
-				const data = event.data;
-				const source = data?.source;
-				if (source?.kind !== "user" || typeof source.rpcId !== "string") return;
-				this.scheduleObservedRetirement(source.rpcId, attachmentRefsIn(data?.content));
-			}
-			/** Retire echoes whose prompts landed in the host inbox instead of the log (running-turn submissions). */
-			observeSubmissionQueue(items) {
 				if (this.submissionSettlements.size === 0) return;
-				for (const item of items) if (item.rpcId !== void 0) this.scheduleObservedRetirement(item.rpcId, attachmentRefsIn(item.message.content));
+				if (event.type === "agent/inbox/spliced") {
+					const { target, start, removedCount = 0, inserted, outcome } = event.data;
+					if (target === "next-step") {
+						for (const [requestId, settlement] of this.submissionSettlements) {
+							const receipt = settlement.receipt;
+							if (receipt === void 0 || receipt.index === null || receipt.seq >= event.seq) continue;
+							const removed = receipt.index >= start && receipt.index < start + removedCount;
+							if (removed && outcome === "canceled") this.retireFailedSubmission(requestId);
+							else settlement.receipt = {
+								...receipt,
+								seq: event.seq,
+								index: removed ? null : receipt.index < start ? receipt.index : receipt.index + inserted.length - removedCount
+							};
+						}
+						this.observeSteeringInsertions(inserted, start, event.seq);
+					}
+					for (const message of inserted) this.observeSubmissionMessage(message, false);
+					return;
+				}
+				if (event.type === "request/context" || event.type === "turn/end") {
+					for (const [requestId, settlement] of this.submissionSettlements) if (settlement.receipt?.index === null && settlement.receipt.seq < event.seq) this.retireFailedSubmission(requestId);
+					return;
+				}
+				if (event.type === "user/message") this.observeSubmissionMessage(event.data, true);
+			}
+			observeSteeringInsertions(messages, start, seq) {
+				for (const [index, message] of messages.entries()) {
+					const source = message.source;
+					if (source.kind !== "user" || !("rpcId" in source)) continue;
+					const settlement = this.submissionSettlements.get(source.rpcId);
+					if (settlement?.placement !== "steering" || settlement.retiring || (settlement.receipt?.seq ?? -1) > seq) continue;
+					settlement.receipt = {
+						seq,
+						index: start + index,
+						attachments: attachmentRefsIn(message.content)
+					};
+				}
+			}
+			observeSubmissionMessage(message, admitted) {
+				const source = message.source;
+				if (source.kind !== "user" || !("rpcId" in source)) return;
+				if (!admitted && this.submissionSettlements.get(source.rpcId)?.placement === "steering") return;
+				this.scheduleObservedRetirement(source.rpcId, attachmentRefsIn(message.content));
+			}
+			/** Retire non-steering echoes when the Inbox accepts their queue occurrences. */
+			observeSubmissionInbox() {
+				if (this.submissionSettlements.size === 0) return;
+				const inbox = this.projections.get("inbox");
+				if (inbox === void 0) return;
+				for (const message of [...inbox["next-turn"], ...inbox["next-step"]]) this.observeSubmissionMessage(message, false);
 			}
 			/**
 			* Latch one observed settlement and remove the echo an animation frame
@@ -2132,13 +2202,16 @@ window.__ModuleLoader__.load({
 				this.notifier.markDirty();
 			}
 			buildSnapshot() {
+				const identity = this.projections.values().subagent;
 				return {
 					sessionId: this.sessionId,
-					queue: this.queueMirror.snapshot(),
 					pendingSubmissions: this.pendingSubmissions,
 					running: this.running,
 					subagent: this.address === void 0 ? null : {
-						address: this.address,
+						address: this.address.mode === "unknown" && identity != null ? {
+							...this.address,
+							mode: identity.mode
+						} : this.address,
 						...this.parentAvailable === void 0 ? {} : { parentAvailable: this.parentAvailable }
 					},
 					removed: this.removed,
@@ -2183,28 +2256,25 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region lib/types/client/sessions/manager.js
+		/** Host catalog, durable projection caches, and explicitly retained Client instances. */
 		function sessionSeqCursor(value) {
 			return value === -1 ? -1 : SessionSeq(value);
 		}
-		function catalogAvailability(parentAvailable) {
-			return parentAvailable === void 0 ? {} : { parentAvailable };
-		}
 		/** Instance cluster + frame entry + the session list. */
 		var SessionManager = class {
 			remote;
 			sessions = /* @__PURE__ */ new Map();
 			/** In-flight Session disposals remain here after instances leave `sessions`, so manager disposal can await quiescence. */
 			sessionDisposals = /* @__PURE__ */ new Set();
-			/** Latest transient queues, retained independently of Session object materialization. */
-			queues = /* @__PURE__ */ new Map();
 			/**
-			* Sessions that finished running while not selected — the sidebar's green
-			* "done" reminder (manager-owned, survives connection generations; cleared
-			* on select and session-removed, re-armed by the next completion).
+			* Accepted/running presentation must survive a later empty-history list
+			* response. Host-asserted running is recorded even before a row, instance, or
+			* address holds the identity — the listing that would hold it may not have
+			* landed yet — while the client-local acceptance callback requires a current
+			* holder, because it can arrive from a replaced or already-dropped Session.
 			*/
-			completedNotifications = /* @__PURE__ */ new Set();
-			/** Last-observed running bits per session; the true→false edge here arms {@link completedNotifications}. */
-			prevRunning = /* @__PURE__ */ new Map();
+			engagedSessions = /* @__PURE__ */ new Set();
+			disposed = false;
 			/** Per-session projection value stores, retained independently of instance arrival (the
 			*  title-snapshot precedent, generalized): push frames land here whether or not the Session
 			*  is instantiated (list rows read the 'title' key), and an instantiated Session adopts the
@@ -2216,22 +2286,11 @@ window.__ModuleLoader__.load({
 			listPhase = "pending";
 			listError = null;
 			listInflight = null;
-			/** Mutations arriving after a list request starts are replayed over its response. */
+			/** Active list request's mutation log; its identity also fences completion after reconnect. */
 			listMutations = null;
 			addresses = /* @__PURE__ */ new Map();
-			catalogs = /* @__PURE__ */ new Map();
-			catalogInflight = /* @__PURE__ */ new Map();
-			/** Catalog owners whose membership changed while a pull was in flight: one trailing refresh after it settles. */
-			catalogStale = /* @__PURE__ */ new Set();
-			openCatalogs = /* @__PURE__ */ new Set();
-			catalogDebounce = /* @__PURE__ */ new Map();
-			/**
-			* Background jobs per session, last-wins from Session Controller's control
-			* stream. An empty set is stored as an absent key, so absence and `[]` are
-			* one representation.
-			*/
-			jobsBySession = /* @__PURE__ */ new Map();
-			selected;
+			projectionLoads = /* @__PURE__ */ new Map();
+			projectionInflight = /* @__PURE__ */ new Map();
 			listSnapshotCache;
 			/** Entry-identity cache (reference stability): list rebuilds reuse the previous entry
 			*  object when every field matches — wire refreshes mint all-new summary objects, so identity
@@ -2241,69 +2300,35 @@ window.__ModuleLoader__.load({
 			notifier = new Notifier(() => {
 				this.listSnapshotCache = this.buildListSnapshot();
 			});
-			/**
-			* @param remote - generated Remote namespaces the Session cluster calls.
-			* @param restoredSelection - persisted real-Session selection candidate.
-			*/
-			constructor(remote, restoredSelection, restoredAddress) {
+			/** @param remote - generated Remote namespaces used by catalog and history readers. */
+			constructor(remote) {
 				this.remote = remote;
-				this.selected = restoredSelection;
-				if (restoredAddress !== void 0) this.addresses.set(restoredAddress.childSessionId, restoredAddress);
 				this.listSnapshotCache = this.buildListSnapshot();
 			}
 			/**
-			* Select a listed Session or a retained catalog-addressed child.
-			* @param sessionId - listed or catalog-addressed Session id.
-			*/
-			select(sessionId) {
-				const address = this.navigationAddress(sessionId);
-				if (!this.summaries.some((summary) => summary.sessionId === sessionId) && address === void 0) throw new Error(`sessions.select: unknown session ${sessionId}`);
-				if (address !== void 0) this.addresses.set(sessionId, address);
-				this.sessions.get(sessionId)?.configureSubagent(address, address === void 0 ? void 0 : this.catalogs.get(address.parentSessionId)?.parentAvailable);
-				this.selected = sessionId;
-				this.completedNotifications.delete(sessionId);
-				this.refreshSubagents(sessionId);
-				this.notifier.notifyNow();
-			}
-			/**
-			* Select a healthy child through its durable direct-parent address.
-			* @param address - catalog-derived parent and child ids.
-			*/
-			selectSubagent(address) {
-				const catalog = this.catalogs.get(address.parentSessionId);
-				const entry = catalog?.entries.find((candidate) => candidate.id === address.childSessionId);
-				if (entry === void 0 || entry.kind !== "child" || entry.mode !== address.mode) throw new Error(`sessions.selectSubagent: ${address.childSessionId} is not a healthy catalog child`);
-				this.addresses.set(address.childSessionId, address);
-				this.sessions.get(address.childSessionId)?.configureSubagent(address, catalog?.parentAvailable);
-				this.selected = address.childSessionId;
-				this.completedNotifications.delete(address.childSessionId);
-				this.refreshSubagents(address.childSessionId);
-				this.notifier.notifyNow();
-			}
-			/** Clear the selection (the layout falls to the no-session view state). */
-			clearSelection() {
-				this.selected = void 0;
-				this.notifier.notifyNow();
-			}
-			/**
-			* Return the durable catalog address retained for one child.
-			* @param sessionId - possible addressed child id.
-			* @returns The direct-parent address, when navigation discovered one.
+			* Resolve an acquisition target without materializing a Session.
+			* @param target - known identity or durable direct-parent address.
+			* @returns the resolved identity with its explicit or catalog-derived history route installed.
 			*/
-			subagentAddress(sessionId) {
-				return this.addresses.get(sessionId);
+			resolveTarget(target) {
+				const id = typeof target === "string" ? target : target.childSessionId;
+				const address = typeof target === "string" ? this.subagentAddress(id) : target;
+				if (typeof target === "string" && !this.sessions.has(id) && !this.summaries.some((summary) => summary.sessionId === id) && address === void 0) throw new Error(`sessions.retain: unknown session ${id}`);
+				if (address !== void 0) this.addresses.set(id, address);
+				this.sessions.get(id)?.configureSubagent(address, address === void 0 ? void 0 : this.agentAvailable(address.parentSessionId));
+				return id;
 			}
 			/**
 			* Resolve an address for breadcrumb navigation without retaining transport authority.
 			* @param sessionId - possible child id in an already-loaded catalog.
 			* @returns A retained or catalog-derived direct-parent address.
 			*/
-			navigationAddress(sessionId) {
+			subagentAddress(sessionId) {
 				const retained = this.addresses.get(sessionId);
 				if (retained !== void 0) return retained;
-				for (const [parentSessionId, catalog] of this.catalogs) {
-					const child = catalog.entries.find((entry) => entry.kind === "child" && entry.id === sessionId);
-					if (child?.kind === "child") return {
+				for (const parentSessionId of this.projectionStores.keys()) {
+					const child = this.projectionStores.get(parentSessionId)?.values().subagentCatalog?.find((entry) => entry.id === sessionId);
+					if (child !== void 0) return {
 						parentSessionId,
 						childSessionId: sessionId,
 						mode: child.mode
@@ -2311,27 +2336,35 @@ window.__ModuleLoader__.load({
 				}
 			}
 			/**
-			* Drop a session instance (scope-prune companion: instance
-			* and scope share one lifecycle). The host session log is the durable
-			* truth — a later get() lazily rebuilds and open() backfills history.
-			* @param sessionId - the session to drop.
+			* Withdraw an exact Client instance before running its teardown callbacks.
+			* @param sessionId - identity to withdraw.
+			* @param expected - instance being released; a replacement is left untouched.
+			* @returns completion of the detached instance's stream teardown.
 			*/
-			async drop(sessionId) {
+			drop(sessionId, expected) {
 				const session = this.sessions.get(sessionId);
+				if (session !== expected) return Promise.resolve();
 				this.sessions.delete(sessionId);
-				if (session !== void 0) await this.startSessionDisposal(session);
+				this.addresses.delete(sessionId);
+				this.pruneEngagement(sessionId, this.retainedIds(this.summaries));
+				return this.startSessionDisposal(session);
 			}
 			/**
-			* Stop owned timers and every remaining Session instance.
-			* @returns when every Session Remote iterator has completed teardown.
+			* Stop catalog requests and dispose every resident Session.
+			* @returns once catalog requests and every Session stream have stopped.
 			*/
 			async dispose() {
-				for (const timer of this.catalogDebounce.values()) clearTimeout(timer);
-				this.catalogDebounce.clear();
-				this.catalogStale.clear();
-				this.openCatalogs.clear();
+				this.disposed = true;
+				this.listMutations = null;
+				this.listInflight = null;
+				this.engagedSessions.clear();
+				const reads = [...this.projectionInflight.values()];
+				for (const { controller } of reads) controller.abort();
+				this.projectionInflight.clear();
+				await Promise.all(reads.map((read) => read.promise));
 				const sessions = [...this.sessions.values()];
 				this.sessions.clear();
+				this.addresses.clear();
 				for (const session of sessions) this.startSessionDisposal(session);
 				await this.drainSessionDisposals();
 			}
@@ -2350,7 +2383,8 @@ window.__ModuleLoader__.load({
 			}
 			/**
 			* Lazy build: return the existing instance or construct one (no auto-open —
-			* open is triggered by the container's select callback).
+			* the reference allocator opens history after binding the scope).
+			* New instances reconcile retained metadata before returning.
 			* @param sessionId - the session to get.
 			* @returns the resident instance.
 			*/
@@ -2359,45 +2393,73 @@ window.__ModuleLoader__.load({
 				if (session === void 0) {
 					session = this.createSession(sessionId);
 					this.sessions.set(sessionId, session);
-					session.replaceControl(this.queues.get(sessionId) ?? []);
 					const summary = this.summaries.find((s) => s.sessionId === sessionId);
 					if (summary !== void 0) {
-						session.handleBlank(summary.blank);
+						session.handleBlank(this.effectiveBlank(summary));
 						session.handleRunning(summary.running);
 					} else {
 						const address = this.addresses.get(sessionId);
-						const child = address === void 0 ? void 0 : this.catalogs.get(address.parentSessionId)?.entries.find((entry) => entry.kind === "child" && entry.id === sessionId);
-						if (child?.kind === "child") {
+						if ((address === void 0 ? void 0 : this.projectionStores.get(address.parentSessionId)?.values().subagentCatalog?.find((entry) => entry.id === sessionId)) !== void 0) {
 							session.handleBlank(false);
-							session.handleRunning(child.activity === "running");
-						}
+							session.handleRunning(false);
+						} else session.handleBlank(true);
 					}
 				}
 				return session;
 			}
 			createSession(sessionId) {
 				const address = this.addresses.get(sessionId);
-				const parentAvailable = address === void 0 ? void 0 : this.catalogs.get(address.parentSessionId)?.parentAvailable;
+				const parentAvailable = address === void 0 ? void 0 : this.agentAvailable(address.parentSessionId);
 				return new Session(sessionId, this.remote, {
 					...address === void 0 ? {} : {
 						address,
-						...catalogAvailability(parentAvailable)
+						...parentAvailable === void 0 ? {} : { parentAvailable }
 					},
 					onEngaged: (engaged) => {
-						this.recordMutation({
-							kind: "engaged",
-							sessionId: engaged.sessionId
-						});
+						if (this.disposed || !this.retainedIds(this.summaries).has(engaged.sessionId)) return;
+						if (!this.engagedSessions.has(engaged.sessionId)) {
+							this.engagedSessions.add(engaged.sessionId);
+							this.recordMutation({
+								kind: "engaged",
+								sessionId: engaged.sessionId
+							});
+						}
+						this.sessions.get(engaged.sessionId)?.handleBlank(false);
 					},
 					projections: this.projectionStore(sessionId)
 				});
 			}
+			effectiveBlank(summary) {
+				return summary.blank && !this.engagedSessions.has(summary.sessionId);
+			}
+			/**
+			* Identities an engagement may still belong to: the given list rows, resident
+			* Session instances, and retained child addresses.
+			* @param summaries - list rows of the caller's snapshot.
+			* @returns the retained identity set.
+			*/
+			retainedIds(summaries) {
+				const retained = new Set(summaries.map((summary) => summary.sessionId));
+				for (const sessionId of this.sessions.keys()) retained.add(sessionId);
+				for (const sessionId of this.addresses.keys()) retained.add(sessionId);
+				return retained;
+			}
+			/**
+			* Forget one engagement that no retained identity holds.
+			* @param sessionId - identity whose engagement may be dropped.
+			* @param retained - identities from {@link retainedIds} for the caller's snapshot.
+			*/
+			pruneEngagement(sessionId, retained) {
+				if (!retained.has(sessionId)) this.engagedSessions.delete(sessionId);
+			}
 			/** Resident per-session projection store (create-on-demand; outlives instantiation). */
 			projectionStore(sessionId) {
 				let store = this.projectionStores.get(sessionId);
 				if (store === void 0) {
 					store = new ProjectionValueStore();
+					const projections = store;
 					store.subscribeAny(() => {
+						if (projections.values().sessionListMetadata?.blank === false) this.sessions.get(sessionId)?.handleBlank(false);
 						this.notifier.markDirty();
 					});
 					this.projectionStores.set(sessionId, store);
@@ -2405,85 +2467,70 @@ window.__ModuleLoader__.load({
 				return store;
 			}
 			/**
-			* Refresh one direct-child catalog, reusing its in-flight request.
-			* @param parentSessionId - catalog owner.
+			* Load a complete projection baseline once per connection; retry unsuccessful reads.
+			* @param sessionId - Session to inspect without opening its conversation.
+			* @returns completion of the current or newly started read.
 			*/
-			refreshSubagents(parentSessionId) {
-				const existing = this.catalogInflight.get(parentSessionId);
+			refreshProjections(sessionId) {
+				const existing = this.projectionInflight.get(sessionId);
 				if (existing !== void 0) return existing.promise;
-				const previous = this.catalogs.get(parentSessionId);
-				const expandableRows = /* @__PURE__ */ new Set();
-				const activityRows = /* @__PURE__ */ new Map();
-				this.catalogs.set(parentSessionId, {
-					entries: previous?.entries ?? [],
-					...previous?.parentAvailable === void 0 ? {} : { parentAvailable: previous.parentAvailable },
+				if (this.projectionLoads.get(sessionId)?.state === "ready") return Promise.resolve();
+				const controller = new AbortController();
+				const store = this.projectionStore(sessionId);
+				const initialValues = store.values();
+				this.projectionLoads.set(sessionId, {
 					state: "loading",
 					error: null
 				});
 				this.notifier.markDirty();
 				const operation = (async () => {
 					try {
-						const result = await this.remote.subagents.list(parentSessionId);
+						const result = await this.remote.session.projections({ sessionId }, controller.signal);
+						if (controller.signal.aborted) return;
 						if (result.ok) {
-							const parentAvailable = this.catalogInflight.get(parentSessionId)?.parentAvailableOverride ?? result.value.parentAvailable;
-							this.catalogs.set(parentSessionId, {
+							if (result.value !== null) store.seed({
 								...result.value,
-								entries: this.withCatalogMutations(result.value.entries, expandableRows, activityRows),
-								parentAvailable,
+								asOfSeq: sessionSeqCursor(result.value.asOfSeq)
+							});
+							else if (store.values() === initialValues) store.clear();
+							this.projectionLoads.set(sessionId, {
 								state: "ready",
 								error: null
 							});
-							for (const [childId, address] of this.addresses) {
-								if (address.parentSessionId !== parentSessionId) continue;
-								this.sessions.get(childId)?.handleSubagentParentAvailable(parentAvailable);
-							}
-						} else this.catalogs.set(parentSessionId, {
-							entries: this.withCatalogMutations(previous?.entries ?? [], expandableRows, activityRows),
-							...catalogAvailability(this.catalogInflight.get(parentSessionId)?.parentAvailableOverride ?? previous?.parentAvailable),
+						} else this.projectionLoads.set(sessionId, {
 							state: "error",
 							error: result.error
 						});
 					} catch (error) {
+						if (controller.signal.aborted) return;
 						if (!(0, _deepseek_ai_dsh_api_gateway_client.isRemoteFailure)(error)) throw error;
-						this.catalogs.set(parentSessionId, {
-							entries: this.withCatalogMutations(previous?.entries ?? [], expandableRows, activityRows),
-							...catalogAvailability(this.catalogInflight.get(parentSessionId)?.parentAvailableOverride ?? previous?.parentAvailable),
+						this.projectionLoads.set(sessionId, {
 							state: "error",
 							error
 						});
 					} finally {
-						this.catalogInflight.delete(parentSessionId);
-						if (this.catalogStale.delete(parentSessionId)) this.refreshSubagents(parentSessionId);
-						this.notifier.markDirty();
+						if (!controller.signal.aborted) {
+							this.projectionInflight.delete(sessionId);
+							this.notifier.markDirty();
+						}
 					}
 				})();
-				this.catalogInflight.set(parentSessionId, {
+				this.projectionInflight.set(sessionId, {
 					promise: operation,
-					expandableRows,
-					activityRows,
-					parentAvailableOverride: void 0
+					controller
 				});
 				return operation;
 			}
-			/**
-			* Mark whether a catalog menu is consuming live membership updates.
-			* @param parentSessionId - catalog owner.
-			* @param open - current menu state.
-			*/
-			setSubagentCatalogOpen(parentSessionId, open) {
-				if (open) {
-					this.openCatalogs.add(parentSessionId);
-					this.refreshSubagents(parentSessionId);
-				} else {
-					this.openCatalogs.delete(parentSessionId);
-					const timer = this.catalogDebounce.get(parentSessionId);
-					if (timer !== void 0) {
-						clearTimeout(timer);
-						this.catalogDebounce.delete(parentSessionId);
-					}
+			agentAvailable(sessionId) {
+				return this.summaries.find((summary) => summary.sessionId === sessionId)?.agentAvailable ?? (this.listPhase === "ready" ? false : void 0);
+			}
+			updateParentAvailability() {
+				for (const [childId, address] of this.addresses) {
+					const available = this.agentAvailable(address.parentSessionId);
+					if (available !== void 0) this.sessions.get(childId)?.handleSubagentParentAvailable(available);
 				}
 			}
-			/** Full refresh via session.list (single-flight: an in-flight call is reused). */
+			/** Full refresh via session.list (single-flight within one Host generation). */
 			refreshList() {
 				if (this.listInflight !== null) return this.listInflight;
 				this.listState = "loading";
@@ -2495,44 +2542,41 @@ window.__ModuleLoader__.load({
 				this.listInflight = (async () => {
 					try {
 						const result = await this.remote.session.list({});
+						if (this.listMutations !== mutations) return;
 						if (result.ok) {
 							const baseline = this.listPhase === "pending" ? [...result.value.items] : mergeOrderedBaseline(established, result.value.items, (summary) => summary.sessionId);
-							for (const s of baseline) if (!this.prevRunning.has(s.sessionId)) this.prevRunning.set(s.sessionId, s.running);
-							let summaries = baseline;
-							for (const mutation of mutations) {
-								summaries = applyMutation(summaries, mutation);
-								this.summaries = summaries;
-								this.syncCompletedNotifications();
-							}
+							const removedSincePull = /* @__PURE__ */ new Set();
+							for (const mutation of mutations) if (mutation.kind === "remove") removedSincePull.add(mutation.sessionId);
+							for (const s of baseline) if (s.running && !removedSincePull.has(s.sessionId)) this.engagedSessions.add(s.sessionId);
+							const summaries = mutations.reduce(applyMutation, baseline);
 							this.summaries = summaries;
+							const retained = this.retainedIds(summaries);
+							for (const sessionId of this.engagedSessions) this.pruneEngagement(sessionId, retained);
 							this.listState = "idle";
 							this.listPhase = "ready";
-							this.syncCompletedNotifications();
+							this.updateParentAvailability();
 							for (const s of this.summaries) {
 								const session = this.sessions.get(s.sessionId);
 								if (session === void 0) continue;
-								session.handleBlank(s.blank);
+								session.handleBlank(this.effectiveBlank(s));
 								session.handleRunning(s.running);
 							}
-							for (const s of result.value.items) {
-								const block = s.projections;
-								if (block === void 0) continue;
-								const store = this.projectionStore(s.sessionId);
-								const values = block.values;
-								for (const key of Object.keys(values)) store.apply(key, values[key], sessionSeqCursor(block.asOfSeq));
-							}
+							for (const s of result.value.items) if (s.projections !== void 0) this.applyListBlock(s.sessionId, s.projections);
 						} else {
 							this.listState = "error";
 							this.listError = result.error;
 						}
 					} catch (error) {
 						if (!(0, _deepseek_ai_dsh_api_gateway_client.isRemoteFailure)(error)) throw error;
+						if (this.listMutations !== mutations) return;
 						this.listState = "error";
 						this.listError = error;
 					} finally {
-						this.listMutations = null;
-						this.listInflight = null;
-						this.notifier.markDirty();
+						if (this.listMutations === mutations) {
+							this.listMutations = null;
+							this.listInflight = null;
+							this.notifier.markDirty();
+						}
 					}
 				})();
 				return this.listInflight;
@@ -2573,8 +2617,9 @@ window.__ModuleLoader__.load({
 				};
 				const result = await this.remote.session.create(payload);
 				if (result.ok) this.recordMutation({
-					kind: "upsert",
+					kind: "placeholder",
 					summary: {
+						agentAvailable: true,
 						sessionId: result.value.sessionId,
 						updatedAt: Date.now(),
 						running: false,
@@ -2585,8 +2630,9 @@ window.__ModuleLoader__.load({
 				else {
 					const publishedSessionId = workspaceAttachSessionId(result.error);
 					if (publishedSessionId !== void 0) this.recordMutation({
-						kind: "upsert",
+						kind: "placeholder",
 						summary: {
+							agentAvailable: true,
 							sessionId: publishedSessionId,
 							updatedAt: Date.now(),
 							running: false,
@@ -2598,11 +2644,12 @@ window.__ModuleLoader__.load({
 			}
 			/**
 			* Contract session.fork; on success merge the child into summaries
-			* immediately (same synchronous-addressability guarantee as create). The
-			* child carries the source's history, so it is never blank; lineage rides
-			* parentSessionId so the list nests it under its source. A child published
-			* before Workspace attachment fails is also reconciled into the list.
-			* @param opts - source session and the optional seq anchoring the cut.
+			* immediately (same synchronous-addressability guarantee as create).
+			* Blankness starts provisionally true so the authoritative Host summary can
+			* preserve it or lower it after an exact cut before the first `turn/start`;
+			* lineage rides parentSessionId. A child published before Workspace
+			* attachment fails is also reconciled into the list.
+			* @param opts - source session and the optional exact inclusive boundary seq.
 			* @returns the fork result (the child session id).
 			*/
 			async fork(opts) {
@@ -2613,12 +2660,13 @@ window.__ModuleLoader__.load({
 				});
 				const childId = result.ok ? result.value.sessionId : workspaceAttachSessionId(result.error);
 				if (childId !== void 0) this.recordMutation({
-					kind: "upsert",
+					kind: "placeholder",
 					summary: {
+						agentAvailable: true,
 						sessionId: childId,
 						updatedAt: Date.now(),
 						running: false,
-						blank: false,
+						blank: true,
 						parentSessionId: opts.sessionId,
 						...source?.cwd !== void 0 ? { cwd: source.cwd } : {}
 					}
@@ -2626,22 +2674,35 @@ window.__ModuleLoader__.load({
 				return result;
 			}
 			/**
-			* Insert-or-enrich a locally synthesized summary: a new id prepends; an
-			* existing entry only gains fields it lacks (the session-added frame and the
-			* create() echo race — whichever lands second must fill the placeholder's
-			* missing cwd/parentSessionId, never overwrite list-refresh data).
+			* Rename a Session and update its title projection without opening its history.
+			* @param sessionId - Session to rename.
+			* @param title - raw title text for Host normalization.
+			* @returns the accepted title and event position, or the Remote failure.
+			*/
+			async rename(sessionId, title) {
+				const result = await this.remote.session.rename({
+					sessionId,
+					title
+				});
+				if (result.ok) this.projectionStore(sessionId).apply("title", result.value.title, SessionSeq(result.value.seq));
+				return result;
+			}
+			/**
+			* Merge a Host summary, replacing live state and filling missing metadata.
+			* Local create/fork placeholders only fill metadata on an existing row.
 			*/
 			mergeSummary(summary) {
 				this.recordMutation({
 					kind: "upsert",
 					summary
 				});
+				this.updateParentAvailability();
 			}
 			/** Apply immediately and retain for replay when a list response is in flight. */
 			recordMutation(mutation) {
+				if (this.disposed) return;
 				this.listMutations?.push(mutation);
 				this.summaries = applyMutation(this.summaries, mutation);
-				this.syncCompletedNotifications();
 				this.notifier.markDirty();
 			}
 			/**
@@ -2661,6 +2722,14 @@ window.__ModuleLoader__.load({
 				return this.listSnapshotCache;
 			}
 			/**
+			* Read cached projection values for a Session that may exist only in a loaded subagent catalog.
+			* @param sessionId - Session whose control or history baseline supplied projections.
+			* @returns current values, or undefined before any projection store exists.
+			*/
+			projectionValues(sessionId) {
+				return this.projectionStores.get(sessionId)?.values();
+			}
+			/**
 			* Apply a complete control baseline or one later replacement frame.
 			* @param frame - baseline or live control replacement from Session Controller.
 			*/
@@ -2669,35 +2738,18 @@ window.__ModuleLoader__.load({
 					this.replaceControlBaseline(frame.value);
 					return;
 				}
-				if (frame.type === "projection") {
-					this.projectionStore(frame.sessionId).apply(frame.key, frame.value, SessionSeq(frame.seq));
-					this.notifier.markDirty();
-					return;
-				}
-				if (frame.type === "jobs") {
-					if (frame.jobs.length === 0) this.jobsBySession.delete(frame.sessionId);
-					else this.jobsBySession.set(frame.sessionId, frame.jobs);
-					this.notifier.markDirty();
-					return;
-				}
-				this.queues.set(frame.sessionId, frame.items);
-				this.sessions.get(frame.sessionId)?.handleControlFrame(frame);
+				this.projectionStore(frame.sessionId).apply(frame.key, frame.value, SessionSeq(frame.seq));
+				this.notifier.markDirty();
 			}
 			replaceControlBaseline(baseline) {
-				this.queues.clear();
-				for (const [sessionId, items] of Object.entries(baseline.queues)) this.queues.set(sessionId, items);
-				this.jobsBySession.clear();
-				for (const [sessionId, jobs] of Object.entries(baseline.jobs)) if (jobs.length > 0) this.jobsBySession.set(sessionId, jobs);
 				for (const [sessionId, block] of Object.entries(baseline.projections)) {
 					const store = this.projectionStore(sessionId);
 					const asOfSeq = sessionSeqCursor(block.asOfSeq);
-					store.truncate(asOfSeq);
 					store.seed({
 						...block,
 						asOfSeq
 					});
 				}
-				for (const [sessionId, session] of this.sessions) session.replaceControl(this.queues.get(sessionId) ?? []);
 				this.notifier.markDirty();
 			}
 			/**
@@ -2706,45 +2758,55 @@ window.__ModuleLoader__.load({
 			*/
 			handleSessionAdded(summary) {
 				this.mergeSummary(summary);
-				this.sessions.get(summary.sessionId)?.handleBlank(summary.blank);
-				const projections = summary.projections;
-				if (projections !== void 0) {
-					const store = this.projectionStore(summary.sessionId);
-					for (const [key, value] of Object.entries(projections.values)) store.apply(key, value, sessionSeqCursor(projections.asOfSeq));
+				if (!this.disposed && summary.running) this.engagedSessions.add(summary.sessionId);
+				this.sessions.get(summary.sessionId)?.handleBlank(this.effectiveBlank(summary));
+				if (summary.projections !== void 0) this.applyListBlock(summary.sessionId, summary.projections);
+			}
+			/**
+			* Merge one list-surface projection block by the sequence space it declares.
+			* A `sequenced` block came from the Host's live registry for an attached
+			* Session, so each key lands under higher-seq-wins against that Session's
+			* baselines and frames. A `cached` block was viewed from the persisted
+			* checkpoint by a header-only listing: its watermark is not comparable with
+			* this connection's seqs, so it only fills keys no sequenced row holds.
+			*/
+			applyListBlock(sessionId, block) {
+				const store = this.projectionStore(sessionId);
+				switch (block.kind) {
+					case "sequenced": {
+						const seq = sessionSeqCursor(block.asOfSeq);
+						for (const [key, value] of Object.entries(block.values)) store.apply(key, value, seq);
+						return;
+					}
+					case "cached":
+						store.applyCached(block.values);
+						return;
+					default: assertNever(block.kind, "session list projection block kind");
 				}
-				if (summary.origin === "subagent" && summary.parentSessionId !== void 0) this.markCatalogParentExpandable(summary.parentSessionId);
-				if (summary.parentSessionId !== void 0 && (this.selected === summary.parentSessionId || this.openCatalogs.has(summary.parentSessionId))) this.scheduleCatalogRefresh(summary.parentSessionId);
 			}
 			/**
 			* Apply one Session removal forwarded through `ctx.remote.$on`.
 			* @param sessionId - removed Session identity.
 			*/
 			handleSessionRemoved(sessionId) {
-				const durableSubagent = this.summaries.find((candidate) => candidate.sessionId === sessionId)?.origin === "subagent" || this.addresses.has(sessionId);
+				const durableSubagent = this.subagentAddress(sessionId) !== void 0 || this.summaries.some((summary) => summary.sessionId === sessionId && summary.origin === "subagent");
 				this.recordMutation(durableSubagent ? {
 					kind: "status",
 					sessionId,
-					running: false
+					running: false,
+					agentAvailable: false
 				} : {
 					kind: "remove",
 					sessionId
 				});
-				this.updateCatalogActivity(sessionId, false);
 				if (durableSubagent) this.sessions.get(sessionId)?.handleRunning(false);
 				else this.sessions.get(sessionId)?.handleRemoved();
-				this.queues.delete(sessionId);
-				this.jobsBySession.delete(sessionId);
-				if (!durableSubagent) this.projectionStores.delete(sessionId);
-				const inflightCatalog = this.catalogInflight.get(sessionId);
-				if (inflightCatalog !== void 0) {
-					inflightCatalog.parentAvailableOverride = false;
-					this.catalogStale.add(sessionId);
-				}
-				const ownedCatalog = this.catalogs.get(sessionId);
-				if (ownedCatalog !== void 0 && ownedCatalog.parentAvailable) this.catalogs.set(sessionId, {
-					...ownedCatalog,
-					parentAvailable: false
-				});
+				const catalog = this.projectionStores.get(sessionId)?.values().subagentCatalog;
+				if (!durableSubagent && (catalog === void 0 || catalog.length === 0)) this.projectionStores.delete(sessionId);
+				this.pruneEngagement(sessionId, this.retainedIds(this.summaries));
+				this.projectionInflight.get(sessionId)?.controller.abort();
+				this.projectionInflight.delete(sessionId);
+				this.projectionLoads.delete(sessionId);
 				for (const [childId, address] of this.addresses) if (address.parentSessionId === sessionId) this.sessions.get(childId)?.handleSubagentParentAvailable(false);
 			}
 			/**
@@ -2753,13 +2815,15 @@ window.__ModuleLoader__.load({
 			* @param running - current Agent running state.
 			*/
 			handleSessionStatus(sessionId, running) {
+				if (!this.disposed && running) this.engagedSessions.add(sessionId);
 				this.recordMutation({
 					kind: "status",
 					sessionId,
-					running
+					running,
+					agentAvailable: true
 				});
+				this.updateParentAvailability();
 				this.sessions.get(sessionId)?.handleRunning(running);
-				this.updateCatalogActivity(sessionId, running);
 			}
 			/**
 			* Advance Session-list activity from one user-authored durable message.
@@ -2783,165 +2847,87 @@ window.__ModuleLoader__.load({
 			}
 			/**
 			* Repair one re-established Host-event generation with queryable baselines.
+			* Discard old projection cuts before new queries, including cold Sessions
+			* absent from the process-local control baseline.
 			* Opened Session follow streams resume independently through API Gateway.
 			*/
 			handleConnected() {
+				for (const store of this.projectionStores.values()) store.clear();
+				this.listMutations = null;
+				this.listInflight = null;
 				this.refreshList();
-				const selectedAddress = this.selected === void 0 ? void 0 : this.addresses.get(this.selected);
-				if (selectedAddress !== void 0) this.refreshSubagents(selectedAddress.parentSessionId);
-				if (this.selected !== void 0) this.refreshSubagents(this.selected);
-				for (const parentSessionId of this.openCatalogs) this.refreshSubagents(parentSessionId);
-			}
-			/** Debounce membership refetches while one parent catalog is selected or open. */
-			scheduleCatalogRefresh(parentSessionId) {
-				if (this.catalogDebounce.has(parentSessionId)) return;
-				const timer = setTimeout(() => {
-					this.catalogDebounce.delete(parentSessionId);
-					if (this.catalogInflight.has(parentSessionId)) {
-						this.catalogStale.add(parentSessionId);
-						return;
-					}
-					this.refreshSubagents(parentSessionId);
-				}, 50);
-				this.catalogDebounce.set(parentSessionId, timer);
-			}
-			/** Apply one Agent-driver transition to loaded and in-flight catalogs. */
-			updateCatalogActivity(childSessionId, running) {
-				const activity = running ? "running" : "inactive";
-				for (const inflight of this.catalogInflight.values()) inflight.activityRows.set(childSessionId, activity);
-				let changed = false;
-				for (const [parentSessionId, catalog] of this.catalogs) {
-					if (!catalog.entries.some((entry) => entry.kind === "child" && entry.id === childSessionId && entry.activity !== activity)) continue;
-					const entries = catalog.entries.map((entry) => {
-						if (entry.kind !== "child" || entry.id !== childSessionId) return entry;
-						return {
-							...entry,
-							activity
-						};
-					});
-					changed = true;
-					this.catalogs.set(parentSessionId, {
-						...catalog,
-						entries
-					});
-				}
-				if (changed) this.notifier.markDirty();
-			}
-			/** Preserve and project a positive expandability hint after one direct subagent publishes. */
-			markCatalogParentExpandable(parentSessionId) {
-				this.applyCatalogParentExpandable(parentSessionId);
-				for (const inflight of this.catalogInflight.values()) inflight.expandableRows.add(parentSessionId);
-			}
-			/** Apply one positive expandability hint to every loaded catalog containing that unique row id. */
-			applyCatalogParentExpandable(parentSessionId) {
-				let changed = false;
-				for (const [catalogParentId, catalog] of this.catalogs) {
-					if (!catalog.entries.some((entry) => entry.kind === "child" && entry.id === parentSessionId && !entry.hasChildren)) continue;
-					const entries = catalog.entries.map((entry) => {
-						if (entry.kind !== "child" || entry.id !== parentSessionId || entry.hasChildren) return entry;
-						return {
-							...entry,
-							hasChildren: true
-						};
-					});
-					changed = true;
-					this.catalogs.set(catalogParentId, {
-						...catalog,
-						entries
-					});
-				}
-				if (changed) this.notifier.markDirty();
-			}
-			/** Fold request-local row mutations into one catalog result before publication. */
-			withCatalogMutations(entries, expandableRows, activityRows) {
-				return entries.map((entry) => {
-					if (entry.kind !== "child") return entry;
-					const activity = activityRows.get(entry.id);
-					if (!expandableRows.has(entry.id) && activity === void 0) return entry;
-					return {
-						...entry,
-						...expandableRows.has(entry.id) ? { hasChildren: true } : {},
-						...activity === void 0 ? {} : { activity }
-					};
-				});
-			}
-			/**
-			* Reconcile completion reminders against the latest summaries, eagerly after
-			* every mutation and pull (a snapshot-build-time pass would collapse
-			* consecutive status frames into one observation). A running→idle edge of a
-			* non-selected session arms its reminder; running disarms it; removal drops
-			* it. First observation only records the running bit — sessions already
-			* idle at load get no reminder.
-			*/
-			syncCompletedNotifications() {
-				const seen = /* @__PURE__ */ new Set();
-				for (const s of this.summaries) {
-					seen.add(s.sessionId);
-					const prev = this.prevRunning.get(s.sessionId);
-					if (prev === void 0) {
-						this.prevRunning.set(s.sessionId, s.running);
-						continue;
-					}
-					if (prev && !s.running) {
-						if (s.sessionId !== this.selected) this.completedNotifications.add(s.sessionId);
-					} else if (s.running) this.completedNotifications.delete(s.sessionId);
-					this.prevRunning.set(s.sessionId, s.running);
+				const parents = new Set(this.projectionLoads.keys());
+				for (const id of this.sessions.keys()) {
+					const address = this.addresses.get(id);
+					if (address !== void 0) parents.add(address.parentSessionId);
 				}
-				for (const id of this.prevRunning.keys()) if (!seen.has(id)) this.prevRunning.delete(id);
-				for (const id of this.completedNotifications) if (!seen.has(id)) this.completedNotifications.delete(id);
+				for (const { controller } of this.projectionInflight.values()) controller.abort();
+				this.projectionInflight.clear();
+				this.projectionLoads.clear();
+				for (const parentSessionId of parents) this.refreshProjections(parentSessionId);
 			}
 			buildListSnapshot() {
 				const items = flattenLineage(this.summaries.map((summary) => {
 					const projectionStore = this.projectionStores.get(summary.sessionId);
 					const title = projectionStore?.get("title");
 					const projectionValues = projectionStore?.values();
+					const metadata = projectionValues?.sessionListMetadata;
 					return {
 						...summary,
+						blank: this.effectiveBlank(summary) && metadata?.blank !== false,
+						updatedAt: Math.max(summary.updatedAt, metadata?.lastPromptAt ?? 0),
 						...typeof title === "string" && title !== "" ? { title } : {},
 						...projectionValues === void 0 ? {} : { projectionValues }
 					};
-				}), this.completedNotifications).map((entry) => {
+				})).map((entry) => {
 					const prev = this.entryCache.get(entry.sessionId);
-					if (prev !== void 0 && prev.updatedAt === entry.updatedAt && prev.running === entry.running && prev.blank === entry.blank && prev.parentSessionId === entry.parentSessionId && prev.cwd === entry.cwd && prev.origin === entry.origin && prev.title === entry.title && prev.depth === entry.depth && prev.projectionValues === entry.projectionValues && prev.completed === entry.completed) return prev;
+					if (prev !== void 0 && prev.updatedAt === entry.updatedAt && prev.running === entry.running && prev.blank === entry.blank && prev.parentSessionId === entry.parentSessionId && prev.cwd === entry.cwd && prev.origin === entry.origin && prev.title === entry.title && prev.depth === entry.depth && prev.projectionValues === entry.projectionValues) return prev;
 					this.entryCache.set(entry.sessionId, entry);
 					return entry;
 				});
-				for (const id of this.entryCache.keys()) if (!items.some((e) => e.sessionId === id)) this.entryCache.delete(id);
+				const itemIds = new Set(items.map((entry) => entry.sessionId));
+				for (const id of this.entryCache.keys()) if (!itemIds.has(id)) this.entryCache.delete(id);
 				if (!(items.length === this.itemsCache.length && items.every((e, i) => e === this.itemsCache[i]))) this.itemsCache = items;
-				const selected = this.selected;
-				const current = selected !== void 0 && (items.some((item) => item.sessionId === selected) || this.addresses.has(selected)) ? selected : void 0;
 				return {
 					items: this.itemsCache,
-					current,
 					state: this.listState,
 					phase: this.listPhase,
 					error: this.listError,
-					subagentsByParent: Object.fromEntries(this.catalogs),
-					jobsBySession: Object.fromEntries(this.jobsBySession),
-					currentAddress: current === void 0 ? void 0 : this.addresses.get(current)
+					projectionsBySession: Object.fromEntries([...this.projectionStores].map(([sessionId, store]) => [sessionId, {
+						values: store.values(),
+						state: "idle",
+						error: null,
+						...this.projectionLoads.get(sessionId)
+					}]))
 				};
 			}
 		};
 		/** Apply one list mutation without deriving display order. */
 		function applyMutation(summaries, mutation) {
 			switch (mutation.kind) {
-				case "upsert": {
+				case "upsert":
+				case "placeholder": {
 					const existing = summaries.find((summary) => summary.sessionId === mutation.summary.sessionId);
 					if (existing === void 0) return [mutation.summary, ...summaries];
 					const filled = {
 						...existing,
 						blank: existing.blank && mutation.summary.blank,
+						...mutation.kind === "upsert" ? {
+							agentAvailable: mutation.summary.agentAvailable,
+							running: mutation.summary.running
+						} : {},
 						...existing.cwd === void 0 && mutation.summary.cwd !== void 0 ? { cwd: mutation.summary.cwd } : {},
 						...existing.parentSessionId === void 0 && mutation.summary.parentSessionId !== void 0 ? { parentSessionId: mutation.summary.parentSessionId } : {},
 						...existing.origin === void 0 && mutation.summary.origin !== void 0 ? { origin: mutation.summary.origin } : {}
 					};
-					if (filled.cwd === existing.cwd && filled.parentSessionId === existing.parentSessionId && filled.origin === existing.origin && filled.blank === existing.blank) return [...summaries];
+					if (filled.cwd === existing.cwd && filled.parentSessionId === existing.parentSessionId && filled.origin === existing.origin && filled.blank === existing.blank && filled.agentAvailable === existing.agentAvailable && filled.running === existing.running) return [...summaries];
 					return summaries.map((summary) => summary.sessionId === mutation.summary.sessionId ? filled : summary);
 				}
 				case "remove": return summaries.filter((summary) => summary.sessionId !== mutation.sessionId);
-				case "status": return summaries.map((summary) => summary.sessionId === mutation.sessionId && (summary.running !== mutation.running || mutation.running && summary.blank) ? {
+				case "status": return summaries.map((summary) => summary.sessionId === mutation.sessionId && (summary.running !== mutation.running || summary.agentAvailable !== mutation.agentAvailable || mutation.running && summary.blank) ? {
 					...summary,
 					running: mutation.running,
+					agentAvailable: mutation.agentAvailable,
 					blank: summary.blank && !mutation.running
 				} : summary);
 				case "activity": return summaries.map((summary) => summary.sessionId === mutation.sessionId && mutation.updatedAt > summary.updatedAt ? {
@@ -3015,7 +3001,74 @@ window.__ModuleLoader__.load({
 			if (fullWidth?.[1] !== void 0 && fullWidth[2] !== void 0) return `${fullWidth[1]}（${BigInt(fullWidth[2]) + 1n}）`;
 			return `${title} (1)`;
 		}
-		/** Root sessions service: list store, current selection, object-layer manager, scope tree, bindings, and breadcrumb routes. */
+		/** Source labels are dictionary keys, including names also present on Object.prototype. */
+		function freezeRetainedBy(counts) {
+			Object.setPrototypeOf(counts, null);
+			return Object.freeze(counts);
+		}
+		const EMPTY_RETAIN_INFO = Object.freeze({
+			referenceCount: 0,
+			retainedBy: freezeRetainedBy({})
+		});
+		/** A cancelled waiter releases only its own reference, not the shared opening. */
+		async function waitForOpen(opening, signal) {
+			if (signal === void 0) return opening;
+			const aborted = Promise.withResolvers();
+			const onAbort = () => {
+				aborted.reject(signal.reason);
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+			try {
+				if (signal.aborted) onAbort();
+				await Promise.race([opening, aborted.promise]);
+			} finally {
+				signal.removeEventListener("abort", onAbort);
+			}
+		}
+		var ClientSessionReference = class {
+			sessionId;
+			record;
+			releaseReference;
+			released = new AbortController();
+			readiness = Promise.withResolvers();
+			ready = this.readiness.promise;
+			constructor(sessionId, record, releaseReference) {
+				this.sessionId = sessionId;
+				this.record = record;
+				this.releaseReference = releaseReference;
+				this.ready.catch(() => {});
+			}
+			get binding() {
+				if (this.record === void 0 || !this.record.live) throw new Error(`Session reference "${this.sessionId}" is released`);
+				return this.record.binding;
+			}
+			attachOpening(opening, signal) {
+				const waitSignal = signal === void 0 ? this.released.signal : AbortSignal.any([this.released.signal, signal]);
+				waitForOpen(opening, waitSignal).then(() => {
+					try {
+						waitSignal.throwIfAborted();
+						this.readiness.resolve(this.binding);
+					} catch (error) {
+						this.readiness.reject(error);
+					}
+				}, (error) => {
+					this.readiness.reject(error);
+				});
+			}
+			release() {
+				const reason = /* @__PURE__ */ new Error(`Session reference "${this.sessionId}" is released`);
+				const release = this.releaseReference;
+				this.released.abort(reason);
+				this.readiness.reject(reason);
+				this.record = void 0;
+				this.releaseReference = void 0;
+				release?.();
+			}
+			[Symbol.dispose]() {
+				this.release();
+			}
+		};
+		/** Host catalog and local reference allocator; view selection remains outside the Controller. */
 		var ClientSessions = class {
 			rootCtx;
 			/**
@@ -3025,115 +3078,109 @@ window.__ModuleLoader__.load({
 			* reports the same number.
 			*/
 			searchResultLimit = 20;
-			/** List snapshot store (list RPC + host stream increments; re-pulled on reconnect) — the useSessions standard feed, current included. */
+			/** Catalog metadata and local reference-source projection. */
 			list;
 			/** The object-layer instance cluster and frame dispatch entry. */
 			manager;
-			/**
-			* Persisted selection cell (the durable half of `list.current`). Private on
-			* purpose: reads go through the list snapshot; writes through {@link
-			* ClientSessions.open} / {@link ClientSessions.clear}. Projection
-			* validates it against the live list instead of destructively pruning, so a
-			* selection survives transient list states (reconnect re-pull) and
-			* resurfaces when its session returns.
-			*/
-			selection;
 			scopes = /* @__PURE__ */ new Map();
-			/** In-flight scope drops remain here after records leave `scopes`, so root disposal can await quiescence. */
+			/** Stable per-id sources retained for the Client root lifetime, including across generation replacement. */
+			retainObservers = /* @__PURE__ */ new Map();
 			scopeDrops = /* @__PURE__ */ new Set();
-			/**
-			* The staged session id — follows `list.current` exactly, holding its last
-			* defined value across masked gaps (a transiently absent selection blanks
-			* `current` without moving the stage, so reconnect re-pulls and removals
-			* keep the staged scope's frozen view alive until the stage moves on).
-			*/
-			watched;
-			/** Removed-while-staged sessions whose teardown waits for the stage to move away. */
-			deferredRemovals = /* @__PURE__ */ new Set();
+			closed = false;
 			/**
 			* @param ctx - client root context (scope fibers mount under it).
 			* @param remote - generated Remote namespaces shared with every Session.
 			*/
 			constructor(rootCtx, remote) {
 				this.rootCtx = rootCtx;
-				this.selection = (0, _deepseek_ai_dsh_client_store.createSnapshotStore)({}, { persist: { name: "dsh.sessions.current" } });
-				const restored = this.selection.getSnapshot();
-				this.manager = new SessionManager(remote, restored.sessionId, restored.subagentAddress);
+				this.manager = new SessionManager(remote);
 				this.list = (0, _deepseek_ai_dsh_client_store.createSnapshotStore)({
 					ids: [],
 					byId: {},
-					current: void 0,
 					phase: "pending",
-					subagentsByParent: {},
-					jobsBySession: {},
-					currentAddress: void 0
+					projectionsBySession: {}
 				});
 				const disposeManagerProjection = this.manager.subscribe(() => {
 					this.projectList();
 				});
-				const disposeStageFollower = this.list.subscribe(() => {
-					this.followCurrent();
-				});
 				rootCtx.effect(() => async () => {
-					disposeStageFollower();
+					this.closed = true;
 					disposeManagerProjection();
 					const scopes = [...this.scopes];
 					this.scopes.clear();
-					this.deferredRemovals.clear();
-					this.watched = void 0;
-					for (const [id, record] of scopes) this.startScopeDrop(id, record);
+					for (const [, record] of scopes) {
+						record.live = false;
+						record.session.unbindScope();
+					}
+					const managerDisposal = this.manager.dispose();
+					for (const [id, record] of scopes) {
+						this.startScopeDrop(id, record);
+						this.publishRetention(id);
+					}
 					await this.drainScopeDrops();
-					await this.manager.dispose();
+					await managerDisposal;
 				}, "session-controller.client.sessions");
 				rootCtx.reflect.provide("sessions", this, void 0);
 			}
-			/**
-			* Select a listed or retained catalog-addressed session as current.
-			* @param id - listed or addressed session id.
-			*/
-			open(id) {
-				this.manager.select(id);
+			retain(target, options) {
+				const { source, signal } = options;
+				signal?.throwIfAborted();
+				if (this.closed) throw new Error("Session Controller is disposed");
+				const id = this.manager.resolveTarget(target);
+				const reference = this.retainScope(id, source);
+				try {
+					reference.attachOpening(this.manager.get(id).open(), signal);
+					return reference;
+				} catch (error) {
+					reference.release();
+					throw error;
+				}
 			}
-			/**
-			* Open a healthy catalog child through its direct-parent address.
-			* @param address - catalog-derived parent and child ids.
-			*/
-			openSubagent(address) {
-				this.manager.selectSubagent(address);
+			async using(target, options, operation) {
+				const reference = this.retain(target, options);
+				try {
+					await reference.ready;
+					return await operation(reference);
+				} finally {
+					reference.release();
+				}
+			}
+			retainInfo(id) {
+				let observer = this.retainObservers.get(id);
+				if (observer === void 0) {
+					const listeners = /* @__PURE__ */ new Set();
+					observer = {
+						listeners,
+						published: this.retentionSnapshot(id),
+						source: {
+							getSnapshot: () => this.retentionSnapshot(id),
+							subscribe: (listener) => {
+								listeners.add(listener);
+								return () => {
+									listeners.delete(listener);
+								};
+							}
+						}
+					};
+					this.retainObservers.set(id, observer);
+				}
+				return observer.source;
 			}
 			/**
 			* Resolve an already discovered direct-parent address without opening it.
 			* Feature plugins use this to avoid Agent-bound RPCs in persisted child views.
 			* @param id - possible addressed child id.
-			* @returns The retained address, when present.
+			* @returns A retained or loaded-catalog address, without retaining a new selection or scope.
 			*/
 			subagentAddress(id) {
 				return this.manager.subagentAddress(id);
 			}
 			/**
-			* Inform the Session Controller whether a catalog menu is consuming membership updates.
-			* @param parentSessionId - selected parent.
-			* @param open - menu state.
-			*/
-			setSubagentCatalogOpen(parentSessionId, open) {
-				this.manager.setSubagentCatalogOpen(parentSessionId, open);
-			}
-			/**
-			* Refresh one direct-child catalog.
-			* @param parentSessionId - catalog owner.
-			*/
-			refreshSubagents(parentSessionId) {
-				return this.manager.refreshSubagents(parentSessionId);
-			}
-			/**
-			* Clear the current selection so the layout shows the no-session empty
-			* state (new-session affordance and the workspace preselection flow).
-			* Wipes the persisted selection too — a reload stays on empty until the
-			* user opens or starts a session. The staged scope keeps its frozen view
-			* per the masked-gap contract until the next open() moves the stage.
+			* Load all Session projections once per connection; retry an unsuccessful initial read.
+			* @param sessionId - Session to inspect without opening its conversation.
 			*/
-			clear() {
-				this.manager.clearSelection();
+			refreshProjections(sessionId) {
+				return this.manager.refreshProjections(sessionId);
 			}
 			/**
 			* Refresh the real Session baseline, reusing an in-flight pull.
@@ -3199,12 +3246,8 @@ window.__ModuleLoader__.load({
 				this.manager.handleConnected();
 			}
 			/**
-			* Create a session on the host. Resolution guarantee: by the time the
-			* promise resolves, the created session is in the list store and
-			* {@link ClientSessions.binding} resolves it — callers (New Session
-			* draft hand-off) may address the scope synchronously, without waiting a
-			* notifier flush. The synchronous projection below makes this structural
-			* rather than an accident of microtask ordering.
+			* Create a Host Session and publish its catalog row before resolving.
+			* Callers retain the returned identity before borrowing its binding.
 			* @param opts - target workspace or directory and an optional preallocated id.
 			* @returns the new session id.
 			* @throws {SessionCreateError} with the requested id.
@@ -3216,16 +3259,14 @@ window.__ModuleLoader__.load({
 				return result.value.sessionId;
 			}
 			/**
-			* Fork a session from a completed-turn prefix of the source (same
+			* Fork a session from an exact inclusive prefix of the source (same
 			* synchronous-addressability guarantee as {@link ClientSessions.create}:
-			* on resolution the child is in the list store and open() can target it).
-			* @param opts - source session id, the optional event seq anchoring the
-			*   cut (the boundary is the first turn/end at or after it; an in-log
-			*   anchor in an open turn is unavailable rather than clipped backward),
-			*   and whether to increment an inherited durable title before resolving.
-			*   A fractional anchor floors to a real event seq: the frozen nodes of an
-			*   interrupted turn carry flow-ordering seqs between two events, and the
-			*   wire takes integers only.
+			* on resolution the child is catalogued and may be explicitly retained).
+			* @param opts - source session id, the optional exact inclusive boundary
+			*   seq (a real event seq the caller already knows; a cut inside an open
+			*   turn is balanced Host-side with synthetic closers, and omission selects
+			*   the latest completed-turn prefix), and whether to increment an
+			*   inherited durable title before resolving.
 			* @returns the child session id.
 			* @throws {SessionForkError} with the source id.
 			* @throws {Error} when a requested child-title rename fails after creation.
@@ -3234,37 +3275,33 @@ window.__ModuleLoader__.load({
 				const sourceTitle = opts.increaseTitle ? this.list.getSnapshot().byId[opts.sessionId]?.title : void 0;
 				const result = await this.manager.fork({
 					sessionId: opts.sessionId,
-					...opts.atSeq === void 0 ? {} : { atSeq: SessionSeq(Math.floor(opts.atSeq)) }
+					...opts.atSeq === void 0 ? {} : { atSeq: SessionSeq(opts.atSeq) }
 				});
 				if (!result.ok) throw new SessionForkError(result.error, opts.sessionId);
 				this.projectList();
 				const childId = result.value.sessionId;
 				if (sourceTitle !== void 0) {
-					const child = this.binding(childId)?.session;
-					if (child === void 0) throw new Error(`fork child "${childId}" is not locally addressable`);
-					const renamed = await child.rename(increasedForkTitle(sourceTitle));
+					const renamed = await this.manager.rename(childId, increasedForkTitle(sourceTitle));
 					if (!renamed.ok) throw new Error(`fork child rename failed: ${renamed.error.code}: ${renamed.error.message}`);
 				}
 				return childId;
 			}
 			/**
-			* Resolve an Agent-scoped context view (use-and-discard).
+			* Borrow an already-retained Agent-scoped Context.
 			* @param id - session id (the agent identity — 1:1 same axis).
-			* @returns scoped ctx, or undefined for a session neither listed nor already scoped.
+			* @returns the scoped Context, or undefined without a retained generation.
 			*/
 			scope(id) {
-				return this.resolve(id)?.ctx;
+				return this.scopes.get(id)?.ctx;
 			}
 			/**
-			* Materialize the Agent scope named by a validated Host Remote Event.
-			* The first successful Session-list baseline becomes authoritative for its
-			* lifetime; until then, transport streams may address the scope in either
-			* arrival order.
-			* @param id - Host-projected Agent identity (the matching Session id).
-			* @returns the identity-stable Agent Context.
+			* Retain a validated Gateway identity synchronously, without history or catalog I/O.
+			* @param id - Host-projected Session identity, possibly not yet catalogued.
+			* @returns a Gateway-source reference owned by the invocation.
 			*/
-			resolveAgentScope(id) {
-				return (this.scopes.get(id) ?? this.materializeScope(id)).ctx;
+			retainAgentScope(id) {
+				if (this.closed) throw new Error("Session Controller is disposed");
+				return this.retainScope(id, "gateway");
 			}
 			/**
 			* Read the Agent scope tag off a context. Service-method boundary: fetch
@@ -3284,55 +3321,83 @@ window.__ModuleLoader__.load({
 			* `agent.session`). Same service-method boundary as
 			* {@link ClientSessions.scopeOf}.
 			* @param ctx - an Agent-scoped context.
-			* @returns the session face, or undefined when the ctx is untagged or its scope was pruned.
+			* @returns the matching live Session, or undefined for an untagged or ended generation.
 			*/
 			sessionOf(ctx) {
 				const id = scopeOf(ctx);
 				if (id === void 0) return void 0;
-				return this.scopes.get(id)?.binding.session;
+				const record = this.scopes.get(id);
+				return record !== void 0 && scopeIdentityOf(record.ctx) === scopeIdentityOf(ctx) ? record.binding.session : void 0;
 			}
 			/**
-			* Resolve the stable session binding (scope-addressed assembly feed). Pure
-			* resolution — no staging, no window side effects.
-			* @param id - session id.
-			* @returns binding, or undefined for a session neither listed nor already scoped.
+			* Borrow an already-retained binding without extending its lifetime.
+			* @param id - Session identity.
+			* @returns the live binding, or undefined without a retained generation.
 			*/
 			binding(id) {
-				return this.resolve(id)?.binding;
-			}
-			/**
-			* Move the stage to the list's current session: sweep teardowns deferred
-			* behind the previous occupant and pull the new occupant's history window.
-			* Staging IS the open signal — the window opens ⟺ the session is on stage
-			* — and open() is idempotent (an in-flight or completed open no-ops; a
-			* failed one retries the next time current is touched).
-			*/
-			followCurrent() {
-				const snapshot = this.list.getSnapshot();
-				const current = snapshot.current;
-				if (current === void 0 || snapshot.byId[current] === void 0 || current === this.watched) return;
-				this.watched = current;
-				this.sweepDeferred();
-				const record = this.resolve(current);
-				/* v8 ignore next 3 -- defensive: current is always a listed id (open()
-				* validates and the projection masks absent selections), so resolve
-				* cannot miss; kept so a future current writer cannot crash the notify. */
-				if (record !== void 0) {
-					record.session.open();
-					this.manager.refreshSubagents(current);
-				}
-			}
-			/**
-			* Lazily mint the scope + binding for an eligible session. Eligibility and
-			* prune share one predicate: listed on the host or selected
-			* through a retained subagent address. Breadcrumb-only ancestors remain
-			* summary data and do not keep scopes alive.
-			*/
-			resolve(id) {
-				const existing = this.scopes.get(id);
-				if (existing !== void 0) return existing;
-				if (!this.eligible(id)) return void 0;
-				return this.materializeScope(id);
+				return this.scopes.get(id)?.binding;
+			}
+			retainScope(id, source) {
+				const record = this.scopes.get(id) ?? this.materializeScope(id);
+				const previous = record.retention;
+				record.retention = Object.freeze({
+					referenceCount: previous.referenceCount + 1,
+					retainedBy: freezeRetainedBy({
+						...previous.retainedBy,
+						[source]: (previous.retainedBy[source] ?? 0) + 1
+					})
+				});
+				const reference = new ClientSessionReference(id, record, () => {
+					if (!record.live) return;
+					const count = record.retention.referenceCount - 1;
+					const { [source]: sourceCount = 0, ...otherSources } = record.retention.retainedBy;
+					const retainedBy = sourceCount > 1 ? {
+						...otherSources,
+						[source]: sourceCount - 1
+					} : otherSources;
+					record.retention = count === 0 ? EMPTY_RETAIN_INFO : Object.freeze({
+						referenceCount: count,
+						retainedBy: freezeRetainedBy(retainedBy)
+					});
+					if (count === 0) this.retireScope(id, record);
+					else this.publishRetention(id);
+				});
+				if (this.list.getSnapshot().byId[id] === void 0 && this.manager.subagentAddress(id) !== void 0) this.projectList();
+				this.publishRetention(id);
+				return reference;
+			}
+			retentionSnapshot(id) {
+				return this.scopes.get(id)?.retention ?? EMPTY_RETAIN_INFO;
+			}
+			publishRetention(id) {
+				const state = this.list.getSnapshot();
+				const row = state.byId[id];
+				const retainedBy = this.retentionSnapshot(id).retainedBy;
+				if (row !== void 0 && row.retainedBy !== retainedBy) this.list.set({
+					...state,
+					byId: {
+						...state.byId,
+						[id]: {
+							...row,
+							retainedBy
+						}
+					}
+				});
+				const observer = this.retainObservers.get(id);
+				const snapshot = this.retentionSnapshot(id);
+				if (observer === void 0 || observer.published === snapshot) return;
+				observer.published = snapshot;
+				(0, _deepseek_ai_dsh_client_store.notifySubscribers)(observer.listeners, "[session-controller] reference sources");
+			}
+			retireScope(id, record, disposeFiber = true) {
+				if (!record.live) return;
+				record.live = false;
+				if (this.scopes.get(id) === record) this.scopes.delete(id);
+				record.session.unbindScope();
+				const sessionDisposal = this.manager.drop(id, record.session);
+				this.projectList();
+				this.publishRetention(id);
+				this.startScopeDrop(id, record, disposeFiber, sessionDisposal);
 			}
 			/** Materialize one scope after its caller establishes that the id may be addressed. */
 			materializeScope(id) {
@@ -3348,19 +3413,20 @@ window.__ModuleLoader__.load({
 						eventSource: session.eventSource,
 						ctx
 					},
-					session
+					session,
+					retention: EMPTY_RETAIN_INFO,
+					live: true
 				};
 				this.scopes.set(id, record);
+				ctx.effect(() => () => {
+					this.retireScope(id, record, false);
+				}, "session-controller: exact generation");
 				return record;
 			}
-			/** The one aliveness predicate shared by scope mint and prune: host-listed or currently addressed. */
-			eligible(id) {
-				const { ids, current } = this.list.getSnapshot();
-				return current === id || ids.includes(id);
-			}
 			/** Project the manager's list snapshot into the store (title derivation is display-only). */
 			projectList() {
-				const { items, current, phase, subagentsByParent, jobsBySession, currentAddress } = this.manager.getListSnapshot();
+				const previousById = this.list.getSnapshot().byId;
+				const { items, phase, projectionsBySession } = this.manager.getListSnapshot();
 				const ids = [];
 				const byId = {};
 				for (const entry of items) {
@@ -3369,7 +3435,7 @@ window.__ModuleLoader__.load({
 						id: entry.sessionId,
 						displayTitle: displayTitleOf(entry.title, entry.cwd, entry.sessionId),
 						running: entry.running,
-						...entry.completed ? { completed: true } : {},
+						retainedBy: this.retentionSnapshot(entry.sessionId).retainedBy,
 						blank: entry.blank,
 						updatedAt: entry.updatedAt,
 						...entry.projectionValues === void 0 ? {} : { projectionValues: entry.projectionValues },
@@ -3379,68 +3445,67 @@ window.__ModuleLoader__.load({
 						...entry.origin !== void 0 ? { origin: entry.origin } : {}
 					};
 				}
-				if (current !== void 0 && currentAddress !== void 0) {
-					const seen = /* @__PURE__ */ new Set();
-					let address = currentAddress;
-					while (address !== void 0 && !seen.has(address.childSessionId)) {
-						const childId = address.childSessionId;
-						seen.add(childId);
-						const child = subagentsByParent[address.parentSessionId]?.entries.find((entry) => entry.kind === "child" && entry.id === childId);
-						if (child?.kind !== "child") break;
-						const displayTitle = child.label ?? childId;
-						const summary = byId[childId];
-						if (summary === void 0) byId[childId] = {
-							id: childId,
-							displayTitle,
-							parentId: address.parentSessionId,
-							origin: "subagent",
-							running: child.activity === "running",
-							blank: false,
+				for (const [parentId, projection] of Object.entries(projectionsBySession)) for (const child of projection.values.subagentCatalog ?? []) {
+					const childId = child.id;
+					const summary = byId[childId];
+					const projectionValues = summary?.projectionValues ?? this.manager.projectionValues(childId);
+					const projectedTitle = projectionValues?.title;
+					const title = typeof projectedTitle === "string" && projectedTitle !== "" ? projectedTitle : void 0;
+					const displayTitle = title ?? child.label ?? childId;
+					if (summary === void 0) byId[childId] = {
+						id: childId,
+						displayTitle,
+						parentId,
+						origin: "subagent",
+						running: this.scopes.get(childId)?.session.getSnapshot().running ?? false,
+						blank: false,
+						updatedAt: 0,
+						retainedBy: this.retentionSnapshot(childId).retainedBy,
+						...projectionValues === void 0 ? {} : { projectionValues },
+						...title === void 0 ? {} : { title }
+					};
+					else if (summary.displayTitle !== displayTitle || summary.projectionValues !== projectionValues) byId[childId] = {
+						...summary,
+						displayTitle,
+						...projectionValues === void 0 ? {} : { projectionValues }
+					};
+				}
+				for (const [id, record] of this.scopes) {
+					if (byId[id] !== void 0) continue;
+					const address = this.manager.subagentAddress(id);
+					if (address === void 0) continue;
+					const previous = previousById[id];
+					const snapshot = record.session.getSnapshot();
+					const projectionValues = this.manager.projectionValues(id);
+					const projectedTitle = projectionValues?.title;
+					const title = typeof projectedTitle === "string" && projectedTitle !== "" ? projectedTitle : previous?.title;
+					byId[id] = {
+						...previous ?? {
+							id,
+							displayTitle: id,
 							updatedAt: 0
-						};
-						else if (summary.displayTitle !== displayTitle) byId[childId] = {
-							...summary,
-							displayTitle
-						};
-						const parent = byId[address.parentSessionId];
-						if (parent !== void 0 && parent.origin !== "subagent") break;
-						address = this.manager.navigationAddress(address.parentSessionId);
-					}
+						},
+						running: snapshot.running,
+						retainedBy: record.retention.retainedBy,
+						blank: snapshot.blank,
+						parentId: address.parentSessionId,
+						origin: "subagent",
+						...projectionValues === void 0 ? {} : { projectionValues },
+						...title === void 0 ? {} : {
+							title,
+							displayTitle: title
+						}
+					};
 				}
-				const persisted = this.selection.getSnapshot().sessionId;
-				if (current === void 0) {
-					if (persisted !== void 0) this.selection.set({});
-				} else if (byId[current] !== void 0 && (persisted !== current || this.selection.getSnapshot().subagentAddress?.childSessionId !== currentAddress?.childSessionId || this.selection.getSnapshot().subagentAddress?.parentSessionId !== currentAddress?.parentSessionId || this.selection.getSnapshot().subagentAddress?.mode !== currentAddress?.mode)) this.selection.set({
-					sessionId: current,
-					...currentAddress === void 0 ? {} : { subagentAddress: currentAddress }
-				});
 				this.list.set({
 					ids,
 					byId,
-					current,
 					phase,
-					subagentsByParent,
-					jobsBySession,
-					currentAddress
+					projectionsBySession
 				});
-				this.pruneScopes();
-			}
-			/** Tear down scope + instance for no-longer-eligible sessions off stage; the staged one defers until the stage moves. */
-			pruneScopes() {
-				if (this.list.getSnapshot().phase === "pending") return;
-				for (const [id, record] of this.scopes) {
-					if (this.eligible(id)) continue;
-					if (id === this.watched) {
-						this.deferredRemovals.add(id);
-						continue;
-					}
-					this.scopes.delete(id);
-					this.deferredRemovals.delete(id);
-					this.startScopeDrop(id, record);
-				}
 			}
-			startScopeDrop(id, record) {
-				const drop = this.dropScope(id, record);
+			startScopeDrop(id, record, disposeFiber = true, sessionDisposal = this.manager.drop(id, record.session)) {
+				const drop = this.dropScope(record, disposeFiber, sessionDisposal);
 				this.scopeDrops.add(drop);
 				drop.then(() => {
 					this.scopeDrops.delete(drop);
@@ -3451,38 +3516,9 @@ window.__ModuleLoader__.load({
 			async drainScopeDrops() {
 				while (this.scopeDrops.size > 0) await Promise.allSettled([...this.scopeDrops]);
 			}
-			/**
-			* One teardown for the whole per-session axis: the scope
-			* fiber (cascading every actx-registered effect: input shell, slash
-			* controller, popup, plugin stores, listeners), the session-keyed slot
-			* registrations and the Session instance itself — the host session log is the
-			* durable truth, a reopen lazily rebuilds and backfills via open().
-			*/
-			async dropScope(id, record) {
-				record.session.unbindScope();
-				await Promise.allSettled([record.fiber.dispose(), this.manager.drop(id)]);
-			}
-			/** Run deferred teardowns whose session is no longer staged (called when the stage moves). */
-			sweepDeferred() {
-				for (const id of [...this.deferredRemovals]) {
-					/* v8 ignore next -- defensive: only the staged id ever defers, and every
-					* stage move sweeps first, so the set cannot contain the id the stage just
-					* moved to; kept as a guard against future extra sweep call sites. */
-					if (id === this.watched) continue;
-					if (this.eligible(id)) {
-						this.deferredRemovals.delete(id);
-						continue;
-					}
-					const record = this.scopes.get(id);
-					this.deferredRemovals.delete(id);
-					/* v8 ignore next -- defensive: prune deletes a scope and its deferral
-					* together, so a deferred id always still owns its record; kept so a
-					* future teardown path cannot double-dispose. */
-					if (record !== void 0) {
-						this.scopes.delete(id);
-						this.startScopeDrop(id, record);
-					}
-				}
+			/** Await the already-withdrawn Session and scoped cleanup to quiescence. */
+			async dropScope(record, disposeFiber, sessionDisposal) {
+				await Promise.allSettled([sessionDisposal, ...disposeFiber ? [record.fiber.dispose()] : []]);
 			}
 		};
 		//#endregion
@@ -3504,6 +3540,7 @@ window.__ModuleLoader__.load({
 		*/
 		function apply(ctx) {
 			const remotes = ctx.remote;
+			const connection = ctx.get("connection");
 			const sessions = new ClientSessions(ctx, remotes);
 			ctx.remote.$on("api-session/added", (summary) => {
 				sessions.handleSessionAdded(summary);
@@ -3528,14 +3565,22 @@ window.__ModuleLoader__.load({
 					console.error("[session-controller] control stream failed:", error);
 				}
 			});
-			control.start();
-			ctx.on("connection/reset", () => {
+			const connected = () => {
+				if (connection.generation.getSnapshot() === void 0) return;
 				sessions.handleConnected();
-			});
-			if (ctx.remote.$host.home !== void 0) sessions.handleConnected();
+				control.restart();
+				control.start();
+			};
+			ctx.effect(() => connection.generation.subscribe(connected), "session-controller.client.generation");
+			connected();
 			ctx.typert.contexts.registerClient("agent", {
-				identity: (candidate) => sessions.scopeOf(candidate),
-				resolve: (sessionId) => sessions.resolveAgentScope(sessionId)
+				identity: (candidate) => sessions.sessionOf(candidate)?.sessionId,
+				resolve: (sessionId) => {
+					const reference = sessions.retainAgentScope(sessionId);
+					return typertOwnedValue(reference.binding.ctx, () => {
+						reference.release();
+					});
+				}
 			});
 			ctx.effect(() => async () => {
 				await control.dispose();