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

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 within the Host generation loses. A replayed
- * frame cannot regress a value; a stale baseline cannot overwrite a newer
- * frame. A key the store has never seen reads `undefined` (capability absent). Faces are identity-stable
+ * key. Sequenced writes (a baseline seeds rows at its cut, a push frame
+ * updates one row) compare seqs among themselves: a lower-or-equal seq within
+ * the Host generation loses, so a replayed frame cannot regress a value and a
+ * stale baseline cannot overwrite a newer frame. Cached writes (the session
+ * list's zero-I/O block) only fill keys no sequenced row holds, and a baseline
+ * discards every cached row before it seeds, regardless of seq: the connected
+ * Session is the truth and a cached value never outranks it. A key the store
+ * has never seen reads `undefined` (capability absent). Faces are identity-stable
  * per key (create-on-demand, cached) so the React side binds each exactly
  * once; the store-level channel (`subscribeAny`) serves coarse consumers (the
  * manager's list projection reads the `title` key).
@@ -67,6 +75,12 @@ export declare class ProjectionValueStore {
      * @returns the value, or undefined while the key is absent.
      */
     get(key: string): unknown;
+    /**
+     * Read the accepted Host watermark without subscribing or copying a value.
+     * @param key - projection key.
+     * @returns the current sequence, or undefined for absent and cached values.
+     */
+    seqOf(key: string): SessionSeqCursor | undefined;
     /**
      * Read every current projection value as one reference-stable snapshot.
      * @returns The same frozen value map until a row changes.
@@ -87,11 +101,22 @@ 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).
+     * 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: Readonly<Record<string, unknown>>): void;
+    /**
+     * 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: ProjectionsBaseline): void;

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 within the Host generation loses. A replayed
- * frame cannot regress a value; a stale baseline cannot overwrite a newer
- * frame. A key the store has never seen reads `undefined` (capability absent). Faces are identity-stable
+ * key. Sequenced writes (a baseline seeds rows at its cut, a push frame
+ * updates one row) compare seqs among themselves: a lower-or-equal seq within
+ * the Host generation loses, so a replayed frame cannot regress a value and a
+ * stale baseline cannot overwrite a newer frame. Cached writes (the session
+ * list's zero-I/O block) only fill keys no sequenced row holds, and a baseline
+ * discards every cached row before it seeds, regardless of seq: the connected
+ * Session is the truth and a cached value never outranks it. A key the store
+ * has never seen reads `undefined` (capability absent). Faces are identity-stable
  * per key (create-on-demand, cached) so the React side binds each exactly
  * once; the store-level channel (`subscribeAny`) serves coarse consumers (the
  * manager's list projection reads the `title` key).
@@ -34,6 +38,15 @@ export class ProjectionValueStore {
     get(key) {
         return this.rows.get(key)?.value;
     }
+    /**
+     * Read the accepted Host watermark without subscribing or copying a value.
+     * @param key - projection key.
+     * @returns the current sequence, or undefined for absent and cached values.
+     */
+    seqOf(key) {
+        const row = this.rows.get(key);
+        return row?.kind === 'sequenced' ? row.seq : undefined;
+    }
     /**
      * Read every current projection value as one reference-stable snapshot.
      * @returns The same frozen value map until a row changes.
@@ -61,20 +74,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,7 +122,9 @@ 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);

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

@@ -3,7 +3,6 @@ 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 ObservableSnapshot, type SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { RemoteFailure, RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
@@ -12,7 +11,7 @@ import type { SessionFace } from '../contract/session.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;
@@ -24,14 +23,16 @@ 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;
     /** 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;
@@ -40,20 +41,14 @@ export interface SessionSummary {
 }
 /** 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/catalog rows plus local fallback rows for live Client generations; only `ids` expresses Host-list membership. */
+    /** Host/catalog rows plus retained subagent fallbacks; only `ids` expresses Host-list membership. */
     byId: Record<SessionId, SessionSummary>;
     /** 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[]>>;
+    /** 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 {
@@ -118,20 +113,14 @@ export declare class ClientSessions implements ISessions {
      * 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.
-     */
-    setSubagentCatalogOpen(parentSessionId: SessionId, open: boolean): void;
-    /**
-     * Refresh one direct-child catalog.
-     * @param parentSessionId - catalog owner.
+     * Load all Session projections once per connection; retry an unsuccessful initial read.
+     * @param sessionId - Session to inspect without opening its conversation.
      */
-    refreshSubagents(parentSessionId: SessionId): Promise<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.
@@ -193,15 +182,14 @@ export declare class ClientSessions implements ISessions {
         sessionId?: SessionId;
     }): Promise<SessionId>;
     /**
-     * Fork a Session from a completed-turn prefix of the source and publish
-     * the child in the catalog before resolving.
-     * @param opts - source session id, the optional event seq anchoring the
-     *   cut (the boundary is the first turn/end at or after it; an in-log
-     *   anchor in an open turn is unavailable rather than clipped backward),
-     *   and whether to increment an inherited durable title before resolving.
-     *   A fractional anchor floors to a real event seq: the frozen nodes of an
-     *   interrupted turn carry flow-ordering seqs between two events, and the
-     *   wire takes integers only.
+     * Fork a session from an exact inclusive prefix of the source (same
+     * synchronous-addressability guarantee as {@link ClientSessions.create}:
+     * on resolution the child is catalogued and may be explicitly retained).
+     * @param opts - source session id, the optional exact inclusive boundary
+     *   seq (a real event seq the caller already knows; a cut inside an open
+     *   turn is balanced Host-side with synthetic closers, and omission selects
+     *   the latest completed-turn prefix), and whether to increment an
+     *   inherited durable title before resolving.
      * @returns the child session id.
      * @throws {SessionForkError} with the source id.
      * @throws {Error} when a requested child-title rename fails after creation.

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

@@ -163,7 +163,7 @@ export class ClientSessions {
         this.rootCtx = rootCtx;
         this.manager = new SessionManager(remote);
         this.list = createSnapshotStore({
-            ids: [], byId: {}, phase: 'pending', subagentsByParent: {}, jobsBySession: {},
+            ids: [], byId: {}, phase: 'pending', projectionsBySession: {},
         });
         const disposeManagerProjection = this.manager.subscribe(() => { this.projectList(); });
         rootCtx.effect(() => async () => {
@@ -234,25 +234,17 @@ export class ClientSessions {
      * Resolve an already discovered direct-parent address without opening it.
      * Feature plugins use this to avoid Agent-bound RPCs in persisted child views.
      * @param id - possible addressed child id.
-     * @returns The retained address, when present.
+     * @returns A retained or loaded-catalog address, without retaining a new selection or scope.
      */
     subagentAddress(id) {
         return this.manager.subagentAddress(id);
     }
     /**
-     * Inform the Session Controller whether a catalog menu is consuming membership updates.
-     * @param parentSessionId - selected parent.
-     * @param open - menu state.
+     * Load all Session projections once per connection; retry an unsuccessful initial read.
+     * @param sessionId - Session to inspect without opening its conversation.
      */
-    setSubagentCatalogOpen(parentSessionId, open) {
-        this.manager.setSubagentCatalogOpen(parentSessionId, open);
-    }
-    /**
-     * Refresh one direct-child catalog.
-     * @param parentSessionId - catalog owner.
-     */
-    refreshSubagents(parentSessionId) {
-        return this.manager.refreshSubagents(parentSessionId);
+    refreshProjections(sessionId) {
+        return this.manager.refreshProjections(sessionId);
     }
     /**
      * Refresh the real Session baseline, reusing an in-flight pull.
@@ -332,15 +324,14 @@ export class ClientSessions {
         return result.value.sessionId;
     }
     /**
-     * Fork a Session from a completed-turn prefix of the source and publish
-     * the child in the catalog before resolving.
-     * @param opts - source session id, the optional event seq anchoring the
-     *   cut (the boundary is the first turn/end at or after it; an in-log
-     *   anchor in an open turn is unavailable rather than clipped backward),
-     *   and whether to increment an inherited durable title before resolving.
-     *   A fractional anchor floors to a real event seq: the frozen nodes of an
-     *   interrupted turn carry flow-ordering seqs between two events, and the
-     *   wire takes integers only.
+     * Fork a session from an exact inclusive prefix of the source (same
+     * synchronous-addressability guarantee as {@link ClientSessions.create}:
+     * on resolution the child is catalogued and may be explicitly retained).
+     * @param opts - source session id, the optional exact inclusive boundary
+     *   seq (a real event seq the caller already knows; a cut inside an open
+     *   turn is balanced Host-side with synthetic closers, and omission selects
+     *   the latest completed-turn prefix), and whether to increment an
+     *   inherited durable title before resolving.
      * @returns the child session id.
      * @throws {SessionForkError} with the source id.
      * @throws {Error} when a requested child-title rename fails after creation.
@@ -351,26 +342,16 @@ export class ClientSessions {
             : undefined;
         const result = await this.manager.fork({
             sessionId: opts.sessionId,
-            // Flooring lands inside the anchor's own turn (every turn opens with a
-            // turn/start), so the host's first-turn/end-at-or-after cut still ends
-            // on that turn — never clipped back to the previous one.
-            ...(opts.atSeq === undefined ? {} : { atSeq: SessionSeq(Math.floor(opts.atSeq)) }),
+            ...(opts.atSeq === undefined ? {} : { atSeq: SessionSeq(opts.atSeq) }),
         });
         if (!result.ok)
             throw new SessionForkError(result.error, opts.sessionId);
         this.projectList();
         const childId = result.value.sessionId;
         if (sourceTitle !== undefined) {
-            const reference = this.retain(childId, { source: 'controllerOperation' });
-            try {
-                await reference.ready;
-                const renamed = await reference.binding.session.rename(increasedForkTitle(sourceTitle));
-                if (!renamed.ok)
-                    throw new Error(`fork child rename failed: ${renamed.error.code}: ${renamed.error.message}`);
-            }
-            finally {
-                reference.release();
-            }
+            const renamed = await this.manager.rename(childId, increasedForkTitle(sourceTitle));
+            if (!renamed.ok)
+                throw new Error(`fork child rename failed: ${renamed.error.code}: ${renamed.error.message}`);
         }
         return childId;
     }
@@ -450,8 +431,9 @@ export class ClientSessions {
             else
                 this.publishRetention(id);
         });
-        if (this.list.getSnapshot().byId[id] === undefined)
+        if (this.list.getSnapshot().byId[id] === undefined && this.manager.subagentAddress(id) !== undefined) {
             this.projectList();
+        }
         this.publishRetention(id);
         return reference;
     }
@@ -507,7 +489,7 @@ export class ClientSessions {
     /** Project the manager's list snapshot into the store (title derivation is display-only). */
     projectList() {
         const previousById = this.list.getSnapshot().byId;
-        const { items, phase, subagentsByParent, jobsBySession, } = this.manager.getListSnapshot();
+        const { items, phase, projectionsBySession, } = this.manager.getListSnapshot();
         const ids = [];
         const byId = {};
         for (const entry of items) {
@@ -528,10 +510,8 @@ export class ClientSessions {
                 ...(entry.origin !== undefined ? { origin: entry.origin } : {}),
             };
         }
-        for (const [parentId, catalog] of Object.entries(subagentsByParent)) {
-            for (const child of catalog.entries) {
-                if (child.kind !== 'child')
-                    continue;
+        for (const [parentId, projection] of Object.entries(projectionsBySession)) {
+            for (const child of projection.values.subagentCatalog ?? []) {
                 const childId = child.id;
                 const summary = byId[childId];
                 const projectionValues = summary?.projectionValues ?? this.manager.projectionValues(childId);
@@ -541,7 +521,7 @@ export class ClientSessions {
                 if (summary === undefined) {
                     byId[childId] = {
                         id: childId, displayTitle, parentId: parentId,
-                        origin: 'subagent', running: child.activity === 'running', blank: false, updatedAt: 0,
+                        origin: 'subagent', running: this.scopes.get(childId)?.session.getSnapshot().running ?? false, blank: false, updatedAt: 0,
                         retainedBy: this.retentionSnapshot(childId).retainedBy,
                         ...(projectionValues === undefined ? {} : { projectionValues }),
                         ...(title === undefined ? {} : { title }),
@@ -559,18 +539,26 @@ export class ClientSessions {
         for (const [id, record] of this.scopes) {
             if (byId[id] !== undefined)
                 continue;
+            const address = this.manager.subagentAddress(id);
+            if (address === undefined)
+                continue;
             const previous = previousById[id];
             const snapshot = record.session.getSnapshot();
-            const address = this.manager.subagentAddress(id);
+            const projectionValues = this.manager.projectionValues(id);
+            const projectedTitle = projectionValues?.title;
+            const title = typeof projectedTitle === 'string' && projectedTitle !== '' ? projectedTitle : previous?.title;
             byId[id] = {
                 ...(previous ?? { id, displayTitle: id, updatedAt: 0 }),
                 running: snapshot.running,
                 retainedBy: record.retention.retainedBy,
                 blank: snapshot.blank,
-                ...(address === undefined ? {} : { parentId: address.parentSessionId, origin: 'subagent' }),
+                parentId: address.parentSessionId,
+                origin: 'subagent',
+                ...(projectionValues === undefined ? {} : { projectionValues }),
+                ...(title === undefined ? {} : { title, displayTitle: title }),
             };
         }
-        this.list.set({ ids, byId, phase, subagentsByParent, jobsBySession });
+        this.list.set({ ids, byId, phase, projectionsBySession });
     }
     startScopeDrop(id, record, disposeFiber = true, sessionDisposal = this.manager.drop(id, record.session)) {
         const drop = this.dropScope(record, disposeFiber, sessionDisposal);

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

@@ -10,23 +10,20 @@ import { MutableSessionEventSource } from '../contract/events.ts';
 import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
 import type { SessionRemotes } from './remotes.ts';
 import { ProjectionValueStore } from './projection-store.ts';
-/** Messages requested per history page. */
+/** Minimum message count for ordinary history windows. */
 export declare const PAGE_MESSAGES = 50;
-/** Messages requested per page while a turn jump loops backwards (fewer, larger round trips). */
+/** Minimum messages per page while a turn jump loops backwards. */
 export declare const JUMP_PAGE_MESSAGES = 200;
 /** Manager-owned observers of a Session object's local state edges. */
 export interface SessionOptions {
     /** Catalog-discovered address selecting non-activating subagent transport. */
     address?: SubagentAddress;
-    /** Whether the exact direct parent Agent was live at the latest catalog read; absent before that read. */
+    /** Whether the exact direct parent Agent is available in Host summaries; absent until known. */
     parentAvailable?: boolean;
     /**
-     * First ACCEPTED prompt on a blank session (fires at most once, on the
-     * prompt RPC's success response): the manager mirrors the blank→false flip
-     * into its list row so the session surfaces without waiting for a host
-     * frame. Acceptance is the flip point because it proves the user message
-     * is in the host log; a rejected first prompt keeps the session blank
-     * (hidden, still reusable by connectWorkspace).
+     * Publish each accepted prompt to the Manager, including after this Session
+     * object is replaced. Acceptance converts display state, but does not
+     * establish that a turn started or reached durable history.
      */
     onEngaged?(session: Session): void;
     /**
@@ -59,6 +56,7 @@ export declare class Session implements SessionFace {
     private jumpTargetSeq;
     /** The running jump loop's completion, shared by retargeting callers. */
     private jumpPromise;
+    private pendingHistory;
     private readonly stopObservingInbox;
     private readonly assistantStream;
     private running;
@@ -72,7 +70,7 @@ export declare class Session implements SessionFace {
     private promptAttempted;
     /** A first accepted prompt stays in the engaging phase until its turn is observable. */
     private firstPromptPendingTurn;
-    /** Empty-log mirror (see ConversationSnapshot.blank); unknown bare sessions begin conservatively blank. */
+    /** New Session display state; unknown bare sessions begin conservatively blank. */
     private blankBit;
     private removed;
     private promptError;
@@ -88,8 +86,9 @@ export declare class Session implements SessionFace {
      * Per-session projection value store (push model; see the session-projection
      * subsystem page, docs/subsystems/session-projection.md): finished whole
      * values computed on the Host, seeded by the tail page's
-     * projections block and updated by Session Controller control frames under the
-     * one higher-seq-wins rule. Keys are read via `projections.faceOf(key)`
+     * projections block and updated by Session Controller control frames;
+     * Host-sequenced writes merge under higher-seq-wins and cached list blocks
+     * yield to them (projection-store.ts). Keys are read via `projections.faceOf(key)`
      * (the useProjection resolution face); the conversation snapshot never
      * carries projection values, and no client-side domain folding exists.
      * Manager-owned when constructed through SessionManager (frames route and
@@ -193,7 +192,7 @@ export declare class Session implements SessionFace {
     }>>;
     /** First open: pull the tail page (idempotent — in-flight/already-open returns the existing promise). */
     open(): Promise<void>;
-    /** Page up: pull one earlier page with the window's first seq as beforeSeq and prepend. */
+    /** Prepend one Turn-aligned page: at least 50 messages and two Turn starts, capped at 500 messages. */
     loadOlder(): Promise<void>;
     /** Jump loader: page backwards until the window covers seq (see ISession.loadThrough). */
     loadThrough(seq: SessionSeq): Promise<void>;
@@ -230,11 +229,12 @@ export declare class Session implements SessionFace {
      */
     handleSubagentParentAvailable(available: boolean): void;
     /**
-     * Blank-bit relay from the authoritative summary source (`session.list` and
-     * `api-session/added`). Monotone: once any signal (local first send,
-     * running flip, an earlier summary) cleared it, a stale true never
-     * re-blanks.
-     * @param blank - the summary's derived empty-log bit.
+     * Apply the Manager's effective display blank, further reconciled with the
+     * current `sessionListMetadata` projection. Local send attempts and current
+     * running state prevent re-blanking; an earlier false summary alone does not.
+     * The Manager retains acceptance and earlier running observations across
+     * Session-object replacement.
+     * @param blank - New Session display state after Manager reconciliation.
      */
     handleBlank(blank: boolean): void;
     /** `api-session/removed` relay: flag the snapshot while retaining the resident instance. */
@@ -262,7 +262,11 @@ export declare class Session implements SessionFace {
     private appendLive;
     /** Observe durable acceptance even when insertion and claim share one projection notification. */
     private observeSubmissionEvent;
-    /** Retire local echoes when their accepted messages appear in the durable Inbox projection. */
+    private observeSubmissionInsertions;
+    private observeSubmissionMessage;
+    /** Retire admitted Chat identities only after stale Inbox rows can no longer reappear. */
+    private retireAdmittedSubmission;
+    /** Inbox acceptance retires queued echoes; its watermark completes admitted Chat handoffs. */
     private observeSubmissionInbox;
     /**
      * Latch one observed settlement and remove the echo an animation frame