@songtonyli/dsh-cli 0.1.12 → 0.1.13

package/node_modules/@deepseek-ai/dsh-api-session-controller/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. */
@@ -170,7 +191,8 @@ 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
@@ -454,23 +476,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 +484,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 +510,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
@@ -549,10 +564,9 @@ window.__ModuleLoader__.load({
 		* 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();
@@ -572,7 +586,6 @@ window.__ModuleLoader__.load({
 				visited.add(s.sessionId);
 				out.push({
 					...s,
-					completed: completed?.has(s.sessionId) ?? false,
 					depth
 				});
 				const kids = children.get(s.sessionId);
@@ -676,9 +689,9 @@ window.__ModuleLoader__.load({
 		/**
 		* 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
+		* 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
 		* 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).
@@ -758,16 +771,9 @@ window.__ModuleLoader__.load({
 					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);
 				}
@@ -951,60 +957,6 @@ window.__ModuleLoader__.load({
 			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) {
@@ -1527,8 +1479,7 @@ 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();
+			stopObservingInbox;
 			assistantStream = new ClientAssistantStream();
 			running = false;
 			address;
@@ -1549,7 +1500,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;
@@ -1594,6 +1545,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;
@@ -1854,7 +1808,7 @@ window.__ModuleLoader__.load({
 				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 +1840,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.
 			*/
@@ -1970,6 +1906,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;
@@ -2067,23 +2004,36 @@ 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;
+				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
+					});
+					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));
 			}
-			/** Retire echoes whose prompts landed in the host inbox instead of the log (running-turn submissions). */
-			observeSubmissionQueue(items) {
+			/** Retire local echoes when their accepted messages appear in the durable Inbox projection. */
+			observeSubmissionInbox() {
 				if (this.submissionSettlements.size === 0) return;
-				for (const item of items) if (item.rpcId !== void 0) this.scheduleObservedRetirement(item.rpcId, attachmentRefsIn(item.message.content));
+				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));
+				}
 			}
 			/**
 			* Latch one observed settlement and remove the echo an animation frame
@@ -2134,7 +2084,6 @@ window.__ModuleLoader__.load({
 			buildSnapshot() {
 				return {
 					sessionId: this.sessionId,
-					queue: this.queueMirror.snapshot(),
 					pendingSubmissions: this.pendingSubmissions,
 					running: this.running,
 					subagent: this.address === void 0 ? null : {
@@ -2183,6 +2132,7 @@ 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);
 		}
@@ -2195,16 +2145,6 @@ window.__ModuleLoader__.load({
 			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).
-			*/
-			completedNotifications = /* @__PURE__ */ new Set();
-			/** Last-observed running bits per session; the true→false edge here arms {@link completedNotifications}. */
-			prevRunning = /* @__PURE__ */ new Map();
 			/** 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,7 +2156,7 @@ 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();
@@ -2231,7 +2171,6 @@ window.__ModuleLoader__.load({
 			* one representation.
 			*/
 			jobsBySession = /* @__PURE__ */ new Map();
-			selected;
 			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,49 +2180,23 @@ 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.
+			* 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.
 			*/
-			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();
+			resolveTarget(target) {
+				const id = typeof target === "string" ? target : target.childSessionId;
+				const address = typeof target === "string" ? this.navigationAddress(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);
+				return id;
 			}
 			/**
 			* Return the durable catalog address retained for one child.
@@ -2291,7 +2204,7 @@ window.__ModuleLoader__.load({
 			* @returns The direct-parent address, when navigation discovered one.
 			*/
 			subagentAddress(sessionId) {
-				return this.addresses.get(sessionId);
+				return this.navigationAddress(sessionId);
 			}
 			/**
 			* Resolve an address for breadcrumb navigation without retaining transport authority.
@@ -2311,19 +2224,21 @@ 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);
+				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);
@@ -2332,6 +2247,7 @@ window.__ModuleLoader__.load({
 				this.openCatalogs.clear();
 				const sessions = [...this.sessions.values()];
 				this.sessions.clear();
+				this.addresses.clear();
 				for (const session of sessions) this.startSessionDisposal(session);
 				await this.drainSessionDisposals();
 			}
@@ -2350,7 +2266,7 @@ 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).
 			* @param sessionId - the session to get.
 			* @returns the resident instance.
 			*/
@@ -2359,7 +2275,6 @@ 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);
@@ -2483,7 +2398,7 @@ window.__ModuleLoader__.load({
 					}
 				}
 			}
-			/** 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,19 +2410,12 @@ 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();
-							}
-							this.summaries = summaries;
+							this.summaries = mutations.reduce(applyMutation, baseline);
 							this.listState = "idle";
 							this.listPhase = "ready";
-							this.syncCompletedNotifications();
 							for (const s of this.summaries) {
 								const session = this.sessions.get(s.sessionId);
 								if (session === void 0) continue;
@@ -2527,12 +2435,15 @@ window.__ModuleLoader__.load({
 						}
 					} 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;
@@ -2641,7 +2552,6 @@ window.__ModuleLoader__.load({
 			recordMutation(mutation) {
 				this.listMutations?.push(mutation);
 				this.summaries = applyMutation(this.summaries, mutation);
-				this.syncCompletedNotifications();
 				this.notifier.markDirty();
 			}
 			/**
@@ -2661,6 +2571,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.
 			*/
@@ -2674,30 +2592,21 @@ window.__ModuleLoader__.load({
 					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);
+				if (frame.jobs.length === 0) this.jobsBySession.delete(frame.sessionId);
+				else this.jobsBySession.set(frame.sessionId, frame.jobs);
+				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();
 			}
 			/**
@@ -2713,7 +2622,7 @@ window.__ModuleLoader__.load({
 					for (const [key, value] of Object.entries(projections.values)) store.apply(key, value, sessionSeqCursor(projections.asOfSeq));
 				}
 				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);
+				if (summary.parentSessionId !== void 0 && this.openCatalogs.has(summary.parentSessionId)) this.scheduleCatalogRefresh(summary.parentSessionId);
 			}
 			/**
 			* Apply one Session removal forwarded through `ctx.remote.$on`.
@@ -2732,7 +2641,6 @@ window.__ModuleLoader__.load({
 				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);
@@ -2783,16 +2691,23 @@ 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);
+				const parents = new Set(this.openCatalogs);
+				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 while one parent catalog is selected or open. */
+			/** Debounce membership refetches for an explicitly consumed catalog. */
 			scheduleCatalogRefresh(parentSessionId) {
 				if (this.catalogDebounce.has(parentSessionId)) return;
 				const timer = setTimeout(() => {
@@ -2865,31 +2780,6 @@ window.__ModuleLoader__.load({
 					};
 				});
 			}
-			/**
-			* 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);
-				}
-				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);
-			}
 			buildListSnapshot() {
 				const items = flattenLineage(this.summaries.map((summary) => {
 					const projectionStore = this.projectionStores.get(summary.sessionId);
@@ -2900,25 +2790,22 @@ window.__ModuleLoader__.load({
 						...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)
+					jobsBySession: Object.fromEntries(this.jobsBySession)
 				};
 			}
 		};
@@ -3015,7 +2902,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,81 +2979,94 @@ 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
+					jobsBySession: {}
 				});
 				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.
@@ -3126,16 +3093,6 @@ window.__ModuleLoader__.load({
 				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.
-			*/
-			clear() {
-				this.manager.clearSelection();
-			}
-			/**
 			* Refresh the real Session baseline, reusing an in-flight pull.
 			* @returns completion of the current or newly started baseline pull.
 			*/
@@ -3199,12 +3156,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,9 +3169,8 @@ window.__ModuleLoader__.load({
 				return result.value.sessionId;
 			}
 			/**
-			* Fork a session from a completed-turn 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).
+			* 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),
@@ -3240,31 +3192,33 @@ window.__ModuleLoader__.load({
 				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));
-					if (!renamed.ok) throw new Error(`fork child rename failed: ${renamed.error.code}: ${renamed.error.message}`);
+					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();
+					}
 				}
 				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 +3238,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.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 +3330,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, subagentsByParent, jobsBySession } = this.manager.getListSnapshot();
 				const ids = [];
 				const byId = {};
 				for (const entry of items) {
@@ -3369,7 +3352,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 +3362,62 @@ 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, catalog] of Object.entries(subagentsByParent)) for (const child of catalog.entries) {
+					if (child.kind !== "child") continue;
+					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: child.activity === "running",
+						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 previous = previousById[id];
+					const snapshot = record.session.getSnapshot();
+					const address = this.manager.subagentAddress(id);
+					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,
+						...address === void 0 ? {} : {
+							parentId: address.parentSessionId,
+							origin: "subagent"
+						}
+					};
 				}
-				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
+					jobsBySession
 				});
-				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 +3428,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 +3452,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 +3477,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();