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

package/lib/client.js

@@ -149,6 +149,7 @@ window.__ModuleLoader__.load({
 			"compaction/start",
 			"compaction/summary",
 			"deliverables/presented",
+			"developer/message",
 			"feedback/message-delete",
 			"feedback/message-put",
 			"feedback/record",
@@ -199,6 +200,7 @@ window.__ModuleLoader__.load({
 		/** Runtime counterpart of the message-producing event union. */
 		const SURFACE_EVENT_TYPES = new Set([
 			"system/message",
+			"developer/message",
 			"user/message",
 			"assistant/message",
 			"tool/result"
@@ -206,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);
@@ -216,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"];
@@ -236,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. */
@@ -331,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. */
@@ -558,6 +576,210 @@ 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
@@ -584,8 +806,9 @@ window.__ModuleLoader__.load({
 					return;
 				}
 				visited.add(s.sessionId);
+				const { agentAvailable: _agentAvailable, ...row } = s;
 				out.push({
-					...s,
+					...row,
 					depth
 				});
 				const kids = children.get(s.sessionId);
@@ -688,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 within the Host generation 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).
@@ -746,27 +973,53 @@ 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);
 				}
@@ -957,199 +1210,6 @@ window.__ModuleLoader__.load({
 			return timeZone;
 		}
 		//#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
-					});
-				}
-			}
-			return value;
-		}
-		//#endregion
 		//#region ../../llm/llm/lib/types/assistant-stream.js
 		/**
 		* Lossless compact representation of one model-stream attempt, plus record-level
@@ -1479,6 +1539,7 @@ window.__ModuleLoader__.load({
 			jumpTargetSeq = null;
 			/** The running jump loop's completion, shared by retargeting callers. */
 			jumpPromise = null;
+			pendingHistory = null;
 			stopObservingInbox;
 			assistantStream = new ClientAssistantStream();
 			running = false;
@@ -1492,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;
@@ -1508,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
@@ -1574,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
 				});
@@ -1649,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;
 			}
 			/**
@@ -1779,29 +1843,37 @@ 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();
 					}
 				})();
@@ -1876,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;
@@ -1962,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) {
@@ -1995,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);
@@ -2012,28 +2105,55 @@ window.__ModuleLoader__.load({
 			observeSubmissionEvent(event) {
 				if (this.submissionSettlements.size === 0) return;
 				if (event.type === "agent/inbox/spliced") {
-					const splice = event.data;
-					if (Array.isArray(splice?.inserted)) for (const message of splice.inserted) this.observeSubmissionEvent({
-						type: "user/message",
-						data: message
-					});
+					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 !== "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));
+				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)
+					};
+				}
 			}
-			/** Retire local echoes when their accepted messages appear in the durable Inbox projection. */
+			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"]]) {
-					const source = message.source;
-					if (source.kind === "user" && "rpcId" in source) this.scheduleObservedRetirement(source.rpcId, attachmentRefsIn(message.content));
-				}
+				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
@@ -2082,12 +2202,16 @@ window.__ModuleLoader__.load({
 				this.notifier.markDirty();
 			}
 			buildSnapshot() {
+				const identity = this.projections.values().subagent;
 				return {
 					sessionId: this.sessionId,
 					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,
@@ -2136,15 +2260,21 @@ window.__ModuleLoader__.load({
 		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();
+			/**
+			* 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.
+			*/
+			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
@@ -2159,18 +2289,8 @@ window.__ModuleLoader__.load({
 			/** 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();
+			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
@@ -2192,31 +2312,23 @@ window.__ModuleLoader__.load({
 			*/
 			resolveTarget(target) {
 				const id = typeof target === "string" ? target : target.childSessionId;
-				const address = typeof target === "string" ? this.navigationAddress(id) : target;
+				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.catalogs.get(address.parentSessionId)?.parentAvailable);
+				this.sessions.get(id)?.configureSubagent(address, address === void 0 ? void 0 : this.agentAvailable(address.parentSessionId));
 				return id;
 			}
 			/**
-			* Return the durable catalog address retained for one child.
-			* @param sessionId - possible addressed child id.
-			* @returns The direct-parent address, when navigation discovered one.
-			*/
-			subagentAddress(sessionId) {
-				return this.navigationAddress(sessionId);
-			}
-			/**
 			* 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
@@ -2234,6 +2346,7 @@ window.__ModuleLoader__.load({
 				if (session !== expected) return Promise.resolve();
 				this.sessions.delete(sessionId);
 				this.addresses.delete(sessionId);
+				this.pruneEngagement(sessionId, this.retainedIds(this.summaries));
 				return this.startSessionDisposal(session);
 			}
 			/**
@@ -2241,10 +2354,14 @@ window.__ModuleLoader__.load({
 			* @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();
@@ -2267,6 +2384,7 @@ window.__ModuleLoader__.load({
 			/**
 			* Lazy build: return the existing instance or construct one (no auto-open —
 			* 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.
 			*/
@@ -2277,42 +2395,71 @@ window.__ModuleLoader__.load({
 					this.sessions.set(sessionId, session);
 					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);
@@ -2320,82 +2467,67 @@ 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 within one Host generation). */
@@ -2413,22 +2545,23 @@ window.__ModuleLoader__.load({
 						if (this.listMutations !== mutations) return;
 						if (result.ok) {
 							const baseline = this.listPhase === "pending" ? [...result.value.items] : mergeOrderedBaseline(established, result.value.items, (summary) => summary.sessionId);
-							this.summaries = mutations.reduce(applyMutation, baseline);
+							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.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;
@@ -2484,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,
@@ -2496,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,
@@ -2509,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) {
@@ -2524,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 } : {}
 					}
@@ -2537,19 +2674,33 @@ 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.notifier.markDirty();
@@ -2587,18 +2738,10 @@ 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.jobs.length === 0) this.jobsBySession.delete(frame.sessionId);
-				else this.jobsBySession.set(frame.sessionId, frame.jobs);
+				this.projectionStore(frame.sessionId).apply(frame.key, frame.value, SessionSeq(frame.seq));
 				this.notifier.markDirty();
 			}
 			replaceControlBaseline(baseline) {
-				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);
@@ -2615,44 +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.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.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);
 			}
 			/**
@@ -2661,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.
@@ -2700,93 +2856,26 @@ window.__ModuleLoader__.load({
 				this.listMutations = null;
 				this.listInflight = null;
 				this.refreshList();
-				const parents = new Set(this.openCatalogs);
+				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 parentSessionId of parents) this.refreshSubagents(parentSessionId);
-			}
-			/** Debounce membership refetches for an explicitly consumed catalog. */
-			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 }
-					};
-				});
+				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 }
 					};
@@ -2804,31 +2893,41 @@ window.__ModuleLoader__.load({
 					state: this.listState,
 					phase: this.listPhase,
 					error: this.listError,
-					subagentsByParent: Object.fromEntries(this.catalogs),
-					jobsBySession: Object.fromEntries(this.jobsBySession)
+					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 ? {
@@ -2999,8 +3098,7 @@ window.__ModuleLoader__.load({
 					ids: [],
 					byId: {},
 					phase: "pending",
-					subagentsByParent: {},
-					jobsBySession: {}
+					projectionsBySession: {}
 				});
 				const disposeManagerProjection = this.manager.subscribe(() => {
 					this.projectList();
@@ -3072,25 +3170,17 @@ window.__ModuleLoader__.load({
 			* 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.
+			* Load all Session projections once per connection; retry an unsuccessful initial read.
+			* @param sessionId - Session to inspect without opening its conversation.
 			*/
-			refreshSubagents(parentSessionId) {
-				return this.manager.refreshSubagents(parentSessionId);
+			refreshProjections(sessionId) {
+				return this.manager.refreshProjections(sessionId);
 			}
 			/**
 			* Refresh the real Session baseline, reusing an in-flight pull.
@@ -3169,15 +3259,14 @@ window.__ModuleLoader__.load({
 				return result.value.sessionId;
 			}
 			/**
-			* Fork a Session from a completed-turn prefix of the source and publish
-			* the child in the catalog before resolving.
-			* @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.
+			* Fork a session from an exact inclusive prefix of the source (same
+			* synchronous-addressability guarantee as {@link ClientSessions.create}:
+			* 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.
@@ -3186,20 +3275,14 @@ 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 reference = this.retain(childId, { source: "controllerOperation" });
-					try {
-						await reference.ready;
-						const renamed = await reference.binding.session.rename(increasedForkTitle(sourceTitle));
-						if (!renamed.ok) throw new Error(`fork child rename failed: ${renamed.error.code}: ${renamed.error.message}`);
-					} finally {
-						reference.release();
-					}
+					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;
 			}
@@ -3279,7 +3362,7 @@ window.__ModuleLoader__.load({
 					if (count === 0) this.retireScope(id, record);
 					else this.publishRetention(id);
 				});
-				if (this.list.getSnapshot().byId[id] === void 0) this.projectList();
+				if (this.list.getSnapshot().byId[id] === void 0 && this.manager.subagentAddress(id) !== void 0) this.projectList();
 				this.publishRetention(id);
 				return reference;
 			}
@@ -3343,7 +3426,7 @@ window.__ModuleLoader__.load({
 			/** Project the manager's list snapshot into the store (title derivation is display-only). */
 			projectList() {
 				const previousById = this.list.getSnapshot().byId;
-				const { items, phase, subagentsByParent, jobsBySession } = this.manager.getListSnapshot();
+				const { items, phase, projectionsBySession } = this.manager.getListSnapshot();
 				const ids = [];
 				const byId = {};
 				for (const entry of items) {
@@ -3362,8 +3445,7 @@ window.__ModuleLoader__.load({
 						...entry.origin !== void 0 ? { origin: entry.origin } : {}
 					};
 				}
-				for (const [parentId, catalog] of Object.entries(subagentsByParent)) for (const child of catalog.entries) {
-					if (child.kind !== "child") continue;
+				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);
@@ -3375,7 +3457,7 @@ window.__ModuleLoader__.load({
 						displayTitle,
 						parentId,
 						origin: "subagent",
-						running: child.activity === "running",
+						running: this.scopes.get(childId)?.session.getSnapshot().running ?? false,
 						blank: false,
 						updatedAt: 0,
 						retainedBy: this.retentionSnapshot(childId).retainedBy,
@@ -3390,9 +3472,13 @@ window.__ModuleLoader__.load({
 				}
 				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 address = this.manager.subagentAddress(id);
+					const projectionValues = this.manager.projectionValues(id);
+					const projectedTitle = projectionValues?.title;
+					const title = typeof projectedTitle === "string" && projectedTitle !== "" ? projectedTitle : previous?.title;
 					byId[id] = {
 						...previous ?? {
 							id,
@@ -3402,9 +3488,12 @@ window.__ModuleLoader__.load({
 						running: snapshot.running,
 						retainedBy: record.retention.retainedBy,
 						blank: snapshot.blank,
-						...address === void 0 ? {} : {
-							parentId: address.parentSessionId,
-							origin: "subagent"
+						parentId: address.parentSessionId,
+						origin: "subagent",
+						...projectionValues === void 0 ? {} : { projectionValues },
+						...title === void 0 ? {} : {
+							title,
+							displayTitle: title
 						}
 					};
 				}
@@ -3412,8 +3501,7 @@ window.__ModuleLoader__.load({
 					ids,
 					byId,
 					phase,
-					subagentsByParent,
-					jobsBySession
+					projectionsBySession
 				});
 			}
 			startScopeDrop(id, record, disposeFiber = true, sessionDisposal = this.manager.drop(id, record.session)) {