@crazx/dsh-api-session-controller 0.1.6-alpha.1.zw.2 → 0.1.6-alpha.2.zw.1

package/lib/types/agent.d.ts

@@ -29,7 +29,7 @@ export declare class ApiSessionPresetConflict extends Error {
     constructor(sessionId: SessionId, requestedPreset: string, existingPreset: string | undefined);
 }
 /** Failures produced while resolving one ordinary Session identity to its live Agent. */
-export type ApiSessionAgentError = RemoteError<'session/not-found' | 'session/agent-busy' | 'gateway/internal'>;
+export type ApiSessionAgentError = RemoteError<'session/not-found' | 'session/agent-busy' | 'session/writer-held' | 'gateway/internal'>;
 /** Result of resolving one ordinary Session identity to its live Agent. */
 export type ApiSessionAgentResult = {
     readonly agent: Agent;

package/lib/types/agent.js

@@ -219,7 +219,11 @@ export class ApiSessionAgentController {
             this.resumes.set(sessionId, resume);
         }
         try {
-            return { agent: await resume };
+            const agent = await resume;
+            // A shared resume can publish an identity that subagent routing adopts
+            // before every waiter observes it; apply the live ownership policy again.
+            const published = this.liveAgent(sessionId);
+            return published ?? { agent };
         }
         catch (error) {
             if (error instanceof ApiSessionNotFound) {
@@ -235,6 +239,9 @@ export class ApiSessionAgentController {
             if (racedSession !== undefined && hasApiSessionSubagentOwner(this.ctx, racedSession, undefined)) {
                 return { error: apiSessionSubagentOwnershipError(sessionId) };
             }
+            if (error instanceof Error && error.name === 'SessionAlreadyOwnedError') {
+                return { error: new RemoteError('session/writer-held', error.message, { sessionId }) };
+            }
             return {
                 error: new RemoteError('gateway/internal', `resume failed for session "${sessionId}": ${String(error)}`, {}),
             };

package/lib/types/client/contract/sessions.d.ts

@@ -14,11 +14,58 @@ import type { SessionSearchResultItem } from '../sessions/manager.ts';
 import type { SessionBinding, SessionListState } from '../sessions/service.ts';
 import type { SessionFace } from './session.ts';
 import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+import type { SessionReferenceSource } from '../index.ts';
 export type { AgentContext } from '../scope.ts';
+/** Known Session identity or durable direct-parent subagent address; an address owns no lifetime. */
+export type SessionTarget = SessionId | SubagentAddress;
+/** One independent use of an exact Client generation, without Host Agent ownership. */
+export interface SessionReference extends Disposable {
+    readonly sessionId: SessionId;
+    /** Shared binding; access fails after reference release or generation disposal. */
+    readonly binding: SessionBinding;
+    /** This reference's cancellable wait for the shared initial `Session.open()` attempt to settle. */
+    readonly ready: Promise<SessionBinding>;
+    /** Release once; the final reference starts local scope and history teardown. */
+    release(): void;
+}
+/** Consumer identity and optional cancellation of one acquisition waiter. */
+export interface SessionRetainOptions {
+    readonly source: SessionReferenceSource;
+    readonly signal?: AbortSignal | undefined;
+}
+/** Local ownership counts, independent of catalog membership and never persisted. */
+export interface SessionRetainInfo {
+    readonly referenceCount: number;
+    /** Positive source counts only; a source without references is absent. */
+    readonly retainedBy: Readonly<Partial<Record<SessionReferenceSource, number>>>;
+}
 /** The sessions-service face injected as `ctx.sessions`. */
 export interface ISessions {
-    /** The useSessions standard feed (list rows + current selection; read face — writes stay inside the domain). */
+    /** Host catalog and local reference-source counts; navigation belongs to view owners. */
     readonly list: ObservableSnapshot<SessionListState>;
+    /**
+     * Retain an exact Client generation and start its shared initial history opening.
+     * @param target - known identity or durable direct-parent address.
+     * @param options - required consumer source and optional independent waiter cancellation.
+     * @returns an owned reference immediately; await `reference.ready` when the initial open attempt must settle first.
+     */
+    retain(target: SessionTarget, options: SessionRetainOptions): SessionReference;
+    /**
+     * Hold one reference through callback settlement, including synchronous and asynchronous failures.
+     * @param target - Session to acquire.
+     * @param options - source and acquisition cancellation.
+     * @param operation - callback using the reference only until its returned value or Promise settles.
+     * @returns the callback result after release; acquisition and callback failures propagate unchanged.
+     */
+    using<T>(target: SessionTarget, options: SessionRetainOptions, operation: (reference: SessionReference) => T | Promise<T>): Promise<T>;
+    /**
+     * Observe local reference counts without retaining, creating a scope, or opening history.
+     * The returned source keeps stable identity across same-id generations and remains allocated
+     * until the Client root is disposed, even after its final subscriber leaves.
+     * @param id - explicit Session identity; Host existence is not implied.
+     * @returns a stable read-only source across same-id generations, with zero counts when none is live.
+     */
+    retainInfo(id: SessionId): ObservableSnapshot<SessionRetainInfo>;
     /**
      * The `session.search` result bound the wire schema fixes, exposed to
      * presentation as injected data. Not per-connection state: every transport
@@ -28,23 +75,13 @@ export interface ISessions {
     /**
      * Create or adopt a Session on the Host.
      * @param opts - target workspace, directory, and optional preallocated identity.
-     * @returns the Session identity after its local binding is addressable.
+     * @returns the catalogued identity; retain it before borrowing its binding.
      */
     create(opts?: {
         workspaceId?: WorkspaceId;
         cwd?: string;
         sessionId?: SessionId;
     }): Promise<SessionId>;
-    /**
-     * Select a session as current.
-     * @param id - session id (must exist in the list; unknown ids fail loud).
-     */
-    open(id: SessionId): void;
-    /**
-     * Open a healthy catalog child through its exact direct-parent address.
-     * @param address - catalog-derived parent and child ids.
-     */
-    openSubagent(address: SubagentAddress): void;
     /**
      * Resolve an already discovered direct-parent address without opening it.
      * @param id - possible addressed child id.
@@ -63,8 +100,6 @@ export interface ISessions {
      * @returns completion of the current or newly started refresh.
      */
     refreshSubagents(parentSessionId: SessionId): Promise<void>;
-    /** Clear the current selection into the no-session view state. */
-    clear(): void;
     /**
      * Refresh the Host-authoritative Session list.
      * @returns completion of the current or newly started Session-list refresh.
@@ -83,7 +118,7 @@ export interface ISessions {
     }>>;
     /**
      * Fork a session from a completed-turn prefix of the source; on resolution
-     * the child is in the list store and `open()` can target it.
+     * the child is in the catalog and may be explicitly retained.
      * @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),
@@ -97,9 +132,9 @@ export interface ISessions {
         increaseTitle?: boolean;
     }): Promise<SessionId>;
     /**
-     * Resolve an Agent-scoped context view (use-and-discard).
+     * Borrow an already-retained Agent-scoped Context without extending its lifetime.
      * @param id - session id.
-     * @returns scoped ctx, or undefined for a session neither listed nor already scoped.
+     * @returns the live scoped Context, or undefined without a retained generation.
      */
     scope(id: SessionId): AgentContext | undefined;
     /**
@@ -112,13 +147,13 @@ export interface ISessions {
     /**
      * Resolve the session face behind an Agent-scoped context.
      * @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, foreign, or ended generation.
      */
     sessionOf(ctx: Context): SessionFace | undefined;
     /**
-     * Resolve the stable session binding (scope-addressed assembly feed).
+     * Borrow an already-retained Session binding without extending its lifetime.
      * @param id - session id.
-     * @returns binding, or undefined for a session neither listed nor already scoped.
+     * @returns the live binding, or undefined without a retained generation.
      */
     binding(id: SessionId): SessionBinding | undefined;
 }

package/lib/types/client/contract/snapshot.d.ts

@@ -1,22 +1,9 @@
 /** Session-owned observable state excluding Conversation target data. */
-import type { ContentBlock } from '@deepseek-ai/dsh-llm/types';
 import type { FileAttachmentRef } from '@deepseek-ai/dsh-attachment';
-import type { MessageId } from '@deepseek-ai/dsh-llm/brand';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { SubagentAddress } from '@deepseek-ai/dsh-subagent/client';
 import type { RemoteFailure } from '@deepseek-ai/dsh-typert-protocol';
 import type { SessionRequestId } from '../../types.ts';
-/** One transient inbox occurrence from the authoritative queue snapshot. */
-export interface QueuedMessage {
-    readonly id: MessageId;
-    readonly messageId: MessageId;
-    readonly placement: 'queued' | 'steering' | 'context';
-    /** Prompt-RPC identity of a browser-submitted occurrence; correlates the local submission echo. */
-    readonly rpcId?: SessionRequestId;
-    readonly content: readonly ContentBlock[];
-    readonly preview: string;
-    readonly text: string | null;
-}
 /** One image displayed by a local submission echo before durable admission. */
 export interface PendingSubmissionImage {
     /** Browser-owned preview URL; its lifecycle belongs to the submitter, never this snapshot. */
@@ -70,7 +57,6 @@ export interface PromptError {
 /** Immutable Session lifecycle and control snapshot. */
 export interface SessionSnapshot {
     readonly sessionId: SessionId;
-    readonly queue: readonly QueuedMessage[];
     /** Local prompt-submission echoes not yet observed as durable events or queue occurrences. */
     readonly pendingSubmissions: readonly PendingSubmission[];
     readonly running: boolean;

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

@@ -10,10 +10,19 @@ export type { SessionListPhase, SessionListSnapshot, SessionSearchResultItem, Su
 export type { Session } from './sessions/session.ts';
 export type { ProjectionsBaseline, ProjectionValueStore, SessionProjectionMap, UseProjection, } from './sessions/projection-store.ts';
 export type { BeginSubmissionInput, ISession, PendingSubmissionRetirement, ProjectionsFace, SessionFace, SubmissionHandle, } from './contract/session.ts';
-export type { ISessions } from './contract/sessions.ts';
+export type { ISessions, SessionReference, SessionRetainInfo, SessionRetainOptions, SessionTarget, } from './contract/sessions.ts';
 export { MutableSessionEventSource } from './contract/events.ts';
 export type { AssistantLiveChunkEvent, SessionAssistantSettlementEntry, SessionEventChange, SessionEventLike, SessionEventLikeEntry, SessionEventSource, SessionEventWindow, SessionLiveEventEntry, SessionTransientEventEntry, } from './contract/events.ts';
-export type { OpenState, PendingSubmission, PendingSubmissionAttachment, PendingSubmissionFileAttachment, PendingSubmissionImage, PendingSubmissionImageAttachment, PendingSubmissionPlacement, PromptError, QueuedMessage, SessionSnapshot, } from './contract/snapshot.ts';
+export type { OpenState, PendingSubmission, PendingSubmissionAttachment, PendingSubmissionFileAttachment, PendingSubmissionImage, PendingSubmissionImageAttachment, PendingSubmissionPlacement, PromptError, SessionSnapshot, } from './contract/snapshot.ts';
+/** Consumer-owned reference labels; extend this map through the package's canonical /client entry. */
+export interface SessionReferenceSourceMap {
+    /** Temporary Client Controller work, including fork-title preparation. */
+    controllerOperation: unknown;
+    /** A Client Gateway invocation's synchronous Context ownership. */
+    gateway: unknown;
+}
+/** Declaration-merge-extensible labels carried by independent Client references. */
+export type SessionReferenceSource = Extract<keyof SessionReferenceSourceMap, string>;
 declare module '@deepseek-ai/cordis' {
     interface Context {
         /** Client Session object layer and Agent scope owner. */

package/lib/types/client/index.js

@@ -1,4 +1,5 @@
 /** Client Session object layer, Agent scopes, and Remote lifecycle wiring. */
+import { typertOwnedValue } from '@deepseek-ai/dsh-typert-protocol';
 import { createSessionControlStream } from "./transport.js";
 import { ClientSessions } from "./sessions/service.js";
 export { createSessionControlStream, SessionEventStream, SESSION_SEARCH_RESULT_LIMIT, SESSION_SEARCH_SNIPPET_MAX_CODE_POINTS, } from "./transport.js";
@@ -21,6 +22,7 @@ export const inject = [
  */
 export 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); });
     ctx.remote.$on('api-session/removed', (sessionId) => { sessions.handleSessionRemoved(sessionId); });
@@ -37,13 +39,22 @@ export function apply(ctx) {
         accept: (frame) => { sessions.handleControlFrame(frame); },
         failed: (error) => { console.error('[session-controller] control stream failed:', error); },
     });
-    control.start();
-    ctx.on('connection/reset', () => { sessions.handleConnected(); });
-    if (ctx.remote.$host.home !== undefined)
+    const connected = () => {
+        if (connection.generation.getSnapshot() === undefined)
+            return;
+        // A ready control baseline may arrive before Cordis delivers connection/reset.
         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(); }, 'session-controller.client.control');
 }

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

@@ -6,11 +6,14 @@ import type { TypertRemoteScopeApi } from '@deepseek-ai/dsh-typert-protocol';
 export type AgentContext = Omit<Context, 'remote'> & {
     readonly remote: ClientRemote & TypertRemoteScopeApi<'agent'>;
 };
+interface ScopeIdentity {
+    readonly sessionId: SessionId;
+}
 /** A minted Agent scope and its disposal boundary. */
 export interface AgentScopeHandle {
     /**
      * Tagged context: scope-owned registrations and scoped dispatch both go
-     * through it (passing it as the dispatch subject routes to this agent's
+     * through it (passing it as the dispatch subject routes to this generation's
      * tagged listeners plus every untagged one).
      */
     ctx: AgentContext;
@@ -20,10 +23,10 @@ export interface AgentScopeHandle {
 /**
  * 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.
  */
 export declare function createScope(ctx: Context, key: SessionId): AgentScopeHandle;
@@ -33,4 +36,11 @@ export declare function createScope(ctx: Context, key: SessionId): AgentScopeHan
  * @returns its agent identity (the session id), or undefined for root contexts.
  */
 export declare function scopeOf(ctx: Context): SessionId | undefined;
+/**
+ * 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.
+ */
+export declare function scopeIdentityOf(ctx: Context): ScopeIdentity | undefined;
+export {};
 //# sourceMappingURL=scope.d.ts.map

package/lib/types/client/scope.js

@@ -1,20 +1,4 @@
-/**
- * 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. */
 import { Context as CordisContext } from '@deepseek-ai/cordis';
 /** Context tag written by {@link createScope}. */
 const kScope = Symbol('dsh.client.scope');
@@ -23,19 +7,20 @@ function agentScope() { }
 /**
  * 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.
  */
 export function createScope(ctx, key) {
     const fiber = ctx.plugin(agentScope);
+    const identity = { sessionId: key };
     const scoped = fiber.ctx.extend({
-        [kScope]: key,
+        [kScope]: identity,
         [CordisContext.filter](listenerCtx) {
-            const tag = scopeOf(listenerCtx);
-            return tag === undefined || tag === key;
+            const tag = scopeIdentityOf(listenerCtx);
+            return tag === undefined || tag === identity;
         },
     });
     return {
@@ -49,6 +34,14 @@ export function createScope(ctx, key) {
  * @returns its agent identity (the session id), or undefined for root contexts.
  */
 export 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.
+ */
+export function scopeIdentityOf(ctx) {
     return ctx[kScope];
 }
 //# sourceMappingURL=scope.js.map

package/lib/types/client/sessions/lineage.d.ts

@@ -21,8 +21,6 @@ export interface SessionListEntry {
     cwd?: string;
     /** Current host-computed projection values for list consumers. */
     projectionValues?: Readonly<Partial<SessionProjectionMap>>;
-    /** Finished running while not selected and not yet opened — the sidebar's green "done" reminder (clears on select or the next run). */
-    completed: boolean;
     /** Lineage indent depth: root = 0; the UI just multiplies by the indent width. */
     depth: number;
 }
@@ -31,8 +29,7 @@ export interface SessionListEntry {
  * 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.
  */
-export declare function flattenLineage(summaries: readonly TitledSessionSummary[], completed?: ReadonlySet<SessionId>): SessionListEntry[];
+export declare function flattenLineage(summaries: readonly TitledSessionSummary[]): SessionListEntry[];
 //# sourceMappingURL=lineage.d.ts.map

package/lib/types/client/sessions/lineage.js

@@ -6,10 +6,9 @@
  * 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.
  */
-export function flattenLineage(summaries, completed) {
+export function flattenLineage(summaries) {
     const byId = new Map();
     for (const s of summaries)
         byId.set(s.sessionId, s);
@@ -35,7 +34,6 @@ export function flattenLineage(summaries, completed) {
         visited.add(s.sessionId);
         out.push({
             ...s,
-            completed: completed?.has(s.sessionId) ?? false,
             depth,
         });
         const kids = children.get(s.sessionId);

package/lib/types/client/sessions/manager.d.ts

@@ -1,11 +1,14 @@
+/** Host catalog, durable projection caches, and explicitly retained Client instances. */
 import type { SubagentAddress, SubagentCatalog } from '@deepseek-ai/dsh-subagent/client';
 import { SessionSeq, type SessionId } from '@deepseek-ai/dsh-session/types';
+import type { SessionProjectionMap } from '@deepseek-ai/dsh-session-projection/types';
 import type { WorkspaceId } from '@deepseek-ai/dsh-workspace/types';
 import type { SessionControlFrame, SessionSummary, SessionJob as JobView } from '../../types.ts';
 import type { RemoteFailure, RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
 import type { SessionListEntry } from './lineage.ts';
 import { Session } from './session.ts';
 import type { SessionRemotes } from './remotes.ts';
+import type { SessionTarget } from '../contract/sessions.ts';
 /**
  * List arrival lifecycle, orthogonal to the pull-activity `state` axis:
  * `pending` (no successful pull yet — an empty items array means "nothing
@@ -23,8 +26,6 @@ export interface SessionSearchResultItem {
 /** Immutable session-list snapshot for useSessionList. */
 export interface SessionListSnapshot {
     items: readonly SessionListEntry[];
-    /** Selected Session id (validated against items; masked to undefined while its session is off the list). */
-    current: SessionId | undefined;
     state: 'idle' | 'loading' | 'error';
     /** Arrival lifecycle (see {@link SessionListPhase}); `state` stays the pull-activity axis. */
     phase: SessionListPhase;
@@ -32,7 +33,6 @@ export interface SessionListSnapshot {
     subagentsByParent: Readonly<Record<SessionId, SubagentCatalogSnapshot>>;
     /** Background jobs per session; an absent key is an empty set. */
     jobsBySession: Readonly<Record<SessionId, readonly JobView[]>>;
-    currentAddress: SubagentAddress | undefined;
 }
 /** One parent-addressed durable catalog projected through the sessions snapshot. */
 export type SubagentCatalogSnapshot = Omit<SubagentCatalog, 'parentAvailable'> & {
@@ -47,16 +47,6 @@ export declare class SessionManager {
     private readonly sessions;
     /** In-flight Session disposals remain here after instances leave `sessions`, so manager disposal can await quiescence. */
     private readonly sessionDisposals;
-    /** Latest transient queues, retained independently of Session object materialization. */
-    private readonly queues;
-    /**
-     * 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).
-     */
-    private readonly completedNotifications;
-    /** Last-observed running bits per session; the true→false edge here arms {@link completedNotifications}. */
-    private readonly prevRunning;
     /** 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
@@ -68,7 +58,7 @@ export declare class SessionManager {
     private listPhase;
     private listError;
     private listInflight;
-    /** 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. */
     private listMutations;
     private readonly addresses;
     private readonly catalogs;
@@ -83,7 +73,6 @@ export declare class SessionManager {
      * one representation.
      */
     private readonly jobsBySession;
-    private selected;
     private 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
@@ -91,23 +80,14 @@ export declare class SessionManager {
     private entryCache;
     private itemsCache;
     private readonly notifier;
+    /** @param remote - generated Remote namespaces used by catalog and history readers. */
+    constructor(remote: SessionRemotes);
     /**
-     * @param remote - generated Remote namespaces the Session cluster calls.
-     * @param restoredSelection - persisted real-Session selection candidate.
-     */
-    constructor(remote: SessionRemotes, restoredSelection?: SessionId, restoredAddress?: SubagentAddress);
-    /**
-     * Select a listed Session or a retained catalog-addressed child.
-     * @param sessionId - listed or catalog-addressed Session id.
-     */
-    select(sessionId: SessionId): void;
-    /**
-     * 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: SubagentAddress): void;
-    /** Clear the selection (the layout falls to the no-session view state). */
-    clearSelection(): void;
+    resolveTarget(target: SessionTarget): SessionId;
     /**
      * Return the durable catalog address retained for one child.
      * @param sessionId - possible addressed child id.
@@ -121,22 +101,22 @@ export declare class SessionManager {
      */
     navigationAddress(sessionId: SessionId): SubagentAddress | undefined;
     /**
-     * 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.
      */
-    drop(sessionId: SessionId): Promise<void>;
+    drop(sessionId: SessionId, expected: Session): Promise<void>;
     /**
-     * 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.
      */
     dispose(): Promise<void>;
     private startSessionDisposal;
     private drainSessionDisposals;
     /**
      * 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.
      */
@@ -155,7 +135,7 @@ export declare class SessionManager {
      * @param open - current menu state.
      */
     setSubagentCatalogOpen(parentSessionId: SessionId, open: boolean): void;
-    /** 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(): Promise<void>;
     /**
      * Search visible session message content without adding transient query
@@ -217,6 +197,12 @@ export declare class SessionManager {
      * @returns the cached reference (stable until the next flush).
      */
     getListSnapshot(): SessionListSnapshot;
+    /**
+     * 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: SessionId): Readonly<Partial<SessionProjectionMap>> | undefined;
     /**
      * Apply a complete control baseline or one later replacement frame.
      * @param frame - baseline or live control replacement from Session Controller.
@@ -253,10 +239,12 @@ export declare class SessionManager {
     handleSessionError(sessionId: SessionId, message: string): void;
     /**
      * 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(): void;
-    /** Debounce membership refetches while one parent catalog is selected or open. */
+    /** Debounce membership refetches for an explicitly consumed catalog. */
     private scheduleCatalogRefresh;
     /** Apply one Agent-driver transition to loaded and in-flight catalogs. */
     private updateCatalogActivity;
@@ -266,15 +254,6 @@ export declare class SessionManager {
     private applyCatalogParentExpandable;
     /** Fold request-local row mutations into one catalog result before publication. */
     private withCatalogMutations;
-    /**
-     * 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.
-     */
-    private syncCompletedNotifications;
     private buildListSnapshot;
 }
 //# sourceMappingURL=manager.d.ts.map