@myagentroam/node 0.9.3 → 0.9.5

package/dist/service/conversation-history-service.js

@@ -2,41 +2,88 @@ import { discoverNativeSessions, readNativeSession } from '../native-session-his
 import { coalesceImageGenerationItems } from '../runner/codex/conversation-parser.js';
 import { nativeConversationPage } from '../util/runner-native-session-parsers.js';
 import { isPlainRecord } from '../util/node-operation-parsers.js';
+import { nodeLog } from '../operational.js';
 export function hasManagedActiveRun(runtime, session) {
     return (session.nativeControl === 'MAR_MANAGED' &&
         runtime
             .listRunsForSession(session.id)
             .some((run) => run.status === 'STARTING' || run.status === 'RUNNING' || run.status === 'CANCELLING'));
 }
+export function convergeConversationWatchPage(previous, previousObserved, next, previousAuthority) {
+    const authority = isConversationHistorySource(previousAuthority)
+        ? previousAuthority
+        : previous?.source;
+    if (previous === undefined ||
+        authority === undefined ||
+        sourceRank(next.source) >= sourceRank(authority))
+        return { page: next, authority: next.source };
+    if (previous.turns.length === 0)
+        return { page: next, authority };
+    const boundary = next.turns.findLastIndex((turn) => previous.turns.some((candidate) => sameConversationTurn(candidate, turn)));
+    const observedBoundary = boundary >= 0 || previousObserved === undefined
+        ? -1
+        : next.turns.findLastIndex((turn) => previousObserved.turns.some((candidate) => sameConversationTurn(candidate, turn)));
+    const safeBoundary = Math.max(boundary, observedBoundary);
+    if (safeBoundary < 0)
+        return { page: previous, authority };
+    const additions = next.turns
+        .slice(safeBoundary + 1)
+        .filter((turn) => !previous.turns.some((candidate) => sameConversationTurn(candidate, turn)));
+    if (additions.length === 0)
+        return { page: previous, authority };
+    return {
+        page: {
+            ...previous,
+            source: next.source,
+            snapshotSequence: Math.max(previous.snapshotSequence, next.snapshotSequence),
+            readAt: next.readAt,
+            latestVisibleAt: next.latestVisibleAt ?? previous.latestVisibleAt,
+            turns: [...previous.turns, ...additions]
+        },
+        authority
+    };
+}
+function isConversationHistorySource(value) {
+    return value === 'official' || value === 'native' || value === 'runtime';
+}
 export class ConversationHistoryService {
     options;
+    activeHistoryReads = new Map();
     constructor(options) {
         this.options = options;
     }
     async read(session, input) {
         const snapshotSequence = this.options.snapshotSequence();
         const readAt = Date.now();
-        let official = await this.readOfficial(session, input);
+        const activeCursor = decodeActiveHistoryCursor(input.cursor, session.id);
+        if (activeCursor !== undefined || this.options.hasManagedActiveRun(session))
+            return this.readManagedActive(session, input, activeCursor, snapshotSequence, readAt);
+        const selected = await this.readRunnerHistory(session, input);
+        if (selected.page?.source === 'native')
+            return this.page(selected.page.nextCursor, selected.page.turns, {
+                snapshotSequence,
+                source: 'native',
+                readAt
+            });
+        let official = selected.page?.source === 'official' ? selected.page : undefined;
         if (official !== undefined) {
             const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
             const runtimeTurns = this.options.runtime.getAgentSession(session.id) === undefined
                 ? []
                 : this.options.runtime.listConversationTurns({ sessionId: session.id, limit: 500 }).turns;
             const initialOfficialRunIds = new Set(official.turns.flatMap((turn) => (turn.runId === null ? [] : [turn.runId])));
-            const absentLocalTurns = runtimeTurns.filter((turn) => turn.runId === null || !initialOfficialRunIds.has(turn.runId));
-            const officialFloor = Math.min(...official.turns.map((turn) => Math.max(turn.startedAt ?? 0, turn.completedAt ?? 0)));
-            const missingLocalTurns = official.turns.length === 0
-                ? absentLocalTurns.slice(-limit)
-                : officialFloor > 0
-                    ? absentLocalTurns.filter((turn) => Math.max(turn.startedAt ?? 0, turn.completedAt ?? 0) >= officialFloor)
-                    : absentLocalTurns.slice(-1);
+            const lastRepresentedRuntimeIndex = runtimeTurns.findLastIndex((turn) => turn.runId !== null && initialOfficialRunIds.has(turn.runId));
+            const officialHasTurns = official.turns.length > 0;
+            const absentLocalTurns = runtimeTurns.filter((turn, index) => (turn.runId === null || !initialOfficialRunIds.has(turn.runId)) &&
+                (!officialHasTurns || index > lastRepresentedRuntimeIndex));
+            const missingLocalTurns = absentLocalTurns.slice(-limit);
             if (input.cursor === undefined &&
                 missingLocalTurns.length > 0 &&
                 official.turns.length + missingLocalTurns.length > limit) {
                 const reserved = Math.min(missingLocalTurns.length, Math.max(0, limit - 1));
                 const narrowed = await this.readOfficial(session, { ...input, limit: limit - reserved });
                 if (narrowed !== undefined)
-                    official = narrowed;
+                    official = { ...narrowed, source: 'official' };
             }
             const officialTurns = await this.attachNativeImages(session, official.turns);
             const officialRunIds = new Set(officialTurns.flatMap((turn) => (turn.runId === null ? [] : [turn.runId])));
@@ -49,7 +96,7 @@ export class ConversationHistoryService {
                     pendingItemsByRunId.set(turn.runId, pendingItems);
             }
             const availableLocalSlots = Math.max(0, limit - officialTurns.length);
-            const localCandidates = (input.cursor === undefined ? missingLocalTurns : []).sort((left, right) => (left.startedAt ?? 0) - (right.startedAt ?? 0));
+            const localCandidates = input.cursor === undefined ? missingLocalTurns : [];
             const localTurns = availableLocalSlots === 0 ? [] : localCandidates.slice(-availableLocalSlots);
             const localRequestIds = new Set([
                 ...localTurns.flatMap((turn) => turn.items.flatMap((item) => {
@@ -78,47 +125,157 @@ export class ConversationHistoryService {
                 })
                     .filter((turn) => turn.items.length > 0),
                 ...localTurns
-            ].sort((left, right) => (left.startedAt ?? 0) - (right.startedAt ?? 0));
+            ];
             return this.page(official.nextCursor, turns, {
                 snapshotSequence,
                 source: 'official',
                 readAt
             });
         }
-        if (session.externalSessionId !== null && !this.options.hasManagedActiveRun(session)) {
-            const history = await this.readNative(session);
-            if (history !== undefined) {
-                if (history.truncated !== true ||
-                    this.options.runners.require(session.runner).acceptsTruncatedNativeHistory()) {
-                    const runtimeTurns = this.options.runtime.getAgentSession(session.id) === undefined
-                        ? []
-                        : this.options.runtime.listConversationTurns({ sessionId: session.id, limit: 500 })
-                            .turns;
-                    const page = nativeConversationPage(session, history, input, runtimeTurns, (images) => this.options.attachments.registerNative(session, images));
-                    return this.page(page.nextCursor, page.turns, {
-                        snapshotSequence,
-                        source: 'native',
-                        readAt
-                    });
-                }
-                const runtimePage = this.options.runtime.listConversationTurns({
-                    sessionId: session.id,
-                    ...input
-                });
-                if (runtimePage.turns.length === 0)
-                    throw new Error('NATIVE_TRANSCRIPT_INCOMPLETE');
-                return this.page(runtimePage.nextCursor, runtimePage.turns, {
-                    snapshotSequence,
-                    source: 'runtime',
-                    readAt
-                });
-            }
-            if (session.nativeControl === 'EXTERNAL')
-                throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+        if (session.externalSessionId !== null && selected.incompleteNative) {
+            const runtimePage = this.options.runtime.listConversationTurns({
+                sessionId: session.id,
+                ...input
+            });
+            if (runtimePage.turns.length === 0)
+                throw new Error('NATIVE_TRANSCRIPT_INCOMPLETE');
+            return this.page(runtimePage.nextCursor, runtimePage.turns, {
+                snapshotSequence,
+                source: 'runtime',
+                readAt
+            });
         }
+        if (session.externalSessionId !== null && session.nativeControl === 'EXTERNAL')
+            throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
         const page = this.options.runtime.listConversationTurns({ sessionId: session.id, ...input });
         return this.page(page.nextCursor, page.turns, { snapshotSequence, source: 'runtime', readAt });
     }
+    async readRunnerHistory(session, input) {
+        const runner = this.options.runners.require(session.runner);
+        let incompleteNative = false;
+        const page = await runner.readConversationHistory({
+            native: async () => {
+                const startedAt = performance.now();
+                let history;
+                try {
+                    history = await this.readNative(session);
+                }
+                catch {
+                    return undefined;
+                }
+                finally {
+                    const durationMs = Math.round(performance.now() - startedAt);
+                    if (durationMs >= 250)
+                        nodeLog('native.session.history.native-read.completed', {
+                            runner: session.runner,
+                            sessionId: session.id,
+                            durationMs
+                        });
+                }
+                if (history === undefined)
+                    return undefined;
+                if (history.truncated === true && !runner.acceptsTruncatedNativeHistory()) {
+                    incompleteNative = true;
+                    return undefined;
+                }
+                const runtimeTurns = this.options.runtime.getAgentSession(session.id) === undefined
+                    ? []
+                    : this.options.runtime.listConversationTurns({ sessionId: session.id, limit: 500 })
+                        .turns;
+                const native = nativeConversationPage(session, history, input, runtimeTurns, (images) => this.options.attachments.registerNative(session, images));
+                return native;
+            },
+            official: () => this.readOfficial(session, input)
+        });
+        return { page, incompleteNative };
+    }
+    async readManagedActive(session, input, cursor, snapshotSequence, readAt) {
+        const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
+        const runtimeTurns = this.options.runtime.listConversationTurns({
+            sessionId: session.id,
+            limit: 500
+        }).turns;
+        const beforeAt = cursor?.beforeAt ?? oldestTurnActivityAt(runtimeTurns);
+        if (cursor?.stage === 'OFFICIAL') {
+            const prefetched = this.takeActiveHistoryRead(session.id, limit, cursor.cursor);
+            const selected = await (prefetched ??
+                this.readRunnerHistory(session, {
+                    ...(cursor.cursor === null ? {} : { cursor: cursor.cursor }),
+                    limit
+                }));
+            const history = selected.page;
+            if (history === undefined)
+                return this.page(null, [], { snapshotSequence, source: 'runtime', readAt });
+            const hydratedTurns = history.source === 'official'
+                ? await this.attachNativeImages(session, history.turns)
+                : history.turns;
+            const turns = hydratedTurns.filter((turn) => latestTurnActivityAt(turn) < beforeAt);
+            return this.page(history.nextCursor === null
+                ? null
+                : encodeActiveHistoryCursor({
+                    sessionId: session.id,
+                    stage: 'OFFICIAL',
+                    beforeAt,
+                    cursor: history.nextCursor
+                }), turns, { snapshotSequence, source: history.source, readAt });
+        }
+        if (cursor === undefined && session.externalSessionId !== null)
+            this.prefetchActiveHistory(session, limit);
+        const runtimePage = this.options.runtime.listConversationTurns({
+            sessionId: session.id,
+            ...(cursor?.cursor === null || cursor === undefined ? {} : { cursor: cursor.cursor }),
+            limit
+        });
+        const nextCursor = runtimePage.nextCursor !== null
+            ? encodeActiveHistoryCursor({
+                sessionId: session.id,
+                stage: 'RUNTIME',
+                beforeAt,
+                cursor: runtimePage.nextCursor
+            })
+            : session.externalSessionId === null
+                ? null
+                : encodeActiveHistoryCursor({
+                    sessionId: session.id,
+                    stage: 'OFFICIAL',
+                    beforeAt,
+                    cursor: null
+                });
+        return this.page(nextCursor, runtimePage.turns, {
+            snapshotSequence,
+            source: 'runtime',
+            readAt,
+            deferredOlderHistory: true
+        });
+    }
+    prefetchActiveHistory(session, limit) {
+        const now = Date.now();
+        for (const [sessionId, read] of this.activeHistoryReads)
+            if (read.createdAt + 60_000 <= now)
+                this.activeHistoryReads.delete(sessionId);
+        const current = this.activeHistoryReads.get(session.id);
+        if (current !== undefined && current.limit === limit)
+            return;
+        this.activeHistoryReads.set(session.id, {
+            createdAt: now,
+            limit,
+            // The active Run fast path must stay independent from an optional
+            // background reader failure until the user explicitly requests older history.
+            page: this.readRunnerHistory(session, { limit }).catch(() => ({
+                page: undefined,
+                incompleteNative: false
+            }))
+        });
+    }
+    takeActiveHistoryRead(sessionId, limit, cursor) {
+        if (cursor !== null)
+            return undefined;
+        const read = this.activeHistoryReads.get(sessionId);
+        if (read === undefined || read.limit !== limit || read.createdAt + 60_000 <= Date.now())
+            return undefined;
+        this.activeHistoryReads.delete(sessionId);
+        return read.page;
+    }
     async refreshExternalActivity(session) {
         const runner = this.options.runners.require(session.runner);
         if (!runner.available(this.options.capabilities())) {
@@ -139,7 +296,15 @@ export class ConversationHistoryService {
         return readNativeSession(session.runner, session.cwd, session.externalSessionId);
     }
     async attachNativeImages(session, turns) {
+        const startedAt = performance.now();
         const history = await this.readNative(session);
+        const readDurationMs = Math.round(performance.now() - startedAt);
+        if (readDurationMs >= 250)
+            nodeLog('native.session.history.attachment-source-read.completed', {
+                runner: session.runner,
+                sessionId: session.id,
+                durationMs: readDurationMs
+            });
         if (history === undefined)
             return turns;
         const attachments = new Map();
@@ -166,7 +331,19 @@ export class ConversationHistoryService {
         const runner = this.options.runners.require(session.runner);
         if (session.externalSessionId === null || !runner.available(this.options.capabilities()))
             return undefined;
-        return runner.readOfficialConversation(session, input, (nativeTurnId) => this.managedRunnerTurn(session, nativeTurnId));
+        const startedAt = performance.now();
+        try {
+            return await runner.readOfficialConversation(session, input, (nativeTurnId) => this.managedRunnerTurn(session, nativeTurnId));
+        }
+        finally {
+            const durationMs = Math.round(performance.now() - startedAt);
+            if (durationMs >= 250)
+                nodeLog('native.session.history.official-read.completed', {
+                    runner: session.runner,
+                    sessionId: session.id,
+                    durationMs
+                });
+        }
     }
     managedRunnerTurn(session, nativeTurnId) {
         const runId = this.options.runners
@@ -187,3 +364,56 @@ export class ConversationHistoryService {
         };
     }
 }
+const ACTIVE_HISTORY_CURSOR_PREFIX = 'mar-active-history:1:';
+function encodeActiveHistoryCursor(cursor) {
+    return `${ACTIVE_HISTORY_CURSOR_PREFIX}${Buffer.from(JSON.stringify(cursor)).toString('base64url')}`;
+}
+function decodeActiveHistoryCursor(value, sessionId) {
+    if (value === undefined || !value.startsWith(ACTIVE_HISTORY_CURSOR_PREFIX))
+        return undefined;
+    try {
+        const decoded = JSON.parse(Buffer.from(value.slice(ACTIVE_HISTORY_CURSOR_PREFIX.length), 'base64url').toString('utf8'));
+        if (decoded.sessionId !== sessionId ||
+            (decoded.stage !== 'RUNTIME' && decoded.stage !== 'OFFICIAL') ||
+            typeof decoded.beforeAt !== 'number' ||
+            !Number.isFinite(decoded.beforeAt) ||
+            decoded.beforeAt < 0 ||
+            (decoded.cursor !== null && typeof decoded.cursor !== 'string'))
+            throw new Error('EVENT_CURSOR_INVALID');
+        return decoded;
+    }
+    catch {
+        throw new Error('EVENT_CURSOR_INVALID');
+    }
+}
+function latestTurnActivityAt(turn) {
+    return Math.max(turn.startedAt ?? 0, turn.completedAt ?? 0);
+}
+function oldestTurnActivityAt(turns) {
+    return turns.length === 0 ? 0 : Math.min(...turns.map(latestTurnActivityAt));
+}
+function sameConversationTurn(left, right) {
+    if (left.id === right.id)
+        return true;
+    if (left.runId !== null && left.runId === right.runId)
+        return true;
+    const leftMessageId = conversationClientMessageId(left);
+    return leftMessageId !== null && leftMessageId === conversationClientMessageId(right);
+}
+function conversationClientMessageId(turn) {
+    for (const item of turn.items) {
+        if (item.kind !== 'user_message' || !isPlainRecord(item.payload))
+            continue;
+        const value = item.payload.clientMessageId;
+        if (typeof value === 'string' && value.length > 0)
+            return value;
+    }
+    return null;
+}
+function sourceRank(source) {
+    if (source === 'official')
+        return 3;
+    if (source === 'native')
+        return 2;
+    return 1;
+}

package/dist/service/conversation-segment-service.js

@@ -16,6 +16,7 @@ export function conversationSegments(turn) {
         const latest = index === groups.length - 1;
         const projectedItems = items.map((item) => ({
             ...item,
+            runId: turn.runId,
             segmentId: id,
             segmentIndex: index
         }));
@@ -89,7 +90,10 @@ export class ConversationSegmentService {
                 snapshotSequence: page.snapshotSequence,
                 source: page.source,
                 readAt: page.readAt,
-                latestVisibleAt: page.latestVisibleAt
+                latestVisibleAt: page.latestVisibleAt,
+                ...(boundary === undefined && page.deferredOlderHistory === true
+                    ? { deferredOlderHistory: true }
+                    : {})
             };
             const pageSegments = page.turns.flatMap(conversationSegments);
             let eligible = pageSegments;
@@ -108,6 +112,8 @@ export class ConversationSegmentService {
                 hasOlder = eligible.length > take.length || page.nextCursor !== null;
                 collected.unshift(...take);
             }
+            if (boundary === undefined && page.deferredOlderHistory === true)
+                break;
             if (collected.length >= limit || page.nextCursor === null)
                 break;
             if (visited.has(page.nextCursor))

package/dist/service/external-session-resume-service.d.ts

@@ -18,7 +18,9 @@ interface ExternalSessionResumeServiceOptions {
 }
 export declare class ExternalSessionResumeService {
     private readonly options;
+    private readonly transitions;
     constructor(options: ExternalSessionResumeServiceOptions);
+    transitioning(sessionId: string): boolean;
     resume(external: NodeAgentSession, force?: boolean): Promise<NodeAgentSession | undefined>;
     failure(sessionId: string): {
         readonly code: string;

package/dist/service/external-session-resume-service.js

@@ -1,9 +1,13 @@
 const RESUME_FAILURE_TTL_MS = 30 * 60_000;
 export class ExternalSessionResumeService {
     options;
+    transitions = new Set();
     constructor(options) {
         this.options = options;
     }
+    transitioning(sessionId) {
+        return this.transitions.has(sessionId);
+    }
     async resume(external, force = false) {
         this.clearFailure(external.id);
         const priorId = this.options.state.resumedByDirectId.get(external.id);
@@ -15,40 +19,47 @@ export class ExternalSessionResumeService {
             this.setFailure(external.id, 'RUNNER_UNAVAILABLE');
             return undefined;
         }
-        const result = await runner.resumeExternal(external, {
-            available: this.options.available(external.runner),
-            projectionFor: this.options.projectionFor,
-            managedAliasFor: this.options.managedAliasFor,
-            currentResumed: (sessionId) => {
-                const resumedId = this.options.state.resumedByDirectId.get(sessionId);
-                return resumedId === undefined
-                    ? undefined
-                    : this.options.runtime.getAgentSession(resumedId);
-            },
-            promote: (sessionId) => {
-                this.options.runtime.setNativeControl(sessionId, 'MAR_MANAGED');
-                return this.options.runtime.getAgentSession(sessionId);
-            },
-            ensureConfiguration: this.options.ensureConfiguration,
-            create: (session) => {
-                const configuration = this.options.configuration(session);
-                return this.options.runtime.createAgentSession({
-                    workspaceId: session.workspaceId,
-                    runner: session.runner,
-                    ...(session.externalSessionId === null
-                        ? {}
-                        : { externalSessionId: session.externalSessionId }),
-                    nativeControl: 'MAR_MANAGED',
-                    cwd: session.cwd,
-                    model: configuration.model,
-                    effort: configuration.effort,
-                    access: configuration.access,
-                    ...(session.runnerTitle === null ? {} : { title: session.runnerTitle })
-                });
-            },
-            workspacePath: this.options.workspacePath,
-            rememberManagedNative: this.options.rememberNative
-        }, force);
+        this.transitions.add(external.id);
+        let result;
+        try {
+            result = await runner.resumeExternal(external, {
+                available: this.options.available(external.runner),
+                projectionFor: this.options.projectionFor,
+                managedAliasFor: this.options.managedAliasFor,
+                currentResumed: (sessionId) => {
+                    const resumedId = this.options.state.resumedByDirectId.get(sessionId);
+                    return resumedId === undefined
+                        ? undefined
+                        : this.options.runtime.getAgentSession(resumedId);
+                },
+                promote: (sessionId) => {
+                    this.options.runtime.setNativeControl(sessionId, 'MAR_MANAGED');
+                    return this.options.runtime.getAgentSession(sessionId);
+                },
+                ensureConfiguration: this.options.ensureConfiguration,
+                create: (session) => {
+                    const configuration = this.options.configuration(session);
+                    return this.options.runtime.createAgentSession({
+                        workspaceId: session.workspaceId,
+                        runner: session.runner,
+                        ...(session.externalSessionId === null
+                            ? {}
+                            : { externalSessionId: session.externalSessionId }),
+                        nativeControl: 'MAR_MANAGED',
+                        cwd: session.cwd,
+                        model: configuration.model,
+                        effort: configuration.effort,
+                        access: configuration.access,
+                        ...(session.runnerTitle === null ? {} : { title: session.runnerTitle })
+                    });
+                },
+                workspacePath: this.options.workspacePath,
+                rememberManagedNative: this.options.rememberNative
+            }, force);
+        }
+        finally {
+            this.transitions.delete(external.id);
+        }
         if (result.activity !== undefined)
             this.options.state.externalActivity.set(external.id, result.activity);
         if (result.session !== undefined) {

package/dist/service/native-session-projection-service.d.ts

@@ -32,6 +32,7 @@ export declare class NativeSessionProjectionService {
     })[]>;
     discoverWorkspace(workspaceId: string): Promise<readonly NodeAgentSession[]>;
     resolve(sessionId: string): Promise<NodeAgentSession | undefined>;
+    resolveCurrent(sessionId: string): Promise<NodeAgentSession | undefined>;
     createMetadataProjection(sessionId: string): Promise<NodeAgentSession | undefined>;
     resumedConfiguration(session: NodeAgentSession): RunnerDefaultConfiguration;
     ensureResumedConfiguration(session: NodeAgentSession): NodeAgentSession;

package/dist/service/native-session-projection-service.js

@@ -81,6 +81,10 @@ export class NativeSessionProjectionService {
             createdAt: 0
         };
     }
+    async resolveCurrent(sessionId) {
+        const direct = await this.resolve(sessionId);
+        return direct === undefined ? undefined : (this.projectionForNative(direct) ?? direct);
+    }
     async createMetadataProjection(sessionId) {
         const direct = await this.resolve(sessionId);
         if (direct === undefined || direct.externalSessionId === null)

package/dist/service/native-session-watch-service.d.ts

@@ -2,24 +2,37 @@ import type { NodeAgentSession } from '../database.js';
 import type { NodeOperationHandler } from '../connector/node-operation-router.js';
 export interface NativeSessionWatchOptions<TPage extends {
     readonly turns: readonly unknown[];
+    readonly source?: unknown;
 }> {
     readonly resolve: (sessionId: string) => Promise<NodeAgentSession | undefined>;
     readonly managedActive: (session: NodeAgentSession) => boolean;
+    readonly suspended?: (sessionId: string) => boolean;
     readonly refreshActivity: (session: NodeAgentSession) => Promise<void>;
     readonly present: (session: NodeAgentSession) => unknown;
     readonly readPage: (session: NodeAgentSession, limit: number) => Promise<TPage>;
+    readonly convergePage: (previous: TPage | undefined, previousObserved: TPage | undefined, next: TPage, previousAuthority: unknown) => {
+        readonly page: TPage;
+        readonly authority: unknown;
+    };
     readonly projectInitialPage?: (session: NodeAgentSession, page: TPage, unit: 'SEGMENT', limit: number) => unknown;
     readonly emitSession: (session: unknown) => void;
-    readonly emitTurn: (turn: unknown) => void;
+    readonly emitPage: (session: NodeAgentSession, page: TPage) => void;
+    readonly nodeId?: () => string;
+    readonly nodeGeneration?: () => string;
+    readonly emitWatchEvent?: (payload: unknown) => void;
 }
 export declare class NativeSessionWatchService<TPage extends {
     readonly turns: readonly unknown[];
+    readonly source?: unknown;
 }> {
     private readonly options;
     private readonly watches;
+    private readonly leases;
+    private snapshotSequence;
     constructor(options: NativeSessionWatchOptions<TPage>);
     operations(): Readonly<Record<string, NodeOperationHandler>>;
     private executeWatch;
+    private executeUnwatch;
     watch(session: NodeAgentSession): {
         readonly expiresAt: number;
     } | undefined;
@@ -33,6 +46,17 @@ export declare class NativeSessionWatchService<TPage extends {
         readonly expiresAt: number;
     } | undefined;
     get size(): number;
-    refresh(sessionId: string, limit?: number): Promise<TPage | undefined>;
+    refresh(sessionId: string, limit?: number, emit?: boolean): Promise<TPage | undefined>;
     private performRefresh;
+    private sessionHash;
+    private ownerKey;
+    private accepted;
+    private initializeLease;
+    private removeLease;
+    private emitObservedPage;
+    private failSession;
+    private releaseSessionLeases;
+    private leaseTimer;
+    private latestLeaseExpiry;
+    private refreshTimer;
 }