@myagentroam/node 0.9.2 → 0.9.4

package/dist/runtime-state.js

@@ -9,22 +9,22 @@ export class NodeRuntimeState {
     nodeId;
     getWorkspace;
     now;
+    static MAX_COMPLETED_TURNS_PER_SESSION = 10;
     sessions = new Map();
     runs = new Map();
     messageRuns = new Map();
     events = new Map();
     turns = new Map();
     approvals = new Map();
-    workspaceEvents = new Map();
     /** A Session owns at most one running turn; Workspace sessions may run concurrently. */
     leases = new Map();
     /** Session FIFO metadata is deliberately process-local with the rest of run state. */
     queuedRuns = new Map();
     queueVersions = new Map();
     pausedQueues = new Set();
-    snapshots = new Map();
+    /** Bounded tombstones reject stale internal start envelopes after terminal cleanup. */
+    terminalRunIds = new Set();
     nextEventId = 1;
-    nextWorkspaceEventId = 1;
     constructor(nodeId, getWorkspace, now = Date.now) {
         this.nodeId = nodeId;
         this.getWorkspace = getWorkspace;
@@ -73,6 +73,8 @@ export class NodeRuntimeState {
     }
     /** Internal envelope compatibility for a Run already accepted in this process. */
     adoptRun(input) {
+        if (this.terminalRunIds.has(input.runId))
+            throw new Error('RUN_TERMINAL');
         let session = this.sessions.get(input.sessionId);
         if (session === undefined) {
             const now = this.now();
@@ -253,7 +255,7 @@ export class NodeRuntimeState {
         const session = this.requireSession(input.sessionId);
         const now = this.now();
         const run = {
-            id: randomUUID(),
+            id: input.runId ?? randomUUID(),
             sessionId: session.id,
             nodeId: this.nodeId(),
             workspaceId: session.workspaceId,
@@ -262,6 +264,9 @@ export class NodeRuntimeState {
             recoveryState: 'ACTIVE',
             version: 0,
             clientMessageId: input.clientMessageId,
+            ...(input.initiatedByUserId === undefined
+                ? {}
+                : { initiatedByUserId: input.initiatedByUserId }),
             createdAt: now,
             updatedAt: now
         };
@@ -316,11 +321,6 @@ export class NodeRuntimeState {
         this.queuedRuns.set(session.id, [...(this.queuedRuns.get(session.id) ?? []), run.id]);
         this.bumpQueueVersion(session.id);
         this.turns.set(session.id, [...(this.turns.get(session.id) ?? []), fixedTurn]);
-        this.recordWorkspaceActivity(run.workspaceId, 'run.created', {
-            runId: run.id,
-            sessionId: session.id,
-            runner: run.runner
-        });
         this.replaceSession(session.id, { lastActivityAt: now });
         return { run, created: true };
     }
@@ -402,7 +402,6 @@ export class NodeRuntimeState {
         this.bumpQueueVersion(run.sessionId);
         this.runs.delete(runId);
         this.events.delete(runId);
-        this.snapshots.delete(runId);
         this.turns.set(run.sessionId, (this.turns.get(run.sessionId) ?? []).filter((turn) => turn.runId !== runId));
         for (const [key, candidate] of this.messageRuns)
             if (candidate === runId)
@@ -468,12 +467,6 @@ export class NodeRuntimeState {
         if (input.status !== undefined)
             this.transitionRun(input.runId, input.status);
         this.projectEvent(value);
-        const run = this.requireRun(input.runId);
-        this.recordWorkspaceActivity(run.workspaceId, 'run.updated', {
-            runId: run.id,
-            eventType: input.eventType,
-            status: input.status ?? null
-        });
         return value;
     }
     listRunEvents(id, after = 0) {
@@ -481,15 +474,16 @@ export class NodeRuntimeState {
     }
     listConversationTurns(input) {
         this.requireSession(input.sessionId);
-        // Queued turns have not received `run.started` yet. Their user item still
-        // has the acceptance timestamp, so use it rather than sorting every
-        // queued turn as time zero. The insertion index makes same-millisecond
-        // sends deterministic; callers receive every page from oldest to newest.
+        // A managed Turn keeps the user's acceptance time as its stable timeline
+        // position. Runner start/completion timestamps must not move it behind a
+        // message that was accepted later. Native Turns without a user timestamp
+        // fall back to their own lifecycle time.
         const all = [...(this.turns.get(input.sessionId) ?? [])]
             .map((turn, index) => ({ turn, index }))
             .sort((a, b) => {
-            const timestamp = (value) => value.startedAt ??
-                value.items.find((item) => item.id === value.userItemId)?.startedAt ??
+            const timestamp = (value) => value.items.find((item) => item.id === value.userItemId)?.startedAt ??
+                value.startedAt ??
+                value.completedAt ??
                 0;
             return timestamp(a.turn) - timestamp(b.turn) || a.index - b.index;
         })
@@ -559,16 +553,6 @@ export class NodeRuntimeState {
         this.replaceSession(session.id, { lastActivityAt: now });
         return completedTurn;
     }
-    listWorkspaceActivity(input) {
-        const all = this.workspaceEvents.get(input.workspaceId) ?? [];
-        const start = decodeCursor(input.cursor, input.workspaceId);
-        const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
-        const events = all.slice(start, start + limit);
-        return {
-            events,
-            nextCursor: start + limit < all.length ? encodeCursor(input.workspaceId, start + limit) : null
-        };
-    }
     createApproval(input) {
         this.requireRun(input.runId);
         if (this.approvals.has(input.approvalId))
@@ -631,11 +615,30 @@ export class NodeRuntimeState {
     lastRunSequence(id) {
         return this.events.get(id)?.at(-1)?.sequence ?? 0;
     }
-    saveSnapshot(id, value) {
-        this.snapshots.set(id, value);
-    }
-    getSnapshot(id) {
-        return this.snapshots.get(id);
+    removeTerminalRun(runId) {
+        const run = this.requireRun(runId);
+        if (!terminal(run.status))
+            throw new Error('RUN_ACTIVE');
+        this.terminalRunIds.add(runId);
+        if (this.terminalRunIds.size > 1_024)
+            this.terminalRunIds.delete(this.terminalRunIds.values().next().value);
+        const queue = this.queuedRuns.get(run.sessionId) ?? [];
+        if (queue.includes(runId)) {
+            this.queuedRuns.set(run.sessionId, queue.filter((candidate) => candidate !== runId));
+            this.bumpQueueVersion(run.sessionId);
+        }
+        this.runs.delete(runId);
+        this.events.delete(runId);
+        const turns = this.turns.get(run.sessionId) ?? [];
+        const completed = turns.filter((turn) => terminalTurn(turn.status));
+        const retainedCompleted = new Set(completed.slice(-NodeRuntimeState.MAX_COMPLETED_TURNS_PER_SESSION).map((turn) => turn.id));
+        this.turns.set(run.sessionId, turns.filter((turn) => !terminalTurn(turn.status) || retainedCompleted.has(turn.id)));
+        for (const [key, candidate] of this.messageRuns)
+            if (candidate === runId)
+                this.messageRuns.delete(key);
+        for (const [approvalId, approval] of this.approvals)
+            if (approval.runId === runId)
+                this.approvals.delete(approvalId);
     }
     hasActiveWorkspaceLease(workspaceId) {
         return [...this.leases.values()]
@@ -658,7 +661,6 @@ export class NodeRuntimeState {
         for (const runId of runIds) {
             this.runs.delete(runId);
             this.events.delete(runId);
-            this.snapshots.delete(runId);
         }
         for (const [key, runId] of this.messageRuns)
             if (runIds.has(runId))
@@ -681,7 +683,6 @@ export class NodeRuntimeState {
         for (const runId of runIds) {
             this.runs.delete(runId);
             this.events.delete(runId);
-            this.snapshots.delete(runId);
         }
         for (const [key, runId] of this.messageRuns)
             if (runIds.has(runId))
@@ -689,7 +690,6 @@ export class NodeRuntimeState {
         for (const [approvalId, approval] of this.approvals)
             if (runIds.has(approval.runId))
                 this.approvals.delete(approvalId);
-        this.workspaceEvents.delete(workspaceId);
         for (const sessionId of sessionIds) {
             this.queuedRuns.delete(sessionId);
             this.queueVersions.delete(sessionId);
@@ -730,19 +730,6 @@ export class NodeRuntimeState {
             throw new Error('APPROVAL_NOT_FOUND');
         return value;
     }
-    recordWorkspaceActivity(workspaceId, eventType, payload) {
-        const event = {
-            id: this.nextWorkspaceEventId++,
-            workspaceId,
-            eventType,
-            payload,
-            createdAt: this.now()
-        };
-        this.workspaceEvents.set(workspaceId, [
-            ...(this.workspaceEvents.get(workspaceId) ?? []),
-            event
-        ]);
-    }
     updateTurnForRun(runId, update) {
         const run = this.requireRun(runId);
         const current = this.turns.get(run.sessionId) ?? [];
@@ -840,6 +827,9 @@ export class NodeRuntimeState {
 function terminal(status) {
     return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED', 'LOST'].includes(status);
 }
+function terminalTurn(status) {
+    return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED'].includes(status);
+}
 function transitionAllowed(from, to) {
     return !terminal(from) || from === to;
 }

package/dist/service/attachment-domain-state.d.ts

@@ -1,5 +1,7 @@
 export declare class AttachmentDomainState<TCachedRunImages, TNativeImageSource> {
     readonly runDirectories: Map<string, string>;
+    readonly runFileDirectories: Map<string, string>;
     readonly runImages: Map<string, TCachedRunImages>;
     readonly nativeHistoryImages: Map<string, TNativeImageSource[]>;
+    readonly nativeHistoryImageTimers: Map<string, NodeJS.Timeout>;
 }

package/dist/service/attachment-domain-state.js

@@ -1,5 +1,7 @@
 export class AttachmentDomainState {
     runDirectories = new Map();
+    runFileDirectories = new Map();
     runImages = new Map();
     nativeHistoryImages = new Map();
+    nativeHistoryImageTimers = new Map();
 }

package/dist/service/conversation-history-service.d.ts

@@ -5,6 +5,10 @@ import type { RunnerRegistry } from '../runner/runner-registry.js';
 import { type ConversationHistoryPage } from '../util/runner-native-session-parsers.js';
 import type { RunAttachmentService } from './run-attachment-service.js';
 export declare function hasManagedActiveRun(runtime: NodeRuntimeState, session: NodeAgentSession): boolean;
+export declare function convergeConversationWatchPage(previous: ConversationHistoryPage | undefined, previousObserved: ConversationHistoryPage | undefined, next: ConversationHistoryPage, previousAuthority: unknown): {
+    readonly page: ConversationHistoryPage;
+    readonly authority: ConversationHistoryPage['source'];
+};
 interface ConversationHistoryServiceOptions {
     readonly runtime: NodeRuntimeState;
     readonly runners: RunnerRegistry;
@@ -16,11 +20,15 @@ interface ConversationHistoryServiceOptions {
 }
 export declare class ConversationHistoryService {
     private readonly options;
+    private readonly activeOfficialReads;
     constructor(options: ConversationHistoryServiceOptions);
     read(session: NodeAgentSession, input: {
         readonly cursor?: string;
         readonly limit?: number;
     }): Promise<ConversationHistoryPage>;
+    private readManagedActive;
+    private prefetchActiveOfficial;
+    private takeActiveOfficialRead;
     refreshExternalActivity(session: NodeAgentSession): Promise<void>;
     readNative(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeSessionHistory | undefined>;
     private attachNativeImages;

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

@@ -8,14 +8,55 @@ export function hasManagedActiveRun(runtime, session) {
             .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;
+    activeOfficialReads = new Map();
     constructor(options) {
         this.options = options;
     }
     async read(session, input) {
         const snapshotSequence = this.options.snapshotSequence();
         const readAt = Date.now();
+        const activeCursor = decodeActiveHistoryCursor(input.cursor, session.id);
+        if (activeCursor !== undefined || this.options.hasManagedActiveRun(session))
+            return this.readManagedActive(session, input, activeCursor, snapshotSequence, readAt);
         let official = await this.readOfficial(session, input);
         if (official !== undefined) {
             const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
@@ -23,13 +64,11 @@ export class ConversationHistoryService {
                 ? []
                 : 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) {
@@ -49,7 +88,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,7 +117,7 @@ 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',
@@ -119,6 +158,86 @@ export class ConversationHistoryService {
         const page = this.options.runtime.listConversationTurns({ sessionId: session.id, ...input });
         return this.page(page.nextCursor, page.turns, { snapshotSequence, source: 'runtime', readAt });
     }
+    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.takeActiveOfficialRead(session.id, limit, cursor.cursor);
+            const official = await (prefetched ??
+                this.readOfficial(session, {
+                    ...(cursor.cursor === null ? {} : { cursor: cursor.cursor }),
+                    limit
+                }));
+            if (official === undefined)
+                return this.page(null, [], { snapshotSequence, source: 'runtime', readAt });
+            const turns = (await this.attachNativeImages(session, official.turns)).filter((turn) => latestTurnActivityAt(turn) < beforeAt);
+            return this.page(official.nextCursor === null
+                ? null
+                : encodeActiveHistoryCursor({
+                    sessionId: session.id,
+                    stage: 'OFFICIAL',
+                    beforeAt,
+                    cursor: official.nextCursor
+                }), turns, { snapshotSequence, source: 'official', readAt });
+        }
+        if (cursor === undefined && session.externalSessionId !== null)
+            this.prefetchActiveOfficial(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
+        });
+    }
+    prefetchActiveOfficial(session, limit) {
+        const now = Date.now();
+        for (const [sessionId, read] of this.activeOfficialReads)
+            if (read.createdAt + 60_000 <= now)
+                this.activeOfficialReads.delete(sessionId);
+        const current = this.activeOfficialReads.get(session.id);
+        if (current !== undefined && current.limit === limit)
+            return;
+        this.activeOfficialReads.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.readOfficial(session, { limit }).catch(() => undefined)
+        });
+    }
+    takeActiveOfficialRead(sessionId, limit, cursor) {
+        if (cursor !== null)
+            return undefined;
+        const read = this.activeOfficialReads.get(sessionId);
+        if (read === undefined || read.limit !== limit || read.createdAt + 60_000 <= Date.now())
+            return undefined;
+        this.activeOfficialReads.delete(sessionId);
+        return read.page;
+    }
     async refreshExternalActivity(session) {
         const runner = this.options.runners.require(session.runner);
         if (!runner.available(this.options.capabilities())) {
@@ -187,3 +306,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

@@ -3,11 +3,11 @@ export function conversationSegments(turn) {
     const groups = [];
     let current = [];
     for (const item of turn.items) {
+        if (current.at(-1)?.kind === 'assistant_message' && item.kind !== 'assistant_message') {
+            groups.push(current);
+            current = [];
+        }
         current.push(item);
-        if (item.kind !== 'assistant_message')
-            continue;
-        groups.push(current);
-        current = [];
     }
     if (current.length > 0 || groups.length === 0)
         groups.push(current);
@@ -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
         }));
@@ -36,14 +37,15 @@ export function conversationSegments(turn) {
 export function conversationSegmentIdentityForItem(turn, itemId, itemKind) {
     let index = 0;
     const runtimeItemId = turn.runId === null ? itemId : `${turn.runId}:${itemId}`;
-    for (const item of turn.items) {
+    for (const [itemIndex, item] of turn.items.entries()) {
+        const previous = turn.items[itemIndex - 1];
+        if (previous?.kind === 'assistant_message' && item.kind !== 'assistant_message')
+            index += 1;
         if (item.id === itemId || item.id === runtimeItemId)
             return { id: `${turn.id}:segment:${index}`, index };
-        if (item.kind === 'assistant_message')
-            index += 1;
     }
-    if (itemKind === 'assistant_message' && turn.items.at(-1)?.kind === 'assistant_message')
-        index -= 1;
+    if (turn.items.at(-1)?.kind === 'assistant_message' && itemKind !== 'assistant_message')
+        index += 1;
     return { id: `${turn.id}:segment:${index}`, index };
 }
 export class ConversationSegmentService {
@@ -88,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;
@@ -107,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.js

@@ -1,3 +1,4 @@
+const RESUME_FAILURE_TTL_MS = 30 * 60_000;
 export class ExternalSessionResumeService {
     options;
     constructor(options) {
@@ -84,15 +85,23 @@ export class ExternalSessionResumeService {
             : 'REJECTED';
     }
     clearFailure(sessionId) {
+        const timer = this.options.state.failureTimers.get(sessionId);
+        if (timer !== undefined)
+            clearTimeout(timer);
+        this.options.state.failureTimers.delete(sessionId);
         this.options.state.resumeFailures.delete(sessionId);
         this.options.state.resumeFailureDetails.delete(sessionId);
         this.options.state.messageResumeFailures.delete(sessionId);
     }
     setFailure(sessionId, code, detail) {
+        this.clearFailure(sessionId);
         this.options.state.resumeFailures.set(sessionId, code);
         if (detail === undefined)
             this.options.state.resumeFailureDetails.delete(sessionId);
         else
             this.options.state.resumeFailureDetails.set(sessionId, detail);
+        const timer = setTimeout(() => this.clearFailure(sessionId), RESUME_FAILURE_TTL_MS);
+        timer.unref();
+        this.options.state.failureTimers.set(sessionId, timer);
     }
 }

package/dist/service/fake-managed-run-service.d.ts

@@ -17,7 +17,6 @@ interface FakeManagedRunServiceOptions {
         readonly payload: unknown;
         readonly expiresAt: number;
     }) => void;
-    readonly captureSnapshot: (runId: string, cwd: string) => Promise<void>;
     readonly disconnect: () => void;
 }
 /** Test-only managed Run adapter; production Runner paths never depend on it. */

package/dist/service/fake-managed-run-service.js

@@ -32,8 +32,6 @@ export class FakeManagedRunService {
                 this.options.emitRun(runId, eventType, eventPayload, status);
                 if (status !== undefined && isTerminalRunStatus(status)) {
                     this.options.state.active.delete(runId);
-                    if (cwd !== undefined)
-                        void this.options.captureSnapshot(runId, cwd);
                 }
             },
             approval: (approvalId, approvalPayload, expiresAt) => {

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

@@ -238,7 +238,12 @@ export class NativeSessionProjectionService {
                 this.options.state.externalActivity.delete(directId);
                 this.options.state.resumedByDirectId.delete(directId);
                 this.options.state.resumeFailures.delete(directId);
+                this.options.state.messageResumeFailures.delete(directId);
                 this.options.state.resumeFailureDetails.delete(directId);
+                const timer = this.options.state.failureTimers.get(directId);
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                this.options.state.failureTimers.delete(directId);
             }
         }
         for (const [directId, resumedId] of this.options.state.resumedByDirectId)

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

@@ -2,18 +2,24 @@ 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 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;
 }
 export declare class NativeSessionWatchService<TPage extends {
     readonly turns: readonly unknown[];
+    readonly source?: unknown;
 }> {
     private readonly options;
     private readonly watches;
@@ -33,6 +39,6 @@ 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;
 }