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

package/lib/types/client/sessions/projection-store.d.ts

@@ -1,10 +1,14 @@
 /**
  * Generic per-session projection value store (push model; see the
  * session-projection subsystem page, docs/subsystems/session-projection.md):
- * the host is the only computation site; the client holds finished
- * whole values per key — `key → { value, seq }` — seeded by a follow opening
- * baseline and updated by Session Controller `projection` frames,
- * under the single rule **higher seq wins**. No client-side domain folding
+ * the host is the only computation site; the client holds finished whole
+ * values per key in one of two row kinds. A `sequenced` row
+ * (`{ value, seq }`) comes from the connected Host — a follow opening
+ * baseline, a Session Controller `projection` frame, a list block the Host
+ * computed for an attached Session — and merges under **higher seq wins**
+ * against other sequenced rows. A `cached` row (`{ value }`) comes from the
+ * session list's view of the persisted checkpoint, carries no comparable
+ * seq, and yields to every sequenced write. No client-side domain folding
  * exists: a domain ships projection support with zero client code. Per-key
  * bare observable faces feed `useProjection` (ui-renderer binds them).
  */
@@ -38,10 +42,14 @@ export interface ProjectionsBaseline {
 }
 /**
  * One session's projection values. Framework semantics, uniform across every
- * key: a baseline seeds rows at its cut, a push frame updates one row, and in
- * both paths a lower-or-equal seq loses — a replayed frame cannot regress a
- * value, a stale baseline cannot overwrite a newer frame. A key the store has
- * never seen reads `undefined` (capability absent). Faces are identity-stable
+ * key. Sequenced writes (a baseline seeds rows at its cut, a push frame
+ * updates one row) compare seqs among themselves: a lower-or-equal seq within
+ * the Host generation loses, so a replayed frame cannot regress a value and a
+ * stale baseline cannot overwrite a newer frame. Cached writes (the session
+ * list's zero-I/O block) only fill keys no sequenced row holds, and a baseline
+ * discards every cached row before it seeds, regardless of seq: the connected
+ * Session is the truth and a cached value never outranks it. A key the store
+ * has never seen reads `undefined` (capability absent). Faces are identity-stable
  * per key (create-on-demand, cached) so the React side binds each exactly
  * once; the store-level channel (`subscribeAny`) serves coarse consumers (the
  * manager's list projection reads the `title` key).
@@ -87,22 +95,27 @@ export declare class ProjectionValueStore {
      */
     apply(key: string, value: unknown, seq: SessionSeqCursor): void;
     /**
-     * Seed from a history tail page's projections block: every carried key
-     * lands under the same seq rule as frames; a key the block omits is
-     * capability-absent as of the cut — its row clears unless a newer frame
-     * already superseded the cut (a stale baseline can neither overwrite nor
-     * clear newer values).
-     * @param baseline - the response's projections block.
+     * Fill keys from a session-list block the Host labeled `cached`: a zero-I/O
+     * view of the persisted checkpoint. A cached value lands only where no
+     * sequenced row exists: a connected Session has already answered for such
+     * a key, and the list's view of the persisted checkpoint cannot be newer
+     * than it.
+     * @param values - whole values by key viewed from the persisted checkpoint.
      */
-    seed(baseline: ProjectionsBaseline): void;
+    applyCached(values: Readonly<Record<string, unknown>>): void;
     /**
-     * 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.
+     * Seed from a history tail page's projections block. Every cached row is
+     * discarded first, regardless of seq: the block comes from the connected
+     * Session, and a value viewed from the persisted checkpoint never outranks
+     * it. Then every carried key lands under the same seq rule as frames, and a
+     * key the block omits is capability-absent as of the cut — its row clears
+     * unless a newer frame already superseded the cut (a stale baseline can
+     * neither overwrite nor clear newer sequenced values).
+     * @param baseline - the response's projections block.
      */
-    truncate(lastSeq: SessionSeqCursor): void;
+    seed(baseline: ProjectionsBaseline): void;
+    /** Discard one Host generation's values and watermarks while preserving subscribed faces. */
+    clear(): void;
     private changed;
     private channel;
 }

package/lib/types/client/sessions/projection-store.js

@@ -1,10 +1,14 @@
 import { Notifier } from "./notifier.js";
 /**
  * One session's projection values. Framework semantics, uniform across every
- * key: a baseline seeds rows at its cut, a push frame updates one row, and in
- * both paths a lower-or-equal seq loses — a replayed frame cannot regress a
- * value, a stale baseline cannot overwrite a newer frame. A key the store has
- * never seen reads `undefined` (capability absent). Faces are identity-stable
+ * key. Sequenced writes (a baseline seeds rows at its cut, a push frame
+ * updates one row) compare seqs among themselves: a lower-or-equal seq within
+ * the Host generation loses, so a replayed frame cannot regress a value and a
+ * stale baseline cannot overwrite a newer frame. Cached writes (the session
+ * list's zero-I/O block) only fill keys no sequenced row holds, and a baseline
+ * discards every cached row before it seeds, regardless of seq: the connected
+ * Session is the truth and a cached value never outranks it. A key the store
+ * has never seen reads `undefined` (capability absent). Faces are identity-stable
  * per key (create-on-demand, cached) so the React side binds each exactly
  * once; the store-level channel (`subscribeAny`) serves coarse consumers (the
  * manager's list projection reads the `title` key).
@@ -61,20 +65,46 @@ export class ProjectionValueStore {
      */
     apply(key, value, seq) {
         const row = this.rows.get(key);
-        if (row !== undefined && seq <= row.seq)
-            return; // higher seq wins; replays and stale frames drop
-        this.rows.set(key, { value, seq });
+        // higher seq wins among sequenced rows; replays and stale frames drop. A
+        // cached row has no comparable seq and always yields.
+        if (row?.kind === 'sequenced' && seq <= row.seq)
+            return;
+        this.rows.set(key, { kind: 'sequenced', value, seq });
         this.changed(key);
     }
     /**
-     * Seed from a history tail page's projections block: every carried key
-     * lands under the same seq rule as frames; a key the block omits is
-     * capability-absent as of the cut — its row clears unless a newer frame
-     * already superseded the cut (a stale baseline can neither overwrite nor
-     * clear newer values).
+     * Fill keys from a session-list block the Host labeled `cached`: a zero-I/O
+     * view of the persisted checkpoint. A cached value lands only where no
+     * sequenced row exists: a connected Session has already answered for such
+     * a key, and the list's view of the persisted checkpoint cannot be newer
+     * than it.
+     * @param values - whole values by key viewed from the persisted checkpoint.
+     */
+    applyCached(values) {
+        for (const key of Object.keys(values)) {
+            if (this.rows.get(key)?.kind === 'sequenced')
+                continue;
+            this.rows.set(key, { kind: 'cached', value: values[key] });
+            this.changed(key);
+        }
+    }
+    /**
+     * Seed from a history tail page's projections block. Every cached row is
+     * discarded first, regardless of seq: the block comes from the connected
+     * Session, and a value viewed from the persisted checkpoint never outranks
+     * it. Then every carried key lands under the same seq rule as frames, and a
+     * key the block omits is capability-absent as of the cut — its row clears
+     * unless a newer frame already superseded the cut (a stale baseline can
+     * neither overwrite nor clear newer sequenced values).
      * @param baseline - the response's projections block.
      */
     seed(baseline) {
+        for (const [key, row] of this.rows) {
+            if (row.kind !== 'cached')
+                continue;
+            this.rows.delete(key);
+            this.changed(key);
+        }
         // Erased walk: the framework crosses the open key space; per-key typing
         // is re-established at the consumer (useProjection's map lookup).
         const values = baseline.values;
@@ -83,23 +113,17 @@ export class ProjectionValueStore {
         for (const [key, row] of this.rows) {
             if (Object.hasOwn(values, key))
                 continue;
-            if (row.seq > baseline.asOfSeq)
+            // Every cached row was deleted above; the kind test only narrows the
+            // type so `row.seq` is readable.
+            if (row.kind === 'sequenced' && row.seq > baseline.asOfSeq)
                 continue;
             this.rows.delete(key);
             this.changed(key);
         }
     }
-    /**
-     * Drop rows beyond a replacement control baseline. Such rows describe
-     * process state the Host lost before persisting it and would otherwise
-     * outrank recomputed lower-seq values forever. The caller seeds the new
-     * baseline immediately afterward.
-     * @param lastSeq - highest durable sequence reflected by the baseline.
-     */
-    truncate(lastSeq) {
-        for (const [key, row] of this.rows) {
-            if (row.seq <= lastSeq)
-                continue;
+    /** Discard one Host generation's values and watermarks while preserving subscribed faces. */
+    clear() {
+        for (const key of this.rows.keys()) {
             this.rows.delete(key);
             this.changed(key);
         }

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

@@ -7,7 +7,7 @@
 import type { ClientRemote } from '@deepseek-ai/dsh-api-gateway/client';
 import type { CommandSubmitAttachment } from '@deepseek-ai/dsh-commands/types';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
-import type { SubagentCatalog, SubagentInterruptReceipt, SubagentPromptReceipt, SubagentPromptRequest } from '@deepseek-ai/dsh-subagent/client';
+import type { SubagentInterruptReceipt, SubagentPromptReceipt, SubagentPromptRequest } from '@deepseek-ai/dsh-subagent/client';
 import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
 import type { SessionRemote } from '../transport.ts';
 /** Narrow Commands namespace consumed by a Client Session. */
@@ -16,7 +16,6 @@ export interface SessionCommandsRemote {
 }
 /** Narrow subagent namespace consumed by a Client Session and its manager. */
 export interface SessionSubagentsRemote {
-    list(parentSessionId: SessionId, signal?: AbortSignal): Promise<RemoteResult<SubagentCatalog>>;
     prompt(request: SubagentPromptRequest, signal?: AbortSignal): Promise<RemoteResult<SubagentPromptReceipt>>;
     interruptByParent(childSessionId: SessionId, parentSessionId: SessionId, mode: 'continuable'): Promise<RemoteResult<SubagentInterruptReceipt>>;
 }

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

@@ -1,33 +1,17 @@
-/**
- * ClientSessions: root sessions service — list snapshot store (manager
- * projection; carries `current`, the persisted selection every
- * session-scoped surface keys off), Agent scope tree (mintScope pattern: no-op plugin
- * Fiber + ctx.extend scope tag; one scope per session, agent id === session
- * id), stable SessionBinding cache, breadcrumb-route projection.
- *
- * Scope lifecycle is stage-driven: a scope is minted lazily on first
- * resolution (pure — resolution has no side effects and is render-safe);
- * the event window and deferred teardown key off the STAGED session, which
- * follows `list.current` exactly. Staging is the open signal: the window
- * opens ⟺ the session is on stage (the stage is `current`; the staged
- * state can widen to a multi-pane list later). A session leaving the list
- * tears its scope down immediately unless it is the staged one, whose scope
- * survives frozen (read-only view) until the stage moves on.
- */
+/** Client catalog and source-labelled ownership of exact Session generations. */
 import type { Context } from '@deepseek-ai/cordis';
 import type { SubagentAddress } from '@deepseek-ai/dsh-subagent/client';
 import { type SessionId } from '@deepseek-ai/dsh-session/types';
 import type { WorkspaceId } from '@deepseek-ai/dsh-workspace/types';
-import type { SessionJob as JobView } from '../../types.ts';
 import type { SessionProjectionMap } from '@deepseek-ai/dsh-session-projection/types';
-import { type SnapshotStore } from '@deepseek-ai/dsh-client-store';
+import { type ObservableSnapshot, type SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { RemoteFailure, RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
 import type { SessionEventSource } from '../contract/events.ts';
 import type { SessionFace } from '../contract/session.ts';
-import type { AgentContext, ISessions } from '../contract/sessions.ts';
+import type { AgentContext, ISessions, SessionReference, SessionRetainInfo, SessionRetainOptions, SessionTarget } from '../contract/sessions.ts';
 import { SessionManager } from './manager.ts';
 import type { SessionRemotes } from './remotes.ts';
-import type { SessionListPhase, SessionSearchResultItem, SubagentCatalogSnapshot } from './manager.ts';
+import type { SessionListPhase, SessionSearchResultItem, SessionProjectionSnapshot } from './manager.ts';
 /** Session list row projected from the host list RPC plus live stream increments. */
 export interface SessionSummary {
     id: SessionId;
@@ -39,43 +23,32 @@ export interface SessionSummary {
     parentId?: SessionId;
     /** Coarse durable origin for navigation filtering; not a continuation capability. */
     origin?: 'subagent';
+    /** Host running state for `ids` members; a display fallback for other rows. */
     running: boolean;
-    /** Finished while not selected and not yet opened — the sidebar's green "done" reminder. Absent = false. */
-    completed?: boolean;
+    /** Local ownership counts; Host metadata refreshes cannot overwrite them. */
+    readonly retainedBy: SessionRetainInfo['retainedBy'];
     /**
-     * Empty-log bit (host summary derivation mirror). New Session reuses a blank
-     * one targeting the same workspace. Filtering stays with the consumer: the
-     * store carries every row, while the Workspace browser shows only the
-     * selected blank entry.
+     * New Session presentation and reuse eligibility, derived from the Host
+     * summary, `sessionListMetadata`, and client acceptance/running observations.
+     * New Session reuses a blank one targeting the same workspace. Filtering
+     * stays with the consumer: the store carries every row, while the Workspace
+     * browser shows only the selected blank entry.
      */
     blank: boolean;
     updatedAt: number;
     /** Current host-computed projection values retained by the object layer. */
     projectionValues?: Readonly<Partial<SessionProjectionMap>>;
 }
-/**
- * Session list store shape. `current` rides the same snapshot (arbitrated:
- * the single useSessions standard hook reads list and selection together —
- * sidebar highlighting and current-session consumers share one fact source).
- */
+/** Catalog metadata and local source counts; catalog membership owns no Client generation. */
 export interface SessionListState {
-    /** Host-list order; addressed breadcrumb-only rows are excluded. */
+    /** Host list order; every id has a matching byId row in the same snapshot. */
     ids: SessionId[];
-    /** Host rows plus the current addressed subagent route used by navigation. */
+    /** Host/catalog rows plus retained subagent fallbacks; only `ids` expresses Host-list membership. */
     byId: Record<SessionId, SessionSummary>;
-    current: SessionId | undefined;
     /** Arrival lifecycle projected 1:1 from the manager snapshot (see SessionListPhase): empty-with-ready means "truly no sessions". */
     phase: SessionListPhase;
-    /** Direct durable catalogs keyed by their selected parent address. */
-    subagentsByParent: Readonly<Record<SessionId, SubagentCatalogSnapshot>>;
-    /**
-     * Background jobs each session can see, mirrored last-wins from Session
-     * Controller's control baseline and `jobs` frames. A missing key is an empty
-     * set, so consumers read absence rather than a sentinel.
-     */
-    jobsBySession: Readonly<Record<SessionId, readonly JobView[]>>;
-    /** Current session's catalog-derived address, absent on ordinary navigation. */
-    currentAddress: SubagentAddress | undefined;
+    /** Shared projection values and explicit-read state, including unopened Sessions. */
+    projectionsBySession: Readonly<Record<SessionId, SessionProjectionSnapshot>>;
 }
 /** Structured session-create failure. */
 export declare class SessionCreateError extends Error {
@@ -109,7 +82,7 @@ export interface SessionBinding {
     readonly ctx: AgentContext;
 }
 export { scopeOf } from '../scope.ts';
-/** Root sessions service: list store, current selection, object-layer manager, scope tree, bindings, and breadcrumb routes. */
+/** Host catalog and local reference allocator; view selection remains outside the Controller. */
 export declare class ClientSessions implements ISessions {
     private readonly rootCtx;
     /**
@@ -119,72 +92,35 @@ export declare class ClientSessions implements ISessions {
      * reports the same number.
      */
     readonly 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. */
     readonly list: SnapshotStore<SessionListState>;
     /** The object-layer instance cluster and frame dispatch entry. */
     private readonly 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.
-     */
-    private readonly selection;
     private readonly scopes;
-    /** 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. */
+    private readonly retainObservers;
     private readonly scopeDrops;
-    /**
-     * 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).
-     */
-    private watched;
-    /** Removed-while-staged sessions whose teardown waits for the stage to move away. */
-    private readonly deferredRemovals;
+    private closed;
     /**
      * @param ctx - client root context (scope fibers mount under it).
      * @param remote - generated Remote namespaces shared with every Session.
      */
     constructor(rootCtx: Context, remote: SessionRemotes);
-    /**
-     * Select a listed or retained catalog-addressed session as current.
-     * @param id - listed or addressed session id.
-     */
-    open(id: SessionId): void;
-    /**
-     * Open a healthy catalog child through its direct-parent address.
-     * @param address - catalog-derived parent and child ids.
-     */
-    openSubagent(address: SubagentAddress): void;
+    retain(target: SessionTarget, options: SessionRetainOptions): SessionReference;
+    using<T>(target: SessionTarget, options: SessionRetainOptions, operation: (reference: SessionReference) => T | Promise<T>): Promise<T>;
+    retainInfo(id: SessionId): ObservableSnapshot<SessionRetainInfo>;
     /**
      * Resolve an already discovered direct-parent address without opening it.
      * Feature plugins use this to avoid Agent-bound RPCs in persisted child views.
      * @param id - possible addressed child id.
-     * @returns The retained address, when present.
+     * @returns A retained or loaded-catalog address, without retaining a new selection or scope.
      */
     subagentAddress(id: SessionId): SubagentAddress | undefined;
     /**
-     * Inform the Session Controller whether a catalog menu is consuming membership updates.
-     * @param parentSessionId - selected parent.
-     * @param open - menu state.
+     * Load all Session projections once per connection; retry an unsuccessful initial read.
+     * @param sessionId - Session to inspect without opening its conversation.
      */
-    setSubagentCatalogOpen(parentSessionId: SessionId, open: boolean): void;
-    /**
-     * Refresh one direct-child catalog.
-     * @param parentSessionId - catalog owner.
-     */
-    refreshSubagents(parentSessionId: SessionId): Promise<void>;
-    /**
-     * 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(): void;
+    refreshProjections(sessionId: SessionId): Promise<void>;
     /**
      * Refresh the real Session baseline, reusing an in-flight pull.
      * @returns completion of the current or newly started baseline pull.
@@ -234,12 +170,8 @@ export declare class ClientSessions implements ISessions {
     /** Rebuild the Session baseline and every opened window after connection. */
     handleConnected(): void;
     /**
-     * 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.
@@ -250,16 +182,14 @@ export declare class ClientSessions implements ISessions {
         sessionId?: SessionId;
     }): Promise<SessionId>;
     /**
-     * Fork a session from a completed-turn prefix of the source (same
+     * Fork a session from an exact inclusive prefix of the source (same
      * synchronous-addressability guarantee as {@link ClientSessions.create}:
-     * on resolution the child is in the list store and open() can target it).
-     * @param opts - source session id, the optional event seq anchoring the
-     *   cut (the boundary is the first turn/end at or after it; an in-log
-     *   anchor in an open turn is unavailable rather than clipped backward),
-     *   and whether to increment an inherited durable title before resolving.
-     *   A fractional anchor floors to a real event seq: the frozen nodes of an
-     *   interrupted turn carry flow-ordering seqs between two events, and the
-     *   wire takes integers only.
+     * on resolution the child is catalogued and may be explicitly retained).
+     * @param opts - source session id, the optional exact inclusive boundary
+     *   seq (a real event seq the caller already knows; a cut inside an open
+     *   turn is balanced Host-side with synthetic closers, and omission selects
+     *   the latest completed-turn prefix), and whether to increment an
+     *   inherited durable title before resolving.
      * @returns the child session id.
      * @throws {SessionForkError} with the source id.
      * @throws {Error} when a requested child-title rename fails after creation.
@@ -270,20 +200,17 @@ export declare class ClientSessions implements ISessions {
         increaseTitle?: boolean;
     }): Promise<SessionId>;
     /**
-     * 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: SessionId): AgentContext | undefined;
     /**
-     * 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: SessionId): AgentContext;
+    retainAgentScope(id: SessionId): SessionReference;
     /**
      * Read the Agent scope tag off a context. Service-method boundary: fetch
      * bundles must reach scope resolution through ctx.sessions — a cross-bundle
@@ -300,50 +227,26 @@ export declare class ClientSessions implements ISessions {
      * `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: Context): SessionFace | undefined;
     /**
-     * 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: SessionId): SessionBinding | undefined;
-    /**
-     * 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).
-     */
-    private followCurrent;
-    /**
-     * 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.
-     */
-    private resolve;
+    private retainScope;
+    private retentionSnapshot;
+    private publishRetention;
+    private retireScope;
     /** Materialize one scope after its caller establishes that the id may be addressed. */
     private materializeScope;
-    /** The one aliveness predicate shared by scope mint and prune: host-listed or currently addressed. */
-    private eligible;
     /** Project the manager's list snapshot into the store (title derivation is display-only). */
     private projectList;
-    /** Tear down scope + instance for no-longer-eligible sessions off stage; the staged one defers until the stage moves. */
-    private pruneScopes;
     private startScopeDrop;
     private drainScopeDrops;
-    /**
-     * 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().
-     */
+    /** Await the already-withdrawn Session and scoped cleanup to quiescence. */
     private dropScope;
-    /** Run deferred teardowns whose session is no longer staged (called when the stage moves). */
-    private sweepDeferred;
 }
 //# sourceMappingURL=service.d.ts.map